ReactOS 0.4.16-dev-1493-ge7358c5
CDefaultContextMenu.cpp
Go to the documentation of this file.
1/*
2 * PROJECT: shell32
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: dll/win32/shell32/shv_item_new.c
5 * PURPOSE: provides default context menu implementation
6 * PROGRAMMERS: Johannes Anderwald (johannes.anderwald@reactos.org)
7 */
8
9#include "precomp.h"
10#include <compat_undoc.h>
11
13
14// FIXME: 260 is correct, but should this be part of the SDK or just MAX_PATH?
15#define MAX_VERB 260
16
17static HRESULT
19{
20 WCHAR buf[42];
21 DWORD cb = sizeof(buf);
24}
25
27{
28 MENUITEMINFOW mii;
29 mii.cbSize = FIELD_OFFSET(MENUITEMINFOW, hbmpItem); // USER32 version agnostic
30 mii.fMask = MIIM_TYPE;
31 mii.fType = Flags;
32 return InsertMenuItemW(hMenu, Pos, TRUE, &mii);
33}
34
35static void DCMA_DestroyEntry(DCMENTRY &dcme)
36{
37 if (!dcme.pCM)
38 return;
40 dcme.pCM->Release();
41 dcme.pCM = NULL;
42}
43
45{
46 UINT i = 0;
47 for (DCMENTRY *p; (p = DCMA_GetEntry(hDCMA, i)) != NULL; ++i)
49 DSA_Destroy(hDCMA);
50}
51
53 _In_ HDCMA hDCMA,
54 _In_ HDCIA hDCIA,
55 _In_opt_ LPCITEMIDLIST pidlFolder,
57 _In_opt_ HKEY *pKeys,
58 _In_opt_ UINT nKeys,
59 _In_ QCMINFO *pQCMI,
60 _In_opt_ UINT fCmf,
61 _In_opt_ IUnknown *pUnkSite)
62{
63 UINT idCmdBase = pQCMI->idCmdFirst, idCmdFirst = idCmdBase;
64 UINT nOffset = 0;
65
66 // Insert in reverse order
67 for (int iCls = DCIA_GetCount(hDCIA) - 1; iCls >= 0; --iCls)
68 {
69 REFCLSID clsid = *DCIA_GetEntry(hDCIA, iCls);
70 if (fCmf & CMF_DEFAULTONLY)
71 {
72 WCHAR szKey[MAX_PATH];
73 wcscpy(szKey, L"CLSID\\");
74 StringFromGUID2(clsid, szKey + _countof(L"CLSID\\") - 1, CHARS_IN_GUID);
75 wcscpy(szKey + _countof(L"CLSID\\") - 1 + CHARS_IN_GUID - 1, L"\\shellex\\MayChangeDefaultMenu");
77 continue;
78 }
79
80 for (UINT iKey = 0; iKey < nKeys; ++iKey)
81 {
84 if (FAILED(hr))
85 break;
86 if (FAILED(hr = pInit->Initialize(pidlFolder, pDO, pKeys[iKey])))
87 continue;
88
89 IContextMenu *pCM;
90 if (FAILED(hr = pInit->QueryInterface(IID_PPV_ARG(IContextMenu, &pCM))))
91 break;
92 IUnknown_SetSite(pCM, pUnkSite);
93
94 hr = pCM->QueryContextMenu(pQCMI->hmenu, pQCMI->indexMenu + nOffset, idCmdFirst, pQCMI->idCmdLast, fCmf);
95 const UINT nCount = HRESULT_CODE(hr);
96 const UINT idThisFirst = idCmdFirst - idCmdBase;
97 DCMENTRY dcme = { pCM, idThisFirst, idThisFirst + nCount - 1 };
98 if (hr > 0)
99 {
100 idCmdFirst += nCount;
101 if (DSA_AppendItem(hDCMA, &dcme) >= 0)
102 {
103 if (nOffset == 0 && GetMenuDefaultItem(pQCMI->hmenu, TRUE, 0) == 0)
104 nOffset++; // Insert new items below the default
105 break;
106 }
107 }
108 DCMA_DestroyEntry(dcme);
109 }
110 }
111 return idCmdFirst;
112}
113
114HRESULT DCMA_InvokeCommand(HDCMA hDCMA, CMINVOKECOMMANDINFO *pICI)
115{
117 for (UINT i = 0;; ++i)
118 {
119 DCMENTRY *p = DCMA_GetEntry(hDCMA, i);
120 if (!p)
121 return hr;
122
123 UINT id = LOWORD(pICI->lpVerb);
124 if (!IS_INTRESOURCE(pICI->lpVerb))
125 {
126 if (SUCCEEDED(hr = p->pCM->InvokeCommand(pICI)))
127 return hr;
128 }
129 else if (id >= p->idCmdFirst && id <= p->idCmdLast)
130 {
131 CMINVOKECOMMANDINFOEX ici;
132 CopyMemory(&ici, pICI, min(sizeof(ici), pICI->cbSize));
133 ici.cbSize = min(sizeof(ici), pICI->cbSize);
134 ici.lpVerb = MAKEINTRESOURCEA(id - p->idCmdFirst);
135 ici.lpVerbW = (PWSTR)ici.lpVerb;
136 return p->pCM->InvokeCommand((CMINVOKECOMMANDINFO*)&ici);
137 }
138 }
139}
140
142{
148
149typedef struct _StaticShellEntry_
150{
154
155#define DCM_FCIDM_SHVIEW_OFFSET 0x7000 // Offset from the menu ids in the menu resource to FCIDM_SHVIEW_*
156
157//
158// verbs for InvokeCommandInfo
159//
160static const struct _StaticInvokeCommandMap_
161{
166{
167 { "runas", 0 }, // Unimplemented
168 { "print", 0 }, // Unimplemented
169 { "preview", 0 }, // Unimplemented
170 { "open", FCIDM_SHVIEW_OPEN },
171 { CMDSTR_NEWFOLDERA, FCIDM_SHVIEW_NEWFOLDER, (SHORT)DFM_CMD_NEWFOLDER },
172 { "cut", FCIDM_SHVIEW_CUT, /* ? */ },
179 { "copyto", FCIDM_SHVIEW_COPYTO },
180 { "moveto", FCIDM_SHVIEW_MOVETO },
182
184{
185 for (SIZE_T i = 0; i < _countof(g_StaticInvokeCmdMap); ++i)
186 {
187 if (g_StaticInvokeCmdMap[i].IntVerb == CmdId && CmdId)
188 return g_StaticInvokeCmdMap[i].szStringVerb;
189 }
190 return NULL;
191}
192
194{
195 for (UINT i = 0; i < _countof(g_StaticInvokeCmdMap); ++i)
196 {
197 if (!lstrcmpiA(g_StaticInvokeCmdMap[i].szStringVerb, verba))
198 return (int)g_StaticInvokeCmdMap[i].DfmCmd;
199 }
200 return 0;
201}
202
203static HRESULT
204MapVerbToCmdId(PVOID Verb, BOOL IsUnicode, IContextMenu *pCM, UINT idFirst, UINT idLast)
205{
206 const UINT gcs = IsUnicode ? GCS_VERBW : GCS_VERBA;
207 for (UINT id = idFirst; id <= idLast; ++id)
208 {
210 *buf = UNICODE_NULL;
211 HRESULT hr = pCM->GetCommandString(id, gcs, NULL, (LPSTR)buf, _countof(buf));
212 if (FAILED(hr) || !*buf)
213 continue;
214 else if (IsUnicode && !_wcsicmp((LPWSTR)Verb, buf))
215 return id;
216 else if (!IsUnicode && !lstrcmpiA((LPSTR)Verb, (LPSTR)buf))
217 return id;
218 }
220}
221
222static inline bool IsVerbListSeparator(WCHAR Ch)
223{
224 return Ch == L' ' || Ch == L','; // learn.microsoft.com/en-us/windows/win32/shell/context-menu-handlers
225}
226
228{
229 for (UINT index = 0; *List; ++index)
230 {
231 while (IsVerbListSeparator(*List))
232 List++;
234 while (*List && !IsVerbListSeparator(*List))
235 List++;
236 // "List > Start" to verify that the list item is non-empty to avoid the edge case where Verb is "" and the list contains ",,"
237 if (!_wcsnicmp(Verb, Start, List - Start) && List > Start)
238 return index;
239 }
240 return -1;
241}
242
244{
245 for (UINT i = 0; *List; ++i)
246 {
247 while (IsVerbListSeparator(*List))
248 List++;
250 while (*List && !IsVerbListSeparator(*List))
251 List++;
252 if (List > Start && i == Index)
254 }
256}
257
259{
260 static const struct { PCWSTR pszVerb; WORD iResId; } map[] =
261 {
262 // { L"open", IDS_OPEN_VERB }, These two have already been handled
263 // { L"explore", IDS_EXPLORE_VERB },
264 { L"edit", IDS_EDIT_VERB },
265 { L"print", IDS_PRINT_VERB },
266 { L"runas", IDS_RUNAS_VERB },
267 { L"openas", IDS_OPEN_VERB },
268 { L"find", IDS_FIND_VERB },
269 };
270 for (SIZE_T i = 0; i < _countof(map); ++i)
271 {
272 if (!_wcsicmp(pszVerb, map[i].pszVerb) &&
273 LoadStringW(shell32_hInstance, map[i].iResId, pszBuf, cchMax))
274 {
275 return S_OK;
276 }
277 }
278
279 // Try to make a friendly verb based on the verb subkey
280 if (pszVerb[0] < 127 && !StrChrW(pszVerb, '&') && SUCCEEDED(StringCchCopyW(pszBuf + 1, --cchMax, pszVerb)))
281 {
282 *pszBuf = L'&';
283 return S_OK; // This can be changed to S_FALSE if the caller needs to know we faked it
284 }
285 return E_FAIL;
286}
287
289 public CComObjectRootEx<CComMultiThreadModelNoCS>,
290 public IContextMenu3,
291 public IObjectWithSite,
292 public IServiceProvider
293{
294 private:
306 UINT m_iIdQCMFirst; /* The first id passed to us in QueryContextMenu */
308 UINT m_iIdSHEFirst; /* first used id */
309 UINT m_iIdSHELast; /* last used id */
311 UINT m_iIdSCMFirst; /* first static used id */
312 UINT m_iIdSCMLast; /* last static used id */
313 UINT m_iIdCBFirst; /* first callback used id */
314 UINT m_iIdCBLast; /* last callback used id */
315 UINT m_iIdDfltFirst; /* first default part id */
316 UINT m_iIdDfltLast; /* last default part id */
317 HWND m_hwnd; /* window passed to callback */
319
322 void AddStaticEntry(const HKEY hkeyClass, const WCHAR *szVerb, UINT uFlags);
324 void TryPickDefault(HMENU hMenu, UINT idCmdFirst, UINT DfltOffset, UINT uFlags);
328 UINT AddShellExtensionsToMenu(HMENU hMenu, UINT* pIndexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags);
329 UINT AddStaticContextMenusToMenu(HMENU hMenu, UINT* IndexMenu, UINT iIdCmdFirst, UINT iIdCmdLast, UINT uFlags);
346 BOOL MapVerbToCmdId(PVOID Verb, PUINT idCmd, BOOL IsUnicode);
347
348 public:
352
353 // IContextMenu
354 STDMETHOD(QueryContextMenu)(HMENU hMenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags) override;
356 STDMETHOD(GetCommandString)(UINT_PTR idCommand, UINT uFlags, UINT *lpReserved, LPSTR lpszName, UINT uMaxNameLen) override;
357
358 // IContextMenu2
360
361 // IContextMenu3
362 STDMETHOD(HandleMenuMsg2)(UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *plResult) override;
363
364 // IObjectWithSite
365 STDMETHOD(SetSite)(IUnknown *pUnkSite) override;
366 STDMETHOD(GetSite)(REFIID riid, void **ppvSite) override;
367
368 // IServiceProvider
370 {
371 return IUnknown_QueryService(m_site, svc, riid, ppv);
372 }
373
375 COM_INTERFACE_ENTRY_IID(IID_IContextMenu, IContextMenu)
376 COM_INTERFACE_ENTRY_IID(IID_IContextMenu2, IContextMenu2)
377 COM_INTERFACE_ENTRY_IID(IID_IContextMenu3, IContextMenu3)
379 COM_INTERFACE_ENTRY_IID(IID_IServiceProvider, IServiceProvider)
381};
382
384 m_psf(NULL),
385 m_pmcb(NULL),
386 m_pfnmcb(NULL),
387 m_cidl(0),
388 m_apidl(NULL),
389 m_pDataObj(NULL),
390 m_aKeys(NULL),
391 m_cKeys(NULL),
392 m_pidlFolder(NULL),
393 m_bGroupPolicyActive(0),
394 m_iIdQCMFirst(0),
395 m_iIdSHEFirst(0),
396 m_iIdSHELast(0),
397 m_iIdSCMFirst(0),
398 m_iIdSCMLast(0),
399 m_iIdCBFirst(0),
400 m_iIdCBLast(0),
401 m_iIdDfltFirst(0),
402 m_iIdDfltLast(0),
403 m_hwnd(NULL)
404{
406}
407
409{
410 for (POSITION it = m_DynamicEntries.GetHeadPosition(); it != NULL;)
411 {
412 const DynamicShellEntry& info = m_DynamicEntries.GetNext(it);
413 IUnknown_SetSite(info.pCM.p, NULL);
414 }
415 m_DynamicEntries.RemoveAll();
416 m_StaticEntries.RemoveAll();
417
418 for (UINT i = 0; i < m_cKeys; i++)
421
422 if (m_pidlFolder)
424 _ILFreeaPidl(const_cast<PITEMID_CHILD *>(m_apidl), m_cidl);
425}
426
428{
429 TRACE("cidl %u\n", pdcm->cidl);
430
431 if (!pdcm->pcmcb && !lpfn)
432 {
433 ERR("CDefaultContextMenu needs a callback!\n");
434 return E_INVALIDARG;
435 }
436
437 m_cidl = pdcm->cidl;
439 if (m_cidl && !m_apidl)
440 return E_OUTOFMEMORY;
441 m_psf = pdcm->psf;
442 m_pmcb = pdcm->pcmcb;
443 m_pfnmcb = lpfn;
444 m_hwnd = pdcm->hwnd;
445
446 m_cKeys = pdcm->cKeys;
447 if (pdcm->cKeys)
448 {
449 m_aKeys = (HKEY*)HeapAlloc(GetProcessHeap(), 0, sizeof(HKEY) * pdcm->cKeys);
450 if (!m_aKeys)
451 return E_OUTOFMEMORY;
452 memcpy(m_aKeys, pdcm->aKeys, sizeof(HKEY) * pdcm->cKeys);
453 }
454
455 m_psf->GetUIObjectOf(pdcm->hwnd, m_cidl, m_apidl, IID_NULL_PPV_ARG(IDataObject, &m_pDataObj));
456
457 if (pdcm->pidlFolder)
458 {
460 }
461 else
462 {
464 if (SUCCEEDED(m_psf->QueryInterface(IID_PPV_ARG(IPersistFolder2, &pf))))
465 {
466 if (FAILED(pf->GetCurFolder(&m_pidlFolder)))
467 ERR("GetCurFolder failed\n");
468 }
469 TRACE("pidlFolder %p\n", m_pidlFolder);
470 }
471
472 return S_OK;
473}
474
476{
477 if (m_pmcb)
478 {
479 return m_pmcb->CallBack(m_psf, m_hwnd, m_pDataObj, uMsg, wParam, (LPARAM)lParam);
480 }
481 else if(m_pfnmcb)
482 {
484 }
485
486 return E_FAIL;
487}
488
489void CDefaultContextMenu::AddStaticEntry(const HKEY hkeyClass, const WCHAR *szVerb, UINT uFlags)
490{
491 POSITION it = m_StaticEntries.GetHeadPosition();
492 while (it != NULL)
493 {
494 const StaticShellEntry& info = m_StaticEntries.GetNext(it);
495 if (info.Verb.CompareNoCase(szVerb) == 0)
496 {
497 /* entry already exists */
498 return;
499 }
500 }
501
502 TRACE("adding verb %s\n", debugstr_w(szVerb));
503
504 if (!_wcsicmp(szVerb, L"open") && !(uFlags & CMF_NODEFAULT))
505 {
506 /* open verb is always inserted in front */
507 m_StaticEntries.AddHead({ szVerb, hkeyClass });
508 }
509 else
510 {
511 m_StaticEntries.AddTail({ szVerb, hkeyClass });
512 }
513}
514
516{
517 WCHAR wszName[VERBKEY_CCHMAX];
518 DWORD cchName, dwIndex = 0;
519 HKEY hShellKey;
520
521 LRESULT lres = RegOpenKeyExW(hKey, L"shell", 0, KEY_READ, &hShellKey);
522 if (lres != STATUS_SUCCESS)
523 return;
524
525 if (!*m_DefVerbs)
526 {
527 DWORD cb = sizeof(m_DefVerbs);
529 }
530
531 while(TRUE)
532 {
533 cchName = _countof(wszName);
534 if (RegEnumKeyExW(hShellKey, dwIndex++, wszName, &cchName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
535 break;
536
537 AddStaticEntry(hKey, wszName, uFlags);
538 }
539
540 RegCloseKey(hShellKey);
541}
542
543static
544BOOL
546{
547 BOOL bRet = FALSE;
548 CComPtr<IDataObject> pDataObj;
549
550 if (SUCCEEDED(OleGetClipboard(&pDataObj)))
551 {
552 FORMATETC formatetc;
553
554 TRACE("pDataObj=%p\n", pDataObj.p);
555
556 /* Set the FORMATETC structure*/
557 InitFormatEtc(formatetc, RegisterClipboardFormatW(CFSTR_SHELLIDLIST), TYMED_HGLOBAL);
558 bRet = SUCCEEDED(pDataObj->QueryGetData(&formatetc));
559 }
560
561 return bRet;
562}
563
564BOOL
566{
567 POSITION it = m_DynamicEntries.GetHeadPosition();
568 while (it != NULL)
569 {
570 const DynamicShellEntry& info = m_DynamicEntries.GetNext(it);
571 if (info.ClassID == clsid)
572 return TRUE;
573 }
574
575 return FALSE;
576}
577
580{
581 HRESULT hr;
582 TRACE("LoadDynamicContextMenuHandler entered with This %p hKey %p pclsid %s\n", this, hKey, wine_dbgstr_guid(&clsid));
583
585 return S_OK;
586
589 if (FAILED(hr))
590 {
591 ERR("SHCoCreateInstance(IContextMenu) failed.clsid %s hr 0x%x\n", wine_dbgstr_guid(&clsid), hr);
592 return hr;
593 }
594
595 CComPtr<IShellExtInit> pExtInit;
596 hr = pcm->QueryInterface(IID_PPV_ARG(IShellExtInit, &pExtInit));
597 if (FAILED(hr))
598 {
599 ERR("IContextMenu->QueryInterface(IShellExtInit) failed.clsid %s hr 0x%x\n", wine_dbgstr_guid(&clsid), hr);
600 return hr;
601 }
602
603 hr = pExtInit->Initialize(m_pDataObj ? NULL : m_pidlFolder, m_pDataObj, hKey);
604 if (FAILED(hr))
605 {
606 WARN("IShellExtInit::Initialize failed.clsid %s hr 0x%x\n", wine_dbgstr_guid(&clsid), hr);
607 return hr;
608 }
609
610 if (m_site)
612
613 m_DynamicEntries.AddTail({ 0, 0, clsid, pcm });
614
615 return S_OK;
616}
617
618BOOL
620{
621 WCHAR wszName[MAX_PATH], wszBuf[MAX_PATH], *pwszClsid;
623 HRESULT hr;
624 HKEY hKey;
625
626 if (RegOpenKeyExW(hRootKey, L"shellex\\ContextMenuHandlers", 0, KEY_READ, &hKey) != ERROR_SUCCESS)
627 {
628 TRACE("RegOpenKeyExW failed\n");
629 return FALSE;
630 }
631
632 DWORD dwIndex = 0;
633 while (TRUE)
634 {
635 cchName = _countof(wszName);
636 if (RegEnumKeyExW(hKey, dwIndex++, wszName, &cchName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
637 break;
638
639 /* Key name or key value is CLSID */
640 CLSID clsid;
641 hr = CLSIDFromString(wszName, &clsid);
642 if (hr == S_OK)
643 pwszClsid = wszName;
644 else
645 {
646 DWORD cchBuf = _countof(wszBuf);
647 if (RegGetValueW(hKey, wszName, NULL, RRF_RT_REG_SZ, NULL, wszBuf, &cchBuf) == ERROR_SUCCESS)
648 hr = CLSIDFromString(wszBuf, &clsid);
649 pwszClsid = wszBuf;
650 }
651
652 if (FAILED(hr))
653 {
654 ERR("CLSIDFromString failed for clsid %S hr 0x%x\n", pwszClsid, hr);
655 continue;
656 }
657
659 {
661 L"Software\\Microsoft\\Windows\\CurrentVersion\\Shell Extensions\\Approved",
662 pwszClsid,
664 NULL,
665 NULL,
667 {
668 ERR("Shell extension %s not approved!\n", pwszClsid);
669 continue;
670 }
671 }
672
674 if (FAILED(hr))
675 WARN("Failed to get context menu entires from shell extension! clsid: %S\n", pwszClsid);
676 }
677
679 return TRUE;
680}
681
682UINT
684{
685 UINT cIds = 0;
686
687 if (m_DynamicEntries.IsEmpty())
688 return cIds;
689
690 POSITION it = m_DynamicEntries.GetHeadPosition();
691 while (it != NULL)
692 {
694
695 HRESULT hr = info.pCM->QueryContextMenu(hMenu, *pIndexMenu, idCmdFirst + cIds, idCmdLast, uFlags);
696 if (SUCCEEDED(hr))
697 {
698 info.iIdCmdFirst = cIds;
699 info.NumIds = HRESULT_CODE(hr);
700 (*pIndexMenu) += info.NumIds;
701
702 cIds += info.NumIds;
703 if (idCmdFirst + cIds >= idCmdLast)
704 break;
705 }
706 TRACE("pEntry hr %x contextmenu %p cmdfirst %x num ids %x\n", hr, info.pCM.p, info.iIdCmdFirst, info.NumIds);
707 }
708 return cIds;
709}
710
711UINT
713 HMENU hMenu,
714 UINT* pIndexMenu,
715 UINT iIdCmdFirst,
716 UINT iIdCmdLast,
717 UINT uFlags)
718{
720 MENUITEMINFOW mii = { sizeof(mii) };
721 WCHAR wszDispVerb[80]; // The limit on XP. If the friendly string is longer, it falls back to the verb key.
722 UINT fState, idVerbRes;
723 UINT cIds = 0, indexFirst = *pIndexMenu, indexDefault;
724 int iDefVerbIndex = -1;
725
727 mii.fType = MFT_STRING;
728
729 POSITION it = m_StaticEntries.GetHeadPosition();
730 bool first = true;
731 while (it != NULL)
732 {
734 BOOL forceFirstPos = FALSE;
735 bool hide = false;
736
737 fState = MFS_ENABLED;
738
739 /* set first entry as default */
740 if (first)
741 {
742 fState |= MFS_DEFAULT;
743 first = false;
744 }
745
746 if (info.Verb.CompareNoCase(L"open") == 0)
747 {
748 idVerbRes = IDS_OPEN_VERB; // TODO: This string should include '&'
749 fState |= MFS_DEFAULT; /* override default when open verb is found */
750 forceFirstPos++;
751 }
752 else if (info.Verb.CompareNoCase(L"explore") == 0)
753 {
754 idVerbRes = IDS_EXPLORE_VERB; // TODO: This string should include '&'
755 if (uFlags & CMF_EXPLORE)
756 {
757 fState |= MFS_DEFAULT;
758 forceFirstPos++;
759 }
760 }
761 else if (info.Verb.CompareNoCase(L"printto") == 0)
762 hide = true;
763 else
764 idVerbRes = 0;
765
766 /* By default use verb for menu item name */
767 mii.dwTypeData = (LPWSTR)info.Verb.GetString();
768
769 WCHAR wszKey[sizeof("shell\\") + MAX_VERB];
770 HRESULT hr = StringCbPrintfW(wszKey, sizeof(wszKey), L"shell\\%s", info.Verb.GetString());
772 hide = true;
773
774 UINT cmdFlags = 0;
775 HKEY hkVerb;
776 if (RegOpenKeyExW(info.hkClass, wszKey, 0, KEY_READ, &hkVerb) == ERROR_SUCCESS)
777 {
778 if (!(uFlags & CMF_OPTIMIZEFORINVOKE))
779 {
780 DWORD cbVerb = sizeof(wszDispVerb);
781 LONG res = RegLoadMUIStringW(hkVerb, L"MUIVerb", wszDispVerb, cbVerb, NULL, 0, NULL);
782 if (res || !*wszDispVerb)
783 res = RegLoadMUIStringW(hkVerb, NULL, wszDispVerb, cbVerb, NULL, 0, NULL);
784
785 if ((res == ERROR_SUCCESS && *wszDispVerb) ||
786 (idVerbRes && LoadStringW(shell32_hInstance, idVerbRes, wszDispVerb, _countof(wszDispVerb))) ||
787 SUCCEEDED(GetFriendlyVerb(info.Verb, wszDispVerb, _countof(wszDispVerb))))
788 {
789 mii.dwTypeData = wszDispVerb;
790 }
791 }
792 }
793 else
794 {
795 hkVerb = NULL;
796 }
797
798 if (hkVerb)
799 {
800 if (!hide && !(uFlags & CMF_EXTENDEDVERBS))
801 hide = RegValueExists(hkVerb, L"Extended");
802
803 if (!hide)
804 hide = RegValueExists(hkVerb, L"ProgrammaticAccessOnly");
805
806 if (!hide && !(uFlags & CMF_DISABLEDVERBS))
807 hide = RegValueExists(hkVerb, L"LegacyDisable");
808
809 if (DWORD dwRest = (hide ? 0 : RegGetDword(hkVerb, NULL, L"SuppressionPolicy", 0)))
810 hide = SHRestricted((RESTRICTIONS)dwRest);
811
812 if (RegValueExists(hkVerb, L"NeverDefault"))
813 fState &= ~MFS_DEFAULT;
814
815 if (RegValueExists(hkVerb, L"SeparatorBefore"))
816 cmdFlags |= ECF_SEPARATORBEFORE;
817 if (RegValueExists(hkVerb, L"SeparatorAfter"))
818 cmdFlags |= ECF_SEPARATORAFTER;
819
820 RegCloseKey(hkVerb);
821 }
822
823 if (((uFlags & CMF_NODEFAULT) && ntver >= _WIN32_WINNT_VISTA) ||
824 ((uFlags & CMF_DONOTPICKDEFAULT) && ntver >= _WIN32_WINNT_WIN7))
825 {
826 fState &= ~MFS_DEFAULT;
827 }
828
829 if (!hide)
830 {
831 if (cmdFlags & ECF_SEPARATORBEFORE)
832 {
833 if (InsertMenuItemAt(hMenu, *pIndexMenu, MF_SEPARATOR))
834 (*pIndexMenu)++;
835 }
836
837 UINT pos = *pIndexMenu;
838 int verbIndex = hkVerb ? FindVerbInDefaultVerbList(m_DefVerbs, info.Verb) : -1;
839 if (verbIndex >= 0)
840 {
841 if (verbIndex < iDefVerbIndex || iDefVerbIndex < 0)
842 {
843 iDefVerbIndex = verbIndex;
844 fState |= MFS_DEFAULT;
845 forceFirstPos = TRUE;
846 }
847 else
848 {
849 fState &= ~MFS_DEFAULT; // We have already set a better default
850 pos = indexDefault;
851 }
852 }
853 else if (iDefVerbIndex >= 0)
854 {
855 fState &= ~MFS_DEFAULT; // We have already set the default
856 if (forceFirstPos)
857 pos = indexDefault;
858 forceFirstPos = FALSE;
859 }
860
861 mii.fState = fState;
862 mii.wID = iIdCmdFirst + cIds;
863 if (InsertMenuItemW(hMenu, forceFirstPos ? indexFirst : pos, TRUE, &mii))
864 (*pIndexMenu)++;
865
866 if (cmdFlags & ECF_SEPARATORAFTER)
867 {
868 if (InsertMenuItemAt(hMenu, *pIndexMenu, MF_SEPARATOR))
869 (*pIndexMenu)++;
870 }
871
872 if (fState & MFS_DEFAULT)
873 indexDefault = *pIndexMenu; // This is where we want to insert "high priority" verbs
874 }
875 cIds++; // Always increment the id because it acts as the index into m_StaticEntries
876
877 if (mii.wID >= iIdCmdLast)
878 break;
879 }
880
881 return cIds;
882}
883
885 HMENU hMenu,
886 UINT indexMenu,
887 BOOL fByPosition,
888 UINT wID,
889 UINT fType,
890 LPCWSTR dwTypeData,
891 UINT fState)
892{
893 MENUITEMINFOW mii;
894 WCHAR wszText[100];
895
896 ZeroMemory(&mii, sizeof(mii));
897 mii.cbSize = sizeof(mii);
898 if (fType == MFT_SEPARATOR)
899 mii.fMask = MIIM_ID | MIIM_TYPE;
900 else if (fType == MFT_STRING)
901 {
903 if (IS_INTRESOURCE(dwTypeData))
904 {
905 if (LoadStringW(shell32_hInstance, LOWORD((ULONG_PTR)dwTypeData), wszText, _countof(wszText)))
906 mii.dwTypeData = wszText;
907 else
908 {
909 ERR("failed to load string %p\n", dwTypeData);
910 return FALSE;
911 }
912 }
913 else
914 mii.dwTypeData = (LPWSTR)dwTypeData;
915 mii.fState = fState;
916 }
917
918 mii.wID = wID;
919 mii.fType = fType;
920 return InsertMenuItemW(hMenu, indexMenu, fByPosition, &mii);
921}
922
923void
925{
926 // Are we allowed to pick a default?
927 if ((uFlags & CMF_NODEFAULT) ||
928 ((uFlags & CMF_DONOTPICKDEFAULT) && RosGetProcessEffectiveVersion() >= _WIN32_WINNT_WIN7))
929 {
930 return;
931 }
932
933 // Do we already have a default?
934 if ((int)GetMenuDefaultItem(hMenu, MF_BYPOSITION, 0) != -1)
935 return;
936
937 // Does the view want to pick one?
938 INT_PTR forceDfm = 0;
939 if (SUCCEEDED(_DoCallback(DFM_GETDEFSTATICID, 0, &forceDfm)) && forceDfm)
940 {
941 for (UINT i = 0; i < _countof(g_StaticInvokeCmdMap); ++i)
942 {
943 UINT menuItemId = g_StaticInvokeCmdMap[i].IntVerb + DfltOffset - DCM_FCIDM_SHVIEW_OFFSET;
944 if (g_StaticInvokeCmdMap[i].DfmCmd == forceDfm &&
945 SetMenuDefaultItem(hMenu, menuItemId, MF_BYCOMMAND))
946 {
947 return;
948 }
949 }
950 }
951
952 // Don't want to pick something like cut or delete as the default but
953 // a static or dynamic verb is a good default.
955 SetMenuDefaultItem(hMenu, idCmdFirst, MF_BYCOMMAND);
956}
957
959WINAPI
961 HMENU hMenu,
962 UINT IndexMenu,
963 UINT idCmdFirst,
964 UINT idCmdLast,
965 UINT uFlags)
966{
967 HRESULT hr;
968 UINT idCmdNext = m_iIdQCMFirst = idCmdFirst;
969 UINT cIds = 0;
970
971 TRACE("BuildShellItemContextMenu entered\n");
972
973 /* Load static verbs and shell extensions from registry */
974 for (UINT i = 0; i < m_cKeys && !(uFlags & CMF_NOVERBS); i++)
975 {
978 }
979
980 /* Add static context menu handlers */
981 cIds = AddStaticContextMenusToMenu(hMenu, &IndexMenu, idCmdFirst, idCmdLast, uFlags);
982 m_iIdSCMFirst = 0; // FIXME: This should be = idCmdFirst?
983 m_iIdSCMLast = cIds;
984 idCmdNext = idCmdFirst + cIds;
985
986 /* Add dynamic context menu handlers */
987 cIds += AddShellExtensionsToMenu(hMenu, &IndexMenu, idCmdNext, idCmdLast, uFlags);
989 m_iIdSHELast = cIds;
990 idCmdNext = idCmdFirst + cIds;
991 TRACE("SH_LoadContextMenuHandlers first %x last %x\n", m_iIdSHEFirst, m_iIdSHELast);
992
993 /* Now let the callback add its own items */
994 QCMINFO qcminfo = {hMenu, IndexMenu, idCmdNext, idCmdLast, NULL};
996 {
997 UINT added = qcminfo.idCmdFirst - idCmdNext;
998 cIds += added;
999 IndexMenu += added;
1001 m_iIdCBLast = cIds;
1002 idCmdNext = idCmdFirst + cIds;
1003 }
1004
1005 //TODO: DFM_MERGECONTEXTMENU_BOTTOM
1006
1007 UINT idDefaultOffset = 0;
1008 BOOL isBackgroundMenu = !m_cidl;
1009 if (!(uFlags & CMF_VERBSONLY) && !isBackgroundMenu)
1010 {
1011 /* Get the attributes of the items */
1012 SFGAOF rfg = SFGAO_BROWSABLE | SFGAO_CANCOPY | SFGAO_CANLINK | SFGAO_CANMOVE | SFGAO_CANDELETE | SFGAO_CANRENAME | SFGAO_HASPROPSHEET | SFGAO_FILESYSTEM | SFGAO_FOLDER;
1013 hr = m_psf->GetAttributesOf(m_cidl, m_apidl, &rfg);
1015 return MAKE_HRESULT(SEVERITY_SUCCESS, 0, cIds);
1016
1017 /* Add the default part of the menu */
1018 HMENU hmenuDefault = LoadMenuW(_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCEW(MENU_SHV_FILE));
1019
1020 /* Remove uneeded entries */
1021 if (!(rfg & SFGAO_CANMOVE))
1022 DeleteMenu(hmenuDefault, IDM_CUT, MF_BYCOMMAND);
1023 if (!(rfg & SFGAO_CANCOPY))
1024 DeleteMenu(hmenuDefault, IDM_COPY, MF_BYCOMMAND);
1025 if (!((rfg & SFGAO_FILESYSTEM) && HasClipboardData()))
1026 DeleteMenu(hmenuDefault, IDM_INSERT, MF_BYCOMMAND);
1027 if (!(rfg & SFGAO_CANLINK))
1028 DeleteMenu(hmenuDefault, IDM_CREATELINK, MF_BYCOMMAND);
1029 if (!(rfg & SFGAO_CANDELETE))
1030 DeleteMenu(hmenuDefault, IDM_DELETE, MF_BYCOMMAND);
1031 if (!(rfg & SFGAO_CANRENAME) || !(uFlags & CMF_CANRENAME))
1032 DeleteMenu(hmenuDefault, IDM_RENAME, MF_BYCOMMAND);
1033 if (!(rfg & SFGAO_HASPROPSHEET))
1034 DeleteMenu(hmenuDefault, IDM_PROPERTIES, MF_BYCOMMAND);
1035
1036 idDefaultOffset = idCmdNext;
1037 UINT idMax = Shell_MergeMenus(hMenu, GetSubMenu(hmenuDefault, 0), IndexMenu, idCmdNext, idCmdLast, 0);
1038 m_iIdDfltFirst = cIds;
1039 cIds += idMax - idCmdNext;
1040 m_iIdDfltLast = cIds;
1041
1042 DestroyMenu(hmenuDefault);
1043 }
1044
1045 TryPickDefault(hMenu, idCmdFirst, idDefaultOffset, uFlags);
1046
1047 // TODO: DFM_MERGECONTEXTMENU_TOP
1048
1049 // TODO: Remove duplicate verbs. This will be easier when the static items handling
1050 // has been moved to CLSID_ShellFileDefExt so we only have to deal with ShellEx.
1051 // This is a Windows XP+ feature. On an unknown file type, Windows 2000 will
1052 // display both "Open" (openas from Unknown) and "Open with..." (openas from *).
1053
1054 return MAKE_HRESULT(SEVERITY_SUCCESS, 0, cIds);
1055}
1056
1058{
1059 HRESULT hr;
1060
1062 hr = OleGetClipboard(&pda);
1064 return hr;
1065
1066 FORMATETC formatetc2;
1067 STGMEDIUM medium2;
1069
1070 DWORD dwKey= 0;
1071
1072 if (SUCCEEDED(pda->GetData(&formatetc2, &medium2)))
1073 {
1074 DWORD * pdwFlag = (DWORD*)GlobalLock(medium2.hGlobal);
1075 if (pdwFlag)
1076 {
1077 if (*pdwFlag == DROPEFFECT_COPY)
1078 dwKey = MK_CONTROL;
1079 else
1080 dwKey = MK_SHIFT;
1081 }
1082 else
1083 {
1084 ERR("No drop effect obtained\n");
1085 }
1086 GlobalUnlock(medium2.hGlobal);
1087 }
1088
1089 if (bLink)
1090 {
1091 dwKey = MK_CONTROL|MK_SHIFT;
1092 }
1093
1095 if (m_cidl)
1096 hr = m_psf->GetUIObjectOf(NULL, 1, &m_apidl[0], IID_NULL_PPV_ARG(IDropTarget, &pdrop));
1097 else
1098 hr = m_psf->CreateViewObject(NULL, IID_PPV_ARG(IDropTarget, &pdrop));
1099
1101 return hr;
1102
1103 SHSimulateDrop(pdrop, pda, dwKey, NULL, NULL);
1104
1105 TRACE("CP result %x\n", hr);
1106 return S_OK;
1107}
1108
1109HRESULT
1111{
1113 return E_FAIL;
1114}
1115
1117{
1118 if (!m_cidl || !m_pDataObj)
1119 return E_FAIL;
1120
1122 HRESULT hr = m_psf->CreateViewObject(NULL, IID_PPV_ARG(IDropTarget, &pDT));
1124 return hr;
1125
1127
1128 return S_OK;
1129}
1130
1132{
1133 if (!m_cidl || !m_pDataObj)
1134 return E_FAIL;
1135
1139 return hr;
1140
1141 DWORD grfKeyState = (lpcmi->fMask & CMIC_MASK_SHIFT_DOWN) ? MK_SHIFT : 0;
1142 SHSimulateDrop(pDT, m_pDataObj, grfKeyState, NULL, NULL);
1143
1144 return S_OK;
1145}
1146
1148{
1149 if (!m_cidl || !m_pDataObj)
1150 return E_FAIL;
1151
1152 FORMATETC formatetc;
1154 STGMEDIUM medium = {0};
1155 medium.tymed = TYMED_HGLOBAL;
1156 medium.hGlobal = GlobalAlloc(GHND, sizeof(DWORD));
1157 DWORD* pdwFlag = (DWORD*)GlobalLock(medium.hGlobal);
1158 if (pdwFlag)
1159 *pdwFlag = bCopy ? DROPEFFECT_COPY : DROPEFFECT_MOVE;
1160 GlobalUnlock(medium.hGlobal);
1161 m_pDataObj->SetData(&formatetc, &medium, TRUE);
1162
1164 if (SUCCEEDED(IUnknown_QueryService(m_site, SID_SFolderView, IID_PPV_ARG(IShellFolderView, &psfv))))
1165 psfv->SetPoints(m_pDataObj);
1166
1169 return hr;
1170
1171 if (psfv)
1172 psfv->SetClipboard(!bCopy);
1173 return S_OK;
1174}
1175
1177{
1179 HRESULT hr;
1180
1181 if (!m_site || !m_cidl)
1182 return E_FAIL;
1183
1184 /* Get a pointer to the shell browser */
1187 return hr;
1188
1190 hr = psb->QueryActiveShellView(&lpSV);
1192 return hr;
1193
1194 SVSIF selFlags = SVSI_DESELECTOTHERS | SVSI_EDIT | SVSI_ENSUREVISIBLE | SVSI_FOCUSED | SVSI_SELECT;
1195 hr = lpSV->SelectItem(m_apidl[0], selFlags);
1197 return hr;
1198
1199 return S_OK;
1200}
1201
1202HRESULT
1205{
1207
1208 // We are asked to run the default property sheet
1209 if (hr == S_FALSE)
1210 {
1212 }
1213
1214 return hr;
1215}
1216
1217HRESULT
1219{
1220 ERR("TODO: Undo\n");
1221 return E_NOTIMPL;
1222}
1223
1224HRESULT
1226{
1227 HRESULT hr = E_FAIL;
1228 if (!m_pDataObj)
1229 {
1230 ERR("m_pDataObj is NULL\n");
1231 return hr;
1232 }
1233
1234 CComPtr<IContextMenu> pContextMenu;
1235 if (bCopy)
1236 hr = SHCoCreateInstance(NULL, &CLSID_CopyToMenu, NULL,
1237 IID_PPV_ARG(IContextMenu, &pContextMenu));
1238 else
1239 hr = SHCoCreateInstance(NULL, &CLSID_MoveToMenu, NULL,
1240 IID_PPV_ARG(IContextMenu, &pContextMenu));
1242 return hr;
1243
1245 hr = pContextMenu->QueryInterface(IID_PPV_ARG(IShellExtInit, &pInit));
1247 return hr;
1248
1249 hr = pInit->Initialize(m_pidlFolder, m_pDataObj, NULL);
1251 return hr;
1252
1253 if (bCopy)
1254 lpici->lpVerb = "copyto";
1255 else
1256 lpici->lpVerb = "moveto";
1257
1258 return pContextMenu->InvokeCommand((LPCMINVOKECOMMANDINFO)lpici);
1259}
1260
1261// This code is taken from CNewMenu and should be shared between the 2 classes
1262HRESULT
1265{
1266 WCHAR wszPath[MAX_PATH];
1267 WCHAR wszName[MAX_PATH];
1268 WCHAR wszNewFolder[25];
1269 HRESULT hr;
1270
1271 /* Get folder path */
1274 return hr;
1275
1276 if (!LoadStringW(shell32_hInstance, IDS_NEWFOLDER, wszNewFolder, _countof(wszNewFolder)))
1277 return E_FAIL;
1278
1279 /* Create the name of the new directory */
1280 if (!PathYetAnotherMakeUniqueName(wszName, wszPath, NULL, wszNewFolder))
1281 return E_FAIL;
1282
1283 /* Create the new directory and show the appropriate dialog in case of error */
1284 if (SHCreateDirectory(lpici->hwnd, wszName) != ERROR_SUCCESS)
1285 return E_FAIL;
1286
1287 /* Show and select the new item in the def view */
1288 LPITEMIDLIST pidl;
1289 PITEMID_CHILD pidlNewItem;
1291
1292 /* Notify the view object about the new item */
1294
1295 if (!m_site)
1296 return S_OK;
1297
1298 /* Get a pointer to the shell view */
1299 hr = IUnknown_QueryService(m_site, SID_SFolderView, IID_PPV_ARG(IShellView, &psv));
1301 return S_OK;
1302
1303 /* Attempt to get the pidl of the new item */
1304 hr = SHILCreateFromPathW(wszName, &pidl, NULL);
1306 return hr;
1307
1308 pidlNewItem = ILFindLastID(pidl);
1309
1310 hr = psv->SelectItem(pidlNewItem, SVSI_DESELECTOTHERS | SVSI_EDIT | SVSI_ENSUREVISIBLE |
1311 SVSI_FOCUSED | SVSI_SELECT);
1313 return hr;
1314
1315 SHFree(pidl);
1316
1317 return S_OK;
1318}
1319
1321{
1322 POSITION it = m_DynamicEntries.GetHeadPosition();
1323 while (it != NULL)
1324 {
1326
1327 if (idCmd >= info.iIdCmdFirst + info.NumIds)
1328 continue;
1329
1330 if (idCmd < info.iIdCmdFirst || idCmd > info.iIdCmdFirst + info.NumIds)
1331 return NULL;
1332
1333 return &info;
1334 }
1335
1336 return NULL;
1337}
1338
1339BOOL
1341{
1342 WCHAR UnicodeStr[MAX_VERB];
1343
1344 /* Loop through all the static verbs looking for a match */
1345 for (UINT i = 0; i < _countof(g_StaticInvokeCmdMap); i++)
1346 {
1347 /* We can match both ANSI and unicode strings */
1348 if (IsUnicode)
1349 {
1350 /* The static verbs are ANSI, get a unicode version before doing the compare */
1351 SHAnsiToUnicode(g_StaticInvokeCmdMap[i].szStringVerb, UnicodeStr, MAX_VERB);
1352 if (!_wcsicmp(UnicodeStr, (LPWSTR)Verb))
1353 {
1354 /* Return the Corresponding Id */
1355 *idCmd = g_StaticInvokeCmdMap[i].IntVerb;
1356 return TRUE;
1357 }
1358 }
1359 else
1360 {
1361 if (!_stricmp(g_StaticInvokeCmdMap[i].szStringVerb, (LPSTR)Verb))
1362 {
1363 *idCmd = g_StaticInvokeCmdMap[i].IntVerb;
1364 return TRUE;
1365 }
1366 }
1367 }
1368
1369 for (POSITION it = m_DynamicEntries.GetHeadPosition(); it != NULL;)
1370 {
1372 if (!entry.NumIds)
1373 continue;
1374 HRESULT hr = ::MapVerbToCmdId(Verb, IsUnicode, entry.pCM, 0, entry.NumIds - 1);
1375 if (SUCCEEDED(hr))
1376 {
1377 *idCmd = m_iIdSHEFirst + entry.iIdCmdFirst + hr;
1378 return TRUE;
1379 }
1380 }
1381 return FALSE;
1382}
1383
1384HRESULT
1387{
1388 TRACE("verb %p first %x last %x\n", lpcmi->lpVerb, m_iIdSHEFirst, m_iIdSHELast);
1389
1390 UINT idCmd = LOWORD(lpcmi->lpVerb);
1392 if (!pEntry)
1393 return E_FAIL;
1394
1395 /* invoke the dynamic context menu */
1396 lpcmi->lpVerb = MAKEINTRESOURCEA(idCmd - pEntry->iIdCmdFirst);
1397 return pEntry->pCM->InvokeCommand((LPCMINVOKECOMMANDINFO)lpcmi);
1398}
1399
1400DWORD
1402{
1404 HWND hwndTree;
1405 LPCWSTR FlagsName;
1406 WCHAR wszKey[sizeof("shell\\") + MAX_VERB];
1407 HRESULT hr;
1408
1409 if (!m_site)
1410 return 0;
1411
1412 /* Get a pointer to the shell browser */
1414 if (FAILED(hr))
1415 return 0;
1416
1417 /* See if we are in Explore or Browse mode. If the browser's tree is present, we are in Explore mode.*/
1418 if (SUCCEEDED(psb->GetControlWindow(FCW_TREE, &hwndTree)) && hwndTree)
1419 FlagsName = L"ExplorerFlags";
1420 else
1421 FlagsName = L"BrowserFlags";
1422
1424 if (SUCCEEDED(psb->QueryInterface(IID_PPV_ARG(ICommDlgBrowser, &pcdb))))
1425 {
1426 if (LOBYTE(GetVersion()) < 6 || FlagsName[0] == 'E')
1427 return 0; // Don't browse in-place
1428 }
1429
1430 /* Try to get the flag from the verb */
1431 hr = StringCbPrintfW(wszKey, sizeof(wszKey), L"shell\\%s", pEntry->Verb.GetString());
1433 return 0;
1434 return RegGetDword(pEntry->hkClass, wszKey, FlagsName, 0);
1435}
1436
1437HRESULT
1440{
1442 HRESULT hr;
1443
1444 if (!m_site)
1445 return E_FAIL;
1446
1447 /* Get a pointer to the shell browser */
1449 if (FAILED(hr))
1450 return hr;
1451
1452 PIDLIST_ABSOLUTE pidl;
1453 hr = SHILCombine(m_pidlFolder, pidlChild, &pidl);
1455 return hr;
1456
1457 hr = psb->BrowseObject(pidl, wFlags & ~SBSP_RELATIVE);
1458 ILFree(pidl);
1459 return hr;
1460}
1461
1462HRESULT
1464{
1465 const BOOL unicode = IsUnicode(*lpcmi);
1466
1467 LPITEMIDLIST pidlFull = ILCombine(m_pidlFolder, pidl);
1468 if (pidlFull == NULL)
1469 {
1470 return E_FAIL;
1471 }
1472
1473 WCHAR wszPath[MAX_PATH];
1474 BOOL bHasPath = SHGetPathFromIDListW(pidlFull, wszPath);
1475
1476 WCHAR wszDir[MAX_PATH];
1477
1478 SHELLEXECUTEINFOW sei = { sizeof(sei) };
1479 sei.fMask = SEE_MASK_CLASSKEY | SEE_MASK_IDLIST | (CmicFlagsToSeeFlags(lpcmi->fMask) & ~SEE_MASK_INVOKEIDLIST);
1480 sei.hwnd = lpcmi->hwnd;
1481 sei.nShow = lpcmi->nShow;
1482 sei.lpVerb = pEntry->Verb;
1483 sei.lpIDList = pidlFull;
1484 sei.hkeyClass = pEntry->hkClass;
1485 sei.dwHotKey = lpcmi->dwHotKey;
1486 sei.hIcon = lpcmi->hIcon;
1487 sei.lpDirectory = wszDir;
1488
1489 if (unicode && !StrIsNullOrEmpty(lpcmi->lpDirectoryW))
1490 {
1491 sei.lpDirectory = lpcmi->lpDirectoryW;
1492 }
1493 else if (bHasPath)
1494 {
1495 wcscpy(wszDir, wszPath);
1496 PathRemoveFileSpec(wszDir);
1497 }
1498 else
1499 {
1500 if (!SHGetPathFromIDListW(m_pidlFolder, wszDir))
1501 *wszDir = UNICODE_NULL;
1502 }
1503
1504 if (bHasPath)
1505 sei.lpFile = wszPath;
1506
1507 CComHeapPtr<WCHAR> pszParamsW;
1508 if (unicode && !StrIsNullOrEmpty(lpcmi->lpParametersW))
1509 sei.lpParameters = lpcmi->lpParametersW;
1510 else if (!StrIsNullOrEmpty(lpcmi->lpParameters) && __SHCloneStrAtoW(&pszParamsW, lpcmi->lpParameters))
1511 sei.lpParameters = pszParamsW;
1512
1513 if (!sei.lpClass && (lpcmi->fMask & (CMIC_MASK_HASLINKNAME | CMIC_MASK_HASTITLE)) && unicode)
1514 sei.lpClass = lpcmi->lpTitleW; // Forward .lnk path from CShellLink::DoOpen (for consrv STARTF_TITLEISLINKNAME)
1515
1517 ILFree(pidlFull);
1518 return hr;
1519}
1520
1521HRESULT
1524{
1525 INT iCmd = LOWORD(lpcmi->lpVerb);
1526 HRESULT hr;
1527 UINT i;
1528
1529 POSITION it = m_StaticEntries.FindIndex(iCmd);
1530
1531 if (it == NULL)
1532 return E_INVALIDARG;
1533
1535
1536 CRegKey VerbKey;
1537 WCHAR VerbKeyPath[sizeof("shell\\") + MAX_VERB];
1538 hr = StringCbPrintfW(VerbKeyPath, sizeof(VerbKeyPath), L"shell\\%s", pEntry->Verb.GetString());
1539 if (SUCCEEDED(hr) && m_pDataObj &&
1540 VerbKey.Open(pEntry->hkClass, VerbKeyPath, KEY_READ) == ERROR_SUCCESS)
1541 {
1542 CLSID clsid;
1543
1544 DWORD KeyState = 0;
1545 if (lpcmi->fMask & CMIC_MASK_SHIFT_DOWN)
1546 KeyState |= MK_SHIFT;
1547 if (lpcmi->fMask & CMIC_MASK_CONTROL_DOWN)
1548 KeyState |= MK_CONTROL;
1549
1550 POINTL *pPtl = NULL;
1551 C_ASSERT(sizeof(POINT) == sizeof(POINTL));
1552 if (lpcmi->fMask & CMIC_MASK_PTINVOKE)
1553 pPtl = (POINTL*)&lpcmi->ptInvoke;
1554
1556 hr = SHELL_GetRegCLSID(VerbKey, L"command", L"DelegateExecute", clsid);
1557 if (SUCCEEDED(hr))
1558 hr = CoCreateInstance(clsid, NULL, CLSCTX_ALL, IID_PPV_ARG(IExecuteCommand, &pEC));
1559 if (SUCCEEDED(hr))
1560 {
1563 return InvokeIExecuteCommandWithDataObject(pEC, pEntry->Verb.GetString(), pPB, m_pDataObj,
1564 lpcmi, static_cast<IContextMenu*>(this));
1565 }
1566
1568 hr = SHELL_GetRegCLSID(VerbKey, L"DropTarget", L"CLSID", clsid);
1569 if (SUCCEEDED(hr))
1570 hr = CoCreateInstance(clsid, NULL, CLSCTX_ALL, IID_PPV_ARG(IDropTarget, &pDT));
1571 if (SUCCEEDED(hr))
1572 {
1573 CScopedSetObjectWithSite site(pDT, static_cast<IContextMenu*>(this));
1576 IUnknown_InitializeCommand(pDT, pEntry->Verb.GetString(), pPB);
1577 hr = SHSimulateDrop(pDT, m_pDataObj, KeyState, pPtl, NULL);
1578 return hr;
1579 }
1580 }
1581
1582 /* Get the browse flags to see if we need to browse */
1584
1585 for (i=0; i < m_cidl; i++)
1586 {
1587 /* Check if we need to browse */
1588 if (wFlags)
1589 {
1590 hr = TryToBrowse(lpcmi, m_apidl[i], wFlags);
1591 if (SUCCEEDED(hr))
1592 {
1593 /* In WinXP if we have browsed, we don't open any more folders.
1594 * In Win7 we browse to the first folder we find and
1595 * open new windows for each of the rest of the folders */
1597 if (ntver >= _WIN32_WINNT_VISTA)
1598 wFlags = 0; // FIXME: = SBSP_NEWBROWSER | (wFlags & ~SBSP_SAMEBROWSER);
1599 else
1600 i = m_cidl;
1601
1602 continue;
1603 }
1604 }
1605
1606 InvokePidl(lpcmi, m_apidl[i], pEntry);
1607 }
1608
1609 return S_OK;
1610}
1611
1612HRESULT
1614 LPCMINVOKECOMMANDINFOEX lpcmi, WPARAM CmdId)
1615{
1616 BOOL Unicode = IsUnicode(*lpcmi);
1617 WCHAR lParamBuf[MAX_PATH];
1618 LPARAM lParam = 0;
1619
1620 if (Unicode && lpcmi->lpParametersW)
1621 lParam = (LPARAM)lpcmi->lpParametersW;
1622 else if (lpcmi->lpParameters)
1623 lParam = SHAnsiToUnicode(lpcmi->lpParameters, lParamBuf, _countof(lParamBuf)) ? (LPARAM)lParamBuf : 0;
1624
1625 HRESULT hr;
1626#if 0 // TODO: Try DFM_INVOKECOMMANDEX first.
1627 DFMICS dfmics = { sizeof(DFMICS), lpcmi->fMask, lParam, m_iIdSCMFirst?, m_iIdDfltLast?, (LPCMINVOKECOMMANDINFO)lpcmi, m_site };
1628 hr = _DoCallback(DFM_INVOKECOMMANDEX, CmdId, &dfmics);
1629 if (hr == E_NOTIMPL)
1630#endif
1631 hr = _DoCallback(DFM_INVOKECOMMAND, CmdId, (void*)lParam);
1632 return hr;
1633}
1634
1635HRESULT
1636WINAPI
1639{
1640 CMINVOKECOMMANDINFOEX LocalInvokeInfo = {};
1642 UINT CmdId;
1643
1644 /* Take a local copy of the fixed members of the
1645 struct as we might need to modify the verb */
1646 memcpy(&LocalInvokeInfo, lpcmi, min(sizeof(LocalInvokeInfo), lpcmi->cbSize));
1647
1648 /* Check if this is a string verb */
1649 if (!IS_INTRESOURCE(LocalInvokeInfo.lpVerb))
1650 {
1651 /* Get the ID which corresponds to this verb, and update our local copy */
1652 if (MapVerbToCmdId((LPVOID)LocalInvokeInfo.lpVerb, &CmdId, FALSE))
1653 LocalInvokeInfo.lpVerb = MAKEINTRESOURCEA(CmdId);
1654 else
1655 return E_INVALIDARG;
1656 }
1657 CmdId = LOWORD(LocalInvokeInfo.lpVerb);
1658
1659 if (!m_DynamicEntries.IsEmpty() && CmdId >= m_iIdSHEFirst && CmdId < m_iIdSHELast)
1660 {
1661 LocalInvokeInfo.lpVerb -= m_iIdSHEFirst;
1662 Result = InvokeShellExt(&LocalInvokeInfo);
1663 return Result;
1664 }
1665
1666 if (!m_StaticEntries.IsEmpty() && CmdId >= m_iIdSCMFirst && CmdId < m_iIdSCMLast)
1667 {
1668 LocalInvokeInfo.lpVerb -= m_iIdSCMFirst;
1669 Result = InvokeRegVerb(&LocalInvokeInfo);
1670 // TODO: if (FAILED(Result) && !(lpcmi->fMask & CMIC_MASK_FLAG_NO_UI)) SHELL_ErrorBox(m_pSite, Result);
1671 return Result;
1672 }
1673
1674 if (m_iIdCBFirst != m_iIdCBLast && CmdId >= m_iIdCBFirst && CmdId < m_iIdCBLast)
1675 {
1676 Result = _DoInvokeCommandCallback(&LocalInvokeInfo, CmdId - m_iIdCBFirst);
1677 return Result;
1678 }
1679
1680 if (m_iIdDfltFirst != m_iIdDfltLast && CmdId >= m_iIdDfltFirst && CmdId < m_iIdDfltLast)
1681 {
1682 CmdId -= m_iIdDfltFirst;
1683 /* See the definitions of IDM_CUT and co to see how this works */
1684 CmdId += DCM_FCIDM_SHVIEW_OFFSET;
1685 }
1686
1687 if (LocalInvokeInfo.cbSize >= sizeof(CMINVOKECOMMANDINFOEX) && (LocalInvokeInfo.fMask & CMIC_MASK_PTINVOKE))
1688 {
1689 if (m_pDataObj && FAILED_UNEXPECTEDLY(DataObject_SetOffset(m_pDataObj, &LocalInvokeInfo.ptInvoke)))
1690 {
1691 ERR("Unable to add OFFSET to DataObject!\n");
1692 }
1693 }
1694
1695 /* Check if this is a Id */
1696 switch (CmdId)
1697 {
1699 Result = DoPaste(&LocalInvokeInfo, FALSE);
1700 break;
1702 Result = DoPaste(&LocalInvokeInfo, TRUE);
1703 break;
1704 case FCIDM_SHVIEW_OPEN:
1706 Result = DoOpenOrExplore(&LocalInvokeInfo);
1707 break;
1708 case FCIDM_SHVIEW_COPY:
1709 case FCIDM_SHVIEW_CUT:
1710 Result = DoCopyOrCut(&LocalInvokeInfo, CmdId == FCIDM_SHVIEW_COPY);
1711 break;
1713 Result = DoCreateLink(&LocalInvokeInfo);
1714 break;
1716 Result = DoDelete(&LocalInvokeInfo);
1717 break;
1719 Result = DoRename(&LocalInvokeInfo);
1720 break;
1722 Result = DoProperties(&LocalInvokeInfo);
1723 break;
1725 Result = DoCreateNewFolder(&LocalInvokeInfo);
1726 break;
1728 Result = DoCopyToMoveToFolder(&LocalInvokeInfo, TRUE);
1729 break;
1731 Result = DoCopyToMoveToFolder(&LocalInvokeInfo, FALSE);
1732 break;
1733 case FCIDM_SHVIEW_UNDO:
1734 Result = DoUndo(&LocalInvokeInfo);
1735 break;
1736 default:
1738 ERR("Unhandled Verb %xl\n", LOWORD(LocalInvokeInfo.lpVerb));
1739 break;
1740 }
1741
1742 return Result;
1743}
1744
1745HRESULT
1746WINAPI
1748 UINT_PTR idCommand,
1749 UINT uFlags,
1751 LPSTR lpszName,
1752 UINT uMaxNameLen)
1753{
1754 /* We don't handle the help text yet */
1755 if (uFlags == GCS_HELPTEXTA ||
1756 uFlags == GCS_HELPTEXTW ||
1757 HIWORD(idCommand) != 0)
1758 {
1759 return E_NOTIMPL;
1760 }
1761
1762 UINT CmdId = LOWORD(idCommand);
1763
1764 if (!m_DynamicEntries.IsEmpty() && CmdId >= m_iIdSHEFirst && CmdId < m_iIdSHELast)
1765 {
1766 idCommand -= m_iIdSHEFirst;
1768 if (!pEntry)
1769 return E_FAIL;
1770
1771 idCommand -= pEntry->iIdCmdFirst;
1772 return pEntry->pCM->GetCommandString(idCommand,
1773 uFlags,
1774 lpReserved,
1775 lpszName,
1776 uMaxNameLen);
1777 }
1778
1779 if (!m_StaticEntries.IsEmpty() && CmdId >= m_iIdSCMFirst && CmdId < m_iIdSCMLast)
1780 {
1781 /* Validation just returns S_OK on a match. The id exists. */
1782 if (uFlags == GCS_VALIDATEA || uFlags == GCS_VALIDATEW)
1783 return S_OK;
1784
1785 CmdId -= m_iIdSCMFirst;
1786
1787 POSITION it = m_StaticEntries.FindIndex(CmdId);
1788
1789 if (it == NULL)
1790 return E_INVALIDARG;
1791
1793
1794 if (uFlags == GCS_VERBW)
1795 return StringCchCopyW((LPWSTR)lpszName, uMaxNameLen, pEntry->Verb);
1796
1797 if (uFlags == GCS_VERBA)
1798 {
1799 if (SHUnicodeToAnsi(pEntry->Verb, lpszName, uMaxNameLen))
1800 return S_OK;
1801 }
1802
1803 return E_INVALIDARG;
1804 }
1805
1806 //FIXME: Should we handle callbacks here?
1807 if (m_iIdDfltFirst != m_iIdDfltLast && CmdId >= m_iIdDfltFirst && CmdId < m_iIdDfltLast)
1808 {
1809 CmdId -= m_iIdDfltFirst;
1810 /* See the definitions of IDM_CUT and co to see how this works */
1811 CmdId += DCM_FCIDM_SHVIEW_OFFSET;
1812 }
1813
1814 /* Loop looking for a matching Id */
1815 for (UINT i = 0; i < _countof(g_StaticInvokeCmdMap); i++)
1816 {
1817 if (g_StaticInvokeCmdMap[i].IntVerb == CmdId)
1818 {
1819 /* Validation just returns S_OK on a match */
1820 if (uFlags == GCS_VALIDATEA || uFlags == GCS_VALIDATEW)
1821 return S_OK;
1822
1823 /* Return a copy of the ANSI verb */
1824 if (uFlags == GCS_VERBA)
1825 return StringCchCopyA(lpszName, uMaxNameLen, g_StaticInvokeCmdMap[i].szStringVerb);
1826
1827 /* Convert the ANSI verb to unicode and return that */
1828 if (uFlags == GCS_VERBW)
1829 {
1830 if (SHAnsiToUnicode(g_StaticInvokeCmdMap[i].szStringVerb, (LPWSTR)lpszName, uMaxNameLen))
1831 return S_OK;
1832 }
1833 }
1834 }
1835
1836 return E_INVALIDARG;
1837}
1838
1839HRESULT
1840WINAPI
1842 UINT uMsg,
1843 WPARAM wParam,
1844 LPARAM lParam)
1845{
1846 return HandleMenuMsg2(uMsg, wParam, lParam, NULL);
1847}
1848
1850{
1851 if (uMsg == WM_DRAWITEM)
1852 {
1853 DRAWITEMSTRUCT* pDrawStruct = reinterpret_cast<DRAWITEMSTRUCT*>(lParam);
1854 *CmdId = pDrawStruct->itemID;
1855 return S_OK;
1856 }
1857 else if (uMsg == WM_MEASUREITEM)
1858 {
1859 MEASUREITEMSTRUCT* pMeasureStruct = reinterpret_cast<MEASUREITEMSTRUCT*>(lParam);
1860 *CmdId = pMeasureStruct->itemID;
1861 return S_OK;
1862 }
1863 return E_FAIL;
1864}
1865
1866HRESULT
1867WINAPI
1869 UINT uMsg,
1870 WPARAM wParam,
1871 LPARAM lParam,
1872 LRESULT *plResult)
1873{
1874 if (!SHELL_IsContextMenuMsg(uMsg))
1875 return E_FAIL;
1876
1877 UINT CmdId;
1878 if (uMsg == WM_INITMENUPOPUP)
1879 {
1880 CmdId = GetMenuItemID((HMENU)wParam, 0);
1881 if (CmdId == ~0ul)
1882 return E_FAIL;
1883 }
1884 else
1885 {
1886 HRESULT hr = SHGetMenuIdFromMenuMsg(uMsg, lParam, &CmdId);
1887 if (FAILED(hr))
1888 return S_FALSE;
1889 }
1890 CmdId -= m_iIdQCMFirst; // Convert from Win32 id to our base
1891
1892 if (CmdId >= m_iIdSHEFirst && CmdId < m_iIdSHELast)
1893 {
1895 return SHForwardContextMenuMsg(pEntry->pCM, uMsg, wParam, lParam, plResult, TRUE);
1896 }
1897 // TODO: _DoCallback(DFM_WM_*, ...)
1898 return E_FAIL;
1899}
1900
1901HRESULT
1902WINAPI
1904{
1905 m_site = pUnkSite;
1906 return S_OK;
1907}
1908
1909HRESULT
1910WINAPI
1912{
1913 if (!m_site)
1914 return E_FAIL;
1915
1916 return m_site->QueryInterface(riid, ppvSite);
1917}
1918
1919static
1920HRESULT
1922{
1923 return ShellObjectCreatorInit<CDefaultContextMenu>(pdcm, lpfn, riid, ppv);
1924}
1925
1926/*************************************************************************
1927 * SHCreateDefaultContextMenu [SHELL32.325] Vista API
1928 *
1929 */
1930
1931HRESULT
1932WINAPI
1934{
1935 HRESULT hr;
1936
1937 if (!ppv)
1938 return E_INVALIDARG;
1939
1942 return hr;
1943
1944 return S_OK;
1945}
1946
1947/*************************************************************************
1948 * CDefFolderMenu_Create2 [SHELL32.701]
1949 *
1950 */
1951
1952HRESULT
1953WINAPI
1955 PCIDLIST_ABSOLUTE pidlFolder,
1956 HWND hwnd,
1957 UINT cidl,
1959 IShellFolder *psf,
1960 LPFNDFMCALLBACK lpfn,
1961 UINT nKeys,
1962 const HKEY *ahkeyClsKeys,
1963 IContextMenu **ppcm)
1964{
1965 DEFCONTEXTMENU dcm;
1966 dcm.hwnd = hwnd;
1967 dcm.pcmcb = NULL;
1968 dcm.pidlFolder = pidlFolder;
1969 dcm.psf = psf;
1970 dcm.cidl = cidl;
1971 dcm.apidl = apidl;
1973 dcm.cKeys = nKeys;
1974 dcm.aKeys = ahkeyClsKeys;
1975
1978 return hr;
1979
1980 return S_OK;
1981}
static const struct _StaticInvokeCommandMap_ g_StaticInvokeCmdMap[]
struct _DynamicShellEntry_ * PDynamicShellEntry
struct _DynamicShellEntry_ DynamicShellEntry
UINT MapVerbToDfmCmd(_In_ LPCSTR verba)
static int FindVerbInDefaultVerbList(LPCWSTR List, LPCWSTR Verb)
static BOOL HasClipboardData()
static HRESULT CDefaultContextMenu_CreateInstance(const DEFCONTEXTMENU *pdcm, LPFNDFMCALLBACK lpfn, REFIID riid, void **ppv)
BOOL WINAPI _InsertMenuItemW(HMENU hMenu, UINT indexMenu, BOOL fByPosition, UINT wID, UINT fType, LPCWSTR dwTypeData, UINT fState)
HRESULT WINAPI SHCreateDefaultContextMenu(const DEFCONTEXTMENU *pdcm, REFIID riid, void **ppv)
static HRESULT SHELL_GetRegCLSID(HKEY hKey, LPCWSTR SubKey, LPCWSTR Value, CLSID &clsid)
UINT DCMA_InsertMenuItems(_In_ HDCMA hDCMA, _In_ HDCIA hDCIA, _In_opt_ LPCITEMIDLIST pidlFolder, _In_opt_ IDataObject *pDO, _In_opt_ HKEY *pKeys, _In_opt_ UINT nKeys, _In_ QCMINFO *pQCMI, _In_opt_ UINT fCmf, _In_opt_ IUnknown *pUnkSite)
PCSTR MapFcidmCmdToVerb(_In_ UINT_PTR CmdId)
static HRESULT GetFriendlyVerb(_In_ PCWSTR pszVerb, _Out_ PWSTR pszBuf, _In_ SIZE_T cchMax)
void DCMA_Destroy(HDCMA hDCMA)
static BOOL InsertMenuItemAt(HMENU hMenu, UINT Pos, UINT Flags)
#define DCM_FCIDM_SHVIEW_OFFSET
static void DCMA_DestroyEntry(DCMENTRY &dcme)
EXTERN_C HRESULT SHELL32_EnumDefaultVerbList(LPCWSTR List, UINT Index, LPWSTR Verb, SIZE_T cchMax)
static bool IsVerbListSeparator(WCHAR Ch)
static HRESULT MapVerbToCmdId(PVOID Verb, BOOL IsUnicode, IContextMenu *pCM, UINT idFirst, UINT idLast)
struct _StaticShellEntry_ StaticShellEntry
struct _StaticShellEntry_ * PStaticShellEntry
HRESULT WINAPI CDefFolderMenu_Create2(PCIDLIST_ABSOLUTE pidlFolder, HWND hwnd, UINT cidl, PCUITEMID_CHILD_ARRAY apidl, IShellFolder *psf, LPFNDFMCALLBACK lpfn, UINT nKeys, const HKEY *ahkeyClsKeys, IContextMenu **ppcm)
HRESULT DCMA_InvokeCommand(HDCMA hDCMA, CMINVOKECOMMANDINFO *pICI)
#define MAX_VERB
HRESULT SHGetMenuIdFromMenuMsg(UINT uMsg, LPARAM lParam, UINT *CmdId)
HRESULT CRecyclerDropTarget_CreateInstance(REFIID riid, LPVOID *ppvOut)
#define shell32_hInstance
UINT cchMax
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
#define index(s, c)
Definition: various.h:29
#define IDM_PROPERTIES
Definition: resources.h:9
#define WARN(fmt,...)
Definition: precomp.h:61
#define ERR(fmt,...)
Definition: precomp.h:57
#define EXTERN_C
Definition: basetyps.h:12
#define STDMETHOD(m)
Definition: basetyps.h:62
#define UNIMPLEMENTED
Definition: ntoskrnl.c:15
HANDLE HKEY
Definition: registry.h:26
#define RegCloseKey(hKey)
Definition: registry.h:49
#define _stricmp
Definition: cat.c:22
EXTERN_C void WINAPI SHChangeNotify(LONG wEventId, UINT uFlags, LPCVOID dwItem1, LPCVOID dwItem2)
LONG Open(HKEY hKeyParent, LPCTSTR lpszKeyName, REGSAM samDesired=KEY_READ|KEY_WRITE) noexcept
Definition: atlbase.h:1173
HRESULT InvokeRegVerb(LPCMINVOKECOMMANDINFOEX lpcmi)
STDMETHOD() QueryService(REFGUID svc, REFIID riid, void **ppv) override
UINT AddShellExtensionsToMenu(HMENU hMenu, UINT *pIndexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags)
HRESULT DoRename(LPCMINVOKECOMMANDINFOEX lpcmi)
STDMETHOD() GetCommandString(UINT_PTR idCommand, UINT uFlags, UINT *lpReserved, LPSTR lpszName, UINT uMaxNameLen) override
BOOL MapVerbToCmdId(PVOID Verb, PUINT idCmd, BOOL IsUnicode)
HRESULT DoCreateLink(LPCMINVOKECOMMANDINFOEX lpcmi)
CComPtr< IDataObject > m_pDataObj
UINT AddStaticContextMenusToMenu(HMENU hMenu, UINT *IndexMenu, UINT iIdCmdFirst, UINT iIdCmdLast, UINT uFlags)
CComPtr< IShellFolder > m_psf
HRESULT DoUndo(LPCMINVOKECOMMANDINFOEX lpcmi)
PCUITEMID_CHILD_ARRAY m_apidl
STDMETHOD() SetSite(IUnknown *pUnkSite) override
STDMETHOD() QueryContextMenu(HMENU hMenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags) override
CComPtr< IContextMenuCB > m_pmcb
PDynamicShellEntry GetDynamicEntry(UINT idCmd)
CAtlList< StaticShellEntry > m_StaticEntries
HRESULT DoCopyOrCut(LPCMINVOKECOMMANDINFOEX lpcmi, BOOL bCopy)
void AddStaticEntry(const HKEY hkeyClass, const WCHAR *szVerb, UINT uFlags)
HRESULT DoDelete(LPCMINVOKECOMMANDINFOEX lpcmi)
HRESULT DoCopyToMoveToFolder(LPCMINVOKECOMMANDINFOEX lpici, BOOL bCopy)
DWORD BrowserFlagsFromVerb(LPCMINVOKECOMMANDINFOEX lpcmi, PStaticShellEntry pEntry)
CAtlList< DynamicShellEntry > m_DynamicEntries
HRESULT WINAPI Initialize(const DEFCONTEXTMENU *pdcm, LPFNDFMCALLBACK lpfn)
HRESULT _DoInvokeCommandCallback(LPCMINVOKECOMMANDINFOEX lpcmi, WPARAM CmdId)
BOOL IsShellExtensionAlreadyLoaded(REFCLSID clsid)
STDMETHOD() HandleMenuMsg(UINT uMsg, WPARAM wParam, LPARAM lParam) override
HRESULT TryToBrowse(LPCMINVOKECOMMANDINFOEX lpcmi, LPCITEMIDLIST pidl, DWORD wFlags)
HRESULT DoProperties(LPCMINVOKECOMMANDINFOEX lpcmi)
CComPtr< IUnknown > m_site
BOOL EnumerateDynamicContextHandlerForKey(HKEY hRootKey)
HRESULT DoCreateNewFolder(LPCMINVOKECOMMANDINFOEX lpici)
HRESULT DoPaste(LPCMINVOKECOMMANDINFOEX lpcmi, BOOL bLink)
STDMETHOD() GetSite(REFIID riid, void **ppvSite) override
HRESULT DoOpenOrExplore(LPCMINVOKECOMMANDINFOEX lpcmi)
HRESULT LoadDynamicContextMenuHandler(HKEY hKey, REFCLSID clsid)
void TryPickDefault(HMENU hMenu, UINT idCmdFirst, UINT DfltOffset, UINT uFlags)
HRESULT InvokeShellExt(LPCMINVOKECOMMANDINFOEX lpcmi)
STDMETHOD() HandleMenuMsg2(UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *plResult) override
HRESULT _DoCallback(UINT uMsg, WPARAM wParam, LPVOID lParam)
STDMETHOD() InvokeCommand(LPCMINVOKECOMMANDINFO lpcmi) override
PIDLIST_ABSOLUTE m_pidlFolder
HRESULT InvokePidl(LPCMINVOKECOMMANDINFOEX lpcmi, LPCITEMIDLIST pidl, PStaticShellEntry pEntry)
void AddStaticEntriesForKey(HKEY hKey, UINT uFlags)
Definition: _map.h:48
WPARAM wParam
Definition: combotst.c:138
LPARAM lParam
Definition: combotst.c:139
static UINT RosGetProcessEffectiveVersion(VOID)
Definition: compat_undoc.h:39
wcscpy
#define CHARS_IN_GUID
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define E_INVALIDARG
Definition: ddrawi.h:101
#define E_NOTIMPL
Definition: ddrawi.h:99
#define E_FAIL
Definition: ddrawi.h:102
ush Pos
Definition: deflate.h:92
#define ERROR_SUCCESS
Definition: deptool.c:10
LONG RegLoadMUIStringW(IN HKEY hKey, IN LPCWSTR pszValue OPTIONAL, OUT LPWSTR pszOutBuf, IN DWORD cbOutBuf, OUT LPDWORD pcbData OPTIONAL, IN DWORD Flags, IN LPCWSTR pszDirectory OPTIONAL)
Definition: muireg.c:53
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define DFM_GETDEFSTATICID
Definition: precomp.h:47
#define DFM_INVOKECOMMANDEX
Definition: precomp.h:46
#define DFM_MERGECONTEXTMENU
Definition: precomp.h:44
#define DFM_INVOKECOMMAND
Definition: precomp.h:45
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3333
LSTATUS WINAPI RegGetValueW(HKEY hKey, LPCWSTR pszSubKey, LPCWSTR pszValue, DWORD dwFlags, LPDWORD pdwType, PVOID pvData, LPDWORD pcbData)
Definition: reg.c:1931
LONG WINAPI RegEnumKeyExW(_In_ HKEY hKey, _In_ DWORD dwIndex, _Out_ LPWSTR lpName, _Inout_ LPDWORD lpcbName, _Reserved_ LPDWORD lpReserved, _Out_opt_ LPWSTR lpClass, _Inout_opt_ LPDWORD lpcbClass, _Out_opt_ PFILETIME lpftLastWriteTime)
Definition: reg.c:2504
UINT uFlags
Definition: api.c:59
LPWSTR WINAPI StrChrW(LPCWSTR lpszStr, WCHAR ch)
Definition: string.c:464
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
#define ERROR_NO_MORE_ITEMS
Definition: compat.h:105
#define MAX_PATH
Definition: compat.h:34
#define HeapFree(x, y, z)
Definition: compat.h:735
int WINAPI lstrcmpiA(LPCSTR str1, LPCSTR str2)
Definition: locale.c:4227
#define IS_INTRESOURCE(x)
Definition: loader.c:613
INT WINAPI DECLSPEC_HOTPATCH LoadStringW(HINSTANCE instance, UINT resource_id, LPWSTR buffer, INT buflen)
Definition: string.c:1220
DWORD WINAPI GetVersion(void)
Definition: version.c:1458
HRESULT WINAPI OleSetClipboard(IDataObject *data)
Definition: clipboard.c:2199
HRESULT WINAPI OleGetClipboard(IDataObject **obj)
Definition: clipboard.c:2249
HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
Definition: compobj.c:3325
HRESULT WINAPI CLSIDFromString(LPCOLESTR idstr, LPCLSID id)
Definition: compobj.c:2338
INT WINAPI StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax)
Definition: compobj.c:2434
#define RRF_RT_REG_SZ
Definition: driver.c:575
#define VERBKEY_CCHMAX
Definition: precomp.h:130
#define DCMA_GetEntry(hDCMA, iItem)
Definition: precomp.h:191
EXTERN_C HRESULT IUnknown_InitializeCommand(_In_ IUnknown *pUnk, _In_ PCWSTR pszCommandName, _In_opt_ IPropertyBag *pPB)
Definition: utils.cpp:1677
EXTERN_C HRESULT InvokeIExecuteCommandWithDataObject(_In_ IExecuteCommand *pEC, _In_ PCWSTR pszCommandName, _In_opt_ IPropertyBag *pPB, _In_ IDataObject *pDO, _In_opt_ LPCMINVOKECOMMANDINFOEX pICI, _In_opt_ IUnknown *pSite)
Definition: utils.cpp:1727
HRESULT SHELL32_ShowPropertiesDialog(IDataObject *pdtobj)
Definition: shlfolder.cpp:616
DWORD RegGetDword(HKEY hKey, PCWSTR pszPath, PCWSTR pszName, DWORD nDefVal)
Definition: utils.h:65
BOOL RegKeyExists(HKEY hKey, LPCWSTR Path)
Definition: utils.h:49
#define DCIA_GetCount(hDCIA)
Definition: utils.h:126
static BOOL RegValueExists(HKEY hKey, LPCWSTR Name)
Definition: utils.h:43
#define DCIA_GetEntry(hDCIA, iItem)
Definition: utils.h:127
void WINAPI SHFree(LPVOID pv)
Definition: shellole.c:370
HRESULT WINAPI SHExtCoCreateInstance(_In_opt_ LPCWSTR aclsid, _In_opt_ const CLSID *clsid, _In_opt_ LPUNKNOWN pUnkOuter, _In_ REFIID riid, _Out_ LPVOID *ppv)
Definition: shellole.c:222
HRESULT WINAPI SHCoCreateInstance(LPCWSTR aclsid, const CLSID *clsid, LPUNKNOWN pUnkOuter, REFIID riid, LPVOID *ppv)
Definition: shellole.c:197
BOOL WINAPI PathYetAnotherMakeUniqueName(LPWSTR buffer, LPCWSTR path, LPCWSTR shortname, LPCWSTR longname)
Definition: shellpath.c:848
BOOL WINAPI SHSimulateDrop(IDropTarget *pDrop, IDataObject *pDataObj, DWORD grfKeyState, PPOINTL lpPt, DWORD *pdwEffect)
Definition: ordinal.c:1828
HRESULT WINAPI IUnknown_QueryService(IUnknown *, REFGUID, REFIID, LPVOID *)
Definition: ordinal.c:1501
HRESULT WINAPI SHCreatePropertyBagOnRegKey(HKEY hKey, LPCWSTR subkey, DWORD grfMode, REFIID riid, void **ppv)
Definition: ordinal.c:5381
HRESULT WINAPI IUnknown_SetSite(IUnknown *obj, IUnknown *site)
Definition: ordinal.c:1411
DWORD WINAPI SHAnsiToUnicode(LPCSTR lpSrcStr, LPWSTR lpDstStr, int iLen)
Definition: string.c:2673
INT WINAPI SHUnicodeToAnsi(LPCWSTR lpSrcStr, LPSTR lpDstStr, INT iLen)
Definition: string.c:2797
#define FAILED_UNEXPECTEDLY
Definition: utils.cpp:30
#define MAKE_HRESULT(sev, fac, code)
Definition: dmerror.h:30
#define L(x)
Definition: resources.c:13
BOOL WINAPI DSA_Destroy(HDSA hdsa)
Definition: dsa.c:103
static IShellFolder IShellItem **static IBindCtx LPITEMIDLIST SFGAOF
Definition: ebrowser.c:83
#define InitFormatEtc(fe, cf, med)
Definition: editor.h:32
#define IDS_NEWFOLDER
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
PWDFDEVICE_INIT pInit
FxAutoRegKey hKey
PLIST_ENTRY pEntry
Definition: fxioqueue.cpp:4484
return pTarget Start()
GLuint res
Definition: glext.h:9613
GLuint index
Definition: glext.h:6031
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
const GLint * first
Definition: glext.h:5794
GLfloat GLfloat p
Definition: glext.h:8902
GLuint id
Definition: glext.h:5910
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
LPVOID NTAPI GlobalLock(HGLOBAL hMem)
Definition: heapmem.c:755
BOOL NTAPI GlobalUnlock(HGLOBAL hMem)
Definition: heapmem.c:1190
HGLOBAL NTAPI GlobalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:368
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:442
REFIID riid
Definition: atlbase.h:39
REFIID LPVOID * ppv
Definition: atlbase.h:39
HRESULT GetCommandString([in] UINT_PTR idCmd, [in] UINT uType, [out] UINT *pwReserved, [out, size_is(cchMax)] LPSTR pszName, [in] UINT cchMax)
HRESULT QueryContextMenu([in] HMENU hmenu, [in] UINT indexMenu, [in] UINT idCmdFirst, [in] UINT idCmdLast, [in] UINT uFlags)
ULONG Release()
#define S_OK
Definition: intsafe.h:52
#define SUCCEEDED(hr)
Definition: intsafe.h:50
#define FAILED(hr)
Definition: intsafe.h:51
#define C_ASSERT(e)
Definition: intsafe.h:73
uint32_t entry
Definition: isohybrid.c:63
#define LOBYTE(W)
Definition: jmemdos.c:487
#define debugstr_w
Definition: kernel32.h:32
#define BEGIN_COM_MAP(x)
Definition: atlcom.h:581
#define COM_INTERFACE_ENTRY_IID(iid, x)
Definition: atlcom.h:601
#define END_COM_MAP()
Definition: atlcom.h:592
if(dx< 0)
Definition: linetemp.h:194
#define HResultFromWin32
Definition: loader.cpp:14
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
const IID IID_IObjectWithSite
static HMODULE MODULEINFO DWORD cb
Definition: module.c:33
static IActiveScriptSite * site
Definition: script.c:149
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:63
#define min(a, b)
Definition: monoChain.cc:55
REFCLSID clsid
Definition: msctf.c:82
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274
unsigned int * PUINT
Definition: ndis.h:50
unsigned int UINT
Definition: ndis.h:50
#define _Out_
Definition: no_sal2.h:160
#define _In_
Definition: no_sal2.h:158
#define _In_opt_
Definition: no_sal2.h:212
#define KEY_READ
Definition: nt_native.h:1023
#define UNICODE_NULL
#define STGM_READ
Definition: objbase.h:917
#define LOWORD(l)
Definition: pedump.c:82
short SHORT
Definition: pedump.c:59
long LONG
Definition: pedump.c:60
PITEMID_CHILD * _ILCopyaPidl(PCUITEMID_CHILD_ARRAY apidlsrc, UINT cidl)
Definition: pidl.c:2623
LPITEMIDLIST WINAPI ILClone(LPCITEMIDLIST pidl)
Definition: pidl.c:238
void WINAPI ILFree(LPITEMIDLIST pidl)
Definition: pidl.c:1045
HRESULT WINAPI SHILCreateFromPathW(LPCWSTR path, LPITEMIDLIST *ppidl, DWORD *attributes)
Definition: pidl.c:404
LPITEMIDLIST WINAPI ILFindLastID(LPCITEMIDLIST pidl)
Definition: pidl.c:199
LPITEMIDLIST WINAPI ILCombine(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
Definition: pidl.c:817
BOOL WINAPI SHGetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath)
Definition: pidl.c:1490
void _ILFreeaPidl(LPITEMIDLIST *apidl, UINT cidl)
Definition: pidl.c:2608
#define DSA_AppendItem(hdsa, pitem)
Definition: commctrl.h:4832
#define REFIID
Definition: guiddef.h:118
#define REFCLSID
Definition: guiddef.h:117
#define err(...)
HRESULT WINAPI SHForwardContextMenuMsg(IUnknown *pUnk, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *pResult, BOOL useIContextMenu2)
Definition: rosordinal.c:11
_Check_return_ _CRTIMP int __cdecl _wcsicmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
_Check_return_ _CRTIMP int __cdecl _wcsnicmp(_In_reads_or_z_(_MaxCount) const wchar_t *_Str1, _In_reads_or_z_(_MaxCount) const wchar_t *_Str2, _In_ size_t _MaxCount)
static __inline const char * wine_dbgstr_guid(const GUID *id)
Definition: debug.h:197
#define _WIN32_WINNT_WIN7
Definition: sdkddkver.h:28
#define _WIN32_WINNT_VISTA
Definition: sdkddkver.h:25
#define Ch(x, y, z)
Definition: sha2.c:141
static __inline LPWSTR __SHCloneStrAtoW(WCHAR **target, const char *source)
Definition: shell32_main.h:204
#define SEE_MASK_CLASSKEY
Definition: shellapi.h:26
#define SEE_MASK_IDLIST
Definition: shellapi.h:27
#define STATUS_SUCCESS
Definition: shellext.h:65
static BOOL SHELL_IsContextMenuMsg(UINT uMsg)
Definition: shellutils.h:697
BOOL WINAPI DECLSPEC_HOTPATCH ShellExecuteExW(LPSHELLEXECUTEINFOW sei)
Definition: shlexec.cpp:2552
int WINAPI SHCreateDirectory(HWND hWnd, LPCWSTR path)
Definition: shlfileop.cpp:948
HRESULT hr
Definition: shlfolder.c:183
#define SID_IShellBrowser
UINT WINAPI Shell_MergeMenus(HMENU hmDst, HMENU hmSrc, UINT uInsert, UINT uIDAdjust, UINT uIDAdjustMax, ULONG uFlags)
Definition: shlmenu.c:856
#define DFM_CMD_DELETE
Definition: shlobj.h:2614
#define CFSTR_SHELLIDLIST
Definition: shlobj.h:558
#define CFSTR_PREFERREDDROPEFFECT
Definition: shlobj.h:568
#define SHCNE_MKDIR
Definition: shlobj.h:1898
#define DFM_CMD_NEWFOLDER
Definition: shlobj.h:2619
#define DFM_CMD_COPY
Definition: shlobj.h:2616
#define DFM_CMD_PASTE
Definition: shlobj.h:2620
#define SHCNF_FLUSH
Definition: shlobj.h:1934
#define SHCNF_PATHW
Definition: shlobj.h:1931
#define DFM_CMD_PROPERTIES
Definition: shlobj.h:2618
HRESULT(CALLBACK * LPFNDFMCALLBACK)(_In_opt_ IShellFolder *, _In_opt_ HWND, _In_opt_ IDataObject *, UINT, WPARAM, LPARAM)
Definition: shlobj.h:2574
#define DFM_CMD_RENAME
Definition: shlobj.h:2626
RESTRICTIONS
Definition: shlobj.h:1646
#define DFM_CMD_LINK
Definition: shlobj.h:2617
#define PathRemoveFileSpec
Definition: shlwapi.h:1078
DWORD WINAPI SHRestricted(RESTRICTIONS rest)
Definition: shpolicy.c:166
#define FCIDM_SHVIEW_CUT
Definition: shresdef.h:863
#define FCIDM_SHVIEW_OPEN
Definition: shresdef.h:888
#define FCIDM_SHVIEW_UNDO
Definition: shresdef.h:866
#define IDM_DELETE
Definition: shresdef.h:903
#define FCIDM_SHVIEW_COPY
Definition: shresdef.h:864
#define IDS_OPEN_VERB
Definition: shresdef.h:212
#define IDM_INSERT
Definition: shresdef.h:901
#define FCIDM_SHVIEW_INSERTLINK
Definition: shresdef.h:867
#define IDS_FIND_VERB
Definition: shresdef.h:216
#define FCIDM_SHVIEW_NEWFOLDER
Definition: shresdef.h:885
#define IDM_RENAME
Definition: shresdef.h:904
#define IDM_COPY
Definition: shresdef.h:900
#define FCIDM_SHVIEW_EXPLORE
Definition: shresdef.h:887
#define FCIDM_SHVIEW_PROPERTIES
Definition: shresdef.h:862
#define IDS_EXPLORE_VERB
Definition: shresdef.h:213
#define IDM_CUT
Definition: shresdef.h:899
#define IDM_CREATELINK
Definition: shresdef.h:902
#define IDS_PRINT_VERB
Definition: shresdef.h:217
#define FCIDM_SHVIEW_COPYTO
Definition: shresdef.h:868
#define FCIDM_SHVIEW_MOVETO
Definition: shresdef.h:869
#define FCIDM_SHVIEW_DELETE
Definition: shresdef.h:860
#define FCIDM_SHVIEW_RENAME
Definition: shresdef.h:861
#define FCIDM_SHVIEW_CREATELINK
Definition: shresdef.h:859
#define IDS_RUNAS_VERB
Definition: shresdef.h:214
#define MENU_SHV_FILE
Definition: shresdef.h:897
#define IDS_EDIT_VERB
Definition: shresdef.h:215
#define FCIDM_SHVIEW_INSERT
Definition: shresdef.h:865
ITEMIDLIST UNALIGNED * LPITEMIDLIST
Definition: shtypes.idl:41
const PCUITEMID_CHILD * PCUITEMID_CHILD_ARRAY
Definition: shtypes.idl:71
const ITEMIDLIST UNALIGNED * LPCITEMIDLIST
Definition: shtypes.idl:42
#define _countof(array)
Definition: sndvol32.h:70
#define TRACE(s)
Definition: solgame.cpp:4
STRSAFEAPI StringCchCopyW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:149
STRSAFEAPI StringCchCopyA(STRSAFE_LPSTR pszDest, size_t cchDest, STRSAFE_LPCSTR pszSrc)
Definition: strsafe.h:145
STRSAFEAPI StringCbPrintfW(STRSAFE_LPWSTR pszDest, size_t cbDest, STRSAFE_LPCWSTR pszFormat,...)
Definition: strsafe.h:557
STRSAFEAPI StringCchCopyNW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszSrc, size_t cchToCopy)
Definition: strsafe.h:236
IContextMenuCB * pcmcb
Definition: shlobj.h:2556
IShellFolder * psf
Definition: shlobj.h:2558
IUnknown * punkAssociationInfo
Definition: shlobj.h:2561
PCUITEMID_CHILD_ARRAY apidl
Definition: shlobj.h:2560
const HKEY * aKeys
Definition: shlobj.h:2563
PCIDLIST_ABSOLUTE pidlFolder
Definition: shlobj.h:2557
IContextMenu * pCM
Definition: precomp.h:185
Definition: dsa.c:45
CComPtr< IContextMenu > pCM
Definition: scsiwmi.h:51
UINT idCmdFirst
Definition: shlobj.h:1397
LPCWSTR lpDirectory
Definition: shellapi.h:340
LPCWSTR lpParameters
Definition: shellapi.h:339
LPWSTR dwTypeData
Definition: winuser.h:3371
uint16_t * PWSTR
Definition: typedefs.h:56
int32_t INT_PTR
Definition: typedefs.h:64
const uint16_t * PCWSTR
Definition: typedefs.h:57
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
ULONG_PTR SIZE_T
Definition: typedefs.h:80
int32_t INT
Definition: typedefs.h:58
const char * PCSTR
Definition: typedefs.h:52
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define HIWORD(l)
Definition: typedefs.h:247
_In_ WDFCOLLECTION _In_ ULONG Index
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:413
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
#define ZeroMemory
Definition: winbase.h:1753
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
#define CopyMemory
Definition: winbase.h:1751
#define GHND
Definition: winbase.h:330
_In_ PSID _Out_writes_to_opt_ cchName LPSTR _Inout_ LPDWORD cchName
Definition: winbase.h:2808
WINBASEAPI _In_ DWORD _Out_ _In_ WORD wFlags
Definition: wincon_undoc.h:337
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023
LONG_PTR LPARAM
Definition: windef.h:208
LONG_PTR LRESULT
Definition: windef.h:209
UINT_PTR WPARAM
Definition: windef.h:207
CONST void * LPCVOID
Definition: windef.h:191
#define WINAPI
Definition: msvc.h:6
#define S_FALSE
Definition: winerror.h:2357
#define SEVERITY_SUCCESS
Definition: winerror.h:64
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
#define HRESULT_CODE(hr)
Definition: winerror.h:76
#define ERROR_NOT_FOUND
Definition: winerror.h:690
_In_ DWORD _In_ int _In_ int _In_opt_ LPNLSVERSIONINFO _In_opt_ LPVOID lpReserved
Definition: winnls.h:1199
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
#define HKEY_CLASSES_ROOT
Definition: winreg.h:10
#define MK_SHIFT
Definition: winuser.h:2405
UINT WINAPI GetMenuDefaultItem(_In_ HMENU hMenu, _In_ UINT fByPos, _In_ UINT gmdiFlags)
#define MF_BYCOMMAND
Definition: winuser.h:202
#define MIIM_ID
Definition: winuser.h:733
BOOL WINAPI SetMenuDefaultItem(_In_ HMENU, _In_ UINT, _In_ UINT)
UINT WINAPI RegisterClipboardFormatW(_In_ LPCWSTR)
BOOL WINAPI DeleteMenu(_In_ HMENU, _In_ UINT, _In_ UINT)
UINT WINAPI GetMenuItemID(_In_ HMENU, _In_ int)
#define MFT_SEPARATOR
Definition: winuser.h:755
#define WM_DRAWITEM
Definition: winuser.h:1673
#define MIIM_STATE
Definition: winuser.h:732
#define MFS_DEFAULT
Definition: winuser.h:759
HMENU WINAPI GetSubMenu(_In_ HMENU, _In_ int)
#define WM_INITMENUPOPUP
Definition: winuser.h:1774
#define MK_CONTROL
Definition: winuser.h:2406
#define MF_SEPARATOR
Definition: winuser.h:137
#define MF_BYPOSITION
Definition: winuser.h:203
#define WM_MEASUREITEM
Definition: winuser.h:1674
#define MFS_ENABLED
Definition: winuser.h:761
#define MAKEINTRESOURCEA(i)
Definition: winuser.h:581
BOOL WINAPI DestroyMenu(_In_ HMENU)
#define MFT_STRING
Definition: winuser.h:757
#define MAKEINTRESOURCEW(i)
Definition: winuser.h:582
HMENU WINAPI LoadMenuW(_In_opt_ HINSTANCE, _In_ LPCWSTR)
#define MIIM_DATA
Definition: winuser.h:737
#define MIIM_TYPE
Definition: winuser.h:736
BOOL WINAPI InsertMenuItemW(_In_ HMENU, _In_ UINT, _In_ BOOL, _In_ LPCMENUITEMINFOW)
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:409
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
static void Initialize()
Definition: xlate.c:212
#define IID_PPV_ARG(Itype, ppType)
#define IID_NULL_PPV_ARG(Itype, ppType)
const char * LPCSTR
Definition: xmlstorage.h:183
char * LPSTR
Definition: xmlstorage.h:182
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185