|
|
#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))) { fAddComp = FALSE;
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;
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++; }
if (SUCCEEDED(StringCchCopy(szFilename, ARRAYSIZE(szFilename), PathFindFileName(szPath)))) { OPENFILENAME ofn = { 0 }; ofn.lStructSize = sizeof(ofn); 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)); fAddComp = TRUE; } } } } } } 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, int cchPath); 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(){ ASSERT( 0 != _cRef ); ULONG cRef = InterlockedDecrement(&_cRef); if ( 0 == cRef ) { delete this; } return cRef;}
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, ARRAYSIZE(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 = HIDA_GetPIDLFolder(pida); 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, ARRAYSIZE(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]; if (SUCCEEDED(StringCchCopy(szBriefPath, ARRAYSIZE(szBriefPath), BOBriefcasePath(pbo)))) { if (SUCCEEDED(StringCchCopy(szPath, ARRAYSIZE(szPath), BOFileList(pbo)))) // first file in list
{ TCHAR szPathTgt[MAX_PATH]; _GetPath(szPathTgt, ARRAYSIZE(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 cchSize){ 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) { if (SUCCEEDED(StringCchCopyA(pszCopiedHTML, (int)(cbHTMLSize + 1), pszHTML))) { //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 pszTemp; LPSTR pszBase = StrStrIA(pszCopiedHTML,"SourceURL:"); // Point to the char after :
if (pszBase) { pszBase += sizeof("SourceURL:")-1;
//Since each line can be terminated by a CR, CR/LF or LF check each case...
pszTemp = StrChrA(pszBase,'\n'); if (!pszTemp) pszTemp = StrChrA(pszBase,'\r');
if (pszTemp) *pszTemp = '\0'; pszTemp++; } else pszTemp = pszCopiedHTML;
//Pull out the Img Src
LPSTR pszImgSrc = StrStrIA(pszTemp,"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.
pszTemp = StrChrA(pszImgSrc,'\"'); // Find the end of the path.
} else { LPSTR pszTemp1; LPSTR pszTemp2;
pszImgSrc = StrChrA(pszImgSrcOrig,'='); if (pszImgSrc) { 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.
pszTemp = pszTemp1; // Assume quote terminates path.
if (!pszTemp1) pszTemp = pszTemp2; // Use '>' if quote not found.
if (pszTemp1 && pszTemp2 && (pszTemp2 < pszTemp1)) pszTemp = pszTemp2; // Change to having '>' terminate path if both exist and it comes first.
} }
if (pszImgSrc && pszTemp) { *pszTemp = '\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) && pszBase) { if (SUCCEEDED(UrlCombineA(pszBase, pszImgSrc, szImg, &cchSize, 0))) { fSucceeded = TRUE; } } else { if (lstrlenA(pszImgSrc) <= (int)cchSize) { StringCchCopyA(szImg, cchSize, 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; if (SUCCEEDED(StringCchCopyA(pToAD->szUrl, ARRAYSIZE(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 { LocalFree(pToAD); hr = E_FAIL; } } } 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 { *pszBuf = 0; 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, min(dw, sizeof(szTemp)), 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, ARRAYSIZE(szPath));
SHAnsiToTChar(szName, szBase, ARRAYSIZE(szBase)); PathAppend(szPath, szBase); if (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_FAIL; } } else { hr = E_UNEXPECTED; } pstm->Release(); } } medium.pstg->Release(); } pLockBytes->Release(); } return hr;}
HRESULT CFSDropTarget::_GetPath(LPTSTR pszPath, int cchPath){ return _pFolder->_GetPath(pszPath, cchPath);}
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, ARRAYSIZE(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, HIDA_GetPIDLFolder(pida), &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, ARRAYSIZE(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_HANDLERCFSDropTarget::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(ici), 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, int cchPath){ if (hNameMap) { SHNAMEMAPPING *pNameMapping; for (int i = 0; (pNameMapping = SHGetNameMappingPtr((HDSA)hNameMap, i)) != NULL; i++) { if (lstrcmpi(pszPath, pNameMapping->pszOldPath) == 0) { StringCchCopy(pszPath, cchPath, 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]; StrCpyN(szPath, pszFiles, ARRAYSIZE(szPath));
_MapName(hNameMap, szPath, ARRAYSIZE(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) + 1) * 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) + 1) * 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); // pszDest allocated exactly, strcpy okay.
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) + 1) * 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) + 1) * 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); // pszDest allocated exactly, strcpy okay.
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, UINT cchSrc, LPTSTR pszDest, UINT cchDest){ if ((1 == CountFiles(pszFiles)) && PathIsRoot(pszFiles) && (cchDest >= MAX_PATH) && (cchSrc >= MAX_PATH)) { 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, ARRAYSIZE(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, ARRAYSIZE(szAltSource), szDest, ARRAYSIZE(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, ARRAYSIZE(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(HIDA_GetPIDLFolder(pida), _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, ARRAYSIZE(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 = (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); }}
|
