#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;
}