2010 lines
56 KiB
C++
2010 lines
56 KiB
C++
#include "stock.h"
|
|
#pragma hdrstop
|
|
|
|
#include <idhidden.h>
|
|
#include <regitemp.h>
|
|
#include <shstr.h>
|
|
#include <shlobjp.h>
|
|
#include <lmcons.h>
|
|
#include <validc.h>
|
|
#include "ccstock2.h"
|
|
|
|
// Alpha platform doesn't need unicode thunks, seems like this
|
|
// should happen automatically in the headerfiles...
|
|
//
|
|
#if defined(_X86_) || defined(UNIX)
|
|
#else
|
|
#define NO_W95WRAPS_UNITHUNK
|
|
#endif
|
|
|
|
#include "wininet.h"
|
|
#include "w95wraps.h"
|
|
|
|
//------------------------------------------------------------------------
|
|
// Random helpful functions
|
|
//------------------------------------------------------------------------
|
|
//
|
|
STDAPI_(LPCTSTR) SkipServerSlashes(LPCTSTR pszName)
|
|
{
|
|
for (pszName; *pszName && *pszName == TEXT('\\'); pszName++);
|
|
|
|
return pszName;
|
|
}
|
|
|
|
|
|
// pbIsNamed is true if the i-th item in hm is a named separator
|
|
STDAPI_(BOOL) _SHIsMenuSeparator2(HMENU hm, int i, BOOL *pbIsNamed)
|
|
{
|
|
MENUITEMINFO mii;
|
|
BOOL bLocal;
|
|
|
|
if (!pbIsNamed)
|
|
pbIsNamed = &bLocal;
|
|
|
|
*pbIsNamed = FALSE;
|
|
|
|
mii.cbSize = sizeof(mii);
|
|
mii.fMask = MIIM_TYPE | MIIM_ID;
|
|
mii.cch = 0; // WARNING: We MUST initialize it to 0!!!
|
|
if (GetMenuItemInfo(hm, i, TRUE, &mii) && (mii.fType & MFT_SEPARATOR))
|
|
{
|
|
// NOTE that there is a bug in either 95 or NT user!!!
|
|
// 95 returns 16 bit ID's and NT 32 bit therefore there is a
|
|
// the following may fail, on win9x, to evaluate to false
|
|
// without casting
|
|
*pbIsNamed = ((WORD)mii.wID != (WORD)-1);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
STDAPI_(BOOL) _SHIsMenuSeparator(HMENU hm, int i)
|
|
{
|
|
return _SHIsMenuSeparator2(hm, i, NULL);
|
|
}
|
|
|
|
//
|
|
// _SHPrettyMenu -- make this menu look darn purty
|
|
//
|
|
// Prune the separators in this hmenu to ensure there isn't one in the first or last
|
|
// position and there aren't any runs of >1 separator.
|
|
//
|
|
// Named separators take precedence over regular separators.
|
|
//
|
|
STDAPI_(void) _SHPrettyMenu(HMENU hm)
|
|
{
|
|
BOOL bSeparated = TRUE;
|
|
BOOL bWasNamed = TRUE;
|
|
|
|
for (int i = GetMenuItemCount(hm) - 1; i > 0; --i)
|
|
{
|
|
BOOL bIsNamed;
|
|
if (_SHIsMenuSeparator2(hm, i, &bIsNamed))
|
|
{
|
|
if (bSeparated)
|
|
{
|
|
// if we have two separators in a row, only one of which is named
|
|
// remove the non named one!
|
|
if (bIsNamed && !bWasNamed)
|
|
{
|
|
DeleteMenu(hm, i+1, MF_BYPOSITION);
|
|
bWasNamed = bIsNamed;
|
|
}
|
|
else
|
|
{
|
|
DeleteMenu(hm, i, MF_BYPOSITION);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bWasNamed = bIsNamed;
|
|
bSeparated = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bSeparated = FALSE;
|
|
}
|
|
}
|
|
|
|
// The above loop does not handle the case of many separators at
|
|
// the beginning of the menu
|
|
while (_SHIsMenuSeparator2(hm, 0, NULL))
|
|
{
|
|
DeleteMenu(hm, 0, MF_BYPOSITION);
|
|
}
|
|
}
|
|
|
|
STDAPI_(DWORD) SHIsButtonObscured(HWND hwnd, PRECT prc, INT_PTR i)
|
|
{
|
|
ASSERT(IsWindow(hwnd));
|
|
ASSERT(i < SendMessage(hwnd, TB_BUTTONCOUNT, 0, 0));
|
|
|
|
DWORD dwEdge = 0;
|
|
|
|
RECT rc, rcInt;
|
|
SendMessage(hwnd, TB_GETITEMRECT, i, (LPARAM)&rc);
|
|
|
|
if (!IntersectRect(&rcInt, prc, &rc))
|
|
{
|
|
dwEdge = EDGE_LEFT | EDGE_RIGHT | EDGE_TOP | EDGE_BOTTOM;
|
|
}
|
|
else
|
|
{
|
|
if (rc.top != rcInt.top)
|
|
dwEdge |= EDGE_TOP;
|
|
|
|
if (rc.bottom != rcInt.bottom)
|
|
dwEdge |= EDGE_BOTTOM;
|
|
|
|
if (rc.left != rcInt.left)
|
|
dwEdge |= EDGE_LEFT;
|
|
|
|
if (rc.right != rcInt.right)
|
|
dwEdge |= EDGE_RIGHT;
|
|
}
|
|
|
|
return dwEdge;
|
|
}
|
|
|
|
STDAPI_(BYTE) SHBtnStateFromRestriction(DWORD dwRest, BYTE fsState)
|
|
{
|
|
if (dwRest == RESTOPT_BTN_STATE_VISIBLE)
|
|
return (fsState & ~TBSTATE_HIDDEN);
|
|
else if (dwRest == RESTOPT_BTN_STATE_HIDDEN)
|
|
return (fsState | TBSTATE_HIDDEN);
|
|
else {
|
|
#ifdef DEBUG
|
|
if (dwRest != RESTOPT_BTN_STATE_DEFAULT)
|
|
TraceMsg(TF_ERROR, "bad toolbar button state policy %x", dwRest);
|
|
#endif
|
|
return fsState;
|
|
}
|
|
}
|
|
|
|
//
|
|
// SHIsDisplayable
|
|
//
|
|
// Figure out if this unicode string can be displayed by the system
|
|
// (i.e., won't be turned into a string of question marks).
|
|
//
|
|
STDAPI_(BOOL) SHIsDisplayable(LPCWSTR pwszName, BOOL fRunOnFE, BOOL fRunOnNT5)
|
|
{
|
|
BOOL fNotDisplayable = FALSE;
|
|
|
|
if (pwszName)
|
|
{
|
|
if (!fRunOnNT5)
|
|
{
|
|
// if WCtoMB has to use default characters in mapping pwszName to multibyte,
|
|
// it sets fNotDisplayable == TRUE, in which case we have to use something
|
|
// else for the title string.
|
|
WideCharToMultiByte(CP_ACP, 0, pwszName, -1, NULL, 0, NULL, &fNotDisplayable);
|
|
if (fNotDisplayable)
|
|
{
|
|
if (fRunOnFE)
|
|
{
|
|
WCHAR wzName[INTERNET_MAX_URL_LENGTH];
|
|
|
|
BOOL fReplaceNbsp = FALSE;
|
|
|
|
StrCpyNW(wzName, pwszName, ARRAYSIZE(wzName));
|
|
for (int i = 0; i < ARRAYSIZE(wzName); i++)
|
|
{
|
|
if (0x00A0 == wzName[i]) // if  
|
|
{
|
|
wzName[i] = 0x0020; // replace to space
|
|
fReplaceNbsp = TRUE;
|
|
}
|
|
else if (0 == wzName[i])
|
|
break;
|
|
}
|
|
if (fReplaceNbsp)
|
|
{
|
|
pwszName = wzName;
|
|
WideCharToMultiByte(CP_ACP, 0, pwszName, -1, NULL, 0, NULL, &fNotDisplayable);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return !fNotDisplayable;
|
|
}
|
|
|
|
// Trident will take URLs that don't indicate their source of
|
|
// origin (about:, javascript:, & vbscript:) and will append
|
|
// an URL turd and then the source URL. The turd will indicate
|
|
// where the source URL begins and that source URL is needed
|
|
// when the action needs to be Zone Checked.
|
|
//
|
|
// This function will remove that URL turd and everything behind
|
|
// it so the URL is presentable for the user.
|
|
|
|
#define URL_TURD ((TCHAR)0x01)
|
|
|
|
STDAPI_(void) SHRemoveURLTurd(LPTSTR pszUrl)
|
|
{
|
|
if (!pszUrl)
|
|
return;
|
|
|
|
while (0 != pszUrl[0])
|
|
{
|
|
if (URL_TURD == pszUrl[0])
|
|
{
|
|
pszUrl[0] = 0;
|
|
break;
|
|
}
|
|
|
|
pszUrl = CharNext(pszUrl);
|
|
}
|
|
}
|
|
|
|
STDAPI_(BOOL) SetWindowZorder(HWND hwnd, HWND hwndInsertAfter)
|
|
{
|
|
return SetWindowPos(hwnd, hwndInsertAfter, 0, 0, 0, 0,
|
|
SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
|
|
}
|
|
|
|
BOOL CALLBACK _FixZorderEnumProc(HWND hwnd, LPARAM lParam)
|
|
{
|
|
HWND hwndTest = (HWND)lParam;
|
|
HWND hwndOwner = hwnd;
|
|
|
|
while (hwndOwner = GetWindow(hwndOwner, GW_OWNER))
|
|
{
|
|
if (hwndOwner == hwndTest)
|
|
{
|
|
TraceMsg(TF_WARNING, "_FixZorderEnumProc: Found topmost window %x owned by non-topmost window %x, fixing...", hwnd, hwndTest);
|
|
SetWindowZorder(hwnd, HWND_NOTOPMOST);
|
|
#ifdef DEBUG
|
|
if (GetWindowLong(hwnd, GWL_EXSTYLE) & WS_EX_TOPMOST)
|
|
TraceMsg(TF_ERROR, "_FixZorderEnumProc: window %x is still topmost", hwnd);
|
|
#endif
|
|
break;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
STDAPI_(BOOL) SHForceWindowZorder(HWND hwnd, HWND hwndInsertAfter)
|
|
{
|
|
BOOL fRet = SetWindowZorder(hwnd, hwndInsertAfter);
|
|
|
|
if (fRet && hwndInsertAfter == HWND_TOPMOST)
|
|
{
|
|
if (!(GetWindowLong(hwnd, GWL_EXSTYLE) & WS_EX_TOPMOST))
|
|
{
|
|
//
|
|
// user didn't actually move the hwnd to topmost
|
|
//
|
|
// According to GerardoB, this can happen if the window has
|
|
// an owned window that somehow has become topmost while the
|
|
// owner remains non-topmost, i.e., the two have become
|
|
// separated in the z-order. In this state, when the owner
|
|
// window tries to make itself topmost, the call will
|
|
// silently fail.
|
|
//
|
|
// TERRIBLE HORRIBLE NO GOOD VERY BAD HACK
|
|
//
|
|
// Hacky fix is to enumerate the toplevel windows, check to see
|
|
// if any are topmost and owned by hwnd, and if so, make them
|
|
// non-topmost. Then, retry the SetWindowPos call.
|
|
//
|
|
|
|
TraceMsg(TF_WARNING, "SHForceWindowZorder: SetWindowPos(%x, HWND_TOPMOST) failed", hwnd);
|
|
|
|
// Fix up the z-order
|
|
EnumWindows(_FixZorderEnumProc, (LPARAM)hwnd);
|
|
|
|
// Retry the set. (This should make all owned windows topmost as well.)
|
|
SetWindowZorder(hwnd, HWND_TOPMOST);
|
|
|
|
#ifdef DEBUG
|
|
if (!(GetWindowLong(hwnd, GWL_EXSTYLE) & WS_EX_TOPMOST))
|
|
TraceMsg(TF_ERROR, "SHForceWindowZorder: window %x is still not topmost", hwnd);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
STDAPI_(LPITEMIDLIST) ILCloneParent(LPCITEMIDLIST pidl)
|
|
{
|
|
LPITEMIDLIST pidlParent = ILClone(pidl);
|
|
if (pidlParent)
|
|
ILRemoveLastID(pidlParent);
|
|
|
|
return pidlParent;
|
|
}
|
|
|
|
|
|
// in:
|
|
// psf OPTIONAL, if NULL assume psfDesktop
|
|
// pidl to bind to from psfParent
|
|
//
|
|
|
|
STDAPI SHBindToObject(IShellFolder *psf, REFIID riid, LPCITEMIDLIST pidl, void **ppv)
|
|
{
|
|
// NOTE: callers should use SHBindToObjectEx!!!
|
|
return SHBindToObjectEx(psf, pidl, NULL, riid, ppv);
|
|
}
|
|
|
|
|
|
// in:
|
|
// psf OPTIONAL, if NULL assume psfDesktop
|
|
// pidl to bind to from psfParent
|
|
// pbc bind context
|
|
|
|
STDAPI SHBindToObjectEx(IShellFolder *psf, LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv)
|
|
{
|
|
HRESULT hr;
|
|
IShellFolder *psfRelease = NULL;
|
|
|
|
if (!psf)
|
|
{
|
|
SHGetDesktopFolder(&psf);
|
|
psfRelease = psf;
|
|
}
|
|
|
|
if (psf)
|
|
{
|
|
if (!pidl || ILIsEmpty(pidl))
|
|
{
|
|
hr = psf->QueryInterface(riid, ppv);
|
|
}
|
|
else
|
|
{
|
|
hr = psf->BindToObject(pidl, pbc, riid, ppv);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*ppv = NULL;
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
if (psfRelease)
|
|
{
|
|
psfRelease->Release();
|
|
}
|
|
|
|
if (SUCCEEDED(hr) && (*ppv == NULL))
|
|
{
|
|
// Some shell extensions (eg WS_FTP) will return success and a null out pointer
|
|
TraceMsg(TF_WARNING, "SHBindToObjectEx: BindToObject succeeded but returned null ppv!!");
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
// psfRoot is the base of the bind. If NULL, then we use the shell desktop.
|
|
// If you want to bind relative to the explorer root (e.g., CabView, MSN),
|
|
// then use SHBindToIDListParent.
|
|
STDAPI SHBindToFolderIDListParent(IShellFolder *psfRoot, LPCITEMIDLIST pidl, REFIID riid, void **ppv, LPCITEMIDLIST *ppidlLast)
|
|
{
|
|
HRESULT hr;
|
|
|
|
// Old shell32 code in some cases simply whacked the pidl,
|
|
// but this is unsafe. Do what shdocvw does and clone/remove:
|
|
//
|
|
LPITEMIDLIST pidlParent = ILCloneParent(pidl);
|
|
if (pidlParent)
|
|
{
|
|
hr = SHBindToObjectEx(psfRoot, pidlParent, NULL, riid, ppv);
|
|
ILFree(pidlParent);
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
if (ppidlLast)
|
|
*ppidlLast = ILFindLastID(pidl);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Warning! brutil.cpp overrides this function
|
|
//
|
|
STDAPI SHBindToIDListParent(LPCITEMIDLIST pidl, REFIID riid, void **ppv, LPCITEMIDLIST *ppidlLast)
|
|
{
|
|
return SHBindToFolderIDListParent(NULL, pidl, riid, ppv, ppidlLast);
|
|
}
|
|
|
|
// should be IUnknown_GetIDList()
|
|
|
|
STDAPI SHGetIDListFromUnk(IUnknown *punk, LPITEMIDLIST *ppidl)
|
|
{
|
|
*ppidl = NULL;
|
|
|
|
HRESULT hr = E_NOINTERFACE;
|
|
if (punk)
|
|
{
|
|
IPersistFolder2 *ppf;
|
|
IPersistIDList *pperid;
|
|
if (SUCCEEDED(punk->QueryInterface(IID_PPV_ARG(IPersistIDList, &pperid))))
|
|
{
|
|
hr = pperid->GetIDList(ppidl);
|
|
pperid->Release();
|
|
}
|
|
else if (SUCCEEDED(punk->QueryInterface(IID_PPV_ARG(IPersistFolder2, &ppf))))
|
|
{
|
|
hr = ppf->GetCurFolder(ppidl);
|
|
ppf->Release();
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// generically useful to hide.
|
|
//
|
|
#pragma pack(1)
|
|
typedef struct _HIDDENCLSID
|
|
{
|
|
HIDDENITEMID hid;
|
|
CLSID clsid;
|
|
} HIDDENCLSID;
|
|
#pragma pack()
|
|
|
|
typedef UNALIGNED HIDDENCLSID *PHIDDENCLSID;
|
|
typedef const UNALIGNED HIDDENCLSID *PCHIDDENCLSID;
|
|
|
|
STDAPI_(LPITEMIDLIST) ILAppendHiddenClsid(LPITEMIDLIST pidl, IDLHID id, CLSID *pclsid)
|
|
{
|
|
HIDDENCLSID hc = {{sizeof(hc), 0, id}};
|
|
hc.clsid = *pclsid;
|
|
// WARNING - cannot use hid.wVersion for compat reasons - ZekeL - 23-OCT-2000
|
|
// on win2k and winMe we appended clsid's with wVersion
|
|
// as stack garbage. this means we cannot use it for anything
|
|
return ILAppendHiddenID(pidl, &hc.hid);
|
|
}
|
|
|
|
STDAPI_(BOOL) ILGetHiddenClsid(LPCITEMIDLIST pidl, IDLHID id, CLSID *pclsid)
|
|
{
|
|
PCHIDDENCLSID phc = (PCHIDDENCLSID) ILFindHiddenID(pidl, id);
|
|
// WARNING - cannot use hid.wVersion for compat reasons - ZekeL - 23-OCT-2000
|
|
// on win2k and winMe we appended clsid's with wVersion
|
|
// as stack garbage. this means we cannot use it for anything
|
|
if (phc)
|
|
{
|
|
*pclsid = phc->clsid;
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
#pragma pack(1)
|
|
typedef struct _HIDDENSTRINGA
|
|
{
|
|
HIDDENITEMID hid;
|
|
WORD type;
|
|
CHAR sz[1]; // variable length string
|
|
} HIDDENSTRINGA;
|
|
#pragma pack()
|
|
|
|
typedef UNALIGNED HIDDENSTRINGA *PHIDDENSTRINGA;
|
|
typedef const UNALIGNED HIDDENSTRINGA *PCHIDDENSTRINGA;
|
|
|
|
#pragma pack(1)
|
|
typedef struct _HIDDENSTRINGW
|
|
{
|
|
HIDDENITEMID hid;
|
|
WORD type;
|
|
WCHAR sz[1]; // canonical name to be passed to ISTRING
|
|
} HIDDENSTRINGW;
|
|
#pragma pack()
|
|
|
|
typedef UNALIGNED HIDDENSTRINGW *PHIDDENSTRINGW;
|
|
typedef const UNALIGNED HIDDENSTRINGW *PCHIDDENSTRINGW;
|
|
|
|
#define HIDSTRTYPE_ANSI 0x0001
|
|
#define HIDSTRTYPE_WIDE 0x0002
|
|
|
|
STDAPI_(LPITEMIDLIST) ILAppendHiddenStringW(LPITEMIDLIST pidl, IDLHID id, LPCWSTR psz)
|
|
{
|
|
// terminator is included in the ID definition
|
|
USHORT cb = (USHORT)sizeof(HIDDENSTRINGW) + CbFromCchW(lstrlenW(psz));
|
|
|
|
//
|
|
// Use HIDDENSTRINGW* here instead of PHIDDENSTRINGW which is defined
|
|
// as UNALIGNED.
|
|
//
|
|
|
|
HIDDENSTRINGW *phs = (HIDDENSTRINGW *) LocalAlloc(LPTR, cb);
|
|
|
|
if (phs)
|
|
{
|
|
phs->hid.cb = cb;
|
|
phs->hid.id = id;
|
|
phs->type = HIDSTRTYPE_WIDE;
|
|
StrCpyW(phs->sz, psz);
|
|
|
|
pidl = ILAppendHiddenID(pidl, &phs->hid);
|
|
LocalFree(phs);
|
|
return pidl;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
STDAPI_(LPITEMIDLIST) ILAppendHiddenStringA(LPITEMIDLIST pidl, IDLHID id, LPCSTR psz)
|
|
{
|
|
// terminator is included in the ID definition
|
|
USHORT cb = (USHORT)sizeof(HIDDENSTRINGA) + CbFromCchA(lstrlenA(psz));
|
|
|
|
//
|
|
// Use HIDDENSTRINGA* here instead of PHIDDENSTRINGW which is defined
|
|
// as UNALIGNED.
|
|
//
|
|
|
|
HIDDENSTRINGA *phs = (HIDDENSTRINGA *) LocalAlloc(LPTR, cb);
|
|
|
|
if (phs)
|
|
{
|
|
phs->hid.cb = cb;
|
|
phs->hid.id = id;
|
|
phs->type = HIDSTRTYPE_ANSI;
|
|
StrCpyA(phs->sz, psz);
|
|
|
|
pidl = ILAppendHiddenID(pidl, &phs->hid);
|
|
LocalFree(phs);
|
|
return pidl;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
STDAPI_(void *) _MemDupe(const UNALIGNED void *pv, DWORD cb)
|
|
{
|
|
void *pvRet = LocalAlloc(LPTR, cb);
|
|
if (pvRet)
|
|
{
|
|
CopyMemory(pvRet, pv, cb);
|
|
}
|
|
|
|
return pvRet;
|
|
}
|
|
|
|
STDAPI_(BOOL) ILGetHiddenStringW(LPCITEMIDLIST pidl, IDLHID id, LPWSTR psz, DWORD cch)
|
|
{
|
|
PCHIDDENSTRINGW phs = (PCHIDDENSTRINGW) ILFindHiddenID(pidl, id);
|
|
|
|
RIP(psz);
|
|
if (phs)
|
|
{
|
|
if (phs->type == HIDSTRTYPE_WIDE)
|
|
{
|
|
ualstrcpynW(psz, phs->sz, cch);
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
ASSERT(phs->type == HIDSTRTYPE_ANSI);
|
|
SHAnsiToUnicode((LPSTR)phs->sz, psz, cch);
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
STDAPI_(BOOL) ILGetHiddenStringA(LPCITEMIDLIST pidl, IDLHID id, LPSTR psz, DWORD cch)
|
|
{
|
|
PCHIDDENSTRINGW phs = (PCHIDDENSTRINGW) ILFindHiddenID(pidl, id);
|
|
|
|
RIP(psz);
|
|
if (phs)
|
|
{
|
|
if (phs->type == HIDSTRTYPE_ANSI)
|
|
{
|
|
ualstrcpynA(psz, (LPSTR)phs->sz, cch);
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
ASSERT(phs->type == HIDSTRTYPE_WIDE);
|
|
// we need to handle the unalignment here...
|
|
LPWSTR pszT = (LPWSTR) _MemDupe(phs->sz, CbFromCch(ualstrlenW(phs->sz) +1));
|
|
|
|
if (pszT)
|
|
{
|
|
SHUnicodeToAnsi(pszT, psz, cch);
|
|
LocalFree(pszT);
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
STDAPI_(int) ILCompareHiddenString(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2, IDLHID id)
|
|
{
|
|
|
|
// if there are fragments in here, then they might
|
|
// differentiate the two pidls
|
|
PCHIDDENSTRINGW ps1 = (PCHIDDENSTRINGW)ILFindHiddenID(pidl1, id);
|
|
PCHIDDENSTRINGW ps2 = (PCHIDDENSTRINGW)ILFindHiddenID(pidl2, id);
|
|
|
|
if (ps1 && ps2)
|
|
{
|
|
if (ps1->type == ps2->type)
|
|
{
|
|
if (ps1->type == HIDSTRTYPE_WIDE)
|
|
return ualstrcmpW(ps1->sz, ps2->sz);
|
|
|
|
ASSERT(ps1->type == HIDSTRTYPE_ANSI);
|
|
|
|
return lstrcmpA((LPCSTR)ps1->sz, (LPCSTR)ps2->sz);
|
|
}
|
|
else
|
|
{
|
|
SHSTRW str;
|
|
|
|
if (ps1->type == HIDSTRTYPE_ANSI)
|
|
{
|
|
str.SetStr((LPCSTR)ps1->sz);
|
|
return ualstrcmpW(str, ps2->sz);
|
|
}
|
|
else
|
|
{
|
|
ASSERT(ps2->type == HIDSTRTYPE_ANSI);
|
|
str.SetStr((LPCSTR)ps2->sz);
|
|
return ualstrcmpW(ps1->sz, str);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ps1)
|
|
return 1;
|
|
if (ps2)
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
STDAPI_(OBJCOMPATFLAGS) SHGetObjectCompatFlagsFromIDList(LPCITEMIDLIST pidl)
|
|
{
|
|
OBJCOMPATFLAGS ocf = 0;
|
|
CLSID clsid;
|
|
|
|
// APPCOMPAT: FileNet IDMDS (Panagon)'s shell folder extension returns
|
|
// E_NOTIMPL for IPersistFolder::GetClassID, so to detect the application,
|
|
// we have to crack the pidl. (B#359464: tracysh)
|
|
|
|
if (!ILIsEmpty(pidl)
|
|
&& pidl->mkid.cb >= sizeof(IDREGITEM)
|
|
&& pidl->mkid.abID[0] == SHID_ROOT_REGITEM)
|
|
{
|
|
clsid = ((LPCIDLREGITEM)pidl)->idri.clsid;
|
|
ocf = SHGetObjectCompatFlags(NULL, &clsid);
|
|
}
|
|
|
|
return ocf;
|
|
}
|
|
|
|
|
|
STDAPI_(LPITEMIDLIST) _ILCreate(UINT cbSize)
|
|
{
|
|
LPITEMIDLIST pidl = (LPITEMIDLIST)SHAlloc(cbSize);
|
|
if (pidl)
|
|
memset(pidl, 0, cbSize); // zero-init for external task allocator
|
|
|
|
return pidl;
|
|
}
|
|
|
|
//
|
|
// ILClone using Task allocator
|
|
//
|
|
STDAPI SHILClone(LPCITEMIDLIST pidl, LPITEMIDLIST * ppidlOut)
|
|
{
|
|
*ppidlOut = ILClone(pidl);
|
|
return *ppidlOut ? S_OK : E_OUTOFMEMORY;
|
|
}
|
|
|
|
//
|
|
// ILCombine using Task allocator
|
|
//
|
|
STDAPI SHILCombine(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2, LPITEMIDLIST * ppidlOut)
|
|
{
|
|
*ppidlOut = ILCombine(pidl1, pidl2);
|
|
return *ppidlOut ? S_OK : E_OUTOFMEMORY;
|
|
}
|
|
|
|
//
|
|
// rooted helpers
|
|
//
|
|
LPCIDREGITEM _IsRooted(LPCITEMIDLIST pidl)
|
|
{
|
|
LPCIDREGITEM pidlr = (LPCIDREGITEM)pidl;
|
|
if (!ILIsEmpty(pidl)
|
|
&& pidlr->cb > sizeof(IDREGITEM)
|
|
&& pidlr->bFlags == SHID_ROOTEDREGITEM)
|
|
return pidlr;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
STDAPI_(BOOL) ILIsRooted(LPCITEMIDLIST pidl)
|
|
{
|
|
return (NULL != _IsRooted(pidl));
|
|
}
|
|
|
|
#define _ROOTEDPIDL(pidlr) (LPITEMIDLIST)(((LPBYTE)pidlr)+sizeof(IDREGITEM))
|
|
|
|
STDAPI_(LPCITEMIDLIST) ILRootedFindIDList(LPCITEMIDLIST pidl)
|
|
{
|
|
LPCIDREGITEM pidlr = _IsRooted(pidl);
|
|
|
|
if (pidlr && pidlr->cb > sizeof(IDREGITEM))
|
|
{
|
|
// then we have a rooted IDList in there
|
|
return _ROOTEDPIDL(pidlr);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
STDAPI_(BOOL) ILRootedGetClsid(LPCITEMIDLIST pidl, CLSID *pclsid)
|
|
{
|
|
LPCIDREGITEM pidlr = _IsRooted(pidl);
|
|
|
|
*pclsid = pidlr ? pidlr->clsid : CLSID_NULL;
|
|
|
|
return (NULL != pidlr);
|
|
}
|
|
|
|
STDAPI_(LPITEMIDLIST) ILRootedCreateIDList(CLSID *pclsid, LPCITEMIDLIST pidl)
|
|
{
|
|
UINT cbPidl = ILGetSize(pidl);
|
|
UINT cbTotal = sizeof(IDREGITEM) + cbPidl;
|
|
|
|
LPIDREGITEM pidlr = (LPIDREGITEM) SHAlloc(cbTotal + sizeof(WORD));
|
|
|
|
if (pidlr)
|
|
{
|
|
pidlr->cb = (WORD)cbTotal;
|
|
|
|
pidlr->bFlags = SHID_ROOTEDREGITEM;
|
|
pidlr->bOrder = 0; // Nobody uses this (yet)
|
|
|
|
if (pclsid)
|
|
pidlr->clsid = *pclsid;
|
|
else
|
|
pidlr->clsid = CLSID_ShellDesktop;
|
|
|
|
MoveMemory(_ROOTEDPIDL(pidlr), pidl, cbPidl);
|
|
|
|
// terminate
|
|
_ILNext((LPITEMIDLIST)pidlr)->mkid.cb = 0;
|
|
}
|
|
|
|
return (LPITEMIDLIST) pidlr;
|
|
}
|
|
|
|
int CompareGUID(REFGUID guid1, REFGUID guid2)
|
|
{
|
|
TCHAR sz1[GUIDSTR_MAX];
|
|
TCHAR sz2[GUIDSTR_MAX];
|
|
|
|
SHStringFromGUIDW(guid1, sz1, SIZECHARS(sz1));
|
|
SHStringFromGUIDW(guid2, sz2, SIZECHARS(sz2));
|
|
|
|
return lstrcmp(sz1, sz2);
|
|
}
|
|
|
|
STDAPI_(int) ILRootedCompare(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
|
|
{
|
|
int iRet;
|
|
LPCIDREGITEM pidlr1 = _IsRooted(pidl1);
|
|
LPCIDREGITEM pidlr2 = _IsRooted(pidl2);
|
|
|
|
if (pidlr1 && pidlr2)
|
|
{
|
|
CLSID clsid1 = pidlr1->clsid;
|
|
CLSID clsid2 = pidlr2->clsid;
|
|
|
|
iRet = CompareGUID(clsid1, clsid2);
|
|
if (0 == iRet)
|
|
{
|
|
if (!ILIsEqual(_ROOTEDPIDL(pidl1), _ROOTEDPIDL(pidl2)))
|
|
{
|
|
IShellFolder *psfDesktop;
|
|
if (SUCCEEDED(SHGetDesktopFolder(&psfDesktop)))
|
|
{
|
|
HRESULT hr = psfDesktop->CompareIDs(0, _ROOTEDPIDL(pidl1), _ROOTEDPIDL(pidl2));
|
|
psfDesktop->Release();
|
|
iRet = ShortFromResult(hr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (pidlr1)
|
|
{
|
|
iRet = -1;
|
|
}
|
|
else if (pidlr2)
|
|
{
|
|
iRet = 1;
|
|
}
|
|
else
|
|
{
|
|
// if neither are rootes, then they share the desktop
|
|
// as the same root...
|
|
iRet = 0;
|
|
}
|
|
|
|
return iRet;
|
|
}
|
|
|
|
LPITEMIDLIST ILRootedTranslate(LPCITEMIDLIST pidlRooted, LPCITEMIDLIST pidlTrans)
|
|
{
|
|
LPCITEMIDLIST pidlChild = ILFindChild(ILRootedFindIDList(pidlRooted), pidlTrans);
|
|
|
|
if (pidlChild)
|
|
{
|
|
LPITEMIDLIST pidlRoot = ILCloneFirst(pidlRooted);
|
|
|
|
if (pidlRoot)
|
|
{
|
|
LPITEMIDLIST pidlRet = ILCombine(pidlRoot, pidlChild);
|
|
ILFree(pidlRoot);
|
|
return pidlRet;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
const ITEMIDLIST s_idlNULL = { 0 } ;
|
|
|
|
HRESULT ILRootedBindToRoot(LPCITEMIDLIST pidl, REFIID riid, void **ppv)
|
|
{
|
|
HRESULT hr;
|
|
CLSID clsid;
|
|
ASSERT(ILIsRooted(pidl));
|
|
|
|
ILRootedGetClsid(pidl, &clsid);
|
|
pidl = ILRootedFindIDList(pidl);
|
|
if (!pidl)
|
|
pidl = &s_idlNULL;
|
|
|
|
if (IsEqualGUID(clsid, CLSID_ShellDesktop))
|
|
{
|
|
hr = SHBindToObjectEx(NULL, pidl, NULL, riid, ppv);
|
|
}
|
|
else
|
|
{
|
|
IPersistFolder* ppf;
|
|
hr = SHCoCreateInstance(NULL, &clsid, NULL, IID_PPV_ARG(IPersistFolder, &ppf));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = ppf->Initialize(pidl);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = ppf->QueryInterface(riid, ppv);
|
|
}
|
|
ppf->Release();
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT ILRootedBindToObject(LPCITEMIDLIST pidl, REFIID riid, void **ppv)
|
|
{
|
|
IShellFolder *psf;
|
|
HRESULT hr = ILRootedBindToRoot(pidl, IID_PPV_ARG(IShellFolder, &psf));
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pidl = _ILNext(pidl);
|
|
|
|
if (ILIsEmpty(pidl))
|
|
hr = psf->QueryInterface(riid, ppv);
|
|
else
|
|
hr = psf->BindToObject(pidl, NULL, riid, ppv);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT ILRootedBindToParentFolder(LPCITEMIDLIST pidl, REFIID riid, void **ppv, LPCITEMIDLIST *ppidlChild)
|
|
{
|
|
//
|
|
// there are three different cases to handle
|
|
//
|
|
// 1. Rooted pidl Alone
|
|
// [ rooted id [ target pidl ] ]
|
|
// return the parent folder of the target pidl
|
|
// and return its last id in ppidlChild
|
|
//
|
|
// 2. Rooted pidl with One Child
|
|
// [ rooted id [ target pidl ] ][ child id ]
|
|
// return the rooted id as the parent folder
|
|
// and the child id in ppidlChild
|
|
//
|
|
// 3. rooted pidl with many children
|
|
// [ rooted id [ target pidl ] ][ parent id ][ child id ]
|
|
// return rooted id bound to parent id as the folder
|
|
// and the child id in ppidlchild
|
|
//
|
|
|
|
HRESULT hr;
|
|
ASSERT(ILIsRooted(pidl));
|
|
|
|
//
|
|
// if this is a rooted pidl and it is just the root
|
|
// then we can bind to the target pidl of the root instead
|
|
//
|
|
if (ILIsEmpty(_ILNext(pidl)))
|
|
{
|
|
hr = SHBindToIDListParent(ILRootedFindIDList(pidl), riid, ppv, ppidlChild);
|
|
}
|
|
else
|
|
{
|
|
LPITEMIDLIST pidlParent = ILCloneParent(pidl);
|
|
if (pidlParent)
|
|
{
|
|
hr = ILRootedBindToObject(pidlParent, riid, ppv);
|
|
ILFree(pidlParent);
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
if (ppidlChild)
|
|
*ppidlChild = ILFindLastID(pidl);
|
|
}
|
|
|
|
|
|
return hr;
|
|
}
|
|
|
|
#define HIDA_GetPIDLItem(pida, i) (LPCITEMIDLIST)(((LPBYTE)pida)+(pida)->aoffset[i+1])
|
|
#define HIDA_GetPIDLFolder(pida) (LPCITEMIDLIST)(((LPBYTE)pida)+(pida)->aoffset[0])
|
|
|
|
STDAPI_(LPITEMIDLIST) IDA_ILClone(LPIDA pida, UINT i)
|
|
{
|
|
if (i < pida->cidl)
|
|
return ILCombine(HIDA_GetPIDLFolder(pida), HIDA_GetPIDLItem(pida, i));
|
|
return NULL;
|
|
}
|
|
|
|
STDAPI_(void) EnableOKButtonFromString(HWND hDlg, LPTSTR pszText)
|
|
{
|
|
BOOL bNonEmpty;
|
|
|
|
PathRemoveBlanks(pszText); // REVIEW, should we not remove from the end of
|
|
bNonEmpty = lstrlen(pszText); // Not a BOOL, but okay
|
|
|
|
EnableWindow(GetDlgItem(hDlg, IDOK), bNonEmpty);
|
|
if (bNonEmpty)
|
|
{
|
|
SendMessage(hDlg, DM_SETDEFID, IDOK, 0L);
|
|
}
|
|
}
|
|
|
|
STDAPI_(void) EnableOKButtonFromID(HWND hDlg, int id)
|
|
{
|
|
TCHAR szText[MAX_PATH];
|
|
|
|
if (!GetDlgItemText(hDlg, id, szText, ARRAYSIZE(szText)))
|
|
{
|
|
szText[0] = 0;
|
|
}
|
|
|
|
EnableOKButtonFromString(hDlg, szText);
|
|
}
|
|
|
|
//
|
|
// C-callable versions of the ATL string conversion functions.
|
|
//
|
|
|
|
STDAPI_(LPWSTR) SHA2WHelper(LPWSTR lpw, LPCSTR lpa, int nChars)
|
|
{
|
|
ASSERT(lpa != NULL);
|
|
ASSERT(lpw != NULL);
|
|
// verify that no illegal character present
|
|
// since lpw was allocated based on the size of lpa
|
|
// don't worry about the number of chars
|
|
lpw[0] = '\0';
|
|
MultiByteToWideChar(CP_ACP, 0, lpa, -1, lpw, nChars);
|
|
return lpw;
|
|
}
|
|
|
|
STDAPI_(LPSTR) SHW2AHelper(LPSTR lpa, LPCWSTR lpw, int nChars)
|
|
{
|
|
ASSERT(lpw != NULL);
|
|
ASSERT(lpa != NULL);
|
|
// verify that no illegal character present
|
|
// since lpa was allocated based on the size of lpw
|
|
// don't worry about the number of chars
|
|
lpa[0] = '\0';
|
|
WideCharToMultiByte(CP_ACP, 0, lpw, -1, lpa, nChars, NULL, NULL);
|
|
return lpa;
|
|
}
|
|
|
|
//
|
|
// Helper functions for SHChangeMenuAsIDList
|
|
//
|
|
// See comment in declaration of SHChangeMenuAsIDList for caveats about
|
|
// the pSender member.
|
|
//
|
|
// This is tricky because IE 5.0 shipped with a Win64-unfriendly version
|
|
// of this notification, so we have to sniff the structure and see if
|
|
// this is an IE 5.0 style notification or a new Win64 style notification.
|
|
// If an IE 5.0 style notification, then it was not sent by us because
|
|
// we send the new Win64-style notification.
|
|
//
|
|
STDAPI_(BOOL) SHChangeMenuWasSentByMe(void * self, LPCITEMIDLIST pidlNotify)
|
|
{
|
|
SHChangeMenuAsIDList UNALIGNED * pcmidl = (SHChangeMenuAsIDList UNALIGNED *)pidlNotify;
|
|
return pcmidl->cb >= FIELD_OFFSET(SHChangeMenuAsIDList, cbZero) &&
|
|
pcmidl->pSender == (INT64)self &&
|
|
pcmidl->dwProcessID == GetCurrentProcessId();
|
|
}
|
|
|
|
//
|
|
//
|
|
// Send out an extended event changenotify, using a SHChangeMenuAsIDList
|
|
// as the pidl1 so recipients can identify whether they were the
|
|
// sender or not.
|
|
//
|
|
// It's okay to pass self==NULL here. It means you don't care about
|
|
// detecting whether it was sent by you or not.
|
|
//
|
|
|
|
STDAPI_(void) SHSendChangeMenuNotify(void * self, DWORD shcnee, DWORD shcnf, LPCITEMIDLIST pidl2)
|
|
{
|
|
SHChangeMenuAsIDList cmidl;
|
|
|
|
cmidl.cb = FIELD_OFFSET(SHChangeMenuAsIDList, cbZero);
|
|
cmidl.dwItem1 = shcnee;
|
|
cmidl.pSender = (INT64)self;
|
|
cmidl.dwProcessID = self ? GetCurrentProcessId() : 0;
|
|
cmidl.cbZero = 0;
|
|
|
|
// Nobody had better have specified a type; the type must be
|
|
// SHCNF_IDLIST.
|
|
ASSERT((shcnf & SHCNF_TYPE) == 0);
|
|
SHChangeNotify(SHCNE_EXTENDED_EVENT, shcnf | SHCNF_IDLIST, (LPCITEMIDLIST)&cmidl, pidl2);
|
|
}
|
|
|
|
|
|
// Return FALSE if out of memory
|
|
STDAPI_(BOOL) Pidl_Set(LPITEMIDLIST* ppidl, LPCITEMIDLIST pidl)
|
|
{
|
|
BOOL bRet = TRUE;
|
|
LPITEMIDLIST pidlNew;
|
|
|
|
ASSERT(IS_VALID_WRITE_PTR(ppidl, LPITEMIDLIST));
|
|
ASSERT(NULL == *ppidl || IS_VALID_PIDL(*ppidl));
|
|
ASSERT(NULL == pidl || IS_VALID_PIDL(pidl));
|
|
|
|
if (pidl)
|
|
{
|
|
pidlNew = ILClone(pidl);
|
|
if (!pidlNew)
|
|
{
|
|
bRet = FALSE; // failed to clone the pidl (out of memory)
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pidlNew = NULL;
|
|
}
|
|
|
|
LPITEMIDLIST pidlToFree = (LPITEMIDLIST)InterlockedExchangePointer((void **)ppidl, (void *)pidlNew);
|
|
if (pidlToFree)
|
|
{
|
|
ILFree(pidlToFree);
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
// this needs to be the last thing in the file that uses ILClone, because everywhere
|
|
// else, ILClone becomes SafeILClone
|
|
#undef ILClone
|
|
|
|
STDAPI_(LPITEMIDLIST) SafeILClone(LPCITEMIDLIST pidl)
|
|
{
|
|
// the shell32 implementation of ILClone is different for win95 an ie4.
|
|
// it doesnt check for NULL in the old version, but it does in the new...
|
|
// so we need to always check
|
|
return pidl ? ILClone(pidl) : NULL;
|
|
}
|
|
|
|
//
|
|
// retrieves the UIObject interface for the specified full pidl.
|
|
//
|
|
STDAPI SHGetUIObjectFromFullPIDL(LPCITEMIDLIST pidl, HWND hwnd, REFIID riid, void **ppv)
|
|
{
|
|
*ppv = NULL;
|
|
|
|
LPCITEMIDLIST pidlChild;
|
|
IShellFolder* psf;
|
|
HRESULT hr = SHBindToIDListParent(pidl, IID_PPV_ARG(IShellFolder, &psf), &pidlChild);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = psf->GetUIObjectOf(hwnd, 1, &pidlChild, riid, NULL, ppv);
|
|
psf->Release();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDAPI LoadFromFileW(REFCLSID clsid, LPCWSTR pszFile, REFIID riid, void **ppv)
|
|
{
|
|
*ppv = NULL;
|
|
|
|
IPersistFile *ppf;
|
|
HRESULT hr = SHCoCreateInstance(NULL, &clsid, NULL, IID_PPV_ARG(IPersistFile, &ppf));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = ppf->Load(pszFile, STGM_READ);
|
|
if (SUCCEEDED(hr))
|
|
hr = ppf->QueryInterface(riid, ppv);
|
|
ppf->Release();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDAPI LoadFromIDList(REFCLSID clsid, LPCITEMIDLIST pidl, REFIID riid, void **ppv)
|
|
{
|
|
*ppv = NULL;
|
|
|
|
IPersistFolder *ppf;
|
|
HRESULT hr = SHCoCreateInstanceAC(clsid, NULL, CLSCTX_INPROC, IID_PPV_ARG(IPersistFolder, &ppf));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = ppf->Initialize(pidl);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = ppf->QueryInterface(riid, ppv);
|
|
}
|
|
ppf->Release();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// This is a helper function for finding a specific verb's index in a context menu
|
|
//
|
|
STDAPI_(UINT) GetMenuIndexForCanonicalVerb(HMENU hMenu, IContextMenu *pcm, UINT idCmdFirst, LPCWSTR pwszVerb)
|
|
{
|
|
int cMenuItems = GetMenuItemCount(hMenu);
|
|
for (int iItem = 0; iItem < cMenuItems; iItem++)
|
|
{
|
|
MENUITEMINFO mii = {0};
|
|
|
|
mii.cbSize = sizeof(mii);
|
|
mii.fMask = MIIM_TYPE | MIIM_ID;
|
|
|
|
// IS_INTRESOURCE guards against mii.wID == -1 **and** against
|
|
// buggy shell extensions which set their menu item IDs out of range.
|
|
if (GetMenuItemInfo(hMenu, iItem, MF_BYPOSITION, &mii) &&
|
|
!(mii.fType & MFT_SEPARATOR) && IS_INTRESOURCE(mii.wID) &&
|
|
(mii.wID >= idCmdFirst))
|
|
{
|
|
union {
|
|
WCHAR szItemNameW[80];
|
|
char szItemNameA[80];
|
|
};
|
|
CHAR aszVerb[80];
|
|
|
|
// try both GCS_VERBA and GCS_VERBW in case it only supports one of them
|
|
SHUnicodeToAnsi(pwszVerb, aszVerb, ARRAYSIZE(aszVerb));
|
|
|
|
if (SUCCEEDED(pcm->GetCommandString(mii.wID - idCmdFirst, GCS_VERBA, NULL, szItemNameA, ARRAYSIZE(szItemNameA))))
|
|
{
|
|
if (StrCmpICA(szItemNameA, aszVerb) == 0)
|
|
{
|
|
break; // found it
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (SUCCEEDED(pcm->GetCommandString(mii.wID - idCmdFirst, GCS_VERBW, NULL, (LPSTR)szItemNameW, ARRAYSIZE(szItemNameW))) &&
|
|
(StrCmpICW(szItemNameW, pwszVerb) == 0))
|
|
{
|
|
break; // found it
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (iItem == cMenuItems)
|
|
{
|
|
iItem = -1; // went through all the menuitems and didn't find it
|
|
}
|
|
|
|
return iItem;
|
|
}
|
|
|
|
// deal with GCS_VERBW/GCS_VERBA maddness
|
|
|
|
STDAPI ContextMenu_GetCommandStringVerb(IContextMenu *pcm, UINT idCmd, LPWSTR pszVerb, int cchVerb)
|
|
{
|
|
// Ulead SmartSaver Pro has a 60 character verb, and
|
|
// over writes out stack, ignoring the cch param and we fault.
|
|
// so make sure this buffer is at least 60 chars
|
|
|
|
TCHAR wszVerb[64];
|
|
wszVerb[0] = 0;
|
|
|
|
HRESULT hr = pcm->GetCommandString(idCmd, GCS_VERBW, NULL, (LPSTR)wszVerb, ARRAYSIZE(wszVerb));
|
|
if (FAILED(hr))
|
|
{
|
|
// be extra paranoid about requesting the ansi version -- we've
|
|
// found IContextMenu implementations that return a UNICODE buffer
|
|
// even though we ask for an ANSI string on NT systems -- hopefully
|
|
// they will have answered the above request already, but just in
|
|
// case let's not let them overrun our stack!
|
|
char szVerbAnsi[128];
|
|
hr = pcm->GetCommandString(idCmd, GCS_VERBA, NULL, szVerbAnsi, ARRAYSIZE(szVerbAnsi) / 2);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
SHAnsiToUnicode(szVerbAnsi, wszVerb, ARRAYSIZE(wszVerb));
|
|
}
|
|
}
|
|
|
|
StrCpyNW(pszVerb, wszVerb, cchVerb);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//
|
|
// Purpose: Deletes the menu item specified by name
|
|
//
|
|
// Parameters: pcm - Context menu interface
|
|
// hpopup - Context menu handle
|
|
// idFirst - Beginning of id range
|
|
// pszCommand - Command to look for
|
|
//
|
|
|
|
STDAPI ContextMenu_DeleteCommandByName(IContextMenu *pcm, HMENU hpopup, UINT idFirst, LPCWSTR pszCommand)
|
|
{
|
|
UINT ipos = GetMenuIndexForCanonicalVerb(hpopup, pcm, idFirst, pszCommand);
|
|
if (ipos != -1)
|
|
{
|
|
DeleteMenu(hpopup, ipos, MF_BYPOSITION);
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Helpers to banish STRRET's into the realm of darkness
|
|
//
|
|
|
|
STDAPI DisplayNameOf(IShellFolder *psf, LPCITEMIDLIST pidl, DWORD flags, LPTSTR psz, UINT cch)
|
|
{
|
|
*psz = 0;
|
|
STRRET sr;
|
|
HRESULT hr = psf->GetDisplayNameOf(pidl, flags, &sr);
|
|
if (SUCCEEDED(hr))
|
|
hr = StrRetToBuf(&sr, pidl, psz, cch);
|
|
return hr;
|
|
}
|
|
|
|
STDAPI DisplayNameOfAsOLESTR(IShellFolder *psf, LPCITEMIDLIST pidl, DWORD flags, LPWSTR *ppsz)
|
|
{
|
|
*ppsz = NULL;
|
|
STRRET sr;
|
|
HRESULT hr = psf->GetDisplayNameOf(pidl, flags, &sr);
|
|
if (SUCCEEDED(hr))
|
|
hr = StrRetToStrW(&sr, pidl, ppsz);
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
// get the target pidl for a folder pidl. this deals with the case where a folder
|
|
// is an alias to a real folder, Folder Shortcuts, etc.
|
|
|
|
STDAPI SHGetTargetFolderIDList(LPCITEMIDLIST pidlFolder, LPITEMIDLIST *ppidl)
|
|
{
|
|
*ppidl = NULL;
|
|
|
|
// likely should ASSERT() that pidlFolder has SFGAO_FOLDER
|
|
IShellLink *psl;
|
|
HRESULT hr = SHGetUIObjectFromFullPIDL(pidlFolder, NULL, IID_PPV_ARG(IShellLink, &psl));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = psl->GetIDList(ppidl);
|
|
psl->Release();
|
|
}
|
|
|
|
// No its not a folder shortcut. Get the pidl normally.
|
|
if (FAILED(hr))
|
|
hr = SHILClone(pidlFolder, ppidl);
|
|
return hr;
|
|
}
|
|
|
|
// get the target folder for a folder pidl. this deals with the case where a folder
|
|
// is an alias to a real folder, Folder Shortcuts, MyDocs, etc.
|
|
|
|
STDAPI SHGetTargetFolderPathW(LPCITEMIDLIST pidlFolder, LPWSTR pszPath, UINT cchPath)
|
|
{
|
|
*pszPath = 0;
|
|
|
|
LPITEMIDLIST pidlTarget;
|
|
if (SUCCEEDED(SHGetTargetFolderIDList(pidlFolder, &pidlTarget)))
|
|
{
|
|
SHGetPathFromIDListW(pidlTarget, pszPath); // make sure it is a path
|
|
ILFree(pidlTarget);
|
|
}
|
|
return *pszPath ? S_OK : E_FAIL;
|
|
}
|
|
|
|
STDAPI SHGetTargetFolderPathA(LPCITEMIDLIST pidlFolder, LPSTR pszPath, UINT cchPath)
|
|
{
|
|
*pszPath = 0;
|
|
WCHAR szPath[MAX_PATH];
|
|
HRESULT hr = SHGetTargetFolderPathW(pidlFolder, szPath, ARRAYSIZE(szPath));
|
|
if (SUCCEEDED(hr))
|
|
SHAnsiToUnicode(pszPath, szPath, cchPath);
|
|
return hr;
|
|
}
|
|
|
|
STDAPI SHBuildDisplayMachineName(LPCWSTR pszMachineName, LPCWSTR pszComment, LPWSTR pszDisplayName, DWORD cchDisplayName)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if (pszComment && pszComment[0])
|
|
{
|
|
// encorporate the comment into the display name
|
|
LPCWSTR pszNoSlashes = SkipServerSlashes(pszMachineName);
|
|
int i = wnsprintfW(pszDisplayName, cchDisplayName, L"%s (%s)", pszComment, pszNoSlashes);
|
|
hr = (i < 0) ? E_FAIL : S_OK;
|
|
}
|
|
else
|
|
{
|
|
// Return failure here so netfldr can do smarter things to build a display name
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
// create objects from registered under a key value, uses the per user per machine
|
|
// reg services to do this.
|
|
|
|
STDAPI CreateFromRegKey(LPCWSTR pszKey, LPCWSTR pszValue, REFIID riid, void **ppv)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
WCHAR szCLSID[MAX_PATH];
|
|
DWORD cbSize = sizeof(szCLSID);
|
|
if (SHRegGetUSValueW(pszKey, pszValue, NULL, szCLSID, &cbSize, FALSE, NULL, 0) == ERROR_SUCCESS)
|
|
{
|
|
CLSID clsid;
|
|
if (GUIDFromString(szCLSID, &clsid))
|
|
{
|
|
hr = SHCoCreateInstanceAC(clsid, NULL, CLSCTX_INPROC_SERVER, riid, ppv);
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// SHProcessMessagesUntilEvent:
|
|
//
|
|
// this executes message loop until an event or a timeout occurs
|
|
//
|
|
STDAPI_(DWORD) SHProcessMessagesUntilEventEx(HWND hwnd, HANDLE hEvent, DWORD dwTimeout, DWORD dwWakeMask)
|
|
{
|
|
DWORD dwEndTime = GetTickCount() + dwTimeout;
|
|
LONG lWait = (LONG)dwTimeout;
|
|
DWORD dwReturn;
|
|
|
|
if (!hEvent && (dwTimeout == INFINITE))
|
|
{
|
|
ASSERTMSG(FALSE, "SHProcessMessagesUntilEvent: caller passed a NULL hEvent and an INFINITE timeout!!");
|
|
return -1;
|
|
}
|
|
|
|
for (;;)
|
|
{
|
|
DWORD dwCount = hEvent ? 1 : 0;
|
|
dwReturn = MsgWaitForMultipleObjects(dwCount, &hEvent, FALSE, lWait, dwWakeMask);
|
|
|
|
// were we signalled or did we time out?
|
|
if (dwReturn != (WAIT_OBJECT_0 + dwCount))
|
|
{
|
|
break;
|
|
}
|
|
|
|
// we woke up because of messages.
|
|
MSG msg;
|
|
while (PeekMessage(&msg, hwnd, 0, 0, PM_REMOVE))
|
|
{
|
|
ASSERT(msg.message != WM_QUIT);
|
|
TranslateMessage(&msg);
|
|
if (msg.message == WM_SETCURSOR)
|
|
{
|
|
SetCursor(LoadCursor(NULL, IDC_WAIT));
|
|
}
|
|
else
|
|
{
|
|
DispatchMessage(&msg);
|
|
}
|
|
}
|
|
|
|
// calculate new timeout value
|
|
if (dwTimeout != INFINITE)
|
|
{
|
|
lWait = (LONG)dwEndTime - GetTickCount();
|
|
}
|
|
}
|
|
|
|
return dwReturn;
|
|
}
|
|
|
|
// deals with goofyness of IShellFolder::GetAttributesOf() including
|
|
// in/out param issue
|
|
// failures
|
|
// goofy cast for 1 item case
|
|
// masks off results to only return what you asked for
|
|
|
|
STDAPI_(DWORD) SHGetAttributes(IShellFolder *psf, LPCITEMIDLIST pidl, DWORD dwAttribs)
|
|
{
|
|
// like SHBindToObject, if psf is NULL, use absolute pidl
|
|
LPCITEMIDLIST pidlChild;
|
|
if (!psf)
|
|
{
|
|
SHBindToParent(pidl, IID_PPV_ARG(IShellFolder, &psf), &pidlChild);
|
|
}
|
|
else
|
|
{
|
|
psf->AddRef();
|
|
pidlChild = pidl;
|
|
}
|
|
|
|
DWORD dw = 0;
|
|
if (psf)
|
|
{
|
|
dw = dwAttribs;
|
|
dw = SUCCEEDED(psf->GetAttributesOf(1, (LPCITEMIDLIST *)&pidlChild, &dw)) ? (dwAttribs & dw) : 0;
|
|
if ((dw & SFGAO_FOLDER) && (dw & SFGAO_CANMONIKER) && !(dw & SFGAO_STORAGEANCESTOR) && (dwAttribs & SFGAO_STORAGEANCESTOR))
|
|
{
|
|
if (OBJCOMPATF_NEEDSSTORAGEANCESTOR & SHGetObjectCompatFlags(psf, NULL))
|
|
{
|
|
// switch SFGAO_CANMONIKER -> SFGAO_STORAGEANCESTOR
|
|
dw |= SFGAO_STORAGEANCESTOR;
|
|
dw &= ~SFGAO_CANMONIKER;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (psf)
|
|
{
|
|
psf->Release();
|
|
}
|
|
|
|
return dw;
|
|
}
|
|
|
|
//===========================================================================
|
|
// IDLARRAY stuff
|
|
//===========================================================================
|
|
|
|
STDAPI_(HIDA) HIDA_Create(LPCITEMIDLIST pidlFolder, UINT cidl, LPCITEMIDLIST * apidl)
|
|
{
|
|
UINT offset = sizeof(CIDA) + sizeof(UINT) * cidl;
|
|
UINT cbTotal = offset + ILGetSize(pidlFolder);
|
|
for (UINT i = 0; i<cidl ; i++)
|
|
{
|
|
cbTotal += ILGetSize(apidl[i]);
|
|
}
|
|
|
|
HIDA hida = GlobalAlloc(GPTR, cbTotal); // This MUST be GlobalAlloc!!!
|
|
if (hida)
|
|
{
|
|
LPIDA pida = (LPIDA)hida; // no need to lock
|
|
|
|
LPCITEMIDLIST pidlNext;
|
|
pida->cidl = cidl;
|
|
|
|
for (i = 0, pidlNext = pidlFolder; ; pidlNext = apidl[i++])
|
|
{
|
|
UINT cbSize = ILGetSize(pidlNext);
|
|
pida->aoffset[i] = offset;
|
|
CopyMemory(((LPBYTE)pida) + offset, pidlNext, cbSize);
|
|
offset += cbSize;
|
|
|
|
ASSERT(ILGetSize(HIDA_GetPIDLItem(pida,i-1)) == cbSize);
|
|
|
|
if (i == cidl)
|
|
break;
|
|
}
|
|
|
|
ASSERT(offset == cbTotal);
|
|
}
|
|
|
|
return hida;
|
|
}
|
|
|
|
STDAPI_(void) HIDA_Free(HIDA hida)
|
|
{
|
|
GlobalFree(hida);
|
|
}
|
|
|
|
STDAPI_(HIDA) HIDA_Clone(HIDA hida)
|
|
{
|
|
SIZE_T cbTotal = GlobalSize(hida);
|
|
HIDA hidaCopy = GlobalAlloc(GMEM_FIXED, cbTotal);
|
|
if (hidaCopy)
|
|
{
|
|
CopyMemory(hidaCopy, GlobalLock(hida), cbTotal);
|
|
GlobalUnlock(hida);
|
|
}
|
|
return hidaCopy;
|
|
}
|
|
|
|
STDAPI_(UINT) HIDA_GetCount(HIDA hida)
|
|
{
|
|
UINT count = 0;
|
|
LPIDA pida = (LPIDA)GlobalLock(hida);
|
|
if (pida)
|
|
{
|
|
count = pida->cidl;
|
|
GlobalUnlock(hida);
|
|
}
|
|
return count;
|
|
}
|
|
|
|
STDAPI_(UINT) HIDA_GetIDList(HIDA hida, UINT i, LPITEMIDLIST pidlOut, UINT cbMax)
|
|
{
|
|
LPIDA pida = (LPIDA)GlobalLock(hida);
|
|
if (pida)
|
|
{
|
|
LPCITEMIDLIST pidlFolder = HIDA_GetPIDLFolder(pida);
|
|
LPCITEMIDLIST pidlItem = HIDA_GetPIDLItem(pida, i);
|
|
UINT cbFolder = ILGetSize(pidlFolder) - sizeof(USHORT);
|
|
UINT cbItem = ILGetSize(pidlItem);
|
|
if (cbMax < cbFolder+cbItem)
|
|
{
|
|
if (pidlOut)
|
|
pidlOut->mkid.cb = 0;
|
|
}
|
|
else
|
|
{
|
|
MoveMemory(pidlOut, pidlFolder, cbFolder);
|
|
MoveMemory(((LPBYTE)pidlOut) + cbFolder, pidlItem, cbItem);
|
|
}
|
|
GlobalUnlock(hida);
|
|
|
|
return cbFolder + cbItem;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
STDAPI_(BOOL) PathIsImage(LPCTSTR pszFile)
|
|
{
|
|
BOOL fPicture = FALSE;
|
|
LPTSTR pszExt = PathFindExtension(pszFile);
|
|
if (pszExt)
|
|
{
|
|
// there's no ASSOCSTR_PERCEIVED so pick it up from the registry.
|
|
TCHAR szPerceivedType[MAX_PATH];
|
|
DWORD cb = ARRAYSIZE(szPerceivedType) * sizeof(TCHAR);
|
|
if (ERROR_SUCCESS == SHGetValue(HKEY_CLASSES_ROOT, pszExt, TEXT("PerceivedType"), NULL, szPerceivedType, &cb))
|
|
{
|
|
fPicture = (StrCmpI(szPerceivedType, TEXT("image")) == 0);
|
|
}
|
|
}
|
|
return fPicture;
|
|
}
|
|
|
|
// helper function to create a stream or storage in a storage.
|
|
HRESULT CreateStreamOrStorage(IStorage * pStorageParent, LPCTSTR pszName, REFIID riid, void **ppv)
|
|
{
|
|
DWORD grfModeCreated = STGM_READWRITE;
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
if (IsEqualGUID(riid, IID_IStorage))
|
|
{
|
|
IStorage * pStorageCreated;
|
|
hr = pStorageParent->CreateStorage(pszName, grfModeCreated, 0, 0, &pStorageCreated);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pStorageParent->Commit(STGC_DEFAULT);
|
|
*ppv = pStorageCreated;
|
|
}
|
|
}
|
|
else if (IsEqualGUID(riid, IID_IStream))
|
|
{
|
|
IStream * pStreamCreated;
|
|
hr = pStorageParent->CreateStream(pszName, grfModeCreated, 0, 0, &pStreamCreated);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pStorageParent->Commit(STGC_DEFAULT);
|
|
*ppv = pStreamCreated;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
// same as PathMakeUniqueNameEx but it works on storages.
|
|
// Note: LFN only!
|
|
STDAPI StgMakeUniqueNameWithCount(IStorage *pStorageParent, LPCWSTR pszTemplate,
|
|
int iMinLong, REFIID riid, void **ppv)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
RIPMSG(pszTemplate && IS_VALID_STRING_PTR(pszTemplate, -1) && lstrlen(pszTemplate)<(MAX_PATH-6), "StgMakeUniqueNameWithCount: invalid pszTemplate");
|
|
if (pszTemplate && lstrlen(pszTemplate)<(MAX_PATH-6)) // -6 for " (999)"
|
|
{
|
|
WCHAR szBuffer[MAX_PATH];
|
|
WCHAR szFormat[MAX_PATH];
|
|
int cchStem;
|
|
|
|
// Set up:
|
|
// cchStem : length of pszTemplate we're going to use w/o wsprintf
|
|
// szFormat : format string to wsprintf the number with, catenates on to pszTemplate[0..cchStem]
|
|
|
|
// Has template already been uniquified?
|
|
//
|
|
LPWSTR pszRest = StrChr(pszTemplate, L'(');
|
|
while (pszRest)
|
|
{
|
|
// First validate that this is the right one
|
|
LPWSTR pszEndUniq = CharNext(pszRest);
|
|
while (*pszEndUniq && *pszEndUniq >= L'0' && *pszEndUniq <= L'9')
|
|
{
|
|
pszEndUniq++;
|
|
}
|
|
if (*pszEndUniq == L')')
|
|
break; // We have the right one!
|
|
pszRest = StrChr(CharNext(pszRest), L'(');
|
|
}
|
|
|
|
if (!pszRest)
|
|
{
|
|
// if no (, then tack it on at the end. (but before the extension)
|
|
// eg. New Link yields New Link (1)
|
|
pszRest = PathFindExtension(pszTemplate);
|
|
cchStem = (int)(pszRest - pszTemplate);
|
|
wsprintf(szFormat, L" (%%d)%s", pszRest ? pszRest : L"");
|
|
}
|
|
else
|
|
{
|
|
// Template has been uniquified, remove uniquing digits
|
|
// eg. New Link (1) yields New Link (2)
|
|
//
|
|
pszRest++; // step over the (
|
|
|
|
cchStem = (int) (pszRest - pszTemplate);
|
|
|
|
while (*pszRest && *pszRest >= L'0' && *pszRest <= L'9')
|
|
{
|
|
pszRest++;
|
|
}
|
|
|
|
// we are guaranteed enough room because we don't include
|
|
// the stuff before the # in this format
|
|
wsprintf(szFormat, L"%%d%s", pszRest);
|
|
}
|
|
|
|
|
|
// copy the fixed portion into the buffer
|
|
//
|
|
StrCpyN(szBuffer, pszTemplate, cchStem+1);
|
|
|
|
// Iterate on the uniquifying szFormat portion until we find a unique name:
|
|
//
|
|
LPTSTR pszDigit = szBuffer + cchStem;
|
|
hr = STG_E_FILEALREADYEXISTS;
|
|
for (int i = iMinLong; (i < 1000) && (STG_E_FILEALREADYEXISTS == hr); i++)
|
|
{
|
|
wsprintf(pszDigit, szFormat, i);
|
|
|
|
// okay, we have the unique name, so create it in the storage.
|
|
hr = CreateStreamOrStorage(pStorageParent, szBuffer, riid, ppv);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDAPI StgMakeUniqueName(IStorage *pStorageParent, LPCTSTR pszFileSpec, REFIID riid, void **ppv)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
TCHAR szTemp[MAX_PATH];
|
|
|
|
LPTSTR psz;
|
|
LPTSTR pszNew;
|
|
|
|
// try it without the ( if there's a space after it
|
|
psz = StrChr(pszFileSpec, L'(');
|
|
while (psz)
|
|
{
|
|
if (*(CharNext(psz)) == L')')
|
|
break;
|
|
psz = StrChr(CharNext(psz), L'(');
|
|
}
|
|
|
|
if (psz)
|
|
{
|
|
// We have the (). See if we have either x () y or x ().y in which case
|
|
// we probably want to get rid of one of the blanks...
|
|
int ichSkip = 2;
|
|
LPTSTR pszT = CharPrev(pszFileSpec, psz);
|
|
if (*pszT == L' ')
|
|
{
|
|
ichSkip = 3;
|
|
psz = pszT;
|
|
}
|
|
|
|
pszNew = szTemp;
|
|
lstrcpy(pszNew, pszFileSpec);
|
|
pszNew += (psz - pszFileSpec);
|
|
lstrcpy(pszNew, psz + ichSkip);
|
|
}
|
|
else
|
|
{
|
|
// 1taro registers its document with '/'.
|
|
if (psz=StrChr(pszFileSpec, '/'))
|
|
{
|
|
LPTSTR pszT = CharNext(psz);
|
|
pszNew = szTemp;
|
|
lstrcpy(pszNew, pszFileSpec);
|
|
pszNew += (psz - pszFileSpec);
|
|
lstrcpy(pszNew, pszT);
|
|
}
|
|
else
|
|
{
|
|
lstrcpy(szTemp, pszFileSpec);
|
|
}
|
|
}
|
|
|
|
hr = CreateStreamOrStorage(pStorageParent, szTemp, riid, ppv);
|
|
if (FAILED(hr))
|
|
{
|
|
hr = StgMakeUniqueNameWithCount(pStorageParent, pszFileSpec, 2, riid, ppv);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDAPI SHInvokeCommandOnPidl(HWND hwnd, IUnknown* punk, LPCITEMIDLIST pidl, UINT uFlags, LPCSTR lpVerb)
|
|
{
|
|
IShellFolder* psf;
|
|
LPCITEMIDLIST pidlChild;
|
|
HRESULT hr = SHBindToFolderIDListParent(NULL, pidl, IID_PPV_ARG(IShellFolder, &psf), &pidlChild);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SHInvokeCommandOnPidlArray(hwnd, punk, psf, &pidlChild, 1, uFlags, lpVerb);
|
|
psf->Release();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDAPI SHInvokeCommandOnPidlArray(HWND hwnd, IUnknown* punk, IShellFolder* psf, LPCITEMIDLIST *ppidlItem, UINT cItems, UINT uFlags, LPCSTR lpVerb)
|
|
{
|
|
IContextMenu *pcm;
|
|
HRESULT hr = psf->GetUIObjectOf(hwnd, cItems, ppidlItem, IID_X_PPV_ARG(IContextMenu, 0, &pcm));
|
|
if (SUCCEEDED(hr) && pcm)
|
|
{
|
|
hr = SHInvokeCommandOnContextMenu(hwnd, punk, pcm, uFlags, lpVerb);
|
|
pcm->Release();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDAPI SHInvokeCommandOnDataObject(HWND hwnd, IUnknown* punk, IDataObject* pdtobj, UINT uFlags, LPCSTR pszVerb)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
STGMEDIUM medium;
|
|
LPIDA pida = DataObj_GetHIDA(pdtobj, &medium);
|
|
if (pida)
|
|
{
|
|
IShellFolder *psf;
|
|
LPCITEMIDLIST pidlParent = IDA_GetIDListPtr(pida, (UINT)-1);
|
|
if (SUCCEEDED(SHBindToObject(NULL, IID_X_PPV_ARG(IShellFolder, pidlParent, &psf))))
|
|
{
|
|
LPCITEMIDLIST *ppidl = (LPCITEMIDLIST *)LocalAlloc(LPTR, pida->cidl * sizeof(LPCITEMIDLIST));
|
|
if (ppidl)
|
|
{
|
|
for (UINT i = 0; i < pida->cidl; i++)
|
|
{
|
|
ppidl[i] = IDA_GetIDListPtr(pida, i);
|
|
}
|
|
hr = SHInvokeCommandOnPidlArray(hwnd, punk, psf, ppidl, pida->cidl, uFlags, pszVerb);
|
|
LocalFree(ppidl);
|
|
}
|
|
psf->Release();
|
|
}
|
|
HIDA_ReleaseStgMedium(pida, &medium);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDAPI_(LPCITEMIDLIST) IDA_GetIDListPtr(LPIDA pida, UINT i)
|
|
{
|
|
LPCITEMIDLIST pidl = NULL;
|
|
if (pida && ((i == (UINT)-1) || i < pida->cidl))
|
|
{
|
|
pidl = HIDA_GetPIDLItem(pida, i);
|
|
}
|
|
return pidl;
|
|
}
|
|
|
|
STDAPI_(void) IEPlaySound(LPCTSTR pszSound, BOOL fSysSound)
|
|
{
|
|
TCHAR szKey[256];
|
|
|
|
// check the registry first
|
|
// if there's nothing registered, we blow off the play,
|
|
// but we don't set the MM_DONTLOAD flag so that if they register
|
|
// something we will play it
|
|
wnsprintf(szKey, ARRAYSIZE(szKey), TEXT("AppEvents\\Schemes\\Apps\\%s\\%s\\.current"),
|
|
(fSysSound ? TEXT(".Default") : TEXT("Explorer")), pszSound);
|
|
|
|
TCHAR szFileName[MAX_PATH];
|
|
szFileName[0] = 0;
|
|
DWORD cbSize = sizeof(szFileName);
|
|
|
|
// note the test for an empty string, PlaySound will play the Default Sound if we
|
|
// give it a sound it cannot find...
|
|
|
|
if ((SHGetValue(HKEY_CURRENT_USER, szKey, NULL, NULL, szFileName, &cbSize) == ERROR_SUCCESS)
|
|
&& cbSize && szFileName[0] != 0)
|
|
{
|
|
DWORD dwFlags = SND_FILENAME | SND_NODEFAULT | SND_ASYNC | SND_NOSTOP | SND_ALIAS;
|
|
|
|
// This flag only works on Win95
|
|
if (IsOS(OS_WIN95GOLD))
|
|
{
|
|
#define SND_LOPRIORITY 0x10000000l
|
|
dwFlags |= SND_LOPRIORITY;
|
|
}
|
|
|
|
// Unlike SHPlaySound in shell32.dll, we get the registry value
|
|
// above and pass it to PlaySound with SND_FILENAME instead of
|
|
// SDN_APPLICATION, so that we play sound even if the application
|
|
// is not Explroer.exe (such as IExplore.exe or WebBrowserOC).
|
|
|
|
PlaySoundWrapW(szFileName, NULL, dwFlags);
|
|
}
|
|
}
|
|
|
|
STDAPI IUnknown_DragEnter(IUnknown* punk, IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
if (punk)
|
|
{
|
|
IDropTarget* pdt;
|
|
hr = punk->QueryInterface(IID_PPV_ARG(IDropTarget, &pdt));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pdt->DragEnter(pdtobj, grfKeyState, pt, pdwEffect);
|
|
pdt->Release();
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
*pdwEffect = DROPEFFECT_NONE;
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDAPI IUnknown_DragOver(IUnknown* punk, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
if (punk)
|
|
{
|
|
IDropTarget* pdt;
|
|
hr = punk->QueryInterface(IID_PPV_ARG(IDropTarget, &pdt));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pdt->DragOver(grfKeyState, pt, pdwEffect);
|
|
pdt->Release();
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
*pdwEffect = DROPEFFECT_NONE;
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDAPI IUnknown_DragLeave(IUnknown* punk)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
if (punk)
|
|
{
|
|
IDropTarget* pdt;
|
|
hr = punk->QueryInterface(IID_PPV_ARG(IDropTarget, &pdt));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pdt->DragLeave();
|
|
pdt->Release();
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDAPI IUnknown_Drop(IUnknown* punk, IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
if (punk)
|
|
{
|
|
IDropTarget* pdt;
|
|
hr = punk->QueryInterface(IID_PPV_ARG(IDropTarget, &pdt));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pdt->Drop(pdtobj, grfKeyState, pt, pdwEffect);
|
|
pdt->Release();
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
*pdwEffect = DROPEFFECT_NONE;
|
|
|
|
return hr;
|
|
}
|
|
|
|
__int64 MakeFileVersion(WORD wMajor, WORD wMinor, WORD wBuild, WORD wQfe)
|
|
{
|
|
return ((__int64)(wMajor) << 48) | ((__int64)(wMinor) << 32) |
|
|
((__int64)(wBuild) << 16) | ((__int64)(wQfe));
|
|
}
|
|
|
|
HRESULT GetVersionFromString64(LPCWSTR psz, __int64 *pVer)
|
|
|
|
{
|
|
HRESULT hr = S_OK;
|
|
int idx = 0;
|
|
WORD nums[4] = { 0, 0, 0, 0 };
|
|
|
|
while (*psz && SUCCEEDED(hr))
|
|
{
|
|
if (L',' == *psz)
|
|
{
|
|
idx++;
|
|
if (idx >= ARRAYSIZE(nums))
|
|
{
|
|
hr = E_INVALIDARG;
|
|
break;
|
|
}
|
|
}
|
|
else if ((*psz >= L'0') && (*psz <= L'9'))
|
|
{
|
|
nums[idx] = (nums[idx] * 10) + (*psz - L'0');
|
|
}
|
|
else
|
|
{
|
|
hr = E_INVALIDARG;
|
|
break;
|
|
}
|
|
psz++;
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
*pVer = MakeFileVersion(nums[0], nums[1], nums[2], nums[3]);
|
|
}
|
|
else
|
|
{
|
|
*pVer = 0i64;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|