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