]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk/dnd.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
renamed AddSubPage() with pos parameter to InsertSubPage()
[wxWidgets.git] / src / gtk / dnd.cpp
... / ...
CommitLineData
1///////////////////////////////////////////////////////////////////////////////
2// Name: dnd.cpp
3// Purpose: wxDropTarget class
4// Author: Robert Roebling
5// Id: $Id$
6// Copyright: (c) 1998 Robert Roebling
7// Licence: wxWindows licence
8///////////////////////////////////////////////////////////////////////////////
9
10// For compilers that support precompilation, includes "wx.h".
11#include "wx/wxprec.h"
12
13#include "wx/dnd.h"
14#include "wx/log.h"
15
16
17#if wxUSE_DRAG_AND_DROP
18
19#include "wx/window.h"
20#include "wx/app.h"
21#include "wx/gdicmn.h"
22#include "wx/intl.h"
23#include "wx/utils.h"
24
25#include "wx/gtk/private.h"
26
27#include <gdk/gdkprivate.h>
28
29#include <gtk/gtkdnd.h>
30#include <gtk/gtkselection.h>
31
32//-----------------------------------------------------------------------------
33// idle system
34//-----------------------------------------------------------------------------
35
36extern void wxapp_install_idle_handler();
37extern bool g_isIdle;
38
39//-----------------------------------------------------------------------------
40// thread system
41//-----------------------------------------------------------------------------
42
43#if wxUSE_THREADS
44#endif
45
46//----------------------------------------------------------------------------
47// global data
48//----------------------------------------------------------------------------
49
50extern bool g_blockEventsOnDrag;
51
52// the flags used for the last DoDragDrop()
53static long gs_flagsForDrag = 0;
54
55// the trace mask we use with wxLogTrace() - call
56// wxLog::AddTraceMask(TRACE_DND) to enable the trace messages from here
57// (there are quite a few of them, so don't enable this by default)
58static const wxChar *TRACE_DND = _T("dnd");
59
60//----------------------------------------------------------------------------
61// standard icons
62//----------------------------------------------------------------------------
63
64/* Copyright (c) Julian Smart */
65static const char * page_xpm[] = {
66/* columns rows colors chars-per-pixel */
67"32 32 37 1",
68"5 c #7198D9",
69", c #769CDA",
70"2 c #DCE6F6",
71"i c #FFFFFF",
72"e c #779DDB",
73": c #9AB6E4",
74"9 c #EAF0FA",
75"- c #B1C7EB",
76"$ c #6992D7",
77"y c #F7F9FD",
78"= c #BED0EE",
79"q c #F0F5FC",
80"; c #A8C0E8",
81"@ c #366BC2",
82" c None",
83"u c #FDFEFF",
84"8 c #5987D3",
85"* c #C4D5F0",
86"7 c #7CA0DC",
87"O c #487BCE",
88"< c #6B94D7",
89"& c #CCDAF2",
90"> c #89A9DF",
91"3 c #5584D1",
92"w c #82A5DE",
93"1 c #3F74CB",
94"+ c #3A70CA",
95". c #3569BF",
96"% c #D2DFF4",
97"# c #3366BB",
98"r c #F5F8FD",
99"0 c #FAFCFE",
100"4 c #DFE8F7",
101"X c #5E8AD4",
102"o c #5282D0",
103"t c #B8CCEC",
104"6 c #E5EDF9",
105/* pixels */
106" ",
107" ",
108" ",
109" ",
110" ",
111" .XXXooOO++@# ",
112" $%&*=-;::>,<1 ",
113" $2%&*=-;::><:3 ",
114" $42%&*=-;::<&:3 ",
115" 56477<<<<8<<9&:X ",
116" 59642%&*=-;<09&:5 ",
117" 5q9642%&*=-<<<<<# ",
118" 5qqw777<<<<<88:>+ ",
119" erqq9642%&*=t;::+ ",
120" eyrqq9642%&*=t;:O ",
121" eyywwww777<<<<t;O ",
122" e0yyrqq9642%&*=to ",
123" e00yyrqq9642%&*=o ",
124" eu0wwwwwww777<&*X ",
125" euu00yyrqq9642%&X ",
126" eiuu00yyrqq9642%X ",
127" eiiwwwwwwwwww742$ ",
128" eiiiuu00yyrqq964$ ",
129" eiiiiuu00yyrqq96$ ",
130" eiiiiiuu00yyrqq95 ",
131" eiiiiiiuu00yyrqq5 ",
132" eeeeeeeeeeeeee55e ",
133" ",
134" ",
135" ",
136" ",
137" "
138};
139
140
141// ============================================================================
142// private functions
143// ============================================================================
144
145// ----------------------------------------------------------------------------
146// convert between GTK+ and wxWidgets DND constants
147// ----------------------------------------------------------------------------
148
149static wxDragResult ConvertFromGTK(long action)
150{
151 switch ( action )
152 {
153 case GDK_ACTION_COPY:
154 return wxDragCopy;
155
156 case GDK_ACTION_LINK:
157 return wxDragLink;
158
159 case GDK_ACTION_MOVE:
160 return wxDragMove;
161 }
162
163 return wxDragNone;
164}
165
166// ----------------------------------------------------------------------------
167// "drag_leave"
168// ----------------------------------------------------------------------------
169
170extern "C" {
171static void target_drag_leave( GtkWidget *WXUNUSED(widget),
172 GdkDragContext *context,
173 guint WXUNUSED(time),
174 wxDropTarget *drop_target )
175{
176 if (g_isIdle) wxapp_install_idle_handler();
177
178 /* inform the wxDropTarget about the current GdkDragContext.
179 this is only valid for the duration of this call */
180 drop_target->SetDragContext( context );
181
182 /* we don't need return values. this event is just for
183 information */
184 drop_target->OnLeave();
185
186 /* this has to be done because GDK has no "drag_enter" event */
187 drop_target->m_firstMotion = true;
188
189 /* after this, invalidate the drop_target's GdkDragContext */
190 drop_target->SetDragContext( (GdkDragContext*) NULL );
191}
192}
193
194// ----------------------------------------------------------------------------
195// "drag_motion"
196// ----------------------------------------------------------------------------
197
198extern "C" {
199static gboolean target_drag_motion( GtkWidget *WXUNUSED(widget),
200 GdkDragContext *context,
201 gint x,
202 gint y,
203 guint time,
204 wxDropTarget *drop_target )
205{
206 if (g_isIdle) wxapp_install_idle_handler();
207
208 /* Owen Taylor: "if the coordinates not in a drop zone,
209 return FALSE, otherwise call gtk_drag_status() and
210 return TRUE" */
211
212 /* inform the wxDropTarget about the current GdkDragContext.
213 this is only valid for the duration of this call */
214 drop_target->SetDragContext( context );
215
216 // GTK+ always supposes that we want to copy the data by default while we
217 // might want to move it, so examine not only suggested_action - which is
218 // only good if we don't have our own preferences - but also the actions
219 // field
220 wxDragResult result;
221 if (drop_target->GetDefaultAction() == wxDragNone)
222 {
223 // use default action set by wxDropSource::DoDragDrop()
224 if ( (gs_flagsForDrag & wxDrag_DefaultMove) == wxDrag_DefaultMove &&
225 (context->actions & GDK_ACTION_MOVE ) )
226 {
227 // move is requested by the program and allowed by GTK+ - do it, even
228 // though suggested_action may be currently wxDragCopy
229 result = wxDragMove;
230 }
231 else // use whatever GTK+ says we should
232 {
233 result = ConvertFromGTK(context->suggested_action);
234
235 if ( (result == wxDragMove) && !(gs_flagsForDrag & wxDrag_AllowMove) )
236 {
237 // we're requested to move but we can't
238 result = wxDragCopy;
239 }
240 }
241 }
242 else if (drop_target->GetDefaultAction() == wxDragMove &&
243 (context->actions & GDK_ACTION_MOVE))
244 {
245 result = wxDragMove;
246 }
247 else
248 {
249 if (context->actions & GDK_ACTION_COPY)
250 result = wxDragCopy;
251 else if (context->actions & GDK_ACTION_MOVE)
252 result = wxDragMove;
253 else
254 result = wxDragNone;
255 }
256
257 if (drop_target->m_firstMotion)
258 {
259 /* the first "drag_motion" event substitutes a "drag_enter" event */
260 result = drop_target->OnEnter( x, y, result );
261 }
262 else
263 {
264 /* give program a chance to react (i.e. to say no by returning FALSE) */
265 result = drop_target->OnDragOver( x, y, result );
266 }
267
268 bool ret = wxIsDragResultOk( result );
269 if (ret)
270 {
271 GdkDragAction action;
272 if (result == wxDragCopy)
273 action = GDK_ACTION_COPY;
274 else if (result == wxDragLink)
275 action = GDK_ACTION_LINK;
276 else
277 action = GDK_ACTION_MOVE;
278
279 gdk_drag_status( context, action, time );
280 }
281
282 /* after this, invalidate the drop_target's GdkDragContext */
283 drop_target->SetDragContext( (GdkDragContext*) NULL );
284
285 /* this has to be done because GDK has no "drag_enter" event */
286 drop_target->m_firstMotion = false;
287
288 return ret;
289}
290}
291
292// ----------------------------------------------------------------------------
293// "drag_drop"
294// ----------------------------------------------------------------------------
295
296extern "C" {
297static gboolean target_drag_drop( GtkWidget *widget,
298 GdkDragContext *context,
299 gint x,
300 gint y,
301 guint time,
302 wxDropTarget *drop_target )
303{
304 if (g_isIdle) wxapp_install_idle_handler();
305
306 /* Owen Taylor: "if the drop is not in a drop zone,
307 return FALSE, otherwise, if you aren't accepting
308 the drop, call gtk_drag_finish() with success == FALSE
309 otherwise call gtk_drag_data_get()" */
310
311// printf( "drop.\n" );
312
313 /* this seems to make a difference between not accepting
314 due to wrong target area and due to wrong format. let
315 us hope that this is not required.. */
316
317 /* inform the wxDropTarget about the current GdkDragContext.
318 this is only valid for the duration of this call */
319 drop_target->SetDragContext( context );
320
321 /* inform the wxDropTarget about the current drag widget.
322 this is only valid for the duration of this call */
323 drop_target->SetDragWidget( widget );
324
325 /* inform the wxDropTarget about the current drag time.
326 this is only valid for the duration of this call */
327 drop_target->SetDragTime( time );
328
329/*
330 wxDragResult result = wxDragMove;
331 if (context->suggested_action == GDK_ACTION_COPY) result = wxDragCopy;
332*/
333
334 /* reset the block here as someone might very well
335 show a dialog as a reaction to a drop and this
336 wouldn't work without events */
337 g_blockEventsOnDrag = false;
338
339 bool ret = drop_target->OnDrop( x, y );
340
341 if (!ret)
342 {
343 wxLogTrace(TRACE_DND, wxT( "Drop target: OnDrop returned FALSE") );
344
345 /* cancel the whole thing */
346 gtk_drag_finish( context,
347 FALSE, /* no success */
348 FALSE, /* don't delete data on dropping side */
349 time );
350 }
351 else
352 {
353 wxLogTrace(TRACE_DND, wxT( "Drop target: OnDrop returned TRUE") );
354
355#if wxUSE_THREADS
356 /* disable GUI threads */
357#endif
358
359 GdkAtom format = drop_target->GetMatchingPair();
360
361 // this does happen somehow, see bug 555111
362 wxCHECK_MSG( format, FALSE, _T("no matching GdkAtom for format?") )
363
364/*
365 GdkDragAction action = GDK_ACTION_MOVE;
366 if (result == wxDragCopy) action == GDK_ACTION_COPY;
367 context->action = action;
368*/
369 /* this should trigger an "drag_data_received" event */
370 gtk_drag_get_data( widget,
371 context,
372 format,
373 time );
374
375#if wxUSE_THREADS
376 /* re-enable GUI threads */
377#endif
378 }
379
380 /* after this, invalidate the drop_target's GdkDragContext */
381 drop_target->SetDragContext( (GdkDragContext*) NULL );
382
383 /* after this, invalidate the drop_target's drag widget */
384 drop_target->SetDragWidget( (GtkWidget*) NULL );
385
386 /* this has to be done because GDK has no "drag_enter" event */
387 drop_target->m_firstMotion = true;
388
389 return ret;
390}
391}
392
393// ----------------------------------------------------------------------------
394// "drag_data_received"
395// ----------------------------------------------------------------------------
396
397extern "C" {
398static void target_drag_data_received( GtkWidget *WXUNUSED(widget),
399 GdkDragContext *context,
400 gint x,
401 gint y,
402 GtkSelectionData *data,
403 guint WXUNUSED(info),
404 guint time,
405 wxDropTarget *drop_target )
406{
407 if (g_isIdle) wxapp_install_idle_handler();
408
409 /* Owen Taylor: "call gtk_drag_finish() with
410 success == TRUE" */
411
412 if ((data->length <= 0) || (data->format != 8))
413 {
414 /* negative data length and non 8-bit data format
415 qualifies for junk */
416 gtk_drag_finish (context, FALSE, FALSE, time);
417
418 return;
419 }
420
421 wxLogTrace(TRACE_DND, wxT( "Drop target: data received event") );
422
423 /* inform the wxDropTarget about the current GtkSelectionData.
424 this is only valid for the duration of this call */
425 drop_target->SetDragData( data );
426
427 wxDragResult result = ConvertFromGTK(context->action);
428
429 if ( wxIsDragResultOk( drop_target->OnData( x, y, result ) ) )
430 {
431 wxLogTrace(TRACE_DND, wxT( "Drop target: OnData returned TRUE") );
432
433 /* tell GTK that data transfer was successful */
434 gtk_drag_finish( context, TRUE, FALSE, time );
435 }
436 else
437 {
438 wxLogTrace(TRACE_DND, wxT( "Drop target: OnData returned FALSE") );
439
440 /* tell GTK that data transfer was not successful */
441 gtk_drag_finish( context, FALSE, FALSE, time );
442 }
443
444 /* after this, invalidate the drop_target's drag data */
445 drop_target->SetDragData( (GtkSelectionData*) NULL );
446}
447}
448
449//----------------------------------------------------------------------------
450// wxDropTarget
451//----------------------------------------------------------------------------
452
453wxDropTarget::wxDropTarget( wxDataObject *data )
454 : wxDropTargetBase( data )
455{
456 m_firstMotion = true;
457 m_dragContext = (GdkDragContext*) NULL;
458 m_dragWidget = (GtkWidget*) NULL;
459 m_dragData = (GtkSelectionData*) NULL;
460 m_dragTime = 0;
461}
462
463wxDragResult wxDropTarget::OnDragOver( wxCoord WXUNUSED(x),
464 wxCoord WXUNUSED(y),
465 wxDragResult def )
466{
467 // GetMatchingPair() checks for m_dataObject too, no need to do it here
468
469 // disable the debug message from GetMatchingPair() - there are too many
470 // of them otherwise
471#ifdef __WXDEBUG__
472 wxLogNull noLog;
473#endif // Debug
474
475 return (GetMatchingPair() != (GdkAtom) 0) ? def : wxDragNone;
476}
477
478bool wxDropTarget::OnDrop( wxCoord WXUNUSED(x), wxCoord WXUNUSED(y) )
479{
480 if (!m_dataObject)
481 return false;
482
483 return (GetMatchingPair() != (GdkAtom) 0);
484}
485
486wxDragResult wxDropTarget::OnData( wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
487 wxDragResult def )
488{
489 if (!m_dataObject)
490 return wxDragNone;
491
492 if (GetMatchingPair() == (GdkAtom) 0)
493 return wxDragNone;
494
495 return GetData() ? def : wxDragNone;
496}
497
498GdkAtom wxDropTarget::GetMatchingPair()
499{
500 if (!m_dataObject)
501 return (GdkAtom) 0;
502
503 if (!m_dragContext)
504 return (GdkAtom) 0;
505
506 GList *child = m_dragContext->targets;
507 while (child)
508 {
509 GdkAtom formatAtom = (GdkAtom)(child->data);
510 wxDataFormat format( formatAtom );
511
512#ifdef __WXDEBUG__
513 wxLogTrace(TRACE_DND, wxT("Drop target: drag has format: %s"),
514 format.GetId().c_str());
515#endif // Debug
516
517 if (m_dataObject->IsSupportedFormat( format ))
518 return formatAtom;
519
520 child = child->next;
521 }
522
523 return (GdkAtom) 0;
524}
525
526bool wxDropTarget::GetData()
527{
528 if (!m_dragData)
529 return false;
530
531 if (!m_dataObject)
532 return false;
533
534 wxDataFormat dragFormat( m_dragData->target );
535
536 if (!m_dataObject->IsSupportedFormat( dragFormat ))
537 return false;
538
539 m_dataObject->SetData( dragFormat, (size_t)m_dragData->length, (const void*)m_dragData->data );
540
541 return true;
542}
543
544void wxDropTarget::UnregisterWidget( GtkWidget *widget )
545{
546 wxCHECK_RET( widget != NULL, wxT("unregister widget is NULL") );
547
548 gtk_drag_dest_unset( widget );
549
550 g_signal_handlers_disconnect_by_func (widget,
551 (gpointer) target_drag_leave, this);
552 g_signal_handlers_disconnect_by_func (widget,
553 (gpointer) target_drag_motion, this);
554 g_signal_handlers_disconnect_by_func (widget,
555 (gpointer) target_drag_drop, this);
556 g_signal_handlers_disconnect_by_func (widget,
557 (gpointer) target_drag_data_received, this);
558}
559
560void wxDropTarget::RegisterWidget( GtkWidget *widget )
561{
562 wxCHECK_RET( widget != NULL, wxT("register widget is NULL") );
563
564 /* gtk_drag_dest_set() determines what default behaviour we'd like
565 GTK to supply. we don't want to specify out targets (=formats)
566 or actions in advance (i.e. not GTK_DEST_DEFAULT_MOTION and
567 not GTK_DEST_DEFAULT_DROP). instead we react individually to
568 "drag_motion" and "drag_drop" events. this makes it possible
569 to allow dropping on only a small area. we should set
570 GTK_DEST_DEFAULT_HIGHLIGHT as this will switch on the nice
571 highlighting if dragging over standard controls, but this
572 seems to be broken without the other two. */
573
574 gtk_drag_dest_set( widget,
575 (GtkDestDefaults) 0, /* no default behaviour */
576 (GtkTargetEntry*) NULL, /* we don't supply any formats here */
577 0, /* number of targets = 0 */
578 (GdkDragAction) 0 ); /* we don't supply any actions here */
579
580 g_signal_connect (widget, "drag_leave",
581 G_CALLBACK (target_drag_leave), this);
582
583 g_signal_connect (widget, "drag_motion",
584 G_CALLBACK (target_drag_motion), this);
585
586 g_signal_connect (widget, "drag_drop",
587 G_CALLBACK (target_drag_drop), this);
588
589 g_signal_connect (widget, "drag_data_received",
590 G_CALLBACK (target_drag_data_received), this);
591}
592
593//----------------------------------------------------------------------------
594// "drag_data_get"
595//----------------------------------------------------------------------------
596
597extern "C" {
598static void
599source_drag_data_get (GtkWidget *WXUNUSED(widget),
600 GdkDragContext *WXUNUSED(context),
601 GtkSelectionData *selection_data,
602 guint WXUNUSED(info),
603 guint WXUNUSED(time),
604 wxDropSource *drop_source )
605{
606 if (g_isIdle) wxapp_install_idle_handler();
607
608 wxDataFormat format( selection_data->target );
609
610 wxLogTrace(TRACE_DND, wxT("Drop source: format requested: %s"),
611 format.GetId().c_str());
612
613 drop_source->m_retValue = wxDragCancel;
614
615 wxDataObject *data = drop_source->GetDataObject();
616
617 if (!data)
618 {
619 wxLogTrace(TRACE_DND, wxT("Drop source: no data object") );
620 return;
621 }
622
623 if (!data->IsSupportedFormat(format))
624 {
625 wxLogTrace(TRACE_DND, wxT("Drop source: unsupported format") );
626 return;
627 }
628
629 if (data->GetDataSize(format) == 0)
630 {
631 wxLogTrace(TRACE_DND, wxT("Drop source: empty data") );
632 return;
633 }
634
635 size_t size = data->GetDataSize(format);
636
637// printf( "data size: %d.\n", (int)data_size );
638
639 guchar *d = new guchar[size];
640
641 if (!data->GetDataHere( format, (void*)d ))
642 {
643 delete[] d;
644 return;
645 }
646
647#if wxUSE_THREADS
648 /* disable GUI threads */
649#endif
650
651 gtk_selection_data_set( selection_data,
652 selection_data->target,
653 8, // 8-bit
654 d,
655 size );
656
657#if wxUSE_THREADS
658 /* enable GUI threads */
659#endif
660
661 delete[] d;
662}
663}
664
665//----------------------------------------------------------------------------
666// "drag_data_delete"
667//----------------------------------------------------------------------------
668
669extern "C" {
670static void source_drag_data_delete( GtkWidget *WXUNUSED(widget),
671 GdkDragContext *context,
672 wxDropSource *WXUNUSED(drop_source) )
673{
674 if (g_isIdle)
675 wxapp_install_idle_handler();
676
677 // printf( "Drag source: drag_data_delete\n" );
678}
679}
680
681//----------------------------------------------------------------------------
682// "drag_begin"
683//----------------------------------------------------------------------------
684
685extern "C" {
686static void source_drag_begin( GtkWidget *WXUNUSED(widget),
687 GdkDragContext *WXUNUSED(context),
688 wxDropSource *WXUNUSED(drop_source) )
689{
690 if (g_isIdle)
691 wxapp_install_idle_handler();
692
693 // printf( "Drag source: drag_begin.\n" );
694}
695}
696
697//----------------------------------------------------------------------------
698// "drag_end"
699//----------------------------------------------------------------------------
700
701extern "C" {
702static void source_drag_end( GtkWidget *WXUNUSED(widget),
703 GdkDragContext *WXUNUSED(context),
704 wxDropSource *drop_source )
705{
706 if (g_isIdle) wxapp_install_idle_handler();
707
708 // printf( "Drag source: drag_end.\n" );
709
710 drop_source->m_waiting = false;
711}
712}
713
714//-----------------------------------------------------------------------------
715// "configure_event" from m_iconWindow
716//-----------------------------------------------------------------------------
717
718extern "C" {
719static gint
720gtk_dnd_window_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxDropSource *source )
721{
722 if (g_isIdle)
723 wxapp_install_idle_handler();
724
725 source->GiveFeedback( ConvertFromGTK(source->m_dragContext->action) );
726
727 return 0;
728}
729}
730
731//---------------------------------------------------------------------------
732// wxDropSource
733//---------------------------------------------------------------------------
734
735wxDropSource::wxDropSource(wxWindow *win,
736 const wxIcon &iconCopy,
737 const wxIcon &iconMove,
738 const wxIcon &iconNone)
739{
740 m_waiting = true;
741
742 m_iconWindow = (GtkWidget*) NULL;
743
744 m_window = win;
745 m_widget = win->m_widget;
746 if (win->m_wxwindow) m_widget = win->m_wxwindow;
747
748 m_retValue = wxDragCancel;
749
750 SetIcons(iconCopy, iconMove, iconNone);
751}
752
753wxDropSource::wxDropSource(wxDataObject& data,
754 wxWindow *win,
755 const wxIcon &iconCopy,
756 const wxIcon &iconMove,
757 const wxIcon &iconNone)
758{
759 m_waiting = true;
760
761 SetData( data );
762
763 m_iconWindow = (GtkWidget*) NULL;
764
765 m_window = win;
766 m_widget = win->m_widget;
767 if (win->m_wxwindow) m_widget = win->m_wxwindow;
768
769 m_retValue = wxDragCancel;
770
771 SetIcons(iconCopy, iconMove, iconNone);
772}
773
774void wxDropSource::SetIcons(const wxIcon &iconCopy,
775 const wxIcon &iconMove,
776 const wxIcon &iconNone)
777{
778 m_iconCopy = iconCopy;
779 m_iconMove = iconMove;
780 m_iconNone = iconNone;
781
782 if ( !m_iconCopy.Ok() )
783 m_iconCopy = wxIcon(page_xpm);
784 if ( !m_iconMove.Ok() )
785 m_iconMove = m_iconCopy;
786 if ( !m_iconNone.Ok() )
787 m_iconNone = m_iconCopy;
788}
789
790wxDropSource::~wxDropSource()
791{
792}
793
794void wxDropSource::PrepareIcon( int action, GdkDragContext *context )
795{
796 // get the right icon to display
797 wxIcon *icon = NULL;
798 if ( action & GDK_ACTION_MOVE )
799 icon = &m_iconMove;
800 else if ( action & GDK_ACTION_COPY )
801 icon = &m_iconCopy;
802 else
803 icon = &m_iconNone;
804
805 GdkBitmap *mask;
806 if ( icon->GetMask() )
807 mask = icon->GetMask()->GetBitmap();
808 else
809 mask = (GdkBitmap *)NULL;
810
811 GdkPixmap *pixmap = icon->GetPixmap();
812
813 gint width,height;
814 gdk_window_get_size (pixmap, &width, &height);
815
816 GdkColormap *colormap = gtk_widget_get_colormap( m_widget );
817 gtk_widget_push_colormap (colormap);
818
819 m_iconWindow = gtk_window_new (GTK_WINDOW_POPUP);
820 gtk_widget_set_events (m_iconWindow, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
821 gtk_widget_set_app_paintable (GTK_WIDGET (m_iconWindow), TRUE);
822
823 gtk_widget_pop_colormap ();
824
825 gtk_widget_set_size_request (m_iconWindow, width, height);
826 gtk_widget_realize (m_iconWindow);
827
828 g_signal_connect (m_iconWindow, "configure_event",
829 G_CALLBACK (gtk_dnd_window_configure_callback), this);
830
831 gdk_window_set_back_pixmap (m_iconWindow->window, pixmap, FALSE);
832
833 if (mask)
834 gtk_widget_shape_combine_mask (m_iconWindow, mask, 0, 0);
835
836 gtk_drag_set_icon_widget( context, m_iconWindow, 0, 0 );
837}
838
839wxDragResult wxDropSource::DoDragDrop(int flags)
840{
841 wxCHECK_MSG( m_data && m_data->GetFormatCount(), wxDragNone,
842 wxT("Drop source: no data") );
843
844 // still in drag
845 if (g_blockEventsOnDrag)
846 return wxDragNone;
847
848 // disabled for now
849 g_blockEventsOnDrag = true;
850
851 RegisterWindow();
852
853 m_waiting = true;
854
855 GtkTargetList *target_list = gtk_target_list_new( (GtkTargetEntry*) NULL, 0 );
856
857 wxDataFormat *array = new wxDataFormat[ m_data->GetFormatCount() ];
858 m_data->GetAllFormats( array );
859 size_t count = m_data->GetFormatCount();
860 for (size_t i = 0; i < count; i++)
861 {
862 GdkAtom atom = array[i];
863 wxLogTrace(TRACE_DND, wxT("Drop source: Supported atom %s"), gdk_atom_name( atom ));
864 gtk_target_list_add( target_list, atom, 0, 0 );
865 }
866 delete[] array;
867
868 GdkEventMotion event;
869 event.window = m_widget->window;
870 int x = 0;
871 int y = 0;
872 GdkModifierType state;
873 gdk_window_get_pointer( event.window, &x, &y, &state );
874 event.x = x;
875 event.y = y;
876 event.state = state;
877 event.time = (guint32)GDK_CURRENT_TIME;
878
879 /* GTK wants to know which button was pressed which caused the dragging */
880 int button_number = 0;
881 if (event.state & GDK_BUTTON1_MASK) button_number = 1;
882 else if (event.state & GDK_BUTTON2_MASK) button_number = 2;
883 else if (event.state & GDK_BUTTON3_MASK) button_number = 3;
884
885#if wxUSE_THREADS
886 /* disable GUI threads */
887#endif
888
889 /* don't start dragging if no button is down */
890 if (button_number)
891 {
892 int action = GDK_ACTION_COPY;
893 if ( flags & wxDrag_AllowMove )
894 action |= GDK_ACTION_MOVE;
895
896 // VZ: as we already use g_blockEventsOnDrag it shouldn't be that bad
897 // to use a global to pass the flags to the drop target but I'd
898 // surely prefer a better way to do it
899 gs_flagsForDrag = flags;
900
901 GdkDragContext *context = gtk_drag_begin( m_widget,
902 target_list,
903 (GdkDragAction)action,
904 button_number, /* number of mouse button which started drag */
905 (GdkEvent*) &event );
906
907 m_dragContext = context;
908
909 PrepareIcon( action, context );
910
911 while (m_waiting)
912 gtk_main_iteration();
913
914 m_retValue = ConvertFromGTK(context->action);
915 if ( m_retValue == wxDragNone )
916 m_retValue = wxDragCancel;
917 }
918
919#if wxUSE_THREADS
920 /* re-enable GUI threads */
921#endif
922
923 g_blockEventsOnDrag = false;
924
925 UnregisterWindow();
926
927 return m_retValue;
928}
929
930void wxDropSource::RegisterWindow()
931{
932 if (!m_widget) return;
933
934 g_signal_connect (m_widget, "drag_data_get",
935 G_CALLBACK (source_drag_data_get), this);
936 g_signal_connect (m_widget, "drag_data_delete",
937 G_CALLBACK (source_drag_data_delete), this);
938 g_signal_connect (m_widget, "drag_begin",
939 G_CALLBACK (source_drag_begin), this);
940 g_signal_connect (m_widget, "drag_end",
941 G_CALLBACK (source_drag_end), this);
942
943}
944
945void wxDropSource::UnregisterWindow()
946{
947 if (!m_widget)
948 return;
949
950 g_signal_handlers_disconnect_by_func (m_widget,
951 (gpointer) source_drag_data_get,
952 this);
953 g_signal_handlers_disconnect_by_func (m_widget,
954 (gpointer) source_drag_data_delete,
955 this);
956 g_signal_handlers_disconnect_by_func (m_widget,
957 (gpointer) source_drag_begin,
958 this);
959 g_signal_handlers_disconnect_by_func (m_widget,
960 (gpointer) source_drag_end,
961 this);
962}
963
964#endif
965 // wxUSE_DRAG_AND_DROP
wxWidgets (Impactor)