src/msw/dragimag.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        dragimag.cpp
// Purpose:     wxDragImage
// Author:      Julian Smart
// Modified by:
// Created:     08/04/99
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#ifdef __GNUG__
#pragma implementation "dragimag.h"
#endif

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#include "wx/msw/private.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#if defined(__WIN95__)

#ifndef WX_PRECOMP
#include <stdio.h>
#include "wx/setup.h"
#include "wx/window.h"
#include "wx/dcclient.h"
#include "wx/dcscreen.h"
#include "wx/dcmemory.h"
#include "wx/settings.h"
#endif

#include "wx/log.h"
#include "wx/intl.h"
#include "wx/frame.h"
#include "wx/image.h"

#include "wx/msw/dragimag.h"
#include "wx/msw/private.h"

#if defined(__WIN95__) && !(defined(__GNUWIN32_OLD__) || defined(__TWIN32__))
#include <commctrl.h>
#endif

// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxDragImage, wxObject)

#define GetHimageList() ((HIMAGELIST) m_hImageList)

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// wxDragImage ctors/dtor
// ----------------------------------------------------------------------------

wxDragImage::wxDragImage()
{
    Init();
}

wxDragImage::~wxDragImage()
{
    if ( m_hImageList )
        ImageList_Destroy(GetHimageList());
#if !wxUSE_SIMPLER_DRAGIMAGE
    if ( m_hCursorImageList )
        ImageList_Destroy((HIMAGELIST) m_hCursorImageList);
#endif
}

void wxDragImage::Init()
{
    m_hImageList = 0;
#if !wxUSE_SIMPLER_DRAGIMAGE
    m_hCursorImageList = 0;
#endif
    m_window = (wxWindow*) NULL;
    m_fullScreen = FALSE;
}

// Attributes
////////////////////////////////////////////////////////////////////////////


// Operations
////////////////////////////////////////////////////////////////////////////

// Create a drag image from a bitmap and optional cursor
bool wxDragImage::Create(const wxBitmap& image, const wxCursor& cursor)
{
    if ( m_hImageList )
        ImageList_Destroy(GetHimageList());
    m_hImageList = 0;

    UINT flags = 0 ;
    if (image.GetDepth() <= 4)
        flags = ILC_COLOR4;
    else if (image.GetDepth() <= 8)
        flags = ILC_COLOR8;
    else if (image.GetDepth() <= 16)
        flags = ILC_COLOR16;
    else if (image.GetDepth() <= 24)
        flags = ILC_COLOR24;
    else
        flags = ILC_COLOR32;

    bool mask = (image.GetMask() != 0);
    if ( mask )
        flags |= ILC_MASK;

    m_hImageList = (WXHIMAGELIST) ImageList_Create(image.GetWidth(), image.GetHeight(), flags, 1, 1);

    int index;
    if (!mask)
    {
        HBITMAP hBitmap1 = (HBITMAP) image.GetHBITMAP();
        index = ImageList_Add(GetHimageList(), hBitmap1, 0);
    }
    else
    {
        HBITMAP hBitmap1 = (HBITMAP) image.GetHBITMAP();
        HBITMAP hBitmap2 = (HBITMAP) image.GetMask()->GetMaskBitmap();
        HBITMAP hbmpMask = wxInvertMask(hBitmap2);

        index = ImageList_Add(GetHimageList(), hBitmap1, hbmpMask);
        ::DeleteObject(hbmpMask);
    }
    if ( index == -1 )
    {
        wxLogError(_("Couldn't add an image to the image list."));
    }
    m_cursor = cursor; // Can only combine with drag image after calling BeginDrag.

    return (index != -1) ;
}

// Create a drag image from an icon and optional cursor
bool wxDragImage::Create(const wxIcon& image, const wxCursor& cursor)
{
    if ( m_hImageList )
        ImageList_Destroy(GetHimageList());
    m_hImageList = 0;

    UINT flags = 0 ;
    if (image.GetDepth() <= 4)
        flags = ILC_COLOR4;
    else if (image.GetDepth() <= 8)
        flags = ILC_COLOR8;
    else if (image.GetDepth() <= 16)
        flags = ILC_COLOR16;
    else if (image.GetDepth() <= 24)
        flags = ILC_COLOR24;
    else
        flags = ILC_COLOR32;
    bool mask = TRUE;
    if ( mask )
        flags |= ILC_MASK;

    m_hImageList = (WXHIMAGELIST) ImageList_Create(image.GetWidth(), image.GetHeight(), flags, 1, 1);

    HICON hIcon = (HICON) image.GetHICON();

    int index = ImageList_AddIcon(GetHimageList(), hIcon);
    if ( index == -1 )
    {
        wxLogError(_("Couldn't add an image to the image list."));
    }

    m_cursor = cursor; // Can only combine with drag image after calling BeginDrag.

    return (index != -1) ;
}

// Create a drag image from a string and optional cursor
bool wxDragImage::Create(const wxString& str, const wxCursor& cursor)
{
    wxFont font(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));

    long w, h;
    wxScreenDC dc;
    dc.SetFont(font);
    dc.GetTextExtent(str, & w, & h);
    dc.SetFont(wxNullFont);

    wxMemoryDC dc2;
    dc2.SetFont(font);
    wxBitmap bitmap((int) w+2, (int) h+2);
    dc2.SelectObject(bitmap);

    dc2.SetBackground(* wxWHITE_BRUSH);
    dc2.Clear();
    dc2.SetBackgroundMode(wxTRANSPARENT);
    dc2.SetTextForeground(* wxLIGHT_GREY);
    dc2.DrawText(str, 0, 0);
    dc2.DrawText(str, 1, 0);
    dc2.DrawText(str, 2, 0);
    dc2.DrawText(str, 1, 1);
    dc2.DrawText(str, 2, 1);
    dc2.DrawText(str, 1, 2);
    dc2.DrawText(str, 2, 2);
    dc2.SetTextForeground(* wxBLACK);
    dc2.DrawText(str, 1, 1);

    dc2.SelectObject(wxNullBitmap);

    // Make the bitmap masked
    wxImage image(bitmap);
    image.SetMaskColour(255, 255, 255);
    bitmap = image.ConvertToBitmap();

    return Create(bitmap, cursor);
}

// Create a drag image for the given tree control item
bool wxDragImage::Create(const wxTreeCtrl& treeCtrl, wxTreeItemId& id)
{
    if ( m_hImageList )
        ImageList_Destroy(GetHimageList());
    m_hImageList = (WXHIMAGELIST) TreeView_CreateDragImage((HWND) treeCtrl.GetHWND(), (HTREEITEM) (WXHTREEITEM) id);
    return TRUE;
}

// Create a drag image for the given list control item
bool wxDragImage::Create(const wxListCtrl& listCtrl, long id)
{
    if ( m_hImageList )
        ImageList_Destroy(GetHimageList());
    POINT pt;
    pt.x = 0; pt.y = 0;
    m_hImageList = (WXHIMAGELIST) ListView_CreateDragImage((HWND) listCtrl.GetHWND(), id, & pt);
    return TRUE;
}

// Begin drag
bool wxDragImage::BeginDrag(const wxPoint& hotspot, wxWindow* window, bool fullScreen, wxRect* rect)
{
    wxASSERT_MSG( (m_hImageList != 0), wxT("Image list must not be null in BeginDrag."));
    wxASSERT_MSG( (window != 0), wxT("Window must not be null in BeginDrag."));

    m_fullScreen = fullScreen;
    if (rect)
        m_boundingRect = * rect;

    bool ret = (ImageList_BeginDrag(GetHimageList(), 0, hotspot.x, hotspot.y) != 0);

    if (!ret)
    {
        wxFAIL_MSG( _T("BeginDrag failed.") );

        return FALSE;
    }

    if (m_cursor.Ok())
    {
#if wxUSE_SIMPLER_DRAGIMAGE
	    m_oldCursor = window->GetCursor();
	    window->SetCursor(m_cursor);
#else
        if (!m_hCursorImageList)
        {
            int cxCursor = GetSystemMetrics(SM_CXCURSOR);
            int cyCursor = GetSystemMetrics(SM_CYCURSOR);

            m_hCursorImageList = (WXHIMAGELIST) ImageList_Create(cxCursor, cyCursor, ILC_MASK, 1, 1);
        }

        // See if we can find the cursor hotspot
        wxPoint curHotSpot(hotspot);

        // Although it seems to produce the right position, when the hotspot goeos
        // negative it has strange effects on the image.
        // How do we stop the cursor jumping right and below of where it should be?
#if 0
        ICONINFO iconInfo;
        if (::GetIconInfo((HICON) (HCURSOR) m_cursor.GetHCURSOR(), & iconInfo) != 0)
        {
            curHotSpot.x -= iconInfo.xHotspot;
            curHotSpot.y -= iconInfo.yHotspot;
        }
#endif
        //wxString msg;
        //msg.Printf("Hotspot = %d, %d", curHotSpot.x, curHotSpot.y);
        //wxLogDebug(msg);

        // First add the cursor to the image list
        HCURSOR hCursor = (HCURSOR) m_cursor.GetHCURSOR();
        int cursorIndex = ImageList_AddIcon((HIMAGELIST) m_hCursorImageList, (HICON) hCursor);

        wxASSERT_MSG( (cursorIndex != -1), wxT("ImageList_AddIcon failed in BeginDrag."));

        if (cursorIndex != -1)
        {
            ImageList_SetDragCursorImage((HIMAGELIST) m_hCursorImageList, cursorIndex, curHotSpot.x, curHotSpot.y);
        }
#endif
    }

#if !wxUSE_SIMPLER_DRAGIMAGE
    if (m_cursor.Ok())
        ::ShowCursor(FALSE);
#endif

    m_window = window;

    ::SetCapture(GetHwndOf(window));

    return TRUE;
}

// Begin drag. hotspot is the location of the drag position relative to the upper-left
// corner of the image. This is full screen only. fullScreenRect gives the
// position of the window on the screen, to restrict the drag to.
bool wxDragImage::BeginDrag(const wxPoint& hotspot, wxWindow* window, wxWindow* fullScreenRect)
{
    wxRect rect;

    int x = fullScreenRect->GetPosition().x;
    int y = fullScreenRect->GetPosition().y;

    wxSize sz = fullScreenRect->GetSize();

    if (fullScreenRect->GetParent() && !fullScreenRect->IsKindOf(CLASSINFO(wxFrame)))
        fullScreenRect->GetParent()->ClientToScreen(& x, & y);

    rect.x = x; rect.y = y;
    rect.width = sz.x; rect.height = sz.y;

    return BeginDrag(hotspot, window, TRUE, & rect);
}

// End drag
bool wxDragImage::EndDrag()
{
    wxASSERT_MSG( (m_hImageList != 0), wxT("Image list must not be null in EndDrag."));

    ImageList_EndDrag();

    if ( !::ReleaseCapture() )
    {
        wxLogLastError(wxT("ReleaseCapture"));
    }

#if wxUSE_SIMPLER_DRAGIMAGE
    if (m_cursor.Ok() && m_oldCursor.Ok())
	    m_window->SetCursor(m_oldCursor);
#else
    ::ShowCursor(TRUE);
#endif

    m_window = (wxWindow*) NULL;

    return TRUE;
}

// Move the image: call from OnMouseMove. Pt is in window client coordinates if window
// is non-NULL, or in screen coordinates if NULL.
bool wxDragImage::Move(const wxPoint& pt)
{
    wxASSERT_MSG( (m_hImageList != 0), wxT("Image list must not be null in Move."));

    // These are in window, not client coordinates.
    // So need to convert to client coordinates.
    wxPoint pt2(pt);
    if (m_window && !m_fullScreen)
    {
        RECT rect;
        rect.left = 0; rect.top = 0;
        rect.right = 0; rect.bottom = 0;
        DWORD style = ::GetWindowLong((HWND) m_window->GetHWND(), GWL_STYLE);
#ifdef __WIN32__
        DWORD exStyle = ::GetWindowLong((HWND) m_window->GetHWND(), GWL_EXSTYLE);
        ::AdjustWindowRectEx(& rect, style, FALSE, exStyle);
#else
        ::AdjustWindowRect(& rect, style, FALSE);
#endif
        // Subtract the (negative) values, i.e. add a small increment
        pt2.x -= rect.left; pt2.y -= rect.top;
    }
    else if (m_window && m_fullScreen)
    {
        pt2 = m_window->ClientToScreen(pt2);
    }

    bool ret = (ImageList_DragMove( pt2.x, pt2.y ) != 0);

    m_position = pt2;

    return ret;
}

bool wxDragImage::Show()
{
    wxASSERT_MSG( (m_hImageList != 0), wxT("Image list must not be null in Show."));

    HWND hWnd = 0;
    if (m_window && !m_fullScreen)
        hWnd = (HWND) m_window->GetHWND();

    bool ret = (ImageList_DragEnter( hWnd, m_position.x, m_position.y ) != 0);

    return ret;
}

bool wxDragImage::Hide()
{
    wxASSERT_MSG( (m_hImageList != 0), wxT("Image list must not be null in Hide."));

    HWND hWnd = 0;
    if (m_window && !m_fullScreen)
        hWnd = (HWND) m_window->GetHWND();

    bool ret = (ImageList_DragLeave( hWnd ) != 0);

    return ret;
}

#endif
    // __WIN95__
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: dragimag.cpp
	3	// Purpose: wxDragImage
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 08/04/99
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	#ifdef __GNUG__
	21	#pragma implementation "dragimag.h"
	22	#endif
	23
	24	// For compilers that support precompilation, includes "wx.h".
	25	#include "wx/wxprec.h"
	26	#include "wx/msw/private.h"
	27
	28	#ifdef __BORLANDC__
	29	#pragma hdrstop
	30	#endif
	31
	32	#if defined(__WIN95__)
	33
	34	#ifndef WX_PRECOMP
	35	#include <stdio.h>
	36	#include "wx/setup.h"
	37	#include "wx/window.h"
	38	#include "wx/dcclient.h"
	39	#include "wx/dcscreen.h"
	40	#include "wx/dcmemory.h"
	41	#include "wx/settings.h"
	42	#endif
	43
	44	#include "wx/log.h"
	45	#include "wx/intl.h"
	46	#include "wx/frame.h"
	47	#include "wx/image.h"
	48
	49	#include "wx/msw/dragimag.h"
	50	#include "wx/msw/private.h"
	51
	52	#if defined(__WIN95__) && !(defined(__GNUWIN32_OLD__) \|\| defined(__TWIN32__))
	53	#include <commctrl.h>
	54	#endif
	55
	56	// ----------------------------------------------------------------------------
	57	// macros
	58	// ----------------------------------------------------------------------------
	59
	60	IMPLEMENT_DYNAMIC_CLASS(wxDragImage, wxObject)
	61
	62	#define GetHimageList() ((HIMAGELIST) m_hImageList)
	63
	64	// ============================================================================
	65	// implementation
	66	// ============================================================================
	67
	68	// ----------------------------------------------------------------------------
	69	// wxDragImage ctors/dtor
	70	// ----------------------------------------------------------------------------
	71
	72	wxDragImage::wxDragImage()
	73	{
	74	Init();
	75	}
	76
	77	wxDragImage::~wxDragImage()
	78	{
	79	if ( m_hImageList )
	80	ImageList_Destroy(GetHimageList());
	81	#if !wxUSE_SIMPLER_DRAGIMAGE
	82	if ( m_hCursorImageList )
	83	ImageList_Destroy((HIMAGELIST) m_hCursorImageList);
	84	#endif
	85	}
	86
	87	void wxDragImage::Init()
	88	{
	89	m_hImageList = 0;
	90	#if !wxUSE_SIMPLER_DRAGIMAGE
	91	m_hCursorImageList = 0;
	92	#endif
	93	m_window = (wxWindow*) NULL;
	94	m_fullScreen = FALSE;
	95	}
	96
	97	// Attributes
	98	////////////////////////////////////////////////////////////////////////////
	99
	100
	101	// Operations
	102	////////////////////////////////////////////////////////////////////////////
	103
	104	// Create a drag image from a bitmap and optional cursor
	105	bool wxDragImage::Create(const wxBitmap& image, const wxCursor& cursor)
	106	{
	107	if ( m_hImageList )
	108	ImageList_Destroy(GetHimageList());
	109	m_hImageList = 0;
	110
	111	UINT flags = 0 ;
	112	if (image.GetDepth() <= 4)
	113	flags = ILC_COLOR4;
	114	else if (image.GetDepth() <= 8)
	115	flags = ILC_COLOR8;
	116	else if (image.GetDepth() <= 16)
	117	flags = ILC_COLOR16;
	118	else if (image.GetDepth() <= 24)
	119	flags = ILC_COLOR24;
	120	else
	121	flags = ILC_COLOR32;
	122
	123	bool mask = (image.GetMask() != 0);
	124	if ( mask )
	125	flags \|= ILC_MASK;
	126
	127	m_hImageList = (WXHIMAGELIST) ImageList_Create(image.GetWidth(), image.GetHeight(), flags, 1, 1);
	128
	129	int index;
	130	if (!mask)
	131	{
	132	HBITMAP hBitmap1 = (HBITMAP) image.GetHBITMAP();
	133	index = ImageList_Add(GetHimageList(), hBitmap1, 0);
	134	}
	135	else
	136	{
	137	HBITMAP hBitmap1 = (HBITMAP) image.GetHBITMAP();
	138	HBITMAP hBitmap2 = (HBITMAP) image.GetMask()->GetMaskBitmap();
	139	HBITMAP hbmpMask = wxInvertMask(hBitmap2);
	140
	141	index = ImageList_Add(GetHimageList(), hBitmap1, hbmpMask);
	142	::DeleteObject(hbmpMask);
	143	}
	144	if ( index == -1 )
	145	{
	146	wxLogError(_("Couldn't add an image to the image list."));
	147	}
	148	m_cursor = cursor; // Can only combine with drag image after calling BeginDrag.
	149
	150	return (index != -1) ;
	151	}
	152
	153	// Create a drag image from an icon and optional cursor
	154	bool wxDragImage::Create(const wxIcon& image, const wxCursor& cursor)
	155	{
	156	if ( m_hImageList )
	157	ImageList_Destroy(GetHimageList());
	158	m_hImageList = 0;
	159
	160	UINT flags = 0 ;
	161	if (image.GetDepth() <= 4)
	162	flags = ILC_COLOR4;
	163	else if (image.GetDepth() <= 8)
	164	flags = ILC_COLOR8;
	165	else if (image.GetDepth() <= 16)
	166	flags = ILC_COLOR16;
	167	else if (image.GetDepth() <= 24)
	168	flags = ILC_COLOR24;
	169	else
	170	flags = ILC_COLOR32;
	171	bool mask = TRUE;
	172	if ( mask )
	173	flags \|= ILC_MASK;
	174
	175	m_hImageList = (WXHIMAGELIST) ImageList_Create(image.GetWidth(), image.GetHeight(), flags, 1, 1);
	176
	177	HICON hIcon = (HICON) image.GetHICON();
	178
	179	int index = ImageList_AddIcon(GetHimageList(), hIcon);
	180	if ( index == -1 )
	181	{
	182	wxLogError(_("Couldn't add an image to the image list."));
	183	}
	184
	185	m_cursor = cursor; // Can only combine with drag image after calling BeginDrag.
	186
	187	return (index != -1) ;
	188	}
	189
	190	// Create a drag image from a string and optional cursor
	191	bool wxDragImage::Create(const wxString& str, const wxCursor& cursor)
	192	{
	193	wxFont font(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
	194
	195	long w, h;
	196	wxScreenDC dc;
	197	dc.SetFont(font);
	198	dc.GetTextExtent(str, & w, & h);
	199	dc.SetFont(wxNullFont);
	200
	201	wxMemoryDC dc2;
	202	dc2.SetFont(font);
	203	wxBitmap bitmap((int) w+2, (int) h+2);
	204	dc2.SelectObject(bitmap);
	205
	206	dc2.SetBackground(* wxWHITE_BRUSH);
	207	dc2.Clear();
	208	dc2.SetBackgroundMode(wxTRANSPARENT);
	209	dc2.SetTextForeground(* wxLIGHT_GREY);
	210	dc2.DrawText(str, 0, 0);
	211	dc2.DrawText(str, 1, 0);
	212	dc2.DrawText(str, 2, 0);
	213	dc2.DrawText(str, 1, 1);
	214	dc2.DrawText(str, 2, 1);
	215	dc2.DrawText(str, 1, 2);
	216	dc2.DrawText(str, 2, 2);
	217	dc2.SetTextForeground(* wxBLACK);
	218	dc2.DrawText(str, 1, 1);
	219
	220	dc2.SelectObject(wxNullBitmap);
	221
	222	// Make the bitmap masked
	223	wxImage image(bitmap);
	224	image.SetMaskColour(255, 255, 255);
	225	bitmap = image.ConvertToBitmap();
	226
	227	return Create(bitmap, cursor);
	228	}
	229
	230	// Create a drag image for the given tree control item
	231	bool wxDragImage::Create(const wxTreeCtrl& treeCtrl, wxTreeItemId& id)
	232	{
	233	if ( m_hImageList )
	234	ImageList_Destroy(GetHimageList());
	235	m_hImageList = (WXHIMAGELIST) TreeView_CreateDragImage((HWND) treeCtrl.GetHWND(), (HTREEITEM) (WXHTREEITEM) id);
	236	return TRUE;
	237	}
	238
	239	// Create a drag image for the given list control item
	240	bool wxDragImage::Create(const wxListCtrl& listCtrl, long id)
	241	{
	242	if ( m_hImageList )
	243	ImageList_Destroy(GetHimageList());
	244	POINT pt;
	245	pt.x = 0; pt.y = 0;
	246	m_hImageList = (WXHIMAGELIST) ListView_CreateDragImage((HWND) listCtrl.GetHWND(), id, & pt);
	247	return TRUE;
	248	}
	249
	250	// Begin drag
	251	bool wxDragImage::BeginDrag(const wxPoint& hotspot, wxWindow* window, bool fullScreen, wxRect* rect)
	252	{
	253	wxASSERT_MSG( (m_hImageList != 0), wxT("Image list must not be null in BeginDrag."));
	254	wxASSERT_MSG( (window != 0), wxT("Window must not be null in BeginDrag."));
	255
	256	m_fullScreen = fullScreen;
	257	if (rect)
	258	m_boundingRect = * rect;
	259
	260	bool ret = (ImageList_BeginDrag(GetHimageList(), 0, hotspot.x, hotspot.y) != 0);
	261
	262	if (!ret)
	263	{
	264	wxFAIL_MSG( _T("BeginDrag failed.") );
	265
	266	return FALSE;
	267	}
	268
	269	if (m_cursor.Ok())
	270	{
	271	#if wxUSE_SIMPLER_DRAGIMAGE
	272	m_oldCursor = window->GetCursor();
	273	window->SetCursor(m_cursor);
	274	#else
	275	if (!m_hCursorImageList)
	276	{
	277	int cxCursor = GetSystemMetrics(SM_CXCURSOR);
	278	int cyCursor = GetSystemMetrics(SM_CYCURSOR);
	279
	280	m_hCursorImageList = (WXHIMAGELIST) ImageList_Create(cxCursor, cyCursor, ILC_MASK, 1, 1);
	281	}
	282
	283	// See if we can find the cursor hotspot
	284	wxPoint curHotSpot(hotspot);
	285
	286	// Although it seems to produce the right position, when the hotspot goeos
	287	// negative it has strange effects on the image.
	288	// How do we stop the cursor jumping right and below of where it should be?
	289	#if 0
	290	ICONINFO iconInfo;
	291	if (::GetIconInfo((HICON) (HCURSOR) m_cursor.GetHCURSOR(), & iconInfo) != 0)
	292	{
	293	curHotSpot.x -= iconInfo.xHotspot;
	294	curHotSpot.y -= iconInfo.yHotspot;
	295	}
	296	#endif
	297	//wxString msg;
	298	//msg.Printf("Hotspot = %d, %d", curHotSpot.x, curHotSpot.y);
	299	//wxLogDebug(msg);
	300
	301	// First add the cursor to the image list
	302	HCURSOR hCursor = (HCURSOR) m_cursor.GetHCURSOR();
	303	int cursorIndex = ImageList_AddIcon((HIMAGELIST) m_hCursorImageList, (HICON) hCursor);
	304
	305	wxASSERT_MSG( (cursorIndex != -1), wxT("ImageList_AddIcon failed in BeginDrag."));
	306
	307	if (cursorIndex != -1)
	308	{
	309	ImageList_SetDragCursorImage((HIMAGELIST) m_hCursorImageList, cursorIndex, curHotSpot.x, curHotSpot.y);
	310	}
	311	#endif
	312	}
	313
	314	#if !wxUSE_SIMPLER_DRAGIMAGE
	315	if (m_cursor.Ok())
	316	::ShowCursor(FALSE);
	317	#endif
	318
	319	m_window = window;
	320
	321	::SetCapture(GetHwndOf(window));
	322
	323	return TRUE;
	324	}
	325
	326	// Begin drag. hotspot is the location of the drag position relative to the upper-left
	327	// corner of the image. This is full screen only. fullScreenRect gives the
	328	// position of the window on the screen, to restrict the drag to.
	329	bool wxDragImage::BeginDrag(const wxPoint& hotspot, wxWindow* window, wxWindow* fullScreenRect)
	330	{
	331	wxRect rect;
	332
	333	int x = fullScreenRect->GetPosition().x;
	334	int y = fullScreenRect->GetPosition().y;
	335
	336	wxSize sz = fullScreenRect->GetSize();
	337
	338	if (fullScreenRect->GetParent() && !fullScreenRect->IsKindOf(CLASSINFO(wxFrame)))
	339	fullScreenRect->GetParent()->ClientToScreen(& x, & y);
	340
	341	rect.x = x; rect.y = y;
	342	rect.width = sz.x; rect.height = sz.y;
	343
	344	return BeginDrag(hotspot, window, TRUE, & rect);
	345	}
	346
	347	// End drag
	348	bool wxDragImage::EndDrag()
	349	{
	350	wxASSERT_MSG( (m_hImageList != 0), wxT("Image list must not be null in EndDrag."));
	351
	352	ImageList_EndDrag();
	353
	354	if ( !::ReleaseCapture() )
	355	{
	356	wxLogLastError(wxT("ReleaseCapture"));
	357	}
	358
	359	#if wxUSE_SIMPLER_DRAGIMAGE
	360	if (m_cursor.Ok() && m_oldCursor.Ok())
	361	m_window->SetCursor(m_oldCursor);
	362	#else
	363	::ShowCursor(TRUE);
	364	#endif
	365
	366	m_window = (wxWindow*) NULL;
	367
	368	return TRUE;
	369	}
	370
	371	// Move the image: call from OnMouseMove. Pt is in window client coordinates if window
	372	// is non-NULL, or in screen coordinates if NULL.
	373	bool wxDragImage::Move(const wxPoint& pt)
	374	{
	375	wxASSERT_MSG( (m_hImageList != 0), wxT("Image list must not be null in Move."));
	376
	377	// These are in window, not client coordinates.
	378	// So need to convert to client coordinates.
	379	wxPoint pt2(pt);
	380	if (m_window && !m_fullScreen)
	381	{
	382	RECT rect;
	383	rect.left = 0; rect.top = 0;
	384	rect.right = 0; rect.bottom = 0;
	385	DWORD style = ::GetWindowLong((HWND) m_window->GetHWND(), GWL_STYLE);
	386	#ifdef __WIN32__
	387	DWORD exStyle = ::GetWindowLong((HWND) m_window->GetHWND(), GWL_EXSTYLE);
	388	::AdjustWindowRectEx(& rect, style, FALSE, exStyle);
	389	#else
	390	::AdjustWindowRect(& rect, style, FALSE);
	391	#endif
	392	// Subtract the (negative) values, i.e. add a small increment
	393	pt2.x -= rect.left; pt2.y -= rect.top;
	394	}
	395	else if (m_window && m_fullScreen)
	396	{
	397	pt2 = m_window->ClientToScreen(pt2);
	398	}
	399
	400	bool ret = (ImageList_DragMove( pt2.x, pt2.y ) != 0);
	401
	402	m_position = pt2;
	403
	404	return ret;
	405	}
	406
	407	bool wxDragImage::Show()
	408	{
	409	wxASSERT_MSG( (m_hImageList != 0), wxT("Image list must not be null in Show."));
	410
	411	HWND hWnd = 0;
	412	if (m_window && !m_fullScreen)
	413	hWnd = (HWND) m_window->GetHWND();
	414
	415	bool ret = (ImageList_DragEnter( hWnd, m_position.x, m_position.y ) != 0);
	416
	417	return ret;
	418	}
	419
	420	bool wxDragImage::Hide()
	421	{
	422	wxASSERT_MSG( (m_hImageList != 0), wxT("Image list must not be null in Hide."));
	423
	424	HWND hWnd = 0;
	425	if (m_window && !m_fullScreen)
	426	hWnd = (HWND) m_window->GetHWND();
	427
	428	bool ret = (ImageList_DragLeave( hWnd ) != 0);
	429
	430	return ret;
	431	}
	432
	433	#endif
	434	// __WIN95__
	435