2344 lines
70 KiB
C++
2344 lines
70 KiB
C++
#include "shellprv.h"
|
|
#include "defview.h"
|
|
#include "lvutil.h"
|
|
#include "ids.h"
|
|
#include "idlcomm.h"
|
|
#pragma hdrstop
|
|
|
|
#include "datautil.h"
|
|
#include "apithk.h"
|
|
|
|
BOOL DAD_IsDraggingImage(void);
|
|
void DAD_SetDragCursor(int idCursor);
|
|
BOOL DAD_IsDragging();
|
|
|
|
#define MONITORS_MAX 16 // Is this really the max?
|
|
|
|
#define DCID_NULL 0
|
|
#define DCID_NO 1
|
|
#define DCID_MOVE 2
|
|
#define DCID_COPY 3
|
|
#define DCID_LINK 4
|
|
#define DCID_MAX 5
|
|
|
|
#define TF_DRAGIMAGES 0x02000000
|
|
#define DRAGDROP_ALPHA 120
|
|
#define MAX_WIDTH_ALPHA 200
|
|
#define MAX_HEIGHT_ALPHA 200
|
|
|
|
#define CIRCULAR_ALPHA // Circular Alpha Blending Centered on Center of image
|
|
|
|
class CDragImages : public IDragSourceHelper, IDropTargetHelper
|
|
{
|
|
public:
|
|
// IUnknown methods
|
|
STDMETHODIMP QueryInterface(REFIID riid, void **ppv);
|
|
STDMETHODIMP_(ULONG) AddRef() { return 2; }; // One global Com object per process
|
|
STDMETHODIMP_(ULONG) Release() { return 1; }; // One global Com object per process
|
|
|
|
// IDragSourceHelper methods
|
|
STDMETHODIMP InitializeFromBitmap(LPSHDRAGIMAGE pshdi, IDataObject* pdtobj);
|
|
STDMETHODIMP InitializeFromWindow(HWND hwnd, POINT* ppt, IDataObject* pdtobj);
|
|
|
|
// IDropTargetHelper methods
|
|
STDMETHODIMP DragEnter(HWND hwndTarget, IDataObject* pdtobj, POINT* ppt, DWORD dwEffect);
|
|
STDMETHODIMP DragLeave();
|
|
STDMETHODIMP DragOver(POINT* ppt, DWORD dwEffect);
|
|
STDMETHODIMP Drop(IDataObject* pdtobj, POINT* ppt, DWORD dwEffect);
|
|
STDMETHODIMP Show(BOOL fShow);
|
|
|
|
// These are public so the DAD_* routines can access.
|
|
BOOL IsDragging() { return (Initialized() && _Single.bDragging); };
|
|
BOOL IsDraggingImage() { return (Initialized() && _fImage && _Single.bDragging); };
|
|
BOOL IsDraggingLayeredWindow() { return _shdi.hbmpDragImage != NULL; };
|
|
BOOL SetDragImage(HIMAGELIST himl, int index, POINT * pptOffset);
|
|
void SetDragCursor(int idCursor);
|
|
HWND GetTarget() { return _hwndTarget; }
|
|
BOOL Initialized();
|
|
DWORD GetThread() { return _idThread; };
|
|
void FreeDragData();
|
|
|
|
void ThreadDetach();
|
|
void ProcessDetach();
|
|
|
|
// for drag source feedback communication
|
|
void SetDropEffectCursor(int idCur);
|
|
|
|
CDragImages() {};
|
|
|
|
private:
|
|
~CDragImages();
|
|
|
|
void _InitDragData();
|
|
BOOL _IsLayeredSupported();
|
|
|
|
HRESULT _SaveToDataObject(IDataObject* pdtobj);
|
|
HRESULT _LoadFromDataObject(IDataObject* pdtobj);
|
|
|
|
HRESULT _LoadLayerdBitmapBits(HGLOBAL hGlobal);
|
|
HRESULT _SaveLayerdBitmapBits(HGLOBAL* phGlobal);
|
|
|
|
BOOL _ShowDragImageInterThread(HWND hwndLock, BOOL * pfShow);
|
|
|
|
// MultiRectDragging
|
|
void _MultipleDragShow(BOOL bShow);
|
|
void _MultipleDragStart(HWND hwndLock, LPRECT aRect, int nRects, POINT ptStart, POINT ptOffset);
|
|
void _MultipleDragMove(POINT ptNew);
|
|
HRESULT _SetLayerdDragging(LPSHDRAGIMAGE pshdi);
|
|
HRESULT _SetMultiItemDragging(HWND hwndLV, int cItems, POINT *pptOffset);
|
|
HRESULT _SetMultiRectDragging(int cItems, LPRECT prect, POINT *pptOffset);
|
|
|
|
// Merged Cursors
|
|
HBITMAP CreateColorBitmap(int cx, int cy);
|
|
void _DestroyCachedCursors();
|
|
HRESULT _GetCursorLowerRight(HCURSOR hcursor, int * px, int * py, POINT *pptHotSpot);
|
|
int _MapCursorIDToImageListIndex(int idCur);
|
|
int _AddCursorToImageList(HCURSOR hcur, LPCTSTR idMerge, POINT *pptHotSpot);
|
|
BOOL _MergeIcons(HCURSOR hcursor, LPCTSTR idMerge, HBITMAP *phbmImage, HBITMAP *phbmMask, POINT* pptHotSpot);
|
|
HCURSOR _SetCursorHotspot(HCURSOR hcur, POINT *ptHot);
|
|
|
|
// Helper Routines
|
|
BOOL _CreateDragWindow();
|
|
BOOL _PreProcessDragBitmap(void** ppvBits);
|
|
BOOL _IsTooBigForAlpha();
|
|
|
|
// Member Variables
|
|
SHDRAGIMAGE _shdi;
|
|
HWND _hwndTarget;
|
|
HWND _hwnd; // The HWND of the Layered Window
|
|
HDC _hdcDragImage;
|
|
HBITMAP _hbmpOld;
|
|
|
|
BOOL _fLayeredSupported;
|
|
BOOL _fCursorDataInited;
|
|
|
|
POINT _ptDebounce;
|
|
|
|
// Legacy drag support
|
|
BOOL _fImage;
|
|
POINT _ptOffset;
|
|
DWORD _idThread;
|
|
HIMAGELIST _himlCursors;
|
|
UINT _cRev;
|
|
int _aindex[DCID_MAX]; // will be initialized.
|
|
HCURSOR _ahcur[DCID_MAX];
|
|
POINT _aptHotSpot[DCID_MAX];
|
|
int _idCursor;
|
|
|
|
// _Single struct is used between DAD_Enter and DAD_Leave
|
|
struct
|
|
{
|
|
// Common part
|
|
BOOL bDragging;
|
|
BOOL bLocked;
|
|
HWND hwndLock;
|
|
BOOL bSingle; // Single imagelist dragging.
|
|
DWORD idThreadEntered;
|
|
|
|
// Multi-rect dragging specific part
|
|
struct
|
|
{
|
|
BOOL bShown;
|
|
LPRECT pRect;
|
|
int nRects;
|
|
POINT ptOffset;
|
|
POINT ptNow;
|
|
} _Multi;
|
|
} _Single;
|
|
|
|
// following fields are used only when fImage==FALSE
|
|
RECT* _parc; // cItems
|
|
UINT _cItems; // This is a sentinal. Needs to be the last item.
|
|
};
|
|
|
|
CDragImages::~CDragImages()
|
|
{
|
|
FreeDragData();
|
|
}
|
|
//
|
|
// Read 'Notes' in CDropSource_GiveFeedback for detail about this
|
|
// g_fDraggingOverSource flag, which is TRUE only if we are dragging
|
|
// over the source window itself with left mouse button
|
|
// (background and large/small icon mode only).
|
|
//
|
|
UINT g_cRev = 0;
|
|
CDragImages* g_pdiDragImages = NULL;
|
|
BOOL g_fDraggingOverSource = FALSE;
|
|
|
|
STDAPI CDragImages_CreateInstance(IUnknown* pUnkOuter, REFIID riid, void **ppvOut)
|
|
{
|
|
ASSERT(pUnkOuter == NULL); //Who's trying to aggregate us?
|
|
if (!g_pdiDragImages)
|
|
g_pdiDragImages = new CDragImages();
|
|
|
|
if (g_pdiDragImages && ppvOut) // ppvOut test for internal create usage
|
|
return g_pdiDragImages->QueryInterface(riid, ppvOut);
|
|
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
STDMETHODIMP CDragImages::QueryInterface(REFIID riid, void **ppv)
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENT(CDragImages, IDragSourceHelper),
|
|
QITABENT(CDragImages, IDropTargetHelper),
|
|
{ 0 },
|
|
};
|
|
return QISearch(this, qit, riid, ppv);
|
|
}
|
|
|
|
#define UM_KILLYOURSELF WM_USER
|
|
|
|
LRESULT CALLBACK DragWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
if (uMsg == UM_KILLYOURSELF)
|
|
{
|
|
DestroyWindow(hwnd);
|
|
|
|
return 0;
|
|
}
|
|
|
|
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
|
|
BOOL CDragImages::_CreateDragWindow()
|
|
{
|
|
if (_hwnd == NULL)
|
|
{
|
|
WNDCLASS wc = {0};
|
|
|
|
wc.hInstance = g_hinst;
|
|
wc.lpfnWndProc = DragWndProc;
|
|
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
|
|
wc.lpszClassName = TEXT("SysDragImage");
|
|
wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1); // NULL;
|
|
SHRegisterClass(&wc);
|
|
|
|
_hwnd = CreateWindowEx(WS_EX_TRANSPARENT | WS_EX_TOPMOST | WS_EX_LAYERED | WS_EX_TOOLWINDOW,
|
|
TEXT("SysDragImage"), TEXT("Drag"), WS_POPUPWINDOW,
|
|
0, 0, 50, 50, NULL, NULL, g_hinst, NULL);
|
|
|
|
if (!_hwnd)
|
|
return FALSE;
|
|
|
|
//
|
|
// This window should not be mirrored so that the image contents won't be flipped. [samera]
|
|
//
|
|
SetWindowBits(_hwnd, GWL_EXSTYLE, RTL_MIRRORED_WINDOW, 0);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CDragImages::Initialized()
|
|
{
|
|
return _fCursorDataInited;
|
|
}
|
|
|
|
void CDragImages::FreeDragData()
|
|
{
|
|
|
|
if (_hwnd)
|
|
{
|
|
SendMessage(_hwnd, UM_KILLYOURSELF, 0, 0);
|
|
_hwnd = NULL;
|
|
}
|
|
|
|
_fCursorDataInited = FALSE;
|
|
|
|
// Make sure we destroy the cursors on an invalidate.
|
|
if (_himlCursors)
|
|
_DestroyCachedCursors();
|
|
|
|
// Do we have an array?
|
|
if (_parc)
|
|
{
|
|
delete _parc;
|
|
_parc = NULL;
|
|
}
|
|
|
|
if (_fImage)
|
|
ImageList_EndDrag();
|
|
|
|
if (_hbmpOld)
|
|
{
|
|
SelectObject(_hdcDragImage, _hbmpOld);
|
|
_hbmpOld = NULL;
|
|
}
|
|
|
|
if (_hdcDragImage)
|
|
{
|
|
DeleteDC(_hdcDragImage);
|
|
_hdcDragImage = NULL;
|
|
}
|
|
|
|
if (_shdi.hbmpDragImage)
|
|
DeleteObject(_shdi.hbmpDragImage);
|
|
|
|
ZeroMemory(&_Single, sizeof(_Single));
|
|
ZeroMemory(&_shdi, sizeof(_shdi));
|
|
|
|
_ptOffset.x = 0;
|
|
_ptOffset.y = 0;
|
|
|
|
_ptDebounce.x = 0;
|
|
_ptDebounce.y = 0;
|
|
|
|
_hwndTarget = _hwnd = NULL;
|
|
_fCursorDataInited = _fLayeredSupported = FALSE;
|
|
_fImage = FALSE;
|
|
_idThread = 0;
|
|
_himlCursors = NULL;
|
|
_cRev = 0;
|
|
_idCursor = 0;
|
|
}
|
|
|
|
void CDragImages::_InitDragData()
|
|
{
|
|
_idThread = GetCurrentThreadId();
|
|
|
|
if (_himlCursors && _cRev != g_cRev)
|
|
_DestroyCachedCursors();
|
|
|
|
if (_himlCursors == NULL)
|
|
{
|
|
UINT uFlags = ILC_MASK | ILC_SHARED;
|
|
if (IS_BIDI_LOCALIZED_SYSTEM())
|
|
uFlags |= ILC_MIRROR;
|
|
|
|
//
|
|
// if this is not a palette device, use a DDB for the imagelist
|
|
// this is important when displaying high-color cursors
|
|
//
|
|
HDC hdc = GetDC(NULL);
|
|
if (!(GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE))
|
|
{
|
|
uFlags |= ILC_COLORDDB;
|
|
}
|
|
ReleaseDC(NULL, hdc);
|
|
|
|
_himlCursors = ImageList_Create(GetSystemMetrics(SM_CXCURSOR),
|
|
GetSystemMetrics(SM_CYCURSOR),
|
|
uFlags, 1, 0);
|
|
|
|
_cRev = g_cRev;
|
|
|
|
// We need to initialize s_cursors._aindex[*]
|
|
_MapCursorIDToImageListIndex(-1);
|
|
}
|
|
_fCursorDataInited = TRUE;
|
|
}
|
|
|
|
BOOL AreAllMonitorsAtLeast(int iBpp)
|
|
{
|
|
DISPLAY_DEVICE DisplayDevice;
|
|
BOOL fAreAllMonitorsAtLeast = TRUE;
|
|
|
|
for (int iEnum = 0; fAreAllMonitorsAtLeast && iEnum < MONITORS_MAX; iEnum++)
|
|
{
|
|
ZeroMemory(&DisplayDevice, sizeof(DISPLAY_DEVICE));
|
|
DisplayDevice.cb = sizeof(DISPLAY_DEVICE);
|
|
|
|
if (EnumDisplayDevices(NULL, iEnum, &DisplayDevice, 0) &&
|
|
(DisplayDevice.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP))
|
|
{
|
|
|
|
HDC hdc = CreateDC(NULL, (LPTSTR)DisplayDevice.DeviceName, NULL, NULL);
|
|
if (hdc)
|
|
{
|
|
int iBits = GetDeviceCaps(hdc, BITSPIXEL);
|
|
|
|
if (iBits < iBpp)
|
|
fAreAllMonitorsAtLeast = FALSE;
|
|
|
|
DeleteDC(hdc);
|
|
}
|
|
}
|
|
}
|
|
|
|
return fAreAllMonitorsAtLeast;
|
|
}
|
|
|
|
BOOL CDragImages::_IsLayeredSupported()
|
|
{
|
|
// For the first rev, we will only support Layered drag images
|
|
// when the Color depth is greater than 65k colors.
|
|
|
|
// We should ask everytime....
|
|
_fLayeredSupported = AreAllMonitorsAtLeast(16);
|
|
|
|
if (_fLayeredSupported)
|
|
{
|
|
BOOL bDrag;
|
|
if (SystemParametersInfo(SPI_GETDRAGFULLWINDOWS, 0, &bDrag, 0))
|
|
{
|
|
_fLayeredSupported = BOOLIFY(bDrag);
|
|
}
|
|
|
|
if (_fLayeredSupported)
|
|
_fLayeredSupported = SHRegGetBoolUSValue(REGSTR_EXPLORER_ADVANCED, TEXT("NewDragImages"), FALSE, TRUE);
|
|
}
|
|
return _fLayeredSupported;
|
|
}
|
|
|
|
//
|
|
// initialize the static drag image manager from a structure
|
|
// this is implemented for WindowLess controls that can act as a
|
|
// drag source.
|
|
//
|
|
HRESULT CDragImages::_SetLayerdDragging(LPSHDRAGIMAGE pshdi)
|
|
{
|
|
// We don't support being initialized from a bitmap when Layered Windows are not supported
|
|
HRESULT hr;
|
|
if (_IsLayeredSupported())
|
|
{
|
|
RIP(IsValidHANDLE(pshdi->hbmpDragImage));
|
|
|
|
_shdi = *pshdi; // Keep a copy of this.
|
|
|
|
_idCursor = -1; // Initialize this... This is an arbitraty place and can be put
|
|
// anywhere before the first Setcursor call
|
|
_InitDragData();
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
hr = E_FAIL;
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CDragImages::InitializeFromBitmap(LPSHDRAGIMAGE pshdi, IDataObject* pdtobj)
|
|
{
|
|
FreeDragData();
|
|
|
|
HRESULT hr = _SetLayerdDragging(pshdi);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = _SaveToDataObject(pdtobj);
|
|
if (FAILED(hr))
|
|
FreeDragData();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
BOOL ListView_HasMask(HWND hwnd)
|
|
{
|
|
HIMAGELIST himl = ListView_GetImageList(hwnd, LVSIL_NORMAL);
|
|
return himl && (ImageList_GetFlags(himl) & ILC_MASK);
|
|
}
|
|
|
|
//
|
|
// initialize the static drag image manager from an HWND that
|
|
// can process the RegisteredWindowMessage(DI_GETDRAGIMAGE)
|
|
//
|
|
STDMETHODIMP CDragImages::InitializeFromWindow(HWND hwnd, POINT* ppt, IDataObject* pdtobj)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
FreeDragData();
|
|
|
|
if (_IsLayeredSupported())
|
|
{
|
|
// Register the message that gets us the Bitmap from the control.
|
|
static int g_msgGetDragImage = 0;
|
|
if (g_msgGetDragImage == 0)
|
|
g_msgGetDragImage = RegisterWindowMessage(DI_GETDRAGIMAGE);
|
|
|
|
// Can this HWND generate a drag image for me?
|
|
if (g_msgGetDragImage && SendMessage(hwnd, g_msgGetDragImage, 0, (LPARAM)&_shdi))
|
|
{
|
|
// Yes; Now we select that into the window
|
|
hr = _SetLayerdDragging(&_shdi);
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
TCHAR szClassName[50];
|
|
|
|
if (GetClassName(hwnd, szClassName, ARRAYSIZE(szClassName)))
|
|
{
|
|
if (lstrcmpi(szClassName, WC_LISTVIEW) == 0)
|
|
{
|
|
POINT ptOffset = {0,0};
|
|
|
|
if (ppt)
|
|
ptOffset = *ppt;
|
|
|
|
int cItems = ListView_GetSelectedCount(hwnd);
|
|
if (cItems >= 1)
|
|
{
|
|
if ((cItems == 1) && ListView_HasMask(hwnd))
|
|
{
|
|
POINT ptTemp;
|
|
HIMAGELIST himl = ListView_CreateDragImage(hwnd, ListView_GetNextItem(hwnd, -1, LVNI_SELECTED), &ptTemp);
|
|
if (himl)
|
|
{
|
|
ClientToScreen(hwnd, &ptTemp);
|
|
ptOffset.x -= ptTemp.x;
|
|
|
|
// Since the listview is mirrored, then mirror the selected
|
|
// icon coord. This would result in negative offset so let's
|
|
// compensate. [samera]
|
|
if (IS_WINDOW_RTL_MIRRORED(hwnd))
|
|
ptOffset.x *= -1;
|
|
|
|
ptOffset.y -= ptTemp.y;
|
|
SetDragImage(himl, 0, &ptOffset);
|
|
ImageList_Destroy(himl);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = _SetMultiItemDragging(hwnd, cItems, &ptOffset);
|
|
}
|
|
}
|
|
}
|
|
else if (lstrcmpi(szClassName, WC_TREEVIEW) == 0)
|
|
{
|
|
HIMAGELIST himlDrag = TreeView_CreateDragImage(hwnd, NULL);
|
|
if (himlDrag)
|
|
{
|
|
SetDragImage(himlDrag, 0, NULL);
|
|
ImageList_Destroy(himlDrag);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// ignore failure here as this will still work in process due to the globals
|
|
// fonts folder depends on this
|
|
_SaveToDataObject(pdtobj);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// create the drag window in the layered window case, or to begin drawing the
|
|
// Multi Rect or icon drag images.
|
|
//
|
|
STDMETHODIMP CDragImages::DragEnter(HWND hwndTarget, IDataObject* pdtobj, POINT* ppt, DWORD dwEffect)
|
|
{
|
|
HRESULT hr = _LoadFromDataObject(pdtobj);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_hwndTarget = hwndTarget ? hwndTarget : GetDesktopWindow();
|
|
SetDragCursor(-1);
|
|
_Single.bDragging = TRUE;
|
|
_Single.bSingle = _fImage;
|
|
_Single.hwndLock = _hwndTarget;
|
|
_Single.bLocked = FALSE;
|
|
_Single.idThreadEntered = GetCurrentThreadId();
|
|
|
|
_ptDebounce.x = 0;
|
|
_ptDebounce.y = 0;
|
|
|
|
if (_shdi.hbmpDragImage)
|
|
{
|
|
TraceMsg(TF_DRAGIMAGES, "CDragImages::DragEnter : Creating Drag Window");
|
|
// At this point the information has been read from the data object.
|
|
// Reconstruct the HWND if necessary
|
|
if (_CreateDragWindow() && _hdcDragImage)
|
|
{
|
|
POINT ptSrc = {0, 0};
|
|
POINT pt;
|
|
|
|
SetWindowPos(_hwnd, NULL, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE |
|
|
SWP_NOSIZE | SWP_NOZORDER | SWP_SHOWWINDOW);
|
|
|
|
GetMsgPos(&pt);
|
|
|
|
pt.x -= _shdi.ptOffset.x;
|
|
pt.y -= _shdi.ptOffset.y;
|
|
|
|
BLENDFUNCTION blend;
|
|
blend.BlendOp = AC_SRC_OVER;
|
|
blend.BlendFlags = 0;
|
|
blend.AlphaFormat = AC_SRC_ALPHA;
|
|
blend.SourceConstantAlpha = 0xFF /*DRAGDROP_ALPHA*/;
|
|
|
|
HDC hdc = GetDC(_hwnd);
|
|
if (hdc)
|
|
{
|
|
DWORD fULWType = ULW_ALPHA;
|
|
|
|
// Should have been preprocess already
|
|
UpdateLayeredWindow(_hwnd, hdc, &pt, &(_shdi.sizeDragImage),
|
|
_hdcDragImage, &ptSrc, _shdi.crColorKey,
|
|
&blend, fULWType);
|
|
|
|
ReleaseDC(_hwnd, hdc);
|
|
}
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// These are in Client Cordinates, not screen coords. Translate:
|
|
POINT pt = *ppt;
|
|
RECT rc;
|
|
GetWindowRect(_hwndTarget, &rc);
|
|
pt.x -= rc.left;
|
|
pt.y -= rc.top;
|
|
if (_fImage)
|
|
{
|
|
// Avoid the flicker by always pass even coords
|
|
ImageList_DragEnter(hwndTarget, pt.x & ~1, pt.y & ~1);
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
_MultipleDragStart(hwndTarget, _parc, _cItems, pt, _ptOffset);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
|
|
//
|
|
// We should always show the image whenever this function is called.
|
|
//
|
|
Show(TRUE);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// kill the Layered Window, or to stop painting the icon or rect drag images
|
|
//
|
|
STDMETHODIMP CDragImages::DragLeave()
|
|
{
|
|
TraceMsg(TF_DRAGIMAGES, "CDragImages::DragLeave");
|
|
if (Initialized())
|
|
{
|
|
if (_hwnd)
|
|
{
|
|
FreeDragData();
|
|
}
|
|
else if (_Single.bDragging &&
|
|
_Single.idThreadEntered == GetCurrentThreadId())
|
|
{
|
|
Show(FALSE);
|
|
|
|
if (_fImage)
|
|
{
|
|
ImageList_DragLeave(_Single.hwndLock);
|
|
}
|
|
|
|
_Single.bDragging = FALSE;
|
|
|
|
DAD_SetDragImage((HIMAGELIST)-1, NULL);
|
|
}
|
|
|
|
_ptDebounce.x = 0;
|
|
_ptDebounce.y = 0;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// move the Layered window or to rerender the icon or rect images within
|
|
// the Window they are over.
|
|
//
|
|
STDMETHODIMP CDragImages::DragOver(POINT* ppt, DWORD dwEffect)
|
|
{
|
|
if (Initialized())
|
|
{
|
|
TraceMsg(TF_DRAGIMAGES, "CDragImages::DragOver pt {%d, %d}", ppt->x, ppt->y);
|
|
// Avoid the flicker by always pass even coords
|
|
ppt->x &= ~1;
|
|
ppt->y &= ~1;
|
|
|
|
if (_ptDebounce.x != ppt->x || _ptDebounce.y != ppt->y)
|
|
{
|
|
_ptDebounce.x = ppt->x;
|
|
_ptDebounce.y = ppt->y;
|
|
if (IsDraggingLayeredWindow())
|
|
{
|
|
POINT pt;
|
|
GetCursorPos(&pt);
|
|
pt.x -= _shdi.ptOffset.x;
|
|
pt.y -= _shdi.ptOffset.y;
|
|
|
|
SetWindowPos(_hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE |
|
|
SWP_NOSIZE | SWP_SHOWWINDOW);
|
|
|
|
UpdateLayeredWindow(_hwnd, NULL, &pt, NULL, NULL, NULL, 0,
|
|
NULL, 0);
|
|
}
|
|
else
|
|
{
|
|
// These are in Client Cordinates, not screen coords. Translate:
|
|
POINT pt = *ppt;
|
|
RECT rc;
|
|
GetWindowRect(_hwndTarget, &rc);
|
|
pt.x -= rc.left;
|
|
pt.y -= rc.top;
|
|
if (_fImage)
|
|
{
|
|
ImageList_DragMove(pt.x, pt.y);
|
|
}
|
|
else
|
|
{
|
|
_MultipleDragMove(pt);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// do any cleanup after a drop (Currently calls DragLeave)
|
|
//
|
|
STDMETHODIMP CDragImages::Drop(IDataObject* pdtobj, POINT* ppt, DWORD dwEffect)
|
|
{
|
|
return DragLeave();
|
|
}
|
|
|
|
// initialize the static drag image manager from a structure
|
|
// this is implemented for WindowLess controls that can act as a
|
|
// drag source.
|
|
//
|
|
void CDragImages::SetDragCursor(int idCursor)
|
|
{
|
|
//
|
|
// Ignore if we are dragging over ourselves.
|
|
//
|
|
if (IsDraggingImage())
|
|
{
|
|
POINT ptHotSpot;
|
|
|
|
if (_himlCursors && (idCursor != -1))
|
|
{
|
|
int iIndex = _MapCursorIDToImageListIndex(idCursor);
|
|
if (iIndex != -1)
|
|
{
|
|
ImageList_GetDragImage(NULL, &ptHotSpot);
|
|
ptHotSpot.x -= _aptHotSpot[idCursor].x;
|
|
ptHotSpot.y -= _aptHotSpot[idCursor].y;
|
|
if (ptHotSpot.x < 0)
|
|
{
|
|
ptHotSpot.x = 0;
|
|
}
|
|
|
|
if (ptHotSpot.y < 0)
|
|
{
|
|
ptHotSpot.y = 0;
|
|
}
|
|
|
|
ImageList_SetDragCursorImage(_himlCursors, iIndex, ptHotSpot.x, ptHotSpot.y);
|
|
}
|
|
else
|
|
{
|
|
// You passed a bad Cursor ID.
|
|
ASSERT(0);
|
|
}
|
|
}
|
|
|
|
_idCursor = idCursor;
|
|
}
|
|
}
|
|
|
|
// init our state from the hGlobal so we can draw
|
|
HRESULT CDragImages::_LoadLayerdBitmapBits(HGLOBAL hGlobal)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if (!Initialized())
|
|
{
|
|
ASSERT(_shdi.hbmpDragImage == NULL);
|
|
ASSERT(_hdcDragImage == NULL);
|
|
|
|
HDC hdcScreen = GetDC(NULL);
|
|
if (hdcScreen)
|
|
{
|
|
void *pvDragStuff = (void*)GlobalLock(hGlobal);
|
|
if (pvDragStuff)
|
|
{
|
|
CopyMemory(&_shdi, pvDragStuff, sizeof(SHDRAGIMAGE));
|
|
|
|
BITMAPINFO bmi = {0};
|
|
|
|
// Create a buffer to read the bits into
|
|
bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
|
bmi.bmiHeader.biWidth = _shdi.sizeDragImage.cx;
|
|
bmi.bmiHeader.biHeight = _shdi.sizeDragImage.cy;
|
|
bmi.bmiHeader.biPlanes = 1;
|
|
bmi.bmiHeader.biBitCount = 32;
|
|
bmi.bmiHeader.biCompression = BI_RGB;
|
|
|
|
// Next create a DC and an HBITMAP.
|
|
_hdcDragImage = CreateCompatibleDC(hdcScreen);
|
|
if (_hdcDragImage)
|
|
{
|
|
void *pvBits;
|
|
_shdi.hbmpDragImage = CreateDIBSection(_hdcDragImage, &bmi, DIB_RGB_COLORS, &pvBits, NULL, NULL);
|
|
if (_shdi.hbmpDragImage)
|
|
{
|
|
_hbmpOld = (HBITMAP)SelectObject(_hdcDragImage, _shdi.hbmpDragImage);
|
|
|
|
// then Set the bits into the Bitmap
|
|
RGBQUAD* pvStart = (RGBQUAD*)((BYTE*)pvDragStuff + sizeof(SHDRAGIMAGE));
|
|
DWORD dwCount = _shdi.sizeDragImage.cx * _shdi.sizeDragImage.cy * sizeof(RGBQUAD);
|
|
CopyMemory((RGBQUAD*)pvBits, (RGBQUAD*)pvStart, dwCount);
|
|
|
|
hr = S_OK; // success!
|
|
}
|
|
}
|
|
GlobalUnlock(hGlobal);
|
|
}
|
|
ReleaseDC(NULL, hdcScreen);
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
// Writes the written information into phGlobal to recreate the drag image
|
|
HRESULT CDragImages::_SaveLayerdBitmapBits(HGLOBAL* phGlobal)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
if (Initialized())
|
|
{
|
|
ASSERT(_shdi.hbmpDragImage);
|
|
|
|
DWORD cbImageSize = _shdi.sizeDragImage.cx * _shdi.sizeDragImage.cy * sizeof(RGBQUAD);
|
|
*phGlobal = GlobalAlloc(GPTR, cbImageSize + sizeof(SHDRAGIMAGE));
|
|
if (*phGlobal)
|
|
{
|
|
void *pvDragStuff = GlobalLock(*phGlobal);
|
|
CopyMemory(pvDragStuff, &_shdi, sizeof(SHDRAGIMAGE));
|
|
|
|
void *pvBits;
|
|
hr = _PreProcessDragBitmap(&pvBits) ? S_OK : E_FAIL;
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
RGBQUAD* pvStart = (RGBQUAD*)((BYTE*)pvDragStuff + sizeof(SHDRAGIMAGE));
|
|
DWORD dwCount = _shdi.sizeDragImage.cx * _shdi.sizeDragImage.cy * sizeof(RGBQUAD);
|
|
CopyMemory((RGBQUAD*)pvStart, (RGBQUAD*)pvBits, dwCount);
|
|
}
|
|
GlobalUnlock(*phGlobal);
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
BOOL CDragImages::_IsTooBigForAlpha()
|
|
{
|
|
BOOL fTooBig = FALSE;
|
|
int dSelectionArea = _shdi.sizeDragImage.cx * _shdi.sizeDragImage.cy;
|
|
|
|
// The number here is "It just feels right" or
|
|
// about 3 Thumbnail icons linned up next to each other.
|
|
if ( dSelectionArea > 0x10000 )
|
|
fTooBig = TRUE;
|
|
|
|
return fTooBig;
|
|
}
|
|
|
|
|
|
BOOL IsColorKey(RGBQUAD rgbPixel, COLORREF crKey)
|
|
{
|
|
// COLORREF is backwards to RGBQUAD
|
|
return InRange( rgbPixel.rgbBlue, ((crKey & 0xFF0000) >> 16) - 5, ((crKey & 0xFF0000) >> 16) + 5) &&
|
|
InRange( rgbPixel.rgbGreen, ((crKey & 0x00FF00) >> 8) - 5, ((crKey & 0x00FF00) >> 8) + 5) &&
|
|
InRange( rgbPixel.rgbRed, ((crKey & 0x0000FF) >> 0) - 5, ((crKey & 0x0000FF) >> 0) + 5);
|
|
}
|
|
|
|
#ifdef RADIAL
|
|
|
|
int QuickRoot(int n, int iNum)
|
|
{
|
|
|
|
int iRoot = iNum;
|
|
for (int i=10; i > 0; i--)
|
|
{
|
|
int iOld = iRoot;
|
|
iRoot = (iRoot + iNum/iRoot)/2;
|
|
if (iRoot == iOld)
|
|
break;
|
|
}
|
|
|
|
return iRoot;
|
|
}
|
|
|
|
#endif
|
|
|
|
BOOL CDragImages::_PreProcessDragBitmap(void** ppvBits)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
|
|
ASSERT(_hdcDragImage == NULL);
|
|
_hdcDragImage = CreateCompatibleDC(NULL);
|
|
if (_hdcDragImage)
|
|
{
|
|
ULONG* pul;
|
|
HBITMAP hbmpResult = NULL;
|
|
HBITMAP hbmpOld;
|
|
HDC hdcSource = NULL;
|
|
BITMAPINFO bmi = {0};
|
|
HBITMAP hbmp = _shdi.hbmpDragImage;
|
|
|
|
bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
|
bmi.bmiHeader.biWidth = _shdi.sizeDragImage.cx;
|
|
bmi.bmiHeader.biHeight = _shdi.sizeDragImage.cy;
|
|
bmi.bmiHeader.biPlanes = 1;
|
|
bmi.bmiHeader.biBitCount = 32;
|
|
bmi.bmiHeader.biCompression = BI_RGB;
|
|
|
|
hdcSource = CreateCompatibleDC(_hdcDragImage);
|
|
if (hdcSource)
|
|
{
|
|
hbmpResult = CreateDIBSection(_hdcDragImage,
|
|
&bmi,
|
|
DIB_RGB_COLORS,
|
|
ppvBits,
|
|
NULL,
|
|
0);
|
|
|
|
if (hbmpResult)
|
|
{
|
|
_hbmpOld = (HBITMAP)SelectObject(_hdcDragImage, hbmpResult);
|
|
hbmpOld = (HBITMAP)SelectObject(hdcSource, hbmp);
|
|
|
|
BitBlt(_hdcDragImage, 0, 0, _shdi.sizeDragImage.cx, _shdi.sizeDragImage.cy,
|
|
hdcSource, 0, 0, SRCCOPY);
|
|
|
|
pul = (ULONG*)*ppvBits;
|
|
|
|
int iOffsetX = _shdi.ptOffset.x;
|
|
int iOffsetY = _shdi.ptOffset.y;
|
|
int iDenomX = max(_shdi.sizeDragImage.cx - iOffsetX, iOffsetX);
|
|
int iDenomY = max(_shdi.sizeDragImage.cy - iOffsetY, iOffsetY);
|
|
BOOL fRadialFade = TRUE;
|
|
// If both are less than the max, then no radial fade.
|
|
if (_shdi.sizeDragImage.cy <= MAX_HEIGHT_ALPHA && _shdi.sizeDragImage.cx <= MAX_WIDTH_ALPHA)
|
|
fRadialFade = FALSE;
|
|
|
|
for (int Y = 0; Y < _shdi.sizeDragImage.cy; Y++)
|
|
{
|
|
int y = _shdi.sizeDragImage.cy - Y; // Bottom up DIB.
|
|
for (int x = 0; x < _shdi.sizeDragImage.cx; x++)
|
|
{
|
|
RGBQUAD* prgb = (RGBQUAD*)&pul[Y * _shdi.sizeDragImage.cx + x];
|
|
|
|
if (_shdi.crColorKey != CLR_NONE &&
|
|
IsColorKey(*prgb, _shdi.crColorKey))
|
|
{
|
|
// Write a pre-multiplied value of 0:
|
|
|
|
*((DWORD*)prgb) = 0;
|
|
}
|
|
else
|
|
{
|
|
int Alpha = prgb->rgbReserved;
|
|
if (_shdi.crColorKey != CLR_NONE)
|
|
{
|
|
Alpha = DRAGDROP_ALPHA;
|
|
}
|
|
else
|
|
{
|
|
Alpha -= (Alpha / 3);
|
|
}
|
|
|
|
if (fRadialFade && Alpha > 0)
|
|
{
|
|
// This does not generate a smooth curve, but this is just
|
|
// an effect, not trying to be accurate here.
|
|
|
|
// 3 devides per pixel
|
|
int ddx = (x < iOffsetX)? iOffsetX - x : x - iOffsetX;
|
|
int ddy = (y < iOffsetY)? iOffsetY - y : y - iOffsetY;
|
|
|
|
__int64 iAlphaX = (100000l - (((__int64)ddx * 100000l) / (iDenomX )));
|
|
__int64 iAlphaY = (100000l - (((__int64)ddy * 100000l) / (iDenomY )));
|
|
|
|
ASSERT (iAlphaX >= 0);
|
|
ASSERT (iAlphaY >= 0);
|
|
|
|
__int64 iDenom = 100000;
|
|
iDenom *= 100000;
|
|
|
|
Alpha = (int) ((Alpha * iAlphaX * iAlphaY * 100000) / (iDenom* 141428));
|
|
}
|
|
|
|
ASSERT(Alpha <= 0xFF);
|
|
prgb->rgbReserved = (BYTE)Alpha;
|
|
prgb->rgbRed = ((prgb->rgbRed * Alpha) + 128) / 255;
|
|
prgb->rgbGreen = ((prgb->rgbGreen * Alpha) + 128) / 255;
|
|
prgb->rgbBlue = ((prgb->rgbBlue * Alpha) + 128) / 255;
|
|
}
|
|
}
|
|
}
|
|
|
|
DeleteObject(hbmp);
|
|
_shdi.hbmpDragImage = hbmpResult;
|
|
|
|
fRet = TRUE;
|
|
|
|
if (hbmpOld)
|
|
SelectObject(hdcSource, hbmpOld);
|
|
}
|
|
|
|
DeleteObject(hdcSource);
|
|
}
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
CLIPFORMAT _GetDragContentsCF()
|
|
{
|
|
static UINT s_cfDragContents = 0;
|
|
if (0 == s_cfDragContents)
|
|
s_cfDragContents = RegisterClipboardFormat(CFSTR_DRAGCONTEXT);
|
|
return (CLIPFORMAT) s_cfDragContents;
|
|
}
|
|
|
|
CLIPFORMAT _GetDragImageBitssCF()
|
|
{
|
|
static UINT s_cfDragImageBitss = 0;
|
|
if (0 == s_cfDragImageBitss)
|
|
s_cfDragImageBitss = RegisterClipboardFormat(TEXT("DragImageBits"));
|
|
return (CLIPFORMAT) s_cfDragImageBitss;
|
|
}
|
|
|
|
|
|
// persist our state into the data object. so on the target side they can grab this
|
|
// data out and render the thing being dragged
|
|
|
|
HRESULT CDragImages::_SaveToDataObject(IDataObject *pdtobj)
|
|
{
|
|
HRESULT hr = E_FAIL; // one form of the saves below must succeed
|
|
if (Initialized())
|
|
{
|
|
STGMEDIUM medium = {0};
|
|
medium.tymed = TYMED_ISTREAM;
|
|
|
|
if (SUCCEEDED(CreateStreamOnHGlobal(NULL, TRUE, &medium.pstm)))
|
|
{
|
|
// Set the header .
|
|
DragContextHeader hdr = {0};
|
|
hdr.fImage = _fImage;
|
|
hdr.fLayered = IsDraggingLayeredWindow();
|
|
hdr.ptOffset = _ptOffset;
|
|
|
|
//First Write the drag context header
|
|
ULONG ulWritten;
|
|
if (SUCCEEDED(medium.pstm->Write(&hdr, sizeof(hdr), &ulWritten)) &&
|
|
(ulWritten == sizeof(hdr)))
|
|
{
|
|
if (hdr.fLayered)
|
|
{
|
|
STGMEDIUM mediumBits = {0};
|
|
// Set the medium.
|
|
mediumBits.tymed = TYMED_HGLOBAL;
|
|
|
|
// Write out layered window information
|
|
hr = _SaveLayerdBitmapBits(&mediumBits.hGlobal);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
FORMATETC fmte = {_GetDragImageBitssCF(), NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
|
|
|
|
// Set the medium in the data.
|
|
hr = pdtobj->SetData(&fmte, &mediumBits, TRUE);
|
|
if (FAILED(hr))
|
|
ReleaseStgMedium(&mediumBits); // cleanup
|
|
}
|
|
}
|
|
else if (hdr.fImage)
|
|
{
|
|
// write an image
|
|
|
|
HIMAGELIST himl = ImageList_GetDragImage(NULL, NULL);
|
|
if (ImageList_Write(himl, medium.pstm))
|
|
{
|
|
hr = S_OK; // success
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// multi rect
|
|
|
|
if (SUCCEEDED(medium.pstm->Write(&_cItems, sizeof(_cItems), &ulWritten)) &&
|
|
(ulWritten == sizeof(_cItems)))
|
|
{
|
|
// Write the rects into the stream
|
|
if (SUCCEEDED(medium.pstm->Write(_parc, sizeof(_parc[0]) * _cItems, &ulWritten)) &&
|
|
(ulWritten == (sizeof(_parc[0]) * _cItems)))
|
|
{
|
|
hr = S_OK; // success
|
|
}
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Set the seek pointer at the beginning.
|
|
medium.pstm->Seek(g_li0, STREAM_SEEK_SET, NULL);
|
|
|
|
// Set the Formatetc
|
|
FORMATETC fmte = {_GetDragContentsCF(), NULL, DVASPECT_CONTENT, -1, TYMED_ISTREAM};
|
|
|
|
// Set the medium in the data.
|
|
hr = pdtobj->SetData(&fmte, &medium, TRUE);
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
ReleaseStgMedium(&medium);
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
// Gets the information to rebuild the drag images from the data object
|
|
HRESULT CDragImages::_LoadFromDataObject(IDataObject *pdtobj)
|
|
{
|
|
// Check if we have a drag context
|
|
HRESULT hr;
|
|
|
|
// NULL pdtobj is for the old DAD_DragEnterXXX() APIs...
|
|
// we hope this in the same process
|
|
if (Initialized() || !pdtobj)
|
|
{
|
|
hr = S_OK; // already loaded
|
|
}
|
|
else
|
|
{
|
|
// Set the format we are interested in
|
|
FORMATETC fmte = {_GetDragContentsCF(), NULL, DVASPECT_CONTENT, -1, TYMED_ISTREAM};
|
|
|
|
//if the data object has the format we are interested in
|
|
// then Get the data
|
|
STGMEDIUM medium = {0};
|
|
hr = pdtobj->GetData(&fmte, &medium);
|
|
if (SUCCEEDED(hr)) // if no pstm, bag out.
|
|
{
|
|
// Set the seek pointer at the beginning. PARANOIA: This is for people
|
|
// Who don't set the seek for me.
|
|
medium.pstm->Seek(g_li0, STREAM_SEEK_SET, NULL);
|
|
|
|
//First Read the drag context header
|
|
DragContextHeader hdr;
|
|
if (SUCCEEDED(IStream_Read(medium.pstm, &hdr, sizeof(hdr))))
|
|
{
|
|
if (hdr.fLayered)
|
|
{
|
|
STGMEDIUM mediumBits;
|
|
FORMATETC fmte = {_GetDragImageBitssCF(), NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
|
|
|
|
hr = pdtobj->GetData(&fmte, &mediumBits);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = _LoadLayerdBitmapBits(mediumBits.hGlobal);
|
|
ReleaseStgMedium(&mediumBits);
|
|
}
|
|
}
|
|
else if (hdr.fImage)
|
|
{
|
|
// single image
|
|
HIMAGELIST himl = ImageList_Read(medium.pstm);
|
|
if (himl)
|
|
{
|
|
DAD_SetDragImage(himl, &(hdr.ptOffset));
|
|
ImageList_Destroy(himl);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// multi rect
|
|
int cItems;
|
|
if (SUCCEEDED(IStream_Read(medium.pstm, &cItems, sizeof(cItems))))
|
|
{
|
|
RECT *prect = (RECT *)LocalAlloc(LPTR, sizeof(*prect) * cItems);
|
|
if (prect)
|
|
{
|
|
if (SUCCEEDED(IStream_Read(medium.pstm, prect, sizeof(*prect) * cItems)))
|
|
{
|
|
hr = _SetMultiRectDragging(cItems, prect, &hdr.ptOffset);
|
|
}
|
|
LocalFree(prect);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
_InitDragData();
|
|
|
|
// Set the seek pointer at the beginning. Just cleaning up...
|
|
medium.pstm->Seek(g_li0, STREAM_SEEK_SET, NULL);
|
|
|
|
// Release the stg medium.
|
|
ReleaseStgMedium(&medium);
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
// Shows or hides the drag images. NOTE: Doesn't do anything in the layered window case.
|
|
// We don't need to because this function is specifically for drawing to a locked window.
|
|
STDMETHODIMP CDragImages::Show(BOOL bShow)
|
|
{
|
|
BOOL fOld = bShow;
|
|
TraceMsg(TF_DRAGIMAGES, "CDragImages::Show(%s)", bShow? TEXT("true") : TEXT("false"));
|
|
|
|
if (!Initialized() || !_Single.bDragging)
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
|
|
// No point in showing and hiding a Window. This causes unnecessary flicker.
|
|
if (_hwnd)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
// If we're going across thread boundaries we have to try a context switch
|
|
if (GetCurrentThreadId() != GetWindowThreadProcessId(_Single.hwndLock, NULL) &&
|
|
_ShowDragImageInterThread(_Single.hwndLock, &fOld))
|
|
return fOld;
|
|
|
|
fOld = _Single.bLocked;
|
|
|
|
//
|
|
// If we are going to show the drag image, lock the target window.
|
|
//
|
|
if (bShow && !_Single.bLocked)
|
|
{
|
|
TraceMsg(TF_DRAGIMAGES, "CDragImages::Show : Shown and not locked");
|
|
UpdateWindow(_Single.hwndLock);
|
|
LockWindowUpdate(_Single.hwndLock);
|
|
_Single.bLocked = TRUE;
|
|
}
|
|
|
|
if (_Single.bSingle)
|
|
{
|
|
TraceMsg(TF_DRAGIMAGES, "CDragImages::Show : Calling ImageList_DragShowNoLock");
|
|
ImageList_DragShowNolock(bShow);
|
|
}
|
|
else
|
|
{
|
|
TraceMsg(TF_DRAGIMAGES, "CDragImages::Show : MultiDragShow");
|
|
_MultipleDragShow(bShow);
|
|
}
|
|
|
|
//
|
|
// If we have just hide the drag image, unlock the target window.
|
|
//
|
|
if (!bShow && _Single.bLocked)
|
|
{
|
|
TraceMsg(TF_DRAGIMAGES, "CDragImages::Show : hiding image, unlocking");
|
|
LockWindowUpdate(NULL);
|
|
_Single.bLocked = FALSE;
|
|
}
|
|
|
|
return fOld ? S_OK : S_FALSE;
|
|
}
|
|
|
|
// tell the drag source to hide or unhide the drag image to allow
|
|
// the destination to do drawing (unlock the screen)
|
|
//
|
|
// in:
|
|
// bShow FALSE - hide the drag image, allow drawing
|
|
// TRUE - show the drag image, no drawing allowed after this
|
|
|
|
// Helper function for DAD_ShowDragImage - handles the inter-thread case.
|
|
// We need to handle this case differently because LockWindowUpdate calls fail
|
|
// if they are on the wrong thread.
|
|
|
|
BOOL CDragImages::_ShowDragImageInterThread(HWND hwndLock, BOOL * pfShow)
|
|
{
|
|
TCHAR szClassName[50];
|
|
|
|
if (GetClassName(hwndLock, szClassName, ARRAYSIZE(szClassName)))
|
|
{
|
|
UINT uMsg = 0;
|
|
ULONG_PTR dw = 0;
|
|
|
|
if (lstrcmpi(szClassName, TEXT("SHELLDLL_DefView")) == 0)
|
|
uMsg = WM_DSV_SHOWDRAGIMAGE;
|
|
if (lstrcmpi(szClassName, TEXT("CabinetWClass")) == 0)
|
|
uMsg = CWM_SHOWDRAGIMAGE;
|
|
|
|
if (uMsg)
|
|
{
|
|
SendMessageTimeout(hwndLock, uMsg, 0, *pfShow, SMTO_ABORTIFHUNG, 1000, &dw);
|
|
*pfShow = (dw != 0);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void CDragImages::ThreadDetach()
|
|
{
|
|
if (_idThread == GetCurrentThreadId())
|
|
FreeDragData();
|
|
}
|
|
|
|
void CDragImages::ProcessDetach()
|
|
{
|
|
FreeDragData();
|
|
}
|
|
|
|
BOOL CDragImages::SetDragImage(HIMAGELIST himl, int index, POINT * pptOffset)
|
|
{
|
|
if (himl)
|
|
{
|
|
// We are setting
|
|
if (Initialized())
|
|
return FALSE;
|
|
|
|
_fImage = TRUE;
|
|
if (pptOffset)
|
|
{
|
|
// Avoid the flicker by always pass even coords
|
|
_ptOffset.x = (pptOffset->x & ~1);
|
|
_ptOffset.y = (pptOffset->y & ~1);
|
|
}
|
|
|
|
ImageList_BeginDrag(himl, index, _ptOffset.x, _ptOffset.y);
|
|
_InitDragData();
|
|
}
|
|
else
|
|
{
|
|
FreeDragData();
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
//=====================================================================
|
|
// Multile Drag show
|
|
//=====================================================================
|
|
|
|
void CDragImages::_MultipleDragShow(BOOL bShow)
|
|
{
|
|
HDC hDC;
|
|
int nRect;
|
|
RECT rc, rcClip;
|
|
|
|
if ((bShow && _Single._Multi.bShown) || (!bShow && !_Single._Multi.bShown))
|
|
return;
|
|
|
|
_Single._Multi.bShown = bShow;
|
|
|
|
// clip to window, NOT SM_CXSCREEN/SM_CYSCREEN (multiple monitors)
|
|
GetWindowRect(_Single.hwndLock, &rcClip);
|
|
rcClip.right -= rcClip.left;
|
|
rcClip.bottom -= rcClip.top;
|
|
|
|
hDC = GetDCEx(_Single.hwndLock, NULL, DCX_WINDOW | DCX_CACHE |
|
|
DCX_LOCKWINDOWUPDATE | DCX_CLIPSIBLINGS);
|
|
|
|
|
|
for (nRect = _Single._Multi.nRects - 1; nRect >= 0; --nRect)
|
|
{
|
|
rc = _Single._Multi.pRect[nRect];
|
|
OffsetRect(&rc, _Single._Multi.ptNow.x - _Single._Multi.ptOffset.x,
|
|
_Single._Multi.ptNow.y - _Single._Multi.ptOffset.y);
|
|
|
|
if ((rc.top < rcClip.bottom) && (rc.bottom > 0) &&
|
|
(rc.left < rcClip.right) && (rc.right > 0))
|
|
{
|
|
DrawFocusRect(hDC, &rc);
|
|
}
|
|
}
|
|
ReleaseDC(_Single.hwndLock, hDC);
|
|
}
|
|
|
|
void CDragImages::_MultipleDragStart(HWND hwndLock, LPRECT aRect, int nRects, POINT ptStart, POINT ptOffset)
|
|
{
|
|
_Single._Multi.bShown = FALSE;
|
|
_Single._Multi.pRect = aRect;
|
|
_Single._Multi.nRects = nRects;
|
|
_Single._Multi.ptOffset = ptOffset;
|
|
_Single._Multi.ptNow = ptStart;
|
|
}
|
|
|
|
void CDragImages::_MultipleDragMove(POINT ptNew)
|
|
{
|
|
if ((_Single._Multi.ptNow.x == ptNew.x) &&
|
|
(_Single._Multi.ptNow.y == ptNew.y))
|
|
{
|
|
// nothing has changed. bail
|
|
return;
|
|
}
|
|
|
|
if (_Single._Multi.bShown)
|
|
{
|
|
HDC hDC;
|
|
int nRect;
|
|
RECT rc, rcClip;
|
|
int dx1 = _Single._Multi.ptNow.x - _Single._Multi.ptOffset.x;
|
|
int dy1 = _Single._Multi.ptNow.y - _Single._Multi.ptOffset.y;
|
|
int dx2 = ptNew.x - _Single._Multi.ptNow.x;
|
|
int dy2 = ptNew.y - _Single._Multi.ptNow.y;
|
|
|
|
// clip to window, NOT SM_CXSCREEN/SM_CYSCREEN (multiple monitors)
|
|
GetWindowRect(_Single.hwndLock, &rcClip);
|
|
rcClip.right -= rcClip.left;
|
|
rcClip.bottom -= rcClip.top;
|
|
|
|
hDC = GetDCEx(_Single.hwndLock, NULL, DCX_WINDOW | DCX_CACHE |
|
|
DCX_LOCKWINDOWUPDATE | DCX_CLIPSIBLINGS);
|
|
|
|
for (nRect = _Single._Multi.nRects - 1; nRect >= 0; --nRect)
|
|
{
|
|
rc = _Single._Multi.pRect[nRect];
|
|
// hide pass
|
|
OffsetRect(&rc, dx1, dy1);
|
|
if ((rc.top < rcClip.bottom) && (rc.bottom > 0) &&
|
|
(rc.left < rcClip.right) && (rc.right > 0))
|
|
{
|
|
|
|
DrawFocusRect(hDC, &rc);
|
|
}
|
|
// show pass
|
|
OffsetRect(&rc, dx2, dy2);
|
|
if ((rc.top < rcClip.bottom) && (rc.bottom > 0) &&
|
|
(rc.left < rcClip.right) && (rc.right > 0))
|
|
{
|
|
DrawFocusRect(hDC, &rc);
|
|
}
|
|
}
|
|
ReleaseDC(_Single.hwndLock, hDC);
|
|
}
|
|
|
|
_Single._Multi.ptNow = ptNew;
|
|
}
|
|
|
|
HRESULT CDragImages::_SetMultiRectDragging(int cItems, LPRECT prect, POINT *pptOffset)
|
|
{
|
|
if (!Initialized())
|
|
{
|
|
// Multiple item drag
|
|
_cItems = cItems;
|
|
_parc = new RECT[2 * _cItems];
|
|
if (_parc)
|
|
{
|
|
for (int i = 0; i < cItems; i++)
|
|
_parc[i] = prect[i];
|
|
|
|
// Avoid the flicker by always pass even coords
|
|
_ptOffset.x = (pptOffset->x & ~1);
|
|
_ptOffset.y = (pptOffset->y & ~1);
|
|
_InitDragData();
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
#define ListView_IsIconView(hwndLV) ((GetWindowLong(hwndLV, GWL_STYLE) & (UINT)LVS_TYPEMASK) == (UINT)LVS_ICON)
|
|
|
|
HRESULT CDragImages::_SetMultiItemDragging(HWND hwndLV, int cItems, POINT *pptOffset)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if (!Initialized())
|
|
{
|
|
// Multiple item drag
|
|
ASSERT(NULL == _parc);
|
|
|
|
_parc = new RECT[2 * cItems];
|
|
if (_parc)
|
|
{
|
|
POINT ptTemp;
|
|
int iLast, iNext;
|
|
int cxScreens, cyScreens;
|
|
LPRECT prcNext;
|
|
RECT rc;
|
|
|
|
_cItems = 0;
|
|
ASSERT(_fImage == FALSE);
|
|
|
|
//
|
|
// If this is a mirrored Window, then lead edge is going
|
|
// to be the far end in screen coord. So let's compute
|
|
// as the original code, and later in _MultipleDragMove
|
|
// we will compensate.
|
|
//
|
|
|
|
GetWindowRect( hwndLV , &rc );
|
|
ptTemp.x = rc.left;
|
|
ptTemp.y = rc.top;
|
|
|
|
//
|
|
// Reflect the shift the if the window is RTL mirrored.
|
|
//
|
|
if (IS_WINDOW_RTL_MIRRORED(hwndLV))
|
|
{
|
|
ptTemp.x = -ptTemp.x;
|
|
pptOffset->x = ((rc.right-rc.left)-pptOffset->x);
|
|
}
|
|
|
|
cxScreens = GetSystemMetrics(SM_CXVIRTUALSCREEN);
|
|
cyScreens = GetSystemMetrics(SM_CYVIRTUALSCREEN);
|
|
|
|
// for pre-Nashville platforms
|
|
if (!cxScreens || !cyScreens)
|
|
{
|
|
cxScreens = GetSystemMetrics(SM_CXSCREEN);
|
|
cyScreens = GetSystemMetrics(SM_CYSCREEN);
|
|
}
|
|
|
|
for (iNext = cItems - 1, iLast = -1, prcNext = _parc; iNext >= 0; --iNext)
|
|
{
|
|
iLast = ListView_GetNextItem(hwndLV, iLast, LVNI_SELECTED);
|
|
if (iLast != -1)
|
|
{
|
|
ListView_GetItemRect(hwndLV, iLast, &prcNext[0], LVIR_ICON);
|
|
OffsetRect(&prcNext[0], ptTemp.x, ptTemp.y);
|
|
|
|
if (((prcNext[0].left - pptOffset->x) < cxScreens) &&
|
|
((pptOffset->x - prcNext[0].right) < cxScreens) &&
|
|
((prcNext[0].top - pptOffset->y) < cyScreens))
|
|
{
|
|
|
|
ListView_GetItemRect(hwndLV, iLast, &prcNext[1], LVIR_LABEL);
|
|
OffsetRect(&prcNext[1], ptTemp.x, ptTemp.y);
|
|
if ((pptOffset->y - prcNext[1].bottom) < cxScreens)
|
|
{
|
|
//
|
|
// Fix 24857: Ask JoeB why we are drawing a bar instead of
|
|
// a text rectangle.
|
|
//
|
|
prcNext[1].top = (prcNext[1].top + prcNext[1].bottom)/2;
|
|
prcNext[1].bottom = prcNext[1].top + 2;
|
|
prcNext += 2;
|
|
_cItems += 2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Avoid the flicker by always pass even coords
|
|
_ptOffset.x = (pptOffset->x & ~1);
|
|
_ptOffset.y = (pptOffset->y & ~1);
|
|
_InitDragData();
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//=====================================================================
|
|
// Cursor Merging
|
|
//=====================================================================
|
|
void CDragImages::_DestroyCachedCursors()
|
|
{
|
|
if (_himlCursors)
|
|
{
|
|
ImageList_Destroy(_himlCursors);
|
|
_himlCursors = NULL;
|
|
}
|
|
|
|
HCURSOR hcursor = GetCursor();
|
|
for (int i = 0; i < ARRAYSIZE(_ahcur); i++)
|
|
{
|
|
if (_ahcur[i])
|
|
{
|
|
if (_ahcur[i] == hcursor)
|
|
{
|
|
//
|
|
// Stuff in some random cursor so that we don't try to
|
|
// destroy the current cursor (and leak it too).
|
|
//
|
|
SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW)));
|
|
}
|
|
DestroyCursor(_ahcur[i]);
|
|
_ahcur[i] = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
HBITMAP CDragImages::CreateColorBitmap(int cx, int cy)
|
|
{
|
|
HDC hdc = GetDC(NULL);
|
|
HBITMAP hbm = CreateCompatibleBitmap(hdc, cx, cy);
|
|
ReleaseDC(NULL, hdc);
|
|
return hbm;
|
|
}
|
|
|
|
#define CreateMonoBitmap( cx, cy) CreateBitmap(cx, cy, 1, 1, NULL)
|
|
typedef WORD CURMASK;
|
|
#define _BitSizeOf(x) (sizeof(x)*8)
|
|
|
|
HRESULT CDragImages::_GetCursorLowerRight(HCURSOR hcursor, int * px, int * py, POINT *pptHotSpot)
|
|
{
|
|
ICONINFO iconinfo;
|
|
HRESULT hr = E_FAIL;
|
|
if (GetIconInfo(hcursor, &iconinfo))
|
|
{
|
|
CURMASK CurMask[16*8];
|
|
BITMAP bm;
|
|
int i;
|
|
int xFine = 16;
|
|
|
|
GetObject(iconinfo.hbmMask, sizeof(bm), (LPTSTR)&bm);
|
|
GetBitmapBits(iconinfo.hbmMask, sizeof(CurMask), CurMask);
|
|
pptHotSpot->x = iconinfo.xHotspot;
|
|
pptHotSpot->y = iconinfo.yHotspot;
|
|
if (iconinfo.hbmColor)
|
|
{
|
|
i = (int)(bm.bmWidth * bm.bmHeight / _BitSizeOf(CURMASK) - 1);
|
|
}
|
|
else
|
|
{
|
|
i = (int)(bm.bmWidth * (bm.bmHeight/2) / _BitSizeOf(CURMASK) - 1);
|
|
}
|
|
|
|
if ( i >= sizeof(CurMask))
|
|
{
|
|
i = sizeof(CurMask) -1;
|
|
}
|
|
|
|
// this assumes that the first pixel encountered on this bottom
|
|
// up/right to left search will be reasonably close to the rightmost pixel
|
|
// which for all of our cursors is correct, but it not necessarly correct.
|
|
|
|
// also, it assumes the cursor has a good mask... not like the IBeam XOR only
|
|
// cursor
|
|
for (; i >= 0; i--)
|
|
{
|
|
if (CurMask[i] != 0xFFFF)
|
|
{
|
|
// this is only accurate to 16 pixels... which is a big gap..
|
|
// so let's try to be a bit more accurate.
|
|
int j;
|
|
DWORD dwMask;
|
|
|
|
for (j = 0; j < 16; j++, xFine--)
|
|
{
|
|
if (j < 8)
|
|
{
|
|
dwMask = (1 << (8 + j));
|
|
}
|
|
else
|
|
{
|
|
dwMask = (1 << (j - 8));
|
|
}
|
|
|
|
if (!(CurMask[i] & dwMask))
|
|
break;
|
|
}
|
|
ASSERT(j < 16);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (iconinfo.hbmColor)
|
|
{
|
|
DeleteObject(iconinfo.hbmColor);
|
|
}
|
|
|
|
if (iconinfo.hbmMask)
|
|
{
|
|
DeleteObject(iconinfo.hbmMask);
|
|
}
|
|
|
|
// Compute the pointer height
|
|
// use width in both directions because the cursor is square, but the
|
|
// height might be doubleheight if it's mono
|
|
*py = ((i + 1) * _BitSizeOf(CURMASK)) / (int)bm.bmWidth;
|
|
*px = ((i * _BitSizeOf(CURMASK)) % (int)bm.bmWidth) + xFine + 2; // hang it off a little
|
|
hr = S_OK;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
// this will draw iiMerge's image over iiMain on main's lower right.
|
|
BOOL CDragImages::_MergeIcons(HCURSOR hcursor, LPCTSTR idMerge, HBITMAP *phbmImage, HBITMAP *phbmMask, POINT* pptHotSpot)
|
|
{
|
|
*phbmImage = NULL;
|
|
*phbmMask = NULL;
|
|
|
|
BOOL fRet = FALSE;
|
|
|
|
int xDraw;
|
|
int yDraw;
|
|
// find the lower corner of the cursor and put it there.
|
|
// do this whether or not we have an idMerge because it will set the hotspot
|
|
if (SUCCEEDED(_GetCursorLowerRight(hcursor, &xDraw, &yDraw, pptHotSpot)))
|
|
{
|
|
int xBitmap;
|
|
int yBitmap;
|
|
int xCursor = GetSystemMetrics(SM_CXCURSOR);
|
|
int yCursor = GetSystemMetrics(SM_CYCURSOR);
|
|
HBITMAP hbmp;
|
|
if (idMerge != (LPCTSTR)-1)
|
|
{
|
|
hbmp = (HBITMAP)LoadImage(HINST_THISDLL, idMerge, IMAGE_BITMAP, 0, 0, 0);
|
|
if (hbmp)
|
|
{
|
|
BITMAP bm;
|
|
GetObject(hbmp, sizeof(bm), &bm);
|
|
xBitmap = bm.bmWidth;
|
|
yBitmap = bm.bmHeight/2;
|
|
|
|
if (xDraw + xBitmap > xCursor)
|
|
xDraw = xCursor - xBitmap;
|
|
if (yDraw + yBitmap > yCursor)
|
|
yDraw = yCursor - yBitmap;
|
|
}
|
|
}
|
|
else
|
|
hbmp = NULL;
|
|
|
|
HDC hdcCursor = CreateCompatibleDC(NULL);
|
|
|
|
HBITMAP hbmMask = CreateMonoBitmap(xCursor, yCursor);
|
|
HBITMAP hbmImage = CreateColorBitmap(xCursor, yCursor);
|
|
|
|
if (hdcCursor && hbmMask && hbmImage)
|
|
{
|
|
HBITMAP hbmTemp = (HBITMAP)SelectObject(hdcCursor, hbmImage);
|
|
DrawIconEx(hdcCursor, 0, 0, hcursor, 0, 0, 0, NULL, DI_NORMAL);
|
|
|
|
HDC hdcBitmap;
|
|
if (hbmp)
|
|
{
|
|
hdcBitmap = CreateCompatibleDC(NULL);
|
|
SelectObject(hdcBitmap, hbmp);
|
|
|
|
//blt the two bitmaps onto the color and mask bitmaps for the cursor
|
|
BitBlt(hdcCursor, xDraw, yDraw, xBitmap, yBitmap, hdcBitmap, 0, 0, SRCCOPY);
|
|
}
|
|
|
|
SelectObject(hdcCursor, hbmMask);
|
|
|
|
DrawIconEx(hdcCursor, 0, 0, hcursor, 0, 0, 0, NULL, DI_MASK);
|
|
|
|
if (hbmp)
|
|
{
|
|
BitBlt(hdcCursor, xDraw, yDraw, xBitmap, yBitmap, hdcBitmap, 0, yBitmap, SRCCOPY);
|
|
|
|
// select back in the old bitmaps
|
|
SelectObject(hdcBitmap, hbmTemp);
|
|
DeleteDC(hdcBitmap);
|
|
DeleteObject(hbmp);
|
|
}
|
|
|
|
// select back in the old bitmaps
|
|
SelectObject(hdcCursor, hbmTemp);
|
|
}
|
|
|
|
if (hdcCursor)
|
|
DeleteDC(hdcCursor);
|
|
|
|
*phbmImage = hbmImage;
|
|
*phbmMask = hbmMask;
|
|
fRet = (hbmImage && hbmMask);
|
|
}
|
|
return fRet;
|
|
}
|
|
|
|
// this will take a cursor index and load
|
|
int CDragImages::_AddCursorToImageList(HCURSOR hcur, LPCTSTR idMerge, POINT *pptHotSpot)
|
|
{
|
|
int iIndex;
|
|
HBITMAP hbmImage, hbmMask;
|
|
|
|
// merge in the plus or link arrow if it's specified
|
|
if (_MergeIcons(hcur, idMerge, &hbmImage, &hbmMask, pptHotSpot))
|
|
{
|
|
iIndex = ImageList_Add(_himlCursors, hbmImage, hbmMask);
|
|
}
|
|
else
|
|
{
|
|
iIndex = -1;
|
|
}
|
|
|
|
if (hbmImage)
|
|
DeleteObject(hbmImage);
|
|
|
|
if (hbmMask)
|
|
DeleteObject(hbmMask);
|
|
|
|
return iIndex;
|
|
}
|
|
|
|
int _MapEffectToId(DWORD dwEffect)
|
|
{
|
|
int idCursor;
|
|
|
|
// DebugMsg(DM_TRACE, "sh TR - DAD_GiveFeedBack dwEffect=%x", dwEffect);
|
|
|
|
switch (dwEffect & (DROPEFFECT_COPY|DROPEFFECT_LINK|DROPEFFECT_MOVE))
|
|
{
|
|
case 0:
|
|
idCursor = DCID_NO;
|
|
break;
|
|
|
|
case DROPEFFECT_COPY:
|
|
idCursor = DCID_COPY;
|
|
break;
|
|
|
|
case DROPEFFECT_LINK:
|
|
idCursor = DCID_LINK;
|
|
break;
|
|
|
|
case DROPEFFECT_MOVE:
|
|
idCursor = DCID_MOVE;
|
|
break;
|
|
|
|
default:
|
|
// if it's a right drag, we can have any effect... we'll
|
|
// default to the arrow without merging in anything
|
|
idCursor = DCID_MOVE;
|
|
break;
|
|
}
|
|
|
|
return idCursor;
|
|
}
|
|
|
|
int CDragImages::_MapCursorIDToImageListIndex(int idCur)
|
|
{
|
|
const static struct
|
|
{
|
|
BOOL fSystem;
|
|
LPCTSTR idRes;
|
|
LPCTSTR idMerge;
|
|
}
|
|
c_acurmap[DCID_MAX] =
|
|
{
|
|
{ FALSE, MAKEINTRESOURCE(IDC_NULL), (LPCTSTR)-1},
|
|
{ TRUE, IDC_NO, (LPCTSTR)-1 },
|
|
{ TRUE, IDC_ARROW, (LPCTSTR)-1 },
|
|
{ TRUE, IDC_ARROW, MAKEINTRESOURCE(IDB_PLUS_MERGE) },
|
|
{ TRUE, IDC_ARROW, MAKEINTRESOURCE(IDB_LINK_MERGE) },
|
|
};
|
|
|
|
ASSERT(idCur >= -1 && idCur < (int)ARRAYSIZE(c_acurmap));
|
|
|
|
// -1 means "Initialize the image list index array".
|
|
if (idCur == -1)
|
|
{
|
|
for (int i = 0; i < ARRAYSIZE(c_acurmap); i++)
|
|
{
|
|
_aindex[i] = -1;
|
|
}
|
|
idCur = 0; // fall through to return -1
|
|
}
|
|
else
|
|
{
|
|
if (_aindex[idCur] == -1)
|
|
{
|
|
HINSTANCE hinst = c_acurmap[idCur].fSystem ? NULL : HINST_THISDLL;
|
|
HCURSOR hcur = LoadCursor(hinst, c_acurmap[idCur].idRes);
|
|
if (hcur)
|
|
{
|
|
_aindex[idCur] = _AddCursorToImageList(hcur, c_acurmap[idCur].idMerge, &_aptHotSpot[idCur]);
|
|
}
|
|
}
|
|
}
|
|
return _aindex[idCur];
|
|
}
|
|
|
|
HCURSOR CDragImages::_SetCursorHotspot(HCURSOR hcur, POINT *ptHot)
|
|
{
|
|
ICONINFO iconinfo = { 0 };
|
|
HCURSOR hcurHotspot;
|
|
|
|
GetIconInfo(hcur, &iconinfo);
|
|
iconinfo.xHotspot = ptHot->x;
|
|
iconinfo.yHotspot = ptHot->y;
|
|
iconinfo.fIcon = FALSE;
|
|
hcurHotspot = (HCURSOR)CreateIconIndirect(&iconinfo);
|
|
if (iconinfo.hbmColor)
|
|
{
|
|
DeleteObject(iconinfo.hbmColor);
|
|
}
|
|
|
|
if (iconinfo.hbmMask)
|
|
{
|
|
DeleteObject(iconinfo.hbmMask);
|
|
}
|
|
return hcurHotspot;
|
|
}
|
|
|
|
void CDragImages::SetDropEffectCursor(int idCur)
|
|
{
|
|
if (_himlCursors && (idCur != -1))
|
|
{
|
|
if (!_ahcur[idCur])
|
|
{
|
|
int iIndex = _MapCursorIDToImageListIndex(idCur);
|
|
if (iIndex != -1)
|
|
{
|
|
HCURSOR hcurColor = ImageList_GetIcon(_himlCursors, iIndex, 0);
|
|
//
|
|
// On non C1_COLORCURSOR displays, CopyImage() will enforce
|
|
// monochrome. So on color cursor displays, we'll get colored
|
|
// dragdrop pix.
|
|
//
|
|
HCURSOR hcurScreen = (HCURSOR)CopyImage(hcurColor, IMAGE_CURSOR,
|
|
0, 0, LR_COPYRETURNORG | LR_DEFAULTSIZE);
|
|
|
|
HCURSOR hcurFinal = _SetCursorHotspot(hcurScreen, &_aptHotSpot[idCur]);
|
|
|
|
if ((hcurScreen != hcurColor) && hcurColor)
|
|
{
|
|
DestroyCursor(hcurColor);
|
|
}
|
|
|
|
if (hcurFinal)
|
|
{
|
|
if (hcurScreen)
|
|
{
|
|
DestroyCursor(hcurScreen);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hcurFinal = hcurScreen;
|
|
}
|
|
|
|
_ahcur[idCur] = hcurFinal;
|
|
}
|
|
}
|
|
|
|
if (_ahcur[idCur])
|
|
{
|
|
//
|
|
// This code assumes that SetCursor is pretty quick if it is
|
|
// already set.
|
|
//
|
|
SetCursor(_ahcur[idCur]);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//=====================================================================
|
|
// CDropSource
|
|
//=====================================================================
|
|
|
|
class CDropSource : public IDropSource
|
|
{
|
|
private:
|
|
LONG _cRef;
|
|
DWORD _grfInitialKeyState;
|
|
IDataObject* _pdtobj;
|
|
|
|
public:
|
|
explicit CDropSource(IDataObject *pdtobj);
|
|
virtual ~CDropSource();
|
|
|
|
// IUnknown methods
|
|
STDMETHODIMP QueryInterface(REFIID riid, void **ppvObj);
|
|
STDMETHODIMP_(ULONG) AddRef();
|
|
STDMETHODIMP_(ULONG) Release();
|
|
|
|
// IDropSource methods
|
|
STDMETHODIMP GiveFeedback(DWORD dwEffect);
|
|
STDMETHODIMP QueryContinueDrag(BOOL fEscapePressed, DWORD grfKeyState);
|
|
};
|
|
|
|
|
|
void DAD_ShowCursor(BOOL fShow)
|
|
{
|
|
static BOOL s_fCursorHidden = FALSE;
|
|
|
|
if (fShow)
|
|
{
|
|
if (s_fCursorHidden)
|
|
{
|
|
ShowCursor(TRUE);
|
|
s_fCursorHidden = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!s_fCursorHidden)
|
|
{
|
|
ShowCursor(FALSE);
|
|
s_fCursorHidden = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
CDropSource::CDropSource(IDataObject *pdtobj) : _cRef(1), _pdtobj(pdtobj), _grfInitialKeyState(0)
|
|
{
|
|
_pdtobj->AddRef();
|
|
|
|
// Tell the data object that we're entering the drag loop.
|
|
DataObj_SetDWORD(_pdtobj, g_cfInDragLoop, 1);
|
|
}
|
|
|
|
CDropSource::~CDropSource()
|
|
{
|
|
DAD_ShowCursor(TRUE); // just in case
|
|
_pdtobj->Release();
|
|
}
|
|
|
|
//
|
|
// Create an instance of CDropSource
|
|
//
|
|
STDMETHODIMP CDropSource_CreateInstance(IDropSource **ppdsrc, IDataObject *pdtobj)
|
|
{
|
|
*ppdsrc = new CDropSource(pdtobj);
|
|
return *ppdsrc ? S_OK : E_OUTOFMEMORY;
|
|
}
|
|
|
|
STDMETHODIMP CDropSource::QueryInterface(REFIID riid, void **ppvObj)
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENT(CDropSource, IDropSource),
|
|
{ 0 },
|
|
};
|
|
return QISearch(this, qit, riid, ppvObj);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CDropSource::AddRef()
|
|
{
|
|
return InterlockedIncrement(&_cRef);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CDropSource::Release()
|
|
{
|
|
if (InterlockedDecrement(&_cRef))
|
|
return _cRef;
|
|
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
STDMETHODIMP CDropSource::QueryContinueDrag(BOOL fEscapePressed, DWORD grfKeyState)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (fEscapePressed)
|
|
{
|
|
hr = DRAGDROP_S_CANCEL;
|
|
}
|
|
else
|
|
{
|
|
// initialize ourself with the drag begin button
|
|
if (_grfInitialKeyState == 0)
|
|
_grfInitialKeyState = (grfKeyState & (MK_LBUTTON | MK_RBUTTON | MK_MBUTTON));
|
|
|
|
// If the window is hung for a while, the drag operation can happen before
|
|
// the first call to this function, so grfInitialKeyState will be 0. If this
|
|
// happened, then we did a drop. No need to assert...
|
|
//ASSERT(this->grfInitialKeyState);
|
|
|
|
if (!(grfKeyState & _grfInitialKeyState))
|
|
{
|
|
//
|
|
// A button is released.
|
|
//
|
|
hr = DRAGDROP_S_DROP;
|
|
}
|
|
else if (_grfInitialKeyState != (grfKeyState & (MK_LBUTTON | MK_RBUTTON | MK_MBUTTON)))
|
|
{
|
|
//
|
|
// If the button state is changed (except the drop case, which we handle
|
|
// above, cancel the drag&drop.
|
|
//
|
|
hr = DRAGDROP_S_CANCEL;
|
|
}
|
|
}
|
|
|
|
if (hr != S_OK)
|
|
{
|
|
SetCursor(LoadCursor(NULL, IDC_ARROW));
|
|
DAD_ShowCursor(TRUE);
|
|
DAD_SetDragCursor(DCID_NULL);
|
|
|
|
// Tell the data object that we're leaving the drag loop.
|
|
if (_pdtobj)
|
|
DataObj_SetDWORD(_pdtobj, g_cfInDragLoop, 0);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CDropSource::GiveFeedback(DWORD dwEffect)
|
|
{
|
|
int idCursor = _MapEffectToId(dwEffect);
|
|
|
|
//
|
|
// OLE does not give us DROPEFFECT_MOVE even though our IDT::DragOver
|
|
// returns it, if we haven't set that bit when we have called DoDragDrop.
|
|
// Instead of arguing whether or not this is a bug or by-design of OLE,
|
|
// we work around it. It is important to note that this hack around
|
|
// g_fDraggingOverSource is purely visual hack. It won't affect the
|
|
// actual drag&drop operations at all (DV_AlterEffect does it all).
|
|
//
|
|
// - SatoNa
|
|
//
|
|
if (idCursor == DCID_NO && g_fDraggingOverSource)
|
|
{
|
|
idCursor = DCID_MOVE;
|
|
}
|
|
|
|
//
|
|
// No need to merge the cursor, if we are not dragging over to
|
|
// one of shell windows.
|
|
//
|
|
if (DAD_IsDraggingImage())
|
|
{
|
|
// Feedback for single (image) dragging
|
|
DAD_ShowCursor(FALSE);
|
|
DAD_SetDragCursor(idCursor);
|
|
}
|
|
else if (DAD_IsDragging() && g_pdiDragImages)
|
|
{
|
|
// Feedback for multiple (rectangles) dragging
|
|
g_pdiDragImages->SetDropEffectCursor(idCursor);
|
|
DAD_ShowCursor(TRUE);
|
|
return NOERROR;
|
|
}
|
|
else
|
|
{
|
|
DAD_ShowCursor(TRUE);
|
|
}
|
|
|
|
return DRAGDROP_S_USEDEFAULTCURSORS;
|
|
}
|
|
|
|
//=====================================================================
|
|
// DAD
|
|
//=====================================================================
|
|
|
|
void FixupDragPoint(HWND hwnd, POINT* ppt)
|
|
{
|
|
if (hwnd)
|
|
{
|
|
RECT rc = {0};
|
|
GetWindowRect(hwnd, &rc);
|
|
ppt->x += rc.left;
|
|
ppt->y += rc.top;
|
|
}
|
|
}
|
|
|
|
BOOL DAD_InitDragImages()
|
|
{
|
|
if (!g_pdiDragImages)
|
|
CDragImages_CreateInstance(NULL, IID_IDragSourceHelper, NULL);
|
|
|
|
return g_pdiDragImages != NULL;
|
|
}
|
|
|
|
|
|
STDAPI_(BOOL) DAD_ShowDragImage(BOOL bShow)
|
|
{
|
|
if (DAD_InitDragImages())
|
|
return g_pdiDragImages->Show(bShow) == S_OK ? TRUE : FALSE;
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL DAD_IsDragging()
|
|
{
|
|
if (DAD_InitDragImages())
|
|
return g_pdiDragImages->IsDragging();
|
|
return FALSE;
|
|
}
|
|
|
|
void DAD_SetDragCursor(int idCursor)
|
|
{
|
|
if (DAD_InitDragImages())
|
|
g_pdiDragImages->SetDragCursor(idCursor);
|
|
}
|
|
|
|
STDAPI_(BOOL) DAD_DragEnterEx3(HWND hwndTarget, const POINTL ptStart, IDataObject *pdtobj)
|
|
{
|
|
RECT rc;
|
|
GetWindowRect(hwndTarget, &rc);
|
|
|
|
// If hwndTarget is RTL mirrored, then measure the
|
|
// the client point from the visual right edge
|
|
// (near edge in RTL mirrored windows). [samera]
|
|
POINT pt;
|
|
if (IS_WINDOW_RTL_MIRRORED(hwndTarget))
|
|
pt.x = rc.right - ptStart.x;
|
|
else
|
|
pt.x = ptStart.x - rc.left;
|
|
|
|
pt.y = ptStart.y - rc.top;
|
|
return DAD_DragEnterEx2(hwndTarget, pt, pdtobj);
|
|
}
|
|
|
|
STDAPI_(BOOL) DAD_DragEnterEx2(HWND hwndTarget, const POINT ptStart, IDataObject *pdtobj)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
if (DAD_InitDragImages())
|
|
{
|
|
POINT pt = ptStart;
|
|
FixupDragPoint(hwndTarget, &pt);
|
|
bRet = SUCCEEDED(g_pdiDragImages->DragEnter(hwndTarget, pdtobj, &pt, NULL));
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
STDAPI_(BOOL) DAD_DragEnterEx(HWND hwndTarget, const POINT ptStart)
|
|
{
|
|
return DAD_DragEnterEx2(hwndTarget, ptStart, NULL);
|
|
}
|
|
|
|
STDAPI_(BOOL) DAD_DragEnter(HWND hwndTarget)
|
|
{
|
|
POINT ptStart;
|
|
|
|
GetCursorPos(&ptStart);
|
|
if (hwndTarget)
|
|
ScreenToClient(hwndTarget, &ptStart);
|
|
|
|
return DAD_DragEnterEx(hwndTarget, ptStart);
|
|
}
|
|
|
|
STDAPI_(BOOL) DAD_DragMoveEx(HWND hwndTarget, const POINTL ptStart)
|
|
{
|
|
RECT rc;
|
|
GetWindowRect(hwndTarget, &rc);
|
|
|
|
// If hwndTarget is RTL mirrored, then measure the
|
|
// the client point from the visual right edge
|
|
// (near edge in RTL mirrored windows). [samera]
|
|
POINT pt;
|
|
if (IS_WINDOW_RTL_MIRRORED(hwndTarget))
|
|
pt.x = rc.right - ptStart.x;
|
|
else
|
|
pt.x = ptStart.x - rc.left;
|
|
|
|
pt.y = ptStart.y - rc.top;
|
|
return DAD_DragMove(pt);
|
|
}
|
|
|
|
|
|
STDAPI_(BOOL) DAD_DragMove(POINT pt)
|
|
{
|
|
if (DAD_InitDragImages())
|
|
{
|
|
FixupDragPoint(g_pdiDragImages->GetTarget(), &pt);
|
|
return g_pdiDragImages->DragOver(&pt, 0);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
STDAPI_(BOOL) DAD_SetDragImage(HIMAGELIST him, POINT *pptOffset)
|
|
{
|
|
if (DAD_InitDragImages() && !g_pdiDragImages->IsDraggingLayeredWindow())
|
|
{
|
|
//
|
|
// DAD_SetDragImage(-1, NULL) means "clear the drag image only
|
|
// if the image is set by this thread"
|
|
//
|
|
if (him == (HIMAGELIST)-1)
|
|
{
|
|
BOOL fThisThreadHasImage = FALSE;
|
|
ENTERCRITICAL;
|
|
if (g_pdiDragImages->Initialized() && g_pdiDragImages->GetThread() == GetCurrentThreadId())
|
|
{
|
|
fThisThreadHasImage = TRUE;
|
|
}
|
|
LEAVECRITICAL;
|
|
|
|
if (fThisThreadHasImage)
|
|
{
|
|
g_pdiDragImages->FreeDragData();
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
return g_pdiDragImages->SetDragImage(him, 0, pptOffset);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// This function returns TRUE, if we are dragging an image. It means
|
|
// you have called either DAD_SetDragImage (with him != NULL) or
|
|
// DAD_SetDragImageFromListview.
|
|
//
|
|
BOOL DAD_IsDraggingImage(void)
|
|
{
|
|
if (DAD_InitDragImages())
|
|
return g_pdiDragImages->IsDraggingImage();
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
STDAPI_(BOOL) DAD_DragLeave()
|
|
{
|
|
if (DAD_InitDragImages())
|
|
return g_pdiDragImages->DragLeave();
|
|
return FALSE;
|
|
}
|
|
|
|
STDAPI_(void) DAD_ProcessDetach(void)
|
|
{
|
|
if (g_pdiDragImages)
|
|
{
|
|
g_pdiDragImages->ProcessDetach();
|
|
g_pdiDragImages->Release();
|
|
}
|
|
}
|
|
|
|
STDAPI_(void) DAD_ThreadDetach(void)
|
|
{
|
|
if (g_pdiDragImages)
|
|
g_pdiDragImages->ThreadDetach();
|
|
}
|
|
|
|
// called from defview on SPI_SETCURSORS (user changed the system cursors)
|
|
STDAPI_(void) DAD_InvalidateCursors(void)
|
|
{
|
|
g_cRev++;
|
|
}
|
|
|
|
STDAPI_(BOOL) DAD_SetDragImageFromWindow(HWND hwnd, POINT* ppt, IDataObject* pdtobj)
|
|
{
|
|
if (DAD_InitDragImages())
|
|
return S_OK == g_pdiDragImages->InitializeFromWindow(hwnd, ppt, pdtobj);
|
|
return FALSE;
|
|
}
|
|
|
|
// shell32.dll export, but only used by print queue window code
|
|
//
|
|
STDAPI_(BOOL) DAD_SetDragImageFromListView(HWND hwndLV, POINT ptOffset)
|
|
{
|
|
// really a nop, as this does not have access to the data object
|
|
return DAD_InitDragImages();
|
|
}
|
|
|
|
// wrapper around OLE DoDragDrop(), will create drag source on demand and supports
|
|
// drag images for you
|
|
|
|
STDAPI SHDoDragDrop(HWND hwnd, IDataObject *pdtobj, IDropSource *pdsrc, DWORD dwEffect, DWORD *pdwEffect)
|
|
{
|
|
IDropSource *pdsrcRelease = NULL;
|
|
|
|
if (pdsrc == NULL)
|
|
{
|
|
CDropSource_CreateInstance(&pdsrcRelease, pdtobj);
|
|
pdsrc = pdsrcRelease;
|
|
}
|
|
|
|
// if there is no drag contents clipboard format present, try to add it
|
|
FORMATETC fmte = {_GetDragContentsCF(), NULL, DVASPECT_CONTENT, -1, TYMED_ISTREAM};
|
|
if (S_OK != pdtobj->QueryGetData(&fmte))
|
|
{
|
|
if (DAD_InitDragImages())
|
|
g_pdiDragImages->InitializeFromWindow(hwnd, NULL, pdtobj);
|
|
}
|
|
|
|
HRESULT hr = DoDragDrop(pdtobj, pdsrc, dwEffect, pdwEffect);
|
|
|
|
if (pdsrcRelease)
|
|
pdsrcRelease->Release();
|
|
|
|
return hr;
|
|
}
|
|
|