CDefaultContextMenu Class Reference

Inheritance diagram for CDefaultContextMenu:

Collaboration diagram for CDefaultContextMenu:

Public Member Functions
	CDefaultContextMenu ()
	~CDefaultContextMenu ()
HRESULT WINAPI	Initialize (const DEFCONTEXTMENU *pdcm, LPFNDFMCALLBACK lpfn)
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()	HandleMenuMsg (UINT uMsg, WPARAM wParam, LPARAM lParam) override
STDMETHOD()	HandleMenuMsg2 (UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *plResult) override
STDMETHOD()	SetSite (IUnknown *pUnkSite) override
STDMETHOD()	GetSite (REFIID riid, void **ppvSite) override
virtual HRESULT STDMETHODCALLTYPE	QueryService (REFGUID svc, REFIID riid, void **ppv)
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 ()
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)
Public Member Functions inherited from IUnknown
HRESULT	QueryInterface ([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
ULONG	AddRef ()
ULONG	Release ()
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 IServiceProvider
HRESULT	QueryService ([in] REFGUID guidService, [in] REFIID riid, [out] void **ppvObject)
HRESULT	RemoteQueryService ([in] REFGUID guidService, [in] REFIID riid, [out, iid_is(riid)] IUnknown **ppvObject)

Private Member Functions
HRESULT	_DoCallback (UINT uMsg, WPARAM wParam, LPVOID lParam)
void	AddStaticEntry (const HKEY hkeyClass, const WCHAR *szVerb, UINT uFlags)
void	AddStaticEntriesForKey (HKEY hKey, UINT uFlags)
void	TryPickDefault (HMENU hMenu, UINT idCmdFirst, UINT DfltOffset, UINT uFlags)
BOOL	IsShellExtensionAlreadyLoaded (REFCLSID clsid)
HRESULT	LoadDynamicContextMenuHandler (HKEY hKey, REFCLSID clsid)
BOOL	EnumerateDynamicContextHandlerForKey (HKEY hRootKey)
UINT	AddShellExtensionsToMenu (HMENU hMenu, UINT *pIndexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags)
UINT	AddStaticContextMenusToMenu (HMENU hMenu, UINT *IndexMenu, UINT iIdCmdFirst, UINT iIdCmdLast, UINT uFlags)
HRESULT	DoPaste (LPCMINVOKECOMMANDINFOEX lpcmi, BOOL bLink)
HRESULT	DoOpenOrExplore (LPCMINVOKECOMMANDINFOEX lpcmi)
HRESULT	DoCreateLink (LPCMINVOKECOMMANDINFOEX lpcmi)
HRESULT	DoDelete (LPCMINVOKECOMMANDINFOEX lpcmi)
HRESULT	DoCopyOrCut (LPCMINVOKECOMMANDINFOEX lpcmi, BOOL bCopy)
HRESULT	DoRename (LPCMINVOKECOMMANDINFOEX lpcmi)
HRESULT	DoProperties (LPCMINVOKECOMMANDINFOEX lpcmi)
HRESULT	DoUndo (LPCMINVOKECOMMANDINFOEX lpcmi)
HRESULT	DoCreateNewFolder (LPCMINVOKECOMMANDINFOEX lpici)
HRESULT	DoCopyToMoveToFolder (LPCMINVOKECOMMANDINFOEX lpici, BOOL bCopy)
HRESULT	InvokeShellExt (LPCMINVOKECOMMANDINFOEX lpcmi)
HRESULT	InvokeRegVerb (LPCMINVOKECOMMANDINFOEX lpcmi)
DWORD	BrowserFlagsFromVerb (LPCMINVOKECOMMANDINFOEX lpcmi, PStaticShellEntry pEntry)
HRESULT	TryToBrowse (LPCMINVOKECOMMANDINFOEX lpcmi, LPCITEMIDLIST pidl, DWORD wFlags)
HRESULT	InvokePidl (LPCMINVOKECOMMANDINFOEX lpcmi, LPCITEMIDLIST pidl, PStaticShellEntry pEntry)
PDynamicShellEntry	GetDynamicEntry (UINT idCmd)
BOOL	MapVerbToCmdId (PVOID Verb, PUINT idCmd, BOOL IsUnicode)

Private Attributes
CComPtr< IUnknown >	m_site
CComPtr< IShellFolder >	m_psf
CComPtr< IContextMenuCB >	m_pmcb
LPFNDFMCALLBACK	m_pfnmcb
UINT	m_cidl
PCUITEMID_CHILD_ARRAY	m_apidl
CComPtr< IDataObject >	m_pDataObj
HKEY *	m_aKeys
UINT	m_cKeys
PIDLIST_ABSOLUTE	m_pidlFolder
DWORD	m_bGroupPolicyActive
CAtlList< DynamicShellEntry >	m_DynamicEntries
UINT	m_iIdSHEFirst
UINT	m_iIdSHELast
CAtlList< StaticShellEntry >	m_StaticEntries
UINT	m_iIdSCMFirst
UINT	m_iIdSCMLast
UINT	m_iIdCBFirst
UINT	m_iIdCBLast
UINT	m_iIdDfltFirst
UINT	m_iIdDfltLast
HWND	m_hwnd

Additional Inherited Members
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 IUnknown
typedef IUnknown *	LPUNKNOWN
Public Types inherited from IObjectWithSite
typedef IObjectWithSite *	LPOBJECTWITHSITE
Public Types inherited from IServiceProvider
typedef IServiceProvider *	LPSERVICEPROVIDER
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 83 of file CDefaultContextMenu.cpp.

Constructor & Destructor Documentation

CDefaultContextMenu()

CDefaultContextMenu::CDefaultContextMenu

(

)

Definition at line 175 of file CDefaultContextMenu.cpp.

                                         :
    m_psf(NULL),
    m_pmcb(NULL),
    m_pfnmcb(NULL),
    m_cidl(0),
    m_apidl(NULL),
    m_pDataObj(NULL),
    m_aKeys(NULL),
    m_cKeys(NULL),
    m_pidlFolder(NULL),
    m_bGroupPolicyActive(0),
    m_iIdSHEFirst(0),
    m_iIdSHELast(0),
    m_iIdSCMFirst(0),
    m_iIdSCMLast(0),
    m_iIdCBFirst(0),
    m_iIdCBLast(0),
    m_iIdDfltFirst(0),
    m_iIdDfltLast(0),
    m_hwnd(NULL)
{
}

~CDefaultContextMenu()

CDefaultContextMenu::~CDefaultContextMenu

(

)

Definition at line 198 of file CDefaultContextMenu.cpp.

{
    m_DynamicEntries.RemoveAll();
    m_StaticEntries.RemoveAll();
 
    for (UINT i = 0; i < m_cKeys; i++)
        RegCloseKey(m_aKeys[i]);
    HeapFree(GetProcessHeap(), 0, m_aKeys);
 
    if (m_pidlFolder)
        CoTaskMemFree(m_pidlFolder);
    _ILFreeaPidl(const_cast<PITEMID_CHILD *>(m_apidl), m_cidl);
}

Member Function Documentation

_DoCallback()

HRESULT CDefaultContextMenu::_DoCallback ( UINT  uMsg, WPARAM  wParam, LPVOID  lParam  )

private

Definition at line 260 of file CDefaultContextMenu.cpp.

{
    if (m_pmcb)
    {
        return m_pmcb->CallBack(m_psf, m_hwnd, m_pDataObj, uMsg, wParam, (LPARAM)lParam);
    }
    else if(m_pfnmcb)
    {
        return m_pfnmcb(m_psf, m_hwnd, m_pDataObj, uMsg, wParam, (LPARAM)lParam);
    }
 
    return E_FAIL;
}

Referenced by DoProperties(), InvokeCommand(), QueryContextMenu(), and TryPickDefault().

AddShellExtensionsToMenu()

UINT CDefaultContextMenu::AddShellExtensionsToMenu ( HMENU  hMenu, UINT *  pIndexMenu, UINT  idCmdFirst, UINT  idCmdLast, UINT  uFlags  )

private

Definition at line 462 of file CDefaultContextMenu.cpp.

{
    UINT cIds = 0;
 
    if (m_DynamicEntries.IsEmpty())
        return cIds;
 
    POSITION it = m_DynamicEntries.GetHeadPosition();
    while (it != NULL)
    {
        DynamicShellEntry& info = m_DynamicEntries.GetNext(it);
 
        HRESULT hr = info.pCM->QueryContextMenu(hMenu, *pIndexMenu, idCmdFirst + cIds, idCmdLast, uFlags);
        if (SUCCEEDED(hr))
        {
            info.iIdCmdFirst = cIds;
            info.NumIds = HRESULT_CODE(hr);
            (*pIndexMenu) += info.NumIds;
 
            cIds += info.NumIds;
            if (idCmdFirst + cIds >= idCmdLast)
                break;
        }
        TRACE("pEntry hr %x contextmenu %p cmdfirst %x num ids %x\n", hr, info.pCM.p, info.iIdCmdFirst, info.NumIds);
    }
    return cIds;
}

Referenced by QueryContextMenu().

AddStaticContextMenusToMenu()

UINT CDefaultContextMenu::AddStaticContextMenusToMenu ( HMENU  hMenu, UINT *  IndexMenu, UINT  iIdCmdFirst, UINT  iIdCmdLast, UINT  uFlags  )

private

Definition at line 491 of file CDefaultContextMenu.cpp.

{
    UINT ntver = RosGetProcessEffectiveVersion();
    MENUITEMINFOW mii = { sizeof(mii) };
    UINT idResource;
    WCHAR wszVerb[40];
    UINT fState;
    UINT cIds = 0, indexFirst = *pIndexMenu;
 
    mii.fMask = MIIM_ID | MIIM_TYPE | MIIM_STATE | MIIM_DATA;
    mii.fType = MFT_STRING;
 
    POSITION it = m_StaticEntries.GetHeadPosition();
    bool first = true;
    while (it != NULL)
    {
        StaticShellEntry& info = m_StaticEntries.GetNext(it);
        BOOL forceFirstPos = FALSE;
 
        fState = MFS_ENABLED;
 
        /* set first entry as default */
        if (first)
        {
            fState |= MFS_DEFAULT;
            first = false;
        }
 
        if (info.Verb.CompareNoCase(L"open") == 0)
        {
            idResource = IDS_OPEN_VERB;
            fState |= MFS_DEFAULT; /* override default when open verb is found */
            forceFirstPos++;
        }
        else if (info.Verb.CompareNoCase(L"explore") == 0)
        {
            idResource = IDS_EXPLORE_VERB;
            if (uFlags & CMF_EXPLORE)
            {
                fState |= MFS_DEFAULT;
                forceFirstPos++;
            }
        }
        else if (info.Verb.CompareNoCase(L"runas") == 0)
            idResource = IDS_RUNAS_VERB;
        else if (info.Verb.CompareNoCase(L"edit") == 0)
            idResource = IDS_EDIT_VERB;
        else if (info.Verb.CompareNoCase(L"find") == 0)
            idResource = IDS_FIND_VERB;
        else if (info.Verb.CompareNoCase(L"print") == 0)
            idResource = IDS_PRINT_VERB;
        else if (info.Verb.CompareNoCase(L"printto") == 0)
            continue;
        else
            idResource = 0;
 
        /* By default use verb for menu item name */
        mii.dwTypeData = (LPWSTR)info.Verb.GetString();
 
        WCHAR wszKey[sizeof("shell\\") + MAX_VERB];
        HRESULT hr;
        hr = StringCbPrintfW(wszKey, sizeof(wszKey), L"shell\\%s", info.Verb.GetString());
        if (FAILED_UNEXPECTEDLY(hr))
        {
            continue;
        }
 
        UINT cmdFlags = 0;
        bool hide = false;
        HKEY hkVerb;
        if (idResource > 0)
        {
            if (!(uFlags & CMF_OPTIMIZEFORINVOKE))
            {
                if (LoadStringW(shell32_hInstance, idResource, wszVerb, _countof(wszVerb)))
                    mii.dwTypeData = wszVerb; /* use translated verb */
                else
                    ERR("Failed to load string\n");
            }
 
            if (RegOpenKeyW(info.hkClass, wszKey, &hkVerb) != ERROR_SUCCESS)
                hkVerb = NULL;
        }
        else
        {
            if (RegOpenKeyW(info.hkClass, wszKey, &hkVerb) == ERROR_SUCCESS)
            {
                if (!(uFlags & CMF_OPTIMIZEFORINVOKE))
                {
                    DWORD cbVerb = sizeof(wszVerb);
 
                    LONG res = RegLoadMUIStringW(hkVerb, L"MUIVerb", wszVerb, cbVerb, NULL, 0, NULL);
                    if (res || !*wszVerb)
                        res = RegLoadMUIStringW(hkVerb, NULL, wszVerb, cbVerb, NULL, 0, NULL);
 
                    if (res == ERROR_SUCCESS && *wszVerb)
                    {
                        /* use description for the menu entry */
                        mii.dwTypeData = wszVerb;
                    }
                }
            }
            else
            {
                hkVerb = NULL;
            }
        }
 
        if (hkVerb)
        {
            // FIXME: GetAsyncKeyState should not be called here, clients
            // need to be updated to set the CMF_EXTENDEDVERBS flag.
            if (!(uFlags & CMF_EXTENDEDVERBS) && GetAsyncKeyState(VK_SHIFT) >= 0)
                hide = RegValueExists(hkVerb, L"Extended");
 
            if (!hide)
                hide = RegValueExists(hkVerb, L"ProgrammaticAccessOnly");
 
            if (!hide && !(uFlags & CMF_DISABLEDVERBS))
                hide = RegValueExists(hkVerb, L"LegacyDisable");
 
            if (RegValueExists(hkVerb, L"NeverDefault"))
                fState &= ~MFS_DEFAULT;
 
            if (RegValueExists(hkVerb, L"SeparatorBefore"))
                cmdFlags |= ECF_SEPARATORBEFORE;
            if (RegValueExists(hkVerb, L"SeparatorAfter"))
                cmdFlags |= ECF_SEPARATORAFTER;
 
            RegCloseKey(hkVerb);
        }
 
        if (((uFlags & CMF_NODEFAULT) && ntver >= _WIN32_WINNT_VISTA) ||
            ((uFlags & CMF_DONOTPICKDEFAULT) && ntver >= _WIN32_WINNT_WIN7))
        {
            fState &= ~MFS_DEFAULT;
        }
 
        if (!hide)
        {
            if (cmdFlags & ECF_SEPARATORBEFORE)
            {
                if (InsertMenuItemAt(hMenu, *pIndexMenu, MF_SEPARATOR))
                    (*pIndexMenu)++;
            }
 
            mii.fState = fState;
            mii.wID = iIdCmdFirst + cIds;
            if (InsertMenuItemW(hMenu, forceFirstPos ? indexFirst : *pIndexMenu, TRUE, &mii))
                (*pIndexMenu)++;
 
            if (cmdFlags & ECF_SEPARATORAFTER)
            {
                if (InsertMenuItemAt(hMenu, *pIndexMenu, MF_SEPARATOR))
                    (*pIndexMenu)++;
            }
        }
        cIds++; // Always increment the id because it acts as the index into m_StaticEntries
 
        if (mii.wID >= iIdCmdLast)
            break;
    }
 
    return cIds;
}

Referenced by QueryContextMenu().

AddStaticEntriesForKey()

void CDefaultContextMenu::AddStaticEntriesForKey ( HKEY  hKey, UINT  uFlags  )

private

Definition at line 300 of file CDefaultContextMenu.cpp.

{
    WCHAR wszName[40];
    DWORD cchName, dwIndex = 0;
    HKEY hShellKey;
 
    LRESULT lres = RegOpenKeyExW(hKey, L"shell", 0, KEY_READ, &hShellKey);
    if (lres != STATUS_SUCCESS)
        return;
 
    while(TRUE)
    {
        cchName = _countof(wszName);
        if (RegEnumKeyExW(hShellKey, dwIndex++, wszName, &cchName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
            break;
 
        AddStaticEntry(hKey, wszName, uFlags);
    }
 
    RegCloseKey(hShellKey);
}

Referenced by QueryContextMenu().

AddStaticEntry()

void CDefaultContextMenu::AddStaticEntry ( const HKEY  hkeyClass, const WCHAR *  szVerb, UINT  uFlags  )

private

Definition at line 274 of file CDefaultContextMenu.cpp.

{
    POSITION it = m_StaticEntries.GetHeadPosition();
    while (it != NULL)
    {
        const StaticShellEntry& info = m_StaticEntries.GetNext(it);
        if (info.Verb.CompareNoCase(szVerb) == 0)
        {
            /* entry already exists */
            return;
        }
    }
 
    TRACE("adding verb %s\n", debugstr_w(szVerb));
 
    if (!wcsicmp(szVerb, L"open") && !(uFlags & CMF_NODEFAULT))
    {
        /* open verb is always inserted in front */
        m_StaticEntries.AddHead({ szVerb, hkeyClass });
    }
    else
    {
        m_StaticEntries.AddTail({ szVerb, hkeyClass });
    }
}

Referenced by AddStaticEntriesForKey().

BrowserFlagsFromVerb()

DWORD CDefaultContextMenu::BrowserFlagsFromVerb ( LPCMINVOKECOMMANDINFOEX  lpcmi, PStaticShellEntry  pEntry  )

private

Definition at line 1157 of file CDefaultContextMenu.cpp.

{
    CComPtr<IShellBrowser> psb;
    HWND hwndTree;
    LPCWSTR FlagsName;
    WCHAR wszKey[sizeof("shell\\") + MAX_VERB];
    HRESULT hr;
    DWORD wFlags;
    DWORD cbVerb;
 
    if (!m_site)
        return 0;
 
    /* Get a pointer to the shell browser */
    hr = IUnknown_QueryService(m_site, SID_IShellBrowser, IID_PPV_ARG(IShellBrowser, &psb));
    if (FAILED(hr))
        return 0;
 
    /* See if we are in Explore or Browse mode. If the browser's tree is present, we are in Explore mode.*/
    if (SUCCEEDED(psb->GetControlWindow(FCW_TREE, &hwndTree)) && hwndTree)
        FlagsName = L"ExplorerFlags";
    else
        FlagsName = L"BrowserFlags";
 
    /* Try to get the flag from the verb */
    hr = StringCbPrintfW(wszKey, sizeof(wszKey), L"shell\\%s", pEntry->Verb.GetString());
    if (FAILED_UNEXPECTEDLY(hr))
        return 0;
 
    cbVerb = sizeof(wFlags);
    if (RegGetValueW(pEntry->hkClass, wszKey, FlagsName, RRF_RT_REG_DWORD, NULL, &wFlags, &cbVerb) == ERROR_SUCCESS)
    {
        return wFlags;
    }
 
    return 0;
}

Referenced by InvokeRegVerb().

DoCopyOrCut()

HRESULT CDefaultContextMenu::DoCopyOrCut ( LPCMINVOKECOMMANDINFOEX  lpcmi, BOOL  bCopy  )

private

Definition at line 921 of file CDefaultContextMenu.cpp.

{
    if (!m_cidl || !m_pDataObj)
        return E_FAIL;
 
    FORMATETC formatetc;
    InitFormatEtc(formatetc, RegisterClipboardFormatW(CFSTR_PREFERREDDROPEFFECT), TYMED_HGLOBAL);
    STGMEDIUM medium = {0};
    medium.tymed = TYMED_HGLOBAL;
    medium.hGlobal = GlobalAlloc(GHND, sizeof(DWORD));
    DWORD* pdwFlag = (DWORD*)GlobalLock(medium.hGlobal);
    if (pdwFlag)
        *pdwFlag = bCopy ? DROPEFFECT_COPY : DROPEFFECT_MOVE;
    GlobalUnlock(medium.hGlobal);
    m_pDataObj->SetData(&formatetc, &medium, TRUE);
 
    HRESULT hr = OleSetClipboard(m_pDataObj);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    return S_OK;
}

Referenced by InvokeCommand().

DoCopyToMoveToFolder()

HRESULT CDefaultContextMenu::DoCopyToMoveToFolder ( LPCMINVOKECOMMANDINFOEX  lpici, BOOL  bCopy  )

private

Definition at line 993 of file CDefaultContextMenu.cpp.

{
    HRESULT hr = E_FAIL;
    if (!m_pDataObj)
    {
        ERR("m_pDataObj is NULL\n");
        return hr;
    }
 
    CComPtr<IContextMenu> pContextMenu;
    if (bCopy)
        hr = SHCoCreateInstance(NULL, &CLSID_CopyToMenu, NULL,
                                IID_PPV_ARG(IContextMenu, &pContextMenu));
    else
        hr = SHCoCreateInstance(NULL, &CLSID_MoveToMenu, NULL,
                                IID_PPV_ARG(IContextMenu, &pContextMenu));
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    CComPtr<IShellExtInit> pInit;
    hr = pContextMenu->QueryInterface(IID_PPV_ARG(IShellExtInit, &pInit));
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    hr = pInit->Initialize(m_pidlFolder, m_pDataObj, NULL);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    if (bCopy)
        lpici->lpVerb = "copyto";
    else
        lpici->lpVerb = "moveto";
 
    return pContextMenu->InvokeCommand((LPCMINVOKECOMMANDINFO)lpici);
}

Referenced by InvokeCommand().

DoCreateLink()

HRESULT CDefaultContextMenu::DoCreateLink ( LPCMINVOKECOMMANDINFOEX  lpcmi )

private

Definition at line 890 of file CDefaultContextMenu.cpp.

{
    if (!m_cidl || !m_pDataObj)
        return E_FAIL;
 
    CComPtr<IDropTarget> pDT;
    HRESULT hr = m_psf->CreateViewObject(NULL, IID_PPV_ARG(IDropTarget, &pDT));
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    SHSimulateDrop(pDT, m_pDataObj, MK_CONTROL|MK_SHIFT, NULL, NULL);
 
    return S_OK;
}

Referenced by InvokeCommand().

DoCreateNewFolder()

HRESULT CDefaultContextMenu::DoCreateNewFolder ( LPCMINVOKECOMMANDINFOEX  lpici )

private

Definition at line 1031 of file CDefaultContextMenu.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 */
    LPITEMIDLIST pidl;
    PITEMID_CHILD pidlNewItem;
    CComPtr<IShellView> psv;
 
    /* Notify the view object about the new item */
    SHChangeNotify(SHCNE_MKDIR, SHCNF_PATHW | SHCNF_FLUSH, (LPCVOID)wszName, NULL);
 
    if (!m_site)
        return S_OK;
 
    /* Get a pointer to the shell view */
    hr = IUnknown_QueryService(m_site, SID_IFolderView, IID_PPV_ARG(IShellView, &psv));
    if (FAILED_UNEXPECTEDLY(hr))
        return S_OK;
 
    /* Attempt to get the pidl of the new item */
    hr = SHILCreateFromPathW(wszName, &pidl, NULL);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    pidlNewItem = ILFindLastID(pidl);
 
    hr = psv->SelectItem(pidlNewItem, SVSI_DESELECTOTHERS | SVSI_EDIT | SVSI_ENSUREVISIBLE |
                          SVSI_FOCUSED | SVSI_SELECT);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    SHFree(pidl);
 
    return S_OK;
}

Referenced by InvokeCommand().

DoDelete()

HRESULT CDefaultContextMenu::DoDelete ( LPCMINVOKECOMMANDINFOEX  lpcmi )

private

Definition at line 905 of file CDefaultContextMenu.cpp.

{
    if (!m_cidl || !m_pDataObj)
        return E_FAIL;
 
    CComPtr<IDropTarget> pDT;
    HRESULT hr = CRecyclerDropTarget_CreateInstance(IID_PPV_ARG(IDropTarget, &pDT));
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    DWORD grfKeyState = (lpcmi->fMask & CMIC_MASK_SHIFT_DOWN) ? MK_SHIFT : 0;
    SHSimulateDrop(pDT, m_pDataObj, grfKeyState, NULL, NULL);
 
    return S_OK;
}

Referenced by InvokeCommand().

DoOpenOrExplore()

HRESULT CDefaultContextMenu::DoOpenOrExplore ( LPCMINVOKECOMMANDINFOEX  lpcmi )

private

Definition at line 884 of file CDefaultContextMenu.cpp.

{
    UNIMPLEMENTED;
    return E_FAIL;
}

Referenced by InvokeCommand().

DoPaste()

HRESULT CDefaultContextMenu::DoPaste ( LPCMINVOKECOMMANDINFOEX  lpcmi, BOOL  bLink  )

private

Definition at line 831 of file CDefaultContextMenu.cpp.

{
    HRESULT hr;
 
    CComPtr<IDataObject> pda;
    hr = OleGetClipboard(&pda);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    FORMATETC formatetc2;
    STGMEDIUM medium2;
    InitFormatEtc(formatetc2, RegisterClipboardFormatW(CFSTR_PREFERREDDROPEFFECT), TYMED_HGLOBAL);
 
    DWORD dwKey= 0;
 
    if (SUCCEEDED(pda->GetData(&formatetc2, &medium2)))
    {
        DWORD * pdwFlag = (DWORD*)GlobalLock(medium2.hGlobal);
        if (pdwFlag)
        {
            if (*pdwFlag == DROPEFFECT_COPY)
                dwKey = MK_CONTROL;
            else
                dwKey = MK_SHIFT;
        }
        else
        {
            ERR("No drop effect obtained\n");
        }
        GlobalUnlock(medium2.hGlobal);
    }
 
    if (bLink)
    {
        dwKey = MK_CONTROL|MK_SHIFT;
    }
 
    CComPtr<IDropTarget> pdrop;
    if (m_cidl)
        hr = m_psf->GetUIObjectOf(NULL, 1, &m_apidl[0], IID_NULL_PPV_ARG(IDropTarget, &pdrop));
    else
        hr = m_psf->CreateViewObject(NULL, IID_PPV_ARG(IDropTarget, &pdrop));
 
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    SHSimulateDrop(pdrop, pda, dwKey, NULL, NULL);
 
    TRACE("CP result %x\n", hr);
    return S_OK;
}

Referenced by InvokeCommand().

DoProperties()

HRESULT CDefaultContextMenu::DoProperties ( LPCMINVOKECOMMANDINFOEX  lpcmi )

private

Definition at line 971 of file CDefaultContextMenu.cpp.

{
    HRESULT hr = _DoCallback(DFM_INVOKECOMMAND, DFM_CMD_PROPERTIES, NULL);
 
    // We are asked to run the default property sheet
    if (hr == S_FALSE)
    {
        return Shell_DefaultContextMenuCallBack(m_psf, m_pDataObj);
    }
 
    return hr;
}

Referenced by InvokeCommand().

DoRename()

HRESULT CDefaultContextMenu::DoRename ( LPCMINVOKECOMMANDINFOEX  lpcmi )

private

Definition at line 944 of file CDefaultContextMenu.cpp.

{
    CComPtr<IShellBrowser> psb;
    HRESULT hr;
 
    if (!m_site || !m_cidl)
        return E_FAIL;
 
    /* Get a pointer to the shell browser */
    hr = IUnknown_QueryService(m_site, SID_IShellBrowser, IID_PPV_ARG(IShellBrowser, &psb));
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    CComPtr<IShellView> lpSV;
    hr = psb->QueryActiveShellView(&lpSV);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    SVSIF selFlags = SVSI_DESELECTOTHERS | SVSI_EDIT | SVSI_ENSUREVISIBLE | SVSI_FOCUSED | SVSI_SELECT;
    hr = lpSV->SelectItem(m_apidl[0], selFlags);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    return S_OK;
}

Referenced by InvokeCommand().

DoUndo()

HRESULT CDefaultContextMenu::DoUndo ( LPCMINVOKECOMMANDINFOEX  lpcmi )

private

Definition at line 986 of file CDefaultContextMenu.cpp.

{
    ERR("TODO: Undo\n");
    return E_NOTIMPL;
}

Referenced by InvokeCommand().

EnumerateDynamicContextHandlerForKey()

BOOL CDefaultContextMenu::EnumerateDynamicContextHandlerForKey ( HKEY  hRootKey )

private

Definition at line 398 of file CDefaultContextMenu.cpp.

{
    WCHAR wszName[MAX_PATH], wszBuf[MAX_PATH], *pwszClsid;
    DWORD cchName;
    HRESULT hr;
    HKEY hKey;
 
    if (RegOpenKeyExW(hRootKey, L"shellex\\ContextMenuHandlers", 0, KEY_READ, &hKey) != ERROR_SUCCESS)
    {
        TRACE("RegOpenKeyExW failed\n");
        return FALSE;
    }
 
    DWORD dwIndex = 0;
    while (TRUE)
    {
        cchName = _countof(wszName);
        if (RegEnumKeyExW(hKey, dwIndex++, wszName, &cchName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
            break;
 
        /* Key name or key value is CLSID */
        CLSID clsid;
        hr = CLSIDFromString(wszName, &clsid);
        if (hr == S_OK)
            pwszClsid = wszName;
        else
        {
            DWORD cchBuf = _countof(wszBuf);
            if (RegGetValueW(hKey, wszName, NULL, RRF_RT_REG_SZ, NULL, wszBuf, &cchBuf) == ERROR_SUCCESS)
                hr = CLSIDFromString(wszBuf, &clsid);
            pwszClsid = wszBuf;
        }
 
        if (FAILED(hr))
        {
            ERR("CLSIDFromString failed for clsid %S hr 0x%x\n", pwszClsid, hr);
            continue;
        }
 
        if (m_bGroupPolicyActive)
        {
            if (RegGetValueW(HKEY_LOCAL_MACHINE,
                             L"Software\\Microsoft\\Windows\\CurrentVersion\\Shell Extensions\\Approved",
                             pwszClsid,
                             RRF_RT_REG_SZ,
                             NULL,
                             NULL,
                             NULL) != ERROR_SUCCESS)
            {
                ERR("Shell extension %s not approved!\n", pwszClsid);
                continue;
            }
        }
 
        hr = LoadDynamicContextMenuHandler(hKey, clsid);
        if (FAILED(hr))
            WARN("Failed to get context menu entires from shell extension! clsid: %S\n", pwszClsid);
    }
 
    RegCloseKey(hKey);
    return TRUE;
}

Referenced by QueryContextMenu().

GetCommandString()

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

override

Implements IContextMenu.

Definition at line 1456 of file CDefaultContextMenu.cpp.

{
    /* We don't handle the help text yet */
    if (uFlags == GCS_HELPTEXTA ||
        uFlags == GCS_HELPTEXTW ||
        HIWORD(idCommand) != 0)
    {
        return E_NOTIMPL;
    }
 
    UINT CmdId = LOWORD(idCommand);
 
    if (!m_DynamicEntries.IsEmpty() && CmdId >= m_iIdSHEFirst && CmdId < m_iIdSHELast)
    {
        idCommand -= m_iIdSHEFirst;
        PDynamicShellEntry pEntry = GetDynamicEntry(idCommand);
        if (!pEntry)
            return E_FAIL;
 
        idCommand -= pEntry->iIdCmdFirst;
        return pEntry->pCM->GetCommandString(idCommand,
                                             uFlags,
                                             lpReserved,
                                             lpszName,
                                             uMaxNameLen);
    }
 
    if (!m_StaticEntries.IsEmpty() && CmdId >= m_iIdSCMFirst && CmdId < m_iIdSCMLast)
    {
        /* Validation just returns S_OK on a match. The id exists. */
        if (uFlags == GCS_VALIDATEA || uFlags == GCS_VALIDATEW)
            return S_OK;
 
        CmdId -= m_iIdSCMFirst;
 
        POSITION it = m_StaticEntries.FindIndex(CmdId);
 
        if (it == NULL)
            return E_INVALIDARG;
 
        PStaticShellEntry pEntry = &m_StaticEntries.GetAt(it);
 
        if (uFlags == GCS_VERBW)
            return StringCchCopyW((LPWSTR)lpszName, uMaxNameLen, pEntry->Verb);
 
        if (uFlags == GCS_VERBA)
        {
            if (SHUnicodeToAnsi(pEntry->Verb, lpszName, uMaxNameLen))
                return S_OK;
        }
 
        return E_INVALIDARG;
    }
 
    //FIXME: Should we handle callbacks here?
    if (m_iIdDfltFirst != m_iIdDfltLast && CmdId >= m_iIdDfltFirst && CmdId < m_iIdDfltLast)
    {
        CmdId -= m_iIdDfltFirst;
        /* See the definitions of IDM_CUT and co to see how this works */
        CmdId += DCM_FCIDM_SHVIEW_OFFSET;
    }
 
    /* Loop looking for a matching Id */
    for (UINT i = 0; i < _countof(g_StaticInvokeCmdMap); i++)
    {
        if (g_StaticInvokeCmdMap[i].IntVerb == CmdId)
        {
            /* Validation just returns S_OK on a match */
            if (uFlags == GCS_VALIDATEA || uFlags == GCS_VALIDATEW)
                return S_OK;
 
            /* Return a copy of the ANSI verb */
            if (uFlags == GCS_VERBA)
                return StringCchCopyA(lpszName, uMaxNameLen, g_StaticInvokeCmdMap[i].szStringVerb);
 
            /* Convert the ANSI verb to unicode and return that */
            if (uFlags == GCS_VERBW)
            {
                if (SHAnsiToUnicode(g_StaticInvokeCmdMap[i].szStringVerb, (LPWSTR)lpszName, uMaxNameLen))
                    return S_OK;
            }
        }
    }
 
    return E_INVALIDARG;
}

GetDynamicEntry()

PDynamicShellEntry CDefaultContextMenu::GetDynamicEntry ( UINT  idCmd )

private

Definition at line 1088 of file CDefaultContextMenu.cpp.

{
    POSITION it = m_DynamicEntries.GetHeadPosition();
    while (it != NULL)
    {
        DynamicShellEntry& info = m_DynamicEntries.GetNext(it);
 
        if (idCmd >= info.iIdCmdFirst + info.NumIds)
            continue;
 
        if (idCmd < info.iIdCmdFirst || idCmd > info.iIdCmdFirst + info.NumIds)
            return NULL;
 
        return &info;
    }
 
    return NULL;
}

Referenced by GetCommandString(), HandleMenuMsg2(), and InvokeShellExt().

GetSite()

HRESULT WINAPI CDefaultContextMenu::GetSite ( REFIID  riid, void **  ppvSite  )

override

Definition at line 1643 of file CDefaultContextMenu.cpp.

{
    if (!m_site)
        return E_FAIL;
 
    return m_site->QueryInterface(riid, ppvSite);
}

HandleMenuMsg()

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

override

Implements IContextMenu2.

Definition at line 1550 of file CDefaultContextMenu.cpp.

{
    /* FIXME: Should we implement this as well? */
    return S_OK;
}

HandleMenuMsg2()

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

override

Implements IContextMenu3.

Definition at line 1597 of file CDefaultContextMenu.cpp.

{
    if (uMsg == WM_INITMENUPOPUP)
    {
        POSITION it = m_DynamicEntries.GetHeadPosition();
        while (it != NULL)
        {
            DynamicShellEntry& info = m_DynamicEntries.GetNext(it);
            SHForwardContextMenuMsg(info.pCM, uMsg, wParam, lParam, plResult, TRUE);
        }
        return S_OK;
    }
 
    UINT CmdId;
    HRESULT hr = SHGetMenuIdFromMenuMsg(uMsg, lParam, &CmdId);
    if (FAILED(hr))
        return S_FALSE;
 
    if (CmdId < m_iIdSHEFirst || CmdId >= m_iIdSHELast)
        return S_FALSE;
 
    CmdId -= m_iIdSHEFirst;
    PDynamicShellEntry pEntry = GetDynamicEntry(CmdId);
    if (pEntry)
    {
        SHSetMenuIdInMenuMsg(uMsg, lParam, CmdId - pEntry->iIdCmdFirst);
        SHForwardContextMenuMsg(pEntry->pCM, uMsg, wParam, lParam, plResult, TRUE);
    }
 
   return S_OK;
}

Initialize()

HRESULT WINAPI CDefaultContextMenu::Initialize	(	const DEFCONTEXTMENU *	pdcm,
		LPFNDFMCALLBACK	lpfn
	)

Definition at line 212 of file CDefaultContextMenu.cpp.

{
    TRACE("cidl %u\n", pdcm->cidl);
 
    if (!pdcm->pcmcb && !lpfn)
    {
        ERR("CDefaultContextMenu needs a callback!\n");
        return E_INVALIDARG;
    }
 
    m_cidl = pdcm->cidl;
    m_apidl = const_cast<PCUITEMID_CHILD_ARRAY>(_ILCopyaPidl(pdcm->apidl, m_cidl));
    if (m_cidl && !m_apidl)
        return E_OUTOFMEMORY;
    m_psf = pdcm->psf;
    m_pmcb = pdcm->pcmcb;
    m_pfnmcb = lpfn;
    m_hwnd = pdcm->hwnd;
 
    m_cKeys = pdcm->cKeys;
    if (pdcm->cKeys)
    {
        m_aKeys = (HKEY*)HeapAlloc(GetProcessHeap(), 0, sizeof(HKEY) * pdcm->cKeys);
        if (!m_aKeys)
            return E_OUTOFMEMORY;
        memcpy(m_aKeys, pdcm->aKeys, sizeof(HKEY) * pdcm->cKeys);
    }
 
    m_psf->GetUIObjectOf(pdcm->hwnd, m_cidl, m_apidl, IID_NULL_PPV_ARG(IDataObject, &m_pDataObj));
 
    if (pdcm->pidlFolder)
    {
        m_pidlFolder = ILClone(pdcm->pidlFolder);
    }
    else
    {
        CComPtr<IPersistFolder2> pf = NULL;
        if (SUCCEEDED(m_psf->QueryInterface(IID_PPV_ARG(IPersistFolder2, &pf))))
        {
            if (FAILED(pf->GetCurFolder(&m_pidlFolder)))
                ERR("GetCurFolder failed\n");
        }
        TRACE("pidlFolder %p\n", m_pidlFolder);
    }
 
    return S_OK;
}

InvokeCommand()

HRESULT WINAPI CDefaultContextMenu::InvokeCommand ( LPCMINVOKECOMMANDINFO  lpcmi )

override

Implements IContextMenu.

Definition at line 1347 of file CDefaultContextMenu.cpp.

{
    CMINVOKECOMMANDINFOEX LocalInvokeInfo = {};
    HRESULT Result;
    UINT CmdId;
 
    /* Take a local copy of the fixed members of the
       struct as we might need to modify the verb */
    memcpy(&LocalInvokeInfo, lpcmi, min(sizeof(LocalInvokeInfo), lpcmi->cbSize));
 
    /* Check if this is a string verb */
    if (!IS_INTRESOURCE(LocalInvokeInfo.lpVerb))
    {
        /* Get the ID which corresponds to this verb, and update our local copy */
        if (MapVerbToCmdId((LPVOID)LocalInvokeInfo.lpVerb, &CmdId, FALSE))
            LocalInvokeInfo.lpVerb = MAKEINTRESOURCEA(CmdId);
    }
 
    CmdId = LOWORD(LocalInvokeInfo.lpVerb);
 
    if (!m_DynamicEntries.IsEmpty() && CmdId >= m_iIdSHEFirst && CmdId < m_iIdSHELast)
    {
        LocalInvokeInfo.lpVerb -= m_iIdSHEFirst;
        Result = InvokeShellExt(&LocalInvokeInfo);
        return Result;
    }
 
    if (!m_StaticEntries.IsEmpty() && CmdId >= m_iIdSCMFirst && CmdId < m_iIdSCMLast)
    {
        LocalInvokeInfo.lpVerb -= m_iIdSCMFirst;
        Result = InvokeRegVerb(&LocalInvokeInfo);
        // TODO: if (FAILED(Result) && !(lpcmi->fMask & CMIC_MASK_FLAG_NO_UI)) SHELL_ErrorBox(m_pSite, Result);
        return Result;
    }
 
    if (m_iIdCBFirst != m_iIdCBLast && CmdId >= m_iIdCBFirst && CmdId < m_iIdCBLast)
    {
        Result = _DoCallback(DFM_INVOKECOMMAND, CmdId - m_iIdCBFirst, NULL);
        return Result;
    }
 
    if (m_iIdDfltFirst != m_iIdDfltLast && CmdId >= m_iIdDfltFirst && CmdId < m_iIdDfltLast)
    {
        CmdId -= m_iIdDfltFirst;
        /* See the definitions of IDM_CUT and co to see how this works */
        CmdId += DCM_FCIDM_SHVIEW_OFFSET;
    }
 
    if (LocalInvokeInfo.cbSize >= sizeof(CMINVOKECOMMANDINFOEX) && (LocalInvokeInfo.fMask & CMIC_MASK_PTINVOKE))
    {
        if (m_pDataObj && FAILED_UNEXPECTEDLY(DataObject_SetOffset(m_pDataObj, &LocalInvokeInfo.ptInvoke)))
        {
            ERR("Unable to add OFFSET to DataObject!\n");
        }
    }
 
    /* Check if this is a Id */
    switch (CmdId)
    {
    case FCIDM_SHVIEW_INSERT:
        Result = DoPaste(&LocalInvokeInfo, FALSE);
        break;
    case FCIDM_SHVIEW_INSERTLINK:
        Result = DoPaste(&LocalInvokeInfo, TRUE);
        break;
    case FCIDM_SHVIEW_OPEN:
    case FCIDM_SHVIEW_EXPLORE:
        Result = DoOpenOrExplore(&LocalInvokeInfo);
        break;
    case FCIDM_SHVIEW_COPY:
    case FCIDM_SHVIEW_CUT:
        Result = DoCopyOrCut(&LocalInvokeInfo, CmdId == FCIDM_SHVIEW_COPY);
        break;
    case FCIDM_SHVIEW_CREATELINK:
        Result = DoCreateLink(&LocalInvokeInfo);
        break;
    case FCIDM_SHVIEW_DELETE:
        Result = DoDelete(&LocalInvokeInfo);
        break;
    case FCIDM_SHVIEW_RENAME:
        Result = DoRename(&LocalInvokeInfo);
        break;
    case FCIDM_SHVIEW_PROPERTIES:
        Result = DoProperties(&LocalInvokeInfo);
        break;
    case FCIDM_SHVIEW_NEWFOLDER:
        Result = DoCreateNewFolder(&LocalInvokeInfo);
        break;
    case FCIDM_SHVIEW_COPYTO:
        Result = DoCopyToMoveToFolder(&LocalInvokeInfo, TRUE);
        break;
    case FCIDM_SHVIEW_MOVETO:
        Result = DoCopyToMoveToFolder(&LocalInvokeInfo, FALSE);
        break;
    case FCIDM_SHVIEW_UNDO:
        Result = DoUndo(&LocalInvokeInfo);
        break;
    default:
        Result = E_INVALIDARG;
        ERR("Unhandled Verb %xl\n", LOWORD(LocalInvokeInfo.lpVerb));
        break;
    }
 
    return Result;
}

InvokePidl()

HRESULT CDefaultContextMenu::InvokePidl ( LPCMINVOKECOMMANDINFOEX  lpcmi, LPCITEMIDLIST  pidl, PStaticShellEntry  pEntry  )

private

Definition at line 1221 of file CDefaultContextMenu.cpp.

{
    LPITEMIDLIST pidlFull = ILCombine(m_pidlFolder, pidl);
    if (pidlFull == NULL)
    {
        return E_FAIL;
    }
 
    WCHAR wszPath[MAX_PATH];
    BOOL bHasPath = SHGetPathFromIDListW(pidlFull, wszPath);
 
    WCHAR wszDir[MAX_PATH];
    if (bHasPath)
    {
        wcscpy(wszDir, wszPath);
        PathRemoveFileSpec(wszDir);
    }
    else
    {
        if (!SHGetPathFromIDListW(m_pidlFolder, wszDir))
            *wszDir = UNICODE_NULL;
    }
 
    SHELLEXECUTEINFOW sei;
    ZeroMemory(&sei, sizeof(sei));
    sei.cbSize = sizeof(sei);
    sei.hwnd = lpcmi->hwnd;
    sei.nShow = SW_SHOWNORMAL;
    sei.lpVerb = pEntry->Verb;
    sei.lpDirectory = wszDir;
    sei.lpIDList = pidlFull;
    sei.hkeyClass = pEntry->hkClass;
    sei.fMask = SEE_MASK_CLASSKEY | SEE_MASK_IDLIST;
    if (bHasPath)
    {
        sei.lpFile = wszPath;
    }
 
    ShellExecuteExW(&sei);
 
    ILFree(pidlFull);
 
    return S_OK;
}

Referenced by InvokeRegVerb().

InvokeRegVerb()

HRESULT CDefaultContextMenu::InvokeRegVerb ( LPCMINVOKECOMMANDINFOEX  lpcmi )

private

Definition at line 1267 of file CDefaultContextMenu.cpp.

{
    INT iCmd = LOWORD(lpcmi->lpVerb);
    HRESULT hr;
    UINT i;
 
    POSITION it = m_StaticEntries.FindIndex(iCmd);
 
    if (it == NULL)
        return E_INVALIDARG;
 
    PStaticShellEntry pEntry = &m_StaticEntries.GetAt(it);
 
    CRegKey VerbKey;
    WCHAR VerbKeyPath[sizeof("shell\\") + MAX_VERB];
    hr = StringCbPrintfW(VerbKeyPath, sizeof(VerbKeyPath), L"shell\\%s", pEntry->Verb.GetString());
    if (SUCCEEDED(hr) && m_pDataObj &&
        VerbKey.Open(pEntry->hkClass, VerbKeyPath, KEY_READ) == ERROR_SUCCESS)
    {
        CLSID clsid;
 
        DWORD KeyState = 0;
        if (lpcmi->fMask & CMIC_MASK_SHIFT_DOWN)
            KeyState |= MK_SHIFT;
        if (lpcmi->fMask & CMIC_MASK_CONTROL_DOWN)
            KeyState |= MK_CONTROL;
 
        POINTL *pPtl = NULL;
        C_ASSERT(sizeof(POINT) == sizeof(POINTL));
        if (lpcmi->fMask & CMIC_MASK_PTINVOKE)
            pPtl = (POINTL*)&lpcmi->ptInvoke;
 
        // TODO: IExecuteCommand
 
        CComPtr<IDropTarget> pDT;
        hr = SHELL_GetRegCLSID(VerbKey, L"DropTarget", L"CLSID", clsid);
        if (SUCCEEDED(hr))
            hr = CoCreateInstance(clsid, NULL, CLSCTX_ALL, IID_PPV_ARG(IDropTarget, &pDT));
        if (SUCCEEDED(hr))
        {
            IUnknown_SetSite(pDT, static_cast<IContextMenu*>(this));
            hr = SHSimulateDrop(pDT, m_pDataObj, KeyState, pPtl, NULL);
            IUnknown_SetSite(pDT, NULL);
            return hr;
        }
    }
 
    /* Get the browse flags to see if we need to browse */
    DWORD wFlags = BrowserFlagsFromVerb(lpcmi, pEntry);
 
    for (i=0; i < m_cidl; i++)
    {
        /* Check if we need to browse */
        if (wFlags)
        {
            hr = TryToBrowse(lpcmi, m_apidl[i], wFlags);
            if (SUCCEEDED(hr))
            {
                /* In WinXP if we have browsed, we don't open any more folders.
                 * In Win7 we browse to the first folder we find and
                 * open new windows for each of the rest of the folders */
                UINT ntver = RosGetProcessEffectiveVersion();
                if (ntver >= _WIN32_WINNT_VISTA)
                    wFlags = 0; // FIXME: = SBSP_NEWBROWSER | (wFlags & ~SBSP_SAMEBROWSER);
                else
                    i = m_cidl;
 
                continue;
            }
        }
 
        InvokePidl(lpcmi, m_apidl[i], pEntry);
    }
 
    return S_OK;
}

Referenced by InvokeCommand().

InvokeShellExt()

HRESULT CDefaultContextMenu::InvokeShellExt ( LPCMINVOKECOMMANDINFOEX  lpcmi )

private

Definition at line 1141 of file CDefaultContextMenu.cpp.

{
    TRACE("verb %p first %x last %x\n", lpcmi->lpVerb, m_iIdSHEFirst, m_iIdSHELast);
 
    UINT idCmd = LOWORD(lpcmi->lpVerb);
    PDynamicShellEntry pEntry = GetDynamicEntry(idCmd);
    if (!pEntry)
        return E_FAIL;
 
    /* invoke the dynamic context menu */
    lpcmi->lpVerb = MAKEINTRESOURCEA(idCmd - pEntry->iIdCmdFirst);
    return pEntry->pCM->InvokeCommand((LPCMINVOKECOMMANDINFO)lpcmi);
}

Referenced by InvokeCommand().

IsShellExtensionAlreadyLoaded()

BOOL CDefaultContextMenu::IsShellExtensionAlreadyLoaded ( REFCLSID  clsid )

private

Definition at line 344 of file CDefaultContextMenu.cpp.

{
    POSITION it = m_DynamicEntries.GetHeadPosition();
    while (it != NULL)
    {
        const DynamicShellEntry& info = m_DynamicEntries.GetNext(it);
        if (info.ClassID == clsid)
            return TRUE;
    }
 
    return FALSE;
}

Referenced by LoadDynamicContextMenuHandler().

LoadDynamicContextMenuHandler()

HRESULT CDefaultContextMenu::LoadDynamicContextMenuHandler ( HKEY  hKey, REFCLSID  clsid  )

private

Definition at line 358 of file CDefaultContextMenu.cpp.

{
    HRESULT hr;
    TRACE("LoadDynamicContextMenuHandler entered with This %p hKey %p pclsid %s\n", this, hKey, wine_dbgstr_guid(&clsid));
 
    if (IsShellExtensionAlreadyLoaded(clsid))
        return S_OK;
 
    CComPtr<IContextMenu> pcm;
    hr = SHCoCreateInstance(NULL, &clsid, NULL, IID_PPV_ARG(IContextMenu, &pcm));
    if (FAILED(hr))
    {
        ERR("SHCoCreateInstance(IContextMenu) failed.clsid %s hr 0x%x\n", wine_dbgstr_guid(&clsid), hr);
        return hr;
    }
 
    CComPtr<IShellExtInit> pExtInit;
    hr = pcm->QueryInterface(IID_PPV_ARG(IShellExtInit, &pExtInit));
    if (FAILED(hr))
    {
        ERR("IContextMenu->QueryInterface(IShellExtInit) failed.clsid %s hr 0x%x\n", wine_dbgstr_guid(&clsid), hr);
        return hr;
    }
 
    hr = pExtInit->Initialize(m_pidlFolder, m_pDataObj, hKey);
    if (FAILED(hr))
    {
        WARN("IShellExtInit::Initialize failed.clsid %s hr 0x%x\n", wine_dbgstr_guid(&clsid), hr);
        return hr;
    }
 
    if (m_site)
        IUnknown_SetSite(pcm, m_site);
 
    m_DynamicEntries.AddTail({ 0, 0, clsid, pcm });
 
    return S_OK;
}

Referenced by EnumerateDynamicContextHandlerForKey().

MapVerbToCmdId()

BOOL CDefaultContextMenu::MapVerbToCmdId ( PVOID  Verb, PUINT  idCmd, BOOL  IsUnicode  )

private

Definition at line 1108 of file CDefaultContextMenu.cpp.

{
    WCHAR UnicodeStr[MAX_VERB];
 
    /* Loop through all the static verbs looking for a match */
    for (UINT i = 0; i < _countof(g_StaticInvokeCmdMap); i++)
    {
        /* We can match both ANSI and unicode strings */
        if (IsUnicode)
        {
            /* The static verbs are ANSI, get a unicode version before doing the compare */
            SHAnsiToUnicode(g_StaticInvokeCmdMap[i].szStringVerb, UnicodeStr, MAX_VERB);
            if (!wcscmp(UnicodeStr, (LPWSTR)Verb))
            {
                /* Return the Corresponding Id */
                *idCmd = g_StaticInvokeCmdMap[i].IntVerb;
                return TRUE;
            }
        }
        else
        {
            if (!strcmp(g_StaticInvokeCmdMap[i].szStringVerb, (LPSTR)Verb))
            {
                *idCmd = g_StaticInvokeCmdMap[i].IntVerb;
                return TRUE;
            }
        }
    }
 
    return FALSE;
}

Referenced by InvokeCommand().

QueryContextMenu()

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

override

Implements IContextMenu.

Definition at line 739 of file CDefaultContextMenu.cpp.

{
    HRESULT hr;
    UINT idCmdNext = idCmdFirst;
    UINT cIds = 0;
 
    TRACE("BuildShellItemContextMenu entered\n");
 
    /* Load static verbs and shell extensions from registry */
    for (UINT i = 0; i < m_cKeys && !(uFlags & CMF_NOVERBS); i++)
    {
        AddStaticEntriesForKey(m_aKeys[i], uFlags);
        EnumerateDynamicContextHandlerForKey(m_aKeys[i]);
    }
 
    /* Add static context menu handlers */
    cIds = AddStaticContextMenusToMenu(hMenu, &IndexMenu, idCmdFirst, idCmdLast, uFlags);
    m_iIdSCMFirst = 0; // FIXME: This should be = idCmdFirst?
    m_iIdSCMLast = cIds;
    idCmdNext = idCmdFirst + cIds;
 
    /* Add dynamic context menu handlers */
    cIds += AddShellExtensionsToMenu(hMenu, &IndexMenu, idCmdNext, idCmdLast, uFlags);
    m_iIdSHEFirst = m_iIdSCMLast;
    m_iIdSHELast = cIds;
    idCmdNext = idCmdFirst + cIds;
    TRACE("SH_LoadContextMenuHandlers first %x last %x\n", m_iIdSHEFirst, m_iIdSHELast);
 
    /* Now let the callback add its own items */
    QCMINFO qcminfo = {hMenu, IndexMenu, idCmdNext, idCmdLast, NULL};
    if (SUCCEEDED(_DoCallback(DFM_MERGECONTEXTMENU, uFlags, &qcminfo)))
    {
        UINT added = qcminfo.idCmdFirst - idCmdNext;
        cIds += added;
        IndexMenu += added;
        m_iIdCBFirst = m_iIdSHELast;
        m_iIdCBLast = cIds;
        idCmdNext = idCmdFirst + cIds;
    }
 
    //TODO: DFM_MERGECONTEXTMENU_BOTTOM
 
    UINT idDefaultOffset = 0;
    BOOL isBackgroundMenu = !m_cidl;
    if (!(uFlags & CMF_VERBSONLY) && !isBackgroundMenu)
    {
        /* Get the attributes of the items */
        SFGAOF rfg = SFGAO_BROWSABLE | SFGAO_CANCOPY | SFGAO_CANLINK | SFGAO_CANMOVE | SFGAO_CANDELETE | SFGAO_CANRENAME | SFGAO_HASPROPSHEET | SFGAO_FILESYSTEM | SFGAO_FOLDER;
        hr = m_psf->GetAttributesOf(m_cidl, m_apidl, &rfg);
        if (FAILED_UNEXPECTEDLY(hr))
            return MAKE_HRESULT(SEVERITY_SUCCESS, 0, cIds);
 
        /* Add the default part of the menu */
        HMENU hmenuDefault = LoadMenu(_AtlBaseModule.GetResourceInstance(), L"MENU_SHV_FILE");
 
        /* Remove uneeded entries */
        if (!(rfg & SFGAO_CANMOVE))
            DeleteMenu(hmenuDefault, IDM_CUT, MF_BYCOMMAND);
        if (!(rfg & SFGAO_CANCOPY))
            DeleteMenu(hmenuDefault, IDM_COPY, MF_BYCOMMAND);
        if (!((rfg & SFGAO_FILESYSTEM) && HasClipboardData()))
            DeleteMenu(hmenuDefault, IDM_INSERT, MF_BYCOMMAND);
        if (!(rfg & SFGAO_CANLINK))
            DeleteMenu(hmenuDefault, IDM_CREATELINK, MF_BYCOMMAND);
        if (!(rfg & SFGAO_CANDELETE))
            DeleteMenu(hmenuDefault, IDM_DELETE, MF_BYCOMMAND);
        if (!(rfg & SFGAO_CANRENAME))
            DeleteMenu(hmenuDefault, IDM_RENAME, MF_BYCOMMAND);
        if (!(rfg & SFGAO_HASPROPSHEET))
            DeleteMenu(hmenuDefault, IDM_PROPERTIES, MF_BYCOMMAND);
 
        idDefaultOffset = idCmdNext;
        UINT idMax = Shell_MergeMenus(hMenu, GetSubMenu(hmenuDefault, 0), IndexMenu, idCmdNext, idCmdLast, 0);
        m_iIdDfltFirst = cIds;
        cIds += idMax - idCmdNext;
        m_iIdDfltLast = cIds;
 
        DestroyMenu(hmenuDefault);
    }
 
    TryPickDefault(hMenu, idCmdFirst, idDefaultOffset, uFlags);
 
    // TODO: DFM_MERGECONTEXTMENU_TOP
 
    return MAKE_HRESULT(SEVERITY_SUCCESS, 0, cIds);
}

QueryService()

virtual HRESULT STDMETHODCALLTYPE CDefaultContextMenu::QueryService ( REFGUID  svc, REFIID  riid, void **  ppv  )

inlinevirtual

Implements IServiceProvider.

Definition at line 161 of file CDefaultContextMenu.cpp.

        {
            return IUnknown_QueryService(m_site, svc, riid, ppv);
        }

SetSite()

HRESULT WINAPI CDefaultContextMenu::SetSite ( IUnknown *  pUnkSite )

override

Implements IObjectWithSite.

Definition at line 1635 of file CDefaultContextMenu.cpp.

{
    m_site = pUnkSite;
    return S_OK;
}

TryPickDefault()

void CDefaultContextMenu::TryPickDefault ( HMENU  hMenu, UINT  idCmdFirst, UINT  DfltOffset, UINT  uFlags  )

private

Definition at line 702 of file CDefaultContextMenu.cpp.

{
    // Are we allowed to pick a default?
    UINT ntver = RosGetProcessEffectiveVersion();
    if (((uFlags & CMF_NODEFAULT) && ntver >= _WIN32_WINNT_VISTA) ||
        ((uFlags & CMF_DONOTPICKDEFAULT) && ntver >= _WIN32_WINNT_WIN7))
    {
        return;
    }
 
    // Do we already have a default?
    if ((int)GetMenuDefaultItem(hMenu, MF_BYPOSITION, 0) != -1)
        return;
 
    // Does the view want to pick one?
    INT_PTR forceDfm = 0;
    if (_DoCallback(DFM_GETDEFSTATICID, 0, &forceDfm) == S_OK && forceDfm)
    {
        for (UINT i = 0; i < _countof(g_StaticInvokeCmdMap); ++i)
        {
            UINT menuItemId = g_StaticInvokeCmdMap[i].IntVerb + DfltOffset - DCM_FCIDM_SHVIEW_OFFSET;
            if (g_StaticInvokeCmdMap[i].DfmCmd == forceDfm &&
                SetMenuDefaultItem(hMenu, menuItemId, MF_BYCOMMAND))
            {
                return;
            }
        }
    }
 
    // Don't want to pick something like cut or delete as the default but
    // a static or dynamic verb is a good default.
    if (m_iIdSCMLast > m_iIdSCMFirst || m_iIdSHELast > m_iIdSHEFirst)
        SetMenuDefaultItem(hMenu, idCmdFirst, MF_BYCOMMAND);
}

Referenced by QueryContextMenu().

TryToBrowse()

HRESULT CDefaultContextMenu::TryToBrowse ( LPCMINVOKECOMMANDINFOEX  lpcmi, LPCITEMIDLIST  pidl, DWORD  wFlags  )

private

Definition at line 1196 of file CDefaultContextMenu.cpp.

{
    CComPtr<IShellBrowser> psb;
    HRESULT hr;
 
    if (!m_site)
        return E_FAIL;
 
    /* Get a pointer to the shell browser */
    hr = IUnknown_QueryService(m_site, SID_IShellBrowser, IID_PPV_ARG(IShellBrowser, &psb));
    if (FAILED(hr))
        return hr;
 
    PIDLIST_ABSOLUTE pidl;
    hr = SHILCombine(m_pidlFolder, pidlChild, &pidl);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    hr = psb->BrowseObject(pidl, wFlags & ~SBSP_RELATIVE);
    ILFree(pidl);
    return hr;
}

Referenced by InvokeRegVerb().

Member Data Documentation

m_aKeys

HKEY* CDefaultContextMenu::m_aKeys

private

Definition at line 97 of file CDefaultContextMenu.cpp.

Referenced by Initialize(), QueryContextMenu(), and ~CDefaultContextMenu().

m_apidl

PCUITEMID_CHILD_ARRAY CDefaultContextMenu::m_apidl

private

Definition at line 95 of file CDefaultContextMenu.cpp.

Referenced by DoPaste(), DoRename(), Initialize(), InvokeRegVerb(), QueryContextMenu(), and ~CDefaultContextMenu().

m_bGroupPolicyActive

DWORD CDefaultContextMenu::m_bGroupPolicyActive

private

Definition at line 100 of file CDefaultContextMenu.cpp.

Referenced by EnumerateDynamicContextHandlerForKey().

m_cidl

UINT CDefaultContextMenu::m_cidl

private

Definition at line 94 of file CDefaultContextMenu.cpp.

Referenced by DoCopyOrCut(), DoCreateLink(), DoDelete(), DoPaste(), DoRename(), Initialize(), InvokeRegVerb(), QueryContextMenu(), and ~CDefaultContextMenu().

m_cKeys

UINT CDefaultContextMenu::m_cKeys

private

Definition at line 98 of file CDefaultContextMenu.cpp.

Referenced by Initialize(), QueryContextMenu(), and ~CDefaultContextMenu().

m_DynamicEntries

CAtlList<DynamicShellEntry> CDefaultContextMenu::m_DynamicEntries

private

Definition at line 101 of file CDefaultContextMenu.cpp.

Referenced by AddShellExtensionsToMenu(), GetCommandString(), GetDynamicEntry(), HandleMenuMsg2(), InvokeCommand(), IsShellExtensionAlreadyLoaded(), LoadDynamicContextMenuHandler(), and ~CDefaultContextMenu().

m_hwnd

HWND CDefaultContextMenu::m_hwnd

private

Definition at line 111 of file CDefaultContextMenu.cpp.

Referenced by _DoCallback(), and Initialize().

m_iIdCBFirst

UINT CDefaultContextMenu::m_iIdCBFirst

private

Definition at line 107 of file CDefaultContextMenu.cpp.

Referenced by InvokeCommand(), and QueryContextMenu().

m_iIdCBLast

UINT CDefaultContextMenu::m_iIdCBLast

private

Definition at line 108 of file CDefaultContextMenu.cpp.

Referenced by InvokeCommand(), and QueryContextMenu().

m_iIdDfltFirst

UINT CDefaultContextMenu::m_iIdDfltFirst

private

Definition at line 109 of file CDefaultContextMenu.cpp.

Referenced by GetCommandString(), InvokeCommand(), and QueryContextMenu().

m_iIdDfltLast

UINT CDefaultContextMenu::m_iIdDfltLast

private

Definition at line 110 of file CDefaultContextMenu.cpp.

Referenced by GetCommandString(), InvokeCommand(), and QueryContextMenu().

m_iIdSCMFirst

UINT CDefaultContextMenu::m_iIdSCMFirst

private

Definition at line 105 of file CDefaultContextMenu.cpp.

Referenced by GetCommandString(), InvokeCommand(), QueryContextMenu(), and TryPickDefault().

m_iIdSCMLast

UINT CDefaultContextMenu::m_iIdSCMLast

private

Definition at line 106 of file CDefaultContextMenu.cpp.

Referenced by GetCommandString(), InvokeCommand(), QueryContextMenu(), and TryPickDefault().

m_iIdSHEFirst

UINT CDefaultContextMenu::m_iIdSHEFirst

private

Definition at line 102 of file CDefaultContextMenu.cpp.

Referenced by GetCommandString(), HandleMenuMsg2(), InvokeCommand(), InvokeShellExt(), QueryContextMenu(), and TryPickDefault().

m_iIdSHELast

UINT CDefaultContextMenu::m_iIdSHELast

private

Definition at line 103 of file CDefaultContextMenu.cpp.

Referenced by GetCommandString(), HandleMenuMsg2(), InvokeCommand(), InvokeShellExt(), QueryContextMenu(), and TryPickDefault().

m_pDataObj

CComPtr<IDataObject> CDefaultContextMenu::m_pDataObj

private

Definition at line 96 of file CDefaultContextMenu.cpp.

Referenced by _DoCallback(), DoCopyOrCut(), DoCopyToMoveToFolder(), DoCreateLink(), DoDelete(), DoProperties(), Initialize(), InvokeCommand(), InvokeRegVerb(), and LoadDynamicContextMenuHandler().

m_pfnmcb

LPFNDFMCALLBACK CDefaultContextMenu::m_pfnmcb

private

Definition at line 93 of file CDefaultContextMenu.cpp.

Referenced by _DoCallback(), and Initialize().

m_pidlFolder

PIDLIST_ABSOLUTE CDefaultContextMenu::m_pidlFolder

private

Definition at line 99 of file CDefaultContextMenu.cpp.

Referenced by DoCopyToMoveToFolder(), DoCreateNewFolder(), Initialize(), InvokePidl(), LoadDynamicContextMenuHandler(), TryToBrowse(), and ~CDefaultContextMenu().

m_pmcb

CComPtr<IContextMenuCB> CDefaultContextMenu::m_pmcb

private

Definition at line 92 of file CDefaultContextMenu.cpp.

Referenced by _DoCallback(), and Initialize().

m_psf

CComPtr<IShellFolder> CDefaultContextMenu::m_psf

private

Definition at line 91 of file CDefaultContextMenu.cpp.

Referenced by _DoCallback(), DoCreateLink(), DoPaste(), DoProperties(), Initialize(), and QueryContextMenu().

m_site

CComPtr<IUnknown> CDefaultContextMenu::m_site

private

Definition at line 90 of file CDefaultContextMenu.cpp.

Referenced by BrowserFlagsFromVerb(), DoCreateNewFolder(), DoRename(), GetSite(), LoadDynamicContextMenuHandler(), QueryService(), SetSite(), and TryToBrowse().

m_StaticEntries

CAtlList<StaticShellEntry> CDefaultContextMenu::m_StaticEntries

private

Definition at line 104 of file CDefaultContextMenu.cpp.

Referenced by AddStaticContextMenusToMenu(), AddStaticEntry(), GetCommandString(), InvokeCommand(), InvokeRegVerb(), and ~CDefaultContextMenu().

---

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

• dll/win32/shell32/CDefaultContextMenu.cpp