samples/dragimag/dragimag.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        dragimag.cpp
   3 // Purpose:     wxDragImage sample
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     28/2/2000
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx/wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16 #pragma hdrstop
  17 #endif
  18
  19 #ifndef WX_PRECOMP
  20 #include "wx/wx.h"
  21 #endif
  22
  23 #include "wx/image.h"
  24
  25 // Under Windows, change this to 1
  26 // to use wxGenericDragImage
  27
  28 #define wxUSE_GENERIC_DRAGIMAGE 1
  29
  30 #if wxUSE_GENERIC_DRAGIMAGE
  31 #include "wx/generic/dragimgg.h"
  32 #define wxDragImage wxGenericDragImage
  33 #else
  34 #include "wx/dragimag.h"
  35 #endif
  36
  37 #include "dragimag.h"
  38
  39 #ifndef wxHAS_IMAGES_IN_RESOURCES
  40     #include "../sample.xpm"
  41     #include "dragicon.xpm"
  42 #endif
  43
  44 // main program
  45
  46 IMPLEMENT_APP(MyApp)
  47
  48 // MyCanvas
  49
  50 IMPLEMENT_CLASS(MyCanvas, wxScrolledWindow)
  51
  52 BEGIN_EVENT_TABLE(MyCanvas, wxScrolledWindow)
  53   EVT_PAINT(MyCanvas::OnPaint)
  54   EVT_ERASE_BACKGROUND(MyCanvas::OnEraseBackground)
  55   EVT_MOUSE_EVENTS(MyCanvas::OnMouseEvent)
  56 END_EVENT_TABLE()
  57
  58 MyCanvas::MyCanvas( wxWindow *parent, wxWindowID id,
  59                     const wxPoint &pos, const wxSize &size )
  60         : wxScrolledWindow( parent, id, pos, size, wxSUNKEN_BORDER )
  61 {
  62     SetBackgroundColour(* wxWHITE);
  63
  64     SetCursor(wxCursor(wxCURSOR_ARROW));
  65
  66     m_dragMode = TEST_DRAG_NONE;
  67     m_draggedShape = (DragShape*) NULL;
  68     m_dragImage = (wxDragImage*) NULL;
  69     m_currentlyHighlighted = (DragShape*) NULL;
  70 }
  71
  72 MyCanvas::~MyCanvas()
  73 {
  74     ClearShapes();
  75
  76     if (m_dragImage)
  77         delete m_dragImage;
  78 }
  79
  80 void MyCanvas::OnPaint( wxPaintEvent &WXUNUSED(event) )
  81 {
  82     wxPaintDC dc( this );
  83     PrepareDC( dc );
  84
  85     DrawShapes(dc);
  86 }
  87
  88 void MyCanvas::OnEraseBackground(wxEraseEvent& event)
  89 {
  90     if (wxGetApp().GetBackgroundBitmap().IsOk())
  91     {
  92         wxSize sz = GetClientSize();
  93         wxRect rect(0, 0, sz.x, sz.y);
  94
  95         if (event.GetDC())
  96         {
  97             wxGetApp().TileBitmap(rect, *(event.GetDC()), wxGetApp().GetBackgroundBitmap());
  98         }
  99         else
 100         {
 101             wxClientDC dc(this);
 102             wxGetApp().TileBitmap(rect, dc, wxGetApp().GetBackgroundBitmap());
 103         }
 104     }
 105     else
 106         event.Skip(); // The official way of doing it
 107 }
 108
 109 void MyCanvas::OnMouseEvent(wxMouseEvent& event)
 110 {
 111     if (event.LeftDown())
 112     {
 113         DragShape* shape = FindShape(event.GetPosition());
 114         if (shape)
 115         {
 116             // We tentatively start dragging, but wait for
 117             // mouse movement before dragging properly.
 118
 119             m_dragMode = TEST_DRAG_START;
 120             m_dragStartPos = event.GetPosition();
 121             m_draggedShape = shape;
 122         }
 123     }
 124     else if (event.LeftUp() && m_dragMode != TEST_DRAG_NONE)
 125     {
 126         // Finish dragging
 127
 128         m_dragMode = TEST_DRAG_NONE;
 129
 130         if (!m_draggedShape || !m_dragImage)
 131             return;
 132
 133         m_draggedShape->SetPosition(m_draggedShape->GetPosition()
 134                                     + event.GetPosition() - m_dragStartPos);
 135
 136         m_dragImage->Hide();
 137         m_dragImage->EndDrag();
 138         wxDELETE(m_dragImage);
 139
 140         m_draggedShape->SetShow(true);
 141
 142         m_currentlyHighlighted = (DragShape*) NULL;
 143
 144         m_draggedShape = (DragShape*) NULL;
 145
 146         Refresh(true);
 147     }
 148     else if (event.Dragging() && m_dragMode != TEST_DRAG_NONE)
 149     {
 150         if (m_dragMode == TEST_DRAG_START)
 151         {
 152             // We will start dragging if we've moved beyond a couple of pixels
 153
 154             int tolerance = 2;
 155             int dx = abs(event.GetPosition().x - m_dragStartPos.x);
 156             int dy = abs(event.GetPosition().y - m_dragStartPos.y);
 157             if (dx <= tolerance && dy <= tolerance)
 158                 return;
 159
 160             // Start the drag.
 161             m_dragMode = TEST_DRAG_DRAGGING;
 162
 163             if (m_dragImage)
 164                 delete m_dragImage;
 165
 166             // Erase the dragged shape from the canvas
 167             m_draggedShape->SetShow(false);
 168
 169             // redraw immediately
 170             Refresh(true);
 171             Update();
 172
 173             switch (m_draggedShape->GetDragMethod())
 174             {
 175                 case SHAPE_DRAG_BITMAP:
 176                 {
 177                     m_dragImage = new MyDragImage(this, m_draggedShape->GetBitmap(), wxCursor(wxCURSOR_HAND));
 178                     break;
 179                 }
 180                 case SHAPE_DRAG_TEXT:
 181                 {
 182                     m_dragImage = new MyDragImage(this, wxString(wxT("Dragging some test text")), wxCursor(wxCURSOR_HAND));
 183                     break;
 184                 }
 185                 case SHAPE_DRAG_ICON:
 186                 {
 187                     m_dragImage = new MyDragImage(this, wxICON(dragicon), wxCursor(wxCURSOR_HAND));
 188                     break;
 189                 }
 190             }
 191
 192             bool fullScreen = wxGetApp().GetUseScreen();
 193
 194             // The offset between the top-left of the shape image and the current shape position
 195             wxPoint beginDragHotSpot = m_dragStartPos - m_draggedShape->GetPosition();
 196
 197             // Now we do this inside the implementation: always assume
 198             // coordinates relative to the capture window (client coordinates)
 199
 200             //if (fullScreen)
 201             //    beginDragHotSpot -= ClientToScreen(wxPoint(0, 0));
 202
 203             if (!m_dragImage->BeginDrag(beginDragHotSpot, this, fullScreen))
 204             {
 205                 wxDELETE(m_dragImage);
 206                 m_dragMode = TEST_DRAG_NONE;
 207
 208             } else
 209             {
 210                 m_dragImage->Move(event.GetPosition());
 211                 m_dragImage->Show();
 212             }
 213         }
 214         else if (m_dragMode == TEST_DRAG_DRAGGING)
 215         {
 216             // We're currently dragging. See if we're over another shape.
 217             DragShape* onShape = FindShape(event.GetPosition());
 218
 219             bool mustUnhighlightOld = false;
 220             bool mustHighlightNew = false;
 221
 222             if (m_currentlyHighlighted)
 223             {
 224                 if ((onShape == (DragShape*) NULL) || (m_currentlyHighlighted != onShape))
 225                     mustUnhighlightOld = true;
 226             }
 227
 228             if (onShape && (onShape != m_currentlyHighlighted) && onShape->IsShown())
 229                 mustHighlightNew = true;
 230
 231             if (mustUnhighlightOld || mustHighlightNew)
 232                 m_dragImage->Hide();
 233
 234             // Now with the drag image switched off, we can change the window contents.
 235             if (mustUnhighlightOld)
 236                 m_currentlyHighlighted = (DragShape*) NULL;
 237
 238             if (mustHighlightNew)
 239                 m_currentlyHighlighted = onShape;
 240
 241             if (mustUnhighlightOld || mustHighlightNew)
 242             {
 243                 Refresh(mustUnhighlightOld);
 244                 Update();
 245             }
 246
 247             // Move and show the image again
 248             m_dragImage->Move(event.GetPosition());
 249
 250             if (mustUnhighlightOld || mustHighlightNew)
 251                  m_dragImage->Show();
 252         }
 253     }
 254 }
 255
 256 void MyCanvas::DrawShapes(wxDC& dc)
 257 {
 258     wxList::compatibility_iterator node = m_displayList.GetFirst();
 259     while (node)
 260     {
 261         DragShape* shape = (DragShape*) node->GetData();
 262         if (shape->IsShown() && m_draggedShape != shape)
 263         {
 264             shape->Draw(dc, (m_currentlyHighlighted == shape));
 265         }
 266         node = node->GetNext();
 267     }
 268 }
 269
 270 void MyCanvas::EraseShape(DragShape* shape, wxDC& dc)
 271 {
 272     wxSize sz = GetClientSize();
 273     wxRect rect(0, 0, sz.x, sz.y);
 274
 275     wxRect rect2(shape->GetRect());
 276     dc.SetClippingRegion(rect2.x, rect2.y, rect2.width, rect2.height);
 277
 278     wxGetApp().TileBitmap(rect, dc, wxGetApp().GetBackgroundBitmap());
 279
 280     dc.DestroyClippingRegion();
 281 }
 282
 283 void MyCanvas::ClearShapes()
 284 {
 285     wxList::compatibility_iterator node = m_displayList.GetFirst();
 286     while (node)
 287     {
 288         DragShape* shape = (DragShape*) node->GetData();
 289         delete shape;
 290         node = node->GetNext();
 291     }
 292     m_displayList.Clear();
 293 }
 294
 295 DragShape* MyCanvas::FindShape(const wxPoint& pt) const
 296 {
 297     wxList::compatibility_iterator node = m_displayList.GetFirst();
 298     while (node)
 299     {
 300         DragShape* shape = (DragShape*) node->GetData();
 301         if (shape->HitTest(pt))
 302             return shape;
 303         node = node->GetNext();
 304     }
 305     return (DragShape*) NULL;
 306 }
 307
 308 // MyFrame
 309 IMPLEMENT_DYNAMIC_CLASS( MyFrame, wxFrame )
 310
 311 BEGIN_EVENT_TABLE(MyFrame,wxFrame)
 312   EVT_MENU    (wxID_ABOUT, MyFrame::OnAbout)
 313   EVT_MENU    (wxID_EXIT,  MyFrame::OnQuit)
 314 END_EVENT_TABLE()
 315
 316 MyFrame::MyFrame()
 317 : wxFrame( (wxFrame *)NULL, wxID_ANY, wxT("wxDragImage sample"),
 318           wxPoint(20,20), wxSize(470,360) )
 319 {
 320     wxMenu *file_menu = new wxMenu();
 321     file_menu->Append( wxID_ABOUT, wxT("&About"));
 322     file_menu->AppendCheckItem( TEST_USE_SCREEN, wxT("&Use whole screen for dragging"), wxT("Use whole screen"));
 323     file_menu->Append( wxID_EXIT, wxT("E&xit"));
 324
 325     wxMenuBar *menu_bar = new wxMenuBar();
 326     menu_bar->Append(file_menu, wxT("&File"));
 327
 328     SetIcon(wxICON(sample));
 329     SetMenuBar( menu_bar );
 330
 331 #if wxUSE_STATUSBAR
 332     CreateStatusBar(2);
 333     int widths[] = { -1, 100 };
 334     SetStatusWidths( 2, widths );
 335 #endif // wxUSE_STATUSBAR
 336
 337     m_canvas = new MyCanvas( this, wxID_ANY, wxPoint(0,0), wxSize(10,10) );
 338 }
 339
 340 void MyFrame::OnQuit( wxCommandEvent &WXUNUSED(event) )
 341 {
 342     Close( true );
 343 }
 344
 345 void MyFrame::OnAbout( wxCommandEvent &WXUNUSED(event) )
 346 {
 347     (void)wxMessageBox( wxT("wxDragImage demo\n")
 348         wxT("Julian Smart (c) 2000"),
 349         wxT("About wxDragImage Demo"),
 350         wxICON_INFORMATION | wxOK );
 351 }
 352
 353 //-----------------------------------------------------------------------------
 354 // MyApp
 355 //-----------------------------------------------------------------------------
 356
 357 BEGIN_EVENT_TABLE(MyApp, wxApp)
 358     EVT_MENU(TEST_USE_SCREEN, MyApp::OnUseScreen)
 359 END_EVENT_TABLE()
 360
 361 MyApp::MyApp()
 362 {
 363     // Drag across whole screen
 364     m_useScreen = false;
 365 }
 366
 367 bool MyApp::OnInit()
 368 {
 369     if ( !wxApp::OnInit() )
 370         return false;
 371
 372 #if wxUSE_LIBPNG
 373     wxImage::AddHandler( new wxPNGHandler );
 374 #endif
 375
 376     wxImage image;
 377     if (image.LoadFile(wxT("backgrnd.png"), wxBITMAP_TYPE_PNG))
 378     {
 379         m_background = wxBitmap(image);
 380     }
 381
 382     MyFrame *frame = new MyFrame();
 383
 384     wxString rootName(wxT("shape0"));
 385
 386     for (int i = 1; i < 4; i++)
 387     {
 388     /* For some reason under wxX11, the 2nd LoadFile in this loop fails, with
 389        a BadMatch inside CreateFromImage (inside ConvertToBitmap). This happens even if you copy
 390        the first file over the second file. */
 391         if (image.LoadFile(wxString::Format("%s%d.png", rootName, i), wxBITMAP_TYPE_PNG))
 392         {
 393             DragShape* newShape = new DragShape(wxBitmap(image));
 394             newShape->SetPosition(wxPoint(i*50, i*50));
 395
 396             if (i == 2)
 397                 newShape->SetDragMethod(SHAPE_DRAG_TEXT);
 398             else if (i == 3)
 399                 newShape->SetDragMethod(SHAPE_DRAG_ICON);
 400             else
 401                 newShape->SetDragMethod(SHAPE_DRAG_BITMAP);
 402             frame->GetCanvas()->GetDisplayList().Append(newShape);
 403         }
 404     }
 405
 406 #if 0
 407     // Under Motif or GTK, this demonstrates that
 408     // wxScreenDC only gets the root window content.
 409     // We need to be able to copy the overall content
 410     // for full-screen dragging to work.
 411     int w, h;
 412     wxDisplaySize(& w, & h);
 413     wxBitmap bitmap(w, h);
 414
 415     wxScreenDC dc;
 416     wxMemoryDC memDC;
 417     memDC.SelectObject(bitmap);
 418     memDC.Blit(0, 0, w, h, & dc, 0, 0);
 419     memDC.SelectObject(wxNullBitmap);
 420     m_background = bitmap;
 421 #endif
 422
 423     frame->Show( true );
 424
 425     return true;
 426 }
 427
 428 int MyApp::OnExit()
 429 {
 430     return 0;
 431 }
 432
 433 bool MyApp::TileBitmap(const wxRect& rect, wxDC& dc, wxBitmap& bitmap)
 434 {
 435     int w = bitmap.GetWidth();
 436     int h = bitmap.GetHeight();
 437
 438     int i, j;
 439     for (i = rect.x; i < rect.x + rect.width; i += w)
 440     {
 441         for (j = rect.y; j < rect.y + rect.height; j+= h)
 442             dc.DrawBitmap(bitmap, i, j);
 443     }
 444     return true;
 445 }
 446
 447 void MyApp::OnUseScreen(wxCommandEvent& WXUNUSED(event))
 448 {
 449     m_useScreen = !m_useScreen;
 450 }
 451
 452 // DragShape
 453
 454 DragShape::DragShape(const wxBitmap& bitmap)
 455 {
 456     m_bitmap = bitmap;
 457     m_pos.x = 0;
 458     m_pos.y = 0;
 459     m_dragMethod = SHAPE_DRAG_BITMAP;
 460     m_show = true;
 461 }
 462
 463 bool DragShape::HitTest(const wxPoint& pt) const
 464 {
 465     wxRect rect(GetRect());
 466     return rect.Contains(pt.x, pt.y);
 467 }
 468
 469 bool DragShape::Draw(wxDC& dc, bool highlight)
 470 {
 471     if (m_bitmap.IsOk())
 472     {
 473         wxMemoryDC memDC;
 474         memDC.SelectObject(m_bitmap);
 475
 476         dc.Blit(m_pos.x, m_pos.y, m_bitmap.GetWidth(), m_bitmap.GetHeight(),
 477             & memDC, 0, 0, wxCOPY, true);
 478
 479         if (highlight)
 480         {
 481             dc.SetPen(*wxWHITE_PEN);
 482             dc.SetBrush(*wxTRANSPARENT_BRUSH);
 483             dc.DrawRectangle(m_pos.x, m_pos.y, m_bitmap.GetWidth(), m_bitmap.GetHeight());
 484         }
 485
 486         return true;
 487     }
 488     else
 489         return false;
 490 }
 491
 492 // MyDragImage
 493
 494 // On some platforms, notably Mac OS X with Core Graphics, we can't blit from
 495 // a window, so we need to draw the background explicitly.
 496 bool MyDragImage::UpdateBackingFromWindow(wxDC& WXUNUSED(windowDC), wxMemoryDC& destDC, const wxRect& WXUNUSED(sourceRect),
 497                     const wxRect& destRect) const
 498 {
 499     destDC.SetClippingRegion(destRect);
 500
 501     if (wxGetApp().GetBackgroundBitmap().IsOk())
 502         wxGetApp().TileBitmap(destRect, destDC, wxGetApp().GetBackgroundBitmap());
 503
 504     m_canvas->DrawShapes(destDC);
 505     return true;
 506 }
 507