#include "shellprv.h"
#include <caggunk.h>
#include "ids.h"
#include "datautil.h"
#include "idlcomm.h"
#include "idldata.h"
#include "views.h"
#include "stgutil.h"
#pragma hdrstop

typedef struct
{
    WORD wSize;
    DWORD dwMagic;
    DWORD dwType;
    ULARGE_INTEGER cbFileSize;
    union 
    {
        FILETIME ftModified;
        ULARGE_INTEGER ulModified;
    };
    WCHAR szName[MAX_PATH];
    WORD wZero;
} STGITEM;

typedef UNALIGNED STGITEM * LPSTGITEM;
typedef const UNALIGNED STGITEM * LPCSTGITEM;

// this sets stgfldr pidls apart from others
#define STGITEM_MAGIC 0x08311978


static const struct
{
    UINT iTitle;
    UINT cchCol;
    UINT iFmt;
} 
g_aStgColumns[] = 
{
    {IDS_NAME_COL,     20, LVCFMT_LEFT},
    {IDS_SIZE_COL,     10, LVCFMT_RIGHT},
    {IDS_TYPE_COL,     20, LVCFMT_LEFT},
    {IDS_MODIFIED_COL, 20, LVCFMT_LEFT},
};

enum
{
    STG_COL_NAME,
    STG_COL_SIZE,
    STG_COL_TYPE,
    STG_COL_MODIFIED,
};


// folder object

class CStgFolder;
class CStgEnum;
class CStgDropTarget;

STDAPI CStgEnum_CreateInstance(CStgFolder *pstgf, DWORD grfFlags, IEnumIDList **ppenum);
STDAPI CStgDropTarget_CreateInstance(CStgFolder *pstgf, HWND hwnd, IDropTarget **ppdt);
STDAPI CStgFolder_CreateInstance(IUnknown *punkOuter, REFIID riid, void **ppv);


class CStgFolder : public CAggregatedUnknown, IShellFolder2, IPersistFolder3, IShellFolderViewCB, IStorage, IPersistStorage
{
public:
    CStgFolder(IUnknown *punkAgg, CStgFolder *pstgfParent);
    ~CStgFolder();

    // IUnknown
    STDMETHODIMP QueryInterface(REFIID riid, void **ppv) { return CAggregatedUnknown::QueryInterface(riid,ppv);};
    STDMETHODIMP_(ULONG) AddRef(void) { return CAggregatedUnknown::AddRef();};
    STDMETHODIMP_(ULONG) Release(void) { return CAggregatedUnknown::Release();};

    // IPersist
    STDMETHODIMP GetClassID(CLSID *pClassID)
            { *pClassID = CLSID_StgFolder; return S_OK; }
    STDMETHODIMP Initialize(LPCITEMIDLIST pidl);

    // IPersistFolder2
    STDMETHODIMP GetCurFolder(LPITEMIDLIST *ppidl);

    // IPersistFolder3
    STDMETHODIMP GetFolderTargetInfo(PERSIST_FOLDER_TARGET_INFO *ppfti)
            { return E_NOTIMPL; }
    STDMETHODIMP InitializeEx(IBindCtx *pbc, LPCITEMIDLIST pidlRoot, const PERSIST_FOLDER_TARGET_INFO *ppfti);

    // IShellFolder
    STDMETHODIMP ParseDisplayName(HWND hwnd, LPBC pbc, LPOLESTR pszName, ULONG * pchEaten, LPITEMIDLIST * ppidl, ULONG *pdwAttributes);
    STDMETHODIMP EnumObjects(HWND hwnd, DWORD grfFlags, IEnumIDList **ppenumIDList)
            { return CStgEnum_CreateInstance(this, grfFlags, ppenumIDList); };
    STDMETHODIMP BindToObject(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv);
    STDMETHODIMP BindToStorage(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv)
            { return BindToObject(pidl, pbc, riid, ppv); };
    STDMETHODIMP CompareIDs(LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2);
    STDMETHODIMP CreateViewObject(HWND hwndOwner, REFIID riid, void **ppv);
    STDMETHODIMP GetAttributesOf(UINT cidl, LPCITEMIDLIST * apidl, ULONG *rgfInOut);
    STDMETHODIMP GetUIObjectOf(HWND hwndOwner, UINT cidl, LPCITEMIDLIST * apidl, REFIID riid, UINT * prgfInOut, void **ppv);
    STDMETHODIMP GetDisplayNameOf(LPCITEMIDLIST pidl, DWORD uFlags, LPSTRRET lpName);
    STDMETHODIMP SetNameOf(HWND hwnd, LPCITEMIDLIST pidl, LPCOLESTR pszName, DWORD uFlags, LPITEMIDLIST * ppidlOut);

    // IShellFolder2
    STDMETHODIMP GetDefaultSearchGUID(GUID *pGuid)
            { return E_NOTIMPL; };
    STDMETHODIMP EnumSearches(IEnumExtraSearch **ppenum)
            { return E_NOTIMPL; };
    STDMETHODIMP GetDefaultColumn(DWORD dwRes, ULONG *pSort, ULONG *pDisplay)
            { return E_NOTIMPL; };
    STDMETHODIMP GetDefaultColumnState(UINT iColumn, DWORD *pbState)
            { return E_NOTIMPL; }
    STDMETHODIMP GetDetailsEx(LPCITEMIDLIST pidl, const SHCOLUMNID *pscid, VARIANT *pv)
            { return E_NOTIMPL; };
    STDMETHODIMP GetDetailsOf(LPCITEMIDLIST pidl, UINT iColumn, SHELLDETAILS *pDetails);
    STDMETHODIMP MapColumnToSCID(UINT iColumn, SHCOLUMNID *pscid)
            { return E_NOTIMPL; };

    // IShellFolderViewCB
    STDMETHODIMP MessageSFVCB(UINT uMsg, WPARAM wParam, LPARAM lParam);

    // IStorage
    STDMETHODIMP Commit(DWORD grfCommitFlags);
    STDMETHODIMP Revert();
    STDMETHODIMP SetClass(REFCLSID clsid);
    STDMETHODIMP SetStateBits(DWORD grfStateBits, DWORD grfMask);
    STDMETHODIMP Stat(STATSTG *pstatstg, DWORD grfStatFlag);
    STDMETHODIMP EnumElements(DWORD reserved1, void *reserved2, DWORD reserved3, IEnumSTATSTG **ppenum);
    STDMETHODIMP OpenStream(LPCWSTR pszRel, VOID *reserved1, DWORD grfMode, DWORD reserved2, IStream **ppstm);
    STDMETHODIMP OpenStorage(LPCWSTR pszRel, IStorage *pstgPriority, DWORD grfMode, SNB snbExclude, DWORD reserved, IStorage **ppstg);
    STDMETHODIMP DestroyElement(LPCWSTR pszRel);
    STDMETHODIMP RenameElement(LPCWSTR pwcsOldName, LPCWSTR pwcsNewName);
    STDMETHODIMP SetElementTimes(LPCWSTR pszRel, const FILETIME *pctime, const FILETIME *patime, const FILETIME *pmtime);
    STDMETHODIMP CopyTo(DWORD ciidExclude, const IID *rgiidExclude, SNB snbExclude, IStorage *pstgDest);
    STDMETHODIMP MoveElementTo(LPCWSTR pszRel, IStorage *pstgDest, LPCWSTR pwcsNewName, DWORD grfFlags);
    STDMETHODIMP CreateStream(LPCWSTR pwcsName, DWORD grfMode, DWORD res1, DWORD res2, IStream **ppstm);
    STDMETHODIMP CreateStorage(LPCWSTR pwcsName, DWORD grfMode, DWORD res1, DWORD res2, IStorage **ppstg);

    // IPersistStorage
    STDMETHODIMP IsDirty(void);
    STDMETHODIMP InitNew(IStorage *pStg);
    STDMETHODIMP Load(IStorage *pStg);
    STDMETHODIMP Save(IStorage *pStgSave, BOOL fSameAsLoad);
    STDMETHODIMP SaveCompleted(IStorage *pStgNew);
    STDMETHODIMP HandsOffStorage(void);

private:
    LONG _cRef;             
    CStgFolder *_pstgfParent;
    IStorage *_pstg;
    IStorage *_pstgLoad;
    LPITEMIDLIST _pidl;
    DWORD _dwMode;

    virtual HRESULT v_InternalQueryInterface(REFIID riid, void **ppv);

    HRESULT _BindToStorageObject(LPCITEMIDLIST pidl, DWORD grfMode, IStorage **ppstg);
    BOOL _OkayWithCurrentMode(DWORD grfMode);
    HRESULT _EnsureStorage(DWORD grfMode);
    void _CloseStorage();
    HRESULT _InitNewStgFolder(CStgFolder *pstgf, DWORD grfMode, LPCITEMIDLIST pidlNew);
    HRESULT _AllocIDList(STATSTG stat, LPITEMIDLIST *ppidl, BOOL *pfFolder);
    HRESULT _AllocIDList(LPCTSTR pszName, LPITEMIDLIST *ppidl, BOOL *pfFolder);
    HRESULT _SetShortcutStorage(IStorage *pstgLink);
    HRESULT _GetTypeOf(LPCSTGITEM pistg, LPTSTR pszBuffer, INT cchBuffer);
    ULONG _GetAttributesOf(LPCSTGITEM pistg, ULONG rgfIn);
    BOOL _ShowExtension();
    static HRESULT CALLBACK _ItemsMenuCB(IShellFolder *psf, HWND hwnd, IDataObject *pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam);

    // folder view callback handlers
    HRESULT _OnBackgroundEnum(DWORD pv)
            { return S_OK; };
    HRESULT _OnGetNotify(DWORD pv, LPITEMIDLIST *ppidl, LONG *plEvents);

    LPCSTGITEM _IsStgItem(LPCITEMIDLIST pidl);
    DWORD _IsFolder(LPCSTGITEM psitem);

    friend CStgEnum;
    friend CStgDropTarget;
    friend HRESULT CStgFolder_CreateInstance(IUnknown *punkOuter, REFIID riid, void **ppv);
};


// Construction and IUnknown for folder root

CStgFolder::CStgFolder(IUnknown *punkAgg, CStgFolder *pstgfParent) : CAggregatedUnknown(punkAgg),
    _dwMode(STGM_READ), _cRef(1)
{
    ASSERT(NULL == _pidl);
    ASSERT(NULL == _pstg);
    ASSERT(NULL == _pstgLoad);

    _pstgfParent = pstgfParent;
    if (_pstgfParent)
        _pstgfParent->AddRef();

    DllAddRef();
}

CStgFolder::~CStgFolder()
{
    ILFree(_pidl);

    if (_pstg)
        _pstg->Commit(STGC_DEFAULT);

    ATOMICRELEASE(_pstg);
    ATOMICRELEASE(_pstgfParent);
    ATOMICRELEASE(_pstgLoad);

    DllRelease();
}

HRESULT CStgFolder::v_InternalQueryInterface(REFIID riid, void **ppv)
{
    static const QITAB qit[] = 
    {
        QITABENTMULTI(CStgFolder, IShellFolder,      IShellFolder2),    // IID_IShellFolder
        QITABENT     (CStgFolder, IShellFolder2),                       // IID_IShellFolder2
        QITABENTMULTI(CStgFolder, IPersist,          IPersistFolder3),  // IID_IPersist
        QITABENTMULTI(CStgFolder, IPersistFolder,    IPersistFolder3),  // IID_IPersistFolder
        QITABENTMULTI(CStgFolder, IPersistFolder2,   IPersistFolder3),  // IID_IPersistFolder2
        QITABENT     (CStgFolder, IPersistStorage),                     // IID_IPersistStorage
        QITABENT     (CStgFolder, IPersistFolder3),                     // IID_IPersistFolder3
        QITABENT     (CStgFolder, IShellFolderViewCB),                  // IID_IShellFolderViewCB
        QITABENT     (CStgFolder, IStorage),                            // IID_IStorage
        { 0 },
    };
    
    if (IsEqualIID(CLSID_StgFolder, riid))
    {
        *ppv = this;                    // not ref counted
        return S_OK;
    }
    return QISearch(this, qit, riid, ppv);
}


STDAPI CStgFolder_CreateInstance(IUnknown* punkOuter, REFIID riid, void** ppv)
{
    CStgFolder *pstgf = new CStgFolder(punkOuter, NULL);
    if (!pstgf)
        return E_OUTOFMEMORY;

    HRESULT hr = pstgf->_GetInner()->QueryInterface(riid, ppv);
    pstgf->_GetInner()->Release();
    return hr;
}


LPCSTGITEM CStgFolder::_IsStgItem(LPCITEMIDLIST pidl)
{
    if (pidl && ((LPCSTGITEM) pidl)->dwMagic == STGITEM_MAGIC)
        return (LPCSTGITEM)pidl;
    return NULL;
}

// BOOL, but returns FILE_ATTRIBUTE_DIRECTORY for convience

DWORD CStgFolder::_IsFolder(LPCSTGITEM pistg)
{
    return pistg->dwType == STGTY_STORAGE ? FILE_ATTRIBUTE_DIRECTORY : 0;
}

// Creates an item identifier list for the objects in the namespace

HRESULT CStgFolder::_AllocIDList(STATSTG stat, LPITEMIDLIST *ppidl, BOOL *pfFolder)
{
    // Note the terminating NULL is already in the sizeof(STGITEM)
    STGITEM sitem = {0};
    UINT uNameLen = lstrlen(stat.pwcsName);

    if (uNameLen >= MAX_PATH)
    {
        return E_INVALIDARG;
    }
    
    sitem.wSize = (WORD)(FIELD_OFFSET(STGITEM, szName[uNameLen + 1]));
    sitem.dwMagic = STGITEM_MAGIC;
    sitem.dwType = stat.type;
    sitem.cbFileSize = stat.cbSize;
    sitem.ftModified = stat.mtime;
    lstrcpyn(sitem.szName, stat.pwcsName, uNameLen + 1);

    if (pfFolder)
    {
        *pfFolder = _IsFolder(&sitem);
    }
        
    return SHILClone((LPCITEMIDLIST)&sitem, ppidl);
}

HRESULT CStgFolder::_AllocIDList(LPCTSTR pszName, LPITEMIDLIST *ppidl, BOOL *pfFolder)
{
    // given a name, look it up in the current storage object we have and
    // compute the STATSTG which we can then build an IDLIST from.

    DWORD grfMode = STGM_READ;
    HRESULT hr = _EnsureStorage(grfMode);
    if (SUCCEEDED(hr))
    {
        STATSTG stat;

        // is it a stream or a storage? 

        IStream *pstrm;
        hr = _pstg->OpenStream(pszName, NULL, grfMode, 0, &pstrm);
        if (SUCCEEDED(hr))
        {
            hr = pstrm->Stat(&stat, STATFLAG_DEFAULT);
            pstrm->Release();
        }
        else
        {
            IStorage *pstg;
            hr = _pstg->OpenStorage(pszName, NULL, grfMode, NULL, 0, &pstg);
            if (SUCCEEDED(hr))
            {
                hr = pstg->Stat(&stat, STATFLAG_DEFAULT);
                pstg->Release();
            }
        }

        // if that worked then lets allocate the object, 
        // nb: release the name returned in the STATSTG

        if (SUCCEEDED(hr))
        {
            hr = _AllocIDList(stat, ppidl, pfFolder);
            CoTaskMemFree(stat.pwcsName);
        }
    }
    return hr;
}


void CStgFolder::_CloseStorage()
{
    if (_pstg)
    {
        _pstg->Commit(STGC_DEFAULT);
        ATOMICRELEASE(_pstg);
    }
}


HRESULT CStgFolder::_BindToStorageObject(LPCITEMIDLIST pidl, DWORD grfMode, IStorage **ppstg)
{
    IBindCtx *pbc;
    HRESULT hr = SHCreateSkipBindCtx(NULL, &pbc); // NULL to mean we skip all CLSIDs
    if (SUCCEEDED(hr))
    {
        BIND_OPTS bo = {sizeof(bo)};
        hr = pbc->GetBindOptions(&bo);
        if (SUCCEEDED(hr))
        {
            bo.grfMode = grfMode;
            hr = pbc->SetBindOptions(&bo);
            if (SUCCEEDED(hr))
            {
                hr = SHBindToObjectEx(NULL, pidl, pbc, IID_PPV_ARG(IStorage, ppstg));
            }
        }
        pbc->Release();
    }
    return hr;
}


HRESULT CStgFolder::_SetShortcutStorage(IStorage *pstgLink)
{
#if 1
    return CShortcutStorage_CreateInstance(pstgLink, IID_PPV_ARG(IStorage, &_pstg));
#else
    IUnknown_Set((IUnknown **)&_pstg, (IUnknown *)pstgLink);
    return S_OK;
#endif
}


BOOL CStgFolder::_OkayWithCurrentMode(DWORD grfMode)
{
    DWORD dwNewBits = grfMode & (STGM_READ | STGM_WRITE | STGM_READWRITE);
    DWORD dwOldBits = _dwMode & (STGM_READ | STGM_WRITE | STGM_READWRITE);
    return (dwOldBits == STGM_READWRITE) || (dwOldBits == dwNewBits);
}


HRESULT CStgFolder::_EnsureStorage(DWORD grfMode)
{
    // if we have a storage and its mode encompasses the grfMode we need then we
    // can skip the whole thing.

    HRESULT hr = S_OK;
    if (!_pstg || !_OkayWithCurrentMode(grfMode))
    {
        _dwMode = grfMode;

        _CloseStorage();

        if (_pstgfParent)
        {
            hr = _pstgfParent->_EnsureStorage(grfMode);

            if (SUCCEEDED(hr))
            {
                LPCWSTR pwszName;
                LPCSTGITEM pit = _IsStgItem(ILFindLastID(_pidl));
                WSTR_ALIGNED_STACK_COPY(&pwszName, pit->szName);

                hr = _pstgfParent->_pstg->OpenStorage(pwszName, NULL, grfMode, NULL, 0, &_pstg);
            }
        }
        else if (_pstgLoad)
        {
            hr = _pstgLoad->QueryInterface(IID_PPV_ARG(IStorage, &_pstg));
        }
        else
        {
            IStorage *pstgLink;
            hr = _BindToStorageObject(_pidl, grfMode, &pstgLink);
            if (hr == STG_E_FILENOTFOUND)
                hr = _BindToStorageObject(_pidl, grfMode | STGM_CREATE, &pstgLink);

            if (SUCCEEDED(hr))
            {
                hr = _SetShortcutStorage(pstgLink);
                pstgLink->Release();
            }
        }
    }
    return hr;
}


BOOL CStgFolder::_ShowExtension()
{
    SHELLSTATE ss;
    SHGetSetSettings(&ss, SSF_SHOWEXTENSIONS, FALSE);
    return ss.fShowExtensions;
}

HRESULT CStgFolder::_GetTypeOf(LPCSTGITEM pistg, LPTSTR pszBuffer, INT cchBuffer)
{
    *pszBuffer = TEXT('\0');                // null out the return buffer

    LPCWSTR pwszName;
    WSTR_ALIGNED_STACK_COPY(&pwszName, pistg->szName);

    LPTSTR pszExt = PathFindExtension(pwszName);
    if (pszExt)
    {
        StrCpyN(pszBuffer, pszExt, cchBuffer);
    }

    return S_OK;
}

CStgFolder* _GetStgFolder(IShellFolder *psf)
{
    CStgFolder *pstgf;
    return SUCCEEDED(psf->QueryInterface(CLSID_StgFolder, (void**)&pstgf)) ? pstgf : NULL;
}

// IPersist / IPersistFolder etc

STDMETHODIMP CStgFolder::Initialize(LPCITEMIDLIST pidl)
{
    ILFree(_pidl);
    return SHILClone(pidl, &_pidl); 
}

HRESULT CStgFolder::GetCurFolder(LPITEMIDLIST *ppidl)
{
    if (_pidl)
        return SHILClone(_pidl, ppidl);

    *ppidl = NULL;
    return S_FALSE;
}


HRESULT CStgFolder::InitializeEx(IBindCtx *pbc, LPCITEMIDLIST pidlRoot, const PERSIST_FOLDER_TARGET_INFO *ppfti)
{
    ASSERTMSG(_pstg == NULL, "shouldn't initialize again if we already have a storage");

    HRESULT hr = Initialize(pidlRoot);
    if (SUCCEEDED(hr) && pbc)
    {
        // we don't care if these don't succeed so don't propagate the hr here
        BIND_OPTS bo = {sizeof(bo)};
        if (SUCCEEDED(pbc->GetBindOptions(&bo)))
        {
            _dwMode = bo.grfMode;
        }

        IUnknown *punk;
        if (SUCCEEDED(pbc->GetObjectParam(STGSTR_STGTOBIND, &punk)))
        {
            IStorage *pstgLink;
            hr = punk->QueryInterface(IID_PPV_ARG(IStorage, &pstgLink));
            if (SUCCEEDED(hr))
            {
                hr = _SetShortcutStorage(pstgLink);
                if (SUCCEEDED(hr))
                {
                    STATSTG stat;
                    hr = _pstg->Stat(&stat, STATFLAG_NONAME);
                    if (SUCCEEDED(hr))
                    {
                        // we want to know what mode we're opened in, so we will only
                        // have to re-open if necessary
                        _dwMode = stat.grfMode;
                    }
                }
                pstgLink->Release();
            }
            punk->Release();
        }
    }

    return hr;
}


// IShellFolder(2)

HRESULT CStgFolder::ParseDisplayName(HWND hwnd, LPBC pbc, LPOLESTR pszName, ULONG *pchEaten, LPITEMIDLIST *ppidl, ULONG *pdwAttributes)
{
    HRESULT hr;

    if (!ppidl)
        return E_INVALIDARG;
    *ppidl = NULL;
    if (!pszName)
        return E_INVALIDARG;

    TCHAR szName[MAX_PATH];
    hr = _NextSegment((LPCWSTR*)&pszName, szName, ARRAYSIZE(szName), TRUE);
    if (SUCCEEDED(hr))
    {
        hr = _AllocIDList(szName, ppidl, NULL);
        if (SUCCEEDED(hr) && pszName)
        {
            IShellFolder *psf;
            hr = BindToObject(*ppidl, pbc, IID_PPV_ARG(IShellFolder, &psf));
            if (SUCCEEDED(hr))
            {
                ULONG chEaten;
                LPITEMIDLIST pidlNext;
                hr = psf->ParseDisplayName(hwnd, pbc, pszName, &chEaten, &pidlNext, pdwAttributes);
                if (SUCCEEDED(hr))
                    hr = SHILAppend(pidlNext, ppidl);
                psf->Release();
            }
        }
        else if (SUCCEEDED(hr) && pdwAttributes && *pdwAttributes)
        {
            GetAttributesOf(1, (LPCITEMIDLIST *)ppidl, pdwAttributes);
        }
    }

    // clean up if the parse failed.

    if (FAILED(hr))
    {
        ILFree(*ppidl);
        *ppidl = NULL;
    }

    return hr;
}


HRESULT CStgFolder::_InitNewStgFolder(CStgFolder *pstgf, DWORD grfMode, LPCITEMIDLIST pidlNew)
{
    HRESULT hr = pstgf->Initialize(pidlNew);
    if (SUCCEEDED(hr))
    {
        pstgf->_dwMode = grfMode;
    }
    return hr;
}



HRESULT CStgFolder::BindToObject(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv)
{
    *ppv = NULL;

    LPCSTGITEM pistg = _IsStgItem(pidl);
    if (!pistg)
        return E_FAIL;

    DWORD grfMode = BindCtx_GetMode(pbc, STGM_READ);
    HRESULT hr;
    if (IsEqualIID(riid, IID_IStream))
    {       
        // they are requesting a stream on the current
        // item, therefore lets return it to them.

        hr = _EnsureStorage(grfMode);        
        if (SUCCEEDED(hr))
        {
            LPCWSTR pwszName;
            WSTR_ALIGNED_STACK_COPY(&pwszName, pistg->szName);

            IStream *pstrm;
            hr = _pstg->OpenStream(pwszName, NULL, grfMode, 0, &pstrm);
            if (SUCCEEDED(hr))
            {
                hr = pstrm->QueryInterface(riid, ppv);
                pstrm->Release();
            }
        }
    }
    else
    {
        // its not an IStream request, so lets bind to the shell folder
        // and get the interface that the caller requested.

        LPCITEMIDLIST pidlNext = _ILNext(pidl);
        LPITEMIDLIST pidlSubFolder = ILCombineParentAndFirst(_pidl, pidl, pidlNext);
        if (pidlSubFolder)
        {
            CStgFolder *pstgf = new CStgFolder(NULL, this);
            if (pstgf)
            {
                hr = _InitNewStgFolder(pstgf, grfMode, pidlSubFolder);
                if (SUCCEEDED(hr))
                {
                    // if there's nothing left in the pidl, get the interface on this one.
                    if (ILIsEmpty(pidlNext))
                        hr = pstgf->QueryInterface(riid, ppv);
                    else
                    {
                        // otherwise, hand the rest of it off to the new shellfolder.
                        hr = pstgf->BindToObject(pidlNext, pbc, riid, ppv);
                    }
                }
                pstgf->Release();
            }
            else
                hr = E_OUTOFMEMORY;

            ILFree(pidlSubFolder);
        }
        else
            hr = E_OUTOFMEMORY;
    }

    ASSERT((SUCCEEDED(hr) && *ppv) || (FAILED(hr) && (NULL == *ppv)));   // Assert hr is consistent w/out param.
    return hr;
}


HRESULT CStgFolder::CompareIDs(LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
{
    LPCSTGITEM pistg1 = _IsStgItem(pidl1);
    LPCSTGITEM pistg2 = _IsStgItem(pidl2);
    INT nCmp = 0;

    if (!pistg1 || !pistg2)
        return E_INVALIDARG;

    // folders always sort to the top of the list, if either of these items
    // are folders then compare on the folderness
    
    if (_IsFolder(pistg1) || _IsFolder(pistg2))
    {
        if (_IsFolder(pistg1) && !_IsFolder(pistg2))
            nCmp = -1;
        else if (!_IsFolder(pistg1) && _IsFolder(pistg2))
            nCmp = 1;
    }

    // if they match (or are not folders, then lets compare based on the column ID.

    if (nCmp == 0)
    {
        switch (lParam & SHCIDS_COLUMNMASK)
        {
            case STG_COL_NAME:          // caught later on
                break;

            case STG_COL_SIZE:
            {
                if (pistg1->cbFileSize.QuadPart < pistg2->cbFileSize.QuadPart)
                    nCmp = -1;
                else if (pistg1->cbFileSize.QuadPart > pistg2->cbFileSize.QuadPart)
                    nCmp = 1;
                break;
            }

            case STG_COL_TYPE:
            {
                TCHAR szType1[MAX_PATH], szType2[MAX_PATH];
                _GetTypeOf(pistg1, szType1, ARRAYSIZE(szType1));
                _GetTypeOf(pistg2, szType2, ARRAYSIZE(szType2));
                nCmp = StrCmpI(szType1, szType2);
                break;
            }

            case STG_COL_MODIFIED:
            {
                if (pistg1->ulModified.QuadPart < pistg2->ulModified.QuadPart)
                    nCmp = -1;
                else if (pistg1->ulModified.QuadPart > pistg2->ulModified.QuadPart)
                    nCmp = 1;
                break;
            }
        }

        if (nCmp == 0)
        {
            nCmp = ualstrcmpi(pistg1->szName, pistg2->szName);
        }
    }
    
    return ResultFromShort(nCmp);
}


HRESULT CStgFolder::_OnGetNotify(DWORD pv, LPITEMIDLIST *ppidl, LONG *plEvents)
{
    *ppidl = _pidl;
    *plEvents = SHCNE_RENAMEITEM | SHCNE_RENAMEFOLDER | \
                SHCNE_CREATE | SHCNE_DELETE | SHCNE_UPDATEDIR | SHCNE_UPDATEITEM | \
                SHCNE_MKDIR | SHCNE_RMDIR;
    return S_OK;
}


STDMETHODIMP CStgFolder::MessageSFVCB(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    HRESULT hr = E_FAIL;
    switch (uMsg)
    {
        HANDLE_MSG(0, SFVM_BACKGROUNDENUM, _OnBackgroundEnum);
        HANDLE_MSG(0, SFVM_GETNOTIFY, _OnGetNotify);
    }
    return hr;
}

HRESULT CStgFolder::CreateViewObject(HWND hwnd, REFIID riid, void **ppv)
{
    HRESULT hr = E_NOINTERFACE;
    *ppv = NULL;
    
    if (IsEqualIID(riid, IID_IShellView))
    {
        SFV_CREATE sSFV = { 0 };
        sSFV.cbSize = sizeof(sSFV);
        sSFV.psfvcb = this;
        sSFV.pshf = this;
        hr = SHCreateShellFolderView(&sSFV, (IShellView**)ppv);
    }
    else if (IsEqualIID(riid, IID_IContextMenu))
    {
        HKEY hkNoFiles = NULL;
        
        RegOpenKey(HKEY_CLASSES_ROOT, TEXT("Directory\\Background"), &hkNoFiles);

        hr = CDefFolderMenu_Create2(_pidl, hwnd,
                                    0, NULL,
                                    this, NULL,
                                    1, &hkNoFiles, 
                                    (IContextMenu **)ppv);
        if (hkNoFiles)
            RegCloseKey(hkNoFiles);
    }
    else if (IsEqualIID(riid, IID_IDropTarget))
    {
        hr = CStgDropTarget_CreateInstance(this, hwnd, (IDropTarget **)ppv);
    }

    return hr;
}


ULONG CStgFolder::_GetAttributesOf(LPCSTGITEM pistg, ULONG rgfIn)
{
    ULONG dwResult = rgfIn & (SFGAO_CANCOPY | SFGAO_CANDELETE | 
                              SFGAO_CANLINK | SFGAO_CANMOVE |
                              SFGAO_CANRENAME | SFGAO_HASPROPSHEET | 
                              SFGAO_DROPTARGET);

    // if the items is a folder then lets check to see if it has sub folders etc...

    if (pistg && _IsFolder(pistg) && (rgfIn & (SFGAO_FOLDER | SFGAO_HASSUBFOLDER)))
    {
        dwResult |= rgfIn & SFGAO_FOLDER;
        if (rgfIn & SFGAO_HASSUBFOLDER)
        {
            IShellFolder *psf = NULL;
            if (SUCCEEDED(BindToObject((LPITEMIDLIST)pistg, NULL, IID_PPV_ARG(IShellFolder, &psf))))
            {
                IEnumIDList * pei;
                if (S_OK == psf->EnumObjects(NULL, SHCONTF_FOLDERS, &pei))
                {
                    LPITEMIDLIST pidl;
                    if (S_OK == pei->Next(1, &pidl, NULL))
                    {
                        dwResult |= rgfIn & SFGAO_HASSUBFOLDER;
                        ILFree(pidl);
                    }
                    pei->Release();
                }
                psf->Release();
            }
        }
    }

    return dwResult;
}

HRESULT CStgFolder::GetAttributesOf(UINT cidl, LPCITEMIDLIST *apidl, ULONG *prgfInOut)
{
    UINT rgfOut = *prgfInOut;

    // return attributes of the namespace root?

    if ( !cidl || !apidl )
    {
        rgfOut &= SFGAO_FOLDER | SFGAO_FILESYSTEM | 
                  SFGAO_LINK | SFGAO_DROPTARGET |
                  SFGAO_CANRENAME | SFGAO_CANDELETE |
                  SFGAO_CANLINK | SFGAO_CANCOPY | 
                  SFGAO_CANMOVE | SFGAO_HASSUBFOLDER;
    }
    else
    {
        for (UINT i = 0; i < cidl; i++)
            rgfOut &= _GetAttributesOf(_IsStgItem(apidl[i]), *prgfInOut);
    }

    *prgfInOut = rgfOut;
    return S_OK;
}


HRESULT CALLBACK CStgFolder::_ItemsMenuCB(IShellFolder *psf, HWND hwnd, IDataObject *pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    HRESULT hr = S_OK;

    switch (uMsg) 
    {
    case DFM_MERGECONTEXTMENU:
        break;

    case DFM_INVOKECOMMANDEX:
    {
        DFMICS *pdfmics = (DFMICS *)lParam;
        switch (wParam)
        {
        case DFM_CMD_DELETE:
            hr = StgDeleteUsingDataObject(hwnd, pdfmics->fMask, pdtobj);
            break;

        case DFM_CMD_PROPERTIES:
            break;

        default:
            // This is common menu items, use the default code.
            hr = S_FALSE;
            break;
        }
        break;
    }

    default:
        hr = E_NOTIMPL;
        break;
    }

    return hr;
}

HRESULT CStgFolder::GetUIObjectOf(HWND hwnd, UINT cidl, LPCITEMIDLIST *apidl, 
                                  REFIID riid, UINT *prgfInOut, void **ppv)
{
    HRESULT hr = E_INVALIDARG;
    LPCSTGITEM pistg = cidl ? _IsStgItem(apidl[0]) : NULL;

    if (pistg &&
        (IsEqualIID(riid, IID_IExtractIconA) || IsEqualIID(riid, IID_IExtractIconW)))
    {
        LPCWSTR pwszName;
        WSTR_ALIGNED_STACK_COPY(&pwszName, pistg->szName);

        hr = SHCreateFileExtractIconW(pwszName, _IsFolder(pistg), riid, ppv);
    }
    else if (IsEqualIID(riid, IID_IDataObject) && cidl)
    {
        hr = CIDLData_CreateInstance(_pidl, cidl, apidl, NULL, (IDataObject **)ppv);
    }
#if 0    
    else if (IsEqualIID(riid, IID_IContextMenu) && pistg)
    {
        // get the association for these files and lets attempt to 
        // build the context menu for the selection.   

        IQueryAssociations *pqa;
        hr = GetUIObjectOf(hwnd, 1, (LPCITEMIDLIST*)&pistg, IID_PPV_ARG_NULL(IQueryAssociations, &pqa));
        if (SUCCEEDED(hr))
        {
            HKEY ahk[3];
            // this is broken for docfiles (shell\ext\stgfldr's keys work though)
            // maybe because GetClassFile punts when it's not fs?
            DWORD cKeys = SHGetAssocKeys(pqa, ahk, ARRAYSIZE(ahk));
            hr = CDefFolderMenu_Create2(_pidl, hwnd, cidl, apidl, 
                                        this, _ItemsMenuCB, cKeys, ahk, 
                                        (IContextMenu **)ppv);
            
            SHRegCloseKeys(ahk, cKeys);
            pqa->Release();
        }
    }
    else if (IsEqualIID(riid, IID_IQueryAssociations) && pistg)
    {
        //  need to create a valid Assoc obj here
    }
#endif    
    else if (IsEqualIID(riid, IID_IDropTarget) && pistg)
    {
        // If a directory is selected in the view, the drop is going to a folder,
        // so we need to bind to that folder and ask it to create a drop target

        if (_IsFolder(pistg))
        {
            IShellFolder *psf;
            hr = BindToObject(apidl[0], NULL, IID_PPV_ARG(IShellFolder, &psf));
            if (SUCCEEDED(hr))
            {
                hr = psf->CreateViewObject(hwnd, IID_IDropTarget, ppv);
                psf->Release();
            }
        }
        else
        {
            hr = CreateViewObject(hwnd, IID_IDropTarget, ppv);
        }
    }

    return hr;
}


HRESULT CStgFolder::GetDisplayNameOf(LPCITEMIDLIST pidl, DWORD dwFlags, STRRET *pStrRet)
{
    HRESULT hr = E_INVALIDARG;
    LPCSTGITEM pistg = _IsStgItem(pidl);
    if (pistg)
    {
        LPCWSTR pwszName;
        WSTR_ALIGNED_STACK_COPY(&pwszName, pistg->szName);

        if (dwFlags & SHGDN_FORPARSING)
        {
            if (dwFlags & SHGDN_INFOLDER)
            {
                hr = StringToStrRet(pwszName, pStrRet);          // relative name
            }
            else
            {
                // compute the for parsing name based on the path to the storage object
                // and then the in folder name of the object

                TCHAR szTemp[MAX_PATH];
                SHGetNameAndFlags(_pidl, dwFlags, szTemp, ARRAYSIZE(szTemp), NULL);
                PathAppend(szTemp, pwszName);
                hr = StringToStrRet(szTemp, pStrRet);
            }
        }
        else
        {
            SHFILEINFO sfi;
            if (SHGetFileInfo(pwszName, _IsFolder(pistg), &sfi, sizeof(sfi), SHGFI_USEFILEATTRIBUTES | SHGFI_DISPLAYNAME))
                hr = StringToStrRet(sfi.szDisplayName, pStrRet);
            else
                hr = E_FAIL;
        }
    }
    return hr;
}

HRESULT CStgFolder::SetNameOf(HWND hwnd, LPCITEMIDLIST pidl, LPCOLESTR pszName, DWORD dwFlags, LPITEMIDLIST *ppidlOut)
{
    LPCSTGITEM pistg = _IsStgItem(pidl);
    if (!pistg)
        return E_INVALIDARG;

    HRESULT hr = _EnsureStorage(STGM_READWRITE);
    if (SUCCEEDED(hr))
    {
        LPCWSTR pwszName;
        WSTR_ALIGNED_STACK_COPY(&pwszName, pistg->szName);
        
        // format up the new name before we attempt to perform the rename

        TCHAR szNewName[MAX_PATH];
        StrCpyN(szNewName, pszName, ARRAYSIZE(szNewName));
        if (!_ShowExtension())
        {
            StrCatBuff(szNewName, PathFindExtension(pwszName), ARRAYSIZE(szNewName));
        }

        hr = _pstg->RenameElement(pwszName, szNewName);            
        if (SUCCEEDED(hr))
        {
            hr = _pstg->Commit(STGC_DEFAULT);
        }

        // if that was successful lets return the
        // new IDLIST we generated.

        if (SUCCEEDED(hr) && ppidlOut)
            hr = _AllocIDList(szNewName, ppidlOut, NULL);
    }
    return hr;
}


HRESULT CStgFolder::GetDetailsOf(LPCITEMIDLIST pidl, UINT iColumn, SHELLDETAILS *pDetail)
{
    HRESULT hr = S_OK;
    TCHAR szTemp[MAX_PATH];

    // is this a valid column?

    if (iColumn >= ARRAYSIZE(g_aStgColumns))
        return E_NOTIMPL;
   
    pDetail->str.uType = STRRET_CSTR;
    pDetail->str.cStr[0] = 0;
    
    LPCSTGITEM pistg = _IsStgItem(pidl);
    if (!pistg)
    {
        // when the IDLIST is not a storage item then we return the column information
        // back to the caller.

        pDetail->fmt = g_aStgColumns[iColumn].iFmt;
        pDetail->cxChar = g_aStgColumns[iColumn].cchCol;
        LoadString(HINST_THISDLL, g_aStgColumns[iColumn].iTitle, szTemp, ARRAYSIZE(szTemp));
        hr = StringToStrRet(szTemp, &(pDetail->str));
    }
    else
    {
        // return the property to the caller that is being requested, this is based on the
        // list of columns we gave out when the view was created.
        LPCWSTR pwszName;
        WSTR_ALIGNED_STACK_COPY(&pwszName, pistg->szName);

        switch (iColumn)
        {
            case STG_COL_NAME:
                hr = StringToStrRet(pwszName, &(pDetail->str));
                break;
        
            case STG_COL_SIZE:
                if (!_IsFolder(pistg))
                {
                    ULARGE_INTEGER ullSize = pistg->cbFileSize;
                    StrFormatKBSize(ullSize.QuadPart, szTemp, ARRAYSIZE(szTemp));
                    hr = StringToStrRet(szTemp, &(pDetail->str));
                }
                break;
        
            case STG_COL_TYPE:
            {
                SHFILEINFO sfi;
                if (SHGetFileInfo(pwszName, _IsFolder(pistg), &sfi, sizeof(sfi), SHGFI_USEFILEATTRIBUTES | SHGFI_TYPENAME))
                    hr =  StringToStrRet(sfi.szTypeName, &(pDetail->str));
                break;
            }

            case STG_COL_MODIFIED:
                SHFormatDateTime(&pistg->ftModified, NULL, szTemp, ARRAYSIZE(szTemp));
                hr = StringToStrRet(szTemp, &(pDetail->str));
                break;
        }             
    }    
    return hr;
}


// IStorage

HRESULT CStgFolder::Commit(DWORD grfCommitFlags)
{
    HRESULT hr = _EnsureStorage(_dwMode);
    if (SUCCEEDED(hr))
    {
        ASSERTMSG(_pstg != NULL, "no _pstg in Commit");
        hr = _pstg->Commit(grfCommitFlags);
    }
    return hr;
}

HRESULT CStgFolder::Revert()
{
    HRESULT hr = _EnsureStorage(_dwMode);
    if (SUCCEEDED(hr))
    {
        ASSERTMSG(_pstg != NULL, "no _pstg in Revert");
        hr = _pstg->Revert();
    }
    return hr;
}

HRESULT CStgFolder::SetClass(REFCLSID clsid)
{
    HRESULT hr = _EnsureStorage(_dwMode);
    if (SUCCEEDED(hr))
    {
        ASSERTMSG(_pstg != NULL, "no _pstg in SetClass");
        hr = _pstg->SetClass(clsid);
    }
    return hr;
}

HRESULT CStgFolder::SetStateBits(DWORD grfStateBits, DWORD grfMask)
{
    HRESULT hr = _EnsureStorage(_dwMode);
    if (SUCCEEDED(hr))
    {
        ASSERTMSG(_pstg != NULL, "no _pstg in SetStateBits");
        hr = _pstg->SetStateBits(grfStateBits, grfMask);
    }
    return hr;
}

HRESULT CStgFolder::Stat(STATSTG *pstatstg, DWORD grfStatFlag)
{
    HRESULT hr = _EnsureStorage(_dwMode);
    if (SUCCEEDED(hr))
    {
        ASSERTMSG(_pstg != NULL, "no _pstg in Stat");
        hr = _pstg->Stat(pstatstg, grfStatFlag);
    }
    return hr;
}

HRESULT CStgFolder::EnumElements(DWORD reserved1, void *reserved2, DWORD reserved3, IEnumSTATSTG **ppenum)
{
    HRESULT hr = _EnsureStorage(_dwMode);
    if (SUCCEEDED(hr))
    {
        ASSERTMSG(_pstg != NULL, "no _pstg in EnumElements");
        hr = _pstg->EnumElements(reserved1, reserved2, reserved3, ppenum);
    }
    return hr;
}

HRESULT CStgFolder::OpenStream(LPCWSTR pszRel, VOID *reserved1, DWORD grfMode, DWORD reserved2, IStream **ppstm)
{
    HRESULT hr = _EnsureStorage(grfMode);
    if (SUCCEEDED(hr))
    {
        ASSERTMSG(_pstg != NULL, "no _pstg in OpenStream");
        hr = _pstg->OpenStream(pszRel, reserved1, grfMode, reserved2, ppstm);
    }
    return hr;
}

HRESULT CStgFolder::OpenStorage(LPCWSTR pszRel, IStorage *pstgPriority, DWORD grfMode, SNB snbExclude, DWORD reserved, IStorage **ppstg)
{
    HRESULT hr = _EnsureStorage(grfMode);
    if (SUCCEEDED(hr))
    {
        ASSERTMSG(_pstg != NULL, "no _pstg in OpenStorage");
        hr = _pstg->OpenStorage(pszRel, pstgPriority, grfMode, snbExclude, reserved, ppstg);
    }
    return hr;
}

HRESULT CStgFolder::DestroyElement(LPCWSTR pszRel)
{
    HRESULT hr = _EnsureStorage(_dwMode);
    if (SUCCEEDED(hr))
    {
        ASSERTMSG(_pstg != NULL, "no _pstg in DestroyElement"); 

        LPITEMIDLIST pidl;
        BOOL fFolder;
        hr = _AllocIDList(pszRel, &pidl, &fFolder);
        if (SUCCEEDED(hr))
        {
            LPITEMIDLIST pidlAbs;
            hr = SHILCombine(_pidl, pidl, &pidlAbs);
            if (SUCCEEDED(hr))
            {
                hr = _pstg->DestroyElement(pszRel);
                if (SUCCEEDED(hr))
                    SHChangeNotify(fFolder ? SHCNE_RMDIR : SHCNE_DELETE, SHCNF_IDLIST, pidlAbs, NULL);
                ILFree(pidlAbs);
            }
            ILFree(pidl);
        }
    }
    return hr;
}


HRESULT CStgFolder::RenameElement(LPCWSTR pwcsOldName, LPCWSTR pwcsNewName)
{
    HRESULT hr = _EnsureStorage(_dwMode);
    if (SUCCEEDED(hr))
    {
        ASSERTMSG(_pstg != NULL, "no _pstg in RenameElement"); 

        LPITEMIDLIST pidlOld;
        BOOL fFolder;
        hr = _AllocIDList(pwcsOldName, &pidlOld, &fFolder);
        if (SUCCEEDED(hr))
        {
            LPITEMIDLIST pidlAbsOld;
            hr = SHILCombine(_pidl, pidlOld, &pidlAbsOld);
            if (SUCCEEDED(hr))
            {
                hr = _pstg->RenameElement(pwcsOldName, pwcsNewName);
                if (SUCCEEDED(hr))
                {
                    LPITEMIDLIST pidlNew;
                    hr = _AllocIDList(pwcsNewName, &pidlNew, NULL);
                    if (SUCCEEDED(hr))
                    {
                        LPITEMIDLIST pidlAbsNew;
                        hr = SHILCombine(_pidl, pidlNew, &pidlAbsNew);
                        if (SUCCEEDED(hr))
                        {
                            SHChangeNotify(fFolder ? SHCNE_RENAMEFOLDER : SHCNE_RENAMEITEM, SHCNF_IDLIST, pidlAbsOld, pidlAbsNew);
                            ILFree(pidlAbsNew);
                        }
                        ILFree(pidlNew);
                    }
                }
                ILFree(pidlAbsOld);
            }
            ILFree(pidlOld);
        }
    }
    return hr;
}


HRESULT CStgFolder::SetElementTimes(LPCWSTR pszRel, const FILETIME *pctime, const FILETIME *patime, const FILETIME *pmtime)
{
    HRESULT hr = _EnsureStorage(_dwMode);
    if (SUCCEEDED(hr))
    {
        ASSERTMSG(_pstg != NULL, "no _pstg in SetElementTimes"); 

        hr = _pstg->SetElementTimes(pszRel, pctime, patime, pmtime);
        if (SUCCEEDED(hr))
        {
            LPITEMIDLIST pidl;
            BOOL fFolder;
            hr = _AllocIDList(pszRel, &pidl, &fFolder);
            if (SUCCEEDED(hr))
            {
                LPITEMIDLIST pidlAbs;
                hr = SHILCombine(_pidl, pidl, &pidlAbs);
                if (SUCCEEDED(hr))
                {
                    SHChangeNotify(fFolder ? SHCNE_UPDATEDIR : SHCNE_UPDATEITEM, SHCNF_IDLIST, pidlAbs, NULL);
                    ILFree(pidlAbs);
                }
                ILFree(pidl);
            }
        }
    }
    return hr;
}


HRESULT CStgFolder::CopyTo(DWORD ciidExclude, const IID *rgiidExclude, SNB snbExclude, IStorage *pstgDest)
{
    HRESULT hr = _EnsureStorage(_dwMode);
    if (SUCCEEDED(hr))
    {
        ASSERTMSG(_pstg != NULL, "no _pstg in CopyTo"); 

        hr = _pstg->CopyTo(ciidExclude, rgiidExclude, snbExclude, pstgDest);
    }
    return hr;
}


HRESULT CStgFolder::MoveElementTo(LPCWSTR pszRel, IStorage *pstgDest, LPCWSTR pwcsNewName, DWORD grfFlags)
{
    HRESULT hr = _EnsureStorage(_dwMode);
    if (SUCCEEDED(hr))
    {
        ASSERTMSG(_pstg != NULL, "no _pstg in MoveElementTo"); 

        hr = _pstg->MoveElementTo(pszRel, pstgDest, pwcsNewName, grfFlags);
    }
    return hr;
}


HRESULT CStgFolder::CreateStream(LPCWSTR pwcsName, DWORD grfMode, DWORD res1, DWORD res2, IStream **ppstm)
{
    HRESULT hr = _EnsureStorage(grfMode);
    if (SUCCEEDED(hr))
    {
        ASSERTMSG(_pstg != NULL, "no _pstg in CreateStream"); 

        hr = _pstg->CreateStream(pwcsName, grfMode, res1, res2, ppstm);
        if (SUCCEEDED(hr))
            hr = _pstg->Commit(STGC_DEFAULT);
        if (SUCCEEDED(hr))
        {
            LPITEMIDLIST pidl;
            hr = _AllocIDList(pwcsName, &pidl, NULL);
            if (SUCCEEDED(hr))
            {
                LPITEMIDLIST pidlAbs;
                hr = SHILCombine(_pidl, pidl, &pidlAbs);
                if (SUCCEEDED(hr))
                {
                    SHChangeNotify(SHCNE_CREATE, SHCNF_IDLIST, pidlAbs, NULL);
                    ILFree(pidlAbs);
                }
                ILFree(pidl);
            }
        }
    }
    return hr;
}


HRESULT CStgFolder::CreateStorage(LPCWSTR pwcsName, DWORD grfMode, DWORD res1, DWORD res2, IStorage **ppstg)
{
    HRESULT hr = _EnsureStorage(grfMode);
    if (SUCCEEDED(hr))
    {
        ASSERTMSG(_pstg != NULL, "no _pstg in CreateStorage"); 

        hr = _pstg->CreateStorage(pwcsName, grfMode, res1, res2, ppstg);
        if (SUCCEEDED(hr))
            hr = _pstg->Commit(STGC_DEFAULT);
        if (SUCCEEDED(hr))
        {
            LPITEMIDLIST pidl;
            hr = _AllocIDList(pwcsName, &pidl, NULL);
            if (SUCCEEDED(hr))
            {
                LPITEMIDLIST pidlAbs;
                hr = SHILCombine(_pidl, pidl, &pidlAbs);
                if (SUCCEEDED(hr))
                {
                    SHChangeNotify(SHCNE_MKDIR, SHCNF_IDLIST, pidlAbs, NULL);
                    ILFree(pidlAbs);
                }
                ILFree(pidl);
            }
        }
    }
    return hr;
}

// IPersistStorage
HRESULT CStgFolder::IsDirty(void)
{
    return E_NOTIMPL;
}

HRESULT CStgFolder::InitNew(IStorage *pStg)
{
    return E_NOTIMPL;
}

HRESULT CStgFolder::Load(IStorage *pStg)
{
    IUnknown_Set((IUnknown **)&_pstgLoad, (IUnknown *)pStg);
    return S_OK;
}

HRESULT CStgFolder::Save(IStorage *pStgSave, BOOL fSameAsLoad)
{
    return E_NOTIMPL;
}

HRESULT CStgFolder::SaveCompleted(IStorage *pStgNew)
{
    return E_NOTIMPL;
}

HRESULT CStgFolder::HandsOffStorage(void)
{
    return E_NOTIMPL;
}

    
// Enumerator object for storages

class CStgEnum : public IEnumIDList
{
public:
    CStgEnum(CStgFolder* prf, DWORD grfFlags);
    ~CStgEnum();

    // IUnknown
    STDMETHODIMP QueryInterface(REFIID riid, void **ppv);
    STDMETHODIMP_(ULONG) AddRef();
    STDMETHODIMP_(ULONG) Release();

    // IEnumIDList
    STDMETHODIMP Next(ULONG celt, LPITEMIDLIST *rgelt, ULONG *pceltFetched);
    STDMETHODIMP Skip(ULONG celt) 
        { return E_NOTIMPL; };
    STDMETHODIMP Reset()
        { ATOMICRELEASE(_pEnum); return S_OK; };
    STDMETHODIMP Clone(IEnumIDList **ppenum) 
        { return E_NOTIMPL; };

private:
    LONG _cRef;
    CStgFolder* _pstgf;
    DWORD _grfFlags;
    IEnumSTATSTG *_pEnum;
};


STDAPI CStgEnum_CreateInstance(CStgFolder *pstgf, DWORD grfFlags, IEnumIDList **ppenum)
{
    CStgEnum *penum = new CStgEnum(pstgf, grfFlags);
    if (!penum)
        return E_OUTOFMEMORY;

    HRESULT hr = penum->QueryInterface(IID_PPV_ARG(IEnumIDList, ppenum));
    penum->Release();
    return hr;
}

CStgEnum::CStgEnum(CStgFolder *pstgf, DWORD grfFlags) :
    _cRef(1), _pstgf(pstgf), _grfFlags(grfFlags)
{
    _pstgf->AddRef();
}

CStgEnum::~CStgEnum()
{
    ATOMICRELEASE(_pEnum);
    _pstgf->Release();
}


STDMETHODIMP_(ULONG) CStgEnum::AddRef()
{
    return InterlockedIncrement(&_cRef);
}


STDMETHODIMP_(ULONG) CStgEnum::Release()
{
    if (InterlockedDecrement(&_cRef))
        return _cRef;

    delete this;
    return 0;
}

HRESULT CStgEnum::QueryInterface(REFIID riid, void **ppv)
{
    static const QITAB qit[] = 
    {
        QITABENT(CStgEnum, IEnumIDList),                    // IID_IEnumIDList
        { 0 },
    };
    return QISearch(this, qit, riid, ppv);
}


HRESULT CStgEnum::Next(ULONG celt, LPITEMIDLIST *rgelt, ULONG *pceltFetched)
{
    HRESULT hr = S_OK;

    // do we have an enumerator, if not then lets get one from the 
    // storage object

    if (!_pEnum)
    {
        // we need to reopen docfile storages to get a new enumerator
        // because they keep giving us a stale one.
        // if we don't close to get a new enumerator, when we delete a file
        // the SHCNE_UPDATEDIR wont work because we'll spit out the same
        // pidls that should have been deleted.
        // can we get around this?
        _pstgf->_CloseStorage();

        hr = _pstgf->_EnsureStorage(STGM_READ);
        if (SUCCEEDED(hr))
            hr = _pstgf->_pstg->EnumElements(0, NULL, 0, &_pEnum);
    }

    // now return items, if all is good and we have stuff to pass back.
    
    for (UINT cItems = 0; (cItems != celt) && SUCCEEDED(hr) && (hr != S_FALSE) ; )
    {
        STATSTG statstg = { 0 };
        hr = _pEnum->Next(1, &statstg, NULL);
        if (SUCCEEDED(hr) && (hr != S_FALSE))
        {
            BOOL fFolder;
            LPITEMIDLIST pidl;

            hr = _pstgf->_AllocIDList(statstg, &pidl, &fFolder);
            CoTaskMemFree(statstg.pwcsName);

            if (SUCCEEDED(hr))
            {
                if (fFolder)
                {
                    if (!(_grfFlags & SHCONTF_FOLDERS))
                    {
                        ILFree(pidl);
                        continue;
                    }
                }
                else if (!(_grfFlags & SHCONTF_NONFOLDERS))
                {
                    ILFree(pidl);
                    continue;
                }

                rgelt[cItems++] = pidl;         // return the idlist
            }
        }
    }

    if (hr == S_FALSE)
        ATOMICRELEASE(_pEnum);

    if (pceltFetched)
        *pceltFetched = cItems;

    return hr;
}


// Drop target object


class CStgDropTarget : public IDropTarget
{
public:
    CStgDropTarget(CStgFolder *pstgf, HWND hwnd);
    ~CStgDropTarget();

    // IUnknown
    STDMETHODIMP QueryInterface(REFIID riid, void **ppv);
    STDMETHODIMP_(ULONG) AddRef(void);
    STDMETHODIMP_(ULONG) Release(void);

    // IDropTarget
    STDMETHODIMP DragEnter(IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);
    STDMETHODIMP DragOver(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);
    STDMETHODIMP DragLeave();
    STDMETHODIMP Drop(IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);

private:
    LONG _cRef;

    CStgFolder *_pstgf;
    HWND _hwnd;                     // EVIL: used as a site and UI host
    IDataObject *_pdtobj;           // used durring DragOver() and DoDrop(), don't use on background thread

    UINT _idCmd;
    DWORD _grfKeyStateLast;         // for previous DragOver/Enter
    DWORD _dwEffectLastReturned;    // stashed effect that's returned by base class's dragover
    DWORD _dwEffectPreferred;       // if dwData & DTID_PREFERREDEFFECT

    DWORD _GetDropEffect(DWORD *pdwEffect, DWORD grfKeyState);
    HRESULT _Transfer(IDataObject *pdtobj, UINT uiCmd);
};

CStgDropTarget::CStgDropTarget(CStgFolder *pstgf, HWND hwnd) :
    _cRef(1),
    _pstgf(pstgf),
    _hwnd(hwnd),
    _grfKeyStateLast(-1)
{
    _pstgf->AddRef();
}

CStgDropTarget::~CStgDropTarget()
{
    DragLeave();
    ATOMICRELEASE(_pstgf);
}

STDMETHODIMP_(ULONG) CStgDropTarget::AddRef()
{
    return InterlockedIncrement(&_cRef);
}

STDMETHODIMP_(ULONG) CStgDropTarget::Release()
{
    if (InterlockedDecrement(&_cRef))
        return _cRef;

    delete this;
    return 0;
}

HRESULT CStgDropTarget::QueryInterface(REFIID riid, void**ppv)
{
    static const QITAB qit[] = {
        QITABENT(CStgDropTarget, IDropTarget),
        { 0 },
    };
    return QISearch(this, qit, riid,ppv);
}

STDAPI CStgDropTarget_CreateInstance(CStgFolder *pstgf, HWND hwnd, IDropTarget **ppdt)
{
    CStgDropTarget *psdt = new CStgDropTarget(pstgf, hwnd);
    if (!psdt)
        return E_OUTOFMEMORY;

    HRESULT hr = psdt->QueryInterface(IID_PPV_ARG(IDropTarget, ppdt));
    psdt->Release();
    return hr;
}

#if 0
HRESULT StorageFromDataObj(IDataObject *pdtobj, IShellFolder **ppsf, IStorage **ppstg)
{
    *ppsf = NULL;
    *ppstg = NULL;

    HRESULT hr = E_FAIL;
    STGMEDIUM medium = {0};
    LPIDA pida = DataObj_GetHIDA(pdtobj, &medium);
    if (pida)
    {
        if (SUCCEEDED(SHBindToObject(NULL, IID_X_PPV_ARG(IShellFolder, IDA_GetIDListPtr(pida, (UINT)-1), ppsf))))
        {
            // for (UINT i = 0; i < pida->cidl; i++) 
            for (UINT i = 0; i < 1; i++) 
            {
                hr = (*ppsf)->BindToObject(IDA_GetIDListPtr(pida, i), NULL, IID_PPV_ARG(IStorage, ppstg));
                if (FAILED(hr))
                {
                    (*ppsf)->Release();
                    *ppsf = NULL;
                }
            }
        }
        HIDA_ReleaseStgMedium(pida, &medium);
    }
    return hr;
}
#endif

HRESULT CStgDropTarget::_Transfer(IDataObject *pdtobj, UINT uiCmd)
{
#if 0
    IShellFolder *psf;
    IStorage *pstg;
    HRESULT hr = StorageFromDataObj(pdtobj, &psf, &pstg);
    if (SUCCEEDED(hr))
    {
        DWORD grfModeCreated = STGM_READWRITE;
        HRESULT hr = _pstgf->_EnsureStorage(grfModeCreated);
        if (SUCCEEDED(hr))
        {
            hr = pstg->CopyTo(0, NULL, 0, _pstgf->_pstg);
            if (SUCCEEDED(hr))
            {
                hr = _pstgf->_pstg->Commit(STGC_DEFAULT);
            }
            SHChangeNotify(SHCNE_UPDATEDIR, SHCNF_IDLIST|SHCNF_FLUSH|SHCNF_FLUSHNOWAIT, _pstgf->_pidl, NULL);
        }
        pstg->Release();
        psf->Release();
    }
#else
    HRESULT hr;
    STGMEDIUM medium = {0};
    LPIDA pida = DataObj_GetHIDA(pdtobj, &medium);
    if (pida)
    {
        IShellFolder *psf;
        hr = SHBindToObjectEx(NULL, IDA_GetIDListPtr(pida, (UINT)-1), NULL, IID_PPV_ARG(IShellFolder, &psf));
        if (SUCCEEDED(hr))
        {
            IStorage *pstgSrc;
            hr = psf->QueryInterface(IID_PPV_ARG(IStorage, &pstgSrc));
            if (SUCCEEDED(hr))
            {
                hr = _pstgf->_EnsureStorage(STGM_READWRITE);
                if (SUCCEEDED(hr))
                {
                    for (UINT i = 0; i < pida->cidl; i++) 
                    {
                        WCHAR szName[MAX_PATH];
                        hr = DisplayNameOf(psf, IDA_GetIDListPtr(pida, i), SHGDN_FORPARSING | SHGDN_INFOLDER, szName, ARRAYSIZE(szName));
                        if (SUCCEEDED(hr))
                        {
                            DWORD grfFlags = (uiCmd == DDIDM_COPY) ? STGMOVE_COPY : STGMOVE_MOVE;
                            hr = pstgSrc->MoveElementTo(szName, _pstgf->_pstg, szName, grfFlags);
                            if (SUCCEEDED(hr))
                                hr = _pstgf->_pstg->Commit(STGC_DEFAULT);
                        }
                    }
                }
                pstgSrc->Release();
            }
            psf->Release();
        }
        HIDA_ReleaseStgMedium(pida, &medium);
        SHChangeNotify(SHCNE_UPDATEDIR, SHCNF_IDLIST|SHCNF_FLUSH|SHCNF_FLUSHNOWAIT, _pstgf->_pidl, NULL);
    }
    else
        hr = E_FAIL;
#endif
    return hr;
}

DWORD CStgDropTarget::_GetDropEffect(DWORD *pdwEffect, DWORD grfKeyState)
{
    DWORD dwEffectReturned = DROPEFFECT_NONE;
    switch (grfKeyState & (MK_CONTROL | MK_SHIFT | MK_ALT))
    {
    case MK_CONTROL:            dwEffectReturned = DROPEFFECT_COPY; break;
    case MK_SHIFT:              dwEffectReturned = DROPEFFECT_MOVE; break;
    case MK_SHIFT | MK_CONTROL: dwEffectReturned = DROPEFFECT_LINK; break;
    case MK_ALT:                dwEffectReturned = DROPEFFECT_LINK; break;
    
    default:
        {
            // no modifier keys:
            // if the data object contains a preferred drop effect, try to use it
            DWORD dwPreferred = DataObj_GetDWORD(_pdtobj, g_cfPreferredDropEffect, DROPEFFECT_NONE) & *pdwEffect;
            if (dwPreferred)
            {
                if (dwPreferred & DROPEFFECT_MOVE)
                {
                    dwEffectReturned = DROPEFFECT_MOVE;
                }
                else if (dwPreferred & DROPEFFECT_COPY)
                {
                    dwEffectReturned = DROPEFFECT_COPY;
                }
                else if (dwPreferred & DROPEFFECT_LINK)
                {
                    dwEffectReturned = DROPEFFECT_LINK;
                }
            }
            else
            {
                dwEffectReturned = DROPEFFECT_COPY;
            }
        }
        break;
    }
    return dwEffectReturned;
}


STDMETHODIMP CStgDropTarget::DragEnter(IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
{
    IUnknown_Set((IUnknown **)&_pdtobj, pdtobj);

    _grfKeyStateLast = grfKeyState;

    if (pdwEffect)
        *pdwEffect = _dwEffectLastReturned = _GetDropEffect(pdwEffect, grfKeyState);

    return S_OK;
}


STDMETHODIMP CStgDropTarget::DragOver(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
{
    // has the key state changed?  if not then lets return the previously cached 
    // version, otherwise recompute.

    if (_grfKeyStateLast == grfKeyState)
    {
        if (*pdwEffect)
            *pdwEffect = _dwEffectLastReturned;
    }
    else if (*pdwEffect)
    {
        *pdwEffect = _GetDropEffect(pdwEffect, grfKeyState);
    }

    _dwEffectLastReturned = *pdwEffect;
    _grfKeyStateLast = grfKeyState;

    return S_OK;
}

 
STDMETHODIMP CStgDropTarget::DragLeave()
{
    ATOMICRELEASE(_pdtobj);
    return S_OK;
}

STDMETHODIMP CStgDropTarget::Drop(IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
{
    *pdwEffect = DROPEFFECT_NONE;           // incase of failure

    // determine the type of operation to performed, if the right button is down
    // then lets display the menu, otherwise base it on the drop effect

    UINT idCmd = 0;                             // Choice from drop popup menu
    if (!(_grfKeyStateLast & MK_LBUTTON))
    {
        HMENU hMenu = SHLoadPopupMenu(HINST_THISDLL, POPUP_NONDEFAULTDD);
        if (!hMenu)
        {
            DragLeave();
            return E_FAIL;
        }
        
        SetMenuDefaultItem(hMenu, POPUP_NONDEFAULTDD, FALSE);
        idCmd = TrackPopupMenu(hMenu, 
                               TPM_RETURNCMD|TPM_RIGHTBUTTON|TPM_LEFTALIGN,
                               pt.x, pt.y, 0, _hwnd, NULL);
        DestroyMenu(hMenu);
    }
    else
    {
        switch (_GetDropEffect(pdwEffect, grfKeyState))
        {
        case DROPEFFECT_COPY:   idCmd = DDIDM_COPY; break;
        case DROPEFFECT_MOVE:   idCmd = DDIDM_MOVE; break;
        case DROPEFFECT_LINK:   idCmd = DDIDM_LINK; break;
        }
    }

    // now perform the operation, based on the command ID we have.

    HRESULT hr = E_FAIL;
    switch (idCmd)
    {
    case DDIDM_COPY:
    case DDIDM_MOVE:
        hr = _Transfer(pdtobj, idCmd);
        if (SUCCEEDED(hr))
            *pdwEffect = (idCmd == DDIDM_COPY) ? DROPEFFECT_COPY : DROPEFFECT_MOVE;
        else
            *pdwEffect = 0;
        break;

    case DDIDM_LINK:
    {
        WCHAR wzPath[MAX_PATH];
        SHGetNameAndFlags(_pstgf->_pidl, SHGDN_FORPARSING, wzPath, ARRAYSIZE(wzPath), NULL);

        hr = SHCreateLinks(_hwnd, wzPath, pdtobj, 0, NULL);
        break;
    }
    }
    
    // success so lets populate the new changes to the effect

    if (SUCCEEDED(hr) && *pdwEffect)
    {
        DataObj_SetDWORD(pdtobj, g_cfLogicalPerformedDropEffect, *pdwEffect);
        DataObj_SetDWORD(pdtobj, g_cfPerformedDropEffect, *pdwEffect);
    }

    DragLeave();
    return hr;
}