]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/dnd.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Better disabling of toolbars and menubars
[wxWidgets.git] / src / gtk / dnd.cpp
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 <X11/Xlib.h>
29
30 // ----------------------------------------------------------------------------
31 // global
32 // ----------------------------------------------------------------------------
33
34 extern bool g_blockEventsOnDrag;
35
36 #ifdef NEW_GTK_DND_CODE
37
38 #include "gtk/gtkdnd.h"
39 #include "gtk/gtkselection.h"
40
41 // ----------------------------------------------------------------------------
42 // "drag_leave"
43 // ----------------------------------------------------------------------------
44
45 static void target_drag_leave( GtkWidget *WXUNUSED(widget),
46 GdkDragContext *WXUNUSED(context),
47 guint WXUNUSED(time) )
48 {
49 printf( "leave.\n" );
50 }
51
52 // ----------------------------------------------------------------------------
53 // "drag_motion"
54 // ----------------------------------------------------------------------------
55
56 static gboolean target_drag_motion( GtkWidget *WXUNUSED(widget),
57 GdkDragContext *context,
58 gint WXUNUSED(x),
59 gint WXUNUSED(y),
60 guint time )
61 {
62 printf( "motion.\n" );
63 gdk_drag_status( context, context->suggested_action, time );
64 return TRUE;
65 }
66
67 // ----------------------------------------------------------------------------
68 // "drag_drop"
69 // ----------------------------------------------------------------------------
70
71 static gboolean target_drag_drop( GtkWidget *widget,
72 GdkDragContext *context,
73 gint x,
74 gint y,
75 guint time )
76 {
77 printf( "drop at: %d,%d.\n", x, y );
78
79 if (context->targets)
80 {
81 gtk_drag_get_data( widget,
82 context,
83 GPOINTER_TO_INT (context->targets->data),
84 time );
85 }
86 return FALSE;
87 }
88
89 // ----------------------------------------------------------------------------
90 // "drag_data_received"
91 // ----------------------------------------------------------------------------
92
93 static void target_drag_data_received( GtkWidget *WXUNUSED(widget),
94 GdkDragContext *context,
95 gint x,
96 gint y,
97 GtkSelectionData *data,
98 guint WXUNUSED(info),
99 guint time )
100 {
101 printf( "data receive at: %d,%d.\n", x, y );
102
103 if ((data->length >= 0) && (data->format == 8))
104 {
105 wxString str = (const char*)data->data;
106 printf( "Received %s\n.", WXSTRINGCAST str );
107 gtk_drag_finish( context, TRUE, FALSE, time );
108 return;
109 }
110
111 gtk_drag_finish (context, FALSE, FALSE, time);
112 }
113
114 // ----------------------------------------------------------------------------
115 // wxDropTarget
116 // ----------------------------------------------------------------------------
117
118 wxDropTarget::wxDropTarget()
119 {
120 }
121
122 wxDropTarget::~wxDropTarget()
123 {
124 }
125
126 void wxDropTarget::UnregisterWidget( GtkWidget *widget )
127 {
128 wxCHECK_RET( widget != NULL, "unregister widget is NULL" );
129
130 gtk_drag_dest_set( widget,
131 (GtkDestDefaults) 0,
132 (GtkTargetEntry*) NULL,
133 0,
134 (GdkDragAction) 0 );
135
136 gtk_signal_disconnect_by_func( GTK_OBJECT(widget),
137 GTK_SIGNAL_FUNC(target_drag_leave), (gpointer) this );
138
139 gtk_signal_disconnect_by_func( GTK_OBJECT(widget),
140 GTK_SIGNAL_FUNC(target_drag_motion), (gpointer) this );
141
142 gtk_signal_disconnect_by_func( GTK_OBJECT(widget),
143 GTK_SIGNAL_FUNC(target_drag_drop), (gpointer) this );
144
145 gtk_signal_disconnect_by_func( GTK_OBJECT(widget),
146 GTK_SIGNAL_FUNC(target_drag_data_received), (gpointer) this );
147 }
148
149 void wxDropTarget::RegisterWidget( GtkWidget *widget )
150 {
151 wxCHECK_RET( widget != NULL, "register widget is NULL" );
152
153 GtkTargetEntry format;
154 format.info = 0;
155 format.flags = 0;
156
157 int valid = 0;
158 for ( size_t i = 0; i < GetFormatCount(); i++ )
159 {
160 wxDataFormat df = GetFormat( i );
161 switch (df)
162 {
163 case wxDF_TEXT:
164 format.target = "text/plain";
165 valid++;
166 break;
167 case wxDF_FILENAME:
168 format.target = "file:ALL";
169 valid++;
170 break;
171 default:
172 break;
173 }
174 }
175
176 wxASSERT_MSG( valid != 0, "No valid DnD format supported." );
177
178 gtk_drag_dest_set( widget,
179 GTK_DEST_DEFAULT_ALL,
180 &format,
181 1,
182 (GdkDragAction)(GDK_ACTION_COPY | GDK_ACTION_MOVE) );
183
184 gtk_signal_connect( GTK_OBJECT(widget), "drag_leave",
185 GTK_SIGNAL_FUNC(target_drag_leave), (gpointer) this );
186
187 gtk_signal_connect( GTK_OBJECT(widget), "drag_motion",
188 GTK_SIGNAL_FUNC(target_drag_motion), (gpointer) this );
189
190 gtk_signal_connect( GTK_OBJECT(widget), "drag_drop",
191 GTK_SIGNAL_FUNC(target_drag_drop), (gpointer) this );
192
193 gtk_signal_connect( GTK_OBJECT(widget), "drag_data_received",
194 GTK_SIGNAL_FUNC(target_drag_data_received), (gpointer) this );
195 }
196
197 // ----------------------------------------------------------------------------
198 // wxTextDropTarget
199 // ----------------------------------------------------------------------------
200
201 bool wxTextDropTarget::OnDrop( long x, long y, const void *data, size_t WXUNUSED(size) )
202 {
203 OnDropText( x, y, (const char*)data );
204 return TRUE;
205 }
206
207 bool wxTextDropTarget::OnDropText( long x, long y, const char *psz )
208 {
209 printf( "Got dropped text: %s.\n", psz );
210 printf( "At x: %d, y: %d.\n", (int)x, (int)y );
211 return TRUE;
212 }
213
214 size_t wxTextDropTarget::GetFormatCount() const
215 {
216 return 1;
217 }
218
219 wxDataFormat wxTextDropTarget::GetFormat(size_t WXUNUSED(n)) const
220 {
221 return wxDF_TEXT;
222 }
223
224 // ----------------------------------------------------------------------------
225 // wxFileDropTarget
226 // ----------------------------------------------------------------------------
227
228 bool wxFileDropTarget::OnDropFiles( long x, long y, size_t nFiles, const char * const aszFiles[] )
229 {
230 printf( "Got %d dropped files.\n", (int)nFiles );
231 printf( "At x: %d, y: %d.\n", (int)x, (int)y );
232 for (size_t i = 0; i < nFiles; i++)
233 {
234 printf( aszFiles[i] );
235 printf( "\n" );
236 }
237 return TRUE;
238 }
239
240 bool wxFileDropTarget::OnDrop(long x, long y, const void *data, size_t size )
241 {
242 size_t number = 0;
243 char *text = (char*) data;
244 for (size_t i = 0; i < size; i++)
245 if (text[i] == 0) number++;
246
247 if (number == 0) return TRUE;
248
249 char **files = new char*[number];
250
251 text = (char*) data;
252 for (size_t i = 0; i < number; i++)
253 {
254 files[i] = text;
255 int len = strlen( text );
256 text += len+1;
257 }
258
259 bool ret = OnDropFiles( x, y, 1, files );
260
261 free( files );
262
263 return ret;
264 }
265
266 size_t wxFileDropTarget::GetFormatCount() const
267 {
268 return 1;
269 }
270
271 wxDataFormat wxFileDropTarget::GetFormat(size_t WXUNUSED(n)) const
272 {
273 return wxDF_FILENAME;
274 }
275
276 //-------------------------------------------------------------------------
277 // wxDropSource
278 //-------------------------------------------------------------------------
279
280 wxDropSource::wxDropSource( wxWindow *win )
281 {
282 g_blockEventsOnDrag = TRUE;
283
284 m_window = win;
285 m_widget = win->m_widget;
286 if (win->m_wxwindow) m_widget = win->m_wxwindow;
287
288 m_data = (wxDataObject *) NULL;
289 m_retValue = wxDragCancel;
290
291 m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
292 m_goaheadCursor = wxCursor( wxCURSOR_HAND );
293 }
294
295 wxDropSource::wxDropSource( wxDataObject &data, wxWindow *win )
296 {
297 g_blockEventsOnDrag = TRUE;
298
299 m_window = win;
300 m_widget = win->m_widget;
301 if (win->m_wxwindow) m_widget = win->m_wxwindow;
302 m_retValue = wxDragCancel;
303
304 m_data = &data;
305
306 m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
307 m_goaheadCursor = wxCursor( wxCURSOR_HAND );
308 }
309
310 void wxDropSource::SetData( wxDataObject &data )
311 {
312 m_data = &data;
313 }
314
315 wxDropSource::~wxDropSource(void)
316 {
317 // if (m_data) delete m_data;
318
319 g_blockEventsOnDrag = FALSE;
320 }
321
322 wxDragResult wxDropSource::DoDragDrop( bool WXUNUSED(bAllowMove) )
323 {
324 wxASSERT_MSG( m_data, "wxDragSource: no data" );
325
326 if (!m_data) return (wxDragResult) wxDragNone;
327 if (m_data->GetDataSize() == 0) return (wxDragResult) wxDragNone;
328
329 RegisterWindow();
330
331 // TODO
332
333 UnregisterWindow();
334
335 g_blockEventsOnDrag = FALSE;
336
337 return m_retValue;
338 }
339
340 void wxDropSource::RegisterWindow(void)
341 {
342 if (!m_data) return;
343
344 wxString formats;
345
346 wxDataFormat df = m_data->GetPreferredFormat();
347
348 switch (df)
349 {
350 case wxDF_TEXT:
351 formats += "text/plain";
352 break;
353 case wxDF_FILENAME:
354 formats += "file:ALL";
355 break;
356 default:
357 break;
358 }
359
360 char *str = WXSTRINGCAST formats;
361
362 // TODO
363 }
364
365 void wxDropSource::UnregisterWindow(void)
366 {
367 if (!m_widget) return;
368
369 // TODO
370 }
371
372
373 #else // NEW_CODE
374
375 GtkWidget *shape_create_icon (char **data,
376 gint x,
377 gint y,
378 gint px,
379 gint py,
380 gint window_type);
381
382 /* XPM */
383 static char * gv_xpm[] = {
384 "40 34 3 1",
385 " s None c None",
386 ". c black",
387 "X c white",
388 " ",
389 " ",
390 " ...... ",
391 " ..XXXXXX.. ",
392 " .XXXXXXXXXX. ",
393 " .XXXXXXXXXXXX. ",
394 " .XXXXXXXXXXXX. ",
395 " .XXXXXXXXXXXXXX. ",
396 " .XXX..XXXX..XXX. ",
397 " ....XX....XX....XX. ",
398 " .XXX.XXX..XXXX..XXX.... ",
399 " .XXXXXXXXXXXXXXXXXXX.XXX. ",
400 " .XXXXXXXXXXXXXXXXXXXXXXXX. ",
401 " .XXXXXXXXXXXXXXXXXXXXXXXX. ",
402 " ..XXXXXXXXXXXXXXXXXXXXXX. ",
403 " .XXXXXXXXXXXXXXXXXX... ",
404 " ..XXXXXXXXXXXXXXXX. ",
405 " .XXXXXXXXXXXXXXXX. ",
406 " .XXXXXXXXXXXXXXXX. ",
407 " .XXXXXXXXXXXXXXXXX. ",
408 " .XXXXXXXXXXXXXXXXX. ",
409 " .XXXXXXXXXXXXXXXXXX. ",
410 " .XXXXXXXXXXXXXXXXXXX. ",
411 " .XXXXXXXXXXXXXXXXXXXXX. ",
412 " .XXXXXXXXXXXXXX.XXXXXXX. ",
413 " .XXXXXXX.XXXXXXX.XXXXXXX. ",
414 " .XXXXXXXX.XXXXXXX.XXXXXXX. ",
415 " .XXXXXXX...XXXXX...XXXXX. ",
416 " .XXXXXXX. ..... ..... ",
417 " ..XXXX.. ",
418 " .... ",
419 " ",
420 " ",
421 " "};
422
423 /* XPM */
424 static char * page_xpm[] = {
425 /* width height ncolors chars_per_pixel */
426 "32 32 5 1",
427 /* colors */
428 " s None c None",
429 ". c black",
430 "X c wheat",
431 "o c tan",
432 "O c #6699FF",
433 /* pixels */
434 " ................... ",
435 " .XXXXXXXXXXXXXXXXX.. ",
436 " .XXXXXXXXXXXXXXXXX.o. ",
437 " .XXXXXXXXXXXXXXXXX.oo. ",
438 " .XXXXXXXXXXXXXXXXX.ooo. ",
439 " .XXXXXXXXXXXXXXXXX.oooo. ",
440 " .XXXXXXXXXXXXXXXXX....... ",
441 " .XXXXXOOOOOOOOOOXXXooooo. ",
442 " .XXXXXXXXXXXXXXXXXXooooo. ",
443 " .XXXXXOOOOOOOOOOXXXXXXXX. ",
444 " .XXXXXXXXXXXXXXXXXXXXXXX. ",
445 " .XXXXXXXOOOOOOOOOXXXXXXX. ",
446 " .XXXXXXXXXXXXXXXXXXXXXXX. ",
447 " .XXXXXXOOOOOOOOOOXXXXXXX. ",
448 " .XXXXXXXXXXXXXXXXXXXXXXX. ",
449 " .XXXXXOOOOOOOOOOXXXXXXXX. ",
450 " .XXXXXXXXXXXXXXXXXXXXXXX. ",
451 " .XXXXXXXOOOOOOOOOXXXXXXX. ",
452 " .XXXXXXXXXXXXXXXXXXXXXXX. ",
453 " .XXXXXXOOOOOOOOOOXXXXXXX. ",
454 " .XXXXXXXXXXXXXXXXXXXXXXX. ",
455 " .XXXXXOOOOOOOOOOXXXXXXXX. ",
456 " .XXXXXXXXXXXXXXXXXXXXXXX. ",
457 " .XXXXXXOOOOOOOOOOXXXXXXX. ",
458 " .XXXXXXXXXXXXXXXXXXXXXXX. ",
459 " .XXXXXOOOOOOOXXXXXXXXXXX. ",
460 " .XXXXXXXXXXXXXXXXXXXXXXX. ",
461 " .XXXXXXXXXXXXXXXXXXXXXXX. ",
462 " .XXXXXXXXXXXXXXXXXXXXXXX. ",
463 " .XXXXXXXXXXXXXXXXXXXXXXX. ",
464 " .XXXXXXXXXXXXXXXXXXXXXXX. ",
465 " ......................... "};
466
467
468 //-----------------------------------------------------------------------------
469 // "drop_data_available_event"
470 //-----------------------------------------------------------------------------
471
472 static void gtk_target_callback( GtkWidget *widget,
473 GdkEventDropDataAvailable *event,
474 wxDropTarget *target )
475 {
476 if (target)
477 {
478 int x = 0;
479 int y = 0;
480 gdk_window_get_pointer( widget->window, &x, &y, (GdkModifierType *) NULL );
481
482 // printf( "Drop data is of type %s.\n", event->data_type );
483
484 target->OnDrop( x, y, (const void*)event->data, (size_t)event->data_numbytes );
485 }
486
487 /*
488 g_free (event->data);
489 g_free (event->data_type);
490 */
491 }
492
493 // ----------------------------------------------------------------------------
494 // wxDropTarget
495 // ----------------------------------------------------------------------------
496
497 wxDropTarget::wxDropTarget()
498 {
499 }
500
501 wxDropTarget::~wxDropTarget()
502 {
503 }
504
505 void wxDropTarget::UnregisterWidget( GtkWidget *widget )
506 {
507 if (!widget) return;
508
509 gtk_signal_disconnect_by_func( GTK_OBJECT(widget),
510 GTK_SIGNAL_FUNC(gtk_target_callback), (gpointer) this );
511
512 gtk_widget_dnd_drop_set( widget, FALSE, (gchar **) NULL, 0, FALSE );
513 }
514
515 void wxDropTarget::RegisterWidget( GtkWidget *widget )
516 {
517 wxString formats;
518 int valid = 0;
519
520 for ( size_t i = 0; i < GetFormatCount(); i++ )
521 {
522 wxDataFormat df = GetFormat( i );
523 switch (df)
524 {
525 case wxDF_TEXT:
526 if (i > 0) formats += ";";
527 formats += "text/plain";
528 valid++;
529 break;
530 case wxDF_FILENAME:
531 if (i > 0) formats += ";";
532 formats += "file:ALL";
533 valid++;
534 break;
535 default:
536 break;
537 }
538 }
539
540 char *str = WXSTRINGCAST formats;
541
542 gtk_widget_dnd_drop_set( widget, TRUE, &str, valid, FALSE );
543
544 gtk_signal_connect( GTK_OBJECT(widget), "drop_data_available_event",
545 GTK_SIGNAL_FUNC(gtk_target_callback), (gpointer) this );
546 }
547
548 // ----------------------------------------------------------------------------
549 // wxTextDropTarget
550 // ----------------------------------------------------------------------------
551
552 bool wxTextDropTarget::OnDrop( long x, long y, const void *data, size_t WXUNUSED(size) )
553 {
554 OnDropText( x, y, (const char*)data );
555 return TRUE;
556 }
557
558 bool wxTextDropTarget::OnDropText( long x, long y, const char *psz )
559 {
560 printf( "Got dropped text: %s.\n", psz );
561 printf( "At x: %d, y: %d.\n", (int)x, (int)y );
562 return TRUE;
563 }
564
565 size_t wxTextDropTarget::GetFormatCount() const
566 {
567 return 1;
568 }
569
570 wxDataFormat wxTextDropTarget::GetFormat(size_t WXUNUSED(n)) const
571 {
572 return wxDF_TEXT;
573 }
574
575 // ----------------------------------------------------------------------------
576 // wxFileDropTarget
577 // ----------------------------------------------------------------------------
578
579 bool wxFileDropTarget::OnDropFiles( long x, long y, size_t nFiles, const char * const aszFiles[] )
580 {
581 printf( "Got %d dropped files.\n", (int)nFiles );
582 printf( "At x: %d, y: %d.\n", (int)x, (int)y );
583 for (size_t i = 0; i < nFiles; i++)
584 {
585 printf( aszFiles[i] );
586 printf( "\n" );
587 }
588 return TRUE;
589 }
590
591 bool wxFileDropTarget::OnDrop(long x, long y, const void *data, size_t size )
592 {
593 size_t number = 0;
594 char *text = (char*) data;
595 for (size_t i = 0; i < size; i++)
596 if (text[i] == 0) number++;
597
598 if (number == 0) return TRUE;
599
600 char **files = new char*[number];
601
602 text = (char*) data;
603 for (size_t i = 0; i < number; i++)
604 {
605 files[i] = text;
606 int len = strlen( text );
607 text += len+1;
608 }
609
610 bool ret = OnDropFiles( x, y, 1, files );
611
612 free( files );
613
614 return ret;
615 }
616
617 size_t wxFileDropTarget::GetFormatCount() const
618 {
619 return 1;
620 }
621
622 wxDataFormat wxFileDropTarget::GetFormat(size_t WXUNUSED(n)) const
623 {
624 return wxDF_FILENAME;
625 }
626
627 //-------------------------------------------------------------------------
628 // wxDropSource
629 //-------------------------------------------------------------------------
630
631 static void
632 shape_motion (GtkWidget *widget,
633 GdkEventMotion */*event*/);
634
635 //-----------------------------------------------------------------------------
636 // drag request
637
638 void gtk_drag_callback( GtkWidget *widget, GdkEvent *event, wxDropSource *source )
639 {
640 wxDataObject *data = source->m_data;
641
642 switch (data->GetFormat())
643 {
644 case wxDF_TEXT:
645 {
646 wxTextDataObject *text_object = (wxTextDataObject*) data;
647
648 wxString text = text_object->GetText();
649
650 char *s = WXSTRINGCAST text;
651
652 gtk_widget_dnd_data_set( widget,
653 event,
654 (unsigned char*) s,
655 (int) text.Length()+1 );
656
657 break;
658 }
659
660 case wxDF_FILENAME:
661 {
662 wxFileDataObject *file_object = (wxFileDataObject*) data;
663
664 wxString text = file_object->GetFiles();
665
666 char *s = WXSTRINGCAST text;
667
668 gtk_widget_dnd_data_set( widget,
669 event,
670 (unsigned char*) s,
671 (int) text.Length()+1 );
672
673 break;
674 }
675
676 default:
677 {
678 return;
679 }
680 }
681
682 source->m_retValue = wxDragCopy;
683 }
684
685 wxDropSource::wxDropSource( wxWindow *win )
686 {
687 g_blockEventsOnDrag = TRUE;
688
689 m_window = win;
690 m_widget = win->m_widget;
691 if (win->m_wxwindow) m_widget = win->m_wxwindow;
692
693 m_data = (wxDataObject *) NULL;
694 m_retValue = wxDragCancel;
695
696 m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
697 m_goaheadCursor = wxCursor( wxCURSOR_HAND );
698 }
699
700 wxDropSource::wxDropSource( wxDataObject &data, wxWindow *win )
701 {
702 g_blockEventsOnDrag = TRUE;
703
704 m_window = win;
705 m_widget = win->m_widget;
706 if (win->m_wxwindow) m_widget = win->m_wxwindow;
707 m_retValue = wxDragCancel;
708
709 m_data = &data;
710
711 m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
712 m_goaheadCursor = wxCursor( wxCURSOR_HAND );
713 }
714
715 void wxDropSource::SetData( wxDataObject &data )
716 {
717 m_data = &data;
718 }
719
720 wxDropSource::~wxDropSource(void)
721 {
722 // if (m_data) delete m_data;
723
724 g_blockEventsOnDrag = FALSE;
725 }
726
727 wxDragResult wxDropSource::DoDragDrop( bool WXUNUSED(bAllowMove) )
728 {
729 if (gdk_dnd.dnd_grabbed) return (wxDragResult) wxDragNone;
730 if (gdk_dnd.drag_really) return (wxDragResult) wxDragNone;
731
732 wxASSERT_MSG( m_data, "wxDragSource: no data" );
733
734 if (!m_data) return (wxDragResult) wxDragNone;
735
736 static GtkWidget *drag_icon = (GtkWidget*) NULL;
737 static GtkWidget *drop_icon = (GtkWidget*) NULL;
738
739 GdkPoint hotspot_1 = {0,-5 };
740
741 if (!drag_icon)
742 {
743 drag_icon = shape_create_icon ( gv_xpm,
744 440, 140, 0,0, GTK_WINDOW_POPUP);
745
746 gtk_signal_connect (GTK_OBJECT (drag_icon), "destroy",
747 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
748 &drag_icon);
749
750 gtk_widget_hide (drag_icon);
751 }
752
753 GdkPoint hotspot_2 = {-5,-5};
754
755 if (!drop_icon)
756 {
757 drop_icon = shape_create_icon ( page_xpm,
758 440, 140, 0,0, GTK_WINDOW_POPUP);
759
760 gtk_signal_connect (GTK_OBJECT (drop_icon), "destroy",
761 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
762 &drop_icon);
763
764 gtk_widget_hide (drop_icon);
765 }
766
767
768 gdk_dnd_set_drag_shape( drag_icon->window,
769 &hotspot_1,
770 drop_icon->window,
771 &hotspot_2);
772
773
774 GdkWindowPrivate *wp = (GdkWindowPrivate*) m_widget->window;
775
776 RegisterWindow();
777
778 gdk_dnd.drag_perhaps = TRUE;
779
780 gdk_dnd.dnd_drag_start.x = 5;
781 gdk_dnd.dnd_drag_start.y = 5;
782 gdk_dnd.real_sw = wp;
783
784 if (gdk_dnd.drag_startwindows)
785 {
786 g_free( gdk_dnd.drag_startwindows );
787 gdk_dnd.drag_startwindows = (GdkWindow **) NULL;
788 }
789 gdk_dnd.drag_numwindows = gdk_dnd.drag_really = 0;
790
791 XWindowAttributes dnd_winattr;
792 XGetWindowAttributes( gdk_display, wp->xwindow, &dnd_winattr );
793 wp->dnd_drag_savedeventmask = dnd_winattr.your_event_mask;
794
795 gdk_dnd_drag_addwindow( m_widget->window );
796
797 GdkEventDragBegin ev;
798 ev.type = GDK_DRAG_BEGIN;
799 ev.window = m_widget->window;
800 ev.u.allflags = 0;
801 ev.u.flags.protocol_version = DND_PROTOCOL_VERSION;
802
803 gdk_event_put( (GdkEvent*)&ev );
804
805 XGrabPointer( gdk_display, wp->xwindow, False,
806 ButtonMotionMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
807 GrabModeAsync, GrabModeAsync, gdk_root_window, None, CurrentTime );
808
809 gdk_dnd_set_drag_cursors( m_defaultCursor.GetCursor(), m_goaheadCursor.GetCursor() );
810
811 gdk_dnd.dnd_grabbed = TRUE;
812 gdk_dnd.drag_really = 1;
813
814 int x = 0;
815 int y = 0;
816 wxGetMousePosition( &x, &y );
817
818 gdk_dnd_display_drag_cursor( x, y, FALSE, TRUE );
819
820 /*
821 shape_motion( drag_icon, (GdkEventMotion *)NULL );
822 shape_motion( drop_icon, (GdkEventMotion *)NULL );
823 */
824
825 while (gdk_dnd.drag_really || gdk_dnd.drag_perhaps) wxYield();
826
827 UnregisterWindow();
828
829 g_blockEventsOnDrag = FALSE;
830
831 return m_retValue;
832 }
833
834 void wxDropSource::RegisterWindow(void)
835 {
836 if (!m_data) return;
837
838 wxString formats;
839
840 wxDataFormat df = m_data->GetFormat();
841
842 switch (df)
843 {
844 case wxDF_TEXT:
845 formats += "text/plain";
846 break;
847 case wxDF_FILENAME:
848 formats += "file:ALL";
849 break;
850 default:
851 break;
852 }
853
854 char *str = WXSTRINGCAST formats;
855
856 gtk_widget_dnd_drag_set( m_widget, TRUE, &str, 1 );
857
858 gtk_signal_connect( GTK_OBJECT(m_widget), "drag_request_event",
859 GTK_SIGNAL_FUNC(gtk_drag_callback), (gpointer)this );
860 }
861
862 void wxDropSource::UnregisterWindow(void)
863 {
864 if (!m_widget) return;
865
866 gtk_widget_dnd_drag_set( m_widget, FALSE, (gchar **) NULL, 0 );
867
868 gtk_signal_disconnect_by_data( GTK_OBJECT(m_widget), (gpointer)this );
869 }
870
871
872 /*
873 * Shaped Windows
874 */
875 static GdkWindow *root_win = (GdkWindow*) NULL;
876
877 typedef struct _cursoroffset {gint x,y;} CursorOffset;
878
879 static void
880 shape_pressed (GtkWidget *widget, GdkEventButton *event)
881 {
882 CursorOffset *p;
883
884 /* ignore double and triple click */
885 if (event->type != GDK_BUTTON_PRESS)
886 return;
887
888 p = (CursorOffset *)gtk_object_get_user_data (GTK_OBJECT(widget));
889 p->x = (int) event->x;
890 p->y = (int) event->y;
891
892 gtk_grab_add (widget);
893 gdk_pointer_grab (widget->window, TRUE,
894 (GdkEventMask)
895 (GDK_BUTTON_RELEASE_MASK |
896 GDK_BUTTON_MOTION_MASK |
897 GDK_POINTER_MOTION_HINT_MASK),
898 (GdkWindow*)NULL,
899 (GdkCursor*) NULL, 0);
900 }
901
902
903 static void
904 shape_released (GtkWidget *widget)
905 {
906 gtk_grab_remove (widget);
907 gdk_pointer_ungrab (0);
908 }
909
910 static void
911 shape_motion (GtkWidget *widget,
912 GdkEventMotion */*event*/)
913 {
914 gint xp, yp;
915 CursorOffset * p;
916 GdkModifierType mask;
917
918 p = (CursorOffset *)gtk_object_get_user_data (GTK_OBJECT (widget));
919
920 /*
921 * Can't use event->x / event->y here
922 * because I need absolute coordinates.
923 */
924 gdk_window_get_pointer (root_win, &xp, &yp, &mask);
925 gtk_widget_set_uposition (widget, xp - p->x, yp - p->y);
926 }
927
928 GtkWidget *
929 shape_create_icon (char **data,
930 gint x,
931 gint y,
932 gint px,
933 gint py,
934 gint window_type)
935 {
936 GtkWidget *window;
937 GtkWidget *pixmap;
938 GtkWidget *fixed;
939 CursorOffset* icon_pos;
940 GdkGC* gc;
941 GdkBitmap *gdk_pixmap_mask;
942 GdkPixmap *gdk_pixmap;
943 GtkStyle *style;
944
945 style = gtk_widget_get_default_style ();
946 gc = style->black_gc;
947
948 /*
949 * GDK_WINDOW_TOPLEVEL works also, giving you a title border
950 */
951 window = gtk_window_new ((GtkWindowType)window_type);
952
953 fixed = gtk_fixed_new ();
954 gtk_widget_set_usize (fixed, 100,100);
955 gtk_container_add (GTK_CONTAINER (window), fixed);
956 gtk_widget_show (fixed);
957
958 gtk_widget_set_events (window,
959 gtk_widget_get_events (window) |
960 GDK_BUTTON_MOTION_MASK |
961 GDK_POINTER_MOTION_HINT_MASK |
962 GDK_BUTTON_PRESS_MASK);
963
964 gtk_widget_realize (window);
965
966 gdk_pixmap = gdk_pixmap_create_from_xpm_d (window->window, &gdk_pixmap_mask,
967 &style->bg[GTK_STATE_NORMAL],
968 (gchar**) data );
969
970 pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
971 gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
972 gtk_widget_show (pixmap);
973
974 gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
975
976
977 gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
978 GTK_SIGNAL_FUNC (shape_pressed),NULL);
979 gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
980 GTK_SIGNAL_FUNC (shape_released),NULL);
981 gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
982 GTK_SIGNAL_FUNC (shape_motion),NULL);
983
984 icon_pos = g_new (CursorOffset, 1);
985 gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
986
987 gtk_widget_set_uposition (window, x, y);
988 gtk_widget_show (window);
989
990 return window;
991 }
992
993 #endif
994 // NEW_GTK_DND_CODE
995
996 #endif
997
998 // wxUSE_DRAG_AND_DROP
wxWidgets (Impactor)