windows-xp/Source/XPSP1/NT/shell/shell32/fsdrptgt.cpp

#include "shellprv.h"
#include <cowsite.h>
#include "datautil.h"
#include "ids.h"
#include "defview.h"
#include "_security.h"
#include "shitemid.h"
#include "idlcomm.h"
#include "bitbuck.h"
#include "bookmk.h"
#include "filefldr.h"
#include "brfcase.h"
#include "copy.h"
#include "filetbl.h"

#define TF_DRAGDROP 0x04000000


typedef struct
{
    HWND    hwnd;
    DWORD   dwFlags;
    POINTL  pt;
    CHAR    szUrl[INTERNET_MAX_URL_LENGTH];
} ADDTODESKTOP;


DWORD CALLBACK AddToActiveDesktopThreadProc(void *pv)
{
    ADDTODESKTOP* pToAD = (ADDTODESKTOP*)pv;
    CHAR szFilePath[MAX_PATH];
    DWORD cchFilePath = SIZECHARS(szFilePath);
    BOOL fAddComp = TRUE;

    if (SUCCEEDED(PathCreateFromUrlA(pToAD->szUrl, szFilePath, &cchFilePath, 0)))
    {
        TCHAR szPath[MAX_PATH];

        SHAnsiToTChar(szFilePath, szPath, ARRAYSIZE(szPath));

        // If the Url is in the Temp directory
        if (PathIsTemporary(szPath))
        {
            if (IDYES == ShellMessageBox(g_hinst, pToAD->hwnd, MAKEINTRESOURCE(IDS_REASONS_URLINTEMPDIR),
                MAKEINTRESOURCE(IDS_AD_NAME), MB_YESNO | MB_ICONQUESTION))
            {
                TCHAR szFilter[64], szTitle[64];
                TCHAR szFilename[MAX_PATH];
                LPTSTR psz;
                OPENFILENAME ofn = { 0 };

                LoadString(g_hinst, IDS_ALLFILESFILTER, szFilter, ARRAYSIZE(szFilter));
                LoadString(g_hinst, IDS_SAVEAS, szTitle, ARRAYSIZE(szTitle));

                psz = szFilter;

                //Strip out the # and make them Nulls for SaveAs Dialog
                while (*psz)
                {
                    if (*psz == (WCHAR)('#'))
                        *psz = (WCHAR)('\0');
                    psz++;
                }

                lstrcpy(szFilename, PathFindFileName(szPath));

                ofn.lStructSize = sizeof(OPENFILENAME);
                ofn.hwndOwner = pToAD->hwnd;
                ofn.hInstance = g_hinst;
                ofn.lpstrFilter = szFilter;
                ofn.lpstrFile = szFilename;
                ofn.nMaxFile = ARRAYSIZE(szFilename);
                ofn.lpstrTitle = szTitle;
                ofn.Flags = OFN_EXPLORER | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT | OFN_PATHMUSTEXIST;

                if (GetSaveFileName(&ofn))
                {
                    SHFILEOPSTRUCT sfo = { 0 };

                    szPath[lstrlen(szPath) + 1] = 0;
                    ofn.lpstrFile[lstrlen(ofn.lpstrFile) + 1] = 0;

                    sfo.hwnd = pToAD->hwnd;
                    sfo.wFunc = FO_COPY;
                    sfo.pFrom = szPath;
                    sfo.pTo = ofn.lpstrFile;

                    cchFilePath = SIZECHARS(szPath);
                    if (SHFileOperation(&sfo) == 0 &&
                        SUCCEEDED(UrlCreateFromPath(szPath, szPath, &cchFilePath, 0)))
                    {
                        SHTCharToAnsi(szPath, pToAD->szUrl, ARRAYSIZE(pToAD->szUrl));
                    }
                    else
                        fAddComp = FALSE;
                }
                else
                    fAddComp = FALSE;
            }
            else
                fAddComp = FALSE;
        }
    }
    if (fAddComp)
        CreateDesktopComponents(pToAD->szUrl, NULL, pToAD->hwnd, pToAD->dwFlags, pToAD->pt.x, pToAD->pt.y);

    LocalFree((HLOCAL)pToAD);

    return 0;
}

typedef struct {
    DWORD        dwDefEffect;
    IDataObject *pdtobj;
    POINTL       pt;
    DWORD *      pdwEffect;
    HKEY         rghk[MAX_ASSOC_KEYS];
    DWORD        ck;
    HMENU        hmenu;
    UINT         idCmd;
    DWORD        grfKeyState;
} FSDRAGDROPMENUPARAM;

typedef struct
{
    HMENU   hMenu;
    UINT    uCopyPos;
    UINT    uMovePos;
    UINT    uLinkPos;
} FSMENUINFO;


class CFSDropTarget : CObjectWithSite, public IDropTarget
{
public:
    // 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);

    CFSDropTarget(CFSFolder *pFolder, HWND hwnd);

protected:
    virtual ~CFSDropTarget();
    BOOL _IsBriefcaseTarget() { return IsEqualCLSID(_pFolder->_clsidBind, CLSID_BriefcaseFolder); };

    BOOL _IsDesktopFolder() { return _GetIDList() && ILIsEmpty(_GetIDList()); };
    
    HRESULT _FilterFileContents(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                                   DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo);
    HRESULT _FilterFileContentsOLEHack(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                                   DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo);
    HRESULT _FilterDeskCompHDROP(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                                    DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo);
    HRESULT _FilterSneakernetBriefcase(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                                DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo);
    HRESULT _FilterBriefcase(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                                        DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo);
    HRESULT _FilterHDROP(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                            DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo);
    HRESULT _FilterHIDA(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                           DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo);
    HRESULT _FilterDeskImage(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                                DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo);
    HRESULT _FilterDeskComp(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                               DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo);
    HRESULT _FilterOlePackage(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                                 DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo);
    HRESULT _FilterOleObj(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                             DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo);
    HRESULT _FilterOleLink(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                              DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo);
    
    DWORD _FilesystemAdjustedDefaultEffect(DWORD dwCurEffectAvail);
    HRESULT _GetPath(LPTSTR pszPath);
    LPCITEMIDLIST _GetIDList();
    DWORD _LimitDefaultEffect(DWORD dwDefEffect, DWORD dwEffectsAllowed);
    DWORD _GetDefaultEffect(DWORD grfKeyState, DWORD dwCurEffectAvail, DWORD dwAllEffectAvail, DWORD dwOrigDefEffect);
    DWORD _DetermineEffects(DWORD grfKeyState, DWORD *pdwEffectInOut, HMENU hmenu);
    DWORD _EffectFromFolder();

    typedef struct
    {
        CFSDropTarget *pThis;
        IStream *pstmDataObj;
        IStream *pstmFolderView;
    } DROPTHREADPARAMS;

    static void _FreeThreadParams(DROPTHREADPARAMS *pdtp);

    static DWORD CALLBACK _DoDropThreadProc(void *pv);
    void _DoDrop(IDataObject *pdtobj, IFolderView* pfv);
    static void _AddVerbs(DWORD* pdwEffects, DWORD dwEffectAvail, DWORD dwDefEffect,
                          UINT idCopy, UINT idMove, UINT idLink,
                          DWORD dwForceEffect, FSMENUINFO* pfsMenuInfo);
    void _FixUpDefaultItem(HMENU hmenu, DWORD dwDefEffect);
    HRESULT _DragDropMenu(FSDRAGDROPMENUPARAM *pddm);

    HRESULT _CreatePackage(IDataObject *pdtobj);
    HRESULT _CreateURLDeskComp(IDataObject *pdtobj, POINTL pt);
    HRESULT _CreateDeskCompImage(IDataObject *pdtobj, POINTL pt);
    void _GetStateFromSite();
    BOOL _IsFromSneakernetBriefcase();
    BOOL _IsFromSameBriefcase();
    void _MoveCopy(IDataObject *pdtobj, IFolderView* pfv, HDROP hDrop);
    void _MoveSelectIcons(IDataObject *pdtobj, IFolderView* pfv, void *hNameMap, LPCTSTR pszFiles, BOOL fMove, HDROP hDrop);

    LONG            _cRef;
    CFSFolder       *_pFolder;
    HWND            _hwnd;                  // EVIL: used as a site and UI host
    UINT            _idCmd;
    DWORD           _grfKeyStateLast;       // for previous DragOver/Enter
    IDataObject     *_pdtobj;               // used durring Dragover() and DoDrop(), don't use on background thread
    DWORD           _dwEffectLastReturned;  // stashed effect that's returned by base class's dragover
    DWORD           _dwEffect;
    DWORD           _dwData;                // DTID_*
    DWORD           _dwEffectPreferred;     // if dwData & DTID_PREFERREDEFFECT
    DWORD           _dwEffectFolder;        // folder desktop.ini preferred effect
    BOOL            _fSameHwnd;             // the drag source and target are the same folder
    BOOL            _fDragDrop;             // 
    BOOL            _fUseExactDropPoint;    // Don't transform the drop point. The target knows exactly where it wants things.
    BOOL            _fBkDropTarget;
    POINT           _ptDrop;
    IFolderView*    _pfv;

    typedef struct {
        FORMATETC fmte;
        HRESULT (CFSDropTarget::*pfnGetDragDropInfo)(
                                      IN FORMATETC* pfmte,
                                      IN DWORD grfKeyFlags,
                                      IN DWORD dwEffectsAvail,
                                      IN OUT DWORD* pdwEffectsUsed,
                                      OUT DWORD* pdwDefaultEffect,
                                      IN OUT FSMENUINFO* pfsMenuInfo);
        CLIPFORMAT *pcfInit;
    } _DATA_HANDLER;

    // HACKHACK:  C++ doesn't let you initialize statics inside a class
    //            definition, and also doesn't let you specify an empty
    //            size (i.e., rg_data_handlers[]) inside a class definition
    //            either, so we have to have this bogus NUM_DATA_HANDLERS
    //            symbol that must manually be kept in sync.

    enum { NUM_DATA_HANDLERS = 16 };
    static _DATA_HANDLER rg_data_handlers[NUM_DATA_HANDLERS];
    static void _Init_rg_data_handlers();

private:
    friend HRESULT CFSDropTarget_CreateInstance(CFSFolder* pFolder, HWND hwnd, IDropTarget** ppdt);
};

CFSDropTarget::CFSDropTarget(CFSFolder *pFolder, HWND hwnd) : _cRef(1), _hwnd(hwnd), _pFolder(pFolder), _dwEffectFolder(-1)
{
    ASSERT(0 == _grfKeyStateLast);
    ASSERT(NULL == _pdtobj);
    ASSERT(0 == _dwEffectLastReturned);
    ASSERT(0 == _dwData);
    ASSERT(0 == _dwEffectPreferred);
    _pFolder->AddRef();
}

CFSDropTarget::~CFSDropTarget()
{
    AssertMsg(_pdtobj == NULL, TEXT("didn't get matching DragLeave, fix that bug"));

    ATOMICRELEASE(_pdtobj);
    ATOMICRELEASE(_pfv);

    _pFolder->Release();
}

STDAPI CFSDropTarget_CreateInstance(CFSFolder* pFolder, HWND hwnd, IDropTarget** ppdt)
{
    *ppdt = new CFSDropTarget(pFolder, hwnd);
    return *ppdt ? S_OK : E_OUTOFMEMORY;
}

HRESULT CFSDropTarget::QueryInterface(REFIID riid, void** ppvObj)
{
    static const QITAB qit[] = {
        QITABENT(CFSDropTarget, IDropTarget),
        QITABENT(CFSDropTarget, IObjectWithSite),
        QITABENTMULTI2(CFSDropTarget, IID_IDropTargetWithDADSupport, IDropTarget),
        { 0 },
    };
    return QISearch(this, qit, riid, ppvObj);
}

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

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

    delete this;
    return 0;
}

void CFSDropTarget::_FreeThreadParams(DROPTHREADPARAMS *pdtp)
{
    pdtp->pThis->Release();
    ATOMICRELEASE(pdtp->pstmDataObj);
    ATOMICRELEASE(pdtp->pstmFolderView);
    LocalFree(pdtp);
}


// compute DTID_ bit flags from the data object to make format testing easier for
// DragOver() and Drop() code

STDAPI GetClipFormatFlags(IDataObject *pdtobj, DWORD *pdwData, DWORD *pdwEffectPreferred)
{
    *pdwData = 0;
    *pdwEffectPreferred = 0;

    if (pdtobj)
    {
        IEnumFORMATETC *penum;
        if (SUCCEEDED(pdtobj->EnumFormatEtc(DATADIR_GET, &penum)))
        {
            FORMATETC fmte;
            ULONG celt;
            while (S_OK == penum->Next(1, &fmte, &celt))
            {
                if (fmte.cfFormat == CF_HDROP && (fmte.tymed & TYMED_HGLOBAL))
                    *pdwData |= DTID_HDROP;

                if (fmte.cfFormat == g_cfHIDA && (fmte.tymed & TYMED_HGLOBAL))
                    *pdwData |= DTID_HIDA;

                if (fmte.cfFormat == g_cfNetResource && (fmte.tymed & TYMED_HGLOBAL))
                    *pdwData |= DTID_NETRES;

                if (fmte.cfFormat == g_cfEmbeddedObject && (fmte.tymed & TYMED_ISTORAGE))
                    *pdwData |= DTID_EMBEDDEDOBJECT;

                if (fmte.cfFormat == g_cfFileContents && (fmte.tymed & (TYMED_HGLOBAL | TYMED_ISTREAM | TYMED_ISTORAGE)))
                    *pdwData |= DTID_CONTENTS;
                
                if (fmte.cfFormat == g_cfFileGroupDescriptorA && (fmte.tymed & TYMED_HGLOBAL))
                    *pdwData |= DTID_FDESCA;

                if (fmte.cfFormat == g_cfFileGroupDescriptorW && (fmte.tymed & TYMED_HGLOBAL))
                    *pdwData |= DTID_FDESCW;

                if ((fmte.cfFormat == g_cfPreferredDropEffect) &&
                    (fmte.tymed & TYMED_HGLOBAL) &&
                    (DROPEFFECT_NONE != (*pdwEffectPreferred = DataObj_GetDWORD(pdtobj, g_cfPreferredDropEffect, DROPEFFECT_NONE))))
                {
                    *pdwData |= DTID_PREFERREDEFFECT;
                }
#ifdef DEBUG
                TCHAR szFormat[MAX_PATH];
                if (GetClipboardFormatName(fmte.cfFormat, szFormat, ARRAYSIZE(szFormat)))
                {
                    TraceMsg(TF_DRAGDROP, "CFSDropTarget - cf %s, tymed %d", szFormat, fmte.tymed);
                }
                else
                {
                    TraceMsg(TF_DRAGDROP, "CFSDropTarget - cf %d, tymed %d", fmte.cfFormat, fmte.tymed);
                }
#endif // DEBUG
                SHFree(fmte.ptd);
            }
            penum->Release();
        }

        //
        // HACK:
        // Win95 always did the GetData below which can be quite expensive if
        // the data is a directory structure on an ftp server etc.
        // dont check for FD_LINKUI if the data object has a preferred effect
        //
        if ((*pdwData & (DTID_PREFERREDEFFECT | DTID_CONTENTS)) == DTID_CONTENTS)
        {
            if (*pdwData & DTID_FDESCA)
            {
                FORMATETC fmteRead = {g_cfFileGroupDescriptorA, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
                STGMEDIUM medium = {0};
                if (S_OK == pdtobj->GetData(&fmteRead, &medium))
                {
                    FILEGROUPDESCRIPTORA * pfgd = (FILEGROUPDESCRIPTORA *)GlobalLock(medium.hGlobal);
                    if (pfgd)
                    {
                        if (pfgd->cItems >= 1)
                        {
                            if (pfgd->fgd[0].dwFlags & FD_LINKUI)
                                *pdwData |= DTID_FD_LINKUI;
                        }
                        GlobalUnlock(medium.hGlobal);
                    }
                    ReleaseStgMedium(&medium);
                }
            }
            else if (*pdwData & DTID_FDESCW)
            {
                FORMATETC fmteRead = {g_cfFileGroupDescriptorW, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
                STGMEDIUM medium = {0};
                if (S_OK == pdtobj->GetData(&fmteRead, &medium))
                {
                    FILEGROUPDESCRIPTORW * pfgd = (FILEGROUPDESCRIPTORW *)GlobalLock(medium.hGlobal);
                    if (pfgd)
                    {
                        if (pfgd->cItems >= 1)
                        {
                            if (pfgd->fgd[0].dwFlags & FD_LINKUI)
                                *pdwData |= DTID_FD_LINKUI;
                        }
                        GlobalUnlock(medium.hGlobal);
                    }
                    ReleaseStgMedium(&medium);
                }
            }
        }

        if (S_OK == OleQueryCreateFromData(pdtobj))
            *pdwData |= DTID_OLEOBJ;

        if (S_OK == OleQueryLinkFromData(pdtobj))
            *pdwData |= DTID_OLELINK;
    }
    return S_OK;    // for now always succeeds
}

STDMETHODIMP CFSDropTarget::DragEnter(IDataObject* pdtobj, DWORD grfKeyState, POINTL pt, DWORD* pdwEffect)
{
    ASSERT(NULL == _pdtobj);    // req DragDrop protocol, someone forgot to call DragLeave

    // init our registerd data formats
    IDLData_InitializeClipboardFormats();

    _grfKeyStateLast = grfKeyState;
    IUnknown_Set((IUnknown **)&_pdtobj, pdtobj);

    GetClipFormatFlags(_pdtobj, &_dwData, &_dwEffectPreferred);

    *pdwEffect = _dwEffectLastReturned = _DetermineEffects(grfKeyState, pdwEffect, NULL);
    return S_OK;
}

STDMETHODIMP CFSDropTarget::DragOver(DWORD grfKeyState, POINTL pt, DWORD* pdwEffect)
{
    if (_grfKeyStateLast != grfKeyState)
    {
        _grfKeyStateLast = grfKeyState;
        *pdwEffect = _dwEffectLastReturned = _DetermineEffects(grfKeyState, pdwEffect, NULL);
    }
    else
    {
        *pdwEffect = _dwEffectLastReturned;
    }
    return S_OK;
}

STDMETHODIMP CFSDropTarget::DragLeave()
{
    IUnknown_Set((IUnknown **)&_pdtobj, NULL);
    return S_OK;
}


// init data from our site that we will need in processing the drop

void CFSDropTarget::_GetStateFromSite()
{
    IShellFolderView* psfv;

    if (SUCCEEDED(IUnknown_QueryService(_punkSite, SID_SFolderView, IID_PPV_ARG(IShellFolderView, &psfv))))
    {
        _fSameHwnd = S_OK == psfv->IsDropOnSource((IDropTarget*)this);
        _fDragDrop = S_OK == psfv->GetDropPoint(&_ptDrop);
        _fBkDropTarget = S_OK == psfv->IsBkDropTarget(NULL);

        psfv->QueryInterface(IID_PPV_ARG(IFolderView, &_pfv));

        psfv->Release();
    }
}

STDMETHODIMP CFSDropTarget::Drop(IDataObject* pdtobj, DWORD grfKeyState, POINTL pt, DWORD* pdwEffect)
{
    // OLE may give us a different data object (fully marshalled)
    // from the one we've got on DragEnter (this is not the case on Win2k, this is a nop)

    IUnknown_Set((IUnknown **)&_pdtobj, pdtobj);

    _GetStateFromSite();

    // note, that on the drop the mouse buttons are not down so the grfKeyState
    // is not what we saw on the DragOver/DragEnter, thus we need to cache
    // the grfKeyState to detect left vs right drag
    //
    // ASSERT(this->grfKeyStateLast == grfKeyState);

    HMENU hmenu = SHLoadPopupMenu(HINST_THISDLL, POPUP_TEMPLATEDD);
    DWORD dwDefEffect = _DetermineEffects(grfKeyState, pdwEffect, hmenu);
    if (DROPEFFECT_NONE == dwDefEffect)
    {
        *pdwEffect = DROPEFFECT_NONE;
        DAD_SetDragImage(NULL, NULL);
        IUnknown_Set((IUnknown **)&_pdtobj, NULL);
        return S_OK;
    }

    TCHAR szPath[MAX_PATH];
    _GetPath(szPath);

    // this doesn't actually do the menu if (grfKeyState MK_LBUTTON)

    FSDRAGDROPMENUPARAM ddm;
    ddm.dwDefEffect = dwDefEffect;
    ddm.pdtobj = pdtobj;
    ddm.pt = pt;
    ddm.pdwEffect = pdwEffect;
    ddm.ck = SHGetAssocKeysForIDList(_GetIDList(), ddm.rghk, ARRAYSIZE(ddm.rghk));
    ddm.hmenu = hmenu;
    ddm.grfKeyState = grfKeyState;

    HRESULT hr = _DragDropMenu(&ddm);

    SHRegCloseKeys(ddm.rghk, ddm.ck);

    DestroyMenu(hmenu);

    if (hr == S_FALSE)
    {
        // let callers know where this is about to go
        // SHScrap cares because it needs to close the file so we can copy/move it
        DataObj_SetDropTarget(pdtobj, &CLSID_ShellFSFolder);

        switch (ddm.idCmd)
        {
        case DDIDM_CONTENTS_DESKCOMP:
            hr = CreateDesktopComponents(NULL, pdtobj, _hwnd, 0, ddm.pt.x, ddm.pt.y);
            break;

        case DDIDM_CONTENTS_DESKURL:
            hr = _CreateURLDeskComp(pdtobj, ddm.pt);
            break;

        case DDIDM_CONTENTS_DESKIMG:
            hr = _CreateDeskCompImage(pdtobj, ddm.pt);
            break;

        case DDIDM_CONTENTS_COPY:
        case DDIDM_CONTENTS_MOVE:
        case DDIDM_CONTENTS_LINK:
            hr = CFSFolder_AsyncCreateFileFromClip(_hwnd, szPath, pdtobj, pt, pdwEffect, _fBkDropTarget);
            break;

        case DDIDM_SCRAP_COPY:
        case DDIDM_SCRAP_MOVE:
        case DDIDM_DOCLINK:
            hr = SHCreateBookMark(_hwnd, szPath, pdtobj, pt, pdwEffect);
            break;

        case DDIDM_OBJECT_COPY:
        case DDIDM_OBJECT_MOVE:
            hr = _CreatePackage(pdtobj);
            if (E_UNEXPECTED == hr)
            {
                // _CreatePackage() can only expand certain types of packages
                // back into files.  For example, it doesn't handle CMDLINK files.
                //
                // If _CreatePackage() didn't recognize the stream format, we fall
                // back to SHCreateBookMark(), which should create a scrap:
                hr = SHCreateBookMark(_hwnd, szPath, pdtobj, pt, pdwEffect);
            }
            break;

        case DDIDM_COPY:
        case DDIDM_SYNCCOPY:
        case DDIDM_SYNCCOPYTYPE:
        case DDIDM_MOVE:
        case DDIDM_LINK:

            _dwEffect = *pdwEffect;
            _idCmd = ddm.idCmd;

            if (DataObj_CanGoAsync(pdtobj) || DataObj_GoAsyncForCompat(pdtobj))
            {
                // create another thread to avoid blocking the source thread.
                DROPTHREADPARAMS *pdtp;
                hr = SHLocalAlloc(sizeof(*pdtp), &pdtp);
                if (SUCCEEDED(hr))
                {
                    pdtp->pThis = this;
                    pdtp->pThis->AddRef();

                    CoMarshalInterThreadInterfaceInStream(IID_IDataObject, pdtobj, &pdtp->pstmDataObj);
                    CoMarshalInterThreadInterfaceInStream(IID_IFolderView,   _pfv, &pdtp->pstmFolderView);

                    if (SHCreateThread(_DoDropThreadProc, pdtp, CTF_COINIT, NULL))
                    {
                        hr = S_OK;
                    }
                    else
                    {
                        _FreeThreadParams(pdtp);
                        hr = E_OUTOFMEMORY;
                    }
                }
            }
            else
            {
                _DoDrop(pdtobj, _pfv);   // synchronously
            }


            // in these CF_HDROP cases "Move" is always an optimized move, we delete the
            // source. make sure we don't return DROPEFFECT_MOVE so the source does not 
            // try to do this too... 
            // even if we have not done anything yet since we may have 
            // kicked of a thread to do this
            
            DataObj_SetDWORD(pdtobj, g_cfLogicalPerformedDropEffect, *pdwEffect);            
            if (DROPEFFECT_MOVE == *pdwEffect)
                *pdwEffect = DROPEFFECT_NONE;
            break;
        }
    }

    IUnknown_Set((IUnknown **)&_pdtobj, NULL);  // don't use this any more

    if (FAILED(hr))
        *pdwEffect = DROPEFFECT_NONE;

    ASSERT(*pdwEffect==DROPEFFECT_COPY || 
           *pdwEffect==DROPEFFECT_LINK || 
           *pdwEffect==DROPEFFECT_MOVE || 
           *pdwEffect==DROPEFFECT_NONE);
    return hr;
}

void CFSDropTarget::_AddVerbs(DWORD* pdwEffects, DWORD dwEffectAvail, DWORD dwDefEffect,
                              UINT idCopy, UINT idMove, UINT idLink,
                              DWORD dwForceEffect, FSMENUINFO* pfsMenuInfo)
{
    ASSERT(pdwEffects);
    MENUITEMINFO mii;
    TCHAR szCmd[MAX_PATH];
    if (NULL != pfsMenuInfo)
    {
        mii.cbSize = sizeof(mii);
        mii.dwTypeData = szCmd;
        mii.fMask = MIIM_ID | MIIM_TYPE | MIIM_STATE | MIIM_DATA;
        mii.fType = MFT_STRING;
    }
    if ((DROPEFFECT_COPY == (DROPEFFECT_COPY & dwEffectAvail)) &&
        ((0 == (*pdwEffects & DROPEFFECT_COPY)) || (dwForceEffect & DROPEFFECT_COPY)))
    {
        ASSERT(0 != idCopy);
        if (NULL != pfsMenuInfo)
        {
            LoadString(HINST_THISDLL, idCopy + IDS_DD_FIRST, szCmd, ARRAYSIZE(szCmd));
            mii.fState = MFS_ENABLED | ((DROPEFFECT_COPY == dwDefEffect) ? MFS_DEFAULT : 0);
            mii.wID = idCopy;
            mii.dwItemData = DROPEFFECT_COPY;
            InsertMenuItem(pfsMenuInfo->hMenu, pfsMenuInfo->uCopyPos, TRUE, &mii);
            pfsMenuInfo->uCopyPos++;
            pfsMenuInfo->uMovePos++;
            pfsMenuInfo->uLinkPos++;
        }
    }
    if ((DROPEFFECT_MOVE == (DROPEFFECT_MOVE & dwEffectAvail)) &&
        ((0 == (*pdwEffects & DROPEFFECT_MOVE)) || (dwForceEffect & DROPEFFECT_MOVE)))
    {
        ASSERT(0 != idMove);
        if (NULL != pfsMenuInfo)
        {
            LoadString(HINST_THISDLL, idMove + IDS_DD_FIRST, szCmd, ARRAYSIZE(szCmd));
            mii.fState = MFS_ENABLED | ((DROPEFFECT_MOVE == dwDefEffect) ? MFS_DEFAULT : 0);
            mii.wID = idMove;
            mii.dwItemData = DROPEFFECT_MOVE;
            InsertMenuItem(pfsMenuInfo->hMenu, pfsMenuInfo->uMovePos, TRUE, &mii);
            pfsMenuInfo->uMovePos++;
            pfsMenuInfo->uLinkPos++;
        }
    }
    if ((DROPEFFECT_LINK == (DROPEFFECT_LINK & dwEffectAvail)) &&
        ((0 == (*pdwEffects & DROPEFFECT_LINK)) || (dwForceEffect & DROPEFFECT_LINK)))
    {
        ASSERT(0 != idLink);
        if (NULL != pfsMenuInfo)
        {
            LoadString(HINST_THISDLL, idLink + IDS_DD_FIRST, szCmd, ARRAYSIZE(szCmd));
            mii.fState = MFS_ENABLED | ((DROPEFFECT_LINK == dwDefEffect) ? MFS_DEFAULT : 0);
            mii.wID = idLink;
            mii.dwItemData = DROPEFFECT_LINK;
            InsertMenuItem(pfsMenuInfo->hMenu, pfsMenuInfo->uLinkPos, TRUE, &mii);
            pfsMenuInfo->uLinkPos++;
        }
    }
    *pdwEffects |= dwEffectAvail;
}

// determine the default drop effect (move/copy/link) from the file type
//
// HKCR\.cda "DefaultDropEffect" = 4   // DROPEFFECT_LINK

DWORD EffectFromFileType(IDataObject *pdtobj)
{
    DWORD dwDefEffect = DROPEFFECT_NONE; // 0

    LPITEMIDLIST pidl;
    if (SUCCEEDED(PidlFromDataObject(pdtobj, &pidl)))
    {
        IQueryAssociations *pqa;
        if (SUCCEEDED(SHGetAssociations(pidl, (void **)&pqa)))
        {
            DWORD cb = sizeof(dwDefEffect);
            pqa->GetData(0, ASSOCDATA_VALUE, L"DefaultDropEffect", &dwDefEffect, &cb);
            pqa->Release();
        }
        ILFree(pidl);
    }

    return dwDefEffect;
}

// compute the default effect based on 
//      the allowed effects
//      the keyboard state, 
//      the preferred effect that might be in the data object
//      and previously computed default effect (if the above yields nothing)

DWORD CFSDropTarget::_GetDefaultEffect(DWORD grfKeyState, DWORD dwCurEffectAvail, DWORD dwAllEffectAvail, DWORD dwOrigDefEffect)
{
    DWORD dwDefEffect = 0;
    //
    // keyboard, (explicit user input) gets first crack
    //
    switch (grfKeyState & (MK_CONTROL | MK_SHIFT | MK_ALT))
    {
    case MK_CONTROL:
        dwDefEffect = DROPEFFECT_COPY;
        break;

    case MK_SHIFT:
        dwDefEffect = DROPEFFECT_MOVE;
        break;

    case MK_SHIFT | MK_CONTROL:
    case MK_ALT:
        dwDefEffect = DROPEFFECT_LINK;
        break;

    default: // no modifier keys case
        // if the data object contains a preferred drop effect, try to use it
        DWORD dwPreferred = DataObj_GetDWORD(_pdtobj, g_cfPreferredDropEffect, DROPEFFECT_NONE) & dwAllEffectAvail;

        if (DROPEFFECT_NONE == dwPreferred)
        {
            dwPreferred = EffectFromFileType(_pdtobj) & dwAllEffectAvail;
        }

        if (dwPreferred)
        {
            if (dwPreferred & DROPEFFECT_MOVE)
            {
                dwDefEffect = DROPEFFECT_MOVE;
            }
            else if (dwPreferred & DROPEFFECT_COPY)
            {
                dwDefEffect = DROPEFFECT_COPY;
            }
            else if (dwPreferred & DROPEFFECT_LINK)
            {
                dwDefEffect = DROPEFFECT_LINK;
            }
        }
        else
        {
            dwDefEffect = dwOrigDefEffect;
        }
        break;
    }
    return dwDefEffect & dwCurEffectAvail;
}

HRESULT CFSDropTarget::_FilterDeskCompHDROP(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                                            DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo)
{
    ASSERT(pdwEffects);
    HRESULT hr = S_FALSE;
    
    if (!PolicyNoActiveDesktop() &&
        !SHRestricted(REST_NOADDDESKCOMP) &&
        _IsDesktopFolder())
    {
        hr = IsDeskCompHDrop(_pdtobj);
        if (S_OK == hr)
        {
            DWORD dwDefEffect = 0;
            DWORD dwEffectAdd = dwEffectsAvail & DROPEFFECT_LINK;
            if (pdwDefaultEffect)
            {
                dwDefEffect = _GetDefaultEffect(grfKeyFlags, dwEffectAdd, dwEffectsAvail, DROPEFFECT_LINK);
                *pdwDefaultEffect = dwDefEffect;
            }
            
            _AddVerbs(pdwEffects, dwEffectAdd, dwDefEffect, 0, 0, DDIDM_CONTENTS_DESKCOMP,
                      DROPEFFECT_LINK, // force add the DDIDM_CONTENTS_DESKCOMP verb
                      pfsMenuInfo);
        }
    }
    return hr;
}

// see if a PIDL is scoped by a briefcaes

BOOL IsBriefcaseOrChild(LPCITEMIDLIST pidlIn)
{
    BOOL bRet = FALSE;
    LPITEMIDLIST pidl = ILClone(pidlIn);
    if (pidl)
    {
        do
        {
            CLSID clsid;
            if (SUCCEEDED(GetCLSIDFromIDList(pidl, &clsid)) &&
                IsEqualCLSID(clsid, CLSID_Briefcase))
            {
                bRet = TRUE;    // it is a briefcase
                break;
            }
        } while (ILRemoveLastID(pidl));
        ILFree(pidl);
    }
    return bRet;
}

// returns true if the data object represents items in a sneakernet briefcase
// (briefcase on removable media)

BOOL CFSDropTarget::_IsFromSneakernetBriefcase()
{
    BOOL bRet = FALSE;  // assume no

    if (!_IsBriefcaseTarget())
    {
        STGMEDIUM medium = {0};
        LPIDA pida = DataObj_GetHIDA(_pdtobj, &medium);
        if (pida)
        {
            LPCITEMIDLIST pidlFolder = IDA_GetIDListPtr(pida, (UINT)-1);
            TCHAR szSource[MAX_PATH];
            if (SHGetPathFromIDList(pidlFolder, szSource))
            {
                // is source on removable device?
                if (!PathIsUNC(szSource) && IsRemovableDrive(DRIVEID(szSource)))
                {
                    TCHAR szTarget[MAX_PATH];
                    _GetPath(szTarget);

                    // is the target fixed media?
                    if (PathIsUNC(szTarget) || !IsRemovableDrive(DRIVEID(szTarget)))
                    {
                        bRet = IsBriefcaseOrChild(pidlFolder);
                    }
                }
            }
            HIDA_ReleaseStgMedium(pida, &medium);
        }
    }
    return bRet;
}

// TRUE if any folders are in hdrop

BOOL DroppingAnyFolders(HDROP hDrop)
{
    TCHAR szPath[MAX_PATH];
    
    for (UINT i = 0; DragQueryFile(hDrop, i, szPath, ARRAYSIZE(szPath)); i++)
    {
        if (PathIsDirectory(szPath))
            return TRUE;
    }
    return FALSE;
}

// sneakernet case:
//      dragging a file/folder from a briefcase on removable media. we special case this
//  and use this as a chance to connect up this target folder with the content of the briefcase

HRESULT CFSDropTarget::_FilterSneakernetBriefcase(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                                                  DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo)
{
    ASSERT(pdwEffects);

    if (_IsFromSneakernetBriefcase())
    {
        // Yes; show the non-default briefcase cm
        STGMEDIUM medium = {0};
        FORMATETC fmte = {CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
        if (SUCCEEDED(_pdtobj->GetData(&fmte, &medium)))
        {
            DWORD dwDefEffect = 0;
            DWORD dwEffectAdd = DROPEFFECT_COPY & dwEffectsAvail;
            if (pdwDefaultEffect)
            {
                dwDefEffect = _GetDefaultEffect(grfKeyFlags, dwEffectAdd, dwEffectsAvail, DROPEFFECT_COPY);
                *pdwDefaultEffect = dwDefEffect;
            }
            
            _AddVerbs(pdwEffects, dwEffectAdd, dwDefEffect, DDIDM_SYNCCOPY, 0, 0, 0, pfsMenuInfo);

            // Call _AddVerbs() again to force "Sync Copy of Type" as a 2nd DROPEFFECT_COPY verb:
            if ((DROPEFFECT_COPY & dwEffectsAvail) && 
                DroppingAnyFolders((HDROP)medium.hGlobal))
            {
                _AddVerbs(pdwEffects, DROPEFFECT_COPY, 0,
                          DDIDM_SYNCCOPYTYPE, 0, 0, DROPEFFECT_COPY, pfsMenuInfo);
            }
            
            ReleaseStgMedium(&medium);
        }
    }
    return S_OK;
}

// returns true if the data object represents items from the same briefcase
// as this drop target
BOOL CFSDropTarget::_IsFromSameBriefcase()
{
    BOOL bRet = FALSE;

    STGMEDIUM medium;
    FORMATETC fmteBrief = {g_cfBriefObj, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
    
    // Yes; are they from the same briefcase as the target?
    if (SUCCEEDED(_pdtobj->GetData(&fmteBrief, &medium)))
    {
        BriefObj *pbo = (BriefObj *)GlobalLock(medium.hGlobal);

        TCHAR szBriefPath[MAX_PATH], szPath[MAX_PATH];
        lstrcpy(szBriefPath, BOBriefcasePath(pbo));
        lstrcpy(szPath, BOFileList(pbo));   // first file in list

        TCHAR szPathTgt[MAX_PATH];
        _GetPath(szPathTgt);

        int cch = PathCommonPrefix(szPath, szPathTgt, NULL);
        bRet = (0 < cch) && (lstrlen(szBriefPath) <= cch);
        
        GlobalUnlock(medium.hGlobal);
        ReleaseStgMedium(&medium);
    }
    return bRet;
}

// briefcase drop target specific handling gets computed here

HRESULT CFSDropTarget::_FilterBriefcase(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                                        DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo)
{
    if (_IsBriefcaseTarget() && !_IsFromSameBriefcase())
    {
        STGMEDIUM medium = {0};
        FORMATETC fmte = {CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
        if (SUCCEEDED(_pdtobj->GetData(&fmte, &medium)))
        {
            DWORD dwDefEffect = DROPEFFECT_COPY;
            DWORD dwEffectAdd = DROPEFFECT_COPY & dwEffectsAvail;
            if (pdwDefaultEffect)
            {
                dwDefEffect = _GetDefaultEffect(grfKeyFlags, dwEffectAdd, dwEffectsAvail, DROPEFFECT_COPY);
                *pdwDefaultEffect = dwDefEffect;
            }
            
            _AddVerbs(pdwEffects, dwEffectAdd, dwDefEffect, DDIDM_SYNCCOPY, 0, 0, 0, pfsMenuInfo);

            // Call _AddVerbs() again to force "Sync Copy of Type" as a 2nd DROPEFFECT_COPY verb:
            if ((DROPEFFECT_COPY & dwEffectsAvail) && 
                DroppingAnyFolders((HDROP)medium.hGlobal))
            {
                _AddVerbs(pdwEffects, DROPEFFECT_COPY, 0,
                          DDIDM_SYNCCOPYTYPE, 0, 0, DROPEFFECT_COPY, pfsMenuInfo);
            }
            
            ReleaseStgMedium(&medium);
        }
    }
    return S_OK;
}


HRESULT CFSDropTarget::_FilterHDROP(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                                    DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo)
{
    ASSERT(pdwEffects);

    DWORD dwDefEffect = 0;
    DWORD dwEffectAdd = dwEffectsAvail & (DROPEFFECT_COPY | DROPEFFECT_MOVE);
    if (pdwDefaultEffect)
    {
        dwDefEffect = _GetDefaultEffect(grfKeyFlags, dwEffectAdd, dwEffectsAvail, _FilesystemAdjustedDefaultEffect(dwEffectAdd));
        *pdwDefaultEffect = dwDefEffect;
    }
    
    _AddVerbs(pdwEffects, dwEffectAdd, dwDefEffect, DDIDM_COPY, DDIDM_MOVE, 0, 0, pfsMenuInfo);

    return S_OK;
}

HRESULT CFSDropTarget::_FilterFileContents(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                                           DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo)
{
    ASSERT(pdwEffects);
    
    if ((_dwData & (DTID_CONTENTS | DTID_FDESCA)) == (DTID_CONTENTS | DTID_FDESCA) ||
        (_dwData & (DTID_CONTENTS | DTID_FDESCW)) == (DTID_CONTENTS | DTID_FDESCW))
    {
        DWORD dwEffectAdd, dwSuggestedEffect;
        //
        // HACK: if there is a preferred drop effect and no HIDA
        // then just take the preferred effect as the available effects
        // this is because we didn't actually check the FD_LINKUI bit
        // back when we assembled dwData! (performance)
        //
        if ((_dwData & (DTID_PREFERREDEFFECT | DTID_HIDA)) == DTID_PREFERREDEFFECT)
        {
            dwEffectAdd = _dwEffectPreferred;
            dwSuggestedEffect = _dwEffectPreferred;
        }
        else if (_dwData & DTID_FD_LINKUI)
        {
            dwEffectAdd = DROPEFFECT_LINK;
            dwSuggestedEffect = DROPEFFECT_LINK;
        }
        else
        {
            dwEffectAdd = DROPEFFECT_COPY | DROPEFFECT_MOVE;
            dwSuggestedEffect = DROPEFFECT_COPY;
        }
        dwEffectAdd &= dwEffectsAvail;

        DWORD dwDefEffect = 0;
        if (pdwDefaultEffect)
        {
            dwDefEffect = _GetDefaultEffect(grfKeyFlags, dwEffectAdd, dwEffectsAvail, dwSuggestedEffect);
            *pdwDefaultEffect = dwDefEffect;
        }

        _AddVerbs(pdwEffects, dwEffectAdd, dwDefEffect,
                  DDIDM_CONTENTS_COPY, DDIDM_CONTENTS_MOVE, DDIDM_CONTENTS_LINK,
                  0, pfsMenuInfo);
    }
    return S_OK;
}

//
//  Old versions of OLE have a bug where if two FORMATETCs use the same
//  CLIPFORMAT, then only the first one makes it to the IEnumFORMATETC,
//  even if the other parameters (such as DVASPECT) are different.
//
//  This causes us problems because those other DVASPECTs might be useful.
//  So if we see a FileContents with the wrong DVASPECT, sniff at the
//  object to see if maybe it also contains a copy with the correct DVASPECT.
//
//  This bug was fixed in 1996 on the NT side, but the Win9x side was
//  not fixed.  The Win9x OLE team was disbanded before the fix could
//  be propagated.  So we get to work around this OLE bug forever.
//
HRESULT CFSDropTarget::_FilterFileContentsOLEHack(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                                                  DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo)
{
    FORMATETC fmte = *pfmte;
    fmte.dwAspect = DVASPECT_CONTENT;

    //
    //  Whoa, this test is so (intentionally) backwards it isn't funny.
    //
    //  We want to see whether there is a DVASPECT_CONTENT available in
    //  the real object.  So we first ask the object if it has a
    //  DVASPECT_CONTENT format already.  If the answer is yes, then we
    //  **skip** this FORMATETC, because it will be found (or has already
    //  been found) by our big EnumFORMATETC loop.
    //
    //  If the answer is NO, then maybe we're hitting an OLE bug.
    //  (They cache the list of available formats, but the bug is that
    //  their cache is broken.)  Bypass the cache by actually getting the
    //  data.  If it works, then run with it.  Otherwise, I guess OLE wasn't
    //  kidding.
    //
    //  Note that we do not GetData() unconditionally -- bad for perf.
    //  Only call GetData() after all the easy tests have failed.
    //

    HRESULT hr = _pdtobj->QueryGetData(&fmte);
    if (hr == DV_E_FORMATETC)
    {
        // Maybe we are hitting the OLE bug.  Try harder.
        STGMEDIUM stgm = {0};
        if (SUCCEEDED(_pdtobj->GetData(&fmte, &stgm)))
        {
            // Yup.  OLE lied to us.
            ReleaseStgMedium(&stgm);

            hr = _FilterFileContents(&fmte, grfKeyFlags, dwEffectsAvail,
                                        pdwEffects, pdwDefaultEffect, pfsMenuInfo);
        }
        else
        {
            // Whaddya know, OLE was telling the truth.  Do nothing with this
            // format.
            hr = S_OK;
        }
    }
    else
    {
        // Either QueryGetData() failed in some bizarre way
        // (in which case we ignore the problem) or the QueryGetData
        // succeeded, in which case we ignore this FORMATETC since
        // the big enumeration will find (or has already found) the
        // DVASPECT_CONTENT.
        hr = S_OK;
    }

    return hr;
}

HRESULT CFSDropTarget::_FilterHIDA(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                                   DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo)
{
    ASSERT(pdwEffects);

    DWORD dwDefEffect = 0;
    DWORD dwEffectAdd = DROPEFFECT_LINK & dwEffectsAvail;
    // NOTE: we only add a HIDA default effect if HDROP isn't going to add a default
    // effect.  This preserves shell behavior with file system data objects without
    // requiring us to change the enumerator order in CIDLDataObj.  When we do change
    // the enumerator order, we can remove this special case:
    if (pdwDefaultEffect &&
        ((0 == (_dwData & DTID_HDROP)) ||
         (0 == _GetDefaultEffect(grfKeyFlags,
                                dwEffectsAvail & (DROPEFFECT_COPY | DROPEFFECT_MOVE),
                                dwEffectsAvail,
                                _FilesystemAdjustedDefaultEffect(dwEffectsAvail & (DROPEFFECT_COPY | DROPEFFECT_MOVE))))))
    {
        dwDefEffect = _GetDefaultEffect(grfKeyFlags, dwEffectAdd, dwEffectsAvail, DROPEFFECT_LINK);
        *pdwDefaultEffect = dwDefEffect;
    }
    
    _AddVerbs(pdwEffects, dwEffectAdd, dwDefEffect, 0, 0, DDIDM_LINK, 0, pfsMenuInfo);

    return S_OK;
}

// {F20DA720-C02F-11CE-927B-0800095AE340}
const GUID CLSID_CPackage = {0xF20DA720L, 0xC02F, 0x11CE, 0x92, 0x7B, 0x08, 0x00, 0x09, 0x5A, 0xE3, 0x40};
// old packager guid...
// {0003000C-0000-0000-C000-000000000046}
const GUID CLSID_OldPackage = {0x0003000CL, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46};

HRESULT CFSDropTarget::_FilterOlePackage(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                                            DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo)
{
    ASSERT(pdwEffects);
    HRESULT hr = S_FALSE;

    if (pdwDefaultEffect)
    {
        *pdwDefaultEffect = 0;
    }

    FORMATETC fmte = {g_cfObjectDescriptor, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
    STGMEDIUM medium = {0};
    if (SUCCEEDED(_pdtobj->GetData(&fmte, &medium)))
    {
        // we've got an object descriptor
        OBJECTDESCRIPTOR* pOD = (OBJECTDESCRIPTOR*) GlobalLock(medium.hGlobal);
        if (pOD)
        {
            if (IsEqualCLSID(CLSID_OldPackage, pOD->clsid) ||
                IsEqualCLSID(CLSID_CPackage, pOD->clsid))
            {
                // This is a package - proceed
                DWORD dwDefEffect = 0;
                DWORD dwEffectAdd = (DROPEFFECT_COPY | DROPEFFECT_MOVE) & dwEffectsAvail;
                if (pdwDefaultEffect)
                {
                    dwDefEffect = _GetDefaultEffect(grfKeyFlags, dwEffectAdd, dwEffectsAvail, DROPEFFECT_COPY);
                    *pdwDefaultEffect = dwDefEffect;
                }
                
                _AddVerbs(pdwEffects, dwEffectAdd, dwDefEffect,
                          DDIDM_OBJECT_COPY, DDIDM_OBJECT_MOVE, 0,
                          0, pfsMenuInfo);

                hr = S_OK;
            }
            GlobalUnlock(medium.hGlobal);
        }
        ReleaseStgMedium(&medium);
    }
    return hr;
}

// REARCHITECT:
//    This code has lots of problems.  We need to fix this the text time we touch this code
// outside of ship mode.  TO FIX:
// 1. Use SHAnsiToUnicode(CP_UTF8, ) to convert pszHTML to unicode.  This will allow international
//    paths to work.
// 2. Obey the selected range.
// 3. Use MSHTML to get the image.  You can have trident parse the HTML via IHTMLTxtRange::pasteHTML.
//    MS HTML has a special collection of images.  Ask for the first image in that collection, or
//    the first image in that collection within the selected range.  (#1 isn't needed with this)
BOOL ExtractImageURLFromCFHTML(IN LPSTR pszHTML, IN SIZE_T cbHTMLSize, OUT LPSTR szImg, IN DWORD dwSize)
{
    BOOL fSucceeded = FALSE;

    // To avoid going nuts, only look at the first 64K of the HTML.
    // (Important on Win64 because StrCpyNA doesn't support more than 4GB.)
    if (cbHTMLSize > 0xFFFF)
        cbHTMLSize = 0xFFFF;

    // NT #391669: pszHTML isn't terminated, so terminate it now.
    LPSTR pszCopiedHTML = (LPSTR) LocalAlloc(LPTR, cbHTMLSize + 1);
    if (pszCopiedHTML)
    {
        LPSTR szTemp;
        DWORD dwLen = dwSize;
        BOOL  bRet = TRUE;

        StrCpyNA(pszCopiedHTML, pszHTML, (int)(cbHTMLSize + 1));

        //DANGER WILL ROBINSON:
        // HTML is comming in as UFT-8 encoded. Neither Unicode or Ansi,
        // We've got to do something.... I'm going to party on it as if it were
        // Ansi. This code will choke on escape sequences.....

        //Find the base URL
        //Locate <!--StartFragment-->
        //Read the <IMG SRC="
        //From there to the "> should be the Image URL
        //Determine if it's an absolute or relative URL
        //If relative, append to BASE url. You may need to lop off from the
        // last delimiter to the end of the string.

        //Pull out the SourceURL

        LPSTR szBase = StrStrIA(pszCopiedHTML,"SourceURL:"); // Point to the char after :
        if (szBase)
        {
            szBase += sizeof("SourceURL:")-1;

            //Since each line can be terminated by a CR, CR/LF or LF check each case...
            szTemp = StrChrA(szBase,'\n');
            if (!szTemp)
                szTemp = StrChrA(szBase,'\r');

            if (szTemp)
                *szTemp = '\0';
            szTemp++;
        }
        else
            szTemp = pszCopiedHTML;


        //Pull out the Img Src
        LPSTR pszImgSrc = StrStrIA(szTemp,"IMG");
        if (pszImgSrc != NULL)
        {
            pszImgSrc = StrStrIA(pszImgSrc,"SRC");
            if (pszImgSrc != NULL)
            {
                LPSTR pszImgSrcOrig = pszImgSrc;
                pszImgSrc = StrChrA(pszImgSrc,'\"');
                if (pszImgSrc)
                {
                    pszImgSrc++;     // Skip over the quote at the beginning of the src path.
                    szTemp = StrChrA(pszImgSrc,'\"');    // Find the end of the path.
                }
                else
                {
                    LPSTR pszTemp1;
                    LPSTR pszTemp2;

                    pszImgSrc = StrChrA(pszImgSrcOrig,'=');
                    pszImgSrc++;     // Skip past the equals to the first char in the path.
                                    // Someday we may need to handle spaces between '=' and the path.

                    pszTemp1 = StrChrA(pszImgSrc,' ');   // Since the path doesn't have quotes around it, assume a space will terminate it.
                    pszTemp2 = StrChrA(pszImgSrc,'>');   // Since the path doesn't have quotes around it, assume a space will terminate it.

                    szTemp = pszTemp1;      // Assume quote terminates path.
                    if (!pszTemp1)
                        szTemp = pszTemp2;  // Use '>' if quote not found.

                    if (pszTemp1 && pszTemp2 && (pszTemp2 < pszTemp1))
                        szTemp = pszTemp2;  // Change to having '>' terminate path if both exist and it comes first.
                }

                *szTemp = '\0'; // Terminate path.

                //At this point, I've reduced the 2 important strings. Now see if I need to
                //Join them.

                //If this fails, then we don't have a full URL, Only a relative.
                if (!UrlIsA(pszImgSrc,URLIS_URL) && szBase)
                {
                    if (SUCCEEDED(UrlCombineA(szBase, pszImgSrc, szImg, &dwLen,0)))
                        fSucceeded = TRUE;
                }
                else
                {
                    if (lstrlenA(pszImgSrc) <= (int)dwSize)
                        lstrcpyA(szImg, pszImgSrc);

                    fSucceeded = TRUE;
                }
            }
        }

        LocalFree(pszCopiedHTML);
    }

    return fSucceeded;
}

HRESULT CFSDropTarget::_FilterDeskImage(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                                        DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo)
{
    ASSERT(pdwEffects);
    HRESULT hr = S_FALSE;

    if (pdwDefaultEffect)
    {
        *pdwDefaultEffect = 0;
    }

    if (!PolicyNoActiveDesktop() &&
        !SHRestricted(REST_NOADDDESKCOMP) &&
        _IsDesktopFolder())
    {
        FORMATETC fmte = {g_cfHTML, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
        STGMEDIUM medium = {0};
        if (SUCCEEDED(_pdtobj->GetData(&fmte, &medium)))
        {
            //DANGER WILL ROBINSON:
            //HTML is UTF-8, a mostly ANSI cross of ANSI and Unicode. Play with
            // it as is it were ANSI. Find a way to escape the sequences...
            CHAR *pszData = (CHAR*) GlobalLock(medium.hGlobal);
            if (pszData)
            {
                CHAR szUrl[MAX_URL_STRING];
                if (ExtractImageURLFromCFHTML(pszData, GlobalSize(medium.hGlobal), szUrl, ARRAYSIZE(szUrl)))
                {
                    // The HTML contains an image tag - carry on...
                    DWORD dwDefEffect = 0;
                    DWORD dwEffectAdd = DROPEFFECT_LINK; // NOTE: ignoring dwEffectsAvail!
                    if (pdwDefaultEffect)
                    {
                        dwDefEffect = _GetDefaultEffect(grfKeyFlags, dwEffectAdd,
                                                        dwEffectsAvail | DROPEFFECT_LINK, DROPEFFECT_LINK);
                        *pdwDefaultEffect = dwDefEffect;
                    }
                    
                    _AddVerbs(pdwEffects, dwEffectAdd, dwDefEffect,
                              0, 0, DDIDM_CONTENTS_DESKIMG,
                              0, pfsMenuInfo);

                    hr = S_OK;
                }
                GlobalUnlock(medium.hGlobal);
            }
            ReleaseStgMedium(&medium);
        }
    }
    return hr;
}

HRESULT CFSDropTarget::_FilterDeskComp(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                                       DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo)
{
    ASSERT(pdwEffects);
    HRESULT hr = S_FALSE;

    if (pdwDefaultEffect)
    {
        *pdwDefaultEffect = 0;
    }

    if (!PolicyNoActiveDesktop() &&
        !SHRestricted(REST_NOADDDESKCOMP) &&
        _IsDesktopFolder())
    {
        FORMATETC fmte = {g_cfShellURL, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
        STGMEDIUM medium = {0};
        if (SUCCEEDED(_pdtobj->GetData(&fmte, &medium)))
        {
            // DANGER WILL ROBINSON:
            // HTML is UTF-8, a mostly ANSI cross of ANSI and Unicode. Play with
            // it as is it were ANSI. Find a way to escape the sequences...
            CHAR *pszData = (CHAR*) GlobalLock(medium.hGlobal);
            if (pszData)
            {
                int nScheme = GetUrlSchemeA(pszData);
                if ((nScheme != URL_SCHEME_INVALID) && (nScheme != URL_SCHEME_FTP))
                {
                    // This is an internet scheme - carry on...
                    DWORD dwDefEffect = 0;
                    DWORD dwEffectAdd = DROPEFFECT_LINK & dwEffectsAvail;
                    if (pdwDefaultEffect)
                    {
                        dwDefEffect = _GetDefaultEffect(grfKeyFlags, dwEffectAdd, dwEffectsAvail, DROPEFFECT_LINK);
                        *pdwDefaultEffect = dwDefEffect;
                    }
                    
                    _AddVerbs(pdwEffects, dwEffectAdd, dwDefEffect,
                              0, 0, DDIDM_CONTENTS_DESKURL,
                              DROPEFFECT_LINK, // force add this verb
                              pfsMenuInfo);

                    hr = S_OK;
                }
                GlobalUnlock(medium.hGlobal);
            }
            ReleaseStgMedium(&medium);
        }
    }
    return hr;
}

HRESULT CFSDropTarget::_FilterOleObj(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                                        DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo)
{
    ASSERT(pdwEffects);
    HRESULT hr = S_FALSE;
    
    if (_dwData & DTID_OLEOBJ)
    {
        DWORD dwDefEffect = 0;
        DWORD dwEffectAdd = (DROPEFFECT_COPY | DROPEFFECT_MOVE) & dwEffectsAvail;
        if (pdwDefaultEffect)
        {
            dwDefEffect = _GetDefaultEffect(grfKeyFlags, dwEffectAdd, dwEffectsAvail, DROPEFFECT_COPY);
            *pdwDefaultEffect = dwDefEffect;
        }
    
        _AddVerbs(pdwEffects, dwEffectAdd, dwDefEffect, DDIDM_SCRAP_COPY, DDIDM_SCRAP_MOVE, 0, 0, pfsMenuInfo);

        hr = S_OK;
    }
    return hr;
}

HRESULT CFSDropTarget::_FilterOleLink(FORMATETC* pfmte, DWORD grfKeyFlags, DWORD dwEffectsAvail,
                                         DWORD* pdwEffects, DWORD* pdwDefaultEffect, FSMENUINFO* pfsMenuInfo)
{
    ASSERT(pdwEffects);
    HRESULT hr = S_FALSE;
    
    if (_dwData & DTID_OLELINK)
    {
        DWORD dwDefEffect = 0;
        DWORD dwEffectAdd = DROPEFFECT_LINK & dwEffectsAvail;
        if (pdwDefaultEffect)
        {
            dwDefEffect = _GetDefaultEffect(grfKeyFlags, dwEffectAdd, dwEffectsAvail, DROPEFFECT_LINK);
            *pdwDefaultEffect = dwDefEffect;
        }
    
        _AddVerbs(pdwEffects, dwEffectAdd, dwDefEffect, 0, 0, DDIDM_DOCLINK, 0, pfsMenuInfo);

        hr = S_OK;
    }
    return hr;
}

HRESULT CFSDropTarget::_CreateURLDeskComp(IDataObject *pdtobj, POINTL pt)
{
    // This code should only be entered if DDIDM_CONTENTS_DESKURL was added to the menu,
    // and it has these checks:
    ASSERT(!PolicyNoActiveDesktop() &&
           !SHRestricted(REST_NOADDDESKCOMP) &&
           _IsDesktopFolder());
           
    STGMEDIUM medium = {0};
    FORMATETC fmte = {g_cfShellURL, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
    HRESULT hr = pdtobj->GetData(&fmte, &medium);
    if (SUCCEEDED(hr))
    {
        //DANGER WILL ROBINSON:
        //HTML is UTF-8, a mostly ANSI cross of ANSI and Unicode. Play with
        // it as is it were ANSI. Find a way to escape the sequences...
        CHAR *pszData = (CHAR*) GlobalLock(medium.hGlobal);
        if (pszData)
        {
            int nScheme = GetUrlSchemeA(pszData);
            if ((nScheme != URL_SCHEME_INVALID) && (nScheme != URL_SCHEME_FTP))
            {
                // This is an internet scheme - URL

                hr = CreateDesktopComponents(pszData, NULL, _hwnd, DESKCOMP_URL, pt.x, pt.y);
            }
            GlobalUnlock(medium.hGlobal);
        }
        else
        {
            hr = E_FAIL;
        }
        ReleaseStgMedium(&medium);
    }
    return hr;
}

HRESULT CFSDropTarget::_CreateDeskCompImage(IDataObject *pdtobj, POINTL pt)
{
    ASSERT(!PolicyNoActiveDesktop() &&
           !SHRestricted(REST_NOADDDESKCOMP) &&
           _IsDesktopFolder());
           
    FORMATETC fmte = {g_cfHTML, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
    STGMEDIUM medium = {0};
    HRESULT hr = pdtobj->GetData(&fmte, &medium);
    if (SUCCEEDED(hr))
    {
        //DANGER WILL ROBINSON:
        //HTML is UTF-8, a mostly ANSI cross of ANSI and Unicode. Play with
        // it as is it were ANSI. Find a way to escape the sequences...
        CHAR *pszData = (CHAR*) GlobalLock(medium.hGlobal);
        if (pszData)
        {
            CHAR szUrl[MAX_URL_STRING];
            if (ExtractImageURLFromCFHTML(pszData, GlobalSize(medium.hGlobal), szUrl, ARRAYSIZE(szUrl)))
            {
                // The HTML contains an image tag - carry on...
                ADDTODESKTOP *pToAD;
                hr = SHLocalAlloc(sizeof(*pToAD), &pToAD);
                if (SUCCEEDED(hr))
                {
                    pToAD->hwnd = _hwnd;
                    lstrcpyA(pToAD->szUrl, szUrl);
                    pToAD->dwFlags = DESKCOMP_IMAGE;
                    pToAD->pt = pt;

                    if (SHCreateThread(AddToActiveDesktopThreadProc, pToAD, CTF_COINIT, NULL))
                    {
                        hr = S_OK;
                    }
                    else
                    {
                        LocalFree(pToAD);
                        hr = E_OUTOFMEMORY;
                    }
                }
            }
            else
            {
                hr = E_FAIL;
            }
            GlobalUnlock(medium.hGlobal);
        }
        else
            hr = E_FAIL;
        ReleaseStgMedium(&medium);
    }
    return hr;
}


//
// read byte by byte until we hit the null terminating char
// return: the number of bytes read
//
HRESULT StringReadFromStream(IStream* pstm, LPSTR pszBuf, UINT cchBuf)
{
    UINT cch = 0;
    
    do {
        pstm->Read(pszBuf, sizeof(CHAR), NULL);
        cch++;
    } while (*pszBuf++ && cch <= cchBuf);  
    return cch;
} 

HRESULT CopyStreamToFile(IStream* pstmSrc, LPCTSTR pszFile, ULONGLONG ullFileSize) 
{
    IStream *pstmFile;
    HRESULT hr = SHCreateStreamOnFile(pszFile, STGM_CREATE | STGM_WRITE | STGM_SHARE_DENY_WRITE, &pstmFile);
    if (SUCCEEDED(hr))
    {
        hr = CopyStreamUI(pstmSrc, pstmFile, NULL, ullFileSize);
        pstmFile->Release();
    }
    return hr;
}   

HRESULT CFSDropTarget::_CreatePackage(IDataObject *pdtobj)
{
    ILockBytes* pLockBytes;
    HRESULT hr = CreateILockBytesOnHGlobal(NULL, TRUE, &pLockBytes);
    if (SUCCEEDED(hr))
    {
        STGMEDIUM medium;
        medium.tymed = TYMED_ISTORAGE;
        hr = StgCreateDocfileOnILockBytes(pLockBytes,
                                        STGM_DIRECT | STGM_READWRITE | STGM_CREATE |
                                        STGM_SHARE_EXCLUSIVE, 0, &medium.pstg);
        if (SUCCEEDED(hr))
        {
            FORMATETC fmte = {g_cfEmbeddedObject, NULL, DVASPECT_CONTENT, -1, TYMED_ISTORAGE};
            hr = pdtobj->GetDataHere(&fmte, &medium);
            if (SUCCEEDED(hr))
            {
                IStream* pstm;
#ifdef DEBUG
                STATSTG stat;
                if (SUCCEEDED(medium.pstg->Stat(&stat, STATFLAG_NONAME)))
                {
                    ASSERT(IsEqualCLSID(CLSID_OldPackage, stat.clsid) ||
                           IsEqualCLSID(CLSID_CPackage, stat.clsid));
                }
#endif // DEBUG                        
                #define PACKAGER_ICON           2
                #define PACKAGER_CONTENTS       L"\001Ole10Native"
                #define PACKAGER_EMBED_TYPE     3
                hr = medium.pstg->OpenStream(PACKAGER_CONTENTS, 0,
                                               STGM_DIRECT | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
                                               0, &pstm);
                if (SUCCEEDED(hr))
                {
                    DWORD dw;
                    WORD w;
                    CHAR szName[MAX_PATH];
                    CHAR szTemp[MAX_PATH];
                    if (SUCCEEDED(pstm->Read(&dw, sizeof(dw), NULL)) && // pkg size
                        SUCCEEDED(pstm->Read(&w, sizeof(w), NULL)) &&   // pkg appearance
                        (PACKAGER_ICON == w) &&
                        SUCCEEDED(StringReadFromStream(pstm, szName, ARRAYSIZE(szName))) &&
                        SUCCEEDED(StringReadFromStream(pstm, szTemp, ARRAYSIZE(szTemp))) && // icon path
                        SUCCEEDED(pstm->Read(&w, sizeof(w), NULL)) &&   // icon index
                        SUCCEEDED(pstm->Read(&w, sizeof(w), NULL)) &&   // panetype
                        (PACKAGER_EMBED_TYPE == w) &&
                        SUCCEEDED(pstm->Read(&dw, sizeof(dw), NULL)) && // filename size
                        SUCCEEDED(pstm->Read(szTemp, dw, NULL)) &&      // filename
                        SUCCEEDED(pstm->Read(&dw, sizeof(dw), NULL)))   // get file size
                    {
                        // The rest of the stream is the file contents
                        TCHAR szPath[MAX_PATH], szBase[MAX_PATH], szDest[MAX_PATH];
                        _GetPath(szPath);

                        SHAnsiToTChar(szName, szBase, ARRAYSIZE(szBase));
                        PathAppend(szPath, szBase);
                        PathYetAnotherMakeUniqueName(szDest, szPath, NULL, szBase);
                        TraceMsg(TF_GENERAL, "CFSIDLDropTarget pkg: %s", szDest);

                        hr = CopyStreamToFile(pstm, szDest, dw);

                        if (SUCCEEDED(hr))
                        {
                            SHChangeNotify(SHCNE_CREATE, SHCNF_PATH, szDest, NULL);
                            if (_fBkDropTarget && _hwnd)
                            {
                                PositionFileFromDrop(_hwnd, szDest, NULL);
                            }
                        }
                    }
                    else
                    {
                        hr = E_UNEXPECTED;
                    }
                    pstm->Release();
                }
            }
            medium.pstg->Release();
        }
        pLockBytes->Release();
    }
    return hr;
}

HRESULT CFSDropTarget::_GetPath(LPTSTR pszPath)
{
    return _pFolder->_GetPath(pszPath);
}

LPCITEMIDLIST CFSDropTarget::_GetIDList()
{
    return _pFolder->_GetIDList();
}

DWORD CFSDropTarget::_EffectFromFolder()
{
    if (-1 == _dwEffectFolder)
    {
        _dwEffectFolder = DROPEFFECT_NONE;    // re-set to nothing (0)

        TCHAR szPath[MAX_PATH];
        // add a simple pathisroot check here to prevent it from hitting the disk (mostly floppy)
        // when we want the dropeffect probe to be fast (sendto, hovering over drives in view).
        // its not likely that we'll want to modify the root's drop effect, and this still allows
        // dropeffect modification on floppy subfolders.
        if (SUCCEEDED(_GetPath(szPath)) && !PathIsRoot(szPath) && PathAppend(szPath, TEXT("desktop.ini")))
        {
            _dwEffectFolder = GetPrivateProfileInt(STRINI_CLASSINFO, TEXT("DefaultDropEffect"), 0, szPath);
        }
    }
    return _dwEffectFolder;
}

BOOL AllRegisteredPrograms(HDROP hDrop)
{
    TCHAR szPath[MAX_PATH];

    for (UINT i = 0; DragQueryFile(hDrop, i, szPath, ARRAYSIZE(szPath)); i++)
    {
        if (!PathIsRegisteredProgram(szPath))
            return FALSE;
    }
    return TRUE;
}

BOOL IsBriefcaseRoot(IDataObject *pdtobj)
{
    BOOL bRet = FALSE;
    STGMEDIUM medium;
    LPIDA pida = DataObj_GetHIDA(pdtobj, &medium);
    if (pida)
    {
        // Is there a briefcase root in this pdtobj?
        IShellFolder2 *psf;
        if (SUCCEEDED(SHBindToObject(NULL, IID_X_PPV_ARG(IShellFolder2, IDA_GetIDListPtr(pida, (UINT)-1), &psf))))
        {
            for (UINT i = 0; i < pida->cidl; i++) 
            {
                CLSID clsid;
                bRet = SUCCEEDED(GetItemCLSID(psf, IDA_GetIDListPtr(pida, i), &clsid)) &&
                        IsEqualCLSID(clsid, CLSID_Briefcase);
                if (bRet)
                    break;
            }
            psf->Release();
        }
        HIDA_ReleaseStgMedium(pida, &medium);
    }
    return bRet;
}

//
// the "default effect" defines what will be choosen out of the allowed effects
//
//  If the data object does NOT contain HDROP -> "none"
//  else if the source data object has a default drop effect folder list (maybe based on sub folderness)
//  else if the source is root or registered progam -> "link"
//   else if this is within a volume   -> "move"
//   else if this is a briefcase       -> "move"
//   else                              -> "copy"
//
DWORD CFSDropTarget::_FilesystemAdjustedDefaultEffect(DWORD dwCurEffectAvail)
{
    DWORD dwDefEffect = DROPEFFECT_NONE;

    FORMATETC fmte = {CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
    STGMEDIUM medium = {0};
    if (SUCCEEDED(_pdtobj->GetData(&fmte, &medium)))
    {
        TCHAR szPath[MAX_PATH];
        DragQueryFile((HDROP) medium.hGlobal, 0, szPath, ARRAYSIZE(szPath)); // focused item

        // DROPEFFECTFOLDERLIST allows the source of the data
        // to specify the desired drop effect for items under
        // certain parts of the name space.
        //
        // cd-burning does this to avoid the default move/copy computation
        // that would kick in for cross volume CD burning/staging area transfers

        FORMATETC fmteDropFolders = {g_cfDropEffectFolderList, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
        STGMEDIUM mediumDropFolders = {0};
        if (SUCCEEDED(_pdtobj->GetData(&fmteDropFolders, &mediumDropFolders)))
        {
            DROPEFFECTFOLDERLIST *pdefl = (DROPEFFECTFOLDERLIST*)GlobalLock(mediumDropFolders.hGlobal);
            if (pdefl)
            {
                // get the default effect from the list -- in the staging area case this is DROPEFFECT_COPY
                // so its a copy even if the staging area and source are on the same volume.
                dwDefEffect = pdefl->dwDefaultDropEffect;
                for (INT i = 0; i < pdefl->cFolders; i++)
                {
                    // some folders are excluded, for example if you move a file from one part of the staging
                    // area to another we override (to DROPEFFECT_MOVE in this case).
                    if (PathIsEqualOrSubFolder(pdefl->aFolders[i].wszPath, szPath))
                    {
                        dwDefEffect = pdefl->aFolders[i].dwDropEffect;
                        break;
                    }
                }
                GlobalUnlock(pdefl);          
            }
            ReleaseStgMedium(&mediumDropFolders);
        }

        if (DROPEFFECT_NONE == dwDefEffect)
        {
            dwDefEffect = _EffectFromFolder();
        }

        // If we didn't get a drop effect (==0) then lets fall back to the old checks
        if (DROPEFFECT_NONE == dwDefEffect)
        {
            TCHAR szFolder[MAX_PATH];
            _GetPath(szFolder);

            // drive/UNC roots and installed programs get link
            if (PathIsRoot(szPath) || AllRegisteredPrograms((HDROP)medium.hGlobal))
            {
                dwDefEffect = DROPEFFECT_LINK;
            }
            else if (PathIsSameRoot(szPath, szFolder))
            {
                dwDefEffect = DROPEFFECT_MOVE;
            }
            else if (IsBriefcaseRoot(_pdtobj))
            {
                // briefcase default to move even accross volumes
                dwDefEffect = DROPEFFECT_MOVE;
            }
            else
            {
                dwDefEffect = DROPEFFECT_COPY;
            }
        }
        ReleaseStgMedium(&medium);
    }
    else if (SUCCEEDED(_pdtobj->QueryGetData(&fmte)))
    {
        // but QueryGetData() succeeds!
        // this means this data object has HDROP but can't
        // provide it until it is dropped. Let's assume we are copying.
        dwDefEffect = DROPEFFECT_COPY;
    }

    // Switch default verb if the dwCurEffectAvail hint suggests that we picked an
    // unavailable effect (this code applies to MOVE and COPY only):
    dwCurEffectAvail &= (DROPEFFECT_MOVE | DROPEFFECT_COPY);
    if ((DROPEFFECT_MOVE == dwDefEffect) && (DROPEFFECT_COPY == dwCurEffectAvail))
    {
        // If we were going to return MOVE, and only COPY is available, return COPY:
        dwDefEffect = DROPEFFECT_COPY;
    }
    else if ((DROPEFFECT_COPY == dwDefEffect) && (DROPEFFECT_MOVE == dwCurEffectAvail))
    {
        // If we were going to return COPY, and only MOVE is available, return MOVE:
        dwDefEffect = DROPEFFECT_MOVE;
    }
    return dwDefEffect;
}

//
// make sure that the default effect is among the allowed effects
//
DWORD CFSDropTarget::_LimitDefaultEffect(DWORD dwDefEffect, DWORD dwEffectsAllowed)
{
    if (dwDefEffect & dwEffectsAllowed)
        return dwDefEffect;

    if (dwEffectsAllowed & DROPEFFECT_COPY)
        return DROPEFFECT_COPY;

    if (dwEffectsAllowed & DROPEFFECT_MOVE)
        return DROPEFFECT_MOVE;

    if (dwEffectsAllowed & DROPEFFECT_LINK)
        return DROPEFFECT_LINK;

    return DROPEFFECT_NONE;
}

// Handy abbreviation
#define TYMED_ALLCONTENT        (TYMED_HGLOBAL | TYMED_ISTREAM | TYMED_ISTORAGE)

// Use  FSDH for registered clipboard formats (anything of the form g_cf*)
// Use _FSDH for predefined clipboard formats (like CF_HDROP or 0)
// Generate the _DATA_HANDLER array
#define  FSDH(pfn, cf, dva, tymed) { {              0, NULL, dva, -1, tymed }, pfn, &cf  }
#define _FSDH(pfn, cf, dva, tymed) { { (CLIPFORMAT)cf, NULL, dva, -1, tymed }, pfn, NULL }

// NOTE: the order is important (particularly for multiple entries with the same FORMATETC)

CFSDropTarget::_DATA_HANDLER
CFSDropTarget::rg_data_handlers[NUM_DATA_HANDLERS] = {
    FSDH(_FilterFileContents,        g_cfFileGroupDescriptorW, DVASPECT_CONTENT, TYMED_HGLOBAL),
    FSDH(_FilterFileContentsOLEHack, g_cfFileGroupDescriptorW, DVASPECT_LINK,    TYMED_HGLOBAL),
    FSDH(_FilterFileContents,        g_cfFileGroupDescriptorA, DVASPECT_CONTENT, TYMED_HGLOBAL),
    FSDH(_FilterFileContentsOLEHack, g_cfFileGroupDescriptorA, DVASPECT_LINK,    TYMED_HGLOBAL),
    FSDH(_FilterFileContents,        g_cfFileContents,         DVASPECT_CONTENT, TYMED_ALLCONTENT),
    FSDH(_FilterFileContentsOLEHack, g_cfFileContents,         DVASPECT_LINK,    TYMED_ALLCONTENT),
   _FSDH(_FilterBriefcase,           CF_HDROP,                 DVASPECT_CONTENT, TYMED_HGLOBAL), 
   _FSDH(_FilterSneakernetBriefcase, CF_HDROP,                 DVASPECT_CONTENT, TYMED_HGLOBAL),
   _FSDH(_FilterHDROP,               CF_HDROP,                 DVASPECT_CONTENT, TYMED_HGLOBAL),
   _FSDH(_FilterDeskCompHDROP,       CF_HDROP,                 DVASPECT_CONTENT, TYMED_HGLOBAL),
    FSDH(_FilterHIDA,                g_cfHIDA,                 DVASPECT_CONTENT, TYMED_HGLOBAL),
    FSDH(_FilterOlePackage,          g_cfEmbeddedObject,       DVASPECT_CONTENT, TYMED_ISTORAGE),
    FSDH(_FilterDeskImage,           g_cfHTML,                 DVASPECT_CONTENT, TYMED_HGLOBAL),
    FSDH(_FilterDeskComp,            g_cfShellURL,             DVASPECT_CONTENT, TYMED_HGLOBAL),
   _FSDH(_FilterOleObj,              0,                        DVASPECT_CONTENT, TYMED_HGLOBAL),
   _FSDH(_FilterOleLink,             0,                        DVASPECT_CONTENT, TYMED_HGLOBAL),
};

// Note that it's safe to race with another thread in this code
// since the function is idemponent.  (Call it as many times as you
// like -- only the first time through actually does anything.)

void CFSDropTarget::_Init_rg_data_handlers()
{
    for (int i = 0; i < ARRAYSIZE(rg_data_handlers); i++)
    {
        // If this assertion fires, then you have to change the value of
        // NUM_DATA_HANDLERS to match the number of entries in the array
        // definition.
        ASSERT(rg_data_handlers[i].fmte.tymed);

        if (rg_data_handlers[i].pcfInit)
        {
            rg_data_handlers[i].fmte.cfFormat = *rg_data_handlers[i].pcfInit;
        }
    }
}

//
// returns the default effect.
// also modifies *pdwEffectInOut to indicate "available" operations.
//
DWORD CFSDropTarget::_DetermineEffects(DWORD grfKeyState, DWORD *pdwEffectInOut, HMENU hmenu)
{
    DWORD dwDefaultEffect = DROPEFFECT_NONE;
    DWORD dwEffectsUsed = DROPEFFECT_NONE;

    _Init_rg_data_handlers();

    // Loop through formats, factoring in both the order of the enumerator and
    // the order of our rg_data_handlers to determine the default effect
    // (and possibly, to create the drop context menu)
    FSMENUINFO fsmi = { hmenu, 0, 0, 0 };
    IEnumFORMATETC *penum;
    AssertMsg((NULL != _pdtobj), TEXT("CFSDropTarget::_DetermineEffects() _pdtobj is NULL but we need it.  this=%#08lx"), this);
    if (_pdtobj && SUCCEEDED(_pdtobj->EnumFormatEtc(DATADIR_GET, &penum)))
    {
        FORMATETC fmte;
        ULONG celt;
        while (penum->Next(1, &fmte, &celt) == S_OK)
        {
            for (int i = 0; i < ARRAYSIZE(rg_data_handlers); i++)
            {
                if (rg_data_handlers[i].fmte.cfFormat == fmte.cfFormat &&
                    rg_data_handlers[i].fmte.dwAspect == fmte.dwAspect &&
                    (rg_data_handlers[i].fmte.tymed & fmte.tymed))
                {
                    // keep passing dwDefaultEffect until someone computes one, this
                    // lets the first guy that figures out the default be the default
                    (this->*(rg_data_handlers[i].pfnGetDragDropInfo))(
                        &fmte, grfKeyState, *pdwEffectInOut, &dwEffectsUsed,
                        (DROPEFFECT_NONE == dwDefaultEffect) ? &dwDefaultEffect : NULL,
                        hmenu ? &fsmi : NULL);
                }
            }
            SHFree(fmte.ptd);
        }
        penum->Release();
    }
    // Loop through the rg_data_handlers that don't have an associated clipboard format last
    for (int i = 0; i < ARRAYSIZE(rg_data_handlers); i++)
    {
        if (0 == rg_data_handlers[i].fmte.cfFormat)
        {
            // if default effect is still not computed continue to pass that
            (this->*(rg_data_handlers[i].pfnGetDragDropInfo))(
               NULL, grfKeyState, *pdwEffectInOut, &dwEffectsUsed,
               (DROPEFFECT_NONE == dwDefaultEffect) ? &dwDefaultEffect : NULL,
               hmenu ? &fsmi : NULL);
        }
    }

    *pdwEffectInOut &= dwEffectsUsed;

    dwDefaultEffect = _LimitDefaultEffect(dwDefaultEffect, *pdwEffectInOut);

    DebugMsg(TF_FSTREE, TEXT("CFSDT::GetDefaultEffect dwDef=%x, dwEffUsed=%x, *pdw=%x"),
             dwDefaultEffect, dwEffectsUsed, *pdwEffectInOut);

    return dwDefaultEffect; // this is what we want to do
}

// This is used to map command id's back to dropeffect's:

const struct {
    UINT uID;
    DWORD dwEffect;
} c_IDFSEffects[] = {
    DDIDM_COPY,         DROPEFFECT_COPY,
    DDIDM_MOVE,         DROPEFFECT_MOVE,
    DDIDM_CONTENTS_DESKCOMP,     DROPEFFECT_LINK,
    DDIDM_LINK,         DROPEFFECT_LINK,
    DDIDM_SCRAP_COPY,   DROPEFFECT_COPY,
    DDIDM_SCRAP_MOVE,   DROPEFFECT_MOVE,
    DDIDM_DOCLINK,      DROPEFFECT_LINK,
    DDIDM_CONTENTS_COPY, DROPEFFECT_COPY,
    DDIDM_CONTENTS_MOVE, DROPEFFECT_MOVE,
    DDIDM_CONTENTS_LINK, DROPEFFECT_LINK,
    DDIDM_CONTENTS_DESKIMG,     DROPEFFECT_LINK,
    DDIDM_SYNCCOPYTYPE, DROPEFFECT_COPY,        // (order is important)
    DDIDM_SYNCCOPY,     DROPEFFECT_COPY,
    DDIDM_OBJECT_COPY,  DROPEFFECT_COPY,
    DDIDM_OBJECT_MOVE,  DROPEFFECT_MOVE,
    DDIDM_CONTENTS_DESKURL,  DROPEFFECT_LINK,
};

void CFSDropTarget::_FixUpDefaultItem(HMENU hmenu, DWORD dwDefEffect)
{
    // only do stuff if there is no default item already and we have a default effect
    if ((GetMenuDefaultItem(hmenu, MF_BYPOSITION, 0) == -1) && dwDefEffect)
    {
        for (int i = 0; i < GetMenuItemCount(hmenu); i++)
        {
            // for menu item matching default effect, make it the default.
            MENUITEMINFO mii = { 0 };
            mii.cbSize = sizeof(mii);
            mii.fMask = MIIM_DATA | MIIM_STATE;
            if (GetMenuItemInfo(hmenu, i, MF_BYPOSITION, &mii) && (mii.dwItemData == dwDefEffect))
            {
                mii.fState |= MFS_DEFAULT;
                SetMenuItemInfo(hmenu, i, MF_BYPOSITION, &mii);
                break;
            }
        }
    }
}

HRESULT CFSDropTarget::_DragDropMenu(FSDRAGDROPMENUPARAM *pddm)
{
    HRESULT hr = E_OUTOFMEMORY;       // assume error
    DWORD dwEffectOut = 0;                              // assume no-ope.
    if (pddm->hmenu)
    {
        UINT idCmd;
        UINT idCmdFirst = DDIDM_EXTFIRST;
        HDXA hdxa = HDXA_Create();
        HDCA hdca = DCA_Create();
        if (hdxa && hdca)
        {
            // Enumerate the DD handlers and let them append menu items.
            for (DWORD i = 0; i < pddm->ck; i++)
            {
                DCA_AddItemsFromKey(hdca, pddm->rghk[i], STRREG_SHEX_DDHANDLER);
            }

            idCmdFirst = HDXA_AppendMenuItems(hdxa, pddm->pdtobj, pddm->ck,
                pddm->rghk, _GetIDList(), pddm->hmenu, 0,
                DDIDM_EXTFIRST, DDIDM_EXTLAST, 0, hdca);
        }

        // modifier keys held down to force operations that are not permitted (for example
        // alt to force a shortcut from the start menu, which does not have SFGAO_CANLINK)
        // can result in no default items on the context menu.  however in displaying the
        // cursor overlay in this case we fall back to DROPEFFECT_COPY.  a left drag then
        // tries to invoke the default menu item (user thinks its copy) but theres no default.

        // this function selects a default menu item to match the default effect if there
        // is no default item already.
        _FixUpDefaultItem(pddm->hmenu, pddm->dwDefEffect);

        // If this dragging is caused by the left button, simply choose
        // the default one, otherwise, pop up the context menu.  If there
        // is no key state info and the original effect is the same as the
        // current effect, choose the default one, otherwise pop up the
        // context menu.  
        if ((_grfKeyStateLast & MK_LBUTTON) ||
             (!_grfKeyStateLast && (*(pddm->pdwEffect) == pddm->dwDefEffect)))
        {
            idCmd = GetMenuDefaultItem(pddm->hmenu, MF_BYCOMMAND, 0);

            // This one MUST be called here. Please read its comment block.
            DAD_DragLeave();

            if (_hwnd)
                SetForegroundWindow(_hwnd);
        }
        else
        {
            // Note that SHTrackPopupMenu calls DAD_DragLeave().
            idCmd = SHTrackPopupMenu(pddm->hmenu, TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTALIGN,
                    pddm->pt.x, pddm->pt.y, 0, _hwnd, NULL);
        }

        //
        // We also need to call this here to release the dragged image.
        //
        DAD_SetDragImage(NULL, NULL);

        //
        // Check if the user selected one of add-in menu items.
        //
        if (idCmd == 0)
        {
            hr = S_OK;        // Canceled by the user, return S_OK
        }
        else if (InRange(idCmd, DDIDM_EXTFIRST, DDIDM_EXTLAST))
        {
            //
            // Yes. Let the context menu handler process it.
            //
            CMINVOKECOMMANDINFOEX ici = {
                sizeof(CMINVOKECOMMANDINFOEX),
                0L,
                _hwnd,
                (LPSTR)MAKEINTRESOURCE(idCmd - DDIDM_EXTFIRST),
                NULL, NULL,
                SW_NORMAL,
            };

            // record if the shift/control keys were down at the time of the drop
            if (_grfKeyStateLast & MK_SHIFT)
            {
                ici.fMask |= CMIC_MASK_SHIFT_DOWN;
            }

            if (_grfKeyStateLast & MK_CONTROL)
            {
                ici.fMask |= CMIC_MASK_CONTROL_DOWN;
            }

            // We may not want to ignore the error code. (Can happen when you use the context menu
            // to create new folders, but I don't know if that can happen here.).
            HDXA_LetHandlerProcessCommandEx(hdxa, &ici, NULL);
            hr = S_OK;
        }
        else
        {
            for (int nItem = 0; nItem < ARRAYSIZE(c_IDFSEffects); ++nItem)
            {
                if (idCmd == c_IDFSEffects[nItem].uID)
                {
                    dwEffectOut = c_IDFSEffects[nItem].dwEffect;
                    break;
                }
            }

            hr = S_FALSE;
        }

        if (hdca)
            DCA_Destroy(hdca);

        if (hdxa)
            HDXA_Destroy(hdxa);

        pddm->idCmd = idCmd;
    }

    *pddm->pdwEffect = dwEffectOut;

    return hr;
}

void _MapName(void *hNameMap, LPTSTR pszPath)
{
    if (hNameMap)
    {
        SHNAMEMAPPING *pNameMapping;
        for (int i = 0; (pNameMapping = SHGetNameMappingPtr((HDSA)hNameMap, i)) != NULL; i++)
        {
            if (lstrcmpi(pszPath, pNameMapping->pszOldPath) == 0)
            {
                lstrcpy(pszPath, pNameMapping->pszNewPath);
                break;
            }
        }
    }
}

// convert double null list of files to array of pidls

int FileListToIDArray(LPCTSTR pszFiles, void *hNameMap, LPITEMIDLIST **pppidl)
{
    int i = 0;
    int nItems = CountFiles(pszFiles);
    LPITEMIDLIST *ppidl = (LPITEMIDLIST *)LocalAlloc(LPTR, nItems * sizeof(*ppidl));
    if (ppidl)
    {
        *pppidl = ppidl;

        while (*pszFiles)
        {
            TCHAR szPath[MAX_PATH];
            lstrcpy(szPath, pszFiles);

            _MapName(hNameMap, szPath);

            ppidl[i] = SHSimpleIDListFromPath(szPath);

            pszFiles += lstrlen(pszFiles) + 1;
            i++;
        }
    }
    return i;
}

// move items to the new drop location

void CFSDropTarget::_MoveSelectIcons(IDataObject *pdtobj, IFolderView* pfv, void *hNameMap, LPCTSTR pszFiles, BOOL fMove, HDROP hDrop)
{
    LPITEMIDLIST *ppidl = NULL;
    int cidl;

    if (pszFiles) 
    {
        cidl = FileListToIDArray(pszFiles, hNameMap, &ppidl);
    } 
    else 
    {
        cidl = CreateMoveCopyList(hDrop, hNameMap, &ppidl);
    }

    if (ppidl)
    {
        if (pfv)
            PositionItems(pfv, (LPCITEMIDLIST*)ppidl, cidl, pdtobj, fMove ? &_ptDrop : NULL);

        FreeIDListArray(ppidl, cidl);
    }
}

// this is the ILIsParent which matches up the desktop with the desktop directory.
BOOL AliasILIsParent(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
{
    LPITEMIDLIST pidlUse1 = SHLogILFromFSIL(pidl1);
    if (pidlUse1)
        pidl1 = pidlUse1;

    LPITEMIDLIST pidlUse2 = SHLogILFromFSIL(pidl2);
    if (pidlUse2)
        pidl2 = pidlUse2;

    BOOL fSame = ILIsParent(pidl1, pidl2, TRUE);

    ILFree(pidlUse1);   // NULL is OK here
    ILFree(pidlUse2);

    return fSame;
}

// in:
//      pszDestDir      destination dir for new file names
//      pszDestSpecs    double null list of destination specs
//
// returns:
//      double null list of fully qualified destination file names to be freed
//      with LocalFree()
//

LPTSTR RemapDestNamesW(LPCTSTR pszDestDir, LPCWSTR pszDestSpecs)
{
    UINT cbDestSpec = lstrlen(pszDestDir) * sizeof(TCHAR) + sizeof(TCHAR);
    LPCWSTR pszTemp;
    UINT cbAlloc = sizeof(TCHAR);       // for double NULL teriminaion of entire string

    // compute length of buffer to aloc
    for (pszTemp = pszDestSpecs; *pszTemp; pszTemp += lstrlenW(pszTemp) + 1)
    {
        // +1 for null teriminator
        cbAlloc += cbDestSpec + lstrlenW(pszTemp) * sizeof(TCHAR) + sizeof(TCHAR);
    }

    LPTSTR pszRet = (LPTSTR)LocalAlloc(LPTR, cbAlloc);
    if (pszRet)
    {
        LPTSTR pszDest = pszRet;

        for (pszTemp = pszDestSpecs; *pszTemp; pszTemp += lstrlenW(pszTemp) + 1)
        {
            // PathCombine requires dest buffer of MAX_PATH size or it'll rip in call
            // to PathCanonicalize (IsBadWritePtr)
            TCHAR szTempDest[MAX_PATH];
            PathCombine(szTempDest, pszDestDir, pszTemp);
            lstrcpy(pszDest, szTempDest);
            pszDest += lstrlen(pszDest) + 1;

            ASSERT((UINT)((BYTE *)pszDest - (BYTE *)pszRet) < cbAlloc);
            ASSERT(*pszDest == 0);      // zero init alloc
        }
        ASSERT((LPTSTR)((BYTE *)pszRet + cbAlloc - sizeof(TCHAR)) >= pszDest);
        ASSERT(*pszDest == 0);  // zero init alloc

    }
    return pszRet;
}

LPTSTR RemapDestNamesA(LPCTSTR pszDestDir, LPCSTR pszDestSpecs)
{
    UINT cbDestSpec = lstrlen(pszDestDir) * sizeof(TCHAR) + sizeof(TCHAR);
    LPCSTR pszTemp;
    LPTSTR pszRet;
    UINT cbAlloc = sizeof(TCHAR);       // for double NULL teriminaion of entire string

    // compute length of buffer to aloc
    for (pszTemp = pszDestSpecs; *pszTemp; pszTemp += lstrlenA(pszTemp) + 1)
    {
        // +1 for null teriminator
        cbAlloc += cbDestSpec + lstrlenA(pszTemp) * sizeof(TCHAR) + sizeof(TCHAR);
    }

    pszRet = (LPTSTR)LocalAlloc(LPTR, cbAlloc);
    if (pszRet)
    {
        LPTSTR pszDest = pszRet;

        for (pszTemp = pszDestSpecs; *pszTemp; pszTemp += lstrlenA(pszTemp) + 1)
        {
            // PathCombine requires dest buffer of MAX_PATH size or it'll rip in call
            // to PathCanonicalize (IsBadWritePtr)
            TCHAR szTempDest[MAX_PATH];
            WCHAR wszTemp[MAX_PATH];
            SHAnsiToUnicode(pszTemp, wszTemp, ARRAYSIZE(wszTemp));
            PathCombine(szTempDest, pszDestDir, wszTemp);
            lstrcpy(pszDest, szTempDest);
            pszDest += lstrlen(pszDest) + 1;

            ASSERT((UINT)((BYTE *)pszDest - (BYTE *)pszRet) < cbAlloc);
            ASSERT(*pszDest == 0);      // zero init alloc
        }
        ASSERT((LPTSTR)((BYTE *)pszRet + cbAlloc - sizeof(TCHAR)) >= pszDest);
        ASSERT(*pszDest == 0);  // zero init alloc

    }
    return pszRet;
}

LPTSTR _GetDestNames(IDataObject *pdtobj, LPCTSTR pszPath)
{
    LPTSTR pszDestNames = NULL;

    STGMEDIUM medium;
    FORMATETC fmte = {g_cfFileNameMapW, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
    if (S_OK == pdtobj->GetData(&fmte, &medium))
    {
        pszDestNames = RemapDestNamesW(pszPath, (LPWSTR)GlobalLock(medium.hGlobal));
        ReleaseStgMediumHGLOBAL(medium.hGlobal, &medium);
    }
    else
    {
        fmte.cfFormat = g_cfFileNameMapA;
        if (S_OK == pdtobj->GetData(&fmte, &medium))
        {
            pszDestNames = RemapDestNamesA(pszPath, (LPSTR)GlobalLock(medium.hGlobal));
            ReleaseStgMediumHGLOBAL(medium.hGlobal, &medium);
        }
    }
    return pszDestNames;
}

BOOL _IsInSameFolder(LPCITEMIDLIST pidlFolder, IDataObject *pdtobj)
{
    BOOL bRet = FALSE;
    STGMEDIUM medium = {0};
    LPIDA pida = DataObj_GetHIDA(pdtobj, &medium);
    if (pida)
    {
        for (UINT i = 0; i < pida->cidl; i++) 
        {
            LPITEMIDLIST pidl = IDA_FullIDList(pida, i);
            if (pidl)
            {
                // if we're doing keyboard cut/copy/paste
                //  to and from the same directories
                // This is needed for common desktop support - BobDay/EricFlo
                if (AliasILIsParent(pidlFolder, pidl))
                {
                    bRet = TRUE;
                }
                ILFree(pidl);
            }
        }
        HIDA_ReleaseStgMedium(pida, &medium);
    }
    return bRet;
}

LPCTSTR _RootSpecialCase(LPCTSTR pszFiles, LPTSTR pszSrc, LPTSTR pszDest)
{
    if ((1 == CountFiles(pszFiles)) &&
        PathIsRoot(pszFiles))
    {
        SHFILEINFO sfi;

        // NOTE: don't use SHGFI_USEFILEATTRIBUTES because the simple IDList
        // support for \\server\share produces the wrong name
        if (SHGetFileInfo(pszFiles, 0, &sfi, sizeof(sfi), SHGFI_DISPLAYNAME)) 
        {
            if (!(PCS_FATAL & PathCleanupSpec(pszDest, sfi.szDisplayName)))
            {
                PathAppend(pszDest, sfi.szDisplayName); // sub dir name based on source root path
                PathCombine(pszSrc, pszFiles, TEXT("*.*")); // all files on source
                pszFiles = pszSrc;
            }
        }
    }
    return pszFiles;
}

void CFSDropTarget::_MoveCopy(IDataObject *pdtobj, IFolderView* pfv, HDROP hDrop)
{
#ifdef DEBUG
    if (_hwnd == NULL)
    {
        TraceMsg(TF_GENERAL, "_MoveCopy() without an hwnd which will prevent displaying insert disk UI");
    }
#endif // DEBUG

    DRAGINFO di = { sizeof(di) };
    if (DragQueryInfo(hDrop, &di))
    {
        TCHAR szDest[MAX_PATH] = {0}; // zero init for dbl null termination

        _GetPath(szDest);

        switch (_idCmd) 
        {
        case DDIDM_MOVE:

            if (_fSameHwnd)
            {
                _MoveSelectIcons(pdtobj, pfv, NULL, NULL, TRUE, hDrop);
                break;
            }

            // fall through...

        case DDIDM_COPY:
            {
                TCHAR szAltSource[MAX_PATH] = {0};  // zero init for dbl null termination
                LPCTSTR pszSource = _RootSpecialCase(di.lpFileList, szAltSource, szDest);

                SHFILEOPSTRUCT fo = 
                {
                    _hwnd,
                    (DDIDM_COPY == _idCmd) ? FO_COPY : FO_MOVE,
                    pszSource,
                    szDest,
                    FOF_WANTMAPPINGHANDLE | FOF_ALLOWUNDO | FOF_NOCONFIRMMKDIR
                };
                if (fo.wFunc == FO_MOVE && IsFolderSecurityModeOn())
                {
                    fo.fFlags |= FOF_NOCOPYSECURITYATTRIBS;
                }

                // if they are in the same hwnd or to and from
                // the same directory, turn on the automatic rename on collision flag
                if (_fSameHwnd || 
                    ((DDIDM_COPY == _idCmd) && _IsInSameFolder(_GetIDList(), pdtobj)))
                {
                    // do rename on collision for copy;
                    fo.fFlags |=  FOF_RENAMEONCOLLISION;
                }

                // see if there is a rename mapping from recycle bin (or someone else)

                LPTSTR pszDestNames = _GetDestNames(pdtobj, szDest);
                if (pszDestNames)
                {
                    fo.pTo = pszDestNames;
                    fo.fFlags |= FOF_MULTIDESTFILES;
                    fo.fFlags &= ~FOF_ALLOWUNDO;    // HACK, this came from the recycle bin, don't allow undo
                }

                {
                    static UINT s_cfFileOpFlags = 0;
                    if (0 == s_cfFileOpFlags)
                        s_cfFileOpFlags = RegisterClipboardFormat(TEXT("FileOpFlags"));

                    fo.fFlags = (FILEOP_FLAGS)DataObj_GetDWORD(pdtobj, s_cfFileOpFlags, fo.fFlags);
                }

                // Check if there were any errors
                if (SHFileOperation(&fo) == 0 && !fo.fAnyOperationsAborted)
                {
                    if (_fBkDropTarget)
                        ShellFolderView_SetRedraw(_hwnd, 0);

                    SHChangeNotifyHandleEvents();   // force update now
                    if (_fBkDropTarget) 
                    {
                        _MoveSelectIcons(pdtobj, pfv, fo.hNameMappings, pszDestNames, _fDragDrop, hDrop);
                        ShellFolderView_SetRedraw(_hwnd, TRUE);
                    }
                }

                if (fo.hNameMappings)
                    SHFreeNameMappings(fo.hNameMappings);

                if (pszDestNames)
                {
                    LocalFree((HLOCAL)pszDestNames);

                    // HACK, this usually comes from the bitbucket
                    // but in our shell, we don't handle the moves from the source
                    if (DDIDM_MOVE == _idCmd)
                        BBCheckRestoredFiles(pszSource);
                }
            }

            break;
        }
        SHFree(di.lpFileList);
    }
}

const UINT c_rgFolderShortcutTargets[] = {
    CSIDL_STARTMENU,
    CSIDL_COMMON_STARTMENU,
    CSIDL_PROGRAMS,
    CSIDL_COMMON_PROGRAMS,
    CSIDL_NETHOOD,
};

BOOL _ShouldCreateFolderShortcut(LPCTSTR pszFolder)
{
    return PathIsEqualOrSubFolderOf(pszFolder, c_rgFolderShortcutTargets, ARRAYSIZE(c_rgFolderShortcutTargets));
}

void CFSDropTarget::_DoDrop(IDataObject *pdtobj, IFolderView* pfv)
{
    HRESULT hr = E_FAIL;

    // Sleep(10 * 1000);   // to debug async case

    TCHAR szPath[MAX_PATH];   
    _GetPath(szPath);
    SHCreateDirectory(NULL, szPath);      // if this fails we catch it later
    
    switch (_idCmd)
    {
    case DDIDM_SYNCCOPY:
    case DDIDM_SYNCCOPYTYPE:
        if (_IsBriefcaseTarget())
        {
            IBriefcaseStg *pbrfstg;
            if (SUCCEEDED(CreateBrfStgFromPath(szPath, _hwnd, &pbrfstg)))
            {
                hr = pbrfstg->AddObject(pdtobj, NULL,
                    (DDIDM_SYNCCOPYTYPE == _idCmd) ? AOF_FILTERPROMPT : AOF_DEFAULT,
                    _hwnd);
                pbrfstg->Release();
            }
        }
        else
        {
            // Perform a sneakernet addition to the briefcase
            STGMEDIUM medium;
            LPIDA pida = DataObj_GetHIDA(pdtobj, &medium);
            if (pida)
            {
                // Is there a briefcase root in this pdtobj?
                IBriefcaseStg *pbrfstg;
                if (SUCCEEDED(CreateBrfStgFromIDList(IDA_GetIDListPtr(pida, (UINT)-1), _hwnd, &pbrfstg)))
                {
                    hr = pbrfstg->AddObject(pdtobj, szPath,
                        (DDIDM_SYNCCOPYTYPE == _idCmd) ? AOF_FILTERPROMPT : AOF_DEFAULT,
                        _hwnd);
                    pbrfstg->Release();
                }

                HIDA_ReleaseStgMedium(pida, &medium);
            }
        }
        break;

    case DDIDM_COPY:
    case DDIDM_MOVE:
        {
            STGMEDIUM medium;
            FORMATETC fmte = {CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
            hr = pdtobj->GetData(&fmte, &medium);
            if (SUCCEEDED(hr))
            {
                _MoveCopy(pdtobj, pfv, (HDROP)medium.hGlobal);
                ReleaseStgMedium(&medium);
            }
        }
        break;

    case DDIDM_LINK:
        {
            int i = 0;
            LPITEMIDLIST *ppidl = NULL;

            if (_fBkDropTarget)
            {
                i = DataObj_GetHIDACount(pdtobj);
                ppidl = (LPITEMIDLIST *)LocalAlloc(LPTR, sizeof(*ppidl) * i);
            }

            // _grfKeyStateLast of 0 means this was a simulated drop
            UINT uCreateFlags = _grfKeyStateLast && !(_dwEffectFolder & DROPEFFECT_LINK) ? SHCL_USETEMPLATE : 0;

            if (_ShouldCreateFolderShortcut(szPath))
                uCreateFlags |= SHCL_MAKEFOLDERSHORTCUT;

            ShellFolderView_SetRedraw(_hwnd, FALSE);
            // passing ppidl == NULL is correct in failure case
            hr = SHCreateLinks(_hwnd, szPath, pdtobj, uCreateFlags, ppidl);
            if (ppidl)
            {
                if (pfv)
                    PositionItems(pfv, (LPCITEMIDLIST*)ppidl, i, pdtobj, &_ptDrop);

                FreeIDListArray(ppidl, i);
            }
            ShellFolderView_SetRedraw(_hwnd, TRUE);
        }
        break;
    }

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

    SHChangeNotifyHandleEvents();       // force update now
}

DWORD CALLBACK CFSDropTarget::_DoDropThreadProc(void *pv)
{
    DROPTHREADPARAMS *pdtp = (DROPTHREADPARAMS *)pv;

    IDataObject *pdtobj;
    if (SUCCEEDED(CoGetInterfaceAndReleaseStream(pdtp->pstmDataObj, IID_PPV_ARG(IDataObject, &pdtobj))))
    {
        IFolderView* pfv;
        if (FAILED(CoGetInterfaceAndReleaseStream(pdtp->pstmFolderView, IID_PPV_ARG(IFolderView, &pfv))))
            pfv = NULL;

        pdtp->pThis->_DoDrop(pdtobj, pfv);

        if (pfv)
            pfv->Release();

        pdtp->pstmFolderView = NULL;  // stream now invalid; CoGetInterfaceAndReleaseStream already released it
        pdtobj->Release();
    }

    pdtp->pstmDataObj    = NULL;  // stream now invalid; CoGetInterfaceAndReleaseStream already released it
    _FreeThreadParams(pdtp);

    CoFreeUnusedLibraries();
    return 0;
}

// REARCHITECT: view and drop related helpers, these use the ugly old private defview messages
// we should replace the usage of this stuff with IShellFolderView programming


// create the pidl array that contains the destination file names. this is
// done by taking the source file names, and translating them through the
// name mapping returned by the copy engine.
//
//
// in:
//      hDrop           HDROP containing files recently moved/copied
//      hNameMap   used to translate names
//
// out:
//      *pppidl         id array of length return value
//      # of items in pppida

//
//  WARNING!  You must use the provided HDROP.  Do not attempt to ask the
//  data object for a HDROP or HIDA or WS_FTP will break!  They don't like
//  it if you ask them for HDROP/HIDA, move the files to a new location
//  (via the copy engine), and then ask them for HDROP/HIDA a second time.
//  They notice that "Hey, those files I downloaded last time are gone!"
//  and then get confused.
//
STDAPI_(int) CreateMoveCopyList(HDROP hDrop, void *hNameMap, LPITEMIDLIST **pppidl)
{
    int nItems = 0;

    if (hDrop)
    {
        nItems = DragQueryFile(hDrop, (UINT)-1, NULL, 0);
        *pppidl = (LPITEMIDLIST *)LocalAlloc(LPTR, nItems * sizeof(*pppidl));
        if (*pppidl)
        {
            for (int i = nItems - 1; i >= 0; i--)
            {
                TCHAR szPath[MAX_PATH];
                DragQueryFile(hDrop, i, szPath, ARRAYSIZE(szPath));
                _MapName(hNameMap, szPath);
                (*pppidl)[i] = SHSimpleIDListFromPath(szPath);
            }
        }
    }
    return nItems;
}

// this is really not related to CFSFolder. it is generic over any view
// REARCHITECT: convert view hwnd programming to site pointer

STDAPI_(void) PositionFileFromDrop(HWND hwnd, LPCTSTR pszFile, DROPHISTORY *pdh)
{
    LPITEMIDLIST pidl = SHSimpleIDListFromPath(pszFile);
    if (pidl)
    {
        LPITEMIDLIST pidlNew = ILFindLastID(pidl);
        HWND hwndView = ShellFolderViewWindow(hwnd);
        SFM_SAP sap;
        
        SHChangeNotifyHandleEvents();
        
        // Fill in some easy SAP fields first.
        sap.uSelectFlags = SVSI_SELECT;
        sap.fMove = TRUE;
        sap.pidl = pidlNew;

        // Now compute the x,y coordinates.
        // If we have a drop history, use it to determine the
        // next point.

        if (pdh)
        {
            // fill in the anchor point first...
            if (!pdh->fInitialized)
            {
                ITEMSPACING is;
                
                ShellFolderView_GetDropPoint(hwnd, &pdh->ptOrigin);
                
                pdh->pt = pdh->ptOrigin;    // Compute the first point.
                
                // Compute the point deltas.
                if (ShellFolderView_GetItemSpacing(hwnd, &is))
                {
                    pdh->cxItem = is.cxSmall;
                    pdh->cyItem = is.cySmall;
                    pdh->xDiv = is.cxLarge;
                    pdh->yDiv = is.cyLarge;
                    pdh->xMul = is.cxSmall;
                    pdh->yMul = is.cySmall;
                }
                else
                {
                    pdh->cxItem = g_cxIcon;
                    pdh->cyItem = g_cyIcon;
                    pdh->xDiv = pdh->yDiv = pdh->xMul = pdh->yMul = 1;
                }
                
                // First point gets special flags.
                sap.uSelectFlags |= SVSI_ENSUREVISIBLE | SVSI_DESELECTOTHERS | SVSI_FOCUSED;
                
                pdh->fInitialized = TRUE;   // We be initialized.
            }
            // if we have no list of offsets, then just inc by icon size..
            else if ( !pdh->pptOffset )
            {
                // Simple computation of the next point.
                pdh->pt.x += pdh->cxItem;
                pdh->pt.y += pdh->cyItem;
            }
            
            // do this after the above stuff so that we always get our position relative to the anchor
            // point, if we use the anchor point as the first one things get screwy...
            if (pdh->pptOffset)
            {
                // Transform the old offset to our coordinates.
                pdh->pt.x = ((pdh->pptOffset[pdh->iItem].x * pdh->xMul) / pdh->xDiv) + pdh->ptOrigin.x;
                pdh->pt.y = ((pdh->pptOffset[pdh->iItem].y * pdh->yMul) / pdh->yDiv) + pdh->ptOrigin.y;
            }
            
            sap.pt = pdh->pt;   // Copy the next point from the drop history.
        }
        else
        {
            // Preinitialize this puppy in case the folder view doesn't
            // know what the drop point is (e.g., if it didn't come from
            // a drag/drop but rather from a paste or a ChangeNotify.)
            sap.pt.x = 0x7FFFFFFF;      // "don't know"
            sap.pt.y = 0x7FFFFFFF;

            // Get the drop point, conveniently already in
            // defview's screen coordinates.
            //
            // pdv->bDropAnchor should be TRUE at this point,
            // see DefView's GetDropPoint() for details.

            ShellFolderView_GetDropPoint(hwnd, &sap.pt);

            // Only point gets special flags.
            sap.uSelectFlags |= SVSI_ENSUREVISIBLE | SVSI_DESELECTOTHERS | SVSI_FOCUSED;
        }
        
        SendMessage(hwndView, SVM_SELECTANDPOSITIONITEM, 1, (LPARAM)&sap);
        
        ILFree(pidl);
    }
}

//
// Class used to scale and position items for drag and drops.  Handles
// scaling between different sized views.
//

//
// Bug 165413 (edwardp 8/16/00) Convert IShellFolderView usage in CItemPositioning to IFolderView
//

class CItemPositioning
{
    // Methods
public:
    CItemPositioning(IFolderView* pifv, LPCITEMIDLIST* apidl, UINT cidl, IDataObject* pdtobj, POINT* ppt);

    void DragSetPoints(void);
    void DropPositionItems(void);

private:

    typedef enum
    {
        DPIWP_AUTOARRANGE,
        DPIWP_DATAOBJ,
    } DPIWP;

    BOOL   _DragShouldPositionItems(void);
    BOOL   _DragGetPoints(POINT* apts);
    void   _DragPositionPoints(POINT* apts);
    void   _DragScalePoints(POINT* apts);

    POINT* _DropGetPoints(DPIWP dpiwp, STGMEDIUM* pMediam);
    void   _DropFreePoints(DPIWP dpiwp, POINT* apts, STGMEDIUM* pmedium);
    void   _DropPositionPoints(POINT* apts);
    void   _DropScalePoints(POINT* apts);
    void   _DropPositionItemsWithPoints(DPIWP dpiwp);
    void   _DropPositionItems(POINT* apts);

    void   _ScalePoints(POINT* apts, POINT ptFrom, POINT ptTo);
    POINT* _SkipAnchorPoint(POINT* apts);

    // Data
private:
    IFolderView*      _pfv;
    LPCITEMIDLIST*    _apidl;
    UINT              _cidl;
    IDataObject*      _pdtobj;
    POINT*            _ppt;
};

CItemPositioning::CItemPositioning(IFolderView* pifv, LPCITEMIDLIST* apidl, UINT cidl, IDataObject* pdtobj, POINT* ppt)
{
    ASSERT(pifv);
    ASSERT(apidl);
    ASSERT(cidl);
    ASSERT(pdtobj);

    _pfv    = pifv;    // No need to addref as long as CPostionItems is only used locally.
    _apidl  = apidl;
    _cidl   = cidl;
    _pdtobj = pdtobj;  // No need to addref as long as CPostionItems is only used locally.
    _ppt    = ppt;
}


void CItemPositioning::DragSetPoints(void)
{
    if (_DragShouldPositionItems())
    {
        POINT* apts = (POINT*) GlobalAlloc(GPTR, sizeof(POINT) * (_cidl + 1));

        if (apts)
        {
            if (_DragGetPoints(apts))
            {
                _DragPositionPoints(_SkipAnchorPoint(apts));
                _DragScalePoints(_SkipAnchorPoint(apts));

                if (FAILED(DataObj_SetGlobal(_pdtobj, g_cfOFFSETS, apts)))
                    GlobalFree((HGLOBAL)apts);
            }
            else
            {
                GlobalFree((HGLOBAL)apts);
            }
        }
    }
}

BOOL CItemPositioning::_DragShouldPositionItems()
{
    // Don't position multiple items if they come from a view that doesn't allow
    // positioning.  The position information is not likely to be usefull in this
    // case.
    // Always position single items so they show up at the drop point.
    // Don't bother with position data for 100 or more items.

    return ((S_OK == _pfv->GetSpacing(NULL)) || 1 == _cidl) && _cidl < 100;
}

BOOL CItemPositioning::_DragGetPoints(POINT* apts)
{
    BOOL fRet = TRUE;

    // The first point is the anchor.
    apts[0] = *_ppt;

    for (UINT i = 0; i < _cidl; i++)
    {
        if (FAILED(_pfv->GetItemPosition(_apidl[i], &apts[i + 1])))
        {
            if (1 == _cidl)
            {
                apts[i + 1].x = _ppt->x;
                apts[i + 1].y = _ppt->y;
            }
            else
            {
                fRet = FALSE;
            }
        }
    }

    return fRet;
}

void CItemPositioning::_DragPositionPoints(POINT* apts)
{
    for (UINT i = 0; i < _cidl; i++)
    {
        apts[i].x -= _ppt->x;
        apts[i].y -= _ppt->y;
    }
}

void CItemPositioning::_DragScalePoints(POINT* apts)
{
    POINT ptFrom;
    POINT ptTo;

    _pfv->GetSpacing(&ptFrom);
    _pfv->GetDefaultSpacing(&ptTo);

    if (ptFrom.x != ptTo.x || ptFrom.y != ptTo.y)
        _ScalePoints(apts, ptFrom, ptTo);
}

void CItemPositioning::DropPositionItems(void)
{
    if (S_OK == _pfv->GetAutoArrange())
    {
        _DropPositionItemsWithPoints(DPIWP_AUTOARRANGE);
    }
    else if (S_OK == _pfv->GetSpacing(NULL) && _ppt)
    {
        _DropPositionItemsWithPoints(DPIWP_DATAOBJ);
    }
    else
    {
        _DropPositionItems(NULL);
    }
}

void CItemPositioning::_DropPositionItemsWithPoints(DPIWP dpiwp)
{
    STGMEDIUM medium;
    POINT*    apts = _DropGetPoints(dpiwp, &medium);

    if (apts)
    {
        if (DPIWP_DATAOBJ == dpiwp)
        {
            _DropScalePoints(_SkipAnchorPoint(apts));
            _DropPositionPoints(_SkipAnchorPoint(apts));
        }

        _DropPositionItems(_SkipAnchorPoint(apts));

        _DropFreePoints(dpiwp, apts, &medium);
    }
    else if (_ppt)
    {
        POINT *ppts;

        ppts = (POINT *)LocalAlloc(LPTR, _cidl * sizeof(POINT));

        if (ppts)
        {
            POINT   pt;

            _pfv->GetDefaultSpacing(&pt);

            for (UINT i = 0; i < _cidl; i++)
            {
                ppts[i].x = (-g_cxIcon / 2) + (i * pt.x);
                ppts[i].y = (-g_cyIcon / 2) + (i * pt.y);
            }
            _DropScalePoints(ppts);
            _DropPositionPoints(ppts);
            _DropPositionItems(ppts);

            LocalFree(ppts);
        }
        else
        {
            _DropPositionItems(NULL);
        }
    }
    else
    {
        _DropPositionItems(NULL);
    }
}

void CItemPositioning::_DropPositionItems(POINT* apts)
{
    // Drop the first item with special selection flags.
    LPCITEMIDLIST pidl = ILFindLastID(_apidl[0]);
    _pfv->SelectAndPositionItems(1, &pidl, apts, SVSI_SELECT | SVSI_ENSUREVISIBLE | SVSI_DESELECTOTHERS | SVSI_FOCUSED);

    // Drop the rest of the items.
    if (_cidl > 1)
    {
        LPCITEMIDLIST* apidl = (LPCITEMIDLIST*)LocalAlloc(GPTR, sizeof(LPCITEMIDLIST) * (_cidl - 1));

        if (apidl)
        {
            for (UINT i = 1; i < _cidl; i++)
                apidl[i - 1] = ILFindLastID(_apidl[i]);

            _pfv->SelectAndPositionItems(_cidl - 1, apidl, (apts) ? &apts[1] : NULL, SVSI_SELECT);

            LocalFree(apidl);
        }
    }
}

POINT* CItemPositioning::_DropGetPoints(DPIWP dpiwp, STGMEDIUM* pmedium)
{
    POINT* pptRet = NULL;

    if (DPIWP_DATAOBJ == dpiwp)
    {
        FORMATETC fmte = {g_cfOFFSETS, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};

        if (SUCCEEDED(_pdtobj->GetData(&fmte, pmedium)))
        {
            if (pmedium->hGlobal)
            {
                POINT *pptSrc;

                pptSrc = (POINT *)GlobalLock(pmedium->hGlobal);

                if (pptSrc)
                {
                    pptRet = (POINT*)LocalAlloc(GPTR, (_cidl + 1) * sizeof(POINT));

                    if (pptRet)
                    {
                        for (UINT i = 0; i <= _cidl; i++)
                        {
                            pptRet[i] = pptSrc[i];
                        }
                    }

                    GlobalUnlock(pptSrc);
                }
            }

            ReleaseStgMedium(pmedium);
        }
    }
    else if (DPIWP_AUTOARRANGE == dpiwp)
    {
        if (_ppt)
        {
            pptRet = (POINT*)LocalAlloc(GPTR, (_cidl + 1) * sizeof(POINT));

            if (pptRet)
            {
                // skip first point to simulate data object use of first point

                for (UINT i = 1; i <= _cidl; i++)
                {
                    pptRet[i] = *_ppt;
                }
            }
        }
    }

    return pptRet;
}

void CItemPositioning::_DropFreePoints(DPIWP dpiwp, POINT* apts, STGMEDIUM* pmedium)
{
    LocalFree(apts);
}

void CItemPositioning::_DropScalePoints(POINT* apts)
{
    POINT ptFrom;
    POINT ptTo;

    _pfv->GetDefaultSpacing(&ptFrom);
    _pfv->GetSpacing(&ptTo);

    if (ptFrom.x != ptTo.x || ptFrom.y != ptTo.y)    
        _ScalePoints(apts, ptFrom, ptTo);
}

void CItemPositioning::_DropPositionPoints(POINT* apts)
{
    for (UINT i = 0; i < _cidl; i++)
    {
        apts[i].x += _ppt->x;
        apts[i].y += _ppt->y;
    }
}

void CItemPositioning::_ScalePoints(POINT* apts, POINT ptFrom, POINT ptTo)
{
    for (UINT i = 0; i < _cidl; i++)
    {
        apts[i].x = MulDiv(apts[i].x, ptTo.x, ptFrom.x);
        apts[i].y = MulDiv(apts[i].y, ptTo.y, ptFrom.y);
    }
}

POINT* CItemPositioning::_SkipAnchorPoint(POINT* apts)
{
    return &apts[1];
}



STDAPI_(void) SetPositionItemsPoints(IFolderView* pifv, LPCITEMIDLIST* apidl, UINT cidl, IDataObject* pdtobj, POINT* ptDrag)
{
    CItemPositioning cpi(pifv, apidl, cidl, pdtobj, ptDrag);
    cpi.DragSetPoints();
}

STDAPI_(void) PositionItems(IFolderView* pifv, LPCITEMIDLIST* apidl, UINT cidl, IDataObject* pdtobj, POINT* ptDrop)
{
    CItemPositioning cip(pifv, apidl, cidl, pdtobj, ptDrop);
    cip.DropPositionItems();
}

//
// Don't use PositionItems_DontUse.  Instead convert to PositionItems.
// PositionItems_DontUse will be removed.
//
// Bug#163533 (edwardp 8/15/00) Remove this code. 

STDAPI_(void) PositionItems_DontUse(HWND hwndOwner, UINT cidl, const LPITEMIDLIST *ppidl, IDataObject *pdtobj, POINT *pptOrigin, BOOL fMove, BOOL fUseExactOrigin)
{
    if (!ppidl || !IsWindow(hwndOwner))
        return;

    SFM_SAP *psap = (SFM_SAP *)GlobalAlloc(GPTR, sizeof(SFM_SAP) * cidl);
    if (psap) 
    {
        UINT i, cxItem, cyItem;
        int xMul, yMul, xDiv, yDiv;
        STGMEDIUM medium;
        POINT *pptItems = NULL;
        POINT pt;
        ITEMSPACING is;
        // select those objects;
        // this had better not fail
        HWND hwnd = ShellFolderViewWindow(hwndOwner);

        if (fMove)
        {
            FORMATETC fmte = {g_cfOFFSETS, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
            if (SUCCEEDED(pdtobj->GetData(&fmte, &medium)) &&
                medium.hGlobal)
            {
                pptItems = (POINT *)GlobalLock(medium.hGlobal);
                pptItems++; // The first point is the anchor
            }
            else
            {
                // By default, drop at (-g_cxIcon/2, -g_cyIcon/2), and increase
                // x and y by icon dimension for each icon
                pt.x = ((-3 * g_cxIcon) / 2) + pptOrigin->x;
                pt.y = ((-3 * g_cyIcon) / 2) + pptOrigin->y;
                medium.hGlobal = NULL;
            }

            if (ShellFolderView_GetItemSpacing(hwndOwner, &is))
            {
                xDiv = is.cxLarge;
                yDiv = is.cyLarge;
                xMul = is.cxSmall;
                yMul = is.cySmall;
                cxItem = is.cxSmall;
                cyItem = is.cySmall;
            }
            else
            {
                xDiv = yDiv = xMul = yMul = 1;
                cxItem = g_cxIcon;
                cyItem = g_cyIcon;
            }
        }

        for (i = 0; i < cidl; i++)
        {
            if (ppidl[i])
            {
                psap[i].pidl = ILFindLastID(ppidl[i]);
                psap[i].fMove = fMove;
                if (fMove)
                {
                    if (fUseExactOrigin)
                    {
                        psap[i].pt = *pptOrigin;
                    }
                    else
                    {
                        if (pptItems)
                        {
                            psap[i].pt.x = ((pptItems[i].x * xMul) / xDiv) + pptOrigin->x;
                            psap[i].pt.y = ((pptItems[i].y * yMul) / yDiv) + pptOrigin->y;
                        }
                        else
                        {
                            pt.x += cxItem;
                            pt.y += cyItem;
                            psap[i].pt = pt;
                        }
                    }
                }

                // do regular selection from all of the rest of the items
                psap[i].uSelectFlags = SVSI_SELECT;
            }
        }

        // do this special one for the first only
        psap[0].uSelectFlags = SVSI_SELECT | SVSI_ENSUREVISIBLE | SVSI_DESELECTOTHERS | SVSI_FOCUSED;

        SendMessage(hwnd, SVM_SELECTANDPOSITIONITEM, cidl, (LPARAM)psap);

        if (fMove && medium.hGlobal)
            ReleaseStgMediumHGLOBAL(NULL, &medium);

        GlobalFree(psap);
    }
}