X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/68be9f090f422450d333385cf62c9b4d350674be..6f026b5b63fe7ccb025e84509886f74772b9df13:/src/generic/dragimgg.cpp

diff --git a/src/generic/dragimgg.cpp b/src/generic/dragimgg.cpp
index 747b155153..15561e5e54 100644
--- a/src/generic/dragimgg.cpp
+++ b/src/generic/dragimgg.cpp
@@ -1,10 +1,9 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        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
 /////////////////////////////////////////////////////////////////////////////
@@ -17,40 +16,29 @@
 // headers
 // ----------------------------------------------------------------------------
 
-#ifdef __GNUG__
-#pragma implementation "dragimgg.h"
-#endif
-
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
-#pragma hdrstop
+    #pragma hdrstop
 #endif
 
+#if wxUSE_DRAGIMAGE
+
 #ifndef WX_PRECOMP
-#include <stdio.h>
-#include "wx/setup.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"
+    #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"
+    #include "wx/intl.h"
+    #include "wx/log.h"
+    #include "wx/image.h"
 #endif
 
-#include "wx/log.h"
-#include "wx/intl.h"
-
-#ifdef __WIN16__
-#define wxUSE_IMAGE_IN_DRAGIMAGE 0
-#else
 #define wxUSE_IMAGE_IN_DRAGIMAGE 1
-#endif
-
-#if wxUSE_IMAGE_IN_DRAGIMAGE
-#include "wx/image.h"
-#endif
 
 #include "wx/generic/dragimgg.h"
 
@@ -68,11 +56,6 @@ IMPLEMENT_DYNAMIC_CLASS(wxGenericDragImage, wxObject)
 // wxGenericDragImage ctors/dtor
 // ----------------------------------------------------------------------------
 
-wxGenericDragImage::wxGenericDragImage()
-{
-    Init();
-}
-
 wxGenericDragImage::~wxGenericDragImage()
 {
     if (m_windowDC)
@@ -83,12 +66,66 @@ wxGenericDragImage::~wxGenericDragImage()
 
 void wxGenericDragImage::Init()
 {
-    m_isDirty = FALSE;
-    m_isShown = FALSE;
-    m_windowDC = (wxDC*) NULL;
-    m_window = (wxWindow*) NULL;
-    m_fullScreen = FALSE;
+    m_isDirty = false;
+    m_isShown = false;
+    m_windowDC = NULL;
+    m_window = NULL;
+    m_fullScreen = false;
+#ifdef wxHAS_NATIVE_OVERLAY
+    m_dcOverlay = NULL;
+#else
+    m_pBackingBitmap = NULL;
+#endif
+}
+
+#if WXWIN_COMPATIBILITY_2_6
+wxGenericDragImage::wxGenericDragImage(const wxCursor& cursor, const wxPoint& WXUNUSED(cursorHotspot))
+{
+    Init();
+    Create(cursor);
+}
+
+wxGenericDragImage::wxGenericDragImage(const wxBitmap& image, const wxCursor& cursor, const wxPoint& WXUNUSED(cursorHotspot))
+{
+    Init();
+
+    Create(image, cursor);
+}
+
+wxGenericDragImage::wxGenericDragImage(const wxIcon& image, const wxCursor& cursor, const wxPoint& WXUNUSED(cursorHotspot))
+{
+    Init();
+
+    Create(image, cursor);
+}
+
+wxGenericDragImage::wxGenericDragImage(const wxString& str, const wxCursor& cursor, const wxPoint& WXUNUSED(cursorHotspot))
+{
+    Init();
+
+    Create(str, cursor);
+}
+
+bool wxGenericDragImage::Create(const wxCursor& cursor, const wxPoint& WXUNUSED(cursorHotspot))
+{
+    return Create(cursor);
+}
+
+bool wxGenericDragImage::Create(const wxBitmap& image, const wxCursor& cursor, const wxPoint& WXUNUSED(cursorHotspot))
+{
+    return Create(image, cursor);
+}
+
+bool wxGenericDragImage::Create(const wxIcon& image, const wxCursor& cursor, const wxPoint& WXUNUSED(cursorHotspot))
+{
+    return Create(image, cursor);
+}
+
+bool wxGenericDragImage::Create(const wxString& str, const wxCursor& cursor, const wxPoint& WXUNUSED(cursorHotspot))
+{
+    return Create(str, cursor);
 }
+#endif // WXWIN_COMPATIBILITY_2_6
 
 // Attributes
 ////////////////////////////////////////////////////////////////////////////
@@ -97,53 +134,59 @@ void wxGenericDragImage::Init()
 // 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, const wxPoint& hotspot)
+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_hotspot = hotspot;
     m_bitmap = image;
 
-    return TRUE ;
+    return true ;
 }
 
 // Create a drag image from an icon and optional cursor
-bool wxGenericDragImage::Create(const wxIcon& image, const wxCursor& cursor, const wxPoint& hotspot)
+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_hotspot = hotspot;
     m_icon = image;
 
-    return TRUE ;
+    return true ;
 }
 
 // Create a drag image from a string and optional cursor
-bool wxGenericDragImage::Create(const wxString& str, const wxCursor& cursor, const wxPoint& hotspot)
+bool wxGenericDragImage::Create(const wxString& str, const wxCursor& cursor)
 {
-    wxFont font(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
+    wxFont font(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
 
-    long w, h;
+    wxCoord w = 0, h = 0;
     wxScreenDC dc;
     dc.SetFont(font);
     dc.GetTextExtent(str, & w, & h);
     dc.SetFont(wxNullFont);
 
     wxMemoryDC dc2;
-    dc2.SetFont(font);
 
     // 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.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
     dc2.SetTextForeground(* wxLIGHT_GREY);
     dc2.DrawText(str, 0, 0);
     dc2.DrawText(str, 1, 0);
@@ -158,60 +201,66 @@ bool wxGenericDragImage::Create(const wxString& str, const wxCursor& cursor, con
 
     dc2.SelectObject(wxNullBitmap);
 
-#if wxUSE_IMAGE_IN_DRAGIMAGE
+#if wxUSE_IMAGE_IN_DRAGIMAGE && (!defined(__WXMSW__) || wxUSE_WXDIB)
     // Make the bitmap masked
-    wxImage image(bitmap);
+    wxImage image = bitmap.ConvertToImage();
     image.SetMaskColour(255, 255, 255);
-    bitmap = image.ConvertToBitmap();
+    bitmap = wxBitmap(image);
 #endif
 
-    return Create(bitmap, cursor, hotspot);
+    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)
+bool wxGenericDragImage::BeginDrag(const wxPoint& hotspot,
+                                   wxWindow* window,
+                                   bool fullScreen,
+                                   wxRect* rect)
 {
-    wxASSERT_MSG( (window != 0), wxT("Window must not be null in BeginDrag."));
+    wxCHECK_MSG( window, false, 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;
+    m_isDirty = false;
+    m_isShown = false;
 
-    if (window)
+    if (m_cursor.IsOk())
     {
-        window->CaptureMouse();
-
-        if (m_cursor.Ok())
-        {
-            m_oldCursor = window->GetCursor();
-            window->SetCursor(m_cursor);
-        }
+        m_oldCursor = window->GetCursor();
+        window->SetCursor(m_cursor);
     }
 
+    window->CaptureMouse();
+
     // Make a copy of the window so we can repair damage done as the image is
     // dragged.
 
     wxSize clientSize;
-    wxPoint pt(0, 0);
+    wxPoint pt;
     if (!m_fullScreen)
     {
         clientSize = window->GetClientSize();
@@ -235,11 +284,17 @@ bool wxGenericDragImage::BeginDrag(const wxPoint& hotspot, wxWindow* window, boo
         }
     }
 
-    if (!m_backingBitmap.Ok() || (m_backingBitmap.GetWidth() < clientSize.x || m_backingBitmap.GetHeight() < clientSize.y))
-        m_backingBitmap = wxBitmap(clientSize.x, clientSize.y);
+#ifndef wxHAS_NATIVE_OVERLAY
+    wxBitmap* backing = (m_pBackingBitmap ? m_pBackingBitmap : (wxBitmap*) & m_backingBitmap);
+
+    if (!backing->IsOk() || (backing->GetWidth() < clientSize.x || backing->GetHeight() < clientSize.y))
+        (*backing) = wxBitmap(clientSize.x, clientSize.y);
+#endif // !wxHAS_NATIVE_OVERLAY
 
     if (!m_fullScreen)
+    {
         m_windowDC = new wxClientDC(window);
+    }
     else
     {
         m_windowDC = new wxScreenDC;
@@ -253,7 +308,7 @@ bool wxGenericDragImage::BeginDrag(const wxPoint& hotspot, wxWindow* window, boo
             m_boundingRect.width, m_boundingRect.height);
     }
 
-    return TRUE;
+    return true;
 }
 
 // Begin drag. hotspot is the location of the drag position relative to the upper-left
@@ -265,16 +320,16 @@ bool wxGenericDragImage::BeginDrag(const wxPoint& hotspot, wxWindow* window, wxW
 
     int x = fullScreenRect->GetPosition().x;
     int y = fullScreenRect->GetPosition().y;
-    
+
     wxSize sz = fullScreenRect->GetSize();
 
-    if (fullScreenRect->GetParent() && !fullScreenRect->IsKindOf(CLASSINFO(wxFrame)))
+    if (fullScreenRect->GetParent() && !wxDynamicCast(fullScreenRect, 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);
+    return BeginDrag(hotspot, window, true, & rect);
 }
 
 // End drag
@@ -282,8 +337,14 @@ bool wxGenericDragImage::EndDrag()
 {
     if (m_window)
     {
-        m_window->ReleaseMouse();
-        if (m_cursor.Ok() && m_oldCursor.Ok())
+#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.IsOk() && m_oldCursor.IsOk())
         {
             m_window->SetCursor(m_oldCursor);
         }
@@ -291,42 +352,51 @@ bool wxGenericDragImage::EndDrag()
 
     if (m_windowDC)
     {
+#ifdef wxHAS_NATIVE_OVERLAY
+        m_overlay.Reset();
+#else
         m_windowDC->DestroyClippingRegion();
-        delete m_windowDC;
-        m_windowDC = (wxDC*) NULL;
+#endif
+        wxDELETE(m_windowDC);
     }
 
+#ifndef wxHAS_NATIVE_OVERLAY
     m_repairBitmap = wxNullBitmap;
+#endif
 
-    return TRUE;
+    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), "No window DC in wxGenericDragImage::Move()" );
+    wxASSERT_MSG( (m_windowDC != 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, pt, eraseOldImage, TRUE);
+        RedrawImage(oldPos - m_offset, pt2 - m_offset, eraseOldImage, true);
 
-    m_position = pt;
+    m_position = pt2;
 
     if (m_isShown)
-        m_isDirty = TRUE;
+        m_isDirty = true;
 
-    return TRUE;
+    return true;
 }
 
 bool wxGenericDragImage::Show()
 {
-    wxASSERT_MSG( (m_windowDC != (wxDC*) NULL), "No window DC in wxGenericDragImage::Show()" );
-    
+    wxASSERT_MSG( (m_windowDC != NULL), wxT("No window DC in wxGenericDragImage::Show()") );
+
     // Show at the current position
 
     if (!m_isShown)
@@ -334,46 +404,70 @@ bool wxGenericDragImage::Show()
         // This is where we restore the backing bitmap, in case
         // something has changed on the window.
 
+#ifndef wxHAS_NATIVE_OVERLAY
+        wxBitmap* backing = (m_pBackingBitmap ? m_pBackingBitmap : (wxBitmap*) & m_backingBitmap);
         wxMemoryDC memDC;
-        memDC.SelectObject(m_backingBitmap);
-        memDC.Blit(0, 0, m_boundingRect.width, m_boundingRect.height, m_windowDC, m_boundingRect.x, m_boundingRect.y);
+        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);
+#endif // !wxHAS_NATIVE_OVERLAY
 
-        RedrawImage(m_position, m_position, FALSE, TRUE);
+        RedrawImage(m_position - m_offset, m_position - m_offset, false, true);
     }
 
-    m_isShown = TRUE;
-    m_isDirty = TRUE;
+    m_isShown = true;
+    m_isDirty = true;
 
-    return 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), "No window DC in wxGenericDragImage::Hide()" );
+    wxASSERT_MSG( (m_windowDC != NULL), wxT("No window DC in wxGenericDragImage::Hide()") );
 
     // Repair the old position
 
     if (m_isShown && m_isDirty)
     {
-        RedrawImage(m_position, m_position, TRUE, FALSE);
+        RedrawImage(m_position - m_offset, m_position - m_offset, true, false);
     }
 
-    m_isShown = FALSE;
-    m_isDirty = FALSE;
+    m_isShown = false;
+    m_isDirty = false;
 
-    return TRUE;
+    return true;
 }
 
 // More efficient: erase and redraw simultaneously if possible
-bool wxGenericDragImage::RedrawImage(const wxPoint& oldPos, const wxPoint& newPos,
+bool wxGenericDragImage::RedrawImage(const wxPoint& oldPos,
+                                     const wxPoint& newPos,
                                      bool eraseOld, bool drawNew)
 {
     if (!m_windowDC)
-        return FALSE;
+        return false;
 
-    if (!m_backingBitmap.Ok())
-        return FALSE;
+#ifdef wxHAS_NATIVE_OVERLAY
+    wxUnusedVar(oldPos);
+
+    wxDCOverlay dcoverlay( m_overlay, (wxWindowDC*) m_windowDC ) ;
+    if ( eraseOld )
+        dcoverlay.Clear() ;
+    if (drawNew)
+        DoDrawImage(*m_windowDC, newPos);
+#else // !wxHAS_NATIVE_OVERLAY
+    wxBitmap* backing = (m_pBackingBitmap ? m_pBackingBitmap : (wxBitmap*) & m_backingBitmap);
+    if (!backing->IsOk())
+        return false;
 
     wxRect oldRect(GetImageRect(oldPos));
     wxRect newRect(GetImageRect(newPos));
@@ -404,13 +498,13 @@ bool wxGenericDragImage::RedrawImage(const wxPoint& oldPos, const wxPoint& newPo
     // keep reallocating all the time.
     int excess = 50;
 
-    if (!m_repairBitmap.Ok() || (m_repairBitmap.GetWidth() < fullRect.GetWidth() || m_repairBitmap.GetHeight() < fullRect.GetHeight()))
+    if (!m_repairBitmap.IsOk() || (m_repairBitmap.GetWidth() < fullRect.GetWidth() || m_repairBitmap.GetHeight() < fullRect.GetHeight()))
     {
         m_repairBitmap = wxBitmap(fullRect.GetWidth() + excess, fullRect.GetHeight() + excess);
     }
 
     wxMemoryDC memDC;
-    memDC.SelectObject(m_backingBitmap);
+    memDC.SelectObject(* backing);
 
     wxMemoryDC memDCTemp;
     memDCTemp.SelectObject(m_repairBitmap);
@@ -426,12 +520,8 @@ bool wxGenericDragImage::RedrawImage(const wxPoint& oldPos, const wxPoint& newPo
     // If drawing, draw the image onto the mem DC
     if (drawNew)
     {
-        int x = newPos.x - fullRect.x;
-        int y = newPos.y - fullRect.y;
-        if (m_bitmap.Ok())
-            memDCTemp.DrawBitmap(m_bitmap, x, y, (m_bitmap.GetMask() != 0));
-        else if (m_icon.Ok())
-            memDCTemp.DrawIcon(m_icon, x, y);
+        wxPoint pos(newPos.x - fullRect.x, newPos.y - fullRect.y) ;
+        DoDrawImage(memDCTemp, pos);
     }
 
     // Now blit to the window
@@ -440,17 +530,36 @@ bool wxGenericDragImage::RedrawImage(const wxPoint& oldPos, const wxPoint& newPo
 
     memDCTemp.SelectObject(wxNullBitmap);
     memDC.SelectObject(wxNullBitmap);
+#endif // wxHAS_NATIVE_OVERLAY/!wxHAS_NATIVE_OVERLAY
 
-    return TRUE;
+    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.IsOk())
+    {
+        dc.DrawBitmap(m_bitmap, pos.x, pos.y, (m_bitmap.GetMask() != 0));
+        return true;
+    }
+    else if (m_icon.IsOk())
+    {
+        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())
+    if (m_bitmap.IsOk())
     {
         return wxRect(pos.x, pos.y, m_bitmap.GetWidth(), m_bitmap.GetHeight());
     }
-    else if (m_icon.Ok())
+    else if (m_icon.IsOk())
     {
         return wxRect(pos.x, pos.y, m_icon.GetWidth(), m_icon.GetHeight());
     }
@@ -460,3 +569,4 @@ wxRect wxGenericDragImage::GetImageRect(const wxPoint& pos) const
     }
 }
 
+#endif // wxUSE_DRAGIMAGE