projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wxUSE_LOG fixes and sizer adjustements related to positioning with/without LOG output.
[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 "mondrian.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 int x, y, // position
349 w, h, // size
350 r, g, b, // colour
351 k; // kind
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(mondrian));
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 *m_sizer_top = new wxBoxSizer( wxHORIZONTAL );
1015 m_sizer_top->Add(m_ctrlFile, 1, wxEXPAND );
1016 m_sizer_top->Add(m_ctrlText, 1, wxEXPAND );
1017
1018 wxBoxSizer *m_sizer = new wxBoxSizer( wxVERTICAL );
1019 m_sizer->Add(m_sizer_top, 1, wxEXPAND );
1020 #if wxUSE_LOG
1021 m_sizer->Add(m_ctrlLog, 1, wxEXPAND);
1022 #endif // wxUSE_LOG
1023 m_sizer->Add(0,50);
1024
1025 SetSizer( m_sizer );
1026 m_sizer->SetSizeHints( this );
1027
1028 // copy data by default but allow moving it as well
1029 m_moveByDefault = false;
1030 m_moveAllow = true;
1031 menu_bar->Check(Menu_DragMoveAllow, true);
1032 }
1033
1034 void DnDFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
1035 {
1036 Close(true);
1037 }
1038
1039 void DnDFrame::OnSize(wxSizeEvent& event)
1040 {
1041 Refresh();
1042
1043 event.Skip();
1044 }
1045
1046 void DnDFrame::OnPaint(wxPaintEvent& WXUNUSED(event))
1047 {
1048 int w = 0;
1049 int h = 0;
1050 GetClientSize( &w, &h );
1051
1052 wxPaintDC dc(this);
1053 // dc.Clear(); -- this kills wxGTK
1054 dc.SetFont( wxFont( 24, wxDECORATIVE, wxNORMAL, wxNORMAL, false, _T("charter") ) );
1055 dc.DrawText( _T("Drag text from here!"), 100, h-50 );
1056 }
1057
1058 void DnDFrame::OnUpdateUIMoveByDefault(wxUpdateUIEvent& event)
1059 {
1060 // only can move by default if moving is allowed at all
1061 event.Enable(m_moveAllow);
1062 }
1063
1064 void DnDFrame::OnUpdateUIPasteText(wxUpdateUIEvent& event)
1065 {
1066 #ifdef __WXDEBUG__
1067 // too many trace messages if we don't do it - this function is called
1068 // very often
1069 wxLogNull nolog;
1070 #endif
1071
1072 event.Enable( wxTheClipboard->IsSupported(wxDF_TEXT) );
1073 }
1074
1075 void DnDFrame::OnUpdateUIPasteBitmap(wxUpdateUIEvent& event)
1076 {
1077 #ifdef __WXDEBUG__
1078 // too many trace messages if we don't do it - this function is called
1079 // very often
1080 wxLogNull nolog;
1081 #endif
1082
1083 event.Enable( wxTheClipboard->IsSupported(wxDF_BITMAP) );
1084 }
1085
1086 void DnDFrame::OnNewFrame(wxCommandEvent& WXUNUSED(event))
1087 {
1088 #if wxUSE_DRAG_AND_DROP
1089 (new DnDShapeFrame(this))->Show(true);
1090
1091 wxLogStatus(this, wxT("Double click the new frame to select a shape for it"));
1092 #endif // wxUSE_DRAG_AND_DROP
1093 }
1094
1095 void DnDFrame::OnDrag(wxCommandEvent& WXUNUSED(event))
1096 {
1097 #if wxUSE_DRAG_AND_DROP
1098 wxString strText = wxGetTextFromUser
1099 (
1100 _T("After you enter text in this dialog, press any mouse\n")
1101 _T("button in the bottom (empty) part of the frame and \n")
1102 _T("drag it anywhere - you will be in fact dragging the\n")
1103 _T("text object containing this text"),
1104 _T("Please enter some text"), m_strText, this
1105 );
1106
1107 m_strText = strText;
1108 #endif // wxUSE_DRAG_AND_DROP
1109 }
1110
1111 void DnDFrame::OnDragMoveByDefault(wxCommandEvent& event)
1112 {
1113 m_moveByDefault = event.IsChecked();
1114 }
1115
1116 void DnDFrame::OnDragMoveAllow(wxCommandEvent& event)
1117 {
1118 m_moveAllow = event.IsChecked();
1119 }
1120
1121 void DnDFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
1122 {
1123 wxMessageBox(_T("Drag-&-Drop Demo\n")
1124 _T("Please see \"Help|Help...\" for details\n")
1125 _T("Copyright (c) 1998 Vadim Zeitlin"),
1126 _T("About wxDnD"),
1127 wxICON_INFORMATION | wxOK,
1128 this);
1129 }
1130
1131 void DnDFrame::OnHelp(wxCommandEvent& /* event */)
1132 {
1133 wxMessageDialog dialog(this,
1134 _T("This small program demonstrates drag & drop support in wxWidgets. The program window\n")
1135 _T("consists of 3 parts: the bottom pane is for debug messages, so that you can see what's\n")
1136 _T("going on inside. The top part is split into 2 listboxes, the left one accepts files\n")
1137 _T("and the right one accepts text.\n")
1138 _T("\n")
1139 _T("To test wxDropTarget: open wordpad (write.exe), select some text in it and drag it to\n")
1140 _T("the right listbox (you'll notice the usual visual feedback, i.e. the cursor will change).\n")
1141 _T("Also, try dragging some files (you can select several at once) from Windows Explorer (or \n")
1142 _T("File Manager) to the left pane. Hold down Ctrl/Shift keys when you drop text (doesn't \n")
1143 _T("work with files) and see what changes.\n")
1144 _T("\n")
1145 _T("To test wxDropSource: just press any mouse button on the empty zone of the window and drag\n")
1146 _T("it to wordpad or any other droptarget accepting text (and of course you can just drag it\n")
1147 _T("to the right pane). Due to a lot of trace messages, the cursor might take some time to \n")
1148 _T("change, don't release the mouse button until it does. You can change the string being\n")
1149 _T("dragged in in \"File|Test drag...\" dialog.\n")
1150 _T("\n")
1151 _T("\n")
1152 _T("Please send all questions/bug reports/suggestions &c to \n")
1153 _T("Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>"),
1154 _T("wxDnD Help"));
1155
1156 dialog.ShowModal();
1157 }
1158
1159 #if wxUSE_LOG
1160 void DnDFrame::OnLogClear(wxCommandEvent& /* event */ )
1161 {
1162 m_ctrlLog->Clear();
1163 m_ctrlText->Clear();
1164 m_ctrlFile->Clear();
1165 }
1166 #endif // wxUSE_LOG
1167
1168 void DnDFrame::OnLeftDown(wxMouseEvent &WXUNUSED(event) )
1169 {
1170 #if wxUSE_DRAG_AND_DROP
1171 if ( !m_strText.IsEmpty() )
1172 {
1173 // start drag operation
1174 wxTextDataObject textData(m_strText);
1175 /*
1176 wxFileDataObject textData;
1177 textData.AddFile( "/file1.txt" );
1178 textData.AddFile( "/file2.txt" );
1179 */
1180 wxDropSource source(textData, this,
1181 wxDROP_ICON(dnd_copy),
1182 wxDROP_ICON(dnd_move),
1183 wxDROP_ICON(dnd_none));
1184
1185 int flags = 0;
1186 if ( m_moveByDefault )
1187 flags |= wxDrag_DefaultMove;
1188 else if ( m_moveAllow )
1189 flags |= wxDrag_AllowMove;
1190
1191 wxDragResult result = source.DoDragDrop(flags);
1192
1193 #if wxUSE_STATUSBAR
1194 const wxChar *pc;
1195 switch ( result )
1196 {
1197 case wxDragError: pc = _T("Error!"); break;
1198 case wxDragNone: pc = _T("Nothing"); break;
1199 case wxDragCopy: pc = _T("Copied"); break;
1200 case wxDragMove: pc = _T("Moved"); break;
1201 case wxDragCancel: pc = _T("Cancelled"); break;
1202 default: pc = _T("Huh?"); break;
1203 }
1204
1205 SetStatusText(wxString(_T("Drag result: ")) + pc);
1206 #else
1207 wxUnusedVar(result);
1208 #endif // wxUSE_STATUSBAR
1209 }
1210 #endif // wxUSE_DRAG_AND_DROP
1211 }
1212
1213 void DnDFrame::OnRightDown(wxMouseEvent &event )
1214 {
1215 wxMenu menu(_T("Dnd sample menu"));
1216
1217 menu.Append(Menu_Drag, _T("&Test drag..."));
1218 menu.AppendSeparator();
1219 menu.Append(Menu_About, _T("&About"));
1220
1221 PopupMenu( &menu, event.GetX(), event.GetY() );
1222 }
1223
1224 DnDFrame::~DnDFrame()
1225 {
1226 #if wxUSE_LOG
1227 if ( m_pLog != NULL ) {
1228 if ( wxLog::SetActiveTarget(m_pLogPrev) == m_pLog )
1229 delete m_pLog;
1230 }
1231 #endif // wxUSE_LOG
1232 }
1233
1234 // ---------------------------------------------------------------------------
1235 // bitmap clipboard
1236 // ---------------------------------------------------------------------------
1237
1238 void DnDFrame::OnCopyBitmap(wxCommandEvent& WXUNUSED(event))
1239 {
1240 // PNG support is not always compiled in under Windows, so use BMP there
1241 #if wxUSE_LIBPNG
1242 wxFileDialog dialog(this, _T("Open a PNG file"), _T(""), _T(""), _T("PNG files (*.png)|*.png"), 0);
1243 #else
1244 wxFileDialog dialog(this, _T("Open a BMP file"), _T(""), _T(""), _T("BMP files (*.bmp)|*.bmp"), 0);
1245 #endif
1246
1247 if (dialog.ShowModal() != wxID_OK)
1248 {
1249 wxLogMessage( _T("Aborted file open") );
1250 return;
1251 }
1252
1253 if (dialog.GetPath().IsEmpty())
1254 {
1255 wxLogMessage( _T("Returned empty string.") );
1256 return;
1257 }
1258
1259 if (!wxFileExists(dialog.GetPath()))
1260 {
1261 wxLogMessage( _T("File doesn't exist.") );
1262 return;
1263 }
1264
1265 wxImage image;
1266 image.LoadFile( dialog.GetPath(),
1267 #if wxUSE_LIBPNG
1268 wxBITMAP_TYPE_PNG
1269 #else
1270 wxBITMAP_TYPE_BMP
1271 #endif
1272 );
1273 if (!image.Ok())
1274 {
1275 wxLogError( _T("Invalid image file...") );
1276 return;
1277 }
1278
1279 wxLogStatus( _T("Decoding image file...") );
1280 wxYield();
1281
1282 wxBitmap bitmap( image );
1283
1284 if ( !wxTheClipboard->Open() )
1285 {
1286 wxLogError(_T("Can't open clipboard."));
1287
1288 return;
1289 }
1290
1291 wxLogMessage( _T("Creating wxBitmapDataObject...") );
1292 wxYield();
1293
1294 if ( !wxTheClipboard->AddData(new wxBitmapDataObject(bitmap)) )
1295 {
1296 wxLogError(_T("Can't copy image to the clipboard."));
1297 }
1298 else
1299 {
1300 wxLogMessage(_T("Image has been put on the clipboard.") );
1301 wxLogMessage(_T("You can paste it now and look at it.") );
1302 }
1303
1304 wxTheClipboard->Close();
1305 }
1306
1307 void DnDFrame::OnPasteBitmap(wxCommandEvent& WXUNUSED(event))
1308 {
1309 if ( !wxTheClipboard->Open() )
1310 {
1311 wxLogError(_T("Can't open clipboard."));
1312
1313 return;
1314 }
1315
1316 if ( !wxTheClipboard->IsSupported(wxDF_BITMAP) )
1317 {
1318 wxLogWarning(_T("No bitmap on clipboard"));
1319
1320 wxTheClipboard->Close();
1321 return;
1322 }
1323
1324 wxBitmapDataObject data;
1325 if ( !wxTheClipboard->GetData(data) )
1326 {
1327 wxLogError(_T("Can't paste bitmap from the clipboard"));
1328 }
1329 else
1330 {
1331 const wxBitmap& bmp = data.GetBitmap();
1332
1333 wxLogMessage(_T("Bitmap %dx%d pasted from the clipboard"),
1334 bmp.GetWidth(), bmp.GetHeight());
1335 ShowBitmap(bmp);
1336 }
1337
1338 wxTheClipboard->Close();
1339 }
1340
1341 #if wxUSE_METAFILES
1342
1343 void DnDFrame::OnPasteMetafile(wxCommandEvent& WXUNUSED(event))
1344 {
1345 if ( !wxTheClipboard->Open() )
1346 {
1347 wxLogError(_T("Can't open clipboard."));
1348
1349 return;
1350 }
1351
1352 if ( !wxTheClipboard->IsSupported(wxDF_METAFILE) )
1353 {
1354 wxLogWarning(_T("No metafile on clipboard"));
1355 }
1356 else
1357 {
1358 wxMetaFileDataObject data;
1359 if ( !wxTheClipboard->GetData(data) )
1360 {
1361 wxLogError(_T("Can't paste metafile from the clipboard"));
1362 }
1363 else
1364 {
1365 const wxMetaFile& mf = data.GetMetafile();
1366
1367 wxLogMessage(_T("Metafile %dx%d pasted from the clipboard"),
1368 mf.GetWidth(), mf.GetHeight());
1369
1370 ShowMetaFile(mf);
1371 }
1372 }
1373
1374 wxTheClipboard->Close();
1375 }
1376
1377 #endif // wxUSE_METAFILES
1378
1379 // ----------------------------------------------------------------------------
1380 // file clipboard
1381 // ----------------------------------------------------------------------------
1382
1383 void DnDFrame::OnCopyFiles(wxCommandEvent& WXUNUSED(event))
1384 {
1385 #ifdef __WXMSW__
1386 wxFileDialog dialog(this, _T("Select a file to copy"), _T(""), _T(""),
1387 _T("All files (*.*)|*.*"), 0);
1388
1389 wxArrayString filenames;
1390 while ( dialog.ShowModal() == wxID_OK )
1391 {
1392 filenames.Add(dialog.GetPath());
1393 }
1394
1395 if ( !filenames.IsEmpty() )
1396 {
1397 wxFileDataObject *dobj = new wxFileDataObject;
1398 size_t count = filenames.GetCount();
1399 for ( size_t n = 0; n < count; n++ )
1400 {
1401 dobj->AddFile(filenames[n]);
1402 }
1403
1404 wxClipboardLocker locker;
1405 if ( !locker )
1406 {
1407 wxLogError(wxT("Can't open clipboard"));
1408 }
1409 else
1410 {
1411 if ( !wxTheClipboard->AddData(dobj) )
1412 {
1413 wxLogError(wxT("Can't copy file(s) to the clipboard"));
1414 }
1415 else
1416 {
1417 wxLogStatus(this, wxT("%d file%s copied to the clipboard"),
1418 count, count == 1 ? wxT("") : wxT("s"));
1419 }
1420 }
1421 }
1422 else
1423 {
1424 wxLogStatus(this, wxT("Aborted"));
1425 }
1426 #else // !MSW
1427 wxLogError(wxT("Sorry, not implemented"));
1428 #endif // MSW/!MSW
1429 }
1430
1431 // ---------------------------------------------------------------------------
1432 // text clipboard
1433 // ---------------------------------------------------------------------------
1434
1435 void DnDFrame::OnCopy(wxCommandEvent& WXUNUSED(event))
1436 {
1437 if ( !wxTheClipboard->Open() )
1438 {
1439 wxLogError(_T("Can't open clipboard."));
1440
1441 return;
1442 }
1443
1444 if ( !wxTheClipboard->AddData(new wxTextDataObject(m_strText)) )
1445 {
1446 wxLogError(_T("Can't copy data to the clipboard"));
1447 }
1448 else
1449 {
1450 wxLogMessage(_T("Text '%s' put on the clipboard"), m_strText.c_str());
1451 }
1452
1453 wxTheClipboard->Close();
1454 }
1455
1456 void DnDFrame::OnPaste(wxCommandEvent& WXUNUSED(event))
1457 {
1458 if ( !wxTheClipboard->Open() )
1459 {
1460 wxLogError(_T("Can't open clipboard."));
1461
1462 return;
1463 }
1464
1465 if ( !wxTheClipboard->IsSupported(wxDF_TEXT) )
1466 {
1467 wxLogWarning(_T("No text data on clipboard"));
1468
1469 wxTheClipboard->Close();
1470 return;
1471 }
1472
1473 wxTextDataObject text;
1474 if ( !wxTheClipboard->GetData(text) )
1475 {
1476 wxLogError(_T("Can't paste data from the clipboard"));
1477 }
1478 else
1479 {
1480 wxLogMessage(_T("Text '%s' pasted from the clipboard"),
1481 text.GetText().c_str());
1482 }
1483
1484 wxTheClipboard->Close();
1485 }
1486
1487 #if wxUSE_DRAG_AND_DROP
1488
1489 // ----------------------------------------------------------------------------
1490 // Notifications called by the base class
1491 // ----------------------------------------------------------------------------
1492
1493 bool DnDText::OnDropText(wxCoord, wxCoord, const wxString& text)
1494 {
1495 m_pOwner->Append(text);
1496
1497 return true;
1498 }
1499
1500 bool DnDFile::OnDropFiles(wxCoord, wxCoord, const wxArrayString& filenames)
1501 {
1502 size_t nFiles = filenames.GetCount();
1503 wxString str;
1504 str.Printf( _T("%d files dropped"), (int)nFiles);
1505 m_pOwner->Append(str);
1506 for ( size_t n = 0; n < nFiles; n++ ) {
1507 m_pOwner->Append(filenames[n]);
1508 }
1509
1510 return true;
1511 }
1512
1513 // ----------------------------------------------------------------------------
1514 // DnDShapeDialog
1515 // ----------------------------------------------------------------------------
1516
1517 DnDShapeDialog::DnDShapeDialog(wxFrame *parent, DnDShape *shape)
1518 :wxDialog( parent, 6001, wxT("Choose Shape"), wxPoint( 10, 10 ),
1519 wxSize( 40, 40 ),
1520 wxRAISED_BORDER|wxCAPTION|wxTHICK_FRAME|wxSYSTEM_MENU )
1521 {
1522 m_shape = shape;
1523 wxBoxSizer* topSizer = new wxBoxSizer( wxVERTICAL );
1524
1525 // radio box
1526 wxBoxSizer* shapesSizer = new wxBoxSizer( wxHORIZONTAL );
1527 const wxString choices[] = { wxT("None"), wxT("Triangle"),
1528 wxT("Rectangle"), wxT("Ellipse") };
1529
1530 m_radio = new wxRadioBox( this, wxID_ANY, wxT("&Shape"),
1531 wxDefaultPosition, wxDefaultSize, 4, choices, 4,
1532 wxRA_SPECIFY_COLS );
1533 shapesSizer->Add( m_radio, 0, wxGROW|wxALL, 5 );
1534 topSizer->Add( shapesSizer, 0, wxALL, 2 );
1535
1536 // attributes
1537 wxStaticBox* box = new wxStaticBox( this, wxID_ANY, wxT("&Attributes") );
1538 wxStaticBoxSizer* attrSizer = new wxStaticBoxSizer( box, wxHORIZONTAL );
1539 wxFlexGridSizer* xywhSizer = new wxFlexGridSizer( 4, 2 );
1540
1541 wxStaticText* st;
1542
1543 st = new wxStaticText( this, wxID_ANY, wxT("Position &X:") );
1544 m_textX = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition,
1545 wxSize( 30, 20 ) );
1546 xywhSizer->Add( st, 1, wxGROW|wxALL, 2 );
1547 xywhSizer->Add( m_textX, 1, wxGROW|wxALL, 2 );
1548
1549 st = new wxStaticText( this, wxID_ANY, wxT("Size &width:") );
1550 m_textW = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition,
1551 wxSize( 30, 20 ) );
1552 xywhSizer->Add( st, 1, wxGROW|wxALL, 2 );
1553 xywhSizer->Add( m_textW, 1, wxGROW|wxALL, 2 );
1554
1555 st = new wxStaticText( this, wxID_ANY, wxT("&Y:") );
1556 m_textY = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition,
1557 wxSize( 30, 20 ) );
1558 xywhSizer->Add( st, 1, wxALL|wxALIGN_RIGHT, 2 );
1559 xywhSizer->Add( m_textY, 1, wxGROW|wxALL, 2 );
1560
1561 st = new wxStaticText( this, wxID_ANY, wxT("&height:") );
1562 m_textH = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition,
1563 wxSize( 30, 20 ) );
1564 xywhSizer->Add( st, 1, wxALL|wxALIGN_RIGHT, 2 );
1565 xywhSizer->Add( m_textH, 1, wxGROW|wxALL, 2 );
1566
1567 wxButton* col = new wxButton( this, Button_Colour, wxT("&Colour...") );
1568 attrSizer->Add( xywhSizer, 1, wxGROW );
1569 attrSizer->Add( col, 0, wxALL|wxALIGN_CENTRE_VERTICAL, 2 );
1570 topSizer->Add( attrSizer, 0, wxGROW|wxALL, 5 );
1571
1572 // buttons
1573 wxBoxSizer* buttonSizer = new wxBoxSizer( wxHORIZONTAL );
1574 wxButton* bt;
1575 bt = new wxButton( this, wxID_OK, wxT("Ok") );
1576 buttonSizer->Add( bt, 0, wxALL, 2 );
1577 bt = new wxButton( this, wxID_CANCEL, wxT("Cancel") );
1578 buttonSizer->Add( bt, 0, wxALL, 2 );
1579 topSizer->Add( buttonSizer, 0, wxALL|wxALIGN_RIGHT, 2 );
1580
1581 SetSizer( topSizer );
1582 topSizer->Fit( this );
1583 }
1584
1585 DnDShape *DnDShapeDialog::GetShape() const
1586 {
1587 switch ( m_shapeKind )
1588 {
1589 default:
1590 case DnDShape::None: return NULL;
1591 case DnDShape::Triangle: return new DnDTriangularShape(m_pos, m_size, m_col);
1592 case DnDShape::Rectangle: return new DnDRectangularShape(m_pos, m_size, m_col);
1593 case DnDShape::Ellipse: return new DnDEllipticShape(m_pos, m_size, m_col);
1594 }
1595 }
1596
1597 bool DnDShapeDialog::TransferDataToWindow()
1598 {
1599
1600 if ( m_shape )
1601 {
1602 m_radio->SetSelection(m_shape->GetKind());
1603 m_pos = m_shape->GetPosition();
1604 m_size = m_shape->GetSize();
1605 m_col = m_shape->GetColour();
1606 }
1607 else
1608 {
1609 m_radio->SetSelection(DnDShape::None);
1610 m_pos = wxPoint(1, 1);
1611 m_size = wxSize(100, 100);
1612 }
1613
1614 m_textX->SetValue(wxString() << m_pos.x);
1615 m_textY->SetValue(wxString() << m_pos.y);
1616 m_textW->SetValue(wxString() << m_size.x);
1617 m_textH->SetValue(wxString() << m_size.y);
1618
1619 return true;
1620 }
1621
1622 bool DnDShapeDialog::TransferDataFromWindow()
1623 {
1624 m_shapeKind = (DnDShape::Kind)m_radio->GetSelection();
1625
1626 m_pos.x = wxAtoi(m_textX->GetValue());
1627 m_pos.y = wxAtoi(m_textY->GetValue());
1628 m_size.x = wxAtoi(m_textW->GetValue());
1629 m_size.y = wxAtoi(m_textH->GetValue());
1630
1631 if ( !m_pos.x || !m_pos.y || !m_size.x || !m_size.y )
1632 {
1633 wxMessageBox(_T("All sizes and positions should be non null!"),
1634 _T("Invalid shape"), wxICON_HAND | wxOK, this);
1635
1636 return false;
1637 }
1638
1639 return true;
1640 }
1641
1642 void DnDShapeDialog::OnColour(wxCommandEvent& WXUNUSED(event))
1643 {
1644 wxColourData data;
1645 data.SetChooseFull(true);
1646 for (int i = 0; i < 16; i++)
1647 {
1648 wxColour colour(i*16, i*16, i*16);
1649 data.SetCustomColour(i, colour);
1650 }
1651
1652 wxColourDialog dialog(this, &data);
1653 if ( dialog.ShowModal() == wxID_OK )
1654 {
1655 m_col = dialog.GetColourData().GetColour();
1656 }
1657 }
1658
1659 // ----------------------------------------------------------------------------
1660 // DnDShapeFrame
1661 // ----------------------------------------------------------------------------
1662
1663 DnDShapeFrame *DnDShapeFrame::ms_lastDropTarget = NULL;
1664
1665 DnDShapeFrame::DnDShapeFrame(wxFrame *parent)
1666 : wxFrame(parent, wxID_ANY, _T("Shape Frame"))
1667 {
1668 #if wxUSE_STATUSBAR
1669 CreateStatusBar();
1670 #endif // wxUSE_STATUSBAR
1671
1672 wxMenu *menuShape = new wxMenu;
1673 menuShape->Append(Menu_Shape_New, _T("&New default shape\tCtrl-S"));
1674 menuShape->Append(Menu_Shape_Edit, _T("&Edit shape\tCtrl-E"));
1675 menuShape->AppendSeparator();
1676 menuShape->Append(Menu_Shape_Clear, _T("&Clear shape\tCtrl-L"));
1677
1678 wxMenu *menuClipboard = new wxMenu;
1679 menuClipboard->Append(Menu_ShapeClipboard_Copy, _T("&Copy\tCtrl-C"));
1680 menuClipboard->Append(Menu_ShapeClipboard_Paste, _T("&Paste\tCtrl-V"));
1681
1682 wxMenuBar *menubar = new wxMenuBar;
1683 menubar->Append(menuShape, _T("&Shape"));
1684 menubar->Append(menuClipboard, _T("&Clipboard"));
1685
1686 SetMenuBar(menubar);
1687
1688 #if wxUSE_STATUSBAR
1689 SetStatusText(_T("Press Ctrl-S to create a new shape"));
1690 #endif // wxUSE_STATUSBAR
1691
1692 SetDropTarget(new DnDShapeDropTarget(this));
1693
1694 m_shape = NULL;
1695
1696 SetBackgroundColour(*wxWHITE);
1697 }
1698
1699 DnDShapeFrame::~DnDShapeFrame()
1700 {
1701 if (m_shape)
1702 delete m_shape;
1703 }
1704
1705 void DnDShapeFrame::SetShape(DnDShape *shape)
1706 {
1707 if (m_shape)
1708 delete m_shape;
1709 m_shape = shape;
1710 Refresh();
1711 }
1712
1713 // callbacks
1714 void DnDShapeFrame::OnDrag(wxMouseEvent& event)
1715 {
1716 if ( !m_shape )
1717 {
1718 event.Skip();
1719
1720 return;
1721 }
1722
1723 // start drag operation
1724 DnDShapeDataObject shapeData(m_shape);
1725 wxDropSource source(shapeData, this);
1726
1727 const wxChar *pc = NULL;
1728 switch ( source.DoDragDrop(true) )
1729 {
1730 default:
1731 case wxDragError:
1732 wxLogError(wxT("An error occured during drag and drop operation"));
1733 break;
1734
1735 case wxDragNone:
1736 #if wxUSE_STATUSBAR
1737 SetStatusText(_T("Nothing happened"));
1738 #endif // wxUSE_STATUSBAR
1739 break;
1740
1741 case wxDragCopy:
1742 pc = _T("copied");
1743 break;
1744
1745 case wxDragMove:
1746 pc = _T("moved");
1747 if ( ms_lastDropTarget != this )
1748 {
1749 // don't delete the shape if we dropped it on ourselves!
1750 SetShape(NULL);
1751 }
1752 break;
1753
1754 case wxDragCancel:
1755 #if wxUSE_STATUSBAR
1756 SetStatusText(_T("Drag and drop operation cancelled"));
1757 #endif // wxUSE_STATUSBAR
1758 break;
1759 }
1760
1761 if ( pc )
1762 {
1763 #if wxUSE_STATUSBAR
1764 SetStatusText(wxString(_T("Shape successfully ")) + pc);
1765 #endif // wxUSE_STATUSBAR
1766 }
1767 //else: status text already set
1768 }
1769
1770 void DnDShapeFrame::OnDrop(wxCoord x, wxCoord y, DnDShape *shape)
1771 {
1772 ms_lastDropTarget = this;
1773
1774 wxPoint pt(x, y);
1775
1776 #if wxUSE_STATUSBAR
1777 wxString s;
1778 s.Printf(wxT("Shape dropped at (%d, %d)"), pt.x, pt.y);
1779 SetStatusText(s);
1780 #endif // wxUSE_STATUSBAR
1781
1782 shape->Move(pt);
1783 SetShape(shape);
1784 }
1785
1786 void DnDShapeFrame::OnEditShape(wxCommandEvent& WXUNUSED(event))
1787 {
1788 DnDShapeDialog dlg(this, m_shape);
1789 if ( dlg.ShowModal() == wxID_OK )
1790 {
1791 SetShape(dlg.GetShape());
1792
1793 #if wxUSE_STATUSBAR
1794 if ( m_shape )
1795 {
1796 SetStatusText(_T("You can now drag the shape to another frame"));
1797 }
1798 #endif // wxUSE_STATUSBAR
1799 }
1800 }
1801
1802 void DnDShapeFrame::OnNewShape(wxCommandEvent& WXUNUSED(event))
1803 {
1804 SetShape(new DnDEllipticShape(wxPoint(10, 10), wxSize(80, 60), *wxRED));
1805
1806 #if wxUSE_STATUSBAR
1807 SetStatusText(_T("You can now drag the shape to another frame"));
1808 #endif // wxUSE_STATUSBAR
1809 }
1810
1811 void DnDShapeFrame::OnClearShape(wxCommandEvent& WXUNUSED(event))
1812 {
1813 SetShape(NULL);
1814 }
1815
1816 void DnDShapeFrame::OnCopyShape(wxCommandEvent& WXUNUSED(event))
1817 {
1818 if ( m_shape )
1819 {
1820 wxClipboardLocker clipLocker;
1821 if ( !clipLocker )
1822 {
1823 wxLogError(wxT("Can't open the clipboard"));
1824
1825 return;
1826 }
1827
1828 wxTheClipboard->AddData(new DnDShapeDataObject(m_shape));
1829 }
1830 }
1831
1832 void DnDShapeFrame::OnPasteShape(wxCommandEvent& WXUNUSED(event))
1833 {
1834 wxClipboardLocker clipLocker;
1835 if ( !clipLocker )
1836 {
1837 wxLogError(wxT("Can't open the clipboard"));
1838
1839 return;
1840 }
1841
1842 DnDShapeDataObject shapeDataObject(NULL);
1843 if ( wxTheClipboard->GetData(shapeDataObject) )
1844 {
1845 SetShape(shapeDataObject.GetShape());
1846 }
1847 else
1848 {
1849 wxLogStatus(wxT("No shape on the clipboard"));
1850 }
1851 }
1852
1853 void DnDShapeFrame::OnUpdateUICopy(wxUpdateUIEvent& event)
1854 {
1855 event.Enable( m_shape != NULL );
1856 }
1857
1858 void DnDShapeFrame::OnUpdateUIPaste(wxUpdateUIEvent& event)
1859 {
1860 event.Enable( wxTheClipboard->IsSupported(wxDataFormat(shapeFormatId)) );
1861 }
1862
1863 void DnDShapeFrame::OnPaint(wxPaintEvent& event)
1864 {
1865 if ( m_shape )
1866 {
1867 wxPaintDC dc(this);
1868
1869 m_shape->Draw(dc);
1870 }
1871 else
1872 {
1873 event.Skip();
1874 }
1875 }
1876
1877 // ----------------------------------------------------------------------------
1878 // DnDShape
1879 // ----------------------------------------------------------------------------
1880
1881 DnDShape *DnDShape::New(const void *buf)
1882 {
1883 const ShapeDump& dump = *(const ShapeDump *)buf;
1884 switch ( dump.k )
1885 {
1886 case Triangle:
1887 return new DnDTriangularShape(wxPoint(dump.x, dump.y),
1888 wxSize(dump.w, dump.h),
1889 wxColour(dump.r, dump.g, dump.b));
1890
1891 case Rectangle:
1892 return new DnDRectangularShape(wxPoint(dump.x, dump.y),
1893 wxSize(dump.w, dump.h),
1894 wxColour(dump.r, dump.g, dump.b));
1895
1896 case Ellipse:
1897 return new DnDEllipticShape(wxPoint(dump.x, dump.y),
1898 wxSize(dump.w, dump.h),
1899 wxColour(dump.r, dump.g, dump.b));
1900
1901 default:
1902 wxFAIL_MSG(wxT("invalid shape!"));
1903 return NULL;
1904 }
1905 }
1906
1907 // ----------------------------------------------------------------------------
1908 // DnDShapeDataObject
1909 // ----------------------------------------------------------------------------
1910
1911 #if wxUSE_METAFILES
1912
1913 void DnDShapeDataObject::CreateMetaFile() const
1914 {
1915 wxPoint pos = m_shape->GetPosition();
1916 wxSize size = m_shape->GetSize();
1917
1918 wxMetaFileDC dcMF(wxEmptyString, pos.x + size.x, pos.y + size.y);
1919
1920 m_shape->Draw(dcMF);
1921
1922 wxMetafile *mf = dcMF.Close();
1923
1924 DnDShapeDataObject *self = (DnDShapeDataObject *)this; // const_cast
1925 self->m_dobjMetaFile.SetMetafile(*mf);
1926 self->m_hasMetaFile = true;
1927
1928 delete mf;
1929 }
1930
1931 #endif // wxUSE_METAFILES
1932
1933 void DnDShapeDataObject::CreateBitmap() const
1934 {
1935 wxPoint pos = m_shape->GetPosition();
1936 wxSize size = m_shape->GetSize();
1937 int x = pos.x + size.x,
1938 y = pos.y + size.y;
1939 wxBitmap bitmap(x, y);
1940 wxMemoryDC dc;
1941 dc.SelectObject(bitmap);
1942 dc.SetBrush(wxBrush(wxT("white"), wxSOLID));
1943 dc.Clear();
1944 m_shape->Draw(dc);
1945 dc.SelectObject(wxNullBitmap);
1946
1947 DnDShapeDataObject *self = (DnDShapeDataObject *)this; // const_cast
1948 self->m_dobjBitmap.SetBitmap(bitmap);
1949 self->m_hasBitmap = true;
1950 }
1951
1952 #endif // wxUSE_DRAG_AND_DROP
1953
1954 // ----------------------------------------------------------------------------
1955 // global functions
1956 // ----------------------------------------------------------------------------
1957
1958 static void ShowBitmap(const wxBitmap& bitmap)
1959 {
1960 wxFrame *frame = new wxFrame(NULL, wxID_ANY, _T("Bitmap view"));
1961 #if wxUSE_STATUSBAR
1962 frame->CreateStatusBar();
1963 #endif // wxUSE_STATUSBAR
1964 DnDCanvasBitmap *canvas = new DnDCanvasBitmap(frame);
1965 canvas->SetBitmap(bitmap);
1966
1967 int w = bitmap.GetWidth(),
1968 h = bitmap.GetHeight();
1969 #if wxUSE_STATUSBAR
1970 frame->SetStatusText(wxString::Format(_T("%dx%d"), w, h));
1971 #endif // wxUSE_STATUSBAR
1972
1973 frame->SetClientSize(w > 100 ? 100 : w, h > 100 ? 100 : h);
1974 frame->Show(true);
1975 }
1976
1977 #if wxUSE_METAFILES
1978
1979 static void ShowMetaFile(const wxMetaFile& metafile)
1980 {
1981 wxFrame *frame = new wxFrame(NULL, wxID_ANY, _T("Metafile view"));
1982 frame->CreateStatusBar();
1983 DnDCanvasMetafile *canvas = new DnDCanvasMetafile(frame);
1984 canvas->SetMetafile(metafile);
1985
1986 wxSize size = metafile.GetSize();
1987 frame->SetStatusText(wxString::Format(_T("%dx%d"), size.x, size.y));
1988
1989 frame->SetClientSize(size.x > 100 ? 100 : size.x,
1990 size.y > 100 ? 100 : size.y);
1991 frame->Show();
1992 }
1993
1994 #endif // wxUSE_METAFILES
1995
1996 #endif // wxUSE_DRAG_AND_DROP || wxUSE_CLIPBOARD
wxWidgets (Impactor)