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