#include <stdlib.h>
#include <string.h>
-#include "gdkconfig.h"
-
-#include "gdk/gdkkeysyms.h"
+#include "gdk/gdk.h"
#ifdef GDK_WINDOWING_X11
#include <X11/Xlib.h>
#include "gtkwindow.h"
#include "gtkintl.h"
#include "gtkdndcursors.h"
+#include "gtkselectionprivate.h"
static GSList *source_widgets = NULL;
GtkImageIconNameData name;
} icon_data;
- GdkColormap *colormap; /* Colormap for drag icon */
-
/* Stored button press information to detect drag beginning */
gint state;
gint x, y;
static GtkWidget *gtk_drag_get_ipc_widget_for_screen (GdkScreen *screen);
static void gtk_drag_release_ipc_widget (GtkWidget *widget);
-static gboolean gtk_drag_highlight_expose (GtkWidget *widget,
- GdkEventExpose *event,
- gpointer data);
-
static void gtk_drag_selection_received (GtkWidget *widget,
GtkSelectionData *selection_data,
guint time,
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
- g_return_if_fail (!context->is_source);
selection_widget = gtk_drag_get_ipc_widget (widget);
GSList *tmp_list;
g_return_val_if_fail (GDK_IS_DRAG_CONTEXT (context), NULL);
- g_return_val_if_fail (!context->is_source, NULL);
tmp_list = source_widgets;
while (tmp_list)
{
GtkWidget *ipc_widget = tmp_list->data;
- if (gtk_widget_get_window (ipc_widget) == context->source_window)
+ if (gtk_widget_get_window (ipc_widget) == gdk_drag_context_get_source_window (context))
{
GtkDragSourceInfo *info;
info = g_object_get_data (G_OBJECT (ipc_widget), "gtk-info");
GdkAtom target = GDK_NONE;
g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
- g_return_if_fail (!context->is_source);
if (success && del)
{
target = gdk_atom_intern_static_string ("DELETE");
}
- else if (context->protocol == GDK_DRAG_PROTO_MOTIF)
+ else if (gdk_drag_context_get_protocol (context) == GDK_DRAG_PROTO_MOTIF)
{
target = gdk_atom_intern_static_string (success ?
"XmTRANSFER_SUCCESS" :
if (target != GDK_NONE)
{
- GtkWidget *selection_widget = gtk_drag_get_ipc_widget_for_screen (gdk_drawable_get_screen (context->source_window));
+ GtkWidget *selection_widget = gtk_drag_get_ipc_widget_for_screen (gdk_window_get_screen (gdk_drag_context_get_source_window (context)));
g_object_ref (context);
}
/*************************************************************
- * gtk_drag_highlight_expose:
+ * gtk_drag_highlight_draw:
* Callback for expose_event for highlighted widgets.
* arguments:
* widget:
*************************************************************/
static gboolean
-gtk_drag_highlight_expose (GtkWidget *widget,
- GdkEventExpose *event,
- gpointer data)
+gtk_drag_highlight_draw (GtkWidget *widget,
+ cairo_t *cr,
+ gpointer data)
{
- gint x, y, width, height;
-
- if (gtk_widget_is_drawable (widget))
- {
- GdkWindow *window;
- cairo_t *cr;
+ int width = gtk_widget_get_allocated_width (widget);
+ int height = gtk_widget_get_allocated_height (widget);
- window = gtk_widget_get_window (widget);
+ gtk_paint_shadow (gtk_widget_get_style (widget), cr,
+ GTK_STATE_NORMAL, GTK_SHADOW_OUT,
+ widget, "dnd",
+ 0, 0, width, height);
- if (!gtk_widget_get_has_window (widget))
- {
- GtkAllocation allocation;
-
- gtk_widget_get_allocation (widget, &allocation);
- x = allocation.x;
- y = allocation.y;
- width = allocation.width;
- height = allocation.height;
- }
- else
- {
- x = 0;
- y = 0;
- gdk_drawable_get_size (window, &width, &height);
- }
-
- gtk_paint_shadow (gtk_widget_get_style (widget), window,
- GTK_STATE_NORMAL, GTK_SHADOW_OUT,
- &event->area, widget, "dnd",
- x, y, width, height);
-
- cr = gdk_cairo_create (window);
- cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); /* black */
- cairo_set_line_width (cr, 1.0);
- cairo_rectangle (cr,
- x + 0.5, y + 0.5,
- width - 1, height - 1);
- cairo_stroke (cr);
- cairo_destroy (cr);
- }
+ cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); /* black */
+ cairo_set_line_width (cr, 1.0);
+ cairo_rectangle (cr,
+ 0.5, 0.5,
+ width - 1, height - 1);
+ cairo_stroke (cr);
return FALSE;
}
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_signal_connect_after (widget, "expose-event",
- G_CALLBACK (gtk_drag_highlight_expose),
+ g_signal_connect_after (widget, "draw",
+ G_CALLBACK (gtk_drag_highlight_draw),
NULL);
gtk_widget_queue_draw (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_signal_handlers_disconnect_by_func (widget,
- gtk_drag_highlight_expose,
+ gtk_drag_highlight_draw,
NULL);
gtk_widget_queue_draw (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (!proxy_window || GDK_IS_WINDOW (proxy_window));
- site = g_new (GtkDragDestSite, 1);
+ site = g_slice_new (GtkDragDestSite);
site->flags = 0;
site->have_drag = FALSE;
else if (event->type == GDK_DROP_START && !info->proxy_source)
{
gdk_drop_reply (context, found, event->dnd.time);
- if ((context->protocol == GDK_DRAG_PROTO_MOTIF) && !found)
+ if ((gdk_drag_context_get_protocol (context) == GDK_DRAG_PROTO_MOTIF) && !found)
gtk_drag_finish (context, FALSE, FALSE, event->dnd.time);
}
}
* @target_list: (allow-none): list of droppable targets, or %NULL to use
* gtk_drag_dest_get_target_list (@widget).
*
- * Looks for a match between @context->targets and the
+ * Looks for a match between the supported targets of @context and the
* @dest_target_list, returning the first matching target, otherwise
* returning %GDK_NONE. @dest_target_list should usually be the return
* value from gtk_drag_dest_get_target_list(), but some widgets may
* that case, they will have to implement a drag_motion handler that
* passes the correct target list to this function.
*
- * Return value: first target that the source offers and the dest can accept, or %GDK_NONE
+ * Return value: first target that the source offers and the dest can
+ * accept, or %GDK_NONE
**/
GdkAtom
gtk_drag_dest_find_target (GtkWidget *widget,
g_return_val_if_fail (GTK_IS_WIDGET (widget), GDK_NONE);
g_return_val_if_fail (GDK_IS_DRAG_CONTEXT (context), GDK_NONE);
- g_return_val_if_fail (!context->is_source, GDK_NONE);
source_widget = gtk_drag_get_source_widget (context);
while (tmp_target)
{
GtkTargetPair *pair = tmp_target->data;
- tmp_source = context->targets;
+ tmp_source = gdk_drag_context_list_targets (context);
while (tmp_source)
{
if (tmp_source->data == GUINT_TO_POINTER (pair->target))
GdkDragContext *context;
GtkDragDestInfo *info;
GtkWidget *drop_widget;
+ GdkAtom target;
drop_widget = data;
info = gtk_drag_get_dest_info (context, FALSE);
if (info->proxy_data &&
- info->proxy_data->target == selection_data->target)
+ gtk_selection_data_get_target (info->proxy_data) == gtk_selection_data_get_target (selection_data))
{
gtk_selection_data_set (info->proxy_data,
- selection_data->type,
- selection_data->format,
- selection_data->data,
- selection_data->length);
+ gtk_selection_data_get_data_type (selection_data),
+ gtk_selection_data_get_format (selection_data),
+ gtk_selection_data_get_data (selection_data),
+ gtk_selection_data_get_length (selection_data));
gtk_main_quit ();
return;
}
- if (selection_data->target == gdk_atom_intern_static_string ("DELETE"))
+ target = gtk_selection_data_get_target (selection_data);
+ if (target == gdk_atom_intern_static_string ("DELETE"))
{
gtk_drag_finish (context, TRUE, FALSE, time);
}
- else if ((selection_data->target == gdk_atom_intern_static_string ("XmTRANSFER_SUCCESS")) ||
- (selection_data->target == gdk_atom_intern_static_string ("XmTRANSFER_FAILURE")))
+ else if ((target == gdk_atom_intern_static_string ("XmTRANSFER_SUCCESS")) ||
+ (target == gdk_atom_intern_static_string ("XmTRANSFER_FAILURE")))
{
/* Do nothing */
}
guint target_info;
if (gtk_target_list_find (site->target_list,
- selection_data->target,
+ target,
&target_info))
{
if (!(site->flags & GTK_DEST_DEFAULT_DROP) ||
- selection_data->length >= 0)
+ gtk_selection_data_get_length (selection_data) >= 0)
g_signal_emit_by_name (drop_widget,
"drag-data-received",
context, info->drop_x, info->drop_y,
{
gtk_drag_finish (context,
- (selection_data->length >= 0),
- (context->action == GDK_ACTION_MOVE),
+ (gtk_selection_data_get_length (selection_data) >= 0),
+ (gdk_drag_context_get_selected_action (context) == GDK_ACTION_MOVE),
time);
}
}
static void
-gtk_drag_proxy_begin (GtkWidget *widget,
+gtk_drag_proxy_begin (GtkWidget *widget,
GtkDragDestInfo *dest_info,
guint32 time)
{
ipc_widget = gtk_drag_get_ipc_widget (widget);
context = gdk_drag_begin (gtk_widget_get_window (ipc_widget),
- dest_info->context->targets);
+ gdk_drag_context_list_targets (dest_info->context));
source_info = gtk_drag_get_source_info (context, TRUE);
source_info->widget = g_object_ref (widget);
source_info->target_list = gtk_target_list_new (NULL, 0);
- tmp_list = dest_info->context->targets;
+ tmp_list = gdk_drag_context_list_targets (dest_info->context);
while (tmp_list)
{
- gtk_target_list_add (source_info->target_list,
+ gtk_target_list_add (source_info->target_list,
GDK_POINTER_TO_ATOM (tmp_list->data), 0, 0);
tmp_list = tmp_list->next;
}
{
gdk_drag_find_window_for_screen (info->proxy_source->context,
NULL,
- gdk_drawable_get_screen (current_event->dnd.window),
+ gdk_window_get_screen (current_event->dnd.window),
current_event->dnd.x_root,
current_event->dnd.y_root,
&dest_window, &proto);
dest_window, proto,
current_event->dnd.x_root,
current_event->dnd.y_root,
- context->suggested_action,
- context->actions, time);
+ gdk_drag_context_get_suggested_action (context),
+ gdk_drag_context_get_actions (context),
+ time);
if (!site->proxy_window && dest_window)
g_object_unref (dest_window);
if (site->track_motion || site->flags & GTK_DEST_DEFAULT_MOTION)
{
- if (context->suggested_action & site->actions)
- action = context->suggested_action;
+ if (gdk_drag_context_get_suggested_action (context) & site->actions)
+ action = gdk_drag_context_get_suggested_action (context);
else
{
gint i;
for (i = 0; i < 8; i++)
{
if ((site->actions & (1 << i)) &&
- (context->actions & (1 << i)))
+ (gdk_drag_context_get_actions (context) & (1 << i)))
{
action = (1 << i);
break;
if (site->do_proxy)
{
if (info->proxy_source ||
- (info->context->protocol == GDK_DRAG_PROTO_ROOTWIN))
+ (gdk_drag_context_get_protocol (info->context) == GDK_DRAG_PROTO_ROOTWIN))
{
gtk_drag_drop (info->proxy_source, time);
}
{
gdk_drag_find_window_for_screen (info->proxy_source->context,
NULL,
- gdk_drawable_get_screen (current_event->dnd.window),
+ gdk_window_get_screen (current_event->dnd.window),
current_event->dnd.x_root,
current_event->dnd.y_root,
&dest_window, &proto);
dest_window, proto,
current_event->dnd.x_root,
current_event->dnd.y_root,
- context->suggested_action,
- context->actions, time);
+ gdk_drag_context_get_suggested_action (context),
+ gdk_drag_context_get_actions (context),
+ time);
if (!site->proxy_window && dest_window)
g_object_unref (dest_window);
pointer = gdk_event_get_device (event);
- if (pointer->source == GDK_SOURCE_KEYBOARD)
+ if (gdk_device_get_source (pointer) == GDK_SOURCE_KEYBOARD)
{
keyboard = pointer;
pointer = gdk_device_get_associated_device (keyboard);
break;
}
site->icon_type = GTK_IMAGE_EMPTY;
-
- if (site->colormap)
- g_object_unref (site->colormap);
- site->colormap = NULL;
}
/**
gint hot_y)
{
g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
- g_return_if_fail (context->is_source);
g_return_if_fail (GTK_IS_WIDGET (widget));
gtk_drag_set_icon_window (context, widget, hot_x, hot_y, FALSE);
g_return_if_fail (pixbuf != NULL || stock_id != NULL);
g_return_if_fail (pixbuf == NULL || stock_id == NULL);
- screen = gdk_drawable_get_screen (context->source_window);
+ screen = gdk_window_get_screen (gdk_drag_context_get_source_window (context));
- /* Push a NULL colormap to guard against gtk_widget_push_colormap() */
- gtk_widget_push_colormap (NULL);
window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_DND);
gtk_window_set_screen (GTK_WINDOW (window), screen);
set_can_change_screen (window, TRUE);
- gtk_widget_pop_colormap ();
gtk_widget_set_events (window, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
gtk_widget_set_app_paintable (window, TRUE);
if (stock_id)
{
- pixbuf = gtk_widget_render_icon (window, stock_id,
- GTK_ICON_SIZE_DND, NULL);
+ pixbuf = gtk_widget_render_icon_pixbuf (window, stock_id,
+ GTK_ICON_SIZE_DND);
if (!pixbuf)
{
else
g_object_ref (pixbuf);
- display = gdk_drawable_get_display (context->source_window);
+ display = gdk_window_get_display (gdk_drag_context_get_source_window (context));
width = gdk_pixbuf_get_width (pixbuf);
height = gdk_pixbuf_get_height (pixbuf);
gint hot_y)
{
g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
- g_return_if_fail (context->is_source);
g_return_if_fail (GDK_IS_PIXBUF (pixbuf));
set_icon_stock_pixbuf (context, NULL, pixbuf, hot_x, hot_y, FALSE);
gint hot_y)
{
g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
- g_return_if_fail (context->is_source);
g_return_if_fail (stock_id != NULL);
set_icon_stock_pixbuf (context, stock_id, NULL, hot_x, hot_y, FALSE);
/**
* gtk_drag_set_icon_surface:
- * @context: the context for a drag. (This must be called
- * with a context for the source side of a drag)
- * @surface: the surface to use as icon
- *
+ * @context: the context for a drag. (This must be called
+ * with a context for the source side of a drag)
+ * @surface: the surface to use as icon
+ *
* Sets @surface as the icon for a given drag. GTK+ retains
* references for the arguments, and will release them when
* they are no longer needed.
+ *
+ * To position the surface relative to the mouse, use
+ * cairo_surface_set_device_offset() on @surface. The mouse
+ * cursor will be positioned at the (0,0) coordinate of the
+ * surface.
**/
void
gtk_drag_set_icon_surface (GdkDragContext *context,
cairo_pattern_t *pattern;
g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
- g_return_if_fail (context->is_source);
g_return_if_fail (surface != NULL);
_gtk_cairo_surface_extents (surface, &extents);
- screen = gdk_drawable_get_screen (context->source_window);
+ screen = gdk_window_get_screen (gdk_drag_context_get_source_window (context));
- /* Push a NULL colormap to guard against gtk_widget_push_colormap() */
- gtk_widget_push_colormap (NULL);
window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_DND);
gtk_window_set_screen (GTK_WINDOW (window), screen);
set_can_change_screen (window, TRUE);
- gtk_widget_pop_colormap ();
gtk_widget_set_events (window, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
gtk_widget_set_app_paintable (window, TRUE);
cairo_t *cr;
region = gdk_cairo_region_create_from_surface (surface);
+ cairo_region_translate (region, -extents.x, -extents.y);
+
gtk_widget_shape_combine_region (window, region);
cairo_region_destroy (region);
cr = cairo_create (saturated);
cairo_push_group_with_content (cr, CAIRO_CONTENT_COLOR_ALPHA);
- cairo_set_source_surface (cr, surface, extents.x, extents.y);
+ cairo_set_source_surface (cr, surface, -extents.x, -extents.y);
cairo_paint (cr);
cairo_set_operator (cr, CAIRO_OPERATOR_SATURATE);
cairo_paint (cr);
gint width, height, icon_size;
g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
- g_return_if_fail (context->is_source);
g_return_if_fail (icon_name != NULL);
- screen = gdk_drawable_get_screen (context->source_window);
+ screen = gdk_window_get_screen (gdk_drag_context_get_source_window (context));
g_return_if_fail (screen != NULL);
settings = gtk_settings_get_for_screen (screen);
gtk_drag_set_icon_default (GdkDragContext *context)
{
g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
- g_return_if_fail (context->is_source);
gtk_drag_set_icon_stock (context, GTK_STOCK_DND, -2, -2);
}
{
if (info->proxy_dest->proxy_drop_wait)
{
- gboolean result = context->action != 0;
+ gboolean result = gdk_drag_context_get_selected_action (context) != 0;
/* Aha - we can finally pass the MOTIF DROP on... */
gdk_drop_reply (info->proxy_dest->context, result, info->proxy_dest->proxy_drop_time);
else
{
gdk_drag_status (info->proxy_dest->context,
- event->dnd.context->action,
+ gdk_drag_context_get_selected_action (event->dnd.context),
event->dnd.time);
}
}
else if (info->have_grab)
{
cursor = gtk_drag_get_cursor (gtk_widget_get_display (widget),
- event->dnd.context->action,
+ gdk_drag_context_get_selected_action (event->dnd.context),
info);
if (info->cursor != cursor)
{
tmp_list = tmp_list->next;
}
- if (info->context->protocol == GDK_DRAG_PROTO_MOTIF)
+ if (gdk_drag_context_get_protocol (info->context) == GDK_DRAG_PROTO_MOTIF)
{
gtk_selection_add_target (info->ipc_widget,
selection,
gtk_drag_drop (GtkDragSourceInfo *info,
guint32 time)
{
- if (info->context->protocol == GDK_DRAG_PROTO_ROOTWIN)
+ if (gdk_drag_context_get_protocol (info->context) == GDK_DRAG_PROTO_ROOTWIN)
{
GtkSelectionData selection_data;
GList *tmp_list;
info->proxy_dest->proxy_data = selection_data;
gtk_drag_get_data (info->widget,
info->proxy_dest->context,
- selection_data->target,
+ gtk_selection_data_get_target (selection_data),
time);
gtk_main ();
info->proxy_dest->proxy_data = NULL;
else
{
if (gtk_target_list_find (info->target_list,
- selection_data->target,
+ gtk_selection_data_get_target (selection_data),
&target_info))
{
g_signal_emit_by_name (info->widget, "drag-data-get",
if (event->button != info->button)
return FALSE;
- if ((info->context->action != 0) && (info->context->dest_window != NULL))
+ if ((gdk_drag_context_get_selected_action (info->context) != 0) &&
+ (gdk_drag_context_get_dest_window (info->context) != NULL))
{
gtk_drag_end (info, event->time);
gtk_drag_drop (info, event->time);