CNewMenu Class Reference

#include <CNewMenu.h>

Inheritance diagram for CNewMenu:

Collaboration diagram for CNewMenu:

Classes
struct	SHELLNEW_ITEM

Public Member Functions
	CNewMenu ()
	~CNewMenu ()
STDMETHOD()	SetSite (IUnknown *pUnkSite) override
STDMETHOD()	GetSite (REFIID riid, void **ppvSite) override
STDMETHOD()	QueryContextMenu (HMENU hMenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags) override
STDMETHOD()	InvokeCommand (LPCMINVOKECOMMANDINFO lpcmi) override
STDMETHOD()	GetCommandString (UINT_PTR idCommand, UINT uFlags, UINT *lpReserved, LPSTR lpszName, UINT uMaxNameLen) override
STDMETHOD()	HandleMenuMsg2 (UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *plResult) override
STDMETHOD()	HandleMenuMsg (UINT uMsg, WPARAM wParam, LPARAM lParam) override
STDMETHOD()	Initialize (PCIDLIST_ABSOLUTE pidlFolder, IDataObject *pdtobj, HKEY hkeyProgID) override
Public Member Functions inherited from ATL::CComObjectRootEx< CComMultiThreadModelNoCS >
	~CComObjectRootEx ()
ULONG	InternalAddRef ()
ULONG	InternalRelease ()
void	Lock ()
void	Unlock ()
HRESULT	_AtlInitialConstruct ()
Public Member Functions inherited from ATL::CComObjectRootBase
	CComObjectRootBase ()
	~CComObjectRootBase ()
void	SetVoid (void *)
HRESULT	_AtlFinalConstruct ()
HRESULT	FinalConstruct ()
void	InternalFinalConstructAddRef ()
void	InternalFinalConstructRelease ()
void	FinalRelease ()
Public Member Functions inherited from IObjectWithSite
HRESULT	SetSite ([in] IUnknown *pUnkSite)
HRESULT	GetSite ([in] REFIID riid, [out, iid_is(riid)] PVOID *ppvSite)
Public Member Functions inherited from IUnknown
HRESULT	QueryInterface ([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
ULONG	AddRef ()
ULONG	Release ()
HRESULT	HandleMenuMsg2 ([in] UINT uMsg, [in] WPARAM wParam, [in] LPARAM lParam, [out] LRESULT *plResult)
HRESULT	HandleMenuMsg ([in] UINT uMsg, [in] WPARAM wParam, [in] LPARAM lParam)
HRESULT	QueryContextMenu ([in] HMENU hmenu, [in] UINT indexMenu, [in] UINT idCmdFirst, [in] UINT idCmdLast, [in] UINT uFlags)
HRESULT	InvokeCommand ([in] LPCMINVOKECOMMANDINFO lpici)
HRESULT	GetCommandString ([in] UINT_PTR idCmd, [in] UINT uType, [out] UINT *pwReserved, [out, size_is(cchMax)] LPSTR pszName, [in] UINT cchMax)
HRESULT	Initialize ([in] PCIDLIST_ABSOLUTE pidlFolder, [in] IDataObject *pdtobj, [in] HKEY hkeyProgID)

Private Types
enum	SHELLNEW_TYPE {   SHELLNEW_TYPE_INVALID = -1 , SHELLNEW_TYPE_COMMAND = 1 , SHELLNEW_TYPE_DATA = 2 , SHELLNEW_TYPE_FILENAME = 4 ,   SHELLNEW_TYPE_NULLFILE = 8 }

Private Member Functions
SHELLNEW_ITEM *	LoadItem (LPCWSTR pwszExt)
void	UnloadItem (SHELLNEW_ITEM *pItem)
void	UnloadAllItems ()
BOOL	CacheItems ()
BOOL	LoadCachedItems ()
BOOL	LoadAllItems ()
UINT	InsertShellNewItems (HMENU hMenu, UINT idFirst, UINT idMenu)
SHELLNEW_ITEM *	FindItemFromIdOffset (UINT IdOffset)
HRESULT	CreateNewFolder (LPCMINVOKECOMMANDINFO lpici)
HRESULT	CreateNewItem (SHELLNEW_ITEM *pItem, LPCMINVOKECOMMANDINFO lpcmi)
HRESULT	SelectNewItem (LONG wEventId, UINT uFlags, LPWSTR pszName, BOOL bRename)
HRESULT	NewItemByCommand (SHELLNEW_ITEM *pItem, LPCWSTR wszPath)
HRESULT	NewItemByNonCommand (SHELLNEW_ITEM *pItem, LPWSTR wszName, DWORD cchNameMax, LPCWSTR wszPath)

Private Attributes
LPITEMIDLIST	m_pidlFolder
SHELLNEW_ITEM *	m_pItems
SHELLNEW_ITEM *	m_pLinkItem
CComPtr< IUnknown >	m_pSite
HMENU	m_hSubMenu
UINT	m_idCmdFirst
UINT	m_idCmdFolder
UINT	m_idCmdLink
BOOL	m_bCustomIconFolder
BOOL	m_bCustomIconLink
HICON	m_hIconFolder
HICON	m_hIconLink

Additional Inherited Members
Public Types inherited from IObjectWithSite
typedef IObjectWithSite *	LPOBJECTWITHSITE
Public Types inherited from IUnknown
typedef IUnknown *	LPUNKNOWN
Public Types inherited from IContextMenu3
typedef IContextMenu3 *	LPCONTEXTMENU3
Public Types inherited from IContextMenu2
typedef IContextMenu2 *	LPCONTEXTMENU2
Public Types inherited from IContextMenu
typedef IContextMenu *	LPCONTEXTMENU
typedef struct IContextMenu::tagCMINVOKECOMMANDINFO	CMINVOKECOMMANDINFO
typedef struct IContextMenu::tagCMINVOKECOMMANDINFO *	LPCMINVOKECOMMANDINFO
typedef struct IContextMenu::tagCMInvokeCommandInfoEx	CMINVOKECOMMANDINFOEX
typedef struct IContextMenu::tagCMInvokeCommandInfoEx *	LPCMINVOKECOMMANDINFOEX
Public Types inherited from IShellExtInit
typedef IShellExtInit *	LPSHELLEXTINIT
Static Public Member Functions inherited from ATL::CComObjectRootBase
static void WINAPI	ObjectMain (bool)
static const struct _ATL_CATMAP_ENTRY *	GetCategoryMap ()
static HRESULT WINAPI	InternalQueryInterface (void *pThis, const _ATL_INTMAP_ENTRY *pEntries, REFIID iid, void **ppvObject)
Public Attributes inherited from ATL::CComObjectRootBase
LONG	m_dwRef
Static Public Attributes inherited from IContextMenu
static const WCHAR	CMDSTR_NEWFOLDERW [] = {'N','e','w','F','o','l','d','e','r',0}
static const WCHAR	CMDSTR_VIEWLISTW [] = {'V','i','e','w','L','i','s','t',0}
static const WCHAR	CMDSTR_VIEWDETAILSW [] = {'V','i','e','w','D','e','t','a','i','l','s',0}

Detailed Description

Definition at line 28 of file CNewMenu.h.

Member Enumeration Documentation

SHELLNEW_TYPE

enum CNewMenu::SHELLNEW_TYPE

private

Enumerator
SHELLNEW_TYPE_INVALID
SHELLNEW_TYPE_COMMAND
SHELLNEW_TYPE_DATA
SHELLNEW_TYPE_FILENAME
SHELLNEW_TYPE_NULLFILE

Definition at line 36 of file CNewMenu.h.

    {
        SHELLNEW_TYPE_INVALID = -1,
        SHELLNEW_TYPE_COMMAND = 1,
        SHELLNEW_TYPE_DATA = 2,
        SHELLNEW_TYPE_FILENAME = 4,
        SHELLNEW_TYPE_NULLFILE = 8
    };

Constructor & Destructor Documentation

CNewMenu()

CNewMenu::CNewMenu

(

)

Definition at line 28 of file CNewMenu.cpp.

                   :
    m_pidlFolder(NULL),
    m_pItems(NULL),
    m_pLinkItem(NULL),
    m_pSite(NULL),
    m_idCmdFirst(0),
    m_idCmdFolder(-1),
    m_idCmdLink(-1),
    m_bCustomIconFolder(FALSE),
    m_bCustomIconLink(FALSE),
    m_hIconFolder(NULL),
    m_hIconLink(NULL)
{
}

~CNewMenu()

CNewMenu::~CNewMenu

(

)

Definition at line 43 of file CNewMenu.cpp.

{
    UnloadAllItems();
 
    if (m_bCustomIconFolder && m_hIconFolder)
        DestroyIcon(m_hIconFolder);
    if (m_bCustomIconLink && m_hIconLink)
        DestroyIcon(m_hIconLink);
    if (m_pidlFolder)
        ILFree(m_pidlFolder);
}

Member Function Documentation

CacheItems()

BOOL CNewMenu::CacheItems ( )

private

Definition at line 189 of file CNewMenu.cpp.

{
    HKEY hKey;
    DWORD dwSize = 0;
    DWORD dwIndex = 0;
    LPWSTR lpValue;
    LPWSTR lpValues;
    WCHAR wszName[MAX_PATH];
    SHELLNEW_ITEM *pNewItem;
    SHELLNEW_ITEM *pCurItem = NULL;
 
    /* Enumerate all extensions */
    while (RegEnumKeyW(HKEY_CLASSES_ROOT, dwIndex++, wszName, _countof(wszName)) == ERROR_SUCCESS)
    {
        if (wszName[0] != L'.')
            continue;
 
        pNewItem = LoadItem(wszName);
        if (pNewItem)
        {
            dwSize += wcslen(wszName) + 1;
            if (!m_pLinkItem && _wcsicmp(pNewItem->pwszExt, L".lnk") == 0)
            {
                /* The unique link handler */
                m_pLinkItem = pNewItem;
            }
 
            /* Add at the end of the list */
            if (pCurItem)
            {
                pCurItem->pNext = pNewItem;
                pCurItem = pNewItem;
            }
            else
            {
                pCurItem = m_pItems = pNewItem;
            }
        }
    }
 
    dwSize++;
 
    lpValues = (LPWSTR) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwSize * sizeof(WCHAR));
    if (!lpValues)
        return FALSE;
 
    for (pCurItem = m_pItems, lpValue = lpValues; pCurItem; pCurItem = pCurItem->pNext)
    {
        memcpy(lpValue, pCurItem->pwszExt, (wcslen(pCurItem->pwszExt) + 1) * sizeof(WCHAR));
        lpValue += wcslen(pCurItem->pwszExt) + 1;
    }
 
    if (RegCreateKeyEx(HKEY_CURRENT_USER, ShellNewKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL) != ERROR_SUCCESS)
    {
        HeapFree(GetProcessHeap(), 0, lpValues);
        return FALSE;
    }
 
    if (RegSetValueExW(hKey, L"Classes", NULL, REG_MULTI_SZ, (LPBYTE)lpValues, dwSize * sizeof(WCHAR)) != ERROR_SUCCESS)
    {
        HeapFree(GetProcessHeap(), 0, lpValues);
        RegCloseKey(hKey);
        return FALSE;
    }
 
    HeapFree(GetProcessHeap(), 0, lpValues);
    RegCloseKey(hKey);
 
    return TRUE;
}

Referenced by LoadAllItems().

CreateNewFolder()

HRESULT CNewMenu::CreateNewFolder ( LPCMINVOKECOMMANDINFO  lpici )

private

Definition at line 465 of file CNewMenu.cpp.

{
    WCHAR wszPath[MAX_PATH];
    WCHAR wszName[MAX_PATH];
    WCHAR wszNewFolder[25];
    HRESULT hr;
 
    /* Get folder path */
    hr = SHGetPathFromIDListW(m_pidlFolder, wszPath);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    if (!LoadStringW(shell32_hInstance, IDS_NEWFOLDER, wszNewFolder, _countof(wszNewFolder)))
        return E_FAIL;
 
    /* Create the name of the new directory */
    if (!PathYetAnotherMakeUniqueName(wszName, wszPath, NULL, wszNewFolder))
        return E_FAIL;
 
    /* Create the new directory and show the appropriate dialog in case of error */
    if (SHCreateDirectory(lpici->hwnd, wszName) != ERROR_SUCCESS)
        return E_FAIL;
 
    /* Show and select the new item in the def view */
    SelectNewItem(SHCNE_MKDIR, SHCNF_PATHW, wszName, TRUE);
 
    return S_OK;
}

Referenced by InvokeCommand().

CreateNewItem()

HRESULT CNewMenu::CreateNewItem ( SHELLNEW_ITEM *  pItem, LPCMINVOKECOMMANDINFO  lpcmi  )

private

Definition at line 593 of file CNewMenu.cpp.

{
    HRESULT hr;
    WCHAR wszPath[MAX_PATH], wszName[MAX_PATH];
 
    /* Get folder path */
    hr = SHGetPathFromIDListW(m_pidlFolder, wszPath);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    if (pItem == m_pLinkItem)
    {
        NewItemByNonCommand(pItem, wszName, _countof(wszName), wszPath);
        NewItemByCommand(pItem, wszName);
        return S_OK;
    }
 
    switch (pItem->Type)
    {
        case SHELLNEW_TYPE_COMMAND:
            NewItemByCommand(pItem, wszPath);
            break;
 
        case SHELLNEW_TYPE_DATA:
        case SHELLNEW_TYPE_FILENAME:
        case SHELLNEW_TYPE_NULLFILE:
            NewItemByNonCommand(pItem, wszName, _countof(wszName), wszPath);
            break;
 
        case SHELLNEW_TYPE_INVALID:
            ERR("Invalid type\n");
            break;
    }
 
    return S_OK;
}

Referenced by InvokeCommand().

FindItemFromIdOffset()

CNewMenu::SHELLNEW_ITEM * CNewMenu::FindItemFromIdOffset ( UINT  IdOffset )

private

Definition at line 404 of file CNewMenu.cpp.

{
    /* Folder */
    if (m_idCmdFirst + IdOffset == m_idCmdFolder)
        return NULL;
 
    /* Shortcut */
    if (m_idCmdFirst + IdOffset == m_idCmdLink)
        return m_pLinkItem;
 
    /* Find shell new item - Retrieve menu item info */
    MENUITEMINFOW mii;
    ZeroMemory(&mii, sizeof(mii));
    mii.cbSize = sizeof(mii);
    mii.fMask = MIIM_DATA;
 
    if (GetMenuItemInfoW(m_hSubMenu, m_idCmdFirst + IdOffset, FALSE, &mii) && mii.dwItemData)
        return (SHELLNEW_ITEM *)mii.dwItemData;
    else
        return NULL;
}

Referenced by HandleMenuMsg2(), and InvokeCommand().

GetCommandString()

HRESULT WINAPI CNewMenu::GetCommandString ( UINT_PTR  idCommand, UINT  uFlags, UINT *  lpReserved, LPSTR  lpszName, UINT  uMaxNameLen  )

override

Implements IContextMenu.

Definition at line 704 of file CNewMenu.cpp.

{
    FIXME("%p %lu %u %p %p %u\n", this,
          idCmd, uType, pwReserved, pszName, cchMax );
 
    return E_NOTIMPL;
}

GetSite()

HRESULT STDMETHODCALLTYPE CNewMenu::GetSite ( REFIID  riid, void **  ppvSite  )

override

Definition at line 636 of file CNewMenu.cpp.

{
    return m_pSite->QueryInterface(riid, ppvSite);
}

HandleMenuMsg()

HRESULT WINAPI CNewMenu::HandleMenuMsg ( UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

override

Implements IContextMenu2.

Definition at line 718 of file CNewMenu.cpp.

{
    return HandleMenuMsg2(uMsg, wParam, lParam, NULL);
}

HandleMenuMsg2()

HRESULT WINAPI CNewMenu::HandleMenuMsg2 ( UINT  uMsg, WPARAM  wParam, LPARAM  lParam, LRESULT *  plResult  )

override

Implements IContextMenu3.

Definition at line 725 of file CNewMenu.cpp.

{
    switch (uMsg)
    {
    case WM_MEASUREITEM:
        {
            MEASUREITEMSTRUCT* lpmis = reinterpret_cast<MEASUREITEMSTRUCT*>(lParam);
            if (!lpmis || lpmis->CtlType != ODT_MENU)
                break;
 
            if (lpmis->itemWidth < (UINT)GetSystemMetrics(SM_CXMENUCHECK))
                lpmis->itemWidth = GetSystemMetrics(SM_CXMENUCHECK);
            if (lpmis->itemHeight < 16)
                lpmis->itemHeight = 16;
 
            if (plResult)
                *plResult = TRUE;
            break;
        }
    case WM_DRAWITEM:
        {
            DRAWITEMSTRUCT* lpdis = reinterpret_cast<DRAWITEMSTRUCT*>(lParam);
            if (!lpdis || lpdis->CtlType != ODT_MENU)
                break;
 
            DWORD id = lpdis->itemID;
            HICON hIcon = NULL;
            if (id == m_idCmdFolder)
            {
                hIcon = m_hIconFolder;
            }
            else if (id == m_idCmdLink)
            {
                hIcon = m_hIconLink;
            }
            else
            {
                SHELLNEW_ITEM *pItem = FindItemFromIdOffset(id - m_idCmdFirst);
                if (pItem)
                    hIcon = pItem->hIcon;
            }
 
            if (!hIcon)
                break;
 
            DrawIconEx(lpdis->hDC,
                       2,
                       lpdis->rcItem.top + (lpdis->rcItem.bottom - lpdis->rcItem.top - 16) / 2,
                       hIcon,
                       16,
                       16,
                       0, NULL, DI_NORMAL);
 
            if(plResult)
                *plResult = TRUE;
        }
    }
 
    return S_OK;
}

Referenced by HandleMenuMsg().

Initialize()

HRESULT WINAPI CNewMenu::Initialize ( PCIDLIST_ABSOLUTE  pidlFolder, IDataObject *  pdtobj, HKEY  hkeyProgID  )

override

Implements IShellExtInit.

Definition at line 787 of file CNewMenu.cpp.

{
    const INT cx = GetSystemMetrics(SM_CXSMICON), cy = GetSystemMetrics(SM_CYSMICON);
    WCHAR wszIconPath[MAX_PATH];
    int icon_idx;
 
    m_pidlFolder = ILClone(pidlFolder);
 
    /* Load folder and shortcut icons */
    if (HLM_GetIconW(IDI_SHELL_FOLDER - 1, wszIconPath, _countof(wszIconPath), &icon_idx))
    {
        ::ExtractIconExW(wszIconPath, icon_idx, &m_hIconFolder, NULL, 1);
        m_bCustomIconFolder = TRUE;
    }
    else
    {
        m_hIconFolder = (HICON)LoadImage(shell32_hInstance, MAKEINTRESOURCE(IDI_SHELL_FOLDER), IMAGE_ICON, cx, cy, LR_SHARED);
    }
 
    if (HLM_GetIconW(IDI_SHELL_SHORTCUT - 1, wszIconPath, _countof(wszIconPath), &icon_idx))
    {
        ::ExtractIconExW(wszIconPath, icon_idx, &m_hIconLink, NULL, 1);
        m_bCustomIconLink = TRUE;
    }
    else
    {
        m_hIconLink = (HICON)LoadImage(shell32_hInstance, MAKEINTRESOURCE(IDI_SHELL_SHORTCUT), IMAGE_ICON, cx, cy, LR_SHARED);
    }
 
    return S_OK;
}

InsertShellNewItems()

UINT CNewMenu::InsertShellNewItems ( HMENU  hMenu, UINT  idFirst, UINT  idMenu  )

private

Definition at line 336 of file CNewMenu.cpp.

{
    MENUITEMINFOW mii;
    UINT idCmd = idCmdFirst;
    WCHAR wszBuf[256];
 
    if (m_pItems == NULL)
    {
        if (!LoadAllItems())
            return 0;
    }
 
    ZeroMemory(&mii, sizeof(mii));
    mii.cbSize = sizeof(mii);
 
    m_idCmdFirst = idCmd;
 
    /* Insert the new folder action */
    if (!LoadStringW(shell32_hInstance, FCIDM_SHVIEW_NEWFOLDER, wszBuf, _countof(wszBuf)))
        wszBuf[0] = 0;
    mii.fMask = MIIM_ID | MIIM_BITMAP | MIIM_STRING;
    mii.dwTypeData = wszBuf;
    mii.cch = wcslen(mii.dwTypeData);
    mii.wID = idCmd;
    mii.hbmpItem = HBMMENU_CALLBACK;
    if (InsertMenuItemW(hMenu, Pos++, TRUE, &mii))
        m_idCmdFolder = idCmd++;
 
    /* Insert the new shortcut action */
    if (m_pLinkItem)
    {
        if (!LoadStringW(shell32_hInstance, FCIDM_SHVIEW_NEWLINK, wszBuf, _countof(wszBuf)))
            wszBuf[0] = 0;
        mii.dwTypeData = wszBuf;
        mii.cch = wcslen(mii.dwTypeData);
        mii.wID = idCmd;
        if (InsertMenuItemW(hMenu, Pos++, TRUE, &mii))
            m_idCmdLink = idCmd++;
    }
 
    /* Insert a seperator for the custom new action */
    mii.fMask = MIIM_TYPE | MIIM_ID;
    mii.fType = MFT_SEPARATOR;
    mii.wID = -1;
    InsertMenuItemW(hMenu, Pos++, TRUE, &mii);
 
    /* Insert the rest of the items */
    mii.fMask = MIIM_ID | MIIM_BITMAP | MIIM_STRING | MIIM_DATA;
    mii.fType = 0;
 
    for (SHELLNEW_ITEM *pCurItem = m_pItems; pCurItem; pCurItem = pCurItem->pNext)
    {
        /* Skip shortcut item */
        if (pCurItem == m_pLinkItem)
            continue;
 
        TRACE("szDesc %s\n", debugstr_w(pCurItem->pwszDesc));
        mii.dwItemData = (ULONG_PTR)pCurItem;
        mii.dwTypeData = pCurItem->pwszDesc;
        mii.cch = wcslen(mii.dwTypeData);
        mii.wID = idCmd;
        if (InsertMenuItemW(hMenu, Pos++, TRUE, &mii))
            ++idCmd;
    }
 
    return idCmd - idCmdFirst;
}

Referenced by QueryContextMenu().

InvokeCommand()

HRESULT WINAPI CNewMenu::InvokeCommand ( LPCMINVOKECOMMANDINFO  lpcmi )

override

Implements IContextMenu.

Definition at line 683 of file CNewMenu.cpp.

{
    HRESULT hr = E_FAIL;
 
    if (m_idCmdFirst + LOWORD(lpici->lpVerb) == m_idCmdFolder)
    {
        hr = CreateNewFolder(lpici);
    }
    else
    {
        SHELLNEW_ITEM *pItem = FindItemFromIdOffset(LOWORD(lpici->lpVerb));
        if (pItem)
            hr = CreateNewItem(pItem, lpici);
    }
 
    TRACE("CNewMenu::InvokeCommand %x\n", hr);
    return hr;
}

LoadAllItems()

BOOL CNewMenu::LoadAllItems ( )

private

Definition at line 319 of file CNewMenu.cpp.

{
    // TODO: We need to find a way to refresh the cache from time to time, when
    // e.g. new extensions with ShellNew handlers have been added or removed.
 
    /* If there are any unload them */
    UnloadAllItems();
 
    if (!LoadCachedItems())
    {
        CacheItems();
    }
 
    return (m_pItems != NULL);
}

Referenced by InsertShellNewItems().

LoadCachedItems()

BOOL CNewMenu::LoadCachedItems ( )

private

Definition at line 261 of file CNewMenu.cpp.

{
    LPWSTR wszName;
    LPWSTR lpValues;
    DWORD dwSize;
    HKEY hKey;
    SHELLNEW_ITEM *pNewItem;
    SHELLNEW_ITEM *pCurItem = NULL;
 
    if (RegOpenKeyExW(HKEY_CURRENT_USER, ShellNewKey, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
        return FALSE;
 
    if (RegQueryValueExW(hKey, L"Classes", NULL, NULL, NULL, &dwSize) != ERROR_SUCCESS)
        return FALSE;
 
    lpValues = (LPWSTR) HeapAlloc(GetProcessHeap(), 0, dwSize);
    if (!lpValues)
        return FALSE;
 
    if (RegQueryValueExW(hKey, L"Classes", NULL, NULL, (LPBYTE)lpValues, &dwSize) != ERROR_SUCCESS)
    {
        HeapFree(GetProcessHeap(), 0, lpValues);
        return FALSE;
    }
 
    wszName = lpValues;
 
    for (; *wszName != '\0'; wszName += wcslen(wszName) + 1)
    {
        pNewItem = LoadItem(wszName);
        if (pNewItem)
        {
            if (!m_pLinkItem && _wcsicmp(pNewItem->pwszExt, L".lnk") == 0)
            {
                /* The unique link handler */
                m_pLinkItem = pNewItem;
            }
 
            /* Add at the end of the list */
            if (pCurItem)
            {
                pCurItem->pNext = pNewItem;
                pCurItem = pNewItem;
            }
            else
            {
                pCurItem = m_pItems = pNewItem;
            }
        }
    }
 
    HeapFree(GetProcessHeap(), 0, lpValues);
    RegCloseKey(hKey);
 
    return TRUE;
}

Referenced by LoadAllItems().

LoadItem()

CNewMenu::SHELLNEW_ITEM * CNewMenu::LoadItem ( LPCWSTR  pwszExt )

private

Definition at line 83 of file CNewMenu.cpp.

{
    HKEY hKey;
    WCHAR wszBuf[MAX_PATH];
    PBYTE pData = NULL;
    DWORD cbData;
 
    StringCbPrintfW(wszBuf, sizeof(wszBuf), L"%s\\ShellNew", pwszExt);
 
    TRACE("LoadItem Keyname %s Name %s\n", debugstr_w(pwszExt), debugstr_w(wszBuf));
 
    if (RegOpenKeyExW(HKEY_CLASSES_ROOT, wszBuf, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
    {
        WCHAR wszValue[MAX_PATH];
        cbData = sizeof(wszValue);
        if (RegGetValueW(HKEY_CLASSES_ROOT, pwszExt, NULL, RRF_RT_REG_SZ, NULL, wszValue,
                         &cbData) != ERROR_SUCCESS || !wszValue[0])
        {
            TRACE("Failed to open key\n");
            return NULL;
        }
        wszValue[_countof(wszValue) - 1] = UNICODE_NULL; // Avoid buffer overrun
        StringCbPrintfW(wszBuf, sizeof(wszBuf), L"%s\\%s\\ShellNew", pwszExt, wszValue);
        if (RegOpenKeyExW(HKEY_CLASSES_ROOT, wszBuf, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
        {
            TRACE("Failed to open key\n");
            return NULL;
        }
    }
 
    /* Find first valid value */
    struct
    {
        LPCWSTR pszName;
        SHELLNEW_TYPE Type;
        BOOL bNeedData;
        BOOL bStr;
    } Types[] = {
        {L"FileName", SHELLNEW_TYPE_FILENAME, TRUE, TRUE},
        {L"Command", SHELLNEW_TYPE_COMMAND, TRUE, TRUE},
        {L"Data", SHELLNEW_TYPE_DATA, TRUE, FALSE},
        {L"NullFile", SHELLNEW_TYPE_NULLFILE, FALSE},
        {NULL}
    };
    UINT i;
 
    for (i = 0; Types[i].pszName; ++i)
    {
        /* Note: We are using ANSI function because strings can be treated as data */
        cbData = 0;
        DWORD dwFlags = Types[i].bStr ? RRF_RT_REG_SZ : RRF_RT_ANY;
        DWORD dwType;
        if (RegGetValueW(hKey, NULL, Types[i].pszName, dwFlags, NULL, NULL, &cbData) == ERROR_SUCCESS)
        {
            if (Types[i].bNeedData && cbData > 0)
            {
                pData = (PBYTE)malloc(cbData);
                RegGetValueW(hKey, NULL, Types[i].pszName, dwFlags, &dwType, pData, &cbData);
                if (!Types[i].bStr && (dwType == REG_SZ || dwType == REG_EXPAND_SZ))
                {
                    PBYTE pData2 = (PBYTE)malloc(cbData);
                    cbData = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)pData, -1, (LPSTR)pData2, cbData, NULL, NULL);
                    free(pData);
                    pData = pData2;
                }
            }
            break;
        }
    }
    RegCloseKey(hKey);
 
    /* Was any key found? */
    if (!Types[i].pszName)
    {
        free(pData);
        return NULL;
    }
 
    SHFILEINFOW fi;
    if (!SHGetFileInfoW(pwszExt, FILE_ATTRIBUTE_NORMAL, &fi, sizeof(fi), SHGFI_USEFILEATTRIBUTES | SHGFI_TYPENAME | SHGFI_ICON | SHGFI_SMALLICON))
    {
        free(pData);
        return NULL;
    }
 
    /* Create new item */
    SHELLNEW_ITEM *pNewItem = static_cast<SHELLNEW_ITEM *>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SHELLNEW_ITEM)));
    if (!pNewItem)
    {
        free(pData);
        return NULL;
    }
 
    TRACE("new item %ls\n", fi.szTypeName);
    pNewItem->Type = Types[i].Type;
    pNewItem->pData = pData;
    pNewItem->cbData = pData ? cbData : 0;
    pNewItem->pwszExt = _wcsdup(pwszExt);
    pNewItem->pwszDesc = _wcsdup(fi.szTypeName);
    if (fi.hIcon)
        pNewItem->hIcon = fi.hIcon;
 
    return pNewItem;
}

Referenced by CacheItems(), and LoadCachedItems().

NewItemByCommand()

HRESULT CNewMenu::NewItemByCommand ( SHELLNEW_ITEM *  pItem, LPCWSTR  wszPath  )

private

Definition at line 494 of file CNewMenu.cpp.

{
    WCHAR wszBuf[MAX_PATH];
    LPWSTR Ptr, pwszCmd;
    WCHAR wszTemp[MAX_PATH];
    STARTUPINFOW si;
    PROCESS_INFORMATION pi;
 
    if (!ExpandEnvironmentStringsW((LPWSTR)pItem->pData, wszBuf, _countof(wszBuf)))
    {
        TRACE("ExpandEnvironmentStrings failed\n");
        return E_FAIL;
    }
 
    /* Expand command parameter, FIXME: there can be more modifiers */
    Ptr = wcsstr(wszBuf, L"%1");
    if (Ptr)
    {
        Ptr[1] = L's';
        StringCbPrintfW(wszTemp, sizeof(wszTemp), wszBuf, wszPath);
        pwszCmd = wszTemp;
    }
    else
    {
        pwszCmd = wszBuf;
    }
 
    /* Create process */
    ZeroMemory(&si, sizeof(si));
    si.cb = sizeof(si);
    if (CreateProcessW(NULL, pwszCmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
    {
        CloseHandle(pi.hProcess);
        CloseHandle(pi.hThread);
        return S_OK;
    }
    else
    {
        ERR("Failed to create process\n");
        return E_FAIL;
    }
}

Referenced by CreateNewItem().

NewItemByNonCommand()

HRESULT CNewMenu::NewItemByNonCommand ( SHELLNEW_ITEM *  pItem, LPWSTR  wszName, DWORD  cchNameMax, LPCWSTR  wszPath  )

private

Definition at line 537 of file CNewMenu.cpp.

{
    BOOL bSuccess = TRUE;
 
    CStringW strNewItem;
    strNewItem.Format(IDS_NEWITEMFORMAT, pItem->pwszDesc);
    strNewItem += pItem->pwszExt;
 
    /* Create the name of the new file */
    if (!PathYetAnotherMakeUniqueName(wszName, wszPath, NULL, strNewItem))
        return E_FAIL;
 
    /* Create new file */
    HANDLE hFile = CreateFileW(wszName, GENERIC_WRITE, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hFile != INVALID_HANDLE_VALUE)
    {
        if (pItem->Type == SHELLNEW_TYPE_DATA)
        {
            /* Write a content */
            DWORD cbWritten;
            WriteFile(hFile, pItem->pData, pItem->cbData, &cbWritten, NULL);
        }
 
        /* Close file now */
        CloseHandle(hFile);
    }
    else
    {
        bSuccess = FALSE;
    }
 
    if (pItem->Type == SHELLNEW_TYPE_FILENAME)
    {
        /* Copy file */
        if (!CopyFileW((LPWSTR)pItem->pData, wszName, FALSE))
            ERR("Copy file failed: %ls\n", (LPWSTR)pItem->pData);
    }
 
    /* Show message if we failed */
    if (bSuccess)
    {
        TRACE("Notifying fs %s\n", debugstr_w(wszName));
        SelectNewItem(SHCNE_CREATE, SHCNF_PATHW, wszName, pItem != m_pLinkItem);
    }
    else
    {
        CStringW Caption(MAKEINTRESOURCEW(IDS_CREATEFILE_CAPTION));
        CStringW Message(MAKEINTRESOURCEW(IDS_CREATEFILE_DENIED));
        Message.FormatMessage(Message.GetString(), wszName);
        MessageBoxW(0, Message, Caption, MB_ICONEXCLAMATION | MB_OK);
    }
 
    return S_OK;
}

Referenced by CreateNewItem().

QueryContextMenu()

HRESULT WINAPI CNewMenu::QueryContextMenu ( HMENU  hMenu, UINT  indexMenu, UINT  idCmdFirst, UINT  idCmdLast, UINT  uFlags  )

override

Implements IContextMenu.

Definition at line 643 of file CNewMenu.cpp.

{
    MENUITEMINFOW mii;
    UINT cItems = 0;
    WCHAR wszNew[200];
 
    TRACE("%p %p %u %u %u %u\n", this,
          hMenu, indexMenu, idCmdFirst, idCmdLast, uFlags);
 
    if (!LoadStringW(shell32_hInstance, FCIDM_SHVIEW_NEW, wszNew, _countof(wszNew)))
        return E_FAIL;
 
    m_hSubMenu = CreateMenu();
    if (!m_hSubMenu)
        return E_FAIL;
 
    cItems = InsertShellNewItems(m_hSubMenu, idCmdFirst, 0);
 
    ZeroMemory(&mii, sizeof(mii));
    mii.cbSize = sizeof(mii);
    mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE | MIIM_SUBMENU;
    mii.fType = MFT_STRING;
    mii.wID = -1;
    mii.dwTypeData = wszNew;
    mii.cch = wcslen(mii.dwTypeData);
    mii.fState = MFS_ENABLED;
    mii.hSubMenu = m_hSubMenu;
 
    if (!InsertMenuItemW(hMenu, indexMenu, TRUE, &mii))
        return E_FAIL;
 
    return MAKE_HRESULT(SEVERITY_SUCCESS, 0, cItems);
}

SelectNewItem()

HRESULT CNewMenu::SelectNewItem ( LONG  wEventId, UINT  uFlags, LPWSTR  pszName, BOOL  bRename  )

private

Definition at line 426 of file CNewMenu.cpp.

{
    CComPtr<IShellBrowser> lpSB;
    CComPtr<IShellView> lpSV;
    HRESULT hr = E_FAIL;
    LPITEMIDLIST pidl;
    PITEMID_CHILD pidlNewItem;
    DWORD dwSelectFlags;
 
    dwSelectFlags = SVSI_DESELECTOTHERS | SVSI_ENSUREVISIBLE | SVSI_FOCUSED | SVSI_SELECT;
    if (bRename)
        dwSelectFlags |= SVSI_EDIT;
 
    /* Notify the view object about the new item */
    SHChangeNotify(wEventId, uFlags | SHCNF_FLUSH, (LPCVOID)pszName, NULL);
 
    if (!m_pSite)
        return S_OK;
 
    /* Get a pointer to the shell view */
    hr = IUnknown_QueryService(m_pSite, SID_SFolderView, IID_PPV_ARG(IShellView, &lpSV));
    if (FAILED_UNEXPECTEDLY(hr))
        return S_OK;
 
    /* Attempt to get the pidl of the new item */
    hr = SHILCreateFromPathW(pszName, &pidl, NULL);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    pidlNewItem = ILFindLastID(pidl);
 
    hr = lpSV->SelectItem(pidlNewItem, dwSelectFlags);
 
    SHFree(pidl);
 
    return hr;
}

Referenced by CreateNewFolder(), and NewItemByNonCommand().

SetSite()

HRESULT STDMETHODCALLTYPE CNewMenu::SetSite ( IUnknown *  pUnkSite )

override

Implements IObjectWithSite.

Definition at line 630 of file CNewMenu.cpp.

{
    m_pSite = pUnkSite;
    return S_OK;
}

UnloadAllItems()

void CNewMenu::UnloadAllItems ( )

private

Definition at line 68 of file CNewMenu.cpp.

{
    SHELLNEW_ITEM *pCurItem;
 
    /* Unload the handler items, including the link item */
    while (m_pItems)
    {
        pCurItem = m_pItems;
        m_pItems = m_pItems->pNext;
        UnloadItem(pCurItem);
    }
    m_pItems = NULL;
    m_pLinkItem = NULL;
}

Referenced by LoadAllItems(), and ~CNewMenu().

UnloadItem()

void CNewMenu::UnloadItem ( SHELLNEW_ITEM *  pItem )

private

Definition at line 55 of file CNewMenu.cpp.

{
    /* Note: free allows NULL as argument */
    free(pItem->pData);
    free(pItem->pwszDesc);
    free(pItem->pwszExt);
 
    if (pItem->hIcon)
        DestroyIcon(pItem->hIcon);
 
    HeapFree(GetProcessHeap(), 0, pItem);
}

Referenced by UnloadAllItems().

Member Data Documentation

m_bCustomIconFolder

BOOL CNewMenu::m_bCustomIconFolder

private

Definition at line 62 of file CNewMenu.h.

Referenced by Initialize(), and ~CNewMenu().

m_bCustomIconLink

BOOL CNewMenu::m_bCustomIconLink

private

Definition at line 62 of file CNewMenu.h.

Referenced by Initialize(), and ~CNewMenu().

m_hIconFolder

HICON CNewMenu::m_hIconFolder

private

Definition at line 63 of file CNewMenu.h.

Referenced by HandleMenuMsg2(), Initialize(), and ~CNewMenu().

m_hIconLink

HICON CNewMenu::m_hIconLink

private

Definition at line 63 of file CNewMenu.h.

Referenced by HandleMenuMsg2(), Initialize(), and ~CNewMenu().

m_hSubMenu

HMENU CNewMenu::m_hSubMenu

private

Definition at line 60 of file CNewMenu.h.

Referenced by FindItemFromIdOffset(), and QueryContextMenu().

m_idCmdFirst

UINT CNewMenu::m_idCmdFirst

private

Definition at line 61 of file CNewMenu.h.

Referenced by FindItemFromIdOffset(), HandleMenuMsg2(), InsertShellNewItems(), and InvokeCommand().

m_idCmdFolder

UINT CNewMenu::m_idCmdFolder

private

Definition at line 61 of file CNewMenu.h.

Referenced by FindItemFromIdOffset(), HandleMenuMsg2(), InsertShellNewItems(), and InvokeCommand().

m_idCmdLink

UINT CNewMenu::m_idCmdLink

private

Definition at line 61 of file CNewMenu.h.

Referenced by FindItemFromIdOffset(), HandleMenuMsg2(), and InsertShellNewItems().

m_pidlFolder

LPITEMIDLIST CNewMenu::m_pidlFolder

private

Definition at line 56 of file CNewMenu.h.

Referenced by CreateNewFolder(), CreateNewItem(), Initialize(), and ~CNewMenu().

m_pItems

SHELLNEW_ITEM* CNewMenu::m_pItems

private

Definition at line 57 of file CNewMenu.h.

Referenced by CacheItems(), InsertShellNewItems(), LoadAllItems(), LoadCachedItems(), and UnloadAllItems().

m_pLinkItem

SHELLNEW_ITEM* CNewMenu::m_pLinkItem

private

Definition at line 58 of file CNewMenu.h.

Referenced by CacheItems(), CreateNewItem(), FindItemFromIdOffset(), InsertShellNewItems(), LoadCachedItems(), NewItemByNonCommand(), and UnloadAllItems().

m_pSite

CComPtr<IUnknown> CNewMenu::m_pSite

private

Definition at line 59 of file CNewMenu.h.

Referenced by GetSite(), SelectNewItem(), and SetSite().

---

The documentation for this class was generated from the following files:

• dll/win32/shell32/CNewMenu.h
• dll/win32/shell32/CNewMenu.cpp