339 lines
8.6 KiB
C
339 lines
8.6 KiB
C
#include <windows.h>
|
|
#include <commctrl.h>
|
|
#include <shlobj.h>
|
|
|
|
#include "debug.h"
|
|
#include "common.h"
|
|
|
|
#include "autoscrl.h"
|
|
|
|
#include "nsc.h"
|
|
|
|
// BUGBUG: do nothing for now
|
|
#define DAD_DragLeave()
|
|
#define DAD_DragEnterEx(hwndLock, pt)
|
|
#define DAD_ShowDragImage(f)
|
|
#define DAD_DragMove(pt)
|
|
|
|
typedef struct { // tdt
|
|
IDropTarget dtgt;
|
|
UINT cRef;
|
|
|
|
NSC *pns;
|
|
|
|
RECT _rcLockWindow;
|
|
HTREEITEM _htiCur; // current tree item (dragging over)
|
|
IDropTarget *_pdtgtCur; // current drop target
|
|
IDataObject *_pdtobjCur; // current data object
|
|
DWORD _dwEffectCur; // current drag effect
|
|
DWORD _dwEffectIn; // *pdwEffect passed-in on last Move/Enter
|
|
DWORD _grfKeyState; // cached key state
|
|
POINT _ptLast; // last dragged over position
|
|
DWORD _dwLastTime;
|
|
AUTO_SCROLL_DATA asd;
|
|
} CTreeDropTarget;
|
|
|
|
STDMETHODIMP CTreeDropTarget_QueryInterface(IDropTarget *pdtgt, REFIID riid, void **ppvObj)
|
|
{
|
|
CTreeDropTarget * this = IToClass(CTreeDropTarget, dtgt, pdtgt);
|
|
|
|
if (IsEqualIID(riid, &IID_IDropTarget) || IsEqualIID(riid, &IID_IUnknown))
|
|
{
|
|
*ppvObj = pdtgt;
|
|
this->cRef++;
|
|
return S_OK;
|
|
}
|
|
|
|
*ppvObj = NULL;
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CTreeDropTarget_AddRef(IDropTarget *pdtgt)
|
|
{
|
|
CTreeDropTarget * this = IToClass(CTreeDropTarget, dtgt, pdtgt);
|
|
|
|
this->cRef++;
|
|
return this->cRef;
|
|
}
|
|
|
|
void CTreeDropTarget_ReleaseDataObject(CTreeDropTarget *this)
|
|
{
|
|
if (this->_pdtobjCur)
|
|
Release(this->_pdtobjCur);
|
|
|
|
this->_pdtobjCur = NULL;
|
|
}
|
|
|
|
void CTreeDropTarget_ReleaseCurrentDropTarget(CTreeDropTarget *this)
|
|
{
|
|
if (this->_pdtgtCur)
|
|
{
|
|
this->_pdtgtCur->lpVtbl->DragLeave(this->_pdtgtCur);
|
|
Release(this->_pdtgtCur);
|
|
this->_pdtgtCur = NULL;
|
|
this->_htiCur = NULL;
|
|
}
|
|
else
|
|
{
|
|
Assert(this->_htiCur == NULL);
|
|
}
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CTreeDropTarget_Release(IDropTarget * pdtgt)
|
|
{
|
|
CTreeDropTarget * this = IToClass(CTreeDropTarget, dtgt, pdtgt);
|
|
|
|
this->cRef--;
|
|
if (this->cRef > 0)
|
|
return this->cRef;
|
|
|
|
AssertMsg(this->_pdtgtCur == NULL, "drag leave was not called properly");
|
|
|
|
// if above is true we can remove this...
|
|
CTreeDropTarget_ReleaseCurrentDropTarget(this);
|
|
|
|
LocalFree(this);
|
|
|
|
return 0;
|
|
}
|
|
|
|
STDMETHODIMP CTreeDropTarget_DragEnter(IDropTarget *pdtgt, IDataObject *pdtobj, DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
|
|
{
|
|
CTreeDropTarget * this = IToClass(CTreeDropTarget, dtgt, pdtgt);
|
|
POINT pt;
|
|
HWND hwndLock;
|
|
|
|
DebugMsg(DM_TRACE, "sh - TR CTreeDropTarget::DragEnter called");
|
|
CTreeDropTarget_ReleaseDataObject(this);
|
|
this->_pdtobjCur = pdtobj;
|
|
this->_grfKeyState = grfKeyState;
|
|
AddRef(pdtobj);
|
|
Assert(this->_pdtgtCur == NULL);
|
|
Assert(this->_htiCur == NULL);
|
|
|
|
hwndLock = this->pns->hwndTree; // clip to this
|
|
GetWindowRect(hwndLock, &this->_rcLockWindow);
|
|
pt.x = ptl.x-this->_rcLockWindow.left;
|
|
pt.y = ptl.y-this->_rcLockWindow.top;
|
|
DAD_DragEnterEx(hwndLock, pt);
|
|
|
|
this->_ptLast.x = this->_ptLast.y = 0x7ffffff; // set bogus position
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CTreeDropTarget_DragOver(IDropTarget *pdtgt, DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
|
|
{
|
|
HRESULT hres = S_OK;
|
|
CTreeDropTarget * this = IToClass(CTreeDropTarget, dtgt, pdtgt);
|
|
TV_HITTESTINFO tvht;
|
|
HTREEITEM htiNew;
|
|
POINT pt = { ptl.x, ptl.y };
|
|
BOOL fSameImage = FALSE;
|
|
DWORD dwEffectScroll = 0;
|
|
|
|
ScreenToClient(this->pns->hwndTree, &pt);
|
|
|
|
if (DAD_AutoScroll(this->pns->hwndTree, &this->asd, &pt))
|
|
dwEffectScroll = DROPEFFECT_SCROLL;
|
|
|
|
tvht.pt = pt;
|
|
|
|
htiNew = TreeView_HitTest(this->pns->hwndTree, &tvht);
|
|
|
|
// don't allow droping on the item being dragged
|
|
if (htiNew == this->pns->htiDragging)
|
|
htiNew = NULL;
|
|
|
|
if (this->_htiCur != htiNew)
|
|
{
|
|
// change in target
|
|
|
|
this->_dwLastTime = GetTickCount(); // keep track for auto-expanding the tree
|
|
|
|
CTreeDropTarget_ReleaseCurrentDropTarget(this);
|
|
|
|
this->_dwEffectCur = 0; // assume error
|
|
|
|
DAD_ShowDragImage(FALSE);
|
|
|
|
TreeView_SelectDropTarget(this->pns->hwndTree, htiNew);
|
|
|
|
DAD_ShowDragImage(TRUE);
|
|
|
|
if (htiNew)
|
|
{
|
|
// get the drop target for the item we hit
|
|
|
|
LPITEMIDLIST pidl = _CacheParentShellFolder(this->pns, htiNew, NULL);
|
|
if (pidl)
|
|
{
|
|
IShellFolder *psf = this->pns->psfCache;
|
|
|
|
AddRef(psf);
|
|
|
|
if (pidl->mkid.cb == 0)
|
|
{
|
|
hres = psf->lpVtbl->CreateViewObject(psf, this->pns->hwnd, &IID_IDropTarget, &this->_pdtgtCur);
|
|
}
|
|
else
|
|
{
|
|
UINT dwAttr = SFGAO_DROPTARGET;
|
|
|
|
hres = psf->lpVtbl->GetAttributesOf(psf, 1, &pidl, &dwAttr);
|
|
|
|
if (SUCCEEDED(hres) && (dwAttr & SFGAO_DROPTARGET))
|
|
{
|
|
hres = psf->lpVtbl->GetUIObjectOf(psf, this->pns->hwnd, 1, &pidl, &IID_IDropTarget, NULL, &this->_pdtgtCur);
|
|
}
|
|
else
|
|
{
|
|
hres = E_INVALIDARG;
|
|
}
|
|
}
|
|
|
|
Release(psf);
|
|
}
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
this->_htiCur = htiNew;
|
|
|
|
this->_dwEffectCur = *pdwEffect; // pdwEffect is In/Out
|
|
hres = this->_pdtgtCur->lpVtbl->DragEnter(this->_pdtgtCur, this->_pdtobjCur, grfKeyState, ptl, &this->_dwEffectCur);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// No target change
|
|
|
|
// auto expand the tree
|
|
if (this->_htiCur)
|
|
{
|
|
DWORD dwNow = GetTickCount();
|
|
|
|
if ((dwNow - this->_dwLastTime) >= 1000)
|
|
{
|
|
this->_dwLastTime = dwNow;
|
|
DAD_ShowDragImage(FALSE);
|
|
this->pns->fAutoExpanding = TRUE;
|
|
TreeView_Expand(this->pns->hwndTree, this->_htiCur, TVE_EXPAND);
|
|
this->pns->fAutoExpanding = FALSE;
|
|
DAD_ShowDragImage(TRUE);
|
|
}
|
|
}
|
|
|
|
// maybe the key state changed
|
|
|
|
if ((this->_grfKeyState != grfKeyState) && this->_pdtgtCur)
|
|
{
|
|
this->_dwEffectCur = *pdwEffect;
|
|
hres = this->_pdtgtCur->lpVtbl->DragOver(this->_pdtgtCur, grfKeyState, ptl, &this->_dwEffectCur);
|
|
}
|
|
else
|
|
{
|
|
fSameImage = TRUE;
|
|
hres = S_OK;
|
|
}
|
|
}
|
|
|
|
DebugMsg(DM_TRACE, "sh TR - CTreeDropTarget_DragOver (In=%x, Out=%x)", *pdwEffect, this->_dwEffectCur);
|
|
|
|
this->_grfKeyState = grfKeyState;
|
|
*pdwEffect = this->_dwEffectCur | dwEffectScroll;
|
|
|
|
// We need pass pt relative to the locked window (not the client).
|
|
pt.x = ptl.x-this->_rcLockWindow.left;
|
|
pt.y = ptl.y-this->_rcLockWindow.top;
|
|
|
|
if (!(fSameImage && this->_ptLast.x == pt.x && this->_ptLast.y == pt.y))
|
|
{
|
|
DAD_DragMove(pt);
|
|
this->_ptLast.x = pt.x;
|
|
this->_ptLast.y = pt.y;
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CTreeDropTarget_DragLeave(IDropTarget *pdtgt)
|
|
{
|
|
CTreeDropTarget * this = IToClass(CTreeDropTarget, dtgt, pdtgt);
|
|
|
|
DebugMsg(DM_TRACE, "sh - TR CTreeDropTarget::DragLeave called");
|
|
CTreeDropTarget_ReleaseCurrentDropTarget(this);
|
|
CTreeDropTarget_ReleaseDataObject(this);
|
|
|
|
DAD_DragLeave();
|
|
|
|
TreeView_SelectDropTarget(this->pns->hwndTree, NULL);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CTreeDropTarget_Drop(IDropTarget *pdtgt, IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
|
|
{
|
|
HRESULT hres;
|
|
CTreeDropTarget * this = IToClass(CTreeDropTarget, dtgt, pdtgt);
|
|
|
|
if (this->_pdtgtCur)
|
|
{
|
|
hres = this->_pdtgtCur->lpVtbl->Drop(this->_pdtgtCur, pdtobj, grfKeyState, pt, pdwEffect);
|
|
}
|
|
else
|
|
{
|
|
DebugMsg(DM_TRACE, "sh TR - CTreeDropTarget::Drop - this->_pdtgtCur==NULL");
|
|
*pdwEffect = 0;
|
|
hres = S_OK;
|
|
}
|
|
|
|
CTreeDropTarget_DragLeave(pdtgt);
|
|
|
|
return hres;
|
|
}
|
|
|
|
const IDropTargetVtbl c_CTreeDropTargetVtbl = {
|
|
CTreeDropTarget_QueryInterface, CTreeDropTarget_AddRef, CTreeDropTarget_Release,
|
|
CTreeDropTarget_DragEnter,
|
|
CTreeDropTarget_DragOver,
|
|
CTreeDropTarget_DragLeave,
|
|
CTreeDropTarget_Drop
|
|
};
|
|
|
|
|
|
HRESULT CTreeDropTarget_Create(NSC *pns, IDropTarget **ppdtgt)
|
|
{
|
|
CTreeDropTarget * this = LocalAlloc(LPTR, sizeof(CTreeDropTarget));
|
|
if (this)
|
|
{
|
|
this->dtgt.lpVtbl = (IDropTargetVtbl *)&c_CTreeDropTargetVtbl;
|
|
this->cRef = 1;
|
|
this->pns = pns;
|
|
|
|
*ppdtgt = &this->dtgt;
|
|
return S_OK;
|
|
}
|
|
|
|
*ppdtgt = NULL;
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
void CTreeDropTarget_Register(NSC *pns)
|
|
{
|
|
IDropTarget *pdtgt;
|
|
|
|
if (SUCCEEDED(CTreeDropTarget_Create(pns, &pdtgt)))
|
|
{
|
|
RegisterDragDrop(pns->hwndTree, pdtgt);
|
|
Release(pdtgt);
|
|
}
|
|
}
|
|
|
|
void CTreeDropTarget_Revoke(NSC *pns)
|
|
{
|
|
RevokeDragDrop(pns->hwndTree);
|
|
}
|
|
|