\nOkay, now that we have two context menu handlers we want to compose\n(namely, the “real” one from the shell namespace and a “fake” one\nthat contains bonus commands we want to add), we can use merge them\ntogether by means of a composite context menu handler.\n<\/P>\n
\nThe kernel of the composite context menu is to multiplex multiple\ncontext menus onto a single context menu handler, using the menu identifer\noffsets to route the commands.\n<\/P>\n
\nEverything else is just typing.\n<\/P>\n
\nclass CCompositeContextMenu : public IContextMenu3\n{\npublic:\n \/\/ *** IUnknown ***\n STDMETHODIMP QueryInterface(REFIID riid, void **ppv);\n STDMETHODIMP_(ULONG) AddRef();\n STDMETHODIMP_(ULONG) Release();<\/p>\n \/\/ *** IContextMenu ***\n STDMETHODIMP QueryContextMenu(HMENU hmenu,\n UINT indexMenu, UINT idCmdFirst,\n UINT idCmdLast, UINT uFlags);\n STDMETHODIMP InvokeCommand(\n LPCMINVOKECOMMANDINFO lpici);\n STDMETHODIMP GetCommandString(\n UINT_PTR idCmd,\n UINT uType,\n UINT * pwReserved,\n LPSTR pszName,\n UINT cchMax);<\/p>\n
\/\/ *** IContextMenu2 ***\n STDMETHODIMP HandleMenuMsg(\n UINT uMsg,\n WPARAM wParam,\n LPARAM lParam);<\/p>\n
\/\/ *** IContextMenu3 ***\n STDMETHODIMP HandleMenuMsg2(\n UINT uMsg,\n WPARAM wParam,\n LPARAM lParam,\n LRESULT* plResult);<\/p>\n
\/\/ Constructor\n static HRESULT Create(IContextMenu **rgpcm, UINT cpcm,\n REFIID riid, void **ppv);<\/p>\n
private:<\/p>\n
HRESULT Initialize(IContextMenu **rgpcm, UINT cpcm);\n CCompositeContextMenu() : m_cRef(1), m_rgcmi(NULL), m_ccmi(0) { }\n ~CCompositeContextMenu();<\/p>\n
struct CONTEXTMENUINFO {\n IContextMenu *pcm;\n UINT cids;\n };<\/p>\n
HRESULT ReduceOrdinal(UINT_PTR *pidCmd, CONTEXTMENUINFO **ppcmi);<\/p>\n
private:\n ULONG m_cRef;\n CONTEXTMENUINFO *m_rgcmi;\n UINT m_ccmi;\n};\n<\/PRE>\n
\nThe local structure CONTEXTMENUINFO<\/CODE> contains\ninformation about each of the context menus that are part of\nour composite. We need to have the context menu pointer itself,\nas well as the number of menu identifiers consumed by that\ncontext menu by its\nIContextMenu::QueryContextMenu<\/A><\/CODE> handler.\nWe’ll see why as we implement this class.\n<\/P>\n\nHRESULT CCompositeContextMenu::Initialize(\n IContextMenu **rgpcm, UINT cpcm)\n{\n m_rgcmi = new CONTEXTMENUINFO[cpcm];\n if (!m_rgcmi) {\n return E_OUTOFMEMORY;\n }<\/p>\n m_ccmi = cpcm;\n for (UINT icmi = 0; icmi < m_ccmi; icmi++) {\n CONTEXTMENUINFO *pcmi = &m_rgcmi[icmi];\n pcmi->pcm = rgpcm[icmi];\n pcmi->pcm->AddRef();\n pcmi->cids = 0;\n }<\/p>\n
return S_OK;\n}\n<\/PRE>\n
\nSince a C++ constructor cannot fail, there are various\nconventions for how one handles failure during construction.\nOne convention, which I use here, is to put the bulk of\nthe work in an Initialize<\/CODE> method, which can\nreturn an appropriate error code if the initialization fails.\n<\/P>\n\n(Note that here I am assuming a non-throwing new<\/CODE> operator.)\n<\/P>\n\nOur initialization function allocates a bunch of\nCONTEXTMENUINFO<\/CODE> structures and copies the\nIContextMenu<\/CODE> pointers (and AddRef<\/CODE>s them)\nfor safekeeping. (Note that the m_ccmi<\/CODE> member is\nnot set until after we know that the memory allocation succeeded.)\n<\/P>\n\nThe destructor therefore undoes these operations.\n<\/P>\n
\nCCompositeContextMenu::~CCompositeContextMenu()\n{\n for (UINT icmi = 0; icmi < m_ccmi; icmi++) {\n m_rgcmi[icmi].pcm->Release();\n }\n delete[] m_rgcmi;\n}\n<\/PRE>\n\n(If you don’t understand the significance of the []<\/CODE>,\n\nhere’s a refresher<\/A>.)\n<\/P>\n\nThe Create<\/CODE> pattern you saw last time, so this\nshouldn’t be too surprising.\n<\/P>\n\nHRESULT CCompositeContextMenu::Create(IContextMenu **rgpcm, UINT cpcm,\n REFIID riid, void **ppv)\n{\n *ppv = NULL;<\/p>\n HRESULT hr;\n CCompositeContextMenu *self = new CCompositeContextMenu();\n if (self) {\n if (SUCCEEDED(hr = self->Initialize(rgpcm, cpcm)) &&\n SUCCEEDED(hr = self->QueryInterface(riid, ppv))) {\n \/\/ success\n }\n self->Release();\n } else {\n hr = E_OUTOFMEMORY;\n }\n return hr;\n}\n<\/PRE>\n
\nAnd then the standard COM bookkeeping.\n<\/P>\n
\nHRESULT CCompositeContextMenu::QueryInterface(REFIID riid, void **ppv)\n{\n IUnknown *punk = NULL;\n if (riid == IID_IUnknown) {\n punk = static_cast<IUnknown*>(this);\n } else if (riid == IID_IContextMenu) {\n punk = static_cast<IContextMenu*>(this);\n } else if (riid == IID_IContextMenu2) {\n punk = static_cast<IContextMenu2*>(this);\n } else if (riid == IID_IContextMenu3) {\n punk = static_cast<IContextMenu3*>(this);\n }<\/p>\n *ppv = punk;\n if (punk) {\n punk->AddRef();\n return S_OK;\n } else {\n return E_NOINTERFACE;\n }\n}<\/p>\n
ULONG CCompositeContextMenu::AddRef()\n{\n return ++m_cRef;\n}<\/p>\n
ULONG CCompositeContextMenu::Release()\n{\n ULONG cRef = –m_cRef;\n if (cRef == 0) delete this;\n return cRef;\n}\n<\/PRE>\n
\nNow we reach our first interesting method:\nIContextMenu::QueryContextMenu<\/CODE>:\n\nHRESULT CCompositeContextMenu::QueryContextMenu(\n HMENU hmenu, UINT indexMenu, UINT idCmdFirst,\n UINT idCmdLast, UINT uFlags)\n{\n UINT idCmdFirstOrig = idCmdFirst;\n UINT cids = 0;<\/p>\n for (UINT icmi = 0; icmi < m_ccmi; icmi++) {\n CONTEXTMENUINFO *pcmi = &m_rgcmi[icmi];\n HRESULT hr = pcmi->pcm->QueryContextMenu(hmenu,\n indexMenu, idCmdFirst, idCmdLast, uFlags);\n if (SUCCEEDED(hr)) {\n pcmi->cids = (USHORT)hr;\n cids += pcmi->cids;\n idCmdFirst += pcmi->cids;\n }\n }<\/p>\n
return MAKE_HRESULT(SEVERITY_SUCCESS, 0, cids);\n}\n<\/PRE>\n
\nWe ask each contained context menu\nin turn to add its commands to the context menu. Here is\nwhere you see one of the reasons for the return value of the\nIContextMenu::QueryContextMenu<\/CODE> method.\nBy telling tells the container how many menu identifiers\nyou used, the container knows how many are left for others.\nThe container then returns the total number of menu identifiers\nconsumed by all of the context menus.\n<\/P>\n\nAnother reason for the return value of the\nIContextMenu::QueryContextMenu<\/CODE> method\nis seen in the next helper method:\n<\/P>\n\nHRESULT CCompositeContextMenu::ReduceOrdinal(\n UINT_PTR *pidCmd, CONTEXTMENUINFO **ppcmi)\n{\n for (UINT icmi = 0; icmi < m_ccmi; icmi++) {\n CONTEXTMENUINFO *pcmi = &m_rgcmi[icmi];\n if (*pidCmd < pcmi->cids) {\n *ppcmi = pcmi;\n return S_OK;\n }\n *pidCmd -= pcmi->cids;\n }\n return E_INVALIDARG;\n}\n<\/PRE>\n\nThis method takes a menu offset and figures out which\nof the contained context menus it belongs to,\nusing the return value from\nIContextMenu::QueryContextMenu<\/CODE> to decide\nhow to divide up the identifier space.\nThe pidCmd<\/CODE> parameter is in\/out.\nOn entry, it’s the menu offset for the composite\ncontext menu; on exit, it’s the menu offset for\nthe contained context menu that is returned via\nthe ppcmi<\/CODE> parameter.\n<\/P>\n\nThe IContextMenu::InvokeCommand<\/CODE> is probably\nthe most complicated, since it needs to support the\nfour different ways of dispatching the command.\n<\/P>\n\nHRESULT CCompositeContextMenu::InvokeCommand(\n LPCMINVOKECOMMANDINFO lpici) {<\/p>\n CMINVOKECOMMANDINFOEX* lpicix =\n reinterpret_cast<CMINVOKECOMMANDINFOEX*>(lpici);\n BOOL fUnicode = lpici->cbSize >= sizeof(CMINVOKECOMMANDINFOEX) &&\n (lpici->fMask & CMIC_MASK_UNICODE);\n UINT_PTR idCmd = fUnicode ? reinterpret_cast<UINT_PTR>(lpicix->lpVerbW)\n : reinterpret_cast<UINT_PTR>(lpici->lpVerb);<\/p>\n
if (!IS_INTRESOURCE(idCmd)) {\n for (UINT icmi = 0; icmi < m_ccmi; icmi++) {\n HRESULT hr = m_rgcmi->pcm->InvokeCommand(lpici);\n if (SUCCEEDED(hr)) {\n return hr;\n }\n }\n return E_INVALIDARG;\n }<\/p>\n
CONTEXTMENUINFO *pcmi;\n HRESULT hr = ReduceOrdinal(&idCmd, &pcmi);\n if (FAILED(hr)) {\n return hr;\n }<\/p>\n
LPCWSTR pszVerbWFake;\n LPCWSTR *ppszVerbW = fUnicode ? &lpicix->lpVerbW : &pszVerbWFake;\n LPCSTR pszVerbOrig = lpici->lpVerb;\n LPCWSTR pszVerbWOrig = *ppszVerbW;<\/p>\n
lpici->lpVerb = reinterpret_cast<LPCSTR>(idCmd);\n *ppszVerbW = reinterpret_cast<LPCWSTR>(idCmd);<\/p>\n
hr = pcmi->pcm->InvokeCommand(lpici);<\/p>\n
lpici->lpVerb = pszVerbOrig;\n *ppszVerbW = pszVerbWOrig;<\/p>\n
return hr;\n}\n<\/PRE>\n
\nAfter some preliminary munging to find the command identifier,\nwe dispatch the invocation in three steps.\n<\/P>\n
\nFirst, if the command is being dispatched as a string, then\nthis is the easiest case. We loop through all the contained\ncontext menus asking each one if it recognizes the command.\nOnce one does, we are done. And if nobody does, then we\nshrug and say we don’t know either.\n<\/P>\n
\nSecond, if the command being dispatched is an ordinal,\nwe ask ReduceOrdinal<\/CODE> to figure out which contained\ncontext menu handler it belongs to.\n<\/P>\n\nThird, we rewrite the CMINVOKECOMMANDINFO<\/CODE> structure\nso it is suitable for use by the contained context menu handler.\nThis means changing the lpVerb<\/CODE> member and possibly the\nlpVerbW<\/CODE> member to contain the new menu offset relative\nto the contained context menu handler rather than being relative\nto the container.\nThis is complicated slightly by the fact that the Unicode verb\nlpVerbW<\/CODE> might not exist. We hide that behind a\npszVerbWFake<\/CODE> local variable which stands in if\nthere is no genuine lpVerbW<\/CODE>.\n<\/P>\n\nOkay, now that you see the basic idea behind distributing the\nmethod calls to the appropriate contained context menu, the\nrest should be comparatively easy.\n<\/P>\n
\nHRESULT CCompositeContextMenu::GetCommandString(\n UINT_PTR idCmd,\n UINT uType,\n UINT * pwReserved,\n LPSTR pszName,\n UINT cchMax)\n{\n HRESULT hr;\n if (!IS_INTRESOURCE(idCmd)) {\n for (UINT icmi = 0; icmi < m_ccmi; icmi++) {\n hr = m_rgcmi[icmi].pcm->GetCommandString(idCmd,\n uType, pwReserved, pszName, cchMax);\n if (hr == S_OK) {\n return hr;\n }\n }\n if (uType == GCS_VALIDATEA || uType == GCS_VALIDATEW) {\n return S_FALSE;\n }\n return E_INVALIDARG;\n }<\/p>\n CONTEXTMENUINFO *pcmi;\n if (FAILED(hr = ReduceOrdinal(&idCmd, &pcmi))) {\n return hr;\n }<\/p>\n
return pcmi->pcm->GetCommandString(idCmd, uType,\n pwReserved, pszName, cchMax);\n}\n<\/PRE>\n
\nThe GetCommandString<\/CODE> method follows the same\nthree-step pattern as InvokeCommand<\/CODE>.\n<\/P>\n\nFirst, dispatch any string-based commands by calling each\ncontained context menu handler until somebody accepts it.\nIf nobody does, then reject the command.\n(Note the special handling of GCS_VALIDATE<\/CODE>,\nwhich expects S_FALSE<\/CODE> rather than an error code.)\n<\/P>\n\nSecond, if the command is specified by ordinal, ask\nReduceOrdinal<\/CODE> to figure out which contained\ncontext menu handler it belongs to.\n<\/P>\n\nThird, pass the reduced command to the applicable contained\ncontext menu handler.\n<\/P>\n
\nThe last methods are made easier by a little helper function:\n<\/P>\n
\nHRESULT IContextMenu_HandleMenuMsg2(\n IContextMenu *pcm, UINT uMsg, WPARAM wParam,\n LPARAM lParam, LRESULT* plResult)\n{\n IContextMenu2 *pcm2;\n IContextMenu3 *pcm3;\n HRESULT hr;\n if (SUCCEEDED(hr = pcm->QueryInterface(\n IID_IContextMenu3, (void**)&pcm3))) {\n hr = pcm3->HandleMenuMsg2(uMsg, wParam, lParam, plResult);\n pcm3->Release();\n } else if (SUCCEEDED(hr = pcm->QueryInterface(\n IID_IContextMenu2, (void**)&pcm2))) {\n if (plResult) *plResult = 0;\n hr = pcm2->HandleMenuMsg(uMsg, wParam, lParam);\n pcm2->Release();\n }\n return hr;\n}\n<\/PRE>\n\nThis helper function takes an IContextMenu<\/CODE>\ninterface pointer and tries to invoke\nIContextMenu3::HandleMenuMsg2<\/CODE>; if that fails,\nthen it tries IContextMenu2::HandleMenuMsg<\/CODE>; and\nif that also fails, then it gives up.\n<\/P>\n\nWith this helper function, the last two methods are a piece of cake.\n<\/P>\n
\nHRESULT CCompositeContextMenu::HandleMenuMsg(\n UINT uMsg, WPARAM wParam, LPARAM lParam)\n{\n LRESULT lres; \/\/ thrown away\n return HandleMenuMsg2(uMsg, wParam, lParam, &lres);\n}\n<\/PRE>\n\nThe IContextMenu2::HandleMenuMsg<\/CODE> method is just\na forwarder to the IContextMenu3::HandleMenuMsg2<\/CODE>\nmethod:\n<\/P>\n\nHRESULT CCompositeContextMenu::HandleMenuMsg2(\n UINT uMsg, WPARAM wParam, LPARAM lParam,\n LRESULT* plResult)\n{\n for (UINT icmi = 0; icmi < m_ccmi; icmi++) {\n HRESULT hr;\n if (SUCCEEDED(hr = IContextMenu_HandleMenuMsg2(\n m_rgcmi[icmi].pcm, uMsg, wParam, lParam,\n plResult))) {\n return hr;\n }\n }\n return E_NOTIMPL;\n}\n<\/PRE>\n\nAnd the IContextMenu3::HandleMenuMsg2<\/CODE> method\nmerely walks through the list of context menu handlers,\nasking each one whether it wishes to handle the command,\nstopping when one finally does.\n<\/P>\n\nArmed with this composite menu class, we can show it off\nin our sample program by compositing the “real” context menu\nwith our CTopContextMenu<\/CODE>, thereby showing\nhow you can combine multiple context menus into one big\ncontext menu.\n<\/P>\n\nHRESULT GetCompositeContextMenuForFile(HWND hwnd,\n LPCWSTR pszPath, REFIID riid, void **ppv)\n{\n *ppv = NULL;\n HRESULT hr;<\/p>\n IContextMenu *rgpcm[2] = { 0 };\n if (SUCCEEDED(hr = GetUIObjectOfFile(hwnd, pszPath,\n IID_IContextMenu, (void**)&rgpcm[0])) &&\n SUCCEEDED(hr = CTopContextMenu::Create(\n IID_IContextMenu, (void**)&rgpcm[1])) &&\n SUCCEEDED(hr = CCompositeContextMenu::Create(rgpcm, 2, riid, ppv))) {\n \/\/ yay\n }\n if (rgpcm[0]) rgpcm[0]->Release();\n if (rgpcm[1]) rgpcm[1]->Release();<\/p>\n
return hr;\n}\n<\/PRE>\n
\nThis function builds the composite by creating the two\ncontained context menu handlers, then creating a composite\ncontext menu that contains both of them. We can use this\nfunction by making the same one-line tweak to the\nOnContextMenu<\/CODE> function that we tweaked last time:\n<\/P>\n\nvoid OnContextMenu(HWND hwnd, HWND hwndContext, int xPos, int yPos)\n{\n POINT pt = { xPos, yPos };\n if (pt.x == -1 && pt.y == -1) {\n pt.x = pt.y = 0;\n ClientToScreen(hwnd, &pt);\n }<\/p>\n IContextMenu *pcm;\n if (SUCCEEDED(GetCompositeContextMenuForFile(\n hwnd, L”C:\\\\Windows\\\\clock.avi”,\n IID_IContextMenu, (void**)&pcm)<\/FONT>)) {\n …\n<\/PRE>\n\nNotice that with this composite context menu, the menu help text\nthat we update in our window title tracks across both the\noriginal file context menu and our “Top” context menu.\nCommands from either half are also invoked successfully.\n<\/P>\n
\nThe value of this approach over the method from\n\npart 9<\/A>\nis that you no longer have to coordinate the customization of\nthe context menu between two pieces of code. Under the previous\ntechnique, you had to make sure that the code that updated the\nmenu help text was in sync with the code that added the custom\ncommands.\n<\/P>\n\nUnder the new method, all the customizations are kept in one\nplace (in the “Top” context menu which is inside the\ncomposite context menu), so that the window procedure doesn’t need\nto know what customizations have taken place.\nThis becomes more valuable if there are multiple points at which\ncontext menus are displayed, some uncustomized, others customized\nin different ways. Centralizing the knowledge of the customizations\nsimplifies the design.\n<\/P>\n
\nOkay, I think that’s enough on context menus for now.\nI hope you’ve gotten a better understanding of how they work,\nhow you can exploit them, and most importantly, how you can\nperform meta-operations on them with techniques like composition.\n<\/P>\n
\nThere are still some\nother things you can do with context menus, but I’m going to leave you\nto experiment with them on your own. For example, you can use\n\nthe IContextMenu::GetCommandString method<\/A> to walk\nthe menu and obtain a language-independent command mame\nfor each item.\nThis is handy if you want to, say, remove the “delete” option:\nYou can look for the command whose language-independent name\nis “delete”. This name does not change when the user changes\nlanguages; it will always be in English.\n<\/P>\n