src/generic/dragimgg.cpp

   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