Microsoft/WindowsXP-SP1
Microsoft
/
WindowsXP-SP1
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
WindowsXP-SP1/shell/shell32/shapi.cpp

2544 lines
80 KiB
C++
Raw Permalink Blame History

#include "shellprv.h"
#include "util.h"
#include "ids.h"
#include "ole2dup.h"
#include "datautil.h"
#include "filetbl.h"
#include "copy.h"
#include "prop.h"
#include <pif.h>
#include "fstreex.h" // GetIconOverlayManager()
#include <runtask.h>
extern void PathStripTrailingDots(LPTSTR szPath);
HRESULT IExtractIcon_Extract(IExtractIcon *pei, LPCTSTR pszFile, UINT nIconIndex, HICON *phiconLarge, HICON *phiconSmall, UINT nIconSize)
{
// wrapper to let us ask an IExtractIcon for only one icon (the large one)
// since many implementations will fault if you pass NULL phiconSmall
HICON hiconDummy;
if (phiconSmall == NULL)
{
phiconSmall = &hiconDummy;
nIconSize = MAKELONG(nIconSize, nIconSize);
}
HRESULT hr = pei->Extract(pszFile, nIconIndex, phiconLarge, phiconSmall, nIconSize);
if (hr == S_OK && phiconSmall == &hiconDummy)
{
DestroyIcon(hiconDummy);
}
return hr;
}
HRESULT IExtractIconA_Extract(IExtractIconA *peia, LPCSTR pszFile, UINT nIconIndex, HICON *phiconLarge, HICON *phiconSmall, UINT nIconSize)
{
// wrapper to let us ask an IExtractIcon for only one icon (the large one)
// since many dudes don't check for NULL phiconSmall
HICON hiconDummy;
if (phiconSmall == NULL)
{
phiconSmall = &hiconDummy;
nIconSize = MAKELONG(nIconSize, nIconSize);
}
HRESULT hr = peia->Extract(pszFile, nIconIndex, phiconLarge, phiconSmall, nIconSize);
if (hr == S_OK && phiconSmall == &hiconDummy)
{
DestroyIcon(hiconDummy);
}
return hr;
}
// try to figure out if this is an icon already
// in our system image list, so that we dont re-add
BOOL _HijackOfficeIcons(HICON hLarge, int iIndex)
{
BOOL fRet = FALSE;
HIMAGELIST himl;
ASSERT(hLarge);
if (Shell_GetImageLists(NULL, &himl))
{
HICON hMaybe = ImageList_GetIcon(himl, iIndex, 0);
if (hMaybe)
{
fRet = SHAreIconsEqual(hLarge, hMaybe);
DestroyIcon(hMaybe);
}
}
#ifdef DEBUG
if (!fRet)
TraceMsg(TF_WARNING, "_HijackOfficeIcons() called in suspicious circumstance");
#endif
return fRet;
}
HRESULT _GetILIndexGivenPXIcon(IExtractIcon *pxicon, UINT uFlags, LPCITEMIDLIST pidl, int *piImage, BOOL fAnsiCrossOver)
{
TCHAR szIconFile[MAX_PATH];
CHAR szIconFileA[MAX_PATH];
IExtractIconA *pxiconA = (IExtractIconA *)pxicon;
int iIndex;
int iImage = -1;
UINT wFlags=0;
HRESULT hr;
if (fAnsiCrossOver)
{
szIconFileA[0] = 0;
hr = pxiconA->GetIconLocation(uFlags | GIL_FORSHELL,
szIconFileA, ARRAYSIZE(szIconFileA), &iIndex, &wFlags);
SHAnsiToUnicode(szIconFileA, szIconFile, ARRAYSIZE(szIconFile));
}
else
{
szIconFile[0] = '\0';
hr = pxicon->GetIconLocation(uFlags | GIL_FORSHELL,
szIconFile, ARRAYSIZE(szIconFile), &iIndex, &wFlags);
}
//
// "*" as the file name means iIndex is already a system
// icon index, we are done.
//
// this is a hack for our own internal icon handler
//
if (SUCCEEDED(hr) && (wFlags & GIL_NOTFILENAME) &&
szIconFile[0] == TEXT('*') && szIconFile[1] == 0)
{
*piImage = iIndex;
return hr;
}
// Do not replace this with SUCCEEDED(hr). hr = S_FALSE means we need to use a default icon.
if (hr == S_OK)
{
// If we have it in shell32, don't delay the extraction
if (!(wFlags & GIL_NOTFILENAME) && lstrcmpi(PathFindFileName(szIconFile), c_szShell32Dll) == 0)
{
iImage = Shell_GetCachedImageIndex(szIconFile, iIndex, wFlags);
}
else
{
//
// if GIL_DONTCACHE was returned by the icon handler, dont
// lookup the previous icon, assume a cache miss.
//
if (!(wFlags & GIL_DONTCACHE) && *szIconFile)
{
iImage = LookupIconIndex(szIconFile, iIndex, wFlags);
}
}
}
// if we miss our cache...
if (iImage == -1 && hr != S_FALSE)
{
if (uFlags & GIL_ASYNC)
{
// If we couldn't get the final icon, try to get a good temporary one
if (fAnsiCrossOver)
{
szIconFileA[0] = 0;
hr = pxiconA->GetIconLocation(uFlags | GIL_FORSHELL | GIL_DEFAULTICON,
szIconFileA, ARRAYSIZE(szIconFileA), &iIndex, &wFlags);
SHAnsiToUnicode(szIconFileA, szIconFile, ARRAYSIZE(szIconFile));
}
else
{
hr = pxicon->GetIconLocation(uFlags | GIL_FORSHELL | GIL_DEFAULTICON,
szIconFile, ARRAYSIZE(szIconFile), &iIndex, &wFlags);
}
if (hr == S_OK)
{
iImage = LookupIconIndex(szIconFile, iIndex, wFlags);
}
// When all else fails...
if (iImage == -1)
{
iImage = Shell_GetCachedImageIndex(c_szShell32Dll, II_DOCNOASSOC, 0);
}
// force a lookup incase we are not in explorer.exe
*piImage = iImage;
return E_PENDING;
}
// try getting it from the ExtractIcon member fuction
HICON rghicon[ARRAYSIZE(g_rgshil)] = {0};
BOOL fHandlerOk = FALSE;
for (int i = 0; i < ARRAYSIZE(g_rgshil); i += 2)
{
// Ask for two at a time because
//
// (a) it's slightly more efficient, and
//
// (b) otherwise we break compatibility with IExtractIcon::Extract
// implementions which ignore the size parameter (the Network
// Connections folder is one). The SHIL_'s are conveniently
// arranged in large/small alternating order for this purpose.
//
HICON *phiconSmall = NULL;
HICON *phiconLarge = &rghicon[i];
UINT nIconSize = g_rgshil[i].size.cx;
if (i + 1 < ARRAYSIZE(g_rgshil))
{
phiconSmall = &rghicon[i+1];
nIconSize = MAKELONG(nIconSize, g_rgshil[i+1].size.cx);
}
if (fAnsiCrossOver)
{
hr = IExtractIconA_Extract(pxiconA, szIconFileA, iIndex,
phiconLarge, phiconSmall, nIconSize);
}
else
{
hr = IExtractIcon_Extract(pxicon, szIconFile, iIndex,
phiconLarge, phiconSmall, nIconSize);
}
// S_FALSE means, can you please do it...Thanks
if (hr == S_FALSE && !(wFlags & GIL_NOTFILENAME))
{
hr = SHDefExtractIcon(szIconFile, iIndex, wFlags,
phiconLarge, phiconSmall, nIconSize);
}
if (SUCCEEDED(hr))
{
fHandlerOk = TRUE;
}
}
// our belief knows no bounds
if (!*szIconFile && rghicon[1] && iIndex > 0 && _HijackOfficeIcons(rghicon[1], iIndex))
{
// it lives!
iImage = iIndex;
}
else
{
// if we extracted a icon add it to the cache.
iImage = SHAddIconsToCache(rghicon, szIconFile, iIndex, wFlags);
}
_DestroyIcons(rghicon, ARRAYSIZE(rghicon));
// if we failed in any way pick a default icon
if (iImage == -1)
{
if (wFlags & GIL_SIMULATEDOC)
{
iImage = II_DOCUMENT;
}
else if ((wFlags & GIL_PERINSTANCE) && PathIsExe(szIconFile))
{
iImage = II_APPLICATION;
}
else
{
iImage = II_DOCNOASSOC;
}
// force a lookup incase we are not in explorer.exe
iImage = Shell_GetCachedImageIndex(c_szShell32Dll, iImage, 0);
// if the handler failed dont cache this default icon.
// so we will try again later and maybe get the right icon.
// handlers should only fail if they cant access the file
// or something equally bad.
//
// if the handler succeeded then go ahead and assume this is
// a usable icon, we must be in some low memory situation, or
// something. So keep mapping to the same shell icon.
//
if (fHandlerOk)
{
if (iImage != -1 && *szIconFile && !(wFlags & (GIL_DONTCACHE | GIL_NOTFILENAME)))
{
AddToIconTable(szIconFile, iIndex, wFlags, iImage);
}
}
else
{
TraceMsg(TF_DEFVIEW, "not caching icon for '%s' because cant access file", szIconFile);
}
}
}
if (iImage < 0)
{
iImage = Shell_GetCachedImageIndex(c_szShell32Dll, II_DOCNOASSOC, 0);
}
*piImage = iImage;
return hr;
}
// given an IShellFolder and and an Idlist that is
// contained in it, get back the index into the system image list.
STDAPI SHGetIconFromPIDL(IShellFolder *psf, IShellIcon *psi, LPCITEMIDLIST pidl, UINT flags, int *piImage)
{
HRESULT hr;
if (psi)
{
#ifdef DEBUG
*piImage = -1;
#endif
hr = psi->GetIconOf(pidl, flags, piImage);
if (hr == S_OK)
{
ASSERT(*piImage != -1);
return hr;
}
if (hr == E_PENDING)
{
ASSERT(flags & GIL_ASYNC);
ASSERT(*piImage != -1);
return hr;
}
}
*piImage = Shell_GetCachedImageIndex(c_szShell32Dll, II_DOCNOASSOC, 0);
// Be careful. Some shellfolders erroneously return S_OK when they fail
IExtractIcon *pxi = NULL;
hr = psf->GetUIObjectOf(NULL, pidl ? 1 : 0, pidl ? &pidl : NULL, IID_PPV_ARG_NULL(IExtractIcon, &pxi));
if (SUCCEEDED(hr) && pxi)
{
hr = _GetILIndexGivenPXIcon(pxi, flags, pidl, piImage, FALSE);
pxi->Release();
}
else
{
// Try the ANSI interface, see if we are dealing with an old set of code
IExtractIconA *pxiA = NULL;
hr = psf->GetUIObjectOf(NULL, pidl ? 1 : 0, pidl ? &pidl : NULL, IID_PPV_ARG_NULL(IExtractIconA, &pxiA));
if (SUCCEEDED(hr))
{
if (pxiA)
{
hr = _GetILIndexGivenPXIcon((IExtractIcon *)pxiA, flags, pidl, piImage, TRUE);
pxiA->Release();
}
else
{
// IShellFolder lied to us - returned S_OK even though it failed
hr = E_FAIL;
}
}
}
return hr;
}
// given an IShellFolder and and an Idlist that is
// contained in it, get back the index into the system image list.
STDAPI_(int) SHMapPIDLToSystemImageListIndex(IShellFolder *psf, LPCITEMIDLIST pidl, int *piIndexSel)
{
int iIndex;
if (piIndexSel)
{
SHGetIconFromPIDL(psf, NULL, pidl, GIL_OPENICON, piIndexSel);
}
SHGetIconFromPIDL(psf, NULL, pidl, 0, &iIndex);
return iIndex;
}
class CGetIconTask : public CRunnableTask
{
public:
STDMETHODIMP RunInitRT(void);
CGetIconTask(HRESULT *phr, IShellFolder *psf, IShellIcon *psi, LPCITEMIDLIST pidl, UINT flags, BOOL fGetOpenIcon,
PFNASYNCICONTASKBALLBACK pfn, void *pvData, void *pvHint);
protected:
~CGetIconTask();
IShellFolder *_psf;
IShellIcon *_psi;
LPITEMIDLIST _pidl;
UINT _flags;
BOOL _fGetOpenIcon;
PFNASYNCICONTASKBALLBACK _pfn;
void *_pvData;
void *_pvHint;
};
CGetIconTask::CGetIconTask(HRESULT *phr, IShellFolder *psf, IShellIcon *psi, LPCITEMIDLIST pidl, UINT flags, BOOL fGetOpenIcon,
PFNASYNCICONTASKBALLBACK pfn, void *pvData, void *pvHint) :
CRunnableTask(RTF_DEFAULT), _psf(psf), _psi(psi), _flags(flags), _fGetOpenIcon(fGetOpenIcon), _pfn(pfn), _pvData(pvData), _pvHint(pvHint)
{
*phr = SHILClone(pidl, &_pidl);
_psf->AddRef();
if (_psi)
_psi->AddRef();
}
CGetIconTask::~CGetIconTask()
{
ILFree(_pidl);
_psf->Release();
if (_psi)
_psi->Release();
}
STDMETHODIMP CGetIconTask::RunInitRT()
{
int iIcon = -1;
int iOpenIcon = -1;
ASSERT(_pidl);
if (_fGetOpenIcon)
{
SHGetIconFromPIDL(_psf, _psi, _pidl, _flags | GIL_OPENICON, &iOpenIcon);
}
// get the icon for this item.
SHGetIconFromPIDL(_psf, _psi, _pidl, _flags, &iIcon);
_pfn(_pidl, _pvData, _pvHint, iIcon, iOpenIcon);
return S_OK;
}
HRESULT CGetIconTask_CreateInstance(IShellFolder *psf, IShellIcon *psi, LPCITEMIDLIST pidl, UINT flags, BOOL fGetOpenIcon,
PFNASYNCICONTASKBALLBACK pfn, void *pvData, void *pvHint, IRunnableTask **ppTask)
{
*ppTask = NULL;
HRESULT hr;
CGetIconTask * pNewTask = new CGetIconTask(&hr, psf, psi, pidl, flags, fGetOpenIcon, pfn, pvData, pvHint);
if (pNewTask)
{
if (SUCCEEDED(hr))
*ppTask = SAFECAST(pNewTask, IRunnableTask *);
else
pNewTask->Release();
}
else
hr = E_OUTOFMEMORY;
return hr;
}
// given an IShellFolder and and an Idlist that is
// contained in it, get back a -possibly temporary - index into the system image list,
// and get the final icon from the callback if necessary
STDAPI SHMapIDListToImageListIndexAsync(IShellTaskScheduler* pts, IShellFolder *psf, LPCITEMIDLIST pidl, UINT flags,
PFNASYNCICONTASKBALLBACK pfn, void *pvData, void *pvHint, int *piIndex, int *piIndexSel)
{
HRESULT hr = S_OK;
IShellIcon *psi = NULL;
psf->QueryInterface(IID_PPV_ARG(IShellIcon, &psi));
// We are doing all the ASYNC handling, not the caller.
flags &= ~GIL_ASYNC;
// Try asynchronous first
if (pfn)
{
hr = SHGetIconFromPIDL(psf, psi, pidl, flags | GIL_ASYNC, piIndex);
if (piIndexSel)
{
HRESULT hr2 = SHGetIconFromPIDL(psf, psi, pidl, flags | GIL_OPENICON | GIL_ASYNC, piIndexSel);
if (SUCCEEDED(hr))
{
// Don't lose the result if the first GetIcon succeeds, but the second one is E_PENDING
hr = hr2;
}
}
if (hr == E_PENDING)
{
if (pts)
{
IRunnableTask *pTask;
hr = CGetIconTask_CreateInstance(psf, psi, pidl, flags, (piIndexSel != NULL), pfn, pvData, pvHint, &pTask);
if (SUCCEEDED(hr))
{
hr = pts->AddTask(pTask, TOID_DVIconExtract, 0, ITSAT_DEFAULT_PRIORITY);
if (SUCCEEDED(hr))
{
hr = E_PENDING;
}
pTask->Release();
}
}
else
{
hr = E_POINTER;
}
}
else if (hr == S_OK)
{
goto cleanup;
}
}
// If asynchronous get failed, try synchronous
if (hr != E_PENDING)
{
if (piIndexSel)
{
SHGetIconFromPIDL(psf, psi, pidl, flags | GIL_OPENICON, piIndexSel);
}
hr = SHGetIconFromPIDL(psf, psi, pidl, flags, piIndex);
}
cleanup:
if (psi)
{
psi->Release();
}
return hr;
}
// returns the icon handle to be used to represent the specified
// file. The caller should destroy the icon eventually.
STDAPI_(HICON) SHGetFileIcon(HINSTANCE hinst, LPCTSTR pszPath, DWORD dwFileAttributes, UINT uFlags)
{
SHFILEINFO sfi;
SHGetFileInfo(pszPath, dwFileAttributes, &sfi, sizeof(sfi), uFlags | SHGFI_ICON);
return sfi.hIcon;
}
// Return 1 on success and 0 on failure.
DWORD_PTR _GetFileInfoSections(LPITEMIDLIST pidl, SHFILEINFO *psfi, UINT uFlags)
{
DWORD_PTR dwResult = 1;
IShellFolder *psf;
LPCITEMIDLIST pidlLast;
HRESULT hr = SHBindToIDListParent(pidl, IID_PPV_ARG(IShellFolder, &psf), &pidlLast);
if (SUCCEEDED(hr))
{
// get attributes for file
if (uFlags & SHGFI_ATTRIBUTES)
{
// [New in IE 4.0] If SHGFI_ATTR_SPECIFIED is set, we use psfi->dwAttributes as is
if (!(uFlags & SHGFI_ATTR_SPECIFIED))
psfi->dwAttributes = 0xFFFFFFFF; // get all of them
if (FAILED(psf->GetAttributesOf(1, &pidlLast, &psfi->dwAttributes)))
psfi->dwAttributes = 0;
}
//
// get icon location, place the icon path into szDisplayName
//
if (uFlags & SHGFI_ICONLOCATION)
{
IExtractIcon *pxi;
if (SUCCEEDED(psf->GetUIObjectOf(NULL, 1, &pidlLast, IID_PPV_ARG_NULL(IExtractIcon, &pxi))))
{
UINT wFlags;
pxi->GetIconLocation(0, psfi->szDisplayName, ARRAYSIZE(psfi->szDisplayName),
&psfi->iIcon, &wFlags);
pxi->Release();
// the returned location is not a filename we cant return it.
// just give then nothing.
if (wFlags & GIL_NOTFILENAME)
{
// special case one of our shell32.dll icons......
if (psfi->szDisplayName[0] != TEXT('*'))
psfi->iIcon = 0;
psfi->szDisplayName[0] = 0;
}
}
}
HIMAGELIST himlLarge, himlSmall;
// get the icon for the file.
if ((uFlags & SHGFI_SYSICONINDEX) || (uFlags & SHGFI_ICON))
{
Shell_GetImageLists(&himlLarge, &himlSmall);
if (uFlags & SHGFI_SYSICONINDEX)
dwResult = (DWORD_PTR)((uFlags & SHGFI_SMALLICON) ? himlSmall : himlLarge);
if (uFlags & SHGFI_OPENICON)
SHMapPIDLToSystemImageListIndex(psf, pidlLast, &psfi->iIcon);
else
psfi->iIcon = SHMapPIDLToSystemImageListIndex(psf, pidlLast, NULL);
}
if (uFlags & SHGFI_ICON)
{
HIMAGELIST himl;
UINT flags = 0;
int cx, cy;
if (uFlags & SHGFI_SMALLICON)
{
himl = himlSmall;
cx = GetSystemMetrics(SM_CXSMICON);
cy = GetSystemMetrics(SM_CYSMICON);
}
else
{
himl = himlLarge;
cx = GetSystemMetrics(SM_CXICON);
cy = GetSystemMetrics(SM_CYICON);
}
if (!(uFlags & SHGFI_ATTRIBUTES))
{
psfi->dwAttributes = SFGAO_LINK; // get link only
psf->GetAttributesOf(1, &pidlLast, &psfi->dwAttributes);
}
//
// check for a overlay image thing (link overlay)
//
if ((psfi->dwAttributes & SFGAO_LINK) || (uFlags & SHGFI_LINKOVERLAY))
{
IShellIconOverlayManager *psiom;
HRESULT hrT = GetIconOverlayManager(&psiom);
if (SUCCEEDED(hrT))
{
int iOverlayIndex = 0;
hrT = psiom->GetReservedOverlayInfo(NULL, -1, &iOverlayIndex, SIOM_OVERLAYINDEX, SIOM_RESERVED_LINK);
if (SUCCEEDED(hrT))
flags |= INDEXTOOVERLAYMASK(iOverlayIndex);
}
}
if ((uFlags & SHGFI_ADDOVERLAYS) || (uFlags & SHGFI_OVERLAYINDEX))
{
IShellIconOverlay * pio;
if (SUCCEEDED(psf->QueryInterface(IID_PPV_ARG(IShellIconOverlay, &pio))))
{
int iOverlayIndex = 0;
if (SUCCEEDED(pio->GetOverlayIndex(pidlLast, &iOverlayIndex)))
{
if (uFlags & SHGFI_ADDOVERLAYS)
{
flags |= INDEXTOOVERLAYMASK(iOverlayIndex);
}
if (uFlags & SHGFI_OVERLAYINDEX)
{
// use the upper 16 bits for the overlayindex
psfi->iIcon |= iOverlayIndex << 24;
}
}
pio->Release();
}
}
// check for selected state
if (uFlags & SHGFI_SELECTED)
flags |= ILD_BLEND50;
psfi->hIcon = ImageList_GetIcon(himl, psfi->iIcon, flags);
// if the caller does not want a "shell size" icon
// convert the icon to the "system" icon size.
if (psfi->hIcon && !(uFlags & SHGFI_SHELLICONSIZE))
psfi->hIcon = (HICON)CopyImage(psfi->hIcon, IMAGE_ICON, cx, cy, LR_COPYRETURNORG | LR_COPYDELETEORG);
}
// get display name for the path
if (uFlags & SHGFI_DISPLAYNAME)
{
DisplayNameOf(psf, pidlLast, SHGDN_NORMAL, psfi->szDisplayName, ARRAYSIZE(psfi->szDisplayName));
}
if (uFlags & SHGFI_TYPENAME)
{
IShellFolder2 *psf2;
if (SUCCEEDED(psf->QueryInterface(IID_PPV_ARG(IShellFolder2, &psf2))))
{
VARIANT var;
VariantInit(&var);
if (SUCCEEDED(psf2->GetDetailsEx(pidlLast, &SCID_TYPE, &var)))
{
VariantToStr(&var, psfi->szTypeName, ARRAYSIZE(psfi->szTypeName));
VariantClear(&var);
}
psf2->Release();
}
}
psf->Release();
}
else
dwResult = 0;
return dwResult;
}
//
// This function returns shell info about a given pathname.
// a app can get the following:
//
// Icon (large or small)
// Display Name
// Name of File Type
//
// this function replaces SHGetFileIcon
#define BUGGY_SHELL16_CBFILEINFO (sizeof(SHFILEINFO) - 4)
STDAPI_(DWORD_PTR) SHGetFileInfo(LPCTSTR pszPath, DWORD dwFileAttributes, SHFILEINFO *psfi, UINT cbFileInfo, UINT uFlags)
{
LPITEMIDLIST pidlFull;
DWORD_PTR res = 1;
TCHAR szPath[MAX_PATH];
// this was never enforced in the past
// TODDB: The 16 to 32 bit thunking layer passes in the wrong value for cbFileInfo.
// The size passed in looks to be the size of the 16 bit version of the structure
// rather than the size of the 32 bit version, as such it is 4 bytes shorter.
// TJGREEN: Special-case that size to keep the assertion from firing and party on.
//
ASSERT(!psfi || cbFileInfo == sizeof(*psfi) || cbFileInfo == BUGGY_SHELL16_CBFILEINFO);
// You can't use both SHGFI_ATTR_SPECIFIED and SHGFI_ICON.
ASSERT(uFlags & SHGFI_ATTR_SPECIFIED ? !(uFlags & SHGFI_ICON) : TRUE);
if (pszPath == NULL)
return 0;
if (uFlags == SHGFI_EXETYPE)
return GetExeType(pszPath); // funky way to get EXE type
if (psfi == NULL)
return 0;
psfi->hIcon = 0;
// Zip Pro 6.0 relies on the fact that if you don't ask for the icon,
// the iIcon field doesn't change.
//
// psfi->iIcon = 0;
psfi->szDisplayName[0] = 0;
psfi->szTypeName[0] = 0;
// do some simmple check on the input path.
if (!(uFlags & SHGFI_PIDL))
{
// If the caller wants us to give them the file attributes, we can't trust
// the attributes they gave us in the following two situations.
if (uFlags & SHGFI_ATTRIBUTES)
{
if ((dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
(dwFileAttributes & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)))
{
DebugMsg(TF_FSTREE, TEXT("SHGetFileInfo cant use caller supplied file attribs for a sys/ro directory (possible junction)"));
uFlags &= ~SHGFI_USEFILEATTRIBUTES;
}
else if (PathIsRoot(pszPath))
{
DebugMsg(TF_FSTREE, TEXT("SHGetFileInfo cant use caller supplied file attribs for a roots"));
uFlags &= ~SHGFI_USEFILEATTRIBUTES;
}
}
if (PathIsRelative(pszPath))
{
if (uFlags & SHGFI_USEFILEATTRIBUTES)
{
// get a shorter path than the current directory to support
// long pszPath names (that might get truncated in the
// long current dir case)
GetWindowsDirectory(szPath, ARRAYSIZE(szPath));
}
else
{
GetCurrentDirectory(ARRAYSIZE(szPath), szPath);
}
PathCombine(szPath, szPath, pszPath);
pszPath = szPath;
}
}
if (uFlags & SHGFI_PIDL)
pidlFull = (LPITEMIDLIST)pszPath;
else if (uFlags & SHGFI_USEFILEATTRIBUTES)
{
WIN32_FIND_DATA fd = {0};
fd.dwFileAttributes = dwFileAttributes;
SHSimpleIDListFromFindData(pszPath, &fd, &pidlFull);
}
else
pidlFull = ILCreateFromPath(pszPath);
if (pidlFull)
{
if (uFlags & (
SHGFI_DISPLAYNAME |
SHGFI_ATTRIBUTES |
SHGFI_SYSICONINDEX |
SHGFI_ICONLOCATION |
SHGFI_ICON |
SHGFI_TYPENAME))
{
res = _GetFileInfoSections(pidlFull, psfi, uFlags);
}
if (!(uFlags & SHGFI_PIDL))
ILFree(pidlFull);
}
else
res = 0;
return res;
}
//===========================================================================
//
// SHGetFileInfoA Stub
//
// This function calls SHGetFileInfoW and then converts the returned
// information back to ANSI.
//
//===========================================================================
STDAPI_(DWORD_PTR) SHGetFileInfoA(LPCSTR pszPath, DWORD dwFileAttributes, SHFILEINFOA *psfi, UINT cbFileInfo, UINT uFlags)
{
WCHAR szPathW[MAX_PATH];
LPWSTR pszPathW;
DWORD_PTR dwRet;
if (uFlags & SHGFI_PIDL)
{
pszPathW = (LPWSTR)pszPath; // Its a pidl, fake it as a WSTR
}
else
{
SHAnsiToUnicode(pszPath, szPathW, ARRAYSIZE(szPathW));
pszPathW = szPathW;
}
if (psfi)
{
SHFILEINFOW sfiw;
ASSERT(cbFileInfo == sizeof(*psfi));
// Zip Pro 6.0 sets SHGFI_SMALLICON | SHGFI_OPENICON but forgets to
// pass SHGFI_ICON or SHGFI_SYSICONINDEX, even though they really
// wanted the sys icon index.
//
// In Windows 95, fields of the SHFILEINFOA structure that you didn't
// query for were left unchanged. They happened to have the icon for
// a closed folder lying around there from a previous query, so they
// got away with it by mistake. They got the wrong icon, but it was
// close enough that nobody really complained.
//
// So pre-initialize the sfiw's iIcon with the app's iIcon. That
// way, if it turns out the app didn't ask for the icon, he just
// gets his old value back.
//
sfiw.iIcon = psfi->iIcon;
sfiw.dwAttributes = psfi->dwAttributes;
dwRet = SHGetFileInfoW(pszPathW, dwFileAttributes, &sfiw, sizeof(sfiw), uFlags);
psfi->hIcon = sfiw.hIcon;
psfi->iIcon = sfiw.iIcon;
psfi->dwAttributes = sfiw.dwAttributes;
SHUnicodeToAnsi(sfiw.szDisplayName, psfi->szDisplayName, ARRAYSIZE(psfi->szDisplayName));
SHUnicodeToAnsi(sfiw.szTypeName, psfi->szTypeName, ARRAYSIZE(psfi->szTypeName));
}
else
{
dwRet = SHGetFileInfoW(pszPathW, dwFileAttributes, NULL, 0, uFlags);
}
return dwRet;
}
STDAPI ThunkFindDataWToA(WIN32_FIND_DATAW *pfd, WIN32_FIND_DATAA *pfda, int cb)
{
if (cb < sizeof(WIN32_FIND_DATAA))
return DISP_E_BUFFERTOOSMALL;
memcpy(pfda, pfd, FIELD_OFFSET(WIN32_FIND_DATAA, cFileName));
SHUnicodeToAnsi(pfd->cFileName, pfda->cFileName, ARRAYSIZE(pfda->cFileName));
SHUnicodeToAnsi(pfd->cAlternateFileName, pfda->cAlternateFileName, ARRAYSIZE(pfda->cAlternateFileName));
return S_OK;
}
STDAPI ThunkNetResourceWToA(LPNETRESOURCEW pnrw, LPNETRESOURCEA pnra, UINT cb)
{
HRESULT hr;
if (cb >= sizeof(NETRESOURCEA))
{
LPSTR psza, pszDest[4] = {NULL, NULL, NULL, NULL};
CopyMemory(pnra, pnrw, FIELD_OFFSET(NETRESOURCE, lpLocalName));
psza = (LPSTR)(pnra + 1); // Point just past the structure
if (cb > sizeof(NETRESOURCE))
{
LPWSTR pszSource[4];
UINT i, cchRemaining = cb - sizeof(NETRESOURCE);
pszSource[0] = pnrw->lpLocalName;
pszSource[1] = pnrw->lpRemoteName;
pszSource[2] = pnrw->lpComment;
pszSource[3] = pnrw->lpProvider;
for (i = 0; i < 4; i++)
{
if (pszSource[i])
{
UINT cchItem;
pszDest[i] = psza;
cchItem = SHUnicodeToAnsi(pszSource[i], pszDest[i], cchRemaining);
cchRemaining -= cchItem;
psza += cchItem;
}
}
}
pnra->lpLocalName = pszDest[0];
pnra->lpRemoteName = pszDest[1];
pnra->lpComment = pszDest[2];
pnra->lpProvider = pszDest[3];
hr = S_OK;
}
else
hr = DISP_E_BUFFERTOOSMALL;
return hr;
}
STDAPI NetResourceWVariantToBuffer(const VARIANT* pvar, void* pv, UINT cb)
{
HRESULT hr;
if (cb >= sizeof(NETRESOURCEW))
{
if (pvar && pvar->vt == (VT_ARRAY | VT_UI1))
{
int i;
NETRESOURCEW* pnrw = (NETRESOURCEW*) pvar->parray->pvData;
UINT cbOffsets[4] = { 0, 0, 0, 0 };
UINT cbEnds[4] = { 0, 0, 0, 0 };
LPWSTR pszPtrs[4] = { pnrw->lpLocalName, pnrw->lpRemoteName,
pnrw->lpComment, pnrw->lpProvider };
hr = S_OK;
for (i = 0; i < ARRAYSIZE(pszPtrs); i++)
{
if (pszPtrs[i])
{
cbOffsets[i] = (UINT) ((BYTE*) pszPtrs[i] - (BYTE*) pnrw);
cbEnds[i] = cbOffsets[i] + (sizeof(WCHAR) * (lstrlenW(pszPtrs[i]) + 1));
// If any of the strings start or end too far into the buffer, then fail:
if ((cbOffsets[i] >= cb) || (cbEnds[i] > cb))
{
hr = DISP_E_BUFFERTOOSMALL;
break;
}
}
}
if (SUCCEEDED(hr))
{
hr = VariantToBuffer(pvar, pv, cb) ? S_OK : E_FAIL;
pnrw = (NETRESOURCEW*) pv;
if (SUCCEEDED(hr))
{
// Fixup pointers in structure to point into the output buffer,
// instead of the variant buffer:
LPWSTR* ppszPtrs[4] = { &(pnrw->lpLocalName), &(pnrw->lpRemoteName),
&(pnrw->lpComment), &(pnrw->lpProvider) };
for (i = 0; i < ARRAYSIZE(ppszPtrs); i++)
{
if (*ppszPtrs[i])
{
*ppszPtrs[i] = (LPWSTR) ((BYTE*) pnrw + cbOffsets[i]);
}
}
}
}
}
else
{
hr = E_FAIL;
}
}
else
{
hr = DISP_E_BUFFERTOOSMALL;
}
return hr;
}
// This function will extract information that is cached in the pidl such
// in the information that was returned from a FindFirst file. This function
// is sortof a hack as t allow outside callers to be able to get at the infomation
// without knowing how we store it in the pidl.
// a app can get the following:
STDAPI SHGetDataFromIDListW(IShellFolder *psf, LPCITEMIDLIST pidl, int nFormat, void *pv, int cb)
{
HRESULT hr = E_NOTIMPL;
SHCOLUMNID* pscid;
if (!pv || !psf || !pidl)
return E_INVALIDARG;
switch (nFormat)
{
case SHGDFIL_FINDDATA:
if (cb < sizeof(WIN32_FIND_DATAW))
return DISP_E_BUFFERTOOSMALL;
else
pscid = (SHCOLUMNID*)&SCID_FINDDATA;
break;
case SHGDFIL_NETRESOURCE:
if (cb < sizeof(NETRESOURCEW))
return DISP_E_BUFFERTOOSMALL;
else
pscid = (SHCOLUMNID*)&SCID_NETRESOURCE;
break;
case SHGDFIL_DESCRIPTIONID:
pscid = (SHCOLUMNID*)&SCID_DESCRIPTIONID;
break;
default:
return E_INVALIDARG;
}
IShellFolder2 *psf2;
if (SUCCEEDED(psf->QueryInterface(IID_PPV_ARG(IShellFolder2, &psf2))))
{
VARIANT var;
VariantInit(&var);
hr = psf2->GetDetailsEx(pidl, pscid, &var);
if (SUCCEEDED(hr))
{
if (SHGDFIL_NETRESOURCE == nFormat)
{
hr = NetResourceWVariantToBuffer(&var, pv, cb);
}
else
{
if (!VariantToBuffer(&var, pv, cb))
hr = E_FAIL;
}
VariantClear(&var);
}
else
{
TraceMsg(TF_WARNING, "Trying to retrieve find data from unknown PIDL %s", DumpPidl(pidl));
}
psf2->Release();
}
return hr;
}
STDAPI SHGetDataFromIDListA(IShellFolder *psf, LPCITEMIDLIST pidl, int nFormat, void *pv, int cb)
{
HRESULT hr;
WIN32_FIND_DATAW fdw;
NETRESOURCEW *pnrw = NULL;
void *pvData = pv;
int cbData = cb;
if (nFormat == SHGDFIL_FINDDATA)
{
cbData = sizeof(fdw);
pvData = &fdw;
}
else if (nFormat == SHGDFIL_NETRESOURCE)
{
cbData = cb;
pvData = pnrw = (NETRESOURCEW *)LocalAlloc(LPTR, cbData);
if (pnrw == NULL)
return E_OUTOFMEMORY;
}
hr = SHGetDataFromIDListW(psf, pidl, nFormat, pvData, cbData);
if (SUCCEEDED(hr))
{
if (nFormat == SHGDFIL_FINDDATA)
{
hr = ThunkFindDataWToA(&fdw, (WIN32_FIND_DATAA *)pv, cb);
}
else if (nFormat == SHGDFIL_NETRESOURCE)
{
hr = ThunkNetResourceWToA(pnrw, (NETRESOURCEA *)pv, cb);
}
}
if (pnrw)
LocalFree(pnrw);
return hr;
}
int g_iUseLinkPrefix = -1;
#define INITIALLINKPREFIXCOUNT 20
#define MAXLINKPREFIXCOUNT 30
void LoadUseLinkPrefixCount()
{
TraceMsg(TF_FSTREE, "LoadUseLinkPrefixCount %d", g_iUseLinkPrefix);
if (g_iUseLinkPrefix < 0)
{
DWORD cb = sizeof(g_iUseLinkPrefix);
if (FAILED(SKGetValue(SHELLKEY_HKCU_EXPLORER, NULL, c_szLink, NULL, &g_iUseLinkPrefix, &cb))
|| g_iUseLinkPrefix < 0)
{
g_iUseLinkPrefix = INITIALLINKPREFIXCOUNT;
}
}
}
void SaveUseLinkPrefixCount()
{
if (g_iUseLinkPrefix >= 0)
{
SKSetValue(SHELLKEY_HKCU_EXPLORER, NULL, c_szLink, REG_BINARY, &g_iUseLinkPrefix, sizeof(g_iUseLinkPrefix));
}
}
#define ISDIGIT(c) ((c) >= TEXT('0') && (c) <= TEXT('9'))
// psz2 = destination
// psz1 = source
void StripNumber(LPTSTR psz2, LPCTSTR psz1)
{
// strip out the '(' and the numbers after it
// We need to verify that it is either simply () or (999) but not (A)
for (; *psz1; psz1 = CharNext(psz1), psz2 = CharNext(psz2))
{
if (*psz1 == TEXT('('))
{
LPCTSTR pszT = psz1;
do
{
psz1 = CharNext(psz1);
} while (*psz1 && ISDIGIT(*psz1));
if (*psz1 == TEXT(')'))
{
psz1 = CharNext(psz1);
if (*psz1 == TEXT(' '))
psz1 = CharNext(psz1); // skip the extra space
lstrcpy(psz2, psz1);
return;
}
// We have a (that does not match the format correctly!
psz1 = pszT; // restore pointer back to copy this char through and continue...
}
*psz2 = *psz1;
}
*psz2 = *psz1;
}
#define SHORTCUT_PREFIX_DECR 5
#define SHORTCUT_PREFIX_INCR 1
// this checks to see if you've renamed 'Shortcut #x To Foo' to 'Foo'
void CheckShortcutRename(LPCTSTR pszOldPath, LPCTSTR pszNewPath)
{
ASSERT(pszOldPath);
ASSERT(pszNewPath);
// already at 0.
if (g_iUseLinkPrefix)
{
LPCTSTR pszOldName = PathFindFileName(pszOldPath);
if (PathIsLnk(pszOldName))
{
TCHAR szBaseName[MAX_PATH];
TCHAR szLinkTo[80];
TCHAR szMockName[MAX_PATH];
LPCTSTR pszNewName = PathFindFileName(pszNewPath);
lstrcpy(szBaseName, pszNewName);
PathRemoveExtension(szBaseName);
// mock up a name using the basename and the linkto template
LoadString(HINST_THISDLL, IDS_LINKTO, szLinkTo, ARRAYSIZE(szLinkTo));
wnsprintf(szMockName, ARRAYSIZE(szMockName), szLinkTo, szBaseName);
StripNumber(szMockName, szMockName);
StripNumber(szBaseName, pszOldName);
// are the remaining gunk the same?
if (!lstrcmp(szMockName, szBaseName))
{
// yes! do the link count magic
LoadUseLinkPrefixCount();
ASSERT(g_iUseLinkPrefix >= 0);
g_iUseLinkPrefix -= SHORTCUT_PREFIX_DECR;
if (g_iUseLinkPrefix < 0)
g_iUseLinkPrefix = 0;
SaveUseLinkPrefixCount();
}
}
}
}
STDAPI_(int) SHRenameFileEx(HWND hwnd, IUnknown *punkEnableModless, LPCTSTR pszDir,
LPCTSTR pszOldName, LPCTSTR pszNewName)
{
int iRet = ERROR_CANCELLED; // user saw the error, don't report again
TCHAR szOldPathName[MAX_PATH + 1]; // +1 for double nul terminating on SHFileOperation
TCHAR szTempNewPath[MAX_PATH];
BOOL bEnableUI = hwnd || punkEnableModless;
IUnknown_EnableModless(punkEnableModless, FALSE);
PathCombine(szOldPathName, pszDir, pszOldName);
szOldPathName[lstrlen(szOldPathName) + 1] = 0;
StrCpyN(szTempNewPath, pszNewName, ARRAYSIZE(szTempNewPath));
int err = PathCleanupSpec(pszDir, szTempNewPath);
if (err)
{
if (bEnableUI)
{
ShellMessageBox(HINST_THISDLL, hwnd,
err & PCS_PATHTOOLONG ?
MAKEINTRESOURCE(IDS_REASONS_INVFILES) :
IsLFNDrive(pszDir) ?
MAKEINTRESOURCE(IDS_INVALIDFN) :
MAKEINTRESOURCE(IDS_INVALIDFNFAT),
MAKEINTRESOURCE(IDS_RENAME), MB_OK | MB_ICONHAND);
}
}
else
{
// strip off leading and trailing blanks off of the new file name.
StrCpyN(szTempNewPath, pszNewName, ARRAYSIZE(szTempNewPath));
PathRemoveBlanks(szTempNewPath);
if (!szTempNewPath[0] || (szTempNewPath[0] == TEXT('.')))
{
if (bEnableUI)
{
ShellMessageBox(HINST_THISDLL, hwnd,
MAKEINTRESOURCE(IDS_NONULLNAME),
MAKEINTRESOURCE(IDS_RENAME), MB_OK | MB_ICONHAND);
}
}
else
{
int idPrompt = IDYES;
TCHAR szNewPathName[MAX_PATH + 1]; // +1 for double nul terminating on SHFileOperation
PathCombine(szNewPathName, pszDir, szTempNewPath);
// if there was an old extension and the new and old don't match complain
LPTSTR pszExt = PathFindExtension(pszOldName);
if (*pszExt && lstrcmpi(pszExt, PathFindExtension(szTempNewPath)))
{
HKEY hk;
if (!PathIsDirectory(szOldPathName) &&
SUCCEEDED(AssocQueryKey(0, ASSOCKEY_SHELLEXECCLASS, pszExt, NULL, &hk)))
{
RegCloseKey(hk);
if (bEnableUI)
{
idPrompt = ShellMessageBox(HINST_THISDLL, hwnd,
MAKEINTRESOURCE(IDS_WARNCHANGEEXT),
MAKEINTRESOURCE(IDS_RENAME), MB_YESNO | MB_ICONEXCLAMATION);
}
}
}
if (IDYES == idPrompt)
{
szNewPathName[lstrlen(szNewPathName) + 1] = 0; // double NULL terminate
SHFILEOPSTRUCT fo = { hwnd, FO_RENAME, szOldPathName, szNewPathName, FOF_SILENT | FOF_ALLOWUNDO, };
iRet = SHFileOperation(&fo);
if (ERROR_SUCCESS == iRet)
CheckShortcutRename(szOldPathName, szNewPathName);
}
}
}
IUnknown_EnableModless(punkEnableModless, TRUE);
return iRet;
}
HKEY SHOpenShellFolderKey(const CLSID *pclsid)
{
HKEY hkey;
return SUCCEEDED(SHRegGetCLSIDKey(*pclsid, TEXT("ShellFolder"), FALSE, FALSE, &hkey)) ? hkey : NULL;
}
BOOL SHQueryShellFolderValue(const CLSID *pclsid, LPCTSTR pszValueName)
{
BOOL bRet = FALSE; // assume no
HKEY hkey = SHOpenShellFolderKey(pclsid);
if (hkey)
{
bRet = SHQueryValueEx(hkey, pszValueName, NULL, NULL, NULL, NULL) == ERROR_SUCCESS;
RegCloseKey(hkey);
}
return bRet;
}
//
// The SZ_REGKEY_MYCOMPUTER_NONENUM_POLICY key contains a bunch of values,
// each named after a GUID. The data associated with each value is a
// DWORD, which is either...
//
// 0 = no restriction on this CLSID
// 1 = unconditional restriction on this CLSID
// 0xFFFFFFFF = same as 1 (in case somebody got "creative")
// any other value = pass to SHRestricted() to see what the restriction is
//
// We support 0xFFFFFFFF only out of paranoia. This flag was only 0 or 1
// in Windows 2000, and somebody might've decided that "all bits set"
// is better than "just one bit set".
//
#define SZ_REGKEY_MYCOMPUTER_NONENUM_POLICY TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\NonEnum")
BOOL _IsNonEnumPolicySet(const CLSID *pclsid)
{
BOOL fPolicySet = FALSE;
TCHAR szCLSID[GUIDSTR_MAX];
DWORD dwDefault = 0;
RESTRICTIONS rest = REST_NONE;
DWORD cbSize = sizeof(rest);
if (EVAL(SHStringFromGUID(*pclsid, szCLSID, ARRAYSIZE(szCLSID))) &&
(ERROR_SUCCESS == SHRegGetUSValue(SZ_REGKEY_MYCOMPUTER_NONENUM_POLICY, szCLSID, NULL, &rest, &cbSize, FALSE, &dwDefault, sizeof(dwDefault))) &&
rest)
{
fPolicySet = rest == 1 || rest == 0xFFFFFFFF || SHRestricted(rest);
}
return fPolicySet;
}
//
// This function returns the attributes (to be returned IShellFolder::
// GetAttributesOf) of the junction point specified by the class ID.
//
STDAPI_(DWORD) SHGetAttributesFromCLSID(const CLSID *pclsid, DWORD dwDefault)
{
return SHGetAttributesFromCLSID2(pclsid, dwDefault, (DWORD)-1);
}
DWORD QueryCallForAttributes(HKEY hkey, const CLSID *pclsid, DWORD dwDefAttrs, DWORD dwRequested)
{
DWORD dwAttr = dwDefAttrs;
DWORD dwData, cbSize = sizeof(dwAttr);
// consider caching this folder to avoid creating over and over
// mydocs.dll uses this for compat with old apps
// See if this folder has asked us specifically to call and get
// the attributes...
//
if (SHQueryValueEx(hkey, TEXT("CallForAttributes"), NULL, NULL, &dwData, &cbSize) == ERROR_SUCCESS)
{
// CallForAttributes can be a masked value. See if it's being supplied in the value.
// NOTE: MyDocs.dll registers with a NULL String, so this check works.
DWORD dwMask = (DWORD)-1;
if (sizeof(dwData) == cbSize)
{
// There is a mask, Use this.
dwMask = dwData;
}
// Is the requested bit contained in the specified mask?
if (dwMask & dwRequested)
{
// Yes. Then CoCreate and Query.
IShellFolder *psf;
if (SUCCEEDED(SHExtCoCreateInstance(NULL, pclsid, NULL, IID_PPV_ARG(IShellFolder, &psf))))
{
dwAttr = dwRequested;
psf->GetAttributesOf(0, NULL, &dwAttr);
psf->Release();
}
else
{
dwAttr |= SFGAO_FILESYSTEM;
}
}
}
return dwAttr;
}
// dwRequested is the bits you are explicitly looking for. This is an optimization that prevents reg hits.
STDAPI_(DWORD) SHGetAttributesFromCLSID2(const CLSID *pclsid, DWORD dwDefAttrs, DWORD dwRequested)
{
DWORD dwAttr = dwDefAttrs;
HKEY hkey = SHOpenShellFolderKey(pclsid);
if (hkey)
{
DWORD dwData, cbSize = sizeof(dwAttr);
// We are looking for some attributes on a shell folder. These attributes can be in two locations:
// 1) In the "Attributes" value in the registry.
// 2) Stored in a the shell folder's GetAttributesOf.
// First, Check to see if the reqested value is contained in the registry.
if (SHQueryValueEx(hkey, TEXT("Attributes"), NULL, NULL, (BYTE *)&dwData, &cbSize) == ERROR_SUCCESS &&
cbSize == sizeof(dwData))
{
// We have data there, but it may not contain the data we are looking for
dwAttr = dwData & dwRequested;
// Does it contain the bit we are looking for?
if (((dwAttr & dwRequested) != dwRequested) && dwRequested != 0)
{
// No. Check to see if it is in the shell folder implementation
goto CallForAttributes;
}
}
else
{
CallForAttributes:
// See if we have to talk to the shell folder.
// I'm passing dwAttr, because if the previous case did not generate any attributes, then it's
// equal to dwDefAttrs. If the call to CallForAttributes fails, then it will contain the value of
// dwDefAttrs or whatever was in the shell folder's Attributes key
dwAttr = QueryCallForAttributes(hkey, pclsid, dwAttr, dwRequested);
}
RegCloseKey(hkey);
}
if (_IsNonEnumPolicySet(pclsid))
dwAttr |= SFGAO_NONENUMERATED;
if (SHGetObjectCompatFlags(NULL, pclsid) & OBJCOMPATF_NOTAFILESYSTEM)
dwAttr &= ~SFGAO_FILESYSTEM;
return dwAttr;
}
// _BuildLinkName
//
// Used during the creation of a shortcut, this function determines an appropriate name for the shortcut.
// This is not the exact name that will be used becuase it will usually contain "() " which will either
// get removed or replaced with "(x) " where x is a number that makes the name unique. This removal is done
// elsewhere (currently in PathYetAnotherMakeUniqueName).
//
// in:
// pszName file spec part
// pszDir path part of name to know how to limit the long name...
//
// out:
// pszLinkName - Full path to link name (May fit in 8.3...). Can be the same buffer as pszName.
//
// NOTES: If pszDir + pszLinkName is greater than MAX_PATH we will fail to create the shortcut.
// In an effort to prevent
void _BuildLinkName(LPTSTR pszLinkName, LPCTSTR pszName, LPCTSTR pszDir, BOOL fLinkTo)
{
TCHAR szLinkTo[40]; // "Shortcut to %s.lnk"
TCHAR szTemp[MAX_PATH + 40];
if (fLinkTo)
{
// check to see if we're in the "don't ever say 'shortcut to' mode"
LoadUseLinkPrefixCount();
if (!g_iUseLinkPrefix)
{
fLinkTo = FALSE;
}
else if (g_iUseLinkPrefix > 0)
{
if (g_iUseLinkPrefix < MAXLINKPREFIXCOUNT)
{
g_iUseLinkPrefix += SHORTCUT_PREFIX_INCR;
SaveUseLinkPrefixCount();
}
}
}
if (!fLinkTo)
{
// Generate the title of this link ("XX.lnk")
LoadString(HINST_THISDLL, IDS_LINKEXTENSION, szLinkTo, ARRAYSIZE(szLinkTo));
}
else
{
// Generate the title of this link ("Shortcut to XX.lnk")
LoadString(HINST_THISDLL, IDS_LINKTO, szLinkTo, ARRAYSIZE(szLinkTo));
}
wnsprintf(szTemp, ARRAYSIZE(szTemp), szLinkTo, pszName);
PathCleanupSpecEx(pszDir, szTemp); // get rid of illegal chars AND ensure correct filename length
lstrcpyn(pszLinkName, szTemp, MAX_PATH);
ASSERT(PathIsLnk(pszLinkName));
}
// return a new destination path for a link
//
// in:
// fErrorSoTryDesktop we are called because there was an error saving
// the shortcut and we want to prompt to see if the
// desktop should be used.
//
// in/out:
// pszPath on input the place being tried, on output the desktop folder
//
// returns:
//
// IDYES user said yes to creating a link at new place
// IDNO user said no to creating a link at new place
// -1 error
//
int _PromptTryDesktopLinks(HWND hwnd, LPTSTR pszPath, BOOL fErrorSoTryDesktop)
{
TCHAR szPath[MAX_PATH];
if (!SHGetSpecialFolderPath(hwnd, szPath, CSIDL_DESKTOPDIRECTORY, FALSE))
return -1; // fail no desktop dir
int idOk;
if (fErrorSoTryDesktop)
{
// Fail, if pszPath already points to the desktop directory.
if (lstrcmpi(szPath, pszPath) == 0)
return -1;
idOk = ShellMessageBox(HINST_THISDLL, hwnd,
MAKEINTRESOURCE(IDS_TRYDESKTOPLINK),
MAKEINTRESOURCE(IDS_LINKTITLE),
MB_YESNO | MB_ICONQUESTION);
}
else
{
ShellMessageBox(HINST_THISDLL, hwnd,
MAKEINTRESOURCE(IDS_MAKINGDESKTOPLINK),
MAKEINTRESOURCE(IDS_LINKTITLE),
MB_OK | MB_ICONASTERISK);
idOk = IDYES;
}
if (idOk == IDYES)
lstrcpy(pszPath , szPath); // output
return idOk; // return yes or no
}
// in:
// pszpdlLinkTo LPCITEMIDLIST or LPCTSTR, target of link to create
// pszDir where we will put the link
// uFlags SHGNLI_ flags
//
// out:
// pszName file name to create "c:\Shortcut to Foo.lnk"
// pfMustCopy pszpdlLinkTo was a link itself, make a copy of this
STDAPI_(BOOL) SHGetNewLinkInfo(LPCTSTR pszpdlLinkTo, LPCTSTR pszDir, LPTSTR pszName,
BOOL *pfMustCopy, UINT uFlags)
{
BOOL fDosApp = FALSE;
BOOL fLongFileNames = IsLFNDrive(pszDir);
SHFILEINFO sfi;
*pfMustCopy = FALSE;
sfi.dwAttributes = SFGAO_FILESYSTEM | SFGAO_LINK | SFGAO_FOLDER;
if (uFlags & SHGNLI_PIDL)
{
if (FAILED(SHGetNameAndFlags((LPCITEMIDLIST)pszpdlLinkTo, SHGDN_NORMAL,
pszName, MAX_PATH, &sfi.dwAttributes)))
return FALSE;
}
else
{
if (SHGetFileInfo(pszpdlLinkTo, 0, &sfi, sizeof(sfi),
SHGFI_DISPLAYNAME | SHGFI_ATTRIBUTES | SHGFI_ATTR_SPECIFIED |
((uFlags & SHGNLI_PIDL) ? SHGFI_PIDL : 0)))
lstrcpy(pszName, sfi.szDisplayName);
else
return FALSE;
}
if (PathCleanupSpecEx(pszDir, pszName) & PCS_FATAL)
return FALSE;
//
// WARNING: From this point on, sfi.szDisplayName may be re-used to
// contain the file path of the PIDL we are linking to. Don't rely on
// it containing the display name.
//
if (sfi.dwAttributes & SFGAO_FILESYSTEM)
{
LPTSTR pszPathSrc;
if (uFlags & SHGNLI_PIDL)
{
pszPathSrc = sfi.szDisplayName;
SHGetPathFromIDList((LPCITEMIDLIST)pszpdlLinkTo, pszPathSrc);
}
else
{
pszPathSrc = (LPTSTR)pszpdlLinkTo;
}
fDosApp = (lstrcmpi(PathFindExtension(pszPathSrc), TEXT(".pif")) == 0) ||
(LOWORD(GetExeType(pszPathSrc)) == 0x5A4D); // 'MZ'
if (sfi.dwAttributes & SFGAO_LINK)
{
*pfMustCopy = TRUE;
if (!(sfi.dwAttributes & SFGAO_FOLDER))
{
uFlags &= ~SHGNLI_NOLNK; // if copying the file then don't trim the extension
}
lstrcpy(pszName, PathFindFileName(pszPathSrc));
}
else
{
//
// when making a link to a drive root. special case a few things
//
// if we are not on a LFN drive, dont use the full name, just
// use the drive letter. "C.LNK" not "Label (C).LNK"
//
// if we are making a link to removable media, we dont want the
// label as part of the name, we want the media type.
//
// CD-ROM drives are currently the only removable media we
// show the volume label for, so we only need to special case
// cdrom drives here.
//
if (PathIsRoot(pszPathSrc) && !PathIsUNC(pszPathSrc))
{
if (!fLongFileNames)
lstrcpy(pszName, pszPathSrc);
else if (IsCDRomDrive(DRIVEID(pszPathSrc)))
LoadString(HINST_THISDLL, IDS_DRIVES_CDROM, pszName, MAX_PATH);
}
}
if (fLongFileNames && fDosApp)
{
HANDLE hPif = PifMgr_OpenProperties(pszPathSrc, NULL, 0, OPENPROPS_INHIBITPIF);
if (hPif)
{
PROPPRG PP = {0};
if (PifMgr_GetProperties(hPif, (LPCSTR)MAKELP(0, GROUP_PRG), &PP, sizeof(PP), 0) &&
((PP.flPrgInit & PRGINIT_INFSETTINGS) ||
((PP.flPrgInit & (PRGINIT_NOPIF | PRGINIT_DEFAULTPIF)) == 0)))
{
SHAnsiToTChar(PP.achTitle, pszName, MAX_PATH);
}
PifMgr_CloseProperties(hPif, 0);
}
}
}
if (!*pfMustCopy)
{
// create full dest path name. only use template iff long file names
// can be created and the caller requested it. _BuildLinkName will
// truncate files on non-lfn drives and clean up any invalid chars.
_BuildLinkName(pszName, pszName, pszDir,
(!(*pfMustCopy) && fLongFileNames && (uFlags & SHGNLI_PREFIXNAME)));
}
if (fDosApp)
PathRenameExtension(pszName, TEXT(".pif"));
if (uFlags & SHGNLI_NOLNK)
{
// Don't do PathRemoveExtension because pszName might contain
// internal dots ("Windows 3.1") and passing that to
// PathYetAnotherMakeUniqueName will result in
// "Windows 3 (2).1" which is wrong. We leave the dot at the
// end so we get "Windows 3.1 (2)." back. We will strip off the
// final dot later.
PathRenameExtension(pszName, TEXT("."));
}
// make sure the name is unique
// NOTE: PathYetAnotherMakeUniqueName will return the directory+filename in the pszName buffer.
// It returns FALSE if the name is not unique or the dir+filename is too long. If it returns
// false then this function should return false because creation will fail.
BOOL fSuccess;
if (!(uFlags & SHGNLI_NOUNIQUE))
fSuccess = PathYetAnotherMakeUniqueName(pszName, pszDir, pszName, pszName);
else
fSuccess = TRUE;
// Strip off any trailing dots that may have been generated by SHGNI_NOLNK
PathStripTrailingDots(pszName);
return fSuccess;
}
STDAPI_(BOOL) SHGetNewLinkInfoA(LPCSTR pszpdlLinkTo, LPCSTR pszDir, LPSTR pszName,
BOOL *pfMustCopy, UINT uFlags)
{
ThunkText * pThunkText;
BOOL bResult = FALSE;
if (uFlags & SHGNLI_PIDL)
{
// 1 string (pszpdlLinkTo is a pidl)
pThunkText = ConvertStrings(2, NULL, pszDir);
if (pThunkText)
pThunkText->m_pStr[0] = (LPWSTR)pszpdlLinkTo;
}
else
{
// 2 strings
pThunkText = ConvertStrings(2, pszpdlLinkTo, pszDir);
}
if (pThunkText)
{
WCHAR wszName[MAX_PATH];
bResult = SHGetNewLinkInfoW(pThunkText->m_pStr[0], pThunkText->m_pStr[1],
wszName, pfMustCopy, uFlags);
LocalFree(pThunkText);
if (bResult)
{
if (0 == WideCharToMultiByte(CP_ACP, 0, wszName, -1,
pszName, MAX_PATH, NULL, NULL))
{
SetLastError((DWORD)E_FAIL);
bResult = FALSE;
}
}
}
return bResult;
}
//
// in:
// pidlTo
STDAPI CreateLinkToPidl(LPCITEMIDLIST pidlTo, LPCTSTR pszDir, LPITEMIDLIST *ppidl, UINT uFlags)
{
HRESULT hr = E_FAIL;
TCHAR szPathDest[MAX_PATH];
BOOL fCopyLnk;
BOOL fUseLinkTemplate = (SHCL_USETEMPLATE & uFlags);
UINT uSHGNLI = fUseLinkTemplate ? SHGNLI_PIDL | SHGNLI_PREFIXNAME : SHGNLI_PIDL;
if (uFlags & SHCL_MAKEFOLDERSHORTCUT)
{
// Don't add ".lnk" to the folder shortcut name; that's just stupid
uSHGNLI |= SHGNLI_NOLNK;
}
if (uFlags & SHCL_NOUNIQUE)
{
uSHGNLI |= SHGNLI_NOUNIQUE;
}
if (SHGetNewLinkInfo((LPTSTR)pidlTo, pszDir, szPathDest, &fCopyLnk, uSHGNLI))
{
TCHAR szPathSrc[MAX_PATH];
IShellLink *psl = NULL;
// If we passed SHGNLI_NOUNIQUE then we need to do the PathCombine ourselves
// because SHGetNewLinkInfo won't
if (uFlags & SHCL_NOUNIQUE)
{
PathCombine(szPathDest, pszDir, szPathDest);
}
DWORD dwAttributes = SFGAO_FILESYSTEM | SFGAO_FOLDER;
SHGetNameAndFlags(pidlTo, SHGDN_FORPARSING | SHGDN_FORADDRESSBAR, szPathSrc, ARRAYSIZE(szPathSrc), &dwAttributes);
if (fCopyLnk)
{
// if it is file system and not a folder (CopyFile does not work on folders)
// just copy it.
if (((dwAttributes & (SFGAO_FILESYSTEM | SFGAO_FOLDER)) == SFGAO_FILESYSTEM) &&
CopyFile(szPathSrc, szPathDest, TRUE))
{
TouchFile(szPathDest);
SHChangeNotify(SHCNE_CREATE, SHCNF_PATH, szPathDest, NULL);
SHChangeNotify(SHCNE_FREESPACE, SHCNF_PATH, szPathDest, NULL);
hr = S_OK;
}
else
{
// load the source object that will be "copied" below (with the ::Save call)
hr = SHGetUIObjectFromFullPIDL(pidlTo, NULL, IID_PPV_ARG(IShellLink, &psl));
}
}
else
{
hr = SHCoCreateInstance(NULL, uFlags & SHCL_MAKEFOLDERSHORTCUT ?
&CLSID_FolderShortcut : &CLSID_ShellLink, NULL, IID_PPV_ARG(IShellLink, &psl));
if (SUCCEEDED(hr))
{
hr = psl->SetIDList(pidlTo);
// set the working directory to the same path
// as the file we are linking too
if (szPathSrc[0] && ((dwAttributes & (SFGAO_FILESYSTEM | SFGAO_FOLDER)) == SFGAO_FILESYSTEM))
{
PathRemoveFileSpec(szPathSrc);
psl->SetWorkingDirectory(szPathSrc);
}
}
}
if (psl)
{
if (SUCCEEDED(hr))
{
IPersistFile *ppf;
hr = psl->QueryInterface(IID_PPV_ARG(IPersistFile, &ppf));
if (SUCCEEDED(hr))
{
USES_CONVERSION;
hr = ppf->Save(T2CW(szPathDest), TRUE);
if (SUCCEEDED(hr))
{
// in case ::Save translated the name of the
// file (.LNK -> .PIF, or Folder Shortcut)
WCHAR *pwsz;
if (SUCCEEDED(ppf->GetCurFile(&pwsz)) && pwsz)
{
SHUnicodeToTChar(pwsz, szPathDest, ARRAYSIZE(szPathDest));
SHFree(pwsz);
}
}
ppf->Release();
}
}
psl->Release();
}
}
if (ppidl)
{
*ppidl = SUCCEEDED(hr) ? SHSimpleIDListFromPath(szPathDest) : NULL;
}
return hr;
}
// in/out:
// pszDir inital folder to try, output new folder (desktop)
// out:
// ppidl optional output PIDL of thing created
HRESULT _CreateLinkRetryDesktop(HWND hwnd, LPCITEMIDLIST pidlTo, LPTSTR pszDir, UINT fFlags, LPITEMIDLIST *ppidl)
{
HRESULT hr;
if (ppidl)
*ppidl = NULL; // assume error
if (*pszDir && (fFlags & SHCL_CONFIRM))
{
hr = CreateLinkToPidl(pidlTo, pszDir, ppidl, fFlags);
}
else
{
hr = E_FAIL;
}
// if we were unable to save, ask user if they want us to
// try it again but change the path to the desktop.
if (FAILED(hr))
{
int id;
if (hr == STG_E_MEDIUMFULL)
{
DebugMsg(TF_ERROR, TEXT("failed to create link because disk is full"));
id = IDYES;
}
else
{
if (fFlags & SHCL_CONFIRM)
{
id = _PromptTryDesktopLinks(hwnd, pszDir, (fFlags & SHCL_CONFIRM));
}
else
{
id = (SHGetSpecialFolderPath(hwnd, pszDir, CSIDL_DESKTOPDIRECTORY, FALSE)) ? IDYES : IDNO;
}
if (id == IDYES && *pszDir)
{
hr = CreateLinkToPidl(pidlTo, pszDir, ppidl, fFlags);
}
}
// we failed to create the link complain to the user.
if (FAILED(hr) && id != IDNO)
{
ShellMessageBox(HINST_THISDLL, hwnd,
MAKEINTRESOURCE(IDS_CANNOTCREATELINK),
MAKEINTRESOURCE(IDS_LINKTITLE),
MB_OK | MB_ICONASTERISK);
}
}
#ifdef DEBUG
if (FAILED(hr) && ppidl)
ASSERT(*ppidl == NULL);
#endif
return hr;
}
//
// This function creates links to the stuff in the IDataObject
//
// Arguments:
// hwnd for any UI
// pszDir optional target directory (where to create links)
// pDataObj data object describing files (array of idlist)
// ppidl optional pointer to an array that receives pidls pointing to the new links
// or NULL if not interested
STDAPI SHCreateLinks(HWND hwnd, LPCTSTR pszDir, IDataObject *pDataObj, UINT fFlags, LPITEMIDLIST* ppidl)
{
DECLAREWAITCURSOR;
STGMEDIUM medium;
HRESULT hr;
SetWaitCursor();
LPIDA pida = DataObj_GetHIDA(pDataObj, &medium);
if (pida)
{
TCHAR szTargetDir[MAX_PATH];
hr = S_OK; // In case hida contains zero elements
szTargetDir[0] = 0;
if (pszDir)
lstrcpyn(szTargetDir, pszDir, ARRAYSIZE(szTargetDir));
if (!(fFlags & SHCL_USEDESKTOP))
fFlags |= SHCL_CONFIRM;
for (UINT i = 0; i < pida->cidl; i++)
{
LPITEMIDLIST pidlTo = IDA_ILClone(pida, i);
if (pidlTo)
{
hr = _CreateLinkRetryDesktop(hwnd, pidlTo, szTargetDir, fFlags, ppidl ? &ppidl[i] : NULL);
ILFree(pidlTo);
if (FAILED(hr))
break;
}
}
HIDA_ReleaseStgMedium(pida, &medium);
}
else
hr = E_OUTOFMEMORY;
SHChangeNotifyHandleEvents();
ResetWaitCursor();
return hr;
}
#if 1
HRESULT SelectPidlInSFV(IShellFolderViewDual *psfv, LPCITEMIDLIST pidl, DWORD dwOpts)
{
VARIANT var;
HRESULT hr = InitVariantFromIDList(&var, pidl);
if (SUCCEEDED(hr))
{
hr = psfv->SelectItem(&var, dwOpts);
VariantClear(&var);
}
return hr;
}
HRESULT OpenFolderAndGetView(LPCITEMIDLIST pidlFolder, IShellFolderViewDual **ppsfv)
{
*ppsfv = NULL;
IWebBrowserApp *pauto;
HRESULT hr = SHGetIDispatchForFolder(pidlFolder, &pauto);
if (SUCCEEDED(hr))
{
HWND hwnd;
if (SUCCEEDED(pauto->get_HWND((LONG_PTR*)&hwnd)))
{
// Make sure we make this the active window
SetForegroundWindow(hwnd);
ShowWindow(hwnd, SW_SHOWNORMAL);
}
IDispatch *pdoc;
hr = pauto->get_Document(&pdoc);
if (S_OK == hr) // careful, automation returns S_FALSE
{
hr = pdoc->QueryInterface(IID_PPV_ARG(IShellFolderViewDual, ppsfv));
pdoc->Release();
}
else
hr = E_FAIL;
pauto->Release();
}
return hr;
}
// pidlFolder - fully qualified pidl to the folder to open
// cidl/apidl - array of items in that folder to select
//
// if cild == 0 then pidlFolder is the fully qualified pidl to a single item, it's
// folder is opened and it is selected.
//
// dwFlags - optional flags, pass 0 for now
SHSTDAPI SHOpenFolderAndSelectItems(LPCITEMIDLIST pidlFolder, UINT cidl, LPCITEMIDLIST *apidl, DWORD dwFlags)
{
HRESULT hr;
if (0 == cidl)
{
// overload the 0 item case to mean pidlFolder is the full pidl to the item
LPITEMIDLIST pidlTemp;
hr = SHILClone(pidlFolder, &pidlTemp);
if (SUCCEEDED(hr))
{
ILRemoveLastID(pidlTemp); // strip to the folder
LPCITEMIDLIST pidl = ILFindLastID(pidlFolder);
hr = SHOpenFolderAndSelectItems(pidlTemp, 1, &pidl, 0); // recurse
ILFree(pidlTemp);
}
}
else
{
IShellFolderViewDual *psfv;
hr = OpenFolderAndGetView(pidlFolder, &psfv);
if (SUCCEEDED(hr))
{
DWORD dwSelFlags = SVSI_SELECT | SVSI_FOCUSED | SVSI_DESELECTOTHERS | SVSI_ENSUREVISIBLE;
for (UINT i = 0; i < cidl; i++)
{
hr = SelectPidlInSFV(psfv, apidl[i], dwSelFlags);
dwSelFlags = SVSI_SELECT; // second items append to sel
}
psfv->Release();
}
}
return hr;
}
#else
HRESULT OpenFolderAndGetView(LPCITEMIDLIST pidlFolder, REFIID riid, void **ppv)
{
*ppv = NULL;
IWebBrowserApp *pauto;
HRESULT hr = SHGetIDispatchForFolder(pidlFolder, &pauto);
if (SUCCEEDED(hr))
{
HWND hwnd;
if (SUCCEEDED(pauto->get_HWND((LONG_PTR*)&hwnd)))
{
// Make sure we make this the active window
SetForegroundWindow(hwnd);
ShowWindow(hwnd, SW_SHOWNORMAL);
}
IShellBrowser* psb;
hr = IUnknown_QueryService(pauto, SID_STopLevelBrowser, IID_PPV_ARG(IShellBrowser, &psb));
if (SUCCEEDED(hr))
{
IShellView* psv;
hr = psb->QueryActiveShellView(&psv);
if (SUCCEEDED(hr))
{
hr = psv->QueryInterface(riid, ppv);
psv->Release();
}
psb->Release();
}
pauto->Release();
}
return hr;
}
// pidlFolder - fully qualified pidl to the folder to open
// cidl/apidl - array of items in that folder to select
//
// if cild == 0 then pidlFolder is the fully qualified pidl to a single item, it's
// folder is opened and it is selected.
//
// dwFlags - optional flags, pass 0 for now
SHSTDAPI SHOpenFolderAndSelectItems(LPCITEMIDLIST pidlFolder, UINT cidl, LPCITEMIDLIST *apidl, DWORD dwFlags)
{
HRESULT hr;
if (0 == cidl)
{
// overload the 0 item case to mean pidlFolder is the full pidl to the item
LPITEMIDLIST pidlTemp;
hr = SHILClone(pidlFolder, &pidlTemp);
if (SUCCEEDED(hr))
{
ILRemoveLastID(pidlTemp); // strip to the folder
LPCITEMIDLIST pidl = ILFindLastID(pidlFolder);
hr = SHOpenFolderAndSelectItems(pidlTemp, 1, &pidl, 0); // recurse
ILFree(pidlTemp);
}
}
else
{
IFolderView *pfv;
hr = OpenFolderAndGetView(pidlFolder, IID_PPV_ARG(IFolderView, &pfv));
if (SUCCEEDED(hr))
{
pfv->SelectAndPositionItems(1, apidl, NULL, SVSI_SELECT | SVSI_FOCUSED | SVSI_DESELECTOTHERS | SVSI_ENSUREVISIBLE);
if (cidl > 1)
pfv->SelectAndPositionItems(cidl - 1, apidl + 1, NULL, SVSI_SELECT);
pfv->Release();
}
}
return hr;
}
#endif
SHSTDAPI SHCreateShellItem(LPCITEMIDLIST pidlParent, IShellFolder *psfParent, LPCITEMIDLIST pidl, IShellItem **ppsi)
{
*ppsi = NULL;
IShellItem *psi;
HRESULT hr = SHCoCreateInstance(NULL, &CLSID_ShellItem, NULL, IID_PPV_ARG(IShellItem, &psi));
if (SUCCEEDED(hr))
{
if (pidlParent || psfParent)
{
IParentAndItem *pinit;
ASSERT(pidl);
hr = psi->QueryInterface(IID_PPV_ARG(IParentAndItem, &pinit));
if (SUCCEEDED(hr))
{
hr = pinit->SetParentAndItem(pidlParent, psfParent, pidl);
pinit->Release();
}
}
else
{
IPersistIDList *pinit;
hr = psi->QueryInterface(IID_PPV_ARG(IPersistIDList, &pinit));
if (SUCCEEDED(hr))
{
hr = pinit->SetIDList(pidl);
pinit->Release();
}
}
if (SUCCEEDED(hr))
*ppsi = psi;
else
psi->Release();
}
return hr;
}
STDAPI SHCreateShellItemFromParent(IShellItem *psiParent, LPCWSTR pszName, IShellItem **ppsi)
{
*ppsi = NULL;
IShellFolder *psf;
HRESULT hr = psiParent->BindToHandler(NULL, BHID_SFObject, IID_PPV_ARG(IShellFolder, &psf));
if (SUCCEEDED(hr))
{
LPITEMIDLIST pidl;
hr = SHGetIDListFromUnk(psiParent, &pidl);
if (SUCCEEDED(hr))
{
ULONG cchEaten;
LPITEMIDLIST pidlChild;
hr = psf->ParseDisplayName(NULL, NULL, (LPWSTR)pszName, &cchEaten, &pidlChild, NULL);
if (SUCCEEDED(hr))
{
hr = SHCreateShellItem(pidl, psf, pidlChild, ppsi);
ILFree(pidlChild);
}
ILFree(pidl);
}
psf->Release();
}
return hr;
}
SHSTDAPI SHSetLocalizedName(LPWSTR pszPath, LPCWSTR pszResModule, int idsRes)
{
IShellFolder *psfDesktop;
HRESULT hrInit = SHCoInitialize();
HRESULT hr = hrInit;
if (SUCCEEDED(hrInit))
{
hr = SHGetDesktopFolder(&psfDesktop);
if (SUCCEEDED(hr))
{
LPITEMIDLIST pidl;
hr = psfDesktop->ParseDisplayName(NULL, NULL, pszPath, NULL, &pidl, NULL);
if (SUCCEEDED(hr))
{
LPCITEMIDLIST pidlChild;
IShellFolder *psf;
hr = SHBindToParent(pidl, IID_PPV_ARG(IShellFolder, &psf), &pidlChild);
if (SUCCEEDED(hr))
{
// WARNING - this is a stack sensitive function - ZekeL 29-Jan-2001
// since this function is called by winlogon/userenv
// we need to be sensitive to the stack limitations of those callers
// the shortname will be no larger than the long name
DWORD cchShort = lstrlenW(pszResModule) + 1;
WCHAR *pszShort = (WCHAR *)alloca(CbFromCchW(cchShort));
DWORD cch = GetShortPathName(pszResModule, pszShort, cchShort);
if (cch)
{
pszResModule = pszShort;
}
else
{
// GSPN() fails when the module passed in is a relative path
cch = cchShort;
}
cch += 14; // 11 for id + ',' + '@' + null
WCHAR *pszName = (WCHAR *)alloca(CbFromCchW(cch));
wnsprintfW(pszName, cch, L"@%s,%d", pszResModule, (idsRes * -1));
hr = psf->SetNameOf(NULL, pidlChild, pszName, SHGDN_NORMAL, NULL);
psf->Release();
}
SHFree(pidl);
}
psfDesktop->Release();
}
}
SHCoUninitialize(hrInit);
return hr;
}
// ShellHookProc was mistakenly exported in the original NT SHELL32.DLL when
// it didn't need to be (hookproc's, like wndproc's don't need to be exported
// in the 32-bit world). In order to maintain loadability of a app
// which might have linked to it, we stub it here. If some app ended up really
// using it, then we'll look into a specific fix for that app.
STDAPI_(LONG) ShellHookProc(int code, WPARAM wParam, LPARAM lParam)
{
return 0;
}
// RegisterShellHook - wrapper around RegisterShellHookWindow()/DeregisterShellHookWindow()
// the GetTaskmanWindow() stuff is legacy that I don't think is really needed
HWND g_hwndTaskMan = NULL;
STDAPI_(BOOL) RegisterShellHook(HWND hwnd, BOOL fInstall)
{
BOOL fOk = TRUE;
switch (fInstall)
{
case 0:
// un-installation of shell hooks
g_hwndTaskMan = GetTaskmanWindow();
if (hwnd == g_hwndTaskMan)
{
SetTaskmanWindow(NULL);
}
DeregisterShellHookWindow(hwnd);
return TRUE;
case 3:
// explorer.exe Tray uses this
if (g_hwndTaskMan != NULL)
{
SetTaskmanWindow(NULL);
g_hwndTaskMan = NULL;
}
fOk = SetTaskmanWindow(hwnd);
if (fOk)
{
g_hwndTaskMan = hwnd;
}
RegisterShellHookWindow(hwnd); // install
break;
}
return TRUE;
}
EXTERN_C DWORD g_dwThreadBindCtx;
class CThreadBindCtx : public IBindCtx
{
public:
CThreadBindCtx(IBindCtx *pbc) : _cRef(1) { _pbc = pbc; _pbc->AddRef(); }
~CThreadBindCtx();
// *** IUnknown methods ***
STDMETHODIMP QueryInterface(REFIID riid, void **ppvObj);
STDMETHODIMP_(ULONG) AddRef(void);
STDMETHODIMP_(ULONG) Release(void);
// *** IBindCtx methods ***
STDMETHODIMP RegisterObjectBound(IUnknown *punk)
{ return _pbc->RegisterObjectBound(punk); }
STDMETHODIMP RevokeObjectBound(IUnknown *punk)
{ return _pbc->RevokeObjectBound(punk); }
STDMETHODIMP ReleaseBoundObjects(void)
{ return _pbc->ReleaseBoundObjects(); }
STDMETHODIMP SetBindOptions(BIND_OPTS *pbindopts)
{ return _pbc->SetBindOptions(pbindopts); }
STDMETHODIMP GetBindOptions(BIND_OPTS *pbindopts)
{ return _pbc->GetBindOptions(pbindopts); }
STDMETHODIMP GetRunningObjectTable(IRunningObjectTable **pprot)
{ return _pbc->GetRunningObjectTable(pprot); }
STDMETHODIMP RegisterObjectParam(LPOLESTR pszKey, IUnknown *punk)
{ return _pbc->RegisterObjectParam(pszKey, punk); }
STDMETHODIMP GetObjectParam(LPOLESTR pszKey, IUnknown **ppunk)
{ return _pbc->GetObjectParam(pszKey, ppunk); }
STDMETHODIMP EnumObjectParam(IEnumString **ppenum)
{ return _pbc->EnumObjectParam(ppenum); }
STDMETHODIMP RevokeObjectParam(LPOLESTR pszKey)
{ return _pbc->RevokeObjectParam(pszKey); }
private:
LONG _cRef;
IBindCtx * _pbc;
};
CThreadBindCtx::~CThreadBindCtx()
{
ATOMICRELEASE(_pbc);
}
HRESULT CThreadBindCtx::QueryInterface(REFIID riid, void **ppvObj)
{
static const QITAB qit[] = {
QITABENT(CThreadBindCtx, IBindCtx),
{ 0 },
};
return QISearch(this, qit, riid, ppvObj);
}
ULONG CThreadBindCtx::AddRef()
{
return InterlockedIncrement(&_cRef);
}
ULONG CThreadBindCtx::Release()
{
if (InterlockedDecrement(&_cRef))
return _cRef;
delete this;
// clear ourselves out
TlsSetValue(g_dwThreadBindCtx, NULL);
return 0;
}
STDAPI TBCGetBindCtx(BOOL fCreate, IBindCtx **ppbc)
{
HRESULT hr = E_UNEXPECTED;
*ppbc = NULL;
if ((DWORD) -1 != g_dwThreadBindCtx)
{
CThreadBindCtx *ptbc = (CThreadBindCtx *)TlsGetValue(g_dwThreadBindCtx);
if (ptbc)
{
ptbc->AddRef();
*ppbc = SAFECAST(ptbc, IBindCtx *);
hr = S_OK;
}
else if (fCreate)
{
IBindCtx *pbcInner;
hr = CreateBindCtx(0, &pbcInner);
if (SUCCEEDED(hr))
{
hr = E_OUTOFMEMORY;
ptbc = new CThreadBindCtx(pbcInner);
if (ptbc)
{
if (TlsSetValue(g_dwThreadBindCtx, ptbc))
{
*ppbc = SAFECAST(ptbc, IBindCtx *);
hr = S_OK;
}
else
delete ptbc;
}
pbcInner->Release();
}
}
}
return hr;
}
STDAPI TBCRegisterObjectParam(LPCOLESTR pszKey, IUnknown *punk, IBindCtx **ppbcLifetime)
{
IBindCtx *pbc;
HRESULT hr = TBCGetBindCtx(TRUE, &pbc);
if (SUCCEEDED(hr))
{
hr = BindCtx_RegisterObjectParam(pbc, pszKey, punk, ppbcLifetime);
pbc->Release();
}
else
*ppbcLifetime = 0;
return hr;
}
STDAPI TBCGetObjectParam(LPCOLESTR pszKey, REFIID riid, void **ppv)
{
IBindCtx *pbc;
HRESULT hr = TBCGetBindCtx(FALSE, &pbc);
if (SUCCEEDED(hr))
{
IUnknown *punk;
hr = pbc->GetObjectParam((LPOLESTR)pszKey, &punk);
if (SUCCEEDED(hr) )
{
if (ppv)
hr = punk->QueryInterface(riid, ppv);
punk->Release();
}
pbc->Release();
}
return hr;
}
#define TBCENVOBJECT L"ThreadEnvironmentVariables"
STDAPI TBCGetEnvironmentVariable(LPCWSTR pszVar, LPWSTR pszValue, DWORD cchValue)
{
IPropertyBag *pbag;
HRESULT hr = TBCGetObjectParam(TBCENVOBJECT, IID_PPV_ARG(IPropertyBag, &pbag));
if (SUCCEEDED(hr))
{
hr = SHPropertyBag_ReadStr(pbag, pszVar, pszValue, cchValue);
pbag->Release();
}
return hr;
}
STDAPI TBCSetEnvironmentVariable(LPCWSTR pszVar, LPCWSTR pszValue, IBindCtx **ppbcLifetime)
{
*ppbcLifetime = 0;
IPropertyBag *pbag;
HRESULT hr = TBCGetObjectParam(TBCENVOBJECT, IID_PPV_ARG(IPropertyBag, &pbag));
if (FAILED(hr))
hr = SHCreatePropertyBagOnMemory(STGM_READWRITE, IID_PPV_ARG(IPropertyBag, &pbag));
if (SUCCEEDED(hr))
{
hr = SHPropertyBag_WriteStr(pbag, pszVar, pszValue);
if (SUCCEEDED(hr))
hr = TBCRegisterObjectParam(TBCENVOBJECT, pbag, ppbcLifetime);
pbag->Release();
}
return hr;
}
// create a stock IExtractIcon handler for a thing that is file like. this is typically
// used by name space extensiosn that display things that are like files in the
// file system. that is the extension, file attributes decrive all that is needed
// for a simple icon extractor
STDAPI SHCreateFileExtractIconW(LPCWSTR pszFile, DWORD dwFileAttributes, REFIID riid, void **ppv)
{
*ppv = NULL;
HRESULT hr = E_FAIL;
SHFILEINFO sfi = {0};
if (SHGetFileInfo(pszFile, dwFileAttributes, &sfi, sizeof(sfi), SHGFI_ICON | SHGFI_LARGEICON | SHGFI_SYSICONINDEX | SHGFI_USEFILEATTRIBUTES))
{
hr = SHCreateDefExtIcon(TEXT("*"), sfi.iIcon, sfi.iIcon, GIL_PERCLASS | GIL_NOTFILENAME, -1, riid, ppv);
DestroyIcon(sfi.hIcon);
}
return hr;
}
Reference in New Issue View Git Blame Copy Permalink