src/generic/dragimgg.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/generic/dragimgg.cpp
// Purpose:     Generic wxDragImage implementation
// Author:      Julian Smart
// Modified by:
// Created:     29/2/2000
// 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/window.h"
#include "wx/frame.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"

#define wxUSE_IMAGE_IN_DRAGIMAGE 1

#if wxUSE_IMAGE_IN_DRAGIMAGE
#include "wx/image.h"
#endif

#include "wx/generic/dragimgg.h"

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

IMPLEMENT_DYNAMIC_CLASS(wxGenericDragImage, wxObject)

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

// ----------------------------------------------------------------------------
// wxGenericDragImage ctors/dtor
// ----------------------------------------------------------------------------

wxGenericDragImage::~wxGenericDragImage()
{
    if (m_windowDC)
    {
        delete m_windowDC;
    }
}

void wxGenericDragImage::Init()
{
    m_isDirty = false;
    m_isShown = false;
    m_windowDC = (wxDC*) NULL;
    m_window = (wxWindow*) NULL;
    m_fullScreen = false;
    m_pBackingBitmap = (wxBitmap*) NULL;
}

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


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

// Create a drag image with a virtual image (need to override DoDrawImage, GetImageRect)
bool wxGenericDragImage::Create(const wxCursor& cursor)
{
    m_cursor = cursor;

    return true;
}

// Create a drag image from a bitmap and optional cursor
bool wxGenericDragImage::Create(const wxBitmap& image, const wxCursor& cursor)
{
    // We don't have to combine the cursor explicitly since we simply show the cursor
    // as we drag. This currently will only work within one window.

    m_cursor = cursor;
    m_bitmap = image;

    return true ;
}

// Create a drag image from an icon and optional cursor
bool wxGenericDragImage::Create(const wxIcon& image, const wxCursor& cursor)
{
    // We don't have to combine the cursor explicitly since we simply show the cursor
    // as we drag. This currently will only work within one window.

    m_cursor = cursor;
    m_icon = image;

    return true ;
}

// Create a drag image from a string and optional cursor
bool wxGenericDragImage::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;

    // Sometimes GetTextExtent isn't accurate enough, so make it longer
    wxBitmap bitmap((int) ((w+2) * 1.5), (int) h+2);
    dc2.SelectObject(bitmap);

    dc2.SetFont(font);
    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_IMAGE_IN_DRAGIMAGE && (!defined(__WXMSW__) || wxUSE_WXDIB)
    // Make the bitmap masked
    wxImage image = bitmap.ConvertToImage();
    image.SetMaskColour(255, 255, 255);
    bitmap = wxBitmap(image);
#endif

    return Create(bitmap, cursor);
}

#if wxUSE_TREECTRL
// Create a drag image for the given tree control item
bool wxGenericDragImage::Create(const wxTreeCtrl& treeCtrl, wxTreeItemId& id)
{
    wxString str = treeCtrl.GetItemText(id);
    return Create(str);
}
#endif

#if wxUSE_LISTCTRL
// Create a drag image for the given list control item
bool wxGenericDragImage::Create(const wxListCtrl& listCtrl, long id)
{
    wxString str = listCtrl.GetItemText(id);
    return Create(str);
}
#endif

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

    // The image should be offset by this amount
    m_offset = hotspot;
    m_window = window;
    m_fullScreen = fullScreen;

    if (rect)
        m_boundingRect = * rect;

    m_isDirty = false;
    m_isDirty = false;

    if (window)
    {
        window->CaptureMouse();

        if (m_cursor.Ok())
        {
            m_oldCursor = window->GetCursor();
            window->SetCursor(m_cursor);
        }
    }

    // Make a copy of the window so we can repair damage done as the image is
    // dragged.

    wxSize clientSize;
    wxPoint pt;
    if (!m_fullScreen)
    {
        clientSize = window->GetClientSize();
        m_boundingRect.x = 0; m_boundingRect.y = 0;
        m_boundingRect.width = clientSize.x; m_boundingRect.height = clientSize.y;
    }
    else
    {
        int w, h;
        wxDisplaySize(& w, & h);
        clientSize.x = w; clientSize.y = h;
        if (rect)
        {
            pt.x = m_boundingRect.x; pt.y = m_boundingRect.y;
            clientSize.x = m_boundingRect.width; clientSize.y = m_boundingRect.height;
        }
        else
        {
            m_boundingRect.x = 0; m_boundingRect.y = 0;
            m_boundingRect.width = w; m_boundingRect.height = h;
        }
    }

    wxBitmap* backing = (m_pBackingBitmap ? m_pBackingBitmap : (wxBitmap*) & m_backingBitmap);

    if (!backing->Ok() || (backing->GetWidth() < clientSize.x || backing->GetHeight() < clientSize.y))
        (*backing) = wxBitmap(clientSize.x, clientSize.y);

    if (!m_fullScreen)
    {
        m_windowDC = new wxClientDC(window);
    }
    else
    {
        m_windowDC = new wxScreenDC;

#if 0
        // Use m_boundingRect to limit the area considered.
        ((wxScreenDC*) m_windowDC)->StartDrawingOnTop(rect);
#endif

        m_windowDC->SetClippingRegion(m_boundingRect.x, m_boundingRect.y,
            m_boundingRect.width, m_boundingRect.height);
    }

    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 wxGenericDragImage::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 wxGenericDragImage::EndDrag()
{
    if (m_window)
    {
#ifdef __WXMSW__
        // Under Windows we can be pretty sure this test will give
        // the correct results
        if (wxWindow::GetCapture() == m_window)
#endif
            m_window->ReleaseMouse();

        if (m_cursor.Ok() && m_oldCursor.Ok())
        {
            m_window->SetCursor(m_oldCursor);
        }
    }

    if (m_windowDC)
    {
        m_windowDC->DestroyClippingRegion();
        delete m_windowDC;
        m_windowDC = (wxDC*) NULL;
    }

    m_repairBitmap = wxNullBitmap;

    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 wxGenericDragImage::Move(const wxPoint& pt)
{
    wxASSERT_MSG( (m_windowDC != (wxDC*) NULL), wxT("No window DC in wxGenericDragImage::Move()") );

    wxPoint pt2(pt);
    if (m_fullScreen)
        pt2 = m_window->ClientToScreen(pt);

    // Erase at old position, then show at the current position
    wxPoint oldPos = m_position;

    bool eraseOldImage = (m_isDirty && m_isShown);

    if (m_isShown)
        RedrawImage(oldPos - m_offset, pt2 - m_offset, eraseOldImage, true);

    m_position = pt2;

    if (m_isShown)
        m_isDirty = true;

    return true;
}

bool wxGenericDragImage::Show()
{
    wxASSERT_MSG( (m_windowDC != (wxDC*) NULL), wxT("No window DC in wxGenericDragImage::Show()") );

    // Show at the current position

    if (!m_isShown)
    {
        // This is where we restore the backing bitmap, in case
        // something has changed on the window.

        wxBitmap* backing = (m_pBackingBitmap ? m_pBackingBitmap : (wxBitmap*) & m_backingBitmap);
        wxMemoryDC memDC;
        memDC.SelectObject(* backing);

        UpdateBackingFromWindow(* m_windowDC, memDC, m_boundingRect, wxRect(0, 0, m_boundingRect.width, m_boundingRect.height));

        //memDC.Blit(0, 0, m_boundingRect.width, m_boundingRect.height, m_windowDC, m_boundingRect.x, m_boundingRect.y);
        memDC.SelectObject(wxNullBitmap);

        RedrawImage(m_position - m_offset, m_position - m_offset, false, true);
    }

    m_isShown = true;
    m_isDirty = true;

    return true;
}

bool wxGenericDragImage::UpdateBackingFromWindow(wxDC& windowDC, wxMemoryDC& destDC,
    const wxRect& sourceRect, const wxRect& destRect) const
{
    return destDC.Blit(destRect.x, destRect.y, destRect.width, destRect.height, & windowDC,
        sourceRect.x, sourceRect.y);
}

bool wxGenericDragImage::Hide()
{
    wxASSERT_MSG( (m_windowDC != (wxDC*) NULL), wxT("No window DC in wxGenericDragImage::Hide()") );

    // Repair the old position

    if (m_isShown && m_isDirty)
    {
        RedrawImage(m_position - m_offset, m_position - m_offset, true, false);
    }

    m_isShown = false;
    m_isDirty = false;

    return true;
}

// More efficient: erase and redraw simultaneously if possible
bool wxGenericDragImage::RedrawImage(const wxPoint& oldPos, const wxPoint& newPos,
                                     bool eraseOld, bool drawNew)
{
    if (!m_windowDC)
        return false;

    wxBitmap* backing = (m_pBackingBitmap ? m_pBackingBitmap : (wxBitmap*) & m_backingBitmap);
    if (!backing->Ok())
        return false;

    wxRect oldRect(GetImageRect(oldPos));
    wxRect newRect(GetImageRect(newPos));

    wxRect fullRect;

    // Full rect: the combination of both rects
    if (eraseOld && drawNew)
    {
        int oldRight = oldRect.GetRight();
        int oldBottom = oldRect.GetBottom();
        int newRight = newRect.GetRight();
        int newBottom = newRect.GetBottom();

        wxPoint topLeft = wxPoint(wxMin(oldPos.x, newPos.x), wxMin(oldPos.y, newPos.y));
        wxPoint bottomRight = wxPoint(wxMax(oldRight, newRight), wxMax(oldBottom, newBottom));

        fullRect.x = topLeft.x; fullRect.y = topLeft.y;
        fullRect.SetRight(bottomRight.x);
        fullRect.SetBottom(bottomRight.y);
    }
    else if (eraseOld)
        fullRect = oldRect;
    else if (drawNew)
        fullRect = newRect;

    // Make the bitmap bigger than it need be, so we don't
    // keep reallocating all the time.
    int excess = 50;

    if (!m_repairBitmap.Ok() || (m_repairBitmap.GetWidth() < fullRect.GetWidth() || m_repairBitmap.GetHeight() < fullRect.GetHeight()))
    {
        m_repairBitmap = wxBitmap(fullRect.GetWidth() + excess, fullRect.GetHeight() + excess);
    }

    wxMemoryDC memDC;
    memDC.SelectObject(* backing);

    wxMemoryDC memDCTemp;
    memDCTemp.SelectObject(m_repairBitmap);

    // Draw the backing bitmap onto the repair bitmap.
    // If full-screen, we may have specified the rect on the
    // screen that we're using for our backing bitmap.
    // So subtract this when we're blitting from the backing bitmap
    // (translate from screen to backing-bitmap coords).

    memDCTemp.Blit(0, 0, fullRect.GetWidth(), fullRect.GetHeight(), & memDC, fullRect.x - m_boundingRect.x, fullRect.y - m_boundingRect.y);

    // If drawing, draw the image onto the mem DC
    if (drawNew)
    {
        wxPoint pos(newPos.x - fullRect.x, newPos.y - fullRect.y) ;
        DoDrawImage(memDCTemp, pos);
    }

    // Now blit to the window
    // Finally, blit the temp mem DC to the window.
    m_windowDC->Blit(fullRect.x, fullRect.y, fullRect.width, fullRect.height, & memDCTemp, 0, 0);

    memDCTemp.SelectObject(wxNullBitmap);
    memDC.SelectObject(wxNullBitmap);

    return true;
}

// Override this if you are using a virtual image (drawing your own image)
bool wxGenericDragImage::DoDrawImage(wxDC& dc, const wxPoint& pos) const
{
    if (m_bitmap.Ok())
    {
        dc.DrawBitmap(m_bitmap, pos.x, pos.y, (m_bitmap.GetMask() != 0));
        return true;
    }
    else if (m_icon.Ok())
    {
        dc.DrawIcon(m_icon, pos.x, pos.y);
        return true;
    }
    else
        return false;
}

// Override this if you are using a virtual image (drawing your own image)
wxRect wxGenericDragImage::GetImageRect(const wxPoint& pos) const
{
    if (m_bitmap.Ok())
    {
        return wxRect(pos.x, pos.y, m_bitmap.GetWidth(), m_bitmap.GetHeight());
    }
    else if (m_icon.Ok())
    {
        return wxRect(pos.x, pos.y, m_icon.GetWidth(), m_icon.GetHeight());
    }
    else
    {
        return wxRect(pos.x, pos.y, 0, 0);
    }
}

#endif // wxUSE_DRAGIMAGE
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/generic/dragimgg.cpp
	3	// Purpose: Generic wxDragImage implementation
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 29/2/2000
	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/window.h"
	32	#include "wx/frame.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/log.h"
	40	#include "wx/intl.h"
	41
	42	#define wxUSE_IMAGE_IN_DRAGIMAGE 1
	43
	44	#if wxUSE_IMAGE_IN_DRAGIMAGE
	45	#include "wx/image.h"
	46	#endif
	47
	48	#include "wx/generic/dragimgg.h"
	49
	50	// ----------------------------------------------------------------------------
	51	// macros
	52	// ----------------------------------------------------------------------------
	53
	54	IMPLEMENT_DYNAMIC_CLASS(wxGenericDragImage, wxObject)
	55
	56	// ============================================================================
	57	// implementation
	58	// ============================================================================
	59
	60	// ----------------------------------------------------------------------------
	61	// wxGenericDragImage ctors/dtor
	62	// ----------------------------------------------------------------------------
	63
	64	wxGenericDragImage::~wxGenericDragImage()
	65	{
	66	if (m_windowDC)
	67	{
	68	delete m_windowDC;
	69	}
	70	}
	71
	72	void wxGenericDragImage::Init()
	73	{
	74	m_isDirty = false;
	75	m_isShown = false;
	76	m_windowDC = (wxDC*) NULL;
	77	m_window = (wxWindow*) NULL;
	78	m_fullScreen = false;
	79	m_pBackingBitmap = (wxBitmap*) NULL;
	80	}
	81
	82	// Attributes
	83	////////////////////////////////////////////////////////////////////////////
	84
	85
	86	// Operations
	87	////////////////////////////////////////////////////////////////////////////
	88
	89	// Create a drag image with a virtual image (need to override DoDrawImage, GetImageRect)
	90	bool wxGenericDragImage::Create(const wxCursor& cursor)
	91	{
	92	m_cursor = cursor;
	93
	94	return true;
	95	}
	96
	97	// Create a drag image from a bitmap and optional cursor
	98	bool wxGenericDragImage::Create(const wxBitmap& image, const wxCursor& cursor)
	99	{
	100	// We don't have to combine the cursor explicitly since we simply show the cursor
	101	// as we drag. This currently will only work within one window.
	102
	103	m_cursor = cursor;
	104	m_bitmap = image;
	105
	106	return true ;
	107	}
	108
	109	// Create a drag image from an icon and optional cursor
	110	bool wxGenericDragImage::Create(const wxIcon& image, const wxCursor& cursor)
	111	{
	112	// We don't have to combine the cursor explicitly since we simply show the cursor
	113	// as we drag. This currently will only work within one window.
	114
	115	m_cursor = cursor;
	116	m_icon = image;
	117
	118	return true ;
	119	}
	120
	121	// Create a drag image from a string and optional cursor
	122	bool wxGenericDragImage::Create(const wxString& str, const wxCursor& cursor)
	123	{
	124	wxFont font(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
	125
	126	long w, h;
	127	wxScreenDC dc;
	128	dc.SetFont(font);
	129	dc.GetTextExtent(str, & w, & h);
	130	dc.SetFont(wxNullFont);
	131
	132	wxMemoryDC dc2;
	133
	134	// Sometimes GetTextExtent isn't accurate enough, so make it longer
	135	wxBitmap bitmap((int) ((w+2) * 1.5), (int) h+2);
	136	dc2.SelectObject(bitmap);
	137
	138	dc2.SetFont(font);
	139	dc2.SetBackground(* wxWHITE_BRUSH);
	140	dc2.Clear();
	141	dc2.SetBackgroundMode(wxTRANSPARENT);
	142	dc2.SetTextForeground(* wxLIGHT_GREY);
	143	dc2.DrawText(str, 0, 0);
	144	dc2.DrawText(str, 1, 0);
	145	dc2.DrawText(str, 2, 0);
	146	dc2.DrawText(str, 1, 1);
	147	dc2.DrawText(str, 2, 1);
	148	dc2.DrawText(str, 1, 2);
	149	dc2.DrawText(str, 2, 2);
	150
	151	dc2.SetTextForeground(* wxBLACK);
	152	dc2.DrawText(str, 1, 1);
	153
	154	dc2.SelectObject(wxNullBitmap);
	155
	156	#if wxUSE_IMAGE_IN_DRAGIMAGE && (!defined(__WXMSW__) \|\| wxUSE_WXDIB)
	157	// Make the bitmap masked
	158	wxImage image = bitmap.ConvertToImage();
	159	image.SetMaskColour(255, 255, 255);
	160	bitmap = wxBitmap(image);
	161	#endif
	162
	163	return Create(bitmap, cursor);
	164	}
	165
	166	#if wxUSE_TREECTRL
	167	// Create a drag image for the given tree control item
	168	bool wxGenericDragImage::Create(const wxTreeCtrl& treeCtrl, wxTreeItemId& id)
	169	{
	170	wxString str = treeCtrl.GetItemText(id);
	171	return Create(str);
	172	}
	173	#endif
	174
	175	#if wxUSE_LISTCTRL
	176	// Create a drag image for the given list control item
	177	bool wxGenericDragImage::Create(const wxListCtrl& listCtrl, long id)
	178	{
	179	wxString str = listCtrl.GetItemText(id);
	180	return Create(str);
	181	}
	182	#endif
	183
	184	// Begin drag
	185	bool wxGenericDragImage::BeginDrag(const wxPoint& hotspot,
	186	wxWindow* window,
	187	bool fullScreen,
	188	wxRect* rect)
	189	{
	190	wxASSERT_MSG( (window != 0), wxT("Window must not be null in BeginDrag."));
	191
	192	// The image should be offset by this amount
	193	m_offset = hotspot;
	194	m_window = window;
	195	m_fullScreen = fullScreen;
	196
	197	if (rect)
	198	m_boundingRect = * rect;
	199
	200	m_isDirty = false;
	201	m_isDirty = false;
	202
	203	if (window)
	204	{
	205	window->CaptureMouse();
	206
	207	if (m_cursor.Ok())
	208	{
	209	m_oldCursor = window->GetCursor();
	210	window->SetCursor(m_cursor);
	211	}
	212	}
	213
	214	// Make a copy of the window so we can repair damage done as the image is
	215	// dragged.
	216
	217	wxSize clientSize;
	218	wxPoint pt;
	219	if (!m_fullScreen)
	220	{
	221	clientSize = window->GetClientSize();
	222	m_boundingRect.x = 0; m_boundingRect.y = 0;
	223	m_boundingRect.width = clientSize.x; m_boundingRect.height = clientSize.y;
	224	}
	225	else
	226	{
	227	int w, h;
	228	wxDisplaySize(& w, & h);
	229	clientSize.x = w; clientSize.y = h;
	230	if (rect)
	231	{
	232	pt.x = m_boundingRect.x; pt.y = m_boundingRect.y;
	233	clientSize.x = m_boundingRect.width; clientSize.y = m_boundingRect.height;
	234	}
	235	else
	236	{
	237	m_boundingRect.x = 0; m_boundingRect.y = 0;
	238	m_boundingRect.width = w; m_boundingRect.height = h;
	239	}
	240	}
	241
	242	wxBitmap* backing = (m_pBackingBitmap ? m_pBackingBitmap : (wxBitmap*) & m_backingBitmap);
	243
	244	if (!backing->Ok() \|\| (backing->GetWidth() < clientSize.x \|\| backing->GetHeight() < clientSize.y))
	245	(*backing) = wxBitmap(clientSize.x, clientSize.y);
	246
	247	if (!m_fullScreen)
	248	{
	249	m_windowDC = new wxClientDC(window);
	250	}
	251	else
	252	{
	253	m_windowDC = new wxScreenDC;
	254
	255	#if 0
	256	// Use m_boundingRect to limit the area considered.
	257	((wxScreenDC*) m_windowDC)->StartDrawingOnTop(rect);
	258	#endif
	259
	260	m_windowDC->SetClippingRegion(m_boundingRect.x, m_boundingRect.y,
	261	m_boundingRect.width, m_boundingRect.height);
	262	}
	263
	264	return true;
	265	}
	266
	267	// Begin drag. hotspot is the location of the drag position relative to the upper-left
	268	// corner of the image. This is full screen only. fullScreenRect gives the
	269	// position of the window on the screen, to restrict the drag to.
	270	bool wxGenericDragImage::BeginDrag(const wxPoint& hotspot, wxWindow* window, wxWindow* fullScreenRect)
	271	{
	272	wxRect rect;
	273
	274	int x = fullScreenRect->GetPosition().x;
	275	int y = fullScreenRect->GetPosition().y;
	276
	277	wxSize sz = fullScreenRect->GetSize();
	278
	279	if (fullScreenRect->GetParent() && !fullScreenRect->IsKindOf(CLASSINFO(wxFrame)))
	280	fullScreenRect->GetParent()->ClientToScreen(& x, & y);
	281
	282	rect.x = x; rect.y = y;
	283	rect.width = sz.x; rect.height = sz.y;
	284
	285	return BeginDrag(hotspot, window, true, & rect);
	286	}
	287
	288	// End drag
	289	bool wxGenericDragImage::EndDrag()
	290	{
	291	if (m_window)
	292	{
	293	#ifdef __WXMSW__
	294	// Under Windows we can be pretty sure this test will give
	295	// the correct results
	296	if (wxWindow::GetCapture() == m_window)
	297	#endif
	298	m_window->ReleaseMouse();
	299
	300	if (m_cursor.Ok() && m_oldCursor.Ok())
	301	{
	302	m_window->SetCursor(m_oldCursor);
	303	}
	304	}
	305
	306	if (m_windowDC)
	307	{
	308	m_windowDC->DestroyClippingRegion();
	309	delete m_windowDC;
	310	m_windowDC = (wxDC*) NULL;
	311	}
	312
	313	m_repairBitmap = wxNullBitmap;
	314
	315	return true;
	316	}
	317
	318	// Move the image: call from OnMouseMove. Pt is in window client coordinates if window
	319	// is non-NULL, or in screen coordinates if NULL.
	320	bool wxGenericDragImage::Move(const wxPoint& pt)
	321	{
	322	wxASSERT_MSG( (m_windowDC != (wxDC*) NULL), wxT("No window DC in wxGenericDragImage::Move()") );
	323
	324	wxPoint pt2(pt);
	325	if (m_fullScreen)
	326	pt2 = m_window->ClientToScreen(pt);
	327
	328	// Erase at old position, then show at the current position
	329	wxPoint oldPos = m_position;
	330
	331	bool eraseOldImage = (m_isDirty && m_isShown);
	332
	333	if (m_isShown)
	334	RedrawImage(oldPos - m_offset, pt2 - m_offset, eraseOldImage, true);
	335
	336	m_position = pt2;
	337
	338	if (m_isShown)
	339	m_isDirty = true;
	340
	341	return true;
	342	}
	343
	344	bool wxGenericDragImage::Show()
	345	{
	346	wxASSERT_MSG( (m_windowDC != (wxDC*) NULL), wxT("No window DC in wxGenericDragImage::Show()") );
	347
	348	// Show at the current position
	349
	350	if (!m_isShown)
	351	{
	352	// This is where we restore the backing bitmap, in case
	353	// something has changed on the window.
	354
	355	wxBitmap* backing = (m_pBackingBitmap ? m_pBackingBitmap : (wxBitmap*) & m_backingBitmap);
	356	wxMemoryDC memDC;
	357	memDC.SelectObject(* backing);
	358
	359	UpdateBackingFromWindow(* m_windowDC, memDC, m_boundingRect, wxRect(0, 0, m_boundingRect.width, m_boundingRect.height));
	360
	361	//memDC.Blit(0, 0, m_boundingRect.width, m_boundingRect.height, m_windowDC, m_boundingRect.x, m_boundingRect.y);
	362	memDC.SelectObject(wxNullBitmap);
	363
	364	RedrawImage(m_position - m_offset, m_position - m_offset, false, true);
	365	}
	366
	367	m_isShown = true;
	368	m_isDirty = true;
	369
	370	return true;
	371	}
	372
	373	bool wxGenericDragImage::UpdateBackingFromWindow(wxDC& windowDC, wxMemoryDC& destDC,
	374	const wxRect& sourceRect, const wxRect& destRect) const
	375	{
	376	return destDC.Blit(destRect.x, destRect.y, destRect.width, destRect.height, & windowDC,
	377	sourceRect.x, sourceRect.y);
	378	}
	379
	380	bool wxGenericDragImage::Hide()
	381	{
	382	wxASSERT_MSG( (m_windowDC != (wxDC*) NULL), wxT("No window DC in wxGenericDragImage::Hide()") );
	383
	384	// Repair the old position
	385
	386	if (m_isShown && m_isDirty)
	387	{
	388	RedrawImage(m_position - m_offset, m_position - m_offset, true, false);
	389	}
	390
	391	m_isShown = false;
	392	m_isDirty = false;
	393
	394	return true;
	395	}
	396
	397	// More efficient: erase and redraw simultaneously if possible
	398	bool wxGenericDragImage::RedrawImage(const wxPoint& oldPos, const wxPoint& newPos,
	399	bool eraseOld, bool drawNew)
	400	{
	401	if (!m_windowDC)
	402	return false;
	403
	404	wxBitmap* backing = (m_pBackingBitmap ? m_pBackingBitmap : (wxBitmap*) & m_backingBitmap);
	405	if (!backing->Ok())
	406	return false;
	407
	408	wxRect oldRect(GetImageRect(oldPos));
	409	wxRect newRect(GetImageRect(newPos));
	410
	411	wxRect fullRect;
	412
	413	// Full rect: the combination of both rects
	414	if (eraseOld && drawNew)
	415	{
	416	int oldRight = oldRect.GetRight();
	417	int oldBottom = oldRect.GetBottom();
	418	int newRight = newRect.GetRight();
	419	int newBottom = newRect.GetBottom();
	420
	421	wxPoint topLeft = wxPoint(wxMin(oldPos.x, newPos.x), wxMin(oldPos.y, newPos.y));
	422	wxPoint bottomRight = wxPoint(wxMax(oldRight, newRight), wxMax(oldBottom, newBottom));
	423
	424	fullRect.x = topLeft.x; fullRect.y = topLeft.y;
	425	fullRect.SetRight(bottomRight.x);
	426	fullRect.SetBottom(bottomRight.y);
	427	}
	428	else if (eraseOld)
	429	fullRect = oldRect;
	430	else if (drawNew)
	431	fullRect = newRect;
	432
	433	// Make the bitmap bigger than it need be, so we don't
	434	// keep reallocating all the time.
	435	int excess = 50;
	436
	437	if (!m_repairBitmap.Ok() \|\| (m_repairBitmap.GetWidth() < fullRect.GetWidth() \|\| m_repairBitmap.GetHeight() < fullRect.GetHeight()))
	438	{
	439	m_repairBitmap = wxBitmap(fullRect.GetWidth() + excess, fullRect.GetHeight() + excess);
	440	}
	441
	442	wxMemoryDC memDC;
	443	memDC.SelectObject(* backing);
	444
	445	wxMemoryDC memDCTemp;
	446	memDCTemp.SelectObject(m_repairBitmap);
	447
	448	// Draw the backing bitmap onto the repair bitmap.
	449	// If full-screen, we may have specified the rect on the
	450	// screen that we're using for our backing bitmap.
	451	// So subtract this when we're blitting from the backing bitmap
	452	// (translate from screen to backing-bitmap coords).
	453
	454	memDCTemp.Blit(0, 0, fullRect.GetWidth(), fullRect.GetHeight(), & memDC, fullRect.x - m_boundingRect.x, fullRect.y - m_boundingRect.y);
	455
	456	// If drawing, draw the image onto the mem DC
	457	if (drawNew)
	458	{
	459	wxPoint pos(newPos.x - fullRect.x, newPos.y - fullRect.y) ;
	460	DoDrawImage(memDCTemp, pos);
	461	}
	462
	463	// Now blit to the window
	464	// Finally, blit the temp mem DC to the window.
	465	m_windowDC->Blit(fullRect.x, fullRect.y, fullRect.width, fullRect.height, & memDCTemp, 0, 0);
	466
	467	memDCTemp.SelectObject(wxNullBitmap);
	468	memDC.SelectObject(wxNullBitmap);
	469
	470	return true;
	471	}
	472
	473	// Override this if you are using a virtual image (drawing your own image)
	474	bool wxGenericDragImage::DoDrawImage(wxDC& dc, const wxPoint& pos) const
	475	{
	476	if (m_bitmap.Ok())
	477	{
	478	dc.DrawBitmap(m_bitmap, pos.x, pos.y, (m_bitmap.GetMask() != 0));
	479	return true;
	480	}
	481	else if (m_icon.Ok())
	482	{
	483	dc.DrawIcon(m_icon, pos.x, pos.y);
	484	return true;
	485	}
	486	else
	487	return false;
	488	}
	489
	490	// Override this if you are using a virtual image (drawing your own image)
	491	wxRect wxGenericDragImage::GetImageRect(const wxPoint& pos) const
	492	{
	493	if (m_bitmap.Ok())
	494	{
	495	return wxRect(pos.x, pos.y, m_bitmap.GetWidth(), m_bitmap.GetHeight());
	496	}
	497	else if (m_icon.Ok())
	498	{
	499	return wxRect(pos.x, pos.y, m_icon.GetWidth(), m_icon.GetHeight());
	500	}
	501	else
	502	{
	503	return wxRect(pos.x, pos.y, 0, 0);
	504	}
	505	}
	506
	507	#endif // wxUSE_DRAGIMAGE