1142 lines
34 KiB
C++
1142 lines
34 KiB
C++
#include "shellprv.h"
|
|
#pragma hdrstop
|
|
|
|
#include <dpa.h>
|
|
#include "ids.h"
|
|
#include "idlcomm.h"
|
|
#include "recdocs.h"
|
|
#include "datautil.h"
|
|
#include "mtpt.h"
|
|
#include <cowsite.h>
|
|
|
|
typedef struct _DKAITEM { // dkai
|
|
HKEY hk;
|
|
TCHAR sz[CCH_KEYMAX];
|
|
} DKAITEM, *PDKAITEM;
|
|
typedef const DKAITEM * PCDKAITEM;
|
|
|
|
class CDKA : public CDSA<DKAITEM>
|
|
{
|
|
public:
|
|
~CDKA();
|
|
UINT AddKeys(HKEY hk, LPCTSTR pszSubKey, PCTSTR pszDefaultOrder);
|
|
|
|
PCTSTR ExposeName(int id)
|
|
{ return GetItemPtr(id)->sz; }
|
|
|
|
HKEY ExposeKey(int id)
|
|
{ return GetItemPtr(id)->hk; }
|
|
|
|
HRESULT GetValue(int id,
|
|
PCTSTR pszSubKey,
|
|
PCTSTR pszValue,
|
|
DWORD *pdwType,
|
|
void *pvData,
|
|
DWORD *pcbData);
|
|
|
|
BOOL DeleteItem(int id);
|
|
BOOL DeleteAllItems();
|
|
void Reset()
|
|
{ if ((HDSA)this) DestroyCallback(_ReleaseItem, NULL); }
|
|
BOOL HasDefault(HKEY hkProgid);
|
|
|
|
protected:
|
|
BOOL _AppendItem(HKEY hk, PDKAITEM pdkai);
|
|
void _AddOrderedKeys(HKEY hk, PCTSTR pszDefOrder);
|
|
void _AddEnumKeys(HKEY hk);
|
|
static int CALLBACK _ReleaseItem(PDKAITEM pdkai, void *pv);
|
|
|
|
protected:
|
|
TRIBIT _tbHasDefault;
|
|
};
|
|
|
|
BOOL CDKA::_AppendItem(HKEY hk, PDKAITEM pdkai)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
// Verify that the key exists before adding it to the list
|
|
if (RegOpenKeyEx(hk, pdkai->sz, 0L, KEY_READ, &pdkai->hk) == ERROR_SUCCESS)
|
|
{
|
|
fRet = (AppendItem(pdkai) >= 0);
|
|
|
|
if (!fRet)
|
|
RegCloseKey(pdkai->hk);
|
|
}
|
|
return fRet;
|
|
}
|
|
|
|
void CDKA::_AddOrderedKeys(HKEY hk, PCTSTR pszDefOrder)
|
|
{
|
|
// First, add the subkeys from the value of the specified key
|
|
// This should never fail, since we just opened this key
|
|
DKAITEM dkai;
|
|
TCHAR szOrder[CCH_KEYMAX * 5];
|
|
LONG cbOrder = CbFromCch(ARRAYSIZE(szOrder));
|
|
*szOrder = 0;
|
|
RegQueryValue(hk, NULL, szOrder, &cbOrder);
|
|
if (*szOrder)
|
|
{
|
|
// now we must find something in this string in order to have a default
|
|
_tbHasDefault = TRIBIT_FALSE;
|
|
}
|
|
else if (pszDefOrder)
|
|
{
|
|
// If there is no value, use the order requested
|
|
// typically "Open" or "Explore Open" in explorer mode
|
|
StrCpyN(szOrder, pszDefOrder, ARRAYSIZE(szOrder));
|
|
}
|
|
|
|
PTSTR psz = szOrder;
|
|
while (psz && *psz)
|
|
{
|
|
// skip the space or comma characters
|
|
while(*psz==TEXT(' ') || *psz==TEXT(','))
|
|
psz++; // NLS Notes: OK to ++
|
|
|
|
if (*psz)
|
|
{
|
|
// Search for the space or comma character
|
|
LPTSTR pszNext = psz + StrCSpn(psz, TEXT(" ,"));
|
|
if (*pszNext) {
|
|
*pszNext++=0; // NLS Notes: OK to ++
|
|
}
|
|
StrCpyN(dkai.sz, psz, ARRAYSIZE(dkai.sz));
|
|
|
|
if (_AppendItem(hk, &dkai))
|
|
_tbHasDefault = TRIBIT_TRUE;
|
|
|
|
psz = pszNext;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDKA::_AddEnumKeys(HKEY hk)
|
|
{
|
|
DKAITEM dkai;
|
|
// Then, append the rest if they are not in the list yet.
|
|
for (int i = 0; RegEnumKey(hk, i, dkai.sz, ARRAYSIZE(dkai.sz)) == ERROR_SUCCESS; i++)
|
|
{
|
|
// Check if the key is already in the list.
|
|
for (int idsa = 0; idsa < GetItemCount(); idsa++)
|
|
{
|
|
PDKAITEM pdkai = GetItemPtr(idsa);
|
|
if (lstrcmpi(dkai.sz, pdkai->sz)==0)
|
|
break;
|
|
}
|
|
|
|
// we made it throug our array
|
|
// so this isnt in there
|
|
if (idsa == GetItemCount())
|
|
_AppendItem(hk, &dkai);
|
|
}
|
|
}
|
|
|
|
UINT CDKA::AddKeys(HKEY hkRoot, LPCTSTR pszSubKey, PCTSTR pszDefaultOrder)
|
|
{
|
|
UINT cKeys = GetItemCount();
|
|
HKEY hk;
|
|
if (ERROR_SUCCESS == RegOpenKeyEx(hkRoot, pszSubKey, 0L, KEY_READ, &hk))
|
|
{
|
|
_AddOrderedKeys(hk, pszDefaultOrder);
|
|
_AddEnumKeys(hk);
|
|
RegCloseKey(hk);
|
|
}
|
|
return GetItemCount() - cKeys;
|
|
}
|
|
|
|
int CALLBACK CDKA::_ReleaseItem(PDKAITEM pdkai, void *pv)
|
|
{
|
|
if (pdkai->hk)
|
|
{
|
|
RegCloseKey(pdkai->hk);
|
|
pdkai->hk = NULL;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
CDKA::~CDKA()
|
|
{
|
|
Reset();
|
|
}
|
|
|
|
// override this DSA methods to get release
|
|
BOOL CDKA::DeleteItem(int id)
|
|
{
|
|
PDKAITEM p = GetItemPtr(id);
|
|
if (p)
|
|
{
|
|
_ReleaseItem(p, NULL);
|
|
return CDSA<DKAITEM>::DeleteItem(id);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
// override this DSA methods to get release
|
|
BOOL CDKA::DeleteAllItems()
|
|
{
|
|
EnumCallback(_ReleaseItem, NULL);
|
|
return CDSA<DKAITEM>::DeleteAllItems();
|
|
}
|
|
|
|
HRESULT CDKA::GetValue(int id,
|
|
PCTSTR pszSubKey,
|
|
PCTSTR pszValue,
|
|
DWORD *pdwType,
|
|
void *pvData,
|
|
DWORD *pcbData)
|
|
{
|
|
DWORD err = SHGetValue(GetItemPtr(id)->hk, pszSubKey, pszValue, pdwType, pvData, pcbData);
|
|
return HRESULT_FROM_WIN32(err);
|
|
}
|
|
|
|
BOOL CDKA::HasDefault(HKEY hkProgid)
|
|
{
|
|
if (_tbHasDefault == TRIBIT_UNDEFINED)
|
|
{
|
|
HKEY hk;
|
|
if (ERROR_SUCCESS== RegOpenKeyEx(hkProgid, L"ShellFolder", 0, MAXIMUM_ALLOWED, &hk))
|
|
{
|
|
// APPCOMPAT - regitems need to have the open verb - ZekeL - 30-JAN-2001
|
|
// so that the IQA and ICM will behave the same,
|
|
// and regitem folders will always default to
|
|
// folder\shell\open unless they implement open
|
|
// or specify default verbs.
|
|
//
|
|
_tbHasDefault = TRIBIT_FALSE;
|
|
RegCloseKey(hk);
|
|
}
|
|
else
|
|
{
|
|
_tbHasDefault = TRIBIT_TRUE;
|
|
}
|
|
}
|
|
return _tbHasDefault == TRIBIT_TRUE;
|
|
}
|
|
|
|
|
|
typedef HRESULT (__stdcall *LPFNADDPAGES)(IDataObject *, LPFNADDPROPSHEETPAGE, LPARAM);
|
|
|
|
class CShellExecMenu : public IShellExtInit, public IContextMenu, public IShellPropSheetExt, CObjectWithSite
|
|
{
|
|
public:
|
|
// IUnknown
|
|
STDMETHODIMP QueryInterface(REFIID riid, void **ppv);
|
|
STDMETHODIMP_(ULONG) AddRef(void);
|
|
STDMETHODIMP_(ULONG) Release(void);
|
|
|
|
// IShellExtInit
|
|
STDMETHODIMP Initialize(LPCITEMIDLIST pidlFolder, IDataObject *pdtobj, HKEY hkeyProgID);
|
|
|
|
// IContextMenu
|
|
STDMETHODIMP QueryContextMenu(HMENU hmenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags);
|
|
STDMETHODIMP InvokeCommand(LPCMINVOKECOMMANDINFO pici);
|
|
STDMETHODIMP GetCommandString(UINT_PTR idCmd, UINT wFlags, UINT *pwRes, LPSTR pszName, UINT cchMax);
|
|
|
|
// IShellPropSheetExt
|
|
STDMETHODIMP AddPages(LPFNADDPROPSHEETPAGE, LPARAM);
|
|
STDMETHODIMP ReplacePage(UINT, LPFNADDPROPSHEETPAGE, LPARAM);
|
|
|
|
CShellExecMenu(LPFNADDPAGES pfnAddPages);
|
|
|
|
protected: // methods
|
|
~CShellExecMenu();
|
|
void _Cleanup();
|
|
HRESULT _InsureVerbs(UINT idVerb = 0);
|
|
UINT _VerbCount();
|
|
LPCTSTR _GetVerb(UINT id);
|
|
UINT _FindIndex(LPCTSTR pszVerb);
|
|
DWORD _BrowseFlagsFromVerb(UINT idVerb);
|
|
BOOL _GetMenuString(UINT id, BOOL fExtended, LPTSTR pszMenu, UINT cchMax);
|
|
BOOL _IsExplorerMode();
|
|
BOOL _SupportsType(UINT idVerb);
|
|
BOOL _IsRestricted(UINT idVerb);
|
|
BOOL _IsVisible(BOOL fExtended, UINT idVerb);
|
|
BOOL _RemoveVerb(UINT idVerb);
|
|
BOOL _VerbCanDrop(UINT idVerb, CLSID *pclsid);
|
|
HRESULT _DoDrop(REFCLSID clsid, UINT idVerb, LPCMINVOKECOMMANDINFOEX pici);
|
|
|
|
HRESULT _MapVerbForInvoke(CMINVOKECOMMANDINFOEX *pici, UINT *pidVerb);
|
|
HRESULT _TryBrowseObject(LPCITEMIDLIST pidl, DWORD uFlags);
|
|
void _DoRecentStuff(LPCITEMIDLIST pidl, LPCTSTR pszPath);
|
|
HRESULT _InvokeOne(CMINVOKECOMMANDINFOEX *pici, UINT idVerb, LPCITEMIDLIST pidl);
|
|
HRESULT _InvokeMany(CMINVOKECOMMANDINFOEX *pici, UINT idVerb, LPIDA pida);
|
|
HRESULT _InvokeEach(LPCITEMIDLIST pidl, CMINVOKECOMMANDINFOEX *pici);
|
|
HRESULT _PromptUser(CMINVOKECOMMANDINFOEX *pici, UINT idVerb, LPIDA pida);
|
|
|
|
HRESULT _MapVerbForGCS(UINT_PTR idCmd, UINT uType, UINT *pidVerb);
|
|
HRESULT _GetHelpText(UINT idVerb, UINT uType, LPSTR pszName, UINT cchMax);
|
|
|
|
private: // members
|
|
LONG _cRef;
|
|
IDataObject *_pdtobj;
|
|
HKEY _hkeyProgID;
|
|
CDKA _dka;
|
|
LPFNADDPAGES _pfnAddPages;
|
|
UINT _uFlags;
|
|
};
|
|
|
|
CShellExecMenu::CShellExecMenu(LPFNADDPAGES pfnAddPages) : _pfnAddPages(pfnAddPages), _cRef(1)
|
|
{
|
|
}
|
|
|
|
CShellExecMenu::~CShellExecMenu()
|
|
{
|
|
_Cleanup();
|
|
}
|
|
|
|
void CShellExecMenu::_Cleanup()
|
|
{
|
|
_dka.Reset();
|
|
|
|
if (_hkeyProgID)
|
|
{
|
|
RegCloseKey(_hkeyProgID);
|
|
_hkeyProgID = NULL;
|
|
}
|
|
|
|
ATOMICRELEASE(_pdtobj);
|
|
}
|
|
|
|
STDMETHODIMP CShellExecMenu::QueryInterface(REFIID riid, void **ppvObj)
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENT(CShellExecMenu, IShellExtInit),
|
|
QITABENT(CShellExecMenu, IContextMenu),
|
|
QITABENT(CShellExecMenu, IShellPropSheetExt),
|
|
QITABENT(CShellExecMenu, IObjectWithSite),
|
|
{ 0 },
|
|
};
|
|
return QISearch(this, qit, riid, ppvObj);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CShellExecMenu::AddRef()
|
|
{
|
|
return InterlockedIncrement(&_cRef);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CShellExecMenu::Release()
|
|
{
|
|
if (InterlockedDecrement(&_cRef))
|
|
return _cRef;
|
|
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
HRESULT CShellExecMenu::_InsureVerbs(UINT idVerb)
|
|
{
|
|
// the idVerb is the minimum verb that we need to succeed
|
|
if (!(HDSA)_dka && _hkeyProgID)
|
|
{
|
|
// create either "open" or "explore open"
|
|
if (_dka.Create(4))
|
|
{
|
|
_dka.AddKeys(_hkeyProgID, c_szShell, _IsExplorerMode() ? TEXT("Explore open") : TEXT("open"));
|
|
|
|
// WARNING - some verbs are not valid and need to be removed
|
|
for (int id = 0; id < _dka.GetItemCount(); id++)
|
|
{
|
|
if (_RemoveVerb(id))
|
|
_dka.DeleteItem(id);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return ((HDSA)_dka && idVerb < (UINT)_dka.GetItemCount()) ? S_OK : E_FAIL;
|
|
}
|
|
|
|
// Descriptions:
|
|
// This function generates appropriate menu string from the given
|
|
// verb key string. This function is called if the verb key does
|
|
// not have the value.
|
|
|
|
BOOL _MenuString(LPCTSTR pszVerbKey, LPTSTR pszMenuString, UINT cchMax)
|
|
{
|
|
// Table look-up (verb key -> menu string mapping)
|
|
const static struct
|
|
{
|
|
LPCTSTR pszVerb;
|
|
UINT id;
|
|
} sVerbTrans[] = {
|
|
c_szOpen, IDS_MENUOPEN,
|
|
c_szExplore, IDS_MENUEXPLORE,
|
|
TEXT("edit"),IDS_MENUEDIT,
|
|
c_szFind, IDS_MENUFIND,
|
|
c_szPrint, IDS_MENUPRINT,
|
|
c_szOpenAs, IDS_MENUOPEN,
|
|
TEXT("runas"),IDS_MENURUNAS
|
|
};
|
|
|
|
for (int i = 0; i < ARRAYSIZE(sVerbTrans); i++)
|
|
{
|
|
if (lstrcmpi(pszVerbKey, sVerbTrans[i].pszVerb) == 0)
|
|
{
|
|
if (LoadString(HINST_THISDLL, sVerbTrans[i].id, pszMenuString, cchMax))
|
|
return TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Worst case: Just put '&' on the top.
|
|
pszMenuString[0] = TEXT('&');
|
|
pszMenuString++;
|
|
cchMax--;
|
|
lstrcpyn(pszMenuString, pszVerbKey, cchMax);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Checks to see if there is a user policy in place that disables this key,
|
|
//
|
|
// For example, in the registry:
|
|
//
|
|
// CLSID_MyComputer
|
|
// +---Shell
|
|
// +---Manage
|
|
// (Default) = "Mana&ge"
|
|
// SuppressionPolicy = REST_NOMANAGEMYCOMPUTERVERB
|
|
//
|
|
// (Where REST_NOMANAGEMYCOMPUTERVERB is the DWORD value of that particular policy)
|
|
|
|
BOOL CShellExecMenu::_IsRestricted(UINT idVerb)
|
|
{
|
|
RESTRICTIONS rest;
|
|
BOOL fRestrict = FALSE;
|
|
if (0 == lstrcmpi(TEXT("runas"), _dka.ExposeName(idVerb)))
|
|
{
|
|
rest = REST_HIDERUNASVERB;
|
|
fRestrict = TRUE;
|
|
}
|
|
else
|
|
{
|
|
DWORD cb = sizeof(rest);
|
|
fRestrict = SUCCEEDED(_dka.GetValue(idVerb, NULL, TEXT("SuppressionPolicy"), NULL, &rest, &cb));
|
|
}
|
|
return fRestrict && SHRestricted(rest);
|
|
}
|
|
|
|
HRESULT _GetAppSource(HKEY hk, PCWSTR pszVerb, IQuerySource **ppqs)
|
|
{
|
|
CComPtr<IAssociationElement> spae;
|
|
HRESULT hr = AssocElemCreateForKey(&CLSID_AssocShellElement, hk, &spae);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CComPtr<IObjectWithQuerySource> spowqsApp;
|
|
hr = spae->QueryObject(AQVO_APPLICATION_DELEGATE, pszVerb, IID_PPV_ARG(IObjectWithQuerySource, &spowqsApp));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = spowqsApp->GetSource(IID_PPV_ARG(IQuerySource, ppqs));
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
BOOL CShellExecMenu::_SupportsType(UINT idVerb)
|
|
{
|
|
BOOL fRet = TRUE;
|
|
if (SUCCEEDED(_dka.GetValue(idVerb, NULL, TEXT("CheckSupportedTypes"), NULL, NULL, NULL)))
|
|
{
|
|
// need to check the supported types for this application
|
|
// get the first item and then check it against SupportedFileExtensions
|
|
CComPtr<IShellItem> spsi;
|
|
if (SUCCEEDED(DataObj_GetIShellItem(_pdtobj, &spsi)))
|
|
{
|
|
SFGAOF sfgao;
|
|
if (S_OK == spsi->GetAttributes(SFGAO_STREAM, &sfgao))
|
|
{
|
|
CSmartCoTaskMem<OLECHAR> spszName;
|
|
if (SUCCEEDED(spsi->GetDisplayName(SIGDN_PARENTRELATIVEPARSING, &spszName)))
|
|
{
|
|
PWSTR pszExt = PathFindExtension(spszName);
|
|
if (*pszExt)
|
|
{
|
|
CComPtr<IQuerySource> spqs;
|
|
if (SUCCEEDED(_GetAppSource(_hkeyProgID, _dka.ExposeName(idVerb), &spqs)))
|
|
{
|
|
fRet = SUCCEEDED(spqs->QueryValueExists(L"SupportedTypes", pszExt));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return fRet;
|
|
}
|
|
|
|
//
|
|
// LegacyDisable
|
|
// LegacyDisable is set, then the verb exists only for legacy reasons, and
|
|
// is actually superceded by a context menu extension or some other behavior
|
|
// it there only to retain legacy behavior for external clients that require
|
|
// the existence of a verb.
|
|
//
|
|
BOOL CShellExecMenu::_RemoveVerb(UINT idVerb)
|
|
{
|
|
if (SUCCEEDED(_dka.GetValue(idVerb, NULL, TEXT("LegacyDisable"), NULL, NULL, NULL)))
|
|
return TRUE;
|
|
|
|
if (!_SupportsType(idVerb))
|
|
return TRUE;
|
|
|
|
return (_IsRestricted(idVerb));
|
|
}
|
|
|
|
BOOL CShellExecMenu::_IsVisible(BOOL fExtended, UINT idVerb)
|
|
{
|
|
// this is not an extended verb, or
|
|
// the request includes extended verbs
|
|
if (!fExtended && SUCCEEDED(_dka.GetValue(idVerb, NULL, TEXT("Extended"), NULL, NULL, NULL)))
|
|
return FALSE;
|
|
|
|
static const struct {
|
|
LPCTSTR pszVerb;
|
|
} sVerbIgnore[] = {
|
|
c_szPrintTo
|
|
};
|
|
|
|
for (int i = 0; i < ARRAYSIZE(sVerbIgnore); i++)
|
|
{
|
|
if (lstrcmpi(_dka.ExposeName(idVerb), sVerbIgnore[i].pszVerb) == 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL CShellExecMenu::_GetMenuString(UINT id, BOOL fExtended, LPTSTR pszMenu, UINT cchMax)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
// other verbs are hidden and just shouldnt be shown.
|
|
if (SUCCEEDED(_InsureVerbs(id)) && _IsVisible(fExtended, id))
|
|
{
|
|
DWORD cbVerb = CbFromCch(cchMax);
|
|
*pszMenu = 0;
|
|
// try the MUIVerb value first
|
|
// if that fails use the default value
|
|
// either of these can actually have an MUI string
|
|
if (FAILED(_dka.GetValue(id, NULL, TEXT("MUIVerb"), NULL, pszMenu, &cbVerb)))
|
|
{
|
|
cbVerb = CbFromCch(cchMax);
|
|
_dka.GetValue(id, NULL, NULL, NULL, pszMenu, &cbVerb);
|
|
}
|
|
|
|
if (!*pszMenu || FAILED(SHLoadIndirectString(pszMenu, pszMenu, cchMax, NULL)))
|
|
{
|
|
// If it does not have the value, generate it.
|
|
bRet = _MenuString(_dka.ExposeName(id), pszMenu, cchMax);
|
|
}
|
|
else
|
|
{
|
|
// use the value
|
|
bRet = TRUE;
|
|
}
|
|
ASSERT(!bRet || *pszMenu);
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
STDMETHODIMP CShellExecMenu::Initialize(LPCITEMIDLIST pidlFolder, IDataObject *pdtobj, HKEY hkeyProgID)
|
|
{
|
|
// new behavior: good context menus should interpret a NULL pidlFolder/hkeyProgID on a re-init
|
|
// as meaning they should use the ones they already have.
|
|
if (hkeyProgID)
|
|
{
|
|
_Cleanup(); // cleans up hkey and hdka, pdtobj too but that's ok
|
|
_hkeyProgID = SHRegDuplicateHKey(hkeyProgID); // make a copy
|
|
}
|
|
IUnknown_Set((IUnknown **)&_pdtobj, pdtobj);
|
|
return S_OK;
|
|
}
|
|
|
|
UINT CShellExecMenu::_VerbCount()
|
|
{
|
|
return SUCCEEDED(_InsureVerbs()) ? _dka.GetItemCount() : 0;
|
|
}
|
|
|
|
UINT CShellExecMenu::_FindIndex(LPCTSTR pszVerb)
|
|
{
|
|
for (UINT i = 0; i < _VerbCount(); i++)
|
|
{
|
|
if (!lstrcmpi(pszVerb, _dka.ExposeName(i)))
|
|
return i; // found it!
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
STDMETHODIMP CShellExecMenu::QueryContextMenu(HMENU hmenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags)
|
|
{
|
|
UINT cVerbs = 0;
|
|
_uFlags = uFlags; // caller may force explorer mode (CMF_EXPLORE) here
|
|
|
|
TCHAR szMenu[CCH_MENUMAX];
|
|
for (UINT idCmd = idCmdFirst;
|
|
idCmd <= idCmdLast && (idCmd - idCmdFirst) < _VerbCount(); idCmd++)
|
|
{
|
|
UINT uMenuFlags = MF_BYPOSITION | MF_STRING;
|
|
if (_GetMenuString(idCmd - idCmdFirst, uFlags & CMF_EXTENDEDVERBS, szMenu, ARRAYSIZE(szMenu)))
|
|
{
|
|
InsertMenu(hmenu, indexMenu + cVerbs, uMenuFlags, idCmd, szMenu);
|
|
cVerbs++;
|
|
}
|
|
}
|
|
|
|
if (cVerbs && (GetMenuDefaultItem(hmenu, MF_BYPOSITION, 0) == -1))
|
|
{
|
|
if (_dka.HasDefault(_hkeyProgID))
|
|
{
|
|
// if there is a default verb on this key,
|
|
// trust that it was the first one that the CDKA added
|
|
SetMenuDefaultItem(hmenu, indexMenu, MF_BYPOSITION);
|
|
}
|
|
}
|
|
|
|
return ResultFromShort(_VerbCount());
|
|
}
|
|
|
|
LPCTSTR CShellExecMenu::_GetVerb(UINT id)
|
|
{
|
|
return SUCCEEDED(_InsureVerbs()) ? _dka.ExposeName(id) : NULL;
|
|
}
|
|
|
|
STATIC BOOL s_fAbortInvoke = FALSE;
|
|
|
|
// This private export allows the folder code a way to cause the main invoke
|
|
// loops processing several different files to abort.
|
|
|
|
STDAPI_(void) SHAbortInvokeCommand()
|
|
{
|
|
DebugMsg(DM_TRACE, TEXT("AbortInvokeCommand was called"));
|
|
s_fAbortInvoke = TRUE;
|
|
}
|
|
|
|
// Call shell exec (for the folder class) using the given file and the
|
|
// given pidl. The file will be passed as %1 in the dde command and the pidl
|
|
// will be passed as %2.
|
|
|
|
STDAPI _InvokePidl(LPCMINVOKECOMMANDINFOEX pici, DWORD dwAttribs, LPCTSTR pszPath, LPCITEMIDLIST pidl, HKEY hkClass)
|
|
{
|
|
SHELLEXECUTEINFO ei;
|
|
HRESULT hr = ICIX2SEI(pici, &ei);
|
|
pszPath = (dwAttribs & SFGAO_FILESYSTEM) ? pszPath : NULL;
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ei.fMask |= SEE_MASK_IDLIST;
|
|
|
|
ei.lpFile = pszPath;
|
|
ei.lpIDList = (void *)pidl;
|
|
|
|
// if a directory is specifed use that, else make the current
|
|
// directory be the folder it self. UNLESS it is a AUDIO CDRom, it
|
|
// should never be the current directory (causes CreateProcess errors)
|
|
if (!ei.lpDirectory && (dwAttribs & SFGAO_FOLDER))
|
|
ei.lpDirectory = pszPath;
|
|
|
|
if (pszPath && ei.lpDirectory)
|
|
{
|
|
INT iDrive = PathGetDriveNumber(ei.lpDirectory);
|
|
|
|
CMountPoint* pmtpt = CMountPoint::GetMountPoint(iDrive);
|
|
|
|
if (pmtpt)
|
|
{
|
|
if (pmtpt->IsAudioCDNoData())
|
|
{
|
|
ei.lpDirectory = NULL;
|
|
}
|
|
|
|
pmtpt->Release();
|
|
}
|
|
}
|
|
|
|
if (hkClass)
|
|
{
|
|
ei.hkeyClass = hkClass;
|
|
ei.fMask |= SEE_MASK_CLASSKEY;
|
|
}
|
|
else
|
|
ei.fMask |= SEE_MASK_INVOKEIDLIST;
|
|
|
|
if (ShellExecuteEx(&ei))
|
|
hr = S_OK;
|
|
else
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
BOOL _QuitInvokeLoop()
|
|
{
|
|
MSG msg;
|
|
|
|
// Try to give the user a way to escape out of this
|
|
if (s_fAbortInvoke || GetAsyncKeyState(VK_ESCAPE) < 0)
|
|
return TRUE;
|
|
|
|
// And the next big mondo hack to handle CAD of our window
|
|
// because the user thinks it is hung.
|
|
if (PeekMessage(&msg, NULL, WM_CLOSE, WM_CLOSE, PM_NOREMOVE))
|
|
return TRUE; // Lets also bail..
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
#define CMINVOKE_VERBT(pici) (pici)->lpVerbW
|
|
|
|
HRESULT CShellExecMenu::_MapVerbForInvoke(CMINVOKECOMMANDINFOEX *pici, UINT *pidVerb)
|
|
{
|
|
LPCTSTR pszVerbKey;
|
|
// is pici->lpVerb specifying the verb index (0-based).
|
|
if (IS_INTRESOURCE(pici->lpVerb))
|
|
{
|
|
// find it in the CDKA
|
|
*pidVerb = LOWORD((ULONG_PTR)pici->lpVerb);
|
|
pszVerbKey = _GetVerb(*pidVerb);
|
|
CMINVOKE_VERBT(pici) = pszVerbKey; // alias into the CDKA
|
|
RIPMSG(pszVerbKey != NULL, "CShellExecMenu::InvokeCommand() passed an invalid verb id");
|
|
}
|
|
else
|
|
{
|
|
pszVerbKey = CMINVOKE_VERBT(pici);
|
|
if (pszVerbKey)
|
|
{
|
|
*pidVerb = _FindIndex(pszVerbKey);
|
|
if (-1 == *pidVerb)
|
|
pszVerbKey = NULL; // not in our list
|
|
}
|
|
}
|
|
|
|
ASSERT(!pszVerbKey || *pidVerb != -1);
|
|
return pszVerbKey ? S_OK : E_INVALIDARG;
|
|
}
|
|
|
|
BOOL CShellExecMenu::_IsExplorerMode()
|
|
{
|
|
BOOL bRet = (_uFlags & CMF_EXPLORE);
|
|
if (!bRet)
|
|
{
|
|
bRet = IsExplorerModeBrowser(_punkSite);
|
|
if (bRet)
|
|
_uFlags |= CMF_EXPLORE;
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
DWORD CShellExecMenu::_BrowseFlagsFromVerb(UINT idVerb)
|
|
{
|
|
DWORD dwFlags = 0;
|
|
DWORD cbFlags = sizeof(dwFlags);
|
|
_dka.GetValue(idVerb, NULL, _IsExplorerMode() ? TEXT("ExplorerFlags") : TEXT("BrowserFlags"), NULL, &dwFlags, &cbFlags);
|
|
return dwFlags;
|
|
}
|
|
|
|
HRESULT CShellExecMenu::_TryBrowseObject(LPCITEMIDLIST pidl, DWORD uFlags)
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
|
|
IShellBrowser *psb;
|
|
if (SUCCEEDED(IUnknown_QueryService(_punkSite, SID_SShellBrowser, IID_PPV_ARG(IShellBrowser, &psb))))
|
|
{
|
|
hr = psb->BrowseObject(pidl, (UINT) uFlags);
|
|
psb->Release();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT _CanTryBrowseObject(DWORD dwAttribs, CMINVOKECOMMANDINFOEX* pici)
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
|
|
if (dwAttribs & SFGAO_FOLDER)
|
|
{
|
|
// we need to sniff the iciex here to see if there is anything special in it
|
|
// that cannot be conveyed to IShellBrowser::BrowseObject() (eg the nShow parameter)
|
|
if ((pici->nShow == SW_SHOWNORMAL) ||
|
|
(pici->nShow == SW_SHOW))
|
|
{
|
|
// nothing special in the ICIEX, should be safe to discard it and use
|
|
// IShellBrowser::BrowseObject() instead of ShellExecuteEx
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
BOOL CShellExecMenu::_VerbCanDrop(UINT idVerb, CLSID *pclsid)
|
|
{
|
|
TCHAR sz[GUIDSTR_MAX];
|
|
DWORD cb = sizeof(sz);
|
|
return (SUCCEEDED(_dka.GetValue(idVerb, L"DropTarget", L"Clsid", NULL, sz, &cb))
|
|
&& GUIDFromString(sz, pclsid));
|
|
}
|
|
|
|
HRESULT CShellExecMenu::_DoDrop(REFCLSID clsid, UINT idVerb, LPCMINVOKECOMMANDINFOEX pici)
|
|
{
|
|
// i think i need to persist the pici into the _pdtobj
|
|
// and probably add some values under the pqs
|
|
// we assume that the app will do something appropriate
|
|
// QueryService(_punkSite, clsid) might be useful
|
|
return SHSimulateDropOnClsid(clsid, _punkSite, _pdtobj);
|
|
}
|
|
|
|
STDMETHODIMP CShellExecMenu::InvokeCommand(LPCMINVOKECOMMANDINFO pici)
|
|
{
|
|
CMINVOKECOMMANDINFOEX ici;
|
|
void *pvFree;
|
|
HRESULT hr = ICI2ICIX(pici, &ici, &pvFree); // thunk incomming params
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
UINT idVerb;
|
|
hr = _MapVerbForInvoke(&ici, &idVerb);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CLSID clsid;
|
|
if (_VerbCanDrop(idVerb, &clsid))
|
|
{
|
|
hr = _DoDrop(clsid, idVerb, &ici);
|
|
}
|
|
else
|
|
{
|
|
STGMEDIUM medium;
|
|
LPIDA pida = DataObj_GetHIDA(_pdtobj, &medium);
|
|
if (pida)
|
|
{
|
|
if (pida->cidl == 1)
|
|
{
|
|
LPITEMIDLIST pidl = IDA_FullIDList(pida, 0);
|
|
if (pidl)
|
|
{
|
|
hr = _InvokeOne(&ici, idVerb, pidl);
|
|
ILFree(pidl);
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
hr = _InvokeMany(&ici, idVerb, pida);
|
|
}
|
|
|
|
HIDA_ReleaseStgMedium(pida, &medium);
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
if (pvFree)
|
|
LocalFree(pvFree);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CShellExecMenu::_InvokeOne(CMINVOKECOMMANDINFOEX *pici, UINT idVerb, LPCITEMIDLIST pidl)
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
TCHAR szPath[MAX_PATH];
|
|
DWORD dwAttrib = SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_LINK;
|
|
SHGetNameAndFlags(pidl, SHGDN_FORPARSING, szPath, ARRAYSIZE(szPath), &dwAttrib);
|
|
|
|
if (S_OK == _CanTryBrowseObject(dwAttrib, pici))
|
|
{
|
|
DWORD uFlags = _BrowseFlagsFromVerb(idVerb);
|
|
if (uFlags)
|
|
{
|
|
// if we did the site based navigation, we are done
|
|
hr = _TryBrowseObject(pidl, uFlags);
|
|
}
|
|
}
|
|
|
|
if (hr != S_OK)
|
|
{
|
|
hr = _InvokePidl(pici, dwAttrib, szPath, pidl, _hkeyProgID);
|
|
|
|
// only set recent on non-folders (SFGAO_STREAM?)
|
|
// and non-link since we know those should never be added
|
|
if (SUCCEEDED(hr) && !(dwAttrib & (SFGAO_FOLDER | SFGAO_LINK)))
|
|
{
|
|
AddToRecentDocs(pidl, szPath);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
BOOL _ShouldPrompt(DWORD cItems)
|
|
{
|
|
DWORD dwMin, cb = sizeof(dwMin);
|
|
if (SHRegGetUSValue(REGSTR_PATH_EXPLORER, TEXT("MultipleInvokePromptMinimum"), NULL, &dwMin, &cb, FALSE, NULL, 0) != ERROR_SUCCESS)
|
|
dwMin = 15;
|
|
|
|
return cItems > dwMin;
|
|
}
|
|
|
|
HRESULT CShellExecMenu::_PromptUser(CMINVOKECOMMANDINFOEX *pici, UINT idVerb, LPIDA pida)
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
if (pici->hwnd && !(pici->fMask & CMIC_MASK_FLAG_NO_UI)
|
|
&& _ShouldPrompt(pida->cidl))
|
|
{
|
|
// prompt the user with the verb and count
|
|
// we make a better experience if we keyed off
|
|
// homo/hetero types and had different behaviors
|
|
// but its not worth it. instead we should
|
|
// switch to using AutoPlay sniffing and dialog.
|
|
TCHAR szVerb[64];
|
|
TCHAR szNum[10];
|
|
wnsprintf(szNum, ARRAYSIZE(szNum), TEXT("%d"), pida->cidl);
|
|
hr = _GetHelpText(idVerb, GCS_HELPTEXT, (PSTR)szVerb, ARRAYSIZE(szVerb));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
PTSTR pszTitle = ShellConstructMessageString(HINST_THISDLL, MAKEINTRESOURCE(IDS_MULTIINVOKEPROMPT_TITLE), szVerb);
|
|
if (pszTitle)
|
|
{
|
|
PTSTR pszMsg = ShellConstructMessageString(HINST_THISDLL, MAKEINTRESOURCE(IDS_MULTIINVOKEPROMPT_MESSAGE), szVerb, szNum);
|
|
if (pszMsg)
|
|
{
|
|
int iRet = SHMessageBoxCheck(pici->hwnd, pszMsg, pszTitle, (MB_OKCANCEL | MB_ICONEXCLAMATION), IDOK, TEXT("MultipleInvokePrompt"));
|
|
hr = iRet == IDOK ? S_OK : HRESULT_FROM_WIN32(ERROR_CANCELLED);
|
|
|
|
LocalFree(pszMsg);
|
|
}
|
|
LocalFree(pszTitle);
|
|
}
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CShellExecMenu::_InvokeEach(LPCITEMIDLIST pidl, CMINVOKECOMMANDINFOEX *pici)
|
|
{
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
HMENU hmenu = CreatePopupMenu();
|
|
if (hmenu)
|
|
{
|
|
CComPtr<IContextMenu> spcm;
|
|
hr = SHGetUIObjectOf(pidl, NULL, IID_PPV_ARG(IContextMenu, &spcm));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (_punkSite)
|
|
IUnknown_SetSite(spcm, _punkSite);
|
|
|
|
hr = spcm->QueryContextMenu(hmenu, 0, CONTEXTMENU_IDCMD_FIRST, CONTEXTMENU_IDCMD_LAST, _uFlags);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = spcm->InvokeCommand((CMINVOKECOMMANDINFO *)pici);
|
|
}
|
|
|
|
if (_punkSite)
|
|
IUnknown_SetSite(spcm, NULL);
|
|
}
|
|
|
|
DestroyMenu(hmenu);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CShellExecMenu::_InvokeMany(CMINVOKECOMMANDINFOEX *pici, UINT idVerb, LPIDA pida)
|
|
{
|
|
HRESULT hr = _PromptUser(pici, idVerb, pida);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
USES_CONVERSION;
|
|
s_fAbortInvoke = FALSE; // reset this global for this run...
|
|
// we want to alter the pici
|
|
// so that each item is handled individually
|
|
pici->hwnd = NULL;
|
|
pici->fMask |= CMIC_MASK_FLAG_NO_UI;
|
|
|
|
// NTBUG #502223 - MSI apps with DDE start multiple copies - ZekeL 2001-DEC-07
|
|
// ShellExec() will create a new thread for MSI apps to
|
|
// avoid a deadlock with the MSI APIs calling SHChangeNotify().
|
|
// this is described in NTBUG #200961
|
|
// however in the multiple invoke case we create one thread
|
|
// for each item in the invoke, which results in several processes
|
|
// contending for the DDE conversation.
|
|
//
|
|
// this is a half fix. we prefer to have the buggy behavior in 502223
|
|
// over the deadlock behavior in 200961 (a definite PSS call).
|
|
// since the deadlock case should only occur for the desktop,
|
|
// the rest of the time we will force a synchronous invoke.
|
|
IBindCtx *pbcRelease = NULL;
|
|
if (!IsDesktopBrowser(_punkSite))
|
|
{
|
|
TBCRegisterObjectParam(TBCDIDASYNC, SAFECAST(this, IContextMenu *), &pbcRelease);
|
|
}
|
|
|
|
pici->lpVerb = T2A(_dka.ExposeName(idVerb));
|
|
pici->lpVerbW = _dka.ExposeName(idVerb);
|
|
|
|
for (UINT iItem = 0; !_QuitInvokeLoop() && (iItem < pida->cidl); iItem++)
|
|
{
|
|
LPITEMIDLIST pidl = IDA_FullIDList(pida, iItem);
|
|
if (pidl)
|
|
{
|
|
hr = _InvokeEach(pidl, pici);
|
|
ILFree(pidl);
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
if (hr == E_OUTOFMEMORY)
|
|
break;
|
|
|
|
}
|
|
|
|
ATOMICRELEASE(pbcRelease);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CShellExecMenu::_GetHelpText(UINT idVerb, UINT uType, LPSTR pszName, UINT cchMax)
|
|
{
|
|
// TODO - shouldnt we let the registry override?
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
TCHAR szMenuString[CCH_MENUMAX];
|
|
if (_GetMenuString(idVerb, TRUE, szMenuString, ARRAYSIZE(szMenuString)))
|
|
{
|
|
SHStripMneumonic(szMenuString);
|
|
// NOTE on US, IDS_VERBHELP is the same as "%s"
|
|
// do we want some better description?
|
|
LPTSTR pszHelp = ShellConstructMessageString(HINST_THISDLL, MAKEINTRESOURCE(IDS_VERBHELP), szMenuString);
|
|
if (pszHelp)
|
|
{
|
|
if (uType == GCS_HELPTEXTA)
|
|
SHTCharToAnsi(pszHelp, pszName, cchMax);
|
|
else
|
|
SHTCharToUnicode(pszHelp, (LPWSTR)pszName, cchMax);
|
|
LocalFree(pszHelp);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CShellExecMenu::_MapVerbForGCS(UINT_PTR idCmd, UINT uType, UINT *pidVerb)
|
|
{
|
|
HRESULT hr = _InsureVerbs();
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (IS_INTRESOURCE(idCmd))
|
|
*pidVerb = (UINT)idCmd;
|
|
else
|
|
{
|
|
*pidVerb = -1;
|
|
if (!(uType & GCS_UNICODE))
|
|
{
|
|
USES_CONVERSION;
|
|
*pidVerb = _FindIndex(A2W((LPCSTR)idCmd));
|
|
}
|
|
|
|
// we fall back to the TCHAR version regardless
|
|
// of what the caller passed in uType
|
|
if (*pidVerb == -1)
|
|
{
|
|
if (!IsBadStringPtrW((LPCWSTR)idCmd, (UINT)-1))
|
|
*pidVerb = _FindIndex((LPCWSTR)idCmd);
|
|
}
|
|
}
|
|
hr = *pidVerb < _VerbCount() ? S_OK : E_INVALIDARG;
|
|
}
|
|
|
|
// VALIDATE returns S_FALSE for bad verbs
|
|
if (FAILED(hr) && (uType == GCS_VALIDATEA || uType == GCS_VALIDATEW))
|
|
hr = S_FALSE;
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CShellExecMenu::GetCommandString(UINT_PTR idCmd, UINT uType, UINT *pwRes, LPSTR pszName, UINT cchMax)
|
|
{
|
|
UINT idVerb;
|
|
HRESULT hr = _MapVerbForGCS(idCmd, uType, &idVerb);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// the verb is good!
|
|
switch (uType)
|
|
{
|
|
case GCS_HELPTEXTA:
|
|
case GCS_HELPTEXTW:
|
|
hr = _GetHelpText(idVerb, uType, pszName, cchMax);
|
|
break;
|
|
|
|
case GCS_VERBA:
|
|
case GCS_VERBW:
|
|
{
|
|
if (uType == GCS_VERBA)
|
|
SHTCharToAnsi(_dka.ExposeName(idVerb), pszName, cchMax);
|
|
else
|
|
SHTCharToUnicode(_dka.ExposeName(idVerb), (LPWSTR)pszName, cchMax);
|
|
hr = S_OK;
|
|
}
|
|
break;
|
|
|
|
case GCS_VALIDATEA:
|
|
case GCS_VALIDATEW:
|
|
// the hr from MapVerb is good enough
|
|
break;
|
|
|
|
default:
|
|
hr = E_NOTIMPL;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CShellExecMenu::AddPages(LPFNADDPROPSHEETPAGE pfnAddPage, LPARAM lParam)
|
|
{
|
|
return _pfnAddPages(_pdtobj, pfnAddPage, lParam);
|
|
}
|
|
|
|
STDMETHODIMP CShellExecMenu::ReplacePage(UINT uPageID, LPFNADDPROPSHEETPAGE pfnReplaceWith, LPARAM lParam)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDAPI CShellExecMenu_CreateInstance(LPFNADDPAGES pfnAddPages, REFIID riid, void **ppv)
|
|
{
|
|
HRESULT hr;
|
|
CShellExecMenu *pdext = new CShellExecMenu(pfnAddPages);
|
|
if (pdext)
|
|
{
|
|
hr = pdext->QueryInterface(riid, ppv);
|
|
pdext->Release();
|
|
}
|
|
else
|
|
{
|
|
*ppv = NULL;
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
// these handlers slime off of CShellExecMenu's IShellPropSheetExt implementation
|
|
|
|
STDAPI FileSystem_AddPages(IDataObject *pdtobj, LPFNADDPROPSHEETPAGE pfnAddPage, LPARAM lParam);
|
|
|
|
STDAPI CShellFileDefExt_CreateInstance(IUnknown *punkOuter, REFIID riid, void **ppv)
|
|
{
|
|
return CShellExecMenu_CreateInstance(FileSystem_AddPages, riid, ppv);
|
|
}
|
|
|
|
STDAPI CDrives_AddPages(IDataObject *pdtobj, LPFNADDPROPSHEETPAGE pfnAddPage, LPARAM lParam);
|
|
|
|
STDAPI CShellDrvDefExt_CreateInstance(IUnknown *punkOuter, REFIID riid, void **ppv)
|
|
{
|
|
return CShellExecMenu_CreateInstance(CDrives_AddPages, riid, ppv);
|
|
}
|
|
|
|
STDAPI PIF_AddPages(IDataObject *pdtobj, LPFNADDPROPSHEETPAGE pfnAddPage, LPARAM lParam);
|
|
|
|
STDAPI CProxyPage_CreateInstance(IUnknown *punkOuter, REFIID riid, void **ppv)
|
|
{
|
|
return CShellExecMenu_CreateInstance(PIF_AddPages, riid, ppv);
|
|
}
|