]> git.saurik.com Git - wxWidgets.git/blob - src/gtk1/dnd.cpp
projects / wxWidgets.git / blob
? search:


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