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
STDMETHOD()	QueryService (REFGUID svc, REFIID riid, void **ppv) 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 ()
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)
HRESULT	_DoInvokeCommandCallback (LPCMINVOKECOMMANDINFOEX lpcmi, WPARAM CmdId)
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	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	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)
HRESULT	GetNoAssocError ()

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 [16]
UINT	m_cKeys
PIDLIST_ABSOLUTE	m_pidlFolder
DWORD	m_bGroupPolicyActive
UINT	m_iIdQCMFirst
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
WCHAR	m_DefVerbs [MAX_PATH]

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 283 of file CDefaultContextMenu.cpp.

Constructor & Destructor Documentation

CDefaultContextMenu()

CDefaultContextMenu::CDefaultContextMenu

(

)

Definition at line 381 of file CDefaultContextMenu.cpp.

                                         :
    m_psf(NULL),
    m_pmcb(NULL),
    m_pfnmcb(NULL),
    m_cidl(0),
    m_apidl(NULL),
    m_pDataObj(NULL),
    m_cKeys(0),
    m_pidlFolder(NULL),
    m_bGroupPolicyActive(0),
    m_iIdQCMFirst(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)
{
    *m_DefVerbs = UNICODE_NULL;
}

~CDefaultContextMenu()

CDefaultContextMenu::~CDefaultContextMenu

(

)

Definition at line 405 of file CDefaultContextMenu.cpp.

{
    for (POSITION it = m_DynamicEntries.GetHeadPosition(); it != NULL;)
    {
        const DynamicShellEntry& info = m_DynamicEntries.GetNext(it);
        IUnknown_SetSite(info.pCM.p, NULL);
    }
    m_DynamicEntries.RemoveAll();
    m_StaticEntries.RemoveAll();
 
    for (UINT i = 0; i < m_cKeys; i++)
        RegCloseKey(m_aKeys[i]);
 
    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 473 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 _DoInvokeCommandCallback(), GetCommandString(), MapVerbToCmdId(), QueryContextMenu(), and TryPickDefault().

_DoInvokeCommandCallback()

HRESULT CDefaultContextMenu::_DoInvokeCommandCallback ( LPCMINVOKECOMMANDINFOEX  lpcmi, WPARAM  CmdId  )

private

Definition at line 1613 of file CDefaultContextMenu.cpp.

{
    BOOL Unicode = IsUnicode(*lpcmi);
    WCHAR lParamBuf[MAX_PATH];
    LPARAM lParam = 0;
 
    if (Unicode && lpcmi->lpParametersW)
        lParam = (LPARAM)lpcmi->lpParametersW;
    else if (lpcmi->lpParameters)
        lParam = SHAnsiToUnicode(lpcmi->lpParameters, lParamBuf, _countof(lParamBuf)) ? (LPARAM)lParamBuf : 0;
 
    HRESULT hr;
#if 0 // TODO: Try DFM_INVOKECOMMANDEX first.
    DFMICS dfmics = { sizeof(DFMICS), lpcmi->fMask, lParam, m_iIdSCMFirst?, m_iIdDfltLast?, (LPCMINVOKECOMMANDINFO)lpcmi, m_site };
    hr = _DoCallback(DFM_INVOKECOMMANDEX, CmdId, &dfmics);
    if (hr == E_NOTIMPL)
#endif
        hr = _DoCallback(DFM_INVOKECOMMAND, CmdId, (void*)lParam);
    return hr;
}

Referenced by DoCopyOrCut(), DoCreateLink(), DoDelete(), DoPaste(), DoProperties(), DoRename(), and InvokeCommand().

AddShellExtensionsToMenu()

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

private

Definition at line 681 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 710 of file CDefaultContextMenu.cpp.

{
    UINT ntver = RosGetProcessEffectiveVersion();
    MENUITEMINFOW mii = { sizeof(mii) };
    WCHAR wszDispVerb[80]; // The limit on XP. If the friendly string is longer, it falls back to the verb key.
    UINT fState, idVerbRes;
    UINT cIds = 0, indexFirst = *pIndexMenu, indexDefault;
    int iDefVerbIndex = -1;
 
    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;
        bool hide = false;
 
        fState = MFS_ENABLED;
 
        /* set first entry as default */
        if (first)
        {
            fState |= MFS_DEFAULT;
            first = false;
        }
 
        if (info.Verb.CompareNoCase(L"open") == 0)
        {
            idVerbRes = IDS_OPEN_VERB;
            fState |= MFS_DEFAULT; /* override default when open verb is found */
            forceFirstPos++;
        }
        else if (info.Verb.CompareNoCase(L"explore") == 0)
        {
            idVerbRes = IDS_EXPLORE_VERB;
            if (uFlags & CMF_EXPLORE)
            {
                fState |= MFS_DEFAULT;
                forceFirstPos++;
            }
        }
        else if (info.Verb.CompareNoCase(L"printto") == 0)
            hide = true;
        else
            idVerbRes = 0;
 
        /* By default use verb for menu item name */
        mii.dwTypeData = (LPWSTR)info.Verb.GetString();
 
        WCHAR wszKey[sizeof("shell\\") + MAX_VERB];
        HRESULT hr = StringCbPrintfW(wszKey, sizeof(wszKey), L"shell\\%s", info.Verb.GetString());
        if (FAILED_UNEXPECTEDLY(hr))
            hide = true;
 
        UINT cmdFlags = 0;
        HKEY hkVerb;
        if (RegOpenKeyExW(info.hkClass, wszKey, 0, KEY_READ, &hkVerb) == ERROR_SUCCESS)
        {
            if (!(uFlags & CMF_OPTIMIZEFORINVOKE))
            {
                DWORD cbVerb = sizeof(wszDispVerb);
                LONG res = RegLoadMUIStringW(hkVerb, L"MUIVerb", wszDispVerb, cbVerb, NULL, 0, NULL);
                if (res || !*wszDispVerb)
                    res = RegLoadMUIStringW(hkVerb, NULL, wszDispVerb, cbVerb, NULL, 0, NULL);
 
                if ((res == ERROR_SUCCESS && *wszDispVerb) ||
                    (idVerbRes && LoadStringW(shell32_hInstance, idVerbRes, wszDispVerb, _countof(wszDispVerb))) ||
                    SUCCEEDED(GetFriendlyVerb(info.Verb, wszDispVerb, _countof(wszDispVerb))))
                {
                    mii.dwTypeData = wszDispVerb;
                }
            }
        }
        else
        {
            hkVerb = NULL;
        }
 
        if (hkVerb)
        {
            if (!hide && !(uFlags & CMF_EXTENDEDVERBS))
                hide = RegValueExists(hkVerb, L"Extended");
 
            if (!hide)
                hide = RegValueExists(hkVerb, L"ProgrammaticAccessOnly");
 
            if (!hide && !(uFlags & CMF_DISABLEDVERBS))
                hide = RegValueExists(hkVerb, L"LegacyDisable");
 
            if (DWORD dwRest = (hide ? 0 : RegGetDword(hkVerb, NULL, L"SuppressionPolicy", 0)))
                hide = SHRestricted((RESTRICTIONS)dwRest);
 
            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)++;
            }
 
            UINT pos = *pIndexMenu;
            int verbIndex = hkVerb ? FindVerbInDefaultVerbList(m_DefVerbs, info.Verb) : -1;
            if (verbIndex >= 0)
            {
                if (verbIndex < iDefVerbIndex || iDefVerbIndex < 0)
                {
                    iDefVerbIndex = verbIndex;
                    fState |= MFS_DEFAULT;
                    forceFirstPos = TRUE;
                }
                else
                {
                    fState &= ~MFS_DEFAULT; // We have already set a better default
                    pos = indexDefault;
                }
            }
            else if (iDefVerbIndex >= 0)
            {
                fState &= ~MFS_DEFAULT; // We have already set the default
                if (forceFirstPos)
                    pos = indexDefault;
                forceFirstPos = FALSE;
            }
 
            mii.fState = fState;
            mii.wID = iIdCmdFirst + cIds;
            if (InsertMenuItemW(hMenu, forceFirstPos ? indexFirst : pos, TRUE, &mii))
                (*pIndexMenu)++;
 
            if (cmdFlags & ECF_SEPARATORAFTER)
            {
                if (InsertMenuItemAt(hMenu, *pIndexMenu, MF_SEPARATOR))
                    (*pIndexMenu)++;
            }
 
            if (fState & MFS_DEFAULT)
                indexDefault = *pIndexMenu; // This is where we want to insert "high priority" verbs
        }
        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 513 of file CDefaultContextMenu.cpp.

{
    WCHAR wszName[VERBKEY_CCHMAX];
    DWORD cchName, dwIndex = 0;
    HKEY hShellKey;
 
    LRESULT lres = RegOpenKeyExW(hKey, L"shell", 0, KEY_READ, &hShellKey);
    if (lres != STATUS_SUCCESS)
        return;
 
    if (!*m_DefVerbs)
    {
        DWORD cb = sizeof(m_DefVerbs);
        RegGetValueW(hShellKey, NULL, NULL, RRF_RT_REG_SZ, NULL, m_DefVerbs, &cb);
    }
 
    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 487 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 1401 of file CDefaultContextMenu.cpp.

{
    CComPtr<IShellBrowser> psb;
    HWND hwndTree;
    LPCWSTR FlagsName;
    WCHAR wszKey[sizeof("shell\\") + MAX_VERB];
    HRESULT hr;
 
    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";
 
    CComPtr<ICommDlgBrowser> pcdb;
    if (SUCCEEDED(psb->QueryInterface(IID_PPV_ARG(ICommDlgBrowser, &pcdb))))
    {
        if (LOBYTE(GetVersion()) < 6 || FlagsName[0] == 'E')
            return 0; // Don't browse in-place
    }
 
    /* 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;
    return RegGetDword(pEntry->hkClass, wszKey, FlagsName, 0);
}

Referenced by InvokeRegVerb().

DoCopyOrCut()

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

private

Definition at line 1148 of file CDefaultContextMenu.cpp.

{
    if (!m_cidl || !m_pDataObj)
        return E_FAIL;
 
    HRESULT hr = _DoInvokeCommandCallback(lpcmi, bCopy ? DFM_CMD_COPY : DFM_CMD_MOVE);
    if (hr == S_OK)
        return hr;
 
    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);
 
    CComPtr<IShellFolderView> psfv;
    if (SUCCEEDED(IUnknown_QueryService(m_site, SID_SFolderView, IID_PPV_ARG(IShellFolderView, &psfv))))
        psfv->SetPoints(m_pDataObj);
 
    hr = OleSetClipboard(m_pDataObj);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    if (psfv)
        psfv->SetClipboard(!bCopy);
    return S_OK;
}

Referenced by InvokeCommand().

DoCreateLink()

HRESULT CDefaultContextMenu::DoCreateLink ( LPCMINVOKECOMMANDINFOEX  lpcmi )

private

Definition at line 1109 of file CDefaultContextMenu.cpp.

{
    HRESULT hr = _DoInvokeCommandCallback(lpcmi, DFM_CMD_LINK);
    if (hr == S_OK)
        return hr;
 
    if (!m_cidl || !m_pDataObj)
        return E_FAIL;
 
    CComPtr<IDropTarget> pDT;
    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 1235 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_SFolderView, 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 1128 of file CDefaultContextMenu.cpp.

{
    HRESULT hr = _DoInvokeCommandCallback(lpcmi, DFM_CMD_DELETE);
    if (hr == S_OK)
        return hr;
 
    if (!m_cidl || !m_pDataObj)
        return E_FAIL;
 
    CComPtr<IDropTarget> pDT;
    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().

DoPaste()

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

private

Definition at line 1055 of file CDefaultContextMenu.cpp.

{
    HRESULT hr = _DoInvokeCommandCallback(lpcmi, DFM_CMD_PASTE);
    if (hr == S_OK)
        return 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 1212 of file CDefaultContextMenu.cpp.

{
    HRESULT hr = _DoInvokeCommandCallback(lpcmi, DFM_CMD_PROPERTIES);
 
    // We are asked to run the default property sheet
    if (hr == S_FALSE)
    {
        return SHELL32_ShowPropertiesDialog(m_pDataObj);
    }
 
    return hr;
}

Referenced by InvokeCommand().

DoRename()

HRESULT CDefaultContextMenu::DoRename ( LPCMINVOKECOMMANDINFOEX  lpcmi )

private

Definition at line 1181 of file CDefaultContextMenu.cpp.

{
    CComPtr<IShellBrowser> psb;
    HRESULT hr;
 
    hr = _DoInvokeCommandCallback(lpcmi, DFM_CMD_RENAME);
    if (hr == S_OK)
        return 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 1227 of file CDefaultContextMenu.cpp.

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

Referenced by InvokeCommand().

EnumerateDynamicContextHandlerForKey()

BOOL CDefaultContextMenu::EnumerateDynamicContextHandlerForKey ( HKEY  hRootKey )

private

Definition at line 617 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(hRootKey, 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 1737 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 (uFlags == GCS_VERBA || uFlags == GCS_VERBW)
    {
        UINT uMsg = (uFlags == GCS_VERBA) ? DFM_GETVERBA : DFM_GETVERBW;
        WPARAM wParam = MAKEWPARAM(idCommand, uMaxNameLen);
        HRESULT hr = _DoCallback(uMsg, wParam, lpszName);
        if (hr == S_OK)
            return S_OK;
    }
 
    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 1292 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().

GetNoAssocError()

HRESULT CDefaultContextMenu::GetNoAssocError ( )

inlineprivate

Definition at line 341 of file CDefaultContextMenu.cpp.

        {
            return LOBYTE(GetVersion()) < 6 ? E_INVALIDARG : HResultFromWin32(ERROR_NO_ASSOCIATION);
        }

Referenced by InvokeCommand().

GetSite()

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

override

Definition at line 1910 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 1840 of file CDefaultContextMenu.cpp.

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

HandleMenuMsg2()

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

override

Implements IContextMenu3.

Definition at line 1867 of file CDefaultContextMenu.cpp.

{
    if (!SHELL_IsContextMenuMsg(uMsg))
        return E_FAIL;
 
    UINT CmdId;
    if (uMsg == WM_INITMENUPOPUP)
    {
        CmdId = GetMenuItemID((HMENU)wParam, 0);
        if (CmdId == ~0ul)
            return E_FAIL;
    }
    else
    {
        HRESULT hr = SHGetMenuIdFromMenuMsg(uMsg, lParam, &CmdId);
        if (FAILED(hr))
            return S_FALSE;
    }
    CmdId -= m_iIdQCMFirst; // Convert from Win32 id to our base
 
    if (CmdId >= m_iIdSHEFirst && CmdId < m_iIdSHELast)
    {
        if (PDynamicShellEntry pEntry = GetDynamicEntry(CmdId - m_iIdSHEFirst))
            return SHForwardContextMenuMsg(pEntry->pCM, uMsg, wParam, lParam, plResult, TRUE);
    }
    // TODO: _DoCallback(DFM_WM_*, ...)
    return E_FAIL;
}

Referenced by HandleMenuMsg().

Initialize()

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

Definition at line 423 of file CDefaultContextMenu.cpp.

{
    TRACE("cidl %u\n", pdcm->cidl);
 
    HRESULT hr = S_OK;
    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;
 
    for (UINT i = 0; i < pdcm->cKeys; ++i)
    {
        if (i >= _countof(m_aKeys))
            hr = E_INVALIDARG;
        else if ((m_aKeys[i] = SHRegDuplicateHKey(pdcm->aKeys[i])) != NULL)
            m_cKeys++;
        else
            hr = E_OUTOFMEMORY;
    }
 
    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 hr;
}

InvokeCommand()

HRESULT WINAPI CDefaultContextMenu::InvokeCommand ( LPCMINVOKECOMMANDINFO  lpcmi )

override

Implements IContextMenu.

Definition at line 1637 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);
        else
            return GetNoAssocError();
    }
    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 = _DoInvokeCommandCallback(&LocalInvokeInfo, CmdId - m_iIdCBFirst);
        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_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_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 1463 of file CDefaultContextMenu.cpp.

{
    const BOOL unicode = IsUnicode(*lpcmi);
 
    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];
 
    SHELLEXECUTEINFOW sei = { sizeof(sei) };
    sei.fMask = SEE_MASK_CLASSKEY | SEE_MASK_IDLIST | (CmicFlagsToSeeFlags(lpcmi->fMask) & ~SEE_MASK_INVOKEIDLIST);
    sei.hwnd = lpcmi->hwnd;
    sei.nShow = lpcmi->nShow;
    sei.lpVerb = pEntry->Verb;
    sei.lpIDList = pidlFull;
    sei.hkeyClass = pEntry->hkClass;
    sei.dwHotKey = lpcmi->dwHotKey;
    sei.hIcon = lpcmi->hIcon;
    sei.lpDirectory = wszDir;
 
    if (unicode && !StrIsNullOrEmpty(lpcmi->lpDirectoryW))
    {
        sei.lpDirectory = lpcmi->lpDirectoryW;
    }
    else if (bHasPath)
    {
        wcscpy(wszDir, wszPath);
        PathRemoveFileSpec(wszDir);
    }
    else
    {
        if (!SHGetPathFromIDListW(m_pidlFolder, wszDir))
            *wszDir = UNICODE_NULL;
    }
 
    if (bHasPath)
        sei.lpFile = wszPath;
 
    CComHeapPtr<WCHAR> pszParamsW;
    if (unicode && !StrIsNullOrEmpty(lpcmi->lpParametersW))
        sei.lpParameters = lpcmi->lpParametersW;
    else if (!StrIsNullOrEmpty(lpcmi->lpParameters) && __SHCloneStrAtoW(&pszParamsW, lpcmi->lpParameters))
        sei.lpParameters = pszParamsW;
 
    if (!sei.lpClass && (lpcmi->fMask & (CMIC_MASK_HASLINKNAME | CMIC_MASK_HASTITLE)) && unicode)
        sei.lpClass = lpcmi->lpTitleW; // Forward .lnk path from CShellLink::DoOpen (for consrv STARTF_TITLEISLINKNAME)
 
    HRESULT hr = ShellExecuteExW(&sei) ? S_OK : HResultFromWin32(GetLastError());
    ILFree(pidlFull);
    return hr;
}

Referenced by InvokeRegVerb().

InvokeRegVerb()

HRESULT CDefaultContextMenu::InvokeRegVerb ( LPCMINVOKECOMMANDINFOEX  lpcmi )

private

Definition at line 1522 of file CDefaultContextMenu.cpp.

{
    INT iCmd = LOWORD(lpcmi->lpVerb);
    HRESULT hr;
    UINT i;
 
    POSITION it = m_StaticEntries.FindIndex(iCmd);
 
    if (it == NULL)
        return HResultFromWin32(ERROR_NO_ASSOCIATION);
 
    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;
 
        CComPtr<IExecuteCommand> pEC;
        hr = SHELL_GetRegCLSID(VerbKey, L"command", L"DelegateExecute", clsid);
        if (SUCCEEDED(hr))
            hr = CoCreateInstance(clsid, NULL, CLSCTX_ALL, IID_PPV_ARG(IExecuteCommand, &pEC));
        if (SUCCEEDED(hr))
        {
            CComPtr<IPropertyBag> pPB;
            SHCreatePropertyBagOnRegKey(VerbKey, NULL, STGM_READ, IID_PPV_ARG(IPropertyBag, &pPB));
            return InvokeIExecuteCommandWithDataObject(pEC, pEntry->Verb.GetString(), pPB, m_pDataObj,
                                                       lpcmi, static_cast<IContextMenu*>(this));
        }
 
        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))
        {
            CScopedSetObjectWithSite site(pDT, static_cast<IContextMenu*>(this));
            CComPtr<IPropertyBag> pPB;
            SHCreatePropertyBagOnRegKey(VerbKey, NULL, STGM_READ, IID_PPV_ARG(IPropertyBag, &pPB));
            IUnknown_InitializeCommand(pDT, pEntry->Verb.GetString(), pPB);
            hr = SHSimulateDrop(pDT, m_pDataObj, KeyState, pPtl, 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 1385 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 563 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 577 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_pDataObj ? NULL : 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 1312 of file CDefaultContextMenu.cpp.

{
    WCHAR UnicodeStr[MAX_VERB];
    UINT i;
 
    /* Loop through all the static verbs looking for a match */
    for (i = 0; i < _countof(g_StaticInvokeCmdMap); i++)
    {
        if (IsUnicode)
        {
            SHAnsiToUnicode(g_StaticInvokeCmdMap[i].szStringVerb, UnicodeStr, MAX_VERB);
            if (!_wcsicmp(UnicodeStr, (LPWSTR)Verb))
            {
                *idCmd = g_StaticInvokeCmdMap[i].IntVerb;
                return TRUE;
            }
        }
        else
        {
            if (!_stricmp(g_StaticInvokeCmdMap[i].szStringVerb, (LPSTR)Verb))
            {
                *idCmd = g_StaticInvokeCmdMap[i].IntVerb;
                return TRUE;
            }
        }
    }
 
    POSITION it;
    HRESULT hr = S_OK;
    // Check the registry verbs
    if (!IsUnicode)
        hr = StringCchPrintfW(UnicodeStr, _countof(UnicodeStr), L"%hs", Verb);
    for (i = 0, it = m_StaticEntries.GetHeadPosition(); it && SUCCEEDED(hr); ++i)
    {
        StaticShellEntry& entry = m_StaticEntries.GetNext(it);
        if (!_wcsicmp(entry.Verb, UnicodeStr))
        {
            *idCmd = m_iIdSCMFirst + i;
            return TRUE;
        }
    }
 
    for (it = m_DynamicEntries.GetHeadPosition(); it != NULL;)
    {
        DynamicShellEntry& entry = m_DynamicEntries.GetNext(it);
        if (!entry.NumIds)
            continue;
        HRESULT hr = ::MapVerbToCmdId(Verb, IsUnicode, entry.pCM, 0, entry.NumIds - 1);
        if (SUCCEEDED(hr))
        {
            *idCmd = m_iIdSHEFirst + entry.iIdCmdFirst + hr;
            return TRUE;
        }
    }
 
    // learn.microsoft.com/en-us/windows/win32/shell/dfm-mapcommandname
    PWSTR pszVerbW = (PWSTR)Verb;
    if (!IsUnicode)
    {
        SHAnsiToUnicode((PCSTR)Verb, UnicodeStr, _countof(UnicodeStr));
        pszVerbW = UnicodeStr;
    }
    i = -1;
    if (*pszVerbW && SUCCEEDED(_DoCallback(DFM_MAPCOMMANDNAME, (WPARAM)&i, pszVerbW)) && !HIWORD(i))
    {
        *idCmd = m_iIdCBFirst + i;
        return TRUE;
    }
 
    return FALSE; // Note: Even if the verb is "open", we must fail if we can't find a handler
}

Referenced by InvokeCommand(), and MapVerbToCmdId().

QueryContextMenu()

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

override

Implements IContextMenu.

Definition at line 958 of file CDefaultContextMenu.cpp.

{
    HRESULT hr;
    UINT idCmdNext = m_iIdQCMFirst = 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; // Note: This is incorrect, forgets about separators and causes CORE-18577. We should build the menu in reverse order like Windows...
        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 = LoadMenuW(_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCEW(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) || !(uFlags & CMF_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
 
    // TODO: Remove duplicate verbs. This will be easier when the static items handling
    // has been moved to CLSID_ShellFileDefExt so we only have to deal with ShellEx.
    // This is a Windows XP+ feature. On an unknown file type, Windows 2000 will
    // display both "Open" (openas from Unknown) and "Open with..." (openas from *).
 
    return MAKE_HRESULT(SEVERITY_SUCCESS, 0, cIds);
}

QueryService()

STDMETHOD() CDefaultContextMenu::QueryService ( REFGUID  svc, REFIID  riid, void **  ppv  )

inlineoverride

Implements IServiceProvider.

Definition at line 367 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 1902 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 922 of file CDefaultContextMenu.cpp.

{
    // Are we allowed to pick a default?
    if ((uFlags & CMF_NODEFAULT) ||
        ((uFlags & CMF_DONOTPICKDEFAULT) && RosGetProcessEffectiveVersion() >= _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 (SUCCEEDED(_DoCallback(DFM_GETDEFSTATICID, 0, &forceDfm)) && 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 1438 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[16]

private

Definition at line 297 of file CDefaultContextMenu.cpp.

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

m_apidl

PCUITEMID_CHILD_ARRAY CDefaultContextMenu::m_apidl

private

Definition at line 295 of file CDefaultContextMenu.cpp.

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

m_bGroupPolicyActive

DWORD CDefaultContextMenu::m_bGroupPolicyActive

private

Definition at line 300 of file CDefaultContextMenu.cpp.

Referenced by EnumerateDynamicContextHandlerForKey().

m_cidl

UINT CDefaultContextMenu::m_cidl

private

Definition at line 294 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 298 of file CDefaultContextMenu.cpp.

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

m_DefVerbs

WCHAR CDefaultContextMenu::m_DefVerbs[MAX_PATH]

private

Definition at line 313 of file CDefaultContextMenu.cpp.

Referenced by AddStaticContextMenusToMenu(), AddStaticEntriesForKey(), and CDefaultContextMenu().

m_DynamicEntries

CAtlList<DynamicShellEntry> CDefaultContextMenu::m_DynamicEntries

private

Definition at line 302 of file CDefaultContextMenu.cpp.

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

m_hwnd

HWND CDefaultContextMenu::m_hwnd

private

Definition at line 312 of file CDefaultContextMenu.cpp.

Referenced by _DoCallback(), and Initialize().

m_iIdCBFirst

UINT CDefaultContextMenu::m_iIdCBFirst

private

Definition at line 308 of file CDefaultContextMenu.cpp.

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

m_iIdCBLast

UINT CDefaultContextMenu::m_iIdCBLast

private

Definition at line 309 of file CDefaultContextMenu.cpp.

Referenced by InvokeCommand(), and QueryContextMenu().

m_iIdDfltFirst

UINT CDefaultContextMenu::m_iIdDfltFirst

private

Definition at line 310 of file CDefaultContextMenu.cpp.

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

m_iIdDfltLast

UINT CDefaultContextMenu::m_iIdDfltLast

private

Definition at line 311 of file CDefaultContextMenu.cpp.

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

m_iIdQCMFirst

UINT CDefaultContextMenu::m_iIdQCMFirst

private

Definition at line 301 of file CDefaultContextMenu.cpp.

Referenced by HandleMenuMsg2(), and QueryContextMenu().

m_iIdSCMFirst

UINT CDefaultContextMenu::m_iIdSCMFirst

private

Definition at line 306 of file CDefaultContextMenu.cpp.

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

m_iIdSCMLast

UINT CDefaultContextMenu::m_iIdSCMLast

private

Definition at line 307 of file CDefaultContextMenu.cpp.

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

m_iIdSHEFirst

UINT CDefaultContextMenu::m_iIdSHEFirst

private

Definition at line 303 of file CDefaultContextMenu.cpp.

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

m_iIdSHELast

UINT CDefaultContextMenu::m_iIdSHELast

private

Definition at line 304 of file CDefaultContextMenu.cpp.

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

m_pDataObj

CComPtr<IDataObject> CDefaultContextMenu::m_pDataObj

private

Definition at line 296 of file CDefaultContextMenu.cpp.

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

m_pfnmcb

LPFNDFMCALLBACK CDefaultContextMenu::m_pfnmcb

private

Definition at line 293 of file CDefaultContextMenu.cpp.

Referenced by _DoCallback(), and Initialize().

m_pidlFolder

PIDLIST_ABSOLUTE CDefaultContextMenu::m_pidlFolder

private

Definition at line 299 of file CDefaultContextMenu.cpp.

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

m_pmcb

CComPtr<IContextMenuCB> CDefaultContextMenu::m_pmcb

private

Definition at line 292 of file CDefaultContextMenu.cpp.

Referenced by _DoCallback(), and Initialize().

m_psf

CComPtr<IShellFolder> CDefaultContextMenu::m_psf

private

Definition at line 291 of file CDefaultContextMenu.cpp.

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

m_site

CComPtr<IUnknown> CDefaultContextMenu::m_site

private

Definition at line 290 of file CDefaultContextMenu.cpp.

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

m_StaticEntries

CAtlList<StaticShellEntry> CDefaultContextMenu::m_StaticEntries

private

Definition at line 305 of file CDefaultContextMenu.cpp.

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

---

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

• dll/win32/shell32/CDefaultContextMenu.cpp