866 lines
23 KiB
C++
866 lines
23 KiB
C++
#include "shellprv.h"
|
|
#pragma hdrstop
|
|
#include "idlcomm.h"
|
|
#include "datautil.h"
|
|
|
|
#ifdef DEBUG
|
|
// Dugging aids for making sure we dont use free pidls
|
|
#define VALIDATE_PIDL(pidl) ASSERT(IS_VALID_PIDL(pidl))
|
|
#else
|
|
#define VALIDATE_PIDL(pidl)
|
|
#endif
|
|
|
|
|
|
STDAPI_(BOOL) SHIsValidPidl(LPCITEMIDLIST pidl)
|
|
{
|
|
__try
|
|
{
|
|
LPCITEMIDLIST pidlIterate = pidl;
|
|
|
|
// I use my own while loop instead of ILGetSize to avoid extra debug spew,
|
|
// including asserts, that would result from the VALIDATE_PIDL call. We are
|
|
// testing for validity so an invalid pidl is an OK condition.
|
|
while (pidlIterate->mkid.cb)
|
|
{
|
|
pidlIterate = _ILNext(pidlIterate);
|
|
}
|
|
|
|
return IsValidPIDL(pidl);
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
STDAPI_(LPITEMIDLIST) ILGetNext(LPCITEMIDLIST pidl)
|
|
{
|
|
LPITEMIDLIST pidlRet = NULL;
|
|
if (pidl && pidl->mkid.cb)
|
|
{
|
|
VALIDATE_PIDL(pidl);
|
|
pidlRet = _ILNext(pidl);
|
|
}
|
|
|
|
return pidlRet;
|
|
}
|
|
|
|
STDAPI_(UINT) ILGetSizeAndDepth(LPCITEMIDLIST pidl, DWORD *pdwDepth)
|
|
{
|
|
DWORD dwDepth = 0;
|
|
UINT cbTotal = 0;
|
|
if (pidl)
|
|
{
|
|
VALIDATE_PIDL(pidl);
|
|
cbTotal += sizeof(pidl->mkid.cb); // Null terminator
|
|
while (pidl->mkid.cb)
|
|
{
|
|
cbTotal += pidl->mkid.cb;
|
|
pidl = _ILNext(pidl);
|
|
dwDepth++;
|
|
}
|
|
}
|
|
|
|
if (pdwDepth)
|
|
*pdwDepth = dwDepth;
|
|
|
|
return cbTotal;
|
|
}
|
|
|
|
STDAPI_(UINT) ILGetSize(LPCITEMIDLIST pidl)
|
|
{
|
|
return ILGetSizeAndDepth(pidl, NULL);
|
|
}
|
|
|
|
#define CBIDL_MIN 256
|
|
#define CBIDL_INCL 256
|
|
|
|
STDAPI_(LPITEMIDLIST) ILCreate()
|
|
{
|
|
return _ILCreate(CBIDL_MIN);
|
|
}
|
|
|
|
// cbExtra is the amount to add to cbRequired if the block needs to grow,
|
|
// or it is 0 if we want to resize to the exact size
|
|
|
|
STDAPI_(LPITEMIDLIST) ILResize(LPITEMIDLIST pidl, UINT cbRequired, UINT cbExtra)
|
|
{
|
|
if (pidl == NULL)
|
|
{
|
|
pidl = _ILCreate(cbRequired + cbExtra);
|
|
}
|
|
else if (!cbExtra || SHGetSize(pidl) < cbRequired)
|
|
{
|
|
pidl = (LPITEMIDLIST)SHRealloc(pidl, cbRequired + cbExtra);
|
|
}
|
|
return pidl;
|
|
}
|
|
|
|
STDAPI_(LPITEMIDLIST) ILAppendID(LPITEMIDLIST pidl, LPCSHITEMID pmkid, BOOL fAppend)
|
|
{
|
|
// Create the ID list, if it is not given.
|
|
if (!pidl)
|
|
{
|
|
pidl = ILCreate();
|
|
if (!pidl)
|
|
return NULL; // memory overflow
|
|
}
|
|
|
|
UINT cbUsed = ILGetSize(pidl);
|
|
UINT cbRequired = cbUsed + pmkid->cb;
|
|
|
|
pidl = ILResize(pidl, cbRequired, CBIDL_INCL);
|
|
if (!pidl)
|
|
return NULL; // memory overflow
|
|
|
|
if (fAppend)
|
|
{
|
|
// Append it.
|
|
MoveMemory(_ILSkip(pidl, cbUsed - sizeof(pidl->mkid.cb)), pmkid, pmkid->cb);
|
|
}
|
|
else
|
|
{
|
|
// Put it at the top
|
|
MoveMemory(_ILSkip(pidl, pmkid->cb), pidl, cbUsed);
|
|
MoveMemory(pidl, pmkid, pmkid->cb);
|
|
|
|
ASSERT((ILGetSize(_ILNext(pidl))==cbUsed) ||
|
|
(pmkid->cb == 0)); // if we're prepending the empty pidl, nothing changed
|
|
}
|
|
|
|
// We must put zero-terminator because of LMEM_ZEROINIT.
|
|
_ILSkip(pidl, cbRequired - sizeof(pidl->mkid.cb))->mkid.cb = 0;
|
|
ASSERT(ILGetSize(pidl) == cbRequired);
|
|
|
|
return pidl;
|
|
}
|
|
|
|
|
|
STDAPI_(LPITEMIDLIST) ILFindLastID(LPCITEMIDLIST pidl)
|
|
{
|
|
LPCITEMIDLIST pidlLast = pidl;
|
|
LPCITEMIDLIST pidlNext = pidl;
|
|
|
|
if (pidl == NULL)
|
|
return NULL;
|
|
|
|
VALIDATE_PIDL(pidl);
|
|
|
|
// Find the last one
|
|
while (pidlNext->mkid.cb)
|
|
{
|
|
pidlLast = pidlNext;
|
|
pidlNext = _ILNext(pidlLast);
|
|
}
|
|
|
|
return (LPITEMIDLIST)pidlLast;
|
|
}
|
|
|
|
|
|
STDAPI_(BOOL) ILRemoveLastID(LPITEMIDLIST pidl)
|
|
{
|
|
BOOL fRemoved = FALSE;
|
|
|
|
if (pidl == NULL)
|
|
return FALSE;
|
|
|
|
if (pidl->mkid.cb)
|
|
{
|
|
LPITEMIDLIST pidlLast = (LPITEMIDLIST)ILFindLastID(pidl);
|
|
|
|
ASSERT(pidlLast->mkid.cb);
|
|
ASSERT(_ILNext(pidlLast)->mkid.cb==0);
|
|
|
|
// Remove the last one
|
|
pidlLast->mkid.cb = 0; // null-terminator
|
|
fRemoved = TRUE;
|
|
}
|
|
|
|
return fRemoved;
|
|
}
|
|
|
|
STDAPI_(LPITEMIDLIST) ILClone(LPCITEMIDLIST pidl)
|
|
{
|
|
if (pidl)
|
|
{
|
|
UINT cb = ILGetSize(pidl);
|
|
LPITEMIDLIST pidlRet = (LPITEMIDLIST)SHAlloc(cb);
|
|
if (pidlRet)
|
|
memcpy(pidlRet, pidl, cb);
|
|
|
|
return pidlRet;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
STDAPI_(LPITEMIDLIST) ILCloneCB(LPCITEMIDLIST pidl, UINT cbPidl)
|
|
{
|
|
UINT cb = cbPidl + sizeof(pidl->mkid.cb);
|
|
LPITEMIDLIST pidlRet = (LPITEMIDLIST)SHAlloc(cb);
|
|
if (pidlRet)
|
|
{
|
|
memcpy(pidlRet, pidl, cbPidl);
|
|
// cbPidl can be odd, must use UNALIGNED
|
|
*((UNALIGNED WORD *)((BYTE *)pidlRet + cbPidl)) = 0; // NULL terminate
|
|
}
|
|
return pidlRet;
|
|
}
|
|
|
|
STDAPI_(LPITEMIDLIST) ILCloneUpTo(LPCITEMIDLIST pidl, LPCITEMIDLIST pidlUpTo)
|
|
{
|
|
return ILCloneCB(pidl, (UINT)((BYTE *)pidlUpTo - (BYTE *)pidl));
|
|
}
|
|
|
|
STDAPI_(LPITEMIDLIST) ILCloneFirst(LPCITEMIDLIST pidl)
|
|
{
|
|
return ILCloneCB(pidl, pidl->mkid.cb);
|
|
}
|
|
|
|
STDAPI_(BOOL) ILIsEqualEx(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2, BOOL fMatchDepth, LPARAM lParam)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
VALIDATE_PIDL(pidl1);
|
|
VALIDATE_PIDL(pidl2);
|
|
|
|
if (pidl1 == pidl2)
|
|
fRet = TRUE;
|
|
else
|
|
{
|
|
DWORD dw1;
|
|
UINT cb1 = ILGetSizeAndDepth(pidl1, &dw1);
|
|
DWORD dw2;
|
|
UINT cb2 = ILGetSizeAndDepth(pidl2, &dw2);
|
|
if (!fMatchDepth || dw1 == dw2)
|
|
{
|
|
if (cb1 == cb2 && memcmp(pidl1, pidl2, cb1) == 0)
|
|
fRet = TRUE;
|
|
else
|
|
{
|
|
IShellFolder *psfDesktop;
|
|
if (SUCCEEDED(SHGetDesktopFolder(&psfDesktop)))
|
|
{
|
|
if (psfDesktop->CompareIDs(lParam, pidl1, pidl2) == 0)
|
|
fRet = TRUE;
|
|
psfDesktop->Release();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return fRet;
|
|
}
|
|
|
|
// the only case where this wouldnt be effective is if we were using
|
|
// an old Simple pidl of a UNC and trying to compare with the actual
|
|
// pidl. because the depth wasnt maintained correctly before.
|
|
// ILIsParent() has always had this problem.
|
|
STDAPI_(BOOL) ILIsEqual(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
|
|
{
|
|
return ILIsEqualEx(pidl1, pidl2, TRUE, SHCIDS_CANONICALONLY);
|
|
}
|
|
|
|
// test if
|
|
// pidlParent is a parent of pidlBelow
|
|
// fImmediate requires that pidlBelow be a direct child of pidlParent.
|
|
// Otherwise, self and grandchildren are okay too.
|
|
//
|
|
// example:
|
|
// pidlParent: [my comp] [c:\] [windows]
|
|
// pidlBelow: [my comp] [c:\] [windows] [system32] [vmm.vxd]
|
|
// fImmediate == FALSE result: TRUE
|
|
// fImmediate == TRUE result: FALSE
|
|
|
|
STDAPI_(BOOL) ILIsParent(LPCITEMIDLIST pidlParent, LPCITEMIDLIST pidlBelow, BOOL fImmediate)
|
|
{
|
|
LPCITEMIDLIST pidlParentT;
|
|
LPCITEMIDLIST pidlBelowT;
|
|
|
|
VALIDATE_PIDL(pidlParent);
|
|
VALIDATE_PIDL(pidlBelow);
|
|
|
|
if (!pidlParent || !pidlBelow)
|
|
return FALSE;
|
|
|
|
/* This code will not work correctly when comparing simple NET id lists
|
|
/ against, real net ID lists. Simple ID lists DO NOT contain network provider
|
|
/ information therefore cannot pass the initial check of is pidlBelow longer than pidlParent.
|
|
/ daviddv (2/19/1996) */
|
|
|
|
for (pidlParentT = pidlParent, pidlBelowT = pidlBelow; !ILIsEmpty(pidlParentT);
|
|
pidlParentT = _ILNext(pidlParentT), pidlBelowT = _ILNext(pidlBelowT))
|
|
{
|
|
// if pidlBelow is shorter than pidlParent, pidlParent can't be its parent.
|
|
if (ILIsEmpty(pidlBelowT))
|
|
return FALSE;
|
|
}
|
|
|
|
if (fImmediate)
|
|
{
|
|
// If fImmediate is TRUE, pidlBelowT should contain exactly one ID.
|
|
if (ILIsEmpty(pidlBelowT) || !ILIsEmpty(_ILNext(pidlBelowT)))
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Create a new IDList from a portion of pidlBelow, which contains the
|
|
// same number of IDs as pidlParent.
|
|
//
|
|
BOOL fRet = FALSE;
|
|
UINT cb = (UINT)((UINT_PTR)pidlBelowT - (UINT_PTR)pidlBelow);
|
|
LPITEMIDLIST pidlBelowPrefix = _ILCreate(cb + sizeof(pidlBelow->mkid.cb));
|
|
if (pidlBelowPrefix)
|
|
{
|
|
IShellFolder *psfDesktop;
|
|
if (SUCCEEDED(SHGetDesktopFolder(&psfDesktop)))
|
|
{
|
|
CopyMemory(pidlBelowPrefix, pidlBelow, cb);
|
|
|
|
ASSERT(ILGetSize(pidlBelowPrefix) == cb + sizeof(pidlBelow->mkid.cb));
|
|
|
|
fRet = psfDesktop->CompareIDs(SHCIDS_CANONICALONLY, pidlParent, pidlBelowPrefix) == ResultFromShort(0);
|
|
psfDesktop->Release();
|
|
}
|
|
ILFree(pidlBelowPrefix);
|
|
}
|
|
return fRet;
|
|
}
|
|
|
|
// this returns a pointer to the child id ie:
|
|
// given
|
|
// pidlParent = [my comp] [c] [windows] [desktop]
|
|
// pidlChild = [my comp] [c] [windows] [desktop] [dir] [bar.txt]
|
|
// return pointer to:
|
|
// [dir] [bar.txt]
|
|
// NULL is returned if pidlParent is not a parent of pidlChild
|
|
STDAPI_(LPITEMIDLIST) ILFindChild(LPCITEMIDLIST pidlParent, LPCITEMIDLIST pidlChild)
|
|
{
|
|
if (ILIsParent(pidlParent, pidlChild, FALSE))
|
|
{
|
|
while (!ILIsEmpty(pidlParent))
|
|
{
|
|
pidlChild = _ILNext(pidlChild);
|
|
pidlParent = _ILNext(pidlParent);
|
|
}
|
|
return (LPITEMIDLIST)pidlChild;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
STDAPI_(LPITEMIDLIST) ILCombine(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
|
|
{
|
|
// Let me pass in NULL pointers
|
|
if (!pidl1)
|
|
{
|
|
if (!pidl2)
|
|
{
|
|
return NULL;
|
|
}
|
|
return ILClone(pidl2);
|
|
}
|
|
else if (!pidl2)
|
|
{
|
|
return ILClone(pidl1);
|
|
}
|
|
|
|
UINT cb1 = ILGetSize(pidl1) - sizeof(pidl1->mkid.cb);
|
|
UINT cb2 = ILGetSize(pidl2);
|
|
|
|
VALIDATE_PIDL(pidl1);
|
|
VALIDATE_PIDL(pidl2);
|
|
LPITEMIDLIST pidlNew = _ILCreate(cb1 + cb2);
|
|
if (pidlNew)
|
|
{
|
|
CopyMemory(pidlNew, pidl1, cb1);
|
|
CopyMemory((LPTSTR)(((LPBYTE)pidlNew) + cb1), pidl2, cb2);
|
|
ASSERT(ILGetSize(pidlNew) == cb1+cb2);
|
|
}
|
|
|
|
return pidlNew;
|
|
}
|
|
|
|
STDAPI_(void) ILFree(LPITEMIDLIST pidl)
|
|
{
|
|
if (pidl)
|
|
{
|
|
ASSERT(IS_VALID_PIDL(pidl));
|
|
SHFree(pidl);
|
|
}
|
|
}
|
|
|
|
// back on Win9x this did global global data, no longer
|
|
STDAPI_(LPITEMIDLIST) ILGlobalClone(LPCITEMIDLIST pidl)
|
|
{
|
|
return ILClone(pidl);
|
|
}
|
|
|
|
STDAPI_(void) ILGlobalFree(LPITEMIDLIST pidl)
|
|
{
|
|
ILFree(pidl);
|
|
}
|
|
|
|
SHSTDAPI SHParseDisplayName(PCWSTR pszName, IBindCtx *pbc, LPITEMIDLIST *ppidl, SFGAOF sfgaoIn, SFGAOF *psfgaoOut)
|
|
{
|
|
*ppidl = 0;
|
|
if (psfgaoOut)
|
|
*psfgaoOut = 0;
|
|
|
|
// since ISF::PDN() takes a non-const pointer
|
|
PWSTR pszParse = StrDupW(pszName);
|
|
HRESULT hr = pszParse ? S_OK : E_OUTOFMEMORY;
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CComPtr<IShellFolder> spsfDesktop;
|
|
hr = SHGetDesktopFolder(&spsfDesktop);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CComPtr<IBindCtx> spbcLocal;
|
|
// if they pass their own pbc, then they are responsible for
|
|
// adding in the translate param, else we default to using it
|
|
if (!pbc)
|
|
{
|
|
hr = BindCtx_RegisterObjectParam(NULL, STR_PARSE_TRANSLATE_ALIASES, NULL, &spbcLocal);
|
|
pbc = spbcLocal;
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ULONG cchEaten;
|
|
SFGAOF sfgaoInOut = sfgaoIn;
|
|
hr = spsfDesktop->ParseDisplayName(BindCtx_GetUIWindow(pbc), pbc, pszParse, &cchEaten, ppidl, psfgaoOut ? &sfgaoInOut : NULL);
|
|
|
|
if (SUCCEEDED(hr) && psfgaoOut)
|
|
{
|
|
*psfgaoOut = (sfgaoInOut & sfgaoIn); // only return attributes passed in
|
|
}
|
|
}
|
|
}
|
|
LocalFree(pszParse);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT _CFPBindCtx(IUnknown *punkToSkip, ILCFP_FLAGS dwFlags, IBindCtx **ppbc)
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
if (punkToSkip || (dwFlags & ILCFP_FLAG_SKIPJUNCTIONS))
|
|
hr = SHCreateSkipBindCtx(punkToSkip, ppbc);
|
|
else if (dwFlags & ILCFP_FLAG_NO_MAP_ALIAS)
|
|
{
|
|
// we need to create a bindctx to block alias mapping.
|
|
// this will keep SHParseDisplayName() from adding the STR_PARSE_TRANSLATE_ALIASES
|
|
hr = CreateBindCtx(0, ppbc);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDAPI ILCreateFromPathEx(LPCTSTR pszPath, IUnknown *punkToSkip, ILCFP_FLAGS dwFlags, LPITEMIDLIST *ppidl, DWORD *rgfInOut)
|
|
{
|
|
CComPtr<IBindCtx> spbc;
|
|
HRESULT hr = _CFPBindCtx(punkToSkip, dwFlags, &spbc);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SHParseDisplayName(pszPath, spbc, ppidl, rgfInOut ? *rgfInOut : 0, rgfInOut);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDAPI ILCreateFromCLSID(REFCLSID clsid, LPITEMIDLIST *ppidl)
|
|
{
|
|
TCHAR szCLSID[GUIDSTR_MAX + 3];
|
|
szCLSID[0] = TEXT(':');
|
|
szCLSID[1] = TEXT(':');
|
|
SHStringFromGUID(clsid, szCLSID + 2, ARRAYSIZE(szCLSID) - 2);
|
|
|
|
return SHILCreateFromPath(szCLSID, ppidl, NULL);
|
|
}
|
|
|
|
STDAPI SHILCreateFromPath(LPCTSTR pszPath, LPITEMIDLIST *ppidl, DWORD *rgfInOut)
|
|
{
|
|
return ILCreateFromPathEx(pszPath, NULL, ILCFP_FLAG_NO_MAP_ALIAS, ppidl, rgfInOut);
|
|
}
|
|
|
|
STDAPI_(LPITEMIDLIST) ILCreateFromPath(LPCTSTR pszPath)
|
|
{
|
|
LPITEMIDLIST pidl = NULL;
|
|
HRESULT hr = SHILCreateFromPath(pszPath, &pidl, NULL);
|
|
|
|
ASSERT(SUCCEEDED(hr) ? pidl != NULL : pidl == NULL);
|
|
|
|
return pidl;
|
|
}
|
|
|
|
|
|
LPITEMIDLIST ILCreateFromPathA(IN LPCSTR pszPath)
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
|
|
SHAnsiToUnicode(pszPath, szPath, SIZECHARS(szPath));
|
|
return ILCreateFromPath(szPath);
|
|
}
|
|
|
|
STDAPI_(BOOL) ILGetDisplayNameExA(IShellFolder *psf, LPCITEMIDLIST pidl, LPSTR pszName, DWORD cchSize, int fType)
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
if (ILGetDisplayNameEx(psf, pidl, szPath, fType))
|
|
{
|
|
SHTCharToAnsi(szPath, pszName, cchSize);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
STDAPI_(BOOL) ILGetDisplayNameEx(IShellFolder *psf, LPCITEMIDLIST pidl, LPTSTR pszName, int fType)
|
|
{
|
|
TraceMsg(TF_WARNING, "WARNING: ILGetDisplayNameEx() has been deprecated, should use SHGetNameAndFlags() instead!!!");
|
|
|
|
RIPMSG(pszName && IS_VALID_WRITE_BUFFER(pszName, TCHAR, MAX_PATH), "ILGetDisplayNameEx: caller passed bad pszName");
|
|
|
|
if (!pszName)
|
|
return FALSE;
|
|
|
|
DEBUGWhackPathBuffer(pszName, MAX_PATH);
|
|
*pszName = 0;
|
|
|
|
if (!pidl)
|
|
return FALSE;
|
|
|
|
HRESULT hr;
|
|
if (psf)
|
|
{
|
|
hr = S_OK;
|
|
psf->AddRef();
|
|
}
|
|
else
|
|
{
|
|
hr = SHGetDesktopFolder(&psf);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
DWORD dwGDNFlags;
|
|
|
|
switch (fType)
|
|
{
|
|
case ILGDN_FULLNAME:
|
|
dwGDNFlags = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR;
|
|
hr = DisplayNameOf(psf, pidl, dwGDNFlags, pszName, MAX_PATH);
|
|
break;
|
|
|
|
case ILGDN_INFOLDER:
|
|
case ILGDN_ITEMONLY:
|
|
dwGDNFlags = fType == ILGDN_INFOLDER ? SHGDN_INFOLDER : SHGDN_NORMAL;
|
|
|
|
if (!ILIsEmpty(pidl))
|
|
{
|
|
hr = SHGetNameAndFlags(pidl, dwGDNFlags, pszName, MAX_PATH, NULL);
|
|
}
|
|
else
|
|
{
|
|
hr = DisplayNameOf(psf, pidl, dwGDNFlags, pszName, MAX_PATH);
|
|
}
|
|
break;
|
|
}
|
|
psf->Release();
|
|
}
|
|
|
|
return SUCCEEDED(hr) ? TRUE : FALSE;
|
|
}
|
|
|
|
STDAPI_(BOOL) ILGetDisplayName(LPCITEMIDLIST pidl, LPTSTR pszPath)
|
|
{
|
|
return ILGetDisplayNameEx(NULL, pidl, pszPath, ILGDN_FULLNAME);
|
|
}
|
|
|
|
//*** ILGetPseudoName -- encode pidl relative to base
|
|
// Not used any more
|
|
//
|
|
STDAPI_(BOOL) ILGetPseudoNameW(LPCITEMIDLIST pidl, LPCITEMIDLIST pidlSpec, WCHAR *pszBuf, int fType)
|
|
{
|
|
*pszBuf = TEXT('\0');
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
STDAPI ILLoadFromStream(IStream *pstm, LPITEMIDLIST * ppidl)
|
|
{
|
|
ASSERT(ppidl);
|
|
|
|
// Delete the old one if any.
|
|
if (*ppidl)
|
|
{
|
|
ILFree(*ppidl);
|
|
*ppidl = NULL;
|
|
}
|
|
|
|
// Read the size of the IDLIST
|
|
ULONG cb = 0; // WARNING: We need to fill its HIWORD!
|
|
HRESULT hr = pstm->Read(&cb, sizeof(USHORT), NULL); // Yes, USHORT
|
|
if (SUCCEEDED(hr) && cb)
|
|
{
|
|
// Create a IDLIST
|
|
LPITEMIDLIST pidl = _ILCreate(cb);
|
|
if (pidl)
|
|
{
|
|
// Read its contents
|
|
hr = pstm->Read(pidl, cb, NULL);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Some pidls may be invalid. We know they are invalid
|
|
// if their size claims to be larger than the memory we
|
|
// allocated.
|
|
if (SHIsValidPidl(pidl) && (cb >= ILGetSize(pidl)))
|
|
{
|
|
*ppidl = pidl;
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
ILFree(pidl);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDAPI ILSaveToStream(IStream *pstm, LPCITEMIDLIST pidl)
|
|
{
|
|
ULONG cb = ILGetSize(pidl);
|
|
ASSERT(HIWORD(cb) == 0);
|
|
HRESULT hr = pstm->Write(&cb, sizeof(USHORT), NULL); // Yes, USHORT
|
|
if (SUCCEEDED(hr) && cb)
|
|
{
|
|
hr = pstm->Write(pidl, cb, NULL);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// This one reallocated pidl if necessary. NULL is valid to pass in as pidl.
|
|
//
|
|
STDAPI_(LPITEMIDLIST) HIDA_FillIDList(HIDA hida, UINT i, LPITEMIDLIST pidl)
|
|
{
|
|
UINT cbRequired = HIDA_GetIDList(hida, i, NULL, 0);
|
|
pidl = ILResize(pidl, cbRequired, 32); // extra 32-byte if we realloc
|
|
if (pidl)
|
|
{
|
|
HIDA_GetIDList(hida, i, pidl, cbRequired);
|
|
}
|
|
|
|
return pidl;
|
|
}
|
|
|
|
|
|
STDAPI_(LPITEMIDLIST) IDA_FullIDList(LPIDA pida, UINT i)
|
|
{
|
|
LPITEMIDLIST pidl = NULL;
|
|
LPCITEMIDLIST pidlParent = IDA_GetIDListPtr(pida, (UINT)-1);
|
|
if (pidlParent)
|
|
{
|
|
LPCITEMIDLIST pidlRel = IDA_GetIDListPtr(pida, i);
|
|
if (pidlRel)
|
|
{
|
|
pidl = ILCombine(pidlParent, pidlRel);
|
|
}
|
|
}
|
|
return pidl;
|
|
}
|
|
|
|
LPITEMIDLIST HIDA_ILClone(HIDA hida, UINT i)
|
|
{
|
|
LPIDA pida = (LPIDA)GlobalLock(hida);
|
|
if (pida)
|
|
{
|
|
LPITEMIDLIST pidl = IDA_ILClone(pida, i);
|
|
GlobalUnlock(hida);
|
|
return pidl;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// This is a helper function to be called from within IShellFolder::CompareIDs.
|
|
// When the first IDs of pidl1 and pidl2 are the (logically) same.
|
|
//
|
|
// Required:
|
|
// psf && pidl1 && pidl2 && !ILEmpty(pidl1) && !ILEmpty(pidl2)
|
|
//
|
|
HRESULT ILCompareRelIDs(IShellFolder *psfParent, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2, LPARAM lParam)
|
|
{
|
|
HRESULT hr;
|
|
LPCITEMIDLIST pidlRel1 = _ILNext(pidl1);
|
|
LPCITEMIDLIST pidlRel2 = _ILNext(pidl2);
|
|
if (ILIsEmpty(pidlRel1))
|
|
{
|
|
if (ILIsEmpty(pidlRel2))
|
|
hr = ResultFromShort(0);
|
|
else
|
|
hr = ResultFromShort(-1);
|
|
}
|
|
else
|
|
{
|
|
if (ILIsEmpty(pidlRel2))
|
|
{
|
|
hr = ResultFromShort(1);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// pidlRel1 and pidlRel2 point to something
|
|
// (1) Bind to the next level of the IShellFolder
|
|
// (2) Call its CompareIDs to let it compare the rest of IDs.
|
|
//
|
|
LPITEMIDLIST pidlNext = ILCloneFirst(pidl1); // pidl2 would work as well
|
|
if (pidlNext)
|
|
{
|
|
IShellFolder *psfNext;
|
|
hr = psfParent->BindToObject(pidlNext, NULL, IID_PPV_ARG(IShellFolder, &psfNext));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IShellFolder2 *psf2;
|
|
if (SUCCEEDED(psfNext->QueryInterface(IID_PPV_ARG(IShellFolder2, &psf2))))
|
|
{
|
|
// we can use the lParam
|
|
psf2->Release();
|
|
}
|
|
else // cant use the lParam
|
|
lParam = 0;
|
|
|
|
// columns arent valid to pass down
|
|
// we just care about the flags param
|
|
hr = psfNext->CompareIDs((lParam & ~SHCIDS_COLUMNMASK), pidlRel1, pidlRel2);
|
|
psfNext->Release();
|
|
}
|
|
ILFree(pidlNext);
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
// in:
|
|
// pszLeft
|
|
// pidl
|
|
//
|
|
// in/out:
|
|
// psr
|
|
|
|
STDAPI StrRetCatLeft(LPCTSTR pszLeft, STRRET *psr, LPCITEMIDLIST pidl)
|
|
{
|
|
HRESULT hr;
|
|
TCHAR szRight[MAX_PATH];
|
|
UINT cchRight, cchLeft = ualstrlen(pszLeft);
|
|
|
|
switch (psr->uType)
|
|
{
|
|
case STRRET_CSTR:
|
|
cchRight = lstrlenA(psr->cStr);
|
|
break;
|
|
case STRRET_OFFSET:
|
|
cchRight = lstrlenA(STRRET_OFFPTR(pidl, psr));
|
|
break;
|
|
case STRRET_WSTR:
|
|
cchRight = lstrlenW(psr->pOleStr);
|
|
break;
|
|
}
|
|
|
|
if (cchLeft + cchRight < MAX_PATH)
|
|
{
|
|
hr = StrRetToBuf(psr, pidl, szRight, ARRAYSIZE(szRight)); // will free psr for us
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
psr->pOleStr = (LPOLESTR)SHAlloc((lstrlen(pszLeft) + 1 + cchRight) * sizeof(TCHAR));
|
|
if (psr->pOleStr == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
psr->uType = STRRET_WSTR;
|
|
lstrcpy(psr->pOleStr, pszLeft);
|
|
lstrcat(psr->pOleStr, szRight);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_NOTIMPL;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDAPI_(void) StrRetFormat(STRRET *psr, LPCITEMIDLIST pidlRel, LPCTSTR pszTemplate, LPCTSTR pszAppend)
|
|
{
|
|
TCHAR szT[MAX_PATH];
|
|
|
|
StrRetToBuf(psr, pidlRel, szT, ARRAYSIZE(szT));
|
|
LPTSTR pszRet = ShellConstructMessageString(HINST_THISDLL, pszTemplate, pszAppend, szT);
|
|
if (pszRet)
|
|
{
|
|
StringToStrRet(pszRet, psr);
|
|
LocalFree(pszRet);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Notes: This one passes SHGDN_FORPARSING to ISF::GetDisplayNameOf.
|
|
//
|
|
HRESULT ILGetRelDisplayName(IShellFolder *psf, STRRET *psr,
|
|
LPCITEMIDLIST pidlRel, LPCTSTR pszName, LPCTSTR pszTemplate, DWORD dwFlags)
|
|
{
|
|
HRESULT hr;
|
|
LPITEMIDLIST pidlLeft = ILCloneFirst(pidlRel);
|
|
if (pidlLeft)
|
|
{
|
|
IShellFolder *psfNext;
|
|
hr = psf->BindToObject(pidlLeft, NULL, IID_PPV_ARG(IShellFolder, &psfNext));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPCITEMIDLIST pidlRight = _ILNext(pidlRel);
|
|
hr = psfNext->GetDisplayNameOf(pidlRight, dwFlags, psr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (pszTemplate)
|
|
{
|
|
StrRetFormat(psr, pidlRight, pszTemplate, pszName);
|
|
}
|
|
else
|
|
{
|
|
hr = StrRetCatLeft(pszName, psr, pidlRight);
|
|
}
|
|
}
|
|
psfNext->Release();
|
|
}
|
|
|
|
ILFree(pidlLeft);
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
#undef ILCreateFromPath
|
|
STDAPI_(LPITEMIDLIST) ILCreateFromPath(LPCTSTR pszPath)
|
|
{
|
|
return ILCreateFromPathW(pszPath);
|
|
}
|