1 files changed, 1156 insertions, 0 deletions
diff --git a/mate-panel/panel-background.c b/mate-panel/panel-background.c
new file mode 100644
index 00000000..6341b290
--- /dev/null
+++ b/mate-panel/panel-background.c
@@ -0,0 +1,1156 @@
+/*
+ * panel-background.c: panel background rendering
+ *
+ * Copyright (C) 2002, 2003 Sun Microsystems, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Authors:
+ * Mark McLoughlin <[email protected]>
+ */
+
+#include <config.h>
+
+#include "panel-background.h"
+
+#include <string.h>
+#include <gdk/gdkx.h>
+#include <gdk/gdk.h>
+#include <cairo.h>
+
+#include "panel-background-monitor.h"
+#include "panel-util.h"
+
+
+static gboolean panel_background_composite (PanelBackground *background);
+static void load_background_file (PanelBackground *background);
+
+
+static void
+free_prepared_resources (PanelBackground *background)
+{
+ background->prepared = FALSE;
+
+ switch (background->type) {
+ case PANEL_BACK_NONE:
+ break;
+ case PANEL_BACK_COLOR:
+ if (background->has_alpha) {
+ if (background->pixmap)
+ g_object_unref (background->pixmap);
+ background->pixmap = NULL;
+ } else {
+ if (background->colormap && background->color.gdk.pixel)
+ gdk_colormap_free_colors (
+ background->colormap,
+ &background->color.gdk, 1);
+ background->color.gdk.pixel = 0;
+ }
+ break;
+ case PANEL_BACK_IMAGE:
+ if (background->pixmap)
+ g_object_unref (background->pixmap);
+ background->pixmap = NULL;
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+}
+
+static void
+set_pixbuf_background (PanelBackground *background)
+{
+ g_assert (background->composited_image != NULL);
+
+ gdk_pixbuf_render_pixmap_and_mask_for_colormap (
+ background->composited_image,
+ background->colormap,
+ &background->pixmap, NULL, 128);
+
+ gdk_window_set_back_pixmap (
+ background->window, background->pixmap, FALSE);
+}
+
+static gboolean
+panel_background_prepare (PanelBackground *background)
+{
+ PanelBackgroundType effective_type;
+ GtkWidget *widget = NULL;
+
+ if (!background->colormap || !background->transformed)
+ return FALSE;
+
+ free_prepared_resources (background);
+
+ effective_type = panel_background_effective_type (background);
+
+ switch (effective_type) {
+ case PANEL_BACK_NONE:
+ if (background->default_pixmap) {
+ if (background->default_pixmap != (GdkPixmap*) GDK_PARENT_RELATIVE)
+ gdk_window_set_back_pixmap (background->window,
+ background->default_pixmap,
+ FALSE);
+ else
+ gdk_window_set_back_pixmap (background->window,
+ NULL,
+ TRUE);
+ } else
+ gdk_window_set_background (
+ background->window, &background->default_color);
+ break;
+ case PANEL_BACK_COLOR:
+ if (background->has_alpha &&
+ background->composited_image)
+ set_pixbuf_background (background);
+ else {
+ gdk_colormap_alloc_color (
+ background->colormap,
+ &background->color.gdk,
+ FALSE, TRUE);
+ gdk_window_set_background (
+ background->window, &background->color.gdk);
+ }
+ 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_drawable_get_display (background->window));
+
+ gdk_window_get_user_data (GDK_WINDOW (background->window),
+ (gpointer) &widget);
+
+ if (GTK_IS_WIDGET (widget))
+ gtk_widget_queue_draw (widget);
+
+ background->prepared = TRUE;
+
+ background->notify_changed (background, background->user_data);
+
+ return TRUE;
+}
+
+static void
+free_composited_resources (PanelBackground *background)
+{
+ free_prepared_resources (background);
+
+ background->composited = FALSE;
+
+ if (background->composited_image)
+ g_object_unref (background->composited_image);
+ background->composited_image = NULL;
+}
+
+static void
+background_changed (PanelBackgroundMonitor *monitor,
+ PanelBackground *background)
+{
+ GdkPixbuf *tmp;
+
+ tmp = background->desktop;
+
+ background->desktop = panel_background_monitor_get_region (
+ background->monitor,
+ background->region.x,
+ background->region.y,
+ background->region.width,
+ background->region.height);
+
+ if (tmp)
+ g_object_unref (tmp);
+
+ panel_background_composite (background);
+}
+
+static GdkPixbuf *
+get_desktop_pixbuf (PanelBackground *background)
+{
+ GdkPixbuf *desktop;
+
+ if (!background->monitor) {
+ background->monitor =
+ panel_background_monitor_get_for_screen (
+ gdk_drawable_get_screen (background->window));
+
+ background->monitor_signal =
+ g_signal_connect (
+ background->monitor, "changed",
+ G_CALLBACK (background_changed), background);
+ }
+
+ desktop = panel_background_monitor_get_region (
+ background->monitor,
+ background->region.x,
+ background->region.y,
+ background->region.width,
+ background->region.height);
+
+ return desktop;
+}
+
+static GdkPixbuf *
+composite_image_onto_desktop (PanelBackground *background)
+{
+ GdkPixbuf *retval;
+ int width, height;
+ unsigned char *data;
+ cairo_t *cr;
+ cairo_surface_t *surface;
+ cairo_pattern_t *pattern;
+
+ if (!background->desktop)
+ background->desktop = get_desktop_pixbuf (background);
+
+ if (!background->desktop)
+ return NULL;
+
+ width = gdk_pixbuf_get_width (background->desktop);
+ height = gdk_pixbuf_get_height (background->desktop);
+
+ data = g_malloc (width * height * 4);
+ if (!data)
+ return NULL;
+
+ surface = cairo_image_surface_create_for_data (data,
+ CAIRO_FORMAT_RGB24,
+ width, height,
+ width * 4);
+ cr = cairo_create (surface);
+ cairo_set_source_rgb (cr, 1, 1, 1);
+ cairo_paint (cr);
+
+ gdk_cairo_set_source_pixbuf (cr, background->desktop, 0, 0);
+ cairo_rectangle (cr, 0, 0, width, height);
+ cairo_fill (cr);
+
+ gdk_cairo_set_source_pixbuf (cr, background->transformed_image, 0, 0);
+ pattern = cairo_get_source (cr);
+ cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
+ cairo_rectangle (cr, 0, 0, width, height);
+ cairo_fill (cr);
+
+ cairo_destroy (cr);
+ cairo_surface_destroy (surface);
+
+ retval = panel_util_cairo_rgbdata_to_pixbuf (data, width, height);
+
+ g_free (data);
+
+ return retval;
+}
+
+static GdkPixbuf *
+composite_color_onto_desktop (PanelBackground *background)
+{
+ guint32 color;
+
+ if (!background->desktop)
+ background->desktop = get_desktop_pixbuf (background);
+
+ if (!background->desktop)
+ return NULL;
+
+ color = ((background->color.gdk.red & 0xff00) << 8) +
+ (background->color.gdk.green & 0xff00) +
+ (background->color.gdk.blue >> 8);
+
+ return gdk_pixbuf_composite_color_simple (
+ background->desktop, 
+ gdk_pixbuf_get_width (background->desktop),
+ gdk_pixbuf_get_height (background->desktop),
+ GDK_INTERP_NEAREST,
+ (255 - (background->color.alpha >> 8)),
+ 255, color, color);
+}
+
+static GdkPixbuf *
+get_composited_pixbuf (PanelBackground *background)
+{
+ GdkPixbuf *retval = NULL;
+
+ switch (background->type) {
+ case PANEL_BACK_NONE:
+ break;
+ case PANEL_BACK_COLOR:
+ retval = composite_color_onto_desktop (background);
+ break;
+ case PANEL_BACK_IMAGE:
+ retval = composite_image_onto_desktop (background);
+ if (!retval)
+ retval = g_object_ref (background->transformed_image);
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ return retval;
+}
+
+static gboolean
+panel_background_composite (PanelBackground *background)
+{
+ if (!background->transformed)
+ return FALSE;
+
+ free_composited_resources (background);
+
+ switch (background->type) {
+ case PANEL_BACK_NONE:
+ break;
+ case PANEL_BACK_COLOR:
+ if (background->has_alpha)
+ background->composited_image =
+ get_composited_pixbuf (background);
+ break;
+ case PANEL_BACK_IMAGE:
+ if (background->transformed_image) {
+ if (background->has_alpha)
+ background->composited_image =
+ get_composited_pixbuf (background);
+ else
+ background->composited_image =
+ g_object_ref (background->transformed_image);
+ }
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ background->composited = TRUE;
+
+ panel_background_prepare (background);
+
+ return TRUE;
+}
+
+static void
+free_transformed_resources (PanelBackground *background)
+{
+ free_composited_resources (background);
+
+ background->transformed = FALSE;
+
+ if (background->type != PANEL_BACK_IMAGE)
+ return;
+
+ if (background->transformed_image)
+ g_object_unref (background->transformed_image);
+ background->transformed_image = NULL;
+}
+
+static GdkPixbuf *
+get_scaled_and_rotated_pixbuf (PanelBackground *background)
+{
+ GdkPixbuf *scaled;
+ GdkPixbuf *retval;
+ int orig_width, orig_height;
+ int panel_width, panel_height;
+ int width, height;
+
+ load_background_file (background);
+ if (!background->loaded_image)
+ return NULL;
+
+ orig_width = gdk_pixbuf_get_width (background->loaded_image);
+ orig_height = gdk_pixbuf_get_height (background->loaded_image);
+
+ panel_width = background->region.width;
+ panel_height = background->region.height;
+
+ width = orig_width;
+ height = orig_height;
+
+ if (background->fit_image) {
+ switch (background->orientation) {
+ case GTK_ORIENTATION_HORIZONTAL:
+ width = orig_width * panel_height / orig_height;
+ height = panel_height;
+ break;
+ case GTK_ORIENTATION_VERTICAL:
+ if (background->rotate_image) {
+ width = orig_width * panel_width / orig_height;
+ height = panel_width;
+ } else {
+ width = panel_width;
+ height = orig_height * panel_width / orig_width;
+ }
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+ } else if (background->stretch_image) {
+ if (background->orientation == GTK_ORIENTATION_VERTICAL &&
+ background->rotate_image) {
+ width = panel_height;
+ height = panel_width;
+ } else {
+ width = panel_width;
+ height = panel_height;
+ }
+ } else if (background->orientation == GTK_ORIENTATION_VERTICAL &&
+ background->rotate_image) {
+ int tmp = width;
+ width = height;
+ height = tmp;
+ }
+
+ if (width == orig_width &&
+ height == orig_height) {
+ scaled = background->loaded_image;
+ g_object_ref (scaled);
+ } else {
+ scaled = gdk_pixbuf_scale_simple (
+ background->loaded_image,
+ width, height,
+ GDK_INTERP_BILINEAR);
+ }
+
+ if (background->rotate_image &&
+ background->orientation == GTK_ORIENTATION_VERTICAL) {
+ if (!background->has_alpha) {
+ guchar *dest;
+ guchar *src;
+ int x, y;
+ int destrowstride;
+ int srcrowstride;
+
+ retval = gdk_pixbuf_new (
+ GDK_COLORSPACE_RGB, FALSE, 8, height, width);
+
+ dest = gdk_pixbuf_get_pixels (retval);
+ destrowstride = gdk_pixbuf_get_rowstride (retval);
+ src = gdk_pixbuf_get_pixels (scaled);
+ srcrowstride = gdk_pixbuf_get_rowstride (scaled);
+
+ for (y = 0; y < height; y++)
+ for (x = 0; x < width; x++) {
+ guchar *dstptr = & ( dest [3*y + destrowstride * (width - x - 1)] );
+ guchar *srcptr = & ( src [y * srcrowstride + 3*x] );
+ dstptr[0] = srcptr[0];
+ dstptr[1] = srcptr[1];
+ dstptr[2] = srcptr[2];
+ }
+
+ g_object_unref (scaled);
+ } else {
+ guint32 *dest;
+ guint32 *src;
+ int x, y;
+ int destrowstride;
+ int srcrowstride;
+
+ retval = gdk_pixbuf_new (
+ GDK_COLORSPACE_RGB, TRUE, 8, height, width);
+
+ dest = (guint32 *) gdk_pixbuf_get_pixels (retval);
+ destrowstride = gdk_pixbuf_get_rowstride (retval) / 4;
+ src = (guint32 *) gdk_pixbuf_get_pixels (scaled);
+ srcrowstride = gdk_pixbuf_get_rowstride (scaled) / 4;
+
+ for (y = 0; y < height; y++)
+ for (x = 0; x < width; x++)
+ dest [y + destrowstride * (width - x - 1)] =
+ src [y * srcrowstride + x];
+
+ g_object_unref (scaled);
+ }
+ } else
+ retval = scaled;
+
+ return retval;
+}
+
+static gboolean
+panel_background_transform (PanelBackground *background)
+{
+ if (background->region.width == -1)
+ return FALSE;
+
+ free_transformed_resources (background);
+
+ if (background->type == PANEL_BACK_IMAGE)
+ background->transformed_image =
+ get_scaled_and_rotated_pixbuf (background);
+
+ background->transformed = TRUE;
+
+ panel_background_composite (background);
+
+ return TRUE;
+}
+
+static void
+disconnect_background_monitor (PanelBackground *background)
+{
+ if (background->monitor) {
+ g_signal_handler_disconnect (
+ background->monitor, background->monitor_signal);
+ background->monitor_signal = -1;
+ g_object_unref (background->monitor);
+ }
+ background->monitor = NULL;
+
+ if (background->desktop)
+ g_object_unref (background->desktop);
+ background->desktop = NULL;
+}
+
+static void
+panel_background_update_has_alpha (PanelBackground *background)
+{
+ gboolean has_alpha = FALSE;
+
+ if (background->type == PANEL_BACK_COLOR)
+ has_alpha = (background->color.alpha != 0xffff);
+
+ else if (background->type == PANEL_BACK_IMAGE &&
+ background->loaded_image)
+ has_alpha = gdk_pixbuf_get_has_alpha (background->loaded_image);
+
+ background->has_alpha = has_alpha;
+
+ if (!has_alpha)
+ disconnect_background_monitor (background);
+}
+
+static void
+load_background_file (PanelBackground *background)
+{
+ GError *error = NULL;
+
+ if (!g_file_test (background->image, G_FILE_TEST_IS_REGULAR))
+ return;
+
+ //FIXME add a monitor on the file so that we reload the background
+ //when it changes
+ background->loaded_image = 
+ gdk_pixbuf_new_from_file (background->image, &error);
+ if (!background->loaded_image) {
+ g_assert (error != NULL);
+ g_warning (G_STRLOC ": unable to open '%s': %s",
+ background->image, error->message);
+ g_error_free (error);
+ }
+
+ panel_background_update_has_alpha (background);
+}
+
+void
+panel_background_set_type (PanelBackground *background,
+ PanelBackgroundType type)
+{
+ if (background->type == type)
+ return;
+
+ free_transformed_resources (background);
+
+ background->type = type;
+
+ panel_background_update_has_alpha (background);
+
+ panel_background_transform (background);
+}
+
+static void
+panel_background_set_gdk_color_no_update (PanelBackground *background,
+ GdkColor *gdk_color)
+{
+ g_return_if_fail (gdk_color != NULL);
+
+ background->color.gdk.red = gdk_color->red;
+ background->color.gdk.green = gdk_color->green;
+ background->color.gdk.blue = gdk_color->blue;
+}
+
+void
+panel_background_set_gdk_color (PanelBackground *background,
+ GdkColor *gdk_color)
+{
+ g_return_if_fail (gdk_color != NULL);
+
+ if (background->color.gdk.red == gdk_color->red &&
+ background->color.gdk.green == gdk_color->green &&
+ background->color.gdk.blue == gdk_color->blue)
+ return;
+
+ free_transformed_resources (background);
+ panel_background_set_gdk_color_no_update (background, gdk_color);
+ panel_background_transform (background);
+}
+
+static void
+panel_background_set_opacity_no_update (PanelBackground *background,
+ guint16 opacity)
+{
+ background->color.alpha = opacity;
+ panel_background_update_has_alpha (background);
+}
+
+void
+panel_background_set_opacity (PanelBackground *background,
+ guint16 opacity)
+{
+ if (background->color.alpha == opacity)
+ return;
+
+ free_transformed_resources (background);
+ panel_background_set_opacity_no_update (background, opacity);
+ panel_background_transform (background);
+}
+
+static void
+panel_background_set_color_no_update (PanelBackground *background,
+ PanelColor *color)
+{
+ g_return_if_fail (color != NULL);
+
+ panel_background_set_gdk_color_no_update (background, &(color->gdk));
+ panel_background_set_opacity_no_update (background, color->alpha);
+}
+
+void
+panel_background_set_color (PanelBackground *background,
+ PanelColor *color)
+{
+ g_return_if_fail (color != NULL);
+
+ if (background->color.gdk.red == color->gdk.red &&
+ background->color.gdk.green == color->gdk.green &&
+ background->color.gdk.blue == color->gdk.blue &&
+ background->color.alpha == color->alpha)
+ return;
+
+ free_transformed_resources (background);
+ panel_background_set_color_no_update (background, color);
+ panel_background_transform (background);
+}
+
+static void
+panel_background_set_image_no_update (PanelBackground *background,
+ const char *image)
+{
+ if (background->loaded_image)
+ g_object_unref (background->loaded_image);
+ background->loaded_image = NULL;
+
+ if (background->image)
+ g_free (background->image);
+ background->image = NULL;
+
+ if (image && image [0])
+ background->image = g_strdup (image);
+
+ panel_background_update_has_alpha (background);
+}
+
+void
+panel_background_set_image (PanelBackground *background,
+ const char *image)
+{
+ if (!background->image && !image)
+ return;
+
+ if (background->image && image && !strcmp (background->image, image))
+ return;
+
+ free_transformed_resources (background);
+ panel_background_set_image_no_update (background, image);
+ panel_background_transform (background);
+}
+
+static void
+panel_background_set_fit_no_update (PanelBackground *background,
+ gboolean fit_image)
+{
+ background->fit_image = fit_image != FALSE;
+}
+
+void
+panel_background_set_fit (PanelBackground *background,
+ gboolean fit_image)
+{
+ fit_image = fit_image != FALSE;
+
+ if (background->fit_image == fit_image)
+ return;
+
+ free_transformed_resources (background);
+ panel_background_set_fit_no_update (background, fit_image);
+ panel_background_transform (background);
+}
+
+static void
+panel_background_set_stretch_no_update (PanelBackground *background,
+ gboolean stretch_image)
+{
+ background->stretch_image = stretch_image != FALSE;
+}
+
+void
+panel_background_set_stretch (PanelBackground *background,
+ gboolean stretch_image)
+{
+ stretch_image = stretch_image != FALSE;
+
+ if (background->stretch_image == stretch_image)
+ return;
+
+ free_transformed_resources (background);
+ panel_background_set_stretch_no_update (background, stretch_image);
+ panel_background_transform (background);
+}
+
+static void
+panel_background_set_rotate_no_update (PanelBackground *background,
+ gboolean rotate_image)
+{
+ background->rotate_image = rotate_image != FALSE;
+}
+
+void
+panel_background_set_rotate (PanelBackground *background,
+ gboolean rotate_image)
+{
+ rotate_image = rotate_image != FALSE;
+
+ if (background->rotate_image == rotate_image)
+ return;
+
+ free_transformed_resources (background);
+ panel_background_set_rotate_no_update (background, rotate_image);
+ panel_background_transform (background);
+}
+
+void
+panel_background_set (PanelBackground *background,
+ PanelBackgroundType type,
+ PanelColor *color,
+ const char *image,
+ gboolean fit_image,
+ gboolean stretch_image,
+ gboolean rotate_image)
+{
+ panel_background_set_color_no_update (background, color);
+ panel_background_set_image_no_update (background, image);
+ panel_background_set_fit_no_update (background, fit_image);
+ panel_background_set_stretch_no_update (background, stretch_image);
+ panel_background_set_rotate_no_update (background, rotate_image);
+ panel_background_set_type (background, type);
+}
+
+void
+panel_background_set_default_style (PanelBackground *background,
+ GdkColor *color,
+ GdkPixmap *pixmap)
+{
+ g_return_if_fail (color != NULL);
+
+ background->default_color = *color;
+
+ if (pixmap && pixmap != (GdkPixmap*) GDK_PARENT_RELATIVE)
+ g_object_ref (pixmap);
+
+ if (background->default_pixmap
+ && background->default_pixmap != (GdkPixmap*) GDK_PARENT_RELATIVE)
+ g_object_unref (background->default_pixmap);
+
+ background->default_pixmap = pixmap;
+
+ if (background->type == PANEL_BACK_NONE)
+ panel_background_prepare (background);
+}
+
+void
+panel_background_realized (PanelBackground *background,
+ GdkWindow *window)
+{
+ g_return_if_fail (window != NULL);
+
+ if (background->window && background->colormap && background->gc)
+ return;
+
+ if (!background->window)
+ background->window = g_object_ref (window);
+
+ if (!background->colormap)
+ background->colormap =
+ g_object_ref (gdk_drawable_get_colormap (window));
+
+ if (!background->gc)
+ background->gc = gdk_gc_new (window);
+
+ panel_background_prepare (background);
+}
+
+void
+panel_background_unrealized (PanelBackground *background)
+{
+ free_prepared_resources (background);
+
+ if (background->window)
+ g_object_unref (background->window);
+ background->window = NULL;
+
+ if (background->colormap)
+ g_object_unref (background->colormap);
+ background->colormap = NULL;
+
+ if (background->gc)
+ g_object_unref (background->gc);
+ background->gc = NULL;
+}
+
+void
+panel_background_change_region (PanelBackground *background,
+ GtkOrientation orientation,
+ int x,
+ int y,
+ int width,
+ int height)
+{
+ gboolean need_to_retransform = FALSE;
+ gboolean need_to_reprepare = FALSE;
+
+ if (background->region.x == x &&
+ background->region.y == y &&
+ background->region.width == width &&
+ background->region.height == height &&
+ background->orientation == orientation)
+ return;
+
+ /* we only need to retransform anything
+ on size/orientation changes if the
+ background is an image and some
+ conditions are met */
+ if (background->type == PANEL_BACK_IMAGE) {
+ if (background->orientation != orientation &&
+ background->rotate_image) {
+ /* if orientation changes and we are rotating */
+ need_to_retransform = TRUE;
+ } else if ((background->region.width != width ||
+ background->region.height != height) &&
+ (background->fit_image ||
+ background->stretch_image)) {
+ /* or if the size changes and we are 
+ stretching or fitting the image */
+ need_to_retransform = TRUE;
+ }
+ }
+
+ /* if size changed, we at least need
+ to "prepare" the background again */
+ if (background->region.width != width ||
+ background->region.height != height)
+ need_to_reprepare = TRUE;
+
+ background->region.x = x;
+ background->region.y = y;
+ background->region.width = width;
+ background->region.height = height;
+
+ background->orientation = orientation;
+
+ if (background->desktop)
+ g_object_unref (background->desktop);
+ background->desktop = NULL;
+
+ if (need_to_retransform || ! background->transformed)
+ /* only retransform the background if we have in
+ fact changed size/orientation */
+ panel_background_transform (background);
+ else if (background->has_alpha || ! background->composited)
+ /* only do compositing if we have some alpha
+ value to worry about */
+ panel_background_composite (background);
+ else if (need_to_reprepare)
+ /* at least we must prepare the background
+ if the size changed */
+ panel_background_prepare (background);
+}
+
+void
+panel_background_init (PanelBackground *background,
+ PanelBackgroundChangedNotify notify_changed,
+ gpointer user_data)
+{
+ background->type = PANEL_BACK_NONE;
+ background->notify_changed = notify_changed;
+ background->user_data = user_data;
+
+ background->color.gdk.red = 0;
+ background->color.gdk.blue = 0;
+ background->color.gdk.green = 0;
+ background->color.gdk.pixel = 0;
+ background->color.alpha = 0xffff;
+
+ background->image = NULL;
+ background->loaded_image = NULL;
+
+ background->orientation = GTK_ORIENTATION_HORIZONTAL;
+ background->region.x = -1;
+ background->region.y = -1;
+ background->region.width = -1;
+ background->region.height = -1;
+ background->transformed_image = NULL;
+ background->composited_image = NULL;
+
+ background->monitor = NULL;
+ background->desktop = NULL;
+ background->monitor_signal = -1;
+
+ background->pixmap = NULL;
+ background->window = NULL;
+ background->colormap = NULL;
+ background->gc = NULL;
+
+ background->default_pixmap = NULL;
+ background->default_color.red = 0;
+ background->default_color.green = 0;
+ background->default_color.blue = 0;
+ background->default_color.pixel = 0;
+
+ background->fit_image = FALSE;
+ background->stretch_image = FALSE;
+ background->rotate_image = FALSE;
+
+ background->has_alpha = FALSE;
+
+ background->transformed = FALSE;
+ background->composited = FALSE;
+ background->prepared = FALSE;
+}
+
+void
+panel_background_free (PanelBackground *background)
+{
+ disconnect_background_monitor (background);
+
+ free_transformed_resources (background);
+
+ if (background->image)
+ g_free (background->image);
+ background->image = NULL;
+
+ if (background->loaded_image)
+ g_object_unref (background->loaded_image);
+ background->loaded_image = NULL;
+
+ if (background->monitor)
+ g_object_unref (background->monitor);
+ background->monitor = NULL;
+
+ if (background->window)
+ g_object_unref (background->window);
+ background->window = NULL;
+
+ if (background->colormap)
+ g_object_unref (background->colormap);
+ background->colormap = NULL;
+
+ if (background->gc)
+ g_object_unref (background->gc);
+ background->gc = NULL;
+
+ if (background->default_pixmap
+ && background->default_pixmap != (GdkPixmap*) GDK_PARENT_RELATIVE)
+ g_object_unref (background->default_pixmap);
+ background->default_pixmap = NULL;
+}
+
+char *
+panel_background_make_string (PanelBackground *background,
+ int x,
+ int y)
+{
+ PanelBackgroundType effective_type;
+ char *retval;
+ 
+ retval = NULL;
+
+ effective_type = panel_background_effective_type (background);
+
+ if (effective_type == PANEL_BACK_IMAGE ||
+ (effective_type == PANEL_BACK_COLOR && background->has_alpha)) {
+ GdkNativeWindow pixmap_xid;
+
+ if (!background->pixmap)
+ return NULL;
+
+ pixmap_xid = gdk_x11_drawable_get_xid (
+ GDK_DRAWABLE (background->pixmap));
+
+ retval = g_strdup_printf ("pixmap:%d,%d,%d", pixmap_xid, x, y);
+
+ } else if (effective_type == PANEL_BACK_COLOR)
+ retval = g_strdup_printf (
+ "color:%.4x%.4x%.4x",
+ background->color.gdk.red,
+ background->color.gdk.green,
+ background->color.gdk.blue);
+ else
+ retval = g_strdup ("none:");
+
+ return retval;
+
+}
+
+PanelBackgroundType
+panel_background_get_type (PanelBackground *background)
+{
+ return background->type;
+}
+
+const PanelColor *
+panel_background_get_color (PanelBackground *background)
+{
+ return &(background->color);
+}
+
+const GdkPixmap *
+panel_background_get_pixmap (PanelBackground *background)
+{
+ return background->pixmap;
+}
+
+
+/* What are we actually rendering - e.g. if we're supposed to
+ * be rendering an image, but haven't got a valid image, then
+ * we're rendering the default gtk background.
+ */
+PanelBackgroundType
+panel_background_effective_type (PanelBackground *background)
+{
+ PanelBackgroundType retval;
+
+ retval = background->type;
+ if (background->type == PANEL_BACK_IMAGE && !background->composited_image)
+ retval = PANEL_BACK_NONE;
+
+ return retval;
+}
+
+static void
+panel_background_set_no_background_on_widget (PanelBackground *background,
+ GtkWidget *widget)
+{
+ GtkRcStyle *rc_style;
+
+ gtk_widget_set_style (widget, NULL);
+ rc_style = gtk_rc_style_new ();
+ gtk_widget_modify_style (widget, rc_style);
+ g_object_unref (rc_style);
+}
+
+static void
+panel_background_set_image_background_on_widget (PanelBackground *background,
+ GtkWidget *widget)
+{
+ const GdkPixmap *bg_pixmap;
+ GtkAllocation allocation;
+ GdkPixmap *pixmap;
+ cairo_t *cr;
+ cairo_pattern_t *pattern;
+ GtkStyle *style;
+
+ bg_pixmap = panel_background_get_pixmap (background);
+ if (!bg_pixmap)
+ return;
+
+ gtk_widget_get_allocation (widget, &allocation);
+ pixmap = gdk_pixmap_new (gtk_widget_get_window (widget),
+ allocation.width,
+ allocation.height,
+ -1);
+
+ cr = gdk_cairo_create (GDK_DRAWABLE (pixmap));
+ gdk_cairo_set_source_pixmap (cr, (GdkPixmap *) bg_pixmap,
+ -allocation.x,
+ -allocation.y);
+ pattern = cairo_get_source (cr);
+ cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
+
+ cairo_rectangle (cr, 0, 0,
+ allocation.width, allocation.height);
+ cairo_fill (cr);
+
+ cairo_destroy (cr);
+
+ style = gtk_style_copy (gtk_widget_get_style (widget));
+ if (style->bg_pixmap[GTK_STATE_NORMAL])
+ g_object_unref (style->bg_pixmap[GTK_STATE_NORMAL]);
+ style->bg_pixmap[GTK_STATE_NORMAL] = g_object_ref (pixmap);
+ gtk_widget_set_style (widget, style);
+ g_object_unref (style);
+
+ g_object_unref (pixmap);
+}
+
+static void
+panel_background_set_color_background_on_widget (PanelBackground *background,
+ GtkWidget *widget)
+{
+ const PanelColor *color;
+
+ color = panel_background_get_color (background);
+ if (color->alpha != 0xffff) {
+ panel_background_set_image_background_on_widget (background,
+ widget);
+ return;
+ }
+
+ gtk_widget_modify_bg (widget, GTK_STATE_NORMAL, &color->gdk);
+}
+
+void
+panel_background_change_background_on_widget (PanelBackground *background,
+ GtkWidget *widget)
+{
+ PanelBackgroundType type;
+
+ panel_background_set_no_background_on_widget (background, widget);
+
+ type = panel_background_get_type (background);
+
+ switch (type) {
+ case PANEL_BACK_NONE:
+ break;
+ case PANEL_BACK_COLOR:
+ panel_background_set_color_background_on_widget (background,
+ widget);
+ break;
+ case PANEL_BACK_IMAGE:
+ panel_background_set_image_background_on_widget (background,
+ widget);
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+}