samples/dnd/dnd.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        dnd.cpp
   3 // Purpose:     Drag and drop sample
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #include "wx/wxprec.h"
  13
  14 #ifdef __BORLANDC__
  15 #pragma hdrstop
  16 #endif
  17
  18 #ifndef WX_PRECOMP
  19 #include "wx/wx.h"
  20 #endif
  21
  22 #if !wxUSE_DRAG_AND_DROP
  23     #error This sample requires drag and drop support in the library
  24 #endif
  25
  26 #include "wx/intl.h"
  27 #include "wx/log.h"
  28
  29 #include "wx/dnd.h"
  30 #include "wx/dirdlg.h"
  31 #include "wx/filedlg.h"
  32 #include "wx/image.h"
  33 #include "wx/clipbrd.h"
  34 #include "wx/colordlg.h"
  35 #include "wx/resource.h"
  36
  37 #if defined(__WXGTK__) || defined(__WXMOTIF__)
  38     #include "mondrian.xpm"
  39 #endif
  40
  41 // ----------------------------------------------------------------------------
  42 // Derive two simple classes which just put in the listbox the strings (text or
  43 // file names) we drop on them
  44 // ----------------------------------------------------------------------------
  45
  46 typedef long wxDropPointCoord;
  47
  48 class DnDText : public wxTextDropTarget
  49 {
  50 public:
  51     DnDText(wxListBox *pOwner) { m_pOwner = pOwner; }
  52
  53     virtual bool OnDropText(wxDropPointCoord x, wxDropPointCoord y,
  54                             const wxChar* psz);
  55
  56 private:
  57     wxListBox *m_pOwner;
  58 };
  59
  60 class DnDFile : public wxFileDropTarget
  61 {
  62 public:
  63     DnDFile(wxListBox *pOwner) { m_pOwner = pOwner; }
  64
  65   virtual bool OnDropFiles(wxDropPointCoord x, wxDropPointCoord y,
  66                            size_t nFiles, const wxChar* const aszFiles[] );
  67
  68 private:
  69     wxListBox *m_pOwner;
  70 };
  71
  72 // ----------------------------------------------------------------------------
  73 // Define a new application type
  74 // ----------------------------------------------------------------------------
  75
  76 class DnDApp : public wxApp
  77 {
  78 public:
  79     virtual bool OnInit();
  80 };
  81
  82 IMPLEMENT_APP(DnDApp);
  83
  84 // ----------------------------------------------------------------------------
  85 // Define a new frame type for the main frame
  86 // ----------------------------------------------------------------------------
  87
  88 class DnDFrame : public wxFrame
  89 {
  90 public:
  91     DnDFrame(wxFrame *frame, char *title, int x, int y, int w, int h);
  92     ~DnDFrame();
  93
  94     void OnPaint(wxPaintEvent& event);
  95     void OnQuit (wxCommandEvent& event);
  96     void OnAbout(wxCommandEvent& event);
  97     void OnDrag (wxCommandEvent& event);
  98     void OnNewFrame(wxCommandEvent& event);
  99     void OnHelp (wxCommandEvent& event);
 100     void OnLogClear(wxCommandEvent& event);
 101     void OnCopy(wxCommandEvent& event);
 102     void OnPaste(wxCommandEvent& event);
 103     void OnCopyBitmap(wxCommandEvent& event);
 104     void OnPasteBitmap(wxCommandEvent& event);
 105     void OnClipboardHasText(wxCommandEvent& event);
 106     void OnClipboardHasBitmap(wxCommandEvent& event);
 107
 108     void OnLeftDown(wxMouseEvent& event);
 109     void OnRightDown(wxMouseEvent& event);
 110
 111     DECLARE_EVENT_TABLE()
 112
 113 private:
 114     wxListBox  *m_ctrlFile,
 115     *m_ctrlText;
 116     wxTextCtrl *m_ctrlLog;
 117
 118     wxLog *m_pLog, *m_pLogPrev;
 119
 120     wxString  m_strText;
 121     wxBitmap  m_bitmap;
 122 };
 123
 124 // ----------------------------------------------------------------------------
 125 // A shape is an example of application-specific data which may be transported
 126 // via drag-and-drop or clipboard: in our case, we have different geometric
 127 // shapes, each one with its own colour and position
 128 // ----------------------------------------------------------------------------
 129
 130 class DnDShape
 131 {
 132 public:
 133     enum Kind
 134     {
 135         None,
 136         Triangle,
 137         Rectangle,
 138         Ellipse
 139     };
 140
 141     DnDShape(const wxPoint& pos,
 142              const wxSize& size,
 143              const wxColour& col)
 144         : m_pos(pos), m_size(size), m_col(col)
 145     {
 146     }
 147
 148     // the functions used for drag-and-drop: they dump and restore a shape into
 149     // some bitwise-copiable data
 150     //
 151     // NB: here we profit from the fact that wxPoint, wxSize and wxColour are
 152     //     POD (plain old data) and so can be copied directly - but it wouldn't
 153     //     work for other types!
 154     // ------------------------------------------------------------------------
 155
 156     // restore from buffer
 157     static DnDShape *New(const void *buf);
 158
 159     virtual size_t GetDataSize() const
 160     {
 161         return sizeof(ShapeDump);
 162     }
 163
 164     virtual void GetDataHere(void *buf) const
 165     {
 166         ShapeDump& dump = *(ShapeDump *)buf;
 167         dump.x = m_pos.x;
 168         dump.y = m_pos.y;
 169         dump.w = m_size.x;
 170         dump.h = m_size.y;
 171         dump.r = m_col.Red();
 172         dump.g = m_col.Green();
 173         dump.b = m_col.Blue();
 174         dump.k = GetKind();
 175     }
 176
 177     // accessors
 178     const wxPoint& GetPosition() const { return m_pos; }
 179     const wxColour& GetColour() const { return m_col; }
 180     const wxSize& GetSize() const { return m_size; }
 181
 182     // to implement in derived classes
 183     virtual Kind GetKind() const = 0;
 184
 185     virtual void Draw(wxDC& dc) = 0
 186     {
 187         dc.SetPen(wxPen(m_col, 1, wxSOLID));
 188     }
 189
 190 protected:
 191     wxPoint GetCentre() const
 192         { return wxPoint(m_pos.x + m_size.x / 2, m_pos.y + m_size.y / 2); }
 193
 194     struct ShapeDump
 195     {
 196         int x, y,       // position
 197             w, h,       // size
 198             r, g, b,    // colour
 199             k;          // kind
 200     };
 201
 202     wxPoint  m_pos;
 203     wxSize   m_size;
 204     wxColour m_col;
 205 };
 206
 207 class DnDTriangularShape : public DnDShape
 208 {
 209 public:
 210     DnDTriangularShape(const wxPoint& pos,
 211                        const wxSize& size,
 212                        const wxColour& col)
 213         : DnDShape(pos, size, col)
 214     {
 215     }
 216
 217     virtual Kind GetKind() const { return Triangle; }
 218     virtual void Draw(wxDC& dc)
 219     {
 220         DnDShape::Draw(dc);
 221
 222         // well, it's a bit difficult to describe a triangle by position and
 223         // size, but we're not doing geometry here, do we? ;-)
 224         wxPoint p1(m_pos);
 225         wxPoint p2(m_pos.x + m_size.x, m_pos.y);
 226         wxPoint p3(m_pos.x, m_pos.y + m_size.y);
 227
 228         dc.DrawLine(p1, p2);
 229         dc.DrawLine(p2, p3);
 230         dc.DrawLine(p3, p1);
 231
 232         dc.FloodFill(GetCentre(), m_col, wxFLOOD_BORDER);
 233     }
 234 };
 235
 236 class DnDRectangularShape : public DnDShape
 237 {
 238 public:
 239     DnDRectangularShape(const wxPoint& pos,
 240                         const wxSize& size,
 241                         const wxColour& col)
 242         : DnDShape(pos, size, col)
 243     {
 244     }
 245
 246     virtual Kind GetKind() const { return Rectangle; }
 247     virtual void Draw(wxDC& dc)
 248     {
 249         DnDShape::Draw(dc);
 250
 251         wxPoint p1(m_pos);
 252         wxPoint p2(p1.x + m_size.x, p1.y);
 253         wxPoint p3(p2.x, p2.y + m_size.y);
 254         wxPoint p4(p1.x, p3.y);
 255
 256         dc.DrawLine(p1, p2);
 257         dc.DrawLine(p2, p3);
 258         dc.DrawLine(p3, p4);
 259         dc.DrawLine(p4, p1);
 260
 261         dc.FloodFill(GetCentre(), m_col, wxFLOOD_BORDER);
 262     }
 263 };
 264
 265 class DnDEllipticShape : public DnDShape
 266 {
 267 public:
 268     DnDEllipticShape(const wxPoint& pos,
 269                      const wxSize& size,
 270                      const wxColour& col)
 271         : DnDShape(pos, size, col)
 272     {
 273     }
 274
 275     virtual Kind GetKind() const { return Ellipse; }
 276     virtual void Draw(wxDC& dc)
 277     {
 278         DnDShape::Draw(dc);
 279
 280         dc.DrawEllipse(m_pos, m_size);
 281
 282         dc.FloodFill(GetCentre(), m_col, wxFLOOD_BORDER);
 283     }
 284 };
 285
 286 // ----------------------------------------------------------------------------
 287 // A wxDataObject specialisation for the application-specific data
 288 // ----------------------------------------------------------------------------
 289
 290 static const char *shapeFormatId = "wxShape";
 291
 292 class DnDShapeDataObject : public wxDataObject
 293 {
 294 public:
 295     // ctor doesn't copy the pointer, so it shouldn't go away while this object
 296     // is alive
 297     DnDShapeDataObject(DnDShape *shape)
 298     {
 299         m_shape = shape;
 300
 301         // this string should uniquely identify our format, but is otherwise
 302         // arbitrary
 303         m_formatShape.SetId(shapeFormatId);
 304
 305         // we don't draw the shape to a bitmap until it's really needed (i.e.
 306         // we're asked to do so)
 307         m_hasBitmap = FALSE;
 308     }
 309
 310     // implement base class pure virtuals
 311     // ----------------------------------
 312
 313     virtual wxDataFormat GetPreferredFormat() const
 314     {
 315         return m_formatShape;
 316     }
 317
 318     virtual size_t GetFormatCount() const
 319     {
 320         // +1 for our custom format
 321         return m_dataobj.GetFormatCount() + 1;
 322     }
 323
 324     virtual void GetAllFormats(wxDataFormat *formats) const
 325     {
 326         formats[0] = m_formatShape;
 327         m_dataobj.GetAllFormats(&formats[1]);
 328     }
 329
 330     virtual size_t GetDataSize(const wxDataFormat& format) const
 331     {
 332         if ( format == m_formatShape )
 333         {
 334             return m_shape->GetDataSize();
 335         }
 336         else
 337         {
 338             wxASSERT_MSG( format == wxDF_BITMAP, "unsupported format" );
 339
 340             if ( !m_hasBitmap )
 341                 CreateBitmap();
 342
 343             return m_dataobj.GetDataSize(format);
 344         }
 345     }
 346
 347     virtual void GetDataHere(const wxDataFormat& format, void *pBuf) const
 348     {
 349         if ( format == m_formatShape )
 350         {
 351             m_shape->GetDataHere(pBuf);
 352         }
 353         else
 354         {
 355             wxASSERT_MSG( format == wxDF_BITMAP, "unsupported format" );
 356
 357             if ( !m_hasBitmap )
 358                 CreateBitmap();
 359
 360             m_dataobj.GetDataHere(format, pBuf);
 361         }
 362     }
 363
 364 private:
 365     // creates a bitmap and assigns it to m_dataobj (also sets m_hasBitmap)
 366     void CreateBitmap() const;
 367
 368     wxDataFormat        m_formatShape;  // our custom format
 369
 370     wxBitmapDataObject  m_dataobj;      // it handles bitmaps
 371     bool                m_hasBitmap;    // true if m_dataobj has valid bitmap
 372
 373     DnDShape           *m_shape;        // our data
 374 };
 375
 376 // ----------------------------------------------------------------------------
 377 // A dialog to edit shape properties
 378 // ----------------------------------------------------------------------------
 379
 380 class DnDShapeDialog : public wxDialog
 381 {
 382 public:
 383     DnDShapeDialog(wxFrame *parent, DnDShape *shape);
 384
 385     DnDShape *GetShape() const;
 386
 387     virtual bool TransferDataToWindow();
 388     virtual bool TransferDataFromWindow();
 389
 390     void OnColour(wxCommandEvent& event);
 391
 392 private:
 393     // input
 394     DnDShape *m_shape;
 395
 396     // output
 397     DnDShape::Kind m_shapeKind;
 398     wxPoint  m_pos;
 399     wxSize   m_size;
 400     wxColour m_col;
 401
 402     // controls
 403     wxRadioBox *m_radio;
 404     wxTextCtrl *m_textX,
 405                *m_textY,
 406                *m_textW,
 407                *m_textH;
 408
 409     DECLARE_EVENT_TABLE()
 410 };
 411
 412 // ----------------------------------------------------------------------------
 413 // A frame for the shapes which can be drag-and-dropped between frames
 414 // ----------------------------------------------------------------------------
 415
 416 class DnDShapeFrame : public wxFrame
 417 {
 418 public:
 419     DnDShapeFrame(wxFrame *parent);
 420     ~DnDShapeFrame();
 421
 422     void SetShape(DnDShape *shape);
 423
 424     // callbacks
 425     void OnDrag(wxMouseEvent& event);
 426     void OnEdit(wxMouseEvent& event);
 427     void OnPaint(wxPaintEvent& event);
 428     void OnDrop(long x, long y, DnDShape *shape);
 429
 430 private:
 431     DnDShape *m_shape;
 432
 433     DECLARE_EVENT_TABLE()
 434 };
 435
 436 // ----------------------------------------------------------------------------
 437 // wxDropTarget derivation for DnDShapes
 438 // ----------------------------------------------------------------------------
 439
 440 class DnDShapeDropTarget : public wxDropTarget
 441 {
 442 public:
 443     DnDShapeDropTarget(DnDShapeFrame *frame)
 444     {
 445         m_frame = frame;
 446
 447         // the same as used by DnDShapeDataObject
 448         m_formatShape.SetId(shapeFormatId);
 449     }
 450
 451     // override base class (pure) virtuals
 452     virtual void OnEnter()
 453         { m_frame->SetStatusText("Mouse entered the frame"); }
 454     virtual void OnLeave()
 455         { m_frame->SetStatusText("Mouse left the frame"); }
 456     virtual bool OnDrop(long x, long y, const void *pData)
 457     {
 458         m_frame->OnDrop(x, y, DnDShape::New(pData));
 459
 460         return TRUE;
 461     }
 462
 463 protected:
 464     virtual size_t GetFormatCount() const { return 1; }
 465     virtual wxDataFormat GetFormat(size_t WXUNUSED(n)) const
 466         { return m_formatShape; }
 467
 468 private:
 469     DnDShapeFrame *m_frame;
 470     wxDataFormat m_formatShape;
 471 };
 472
 473 // ----------------------------------------------------------------------------
 474 // IDs for the menu commands
 475 // ----------------------------------------------------------------------------
 476
 477 enum
 478 {
 479     Menu_Quit = 1,
 480     Menu_Drag,
 481     Menu_NewFrame,
 482     Menu_About = 101,
 483     Menu_Help,
 484     Menu_Clear,
 485     Menu_Copy,
 486     Menu_Paste,
 487     Menu_CopyBitmap,
 488     Menu_PasteBitmap,
 489     Menu_HasText,
 490     Menu_HasBitmap,
 491     Menu_ToBeGreyed,   /* for testing */
 492     Menu_ToBeDeleted,  /* for testing */
 493     Button_Colour = 1001
 494 };
 495
 496 BEGIN_EVENT_TABLE(DnDFrame, wxFrame)
 497     EVT_MENU(Menu_Quit,       DnDFrame::OnQuit)
 498     EVT_MENU(Menu_About,      DnDFrame::OnAbout)
 499     EVT_MENU(Menu_Drag,       DnDFrame::OnDrag)
 500     EVT_MENU(Menu_NewFrame,   DnDFrame::OnNewFrame)
 501     EVT_MENU(Menu_Help,       DnDFrame::OnHelp)
 502     EVT_MENU(Menu_Clear,      DnDFrame::OnLogClear)
 503     EVT_MENU(Menu_Copy,       DnDFrame::OnCopy)
 504     EVT_MENU(Menu_Paste,      DnDFrame::OnPaste)
 505     EVT_MENU(Menu_CopyBitmap, DnDFrame::OnCopyBitmap)
 506     EVT_MENU(Menu_PasteBitmap,DnDFrame::OnPasteBitmap)
 507     EVT_MENU(Menu_HasText,    DnDFrame::OnClipboardHasText)
 508     EVT_MENU(Menu_HasBitmap,  DnDFrame::OnClipboardHasBitmap)
 509
 510     EVT_LEFT_DOWN(            DnDFrame::OnLeftDown)
 511     EVT_RIGHT_DOWN(           DnDFrame::OnRightDown)
 512     EVT_PAINT(                DnDFrame::OnPaint)
 513 END_EVENT_TABLE()
 514
 515 BEGIN_EVENT_TABLE(DnDShapeFrame, wxFrame)
 516     EVT_RIGHT_DOWN(DnDShapeFrame::OnDrag)
 517     EVT_LEFT_DCLICK(DnDShapeFrame::OnEdit)
 518     EVT_PAINT(DnDShapeFrame::OnPaint)
 519 END_EVENT_TABLE()
 520
 521 BEGIN_EVENT_TABLE(DnDShapeDialog, wxDialog)
 522     EVT_BUTTON(Button_Colour, OnColour)
 523 END_EVENT_TABLE()
 524
 525 // ============================================================================
 526 // implementation
 527 // ============================================================================
 528
 529 // `Main program' equivalent, creating windows and returning main app frame
 530 bool DnDApp::OnInit()
 531 {
 532 #if wxUSE_LIBPNG
 533     wxImage::AddHandler( new wxPNGHandler );
 534 #endif
 535
 536     // create the main frame window
 537     DnDFrame *frame = new DnDFrame((wxFrame  *) NULL,
 538                                    "Drag-and-Drop/Clipboard wxWindows Sample",
 539                                    50, 50, 450, 340);
 540
 541     // activate it
 542     frame->Show(TRUE);
 543
 544     SetTopWindow(frame);
 545
 546     wxDefaultResourceTable->ParseResourceFile("dnd.wxr");
 547
 548     return TRUE;
 549 }
 550
 551 DnDFrame::DnDFrame(wxFrame *frame, char *title, int x, int y, int w, int h)
 552         : wxFrame(frame, -1, title, wxPoint(x, y), wxSize(w, h)),
 553           m_strText("wxWindows drag & drop works :-)")
 554
 555 {
 556     // frame icon and status bar
 557     SetIcon(wxICON(mondrian));
 558
 559     CreateStatusBar();
 560
 561     // construct menu
 562     wxMenu *file_menu = new wxMenu;
 563     file_menu->Append(Menu_Drag, "&Test drag...");
 564     file_menu->AppendSeparator();
 565     file_menu->Append(Menu_NewFrame, "&New frame\tCtrl-N");
 566     file_menu->AppendSeparator();
 567     file_menu->Append(Menu_Quit, "E&xit");
 568
 569     wxMenu *log_menu = new wxMenu;
 570     log_menu->Append(Menu_Clear, "Clear");
 571
 572     wxMenu *help_menu = new wxMenu;
 573     help_menu->Append(Menu_Help, "&Help...");
 574     help_menu->AppendSeparator();
 575     help_menu->Append(Menu_About, "&About");
 576
 577     wxMenu *clip_menu = new wxMenu;
 578     clip_menu->Append(Menu_Copy, "&Copy text\tCtrl+C");
 579     clip_menu->Append(Menu_Paste, "&Paste text\tCtrl+V");
 580     clip_menu->AppendSeparator();
 581     clip_menu->Append(Menu_CopyBitmap, "&Copy bitmap");
 582     clip_menu->Append(Menu_PasteBitmap, "&Paste bitmap");
 583     clip_menu->AppendSeparator();
 584     clip_menu->Append(Menu_HasText, "Clipboard has &text\tCtrl+T");
 585     clip_menu->Append(Menu_HasBitmap, "Clipboard has a &bitmap\tCtrl+B");
 586
 587     wxMenuBar *menu_bar = new wxMenuBar;
 588     menu_bar->Append(file_menu, "&File");
 589     menu_bar->Append(log_menu,  "&Log");
 590     menu_bar->Append(clip_menu, "&Clipboard");
 591     menu_bar->Append(help_menu, "&Help");
 592
 593     SetMenuBar(menu_bar);
 594
 595     // make a panel with 3 subwindows
 596     wxPoint pos(0, 0);
 597     wxSize  size(400, 200);
 598
 599     wxString strFile("Drop files here!"), strText("Drop text on me");
 600
 601     m_ctrlFile  = new wxListBox(this, -1, pos, size, 1, &strFile, wxLB_HSCROLL | wxLB_ALWAYS_SB );
 602     m_ctrlText  = new wxListBox(this, -1, pos, size, 1, &strText, wxLB_HSCROLL | wxLB_ALWAYS_SB );
 603
 604     m_ctrlLog   = new wxTextCtrl(this, -1, "", pos, size,
 605                                wxTE_MULTILINE | wxTE_READONLY |
 606                                wxSUNKEN_BORDER );
 607
 608     // redirect log messages to the text window and switch on OLE messages
 609     // logging
 610     wxLog::AddTraceMask(wxTRACE_OleCalls);
 611     m_pLog = new wxLogTextCtrl(m_ctrlLog);
 612     m_pLogPrev = wxLog::SetActiveTarget(m_pLog);
 613
 614     // associate drop targets with 2 text controls
 615     m_ctrlFile->SetDropTarget(new DnDFile(m_ctrlFile));
 616     m_ctrlText->SetDropTarget(new DnDText(m_ctrlText));
 617
 618     wxLayoutConstraints *c;
 619
 620     // Top-left listbox
 621     c = new wxLayoutConstraints;
 622     c->left.SameAs(this, wxLeft);
 623     c->top.SameAs(this, wxTop);
 624     c->right.PercentOf(this, wxRight, 50);
 625     c->height.PercentOf(this, wxHeight, 30);
 626     m_ctrlFile->SetConstraints(c);
 627
 628     // Top-right listbox
 629     c = new wxLayoutConstraints;
 630     c->left.SameAs    (m_ctrlFile, wxRight);
 631     c->top.SameAs     (this, wxTop);
 632     c->right.SameAs   (this, wxRight);
 633     c->height.PercentOf(this, wxHeight, 30);
 634     m_ctrlText->SetConstraints(c);
 635
 636     // Lower text control
 637     c = new wxLayoutConstraints;
 638     c->left.SameAs    (this, wxLeft);
 639     c->right.SameAs   (this, wxRight);
 640     c->height.PercentOf(this, wxHeight, 30);
 641     c->top.SameAs(m_ctrlText, wxBottom);
 642     m_ctrlLog->SetConstraints(c);
 643
 644     SetAutoLayout(TRUE);
 645 }
 646
 647 void DnDFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
 648 {
 649     Close(TRUE);
 650 }
 651
 652 void DnDFrame::OnPaint(wxPaintEvent& WXUNUSED(event))
 653 {
 654     int w = 0;
 655     int h = 0;
 656     GetClientSize( &w, &h );
 657
 658     wxPaintDC dc(this);
 659     dc.SetFont( wxFont( 24, wxDECORATIVE, wxNORMAL, wxNORMAL, FALSE, "charter" ) );
 660     dc.DrawText( "Drag text from here!", 20, h-50 );
 661
 662     if (m_bitmap.Ok())
 663         dc.DrawBitmap( m_bitmap, 280, h-120, TRUE );
 664 }
 665
 666 void DnDFrame::OnClipboardHasText(wxCommandEvent& WXUNUSED(event))
 667 {
 668     if ( !wxTheClipboard->Open() )
 669     {
 670         wxLogError( _T("Can't open clipboard.") );
 671
 672         return;
 673     }
 674
 675     if ( !wxTheClipboard->IsSupported( wxDF_TEXT ) )
 676     {
 677         wxLogMessage( _T("No text on the clipboard") );
 678     }
 679     else
 680     {
 681         wxLogMessage( _T("There is text on the clipboard") );
 682     }
 683
 684     wxTheClipboard->Close();
 685 }
 686
 687 void DnDFrame::OnClipboardHasBitmap(wxCommandEvent& WXUNUSED(event))
 688 {
 689     if ( !wxTheClipboard->Open() )
 690     {
 691         wxLogError( _T("Can't open clipboard.") );
 692
 693         return;
 694     }
 695
 696     if ( !wxTheClipboard->IsSupported( wxDF_BITMAP ) )
 697     {
 698         wxLogMessage( _T("No bitmap on the clipboard") );
 699     }
 700     else
 701     {
 702         wxLogMessage( _T("There is a bitmap on the clipboard") );
 703     }
 704
 705     wxTheClipboard->Close();
 706 }
 707
 708 void DnDFrame::OnNewFrame(wxCommandEvent& WXUNUSED(event))
 709 {
 710     (new DnDShapeFrame(this))->Show(TRUE);
 711
 712     wxLogStatus(this, "Double click the new frame to select a shape for it");
 713 }
 714
 715 void DnDFrame::OnDrag(wxCommandEvent& WXUNUSED(event))
 716 {
 717     wxString strText = wxGetTextFromUser
 718         (
 719          "After you enter text in this dialog, press any mouse\n"
 720          "button in the bottom (empty) part of the frame and \n"
 721          "drag it anywhere - you will be in fact dragging the\n"
 722          "text object containing this text",
 723          "Please enter some text", m_strText, this
 724         );
 725
 726     m_strText = strText;
 727 }
 728
 729 void DnDFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
 730 {
 731     wxMessageBox("Drag-&-Drop Demo\n"
 732                  "Please see \"Help|Help...\" for details\n"
 733                  "Copyright (c) 1998 Vadim Zeitlin",
 734                  "About wxDnD",
 735                  wxICON_INFORMATION | wxOK,
 736                  this);
 737 }
 738
 739 void DnDFrame::OnHelp(wxCommandEvent& /* event */)
 740 {
 741     wxMessageDialog dialog(this,
 742             "This small program demonstrates drag & drop support in wxWindows. The program window\n"
 743             "consists of 3 parts: the bottom pane is for debug messages, so that you can see what's\n"
 744             "going on inside. The top part is split into 2 listboxes, the left one accepts files\n"
 745             "and the right one accepts text.\n"
 746             "\n"
 747             "To test wxDropTarget: open wordpad (write.exe), select some text in it and drag it to\n"
 748             "the right listbox (you'll notice the usual visual feedback, i.e. the cursor will change).\n"
 749             "Also, try dragging some files (you can select several at once) from Windows Explorer (or \n"
 750             "File Manager) to the left pane. Hold down Ctrl/Shift keys when you drop text (doesn't \n"
 751             "work with files) and see what changes.\n"
 752             "\n"
 753             "To test wxDropSource: just press any mouse button on the empty zone of the window and drag\n"
 754             "it to wordpad or any other droptarget accepting text (and of course you can just drag it\n"
 755             "to the right pane). Due to a lot of trace messages, the cursor might take some time to \n"
 756             "change, don't release the mouse button until it does. You can change the string being\n"
 757             "dragged in in \"File|Test drag...\" dialog.\n"
 758             "\n"
 759             "\n"
 760             "Please send all questions/bug reports/suggestions &c to \n"
 761             "Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>",
 762             "wxDnD Help");
 763
 764     dialog.ShowModal();
 765 }
 766
 767 void DnDFrame::OnLogClear(wxCommandEvent& /* event */ )
 768 {
 769     m_ctrlLog->Clear();
 770 }
 771
 772 void DnDFrame::OnLeftDown(wxMouseEvent &WXUNUSED(event) )
 773 {
 774     if ( !m_strText.IsEmpty() )
 775     {
 776         // start drag operation
 777         wxTextDataObject textData(m_strText);
 778         wxDropSource source(textData, this, wxICON(mondrian));
 779
 780         const char *pc;
 781
 782         switch ( source.DoDragDrop(TRUE) )
 783         {
 784             case wxDragError:   pc = "Error!";    break;
 785             case wxDragNone:    pc = "Nothing";   break;
 786             case wxDragCopy:    pc = "Copied";    break;
 787             case wxDragMove:    pc = "Moved";     break;
 788             case wxDragCancel:  pc = "Cancelled"; break;
 789             default:            pc = "Huh?";      break;
 790         }
 791
 792         SetStatusText(wxString("Drag result: ") + pc);
 793     }
 794 }
 795
 796 void DnDFrame::OnRightDown(wxMouseEvent &event )
 797 {
 798     wxMenu *menu = new wxMenu;
 799
 800     menu->Append(Menu_Drag, "&Test drag...");
 801     menu->Append(Menu_About, "&About");
 802     menu->Append(Menu_Quit, "E&xit");
 803     menu->Append(Menu_ToBeDeleted, "To be deleted");
 804     menu->Append(Menu_ToBeGreyed, "To be greyed");
 805
 806     menu->Delete( Menu_ToBeDeleted );
 807     menu->Enable( Menu_ToBeGreyed, FALSE );
 808
 809     PopupMenu( menu, event.GetX(), event.GetY() );
 810 }
 811
 812 DnDFrame::~DnDFrame()
 813 {
 814     if ( m_pLog != NULL ) {
 815         if ( wxLog::SetActiveTarget(m_pLogPrev) == m_pLog )
 816             delete m_pLog;
 817     }
 818 }
 819
 820 // ---------------------------------------------------------------------------
 821 // bitmap clipboard
 822 // ---------------------------------------------------------------------------
 823
 824 void DnDFrame::OnCopyBitmap(wxCommandEvent& WXUNUSED(event))
 825 {
 826     // PNG support is not always compiled in under Windows, so use BMP there
 827 #ifdef __WXMSW__
 828     wxFileDialog dialog(this, "Open a BMP file", "", "", "BMP files (*.bmp)|*.bmp", 0);
 829 #else
 830     wxFileDialog dialog(this, "Open a PNG file", "", "", "PNG files (*.png)|*.png", 0);
 831 #endif
 832
 833     if (dialog.ShowModal() != wxID_OK)
 834     {
 835         wxLogMessage( _T("Aborted file open") );
 836         return;
 837     }
 838
 839     if (dialog.GetPath().IsEmpty())
 840     {
 841         wxLogMessage( _T("Returned empty string.") );
 842         return;
 843     }
 844
 845     if (!wxFileExists(dialog.GetPath()))
 846     {
 847         wxLogMessage( _T("File doesn't exist.") );
 848         return;
 849     }
 850
 851     wxImage image;
 852     image.LoadFile( dialog.GetPath(),
 853 #ifdef __WXMSW__
 854                     wxBITMAP_TYPE_BMP
 855 #else
 856                     wxBITMAP_TYPE_PNG
 857 #endif
 858                   );
 859     if (!image.Ok())
 860     {
 861         wxLogError( _T("Invalid image file...") );
 862         return;
 863     }
 864
 865     wxLogStatus( _T("Decoding image file...") );
 866     wxYield();
 867
 868     wxBitmap bitmap( image.ConvertToBitmap() );
 869
 870     if ( !wxTheClipboard->Open() )
 871     {
 872         wxLogError(_T("Can't open clipboard."));
 873
 874         return;
 875     }
 876
 877     wxLogMessage( _T("Creating wxBitmapDataObject...") );
 878     wxYield();
 879
 880     if ( !wxTheClipboard->AddData(new wxBitmapDataObject(bitmap)) )
 881     {
 882         wxLogError(_T("Can't copy image to the clipboard."));
 883     }
 884     else
 885     {
 886         wxLogMessage(_T("Image has been put on the clipboard.") );
 887         wxLogMessage(_T("You can paste it now and look at it.") );
 888     }
 889
 890     wxTheClipboard->Close();
 891 }
 892
 893 void DnDFrame::OnPasteBitmap(wxCommandEvent& WXUNUSED(event))
 894 {
 895     if ( !wxTheClipboard->Open() )
 896     {
 897         wxLogError(_T("Can't open clipboard."));
 898
 899         return;
 900     }
 901
 902     if ( !wxTheClipboard->IsSupported(wxDF_BITMAP) )
 903     {
 904         wxLogWarning(_T("No bitmap on clipboard"));
 905
 906         wxTheClipboard->Close();
 907         return;
 908     }
 909
 910     wxBitmapDataObject data;
 911     if ( !wxTheClipboard->GetData(&data) )
 912     {
 913         wxLogError(_T("Can't paste bitmap from the clipboard"));
 914     }
 915     else
 916     {
 917         wxLogMessage(_T("Bitmap pasted from the clipboard") );
 918         m_bitmap = data.GetBitmap();
 919         Refresh();
 920     }
 921
 922     wxTheClipboard->Close();
 923 }
 924
 925 // ---------------------------------------------------------------------------
 926 // text clipboard
 927 // ---------------------------------------------------------------------------
 928
 929 void DnDFrame::OnCopy(wxCommandEvent& WXUNUSED(event))
 930 {
 931     if ( !wxTheClipboard->Open() )
 932     {
 933         wxLogError(_T("Can't open clipboard."));
 934
 935         return;
 936     }
 937
 938     if ( !wxTheClipboard->AddData(new wxTextDataObject(m_strText)) )
 939     {
 940         wxLogError(_T("Can't copy data to the clipboard"));
 941     }
 942     else
 943     {
 944         wxLogMessage(_T("Text '%s' put on the clipboard"), m_strText.c_str());
 945     }
 946
 947     wxTheClipboard->Close();
 948 }
 949
 950 void DnDFrame::OnPaste(wxCommandEvent& WXUNUSED(event))
 951 {
 952     if ( !wxTheClipboard->Open() )
 953     {
 954         wxLogError(_T("Can't open clipboard."));
 955
 956         return;
 957     }
 958
 959     if ( !wxTheClipboard->IsSupported(wxDF_TEXT) )
 960     {
 961         wxLogWarning(_T("No text data on clipboard"));
 962
 963         wxTheClipboard->Close();
 964         return;
 965     }
 966
 967     wxTextDataObject text;
 968     if ( !wxTheClipboard->GetData(&text) )
 969     {
 970         wxLogError(_T("Can't paste data from the clipboard"));
 971     }
 972     else
 973     {
 974         wxLogMessage(_T("Text '%s' pasted from the clipboard"),
 975                      text.GetText().c_str());
 976     }
 977
 978     wxTheClipboard->Close();
 979 }
 980
 981 // ----------------------------------------------------------------------------
 982 // Notifications called by the base class
 983 // ----------------------------------------------------------------------------
 984
 985 bool DnDText::OnDropText( wxDropPointCoord, wxDropPointCoord, const wxChar *psz )
 986 {
 987     m_pOwner->Append(psz);
 988
 989     return TRUE;
 990 }
 991
 992 bool DnDFile::OnDropFiles( wxDropPointCoord, wxDropPointCoord, size_t nFiles,
 993                            const wxChar* const aszFiles[])
 994 {
 995     wxString str;
 996     str.Printf( _T("%d files dropped"), nFiles);
 997     m_pOwner->Append(str);
 998     for ( size_t n = 0; n < nFiles; n++ ) {
 999         m_pOwner->Append(aszFiles[n]);
1000     }
1001
1002     return TRUE;
1003 }
1004
1005 // ----------------------------------------------------------------------------
1006 // DnDShapeDialog
1007 // ----------------------------------------------------------------------------
1008
1009 DnDShapeDialog::DnDShapeDialog(wxFrame *parent, DnDShape *shape)
1010 {
1011     m_shape = shape;
1012
1013     LoadFromResource(parent, "dialogShape");
1014
1015     m_textX = (wxTextCtrl *)wxFindWindowByName("textX", this);
1016     m_textY = (wxTextCtrl *)wxFindWindowByName("textY", this);
1017     m_textW = (wxTextCtrl *)wxFindWindowByName("textW", this);
1018     m_textH = (wxTextCtrl *)wxFindWindowByName("textH", this);
1019
1020     m_radio = (wxRadioBox *)wxFindWindowByName("radio", this);
1021 }
1022
1023 DnDShape *DnDShapeDialog::GetShape() const
1024 {
1025     switch ( m_shapeKind )
1026     {
1027         default:
1028         case DnDShape::None:      return NULL;
1029         case DnDShape::Triangle:  return new DnDTriangularShape(m_pos, m_size, m_col);
1030         case DnDShape::Rectangle: return new DnDRectangularShape(m_pos, m_size, m_col);
1031         case DnDShape::Ellipse:   return new DnDEllipticShape(m_pos, m_size, m_col);
1032     }
1033 }
1034
1035 bool DnDShapeDialog::TransferDataToWindow()
1036 {
1037     if ( m_shape )
1038     {
1039         m_radio->SetSelection(m_shape->GetKind());
1040         m_pos = m_shape->GetPosition();
1041         m_size = m_shape->GetSize();
1042         m_col = m_shape->GetColour();
1043     }
1044     else
1045     {
1046         m_radio->SetSelection(DnDShape::None);
1047         m_pos = wxPoint(1, 1);
1048         m_size = wxSize(100, 100);
1049     }
1050
1051     m_textX->SetValue(wxString() << m_pos.x);
1052     m_textY->SetValue(wxString() << m_pos.y);
1053     m_textW->SetValue(wxString() << m_size.x);
1054     m_textH->SetValue(wxString() << m_size.y);
1055
1056     return TRUE;
1057 }
1058
1059 bool DnDShapeDialog::TransferDataFromWindow()
1060 {
1061     m_shapeKind = (DnDShape::Kind)m_radio->GetSelection();
1062
1063     m_pos.x = atoi(m_textX->GetValue());
1064     m_pos.y = atoi(m_textY->GetValue());
1065     m_size.x = atoi(m_textW->GetValue());
1066     m_size.y = atoi(m_textH->GetValue());
1067
1068     if ( !m_pos.x || !m_pos.y || !m_size.x || !m_size.y )
1069     {
1070         wxMessageBox("All sizes and positions should be non null!",
1071                      "Invalid shape", wxICON_HAND | wxOK, this);
1072
1073         return FALSE;
1074     }
1075
1076     return TRUE;
1077 }
1078
1079 void DnDShapeDialog::OnColour(wxCommandEvent& WXUNUSED(event))
1080 {
1081     wxColourData data;
1082     data.SetChooseFull(TRUE);
1083     for (int i = 0; i < 16; i++)
1084     {
1085         wxColour colour(i*16, i*16, i*16);
1086         data.SetCustomColour(i, colour);
1087     }
1088
1089     wxColourDialog dialog(this, &data);
1090     if ( dialog.ShowModal() == wxID_OK )
1091     {
1092         m_col = dialog.GetColourData().GetColour();
1093     }
1094 }
1095
1096 // ----------------------------------------------------------------------------
1097 // DnDShapeFrame
1098 // ----------------------------------------------------------------------------
1099
1100 DnDShapeFrame::DnDShapeFrame(wxFrame *parent)
1101              : wxFrame(parent, -1, "Shape Frame",
1102                        wxDefaultPosition, wxSize(250, 150))
1103 {
1104     SetBackgroundColour(*wxWHITE);
1105
1106     CreateStatusBar();
1107
1108     SetStatusText("Double click the frame to create a shape");
1109
1110     SetDropTarget(new DnDShapeDropTarget(this));
1111
1112     m_shape = NULL;
1113 }
1114
1115 DnDShapeFrame::~DnDShapeFrame()
1116 {
1117     delete m_shape;
1118 }
1119
1120 void DnDShapeFrame::SetShape(DnDShape *shape)
1121 {
1122     delete m_shape;
1123     m_shape = shape;
1124     Refresh();
1125 }
1126
1127 // callbacks
1128 void DnDShapeFrame::OnDrag(wxMouseEvent& event)
1129 {
1130     if ( !m_shape )
1131     {
1132         event.Skip();
1133
1134         return;
1135     }
1136
1137     // start drag operation
1138     DnDShapeDataObject shapeData(m_shape);
1139     wxDropSource source(shapeData, this, wxICON(mondrian));
1140
1141     const char *pc = NULL;
1142     switch ( source.DoDragDrop(TRUE) )
1143     {
1144         default:
1145         case wxDragError:
1146             wxLogError("An error occured during drag and drop operation");
1147             break;
1148
1149         case wxDragNone:
1150             SetStatusText("Nothing happened");
1151             break;
1152
1153         case wxDragCopy:
1154             pc = "copied";
1155             break;
1156
1157         case wxDragMove:
1158             pc = "moved";
1159             SetShape(NULL);
1160             break;
1161
1162         case wxDragCancel:
1163             SetStatusText("Drag and drop operation cancelled");
1164             break;
1165     }
1166
1167     if ( pc )
1168     {
1169         SetStatusText(wxString("Shape successfully ") + pc);
1170     }
1171     //else: status text already set
1172 }
1173
1174 void DnDShapeFrame::OnEdit(wxMouseEvent& event)
1175 {
1176     DnDShapeDialog dlg(this, m_shape);
1177     if ( dlg.ShowModal() == wxID_OK )
1178     {
1179         SetShape(dlg.GetShape());
1180
1181         if ( m_shape )
1182         {
1183             SetStatusText("Right click now drag the shape to another frame");
1184         }
1185     }
1186 }
1187
1188 void DnDShapeFrame::OnPaint(wxPaintEvent& event)
1189 {
1190     if ( m_shape )
1191         m_shape->Draw(wxPaintDC(this));
1192     else
1193         event.Skip();
1194 }
1195
1196 void DnDShapeFrame::OnDrop(long x, long y, DnDShape *shape)
1197 {
1198     wxString s;
1199     s.Printf("Drop occured at (%ld, %ld)", x, y);
1200     SetStatusText(s);
1201
1202     SetShape(shape);
1203 }
1204
1205 // ----------------------------------------------------------------------------
1206 // DnDShape
1207 // ----------------------------------------------------------------------------
1208
1209 DnDShape *DnDShape::New(const void *buf)
1210 {
1211     const ShapeDump& dump = *(const ShapeDump *)buf;
1212     switch ( dump.k )
1213     {
1214         case Triangle:
1215             return new DnDTriangularShape(wxPoint(dump.x, dump.y),
1216                                           wxSize(dump.w, dump.h),
1217                                           wxColour(dump.r, dump.g, dump.b));
1218
1219         case Rectangle:
1220             return new DnDRectangularShape(wxPoint(dump.x, dump.y),
1221                                            wxSize(dump.w, dump.h),
1222                                            wxColour(dump.r, dump.g, dump.b));
1223
1224         case Ellipse:
1225             return new DnDEllipticShape(wxPoint(dump.x, dump.y),
1226                                         wxSize(dump.w, dump.h),
1227                                         wxColour(dump.r, dump.g, dump.b));
1228
1229         default:
1230             wxFAIL_MSG("invalid shape!");
1231             return NULL;
1232     }
1233 }
1234
1235 // ----------------------------------------------------------------------------
1236 // DnDShapeDataObject
1237 // ----------------------------------------------------------------------------
1238
1239 void DnDShapeDataObject::CreateBitmap() const
1240 {
1241     wxBitmap bitmap;
1242     wxMemoryDC dc;
1243     dc.SelectObject(bitmap);
1244     m_shape->Draw(dc);
1245     dc.SelectObject(wxNullBitmap);
1246
1247     DnDShapeDataObject *self = (DnDShapeDataObject *)this; // const_cast
1248     self->m_dataobj.SetBitmap(bitmap);
1249     self->m_hasBitmap = TRUE;
1250 }
1251