src/msw/dragimag.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/msw/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
// ----------------------------------------------------------------------------

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

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#if wxUSE_DRAGIMAGE

#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/msw/private.h"
#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"

#ifdef __WXWINCE__  // for SM_CXCURSOR and SM_CYCURSOR
#include "wx/msw/wince/missing.h"
#endif // __WXWINCE__

// include <commctrl.h> "properly"
#include "wx/msw/wrapcctl.h"

// Wine doesn't have this yet
#ifndef ListView_CreateDragImage
#define ListView_CreateDragImage(hwnd, i, lpptUpLeft) \
    (HIMAGELIST)SNDMSG((hwnd), LVM_CREATEDRAGIMAGE, (WPARAM)(int)(i), (LPARAM)(LPPOINT)(lpptUpLeft))
#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;

#ifdef __WXWINCE__
    UINT flags = ILC_COLOR;
#else
    UINT flags wxDUMMY_INITIALIZE(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;
#endif

    bool mask = (image.GetMask() != 0);

    // Curiously, even if the image doesn't have a mask,
    // we still have to use ILC_MASK or the image won't show
    // up when dragged.
//    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;

#ifdef __WXWINCE__
    UINT flags = ILC_COLOR;
#else
    UINT flags wxDUMMY_INITIALIZE(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;
#endif
    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::GetFont(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);

#if wxUSE_WXDIB
    // Make the bitmap masked
    wxImage image = bitmap.ConvertToImage();
    image.SetMaskColour(255, 255, 255);
    return Create(wxBitmap(image), cursor);
#else
    return false;
#endif
}

#if wxUSE_TREECTRL
// 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(GetHwndOf(&treeCtrl), (HTREEITEM) id.m_pItem);
    return m_hImageList != 0;
}
#endif

#if wxUSE_LISTCTRL
// 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;
}
#endif

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