#include "config.h"
+#include <math.h>
#include <stdlib.h>
#include <string.h>
GtkImageType icon_type;
union
{
- GtkImagePixmapData pixmap;
GtkImagePixbufData pixbuf;
GtkImageStockData stock;
GtkImageIconNameData name;
} icon_data;
- GdkBitmap *icon_mask;
-
- GdkColormap *colormap; /* Colormap for drag icon */
/* Stored button press information to detect drag beginning */
gint state;
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,
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 (context->source_window));
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;
-
- window = gtk_widget_get_window (widget);
+ int width = gtk_widget_get_allocated_width (widget);
+ int height = gtk_widget_get_allocated_height (widget);
- 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), cr,
+ GTK_STATE_NORMAL, GTK_SHADOW_OUT,
+ widget, "dnd",
+ 0, 0, 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;
{
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);
{
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);
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);
else
switch (site->icon_type)
{
- case GTK_IMAGE_PIXMAP:
- gtk_drag_set_icon_pixmap (context,
- site->colormap,
- site->icon_data.pixmap.pixmap,
- site->icon_mask,
- -2, -2);
- break;
case GTK_IMAGE_PIXBUF:
gtk_drag_set_icon_pixbuf (context,
site->icon_data.pixbuf.pixbuf,
{
case GTK_IMAGE_EMPTY:
break;
- case GTK_IMAGE_PIXMAP:
- if (site->icon_data.pixmap.pixmap)
- g_object_unref (site->icon_data.pixmap.pixmap);
- if (site->icon_mask)
- g_object_unref (site->icon_mask);
- break;
case GTK_IMAGE_PIXBUF:
g_object_unref (site->icon_data.pixbuf.pixbuf);
break;
break;
}
site->icon_type = GTK_IMAGE_EMPTY;
-
- if (site->colormap)
- g_object_unref (site->colormap);
- site->colormap = NULL;
-}
-
-/**
- * gtk_drag_source_set_icon:
- * @widget: a #GtkWidget
- * @colormap: the colormap of the icon
- * @pixmap: the image data for the icon
- * @mask: (allow-none): the transparency mask for an image.
- *
- * Sets the icon that will be used for drags from a particular widget
- * from a pixmap/mask. GTK+ retains references for the arguments, and
- * will release them when they are no longer needed.
- * Use gtk_drag_source_set_icon_pixbuf() instead.
- **/
-void
-gtk_drag_source_set_icon (GtkWidget *widget,
- GdkColormap *colormap,
- GdkPixmap *pixmap,
- GdkBitmap *mask)
-{
- GtkDragSourceSite *site;
-
- g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (GDK_IS_COLORMAP (colormap));
- g_return_if_fail (GDK_IS_PIXMAP (pixmap));
- g_return_if_fail (!mask || GDK_IS_PIXMAP (mask));
-
- site = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
- g_return_if_fail (site != NULL);
-
- g_object_ref (colormap);
- g_object_ref (pixmap);
- if (mask)
- g_object_ref (mask);
-
- gtk_drag_source_unset_icon (site);
-
- site->icon_type = GTK_IMAGE_PIXMAP;
-
- site->icon_data.pixmap.pixmap = pixmap;
- site->icon_mask = mask;
- site->colormap = colormap;
}
/**
icon_window_realize (GtkWidget *window,
GdkPixbuf *pixbuf)
{
- GdkPixmap *pixmap;
- GdkPixmap *mask;
+ cairo_surface_t *surface;
+ cairo_pattern_t *pattern;
+ cairo_t *cr;
+
+ surface = gdk_window_create_similar_surface (gtk_widget_get_window (window),
+ CAIRO_CONTENT_COLOR,
+ gdk_pixbuf_get_width (pixbuf),
+ gdk_pixbuf_get_height (pixbuf));
+
+ cr = cairo_create (surface);
+ cairo_push_group_with_content (cr, CAIRO_CONTENT_COLOR_ALPHA);
+ gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
+ cairo_paint (cr);
+ cairo_set_operator (cr, CAIRO_OPERATOR_SATURATE);
+ cairo_paint (cr);
+ cairo_pop_group_to_source (cr);
+ cairo_paint (cr);
+ cairo_destroy (cr);
+
+ pattern = cairo_pattern_create_for_surface (surface);
+ gdk_window_set_background_pattern (gtk_widget_get_window (window), pattern);
+ cairo_pattern_destroy (pattern);
+
+ cairo_surface_destroy (surface);
+
+ if (gdk_pixbuf_get_has_alpha (pixbuf))
+ {
+ cairo_region_t *region;
- gdk_pixbuf_render_pixmap_and_mask_for_colormap (pixbuf,
- gtk_widget_get_colormap (window),
- &pixmap, &mask, 128);
+ surface = cairo_image_surface_create (CAIRO_FORMAT_A1,
+ gdk_pixbuf_get_width (pixbuf),
+ gdk_pixbuf_get_height (pixbuf));
+
+ cr = cairo_create (surface);
+ gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
+ cairo_paint (cr);
+ cairo_destroy (cr);
- gdk_window_set_back_pixmap (gtk_widget_get_window (window),
- pixmap, FALSE);
- g_object_unref (pixmap);
-
- if (mask)
- {
- gtk_widget_shape_combine_mask (window, mask, 0, 0);
- g_object_unref (mask);
+ region = gdk_cairo_region_create_from_surface (surface);
+ gtk_widget_shape_combine_region (window, region);
+ cairo_region_destroy (region);
+
+ cairo_surface_destroy (surface);
}
}
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 (context->source_window);
- /* 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 (context->source_window);
width = gdk_pixbuf_get_width (pixbuf);
height = gdk_pixbuf_get_height (pixbuf);
set_icon_stock_pixbuf (context, stock_id, NULL, hot_x, hot_y, FALSE);
}
+/* XXX: This function is in gdk, too. Should it be in Cairo? */
+static gboolean
+_gtk_cairo_surface_extents (cairo_surface_t *surface,
+ GdkRectangle *extents)
+{
+ double x1, x2, y1, y2;
+ cairo_t *cr;
+
+ g_return_val_if_fail (surface != NULL, FALSE);
+ g_return_val_if_fail (extents != NULL, FALSE);
+
+ cr = cairo_create (surface);
+ cairo_clip_extents (cr, &x1, &y1, &x2, &y2);
+
+ x1 = floor (x1);
+ y1 = floor (y1);
+ x2 = ceil (x2);
+ y2 = ceil (y2);
+ x2 -= x1;
+ y2 -= y1;
+
+ if (x1 < G_MININT || x1 > G_MAXINT ||
+ y1 < G_MININT || y1 > G_MAXINT ||
+ x2 > G_MAXINT || y2 > G_MAXINT)
+ {
+ extents->x = extents->y = extents->width = extents->height = 0;
+ return FALSE;
+ }
+
+ extents->x = x1;
+ extents->y = y1;
+ extents->width = x2;
+ extents->height = y2;
+
+ return TRUE;
+}
+
/**
- * gtk_drag_set_icon_pixmap:
- * @context: the context for a drag. (This must be called
- * with a context for the source side of a drag)
- * @colormap: the colormap of the icon
- * @pixmap: the image data for the icon
- * @mask: (allow-none): the transparency mask for the icon or %NULL for none.
- * @hot_x: the X offset within @pixmap of the hotspot.
- * @hot_y: the Y offset within @pixmap of the hotspot.
- *
- * Sets @pixmap as the icon for a given drag. GTK+ retains
+ * 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
+ *
+ * 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. In general, gtk_drag_set_icon_pixbuf()
- * will be more convenient to use.
+ * 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_pixmap (GdkDragContext *context,
- GdkColormap *colormap,
- GdkPixmap *pixmap,
- GdkBitmap *mask,
- gint hot_x,
- gint hot_y)
+gtk_drag_set_icon_surface (GdkDragContext *context,
+ cairo_surface_t *surface)
{
GtkWidget *window;
GdkScreen *screen;
- gint width, height;
+ GdkRectangle extents;
+ cairo_pattern_t *pattern;
g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
g_return_if_fail (context->is_source);
- g_return_if_fail (GDK_IS_COLORMAP (colormap));
- g_return_if_fail (GDK_IS_PIXMAP (pixmap));
- g_return_if_fail (!mask || GDK_IS_PIXMAP (mask));
+ g_return_if_fail (surface != NULL);
- screen = gdk_colormap_get_screen (colormap);
-
- g_return_if_fail (gdk_drawable_get_screen (pixmap) == screen);
- g_return_if_fail (!mask || gdk_drawable_get_screen (mask) == screen);
-
- gdk_drawable_get_size (pixmap, &width, &height);
+ _gtk_cairo_surface_extents (surface, &extents);
- gtk_widget_push_colormap (colormap);
+
+ screen = gdk_window_get_screen (context->source_window);
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, FALSE);
- gtk_widget_set_events (window, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
- gtk_widget_set_app_paintable (GTK_WIDGET (window), TRUE);
+ 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);
- gtk_widget_set_size_request (window, width, height);
+ gtk_widget_set_size_request (window, extents.width, extents.height);
gtk_widget_realize (window);
- gdk_window_set_back_pixmap (gtk_widget_get_window (window),
- pixmap, FALSE);
+ if (cairo_surface_get_content (surface) != CAIRO_CONTENT_COLOR)
+ {
+ cairo_surface_t *saturated;
+ cairo_region_t *region;
+ 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);
+
+ /* Need to saturate the colors, so it doesn't look like semi-transparent
+ * pixels were painted on black. */
+ saturated = gdk_window_create_similar_surface (gtk_widget_get_window (window),
+ CAIRO_CONTENT_COLOR,
+ extents.width,
+ extents.height);
+
+ 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_paint (cr);
+ cairo_set_operator (cr, CAIRO_OPERATOR_SATURATE);
+ cairo_paint (cr);
+ cairo_pop_group_to_source (cr);
+ cairo_paint (cr);
+ cairo_destroy (cr);
+
+ pattern = cairo_pattern_create_for_surface (saturated);
+
+ cairo_surface_destroy (saturated);
+ }
+ else
+ {
+ cairo_matrix_t matrix;
+
+ pattern = cairo_pattern_create_for_surface (surface);
+ cairo_matrix_init_translate (&matrix, extents.x, extents.y);
+ cairo_pattern_set_matrix (pattern, &matrix);
+ }
- if (mask)
- gtk_widget_shape_combine_mask (window, mask, 0, 0);
+ gdk_window_set_background_pattern (gtk_widget_get_window (window), pattern);
- gtk_drag_set_icon_window (context, window, hot_x, hot_y, TRUE);
+ gtk_drag_set_icon_window (context, window, extents.x, extents.y, TRUE);
}
/**
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 (context->source_window);
g_return_if_fail (screen != NULL);
settings = gtk_settings_get_for_screen (screen);