Context Navigation

gtkdnd.c @ 17071

Visit:

Revision 17071, 76.0 KB checked in by ghudson, 23 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r17070, which included commits to RCS files with non-trunk default branches.

Rev	Line
[14481]	1	/* GTK - The GIMP Toolkit
	2	* Copyright (C) 1995-1999 Peter Mattis, Spencer Kimball and Josh MacDonald
	3	*
	4	* This library is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU Library General Public
	6	* License as published by the Free Software Foundation; either
	7	* version 2 of the License, or (at your option) any later version.
	8	*
	9	* This library is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	* Library General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU Library General Public
	15	* License along with this library; if not, write to the
	16	* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	17	* Boston, MA 02111-1307, USA.
	18	*/
	19
	20	/*
	21	* Modified by the GTK+ Team and others 1997-1999. See the AUTHORS
	22	* file for a list of people on the GTK+ Team. See the ChangeLog
	23	* files for a list of changes. These files are distributed with
	24	* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
	25	*/
	26
[15780]	27	#include <stdlib.h>
	28
[14481]	29	#include "gdk/gdkx.h"
	30	#include "gdk/gdkkeysyms.h"
	31
	32	#include "gtkdnd.h"
	33	#include "gtkinvisible.h"
	34	#include "gtkmain.h"
	35	#include "gtksignal.h"
	36	#include "gtkwindow.h"
	37
	38	static GSList *drag_widgets = NULL;
	39	static GSList *source_widgets = NULL;
	40
	41	typedef struct _GtkDragSourceSite GtkDragSourceSite;
	42	typedef struct _GtkDragSourceInfo GtkDragSourceInfo;
	43	typedef struct _GtkDragDestSite GtkDragDestSite;
	44	typedef struct _GtkDragDestInfo GtkDragDestInfo;
	45	typedef struct _GtkDragAnim GtkDragAnim;
	46	typedef struct _GtkDragFindData GtkDragFindData;
	47
	48
	49	typedef enum
	50	{
	51	GTK_DRAG_STATUS_DRAG,
	52	GTK_DRAG_STATUS_WAIT,
	53	GTK_DRAG_STATUS_DROP
	54	} GtkDragStatus;
	55
	56	struct _GtkDragSourceSite
	57	{
	58	GdkModifierType start_button_mask;
	59	GtkTargetList target_list; / Targets for drag data */
	60	GdkDragAction actions; /* Possible actions */
	61	GdkColormap colormap; / Colormap for drag icon */
	62	GdkPixmap pixmap; / Icon for drag data */
	63	GdkBitmap *mask;
	64
	65	/* Stored button press information to detect drag beginning */
	66	gint state;
	67	gint x, y;
	68	};
	69
	70	struct _GtkDragSourceInfo
	71	{
	72	GtkWidget *widget;
	73	GtkTargetList target_list; / Targets for drag data */
	74	GdkDragAction possible_actions; /* Actions allowed by source */
	75	GdkDragContext context; / drag context */
	76	GtkWidget icon_window; / Window for drag */
	77	GtkWidget ipc_widget; / GtkInvisible for grab, message passing */
	78	GdkCursor cursor; / Cursor for drag */
	79	gint hot_x, hot_y; /* Hot spot for drag */
	80	gint button; /* mouse button starting drag */
	81
	82	GtkDragStatus status; /* drag status */
	83	GdkEvent last_event; / motion event waiting for response */
	84
	85	gint start_x, start_y; /* Initial position */
	86	gint cur_x, cur_y; /* Current Position */
	87
	88	GList selections; / selections we've claimed */
	89
	90	GtkDragDestInfo proxy_dest; / Set if this is a proxy drag */
	91
	92	guint drop_timeout; /* Timeout for aborting drop */
	93	guint destroy_icon : 1; /* If true, destroy icon_window
	94	*/
	95	};
	96
	97	struct _GtkDragDestSite
	98	{
	99	GtkDestDefaults flags;
	100	GtkTargetList *target_list;
	101	GdkDragAction actions;
	102	GdkWindow *proxy_window;
	103	GdkDragProtocol proxy_protocol;
	104	gboolean do_proxy : 1;
	105	gboolean proxy_coords : 1;
	106	gboolean have_drag : 1;
	107	};
	108
	109	struct _GtkDragDestInfo
	110	{
	111	GtkWidget widget; / Widget in which drag is in */
	112	GdkDragContext context; / Drag context */
	113	GtkDragSourceInfo proxy_source; / Set if this is a proxy drag */
	114	GtkSelectionData proxy_data; / Set while retrieving proxied data */
	115	gboolean dropped : 1; /* Set after we receive a drop */
	116	guint32 proxy_drop_time; /* Timestamp for proxied drop */
	117	gboolean proxy_drop_wait : 1; /* Set if we are waiting for a
	118	* status reply before sending
	119	* a proxied drop on.
	120	*/
	121	gint drop_x, drop_y; /* Position of drop */
	122	};
	123
	124	#define DROP_ABORT_TIME 300000
	125
	126	#define ANIM_STEP_TIME 50
	127	#define ANIM_STEP_LENGTH 50
	128	#define ANIM_MIN_STEPS 5
	129	#define ANIM_MAX_STEPS 10
	130
	131	struct _GtkDragAnim
	132	{
	133	GtkDragSourceInfo *info;
	134	gint step;
	135	gint n_steps;
	136	};
	137
	138	struct _GtkDragFindData
	139	{
	140	gint x;
	141	gint y;
	142	GdkDragContext *context;
	143	GtkDragDestInfo *info;
	144	gboolean found;
	145	gboolean toplevel;
	146	gboolean (callback) (GtkWidget widget, GdkDragContext *context,
	147	gint x, gint y, guint32 time);
	148	guint32 time;
	149	};
	150
	151	/* Enumeration for some targets we handle internally */
	152
	153	enum {
	154	TARGET_MOTIF_SUCCESS = 0x40000000,
	155	TARGET_MOTIF_FAILURE,
	156	TARGET_DELETE
	157	};
	158
	159	/* Drag icons */
	160
	161	static GdkPixmap *default_icon_pixmap = NULL;
	162	static GdkPixmap *default_icon_mask = NULL;
	163	static GdkColormap *default_icon_colormap = NULL;
	164	static gint default_icon_hot_x;
	165	static gint default_icon_hot_y;
	166
	167	/* Forward declarations */
	168	static void gtk_drag_get_event_actions (GdkEvent *event,
	169	gint button,
	170	GdkDragAction actions,
	171	GdkDragAction *suggested_action,
	172	GdkDragAction *possible_actions);
	173	static GdkCursor * gtk_drag_get_cursor (GdkDragAction action);
	174	static GtkWidget *gtk_drag_get_ipc_widget (void);
	175	static void gtk_drag_release_ipc_widget (GtkWidget *widget);
	176
	177	static void gtk_drag_highlight_paint (GtkWidget *widget);
	178	static gboolean gtk_drag_highlight_expose (GtkWidget *widget,
	179	GdkEventExpose *event,
	180	gpointer data);
	181
	182
	183	static GdkAtom gtk_drag_dest_find_target (GtkWidget *widget,
	184	GtkDragDestSite *site,
	185	GdkDragContext *context);
	186	static void gtk_drag_selection_received (GtkWidget *widget,
	187	GtkSelectionData *selection_data,
	188	guint32 time,
	189	gpointer data);
	190	static void gtk_drag_find_widget (GtkWidget *widget,
	191	GtkDragFindData *data);
	192	static void gtk_drag_proxy_begin (GtkWidget *widget,
	193	GtkDragDestInfo *dest_info);
	194	static void gtk_drag_dest_info_destroy (gpointer data);
	195	static void gtk_drag_dest_realized (GtkWidget *widget);
	196	static void gtk_drag_dest_site_destroy (gpointer data);
	197	static void gtk_drag_dest_leave (GtkWidget *widget,
	198	GdkDragContext *context,
	199	guint time);
	200	static gboolean gtk_drag_dest_motion (GtkWidget *widget,
	201	GdkDragContext *context,
	202	gint x,
	203	gint y,
	204	guint time);
	205	static gboolean gtk_drag_dest_drop (GtkWidget *widget,
	206	GdkDragContext *context,
	207	gint x,
	208	gint y,
	209	guint time);
	210
	211	static void gtk_drag_source_check_selection (GtkDragSourceInfo *info,
	212	GdkAtom selection,
	213	guint32 time);
	214	static void gtk_drag_source_release_selections (GtkDragSourceInfo *info,
	215	guint32 time);
	216	static void gtk_drag_drop (GtkDragSourceInfo *info,
	217	guint32 time);
	218	static void gtk_drag_drop_finished (GtkDragSourceInfo *info,
	219	gboolean success,
	220	guint time);
	221
	222	static gint gtk_drag_source_event_cb (GtkWidget *widget,
	223	GdkEvent *event,
	224	gpointer data);
	225	static void gtk_drag_source_site_destroy (gpointer data);
	226	static void gtk_drag_selection_get (GtkWidget *widget,
	227	GtkSelectionData *selection_data,
	228	guint sel_info,
	229	guint32 time,
	230	gpointer data);
	231	static gint gtk_drag_anim_timeout (gpointer data);
	232	static void gtk_drag_remove_icon (GtkDragSourceInfo *info);
	233	static void gtk_drag_source_info_destroy (gpointer data);
	234	static void gtk_drag_update (GtkDragSourceInfo *info,
	235	gint x_root,
	236	gint y_root,
	237	GdkEvent *event);
	238	static gint gtk_drag_motion_cb (GtkWidget *widget,
	239	GdkEventMotion *event,
	240	gpointer data);
	241	static gint gtk_drag_key_cb (GtkWidget *widget,
	242	GdkEventKey *event,
	243	gpointer data);
	244	static gint gtk_drag_button_release_cb (GtkWidget *widget,
	245	GdkEventButton *event,
	246	gpointer data);
	247	static gint gtk_drag_abort_timeout (gpointer data);
	248
	249	/************************
	250	* Cursor and Icon data *
	251	************************/
	252
	253	#define action_ask_width 16
	254	#define action_ask_height 16
	255	static const guchar action_ask_bits[] = {
	256	0x00, 0x00, 0xfe, 0x7f, 0xfe, 0x1f, 0x06, 0xc0, 0x76, 0xf8, 0xb6, 0xf7,
	257	0xd6, 0xec, 0x66, 0xdb, 0x66, 0xdb, 0x96, 0xec, 0x76, 0xf7, 0x76, 0xfb,
	258	0xf6, 0xfc, 0x72, 0xfb, 0x7a, 0xfb, 0xf8, 0xfc, };
	259
	260	#define action_ask_mask_width 16
	261	#define action_ask_mask_height 16
	262	static const guchar action_ask_mask_bits[] = {
	263	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x8f, 0x07, 0xcf, 0x0f,
	264	0xef, 0x1f, 0xff, 0x3c, 0xff, 0x3c, 0x6f, 0x1f, 0x8f, 0x0f, 0x8f, 0x07,
	265	0x0f, 0x03, 0x8f, 0x07, 0x87, 0x07, 0x07, 0x03, };
	266
	267	#define action_copy_width 16
	268	#define action_copy_height 16
	269	static const guchar action_copy_bits[] = {
	270	0x00, 0x00, 0xfe, 0x7f, 0xfe, 0x1f, 0x06, 0xc0, 0x76, 0xfb, 0x76, 0xfb,
	271	0x76, 0xfb, 0x06, 0x83, 0xf6, 0xbf, 0xf6, 0xbf, 0x06, 0x83, 0x76, 0xfb,
	272	0x76, 0xfb, 0x72, 0xfb, 0x7a, 0xf8, 0xf8, 0xff, };
	273
	274	#define action_copy_mask_width 16
	275	#define action_copy_mask_height 16
	276	static const guchar action_copy_mask_bits[] = {
	277	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x8f, 0x07, 0x8f, 0x07,
	278	0x8f, 0x07, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0x8f, 0x07,
	279	0x8f, 0x07, 0x8f, 0x07, 0x87, 0x07, 0x07, 0x00, };
	280
	281	#define action_move_width 16
	282	#define action_move_height 16
	283	static const guchar action_move_bits[] = {
	284	0x00, 0x00, 0xfe, 0x7f, 0xfe, 0x1f, 0x06, 0xc0, 0x96, 0xff, 0x26, 0xff,
	285	0xc6, 0xf8, 0xd6, 0xe3, 0x96, 0x8f, 0xb6, 0xbf, 0x36, 0xc3, 0x76, 0xfb,
	286	0x76, 0xfa, 0xf2, 0xfa, 0xfa, 0xf8, 0xf8, 0xff, };
	287
	288	#define action_move_mask_width 16
	289	#define action_move_mask_height 16
	290	static const guchar action_move_mask_bits[] = {
	291	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x6f, 0x00, 0xff, 0x00,
	292	0xff, 0x07, 0xef, 0x1f, 0xef, 0x7f, 0xcf, 0x7f, 0xcf, 0x3f, 0x8f, 0x07,
	293	0x8f, 0x07, 0x0f, 0x07, 0x07, 0x07, 0x07, 0x00, };
	294
	295	#define action_link_width 16
	296	#define action_link_height 16
	297	static const guchar action_link_bits[] = {
	298	0x00, 0x00, 0xfe, 0x7f, 0xfe, 0x1f, 0x06, 0xc0, 0x36, 0xf8, 0xd6, 0xf7,
	299	0x66, 0xec, 0xa6, 0xe8, 0x26, 0xdf, 0xe6, 0xbd, 0xd6, 0xa7, 0xb6, 0xa8,
	300	0xb6, 0xb1, 0x72, 0xdf, 0xfa, 0xe0, 0xf8, 0xff, };
	301
	302	#define action_link_mask_width 16
	303	#define action_link_mask_height 16
	304	static const guchar action_link_mask_bits[] = {
	305	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xcf, 0x07, 0xef, 0x0f,
	306	0xff, 0x1f, 0x7f, 0x1f, 0xff, 0x3f, 0xff, 0x7f, 0xef, 0x7f, 0xcf, 0x77,
	307	0xcf, 0x7f, 0x8f, 0x3f, 0x07, 0x1f, 0x07, 0x00, };
	308
	309	#define action_none_width 16
	310	#define action_none_height 16
	311	static const guchar action_none_bits[] = {
	312	0x00, 0x00, 0xfe, 0x7f, 0xfe, 0x1f, 0x06, 0xc0, 0xf6, 0xff, 0xf6, 0xff,
	313	0xf6, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, 0xff,
	314	0xf6, 0xff, 0xf2, 0xff, 0xfa, 0xff, 0xf8, 0xff, };
	315
	316	#define action_none_mask_width 16
	317	#define action_none_mask_height 16
	318	static const guchar action_none_mask_bits[] = {
	319	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x0f, 0x00, 0x0f, 0x00,
	320	0x0f, 0x00, 0x0f, 0x00, 0x0f, 0x00, 0x0f, 0x00, 0x0f, 0x00, 0x0f, 0x00,
	321	0x0f, 0x00, 0x0f, 0x00, 0x07, 0x00, 0x07, 0x00, };
	322
	323	#define CURSOR_WIDTH 16
	324	#define CURSOR_HEIGHT 16
	325
	326	static struct {
	327	GdkDragAction action;
	328	const char *bits;
	329	const char *mask;
	330	GdkCursor *cursor;
	331	} drag_cursors[] = {
	332	{ GDK_ACTION_DEFAULT, 0 },
	333	{ GDK_ACTION_ASK, action_ask_bits, action_ask_mask_bits, NULL },
	334	{ GDK_ACTION_COPY, action_copy_bits, action_copy_mask_bits, NULL },
	335	{ GDK_ACTION_MOVE, action_move_bits, action_move_mask_bits, NULL },
	336	{ GDK_ACTION_LINK, action_link_bits, action_link_mask_bits, NULL },
	337	{ 0 , action_none_bits, action_none_mask_bits, NULL },
	338	};
	339
	340	static const gint n_drag_cursors = sizeof (drag_cursors) / sizeof (drag_cursors[0]);
	341
	342	/* XPM */
	343	static const char *drag_default_xpm[] = {
	344	"32 32 3 1",
	345	" c None",
	346	". c #000000",
	347	"+ c #FFFFFF",
	348	" ",
	349	" ",
	350	" .. ",
	351	" ..+. ",
	352	" ..++.. ",
	353	" ...++++. ",
	354	" ...++++++.. ",
	355	" ...+++++++++. ",
	356	" ...+++++++++++.. ",
	357	" ..+.++++++++++++.. ",
	358	" .++.++++++++++++.. ",
	359	" .+++.++++++++++++.. ",
	360	" .++++.++++++++++++. ",
	361	" .+++.+++++++++++++.. ",
	362	" .++.+++++++++++++++.. ",
	363	" .+.+++++++++++++++++.. ",
	364	" ..+++++++++++++++++++.. ",
	365	" ..++++++++++++++++++++. ",
	366	" .++++++++++++++++++++.. ",
	367	" ..+++++++++++++++++.. ",
	368	" .++++++++++++++++.. ",
	369	" ..+++++++++++++... ",
	370	" .++++++++++++.. ",
	371	" ..+++++++++.. ",
	372	" .++++++++.. ",
	373	" ..++++++.. ",
	374	" .+++++.. ",
	375	" .++.. ",
	376	" ... ",
	377	" .. ",
	378	" ",
	379	" "};
	380
	381	/*********************
	382	* Utility functions *
	383	*********************/
	384
	385	/*************************************************************
	386	* gtk_drag_get_ipc_widget:
	387	* Return a invisible, off-screen, override-redirect
	388	* widget for IPC.
	389	* arguments:
	390	*
	391	* results:
	392	*************************************************************/
	393
	394	static GtkWidget *
	395	gtk_drag_get_ipc_widget (void)
	396	{
	397	GtkWidget *result;
	398
	399	if (drag_widgets)
	400	{
	401	GSList *tmp = drag_widgets;
	402	result = drag_widgets->data;
	403	drag_widgets = drag_widgets->next;
	404	g_slist_free_1 (tmp);
	405	}
	406	else
	407	{
	408	result = gtk_invisible_new ();
	409	gtk_widget_show (result);
	410	}
	411
	412	return result;
	413	}
	414
	415	/***************************************************************
	416	* gtk_drag_release_ipc_widget:
	417	* Releases widget retrieved with gtk_drag_get_ipc_widget ()
	418	* arguments:
	419	* widget: the widget to release.
	420	* results:
	421	***************************************************************/
	422
	423	static void
	424	gtk_drag_release_ipc_widget (GtkWidget *widget)
	425	{
	426	drag_widgets = g_slist_prepend (drag_widgets, widget);
	427	}
	428
	429	static guint32
	430	gtk_drag_get_event_time (GdkEvent *event)
	431	{
	432	guint32 tm = GDK_CURRENT_TIME;
	433
	434	if (event)
	435	switch (event->type)
	436	{
	437	case GDK_MOTION_NOTIFY:
	438	tm = event->motion.time; break;
	439	case GDK_BUTTON_PRESS:
	440	case GDK_2BUTTON_PRESS:
	441	case GDK_3BUTTON_PRESS:
	442	case GDK_BUTTON_RELEASE:
	443	tm = event->button.time; break;
	444	case GDK_KEY_PRESS:
	445	case GDK_KEY_RELEASE:
	446	tm = event->key.time; break;
	447	case GDK_ENTER_NOTIFY:
	448	case GDK_LEAVE_NOTIFY:
	449	tm = event->crossing.time; break;
	450	case GDK_PROPERTY_NOTIFY:
	451	tm = event->property.time; break;
	452	case GDK_SELECTION_CLEAR:
	453	case GDK_SELECTION_REQUEST:
	454	case GDK_SELECTION_NOTIFY:
	455	tm = event->selection.time; break;
	456	case GDK_PROXIMITY_IN:
	457	case GDK_PROXIMITY_OUT:
	458	tm = event->proximity.time; break;
	459	default: /* use current time */
	460	break;
	461	}
	462
	463	return tm;
	464	}
	465
	466	static void
	467	gtk_drag_get_event_actions (GdkEvent *event,
	468	gint button,
	469	GdkDragAction actions,
	470	GdkDragAction *suggested_action,
	471	GdkDragAction *possible_actions)
	472	{
	473	*suggested_action = 0;
	474	*possible_actions = 0;
	475
	476	if (event)
	477	{
	478	GdkModifierType state = 0;
	479
	480	switch (event->type)
	481	{
	482	case GDK_MOTION_NOTIFY:
	483	state = event->motion.state;
	484	break;
	485	case GDK_BUTTON_PRESS:
	486	case GDK_2BUTTON_PRESS:
	487	case GDK_3BUTTON_PRESS:
	488	case GDK_BUTTON_RELEASE:
	489	state = event->button.state;
	490	break;
	491	case GDK_KEY_PRESS:
	492	case GDK_KEY_RELEASE:
	493	state = event->key.state;
	494	break;
	495	case GDK_ENTER_NOTIFY:
	496	case GDK_LEAVE_NOTIFY:
	497	state = event->crossing.state;
	498	break;
	499	default:
	500	break;
	501	}
	502
	503	if ((button == 2 \|\| button == 3) && (actions & GDK_ACTION_ASK))
	504	{
	505	*suggested_action = GDK_ACTION_ASK;
	506	*possible_actions = actions;
	507	}
	508	else if (state & (GDK_SHIFT_MASK \| GDK_CONTROL_MASK))
	509	{
	510	if ((state & GDK_SHIFT_MASK) && (state & GDK_CONTROL_MASK))
	511	{
	512	if (actions & GDK_ACTION_LINK)
	513	{
	514	*suggested_action = GDK_ACTION_LINK;
	515	*possible_actions = GDK_ACTION_LINK;
	516	}
	517	}
	518	else if (state & GDK_CONTROL_MASK)
	519	{
	520	if (actions & GDK_ACTION_COPY)
	521	{
	522	*suggested_action = GDK_ACTION_COPY;
	523	*possible_actions = GDK_ACTION_COPY;
	524	}
	525	return;
	526	}
	527	else
	528	{
	529	if (actions & GDK_ACTION_MOVE)
	530	{
	531	*suggested_action = GDK_ACTION_MOVE;
	532	*possible_actions = GDK_ACTION_MOVE;
	533	}
	534	return;
	535	}
	536	}
	537	else
	538	{
	539	*possible_actions = actions;
	540
	541	if ((state & (GDK_MOD1_MASK)) && (actions & GDK_ACTION_ASK))
	542	*suggested_action = GDK_ACTION_ASK;
	543	else if (actions & GDK_ACTION_COPY)
	544	*suggested_action = GDK_ACTION_COPY;
	545	else if (actions & GDK_ACTION_MOVE)
	546	*suggested_action = GDK_ACTION_MOVE;
	547	else if (actions & GDK_ACTION_LINK)
	548	*suggested_action = GDK_ACTION_LINK;
	549	}
	550	}
	551	else
	552	{
	553	*possible_actions = actions;
	554
	555	if (actions & GDK_ACTION_COPY)
	556	*suggested_action = GDK_ACTION_COPY;
	557	else if (actions & GDK_ACTION_MOVE)
	558	*suggested_action = GDK_ACTION_MOVE;
	559	else if (actions & GDK_ACTION_LINK)
	560	*suggested_action = GDK_ACTION_LINK;
	561	}
	562
	563	return;
	564	}
	565
	566	static GdkCursor *
	567	gtk_drag_get_cursor (GdkDragAction action)
	568	{
	569	gint i;
	570
	571	for (i = 0 ; i < n_drag_cursors - 1; i++)
	572	if (drag_cursors[i].action == action)
	573	break;
	574
	575	if (drag_cursors[i].cursor == NULL)
	576	{
	577	GdkColor fg, bg;
	578
	579	GdkPixmap *pixmap =
	580	gdk_bitmap_create_from_data (NULL,
	581	drag_cursors[i].bits,
	582	CURSOR_WIDTH, CURSOR_HEIGHT);
	583	GdkPixmap *mask =
	584	gdk_bitmap_create_from_data (NULL,
	585	drag_cursors[i].mask,
	586	CURSOR_WIDTH, CURSOR_HEIGHT);
	587
	588	gdk_color_white (gdk_colormap_get_system (), &bg);
	589	gdk_color_black (gdk_colormap_get_system (), &fg);
	590
	591	drag_cursors[i].cursor = gdk_cursor_new_from_pixmap (pixmap, mask, &fg, &bg, 0, 0);
	592
	593	gdk_pixmap_unref (pixmap);
	594	gdk_pixmap_unref (mask);
	595	}
	596
	597	return drag_cursors[i].cursor;
	598	}
	599
	600	/********************
	601	* Destination side *
	602	********************/
	603
	604	/*************************************************************
	605	* gtk_drag_get_data:
	606	* Get the data for a drag or drop
	607	* arguments:
	608	* context - drag context
	609	* target - format to retrieve the data in.
	610	* time - timestamp of triggering event.
	611	*
	612	* results:
	613	*************************************************************/
	614
	615	void
	616	gtk_drag_get_data (GtkWidget *widget,
	617	GdkDragContext *context,
	618	GdkAtom target,
	619	guint32 time)
	620	{
	621	GtkWidget *selection_widget;
	622
	623	g_return_if_fail (widget != NULL);
	624	g_return_if_fail (context != NULL);
	625
	626	selection_widget = gtk_drag_get_ipc_widget ();
	627
	628	gdk_drag_context_ref (context);
	629	gtk_widget_ref (widget);
	630
	631	gtk_signal_connect (GTK_OBJECT (selection_widget), "selection_received",
	632	GTK_SIGNAL_FUNC (gtk_drag_selection_received), widget);
	633
	634	gtk_object_set_data (GTK_OBJECT (selection_widget), "drag-context", context);
	635
	636	gtk_selection_convert (selection_widget,
	637	gdk_drag_get_selection (context),
	638	target,
	639	time);
	640	}
	641
	642
	643	/*************************************************************
	644	* gtk_drag_get_source_widget:
	645	* Get the widget the was the source of this drag, if
	646	* the drag originated from this application.
	647	* arguments:
	648	* context: The drag context for this drag
	649	* results:
	650	* The source widget, or NULL if the drag originated from
	651	* a different application.
	652	*************************************************************/
	653
	654	GtkWidget *
	655	gtk_drag_get_source_widget (GdkDragContext *context)
	656	{
	657	GSList *tmp_list;
	658
	659	tmp_list = source_widgets;
	660	while (tmp_list)
	661	{
	662	GtkWidget *ipc_widget = tmp_list->data;
	663
	664	if (ipc_widget->window == context->source_window)
	665	{
	666	GtkDragSourceInfo *info;
	667	info = gtk_object_get_data (GTK_OBJECT (ipc_widget), "gtk-info");
	668
	669	return info ? info->widget : NULL;
	670	}
	671
	672	tmp_list = tmp_list->next;
	673	}
	674
	675	return NULL;
	676	}
	677
	678	/*************************************************************
	679	* gtk_drag_finish:
	680	* Notify the drag source that the transfer of data
	681	* is complete.
	682	* arguments:
	683	* context: The drag context for this drag
	684	* success: Was the data successfully transferred?
	685	* time: The timestamp to use when notifying the destination.
	686	* results:
	687	*************************************************************/
	688
	689	void
	690	gtk_drag_finish (GdkDragContext *context,
	691	gboolean success,
	692	gboolean del,
	693	guint32 time)
	694	{
	695	GdkAtom target = GDK_NONE;
	696
	697	g_return_if_fail (context != NULL);
	698
	699	if (success && del)
	700	{
	701	target = gdk_atom_intern ("DELETE", FALSE);
	702	}
	703	else if (context->protocol == GDK_DRAG_PROTO_MOTIF)
	704	{
	705	target = gdk_atom_intern (success ?
	706	"XmTRANSFER_SUCCESS" :
	707	"XmTRANSFER_FAILURE",
	708	FALSE);
	709	}
	710
	711	if (target != GDK_NONE)
	712	{
	713	GtkWidget *selection_widget = gtk_drag_get_ipc_widget ();
	714
	715	gdk_drag_context_ref (context);
	716
	717	gtk_object_set_data (GTK_OBJECT (selection_widget), "drag-context", context);
	718	gtk_signal_connect (GTK_OBJECT (selection_widget), "selection_received",
	719	GTK_SIGNAL_FUNC (gtk_drag_selection_received),
	720	NULL);
	721
	722	gtk_selection_convert (selection_widget,
	723	gdk_drag_get_selection (context),
	724	target,
	725	time);
	726	}
	727
	728	if (!del)
	729	gdk_drop_finish (context, success, time);
	730	}
	731
	732	/*************************************************************
	733	* gtk_drag_highlight_paint:
	734	* Paint a highlight indicating drag status onto the widget.
	735	* arguments:
	736	* widget:
	737	* results:
	738	*************************************************************/
	739
	740	static void
	741	gtk_drag_highlight_paint (GtkWidget *widget)
	742	{
	743	gint x, y, width, height;
	744
	745	g_return_if_fail (widget != NULL);
	746
	747	if (GTK_WIDGET_DRAWABLE (widget))
	748	{
	749	if (GTK_WIDGET_NO_WINDOW (widget))
	750	{
	751	x = widget->allocation.x;
	752	y = widget->allocation.y;
	753	width = widget->allocation.width;
	754	height = widget->allocation.height;
	755	}
	756	else
	757	{
	758	x = 0;
	759	y = 0;
	760	gdk_window_get_size (widget->window, &width, &height);
	761	}
	762
	763	gtk_draw_shadow (widget->style, widget->window,
	764	GTK_STATE_NORMAL, GTK_SHADOW_OUT,
	765	x, y, width, height);
	766
	767	gdk_draw_rectangle (widget->window,
	768	widget->style->black_gc,
	769	FALSE,
	770	x, y, width - 1, height - 1);
	771	}
	772	}
	773
	774	/*************************************************************
	775	* gtk_drag_highlight_expose:
	776	* Callback for expose_event for highlighted widgets.
	777	* arguments:
	778	* widget:
	779	* event:
	780	* data:
	781	* results:
	782	*************************************************************/
	783
	784	static gboolean
	785	gtk_drag_highlight_expose (GtkWidget *widget,
	786	GdkEventExpose *event,
	787	gpointer data)
	788	{
	789	gtk_drag_highlight_paint (widget);
	790	return TRUE;
	791	}
	792
	793	/*************************************************************
	794	* gtk_drag_highlight:
	795	* Highlight the given widget in the default manner.
	796	* arguments:
	797	* widget:
	798	* results:
	799	*************************************************************/
	800
	801	void
	802	gtk_drag_highlight (GtkWidget *widget)
	803	{
	804	gtk_signal_connect_after (GTK_OBJECT (widget), "draw",
	805	GTK_SIGNAL_FUNC (gtk_drag_highlight_paint),
	806	NULL);
	807	gtk_signal_connect (GTK_OBJECT (widget), "expose_event",
	808	GTK_SIGNAL_FUNC (gtk_drag_highlight_expose),
	809	NULL);
	810
	811	gtk_widget_queue_draw (widget);
	812	}
	813
	814	/*************************************************************
	815	* gtk_drag_unhighlight:
	816	* Refresh the given widget to remove the highlight.
	817	* arguments:
	818	* widget:
	819	* results:
	820	*************************************************************/
	821
	822	void
	823	gtk_drag_unhighlight (GtkWidget *widget)
	824	{
	825	g_return_if_fail (widget != NULL);
	826
	827	gtk_signal_disconnect_by_func (GTK_OBJECT (widget),
	828	GTK_SIGNAL_FUNC (gtk_drag_highlight_paint),
	829	NULL);
	830	gtk_signal_disconnect_by_func (GTK_OBJECT (widget),
	831	GTK_SIGNAL_FUNC (gtk_drag_highlight_expose),
	832	NULL);
	833
	834	gtk_widget_queue_clear (widget);
	835	}
	836
	837	/*************************************************************
	838	* gtk_drag_dest_set:
	839	* Register a drop site, and possibly add default behaviors.
	840	* arguments:
	841	* widget:
	842	* flags: Which types of default drag behavior to use
	843	* targets: Table of targets that can be accepted
	844	* n_targets: Number of of entries in targets
	845	* actions:
	846	* results:
	847	*************************************************************/
	848
	849	void
	850	gtk_drag_dest_set (GtkWidget *widget,
	851	GtkDestDefaults flags,
	852	const GtkTargetEntry *targets,
	853	gint n_targets,
	854	GdkDragAction actions)
	855	{
	856	GtkDragDestSite *site;
	857
	858	g_return_if_fail (widget != NULL);
	859
	860	/* HACK, do this in the destroy */
	861	site = gtk_object_get_data (GTK_OBJECT (widget), "gtk-drag-dest");
	862	if (site)
	863	gtk_signal_disconnect_by_data (GTK_OBJECT (widget), site);
	864
	865	if (GTK_WIDGET_REALIZED (widget))
	866	gtk_drag_dest_realized (widget);
	867
	868	gtk_signal_connect (GTK_OBJECT (widget), "realize",
	869	GTK_SIGNAL_FUNC (gtk_drag_dest_realized), NULL);
	870
	871	site = g_new (GtkDragDestSite, 1);
	872
	873	site->flags = flags;
	874	site->have_drag = FALSE;
	875	if (targets)
	876	site->target_list = gtk_target_list_new (targets, n_targets);
	877	else
	878	site->target_list = NULL;
	879
	880	site->actions = actions;
	881	site->do_proxy = FALSE;
	882
	883	gtk_object_set_data_full (GTK_OBJECT (widget), "gtk-drag-dest",
	884	site, gtk_drag_dest_site_destroy);
	885	}
	886
	887	/*************************************************************
	888	* gtk_drag_dest_set_proxy:
	889	* Set up this widget to proxy drags elsewhere.
	890	* arguments:
	891	* widget:
	892	* proxy_window: window to which forward drag events
	893	* protocol: Drag protocol which the dest widget accepts
	894	* use_coordinates: If true, send the same coordinates to the
	895	* destination, because it is a embedded
	896	* subwindow.
	897	* results:
	898	*************************************************************/
	899
	900	void
	901	gtk_drag_dest_set_proxy (GtkWidget *widget,
	902	GdkWindow *proxy_window,
	903	GdkDragProtocol protocol,
	904	gboolean use_coordinates)
	905	{
	906	GtkDragDestSite *site;
	907
	908	g_return_if_fail (widget != NULL);
	909
	910	/* HACK, do this in the destroy */
	911	site = gtk_object_get_data (GTK_OBJECT (widget), "gtk-drag-dest");
	912	if (site)
	913	gtk_signal_disconnect_by_data (GTK_OBJECT (widget), site);
	914
	915	if (GTK_WIDGET_REALIZED (widget))
	916	gtk_drag_dest_realized (widget);
	917
	918	gtk_signal_connect (GTK_OBJECT (widget), "realize",
	919	GTK_SIGNAL_FUNC (gtk_drag_dest_realized), NULL);
	920
	921	site = g_new (GtkDragDestSite, 1);
	922
	923	site->flags = 0;
	924	site->have_drag = FALSE;
	925	site->target_list = NULL;
	926	site->actions = 0;
	927	site->proxy_window = proxy_window;
	928	if (proxy_window)
	929	gdk_window_ref (proxy_window);
	930	site->do_proxy = TRUE;
	931	site->proxy_protocol = protocol;
	932	site->proxy_coords = use_coordinates;
	933
	934	gtk_object_set_data_full (GTK_OBJECT (widget), "gtk-drag-dest",
	935	site, gtk_drag_dest_site_destroy);
	936	}
	937
	938	/*************************************************************
	939	* gtk_drag_dest_unset
	940	* Unregister this widget as a drag target.
	941	* arguments:
	942	* widget:
	943	* results:
	944	*************************************************************/
	945
	946	void
	947	gtk_drag_dest_unset (GtkWidget *widget)
	948	{
	949	g_return_if_fail (widget != NULL);
	950
	951	gtk_object_set_data (GTK_OBJECT (widget), "gtk-drag-dest", NULL);
	952	}
	953
	954	/*************************************************************
	955	* gtk_drag_dest_handle_event:
	956	* Called from widget event handling code on Drag events
	957	* for destinations.
	958	*
	959	* arguments:
	960	* toplevel: Toplevel widget that received the event
	961	* event:
	962	* results:
	963	*************************************************************/
	964
	965	void
	966	gtk_drag_dest_handle_event (GtkWidget *toplevel,
	967	GdkEvent *event)
	968	{
	969	GtkDragDestInfo *info;
	970	GdkDragContext *context;
	971
	972	g_return_if_fail (toplevel != NULL);
	973	g_return_if_fail (event != NULL);
	974
	975	context = event->dnd.context;
	976
	977	info = g_dataset_get_data (context, "gtk-info");
	978	if (!info)
	979	{
	980	info = g_new (GtkDragDestInfo, 1);
	981	info->widget = NULL;
	982	info->context = event->dnd.context;
	983	info->proxy_source = NULL;
	984	info->proxy_data = NULL;
	985	info->dropped = FALSE;
	986	info->proxy_drop_wait = FALSE;
	987	g_dataset_set_data_full (context,
	988	"gtk-info",
	989	info,
	990	gtk_drag_dest_info_destroy);
	991	}
	992
	993	/* Find the widget for the event */
	994	switch (event->type)
	995	{
	996	case GDK_DRAG_ENTER:
	997	break;
	998
	999	case GDK_DRAG_LEAVE:
	1000	if (info->widget)
	1001	{
	1002	gtk_drag_dest_leave (info->widget, context, event->dnd.time);
	1003	info->widget = NULL;
	1004	}
	1005	break;
	1006
	1007	case GDK_DRAG_MOTION:
	1008	case GDK_DROP_START:
	1009	{
	1010	GtkDragFindData data;
	1011	gint tx, ty;
	1012
	1013	if (event->type == GDK_DROP_START)
	1014	{
	1015	info->dropped = TRUE;
	1016	/* We send a leave here so that the widget unhighlights
	1017	* properly.
	1018	*/
	1019	if (info->widget)
	1020	{
	1021	gtk_drag_dest_leave (info->widget, context, event->dnd.time);
	1022	info->widget = NULL;
	1023	}
	1024	}
	1025
	1026	gdk_window_get_origin (toplevel->window, &tx, &ty);
	1027
	1028	data.x = event->dnd.x_root - tx;
	1029	data.y = event->dnd.y_root - ty;
	1030	data.context = context;
	1031	data.info = info;
	1032	data.found = FALSE;
	1033	data.toplevel = TRUE;
	1034	data.callback = (event->type == GDK_DRAG_MOTION) ?
	1035	gtk_drag_dest_motion : gtk_drag_dest_drop;
	1036	data.time = event->dnd.time;
	1037
	1038	gtk_drag_find_widget (toplevel, &data);
	1039
	1040	if (info->widget && !data.found)
	1041	{
	1042	gtk_drag_dest_leave (info->widget, context, event->dnd.time);
	1043	info->widget = NULL;
	1044	}
	1045
	1046	/* Send a reply.
	1047	*/
	1048	if (event->type == GDK_DRAG_MOTION)
	1049	{
	1050	if (!data.found)
	1051	gdk_drag_status (context, 0, event->dnd.time);
	1052	}
	1053	else if (event->type == GDK_DROP_START && !info->proxy_source)
	1054	{
	1055	gdk_drop_reply (context, data.found, event->dnd.time);
	1056	if ((context->protocol == GDK_DRAG_PROTO_MOTIF) && !data.found)
	1057	gtk_drag_finish (context, FALSE, FALSE, event->dnd.time);
	1058	}
	1059	}
	1060	break;
	1061
	1062	default:
	1063	g_assert_not_reached ();
	1064	}
	1065	}
	1066
	1067	/*************************************************************
	1068	* gtk_drag_dest_find_target:
	1069	* Decide on a target for the drag.
	1070	* arguments:
	1071	* site:
	1072	* context:
	1073	* results:
	1074	*************************************************************/
	1075
	1076	static GdkAtom
	1077	gtk_drag_dest_find_target (GtkWidget *widget,
	1078	GtkDragDestSite *site,
	1079	GdkDragContext *context)
	1080	{
	1081	GList *tmp_target;
	1082	GList *tmp_source = NULL;
	1083	GtkWidget *source_widget = gtk_drag_get_source_widget (context);
	1084
	1085	tmp_target = site->target_list->list;
	1086	while (tmp_target)
	1087	{
	1088	GtkTargetPair *pair = tmp_target->data;
	1089	tmp_source = context->targets;
	1090	while (tmp_source)
	1091	{
	1092	if (tmp_source->data == GUINT_TO_POINTER (pair->target))
	1093	{
	1094	if ((!(pair->flags & GTK_TARGET_SAME_APP) \|\| source_widget) &&
	1095	(!(pair->flags & GTK_TARGET_SAME_WIDGET) \|\| (source_widget == widget)))
	1096	return pair->target;
	1097	else
	1098	break;
	1099	}
	1100	tmp_source = tmp_source->next;
	1101	}
	1102	tmp_target = tmp_target->next;
	1103	}
	1104
	1105	return GDK_NONE;
	1106	}
	1107
	1108	static void
	1109	gtk_drag_selection_received (GtkWidget *widget,
	1110	GtkSelectionData *selection_data,
	1111	guint32 time,
	1112	gpointer data)
	1113	{
	1114	GdkDragContext *context;
	1115	GtkDragDestInfo *info;
	1116	GtkWidget *drop_widget;
	1117
	1118	drop_widget = data;
	1119
	1120	context = gtk_object_get_data (GTK_OBJECT (widget), "drag-context");
	1121	info = g_dataset_get_data (context, "gtk-info");
	1122
	1123	if (info->proxy_data &&
	1124	info->proxy_data->target == selection_data->target)
	1125	{
	1126	gtk_selection_data_set (info->proxy_data,
	1127	selection_data->type,
	1128	selection_data->format,
	1129	selection_data->data,
	1130	selection_data->length);
	1131	gtk_main_quit ();
	1132	return;
	1133	}
	1134
	1135	if (selection_data->target == gdk_atom_intern ("DELETE", FALSE))
	1136	{
	1137	gtk_drag_finish (context, TRUE, FALSE, time);
	1138	}
	1139	else if ((selection_data->target == gdk_atom_intern ("XmTRANSFER_SUCCESS", FALSE)) \|\|
	1140	(selection_data->target == gdk_atom_intern ("XmTRANSFER_FAILURE", FALSE)))
	1141	{
	1142	/* Do nothing */
	1143	}
	1144	else
	1145	{
	1146	GtkDragDestSite *site;
	1147
	1148	site = gtk_object_get_data (GTK_OBJECT (drop_widget), "gtk-drag-dest");
	1149
	1150	if (site->target_list)
	1151	{
	1152	guint target_info;
	1153
	1154	if (gtk_target_list_find (site->target_list,
	1155	selection_data->target,
	1156	&target_info))
	1157	{
	1158	if (!(site->flags & GTK_DEST_DEFAULT_DROP) \|\|
	1159	selection_data->length >= 0)
	1160	gtk_signal_emit_by_name (GTK_OBJECT (drop_widget),
	1161	"drag_data_received",
	1162	context, info->drop_x, info->drop_y,
	1163	selection_data,
	1164	target_info, time);
	1165	}
	1166	}
	1167	else
	1168	{
	1169	gtk_signal_emit_by_name (GTK_OBJECT (drop_widget),
	1170	"drag_data_received",
	1171	context, info->drop_x, info->drop_y,
	1172	selection_data, 0, time);
	1173	}
	1174
	1175	if (site->flags & GTK_DEST_DEFAULT_DROP)
	1176	{
	1177
	1178	gtk_drag_finish (context,
	1179	(selection_data->length >= 0),
	1180	(context->action == GDK_ACTION_MOVE),
	1181	time);
	1182	}
	1183
	1184	gtk_widget_unref (drop_widget);
	1185	}
	1186
	1187	gtk_signal_disconnect_by_func (GTK_OBJECT (widget),
	1188	GTK_SIGNAL_FUNC (gtk_drag_selection_received),
	1189	data);
	1190
	1191	gtk_object_set_data (GTK_OBJECT (widget), "drag-context", NULL);
	1192	gdk_drag_context_unref (context);
	1193
	1194	gtk_drag_release_ipc_widget (widget);
	1195	}
	1196
[17070]	1197	static void
	1198	get_all_children_callback (GtkWidget *widget,
	1199	gpointer client_data)
	1200	{
	1201	GList **children;
	1202
	1203	children = (GList**) client_data;
	1204	gtk_widget_ref (widget);
	1205
	1206	children = g_list_prepend (children, widget);
	1207	}
	1208
	1209	static GList*
	1210	get_all_children (GtkContainer *container)
	1211	{
	1212	GList *children;
	1213
	1214	children = NULL;
	1215
	1216	gtk_container_forall (container,
	1217	get_all_children_callback,
	1218	&children);
	1219
	1220	return g_list_reverse (children);
	1221	}
	1222
	1223
	1224
[14481]	1225	/*************************************************************
	1226	* gtk_drag_find_widget:
	1227	* Recursive callback used to locate widgets for
	1228	* DRAG_MOTION and DROP_START events.
	1229	* arguments:
	1230	*
	1231	* results:
	1232	*************************************************************/
	1233
	1234	static void
	1235	gtk_drag_find_widget (GtkWidget *widget,
	1236	GtkDragFindData *data)
	1237	{
	1238	GtkAllocation new_allocation;
	1239	gint x_offset = 0;
	1240	gint y_offset = 0;
	1241
	1242	new_allocation = widget->allocation;
	1243
	1244	if (data->found \|\| !GTK_WIDGET_MAPPED (widget))
	1245	return;
	1246
	1247	/* Note that in the following code, we only count the
	1248	* position as being inside a WINDOW widget if it is inside
	1249	* widget->window; points that are outside of widget->window
	1250	* but within the allocation are not counted. This is consistent
	1251	* with the way we highlight drag targets.
	1252	*/
	1253	if (!GTK_WIDGET_NO_WINDOW (widget))
	1254	{
	1255	new_allocation.x = 0;
	1256	new_allocation.y = 0;
	1257	}
	1258
	1259	if (widget->parent)
	1260	{
	1261	GdkWindow *window = widget->window;
	1262	while (window != widget->parent->window)
	1263	{
	1264	gint tx, ty, twidth, theight;
	1265	gdk_window_get_size (window, &twidth, &theight);
	1266
	1267	if (new_allocation.x < 0)
	1268	{
	1269	new_allocation.width += new_allocation.x;
	1270	new_allocation.x = 0;
	1271	}
	1272	if (new_allocation.y < 0)
	1273	{
	1274	new_allocation.height += new_allocation.y;
	1275	new_allocation.y = 0;
	1276	}
	1277	if (new_allocation.x + new_allocation.width > twidth)
	1278	new_allocation.width = twidth - new_allocation.x;
	1279	if (new_allocation.y + new_allocation.height > theight)
	1280	new_allocation.height = theight - new_allocation.y;
	1281
	1282	gdk_window_get_position (window, &tx, &ty);
	1283	new_allocation.x += tx;
	1284	x_offset += tx;
	1285	new_allocation.y += ty;
	1286	y_offset += ty;
	1287
	1288	window = gdk_window_get_parent (window);
	1289	}
	1290	}
	1291
	1292	if (data->toplevel \|\|
	1293	((data->x >= new_allocation.x) && (data->y >= new_allocation.y) &&
	1294	(data->x < new_allocation.x + new_allocation.width) &&
	1295	(data->y < new_allocation.y + new_allocation.height)))
	1296	{
	1297	/* First, check if the drag is in a valid drop site in
	1298	* one of our children
	1299	*/
	1300	if (GTK_IS_CONTAINER (widget))
	1301	{
	1302	GtkDragFindData new_data = *data;
[17070]	1303	GList *children = get_all_children (GTK_CONTAINER (widget));
[15780]	1304	GList *tmp_list;
	1305
[14481]	1306	new_data.x -= x_offset;
	1307	new_data.y -= y_offset;
	1308	new_data.found = FALSE;
	1309	new_data.toplevel = FALSE;
[15780]	1310
	1311	tmp_list = children;
	1312	while (tmp_list)
	1313	{
	1314	GtkWidget *child = tmp_list->data;
	1315
	1316	if (child->parent == widget)
	1317	gtk_drag_find_widget (child, &new_data);
	1318
	1319	gtk_widget_unref (child);
	1320	tmp_list = tmp_list->next;
	1321	}
	1322
	1323	g_list_free (children);
	1324
[14481]	1325	data->found = new_data.found;
	1326	}
	1327
	1328	/* If not, and this widget is registered as a drop site, check to
	1329	* emit "drag_motion" to check if we are actually in
	1330	* a drop site.
	1331	*/
	1332	if (!data->found &&
	1333	gtk_object_get_data (GTK_OBJECT (widget), "gtk-drag-dest"))
	1334	{
	1335	data->found = data->callback (widget,
	1336	data->context,
[15780]	1337	data->x - x_offset,
	1338	data->y - y_offset,
[14481]	1339	data->time);
	1340	/* If so, send a "drag_leave" to the last widget */
	1341	if (data->found)
	1342	{
	1343	if (data->info->widget && data->info->widget != widget)
	1344	{
	1345	gtk_drag_dest_leave (data->info->widget, data->context, data->time);
	1346	}
	1347	data->info->widget = widget;
	1348	}
	1349	}
	1350	}
	1351	}
	1352
	1353	static void
	1354	gtk_drag_proxy_begin (GtkWidget *widget,
	1355	GtkDragDestInfo *dest_info)
	1356	{
	1357	GtkDragSourceInfo *source_info;
	1358	GList *tmp_list;
	1359
	1360	source_info = g_new0 (GtkDragSourceInfo, 1);
	1361	source_info->ipc_widget = gtk_drag_get_ipc_widget ();
	1362
	1363	source_info->widget = widget;
	1364	gtk_widget_ref (source_info->widget);
	1365	source_info->context = gdk_drag_begin (source_info->ipc_widget->window,
	1366	dest_info->context->targets);
	1367
	1368	source_info->target_list = gtk_target_list_new (NULL, 0);
	1369	tmp_list = dest_info->context->targets;
	1370	while (tmp_list)
	1371	{
	1372	gtk_target_list_add (source_info->target_list,
	1373	GPOINTER_TO_UINT (tmp_list->data), 0, 0);
	1374	tmp_list = tmp_list->next;
	1375	}
	1376
	1377	source_info->proxy_dest = dest_info;
	1378
	1379	g_dataset_set_data (source_info->context, "gtk-info", source_info);
	1380
	1381	gtk_signal_connect (GTK_OBJECT (source_info->ipc_widget),
	1382	"selection_get",
	1383	GTK_SIGNAL_FUNC (gtk_drag_selection_get),
	1384	source_info);
	1385
	1386	dest_info->proxy_source = source_info;
	1387	}
	1388
	1389	static void
	1390	gtk_drag_dest_info_destroy (gpointer data)
	1391	{
	1392	GtkDragDestInfo *info = data;
	1393
	1394	g_free (info);
	1395	}
	1396
	1397	static void
	1398	gtk_drag_dest_realized (GtkWidget *widget)
	1399	{
	1400	GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
	1401	gdk_window_register_dnd (toplevel->window);
	1402	}
	1403
	1404	static void
	1405	gtk_drag_dest_site_destroy (gpointer data)
	1406	{
	1407	GtkDragDestSite *site = data;
	1408
	1409	if (site->target_list)
	1410	gtk_target_list_unref (site->target_list);
	1411
	1412	g_free (site);
	1413	}
	1414
	1415	/*
	1416	* Default drag handlers
	1417	*/
	1418	static void
	1419	gtk_drag_dest_leave (GtkWidget *widget,
	1420	GdkDragContext *context,
	1421	guint time)
	1422	{
	1423	GtkDragDestSite *site;
	1424
	1425	site = gtk_object_get_data (GTK_OBJECT (widget), "gtk-drag-dest");
	1426	g_return_if_fail (site != NULL);
	1427
	1428	if (site->do_proxy)
	1429	{
	1430	GtkDragDestInfo *info = g_dataset_get_data (context, "gtk-info");
	1431
	1432	if (info->proxy_source && !info->dropped)
	1433	gdk_drag_abort (info->proxy_source->context, time);
	1434
	1435	return;
	1436	}
	1437	else
	1438	{
	1439	if ((site->flags & GTK_DEST_DEFAULT_HIGHLIGHT) && site->have_drag)
	1440	gtk_drag_unhighlight (widget);
	1441
	1442	if (!(site->flags & GTK_DEST_DEFAULT_MOTION) \|\| site->have_drag)
	1443	gtk_signal_emit_by_name (GTK_OBJECT (widget), "drag_leave",
	1444	context, time);
	1445
	1446	site->have_drag = FALSE;
	1447	}
	1448	}
	1449
	1450	static gboolean
	1451	gtk_drag_dest_motion (GtkWidget *widget,
	1452	GdkDragContext *context,
	1453	gint x,
	1454	gint y,
	1455	guint time)
	1456	{
	1457	GtkDragDestSite *site;
	1458	GdkDragAction action = 0;
	1459	gboolean retval;
	1460
	1461	site = gtk_object_get_data (GTK_OBJECT (widget), "gtk-drag-dest");
	1462	g_return_val_if_fail (site != NULL, FALSE);
	1463
	1464	if (site->do_proxy)
	1465	{
	1466	GdkAtom selection;
	1467	GdkEvent *current_event;
	1468	GdkWindow *dest_window;
	1469	GdkDragProtocol proto;
	1470
	1471	GtkDragDestInfo *info = g_dataset_get_data (context, "gtk-info");
	1472
	1473	if (!info->proxy_source)
	1474	gtk_drag_proxy_begin (widget, info);
	1475
	1476	current_event = gtk_get_current_event ();
	1477
	1478	if (site->proxy_window)
	1479	{
	1480	dest_window = site->proxy_window;
	1481	proto = site->proxy_protocol;
	1482	}
	1483	else
	1484	{
	1485	gdk_drag_find_window (info->proxy_source->context,
	1486	NULL,
	1487	current_event->dnd.x_root,
	1488	current_event->dnd.y_root,
	1489	&dest_window, &proto);
	1490	}
	1491
	1492	gdk_drag_motion (info->proxy_source->context,
	1493	dest_window, proto,
	1494	current_event->dnd.x_root,
	1495	current_event->dnd.y_root,
	1496	context->suggested_action,
	1497	context->actions, time);
	1498
	1499	if (!site->proxy_window && dest_window)
	1500	gdk_window_unref (dest_window);
	1501
	1502	selection = gdk_drag_get_selection (info->proxy_source->context);
	1503	if (selection &&
	1504	selection != gdk_drag_get_selection (info->context))
	1505	gtk_drag_source_check_selection (info->proxy_source, selection, time);
	1506
	1507	gdk_event_free (current_event);
	1508
	1509	return TRUE;
	1510	}
	1511
	1512	if (site->flags & GTK_DEST_DEFAULT_MOTION)
	1513	{
	1514	if (context->suggested_action & site->actions)
	1515	action = context->suggested_action;
	1516	else
	1517	{
	1518	gint i;
	1519
	1520	for (i=0; i<8; i++)
	1521	{
	1522	if ((site->actions & (1 << i)) &&
	1523	(context->actions & (1 << i)))
	1524	{
	1525	action = (1 << i);
	1526	break;
	1527	}
	1528	}
	1529	}
	1530
	1531	if (action && gtk_drag_dest_find_target (widget, site, context))
	1532	{
	1533	if (!site->have_drag)
	1534	{
	1535	site->have_drag = TRUE;
	1536	if (site->flags & GTK_DEST_DEFAULT_HIGHLIGHT)
	1537	gtk_drag_highlight (widget);
	1538	}
	1539
	1540	gdk_drag_status (context, action, time);
	1541	}
	1542	else
	1543	{
	1544	gdk_drag_status (context, 0, time);
	1545	return TRUE;
	1546	}
	1547	}
	1548
	1549	gtk_signal_emit_by_name (GTK_OBJECT (widget), "drag_motion",
	1550	context, x, y, time, &retval);
	1551
	1552	return (site->flags & GTK_DEST_DEFAULT_MOTION) ? TRUE : retval;
	1553	}
	1554
	1555	static gboolean
	1556	gtk_drag_dest_drop (GtkWidget *widget,
	1557	GdkDragContext *context,
	1558	gint x,
	1559	gint y,
	1560	guint time)
	1561	{
	1562	GtkDragDestSite *site;
	1563	GtkDragDestInfo *info;
	1564
	1565	site = gtk_object_get_data (GTK_OBJECT (widget), "gtk-drag-dest");
	1566	g_return_val_if_fail (site != NULL, FALSE);
	1567
	1568	info = g_dataset_get_data (context, "gtk-info");
	1569	g_return_val_if_fail (info != NULL, FALSE);
	1570
	1571	info->drop_x = x;
	1572	info->drop_y = y;
	1573
	1574	if (site->do_proxy)
	1575	{
	1576	if (info->proxy_source \|\|
	1577	(info->context->protocol == GDK_DRAG_PROTO_ROOTWIN))
	1578	{
	1579	gtk_drag_drop (info->proxy_source, time);
	1580	}
	1581	else
	1582	{
	1583	/* We need to synthesize a motion event, wait for a status,
	1584	* and, if we get a good one, do a drop.
	1585	*/
	1586
	1587	GdkEvent *current_event;
	1588	GdkAtom selection;
	1589	GdkWindow *dest_window;
	1590	GdkDragProtocol proto;
	1591
	1592	gtk_drag_proxy_begin (widget, info);
	1593	info->proxy_drop_wait = TRUE;
	1594	info->proxy_drop_time = time;
	1595
	1596	current_event = gtk_get_current_event ();
	1597
	1598	if (site->proxy_window)
	1599	{
	1600	dest_window = site->proxy_window;
	1601	proto = site->proxy_protocol;
	1602	}
	1603	else
	1604	{
	1605	gdk_drag_find_window (info->proxy_source->context,
	1606	NULL,
	1607	current_event->dnd.x_root,
	1608	current_event->dnd.y_root,
	1609	&dest_window, &proto);
	1610	}
	1611
	1612	gdk_drag_motion (info->proxy_source->context,
	1613	dest_window, proto,
	1614	current_event->dnd.x_root,
	1615	current_event->dnd.y_root,
	1616	context->suggested_action,
	1617	context->actions, time);
	1618
	1619	if (!site->proxy_window && dest_window)
	1620	gdk_window_unref (dest_window);
	1621
	1622	selection = gdk_drag_get_selection (info->proxy_source->context);
	1623	if (selection &&
	1624	selection != gdk_drag_get_selection (info->context))
	1625	gtk_drag_source_check_selection (info->proxy_source, selection, time);
	1626
	1627	gdk_event_free (current_event);
	1628
	1629	}
	1630
	1631	return TRUE;
	1632	}
	1633	else
	1634	{
	1635	gboolean retval;
	1636
	1637	if (site->flags & GTK_DEST_DEFAULT_DROP)
	1638	{
	1639	GdkAtom target = gtk_drag_dest_find_target (widget, site, context);
	1640
	1641	if (target == GDK_NONE)
	1642	return FALSE;
	1643
	1644	gtk_drag_get_data (widget, context, target, time);
	1645	}
	1646
	1647	gtk_signal_emit_by_name (GTK_OBJECT (widget), "drag_drop",
	1648	context, x, y, time, &retval);
	1649
	1650	return (site->flags & GTK_DEST_DEFAULT_DROP) ? TRUE : retval;
	1651	}
	1652	}
	1653
	1654	/***************
	1655	* Source side *
	1656	***************/
	1657
	1658	/*************************************************************
	1659	* gtk_drag_begin: Start a drag operation
	1660	*
	1661	* arguments:
	1662	* widget: Widget from which drag starts
	1663	* handlers: List of handlers to supply the data for the drag
	1664	* button: Button user used to start drag
	1665	* time: Time of event starting drag
	1666	*
	1667	* results:
	1668	*************************************************************/
	1669
	1670	GdkDragContext *
	1671	gtk_drag_begin (GtkWidget *widget,
	1672	GtkTargetList *target_list,
	1673	GdkDragAction actions,
	1674	gint button,
	1675	GdkEvent *event)
	1676	{
	1677	GtkDragSourceInfo *info;
	1678	GList *targets = NULL;
	1679	GList *tmp_list;
	1680	guint32 time = GDK_CURRENT_TIME;
	1681	GdkDragAction possible_actions, suggested_action;
	1682
	1683	g_return_val_if_fail (widget != NULL, NULL);
	1684	g_return_val_if_fail (GTK_WIDGET_REALIZED (widget), NULL);
	1685	g_return_val_if_fail (target_list != NULL, NULL);
	1686
	1687	if (event)
	1688	time = gdk_event_get_time (event);
	1689
	1690	info = g_new0 (GtkDragSourceInfo, 1);
	1691	info->ipc_widget = gtk_drag_get_ipc_widget ();
	1692	source_widgets = g_slist_prepend (source_widgets, info->ipc_widget);
	1693
	1694	gtk_object_set_data (GTK_OBJECT (info->ipc_widget), "gtk-info", info);
	1695
	1696	tmp_list = g_list_last (target_list->list);
	1697	while (tmp_list)
	1698	{
	1699	GtkTargetPair *pair = tmp_list->data;
	1700	targets = g_list_prepend (targets,
	1701	GINT_TO_POINTER (pair->target));
	1702	tmp_list = tmp_list->prev;
	1703	}
	1704
	1705	info->widget = widget;
	1706	gtk_widget_ref (info->widget);
	1707
	1708	info->context = gdk_drag_begin (info->ipc_widget->window, targets);
	1709	g_list_free (targets);
	1710
	1711	g_dataset_set_data (info->context, "gtk-info", info);
	1712
	1713	info->button = button;
	1714	info->target_list = target_list;
	1715	gtk_target_list_ref (target_list);
	1716
	1717	info->possible_actions = actions;
	1718
	1719	info->cursor = NULL;
	1720	info->status = GTK_DRAG_STATUS_DRAG;
	1721	info->last_event = NULL;
	1722	info->selections = NULL;
	1723	info->icon_window = NULL;
	1724	info->destroy_icon = FALSE;
	1725
	1726	gtk_drag_get_event_actions (event, info->button, actions,
	1727	&suggested_action, &possible_actions);
	1728
	1729	info->cursor = gtk_drag_get_cursor (suggested_action);
	1730
	1731	/* Set cur_x, cur_y here so if the "drag_begin" signal shows
	1732	* the drag icon, it will be in the right place
	1733	*/
	1734	if (event && event->type == GDK_MOTION_NOTIFY)
	1735	{
	1736	info->cur_x = event->motion.x_root;
	1737	info->cur_y = event->motion.y_root;
	1738	}
	1739	else
	1740	{
	1741	gint x, y;
	1742	gdk_window_get_pointer (GDK_ROOT_PARENT (), &x, &y, NULL);
	1743
	1744	info->cur_x = x;
	1745	info->cur_y = y;
	1746	}
	1747
	1748	gtk_signal_emit_by_name (GTK_OBJECT (widget), "drag_begin",
	1749	info->context);
	1750
	1751	if (event && event->type == GDK_MOTION_NOTIFY)
	1752	gtk_drag_motion_cb (info->ipc_widget, (GdkEventMotion *)event, info);
	1753
	1754	info->start_x = info->cur_x;
	1755	info->start_y = info->cur_y;
	1756
	1757	gtk_signal_connect (GTK_OBJECT (info->ipc_widget), "button_release_event",
	1758	GTK_SIGNAL_FUNC (gtk_drag_button_release_cb), info);
	1759	gtk_signal_connect (GTK_OBJECT (info->ipc_widget), "motion_notify_event",
	1760	GTK_SIGNAL_FUNC (gtk_drag_motion_cb), info);
	1761	gtk_signal_connect (GTK_OBJECT (info->ipc_widget), "key_press_event",
	1762	GTK_SIGNAL_FUNC (gtk_drag_key_cb), info);
	1763	gtk_signal_connect (GTK_OBJECT (info->ipc_widget), "key_release_event",
	1764	GTK_SIGNAL_FUNC (gtk_drag_key_cb), info);
	1765	gtk_signal_connect (GTK_OBJECT (info->ipc_widget), "selection_get",
	1766	GTK_SIGNAL_FUNC (gtk_drag_selection_get), info);
	1767
	1768	/* We use a GTK grab here to override any grabs that the widget
	1769	* we are dragging from might have held
	1770	*/
	1771	gtk_grab_add (info->ipc_widget);
	1772	if (gdk_pointer_grab (info->ipc_widget->window, FALSE,
	1773	GDK_POINTER_MOTION_MASK \| GDK_POINTER_MOTION_HINT_MASK \|
	1774	GDK_BUTTON_RELEASE_MASK, NULL,
	1775	info->cursor, time) == 0)
	1776	{
	1777	if (gdk_keyboard_grab (info->ipc_widget->window, FALSE, time) != 0)
	1778	{
	1779	/* FIXME: This should be cleaned up... */
	1780	GdkEventButton ev;
	1781
	1782	ev.time = time;
	1783	ev.type = GDK_BUTTON_RELEASE;
	1784	ev.button = info->button;
	1785
	1786	gtk_drag_button_release_cb (widget, &ev, info);
	1787
	1788	return NULL;
	1789	}
	1790	}
	1791
	1792	return info->context;
	1793	}
	1794
	1795	/*************************************************************
	1796	* gtk_drag_source_set:
	1797	* Register a drop site, and possibly add default behaviors.
	1798	* arguments:
	1799	* widget:
	1800	* start_button_mask: Mask of allowed buttons to start drag
	1801	* targets: Table of targets for this source
	1802	* n_targets:
	1803	* actions: Actions allowed for this source
	1804	* results:
	1805	*************************************************************/
	1806
	1807	void
	1808	gtk_drag_source_set (GtkWidget *widget,
	1809	GdkModifierType start_button_mask,
	1810	const GtkTargetEntry *targets,
	1811	gint n_targets,
	1812	GdkDragAction actions)
	1813	{
	1814	GtkDragSourceSite *site;
	1815
	1816	g_return_if_fail (widget != NULL);
	1817
	1818	site = gtk_object_get_data (GTK_OBJECT (widget), "gtk-site-data");
	1819
	1820	gtk_widget_add_events (widget,
	1821	gtk_widget_get_events (widget) \|
	1822	GDK_BUTTON_PRESS_MASK \| GDK_BUTTON_RELEASE_MASK \|
	1823	GDK_BUTTON_MOTION_MASK);
	1824
	1825	if (site)
	1826	{
	1827	if (site->target_list)
	1828	gtk_target_list_unref (site->target_list);
	1829	}
	1830	else
	1831	{
	1832	site = g_new0 (GtkDragSourceSite, 1);
	1833
	1834	gtk_signal_connect (GTK_OBJECT (widget), "button_press_event",
	1835	GTK_SIGNAL_FUNC (gtk_drag_source_event_cb),
	1836	site);
	1837	gtk_signal_connect (GTK_OBJECT (widget), "motion_notify_event",
	1838	GTK_SIGNAL_FUNC (gtk_drag_source_event_cb),
	1839	site);
	1840
	1841	gtk_object_set_data_full (GTK_OBJECT (widget),
	1842	"gtk-site-data",
	1843	site, gtk_drag_source_site_destroy);
	1844	}
	1845
	1846	site->start_button_mask = start_button_mask;
	1847
	1848	if (targets)
	1849	site->target_list = gtk_target_list_new (targets, n_targets);
	1850	else
	1851	site->target_list = NULL;
	1852
	1853	site->actions = actions;
	1854
	1855	}
	1856
	1857	/*************************************************************
	1858	* gtk_drag_source_unset
	1859	* Unregister this widget as a drag source.
	1860	* arguments:
	1861	* widget:
	1862	* results:
	1863	*************************************************************/
	1864
	1865	void
	1866	gtk_drag_source_unset (GtkWidget *widget)
	1867	{
	1868	GtkDragSourceSite *site;
	1869
	1870	g_return_if_fail (widget != NULL);
	1871
	1872	site = gtk_object_get_data (GTK_OBJECT (widget), "gtk-site-data");
	1873
	1874	if (site)
	1875	{
	1876	gtk_signal_disconnect_by_data (GTK_OBJECT (widget), site);
	1877	gtk_object_set_data (GTK_OBJECT (widget), "gtk-site-data", NULL);
	1878	}
	1879	}
	1880
	1881	/*************************************************************
	1882	* gtk_drag_source_set_icon:
	1883	* Set an icon for drags from this source.
	1884	* arguments:
	1885	* colormap: Colormap for this icon
	1886	* pixmap:
	1887	* mask
	1888	* results:
	1889	*************************************************************/
	1890
	1891	void
	1892	gtk_drag_source_set_icon (GtkWidget *widget,
	1893	GdkColormap *colormap,
	1894	GdkPixmap *pixmap,
	1895	GdkBitmap *mask)
	1896	{
	1897	GtkDragSourceSite *site;
	1898
	1899	g_return_if_fail (widget != NULL);
	1900
	1901	site = gtk_object_get_data (GTK_OBJECT (widget), "gtk-site-data");
	1902	g_return_if_fail (site != NULL);
	1903
	1904	if (site->colormap)
	1905	gdk_colormap_unref (site->colormap);
	1906	if (site->pixmap)
	1907	gdk_pixmap_unref (site->pixmap);
	1908	if (site->mask)
	1909	gdk_pixmap_unref (site->mask);
	1910
	1911	site->colormap = colormap;
	1912	if (colormap)
	1913	gdk_colormap_ref (colormap);
	1914
	1915	site->pixmap = pixmap;
	1916	if (pixmap)
	1917	gdk_pixmap_ref (pixmap);
	1918
	1919	site->mask = mask;
	1920	if (mask)
	1921	gdk_pixmap_ref (mask);
	1922	}
	1923
	1924	/*************************************************************
	1925	* gtk_drag_set_icon_window:
	1926	* Set a widget as the icon for a drag.
	1927	* arguments:
	1928	* context:
	1929	* widget:
	1930	* hot_x: Hot spot
	1931	* hot_y:
	1932	* results:
	1933	*************************************************************/
	1934
	1935	static void
	1936	gtk_drag_set_icon_window (GdkDragContext *context,
	1937	GtkWidget *widget,
	1938	gint hot_x,
	1939	gint hot_y,
	1940	gboolean destroy_on_release)
	1941	{
	1942	GtkDragSourceInfo *info;
	1943
	1944	g_return_if_fail (context != NULL);
	1945	g_return_if_fail (widget != NULL);
	1946
	1947	info = g_dataset_get_data (context, "gtk-info");
	1948	gtk_drag_remove_icon (info);
	1949
	1950	info->icon_window = widget;
	1951	info->hot_x = hot_x;
	1952	info->hot_y = hot_y;
	1953
	1954	if (widget)
	1955	{
	1956	gtk_widget_set_uposition (widget,
	1957	info->cur_x - info->hot_x,
	1958	info->cur_y - info->hot_y);
	1959	gtk_widget_ref (widget);
	1960	gdk_window_raise (widget->window);
	1961	gtk_widget_show (widget);
	1962	}
	1963
	1964	info->destroy_icon = destroy_on_release;
	1965	}
	1966
	1967	/*************************************************************
	1968	* gtk_drag_set_icon_widget:
	1969	* Set a widget as the icon for a drag.
	1970	* arguments:
	1971	* context:
	1972	* widget:
	1973	* hot_x: Hot spot
	1974	* hot_y:
	1975	* results:
	1976	*************************************************************/
	1977
	1978	void
	1979	gtk_drag_set_icon_widget (GdkDragContext *context,
	1980	GtkWidget *widget,
	1981	gint hot_x,
	1982	gint hot_y)
	1983	{
	1984	g_return_if_fail (context != NULL);
	1985	g_return_if_fail (widget != NULL);
	1986
	1987	gtk_drag_set_icon_window (context, widget, hot_x, hot_y, FALSE);
	1988	}
	1989
	1990	/*************************************************************
	1991	* gtk_drag_set_icon_pixmap:
	1992	* Set a widget as the icon for a drag.
	1993	* arguments:
	1994	* context:
	1995	* colormap: Colormap for the icon window.
	1996	* pixmap:
	1997	* mask:
	1998	* hot_x: Hot spot
	1999	* hot_y:
	2000	* results:
	2001	*************************************************************/
	2002
	2003	void
	2004	gtk_drag_set_icon_pixmap (GdkDragContext *context,
	2005	GdkColormap *colormap,
	2006	GdkPixmap *pixmap,
	2007	GdkBitmap *mask,
	2008	gint hot_x,
	2009	gint hot_y)
	2010	{
	2011	GtkWidget *window;
	2012	gint width, height;
	2013
	2014	g_return_if_fail (context != NULL);
	2015	g_return_if_fail (colormap != NULL);
	2016	g_return_if_fail (pixmap != NULL);
	2017
	2018	gdk_window_get_size (pixmap, &width, &height);
	2019
	2020	gtk_widget_push_visual (gdk_colormap_get_visual (colormap));
	2021	gtk_widget_push_colormap (colormap);
	2022
	2023	window = gtk_window_new (GTK_WINDOW_POPUP);
	2024	gtk_widget_set_events (window, GDK_BUTTON_PRESS_MASK \| GDK_BUTTON_RELEASE_MASK);
	2025	gtk_widget_set_app_paintable (GTK_WIDGET (window), TRUE);
	2026
	2027	gtk_widget_pop_visual ();
	2028	gtk_widget_pop_colormap ();
	2029
	2030	gtk_widget_set_usize (window, width, height);
	2031	gtk_widget_realize (window);
	2032
	2033	gdk_window_set_back_pixmap (window->window, pixmap, FALSE);
	2034
	2035	if (mask)
	2036	gtk_widget_shape_combine_mask (window, mask, 0, 0);
	2037
	2038	gtk_drag_set_icon_window (context, window, hot_x, hot_y, TRUE);
	2039	}
	2040
	2041	/*************************************************************
	2042	* gtk_drag_set_icon_default:
	2043	* Set the icon for a drag to the default icon.
	2044	* arguments:
	2045	* context:
	2046	* results:
	2047	*************************************************************/
	2048
	2049	void
	2050	gtk_drag_set_icon_default (GdkDragContext *context)
	2051	{
	2052	g_return_if_fail (context != NULL);
	2053
	2054	if (!default_icon_pixmap)
	2055	{
	2056	default_icon_colormap = gdk_colormap_get_system ();
	2057	default_icon_pixmap =
	2058	gdk_pixmap_colormap_create_from_xpm_d (NULL,
	2059	default_icon_colormap,
	2060	&default_icon_mask,
	2061	NULL, (gchar **)drag_default_xpm);
	2062	default_icon_hot_x = -2;
	2063	default_icon_hot_y = -2;
	2064	}
	2065
	2066	gtk_drag_set_icon_pixmap (context,
	2067	default_icon_colormap,
	2068	default_icon_pixmap,
	2069	default_icon_mask,
	2070	default_icon_hot_x,
	2071	default_icon_hot_y);
	2072	}
	2073
	2074	/*************************************************************
	2075	* gtk_drag_set_default_icon:
	2076	* Set a default icon for all drags as a pixmap.
	2077	* arguments:
	2078	* colormap: Colormap for the icon window.
	2079	* pixmap:
	2080	* mask:
	2081	* hot_x: Hot spot
	2082	* hot_y:
	2083	* results:
	2084	*************************************************************/
	2085
	2086	void
	2087	gtk_drag_set_default_icon (GdkColormap *colormap,
	2088	GdkPixmap *pixmap,
	2089	GdkBitmap *mask,
	2090	gint hot_x,
	2091	gint hot_y)
	2092	{
	2093	g_return_if_fail (colormap != NULL);
	2094	g_return_if_fail (pixmap != NULL);
	2095
	2096	if (default_icon_colormap)
	2097	gdk_colormap_unref (default_icon_colormap);
	2098	if (default_icon_pixmap)
	2099	gdk_pixmap_unref (default_icon_pixmap);
	2100	if (default_icon_mask)
[15780]	2101	gdk_pixmap_unref (default_icon_mask);
[14481]	2102
	2103	default_icon_colormap = colormap;
	2104	gdk_colormap_ref (colormap);
	2105
	2106	default_icon_pixmap = pixmap;
	2107	gdk_pixmap_ref (pixmap);
	2108
	2109	default_icon_mask = mask;
	2110	if (mask)
	2111	gdk_pixmap_ref (mask);
	2112
	2113	default_icon_hot_x = hot_x;
	2114	default_icon_hot_y = hot_y;
	2115	}
	2116
	2117
	2118	/*************************************************************
	2119	* gtk_drag_source_handle_event:
	2120	* Called from widget event handling code on Drag events
	2121	* for drag sources.
	2122	*
	2123	* arguments:
	2124	* toplevel: Toplevel widget that received the event
	2125	* event:
	2126	* results:
	2127	*************************************************************/
	2128
	2129	void
	2130	gtk_drag_source_handle_event (GtkWidget *widget,
	2131	GdkEvent *event)
	2132	{
	2133	GtkDragSourceInfo *info;
	2134	GdkDragContext *context;
	2135
	2136	g_return_if_fail (widget != NULL);
	2137	g_return_if_fail (event != NULL);
	2138
	2139	context = event->dnd.context;
	2140	info = g_dataset_get_data (context, "gtk-info");
	2141	if (!info)
	2142	return;
	2143
	2144	switch (event->type)
	2145	{
	2146	case GDK_DRAG_STATUS:
	2147	{
	2148	GdkCursor *cursor;
	2149
	2150	if (info->proxy_dest)
	2151	{
	2152	if (!event->dnd.send_event)
	2153	{
	2154	if (info->proxy_dest->proxy_drop_wait)
	2155	{
	2156	gboolean result = context->action != 0;
	2157
	2158	/* Aha - we can finally pass the MOTIF DROP on... */
	2159	gdk_drop_reply (info->proxy_dest->context, result, info->proxy_dest->proxy_drop_time);
	2160	if (result)
	2161	gdk_drag_drop (info->context, info->proxy_dest->proxy_drop_time);
	2162	else
	2163	gtk_drag_finish (info->proxy_dest->context, FALSE, FALSE, info->proxy_dest->proxy_drop_time);
	2164	}
	2165	else
	2166	{
	2167	gdk_drag_status (info->proxy_dest->context,
	2168	event->dnd.context->action,
	2169	event->dnd.time);
	2170	}
	2171	}
	2172	}
	2173	else
	2174	{
	2175	cursor = gtk_drag_get_cursor (event->dnd.context->action);
	2176	if (info->cursor != cursor)
	2177	{
	2178	XChangeActivePointerGrab (GDK_WINDOW_XDISPLAY (widget->window),
	2179	PointerMotionMask \| PointerMotionHintMask \| ButtonReleaseMask,
	2180	((GdkCursorPrivate *)cursor)->xcursor,
	2181	event->dnd.time);
	2182	info->cursor = cursor;
	2183	}
	2184
	2185	if (info->last_event)
	2186	{
	2187	gtk_drag_update (info,
	2188	info->cur_x, info->cur_y,
	2189	info->last_event);
	2190	info->last_event = NULL;
	2191	}
	2192	}
	2193	}
	2194	break;
	2195
	2196	case GDK_DROP_FINISHED:
	2197	gtk_drag_drop_finished (info, TRUE, event->dnd.time);
	2198	break;
	2199	default:
	2200	g_assert_not_reached ();
	2201	}
	2202	}
	2203
	2204	/*************************************************************
	2205	* gtk_drag_source_check_selection:
	2206	* Check if we've set up handlers/claimed the selection
	2207	* for a given drag. If not, add them.
	2208	* arguments:
	2209	*
	2210	* results:
	2211	*************************************************************/
	2212
	2213	static void
	2214	gtk_drag_source_check_selection (GtkDragSourceInfo *info,
	2215	GdkAtom selection,
	2216	guint32 time)
	2217	{
	2218	GList *tmp_list;
	2219
	2220	tmp_list = info->selections;
	2221	while (tmp_list)
	2222	{
	2223	if (GPOINTER_TO_UINT (tmp_list->data) == selection)
	2224	return;
	2225	tmp_list = tmp_list->next;
	2226	}
	2227
	2228	gtk_selection_owner_set (info->ipc_widget, selection, time);
	2229	info->selections = g_list_prepend (info->selections,
	2230	GUINT_TO_POINTER (selection));
	2231
	2232	tmp_list = info->target_list->list;
	2233	while (tmp_list)
	2234	{
	2235	GtkTargetPair *pair = tmp_list->data;
	2236
	2237	gtk_selection_add_target (info->ipc_widget,
	2238	selection,
	2239	pair->target,
	2240	pair->info);
	2241	tmp_list = tmp_list->next;
	2242	}
	2243
	2244	if (info->context->protocol == GDK_DRAG_PROTO_MOTIF)
	2245	{
	2246	gtk_selection_add_target (info->ipc_widget,
	2247	selection,
	2248	gdk_atom_intern ("XmTRANSFER_SUCCESS", FALSE),
	2249	TARGET_MOTIF_SUCCESS);
	2250	gtk_selection_add_target (info->ipc_widget,
	2251	selection,
	2252	gdk_atom_intern ("XmTRANSFER_FAILURE", FALSE),
	2253	TARGET_MOTIF_FAILURE);
	2254	}
	2255
	2256	gtk_selection_add_target (info->ipc_widget,
	2257	selection,
	2258	gdk_atom_intern ("DELETE", FALSE),
	2259	TARGET_DELETE);
	2260	}
	2261
	2262	/*************************************************************
	2263	* gtk_drag_drop_finished:
	2264	* Clean up from the drag, and display snapback, if necessary.
	2265	* arguments:
	2266	* info:
	2267	* success:
	2268	* time:
	2269	* results:
	2270	*************************************************************/
	2271
	2272	static void
	2273	gtk_drag_drop_finished (GtkDragSourceInfo *info,
	2274	gboolean success,
	2275	guint time)
	2276	{
	2277	gtk_drag_source_release_selections (info, time);
	2278
	2279	if (info->proxy_dest)
	2280	{
	2281	/* The time from the event isn't reliable for Xdnd drags */
	2282	gtk_drag_finish (info->proxy_dest->context, success, FALSE,
	2283	info->proxy_dest->proxy_drop_time);
	2284	gtk_drag_source_info_destroy (info);
	2285	}
	2286	else
	2287	{
	2288	if (success)
	2289	{
	2290	gtk_drag_source_info_destroy (info);
	2291	}
	2292	else
	2293	{
	2294	GtkDragAnim *anim = g_new (GtkDragAnim, 1);
	2295	anim->info = info;
	2296	anim->step = 0;
	2297
	2298	anim->n_steps = MAX (info->cur_x - info->start_x,
	2299	info->cur_y - info->start_y) / ANIM_STEP_LENGTH;
	2300	anim->n_steps = CLAMP (anim->n_steps, ANIM_MIN_STEPS, ANIM_MAX_STEPS);
	2301	if (info->icon_window)
	2302	{
	2303	gtk_widget_show (info->icon_window);
	2304	gdk_window_raise (info->icon_window->window);
	2305	}
	2306
	2307	/* Mark the context as dead, so if the destination decides
	2308	* to respond really late, we still are OK.
	2309	*/
	2310	g_dataset_set_data (info->context, "gtk-info", NULL);
	2311	gtk_timeout_add (ANIM_STEP_TIME, gtk_drag_anim_timeout, anim);
	2312	}
	2313	}
	2314	}
	2315
	2316	static void
	2317	gtk_drag_source_release_selections (GtkDragSourceInfo *info,
	2318	guint32 time)
	2319	{
	2320	GList *tmp_list = info->selections;
	2321	while (tmp_list)
	2322	{
	2323	GdkAtom selection = GPOINTER_TO_UINT (tmp_list->data);
	2324	if (gdk_selection_owner_get (selection) == info->ipc_widget->window)
	2325	gtk_selection_owner_set (NULL, selection, time);
	2326	tmp_list = tmp_list->next;
	2327	}
	2328
	2329	g_list_free (info->selections);
	2330	info->selections = NULL;
	2331	}
	2332
	2333	/*************************************************************
	2334	* gtk_drag_drop:
	2335	* Send a drop event.
	2336	* arguments:
	2337	*
	2338	* results:
	2339	*************************************************************/
	2340
	2341	static void
	2342	gtk_drag_drop (GtkDragSourceInfo *info,
	2343	guint32 time)
	2344	{
	2345	if (info->context->protocol == GDK_DRAG_PROTO_ROOTWIN)
	2346	{
	2347	GtkSelectionData selection_data;
	2348	GList *tmp_list;
	2349	GdkAtom target = gdk_atom_intern ("application/x-rootwin-drop", FALSE);
	2350
	2351	tmp_list = info->target_list->list;
	2352	while (tmp_list)
	2353	{
	2354	GtkTargetPair *pair = tmp_list->data;
	2355
	2356	if (pair->target == target)
	2357	{
	2358	selection_data.selection = GDK_NONE;
	2359	selection_data.target = target;
	2360	selection_data.data = NULL;
	2361	selection_data.length = -1;
	2362
	2363	gtk_signal_emit_by_name (GTK_OBJECT (info->widget), "drag_data_get",
	2364	info->context, &selection_data,
	2365	pair->info,
	2366	time);
	2367
	2368	/* FIXME: Should we check for length >= 0 here? */
	2369	gtk_drag_drop_finished (info, TRUE, time);
	2370	return;
	2371	}
	2372	tmp_list = tmp_list->next;
	2373	}
	2374	gtk_drag_drop_finished (info, FALSE, time);
	2375	}
	2376	else
	2377	{
	2378	if (info->icon_window)
	2379	gtk_widget_hide (info->icon_window);
	2380
	2381	gdk_drag_drop (info->context, time);
	2382	info->drop_timeout = gtk_timeout_add (DROP_ABORT_TIME,
	2383	gtk_drag_abort_timeout,
	2384	info);
	2385	}
	2386	}
	2387
	2388	/*
	2389	* Source side callbacks.
	2390	*/
	2391
	2392	static gint
	2393	gtk_drag_source_event_cb (GtkWidget *widget,
	2394	GdkEvent *event,
	2395	gpointer data)
	2396	{
	2397	GtkDragSourceSite *site;
	2398	site = (GtkDragSourceSite *)data;
	2399
	2400	switch (event->type)
	2401	{
	2402	case GDK_BUTTON_PRESS:
	2403	if ((GDK_BUTTON1_MASK << (event->button.button - 1)) & site->start_button_mask)
	2404	{
	2405	site->state \|= (GDK_BUTTON1_MASK << (event->button.button - 1));
	2406	site->x = event->button.x;
	2407	site->y = event->button.y;
	2408	}
	2409	break;
	2410
	2411	case GDK_BUTTON_RELEASE:
	2412	if ((GDK_BUTTON1_MASK << (event->button.button - 1)) & site->start_button_mask)
	2413	{
	2414	site->state &= ~(GDK_BUTTON1_MASK << (event->button.button - 1));
	2415	}
	2416	break;
	2417
	2418	case GDK_MOTION_NOTIFY:
	2419	if (site->state & event->motion.state & site->start_button_mask)
	2420	{
	2421	/* FIXME: This is really broken and can leave us
	2422	* with a stuck grab
	2423	*/
	2424	int i;
	2425	for (i=1; i<6; i++)
	2426	{
	2427	if (site->state & event->motion.state &
	2428	GDK_BUTTON1_MASK << (i - 1))
	2429	break;
	2430	}
	2431
	2432	if (MAX (abs (site->x - event->motion.x),
	2433	abs (site->y - event->motion.y)) > 3)
	2434	{
	2435	GtkDragSourceInfo *info;
	2436	GdkDragContext *context;
	2437
	2438	site->state = 0;
	2439	context = gtk_drag_begin (widget, site->target_list,
	2440	site->actions,
	2441	i, event);
	2442
	2443
	2444	info = g_dataset_get_data (context, "gtk-info");
	2445
	2446	if (!info->icon_window)
	2447	{
	2448	if (site->pixmap)
	2449	gtk_drag_set_icon_pixmap (context,
	2450	site->colormap,
	2451	site->pixmap,
	2452	site->mask, -2, -2);
	2453	else
	2454	gtk_drag_set_icon_default (context);
	2455	}
	2456
	2457	return TRUE;
	2458	}
	2459	}
	2460	break;
	2461
	2462	default: /* hit for 2/3BUTTON_PRESS */
	2463	break;
	2464	}
	2465	return FALSE;
	2466	}
	2467
	2468	static void
	2469	gtk_drag_source_site_destroy (gpointer data)
	2470	{
	2471	GtkDragSourceSite *site = data;
	2472
	2473	if (site->target_list)
	2474	gtk_target_list_unref (site->target_list);
	2475
	2476	if (site->pixmap)
	2477	gdk_pixmap_unref (site->pixmap);
	2478
	2479	if (site->mask)
	2480	gdk_pixmap_unref (site->mask);
	2481
	2482	g_free (site);
	2483	}
	2484
	2485	static void
	2486	gtk_drag_selection_get (GtkWidget *widget,
	2487	GtkSelectionData *selection_data,
	2488	guint sel_info,
	2489	guint32 time,
	2490	gpointer data)
	2491	{
	2492	GtkDragSourceInfo *info = data;
	2493	static GdkAtom null_atom = GDK_NONE;
	2494	guint target_info;
	2495
	2496	if (!null_atom)
	2497	null_atom = gdk_atom_intern ("NULL", FALSE);
	2498
	2499	switch (sel_info)
	2500	{
	2501	case TARGET_DELETE:
	2502	gtk_signal_emit_by_name (GTK_OBJECT (info->widget),
	2503	"drag_data_delete",
	2504	info->context);
	2505	gtk_selection_data_set (selection_data, null_atom, 8, NULL, 0);
	2506	break;
	2507	case TARGET_MOTIF_SUCCESS:
	2508	gtk_drag_drop_finished (info, TRUE, time);
	2509	gtk_selection_data_set (selection_data, null_atom, 8, NULL, 0);
	2510	break;
	2511	case TARGET_MOTIF_FAILURE:
	2512	gtk_drag_drop_finished (info, FALSE, time);
	2513	gtk_selection_data_set (selection_data, null_atom, 8, NULL, 0);
	2514	break;
	2515	default:
	2516	if (info->proxy_dest)
	2517	{
	2518	/* This is sort of dangerous and needs to be thought
	2519	* through better
	2520	*/
	2521	info->proxy_dest->proxy_data = selection_data;
	2522	gtk_drag_get_data (info->widget,
	2523	info->proxy_dest->context,
	2524	selection_data->target,
	2525	time);
	2526	gtk_main ();
	2527	info->proxy_dest->proxy_data = NULL;
	2528	}
	2529	else
	2530	{
	2531	if (gtk_target_list_find (info->target_list,
	2532	selection_data->target,
	2533	&target_info))
	2534	{
	2535	gtk_signal_emit_by_name (GTK_OBJECT (info->widget), "drag_data_get",
	2536	info->context,
	2537	selection_data,
	2538	target_info,
	2539	time);
	2540	}
	2541	}
	2542	break;
	2543	}
	2544	}
	2545
	2546	static gint
	2547	gtk_drag_anim_timeout (gpointer data)
	2548	{
	2549	GtkDragAnim *anim = data;
	2550	gint x, y;
	2551	gboolean retval;
	2552
	2553	GDK_THREADS_ENTER ();
	2554
	2555	if (anim->step == anim->n_steps)
	2556	{
	2557	gtk_drag_source_info_destroy (anim->info);
	2558	g_free (anim);
	2559
	2560	retval = FALSE;
	2561	}
	2562	else
	2563	{
	2564	x = (anim->info->start_x * (anim->step + 1) +
	2565	anim->info->cur_x * (anim->n_steps - anim->step - 1)) / anim->n_steps;
	2566	y = (anim->info->start_y * (anim->step + 1) +
	2567	anim->info->cur_y * (anim->n_steps - anim->step - 1)) / anim->n_steps;
	2568	if (anim->info->icon_window)
	2569	gtk_widget_set_uposition (anim->info->icon_window,
	2570	x - anim->info->hot_x,
	2571	y - anim->info->hot_y);
	2572
	2573	anim->step++;
	2574
	2575	retval = TRUE;
	2576	}
	2577
	2578	GDK_THREADS_LEAVE ();
	2579
	2580	return retval;
	2581	}
	2582
	2583	static void
	2584	gtk_drag_remove_icon (GtkDragSourceInfo *info)
	2585	{
	2586	if (info->icon_window)
	2587	{
	2588	gtk_widget_hide (info->icon_window);
	2589	if (info->destroy_icon)
	2590	gtk_widget_destroy (info->icon_window);
	2591
	2592	gtk_widget_unref (info->icon_window);
	2593	info->icon_window = NULL;
	2594	}
	2595	}
	2596
	2597	static void
	2598	gtk_drag_source_info_destroy (gpointer data)
	2599	{
	2600	GtkDragSourceInfo *info = data;
	2601
	2602	gtk_drag_remove_icon (data);
	2603
	2604	if (!info->proxy_dest)
	2605	gtk_signal_emit_by_name (GTK_OBJECT (info->widget), "drag_end",
	2606	info->context);
	2607
	2608	if (info->widget)
	2609	gtk_widget_unref (info->widget);
	2610
	2611	gtk_signal_disconnect_by_data (GTK_OBJECT (info->ipc_widget), info);
	2612	gtk_selection_remove_all (info->ipc_widget);
	2613	gtk_object_set_data (GTK_OBJECT (info->ipc_widget), "gtk-info", NULL);
	2614	source_widgets = g_slist_remove (source_widgets, info->ipc_widget);
	2615	gtk_drag_release_ipc_widget (info->ipc_widget);
	2616
	2617	gtk_target_list_unref (info->target_list);
	2618
	2619	g_dataset_set_data (info->context, "gtk-info", NULL);
	2620	gdk_drag_context_unref (info->context);
	2621
	2622	if (info->drop_timeout)
	2623	gtk_timeout_remove (info->drop_timeout);
	2624
	2625	g_free (info);
	2626	}
	2627
	2628	/*************************************************************
	2629	* gtk_drag_update:
	2630	* Function to update the status of the drag when the
	2631	* cursor moves or the modifier changes
	2632	* arguments:
	2633	* info: DragSourceInfo for the drag
	2634	* x_root, y_root: position of darg
	2635	* event: The event that triggered this call
	2636	* results:
	2637	*************************************************************/
	2638
	2639	static void
	2640	gtk_drag_update (GtkDragSourceInfo *info,
	2641	gint x_root,
	2642	gint y_root,
	2643	GdkEvent *event)
	2644	{
	2645	GdkDragAction action;
	2646	GdkDragAction possible_actions;
	2647	GdkWindow *window = NULL;
	2648	GdkWindow *dest_window;
	2649	GdkDragProtocol protocol;
	2650	GdkAtom selection;
	2651	guint32 time = gtk_drag_get_event_time (event);
	2652
	2653	gtk_drag_get_event_actions (event,
	2654	info->button,
	2655	info->possible_actions,
	2656	&action, &possible_actions);
	2657	info->cur_x = x_root;
	2658	info->cur_y = y_root;
	2659
	2660	if (info->icon_window)
	2661	{
	2662	gdk_window_raise (info->icon_window->window);
	2663	gtk_widget_set_uposition (info->icon_window,
	2664	info->cur_x - info->hot_x,
	2665	info->cur_y - info->hot_y);
	2666	window = info->icon_window->window;
	2667	}
	2668
	2669	gdk_drag_find_window (info->context,
	2670	window, x_root, y_root,
	2671	&dest_window, &protocol);
	2672
	2673	if (gdk_drag_motion (info->context, dest_window, protocol,
	2674	x_root, y_root, action,
	2675	possible_actions,
	2676	time))
	2677	{
	2678	if (info->last_event)
	2679	gdk_event_free ((GdkEvent *)info->last_event);
	2680
	2681	info->last_event = gdk_event_copy ((GdkEvent *)event);
	2682	}
	2683
	2684	if (dest_window)
	2685	gdk_window_unref (dest_window);
	2686
	2687	selection = gdk_drag_get_selection (info->context);
	2688	if (selection)
	2689	gtk_drag_source_check_selection (info, selection, time);
	2690	}
	2691
	2692	/*************************************************************
	2693	* gtk_drag_end:
	2694	* Called when the user finishes to drag, either by
	2695	* releasing the mouse, or by pressing Esc.
	2696	* arguments:
	2697	* widget: GtkInvisible widget for this drag
	2698	* info:
	2699	* results:
	2700	*************************************************************/
	2701
	2702	static void
	2703	gtk_drag_end (GtkDragSourceInfo *info, guint32 time)
	2704	{
	2705	GdkEvent send_event;
	2706	GtkWidget *source_widget = info->widget;
	2707
	2708	gdk_pointer_ungrab (time);
	2709	gdk_keyboard_ungrab (time);
	2710
	2711	gtk_grab_remove (info->ipc_widget);
	2712
	2713	gtk_signal_disconnect_by_func (GTK_OBJECT (info->ipc_widget),
	2714	GTK_SIGNAL_FUNC (gtk_drag_button_release_cb),
	2715	info);
	2716	gtk_signal_disconnect_by_func (GTK_OBJECT (info->ipc_widget),
	2717	GTK_SIGNAL_FUNC (gtk_drag_motion_cb),
	2718	info);
[15780]	2719	gtk_signal_disconnect_by_func (GTK_OBJECT (info->ipc_widget),
	2720	GTK_SIGNAL_FUNC (gtk_drag_key_cb),
	2721	info);
[14481]	2722
	2723	/* Send on a release pair to the the original
	2724	* widget to convince it to release its grab. We need to
	2725	* call gtk_propagate_event() here, instead of
	2726	* gtk_widget_event() because widget like GtkList may
	2727	* expect propagation.
	2728	*/
	2729
	2730	send_event.button.type = GDK_BUTTON_RELEASE;
	2731	send_event.button.window = GDK_ROOT_PARENT ();
	2732	send_event.button.send_event = TRUE;
	2733	send_event.button.time = time;
	2734	send_event.button.x = 0;
	2735	send_event.button.y = 0;
	2736	send_event.button.pressure = 0.;
	2737	send_event.button.xtilt = 0.;
	2738	send_event.button.ytilt = 0.;
	2739	send_event.button.state = 0;
	2740	send_event.button.button = info->button;
	2741	send_event.button.source = GDK_SOURCE_PEN;
	2742	send_event.button.deviceid = GDK_CORE_POINTER;
	2743	send_event.button.x_root = 0;
	2744	send_event.button.y_root = 0;
	2745
	2746	gtk_propagate_event (source_widget, &send_event);
	2747	}
	2748
	2749	/*************************************************************
	2750	* gtk_drag_motion_cb:
	2751	* "motion_notify_event" callback during drag.
	2752	* arguments:
	2753	*
	2754	* results:
	2755	*************************************************************/
	2756
	2757	static gint
	2758	gtk_drag_motion_cb (GtkWidget *widget,
	2759	GdkEventMotion *event,
	2760	gpointer data)
	2761	{
	2762	GtkDragSourceInfo info = (GtkDragSourceInfo )data;
	2763	gint x_root, y_root;
	2764
	2765	if (event->is_hint)
	2766	{
	2767	gdk_window_get_pointer (GDK_ROOT_PARENT(), &x_root, &y_root, NULL);
	2768	event->x_root = x_root;
	2769	event->y_root = y_root;
	2770	}
	2771
	2772	gtk_drag_update (info, event->x_root, event->y_root, (GdkEvent *)event);
	2773
	2774	return TRUE;
	2775	}
	2776
	2777	/*************************************************************
	2778	* gtk_drag_key_cb:
	2779	* "key_press/release_event" callback during drag.
	2780	* arguments:
	2781	*
	2782	* results:
	2783	*************************************************************/
	2784
	2785	static gint
	2786	gtk_drag_key_cb (GtkWidget *widget,
	2787	GdkEventKey *event,
	2788	gpointer data)
	2789	{
	2790	GtkDragSourceInfo info = (GtkDragSourceInfo )data;
	2791	GdkModifierType state;
	2792
	2793	if (event->type == GDK_KEY_PRESS)
	2794	{
	2795	if (event->keyval == GDK_Escape)
	2796	{
	2797	gtk_drag_end (info, event->time);
	2798	gdk_drag_abort (info->context, event->time);
	2799	gtk_drag_drop_finished (info, FALSE, event->time);
	2800
	2801	return TRUE;
	2802	}
	2803	}
	2804
	2805	/* Now send a "motion" so that the modifier state is updated */
	2806
	2807	/* The state is not yet updated in the event, so we need
	2808	* to query it here. We could use XGetModifierMapping, but
	2809	* that would be overkill.
	2810	*/
	2811	gdk_window_get_pointer (GDK_ROOT_PARENT(), NULL, NULL, &state);
	2812
	2813	event->state = state;
	2814	gtk_drag_update (info, info->cur_x, info->cur_y, (GdkEvent *)event);
	2815
	2816	return TRUE;
	2817	}
	2818
	2819	/*************************************************************
	2820	* gtk_drag_button_release_cb:
	2821	* "button_release_event" callback during drag.
	2822	* arguments:
	2823	*
	2824	* results:
	2825	*************************************************************/
	2826
	2827	static gint
	2828	gtk_drag_button_release_cb (GtkWidget *widget,
	2829	GdkEventButton *event,
	2830	gpointer data)
	2831	{
	2832	GtkDragSourceInfo info = (GtkDragSourceInfo )data;
	2833
	2834	if (event->button != info->button)
	2835	return FALSE;
	2836
	2837	gtk_drag_end (info, event->time);
	2838
	2839	if ((info->context->action != 0) && (info->context->dest_window != NULL))
	2840	{
	2841	gtk_drag_drop (info, event->time);
	2842	}
	2843	else
	2844	{
	2845	gdk_drag_abort (info->context, event->time);
	2846	gtk_drag_drop_finished (info, FALSE, event->time);
	2847	}
	2848
	2849	return TRUE;
	2850	}
	2851
	2852	static gint
	2853	gtk_drag_abort_timeout (gpointer data)
	2854	{
	2855	GtkDragSourceInfo *info = data;
	2856	guint32 time = GDK_CURRENT_TIME;
	2857
	2858	GDK_THREADS_ENTER ();
	2859
	2860	if (info->proxy_dest)
	2861	time = info->proxy_dest->proxy_drop_time;
	2862
	2863	info->drop_timeout = 0;
	2864	gtk_drag_drop_finished (info, FALSE, time);
	2865
	2866	GDK_THREADS_LEAVE ();
	2867
	2868	return FALSE;
	2869	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/third/gtk/gtk/gtkdnd.c @ 17071

Download in other formats: