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 #include "wx/dnd.h"
  23 #include "wx/dataobj.h"
  24 #include "wx/image.h"
  25 #include "wx/clipbrd.h"
  26 #include "wx/colordlg.h"
  27 #include "wx/metafile.h"
  28
  29 #if defined(__WXGTK__) || defined(__WXX11__) || defined(__WXMOTIF__) || defined(__WXMAC__)
  30     #include "../sample.xpm"
  31 #if wxUSE_DRAG_AND_DROP
  32     #include "dnd_copy.xpm"
  33     #include "dnd_move.xpm"
  34     #include "dnd_none.xpm"
  35 #endif
  36 #endif
  37
  38 #if wxUSE_DRAG_AND_DROP
  39
  40 // ----------------------------------------------------------------------------
  41 // Derive two simple classes which just put in the listbox the strings (text or
  42 // file names) we drop on them
  43 // ----------------------------------------------------------------------------
  44
  45 class DnDText : public wxTextDropTarget
  46 {
  47 public:
  48     DnDText(wxListBox *pOwner) { m_pOwner = pOwner; }
  49
  50     virtual bool OnDropText(wxCoord x, wxCoord y, const wxString& text);
  51
  52 private:
  53     wxListBox *m_pOwner;
  54 };
  55
  56 class DnDFile : public wxFileDropTarget
  57 {
  58 public:
  59     DnDFile(wxListBox *pOwner) { m_pOwner = pOwner; }
  60
  61     virtual bool OnDropFiles(wxCoord x, wxCoord y,
  62                              const wxArrayString& filenames);
  63
  64 private:
  65     wxListBox *m_pOwner;
  66 };
  67
  68 // ----------------------------------------------------------------------------
  69 // Define a custom dtop target accepting URLs
  70 // ----------------------------------------------------------------------------
  71
  72 class URLDropTarget : public wxDropTarget
  73 {
  74 public:
  75     URLDropTarget() { SetDataObject(new wxURLDataObject); }
  76
  77     void OnDropURL(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y), const wxString& text)
  78     {
  79         // of course, a real program would do something more useful here...
  80         wxMessageBox(text, _T("wxDnD sample: got URL"),
  81                      wxICON_INFORMATION | wxOK);
  82     }
  83
  84     // URLs can't be moved, only copied
  85     virtual wxDragResult OnDragOver(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
  86                                     wxDragResult WXUNUSED(def))
  87         {
  88             return wxDragLink;  // At least IE 5.x needs wxDragLink, the
  89                                 // other browsers on MSW seem okay with it too.
  90         }
  91
  92     // translate this to calls to OnDropURL() just for convenience
  93     virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def)
  94     {
  95         if ( !GetData() )
  96             return wxDragNone;
  97
  98         OnDropURL(x, y, ((wxURLDataObject *)m_dataObject)->GetURL());
  99
 100         return def;
 101     }
 102 };
 103
 104 #endif // wxUSE_DRAG_AND_DROP
 105
 106 // ----------------------------------------------------------------------------
 107 // Define a new application type
 108 // ----------------------------------------------------------------------------
 109
 110 class DnDApp : public wxApp
 111 {
 112 public:
 113     virtual bool OnInit();
 114 };
 115
 116 IMPLEMENT_APP(DnDApp)
 117
 118 #if wxUSE_DRAG_AND_DROP || wxUSE_CLIPBOARD
 119
 120 // ----------------------------------------------------------------------------
 121 // Define canvas class to show a bitmap
 122 // ----------------------------------------------------------------------------
 123
 124 class DnDCanvasBitmap : public wxScrolledWindow
 125 {
 126 public:
 127     DnDCanvasBitmap(wxWindow *parent) : wxScrolledWindow(parent) { }
 128
 129     void SetBitmap(const wxBitmap& bitmap)
 130     {
 131         m_bitmap = bitmap;
 132
 133         SetScrollbars(10, 10,
 134                       m_bitmap.GetWidth() / 10, m_bitmap.GetHeight() / 10);
 135
 136         Refresh();
 137     }
 138
 139     void OnPaint(wxPaintEvent& WXUNUSED(event))
 140     {
 141         wxPaintDC dc(this);
 142
 143         if ( m_bitmap.Ok() )
 144         {
 145             PrepareDC(dc);
 146
 147             dc.DrawBitmap(m_bitmap, 0, 0);
 148         }
 149     }
 150
 151 private:
 152     wxBitmap m_bitmap;
 153
 154     DECLARE_EVENT_TABLE()
 155 };
 156
 157 #if wxUSE_METAFILE
 158
 159 // and the same thing fo metafiles
 160 class DnDCanvasMetafile : public wxScrolledWindow
 161 {
 162 public:
 163     DnDCanvasMetafile(wxWindow *parent) : wxScrolledWindow(parent) { }
 164
 165     void SetMetafile(const wxMetafile& metafile)
 166     {
 167         m_metafile = metafile;
 168
 169         SetScrollbars(10, 10,
 170                       m_metafile.GetWidth() / 10, m_metafile.GetHeight() / 10);
 171
 172         Refresh();
 173     }
 174
 175     void OnPaint(wxPaintEvent&)
 176     {
 177         wxPaintDC dc(this);
 178
 179         if ( m_metafile.Ok() )
 180         {
 181             PrepareDC(dc);
 182
 183             m_metafile.Play(&dc);
 184         }
 185     }
 186
 187 private:
 188     wxMetafile m_metafile;
 189
 190     DECLARE_EVENT_TABLE()
 191 };
 192
 193 #endif // wxUSE_METAFILE
 194
 195 // ----------------------------------------------------------------------------
 196 // Define a new frame type for the main frame
 197 // ----------------------------------------------------------------------------
 198
 199 class DnDFrame : public wxFrame
 200 {
 201 public:
 202     DnDFrame(wxFrame *frame, const wxChar *title, int x, int y, int w, int h);
 203     virtual ~DnDFrame();
 204
 205     void OnPaint(wxPaintEvent& event);
 206     void OnSize(wxSizeEvent& event);
 207     void OnQuit(wxCommandEvent& event);
 208     void OnAbout(wxCommandEvent& event);
 209     void OnDrag(wxCommandEvent& event);
 210     void OnDragMoveByDefault(wxCommandEvent& event);
 211     void OnDragMoveAllow(wxCommandEvent& event);
 212     void OnNewFrame(wxCommandEvent& event);
 213     void OnHelp (wxCommandEvent& event);
 214 #if wxUSE_LOG
 215     void OnLogClear(wxCommandEvent& event);
 216 #endif // wxUSE_LOG
 217
 218     void OnCopy(wxCommandEvent& event);
 219     void OnPaste(wxCommandEvent& event);
 220
 221     void OnCopyBitmap(wxCommandEvent& event);
 222     void OnPasteBitmap(wxCommandEvent& event);
 223
 224 #if wxUSE_METAFILE
 225     void OnPasteMetafile(wxCommandEvent& event);
 226 #endif // wxUSE_METAFILE
 227
 228     void OnCopyFiles(wxCommandEvent& event);
 229
 230     void OnLeftDown(wxMouseEvent& event);
 231     void OnRightDown(wxMouseEvent& event);
 232
 233     void OnUpdateUIMoveByDefault(wxUpdateUIEvent& event);
 234
 235     void OnUpdateUIPasteText(wxUpdateUIEvent& event);
 236     void OnUpdateUIPasteBitmap(wxUpdateUIEvent& event);
 237
 238     DECLARE_EVENT_TABLE()
 239
 240 private:
 241     // GUI controls
 242     wxListBox  *m_ctrlFile,
 243                *m_ctrlText;
 244
 245 #if wxUSE_LOG
 246     wxTextCtrl *m_ctrlLog;
 247
 248     wxLog *m_pLog,
 249           *m_pLogPrev;
 250 #endif // wxUSE_LOG
 251
 252     // move the text by default (or copy)?
 253     bool m_moveByDefault;
 254
 255     // allow moving the text at all?
 256     bool m_moveAllow;
 257
 258     // the text we drag
 259     wxString  m_strText;
 260 };
 261
 262 // ----------------------------------------------------------------------------
 263 // A shape is an example of application-specific data which may be transported
 264 // via drag-and-drop or clipboard: in our case, we have different geometric
 265 // shapes, each one with its own colour and position
 266 // ----------------------------------------------------------------------------
 267
 268 #if wxUSE_DRAG_AND_DROP
 269
 270 class DnDShape
 271 {
 272 public:
 273     enum Kind
 274     {
 275         None,
 276         Triangle,
 277         Rectangle,
 278         Ellipse
 279     };
 280
 281     DnDShape(const wxPoint& pos,
 282              const wxSize& size,
 283              const wxColour& col)
 284         : m_pos(pos), m_size(size), m_col(col)
 285     {
 286     }
 287
 288     // this is for debugging - lets us see when exactly an object is freed
 289     // (this may be later than you think if it's on the clipboard, for example)
 290     virtual ~DnDShape() { }
 291
 292     // the functions used for drag-and-drop: they dump and restore a shape into
 293     // some bitwise-copiable data (might use streams too...)
 294     // ------------------------------------------------------------------------
 295
 296     // restore from buffer
 297     static DnDShape *New(const void *buf);
 298
 299     virtual size_t GetDataSize() const
 300     {
 301         return sizeof(ShapeDump);
 302     }
 303
 304     virtual void GetDataHere(void *buf) const
 305     {
 306         ShapeDump& dump = *(ShapeDump *)buf;
 307         dump.x = m_pos.x;
 308         dump.y = m_pos.y;
 309         dump.w = m_size.x;
 310         dump.h = m_size.y;
 311         dump.r = m_col.Red();
 312         dump.g = m_col.Green();
 313         dump.b = m_col.Blue();
 314         dump.k = GetKind();
 315     }
 316
 317     // accessors
 318     const wxPoint& GetPosition() const { return m_pos; }
 319     const wxColour& GetColour() const { return m_col; }
 320     const wxSize& GetSize() const { return m_size; }
 321
 322     void Move(const wxPoint& pos) { m_pos = pos; }
 323
 324     // to implement in derived classes
 325     virtual Kind GetKind() const = 0;
 326
 327     virtual void Draw(wxDC& dc)
 328     {
 329         dc.SetPen(wxPen(m_col, 1, wxSOLID));
 330     }
 331
 332 protected:
 333     //get a point 1 up and 1 left, otherwise the mid-point of a triangle is on the line
 334     wxPoint GetCentre() const
 335          { return wxPoint(m_pos.x + m_size.x / 2 - 1, m_pos.y + m_size.y / 2 - 1); }
 336
 337     struct ShapeDump
 338     {
 339         wxCoord x, y,             // position
 340                 w, h;             // size
 341         int k;                    // kind
 342         unsigned char r, g, b;    // colour
 343     };
 344
 345     wxPoint  m_pos;
 346     wxSize   m_size;
 347     wxColour m_col;
 348 };
 349
 350 class DnDTriangularShape : public DnDShape
 351 {
 352 public:
 353     DnDTriangularShape(const wxPoint& pos,
 354                        const wxSize& size,
 355                        const wxColour& col)
 356         : DnDShape(pos, size, col)
 357     {
 358         wxLogMessage(wxT("DnDTriangularShape is being created"));
 359     }
 360
 361     virtual ~DnDTriangularShape()
 362     {
 363         wxLogMessage(wxT("DnDTriangularShape is being deleted"));
 364     }
 365
 366     virtual Kind GetKind() const { return Triangle; }
 367     virtual void Draw(wxDC& dc)
 368     {
 369         DnDShape::Draw(dc);
 370
 371         // well, it's a bit difficult to describe a triangle by position and
 372         // size, but we're not doing geometry here, do we? ;-)
 373         wxPoint p1(m_pos);
 374         wxPoint p2(m_pos.x + m_size.x, m_pos.y);
 375         wxPoint p3(m_pos.x, m_pos.y + m_size.y);
 376
 377         dc.DrawLine(p1, p2);
 378         dc.DrawLine(p2, p3);
 379         dc.DrawLine(p3, p1);
 380
 381         //works in multicolor modes; on GTK (at least) will fail in 16-bit color
 382         dc.SetBrush(wxBrush(m_col, wxSOLID));
 383         dc.FloodFill(GetCentre(), m_col, wxFLOOD_BORDER);
 384     }
 385 };
 386
 387 class DnDRectangularShape : public DnDShape
 388 {
 389 public:
 390     DnDRectangularShape(const wxPoint& pos,
 391                         const wxSize& size,
 392                         const wxColour& col)
 393         : DnDShape(pos, size, col)
 394     {
 395         wxLogMessage(wxT("DnDRectangularShape is being created"));
 396     }
 397
 398     virtual ~DnDRectangularShape()
 399     {
 400         wxLogMessage(wxT("DnDRectangularShape is being deleted"));
 401     }
 402
 403     virtual Kind GetKind() const { return Rectangle; }
 404     virtual void Draw(wxDC& dc)
 405     {
 406         DnDShape::Draw(dc);
 407
 408         wxPoint p1(m_pos);
 409         wxPoint p2(p1.x + m_size.x, p1.y);
 410         wxPoint p3(p2.x, p2.y + m_size.y);
 411         wxPoint p4(p1.x, p3.y);
 412
 413         dc.DrawLine(p1, p2);
 414         dc.DrawLine(p2, p3);
 415         dc.DrawLine(p3, p4);
 416         dc.DrawLine(p4, p1);
 417
 418         dc.SetBrush(wxBrush(m_col, wxSOLID));
 419         dc.FloodFill(GetCentre(), m_col, wxFLOOD_BORDER);
 420     }
 421 };
 422
 423 class DnDEllipticShape : public DnDShape
 424 {
 425 public:
 426     DnDEllipticShape(const wxPoint& pos,
 427                      const wxSize& size,
 428                      const wxColour& col)
 429         : DnDShape(pos, size, col)
 430     {
 431         wxLogMessage(wxT("DnDEllipticShape is being created"));
 432     }
 433
 434     virtual ~DnDEllipticShape()
 435     {
 436         wxLogMessage(wxT("DnDEllipticShape is being deleted"));
 437     }
 438
 439     virtual Kind GetKind() const { return Ellipse; }
 440     virtual void Draw(wxDC& dc)
 441     {
 442         DnDShape::Draw(dc);
 443
 444         dc.DrawEllipse(m_pos, m_size);
 445
 446         dc.SetBrush(wxBrush(m_col, wxSOLID));
 447         dc.FloodFill(GetCentre(), m_col, wxFLOOD_BORDER);
 448     }
 449 };
 450
 451 // ----------------------------------------------------------------------------
 452 // A wxDataObject specialisation for the application-specific data
 453 // ----------------------------------------------------------------------------
 454
 455 static const wxChar *shapeFormatId = wxT("wxShape");
 456
 457 class DnDShapeDataObject : public wxDataObject
 458 {
 459 public:
 460     // ctor doesn't copy the pointer, so it shouldn't go away while this object
 461     // is alive
 462     DnDShapeDataObject(DnDShape *shape = (DnDShape *)NULL)
 463     {
 464         if ( shape )
 465         {
 466             // we need to copy the shape because the one we're handled may be
 467             // deleted while it's still on the clipboard (for example) - and we
 468             // reuse the serialisation methods here to copy it
 469             void *buf = malloc(shape->DnDShape::GetDataSize());
 470             shape->GetDataHere(buf);
 471             m_shape = DnDShape::New(buf);
 472
 473             free(buf);
 474         }
 475         else
 476         {
 477             // nothing to copy
 478             m_shape = NULL;
 479         }
 480
 481         // this string should uniquely identify our format, but is otherwise
 482         // arbitrary
 483         m_formatShape.SetId(shapeFormatId);
 484
 485         // we don't draw the shape to a bitmap until it's really needed (i.e.
 486         // we're asked to do so)
 487         m_hasBitmap = false;
 488 #if wxUSE_METAFILE
 489         m_hasMetaFile = false;
 490 #endif // wxUSE_METAFILE
 491     }
 492
 493     virtual ~DnDShapeDataObject() { delete m_shape; }
 494
 495     // after a call to this function, the shape is owned by the caller and it
 496     // is responsible for deleting it!
 497     //
 498     // NB: a better solution would be to make DnDShapes ref counted and this
 499     //     is what should probably be done in a real life program, otherwise
 500     //     the ownership problems become too complicated really fast
 501     DnDShape *GetShape()
 502     {
 503         DnDShape *shape = m_shape;
 504
 505         m_shape = (DnDShape *)NULL;
 506         m_hasBitmap = false;
 507 #if wxUSE_METAFILE
 508         m_hasMetaFile = false;
 509 #endif // wxUSE_METAFILE
 510
 511         return shape;
 512     }
 513
 514     // implement base class pure virtuals
 515     // ----------------------------------
 516
 517     virtual wxDataFormat GetPreferredFormat(Direction WXUNUSED(dir)) const
 518     {
 519         return m_formatShape;
 520     }
 521
 522     virtual size_t GetFormatCount(Direction dir) const
 523     {
 524         // our custom format is supported by both GetData() and SetData()
 525         size_t nFormats = 1;
 526         if ( dir == Get )
 527         {
 528             // but the bitmap format(s) are only supported for output
 529             nFormats += m_dobjBitmap.GetFormatCount(dir);
 530
 531 #if wxUSE_METAFILE
 532             nFormats += m_dobjMetaFile.GetFormatCount(dir);
 533 #endif // wxUSE_METAFILE
 534         }
 535
 536         return nFormats;
 537     }
 538
 539     virtual void GetAllFormats(wxDataFormat *formats, Direction dir) const
 540     {
 541         formats[0] = m_formatShape;
 542         if ( dir == Get )
 543         {
 544             // in Get direction we additionally support bitmaps and metafiles
 545             // under Windows
 546             m_dobjBitmap.GetAllFormats(&formats[1], dir);
 547
 548 #if wxUSE_METAFILE
 549             // don't assume that m_dobjBitmap has only 1 format
 550             m_dobjMetaFile.GetAllFormats(&formats[1 +
 551                     m_dobjBitmap.GetFormatCount(dir)], dir);
 552 #endif // wxUSE_METAFILE
 553         }
 554     }
 555
 556     virtual size_t GetDataSize(const wxDataFormat& format) const
 557     {
 558         if ( format == m_formatShape )
 559         {
 560             return m_shape->GetDataSize();
 561         }
 562 #if wxUSE_METAFILE
 563         else if ( m_dobjMetaFile.IsSupported(format) )
 564         {
 565             if ( !m_hasMetaFile )
 566                 CreateMetaFile();
 567
 568             return m_dobjMetaFile.GetDataSize(format);
 569         }
 570 #endif // wxUSE_METAFILE
 571         else
 572         {
 573             wxASSERT_MSG( m_dobjBitmap.IsSupported(format),
 574                           wxT("unexpected format") );
 575
 576             if ( !m_hasBitmap )
 577                 CreateBitmap();
 578
 579             return m_dobjBitmap.GetDataSize();
 580         }
 581     }
 582
 583     virtual bool GetDataHere(const wxDataFormat& format, void *pBuf) const
 584     {
 585         if ( format == m_formatShape )
 586         {
 587             m_shape->GetDataHere(pBuf);
 588
 589             return true;
 590         }
 591 #if wxUSE_METAFILE
 592         else if ( m_dobjMetaFile.IsSupported(format) )
 593         {
 594             if ( !m_hasMetaFile )
 595                 CreateMetaFile();
 596
 597             return m_dobjMetaFile.GetDataHere(format, pBuf);
 598         }
 599 #endif // wxUSE_METAFILE
 600         else
 601         {
 602             wxASSERT_MSG( m_dobjBitmap.IsSupported(format),
 603                           wxT("unexpected format") );
 604
 605             if ( !m_hasBitmap )
 606                 CreateBitmap();
 607
 608             return m_dobjBitmap.GetDataHere(pBuf);
 609         }
 610     }
 611
 612     virtual bool SetData(const wxDataFormat& format,
 613                          size_t WXUNUSED(len), const void *buf)
 614     {
 615         wxCHECK_MSG( format == m_formatShape, false,
 616                      wxT( "unsupported format") );
 617
 618         delete m_shape;
 619         m_shape = DnDShape::New(buf);
 620
 621         // the shape has changed
 622         m_hasBitmap = false;
 623
 624 #if wxUSE_METAFILE
 625         m_hasMetaFile = false;
 626 #endif // wxUSE_METAFILE
 627
 628         return true;
 629     }
 630
 631 private:
 632     // creates a bitmap and assigns it to m_dobjBitmap (also sets m_hasBitmap)
 633     void CreateBitmap() const;
 634 #if wxUSE_METAFILE
 635     void CreateMetaFile() const;
 636 #endif // wxUSE_METAFILE
 637
 638     wxDataFormat        m_formatShape;  // our custom format
 639
 640     wxBitmapDataObject  m_dobjBitmap;   // it handles bitmaps
 641     bool                m_hasBitmap;    // true if m_dobjBitmap has valid bitmap
 642
 643 #if wxUSE_METAFILE
 644     wxMetaFileDataObject m_dobjMetaFile;// handles metafiles
 645     bool                 m_hasMetaFile; // true if we have valid metafile
 646 #endif // wxUSE_METAFILE
 647
 648     DnDShape           *m_shape;        // our data
 649 };
 650
 651 // ----------------------------------------------------------------------------
 652 // A dialog to edit shape properties
 653 // ----------------------------------------------------------------------------
 654
 655 class DnDShapeDialog : public wxDialog
 656 {
 657 public:
 658     DnDShapeDialog(wxFrame *parent, DnDShape *shape);
 659
 660     DnDShape *GetShape() const;
 661
 662     virtual bool TransferDataToWindow();
 663     virtual bool TransferDataFromWindow();
 664
 665     void OnColour(wxCommandEvent& event);
 666
 667 private:
 668     // input
 669     DnDShape *m_shape;
 670
 671     // output
 672     DnDShape::Kind m_shapeKind;
 673     wxPoint  m_pos;
 674     wxSize   m_size;
 675     wxColour m_col;
 676
 677     // controls
 678     wxRadioBox *m_radio;
 679     wxTextCtrl *m_textX,
 680                *m_textY,
 681                *m_textW,
 682                *m_textH;
 683
 684     DECLARE_EVENT_TABLE()
 685 };
 686
 687 // ----------------------------------------------------------------------------
 688 // A frame for the shapes which can be drag-and-dropped between frames
 689 // ----------------------------------------------------------------------------
 690
 691 class DnDShapeFrame : public wxFrame
 692 {
 693 public:
 694     DnDShapeFrame(wxFrame *parent);
 695     ~DnDShapeFrame();
 696
 697     void SetShape(DnDShape *shape);
 698     virtual bool SetShape(const wxRegion &region)
 699     {
 700         return wxFrame::SetShape( region );
 701     }
 702
 703     // callbacks
 704     void OnNewShape(wxCommandEvent& event);
 705     void OnEditShape(wxCommandEvent& event);
 706     void OnClearShape(wxCommandEvent& event);
 707
 708     void OnCopyShape(wxCommandEvent& event);
 709     void OnPasteShape(wxCommandEvent& event);
 710
 711     void OnUpdateUICopy(wxUpdateUIEvent& event);
 712     void OnUpdateUIPaste(wxUpdateUIEvent& event);
 713
 714     void OnDrag(wxMouseEvent& event);
 715     void OnPaint(wxPaintEvent& event);
 716     void OnDrop(wxCoord x, wxCoord y, DnDShape *shape);
 717
 718 private:
 719     DnDShape *m_shape;
 720
 721     static DnDShapeFrame *ms_lastDropTarget;
 722
 723     DECLARE_EVENT_TABLE()
 724 };
 725
 726 // ----------------------------------------------------------------------------
 727 // wxDropTarget derivation for DnDShapes
 728 // ----------------------------------------------------------------------------
 729
 730 class DnDShapeDropTarget : public wxDropTarget
 731 {
 732 public:
 733     DnDShapeDropTarget(DnDShapeFrame *frame)
 734         : wxDropTarget(new DnDShapeDataObject)
 735     {
 736         m_frame = frame;
 737     }
 738
 739     // override base class (pure) virtuals
 740     virtual wxDragResult OnEnter(wxCoord x, wxCoord y, wxDragResult def)
 741     {
 742 #if wxUSE_STATUSBAR
 743         m_frame->SetStatusText(_T("Mouse entered the frame"));
 744 #endif // wxUSE_STATUSBAR
 745         return OnDragOver(x, y, def);
 746     }
 747     virtual void OnLeave()
 748     {
 749 #if wxUSE_STATUSBAR
 750         m_frame->SetStatusText(_T("Mouse left the frame"));
 751 #endif // wxUSE_STATUSBAR
 752     }
 753     virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def)
 754     {
 755         if ( !GetData() )
 756         {
 757             wxLogError(wxT("Failed to get drag and drop data"));
 758
 759             return wxDragNone;
 760         }
 761
 762         m_frame->OnDrop(x, y,
 763                         ((DnDShapeDataObject *)GetDataObject())->GetShape());
 764
 765         return def;
 766     }
 767
 768 private:
 769     DnDShapeFrame *m_frame;
 770 };
 771
 772 #endif // wxUSE_DRAG_AND_DROP
 773
 774 // ----------------------------------------------------------------------------
 775 // functions prototypes
 776 // ----------------------------------------------------------------------------
 777
 778 static void ShowBitmap(const wxBitmap& bitmap);
 779
 780 #if wxUSE_METAFILE
 781 static void ShowMetaFile(const wxMetaFile& metafile);
 782 #endif // wxUSE_METAFILE
 783
 784 // ----------------------------------------------------------------------------
 785 // IDs for the menu commands
 786 // ----------------------------------------------------------------------------
 787
 788 enum
 789 {
 790     Menu_Quit = 1,
 791     Menu_Drag,
 792     Menu_DragMoveDef,
 793     Menu_DragMoveAllow,
 794     Menu_NewFrame,
 795     Menu_About = 101,
 796     Menu_Help,
 797     Menu_Clear,
 798     Menu_Copy,
 799     Menu_Paste,
 800     Menu_CopyBitmap,
 801     Menu_PasteBitmap,
 802     Menu_PasteMFile,
 803     Menu_CopyFiles,
 804     Menu_Shape_New = 500,
 805     Menu_Shape_Edit,
 806     Menu_Shape_Clear,
 807     Menu_ShapeClipboard_Copy,
 808     Menu_ShapeClipboard_Paste,
 809     Button_Colour = 1001
 810 };
 811
 812 BEGIN_EVENT_TABLE(DnDFrame, wxFrame)
 813     EVT_MENU(Menu_Quit,       DnDFrame::OnQuit)
 814     EVT_MENU(Menu_About,      DnDFrame::OnAbout)
 815     EVT_MENU(Menu_Drag,       DnDFrame::OnDrag)
 816     EVT_MENU(Menu_DragMoveDef,  DnDFrame::OnDragMoveByDefault)
 817     EVT_MENU(Menu_DragMoveAllow,DnDFrame::OnDragMoveAllow)
 818     EVT_MENU(Menu_NewFrame,   DnDFrame::OnNewFrame)
 819     EVT_MENU(Menu_Help,       DnDFrame::OnHelp)
 820 #if wxUSE_LOG
 821     EVT_MENU(Menu_Clear,      DnDFrame::OnLogClear)
 822 #endif // wxUSE_LOG
 823     EVT_MENU(Menu_Copy,       DnDFrame::OnCopy)
 824     EVT_MENU(Menu_Paste,      DnDFrame::OnPaste)
 825     EVT_MENU(Menu_CopyBitmap, DnDFrame::OnCopyBitmap)
 826     EVT_MENU(Menu_PasteBitmap,DnDFrame::OnPasteBitmap)
 827 #if wxUSE_METAFILE
 828     EVT_MENU(Menu_PasteMFile, DnDFrame::OnPasteMetafile)
 829 #endif // wxUSE_METAFILE
 830     EVT_MENU(Menu_CopyFiles,  DnDFrame::OnCopyFiles)
 831
 832     EVT_UPDATE_UI(Menu_DragMoveDef, DnDFrame::OnUpdateUIMoveByDefault)
 833
 834     EVT_UPDATE_UI(Menu_Paste,       DnDFrame::OnUpdateUIPasteText)
 835     EVT_UPDATE_UI(Menu_PasteBitmap, DnDFrame::OnUpdateUIPasteBitmap)
 836
 837     EVT_LEFT_DOWN(            DnDFrame::OnLeftDown)
 838     EVT_RIGHT_DOWN(           DnDFrame::OnRightDown)
 839     EVT_PAINT(                DnDFrame::OnPaint)
 840     EVT_SIZE(                 DnDFrame::OnSize)
 841 END_EVENT_TABLE()
 842
 843 #if wxUSE_DRAG_AND_DROP
 844
 845 BEGIN_EVENT_TABLE(DnDShapeFrame, wxFrame)
 846     EVT_MENU(Menu_Shape_New,    DnDShapeFrame::OnNewShape)
 847     EVT_MENU(Menu_Shape_Edit,   DnDShapeFrame::OnEditShape)
 848     EVT_MENU(Menu_Shape_Clear,  DnDShapeFrame::OnClearShape)
 849
 850     EVT_MENU(Menu_ShapeClipboard_Copy,  DnDShapeFrame::OnCopyShape)
 851     EVT_MENU(Menu_ShapeClipboard_Paste, DnDShapeFrame::OnPasteShape)
 852
 853     EVT_UPDATE_UI(Menu_ShapeClipboard_Copy,  DnDShapeFrame::OnUpdateUICopy)
 854     EVT_UPDATE_UI(Menu_ShapeClipboard_Paste, DnDShapeFrame::OnUpdateUIPaste)
 855
 856     EVT_LEFT_DOWN(DnDShapeFrame::OnDrag)
 857
 858     EVT_PAINT(DnDShapeFrame::OnPaint)
 859 END_EVENT_TABLE()
 860
 861 BEGIN_EVENT_TABLE(DnDShapeDialog, wxDialog)
 862     EVT_BUTTON(Button_Colour, DnDShapeDialog::OnColour)
 863 END_EVENT_TABLE()
 864
 865 #endif // wxUSE_DRAG_AND_DROP
 866
 867 BEGIN_EVENT_TABLE(DnDCanvasBitmap, wxScrolledWindow)
 868     EVT_PAINT(DnDCanvasBitmap::OnPaint)
 869 END_EVENT_TABLE()
 870
 871 #if wxUSE_METAFILE
 872 BEGIN_EVENT_TABLE(DnDCanvasMetafile, wxScrolledWindow)
 873     EVT_PAINT(DnDCanvasMetafile::OnPaint)
 874 END_EVENT_TABLE()
 875 #endif // wxUSE_METAFILE
 876
 877 #endif // wxUSE_DRAG_AND_DROP
 878
 879 // ============================================================================
 880 // implementation
 881 // ============================================================================
 882
 883 // `Main program' equivalent, creating windows and returning main app frame
 884 bool DnDApp::OnInit()
 885 {
 886 #if wxUSE_DRAG_AND_DROP || wxUSE_CLIPBOARD
 887     // switch on trace messages
 888 #if wxUSE_LOG
 889 #if defined(__WXGTK__)
 890     wxLog::AddTraceMask(_T("clipboard"));
 891 #elif defined(__WXMSW__)
 892     wxLog::AddTraceMask(wxTRACE_OleCalls);
 893 #endif
 894 #endif // wxUSE_LOG
 895
 896 #if wxUSE_LIBPNG
 897     wxImage::AddHandler( new wxPNGHandler );
 898 #endif
 899
 900     // under X we usually want to use the primary selection by default (which
 901     // is shared with other apps)
 902     wxTheClipboard->UsePrimarySelection();
 903
 904     // create the main frame window
 905     DnDFrame *frame = new DnDFrame((wxFrame  *) NULL,
 906                                    _T("Drag-and-Drop/Clipboard wxWidgets Sample"),
 907                                    10, 100, 650, 340);
 908
 909     // activate it
 910     frame->Show(true);
 911
 912     SetTopWindow(frame);
 913
 914     return true;
 915 #else
 916     wxMessageBox( _T("This sample has to be compiled with wxUSE_DRAG_AND_DROP"), _T("Building error"), wxOK);
 917     return false;
 918 #endif // wxUSE_DRAG_AND_DROP
 919 }
 920
 921 #if wxUSE_DRAG_AND_DROP || wxUSE_CLIPBOARD
 922
 923 DnDFrame::DnDFrame(wxFrame *frame, const wxChar *title, int x, int y, int w, int h)
 924         : wxFrame(frame, wxID_ANY, title, wxPoint(x, y), wxSize(w, h)),
 925           m_strText(_T("wxWidgets drag & drop works :-)"))
 926
 927 {
 928     // frame icon and status bar
 929     SetIcon(wxICON(sample));
 930
 931 #if wxUSE_STATUSBAR
 932     CreateStatusBar();
 933 #endif // wxUSE_STATUSBAR
 934
 935     // construct menu
 936     wxMenu *file_menu = new wxMenu;
 937     file_menu->Append(Menu_Drag, _T("&Test drag..."));
 938     file_menu->AppendCheckItem(Menu_DragMoveDef, _T("&Move by default"));
 939     file_menu->AppendCheckItem(Menu_DragMoveAllow, _T("&Allow moving"));
 940     file_menu->AppendSeparator();
 941     file_menu->Append(Menu_NewFrame, _T("&New frame\tCtrl-N"));
 942     file_menu->AppendSeparator();
 943     file_menu->Append(Menu_Quit, _T("E&xit\tCtrl-Q"));
 944
 945 #if wxUSE_LOG
 946     wxMenu *log_menu = new wxMenu;
 947     log_menu->Append(Menu_Clear, _T("Clear\tCtrl-L"));
 948 #endif // wxUSE_LOG
 949
 950     wxMenu *help_menu = new wxMenu;
 951     help_menu->Append(Menu_Help, _T("&Help..."));
 952     help_menu->AppendSeparator();
 953     help_menu->Append(Menu_About, _T("&About"));
 954
 955     wxMenu *clip_menu = new wxMenu;
 956     clip_menu->Append(Menu_Copy, _T("&Copy text\tCtrl-C"));
 957     clip_menu->Append(Menu_Paste, _T("&Paste text\tCtrl-V"));
 958     clip_menu->AppendSeparator();
 959     clip_menu->Append(Menu_CopyBitmap, _T("Copy &bitmap\tCtrl-Shift-C"));
 960     clip_menu->Append(Menu_PasteBitmap, _T("Paste b&itmap\tCtrl-Shift-V"));
 961 #if wxUSE_METAFILE
 962     clip_menu->AppendSeparator();
 963     clip_menu->Append(Menu_PasteMFile, _T("Paste &metafile\tCtrl-M"));
 964 #endif // wxUSE_METAFILE
 965     clip_menu->AppendSeparator();
 966     clip_menu->Append(Menu_CopyFiles, _T("Copy &files\tCtrl-F"));
 967
 968     wxMenuBar *menu_bar = new wxMenuBar;
 969     menu_bar->Append(file_menu, _T("&File"));
 970 #if wxUSE_LOG
 971     menu_bar->Append(log_menu,  _T("&Log"));
 972 #endif // wxUSE_LOG
 973     menu_bar->Append(clip_menu, _T("&Clipboard"));
 974     menu_bar->Append(help_menu, _T("&Help"));
 975
 976     SetMenuBar(menu_bar);
 977
 978     // make a panel with 3 subwindows
 979     wxString strFile(_T("Drop files here!")), strText(_T("Drop text on me"));
 980
 981     m_ctrlFile  = new wxListBox(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, 1, &strFile,
 982                                 wxLB_HSCROLL | wxLB_ALWAYS_SB );
 983     m_ctrlText  = new wxListBox(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, 1, &strText,
 984                                 wxLB_HSCROLL | wxLB_ALWAYS_SB );
 985
 986 #if wxUSE_LOG
 987     m_ctrlLog   = new wxTextCtrl(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize,
 988                                  wxTE_MULTILINE | wxTE_READONLY |
 989                                  wxSUNKEN_BORDER );
 990
 991     // redirect log messages to the text window
 992     m_pLog = new wxLogTextCtrl(m_ctrlLog);
 993     m_pLogPrev = wxLog::SetActiveTarget(m_pLog);
 994 #endif // wxUSE_LOG
 995
 996 #if wxUSE_DRAG_AND_DROP
 997     // associate drop targets with the controls
 998     m_ctrlFile->SetDropTarget(new DnDFile(m_ctrlFile));
 999     m_ctrlText->SetDropTarget(new DnDText(m_ctrlText));
1000 #if wxUSE_LOG
1001     m_ctrlLog->SetDropTarget(new URLDropTarget);
1002 #endif // wxUSE_LOG
1003 #endif // wxUSE_DRAG_AND_DROP
1004
1005     wxBoxSizer *sizer_top = new wxBoxSizer( wxHORIZONTAL );
1006     sizer_top->Add(m_ctrlFile, 1, wxEXPAND );
1007     sizer_top->Add(m_ctrlText, 1, wxEXPAND );
1008
1009     wxBoxSizer *sizer = new wxBoxSizer( wxVERTICAL );
1010     sizer->Add(sizer_top, 1, wxEXPAND );
1011 #if wxUSE_LOG
1012     sizer->Add(m_ctrlLog, 2, wxEXPAND);
1013     sizer->SetItemMinSize(m_ctrlLog, 450, 0);
1014 #endif // wxUSE_LOG
1015     sizer->AddSpacer(50);
1016
1017     SetSizer(sizer);
1018     sizer->SetSizeHints( this );
1019
1020     // copy data by default but allow moving it as well
1021     m_moveByDefault = false;
1022     m_moveAllow = true;
1023     menu_bar->Check(Menu_DragMoveAllow, true);
1024 }
1025
1026 void DnDFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
1027 {
1028     Close(true);
1029 }
1030
1031 void DnDFrame::OnSize(wxSizeEvent& event)
1032 {
1033     Refresh();
1034
1035     event.Skip();
1036 }
1037
1038 void DnDFrame::OnPaint(wxPaintEvent& WXUNUSED(event))
1039 {
1040     int w = 0;
1041     int h = 0;
1042     GetClientSize( &w, &h );
1043
1044     wxPaintDC dc(this);
1045     // dc.Clear(); -- this kills wxGTK
1046     dc.SetFont( wxFont( 24, wxDECORATIVE, wxNORMAL, wxNORMAL, false, _T("charter") ) );
1047     dc.DrawText( _T("Drag text from here!"), 100, h-50 );
1048 }
1049
1050 void DnDFrame::OnUpdateUIMoveByDefault(wxUpdateUIEvent& event)
1051 {
1052     // only can move by default if moving is allowed at all
1053     event.Enable(m_moveAllow);
1054 }
1055
1056 void DnDFrame::OnUpdateUIPasteText(wxUpdateUIEvent& event)
1057 {
1058 #ifdef __WXDEBUG__
1059     // too many trace messages if we don't do it - this function is called
1060     // very often
1061     wxLogNull nolog;
1062 #endif
1063
1064     event.Enable( wxTheClipboard->IsSupported(wxDF_TEXT) );
1065 }
1066
1067 void DnDFrame::OnUpdateUIPasteBitmap(wxUpdateUIEvent& event)
1068 {
1069 #ifdef __WXDEBUG__
1070     // too many trace messages if we don't do it - this function is called
1071     // very often
1072     wxLogNull nolog;
1073 #endif
1074
1075     event.Enable( wxTheClipboard->IsSupported(wxDF_BITMAP) );
1076 }
1077
1078 void DnDFrame::OnNewFrame(wxCommandEvent& WXUNUSED(event))
1079 {
1080 #if wxUSE_DRAG_AND_DROP
1081     (new DnDShapeFrame(this))->Show(true);
1082
1083     wxLogStatus(this, wxT("Double click the new frame to select a shape for it"));
1084 #endif // wxUSE_DRAG_AND_DROP
1085 }
1086
1087 void DnDFrame::OnDrag(wxCommandEvent& WXUNUSED(event))
1088 {
1089 #if wxUSE_DRAG_AND_DROP
1090     wxString strText = wxGetTextFromUser
1091         (
1092             _T("After you enter text in this dialog, press any mouse\n")
1093             _T("button in the bottom (empty) part of the frame and \n")
1094             _T("drag it anywhere - you will be in fact dragging the\n")
1095          _T("text object containing this text"),
1096          _T("Please enter some text"), m_strText, this
1097         );
1098
1099     m_strText = strText;
1100 #endif // wxUSE_DRAG_AND_DROP
1101 }
1102
1103 void DnDFrame::OnDragMoveByDefault(wxCommandEvent& event)
1104 {
1105     m_moveByDefault = event.IsChecked();
1106 }
1107
1108 void DnDFrame::OnDragMoveAllow(wxCommandEvent& event)
1109 {
1110     m_moveAllow = event.IsChecked();
1111 }
1112
1113 void DnDFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
1114 {
1115     wxMessageBox(_T("Drag-&-Drop Demo\n")
1116                  _T("Please see \"Help|Help...\" for details\n")
1117                  _T("Copyright (c) 1998 Vadim Zeitlin"),
1118                  _T("About wxDnD"),
1119                  wxICON_INFORMATION | wxOK,
1120                  this);
1121 }
1122
1123 void DnDFrame::OnHelp(wxCommandEvent& /* event */)
1124 {
1125     wxMessageDialog dialog(this,
1126                            _T("This small program demonstrates drag & drop support in wxWidgets. The program window\n")
1127                            _T("consists of 3 parts: the bottom pane is for debug messages, so that you can see what's\n")
1128                            _T("going on inside. The top part is split into 2 listboxes, the left one accepts files\n")
1129                            _T("and the right one accepts text.\n")
1130                            _T("\n")
1131                            _T("To test wxDropTarget: open wordpad (write.exe), select some text in it and drag it to\n")
1132                            _T("the right listbox (you'll notice the usual visual feedback, i.e. the cursor will change).\n")
1133                            _T("Also, try dragging some files (you can select several at once) from Windows Explorer (or \n")
1134                            _T("File Manager) to the left pane. Hold down Ctrl/Shift keys when you drop text (doesn't \n")
1135                            _T("work with files) and see what changes.\n")
1136                            _T("\n")
1137                            _T("To test wxDropSource: just press any mouse button on the empty zone of the window and drag\n")
1138                            _T("it to wordpad or any other droptarget accepting text (and of course you can just drag it\n")
1139                            _T("to the right pane). Due to a lot of trace messages, the cursor might take some time to \n")
1140                            _T("change, don't release the mouse button until it does. You can change the string being\n")
1141                            _T("dragged in in \"File|Test drag...\" dialog.\n")
1142                            _T("\n")
1143                            _T("\n")
1144                            _T("Please send all questions/bug reports/suggestions &c to \n")
1145                            _T("Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>"),
1146                            _T("wxDnD Help"));
1147
1148     dialog.ShowModal();
1149 }
1150
1151 #if wxUSE_LOG
1152 void DnDFrame::OnLogClear(wxCommandEvent& /* event */ )
1153 {
1154     m_ctrlLog->Clear();
1155     m_ctrlText->Clear();
1156     m_ctrlFile->Clear();
1157 }
1158 #endif // wxUSE_LOG
1159
1160 void DnDFrame::OnLeftDown(wxMouseEvent &WXUNUSED(event) )
1161 {
1162 #if wxUSE_DRAG_AND_DROP
1163     if ( !m_strText.empty() )
1164     {
1165         // start drag operation
1166         wxTextDataObject textData(m_strText);
1167         wxDropSource source(textData, this,
1168                             wxDROP_ICON(dnd_copy),
1169                             wxDROP_ICON(dnd_move),
1170                             wxDROP_ICON(dnd_none));
1171
1172         int flags = 0;
1173         if ( m_moveByDefault )
1174             flags |= wxDrag_DefaultMove;
1175         else if ( m_moveAllow )
1176             flags |= wxDrag_AllowMove;
1177
1178         wxDragResult result = source.DoDragDrop(flags);
1179
1180 #if wxUSE_STATUSBAR
1181         const wxChar *pc;
1182         switch ( result )
1183         {
1184             case wxDragError:   pc = _T("Error!");    break;
1185             case wxDragNone:    pc = _T("Nothing");   break;
1186             case wxDragCopy:    pc = _T("Copied");    break;
1187             case wxDragMove:    pc = _T("Moved");     break;
1188             case wxDragCancel:  pc = _T("Cancelled"); break;
1189             default:            pc = _T("Huh?");      break;
1190         }
1191
1192         SetStatusText(wxString(_T("Drag result: ")) + pc);
1193 #else
1194         wxUnusedVar(result);
1195 #endif // wxUSE_STATUSBAR
1196     }
1197 #endif // wxUSE_DRAG_AND_DROP
1198 }
1199
1200 void DnDFrame::OnRightDown(wxMouseEvent &event )
1201 {
1202     wxMenu menu(_T("Dnd sample menu"));
1203
1204     menu.Append(Menu_Drag, _T("&Test drag..."));
1205     menu.AppendSeparator();
1206     menu.Append(Menu_About, _T("&About"));
1207
1208     PopupMenu( &menu, event.GetX(), event.GetY() );
1209 }
1210
1211 DnDFrame::~DnDFrame()
1212 {
1213 #if wxUSE_LOG
1214     if ( m_pLog != NULL ) {
1215         if ( wxLog::SetActiveTarget(m_pLogPrev) == m_pLog )
1216             delete m_pLog;
1217     }
1218 #endif // wxUSE_LOG
1219 }
1220
1221 // ---------------------------------------------------------------------------
1222 // bitmap clipboard
1223 // ---------------------------------------------------------------------------
1224
1225 void DnDFrame::OnCopyBitmap(wxCommandEvent& WXUNUSED(event))
1226 {
1227     // PNG support is not always compiled in under Windows, so use BMP there
1228 #if wxUSE_LIBPNG
1229     wxFileDialog dialog(this, _T("Open a PNG file"), wxEmptyString, wxEmptyString, _T("PNG files (*.png)|*.png"), 0);
1230 #else
1231     wxFileDialog dialog(this, _T("Open a BMP file"), wxEmptyString, wxEmptyString, _T("BMP files (*.bmp)|*.bmp"), 0);
1232 #endif
1233
1234     if (dialog.ShowModal() != wxID_OK)
1235     {
1236         wxLogMessage( _T("Aborted file open") );
1237         return;
1238     }
1239
1240     if (dialog.GetPath().empty())
1241     {
1242         wxLogMessage( _T("Returned empty string.") );
1243         return;
1244     }
1245
1246     if (!wxFileExists(dialog.GetPath()))
1247     {
1248         wxLogMessage( _T("File doesn't exist.") );
1249         return;
1250     }
1251
1252     wxImage image;
1253     image.LoadFile( dialog.GetPath(),
1254 #if wxUSE_LIBPNG
1255                     wxBITMAP_TYPE_PNG
1256 #else
1257                     wxBITMAP_TYPE_BMP
1258 #endif
1259                   );
1260     if (!image.Ok())
1261     {
1262         wxLogError( _T("Invalid image file...") );
1263         return;
1264     }
1265
1266     wxLogStatus( _T("Decoding image file...") );
1267     wxYield();
1268
1269     wxBitmap bitmap( image );
1270
1271     if ( !wxTheClipboard->Open() )
1272     {
1273         wxLogError(_T("Can't open clipboard."));
1274
1275         return;
1276     }
1277
1278     wxLogMessage( _T("Creating wxBitmapDataObject...") );
1279     wxYield();
1280
1281     if ( !wxTheClipboard->AddData(new wxBitmapDataObject(bitmap)) )
1282     {
1283         wxLogError(_T("Can't copy image to the clipboard."));
1284     }
1285     else
1286     {
1287         wxLogMessage(_T("Image has been put on the clipboard.") );
1288         wxLogMessage(_T("You can paste it now and look at it.") );
1289     }
1290
1291     wxTheClipboard->Close();
1292 }
1293
1294 void DnDFrame::OnPasteBitmap(wxCommandEvent& WXUNUSED(event))
1295 {
1296     if ( !wxTheClipboard->Open() )
1297     {
1298         wxLogError(_T("Can't open clipboard."));
1299
1300         return;
1301     }
1302
1303     if ( !wxTheClipboard->IsSupported(wxDF_BITMAP) )
1304     {
1305         wxLogWarning(_T("No bitmap on clipboard"));
1306
1307         wxTheClipboard->Close();
1308         return;
1309     }
1310
1311     wxBitmapDataObject data;
1312     if ( !wxTheClipboard->GetData(data) )
1313     {
1314         wxLogError(_T("Can't paste bitmap from the clipboard"));
1315     }
1316     else
1317     {
1318         const wxBitmap& bmp = data.GetBitmap();
1319
1320         wxLogMessage(_T("Bitmap %dx%d pasted from the clipboard"),
1321                      bmp.GetWidth(), bmp.GetHeight());
1322         ShowBitmap(bmp);
1323     }
1324
1325     wxTheClipboard->Close();
1326 }
1327
1328 #if wxUSE_METAFILE
1329
1330 void DnDFrame::OnPasteMetafile(wxCommandEvent& WXUNUSED(event))
1331 {
1332     if ( !wxTheClipboard->Open() )
1333     {
1334         wxLogError(_T("Can't open clipboard."));
1335
1336         return;
1337     }
1338
1339     if ( !wxTheClipboard->IsSupported(wxDF_METAFILE) )
1340     {
1341         wxLogWarning(_T("No metafile on clipboard"));
1342     }
1343     else
1344     {
1345         wxMetaFileDataObject data;
1346         if ( !wxTheClipboard->GetData(data) )
1347         {
1348             wxLogError(_T("Can't paste metafile from the clipboard"));
1349         }
1350         else
1351         {
1352             const wxMetaFile& mf = data.GetMetafile();
1353
1354             wxLogMessage(_T("Metafile %dx%d pasted from the clipboard"),
1355                          mf.GetWidth(), mf.GetHeight());
1356
1357             ShowMetaFile(mf);
1358         }
1359     }
1360
1361     wxTheClipboard->Close();
1362 }
1363
1364 #endif // wxUSE_METAFILE
1365
1366 // ----------------------------------------------------------------------------
1367 // file clipboard
1368 // ----------------------------------------------------------------------------
1369
1370 void DnDFrame::OnCopyFiles(wxCommandEvent& WXUNUSED(event))
1371 {
1372 #ifdef __WXMSW__
1373     wxFileDialog dialog(this, _T("Select a file to copy"), wxEmptyString, wxEmptyString,
1374                          _T("All files (*.*)|*.*"), 0);
1375
1376     wxArrayString filenames;
1377     while ( dialog.ShowModal() == wxID_OK )
1378     {
1379         filenames.Add(dialog.GetPath());
1380     }
1381
1382     if ( !filenames.IsEmpty() )
1383     {
1384         wxFileDataObject *dobj = new wxFileDataObject;
1385         size_t count = filenames.GetCount();
1386         for ( size_t n = 0; n < count; n++ )
1387         {
1388             dobj->AddFile(filenames[n]);
1389         }
1390
1391         wxClipboardLocker locker;
1392         if ( !locker )
1393         {
1394             wxLogError(wxT("Can't open clipboard"));
1395         }
1396         else
1397         {
1398             if ( !wxTheClipboard->AddData(dobj) )
1399             {
1400                 wxLogError(wxT("Can't copy file(s) to the clipboard"));
1401             }
1402             else
1403             {
1404                 wxLogStatus(this, wxT("%d file%s copied to the clipboard"),
1405                             count, count == 1 ? wxEmptyString : wxEmptyString);
1406             }
1407         }
1408     }
1409     else
1410     {
1411         wxLogStatus(this, wxT("Aborted"));
1412     }
1413 #else // !MSW
1414     wxLogError(wxT("Sorry, not implemented"));
1415 #endif // MSW/!MSW
1416 }
1417
1418 // ---------------------------------------------------------------------------
1419 // text clipboard
1420 // ---------------------------------------------------------------------------
1421
1422 void DnDFrame::OnCopy(wxCommandEvent& WXUNUSED(event))
1423 {
1424     if ( !wxTheClipboard->Open() )
1425     {
1426         wxLogError(_T("Can't open clipboard."));
1427
1428         return;
1429     }
1430
1431     if ( !wxTheClipboard->AddData(new wxTextDataObject(m_strText)) )
1432     {
1433         wxLogError(_T("Can't copy data to the clipboard"));
1434     }
1435     else
1436     {
1437         wxLogMessage(_T("Text '%s' put on the clipboard"), m_strText.c_str());
1438     }
1439
1440     wxTheClipboard->Close();
1441 }
1442
1443 void DnDFrame::OnPaste(wxCommandEvent& WXUNUSED(event))
1444 {
1445     if ( !wxTheClipboard->Open() )
1446     {
1447         wxLogError(_T("Can't open clipboard."));
1448
1449         return;
1450     }
1451
1452     if ( !wxTheClipboard->IsSupported(wxDF_TEXT) )
1453     {
1454         wxLogWarning(_T("No text data on clipboard"));
1455
1456         wxTheClipboard->Close();
1457         return;
1458     }
1459
1460     wxTextDataObject text;
1461     if ( !wxTheClipboard->GetData(text) )
1462     {
1463         wxLogError(_T("Can't paste data from the clipboard"));
1464     }
1465     else
1466     {
1467         wxLogMessage(_T("Text '%s' pasted from the clipboard"),
1468                      text.GetText().c_str());
1469     }
1470
1471     wxTheClipboard->Close();
1472 }
1473
1474 #if wxUSE_DRAG_AND_DROP
1475
1476 // ----------------------------------------------------------------------------
1477 // Notifications called by the base class
1478 // ----------------------------------------------------------------------------
1479
1480 bool DnDText::OnDropText(wxCoord, wxCoord, const wxString& text)
1481 {
1482     m_pOwner->Append(text);
1483
1484     return true;
1485 }
1486
1487 bool DnDFile::OnDropFiles(wxCoord, wxCoord, const wxArrayString& filenames)
1488 {
1489     size_t nFiles = filenames.GetCount();
1490     wxString str;
1491     str.Printf( _T("%d files dropped"), (int)nFiles);
1492     m_pOwner->Append(str);
1493     for ( size_t n = 0; n < nFiles; n++ ) {
1494         m_pOwner->Append(filenames[n]);
1495     }
1496
1497     return true;
1498 }
1499
1500 // ----------------------------------------------------------------------------
1501 // DnDShapeDialog
1502 // ----------------------------------------------------------------------------
1503
1504 DnDShapeDialog::DnDShapeDialog(wxFrame *parent, DnDShape *shape)
1505   :wxDialog( parent, 6001, wxT("Choose Shape"), wxPoint( 10, 10 ),
1506              wxSize( 40, 40 ),
1507              wxDEFAULT_DIALOG_STYLE | wxRAISED_BORDER | wxRESIZE_BORDER )
1508 {
1509     m_shape = shape;
1510     wxBoxSizer* topSizer = new wxBoxSizer( wxVERTICAL );
1511
1512     // radio box
1513     wxBoxSizer* shapesSizer = new wxBoxSizer( wxHORIZONTAL );
1514     const wxString choices[] = { wxT("None"), wxT("Triangle"),
1515                                  wxT("Rectangle"), wxT("Ellipse") };
1516
1517     m_radio = new wxRadioBox( this, wxID_ANY, wxT("&Shape"),
1518                               wxDefaultPosition, wxDefaultSize, 4, choices, 4,
1519                               wxRA_SPECIFY_COLS );
1520     shapesSizer->Add( m_radio, 0, wxGROW|wxALL, 5 );
1521     topSizer->Add( shapesSizer, 0, wxALL, 2 );
1522
1523     // attributes
1524     wxStaticBox* box = new wxStaticBox( this, wxID_ANY, wxT("&Attributes") );
1525     wxStaticBoxSizer* attrSizer = new wxStaticBoxSizer( box, wxHORIZONTAL );
1526     wxFlexGridSizer* xywhSizer = new wxFlexGridSizer( 4, 2 );
1527
1528     wxStaticText* st;
1529
1530     st = new wxStaticText( this, wxID_ANY, wxT("Position &X:") );
1531     m_textX = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition,
1532                               wxSize( 30, 20 ) );
1533     xywhSizer->Add( st, 1, wxGROW|wxALL, 2 );
1534     xywhSizer->Add( m_textX, 1, wxGROW|wxALL, 2 );
1535
1536     st = new wxStaticText( this, wxID_ANY, wxT("Size &width:") );
1537     m_textW = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition,
1538                               wxSize( 30, 20 ) );
1539     xywhSizer->Add( st, 1, wxGROW|wxALL, 2 );
1540     xywhSizer->Add( m_textW, 1, wxGROW|wxALL, 2 );
1541
1542     st = new wxStaticText( this, wxID_ANY, wxT("&Y:") );
1543     m_textY = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition,
1544                               wxSize( 30, 20 ) );
1545     xywhSizer->Add( st, 1, wxALL|wxALIGN_RIGHT, 2 );
1546     xywhSizer->Add( m_textY, 1, wxGROW|wxALL, 2 );
1547
1548     st = new wxStaticText( this, wxID_ANY, wxT("&height:") );
1549     m_textH = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition,
1550                               wxSize( 30, 20 ) );
1551     xywhSizer->Add( st, 1, wxALL|wxALIGN_RIGHT, 2 );
1552     xywhSizer->Add( m_textH, 1, wxGROW|wxALL, 2 );
1553
1554     wxButton* col = new wxButton( this, Button_Colour, wxT("&Colour...") );
1555     attrSizer->Add( xywhSizer, 1, wxGROW );
1556     attrSizer->Add( col, 0, wxALL|wxALIGN_CENTRE_VERTICAL, 2 );
1557     topSizer->Add( attrSizer, 0, wxGROW|wxALL, 5 );
1558
1559     // buttons
1560     wxBoxSizer* buttonSizer = new wxBoxSizer( wxHORIZONTAL );
1561     wxButton* bt;
1562     bt = new wxButton( this, wxID_OK, wxT("Ok") );
1563     buttonSizer->Add( bt, 0, wxALL, 2 );
1564     bt = new wxButton( this, wxID_CANCEL, wxT("Cancel") );
1565     buttonSizer->Add( bt, 0, wxALL, 2 );
1566     topSizer->Add( buttonSizer, 0, wxALL|wxALIGN_RIGHT, 2 );
1567
1568     SetSizer( topSizer );
1569     topSizer->Fit( this );
1570 }
1571
1572 DnDShape *DnDShapeDialog::GetShape() const
1573 {
1574     switch ( m_shapeKind )
1575     {
1576         default:
1577         case DnDShape::None:      return NULL;
1578         case DnDShape::Triangle:  return new DnDTriangularShape(m_pos, m_size, m_col);
1579         case DnDShape::Rectangle: return new DnDRectangularShape(m_pos, m_size, m_col);
1580         case DnDShape::Ellipse:   return new DnDEllipticShape(m_pos, m_size, m_col);
1581     }
1582 }
1583
1584 bool DnDShapeDialog::TransferDataToWindow()
1585 {
1586
1587     if ( m_shape )
1588     {
1589         m_radio->SetSelection(m_shape->GetKind());
1590         m_pos = m_shape->GetPosition();
1591         m_size = m_shape->GetSize();
1592         m_col = m_shape->GetColour();
1593     }
1594     else
1595     {
1596         m_radio->SetSelection(DnDShape::None);
1597         m_pos = wxPoint(1, 1);
1598         m_size = wxSize(100, 100);
1599     }
1600
1601     m_textX->SetValue(wxString() << m_pos.x);
1602     m_textY->SetValue(wxString() << m_pos.y);
1603     m_textW->SetValue(wxString() << m_size.x);
1604     m_textH->SetValue(wxString() << m_size.y);
1605
1606     return true;
1607 }
1608
1609 bool DnDShapeDialog::TransferDataFromWindow()
1610 {
1611     m_shapeKind = (DnDShape::Kind)m_radio->GetSelection();
1612
1613     m_pos.x = wxAtoi(m_textX->GetValue());
1614     m_pos.y = wxAtoi(m_textY->GetValue());
1615     m_size.x = wxAtoi(m_textW->GetValue());
1616     m_size.y = wxAtoi(m_textH->GetValue());
1617
1618     if ( !m_pos.x || !m_pos.y || !m_size.x || !m_size.y )
1619     {
1620         wxMessageBox(_T("All sizes and positions should be non null!"),
1621                      _T("Invalid shape"), wxICON_HAND | wxOK, this);
1622
1623         return false;
1624     }
1625
1626     return true;
1627 }
1628
1629 void DnDShapeDialog::OnColour(wxCommandEvent& WXUNUSED(event))
1630 {
1631     wxColourData data;
1632     data.SetChooseFull(true);
1633     for (int i = 0; i < 16; i++)
1634     {
1635         wxColour colour((unsigned char)(i*16), (unsigned char)(i*16), (unsigned char)(i*16));
1636         data.SetCustomColour(i, colour);
1637     }
1638
1639     wxColourDialog dialog(this, &data);
1640     if ( dialog.ShowModal() == wxID_OK )
1641     {
1642         m_col = dialog.GetColourData().GetColour();
1643     }
1644 }
1645
1646 // ----------------------------------------------------------------------------
1647 // DnDShapeFrame
1648 // ----------------------------------------------------------------------------
1649
1650 DnDShapeFrame *DnDShapeFrame::ms_lastDropTarget = NULL;
1651
1652 DnDShapeFrame::DnDShapeFrame(wxFrame *parent)
1653              : wxFrame(parent, wxID_ANY, _T("Shape Frame"))
1654 {
1655 #if wxUSE_STATUSBAR
1656     CreateStatusBar();
1657 #endif // wxUSE_STATUSBAR
1658
1659     wxMenu *menuShape = new wxMenu;
1660     menuShape->Append(Menu_Shape_New, _T("&New default shape\tCtrl-S"));
1661     menuShape->Append(Menu_Shape_Edit, _T("&Edit shape\tCtrl-E"));
1662     menuShape->AppendSeparator();
1663     menuShape->Append(Menu_Shape_Clear, _T("&Clear shape\tCtrl-L"));
1664
1665     wxMenu *menuClipboard = new wxMenu;
1666     menuClipboard->Append(Menu_ShapeClipboard_Copy, _T("&Copy\tCtrl-C"));
1667     menuClipboard->Append(Menu_ShapeClipboard_Paste, _T("&Paste\tCtrl-V"));
1668
1669     wxMenuBar *menubar = new wxMenuBar;
1670     menubar->Append(menuShape, _T("&Shape"));
1671     menubar->Append(menuClipboard, _T("&Clipboard"));
1672
1673     SetMenuBar(menubar);
1674
1675 #if wxUSE_STATUSBAR
1676     SetStatusText(_T("Press Ctrl-S to create a new shape"));
1677 #endif // wxUSE_STATUSBAR
1678
1679     SetDropTarget(new DnDShapeDropTarget(this));
1680
1681     m_shape = NULL;
1682
1683     SetBackgroundColour(*wxWHITE);
1684 }
1685
1686 DnDShapeFrame::~DnDShapeFrame()
1687 {
1688     if (m_shape)
1689         delete m_shape;
1690 }
1691
1692 void DnDShapeFrame::SetShape(DnDShape *shape)
1693 {
1694     if (m_shape)
1695         delete m_shape;
1696     m_shape = shape;
1697     Refresh();
1698 }
1699
1700 // callbacks
1701 void DnDShapeFrame::OnDrag(wxMouseEvent& event)
1702 {
1703     if ( !m_shape )
1704     {
1705         event.Skip();
1706
1707         return;
1708     }
1709
1710     // start drag operation
1711     DnDShapeDataObject shapeData(m_shape);
1712     wxDropSource source(shapeData, this);
1713
1714     const wxChar *pc = NULL;
1715     switch ( source.DoDragDrop(true) )
1716     {
1717         default:
1718         case wxDragError:
1719             wxLogError(wxT("An error occurred during drag and drop operation"));
1720             break;
1721
1722         case wxDragNone:
1723 #if wxUSE_STATUSBAR
1724             SetStatusText(_T("Nothing happened"));
1725 #endif // wxUSE_STATUSBAR
1726             break;
1727
1728         case wxDragCopy:
1729             pc = _T("copied");
1730             break;
1731
1732         case wxDragMove:
1733             pc = _T("moved");
1734             if ( ms_lastDropTarget != this )
1735             {
1736                 // don't delete the shape if we dropped it on ourselves!
1737                 SetShape(NULL);
1738             }
1739             break;
1740
1741         case wxDragCancel:
1742 #if wxUSE_STATUSBAR
1743             SetStatusText(_T("Drag and drop operation cancelled"));
1744 #endif // wxUSE_STATUSBAR
1745             break;
1746     }
1747
1748     if ( pc )
1749     {
1750 #if wxUSE_STATUSBAR
1751         SetStatusText(wxString(_T("Shape successfully ")) + pc);
1752 #endif // wxUSE_STATUSBAR
1753     }
1754     //else: status text already set
1755 }
1756
1757 void DnDShapeFrame::OnDrop(wxCoord x, wxCoord y, DnDShape *shape)
1758 {
1759     ms_lastDropTarget = this;
1760
1761     wxPoint pt(x, y);
1762
1763 #if wxUSE_STATUSBAR
1764     wxString s;
1765     s.Printf(wxT("Shape dropped at (%d, %d)"), pt.x, pt.y);
1766     SetStatusText(s);
1767 #endif // wxUSE_STATUSBAR
1768
1769     shape->Move(pt);
1770     SetShape(shape);
1771 }
1772
1773 void DnDShapeFrame::OnEditShape(wxCommandEvent& WXUNUSED(event))
1774 {
1775     DnDShapeDialog dlg(this, m_shape);
1776     if ( dlg.ShowModal() == wxID_OK )
1777     {
1778         SetShape(dlg.GetShape());
1779
1780 #if wxUSE_STATUSBAR
1781         if ( m_shape )
1782         {
1783             SetStatusText(_T("You can now drag the shape to another frame"));
1784         }
1785 #endif // wxUSE_STATUSBAR
1786     }
1787 }
1788
1789 void DnDShapeFrame::OnNewShape(wxCommandEvent& WXUNUSED(event))
1790 {
1791     SetShape(new DnDEllipticShape(wxPoint(10, 10), wxSize(80, 60), *wxRED));
1792
1793 #if wxUSE_STATUSBAR
1794     SetStatusText(_T("You can now drag the shape to another frame"));
1795 #endif // wxUSE_STATUSBAR
1796 }
1797
1798 void DnDShapeFrame::OnClearShape(wxCommandEvent& WXUNUSED(event))
1799 {
1800     SetShape(NULL);
1801 }
1802
1803 void DnDShapeFrame::OnCopyShape(wxCommandEvent& WXUNUSED(event))
1804 {
1805     if ( m_shape )
1806     {
1807         wxClipboardLocker clipLocker;
1808         if ( !clipLocker )
1809         {
1810             wxLogError(wxT("Can't open the clipboard"));
1811
1812             return;
1813         }
1814
1815         wxTheClipboard->AddData(new DnDShapeDataObject(m_shape));
1816     }
1817 }
1818
1819 void DnDShapeFrame::OnPasteShape(wxCommandEvent& WXUNUSED(event))
1820 {
1821     wxClipboardLocker clipLocker;
1822     if ( !clipLocker )
1823     {
1824         wxLogError(wxT("Can't open the clipboard"));
1825
1826         return;
1827     }
1828
1829     DnDShapeDataObject shapeDataObject(NULL);
1830     if ( wxTheClipboard->GetData(shapeDataObject) )
1831     {
1832         SetShape(shapeDataObject.GetShape());
1833     }
1834     else
1835     {
1836         wxLogStatus(wxT("No shape on the clipboard"));
1837     }
1838 }
1839
1840 void DnDShapeFrame::OnUpdateUICopy(wxUpdateUIEvent& event)
1841 {
1842     event.Enable( m_shape != NULL );
1843 }
1844
1845 void DnDShapeFrame::OnUpdateUIPaste(wxUpdateUIEvent& event)
1846 {
1847     event.Enable( wxTheClipboard->IsSupported(wxDataFormat(shapeFormatId)) );
1848 }
1849
1850 void DnDShapeFrame::OnPaint(wxPaintEvent& event)
1851 {
1852     if ( m_shape )
1853     {
1854         wxPaintDC dc(this);
1855
1856         m_shape->Draw(dc);
1857     }
1858     else
1859     {
1860         event.Skip();
1861     }
1862 }
1863
1864 // ----------------------------------------------------------------------------
1865 // DnDShape
1866 // ----------------------------------------------------------------------------
1867
1868 DnDShape *DnDShape::New(const void *buf)
1869 {
1870     const ShapeDump& dump = *(const ShapeDump *)buf;
1871     switch ( dump.k )
1872     {
1873         case Triangle:
1874             return new DnDTriangularShape(wxPoint(dump.x, dump.y),
1875                                           wxSize(dump.w, dump.h),
1876                                           wxColour(dump.r, dump.g, dump.b));
1877
1878         case Rectangle:
1879             return new DnDRectangularShape(wxPoint(dump.x, dump.y),
1880                                            wxSize(dump.w, dump.h),
1881                                            wxColour(dump.r, dump.g, dump.b));
1882
1883         case Ellipse:
1884             return new DnDEllipticShape(wxPoint(dump.x, dump.y),
1885                                         wxSize(dump.w, dump.h),
1886                                         wxColour(dump.r, dump.g, dump.b));
1887
1888         default:
1889             wxFAIL_MSG(wxT("invalid shape!"));
1890             return NULL;
1891     }
1892 }
1893
1894 // ----------------------------------------------------------------------------
1895 // DnDShapeDataObject
1896 // ----------------------------------------------------------------------------
1897
1898 #if wxUSE_METAFILE
1899
1900 void DnDShapeDataObject::CreateMetaFile() const
1901 {
1902     wxPoint pos = m_shape->GetPosition();
1903     wxSize size = m_shape->GetSize();
1904
1905     wxMetaFileDC dcMF(wxEmptyString, pos.x + size.x, pos.y + size.y);
1906
1907     m_shape->Draw(dcMF);
1908
1909     wxMetafile *mf = dcMF.Close();
1910
1911     DnDShapeDataObject *self = (DnDShapeDataObject *)this; // const_cast
1912     self->m_dobjMetaFile.SetMetafile(*mf);
1913     self->m_hasMetaFile = true;
1914
1915     delete mf;
1916 }
1917
1918 #endif // wxUSE_METAFILE
1919
1920 void DnDShapeDataObject::CreateBitmap() const
1921 {
1922     wxPoint pos = m_shape->GetPosition();
1923     wxSize size = m_shape->GetSize();
1924     int x = pos.x + size.x,
1925         y = pos.y + size.y;
1926     wxBitmap bitmap(x, y);
1927     wxMemoryDC dc;
1928     dc.SelectObject(bitmap);
1929     dc.SetBrush(wxBrush(wxT("white"), wxSOLID));
1930     dc.Clear();
1931     m_shape->Draw(dc);
1932     dc.SelectObject(wxNullBitmap);
1933
1934     DnDShapeDataObject *self = (DnDShapeDataObject *)this; // const_cast
1935     self->m_dobjBitmap.SetBitmap(bitmap);
1936     self->m_hasBitmap = true;
1937 }
1938
1939 #endif // wxUSE_DRAG_AND_DROP
1940
1941 // ----------------------------------------------------------------------------
1942 // global functions
1943 // ----------------------------------------------------------------------------
1944
1945 static void ShowBitmap(const wxBitmap& bitmap)
1946 {
1947     wxFrame *frame = new wxFrame(NULL, wxID_ANY, _T("Bitmap view"));
1948 #if wxUSE_STATUSBAR
1949     frame->CreateStatusBar();
1950 #endif // wxUSE_STATUSBAR
1951     DnDCanvasBitmap *canvas = new DnDCanvasBitmap(frame);
1952     canvas->SetBitmap(bitmap);
1953
1954     int w = bitmap.GetWidth(),
1955         h = bitmap.GetHeight();
1956 #if wxUSE_STATUSBAR
1957     frame->SetStatusText(wxString::Format(_T("%dx%d"), w, h));
1958 #endif // wxUSE_STATUSBAR
1959
1960     frame->SetClientSize(w > 100 ? 100 : w, h > 100 ? 100 : h);
1961     frame->Show(true);
1962 }
1963
1964 #if wxUSE_METAFILE
1965
1966 static void ShowMetaFile(const wxMetaFile& metafile)
1967 {
1968     wxFrame *frame = new wxFrame(NULL, wxID_ANY, _T("Metafile view"));
1969     frame->CreateStatusBar();
1970     DnDCanvasMetafile *canvas = new DnDCanvasMetafile(frame);
1971     canvas->SetMetafile(metafile);
1972
1973     wxSize size = metafile.GetSize();
1974     frame->SetStatusText(wxString::Format(_T("%dx%d"), size.x, size.y));
1975
1976     frame->SetClientSize(size.x > 100 ? 100 : size.x,
1977                          size.y > 100 ? 100 : size.y);
1978     frame->Show();
1979 }
1980
1981 #endif // wxUSE_METAFILE
1982
1983 #endif // wxUSE_DRAG_AND_DROP || wxUSE_CLIPBOARD