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