static void
na_tray_child_realize (GtkWidget *widget)
{
NaTrayChild *child = NA_TRAY_CHILD (widget);
GdkVisual *visual = gtk_widget_get_visual (widget);
GdkWindow *window;
GTK_WIDGET_CLASS (na_tray_child_parent_class)->realize (widget);
window = gtk_widget_get_window (widget);
if (child->has_alpha)
{
/* We have real transparency with an ARGB visual and the Composite
* extension. */
/* Set a transparent background */
cairo_pattern_t *transparent = cairo_pattern_create_rgba (0, 0, 0, 0);
gdk_window_set_background_pattern (window, transparent);
gdk_window_set_composited (window, TRUE);
cairo_pattern_destroy (transparent);
child->parent_relative_bg = FALSE;
}
else if (visual == gdk_window_get_visual (gdk_window_get_parent (window)))
{
/* Otherwise, if the visual matches the visual of the parent window, we
* can use a parent-relative background and fake transparency. */
gdk_window_set_background_pattern (window, NULL);
child->parent_relative_bg = TRUE;
}
else
{
/* Nothing to do; the icon will sit on top of an ugly gray box */
child->parent_relative_bg = FALSE;
}
gdk_window_set_composited (window, child->composited);
gtk_widget_set_app_paintable (GTK_WIDGET (child),
child->parent_relative_bg || child->has_alpha);
/* Double-buffering will interfere with the parent-relative-background fake
* transparency, since the double-buffer code doesn't know how to fill in the
* background of the double-buffer correctly.
*/
gtk_widget_set_double_buffered (GTK_WIDGET (child),
child->parent_relative_bg);
}
static void
on_finished (MateBGCrossfade *fade)
{
if (fade->priv->timeout_id == 0)
return;
g_assert (fade->priv->end_surface != NULL);
#if GTK_CHECK_VERSION (3, 0, 0)
cairo_pattern_t *pattern;
pattern = cairo_pattern_create_for_surface (fade->priv->end_surface);
gdk_window_set_background_pattern (fade->priv->window, pattern);
cairo_pattern_destroy (pattern);
#else
gdk_window_set_back_pixmap (fade->priv->window,
fade->priv->end_surface,
FALSE);
#endif
draw_background (fade);
cairo_surface_destroy (fade->priv->end_surface);
fade->priv->end_surface = NULL;
g_assert (fade->priv->fading_surface != NULL);
cairo_surface_destroy (fade->priv->fading_surface);
fade->priv->fading_surface = NULL;
fade->priv->timeout_id = 0;
g_signal_emit (fade, signals[FINISHED], 0, fade->priv->window);
}
static void
cinnamon_tray_manager_child_on_realize (GtkWidget *widget,
CinnamonTrayManagerChild *child)
{
/* If the tray child is using an RGBA colormap (and so we have real
* transparency), we don't need to worry about the background. If
* not, we obey the bg-color property by creating a cairo pattern of
* that color and setting it as our background. Then "parent-relative"
* background on the socket and the plug within that will cause
* the icons contents to appear on top of our background color.
*/
if (!na_tray_child_has_alpha (NA_TRAY_CHILD (child->socket)))
{
ClutterColor color = child->manager->priv->bg_color;
cairo_pattern_t *bg_pattern;
bg_pattern = cairo_pattern_create_rgb (color.red / 255.,
color.green / 255.,
color.blue / 255.);
gdk_window_set_background_pattern (gtk_widget_get_window (widget),
bg_pattern);
cairo_pattern_destroy (bg_pattern);
}
}
static void
on_finished (GnomeBGCrossfade *fade)
{
cairo_pattern_t *pattern;
if (fade->priv->timeout_id == 0)
return;
g_assert (fade->priv->end_surface != NULL);
pattern = cairo_pattern_create_for_surface (fade->priv->end_surface);
gdk_window_set_background_pattern (fade->priv->window, pattern);
cairo_pattern_destroy (pattern);
draw_background (fade);
cairo_surface_destroy (fade->priv->end_surface);
fade->priv->end_surface = NULL;
g_assert (fade->priv->fading_surface != NULL);
cairo_surface_destroy (fade->priv->fading_surface);
fade->priv->fading_surface = NULL;
fade->priv->timeout_id = 0;
g_signal_emit (fade, signals[FINISHED], 0, fade->priv->window);
}
/**
* gnome_bg_crossfade_start:
* @fade: a #GnomeBGCrossfade
* @window: The #GdkWindow to draw crossfade on
*
* This function initiates a quick crossfade between two surfaces on
* the background of @window. Before initiating the crossfade both
* gnome_bg_crossfade_start() and gnome_bg_crossfade_end() need to
* be called. If animations are disabled, the crossfade is skipped,
* and the window background is set immediately to the end surface.
**/
void
gnome_bg_crossfade_start (GnomeBGCrossfade *fade,
GdkWindow *window)
{
GSource *source;
GMainContext *context;
cairo_pattern_t *pattern;
g_return_if_fail (GNOME_IS_BG_CROSSFADE (fade));
g_return_if_fail (window != NULL);
g_return_if_fail (fade->priv->fading_surface != NULL);
g_return_if_fail (fade->priv->end_surface != NULL);
g_return_if_fail (!gnome_bg_crossfade_is_started (fade));
g_return_if_fail (gdk_window_get_window_type (window) != GDK_WINDOW_FOREIGN);
source = g_timeout_source_new (1000 / 60.0);
g_source_set_callback (source,
(GSourceFunc) on_tick,
fade,
(GDestroyNotify) on_finished);
context = g_main_context_default ();
fade->priv->timeout_id = g_source_attach (source, context);
g_source_unref (source);
fade->priv->window = window;
pattern = cairo_pattern_create_for_surface (fade->priv->fading_surface);
gdk_window_set_background_pattern (fade->priv->window, pattern);
cairo_pattern_destroy (pattern);
draw_background (fade);
fade->priv->is_first_frame = TRUE;
fade->priv->total_duration = .75;
fade->priv->start_time = get_current_time ();
}
static void
set_pixbuf_background (PanelBackground *background)
{
g_assert (background->composited_pattern != NULL);
gdk_window_set_background_pattern (background->window, background->composited_pattern);
}
static void
athena_desktop_background_set_up_widget (AthenaDesktopBackground *self)
{
GdkWindow *window;
gboolean in_fade = FALSE;
GtkWidget *widget;
widget = self->details->widget;
if (!gtk_widget_get_realized (widget)) {
return;
}
athena_desktop_background_ensure_realized (self);
window = gtk_layout_get_bin_window (GTK_LAYOUT (widget));
in_fade = fade_to_surface (self, window,
self->details->background_surface);
if (!in_fade) {
cairo_pattern_t *pattern;
pattern = cairo_pattern_create_for_surface (self->details->background_surface);
gdk_window_set_background_pattern (window, pattern);
cairo_pattern_destroy (pattern);
gnome_bg_set_surface_as_root (gtk_widget_get_screen (widget),
self->details->background_surface);
}
}
static void rc_ui_scrollable_label_realize(GtkWidget *widget)
{
RCUiScrollableLabel *label;
GdkWindowAttr attributes;
GtkAllocation allocation;
GdkWindow *window, *parent;
gint attr_mask;
GtkStyleContext *context;
g_return_if_fail(widget!=NULL);
g_return_if_fail(RC_UI_IS_SCROLLABLE_LABEL(widget));
label = RC_UI_SCROLLABLE_LABEL(widget);
gtk_widget_set_realized(widget, TRUE);
gtk_widget_get_allocation(widget, &allocation);
attributes.x = allocation.x;
attributes.y = allocation.y;
attributes.width = allocation.width;
attributes.height = allocation.height;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.event_mask = gtk_widget_get_events(widget);
attributes.event_mask |= (GDK_EXPOSURE_MASK);
attributes.visual = gtk_widget_get_visual(widget);
attr_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
gtk_widget_set_has_window(widget, TRUE);
parent = gtk_widget_get_parent_window(widget);
window = gdk_window_new(parent, &attributes, attr_mask);
gtk_widget_set_window(widget, window);
gdk_window_set_user_data(window, label);
gdk_window_set_background_pattern(window, NULL);
context = gtk_widget_get_style_context(widget);
gtk_style_context_set_background(context, window);
gdk_window_show(window);
}
/**
* gdk_window_set_gl_capability:
* @window: the #GdkWindow to be used as the rendering area.
* @glconfig: a #GdkGLConfig.
* @attrib_list: this must be set to NULL or empty (first attribute of None).
*
* Set the OpenGL-capability to the @window.
* This function creates a new #GdkGLWindow held by the @window.
* attrib_list is currently unused. This must be set to NULL or empty
* (first attribute of None).
*
* Return value: the #GdkGLWindow used by the @window if it is successful,
* NULL otherwise.
**/
GdkGLWindow *
gdk_window_set_gl_capability (GdkWindow *window,
GdkGLConfig *glconfig,
const int *attrib_list)
{
GdkGLWindow *glwindow;
GDK_GL_NOTE_FUNC ();
g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
g_return_val_if_fail (GDK_IS_GL_CONFIG (glconfig), NULL);
if (quark_gl_window == 0)
quark_gl_window = g_quark_from_static_string (quark_gl_window_string);
/* If already set */
glwindow = g_object_get_qdata (G_OBJECT (window), quark_gl_window);
if (glwindow != NULL)
return glwindow;
/*
* Create GdkGLWindow
*/
glwindow = gdk_gl_window_new (glconfig, window, attrib_list);
if (glwindow == NULL)
{
g_warning ("cannot create GdkGLWindow\n");
return NULL;
}
g_object_set_qdata_full (G_OBJECT (window), quark_gl_window, glwindow,
(GDestroyNotify) g_object_unref);
/*
* Set a background of "None" on window to avoid AIX X server crash
*/
GDK_GL_NOTE (MISC,
g_message (" - window->bg_pixmap = %p",
(void*)gdk_window_get_background_pattern (window)));
gdk_window_set_background_pattern (window, NULL);
GDK_GL_NOTE (MISC,
g_message (" - window->bg_pixmap = %p",
(void*)gdk_window_get_background_pattern (window)));
return glwindow;
}
static void
canvas_realize (GtkWidget *widget)
{
ECanvas *ecanvas = E_CANVAS (widget);
GdkWindow *window;
/* Chain up to parent's realize() method. */
GTK_WIDGET_CLASS (e_canvas_parent_class)->realize (widget);
window = gtk_layout_get_bin_window (GTK_LAYOUT (widget));
gdk_window_set_background_pattern (window, NULL);
window = gtk_widget_get_window (widget);
gtk_im_context_set_client_window (ecanvas->im_context, window);
}
void
set_desktop_background(GdkWindow *window)
{
Pixmap xpm = get_pixmap_prop(GDK_WINDOW_XWINDOW(window), "_XROOTPMAP_ID");
#ifdef HAVE_GTK3
if (xpm != None)
{
GdkScreen *screen = gdk_window_get_screen(window);
Window root_return;
int x, y;
unsigned int width, height, bw, depth_ret;
cairo_surface_t *surface = NULL;
gdk_error_trap_push();
if (XGetGeometry(GDK_SCREEN_XDISPLAY(screen),
xpm,
&root_return,
&x, &y, &width, &height, &bw, &depth_ret))
{
surface = cairo_xlib_surface_create(GDK_SCREEN_XDISPLAY (screen),
xpm,
GDK_VISUAL_XVISUAL(gdk_screen_get_system_visual(screen)),
width, height);
}
gdk_error_trap_pop_ignored ();
cairo_pattern_t *pattern = cairo_pattern_create_for_surface(surface);
gdk_window_set_background_pattern(window, pattern);
cairo_surface_destroy(surface);
// cairo_pattern_destroy ???
}
else
{
GdkRGBA black = { 0.0, 0.0, 0.0, 1.0 };
gdk_window_set_background_rgba(window, &black);
}
#else
if (xpm != None)
{
GDKPIXMAP *gpm = gdk_pixmap_foreign_new(xpm);
gdk_window_set_back_pixmap (window, gpm, FALSE);
g_object_unref (gpm);
}
#endif
}
/**
* mate_bg_crossfade_start:
* @fade: a #MateBGCrossfade
* @window: The #GdkWindow to draw crossfade on
*
* This function initiates a quick crossfade between two surfaces on
* the background of @window. Before initiating the crossfade both
* mate_bg_crossfade_start() and mate_bg_crossfade_end() need to
* be called. If animations are disabled, the crossfade is skipped,
* and the window background is set immediately to the end surface.
**/
void
mate_bg_crossfade_start (MateBGCrossfade *fade,
GdkWindow *window)
{
GSource *source;
GMainContext *context;
g_return_if_fail (MATE_IS_BG_CROSSFADE (fade));
g_return_if_fail (window != NULL);
g_return_if_fail (fade->priv->fading_surface != NULL);
g_return_if_fail (fade->priv->end_surface != NULL);
g_return_if_fail (!mate_bg_crossfade_is_started (fade));
g_return_if_fail (GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN);
source = g_timeout_source_new (1000 / 60.0);
g_source_set_callback (source,
(GSourceFunc) on_tick,
fade,
(GDestroyNotify) on_finished);
context = g_main_context_default ();
fade->priv->timeout_id = g_source_attach (source, context);
g_source_unref (source);
fade->priv->window = window;
#if GTK_CHECK_VERSION (3, 0, 0)
cairo_pattern_t *pattern;
pattern = cairo_pattern_create_for_surface (fade->priv->fading_surface);
gdk_window_set_background_pattern (fade->priv->window, pattern);
cairo_pattern_destroy (pattern);
#else
gdk_window_set_back_pixmap (fade->priv->window,
fade->priv->fading_surface,
FALSE);
#endif
draw_background (fade);
fade->priv->is_first_frame = TRUE;
fade->priv->total_duration = .75;
fade->priv->start_time = get_current_time ();
}
static int gtkDialogSetBackgroundAttrib(Ihandle* ih, const char* value)
{
if (iupdrvBaseSetBgColorAttrib(ih, value))
{
#if GTK_CHECK_VERSION(3, 0, 0)
GdkWindow* window = iupgtkGetWindow(ih->handle);
if (window)
gdk_window_set_background_pattern(window, NULL);
#else
GtkStyle *style = gtk_widget_get_style(ih->handle);
if (style->bg_pixmap[GTK_STATE_NORMAL])
{
style = gtk_style_copy(style);
style->bg_pixmap[GTK_STATE_NORMAL] = NULL;
gtk_widget_set_style(ih->handle, style);
}
#endif
return 1;
}
else
{
GdkPixbuf* pixbuf = iupImageGetImage(value, ih, 0);
if (pixbuf)
{
#if GTK_CHECK_VERSION(3, 0, 0)
GdkWindow* window = iupgtkGetWindow(ih->handle);
if (window)
{
/* TODO: this is NOT working!!!! */
cairo_pattern_t* pattern;
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);
pattern = cairo_pattern_create_for_surface(surface);
cairo_pattern_set_extend(pattern, CAIRO_EXTEND_REPEAT);
gdk_window_set_background_pattern(window, pattern);
cairo_pattern_destroy (pattern);
cairo_surface_destroy(surface);
}
#else
GdkPixmap* pixmap;
GtkStyle *style = gtk_style_copy(gtk_widget_get_style(ih->handle));
gdk_pixbuf_render_pixmap_and_mask(pixbuf, &pixmap, NULL, 255);
style->bg_pixmap[GTK_STATE_NORMAL] = pixmap;
gtk_widget_set_style(ih->handle, style);
#endif
return 1;
}
}
return 0;
}
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 );
}
static gboolean
panel_background_prepare (PanelBackground *background)
{
PanelBackgroundType effective_type;
GtkWidget *widget = NULL;
if (!background->transformed)
return FALSE;
effective_type = panel_background_effective_type (background);
switch (effective_type) {
case PANEL_BACK_NONE:
if (background->default_pattern) {
/* the theme background-image pattern must be scaled by
* the width & height of the panel so that when the
* backing region is cleared
* (gdk_window_clear_backing_region), the correctly
* scaled pattern is used */
cairo_matrix_t m;
cairo_surface_t *surface;
double width, height;
surface = NULL;
width = 1.0;
height = 1.0;
cairo_pattern_get_surface(background->default_pattern, &surface);
/* catch invalid images (e.g. -gtk-gradient) before scaling and rendering */
if (surface != NULL ){
cairo_surface_reference(surface);
width = cairo_image_surface_get_width (surface);
height = cairo_image_surface_get_height (surface);
cairo_matrix_init_translate (&m, 0, 0);
cairo_matrix_scale (&m,
width / background->region.width,
height / background->region.height);
cairo_pattern_set_matrix (background->default_pattern, &m);
gdk_window_set_background_pattern (background->window,
background->default_pattern);
}
else {
g_warning ("%s", "unsupported value of 'background-image' in GTK+ theme (such as '-gtk-gradient')");
/* use any background color that has been set if image is invalid */
gdk_window_set_background_rgba (
background->window, &background->default_color);
}
cairo_surface_destroy(surface);
} else
gdk_window_set_background_rgba (
background->window, &background->default_color);
break;
case PANEL_BACK_COLOR:
if (background->has_alpha &&
!gdk_window_check_composited_wm(background->window))
set_pixbuf_background (background);
else {
gdk_window_set_background_rgba (background->window,
&background->color);
}
break;
case PANEL_BACK_IMAGE:
set_pixbuf_background (background);
break;
default:
g_assert_not_reached ();
break;
}
/* Panel applets may use the panel's background pixmap to
* decide how to draw themselves. Therefore, we need to
* make sure that all drawing has been completed before
* the applet looks at the pixmap. */
gdk_display_sync (gdk_window_get_display (background->window));
gdk_window_get_user_data (GDK_WINDOW (background->window),
(gpointer) &widget);
if (GTK_IS_WIDGET (widget)) {
panel_background_apply_css (background, gtk_widget_get_toplevel(widget));
gtk_widget_set_app_paintable(widget,TRUE);
gtk_widget_queue_draw (widget);
}
background->notify_changed (background, background->user_data);
return TRUE;
}
void desktop_set_background (GtkWidget *desktop, gchar *wallpaper, FmWallpaperMode wallpaper_mode,
GdkColor *color_background)
{
GdkPixbuf *pixbuf;
GdkWindow *root = gdk_screen_get_root_window (gtk_widget_get_screen (desktop));
GdkWindow *window = gtk_widget_get_window (desktop);
if (wallpaper_mode == FM_WP_COLOR
|| !wallpaper
|| !*wallpaper
|| !(pixbuf = gdk_pixbuf_new_from_file (wallpaper, NULL)))
{
//GdkColor bg = color_background;
//gdk_rgb_find_color (gdk_drawable_get_colormap (window), &bg);
//gdk_window_set_back_pixmap (window, NULL, FALSE);
gdk_window_set_background (window, color_background);
//gdk_window_set_back_pixmap (root, NULL, FALSE);
gdk_window_set_background (root, color_background);
//gdk_window_clear (root);
//gdk_window_clear (window);
gdk_window_invalidate_rect (window, NULL, TRUE);
return;
}
// #if 0
int src_w = gdk_pixbuf_get_width (pixbuf);
int src_h = gdk_pixbuf_get_height (pixbuf);
cairo_surface_t *surface;
int dest_w;
int dest_h;
if (wallpaper_mode == FM_WP_TILE)
{
dest_w = src_w;
dest_h = src_h;
//pixmap = gdk_pixmap_new (window, dest_w, dest_h, -1);
surface = gdk_window_create_similar_surface (window, CAIRO_CONTENT_COLOR, dest_w, dest_h);
}
else
{
GdkScreen *screen = gtk_widget_get_screen (desktop);
dest_w = gdk_screen_get_width (screen);
dest_h = gdk_screen_get_height (screen);
//pixmap = gdk_pixmap_new (window, dest_w, dest_h, -1);
surface = gdk_window_create_similar_surface (window, CAIRO_CONTENT_COLOR, dest_w, dest_h);
}
//~ if (gdk_pixbuf_get_has_alpha (pixbuf)
//~ || wallpaper_mode == FM_WP_CENTER
//~ || wallpaper_mode == FM_WP_FIT)
//~ {
//~ gdk_gc_set_rgb_fg_color (desktop->gc, &color_background);
//~ gdk_draw_rectangle (pixmap, desktop->gc, TRUE, 0, 0, dest_w, dest_h);
//~ }
// GdkPixbuf *scaled;
cairo_t *cr;
switch (wallpaper_mode)
{
case FM_WP_COLOR:
break;
case FM_WP_TILE:
//gdk_draw_pixbuf (pixmap, desktop->gc, pixbuf, 0, 0, 0, 0, dest_w, dest_h, GDK_RGB_DITHER_NORMAL, 0, 0);
cr = cairo_create (surface);
gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
cairo_paint (cr);
cairo_destroy (cr);
break;
case FM_WP_STRETCH:
//~ if (dest_w == src_w && dest_h == src_h)
//~ scaled = (GdkPixbuf*) g_object_ref (pixbuf);
//~ else
//~ scaled = gdk_pixbuf_scale_simple (pixbuf, dest_w, dest_h, GDK_INTERP_BILINEAR);
//~
//~ gdk_draw_pixbuf (pixmap, desktop->gc, scaled, 0, 0, 0, 0, dest_w, dest_h, GDK_RGB_DITHER_NORMAL, 0, 0);
//~
//~ g_object_unref (scaled);
break;
case FM_WP_FIT:
//~ if (dest_w != src_w || dest_h != src_h)
//~ {
//~ gdouble w_ratio = (float) dest_w / src_w;
//~ gdouble h_ratio = (float) dest_h / src_h;
//~ gdouble ratio = MIN (w_ratio, h_ratio);
//~
//~ if (ratio != 1.0)
//~ {
//~ src_w *= ratio;
//~ src_h *= ratio;
//~
//~ scaled = gdk_pixbuf_scale_simple (pixbuf, src_w, src_h, GDK_INTERP_BILINEAR);
//~
//~ g_object_unref (pixbuf);
//~ pixbuf = scaled;
//~ }
//~ }
case FM_WP_CENTER:
{
//~ int x;
//~ int y;
//~ x = (dest_w - src_w) / 2;
//~ y = (dest_h - src_h) / 2;
//~
//~ gdk_draw_pixbuf (pixmap, desktop->gc, pixbuf, 0, 0, x, y, -1, -1, GDK_RGB_DITHER_NORMAL, 0, 0);
}
break;
}
Display *xdisplay;
Pixmap xpixmap = 0;
Window xroot;
cairo_pattern_t *pattern = cairo_pattern_create_for_surface (surface);
//gdk_window_set_back_pixmap (root, pixmap, FALSE);
gdk_window_set_background_pattern (root, pattern);
//gdk_window_set_back_pixmap (window, NULL, TRUE);
gdk_window_set_background_pattern (window, pattern);
cairo_pattern_destroy (pattern);
Pixmap pixmap_id = cairo_xlib_surface_get_drawable (surface);
XChangeProperty (GDK_WINDOW_XDISPLAY (root),
GDK_WINDOW_XID (root),
gdk_x11_get_xatom_by_name ("_XROOTPMAP_ID"), //XA_XROOTMAP_ID,
XA_PIXMAP,
32,
PropModeReplace,
(guchar*) &pixmap_id,
1);
// Set root map here...
xdisplay = GDK_WINDOW_XDISPLAY (root);
xroot = GDK_WINDOW_XID (root);
XGrabServer (xdisplay);
if (surface)
{
xpixmap = cairo_xlib_surface_get_drawable (surface);
XChangeProperty (xdisplay,
xroot,
gdk_x11_get_xatom_by_name ("_XROOTPMAP_ID"),
XA_PIXMAP,
32,
PropModeReplace,
(guchar *) &xpixmap,
1);
XSetWindowBackgroundPixmap (xdisplay, xroot, xpixmap);
}
else
{
// Anyone knows how to handle this correctly ?
}
XClearWindow (xdisplay, xroot);
XUngrabServer (xdisplay);
XFlush (xdisplay);
cairo_surface_destroy (surface);
if (pixbuf)
g_object_unref (pixbuf);
// gdk_window_clear (root);
// gdk_window_clear (window);
gdk_window_invalidate_rect (window, NULL, TRUE);
// #endif
}
