diff options
Diffstat (limited to 'libmate-desktop/mate-bg.c')
| -rw-r--r-- | libmate-desktop/mate-bg.c | 2930 |
1 files changed, 2930 insertions, 0 deletions
diff --git a/libmate-desktop/mate-bg.c b/libmate-desktop/mate-bg.c new file mode 100644 index 0000000..3b0f684 --- /dev/null +++ b/libmate-desktop/mate-bg.c @@ -0,0 +1,2930 @@ +/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- + +matebg.c: Object for the desktop background. + +Copyright (C) 2000 Eazel, Inc. +Copyright (C) 2007-2008 Red Hat, Inc. + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU Library 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library 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. + +Derived from eel-background.c and eel-gdk-pixbuf-extensions.c by +Darin Adler <[email protected]> and Ramiro Estrugo <[email protected]> + +Author: Soren Sandmann <[email protected]> + +*/ + +#include <string.h> +#include <math.h> +#include <stdarg.h> +#include <stdlib.h> + +#include <gio/gio.h> + +#include <gdk/gdkx.h> +#include <X11/Xlib.h> +#include <X11/Xatom.h> + +#include <cairo.h> + +#include <mateconf/mateconf-client.h> + +#define MATE_DESKTOP_USE_UNSTABLE_API +#include <libmateui/mate-bg.h> +#include <libmateui/mate-bg-crossfade.h> + +#define BG_KEY_DRAW_BACKGROUND MATE_BG_KEY_DIR "/draw_background" +#define BG_KEY_PRIMARY_COLOR MATE_BG_KEY_DIR "/primary_color" +#define BG_KEY_SECONDARY_COLOR MATE_BG_KEY_DIR "/secondary_color" +#define BG_KEY_COLOR_TYPE MATE_BG_KEY_DIR "/color_shading_type" +#define BG_KEY_PICTURE_PLACEMENT MATE_BG_KEY_DIR "/picture_options" +#define BG_KEY_PICTURE_OPACITY MATE_BG_KEY_DIR "/picture_opacity" +#define BG_KEY_PICTURE_FILENAME MATE_BG_KEY_DIR "/picture_filename" + +/* We keep the large pixbufs around if the next update + in the slideshow is less than 60 seconds away */ +#define KEEP_EXPENSIVE_CACHE_SECS 60 + +typedef struct _SlideShow SlideShow; +typedef struct _Slide Slide; + +struct _Slide { + double duration; /* in seconds */ + gboolean fixed; + + GSList* file1; + GSList* file2; /* NULL if fixed is TRUE */ +}; + +typedef struct _FileSize FileSize; +struct _FileSize { + gint width; + gint height; + + char* file; +}; + +/* This is the size of the GdkRGB dither matrix, in order to avoid + * bad dithering when tiling the gradient + */ +#define GRADIENT_PIXMAP_TILE_SIZE 128 + +typedef struct FileCacheEntry FileCacheEntry; +#define CACHE_SIZE 4 + +/* + * Implementation of the MateBG class + */ +struct _MateBG { + GObject parent_instance; + char* filename; + MateBGPlacement placement; + MateBGColorType color_type; + GdkColor primary; + GdkColor secondary; + + gint last_pixmap_width; + gint last_pixmap_height; + + GFileMonitor* file_monitor; + + guint changed_id; + guint transitioned_id; + guint blow_caches_id; + + /* Cached information, only access through cache accessor functions */ + SlideShow* slideshow; + time_t file_mtime; + GdkPixbuf* pixbuf_cache; + int timeout_id; + + GList* file_cache; +}; + +struct _MateBGClass { + GObjectClass parent_class; +}; + +enum { + CHANGED, + TRANSITIONED, + N_SIGNALS +}; + +static guint signals[N_SIGNALS] = {0}; + +G_DEFINE_TYPE(MateBG, mate_bg, G_TYPE_OBJECT) + +static GdkPixmap* make_root_pixmap(GdkScreen* screen, gint width, gint height); + +/* Pixbuf utils */ +static guint32 pixbuf_average_value (GdkPixbuf *pixbuf); +static GdkPixbuf *pixbuf_scale_to_fit (GdkPixbuf *src, + int max_width, + int max_height); +static GdkPixbuf *pixbuf_scale_to_min (GdkPixbuf *src, + int min_width, + int min_height); +static void pixbuf_draw_gradient (GdkPixbuf *pixbuf, + gboolean horizontal, + GdkColor *c1, + GdkColor *c2, + GdkRectangle *rect); +static void pixbuf_tile (GdkPixbuf *src, + GdkPixbuf *dest); +static void pixbuf_blend (GdkPixbuf *src, + GdkPixbuf *dest, + int src_x, + int src_y, + int width, + int height, + int dest_x, + int dest_y, + double alpha); + +/* Thumbnail utilities */ +static GdkPixbuf *create_thumbnail_for_filename (MateDesktopThumbnailFactory *factory, + const char *filename); +static gboolean get_thumb_annotations (GdkPixbuf *thumb, + int *orig_width, + int *orig_height); + +/* Cache */ +static GdkPixbuf *get_pixbuf_for_size (MateBG *bg, + int width, + int height); +static void clear_cache (MateBG *bg); +static gboolean is_different (MateBG *bg, + const char *filename); +static time_t get_mtime (const char *filename); +static GdkPixbuf *create_img_thumbnail (MateBG *bg, + MateDesktopThumbnailFactory *factory, + GdkScreen *screen, + int dest_width, + int dest_height, + int frame_num); +static SlideShow * get_as_slideshow (MateBG *bg, + const char *filename); +static Slide * get_current_slide (SlideShow *show, + double *alpha); +static gboolean slideshow_has_multiple_sizes (SlideShow *show); + +static SlideShow *read_slideshow_file (const char *filename, + GError **err); +static SlideShow *slideshow_ref (SlideShow *show); +static void slideshow_unref (SlideShow *show); + +static FileSize *find_best_size (GSList *sizes, + gint width, + gint height); + +static void +color_from_string (const char *string, + GdkColor *colorp) +{ + /* If all else fails use black */ + gdk_color_parse ("black", colorp); + + if (!string) + return; + + gdk_color_parse (string, colorp); +} + +static char * +color_to_string (const GdkColor *color) +{ + return g_strdup_printf ("#%02x%02x%02x", + color->red >> 8, + color->green >> 8, + color->blue >> 8); +} + +static MateConfEnumStringPair placement_lookup[] = { + { MATE_BG_PLACEMENT_CENTERED, "centered" }, + { MATE_BG_PLACEMENT_FILL_SCREEN, "stretched" }, + { MATE_BG_PLACEMENT_SCALED, "scaled" }, + { MATE_BG_PLACEMENT_ZOOMED, "zoom" }, + { MATE_BG_PLACEMENT_TILED, "wallpaper" }, + { MATE_BG_PLACEMENT_SPANNED, "spanned" }, + { 0, NULL } +}; + +static MateConfEnumStringPair color_type_lookup[] = { + { MATE_BG_COLOR_SOLID, "solid" }, + { MATE_BG_COLOR_H_GRADIENT, "horizontal-gradient" }, + { MATE_BG_COLOR_V_GRADIENT, "vertical-gradient" }, + { 0, NULL } +}; + +static void +color_type_from_string (const char *string, + MateBGColorType *color_type) +{ + *color_type = MATE_BG_COLOR_SOLID; + + if (string) { + mateconf_string_to_enum (color_type_lookup, + string, (int *)color_type); + } +} + +static const char * +color_type_to_string (MateBGColorType color_type) +{ + return mateconf_enum_to_string (color_type_lookup, color_type); +} + +static void +placement_from_string (const char *string, + MateBGPlacement *placement) +{ + *placement = MATE_BG_PLACEMENT_ZOOMED; + + if (string) { + mateconf_string_to_enum (placement_lookup, + string, (int *)placement); + } +} + +static const char * +placement_to_string (MateBGPlacement placement) +{ + return mateconf_enum_to_string (placement_lookup, placement); +} + +static gboolean +do_changed (MateBG *bg) +{ + gboolean ignore_pending_change; + bg->changed_id = 0; + + ignore_pending_change = + GPOINTER_TO_INT (g_object_get_data (G_OBJECT (bg), + "ignore-pending-change")); + + if (!ignore_pending_change) { + g_signal_emit (G_OBJECT (bg), signals[CHANGED], 0); + } + + return FALSE; +} + +static void +queue_changed (MateBG *bg) +{ + if (bg->changed_id > 0) { + g_source_remove (bg->changed_id); + } + + /* We unset this here to allow apps to set it if they don't want + to get the change event. This is used by caja when it + gets the pixmap from the bg (due to a reason other than the changed + event). Because if there is no other change after this time the + pending changed event will just uselessly cause us to recreate + the pixmap. */ + g_object_set_data (G_OBJECT (bg), "ignore-pending-change", + GINT_TO_POINTER (FALSE)); + bg->changed_id = g_timeout_add_full (G_PRIORITY_LOW, + 100, + (GSourceFunc)do_changed, + bg, + NULL); +} + +static gboolean +do_transitioned (MateBG *bg) +{ + bg->transitioned_id = 0; + + if (bg->pixbuf_cache) { + g_object_unref (bg->pixbuf_cache); + bg->pixbuf_cache = NULL; + } + + g_signal_emit (G_OBJECT (bg), signals[TRANSITIONED], 0); + + return FALSE; +} + +static void +queue_transitioned (MateBG *bg) +{ + if (bg->transitioned_id > 0) { + g_source_remove (bg->transitioned_id); + } + + bg->transitioned_id = g_timeout_add_full (G_PRIORITY_LOW, + 100, + (GSourceFunc)do_transitioned, + bg, + NULL); +} + +void +mate_bg_load_from_preferences (MateBG *bg, + MateConfClient *client) +{ + char *tmp; + char *filename; + MateBGColorType ctype; + GdkColor c1, c2; + MateBGPlacement placement; + + g_return_if_fail (MATE_IS_BG (bg)); + g_return_if_fail (client != NULL); + + /* Filename */ + filename = NULL; + tmp = mateconf_client_get_string (client, BG_KEY_PICTURE_FILENAME, NULL); + if (tmp != NULL && *tmp != '\0') { + if (g_utf8_validate (tmp, -1, NULL) && + g_file_test (tmp, G_FILE_TEST_EXISTS)) { + filename = g_strdup (tmp); + } else { + filename = g_filename_from_utf8 (tmp, -1, NULL, NULL, NULL); + } + + /* Fall back to default background if filename was set + but no longer exists */ + if (!g_file_test (filename, G_FILE_TEST_EXISTS)) { + MateConfValue *default_value; + + g_free (filename); + filename = NULL; + + default_value = + mateconf_client_get_default_from_schema (client, + BG_KEY_PICTURE_FILENAME, + NULL); + if (default_value != NULL) { + filename = g_strdup (mateconf_value_get_string (default_value)); + mateconf_value_free (default_value); + } + } + } + g_free (tmp); + + /* Colors */ + tmp = mateconf_client_get_string (client, BG_KEY_PRIMARY_COLOR, NULL); + color_from_string (tmp, &c1); + g_free (tmp); + + tmp = mateconf_client_get_string (client, BG_KEY_SECONDARY_COLOR, NULL); + color_from_string (tmp, &c2); + g_free (tmp); + + /* Color type */ + tmp = mateconf_client_get_string (client, BG_KEY_COLOR_TYPE, NULL); + color_type_from_string (tmp, &ctype); + g_free (tmp); + + /* Placement */ + tmp = mateconf_client_get_string (client, BG_KEY_PICTURE_PLACEMENT, NULL); + placement_from_string (tmp, &placement); + g_free (tmp); + + mate_bg_set_color (bg, ctype, &c1, &c2); + mate_bg_set_placement (bg, placement); + mate_bg_set_filename (bg, filename); + + g_free (filename); +} + +void +mate_bg_save_to_preferences (MateBG *bg, + MateConfClient *client) +{ + const char *color_type; + const char *placement; + const gchar *filename; + gchar *primary; + gchar *secondary; + + primary = color_to_string (&bg->primary); + secondary = color_to_string (&bg->secondary); + + color_type = color_type_to_string (bg->color_type); + + if (bg->filename) { + filename = bg->filename; + placement = placement_to_string (bg->placement); + } + else { + filename = "(none)"; + placement = "none"; + } + + mateconf_client_set_string (client, BG_KEY_PICTURE_FILENAME, filename, NULL); + mateconf_client_set_string (client, BG_KEY_PRIMARY_COLOR, primary, NULL); + mateconf_client_set_string (client, BG_KEY_SECONDARY_COLOR, secondary, NULL); + mateconf_client_set_string (client, BG_KEY_COLOR_TYPE, color_type, NULL); + mateconf_client_set_string (client, BG_KEY_PICTURE_PLACEMENT, placement, NULL); + + g_free (primary); + g_free (secondary); +} + + +static void +mate_bg_init (MateBG *bg) +{ +} + +static void +mate_bg_dispose (GObject *object) +{ + MateBG *bg = MATE_BG (object); + + if (bg->file_monitor) { + g_object_unref (bg->file_monitor); + bg->file_monitor = NULL; + } + + clear_cache (bg); + + G_OBJECT_CLASS (mate_bg_parent_class)->dispose (object); +} + +static void +mate_bg_finalize (GObject *object) +{ + MateBG *bg = MATE_BG (object); + + if (bg->changed_id != 0) { + g_source_remove (bg->changed_id); + bg->changed_id = 0; + } + + if (bg->transitioned_id != 0) { + g_source_remove (bg->transitioned_id); + bg->transitioned_id = 0; + } + + if (bg->blow_caches_id != 0) { + g_source_remove (bg->blow_caches_id); + bg->blow_caches_id = 0; + } + + if (bg->filename) { + g_free (bg->filename); + bg->filename = NULL; + } + + G_OBJECT_CLASS (mate_bg_parent_class)->finalize (object); +} + +static void +mate_bg_class_init (MateBGClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->dispose = mate_bg_dispose; + object_class->finalize = mate_bg_finalize; + + signals[CHANGED] = g_signal_new ("changed", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + 0, + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + signals[TRANSITIONED] = g_signal_new ("transitioned", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + 0, + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); +} + +MateBG * +mate_bg_new (void) +{ + return g_object_new (MATE_TYPE_BG, NULL); +} + +void +mate_bg_set_color (MateBG *bg, + MateBGColorType type, + GdkColor *primary, + GdkColor *secondary) +{ + g_return_if_fail (bg != NULL); + + if (bg->color_type != type || + !gdk_color_equal (&bg->primary, primary) || + (secondary && !gdk_color_equal (&bg->secondary, secondary))) { + + bg->color_type = type; + bg->primary = *primary; + if (secondary) { + bg->secondary = *secondary; + } + + queue_changed (bg); + } +} + +void +mate_bg_set_placement (MateBG *bg, + MateBGPlacement placement) +{ + g_return_if_fail (bg != NULL); + + if (bg->placement != placement) { + bg->placement = placement; + + queue_changed (bg); + } +} + +MateBGPlacement +mate_bg_get_placement (MateBG *bg) +{ + g_return_val_if_fail (bg != NULL, -1); + + return bg->placement; +} + +void +mate_bg_get_color (MateBG *bg, + MateBGColorType *type, + GdkColor *primary, + GdkColor *secondary) +{ + g_return_if_fail (bg != NULL); + + if (type) + *type = bg->color_type; + + if (primary) + *primary = bg->primary; + + if (secondary) + *secondary = bg->secondary; +} + +const gchar * +mate_bg_get_filename (MateBG *bg) +{ + g_return_val_if_fail (bg != NULL, NULL); + + return bg->filename; +} + +static void +file_changed (GFileMonitor *file_monitor, + GFile *child, + GFile *other_file, + GFileMonitorEvent event_type, + gpointer user_data) +{ + MateBG *bg = MATE_BG (user_data); + + clear_cache (bg); + queue_changed (bg); +} + +void +mate_bg_set_filename (MateBG *bg, + const char *filename) +{ + g_return_if_fail (bg != NULL); + + if (is_different (bg, filename)) { + char *tmp = g_strdup (filename); + + g_free (bg->filename); + + bg->filename = tmp; + bg->file_mtime = get_mtime (bg->filename); + + if (bg->file_monitor) { + g_object_unref (bg->file_monitor); + bg->file_monitor = NULL; + } + + if (bg->filename) { + GFile *f = g_file_new_for_path (bg->filename); + + bg->file_monitor = g_file_monitor_file (f, 0, NULL, NULL); + g_signal_connect (bg->file_monitor, "changed", + G_CALLBACK (file_changed), bg); + + g_object_unref (f); + } + + clear_cache (bg); + + queue_changed (bg); + } +} + +static void +draw_color_area (MateBG *bg, + GdkPixbuf *dest, + GdkRectangle *rect) +{ + guint32 pixel; + GdkRectangle extent; + + extent.x = 0; + extent.y = 0; + extent.width = gdk_pixbuf_get_width (dest); + extent.height = gdk_pixbuf_get_height (dest); + + gdk_rectangle_intersect (rect, &extent, rect); + + switch (bg->color_type) { + case MATE_BG_COLOR_SOLID: + /* not really a big deal to ignore the area of interest */ + pixel = ((bg->primary.red >> 8) << 24) | + ((bg->primary.green >> 8) << 16) | + ((bg->primary.blue >> 8) << 8) | + (0xff); + + gdk_pixbuf_fill (dest, pixel); + break; + + case MATE_BG_COLOR_H_GRADIENT: + pixbuf_draw_gradient (dest, TRUE, &(bg->primary), &(bg->secondary), rect); + break; + + case MATE_BG_COLOR_V_GRADIENT: + pixbuf_draw_gradient (dest, FALSE, &(bg->primary), &(bg->secondary), rect); + break; + + default: + break; + } +} + +static void +draw_color (MateBG *bg, + GdkPixbuf *dest, + GdkScreen *screen) +{ + GdkRectangle rect; + rect.x = 0; + rect.y = 0; + rect.width = gdk_pixbuf_get_width (dest); + rect.height = gdk_pixbuf_get_height (dest); + draw_color_area (bg, dest, &rect); +} + +static void +draw_color_each_monitor (MateBG *bg, + GdkPixbuf *dest, + GdkScreen *screen) +{ + GdkRectangle rect; + gint num_monitors; + int monitor; + + num_monitors = gdk_screen_get_n_monitors (screen); + for (monitor = 0; monitor < num_monitors; monitor++) { + gdk_screen_get_monitor_geometry (screen, monitor, &rect); + draw_color_area (bg, dest, &rect); + } +} + +static GdkPixbuf * +pixbuf_clip_to_fit (GdkPixbuf *src, + int max_width, + int max_height) +{ + int src_width, src_height; + int w, h; + int src_x, src_y; + GdkPixbuf *pixbuf; + + src_width = gdk_pixbuf_get_width (src); + src_height = gdk_pixbuf_get_height (src); + + if (src_width < max_width && src_height < max_height) + return g_object_ref (src); + + w = MIN(src_width, max_width); + h = MIN(src_height, max_height); + + pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, + gdk_pixbuf_get_has_alpha (src), + 8, w, h); + + src_x = (src_width - w) / 2; + src_y = (src_height - h) / 2; + gdk_pixbuf_copy_area (src, + src_x, src_y, + w, h, + pixbuf, + 0, 0); + return pixbuf; +} + +static GdkPixbuf * +get_scaled_pixbuf (MateBGPlacement placement, + GdkPixbuf *pixbuf, + int width, int height, + int *x, int *y, + int *w, int *h) +{ + GdkPixbuf *new; + +#if 0 + g_print ("original_width: %d %d\n", + gdk_pixbuf_get_width (pixbuf), + gdk_pixbuf_get_height (pixbuf)); +#endif + + switch (placement) { + case MATE_BG_PLACEMENT_SPANNED: + new = pixbuf_scale_to_fit (pixbuf, width, height); + break; + case MATE_BG_PLACEMENT_ZOOMED: + new = pixbuf_scale_to_min (pixbuf, width, height); + break; + + case MATE_BG_PLACEMENT_FILL_SCREEN: + new = gdk_pixbuf_scale_simple (pixbuf, width, height, + GDK_INTERP_BILINEAR); + break; + + case MATE_BG_PLACEMENT_SCALED: + new = pixbuf_scale_to_fit (pixbuf, width, height); + break; + + case MATE_BG_PLACEMENT_CENTERED: + case MATE_BG_PLACEMENT_TILED: + default: + new = pixbuf_clip_to_fit (pixbuf, width, height); + break; + } + + *w = gdk_pixbuf_get_width (new); + *h = gdk_pixbuf_get_height (new); + *x = (width - *w) / 2; + *y = (height - *h) / 2; + + return new; +} + +static void +draw_image_area (MateBGPlacement placement, + GdkPixbuf *pixbuf, + GdkPixbuf *dest, + GdkRectangle *area) +{ + int dest_width = area->width; + int dest_height = area->height; + int x, y, w, h; + GdkPixbuf *scaled; + + if (!pixbuf) + return; + + scaled = get_scaled_pixbuf (placement, pixbuf, dest_width, dest_height, &x, &y, &w, &h); + + switch (placement) { + case MATE_BG_PLACEMENT_TILED: + pixbuf_tile (scaled, dest); + break; + case MATE_BG_PLACEMENT_ZOOMED: + case MATE_BG_PLACEMENT_CENTERED: + case MATE_BG_PLACEMENT_FILL_SCREEN: + case MATE_BG_PLACEMENT_SCALED: + pixbuf_blend (scaled, dest, 0, 0, w, h, x + area->x, y + area->y, 1.0); + break; + case MATE_BG_PLACEMENT_SPANNED: + pixbuf_blend (scaled, dest, 0, 0, w, h, x, y, 1.0); + break; + default: + g_assert_not_reached (); + break; + } + + g_object_unref (scaled); +} + +static void +draw_image (MateBGPlacement placement, + GdkPixbuf *pixbuf, + GdkPixbuf *dest) +{ + GdkRectangle rect; + + rect.x = 0; + rect.y = 0; + rect.width = gdk_pixbuf_get_width (dest); + rect.height = gdk_pixbuf_get_height (dest); + + draw_image_area (placement, pixbuf, dest, &rect); +} + +static void +draw_once (MateBG *bg, + GdkPixbuf *dest, + GdkScreen *screen) +{ + GdkRectangle rect; + GdkPixbuf *pixbuf; + + rect.x = 0; + rect.y = 0; + rect.width = gdk_pixbuf_get_width (dest); + rect.height = gdk_pixbuf_get_height (dest); + + pixbuf = get_pixbuf_for_size (bg, gdk_pixbuf_get_width (dest), gdk_pixbuf_get_height (dest)); + if (pixbuf) { + draw_image_area (bg->placement, + pixbuf, + dest, + &rect); + g_object_unref (pixbuf); + } +} + +static void +draw_each_monitor (MateBG *bg, + GdkPixbuf *dest, + GdkScreen *screen) +{ + GdkRectangle rect; + gint num_monitors; + int monitor; + + num_monitors = gdk_screen_get_n_monitors (screen); + for (monitor = 0; monitor < num_monitors; monitor++) { + GdkPixbuf *pixbuf; + gdk_screen_get_monitor_geometry (screen, monitor, &rect); + pixbuf = get_pixbuf_for_size (bg, rect.width, rect.height); + if (pixbuf) { + draw_image_area (bg->placement, + pixbuf, + dest, &rect); + g_object_unref (pixbuf); + } + } +} + +void +mate_bg_draw (MateBG *bg, + GdkPixbuf *dest, + GdkScreen *screen, + gboolean is_root) +{ + if (!bg) + return; + + if (is_root && (bg->placement != MATE_BG_PLACEMENT_SPANNED)) { + draw_color_each_monitor (bg, dest, screen); + draw_each_monitor (bg, dest, screen); + } else { + draw_color (bg, dest, screen); + draw_once (bg, dest, screen); + } +} + +gboolean +mate_bg_has_multiple_sizes (MateBG *bg) +{ + SlideShow *show; + gboolean ret; + + g_return_val_if_fail (bg != NULL, FALSE); + + ret = FALSE; + + show = get_as_slideshow (bg, bg->filename); + if (show) { + ret = slideshow_has_multiple_sizes (show); + slideshow_unref (show); + } + + return ret; +} + +static void +mate_bg_get_pixmap_size (MateBG *bg, + int width, + int height, + int *pixmap_width, + int *pixmap_height) +{ + int dummy; + + if (!pixmap_width) + pixmap_width = &dummy; + if (!pixmap_height) + pixmap_height = &dummy; + + *pixmap_width = width; + *pixmap_height = height; + + if (!bg->filename) { + switch (bg->color_type) { + case MATE_BG_COLOR_SOLID: + *pixmap_width = 1; + *pixmap_height = 1; + break; + + case MATE_BG_COLOR_H_GRADIENT: + case MATE_BG_COLOR_V_GRADIENT: + break; + } + + return; + } +} + +/** + * mate_bg_get_pixmap: + * @bg: MateBG + * @window: + * @width: + * @height: + * + * Create a pixmap that can be set as background for @window. If @root is TRUE, + * the pixmap created will be created by a temporary X server connection so + * that if someone calls XKillClient on it, it won't affect the application who + * created it. + * + * Since: 2.20 + **/ +GdkPixmap * +mate_bg_create_pixmap (MateBG *bg, + GdkWindow *window, + int width, + int height, + gboolean is_root) +{ + int pm_width, pm_height; + GdkPixmap *pixmap; + cairo_t *cr; + + g_return_val_if_fail (bg != NULL, NULL); + g_return_val_if_fail (window != NULL, NULL); + + if (bg->last_pixmap_width != width || + bg->last_pixmap_height != height) { + if (bg->pixbuf_cache) { + g_object_unref (bg->pixbuf_cache); + bg->pixbuf_cache = NULL; + } + } + bg->last_pixmap_width = width; + bg->last_pixmap_height = height; + + /* has the side effect of loading and caching pixbuf only when in tile mode */ + mate_bg_get_pixmap_size (bg, width, height, &pm_width, &pm_height); + + if (is_root) { + pixmap = make_root_pixmap (gdk_drawable_get_screen (window), + pm_width, pm_height); + } + else { + pixmap = gdk_pixmap_new (window, pm_width, pm_height, -1); + } + + cr = gdk_cairo_create (pixmap); + if (!bg->filename && bg->color_type == MATE_BG_COLOR_SOLID) { + gdk_cairo_set_source_color (cr, &(bg->primary)); + } + else { + GdkPixbuf *pixbuf; + + pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, + width, height); + mate_bg_draw (bg, pixbuf, gdk_drawable_get_screen (GDK_DRAWABLE (window)), is_root); + gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0); + g_object_unref (pixbuf); + } + + cairo_paint (cr); + + cairo_destroy (cr); + + return pixmap; +} + + +/* determine if a background is darker or lighter than average, to help + * clients know what colors to draw on top with + */ +gboolean +mate_bg_is_dark (MateBG *bg, + int width, + int height) +{ + GdkColor color; + int intensity; + GdkPixbuf *pixbuf; + + g_return_val_if_fail (bg != NULL, FALSE); + + if (bg->color_type == MATE_BG_COLOR_SOLID) { + color = bg->primary; + } else { + color.red = (bg->primary.red + bg->secondary.red) / 2; + color.green = (bg->primary.green + bg->secondary.green) / 2; + color.blue = (bg->primary.blue + bg->secondary.blue) / 2; + } + pixbuf = get_pixbuf_for_size (bg, width, height); + if (pixbuf) { + guint32 argb = pixbuf_average_value (pixbuf); + guchar a = (argb >> 24) & 0xff; + guchar r = (argb >> 16) & 0xff; + guchar g = (argb >> 8) & 0xff; + guchar b = (argb >> 0) & 0xff; + + color.red = (color.red * (0xFF - a) + r * 0x101 * a) / 0xFF; + color.green = (color.green * (0xFF - a) + g * 0x101 * a) / 0xFF; + color.blue = (color.blue * (0xFF - a) + b * 0x101 * a) / 0xFF; + g_object_unref (pixbuf); + } + + intensity = (color.red * 77 + + color.green * 150 + + color.blue * 28) >> 16; + + return intensity < 160; /* biased slightly to be dark */ +} + +/* + * Create a persistent pixmap. We create a separate display + * and set the closedown mode on it to RetainPermanent. + */ +static GdkPixmap * +make_root_pixmap (GdkScreen *screen, gint width, gint height) +{ + Display *display; + const char *display_name; + Pixmap result; + GdkPixmap *gdk_pixmap; + int screen_num; + int depth; + + screen_num = gdk_screen_get_number (screen); + + gdk_flush (); + + display_name = gdk_display_get_name (gdk_screen_get_display (screen)); + display = XOpenDisplay (display_name); + + if (display == NULL) { + g_warning ("Unable to open display '%s' when setting " + "background pixmap\n", + (display_name) ? display_name : "NULL"); + return NULL; + } + + /* Desktop background pixmap should be created from + * dummy X client since most applications will try to + * kill it with XKillClient later when changing pixmap + */ + + XSetCloseDownMode (display, RetainPermanent); + + depth = DefaultDepth (display, screen_num); + + result = XCreatePixmap (display, + RootWindow (display, screen_num), + width, height, depth); + + XCloseDisplay (display); + + gdk_pixmap = gdk_pixmap_foreign_new_for_screen (screen, result, + width, height, depth); + + gdk_drawable_set_colormap ( + GDK_DRAWABLE (gdk_pixmap), + gdk_drawable_get_colormap (gdk_screen_get_root_window (screen))); + + return gdk_pixmap; +} + +static gboolean +get_original_size (const char *filename, + int *orig_width, + int *orig_height) +{ + gboolean result; + + if (gdk_pixbuf_get_file_info (filename, orig_width, orig_height)) + result = TRUE; + else + result = FALSE; + + return result; +} + +static const char * +get_filename_for_size (MateBG *bg, gint best_width, gint best_height) +{ + SlideShow *show; + Slide *slide; + FileSize *size; + + if (!bg->filename) + return NULL; + + show = get_as_slideshow (bg, bg->filename); + if (!show) { + return bg->filename; + } + + slide = get_current_slide (show, NULL); + slideshow_unref (show); + size = find_best_size (slide->file1, best_width, best_height); + return size->file; +} + +gboolean +mate_bg_get_image_size (MateBG *bg, + MateDesktopThumbnailFactory *factory, + int best_width, + int best_height, + int *width, + int *height) +{ + GdkPixbuf *thumb; + gboolean result = FALSE; + const gchar *filename; + + g_return_val_if_fail (bg != NULL, FALSE); + g_return_val_if_fail (factory != NULL, FALSE); + + if (!bg->filename) + return FALSE; + + filename = get_filename_for_size (bg, best_width, best_height); + thumb = create_thumbnail_for_filename (factory, filename); + if (thumb) { + if (get_thumb_annotations (thumb, width, height)) + result = TRUE; + + g_object_unref (thumb); + } + + if (!result) { + if (get_original_size (filename, width, height)) + result = TRUE; + } + + return result; +} + +static double +fit_factor (int from_width, int from_height, + int to_width, int to_height) +{ + return MIN (to_width / (double) from_width, to_height / (double) from_height); +} + +GdkPixbuf * +mate_bg_create_thumbnail (MateBG *bg, + MateDesktopThumbnailFactory *factory, + GdkScreen *screen, + int dest_width, + int dest_height) +{ + GdkPixbuf *result; + GdkPixbuf *thumb; + + g_return_val_if_fail (bg != NULL, NULL); + + result = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, dest_width, dest_height); + + draw_color (bg, result, screen); + + thumb = create_img_thumbnail (bg, factory, screen, dest_width, dest_height, -1); + + if (thumb) { + draw_image (bg->placement, thumb, result); + g_object_unref (thumb); + } + + return result; +} + +/** + * mate_bg_get_pixmap_from_root: + * @screen: a #GdkScreen + * + * This function queries the _XROOTPMAP_ID property from + * the root window associated with @screen to determine + * the current root window background pixmap and returns + * a copy of it. If the _XROOTPMAP_ID is not set, then + * a black pixmap is returned. + * + * Return value: a #GdkPixmap if successful or %NULL + **/ +GdkPixmap * +mate_bg_get_pixmap_from_root (GdkScreen *screen) +{ + int result; + gint format; + gulong nitems; + gulong bytes_after; + guchar *data; + Atom type; + Display *display; + int screen_num; + GdkPixmap *pixmap; + GdkPixmap *source_pixmap; + int width, height; + cairo_t *cr; + cairo_pattern_t *pattern; + + display = GDK_DISPLAY_XDISPLAY (gdk_screen_get_display (screen)); + screen_num = gdk_screen_get_number (screen); + + result = XGetWindowProperty (display, + RootWindow (display, screen_num), + gdk_x11_get_xatom_by_name ("_XROOTPMAP_ID"), + 0L, 1L, False, XA_PIXMAP, + &type, &format, &nitems, &bytes_after, + &data); + pixmap = NULL; + source_pixmap = NULL; + + if (result != Success || type != XA_PIXMAP || + format != 32 || nitems != 1) { + XFree (data); + data = NULL; + } + + if (data != NULL) { + gdk_error_trap_push (); + source_pixmap = gdk_pixmap_foreign_new (*(Pixmap *) data); + gdk_error_trap_pop (); + + if (source_pixmap != NULL) { + gdk_drawable_set_colormap (source_pixmap, + gdk_screen_get_default_colormap (screen)); + } + } + + width = gdk_screen_get_width (screen); + height = gdk_screen_get_height (screen); + + pixmap = gdk_pixmap_new (source_pixmap != NULL? source_pixmap : + gdk_screen_get_root_window (screen), + width, height, -1); + + cr = gdk_cairo_create (pixmap); + if (source_pixmap != NULL) { + gdk_cairo_set_source_pixmap (cr, source_pixmap, 0, 0); + pattern = cairo_get_source (cr); + cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT); + } else { + cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); + } + cairo_paint (cr); + + if (cairo_status (cr) != CAIRO_STATUS_SUCCESS) { + g_object_unref (pixmap); + pixmap = NULL; + } + cairo_destroy (cr); + + if (source_pixmap != NULL) + g_object_unref (source_pixmap); + + if (data != NULL) + XFree (data); + + return pixmap; +} + +static void +mate_bg_set_root_pixmap_id (GdkScreen *screen, + GdkPixmap *pixmap) +{ + int result; + gint format; + gulong nitems; + gulong bytes_after; + guchar *data_esetroot; + Pixmap pixmap_id; + Atom type; + Display *display; + int screen_num; + + screen_num = gdk_screen_get_number (screen); + data_esetroot = NULL; + + display = GDK_DISPLAY_XDISPLAY (gdk_screen_get_display (screen)); + + result = XGetWindowProperty (display, + RootWindow (display, screen_num), + gdk_x11_get_xatom_by_name ("ESETROOT_PMAP_ID"), + 0L, 1L, False, XA_PIXMAP, + &type, &format, &nitems, + &bytes_after, + &data_esetroot); + + if (data_esetroot != NULL) { + if (result == Success && type == XA_PIXMAP && + format == 32 && + nitems == 1) { + gdk_error_trap_push (); + XKillClient (display, *(Pixmap *)data_esetroot); + gdk_flush (); + gdk_error_trap_pop (); + } + XFree (data_esetroot); + } + + pixmap_id = GDK_WINDOW_XWINDOW (pixmap); + + XChangeProperty (display, RootWindow (display, screen_num), + gdk_x11_get_xatom_by_name ("ESETROOT_PMAP_ID"), + XA_PIXMAP, 32, PropModeReplace, + (guchar *) &pixmap_id, 1); + XChangeProperty (display, RootWindow (display, screen_num), + gdk_x11_get_xatom_by_name ("_XROOTPMAP_ID"), XA_PIXMAP, + 32, PropModeReplace, + (guchar *) &pixmap_id, 1); +} + +/** + * mate_bg_set_pixmap_as_root: + * @screen: the #GdkScreen to change root background on + * @pixmap: the #GdkPixmap to set root background from + * + * Set the root pixmap, and properties pointing to it. We + * do this atomically with a server grab to make sure that + * we won't leak the pixmap if somebody else it setting + * it at the same time. (This assumes that they follow the + * same conventions we do). @pixmap should come from a call + * to mate_bg_create_pixmap(). + **/ +void +mate_bg_set_pixmap_as_root (GdkScreen *screen, GdkPixmap *pixmap) +{ + Display *display; + int screen_num; + + g_return_if_fail (screen != NULL); + g_return_if_fail (pixmap != NULL); + + screen_num = gdk_screen_get_number (screen); + + display = GDK_DISPLAY_XDISPLAY (gdk_screen_get_display (screen)); + + gdk_x11_display_grab (gdk_screen_get_display (screen)); + + mate_bg_set_root_pixmap_id (screen, pixmap); + + XSetWindowBackgroundPixmap (display, RootWindow (display, screen_num), + GDK_PIXMAP_XID (pixmap)); + XClearWindow (display, RootWindow (display, screen_num)); + + gdk_display_flush (gdk_screen_get_display (screen)); + gdk_x11_display_ungrab (gdk_screen_get_display (screen)); +} + +/** + * mate_bg_set_pixmap_as_root_with_crossfade: + * @screen: the #GdkScreen to change root background on + * @pixmap: the #GdkPixmap to set root background from + * @context: a #GMainContext or %NULL + * + * Set the root pixmap, and properties pointing to it. + * This function differs from mate_bg_set_pixmap_as_root() + * in that it adds a subtle crossfade animation from the + * current root pixmap to the new one. + * same conventions we do). + * + * Return value: a #MateBGCrossfade object + **/ +MateBGCrossfade * +mate_bg_set_pixmap_as_root_with_crossfade (GdkScreen *screen, + GdkPixmap *pixmap) +{ + GdkDisplay *display; + GdkWindow *root_window; + GdkPixmap *old_pixmap; + int width, height; + MateBGCrossfade *fade; + + g_return_val_if_fail (screen != NULL, NULL); + g_return_val_if_fail (pixmap != NULL, NULL); + + root_window = gdk_screen_get_root_window (screen); + + width = gdk_screen_get_width (screen); + height = gdk_screen_get_height (screen); + + fade = mate_bg_crossfade_new (width, height); + + display = gdk_screen_get_display (screen); + gdk_x11_display_grab (display); + old_pixmap = mate_bg_get_pixmap_from_root (screen); + mate_bg_set_root_pixmap_id (screen, pixmap); + mate_bg_crossfade_set_start_pixmap (fade, old_pixmap); + g_object_unref (old_pixmap); + mate_bg_crossfade_set_end_pixmap (fade, pixmap); + gdk_display_flush (display); + gdk_x11_display_ungrab (display); + + mate_bg_crossfade_start (fade, root_window); + + return fade; +} + +/* Implementation of the pixbuf cache */ +struct _SlideShow +{ + gint ref_count; + double start_time; + double total_duration; + + GQueue *slides; + + gboolean has_multiple_sizes; + + /* used during parsing */ + struct tm start_tm; + GQueue *stack; +}; + + +static double +now (void) +{ + GTimeVal tv; + + g_get_current_time (&tv); + + return (double)tv.tv_sec + (tv.tv_usec / 1000000.0); +} + +static Slide * +get_current_slide (SlideShow *show, + double *alpha) +{ + double delta = fmod (now() - show->start_time, show->total_duration); + GList *list; + double elapsed; + int i; + + if (delta < 0) + delta += show->total_duration; + + elapsed = 0; + i = 0; + for (list = show->slides->head; list != NULL; list = list->next) { + Slide *slide = list->data; + + if (elapsed + slide->duration > delta) { + if (alpha) + *alpha = (delta - elapsed) / (double)slide->duration; + return slide; + } + + i++; + elapsed += slide->duration; + } + + /* this should never happen since we have slides and we should always + * find a current slide for the elapsed time since beginning -- we're + * looping with fmod() */ + g_assert_not_reached (); + + return NULL; +} + +static GdkPixbuf * +blend (GdkPixbuf *p1, + GdkPixbuf *p2, + double alpha) +{ + GdkPixbuf *result = gdk_pixbuf_copy (p1); + GdkPixbuf *tmp; + + if (gdk_pixbuf_get_width (p2) != gdk_pixbuf_get_width (p1) || + gdk_pixbuf_get_height (p2) != gdk_pixbuf_get_height (p1)) { + tmp = gdk_pixbuf_scale_simple (p2, + gdk_pixbuf_get_width (p1), + gdk_pixbuf_get_height (p1), + GDK_INTERP_BILINEAR); + } + else { + tmp = g_object_ref (p2); + } + + pixbuf_blend (tmp, result, 0, 0, -1, -1, 0, 0, alpha); + + g_object_unref (tmp); + + return result; +} + +typedef enum { + PIXBUF, + SLIDESHOW, + THUMBNAIL +} FileType; + +struct FileCacheEntry +{ + FileType type; + char *filename; + union { + GdkPixbuf *pixbuf; + SlideShow *slideshow; + GdkPixbuf *thumbnail; + } u; +}; + +static void +file_cache_entry_delete (FileCacheEntry *ent) +{ + g_free (ent->filename); + + switch (ent->type) { + case PIXBUF: + g_object_unref (ent->u.pixbuf); + break; + case SLIDESHOW: + slideshow_unref (ent->u.slideshow); + break; + case THUMBNAIL: + g_object_unref (ent->u.thumbnail); + break; + } + + g_free (ent); +} + +static void +bound_cache (MateBG *bg) +{ + while (g_list_length (bg->file_cache) >= CACHE_SIZE) { + GList *last_link = g_list_last (bg->file_cache); + FileCacheEntry *ent = last_link->data; + + file_cache_entry_delete (ent); + + bg->file_cache = g_list_delete_link (bg->file_cache, last_link); + } +} + +static const FileCacheEntry * +file_cache_lookup (MateBG *bg, FileType type, const char *filename) +{ + GList *list; + + for (list = bg->file_cache; list != NULL; list = list->next) { + FileCacheEntry *ent = list->data; + + if (ent && ent->type == type && + strcmp (ent->filename, filename) == 0) { + return ent; + } + } + + return NULL; +} + +static FileCacheEntry * +file_cache_entry_new (MateBG *bg, + FileType type, + const char *filename) +{ + FileCacheEntry *ent = g_new0 (FileCacheEntry, 1); + + g_assert (!file_cache_lookup (bg, type, filename)); + + ent->type = type; + ent->filename = g_strdup (filename); + + bg->file_cache = g_list_prepend (bg->file_cache, ent); + + bound_cache (bg); + + return ent; +} + +static void +file_cache_add_pixbuf (MateBG *bg, + const char *filename, + GdkPixbuf *pixbuf) +{ + FileCacheEntry *ent = file_cache_entry_new (bg, PIXBUF, filename); + ent->u.pixbuf = g_object_ref (pixbuf); +} + +static void +file_cache_add_thumbnail (MateBG *bg, + const char *filename, + GdkPixbuf *pixbuf) +{ + FileCacheEntry *ent = file_cache_entry_new (bg, THUMBNAIL, filename); + ent->u.thumbnail = g_object_ref (pixbuf); +} + +static void +file_cache_add_slide_show (MateBG *bg, + const char *filename, + SlideShow *show) +{ + FileCacheEntry *ent = file_cache_entry_new (bg, SLIDESHOW, filename); + ent->u.slideshow = slideshow_ref (show); +} + +static GdkPixbuf * +get_as_pixbuf_for_size (MateBG *bg, + const char *filename, + int best_width, + int best_height) +{ + const FileCacheEntry *ent; + if ((ent = file_cache_lookup (bg, PIXBUF, filename))) { + return g_object_ref (ent->u.pixbuf); + } + else { + GdkPixbufFormat *format; + GdkPixbuf *pixbuf; + gchar *tmp; + + /* If scalable choose maximum size */ + format = gdk_pixbuf_get_file_info (filename, NULL, NULL); + tmp = gdk_pixbuf_format_get_name (format); + if (format != NULL && + strcmp (tmp, "svg") == 0 && + (best_width > 0 && best_height > 0) && + (bg->placement == MATE_BG_PLACEMENT_FILL_SCREEN || + bg->placement == MATE_BG_PLACEMENT_SCALED || + bg->placement == MATE_BG_PLACEMENT_ZOOMED)) + pixbuf = gdk_pixbuf_new_from_file_at_size (filename, best_width, best_height, NULL); + else + pixbuf = gdk_pixbuf_new_from_file (filename, NULL); + g_free (tmp); + + if (pixbuf) + file_cache_add_pixbuf (bg, filename, pixbuf); + + return pixbuf; + } +} + +static SlideShow * +get_as_slideshow (MateBG *bg, const char *filename) +{ + const FileCacheEntry *ent; + if ((ent = file_cache_lookup (bg, SLIDESHOW, filename))) { + return slideshow_ref (ent->u.slideshow); + } + else { + SlideShow *show = read_slideshow_file (filename, NULL); + + if (show) + file_cache_add_slide_show (bg, filename, show); + + return show; + } +} + +static GdkPixbuf * +get_as_thumbnail (MateBG *bg, MateDesktopThumbnailFactory *factory, const char *filename) +{ + const FileCacheEntry *ent; + if ((ent = file_cache_lookup (bg, THUMBNAIL, filename))) { + return g_object_ref (ent->u.thumbnail); + } + else { + GdkPixbuf *thumb = create_thumbnail_for_filename (factory, filename); + + if (thumb) + file_cache_add_thumbnail (bg, filename, thumb); + + return thumb; + } +} + +static gboolean +blow_expensive_caches (gpointer data) +{ + MateBG *bg = data; + GList *list, *next; + + bg->blow_caches_id = 0; + + for (list = bg->file_cache; list != NULL; list = next) { + FileCacheEntry *ent = list->data; + next = list->next; + + if (ent->type == PIXBUF) { + file_cache_entry_delete (ent); + bg->file_cache = g_list_delete_link (bg->file_cache, + list); + } + } + + if (bg->pixbuf_cache) { + g_object_unref (bg->pixbuf_cache); + bg->pixbuf_cache = NULL; + } + + return FALSE; +} + +static void +blow_expensive_caches_in_idle (MateBG *bg) +{ + if (bg->blow_caches_id == 0) { + bg->blow_caches_id = + g_idle_add (blow_expensive_caches, + bg); + } +} + + +static gboolean +on_timeout (gpointer data) +{ + MateBG *bg = data; + + bg->timeout_id = 0; + + queue_transitioned (bg); + + return FALSE; +} + +static double +get_slide_timeout (Slide *slide) +{ + double timeout; + if (slide->fixed) { + timeout = slide->duration; + } else { + /* Maybe the number of steps should be configurable? */ + + /* In the worst case we will do a fade from 0 to 256, which mean + * we will never use more than 255 steps, however in most cases + * the first and last value are similar and users can't percieve + * changes in pixel values as small as 1/255th. So, lets not waste + * CPU cycles on transitioning to often. + * + * 64 steps is enough for each step to be just detectable in a 16bit + * color mode in the worst case, so we'll use this as an approximation + * of whats detectable. + */ + timeout = slide->duration / 64.0; + } + return timeout; +} + +static void +ensure_timeout (MateBG *bg, + Slide *slide) +{ + if (!bg->timeout_id) { + double timeout = get_slide_timeout (slide); + bg->timeout_id = g_timeout_add_full ( + G_PRIORITY_LOW, + timeout * 1000, on_timeout, bg, NULL); + + } +} + +static time_t +get_mtime (const char *filename) +{ + GFile *file; + GFileInfo *info; + time_t mtime; + + mtime = (time_t)-1; + + if (filename) { + file = g_file_new_for_path (filename); + info = g_file_query_info (file, G_FILE_ATTRIBUTE_TIME_MODIFIED, + G_FILE_QUERY_INFO_NONE, NULL, NULL); + if (info) { + mtime = g_file_info_get_attribute_uint64 (info, + G_FILE_ATTRIBUTE_TIME_MODIFIED); + g_object_unref (info); + } + g_object_unref (file); + } + + return mtime; +} + +static GdkPixbuf * +scale_thumbnail (MateBGPlacement placement, + const char *filename, + GdkPixbuf *thumb, + GdkScreen *screen, + int dest_width, + int dest_height) +{ + int o_width; + int o_height; + + if (placement != MATE_BG_PLACEMENT_TILED && + placement != MATE_BG_PLACEMENT_CENTERED) { + + /* In this case, the pixbuf will be scaled to fit the screen anyway, + * so just return the pixbuf here + */ + return g_object_ref (thumb); + } + + if (get_thumb_annotations (thumb, &o_width, &o_height) || + (filename && get_original_size (filename, &o_width, &o_height))) { + + int scr_height = gdk_screen_get_height (screen); + int scr_width = gdk_screen_get_width (screen); + int thumb_width = gdk_pixbuf_get_width (thumb); + int thumb_height = gdk_pixbuf_get_height (thumb); + double screen_to_dest = fit_factor (scr_width, scr_height, + dest_width, dest_height); + double thumb_to_orig = fit_factor (thumb_width, thumb_height, + o_width, o_height); + double f = thumb_to_orig * screen_to_dest; + int new_width, new_height; + + new_width = floor (thumb_width * f + 0.5); + new_height = floor (thumb_height * f + 0.5); + + if (placement == MATE_BG_PLACEMENT_TILED) { + /* Heuristic to make sure tiles don't become so small that + * they turn into a blur. + * + * This is strictly speaking incorrect, but the resulting + * thumbnail gives a much better idea what the background + * will actually look like. + */ + + if ((new_width < 32 || new_height < 32) && + (new_width < o_width / 4 || new_height < o_height / 4)) { + new_width = o_width / 4; + new_height = o_height / 4; + } + } + + thumb = gdk_pixbuf_scale_simple (thumb, new_width, new_height, + GDK_INTERP_BILINEAR); + } + else + g_object_ref (thumb); + + return thumb; +} + +/* frame_num determines which slide to thumbnail. + * -1 means 'current slide'. + */ +static GdkPixbuf * +create_img_thumbnail (MateBG *bg, + MateDesktopThumbnailFactory *factory, + GdkScreen *screen, + int dest_width, + int dest_height, + int frame_num) +{ + if (bg->filename) { + GdkPixbuf *thumb; + + thumb = get_as_thumbnail (bg, factory, bg->filename); + + if (thumb) { + GdkPixbuf *result; + result = scale_thumbnail (bg->placement, + bg->filename, + thumb, + screen, + dest_width, + dest_height); + g_object_unref (thumb); + return result; + } + else { + SlideShow *show = get_as_slideshow (bg, bg->filename); + + if (show) { + double alpha; + Slide *slide; + + if (frame_num == -1) + slide = get_current_slide (show, &alpha); + else + slide = g_queue_peek_nth (show->slides, frame_num); + + if (slide->fixed) { + GdkPixbuf *tmp; + FileSize *fs; + fs = find_best_size (slide->file1, dest_width, dest_height); + tmp = get_as_thumbnail (bg, factory, fs->file); + if (tmp) { + thumb = scale_thumbnail (bg->placement, + fs->file, + tmp, + screen, + dest_width, + dest_height); + g_object_unref (tmp); + } + } + else { + FileSize *fs1, *fs2; + GdkPixbuf *p1, *p2; + fs1 = find_best_size (slide->file1, dest_width, dest_height); + p1 = get_as_thumbnail (bg, factory, fs1->file); + + fs2 = find_best_size (slide->file2, dest_width, dest_height); + p2 = get_as_thumbnail (bg, factory, fs2->file); + + if (p1 && p2) { + GdkPixbuf *thumb1, *thumb2; + + thumb1 = scale_thumbnail (bg->placement, + fs1->file, + p1, + screen, + dest_width, + dest_height); + + thumb2 = scale_thumbnail (bg->placement, + fs2->file, + p2, + screen, + dest_width, + dest_height); + + thumb = blend (thumb1, thumb2, alpha); + + g_object_unref (thumb1); + g_object_unref (thumb2); + } + if (p1) + g_object_unref (p1); + if (p2) + g_object_unref (p2); + } + + ensure_timeout (bg, slide); + + slideshow_unref (show); + } + } + + return thumb; + } + + return NULL; +} + +/* + * Find the FileSize that best matches the given size. + * Do two passes; the first pass only considers FileSizes + * that are larger than the given size. + * We are looking for the image that best matches the aspect ratio. + * When two images have the same aspect ratio, prefer the one whose + * width is closer to the given width. + */ +static FileSize * +find_best_size (GSList *sizes, gint width, gint height) +{ + GSList *s; + gdouble a, d, distance; + FileSize *best = NULL; + gint pass; + + a = width/(gdouble)height; + distance = 10000.0; + + for (pass = 0; pass < 2; pass++) { + for (s = sizes; s; s = s->next) { + FileSize *size = s->data; + + if (pass == 0 && (size->width < width || size->height < height)) + continue; + + d = fabs (a - size->width/(gdouble)size->height); + if (d < distance) { + distance = d; + best = size; + } + else if (d == distance) { + if (abs (size->width - width) < abs (best->width - width)) { + best = size; + } + } + } + + if (best) + break; + } + + return best; +} + +static GdkPixbuf * +get_pixbuf_for_size (MateBG *bg, + gint best_width, + gint best_height) +{ + guint time_until_next_change; + gboolean hit_cache = FALSE; + + /* only hit the cache if the aspect ratio matches */ + if (bg->pixbuf_cache) { + int width, height; + width = gdk_pixbuf_get_width (bg->pixbuf_cache); + height = gdk_pixbuf_get_height (bg->pixbuf_cache); + hit_cache = 0.2 > fabs ((best_width / (double)best_height) - (width / (double)height)); + if (!hit_cache) { + g_object_unref (bg->pixbuf_cache); + bg->pixbuf_cache = NULL; + } + } + + if (!hit_cache && bg->filename) { + bg->file_mtime = get_mtime (bg->filename); + + bg->pixbuf_cache = get_as_pixbuf_for_size (bg, bg->filename, best_width, best_height); + time_until_next_change = G_MAXUINT; + if (!bg->pixbuf_cache) { + SlideShow *show = get_as_slideshow (bg, bg->filename); + + if (show) { + double alpha; + Slide *slide; + + slideshow_ref (show); + + slide = get_current_slide (show, &alpha); + time_until_next_change = (guint)get_slide_timeout (slide); + if (slide->fixed) { + FileSize *size; + size = find_best_size (slide->file1, best_width, best_height); + bg->pixbuf_cache = get_as_pixbuf_for_size (bg, size->file, best_width, best_height); + } + else { + FileSize *size; + GdkPixbuf *p1, *p2; + size = find_best_size (slide->file1, best_width, best_height); + p1 = get_as_pixbuf_for_size (bg, size->file, best_width, best_height); + size = find_best_size (slide->file2, best_width, best_height); + p2 = get_as_pixbuf_for_size (bg, size->file, best_width, best_height); + + if (p1 && p2) { + bg->pixbuf_cache = blend (p1, p2, alpha); + } + if (p1) + g_object_unref (p1); + if (p2) + g_object_unref (p2); + } + + ensure_timeout (bg, slide); + + slideshow_unref (show); + } + } + + /* If the next slideshow step is a long time away then + we blow away the expensive stuff (large pixbufs) from + the cache */ + if (time_until_next_change > KEEP_EXPENSIVE_CACHE_SECS) + blow_expensive_caches_in_idle (bg); + } + + if (bg->pixbuf_cache) + g_object_ref (bg->pixbuf_cache); + + return bg->pixbuf_cache; +} + +static gboolean +is_different (MateBG *bg, + const char *filename) +{ + if (!filename && bg->filename) { + return TRUE; + } + else if (filename && !bg->filename) { + return TRUE; + } + else if (!filename && !bg->filename) { + return FALSE; + } + else { + time_t mtime = get_mtime (filename); + + if (mtime != bg->file_mtime) + return TRUE; + + if (strcmp (filename, bg->filename) != 0) + return TRUE; + + return FALSE; + } +} + +static void +clear_cache (MateBG *bg) +{ + GList *list; + + if (bg->file_cache) { + for (list = bg->file_cache; list != NULL; list = list->next) { + FileCacheEntry *ent = list->data; + + file_cache_entry_delete (ent); + } + g_list_free (bg->file_cache); + bg->file_cache = NULL; + } + + if (bg->pixbuf_cache) { + g_object_unref (bg->pixbuf_cache); + + bg->pixbuf_cache = NULL; + } + + if (bg->timeout_id) { + g_source_remove (bg->timeout_id); + + bg->timeout_id = 0; + } +} + +/* Pixbuf utilities */ +static guint32 +pixbuf_average_value (GdkPixbuf *pixbuf) +{ + guint64 a_total, r_total, g_total, b_total; + guint row, column; + int row_stride; + const guchar *pixels, *p; + int r, g, b, a; + guint64 dividend; + guint width, height; + + width = gdk_pixbuf_get_width (pixbuf); + height = gdk_pixbuf_get_height (pixbuf); + row_stride = gdk_pixbuf_get_rowstride (pixbuf); + pixels = gdk_pixbuf_get_pixels (pixbuf); + + /* iterate through the pixbuf, counting up each component */ + a_total = 0; + r_total = 0; + g_total = 0; + b_total = 0; + + if (gdk_pixbuf_get_has_alpha (pixbuf)) { + for (row = 0; row < height; row++) { + p = pixels + (row * row_stride); + for (column = 0; column < width; column++) { + r = *p++; + g = *p++; + b = *p++; + a = *p++; + + a_total += a; + r_total += r * a; + g_total += g * a; + b_total += b * a; + } + } + dividend = height * width * 0xFF; + a_total *= 0xFF; + } else { + for (row = 0; row < height; row++) { + p = pixels + (row * row_stride); + for (column = 0; column < width; column++) { + r = *p++; + g = *p++; + b = *p++; + + r_total += r; + g_total += g; + b_total += b; + } + } + dividend = height * width; + a_total = dividend * 0xFF; + } + + return ((a_total + dividend / 2) / dividend) << 24 + | ((r_total + dividend / 2) / dividend) << 16 + | ((g_total + dividend / 2) / dividend) << 8 + | ((b_total + dividend / 2) / dividend); +} + +static GdkPixbuf * +pixbuf_scale_to_fit (GdkPixbuf *src, int max_width, int max_height) +{ + double factor; + int src_width, src_height; + int new_width, new_height; + + src_width = gdk_pixbuf_get_width (src); + src_height = gdk_pixbuf_get_height (src); + + factor = MIN (max_width / (double) src_width, max_height / (double) src_height); + + new_width = floor (src_width * factor + 0.5); + new_height = floor (src_height * factor + 0.5); + + return gdk_pixbuf_scale_simple (src, new_width, new_height, GDK_INTERP_BILINEAR); +} + +static GdkPixbuf * +pixbuf_scale_to_min (GdkPixbuf *src, int min_width, int min_height) +{ + double factor; + int src_width, src_height; + int new_width, new_height; + GdkPixbuf *dest; + + src_width = gdk_pixbuf_get_width (src); + src_height = gdk_pixbuf_get_height (src); + + factor = MAX (min_width / (double) src_width, min_height / (double) src_height); + + new_width = floor (src_width * factor + 0.5); + new_height = floor (src_height * factor + 0.5); + + dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB, + gdk_pixbuf_get_has_alpha (src), + 8, min_width, min_height); + if (!dest) + return NULL; + + /* crop the result */ + gdk_pixbuf_scale (src, dest, + 0, 0, + min_width, min_height, + (new_width - min_width) / -2, + (new_height - min_height) / -2, + factor, + factor, + GDK_INTERP_BILINEAR); + return dest; +} + +static guchar * +create_gradient (const GdkColor *primary, + const GdkColor *secondary, + int n_pixels) +{ + guchar *result = g_malloc (n_pixels * 3); + int i; + + for (i = 0; i < n_pixels; ++i) { + double ratio = (i + 0.5) / n_pixels; + + result[3 * i + 0] = ((guint16) (primary->red * (1 - ratio) + secondary->red * ratio)) >> 8; + result[3 * i + 1] = ((guint16) (primary->green * (1 - ratio) + secondary->green * ratio)) >> 8; + result[3 * i + 2] = ((guint16) (primary->blue * (1 - ratio) + secondary->blue * ratio)) >> 8; + } + + return result; +} + +static void +pixbuf_draw_gradient (GdkPixbuf *pixbuf, + gboolean horizontal, + GdkColor *primary, + GdkColor *secondary, + GdkRectangle *rect) +{ + int width; + int height; + int rowstride; + guchar *dst; + guchar *dst_limit; + int n_channels = 3; + + rowstride = gdk_pixbuf_get_rowstride (pixbuf); + width = rect->width; + height = rect->height; + dst = gdk_pixbuf_get_pixels (pixbuf) + rect->x * n_channels + rowstride * rect->y; + dst_limit = dst + height * rowstride; + + if (horizontal) { + guchar *gradient = create_gradient (primary, secondary, width); + int copy_bytes_per_row = width * n_channels; + int i; + + for (i = 0; i < height; i++) { + guchar *d; + d = dst + rowstride * i; + memcpy (d, gradient, copy_bytes_per_row); + } + g_free (gradient); + } else { + guchar *gb, *gradient; + int i; + + gradient = create_gradient (primary, secondary, height); + for (i = 0; i < height; i++) { + int j; + guchar *d; + + d = dst + rowstride * i; + gb = gradient + n_channels * i; + for (j = width; j > 0; j--) { + int k; + + for (k = 0; k < n_channels; k++) { + *(d++) = gb[k]; + } + } + } + + g_free (gradient); + } +} + +static void +pixbuf_blend (GdkPixbuf *src, + GdkPixbuf *dest, + int src_x, + int src_y, + int src_width, + int src_height, + int dest_x, + int dest_y, + double alpha) +{ + int dest_width = gdk_pixbuf_get_width (dest); + int dest_height = gdk_pixbuf_get_height (dest); + int offset_x = dest_x - src_x; + int offset_y = dest_y - src_y; + + if (src_width < 0) + src_width = gdk_pixbuf_get_width (src); + + if (src_height < 0) + src_height = gdk_pixbuf_get_height (src); + + if (dest_x < 0) + dest_x = 0; + + if (dest_y < 0) + dest_y = 0; + + if (dest_x + src_width > dest_width) { + src_width = dest_width - dest_x; + } + + if (dest_y + src_height > dest_height) { + src_height = dest_height - dest_y; + } + + gdk_pixbuf_composite (src, dest, + dest_x, dest_y, + src_width, src_height, + offset_x, offset_y, + 1, 1, GDK_INTERP_NEAREST, + alpha * 0xFF + 0.5); +} + +static void +pixbuf_tile (GdkPixbuf *src, GdkPixbuf *dest) +{ + int x, y; + int tile_width, tile_height; + int dest_width = gdk_pixbuf_get_width (dest); + int dest_height = gdk_pixbuf_get_height (dest); + + tile_width = gdk_pixbuf_get_width (src); + tile_height = gdk_pixbuf_get_height (src); + + for (y = 0; y < dest_height; y += tile_height) { + for (x = 0; x < dest_width; x += tile_width) { + pixbuf_blend (src, dest, 0, 0, + tile_width, tile_height, x, y, 1.0); + } + } +} + +static gboolean stack_is (SlideShow *parser, const char *s1, ...); + +/* Parser for fading background */ +static void +handle_start_element (GMarkupParseContext *context, + const gchar *name, + const gchar **attr_names, + const gchar **attr_values, + gpointer user_data, + GError **err) +{ + SlideShow *parser = user_data; + gint i; + + if (strcmp (name, "static") == 0 || strcmp (name, "transition") == 0) { + Slide *slide = g_new0 (Slide, 1); + + if (strcmp (name, "static") == 0) + slide->fixed = TRUE; + + g_queue_push_tail (parser->slides, slide); + } + else if (strcmp (name, "size") == 0) { + Slide *slide = parser->slides->tail->data; + FileSize *size = g_new0 (FileSize, 1); + for (i = 0; attr_names[i]; i++) { + if (strcmp (attr_names[i], "width") == 0) + size->width = atoi (attr_values[i]); + else if (strcmp (attr_names[i], "height") == 0) + size->height = atoi (attr_values[i]); + } + if (parser->stack->tail && + (strcmp (parser->stack->tail->data, "file") == 0 || + strcmp (parser->stack->tail->data, "from") == 0)) { + slide->file1 = g_slist_prepend (slide->file1, size); + } + else if (parser->stack->tail && + strcmp (parser->stack->tail->data, "to") == 0) { + slide->file2 = g_slist_prepend (slide->file2, size); + } + } + g_queue_push_tail (parser->stack, g_strdup (name)); +} + +static void +handle_end_element (GMarkupParseContext *context, + const gchar *name, + gpointer user_data, + GError **err) +{ + SlideShow *parser = user_data; + + g_free (g_queue_pop_tail (parser->stack)); +} + +static gboolean +stack_is (SlideShow *parser, + const char *s1, + ...) +{ + GList *stack = NULL; + const char *s; + GList *l1, *l2; + va_list args; + + stack = g_list_prepend (stack, (gpointer)s1); + + va_start (args, s1); + + s = va_arg (args, const char *); + while (s) { + stack = g_list_prepend (stack, (gpointer)s); + s = va_arg (args, const char *); + } + + l1 = stack; + l2 = parser->stack->head; + + while (l1 && l2) { + if (strcmp (l1->data, l2->data) != 0) { + g_list_free (stack); + return FALSE; + } + + l1 = l1->next; + l2 = l2->next; + } + + g_list_free (stack); + + return (!l1 && !l2); +} + +static int +parse_int (const char *text) +{ + return strtol (text, NULL, 0); +} + +static void +handle_text (GMarkupParseContext *context, + const gchar *text, + gsize text_len, + gpointer user_data, + GError **err) +{ + SlideShow *parser = user_data; + Slide *slide = parser->slides->tail? parser->slides->tail->data : NULL; + FileSize *fs; + gint i; + + if (stack_is (parser, "year", "starttime", "background", NULL)) { + parser->start_tm.tm_year = parse_int (text) - 1900; + } + else if (stack_is (parser, "month", "starttime", "background", NULL)) { + parser->start_tm.tm_mon = parse_int (text) - 1; + } + else if (stack_is (parser, "day", "starttime", "background", NULL)) { + parser->start_tm.tm_mday = parse_int (text); + } + else if (stack_is (parser, "hour", "starttime", "background", NULL)) { + parser->start_tm.tm_hour = parse_int (text) - 1; + } + else if (stack_is (parser, "minute", "starttime", "background", NULL)) { + parser->start_tm.tm_min = parse_int (text); + } + else if (stack_is (parser, "second", "starttime", "background", NULL)) { + parser->start_tm.tm_sec = parse_int (text); + } + else if (stack_is (parser, "duration", "static", "background", NULL) || + stack_is (parser, "duration", "transition", "background", NULL)) { + slide->duration = g_strtod (text, NULL); + parser->total_duration += slide->duration; + } + else if (stack_is (parser, "file", "static", "background", NULL) || + stack_is (parser, "from", "transition", "background", NULL)) { + for (i = 0; text[i]; i++) { + if (!g_ascii_isspace (text[i])) + break; + } + if (text[i] == 0) + return; + fs = g_new (FileSize, 1); + fs->width = -1; + fs->height = -1; + fs->file = g_strdup (text); + slide->file1 = g_slist_prepend (slide->file1, fs); + if (slide->file1->next != NULL) + parser->has_multiple_sizes = TRUE; + } + else if (stack_is (parser, "size", "file", "static", "background", NULL) || + stack_is (parser, "size", "from", "transition", "background", NULL)) { + fs = slide->file1->data; + fs->file = g_strdup (text); + if (slide->file1->next != NULL) + parser->has_multiple_sizes = TRUE; + } + else if (stack_is (parser, "to", "transition", "background", NULL)) { + for (i = 0; text[i]; i++) { + if (!g_ascii_isspace (text[i])) + break; + } + if (text[i] == 0) + return; + fs = g_new (FileSize, 1); + fs->width = -1; + fs->height = -1; + fs->file = g_strdup (text); + slide->file2 = g_slist_prepend (slide->file2, fs); + if (slide->file2->next != NULL) + parser->has_multiple_sizes = TRUE; + } + else if (stack_is (parser, "size", "to", "transition", "background", NULL)) { + fs = slide->file2->data; + fs->file = g_strdup (text); + if (slide->file2->next != NULL) + parser->has_multiple_sizes = TRUE; + } +} + +static SlideShow * +slideshow_ref (SlideShow *show) +{ + show->ref_count++; + return show; +} + +static void +slideshow_unref (SlideShow *show) +{ + GList *list; + GSList *slist; + FileSize *size; + + show->ref_count--; + if (show->ref_count > 0) + return; + + for (list = show->slides->head; list != NULL; list = list->next) { + Slide *slide = list->data; + + for (slist = slide->file1; slist != NULL; slist = slist->next) { + size = slist->data; + g_free (size->file); + g_free (size); + } + g_slist_free (slide->file1); + + for (slist = slide->file2; slist != NULL; slist = slist->next) { + size = slist->data; + g_free (size->file); + g_free (size); + } + g_slist_free (slide->file2); + + g_free (slide); + } + + g_queue_free (show->slides); + + g_list_foreach (show->stack->head, (GFunc) g_free, NULL); + g_queue_free (show->stack); + + g_free (show); +} + +static void +dump_bg (SlideShow *show) +{ +#if 0 + GList *list; + GSList *slist; + + for (list = show->slides->head; list != NULL; list = list->next) + { + Slide *slide = list->data; + + g_print ("\nSlide: %s\n", slide->fixed? "fixed" : "transition"); + g_print ("duration: %f\n", slide->duration); + g_print ("File1:\n"); + for (slist = slide->file1; slist != NULL; slist = slist->next) { + FileSize *size = slist->data; + g_print ("\t%s (%dx%d)\n", + size->file, size->width, size->height); + } + g_print ("File2:\n"); + for (slist = slide->file2; slist != NULL; slist = slist->next) { + FileSize *size = slist->data; + g_print ("\t%s (%dx%d)\n", + size->file, size->width, size->height); + } + } +#endif +} + +static void +threadsafe_localtime (time_t time, struct tm *tm) +{ + struct tm *res; + + G_LOCK_DEFINE_STATIC (localtime_mutex); + + G_LOCK (localtime_mutex); + + res = localtime (&time); + if (tm) { + *tm = *res; + } + + G_UNLOCK (localtime_mutex); +} + +static SlideShow * +read_slideshow_file (const char *filename, + GError **err) +{ + GMarkupParser parser = { + handle_start_element, + handle_end_element, + handle_text, + NULL, /* passthrough */ + NULL, /* error */ + }; + + GFile *file; + char *contents = NULL; + gsize len; + SlideShow *show = NULL; + GMarkupParseContext *context = NULL; + time_t t; + + if (!filename) + return NULL; + + file = g_file_new_for_path (filename); + if (!g_file_load_contents (file, NULL, &contents, &len, NULL, NULL)) { + g_object_unref (file); + return NULL; + } + g_object_unref (file); + + show = g_new0 (SlideShow, 1); + show->ref_count = 1; + threadsafe_localtime ((time_t)0, &show->start_tm); + show->stack = g_queue_new (); + show->slides = g_queue_new (); + + context = g_markup_parse_context_new (&parser, 0, show, NULL); + + if (!g_markup_parse_context_parse (context, contents, len, err)) { + slideshow_unref (show); + show = NULL; + } + + + if (show) { + if (!g_markup_parse_context_end_parse (context, err)) { + slideshow_unref (show); + show = NULL; + } + } + + g_markup_parse_context_free (context); + + if (show) { + t = mktime (&show->start_tm); + + show->start_time = (double)t; + + dump_bg (show); + + /* no slides, that's not a slideshow */ + if (g_queue_get_length (show->slides) == 0) { + slideshow_unref (show); + show = NULL; + } + } + + g_free (contents); + + return show; +} + +/* Thumbnail utilities */ +static GdkPixbuf * +create_thumbnail_for_filename (MateDesktopThumbnailFactory *factory, + const char *filename) +{ + char *thumb; + time_t mtime; + GdkPixbuf *orig, *result = NULL; + char *uri; + + mtime = get_mtime (filename); + + if (mtime == (time_t)-1) + return NULL; + + uri = g_filename_to_uri (filename, NULL, NULL); + + thumb = mate_desktop_thumbnail_factory_lookup (factory, uri, mtime); + + if (thumb) { + result = gdk_pixbuf_new_from_file (thumb, NULL); + g_free (thumb); + } + else { + orig = gdk_pixbuf_new_from_file (filename, NULL); + if (orig) { + int orig_width = gdk_pixbuf_get_width (orig); + int orig_height = gdk_pixbuf_get_height (orig); + + result = pixbuf_scale_to_fit (orig, 128, 128); + + g_object_set_data_full (G_OBJECT (result), "mate-thumbnail-height", + g_strdup_printf ("%d", orig_height), g_free); + g_object_set_data_full (G_OBJECT (result), "mate-thumbnail-width", + g_strdup_printf ("%d", orig_width), g_free); + + g_object_unref (orig); + + mate_desktop_thumbnail_factory_save_thumbnail (factory, result, uri, mtime); + } + else { + mate_desktop_thumbnail_factory_create_failed_thumbnail (factory, uri, mtime); + } + } + + g_free (uri); + + return result; +} + +static gboolean +get_thumb_annotations (GdkPixbuf *thumb, + int *orig_width, + int *orig_height) +{ + char *end; + const char *wstr, *hstr; + + wstr = gdk_pixbuf_get_option (thumb, "tEXt::Thumb::Image::Width"); + hstr = gdk_pixbuf_get_option (thumb, "tEXt::Thumb::Image::Height"); + + if (hstr && wstr) { + *orig_width = strtol (wstr, &end, 10); + if (*end != 0) + return FALSE; + + *orig_height = strtol (hstr, &end, 10); + if (*end != 0) + return FALSE; + + return TRUE; + } + + return FALSE; +} + +static gboolean +slideshow_has_multiple_sizes (SlideShow *show) +{ + return show->has_multiple_sizes; +} + +/* + * Returns whether the background is a slideshow. + */ +gboolean +mate_bg_changes_with_time (MateBG *bg) +{ + SlideShow *show; + + g_return_val_if_fail (bg != NULL, FALSE); + + show = get_as_slideshow (bg, bg->filename); + if (show) + return g_queue_get_length (show->slides) > 1; + + return FALSE; +} + +/* Creates a thumbnail for a certain frame, where 'frame' is somewhat + * vaguely defined as 'suitable point to show while single-stepping + * through the slideshow'. Returns NULL if frame_num is out of bounds. + */ +GdkPixbuf * +mate_bg_create_frame_thumbnail (MateBG *bg, + MateDesktopThumbnailFactory *factory, + GdkScreen *screen, + int dest_width, + int dest_height, + int frame_num) +{ + SlideShow *show; + GdkPixbuf *result; + GdkPixbuf *thumb; + GList *l; + int i, skipped; + gboolean found; + + g_return_val_if_fail (bg != NULL, FALSE); + + show = get_as_slideshow (bg, bg->filename); + + if (!show) + return NULL; + + + if (frame_num < 0 || frame_num >= g_queue_get_length (show->slides)) + return NULL; + + i = 0; + skipped = 0; + found = FALSE; + for (l = show->slides->head; l; l = l->next) { + Slide *slide = l->data; + if (!slide->fixed) { + skipped++; + continue; + } + if (i == frame_num) { + found = TRUE; + break; + } + i++; + } + if (!found) + return NULL; + + + result = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, dest_width, dest_height); + + draw_color (bg, result, screen); + + thumb = create_img_thumbnail (bg, factory, screen, dest_width, dest_height, frame_num + skipped); + + if (thumb) { + draw_image (bg->placement, thumb, result); + g_object_unref (thumb); + } + + return result; +} + |