]> 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
Pressing build-in joystick on WinCE phones fires wxEVT_JOY_BUTTON_DOWN event.
[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 // in GTK+ 1.x GdkAtom was a gulong, but now it's a pointer
510 GdkAtom formatAtom =
511#ifdef __WXGTK20__
512 (GdkAtom)(child->data);
513#else
514 GPOINTER_TO_INT(child->data);
515#endif
516 wxDataFormat format( formatAtom );
517
518#ifdef __WXDEBUG__
519 wxLogTrace(TRACE_DND, wxT("Drop target: drag has format: %s"),
520 format.GetId().c_str());
521#endif // Debug
522
523 if (m_dataObject->IsSupportedFormat( format ))
524 return formatAtom;
525
526 child = child->next;
527 }
528
529 return (GdkAtom) 0;
530}
531
532bool wxDropTarget::GetData()
533{
534 if (!m_dragData)
535 return false;
536
537 if (!m_dataObject)
538 return false;
539
540 wxDataFormat dragFormat( m_dragData->target );
541
542 if (!m_dataObject->IsSupportedFormat( dragFormat ))
543 return false;
544
545 m_dataObject->SetData( dragFormat, (size_t)m_dragData->length, (const void*)m_dragData->data );
546
547 return true;
548}
549
550void wxDropTarget::UnregisterWidget( GtkWidget *widget )
551{
552 wxCHECK_RET( widget != NULL, wxT("unregister widget is NULL") );
553
554 gtk_drag_dest_unset( widget );
555
556 gtk_signal_disconnect_by_func( GTK_OBJECT(widget),
557 GTK_SIGNAL_FUNC(target_drag_leave), (gpointer) this );
558
559 gtk_signal_disconnect_by_func( GTK_OBJECT(widget),
560 GTK_SIGNAL_FUNC(target_drag_motion), (gpointer) this );
561
562 gtk_signal_disconnect_by_func( GTK_OBJECT(widget),
563 GTK_SIGNAL_FUNC(target_drag_drop), (gpointer) this );
564
565 gtk_signal_disconnect_by_func( GTK_OBJECT(widget),
566 GTK_SIGNAL_FUNC(target_drag_data_received), (gpointer) this );
567}
568
569void wxDropTarget::RegisterWidget( GtkWidget *widget )
570{
571 wxCHECK_RET( widget != NULL, wxT("register widget is NULL") );
572
573 /* gtk_drag_dest_set() determines what default behaviour we'd like
574 GTK to supply. we don't want to specify out targets (=formats)
575 or actions in advance (i.e. not GTK_DEST_DEFAULT_MOTION and
576 not GTK_DEST_DEFAULT_DROP). instead we react individually to
577 "drag_motion" and "drag_drop" events. this makes it possible
578 to allow dropping on only a small area. we should set
579 GTK_DEST_DEFAULT_HIGHLIGHT as this will switch on the nice
580 highlighting if dragging over standard controls, but this
581 seems to be broken without the other two. */
582
583 gtk_drag_dest_set( widget,
584 (GtkDestDefaults) 0, /* no default behaviour */
585 (GtkTargetEntry*) NULL, /* we don't supply any formats here */
586 0, /* number of targets = 0 */
587 (GdkDragAction) 0 ); /* we don't supply any actions here */
588
589 gtk_signal_connect( GTK_OBJECT(widget), "drag_leave",
590 GTK_SIGNAL_FUNC(target_drag_leave), (gpointer) this );
591
592 gtk_signal_connect( GTK_OBJECT(widget), "drag_motion",
593 GTK_SIGNAL_FUNC(target_drag_motion), (gpointer) this );
594
595 gtk_signal_connect( GTK_OBJECT(widget), "drag_drop",
596 GTK_SIGNAL_FUNC(target_drag_drop), (gpointer) this );
597
598 gtk_signal_connect( GTK_OBJECT(widget), "drag_data_received",
599 GTK_SIGNAL_FUNC(target_drag_data_received), (gpointer) this );
600}
601
602//----------------------------------------------------------------------------
603// "drag_data_get"
604//----------------------------------------------------------------------------
605
606extern "C" {
607static void
608source_drag_data_get (GtkWidget *WXUNUSED(widget),
609 GdkDragContext *WXUNUSED(context),
610 GtkSelectionData *selection_data,
611 guint WXUNUSED(info),
612 guint WXUNUSED(time),
613 wxDropSource *drop_source )
614{
615 if (g_isIdle) wxapp_install_idle_handler();
616
617 wxDataFormat format( selection_data->target );
618
619 wxLogTrace(TRACE_DND, wxT("Drop source: format requested: %s"),
620 format.GetId().c_str());
621
622 drop_source->m_retValue = wxDragCancel;
623
624 wxDataObject *data = drop_source->GetDataObject();
625
626 if (!data)
627 {
628 wxLogTrace(TRACE_DND, wxT("Drop source: no data object") );
629 return;
630 }
631
632 if (!data->IsSupportedFormat(format))
633 {
634 wxLogTrace(TRACE_DND, wxT("Drop source: unsupported format") );
635 return;
636 }
637
638 if (data->GetDataSize(format) == 0)
639 {
640 wxLogTrace(TRACE_DND, wxT("Drop source: empty data") );
641 return;
642 }
643
644 size_t size = data->GetDataSize(format);
645
646// printf( "data size: %d.\n", (int)data_size );
647
648 guchar *d = new guchar[size];
649
650 if (!data->GetDataHere( format, (void*)d ))
651 {
652 delete[] d;
653 return;
654 }
655
656#if wxUSE_THREADS
657 /* disable GUI threads */
658#endif
659
660 gtk_selection_data_set( selection_data,
661 selection_data->target,
662 8, // 8-bit
663 d,
664 size );
665
666#if wxUSE_THREADS
667 /* enable GUI threads */
668#endif
669
670 delete[] d;
671}
672}
673
674//----------------------------------------------------------------------------
675// "drag_data_delete"
676//----------------------------------------------------------------------------
677
678extern "C" {
679static void source_drag_data_delete( GtkWidget *WXUNUSED(widget),
680 GdkDragContext *context,
681 wxDropSource *WXUNUSED(drop_source) )
682{
683 if (g_isIdle)
684 wxapp_install_idle_handler();
685
686 // printf( "Drag source: drag_data_delete\n" );
687}
688}
689
690//----------------------------------------------------------------------------
691// "drag_begin"
692//----------------------------------------------------------------------------
693
694extern "C" {
695static void source_drag_begin( GtkWidget *WXUNUSED(widget),
696 GdkDragContext *WXUNUSED(context),
697 wxDropSource *WXUNUSED(drop_source) )
698{
699 if (g_isIdle)
700 wxapp_install_idle_handler();
701
702 // printf( "Drag source: drag_begin.\n" );
703}
704}
705
706//----------------------------------------------------------------------------
707// "drag_end"
708//----------------------------------------------------------------------------
709
710extern "C" {
711static void source_drag_end( GtkWidget *WXUNUSED(widget),
712 GdkDragContext *WXUNUSED(context),
713 wxDropSource *drop_source )
714{
715 if (g_isIdle) wxapp_install_idle_handler();
716
717 // printf( "Drag source: drag_end.\n" );
718
719 drop_source->m_waiting = false;
720}
721}
722
723//-----------------------------------------------------------------------------
724// "configure_event" from m_iconWindow
725//-----------------------------------------------------------------------------
726
727extern "C" {
728static gint
729gtk_dnd_window_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxDropSource *source )
730{
731 if (g_isIdle)
732 wxapp_install_idle_handler();
733
734 source->GiveFeedback( ConvertFromGTK(source->m_dragContext->action) );
735
736 return 0;
737}
738}
739
740//---------------------------------------------------------------------------
741// wxDropSource
742//---------------------------------------------------------------------------
743
744wxDropSource::wxDropSource(wxWindow *win,
745 const wxIcon &iconCopy,
746 const wxIcon &iconMove,
747 const wxIcon &iconNone)
748{
749 m_waiting = true;
750
751 m_iconWindow = (GtkWidget*) NULL;
752
753 m_window = win;
754 m_widget = win->m_widget;
755 if (win->m_wxwindow) m_widget = win->m_wxwindow;
756
757 m_retValue = wxDragCancel;
758
759 SetIcons(iconCopy, iconMove, iconNone);
760}
761
762wxDropSource::wxDropSource(wxDataObject& data,
763 wxWindow *win,
764 const wxIcon &iconCopy,
765 const wxIcon &iconMove,
766 const wxIcon &iconNone)
767{
768 m_waiting = true;
769
770 SetData( data );
771
772 m_iconWindow = (GtkWidget*) NULL;
773
774 m_window = win;
775 m_widget = win->m_widget;
776 if (win->m_wxwindow) m_widget = win->m_wxwindow;
777
778 m_retValue = wxDragCancel;
779
780 SetIcons(iconCopy, iconMove, iconNone);
781}
782
783void wxDropSource::SetIcons(const wxIcon &iconCopy,
784 const wxIcon &iconMove,
785 const wxIcon &iconNone)
786{
787 m_iconCopy = iconCopy;
788 m_iconMove = iconMove;
789 m_iconNone = iconNone;
790
791 if ( !m_iconCopy.Ok() )
792 m_iconCopy = wxIcon(page_xpm);
793 if ( !m_iconMove.Ok() )
794 m_iconMove = m_iconCopy;
795 if ( !m_iconNone.Ok() )
796 m_iconNone = m_iconCopy;
797}
798
799wxDropSource::~wxDropSource()
800{
801}
802
803void wxDropSource::PrepareIcon( int action, GdkDragContext *context )
804{
805 // get the right icon to display
806 wxIcon *icon = NULL;
807 if ( action & GDK_ACTION_MOVE )
808 icon = &m_iconMove;
809 else if ( action & GDK_ACTION_COPY )
810 icon = &m_iconCopy;
811 else
812 icon = &m_iconNone;
813
814 GdkBitmap *mask;
815 if ( icon->GetMask() )
816 mask = icon->GetMask()->GetBitmap();
817 else
818 mask = (GdkBitmap *)NULL;
819
820 GdkPixmap *pixmap = icon->GetPixmap();
821
822 gint width,height;
823 gdk_window_get_size (pixmap, &width, &height);
824
825 GdkColormap *colormap = gtk_widget_get_colormap( m_widget );
826#ifndef __WXGTK20__
827 gtk_widget_push_visual (gdk_colormap_get_visual (colormap));
828#endif
829 gtk_widget_push_colormap (colormap);
830
831 m_iconWindow = gtk_window_new (GTK_WINDOW_POPUP);
832 gtk_widget_set_events (m_iconWindow, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
833 gtk_widget_set_app_paintable (GTK_WIDGET (m_iconWindow), TRUE);
834
835#ifndef __WXGTK20__
836 gtk_widget_pop_visual ();
837#endif
838 gtk_widget_pop_colormap ();
839
840 gtk_widget_set_usize (m_iconWindow, width, height);
841 gtk_widget_realize (m_iconWindow);
842
843 gtk_signal_connect( GTK_OBJECT(m_iconWindow), "configure_event",
844 GTK_SIGNAL_FUNC(gtk_dnd_window_configure_callback), (gpointer)this );
845
846 gdk_window_set_back_pixmap (m_iconWindow->window, pixmap, FALSE);
847
848 if (mask)
849 gtk_widget_shape_combine_mask (m_iconWindow, mask, 0, 0);
850
851 gtk_drag_set_icon_widget( context, m_iconWindow, 0, 0 );
852}
853
854wxDragResult wxDropSource::DoDragDrop(int flags)
855{
856 wxCHECK_MSG( m_data && m_data->GetFormatCount(), wxDragNone,
857 wxT("Drop source: no data") );
858
859 // still in drag
860 if (g_blockEventsOnDrag)
861 return wxDragNone;
862
863 // disabled for now
864 g_blockEventsOnDrag = true;
865
866 RegisterWindow();
867
868 m_waiting = true;
869
870 GtkTargetList *target_list = gtk_target_list_new( (GtkTargetEntry*) NULL, 0 );
871
872 wxDataFormat *array = new wxDataFormat[ m_data->GetFormatCount() ];
873 m_data->GetAllFormats( array );
874 size_t count = m_data->GetFormatCount();
875 for (size_t i = 0; i < count; i++)
876 {
877 GdkAtom atom = array[i];
878 wxLogTrace(TRACE_DND, wxT("Drop source: Supported atom %s"), gdk_atom_name( atom ));
879 gtk_target_list_add( target_list, atom, 0, 0 );
880 }
881 delete[] array;
882
883 GdkEventMotion event;
884 event.window = m_widget->window;
885 int x = 0;
886 int y = 0;
887 GdkModifierType state;
888 gdk_window_get_pointer( event.window, &x, &y, &state );
889 event.x = x;
890 event.y = y;
891 event.state = state;
892 event.time = (guint32)GDK_CURRENT_TIME;
893
894 /* GTK wants to know which button was pressed which caused the dragging */
895 int button_number = 0;
896 if (event.state & GDK_BUTTON1_MASK) button_number = 1;
897 else if (event.state & GDK_BUTTON2_MASK) button_number = 2;
898 else if (event.state & GDK_BUTTON3_MASK) button_number = 3;
899
900#if wxUSE_THREADS
901 /* disable GUI threads */
902#endif
903
904 /* don't start dragging if no button is down */
905 if (button_number)
906 {
907 int action = GDK_ACTION_COPY;
908 if ( flags & wxDrag_AllowMove )
909 action |= GDK_ACTION_MOVE;
910
911 // VZ: as we already use g_blockEventsOnDrag it shouldn't be that bad
912 // to use a global to pass the flags to the drop target but I'd
913 // surely prefer a better way to do it
914 gs_flagsForDrag = flags;
915
916 GdkDragContext *context = gtk_drag_begin( m_widget,
917 target_list,
918 (GdkDragAction)action,
919 button_number, /* number of mouse button which started drag */
920 (GdkEvent*) &event );
921
922 m_dragContext = context;
923
924 PrepareIcon( action, context );
925
926 while (m_waiting)
927 gtk_main_iteration();
928
929 m_retValue = ConvertFromGTK(context->action);
930 if ( m_retValue == wxDragNone )
931 m_retValue = wxDragCancel;
932 }
933
934#if wxUSE_THREADS
935 /* re-enable GUI threads */
936#endif
937
938 g_blockEventsOnDrag = false;
939
940 UnregisterWindow();
941
942 return m_retValue;
943}
944
945void wxDropSource::RegisterWindow()
946{
947 if (!m_widget) return;
948
949 gtk_signal_connect( GTK_OBJECT(m_widget), "drag_data_get",
950 GTK_SIGNAL_FUNC (source_drag_data_get), (gpointer) this);
951 gtk_signal_connect (GTK_OBJECT(m_widget), "drag_data_delete",
952 GTK_SIGNAL_FUNC (source_drag_data_delete), (gpointer) this );
953 gtk_signal_connect (GTK_OBJECT(m_widget), "drag_begin",
954 GTK_SIGNAL_FUNC (source_drag_begin), (gpointer) this );
955 gtk_signal_connect (GTK_OBJECT(m_widget), "drag_end",
956 GTK_SIGNAL_FUNC (source_drag_end), (gpointer) this );
957
958}
959
960void wxDropSource::UnregisterWindow()
961{
962 if (!m_widget) return;
963
964 gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget),
965 GTK_SIGNAL_FUNC(source_drag_data_get), (gpointer) this );
966 gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget),
967 GTK_SIGNAL_FUNC(source_drag_data_delete), (gpointer) this );
968 gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget),
969 GTK_SIGNAL_FUNC(source_drag_begin), (gpointer) this );
970 gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget),
971 GTK_SIGNAL_FUNC(source_drag_end), (gpointer) this );
972}
973
974#endif
975 // wxUSE_DRAG_AND_DROP
wxWidgets (Impactor)