able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/shell32/dragdrop.cpp

2344 lines
68 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#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;
}
Reference in a new issue Copy permalink