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