ReactOS 0.4.16-dev-1338-g8aab5a9
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 (UINT i = 0; i < _countof(g_StaticInvokeCmdMap); ++i)
186 {
187 if (!lstrcmpiA(g_StaticInvokeCmdMap[i].szStringVerb, verba))
188 return (int)g_StaticInvokeCmdMap[i].DfmCmd;
189 }
190 return 0;
191}
192
193static HRESULT
194MapVerbToCmdId(PVOID Verb, BOOL IsUnicode, IContextMenu *pCM, UINT idFirst, UINT idLast)
195{
196 const UINT gcs = IsUnicode ? GCS_VERBW : GCS_VERBA;
197 for (UINT id = idFirst; id <= idLast; ++id)
198 {
200 *buf = UNICODE_NULL;
201 HRESULT hr = pCM->GetCommandString(id, gcs, NULL, (LPSTR)buf, _countof(buf));
202 if (FAILED(hr) || !*buf)
203 continue;
204 else if (IsUnicode && !_wcsicmp((LPWSTR)Verb, buf))
205 return id;
206 else if (!IsUnicode && !lstrcmpiA((LPSTR)Verb, (LPSTR)buf))
207 return id;
208 }
210}
211
212static inline bool IsVerbListSeparator(WCHAR Ch)
213{
214 return Ch == L' ' || Ch == L','; // learn.microsoft.com/en-us/windows/win32/shell/context-menu-handlers
215}
216
218{
219 for (UINT index = 0; *List; ++index)
220 {
221 while (IsVerbListSeparator(*List))
222 List++;
224 while (*List && !IsVerbListSeparator(*List))
225 List++;
226 // "List > Start" to verify that the list item is non-empty to avoid the edge case where Verb is "" and the list contains ",,"
227 if (!_wcsnicmp(Verb, Start, List - Start) && List > Start)
228 return index;
229 }
230 return -1;
231}
232
234{
235 for (UINT i = 0; *List; ++i)
236 {
237 while (IsVerbListSeparator(*List))
238 List++;
240 while (*List && !IsVerbListSeparator(*List))
241 List++;
242 if (List > Start && i == Index)
244 }
246}
247
249{
250 static const struct { PCWSTR pszVerb; WORD iResId; } map[] =
251 {
252 // { L"open", IDS_OPEN_VERB }, These two have already been handled
253 // { L"explore", IDS_EXPLORE_VERB },
254 { L"edit", IDS_EDIT_VERB },
255 { L"print", IDS_PRINT_VERB },
256 { L"runas", IDS_RUNAS_VERB },
257 { L"openas", IDS_OPEN_VERB },
258 { L"find", IDS_FIND_VERB },
259 };
260 for (SIZE_T i = 0; i < _countof(map); ++i)
261 {
262 if (!_wcsicmp(pszVerb, map[i].pszVerb) &&
263 LoadStringW(shell32_hInstance, map[i].iResId, pszBuf, cchMax))
264 {
265 return S_OK;
266 }
267 }
268
269 // Try to make a friendly verb based on the verb subkey
270 if (pszVerb[0] < 127 && !StrChrW(pszVerb, '&') && SUCCEEDED(StringCchCopyW(pszBuf + 1, --cchMax, pszVerb)))
271 {
272 *pszBuf = L'&';
273 return S_OK; // This can be changed to S_FALSE if the caller needs to know we faked it
274 }
275 return E_FAIL;
276}
277
279 public CComObjectRootEx<CComMultiThreadModelNoCS>,
280 public IContextMenu3,
281 public IObjectWithSite,
282 public IServiceProvider
283{
284 private:
296 UINT m_iIdQCMFirst; /* The first id passed to us in QueryContextMenu */
298 UINT m_iIdSHEFirst; /* first used id */
299 UINT m_iIdSHELast; /* last used id */
301 UINT m_iIdSCMFirst; /* first static used id */
302 UINT m_iIdSCMLast; /* last static used id */
303 UINT m_iIdCBFirst; /* first callback used id */
304 UINT m_iIdCBLast; /* last callback used id */
305 UINT m_iIdDfltFirst; /* first default part id */
306 UINT m_iIdDfltLast; /* last default part id */
307 HWND m_hwnd; /* window passed to callback */
309
312 void AddStaticEntry(const HKEY hkeyClass, const WCHAR *szVerb, UINT uFlags);
314 void TryPickDefault(HMENU hMenu, UINT idCmdFirst, UINT DfltOffset, UINT uFlags);
318 UINT AddShellExtensionsToMenu(HMENU hMenu, UINT* pIndexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags);
319 UINT AddStaticContextMenusToMenu(HMENU hMenu, UINT* IndexMenu, UINT iIdCmdFirst, UINT iIdCmdLast, UINT uFlags);
336 BOOL MapVerbToCmdId(PVOID Verb, PUINT idCmd, BOOL IsUnicode);
337
338 public:
342
343 // IContextMenu
344 STDMETHOD(QueryContextMenu)(HMENU hMenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags) override;
346 STDMETHOD(GetCommandString)(UINT_PTR idCommand, UINT uFlags, UINT *lpReserved, LPSTR lpszName, UINT uMaxNameLen) override;
347
348 // IContextMenu2
350
351 // IContextMenu3
352 STDMETHOD(HandleMenuMsg2)(UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *plResult) override;
353
354 // IObjectWithSite
355 STDMETHOD(SetSite)(IUnknown *pUnkSite) override;
356 STDMETHOD(GetSite)(REFIID riid, void **ppvSite) override;
357
358 // IServiceProvider
360 {
361 return IUnknown_QueryService(m_site, svc, riid, ppv);
362 }
363
365 COM_INTERFACE_ENTRY_IID(IID_IContextMenu, IContextMenu)
366 COM_INTERFACE_ENTRY_IID(IID_IContextMenu2, IContextMenu2)
367 COM_INTERFACE_ENTRY_IID(IID_IContextMenu3, IContextMenu3)
369 COM_INTERFACE_ENTRY_IID(IID_IServiceProvider, IServiceProvider)
371};
372
374 m_psf(NULL),
375 m_pmcb(NULL),
376 m_pfnmcb(NULL),
377 m_cidl(0),
378 m_apidl(NULL),
379 m_pDataObj(NULL),
380 m_aKeys(NULL),
381 m_cKeys(NULL),
382 m_pidlFolder(NULL),
383 m_bGroupPolicyActive(0),
384 m_iIdQCMFirst(0),
385 m_iIdSHEFirst(0),
386 m_iIdSHELast(0),
387 m_iIdSCMFirst(0),
388 m_iIdSCMLast(0),
389 m_iIdCBFirst(0),
390 m_iIdCBLast(0),
391 m_iIdDfltFirst(0),
392 m_iIdDfltLast(0),
393 m_hwnd(NULL)
394{
396}
397
399{
400 for (POSITION it = m_DynamicEntries.GetHeadPosition(); it != NULL;)
401 {
402 const DynamicShellEntry& info = m_DynamicEntries.GetNext(it);
403 IUnknown_SetSite(info.pCM.p, NULL);
404 }
405 m_DynamicEntries.RemoveAll();
406 m_StaticEntries.RemoveAll();
407
408 for (UINT i = 0; i < m_cKeys; i++)
411
412 if (m_pidlFolder)
414 _ILFreeaPidl(const_cast<PITEMID_CHILD *>(m_apidl), m_cidl);
415}
416
418{
419 TRACE("cidl %u\n", pdcm->cidl);
420
421 if (!pdcm->pcmcb && !lpfn)
422 {
423 ERR("CDefaultContextMenu needs a callback!\n");
424 return E_INVALIDARG;
425 }
426
427 m_cidl = pdcm->cidl;
429 if (m_cidl && !m_apidl)
430 return E_OUTOFMEMORY;
431 m_psf = pdcm->psf;
432 m_pmcb = pdcm->pcmcb;
433 m_pfnmcb = lpfn;
434 m_hwnd = pdcm->hwnd;
435
436 m_cKeys = pdcm->cKeys;
437 if (pdcm->cKeys)
438 {
439 m_aKeys = (HKEY*)HeapAlloc(GetProcessHeap(), 0, sizeof(HKEY) * pdcm->cKeys);
440 if (!m_aKeys)
441 return E_OUTOFMEMORY;
442 memcpy(m_aKeys, pdcm->aKeys, sizeof(HKEY) * pdcm->cKeys);
443 }
444
445 m_psf->GetUIObjectOf(pdcm->hwnd, m_cidl, m_apidl, IID_NULL_PPV_ARG(IDataObject, &m_pDataObj));
446
447 if (pdcm->pidlFolder)
448 {
450 }
451 else
452 {
454 if (SUCCEEDED(m_psf->QueryInterface(IID_PPV_ARG(IPersistFolder2, &pf))))
455 {
456 if (FAILED(pf->GetCurFolder(&m_pidlFolder)))
457 ERR("GetCurFolder failed\n");
458 }
459 TRACE("pidlFolder %p\n", m_pidlFolder);
460 }
461
462 return S_OK;
463}
464
466{
467 if (m_pmcb)
468 {
469 return m_pmcb->CallBack(m_psf, m_hwnd, m_pDataObj, uMsg, wParam, (LPARAM)lParam);
470 }
471 else if(m_pfnmcb)
472 {
474 }
475
476 return E_FAIL;
477}
478
479void CDefaultContextMenu::AddStaticEntry(const HKEY hkeyClass, const WCHAR *szVerb, UINT uFlags)
480{
481 POSITION it = m_StaticEntries.GetHeadPosition();
482 while (it != NULL)
483 {
484 const StaticShellEntry& info = m_StaticEntries.GetNext(it);
485 if (info.Verb.CompareNoCase(szVerb) == 0)
486 {
487 /* entry already exists */
488 return;
489 }
490 }
491
492 TRACE("adding verb %s\n", debugstr_w(szVerb));
493
494 if (!_wcsicmp(szVerb, L"open") && !(uFlags & CMF_NODEFAULT))
495 {
496 /* open verb is always inserted in front */
497 m_StaticEntries.AddHead({ szVerb, hkeyClass });
498 }
499 else
500 {
501 m_StaticEntries.AddTail({ szVerb, hkeyClass });
502 }
503}
504
506{
507 WCHAR wszName[VERBKEY_CCHMAX];
508 DWORD cchName, dwIndex = 0;
509 HKEY hShellKey;
510
511 LRESULT lres = RegOpenKeyExW(hKey, L"shell", 0, KEY_READ, &hShellKey);
512 if (lres != STATUS_SUCCESS)
513 return;
514
515 if (!*m_DefVerbs)
516 {
517 DWORD cb = sizeof(m_DefVerbs);
519 }
520
521 while(TRUE)
522 {
523 cchName = _countof(wszName);
524 if (RegEnumKeyExW(hShellKey, dwIndex++, wszName, &cchName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
525 break;
526
527 AddStaticEntry(hKey, wszName, uFlags);
528 }
529
530 RegCloseKey(hShellKey);
531}
532
533static
534BOOL
536{
537 BOOL bRet = FALSE;
538 CComPtr<IDataObject> pDataObj;
539
540 if (SUCCEEDED(OleGetClipboard(&pDataObj)))
541 {
542 FORMATETC formatetc;
543
544 TRACE("pDataObj=%p\n", pDataObj.p);
545
546 /* Set the FORMATETC structure*/
547 InitFormatEtc(formatetc, RegisterClipboardFormatW(CFSTR_SHELLIDLIST), TYMED_HGLOBAL);
548 bRet = SUCCEEDED(pDataObj->QueryGetData(&formatetc));
549 }
550
551 return bRet;
552}
553
554BOOL
556{
557 POSITION it = m_DynamicEntries.GetHeadPosition();
558 while (it != NULL)
559 {
560 const DynamicShellEntry& info = m_DynamicEntries.GetNext(it);
561 if (info.ClassID == clsid)
562 return TRUE;
563 }
564
565 return FALSE;
566}
567
570{
571 HRESULT hr;
572 TRACE("LoadDynamicContextMenuHandler entered with This %p hKey %p pclsid %s\n", this, hKey, wine_dbgstr_guid(&clsid));
573
575 return S_OK;
576
579 if (FAILED(hr))
580 {
581 ERR("SHCoCreateInstance(IContextMenu) failed.clsid %s hr 0x%x\n", wine_dbgstr_guid(&clsid), hr);
582 return hr;
583 }
584
585 CComPtr<IShellExtInit> pExtInit;
586 hr = pcm->QueryInterface(IID_PPV_ARG(IShellExtInit, &pExtInit));
587 if (FAILED(hr))
588 {
589 ERR("IContextMenu->QueryInterface(IShellExtInit) failed.clsid %s hr 0x%x\n", wine_dbgstr_guid(&clsid), hr);
590 return hr;
591 }
592
593 hr = pExtInit->Initialize(m_pDataObj ? NULL : m_pidlFolder, m_pDataObj, hKey);
594 if (FAILED(hr))
595 {
596 WARN("IShellExtInit::Initialize failed.clsid %s hr 0x%x\n", wine_dbgstr_guid(&clsid), hr);
597 return hr;
598 }
599
600 if (m_site)
602
603 m_DynamicEntries.AddTail({ 0, 0, clsid, pcm });
604
605 return S_OK;
606}
607
608BOOL
610{
611 WCHAR wszName[MAX_PATH], wszBuf[MAX_PATH], *pwszClsid;
613 HRESULT hr;
614 HKEY hKey;
615
616 if (RegOpenKeyExW(hRootKey, L"shellex\\ContextMenuHandlers", 0, KEY_READ, &hKey) != ERROR_SUCCESS)
617 {
618 TRACE("RegOpenKeyExW failed\n");
619 return FALSE;
620 }
621
622 DWORD dwIndex = 0;
623 while (TRUE)
624 {
625 cchName = _countof(wszName);
626 if (RegEnumKeyExW(hKey, dwIndex++, wszName, &cchName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
627 break;
628
629 /* Key name or key value is CLSID */
630 CLSID clsid;
631 hr = CLSIDFromString(wszName, &clsid);
632 if (hr == S_OK)
633 pwszClsid = wszName;
634 else
635 {
636 DWORD cchBuf = _countof(wszBuf);
637 if (RegGetValueW(hKey, wszName, NULL, RRF_RT_REG_SZ, NULL, wszBuf, &cchBuf) == ERROR_SUCCESS)
638 hr = CLSIDFromString(wszBuf, &clsid);
639 pwszClsid = wszBuf;
640 }
641
642 if (FAILED(hr))
643 {
644 ERR("CLSIDFromString failed for clsid %S hr 0x%x\n", pwszClsid, hr);
645 continue;
646 }
647
649 {
651 L"Software\\Microsoft\\Windows\\CurrentVersion\\Shell Extensions\\Approved",
652 pwszClsid,
654 NULL,
655 NULL,
657 {
658 ERR("Shell extension %s not approved!\n", pwszClsid);
659 continue;
660 }
661 }
662
664 if (FAILED(hr))
665 WARN("Failed to get context menu entires from shell extension! clsid: %S\n", pwszClsid);
666 }
667
669 return TRUE;
670}
671
672UINT
674{
675 UINT cIds = 0;
676
677 if (m_DynamicEntries.IsEmpty())
678 return cIds;
679
680 POSITION it = m_DynamicEntries.GetHeadPosition();
681 while (it != NULL)
682 {
684
685 HRESULT hr = info.pCM->QueryContextMenu(hMenu, *pIndexMenu, idCmdFirst + cIds, idCmdLast, uFlags);
686 if (SUCCEEDED(hr))
687 {
688 info.iIdCmdFirst = cIds;
689 info.NumIds = HRESULT_CODE(hr);
690 (*pIndexMenu) += info.NumIds;
691
692 cIds += info.NumIds;
693 if (idCmdFirst + cIds >= idCmdLast)
694 break;
695 }
696 TRACE("pEntry hr %x contextmenu %p cmdfirst %x num ids %x\n", hr, info.pCM.p, info.iIdCmdFirst, info.NumIds);
697 }
698 return cIds;
699}
700
701UINT
703 HMENU hMenu,
704 UINT* pIndexMenu,
705 UINT iIdCmdFirst,
706 UINT iIdCmdLast,
707 UINT uFlags)
708{
710 MENUITEMINFOW mii = { sizeof(mii) };
711 WCHAR wszDispVerb[80]; // The limit on XP. If the friendly string is longer, it falls back to the verb key.
712 UINT fState, idVerbRes;
713 UINT cIds = 0, indexFirst = *pIndexMenu, indexDefault;
714 int iDefVerbIndex = -1;
715
717 mii.fType = MFT_STRING;
718
719 POSITION it = m_StaticEntries.GetHeadPosition();
720 bool first = true;
721 while (it != NULL)
722 {
724 BOOL forceFirstPos = FALSE;
725 bool hide = false;
726
727 fState = MFS_ENABLED;
728
729 /* set first entry as default */
730 if (first)
731 {
732 fState |= MFS_DEFAULT;
733 first = false;
734 }
735
736 if (info.Verb.CompareNoCase(L"open") == 0)
737 {
738 idVerbRes = IDS_OPEN_VERB; // TODO: This string should include '&'
739 fState |= MFS_DEFAULT; /* override default when open verb is found */
740 forceFirstPos++;
741 }
742 else if (info.Verb.CompareNoCase(L"explore") == 0)
743 {
744 idVerbRes = IDS_EXPLORE_VERB; // TODO: This string should include '&'
745 if (uFlags & CMF_EXPLORE)
746 {
747 fState |= MFS_DEFAULT;
748 forceFirstPos++;
749 }
750 }
751 else if (info.Verb.CompareNoCase(L"printto") == 0)
752 hide = true;
753 else
754 idVerbRes = 0;
755
756 /* By default use verb for menu item name */
757 mii.dwTypeData = (LPWSTR)info.Verb.GetString();
758
759 WCHAR wszKey[sizeof("shell\\") + MAX_VERB];
760 HRESULT hr = StringCbPrintfW(wszKey, sizeof(wszKey), L"shell\\%s", info.Verb.GetString());
762 hide = true;
763
764 UINT cmdFlags = 0;
765 HKEY hkVerb;
766 if (RegOpenKeyExW(info.hkClass, wszKey, 0, KEY_READ, &hkVerb) == ERROR_SUCCESS)
767 {
768 if (!(uFlags & CMF_OPTIMIZEFORINVOKE))
769 {
770 DWORD cbVerb = sizeof(wszDispVerb);
771 LONG res = RegLoadMUIStringW(hkVerb, L"MUIVerb", wszDispVerb, cbVerb, NULL, 0, NULL);
772 if (res || !*wszDispVerb)
773 res = RegLoadMUIStringW(hkVerb, NULL, wszDispVerb, cbVerb, NULL, 0, NULL);
774
775 if ((res == ERROR_SUCCESS && *wszDispVerb) ||
776 (idVerbRes && LoadStringW(shell32_hInstance, idVerbRes, wszDispVerb, _countof(wszDispVerb))) ||
777 SUCCEEDED(GetFriendlyVerb(info.Verb, wszDispVerb, _countof(wszDispVerb))))
778 {
779 mii.dwTypeData = wszDispVerb;
780 }
781 }
782 }
783 else
784 {
785 hkVerb = NULL;
786 }
787
788 if (hkVerb)
789 {
790 if (!hide && !(uFlags & CMF_EXTENDEDVERBS))
791 hide = RegValueExists(hkVerb, L"Extended");
792
793 if (!hide)
794 hide = RegValueExists(hkVerb, L"ProgrammaticAccessOnly");
795
796 if (!hide && !(uFlags & CMF_DISABLEDVERBS))
797 hide = RegValueExists(hkVerb, L"LegacyDisable");
798
799 if (DWORD dwRest = (hide ? 0 : RegGetDword(hkVerb, NULL, L"SuppressionPolicy", 0)))
800 hide = SHRestricted((RESTRICTIONS)dwRest);
801
802 if (RegValueExists(hkVerb, L"NeverDefault"))
803 fState &= ~MFS_DEFAULT;
804
805 if (RegValueExists(hkVerb, L"SeparatorBefore"))
806 cmdFlags |= ECF_SEPARATORBEFORE;
807 if (RegValueExists(hkVerb, L"SeparatorAfter"))
808 cmdFlags |= ECF_SEPARATORAFTER;
809
810 RegCloseKey(hkVerb);
811 }
812
813 if (((uFlags & CMF_NODEFAULT) && ntver >= _WIN32_WINNT_VISTA) ||
814 ((uFlags & CMF_DONOTPICKDEFAULT) && ntver >= _WIN32_WINNT_WIN7))
815 {
816 fState &= ~MFS_DEFAULT;
817 }
818
819 if (!hide)
820 {
821 if (cmdFlags & ECF_SEPARATORBEFORE)
822 {
823 if (InsertMenuItemAt(hMenu, *pIndexMenu, MF_SEPARATOR))
824 (*pIndexMenu)++;
825 }
826
827 UINT pos = *pIndexMenu;
828 int verbIndex = hkVerb ? FindVerbInDefaultVerbList(m_DefVerbs, info.Verb) : -1;
829 if (verbIndex >= 0)
830 {
831 if (verbIndex < iDefVerbIndex || iDefVerbIndex < 0)
832 {
833 iDefVerbIndex = verbIndex;
834 fState |= MFS_DEFAULT;
835 forceFirstPos = TRUE;
836 }
837 else
838 {
839 fState &= ~MFS_DEFAULT; // We have already set a better default
840 pos = indexDefault;
841 }
842 }
843 else if (iDefVerbIndex >= 0)
844 {
845 fState &= ~MFS_DEFAULT; // We have already set the default
846 if (forceFirstPos)
847 pos = indexDefault;
848 forceFirstPos = FALSE;
849 }
850
851 mii.fState = fState;
852 mii.wID = iIdCmdFirst + cIds;
853 if (InsertMenuItemW(hMenu, forceFirstPos ? indexFirst : pos, TRUE, &mii))
854 (*pIndexMenu)++;
855
856 if (cmdFlags & ECF_SEPARATORAFTER)
857 {
858 if (InsertMenuItemAt(hMenu, *pIndexMenu, MF_SEPARATOR))
859 (*pIndexMenu)++;
860 }
861
862 if (fState & MFS_DEFAULT)
863 indexDefault = *pIndexMenu; // This is where we want to insert "high priority" verbs
864 }
865 cIds++; // Always increment the id because it acts as the index into m_StaticEntries
866
867 if (mii.wID >= iIdCmdLast)
868 break;
869 }
870
871 return cIds;
872}
873
875 HMENU hMenu,
876 UINT indexMenu,
877 BOOL fByPosition,
878 UINT wID,
879 UINT fType,
880 LPCWSTR dwTypeData,
881 UINT fState)
882{
883 MENUITEMINFOW mii;
884 WCHAR wszText[100];
885
886 ZeroMemory(&mii, sizeof(mii));
887 mii.cbSize = sizeof(mii);
888 if (fType == MFT_SEPARATOR)
889 mii.fMask = MIIM_ID | MIIM_TYPE;
890 else if (fType == MFT_STRING)
891 {
893 if (IS_INTRESOURCE(dwTypeData))
894 {
895 if (LoadStringW(shell32_hInstance, LOWORD((ULONG_PTR)dwTypeData), wszText, _countof(wszText)))
896 mii.dwTypeData = wszText;
897 else
898 {
899 ERR("failed to load string %p\n", dwTypeData);
900 return FALSE;
901 }
902 }
903 else
904 mii.dwTypeData = (LPWSTR)dwTypeData;
905 mii.fState = fState;
906 }
907
908 mii.wID = wID;
909 mii.fType = fType;
910 return InsertMenuItemW(hMenu, indexMenu, fByPosition, &mii);
911}
912
913void
915{
916 // Are we allowed to pick a default?
917 if ((uFlags & CMF_NODEFAULT) ||
918 ((uFlags & CMF_DONOTPICKDEFAULT) && RosGetProcessEffectiveVersion() >= _WIN32_WINNT_WIN7))
919 {
920 return;
921 }
922
923 // Do we already have a default?
924 if ((int)GetMenuDefaultItem(hMenu, MF_BYPOSITION, 0) != -1)
925 return;
926
927 // Does the view want to pick one?
928 INT_PTR forceDfm = 0;
929 if (SUCCEEDED(_DoCallback(DFM_GETDEFSTATICID, 0, &forceDfm)) && forceDfm)
930 {
931 for (UINT i = 0; i < _countof(g_StaticInvokeCmdMap); ++i)
932 {
933 UINT menuItemId = g_StaticInvokeCmdMap[i].IntVerb + DfltOffset - DCM_FCIDM_SHVIEW_OFFSET;
934 if (g_StaticInvokeCmdMap[i].DfmCmd == forceDfm &&
935 SetMenuDefaultItem(hMenu, menuItemId, MF_BYCOMMAND))
936 {
937 return;
938 }
939 }
940 }
941
942 // Don't want to pick something like cut or delete as the default but
943 // a static or dynamic verb is a good default.
945 SetMenuDefaultItem(hMenu, idCmdFirst, MF_BYCOMMAND);
946}
947
949WINAPI
951 HMENU hMenu,
952 UINT IndexMenu,
953 UINT idCmdFirst,
954 UINT idCmdLast,
955 UINT uFlags)
956{
957 HRESULT hr;
958 UINT idCmdNext = m_iIdQCMFirst = idCmdFirst;
959 UINT cIds = 0;
960
961 TRACE("BuildShellItemContextMenu entered\n");
962
963 /* Load static verbs and shell extensions from registry */
964 for (UINT i = 0; i < m_cKeys && !(uFlags & CMF_NOVERBS); i++)
965 {
968 }
969
970 /* Add static context menu handlers */
971 cIds = AddStaticContextMenusToMenu(hMenu, &IndexMenu, idCmdFirst, idCmdLast, uFlags);
972 m_iIdSCMFirst = 0; // FIXME: This should be = idCmdFirst?
973 m_iIdSCMLast = cIds;
974 idCmdNext = idCmdFirst + cIds;
975
976 /* Add dynamic context menu handlers */
977 cIds += AddShellExtensionsToMenu(hMenu, &IndexMenu, idCmdNext, idCmdLast, uFlags);
979 m_iIdSHELast = cIds;
980 idCmdNext = idCmdFirst + cIds;
981 TRACE("SH_LoadContextMenuHandlers first %x last %x\n", m_iIdSHEFirst, m_iIdSHELast);
982
983 /* Now let the callback add its own items */
984 QCMINFO qcminfo = {hMenu, IndexMenu, idCmdNext, idCmdLast, NULL};
986 {
987 UINT added = qcminfo.idCmdFirst - idCmdNext;
988 cIds += added;
989 IndexMenu += added;
991 m_iIdCBLast = cIds;
992 idCmdNext = idCmdFirst + cIds;
993 }
994
995 //TODO: DFM_MERGECONTEXTMENU_BOTTOM
996
997 UINT idDefaultOffset = 0;
998 BOOL isBackgroundMenu = !m_cidl;
999 if (!(uFlags & CMF_VERBSONLY) && !isBackgroundMenu)
1000 {
1001 /* Get the attributes of the items */
1002 SFGAOF rfg = SFGAO_BROWSABLE | SFGAO_CANCOPY | SFGAO_CANLINK | SFGAO_CANMOVE | SFGAO_CANDELETE | SFGAO_CANRENAME | SFGAO_HASPROPSHEET | SFGAO_FILESYSTEM | SFGAO_FOLDER;
1003 hr = m_psf->GetAttributesOf(m_cidl, m_apidl, &rfg);
1005 return MAKE_HRESULT(SEVERITY_SUCCESS, 0, cIds);
1006
1007 /* Add the default part of the menu */
1008 HMENU hmenuDefault = LoadMenuW(_AtlBaseModule.GetResourceInstance(), L"MENU_SHV_FILE");
1009
1010 /* Remove uneeded entries */
1011 if (!(rfg & SFGAO_CANMOVE))
1012 DeleteMenu(hmenuDefault, IDM_CUT, MF_BYCOMMAND);
1013 if (!(rfg & SFGAO_CANCOPY))
1014 DeleteMenu(hmenuDefault, IDM_COPY, MF_BYCOMMAND);
1015 if (!((rfg & SFGAO_FILESYSTEM) && HasClipboardData()))
1016 DeleteMenu(hmenuDefault, IDM_INSERT, MF_BYCOMMAND);
1017 if (!(rfg & SFGAO_CANLINK))
1018 DeleteMenu(hmenuDefault, IDM_CREATELINK, MF_BYCOMMAND);
1019 if (!(rfg & SFGAO_CANDELETE))
1020 DeleteMenu(hmenuDefault, IDM_DELETE, MF_BYCOMMAND);
1021 if (!(rfg & SFGAO_CANRENAME) || !(uFlags & CMF_CANRENAME))
1022 DeleteMenu(hmenuDefault, IDM_RENAME, MF_BYCOMMAND);
1023 if (!(rfg & SFGAO_HASPROPSHEET))
1024 DeleteMenu(hmenuDefault, IDM_PROPERTIES, MF_BYCOMMAND);
1025
1026 idDefaultOffset = idCmdNext;
1027 UINT idMax = Shell_MergeMenus(hMenu, GetSubMenu(hmenuDefault, 0), IndexMenu, idCmdNext, idCmdLast, 0);
1028 m_iIdDfltFirst = cIds;
1029 cIds += idMax - idCmdNext;
1030 m_iIdDfltLast = cIds;
1031
1032 DestroyMenu(hmenuDefault);
1033 }
1034
1035 TryPickDefault(hMenu, idCmdFirst, idDefaultOffset, uFlags);
1036
1037 // TODO: DFM_MERGECONTEXTMENU_TOP
1038
1039 // TODO: Remove duplicate verbs. This will be easier when the static items handling
1040 // has been moved to CLSID_ShellFileDefExt so we only have to deal with ShellEx.
1041 // This is a Windows XP+ feature. On an unknown file type, Windows 2000 will
1042 // display both "Open" (openas from Unknown) and "Open with..." (openas from *).
1043
1044 return MAKE_HRESULT(SEVERITY_SUCCESS, 0, cIds);
1045}
1046
1048{
1049 HRESULT hr;
1050
1052 hr = OleGetClipboard(&pda);
1054 return hr;
1055
1056 FORMATETC formatetc2;
1057 STGMEDIUM medium2;
1059
1060 DWORD dwKey= 0;
1061
1062 if (SUCCEEDED(pda->GetData(&formatetc2, &medium2)))
1063 {
1064 DWORD * pdwFlag = (DWORD*)GlobalLock(medium2.hGlobal);
1065 if (pdwFlag)
1066 {
1067 if (*pdwFlag == DROPEFFECT_COPY)
1068 dwKey = MK_CONTROL;
1069 else
1070 dwKey = MK_SHIFT;
1071 }
1072 else
1073 {
1074 ERR("No drop effect obtained\n");
1075 }
1076 GlobalUnlock(medium2.hGlobal);
1077 }
1078
1079 if (bLink)
1080 {
1081 dwKey = MK_CONTROL|MK_SHIFT;
1082 }
1083
1085 if (m_cidl)
1086 hr = m_psf->GetUIObjectOf(NULL, 1, &m_apidl[0], IID_NULL_PPV_ARG(IDropTarget, &pdrop));
1087 else
1088 hr = m_psf->CreateViewObject(NULL, IID_PPV_ARG(IDropTarget, &pdrop));
1089
1091 return hr;
1092
1093 SHSimulateDrop(pdrop, pda, dwKey, NULL, NULL);
1094
1095 TRACE("CP result %x\n", hr);
1096 return S_OK;
1097}
1098
1099HRESULT
1101{
1103 return E_FAIL;
1104}
1105
1107{
1108 if (!m_cidl || !m_pDataObj)
1109 return E_FAIL;
1110
1112 HRESULT hr = m_psf->CreateViewObject(NULL, IID_PPV_ARG(IDropTarget, &pDT));
1114 return hr;
1115
1117
1118 return S_OK;
1119}
1120
1122{
1123 if (!m_cidl || !m_pDataObj)
1124 return E_FAIL;
1125
1129 return hr;
1130
1131 DWORD grfKeyState = (lpcmi->fMask & CMIC_MASK_SHIFT_DOWN) ? MK_SHIFT : 0;
1132 SHSimulateDrop(pDT, m_pDataObj, grfKeyState, NULL, NULL);
1133
1134 return S_OK;
1135}
1136
1138{
1139 if (!m_cidl || !m_pDataObj)
1140 return E_FAIL;
1141
1142 FORMATETC formatetc;
1144 STGMEDIUM medium = {0};
1145 medium.tymed = TYMED_HGLOBAL;
1146 medium.hGlobal = GlobalAlloc(GHND, sizeof(DWORD));
1147 DWORD* pdwFlag = (DWORD*)GlobalLock(medium.hGlobal);
1148 if (pdwFlag)
1149 *pdwFlag = bCopy ? DROPEFFECT_COPY : DROPEFFECT_MOVE;
1150 GlobalUnlock(medium.hGlobal);
1151 m_pDataObj->SetData(&formatetc, &medium, TRUE);
1152
1154 if (SUCCEEDED(IUnknown_QueryService(m_site, SID_SFolderView, IID_PPV_ARG(IShellFolderView, &psfv))))
1155 psfv->SetPoints(m_pDataObj);
1156
1159 return hr;
1160
1161 if (psfv)
1162 psfv->SetClipboard(!bCopy);
1163 return S_OK;
1164}
1165
1167{
1169 HRESULT hr;
1170
1171 if (!m_site || !m_cidl)
1172 return E_FAIL;
1173
1174 /* Get a pointer to the shell browser */
1177 return hr;
1178
1180 hr = psb->QueryActiveShellView(&lpSV);
1182 return hr;
1183
1184 SVSIF selFlags = SVSI_DESELECTOTHERS | SVSI_EDIT | SVSI_ENSUREVISIBLE | SVSI_FOCUSED | SVSI_SELECT;
1185 hr = lpSV->SelectItem(m_apidl[0], selFlags);
1187 return hr;
1188
1189 return S_OK;
1190}
1191
1192HRESULT
1195{
1197
1198 // We are asked to run the default property sheet
1199 if (hr == S_FALSE)
1200 {
1202 }
1203
1204 return hr;
1205}
1206
1207HRESULT
1209{
1210 ERR("TODO: Undo\n");
1211 return E_NOTIMPL;
1212}
1213
1214HRESULT
1216{
1217 HRESULT hr = E_FAIL;
1218 if (!m_pDataObj)
1219 {
1220 ERR("m_pDataObj is NULL\n");
1221 return hr;
1222 }
1223
1224 CComPtr<IContextMenu> pContextMenu;
1225 if (bCopy)
1226 hr = SHCoCreateInstance(NULL, &CLSID_CopyToMenu, NULL,
1227 IID_PPV_ARG(IContextMenu, &pContextMenu));
1228 else
1229 hr = SHCoCreateInstance(NULL, &CLSID_MoveToMenu, NULL,
1230 IID_PPV_ARG(IContextMenu, &pContextMenu));
1232 return hr;
1233
1235 hr = pContextMenu->QueryInterface(IID_PPV_ARG(IShellExtInit, &pInit));
1237 return hr;
1238
1239 hr = pInit->Initialize(m_pidlFolder, m_pDataObj, NULL);
1241 return hr;
1242
1243 if (bCopy)
1244 lpici->lpVerb = "copyto";
1245 else
1246 lpici->lpVerb = "moveto";
1247
1248 return pContextMenu->InvokeCommand((LPCMINVOKECOMMANDINFO)lpici);
1249}
1250
1251// This code is taken from CNewMenu and should be shared between the 2 classes
1252HRESULT
1255{
1256 WCHAR wszPath[MAX_PATH];
1257 WCHAR wszName[MAX_PATH];
1258 WCHAR wszNewFolder[25];
1259 HRESULT hr;
1260
1261 /* Get folder path */
1264 return hr;
1265
1266 if (!LoadStringW(shell32_hInstance, IDS_NEWFOLDER, wszNewFolder, _countof(wszNewFolder)))
1267 return E_FAIL;
1268
1269 /* Create the name of the new directory */
1270 if (!PathYetAnotherMakeUniqueName(wszName, wszPath, NULL, wszNewFolder))
1271 return E_FAIL;
1272
1273 /* Create the new directory and show the appropriate dialog in case of error */
1274 if (SHCreateDirectory(lpici->hwnd, wszName) != ERROR_SUCCESS)
1275 return E_FAIL;
1276
1277 /* Show and select the new item in the def view */
1278 LPITEMIDLIST pidl;
1279 PITEMID_CHILD pidlNewItem;
1281
1282 /* Notify the view object about the new item */
1284
1285 if (!m_site)
1286 return S_OK;
1287
1288 /* Get a pointer to the shell view */
1289 hr = IUnknown_QueryService(m_site, SID_SFolderView, IID_PPV_ARG(IShellView, &psv));
1291 return S_OK;
1292
1293 /* Attempt to get the pidl of the new item */
1294 hr = SHILCreateFromPathW(wszName, &pidl, NULL);
1296 return hr;
1297
1298 pidlNewItem = ILFindLastID(pidl);
1299
1300 hr = psv->SelectItem(pidlNewItem, SVSI_DESELECTOTHERS | SVSI_EDIT | SVSI_ENSUREVISIBLE |
1301 SVSI_FOCUSED | SVSI_SELECT);
1303 return hr;
1304
1305 SHFree(pidl);
1306
1307 return S_OK;
1308}
1309
1311{
1312 POSITION it = m_DynamicEntries.GetHeadPosition();
1313 while (it != NULL)
1314 {
1316
1317 if (idCmd >= info.iIdCmdFirst + info.NumIds)
1318 continue;
1319
1320 if (idCmd < info.iIdCmdFirst || idCmd > info.iIdCmdFirst + info.NumIds)
1321 return NULL;
1322
1323 return &info;
1324 }
1325
1326 return NULL;
1327}
1328
1329BOOL
1331{
1332 WCHAR UnicodeStr[MAX_VERB];
1333
1334 /* Loop through all the static verbs looking for a match */
1335 for (UINT i = 0; i < _countof(g_StaticInvokeCmdMap); i++)
1336 {
1337 /* We can match both ANSI and unicode strings */
1338 if (IsUnicode)
1339 {
1340 /* The static verbs are ANSI, get a unicode version before doing the compare */
1341 SHAnsiToUnicode(g_StaticInvokeCmdMap[i].szStringVerb, UnicodeStr, MAX_VERB);
1342 if (!_wcsicmp(UnicodeStr, (LPWSTR)Verb))
1343 {
1344 /* Return the Corresponding Id */
1345 *idCmd = g_StaticInvokeCmdMap[i].IntVerb;
1346 return TRUE;
1347 }
1348 }
1349 else
1350 {
1351 if (!_stricmp(g_StaticInvokeCmdMap[i].szStringVerb, (LPSTR)Verb))
1352 {
1353 *idCmd = g_StaticInvokeCmdMap[i].IntVerb;
1354 return TRUE;
1355 }
1356 }
1357 }
1358
1359 for (POSITION it = m_DynamicEntries.GetHeadPosition(); it != NULL;)
1360 {
1362 if (!entry.NumIds)
1363 continue;
1364 HRESULT hr = ::MapVerbToCmdId(Verb, IsUnicode, entry.pCM, 0, entry.NumIds - 1);
1365 if (SUCCEEDED(hr))
1366 {
1367 *idCmd = m_iIdSHEFirst + entry.iIdCmdFirst + hr;
1368 return TRUE;
1369 }
1370 }
1371 return FALSE;
1372}
1373
1374HRESULT
1377{
1378 TRACE("verb %p first %x last %x\n", lpcmi->lpVerb, m_iIdSHEFirst, m_iIdSHELast);
1379
1380 UINT idCmd = LOWORD(lpcmi->lpVerb);
1382 if (!pEntry)
1383 return E_FAIL;
1384
1385 /* invoke the dynamic context menu */
1386 lpcmi->lpVerb = MAKEINTRESOURCEA(idCmd - pEntry->iIdCmdFirst);
1387 return pEntry->pCM->InvokeCommand((LPCMINVOKECOMMANDINFO)lpcmi);
1388}
1389
1390DWORD
1392{
1394 HWND hwndTree;
1395 LPCWSTR FlagsName;
1396 WCHAR wszKey[sizeof("shell\\") + MAX_VERB];
1397 HRESULT hr;
1398
1399 if (!m_site)
1400 return 0;
1401
1402 /* Get a pointer to the shell browser */
1404 if (FAILED(hr))
1405 return 0;
1406
1407 /* See if we are in Explore or Browse mode. If the browser's tree is present, we are in Explore mode.*/
1408 if (SUCCEEDED(psb->GetControlWindow(FCW_TREE, &hwndTree)) && hwndTree)
1409 FlagsName = L"ExplorerFlags";
1410 else
1411 FlagsName = L"BrowserFlags";
1412
1414 if (SUCCEEDED(psb->QueryInterface(IID_PPV_ARG(ICommDlgBrowser, &pcdb))))
1415 {
1416 if (LOBYTE(GetVersion()) < 6 || FlagsName[0] == 'E')
1417 return 0; // Don't browse in-place
1418 }
1419
1420 /* Try to get the flag from the verb */
1421 hr = StringCbPrintfW(wszKey, sizeof(wszKey), L"shell\\%s", pEntry->Verb.GetString());
1423 return 0;
1424 return RegGetDword(pEntry->hkClass, wszKey, FlagsName, 0);
1425}
1426
1427HRESULT
1430{
1432 HRESULT hr;
1433
1434 if (!m_site)
1435 return E_FAIL;
1436
1437 /* Get a pointer to the shell browser */
1439 if (FAILED(hr))
1440 return hr;
1441
1442 PIDLIST_ABSOLUTE pidl;
1443 hr = SHILCombine(m_pidlFolder, pidlChild, &pidl);
1445 return hr;
1446
1447 hr = psb->BrowseObject(pidl, wFlags & ~SBSP_RELATIVE);
1448 ILFree(pidl);
1449 return hr;
1450}
1451
1452HRESULT
1454{
1455 const BOOL unicode = IsUnicode(*lpcmi);
1456
1457 LPITEMIDLIST pidlFull = ILCombine(m_pidlFolder, pidl);
1458 if (pidlFull == NULL)
1459 {
1460 return E_FAIL;
1461 }
1462
1463 WCHAR wszPath[MAX_PATH];
1464 BOOL bHasPath = SHGetPathFromIDListW(pidlFull, wszPath);
1465
1466 WCHAR wszDir[MAX_PATH];
1467
1468 SHELLEXECUTEINFOW sei = { sizeof(sei) };
1469 sei.fMask = SEE_MASK_CLASSKEY | SEE_MASK_IDLIST | (CmicFlagsToSeeFlags(lpcmi->fMask) & ~SEE_MASK_INVOKEIDLIST);
1470 sei.hwnd = lpcmi->hwnd;
1471 sei.nShow = lpcmi->nShow;
1472 sei.lpVerb = pEntry->Verb;
1473 sei.lpIDList = pidlFull;
1474 sei.hkeyClass = pEntry->hkClass;
1475 sei.dwHotKey = lpcmi->dwHotKey;
1476 sei.hIcon = lpcmi->hIcon;
1477 sei.lpDirectory = wszDir;
1478
1479 if (unicode && !StrIsNullOrEmpty(lpcmi->lpDirectoryW))
1480 {
1481 sei.lpDirectory = lpcmi->lpDirectoryW;
1482 }
1483 else if (bHasPath)
1484 {
1485 wcscpy(wszDir, wszPath);
1486 PathRemoveFileSpec(wszDir);
1487 }
1488 else
1489 {
1490 if (!SHGetPathFromIDListW(m_pidlFolder, wszDir))
1491 *wszDir = UNICODE_NULL;
1492 }
1493
1494 if (bHasPath)
1495 sei.lpFile = wszPath;
1496
1497 CComHeapPtr<WCHAR> pszParamsW;
1498 if (unicode && !StrIsNullOrEmpty(lpcmi->lpParametersW))
1499 sei.lpParameters = lpcmi->lpParametersW;
1500 else if (!StrIsNullOrEmpty(lpcmi->lpParameters) && __SHCloneStrAtoW(&pszParamsW, lpcmi->lpParameters))
1501 sei.lpParameters = pszParamsW;
1502
1503 if (!sei.lpClass && (lpcmi->fMask & (CMIC_MASK_HASLINKNAME | CMIC_MASK_HASTITLE)) && unicode)
1504 sei.lpClass = lpcmi->lpTitleW; // Forward .lnk path from CShellLink::DoOpen (for consrv STARTF_TITLEISLINKNAME)
1505
1507 ILFree(pidlFull);
1508 return hr;
1509}
1510
1511HRESULT
1514{
1515 INT iCmd = LOWORD(lpcmi->lpVerb);
1516 HRESULT hr;
1517 UINT i;
1518
1519 POSITION it = m_StaticEntries.FindIndex(iCmd);
1520
1521 if (it == NULL)
1522 return E_INVALIDARG;
1523
1525
1526 CRegKey VerbKey;
1527 WCHAR VerbKeyPath[sizeof("shell\\") + MAX_VERB];
1528 hr = StringCbPrintfW(VerbKeyPath, sizeof(VerbKeyPath), L"shell\\%s", pEntry->Verb.GetString());
1529 if (SUCCEEDED(hr) && m_pDataObj &&
1530 VerbKey.Open(pEntry->hkClass, VerbKeyPath, KEY_READ) == ERROR_SUCCESS)
1531 {
1532 CLSID clsid;
1533
1534 DWORD KeyState = 0;
1535 if (lpcmi->fMask & CMIC_MASK_SHIFT_DOWN)
1536 KeyState |= MK_SHIFT;
1537 if (lpcmi->fMask & CMIC_MASK_CONTROL_DOWN)
1538 KeyState |= MK_CONTROL;
1539
1540 POINTL *pPtl = NULL;
1541 C_ASSERT(sizeof(POINT) == sizeof(POINTL));
1542 if (lpcmi->fMask & CMIC_MASK_PTINVOKE)
1543 pPtl = (POINTL*)&lpcmi->ptInvoke;
1544
1546 hr = SHELL_GetRegCLSID(VerbKey, L"command", L"DelegateExecute", clsid);
1547 if (SUCCEEDED(hr))
1548 hr = CoCreateInstance(clsid, NULL, CLSCTX_ALL, IID_PPV_ARG(IExecuteCommand, &pEC));
1549 if (SUCCEEDED(hr))
1550 {
1553 return InvokeIExecuteCommandWithDataObject(pEC, pEntry->Verb.GetString(), pPB, m_pDataObj,
1554 lpcmi, static_cast<IContextMenu*>(this));
1555 }
1556
1558 hr = SHELL_GetRegCLSID(VerbKey, L"DropTarget", L"CLSID", clsid);
1559 if (SUCCEEDED(hr))
1560 hr = CoCreateInstance(clsid, NULL, CLSCTX_ALL, IID_PPV_ARG(IDropTarget, &pDT));
1561 if (SUCCEEDED(hr))
1562 {
1565 IUnknown_SetSite(pDT, static_cast<IContextMenu*>(this));
1566 IUnknown_InitializeCommand(pDT, pEntry->Verb.GetString(), pPB);
1567 hr = SHSimulateDrop(pDT, m_pDataObj, KeyState, pPtl, NULL);
1568 IUnknown_SetSite(pDT, NULL);
1569 return hr;
1570 }
1571 }
1572
1573 /* Get the browse flags to see if we need to browse */
1575
1576 for (i=0; i < m_cidl; i++)
1577 {
1578 /* Check if we need to browse */
1579 if (wFlags)
1580 {
1581 hr = TryToBrowse(lpcmi, m_apidl[i], wFlags);
1582 if (SUCCEEDED(hr))
1583 {
1584 /* In WinXP if we have browsed, we don't open any more folders.
1585 * In Win7 we browse to the first folder we find and
1586 * open new windows for each of the rest of the folders */
1588 if (ntver >= _WIN32_WINNT_VISTA)
1589 wFlags = 0; // FIXME: = SBSP_NEWBROWSER | (wFlags & ~SBSP_SAMEBROWSER);
1590 else
1591 i = m_cidl;
1592
1593 continue;
1594 }
1595 }
1596
1597 InvokePidl(lpcmi, m_apidl[i], pEntry);
1598 }
1599
1600 return S_OK;
1601}
1602
1603HRESULT
1605 LPCMINVOKECOMMANDINFOEX lpcmi, WPARAM CmdId)
1606{
1607 BOOL Unicode = IsUnicode(*lpcmi);
1608 WCHAR lParamBuf[MAX_PATH];
1609 LPARAM lParam = 0;
1610
1611 if (Unicode && lpcmi->lpParametersW)
1612 lParam = (LPARAM)lpcmi->lpParametersW;
1613 else if (lpcmi->lpParameters)
1614 lParam = SHAnsiToUnicode(lpcmi->lpParameters, lParamBuf, _countof(lParamBuf)) ? (LPARAM)lParamBuf : 0;
1615
1616 HRESULT hr;
1617#if 0 // TODO: Try DFM_INVOKECOMMANDEX first.
1618 DFMICS dfmics = { sizeof(DFMICS), lpcmi->fMask, lParam, m_iIdSCMFirst?, m_iIdDfltLast?, (LPCMINVOKECOMMANDINFO)lpcmi, m_site };
1619 hr = _DoCallback(DFM_INVOKECOMMANDEX, CmdId, &dfmics);
1620 if (hr == E_NOTIMPL)
1621#endif
1622 hr = _DoCallback(DFM_INVOKECOMMAND, CmdId, (void*)lParam);
1623 return hr;
1624}
1625
1626HRESULT
1627WINAPI
1630{
1631 CMINVOKECOMMANDINFOEX LocalInvokeInfo = {};
1633 UINT CmdId;
1634
1635 /* Take a local copy of the fixed members of the
1636 struct as we might need to modify the verb */
1637 memcpy(&LocalInvokeInfo, lpcmi, min(sizeof(LocalInvokeInfo), lpcmi->cbSize));
1638
1639 /* Check if this is a string verb */
1640 if (!IS_INTRESOURCE(LocalInvokeInfo.lpVerb))
1641 {
1642 /* Get the ID which corresponds to this verb, and update our local copy */
1643 if (MapVerbToCmdId((LPVOID)LocalInvokeInfo.lpVerb, &CmdId, FALSE))
1644 LocalInvokeInfo.lpVerb = MAKEINTRESOURCEA(CmdId);
1645 else
1646 return E_INVALIDARG;
1647 }
1648 CmdId = LOWORD(LocalInvokeInfo.lpVerb);
1649
1650 if (!m_DynamicEntries.IsEmpty() && CmdId >= m_iIdSHEFirst && CmdId < m_iIdSHELast)
1651 {
1652 LocalInvokeInfo.lpVerb -= m_iIdSHEFirst;
1653 Result = InvokeShellExt(&LocalInvokeInfo);
1654 return Result;
1655 }
1656
1657 if (!m_StaticEntries.IsEmpty() && CmdId >= m_iIdSCMFirst && CmdId < m_iIdSCMLast)
1658 {
1659 LocalInvokeInfo.lpVerb -= m_iIdSCMFirst;
1660 Result = InvokeRegVerb(&LocalInvokeInfo);
1661 // TODO: if (FAILED(Result) && !(lpcmi->fMask & CMIC_MASK_FLAG_NO_UI)) SHELL_ErrorBox(m_pSite, Result);
1662 return Result;
1663 }
1664
1665 if (m_iIdCBFirst != m_iIdCBLast && CmdId >= m_iIdCBFirst && CmdId < m_iIdCBLast)
1666 {
1667 Result = _DoInvokeCommandCallback(&LocalInvokeInfo, CmdId - m_iIdCBFirst);
1668 return Result;
1669 }
1670
1671 if (m_iIdDfltFirst != m_iIdDfltLast && CmdId >= m_iIdDfltFirst && CmdId < m_iIdDfltLast)
1672 {
1673 CmdId -= m_iIdDfltFirst;
1674 /* See the definitions of IDM_CUT and co to see how this works */
1675 CmdId += DCM_FCIDM_SHVIEW_OFFSET;
1676 }
1677
1678 if (LocalInvokeInfo.cbSize >= sizeof(CMINVOKECOMMANDINFOEX) && (LocalInvokeInfo.fMask & CMIC_MASK_PTINVOKE))
1679 {
1680 if (m_pDataObj && FAILED_UNEXPECTEDLY(DataObject_SetOffset(m_pDataObj, &LocalInvokeInfo.ptInvoke)))
1681 {
1682 ERR("Unable to add OFFSET to DataObject!\n");
1683 }
1684 }
1685
1686 /* Check if this is a Id */
1687 switch (CmdId)
1688 {
1690 Result = DoPaste(&LocalInvokeInfo, FALSE);
1691 break;
1693 Result = DoPaste(&LocalInvokeInfo, TRUE);
1694 break;
1695 case FCIDM_SHVIEW_OPEN:
1697 Result = DoOpenOrExplore(&LocalInvokeInfo);
1698 break;
1699 case FCIDM_SHVIEW_COPY:
1700 case FCIDM_SHVIEW_CUT:
1701 Result = DoCopyOrCut(&LocalInvokeInfo, CmdId == FCIDM_SHVIEW_COPY);
1702 break;
1704 Result = DoCreateLink(&LocalInvokeInfo);
1705 break;
1707 Result = DoDelete(&LocalInvokeInfo);
1708 break;
1710 Result = DoRename(&LocalInvokeInfo);
1711 break;
1713 Result = DoProperties(&LocalInvokeInfo);
1714 break;
1716 Result = DoCreateNewFolder(&LocalInvokeInfo);
1717 break;
1719 Result = DoCopyToMoveToFolder(&LocalInvokeInfo, TRUE);
1720 break;
1722 Result = DoCopyToMoveToFolder(&LocalInvokeInfo, FALSE);
1723 break;
1724 case FCIDM_SHVIEW_UNDO:
1725 Result = DoUndo(&LocalInvokeInfo);
1726 break;
1727 default:
1729 ERR("Unhandled Verb %xl\n", LOWORD(LocalInvokeInfo.lpVerb));
1730 break;
1731 }
1732
1733 return Result;
1734}
1735
1736HRESULT
1737WINAPI
1739 UINT_PTR idCommand,
1740 UINT uFlags,
1742 LPSTR lpszName,
1743 UINT uMaxNameLen)
1744{
1745 /* We don't handle the help text yet */
1746 if (uFlags == GCS_HELPTEXTA ||
1747 uFlags == GCS_HELPTEXTW ||
1748 HIWORD(idCommand) != 0)
1749 {
1750 return E_NOTIMPL;
1751 }
1752
1753 UINT CmdId = LOWORD(idCommand);
1754
1755 if (!m_DynamicEntries.IsEmpty() && CmdId >= m_iIdSHEFirst && CmdId < m_iIdSHELast)
1756 {
1757 idCommand -= m_iIdSHEFirst;
1759 if (!pEntry)
1760 return E_FAIL;
1761
1762 idCommand -= pEntry->iIdCmdFirst;
1763 return pEntry->pCM->GetCommandString(idCommand,
1764 uFlags,
1765 lpReserved,
1766 lpszName,
1767 uMaxNameLen);
1768 }
1769
1770 if (!m_StaticEntries.IsEmpty() && CmdId >= m_iIdSCMFirst && CmdId < m_iIdSCMLast)
1771 {
1772 /* Validation just returns S_OK on a match. The id exists. */
1773 if (uFlags == GCS_VALIDATEA || uFlags == GCS_VALIDATEW)
1774 return S_OK;
1775
1776 CmdId -= m_iIdSCMFirst;
1777
1778 POSITION it = m_StaticEntries.FindIndex(CmdId);
1779
1780 if (it == NULL)
1781 return E_INVALIDARG;
1782
1784
1785 if (uFlags == GCS_VERBW)
1786 return StringCchCopyW((LPWSTR)lpszName, uMaxNameLen, pEntry->Verb);
1787
1788 if (uFlags == GCS_VERBA)
1789 {
1790 if (SHUnicodeToAnsi(pEntry->Verb, lpszName, uMaxNameLen))
1791 return S_OK;
1792 }
1793
1794 return E_INVALIDARG;
1795 }
1796
1797 //FIXME: Should we handle callbacks here?
1798 if (m_iIdDfltFirst != m_iIdDfltLast && CmdId >= m_iIdDfltFirst && CmdId < m_iIdDfltLast)
1799 {
1800 CmdId -= m_iIdDfltFirst;
1801 /* See the definitions of IDM_CUT and co to see how this works */
1802 CmdId += DCM_FCIDM_SHVIEW_OFFSET;
1803 }
1804
1805 /* Loop looking for a matching Id */
1806 for (UINT i = 0; i < _countof(g_StaticInvokeCmdMap); i++)
1807 {
1808 if (g_StaticInvokeCmdMap[i].IntVerb == CmdId)
1809 {
1810 /* Validation just returns S_OK on a match */
1811 if (uFlags == GCS_VALIDATEA || uFlags == GCS_VALIDATEW)
1812 return S_OK;
1813
1814 /* Return a copy of the ANSI verb */
1815 if (uFlags == GCS_VERBA)
1816 return StringCchCopyA(lpszName, uMaxNameLen, g_StaticInvokeCmdMap[i].szStringVerb);
1817
1818 /* Convert the ANSI verb to unicode and return that */
1819 if (uFlags == GCS_VERBW)
1820 {
1821 if (SHAnsiToUnicode(g_StaticInvokeCmdMap[i].szStringVerb, (LPWSTR)lpszName, uMaxNameLen))
1822 return S_OK;
1823 }
1824 }
1825 }
1826
1827 return E_INVALIDARG;
1828}
1829
1830HRESULT
1831WINAPI
1833 UINT uMsg,
1834 WPARAM wParam,
1835 LPARAM lParam)
1836{
1837 return HandleMenuMsg2(uMsg, wParam, lParam, NULL);
1838}
1839
1841{
1842 if (uMsg == WM_DRAWITEM)
1843 {
1844 DRAWITEMSTRUCT* pDrawStruct = reinterpret_cast<DRAWITEMSTRUCT*>(lParam);
1845 *CmdId = pDrawStruct->itemID;
1846 return S_OK;
1847 }
1848 else if (uMsg == WM_MEASUREITEM)
1849 {
1850 MEASUREITEMSTRUCT* pMeasureStruct = reinterpret_cast<MEASUREITEMSTRUCT*>(lParam);
1851 *CmdId = pMeasureStruct->itemID;
1852 return S_OK;
1853 }
1854 return E_FAIL;
1855}
1856
1857HRESULT
1858WINAPI
1860 UINT uMsg,
1861 WPARAM wParam,
1862 LPARAM lParam,
1863 LRESULT *plResult)
1864{
1865 if (!SHELL_IsContextMenuMsg(uMsg))
1866 return E_FAIL;
1867
1868 UINT CmdId;
1869 if (uMsg == WM_INITMENUPOPUP)
1870 {
1871 CmdId = GetMenuItemID((HMENU)wParam, 0);
1872 if (CmdId == ~0ul)
1873 return E_FAIL;
1874 }
1875 else
1876 {
1877 HRESULT hr = SHGetMenuIdFromMenuMsg(uMsg, lParam, &CmdId);
1878 if (FAILED(hr))
1879 return S_FALSE;
1880 }
1881 CmdId -= m_iIdQCMFirst; // Convert from Win32 id to our base
1882
1883 if (CmdId >= m_iIdSHEFirst && CmdId < m_iIdSHELast)
1884 {
1886 return SHForwardContextMenuMsg(pEntry->pCM, uMsg, wParam, lParam, plResult, TRUE);
1887 }
1888 // TODO: _DoCallback(DFM_WM_*, ...)
1889 return E_FAIL;
1890}
1891
1892HRESULT
1893WINAPI
1895{
1896 m_site = pUnkSite;
1897 return S_OK;
1898}
1899
1900HRESULT
1901WINAPI
1903{
1904 if (!m_site)
1905 return E_FAIL;
1906
1907 return m_site->QueryInterface(riid, ppvSite);
1908}
1909
1910static
1911HRESULT
1913{
1914 return ShellObjectCreatorInit<CDefaultContextMenu>(pdcm, lpfn, riid, ppv);
1915}
1916
1917/*************************************************************************
1918 * SHCreateDefaultContextMenu [SHELL32.325] Vista API
1919 *
1920 */
1921
1922HRESULT
1923WINAPI
1925{
1926 HRESULT hr;
1927
1928 if (!ppv)
1929 return E_INVALIDARG;
1930
1933 return hr;
1934
1935 return S_OK;
1936}
1937
1938/*************************************************************************
1939 * CDefFolderMenu_Create2 [SHELL32.701]
1940 *
1941 */
1942
1943HRESULT
1944WINAPI
1946 PCIDLIST_ABSOLUTE pidlFolder,
1947 HWND hwnd,
1948 UINT cidl,
1950 IShellFolder *psf,
1951 LPFNDFMCALLBACK lpfn,
1952 UINT nKeys,
1953 const HKEY *ahkeyClsKeys,
1954 IContextMenu **ppcm)
1955{
1956 DEFCONTEXTMENU dcm;
1957 dcm.hwnd = hwnd;
1958 dcm.pcmcb = NULL;
1959 dcm.pidlFolder = pidlFolder;
1960 dcm.psf = psf;
1961 dcm.cidl = cidl;
1962 dcm.apidl = apidl;
1964 dcm.cKeys = nKeys;
1965 dcm.aKeys = ahkeyClsKeys;
1966
1969 return hr;
1970
1971 return S_OK;
1972}
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)
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:1731
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:337
HRESULT WINAPI SHExtCoCreateInstance(_In_opt_ LPCWSTR aclsid, _In_opt_ const CLSID *clsid, _In_opt_ LPUNKNOWN pUnkOuter, _In_ REFIID refiid, _Out_ LPVOID *ppv)
Definition: shellole.c:196
HRESULT WINAPI SHCoCreateInstance(LPCWSTR aclsid, const CLSID *clsid, LPUNKNOWN pUnkOuter, REFIID refiid, LPVOID *ppv)
Definition: shellole.c:105
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 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:194
#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:679
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:2616
#define CFSTR_SHELLIDLIST
Definition: shlobj.h:558
#define CFSTR_PREFERREDDROPEFFECT
Definition: shlobj.h:568
#define SHCNE_MKDIR
Definition: shlobj.h:1901
#define DFM_CMD_NEWFOLDER
Definition: shlobj.h:2621
#define DFM_CMD_COPY
Definition: shlobj.h:2618
#define DFM_CMD_PASTE
Definition: shlobj.h:2622
#define SHCNF_FLUSH
Definition: shlobj.h:1936
#define SHCNF_PATHW
Definition: shlobj.h:1933
#define DFM_CMD_PROPERTIES
Definition: shlobj.h:2620
HRESULT(CALLBACK * LPFNDFMCALLBACK)(_In_opt_ IShellFolder *, _In_opt_ HWND, _In_opt_ IDataObject *, UINT, WPARAM, LPARAM)
Definition: shlobj.h:2576
#define DFM_CMD_RENAME
Definition: shlobj.h:2628
RESTRICTIONS
Definition: shlobj.h:1649
#define DFM_CMD_LINK
Definition: shlobj.h:2619
#define PathRemoveFileSpec
Definition: shlwapi.h:1078
DWORD WINAPI SHRestricted(RESTRICTIONS rest)
Definition: shpolicy.c:166
#define FCIDM_SHVIEW_CUT
Definition: shresdef.h:861
#define FCIDM_SHVIEW_OPEN
Definition: shresdef.h:888
#define FCIDM_SHVIEW_UNDO
Definition: shresdef.h:864
#define IDM_DELETE
Definition: shresdef.h:901
#define FCIDM_SHVIEW_COPY
Definition: shresdef.h:862
#define IDS_OPEN_VERB
Definition: shresdef.h:212
#define IDM_INSERT
Definition: shresdef.h:899
#define FCIDM_SHVIEW_INSERTLINK
Definition: shresdef.h:865
#define IDS_FIND_VERB
Definition: shresdef.h:216
#define FCIDM_SHVIEW_NEWFOLDER
Definition: shresdef.h:884
#define IDM_RENAME
Definition: shresdef.h:902
#define IDM_COPY
Definition: shresdef.h:898
#define FCIDM_SHVIEW_EXPLORE
Definition: shresdef.h:887
#define FCIDM_SHVIEW_PROPERTIES
Definition: shresdef.h:860
#define IDS_EXPLORE_VERB
Definition: shresdef.h:213
#define IDM_CUT
Definition: shresdef.h:897
#define IDM_CREATELINK
Definition: shresdef.h:900
#define IDS_PRINT_VERB
Definition: shresdef.h:217
#define FCIDM_SHVIEW_COPYTO
Definition: shresdef.h:866
#define FCIDM_SHVIEW_MOVETO
Definition: shresdef.h:867
#define FCIDM_SHVIEW_DELETE
Definition: shresdef.h:859
#define FCIDM_SHVIEW_RENAME
Definition: shresdef.h:881
#define FCIDM_SHVIEW_CREATELINK
Definition: shresdef.h:882
#define IDS_RUNAS_VERB
Definition: shresdef.h:214
#define IDS_EDIT_VERB
Definition: shresdef.h:215
#define FCIDM_SHVIEW_INSERT
Definition: shresdef.h:863
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:2558
IShellFolder * psf
Definition: shlobj.h:2560
IUnknown * punkAssociationInfo
Definition: shlobj.h:2563
PCUITEMID_CHILD_ARRAY apidl
Definition: shlobj.h:2562
const HKEY * aKeys
Definition: shlobj.h:2565
PCIDLIST_ABSOLUTE pidlFolder
Definition: shlobj.h:2559
IContextMenu * pCM
Definition: precomp.h:185
Definition: dsa.c:45
CComPtr< IContextMenu > pCM
Definition: scsiwmi.h:51
UINT idCmdFirst
Definition: shlobj.h:1400
LPCWSTR lpDirectory
Definition: shellapi.h:340
LPCWSTR lpParameters
Definition: shellapi.h:339
LPWSTR dwTypeData
Definition: winuser.h:3345
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
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:2388
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:1664
#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:1765
#define MK_CONTROL
Definition: winuser.h:2389
#define MF_SEPARATOR
Definition: winuser.h:137
#define MF_BYPOSITION
Definition: winuser.h:203
#define WM_MEASUREITEM
Definition: winuser.h:1665
#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
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