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