static void
gtk_bubble_window_update_shape (GtkBubbleWindow *window)
{
cairo_surface_t *surface;
cairo_region_t *region;
GdkWindow *win;
cairo_t *cr;
win = gtk_widget_get_window (GTK_WIDGET (window));
surface =
gdk_window_create_similar_surface (win,
CAIRO_CONTENT_COLOR_ALPHA,
gdk_window_get_width (win),
gdk_window_get_height (win));
cr = cairo_create (surface);
gtk_bubble_window_apply_border_path (window, cr);
cairo_fill (cr);
cairo_destroy (cr);
region = gdk_cairo_region_create_from_surface (surface);
cairo_surface_destroy (surface);
if (!gtk_widget_is_composited (GTK_WIDGET (window)))
gtk_widget_shape_combine_region (GTK_WIDGET (window), region);
gtk_widget_input_shape_combine_region (GTK_WIDGET (window), region);
cairo_region_destroy (region);
}
static void
maybe_update_shape (GtkWidget *widget)
{
cairo_t *cr;
cairo_surface_t *surface;
cairo_region_t *region;
/* fallback to XShape only for non-composited clients */
if (gtk_widget_is_composited (widget)) {
gtk_widget_shape_combine_region (widget, NULL);
return;
}
surface = gdk_window_create_similar_surface (gtk_widget_get_window (widget),
CAIRO_CONTENT_COLOR_ALPHA,
gtk_widget_get_allocated_width (widget),
gtk_widget_get_allocated_height (widget));
cr = cairo_create (surface);
label_draw_background_and_frame (widget, cr, TRUE);
cairo_destroy (cr);
region = gdk_cairo_region_create_from_surface (surface);
gtk_widget_shape_combine_region (widget, region);
cairo_surface_destroy (surface);
cairo_region_destroy (region);
}
static void
maybe_update_shape (GtkTooltip *tooltip)
{
cairo_t *cr;
cairo_surface_t *surface;
cairo_region_t *region;
/* fallback to XShape only for non-composited clients */
if (gtk_widget_is_composited (tooltip->window))
{
gtk_widget_shape_combine_region (tooltip->window, NULL);
return;
}
surface = gdk_window_create_similar_surface (gtk_widget_get_window (tooltip->window),
CAIRO_CONTENT_COLOR_ALPHA,
gtk_widget_get_allocated_width (tooltip->window),
gtk_widget_get_allocated_height (tooltip->window));
cr = cairo_create (surface);
paint_background_and_frame (tooltip, cr);
cairo_destroy (cr);
region = gdk_cairo_region_create_from_surface (surface);
gtk_widget_shape_combine_region (tooltip->window, region);
cairo_surface_destroy (surface);
cairo_region_destroy (region);
}
static gboolean on_draw(GtkWidget *widget, gpointer data)
{
cairo_t *cr;
GtkAllocation alloc;
gtk_widget_get_allocation(widget, &alloc);
gint width = alloc.width;
gint height = alloc.height;
gint r = 5;
cr = gdk_cairo_create(gtk_widget_get_window(widget));
cairo_surface_t *surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
width,
height);
cairo_t *cr2 = cairo_create(surface);
draw_round_rectangle(cr2, 0, 0, width, height, r);
cairo_stroke_preserve(cr2);
cairo_fill(cr2) ;
cairo_destroy(cr2);
cairo_region_t *region = gdk_cairo_region_create_from_surface(surface);
gtk_widget_shape_combine_region(widget, region);
cairo_set_line_width(cr, 0.3);
cairo_set_source_rgb(cr, 0.78, 0.78, 0.78);
draw_round_rectangle(cr, 0, 0, width, height, r);
cairo_stroke(cr);
cairo_region_destroy(region);
cairo_surface_destroy(surface);
cairo_destroy(cr);
}
static void
dnd_hints_realized_cb(GtkWidget *window, GtkWidget *pix)
{
GdkPixbuf *pixbuf;
cairo_surface_t *surface;
cairo_region_t *region;
cairo_t *cr;
pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(pix));
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);
region = gdk_cairo_region_create_from_surface(surface);
gtk_widget_shape_combine_region(window, region);
cairo_region_destroy(region);
cairo_surface_destroy(surface);
}
static void
update_shape_region (cairo_surface_t *surface,
WindowData *windata)
{
if (windata->width == windata->last_width && windata->height == windata->last_height)
{
return;
}
if (windata->width == 0 || windata->height == 0)
{
GtkAllocation allocation;
gtk_widget_get_allocation (windata->win, &allocation);
windata->width = MAX (allocation.width, 1);
windata->height = MAX (allocation.height, 1);
}
if (!windata->composited) {
cairo_region_t *region;
region = gdk_cairo_region_create_from_surface (surface);
gtk_widget_shape_combine_region (windata->win, region);
cairo_region_destroy (region);
} else {
gtk_widget_shape_combine_region (windata->win, NULL);
return;
}
windata->last_width = windata->width;
windata->last_height = windata->height;
}
void on_monitors_changed ( GdkScreen *screen,
gpointer user_data)
{
GromitData *data = (GromitData *) user_data;
if(data->debug)
g_printerr("DEBUG: screen size changed!\n");
// get new sizes
data->width = gdk_screen_get_width (data->screen);
data->height = gdk_screen_get_height (data->screen);
// change size
gtk_widget_set_size_request(GTK_WIDGET(data->win), data->width, data->height);
// try to set transparent for input
cairo_region_t* r = cairo_region_create();
gtk_widget_input_shape_combine_region(data->win, r);
cairo_region_destroy(r);
/* recreate the shape surface */
cairo_surface_t *new_shape = cairo_image_surface_create(CAIRO_FORMAT_ARGB32 ,data->width, data->height);
cairo_t *cr = cairo_create (new_shape);
cairo_set_source_surface (cr, data->backbuffer, 0, 0);
cairo_paint (cr);
cairo_destroy (cr);
cairo_surface_destroy(data->backbuffer);
data->backbuffer = new_shape;
/*
these depend on the shape surface
*/
GHashTableIter it;
gpointer value;
g_hash_table_iter_init (&it, data->tool_config);
while (g_hash_table_iter_next (&it, NULL, &value))
paint_context_free(value);
g_hash_table_remove_all(data->tool_config);
parse_config(data); // also calls paint_context_new() :-(
data->default_pen = paint_context_new (data, GROMIT_PEN,
data->red, 7, 0, 1);
data->default_eraser = paint_context_new (data, GROMIT_ERASER,
data->red, 75, 0, 1);
if(!data->composited) // set shape
{
cairo_region_t* r = gdk_cairo_region_create_from_surface(data->backbuffer);
gtk_widget_shape_combine_region(data->win, r);
cairo_region_destroy(r);
}
setup_input_devices(data);
gtk_widget_show_all (data->win);
}
void gMainWindow::drawMask()
{
bool do_remap = false;
if (!isVisible())
return;
#ifdef GTK3
cairo_region_t *mask;
if (_mask && _picture)
mask = gdk_cairo_region_create_from_surface(_picture->getSurface());
else
mask = NULL;
gdk_window_shape_combine_region(gtk_widget_get_window(border), mask, 0, 0);
if (mask)
cairo_region_destroy(mask);
refresh();
#else
GdkBitmap *mask = (_mask && _picture) ? _picture->getMask() : NULL;
do_remap = !mask && _masked;
gdk_window_shape_combine_mask(border->window, mask, 0, 0);
#endif
if (_picture)
{
gtk_widget_set_app_paintable(border, TRUE);
gtk_widget_realize(border);
gtk_widget_realize(widget);
for (int i = 0; i < controlCount(); i++)
getControl(i)->refresh();
}
else if (!_transparent)
{
gtk_widget_set_app_paintable(border, FALSE);
setRealBackground(background());
}
_masked = mask != NULL;
if (do_remap)
remap();
else
{
if (!_skip_taskbar)
{
setSkipTaskBar(true);
setSkipTaskBar(false);
}
}
}
static cairo_region_t*
curved_rect_mask(GtkWidget *widget)
{
GdkWindow *window;
cairo_region_t *shape;
cairo_surface_t *surface;
cairo_t *cr;
double w, h;
int radius;
if (!gtk_widget_get_realized(widget))
return NULL;
window = gtk_widget_get_window(widget);
w = gdk_window_get_width(window);
h = gdk_window_get_height(window);
if (w <= 50 || h <= 50)
return NULL;
radius = h / 4;
surface = gdk_window_create_similar_surface(window,
CAIRO_CONTENT_COLOR_ALPHA,
w, h);
cr = cairo_create (surface);
if (radius > w / 2)
radius = w / 2;
if (radius > h / 2)
radius = h / 2;
// fill shape with black
cairo_save(cr);
cairo_rectangle (cr, 0, 0, w, h);
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
cairo_fill (cr);
cairo_restore (cr);
cairo_move_to (cr, 0, radius);
cairo_curve_to (cr, 0 , 0, 0 , 0, radius, 0);
cairo_line_to (cr, w - radius, 0);
cairo_curve_to (cr, w, 0, w, 0, w, radius);
cairo_line_to (cr, w , h - radius);
cairo_curve_to (cr, w, h, w, h, w - radius, h);
cairo_line_to (cr, 0 + radius, h);
cairo_curve_to (cr, 0, h, 0, h, 0, h - radius);
cairo_close_path(cr);
cairo_set_source_rgb(cr, 1, 1, 1);
cairo_fill(cr);
cairo_destroy(cr);
shape = gdk_cairo_region_create_from_surface(surface);
cairo_surface_destroy(surface);
return shape;
}
virtual bool DoSetShape(GdkWindow *window)
{
if (!m_mask)
return false;
#ifdef __WXGTK3__
cairo_region_t* region = gdk_cairo_region_create_from_surface(m_mask);
gdk_window_shape_combine_region(window, region, 0, 0);
cairo_region_destroy(region);
#else
gdk_window_shape_combine_mask(window, m_mask, 0, 0);
#endif
return true;
}
gboolean on_draw(GtkWidget *widget, gpointer data)
{
GtkAllocation alloc;
gint x, y, width, height, r;
gtk_widget_get_allocation(widget, &alloc);
x = alloc.x;
y = alloc.y;
width = alloc.width;
height = alloc.height;
r = 5;
cairo_t *cr = gdk_cairo_create(gtk_widget_get_window(widget));
cairo_surface_t *surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
cairo_t *cr2 = cairo_create(surface);
cairo_move_to(cr2, r, 0);
cairo_line_to(cr2, width-r, 0);
cairo_move_to(cr2, width, r);
cairo_line_to(cr2, width, height-r);
cairo_move_to(cr2, width-r, height);
cairo_move_to(cr2, r, height);
cairo_move_to(cr2, 0, height-r);
cairo_line_to(cr2, 0, r);
cairo_arc(cr2, r, r, r, G_PI, 3 * G_PI / 2.0 );
cairo_arc(cr2, width-r, r, r, 3 * G_PI /2.0, 2 * G_PI);
cairo_arc(cr2, width-r, height-r, r, 0, G_PI / 2);
cairo_arc(cr2, r, height-r, r, G_PI / 2, G_PI);
cairo_fill(cr2);
cairo_set_source_rgba(cr, 0, 0, 0, 0);
cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
cairo_paint(cr);
cairo_region_t *region = gdk_cairo_region_create_from_surface(surface);
gtk_widget_shape_combine_region(widget, region);
cairo_destroy(cr2);
cairo_destroy(cr);
cairo_region_destroy(region);
cairo_surface_destroy(surface);
return FALSE;
}
static void
update_shape (CsdLocatePointerData *data)
{
cairo_t *cr;
cairo_region_t *region;
cairo_surface_t *mask;
mask = cairo_image_surface_create (CAIRO_FORMAT_A1, WINDOW_SIZE, WINDOW_SIZE);
cr = cairo_create (mask);
locate_pointer_paint (data, cr, FALSE);
region = gdk_cairo_region_create_from_surface (mask);
gdk_window_shape_combine_region (data->window, region, 0, 0);
cairo_region_destroy (region);
cairo_destroy (cr);
cairo_surface_destroy (mask);
}
/* Clear the background. */
void clear_background_window ()
{
/*
* @HACK Deny the mouse input to go below the window putting the opacity greater than 0
* I avoid a complete transparent window because in some operating system this would become
* transparent to the pointer input also.
*
*/
gtk_window_set_opacity (GTK_WINDOW (background_data->background_window), BACKGROUND_OPACITY);
clear_cairo_context (background_data->background_cr);
/* This allows the mouse event to be passed to the window below. */
#ifndef _WIN32
cairo_region_t* r = gdk_cairo_region_create_from_surface(cairo_get_target (background_data->background_cr));
gtk_widget_input_shape_combine_region (background_data->background_window, r);
cairo_region_destroy(r);
#endif
}
static int gtkDialogSetOpacityImageAttrib(Ihandle *ih, const char *value)
{
GdkPixbuf* pixbuf = iupImageGetImage(value, ih, 0);
if (pixbuf)
{
#if GTK_CHECK_VERSION(3, 0, 0)
GdkWindow* window = iupgtkGetWindow(ih->handle);
if (window)
{
cairo_region_t *shape;
#if GTK_CHECK_VERSION(3, 10, 0)
cairo_surface_t* surface = gdk_cairo_surface_create_from_pixbuf(pixbuf, 0, window);
#else
int width = gdk_pixbuf_get_width(pixbuf);
int height = gdk_pixbuf_get_height(pixbuf);
cairo_surface_t* surface = gdk_window_create_similar_surface(window, CAIRO_CONTENT_COLOR_ALPHA, width, height);
cairo_t* cr = cairo_create(surface);
gdk_cairo_set_source_pixbuf(cr, pixbuf, 0, 0);
cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
cairo_paint(cr);
cairo_destroy(cr);
#endif
shape = gdk_cairo_region_create_from_surface(surface);
cairo_surface_destroy(surface);
gtk_widget_shape_combine_region(ih->handle, shape);
cairo_region_destroy(shape);
}
#else
GdkBitmap* mask = NULL;
gdk_pixbuf_render_pixmap_and_mask(pixbuf, NULL, &mask, 255);
if (mask)
{
gtk_widget_shape_combine_mask(ih->handle, mask, 0, 0);
g_object_unref(mask);
}
#endif
return 1;
}
return 0;
}
static inline
cairo_region_t *
get_cairo_region_create_from_surface(struct qp_graph *gr,
cairo_surface_t *surface, int width, int height)
{
/* TODO: this is a resource pig. Make it better. */
cairo_rectangle_int_t rect;
cairo_surface_t *image;
cairo_region_t *region;
cairo_t *cr;
uint32_t *data, bg;
int x, y, stride;
if(!gr->x11)
/* Creates region that covers the area where the
* given surface is more than 50% opaque.
* The below code copies this method. This GDK
* code is a pig too. */
return gdk_cairo_region_create_from_surface(surface);
if(!gr->x11->background_set)
{
/* We need to see what the background color is when it is
* applied to an image. A small image. */
image = cairo_image_surface_create(CAIRO_FORMAT_RGB24, 1, 1);
cr = cairo_create(image);
cairo_set_source_rgba(cr, gr->background_color.r,
gr->background_color.g, gr->background_color.b,
gr->background_color.a);
cairo_paint (cr);
cairo_destroy (cr);
data = (void *) cairo_image_surface_get_data(image);
gr->x11->background = (data[0] & 0x00FFFFFF);
cairo_surface_destroy(image);
gr->x11->background_set = 1;
}
bg = gr->x11->background;
image = cairo_image_surface_create(CAIRO_FORMAT_RGB24, width, height);
cr = cairo_create(image);
cairo_set_source_surface(cr, surface, 0, 0);
cairo_paint (cr);
cairo_destroy (cr);
data = (void *) cairo_image_surface_get_data(image);
stride = cairo_image_surface_get_stride(image);
region = cairo_region_create();
for(y=0; y < height; y++)
{
for(x=0; x < width; x++)
{
/* Search for a continuous range of "background pixels"*/
gint x0=x;
while(x < width)
{
if((data[x] & 0x00FFFFFF) == bg)
/* This pixel is the background color */
break;
x++;
}
if(x > x0)
{
/* Add the pixels (x0, y) to (x, y+1) as a new rectangle
* in the region
*/
rect.x = x0;
rect.width = x - x0;
rect.y = y;
rect.height = 1;
cairo_region_union_rectangle(region, &rect);
}
}
data += stride/4;
}
cairo_surface_destroy(image);
return region;
}
static void create_win_message(char *icon, char *text, int duration)
{
GtkWidget *gwin_message = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_has_resize_grip(GTK_WINDOW(gwin_message), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (gwin_message), 0);
gtk_widget_realize (gwin_message);
GdkWindow *gdkwin = gtk_widget_get_window(gwin_message);
set_no_focus(gwin_message);
GtkWidget *hbox = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (gwin_message), hbox);
if (icon[0] != '-') {
GtkWidget *image = gtk_image_new_from_file(icon);
if (text[0] == '-') {
#if GTK_CHECK_VERSION(2,91,0)
GdkPixbuf *pixbuf = NULL;
GdkPixbufAnimation *anime = NULL;
switch(gtk_image_get_storage_type(GTK_IMAGE(image))) {
case GTK_IMAGE_PIXBUF:
pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(image));
break;
case GTK_IMAGE_ANIMATION:
anime = gtk_image_get_animation(GTK_IMAGE(image));
pixbuf = gdk_pixbuf_animation_get_static_image(anime);
break;
default:
break;
}
cairo_surface_t *img = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf));
cairo_t *cr = cairo_create(img);
gdk_cairo_set_source_pixbuf(cr, pixbuf, 0, 0);
cairo_paint(cr);
cairo_region_t *mask = gdk_cairo_region_create_from_surface(img);
gtk_widget_shape_combine_region(gwin_message, mask);
cairo_region_destroy(mask);
cairo_destroy(cr);
cairo_surface_destroy(img);
#else
GdkBitmap *bitmap = NULL;
gdk_pixbuf_render_pixmap_and_mask(gdk_pixbuf_new_from_file(icon, NULL), NULL, &bitmap, 128);
gtk_widget_shape_combine_mask(gwin_message, bitmap, 0, 0);
#endif
}
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
}
if (text[0] != '-') {
GtkWidget *label = gtk_label_new(text);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
}
gtk_widget_show_all(gwin_message);
int width, height;
get_win_size(gwin_message, &width, &height);
int ox=-1, oy;
int szx, szy;
if (tray_da_win) {
gdk_window_get_origin (tray_da_win, &ox, &oy);
#if !GTK_CHECK_VERSION(2,91,0)
gdk_drawable_get_size(tray_da_win, &szx, &szy);
#else
szx = gdk_window_get_width(tray_da_win);
szy = gdk_window_get_height(tray_da_win);
#endif
if (oy<height) {
oy = szy;
} else {
oy -= height;
if (oy + height > dpy_yl)
oy = dpy_yl - height;
if (oy < 0)
oy = 0;
}
if (ox + width > dpy_xl)
ox = dpy_xl - width;
if (ox < 0)
ox = 0;
} else
if (icon_main) {
GdkRectangle rect;
GtkOrientation ori;
if (gtk_status_icon_get_geometry(icon_main, NULL, &rect, &ori)) {
dbg("rect %d,%d\n", rect.x, rect.y, rect.width, rect.height);
if (ori==GTK_ORIENTATION_HORIZONTAL) {
ox=rect.x;
if (rect.y > 100)
oy=rect.y - height;
else
oy=rect.y + rect.height;
} else {
oy=rect.y;
if (rect.x > 100)
ox=rect.x - width;
else
ox=rect.x + rect.width;
}
}
}
if (ox < 0) {
ox = dpy_xl - width;
oy = dpy_yl - height;
}
gtk_window_move(GTK_WINDOW(gwin_message), ox, oy);
g_timeout_add(duration, (GSourceFunc)timeout_destroy_window, gwin_message);
}
wxRegion::wxRegion( size_t n, const wxPoint *points,
wxPolygonFillMode fillStyle )
{
#ifdef __WXGTK3__
// Make a cairo path from the points, draw it onto an image surface, use
// gdk_cairo_region_create_from_surface() to get a cairo region
// need at least 3 points to make a useful polygon
if (n < 3)
return;
// get bounding rect
int min_x = points[0].x;
int max_x = min_x;
int min_y = points[0].y;
int max_y = min_y;
size_t i;
for (i = 1; i < n; i++)
{
const int x = points[i].x;
if (min_x > x)
min_x = x;
else if (max_x < x)
max_x = x;
const int y = points[i].y;
if (min_y > y)
min_y = y;
else if (max_y < y)
max_y = y;
}
const int w = max_x - min_x + 1;
const int h = max_y - min_y + 1;
// make surface just big enough to contain polygon (A1 is native format
// for gdk_cairo_region_create_from_surface)
cairo_surface_t* surface = cairo_image_surface_create(CAIRO_FORMAT_A1, w, h);
memset(cairo_image_surface_get_data(surface), 0, cairo_image_surface_get_stride(surface) * h);
cairo_surface_mark_dirty(surface);
cairo_surface_set_device_offset(surface, -min_x, -min_y);
cairo_t* cr = cairo_create(surface);
cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
if (fillStyle == wxODDEVEN_RULE)
cairo_set_fill_rule(cr, CAIRO_FILL_RULE_EVEN_ODD);
// make path
cairo_move_to(cr, points[0].x, points[0].y);
for (i = 1; i < n; i++)
cairo_line_to(cr, points[i].x, points[i].y);
cairo_close_path(cr);
cairo_fill(cr);
cairo_destroy(cr);
cairo_surface_flush(surface);
m_refData = new wxRegionRefData;
M_REGIONDATA->m_region = gdk_cairo_region_create_from_surface(surface);
cairo_surface_destroy(surface);
#else
GdkPoint *gdkpoints = new GdkPoint[n];
for ( size_t i = 0 ; i < n ; i++ )
{
gdkpoints[i].x = points[i].x;
gdkpoints[i].y = points[i].y;
}
m_refData = new wxRegionRefData();
GdkRegion* reg = gdk_region_polygon
(
gdkpoints,
n,
fillStyle == wxWINDING_RULE ? GDK_WINDING_RULE
: GDK_EVEN_ODD_RULE
);
M_REGIONDATA->m_region = reg;
delete [] gdkpoints;
#endif
}
void wxDropSource::PrepareIcon( int action, GdkDragContext *context )
{
// get the right icon to display
wxIcon *icon = NULL;
if ( action & GDK_ACTION_MOVE )
icon = &m_iconMove;
else if ( action & GDK_ACTION_COPY )
icon = &m_iconCopy;
else
icon = &m_iconNone;
#ifndef __WXGTK3__
GdkBitmap *mask;
if ( icon->GetMask() )
mask = *icon->GetMask();
else
mask = NULL;
GdkPixmap *pixmap = icon->GetPixmap();
GdkColormap *colormap = gtk_widget_get_colormap( m_widget );
gtk_widget_push_colormap (colormap);
#endif
m_iconWindow = gtk_window_new (GTK_WINDOW_POPUP);
gtk_widget_set_events (m_iconWindow, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
gtk_widget_set_app_paintable (m_iconWindow, TRUE);
#ifdef __WXGTK3__
gtk_widget_set_visual(m_iconWindow, gtk_widget_get_visual(m_widget));
#else
gtk_widget_pop_colormap ();
#endif
gtk_widget_set_size_request (m_iconWindow, icon->GetWidth(), icon->GetHeight());
gtk_widget_realize (m_iconWindow);
g_signal_connect (m_iconWindow, "configure_event",
G_CALLBACK (gtk_dnd_window_configure_callback), this);
#ifdef __WXGTK3__
cairo_t* cr = gdk_cairo_create(gtk_widget_get_window(m_iconWindow));
icon->SetSourceSurface(cr, 0, 0);
cairo_pattern_t* pattern = cairo_get_source(cr);
gdk_window_set_background_pattern(gtk_widget_get_window(m_iconWindow), pattern);
cairo_destroy(cr);
cairo_surface_t* mask = NULL;
if (icon->GetMask())
mask = *icon->GetMask();
if (mask)
{
cairo_region_t* region = gdk_cairo_region_create_from_surface(mask);
gtk_widget_shape_combine_region(m_iconWindow, region);
cairo_region_destroy(region);
}
#else
gdk_window_set_back_pixmap(gtk_widget_get_window(m_iconWindow), pixmap, false);
if (mask)
gtk_widget_shape_combine_mask (m_iconWindow, mask, 0, 0);
#endif
gtk_drag_set_icon_widget( context, m_iconWindow, 0, 0 );
}
