cafe-bg.c

Bug Summary

File:	libcafe-desktop/cafe-bg.c
Warning:	line 2329, column 42 Access to field 'width' results in a dereference of a null pointer (loaded from variable 'best')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name cafe-bg.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/rootdir/libcafe-desktop -fcoverage-compilation-dir=/rootdir/libcafe-desktop -resource-dir /usr/lib/llvm-19/lib/clang/19 -D HAVE_CONFIG_H -I . -I .. -I /usr/include/gdk-pixbuf-2.0 -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/sysprof-6 -I /usr/include/libpng16 -I /usr/include/x86_64-linux-gnu -I /usr/include/webp -I /usr/include/libmount -I /usr/include/blkid -I /usr/include/ctk-3.0 -I /usr/include/pango-1.0 -I /usr/include/harfbuzz -I /usr/include/freetype2 -I /usr/include/fribidi -I /usr/include/cairo -I /usr/include/pixman-1 -I /usr/include/gio-unix-2.0 -I /usr/include/atk-1.0 -I /usr/include/at-spi2-atk/2.0 -I /usr/include/at-spi-2.0 -I /usr/include/dbus-1.0 -I /usr/lib/x86_64-linux-gnu/dbus-1.0/include -I /usr/include/startup-notification-1.0 -I /usr/include/dconf -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/sysprof-6 -I /usr/include/libmount -I /usr/include/blkid -D G_LOG_DOMAIN="CafeDesktop" -D CAFELOCALEDIR="/usr/share/locale" -D PNP_IDS="/usr/share/libcafe-desktop/pnp.ids" -D ISO_CODES_PREFIX="/usr" -D PIC -internal-isystem /usr/lib/llvm-19/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -analyzer-checker deadcode.DeadStores -analyzer-checker alpha.deadcode.UnreachableCode -analyzer-checker alpha.core.CastSize -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.core.IdenticalExpr -analyzer-checker alpha.security.ArrayBoundV2 -analyzer-checker alpha.security.MallocOverflow -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -analyzer-checker alpha.unix.cstring.NotNullTerminated -analyzer-checker alpha.unix.cstring.OutOfBounds -analyzer-checker alpha.core.FixedAddr -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /rootdir/html-report/2024-12-27-183908-15073-1 -x c cafe-bg.c
1/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*-

3cafebg.c: Object for the desktop background.

5Copyright (C) 2000 Eazel, Inc.
6Copyright (C) 2007-2008 Red Hat, Inc.
7Copyright (C) 2012 Jasmine Hassan <jasmine.aura@gmail.com>

9This program is free software; you can redistribute it and/or
10modify it under the terms of the GNU Library General Public License as
11published by the Free Software Foundation; either version 2 of the
12License, or (at your option) any later version.

14This program is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17Library General Public License for more details.

19You should have received a copy of the GNU Library General Public
20License along with this program; if not, write to the
21Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
22Boston, MA 02110-1301, USA.

24Derived from eel-background.c and eel-gdk-pixbuf-extensions.c by
25Darin Adler <darin@eazel.com> and Ramiro Estrugo <ramiro@eazel.com>

27Authors: Soren Sandmann <sandmann@redhat.com>
Jasmine Hassan <jasmine.aura@gmail.com>

30*/

32#include <string.h>
33#include <math.h>
34#include <stdarg.h>
35#include <stdlib.h>

37#include <glib/gstdio.h>
38#include <gio/gio.h>

40#include <cdk/cdkx.h>
41#include <X11/Xlib.h>
42#include <X11/Xatom.h>

44#include <cairo.h>

46#define CAFE_DESKTOP_USE_UNSTABLE_API
47#include <cafe-bg.h>
48#include <cafe-bg-crossfade.h>

50# include <cairo-xlib.h>

52#define CAFE_BG_CACHE_DIR"cafe/background" "cafe/background"

54/* We keep the large pixbufs around if the next update
 in the slideshow is less than 60 seconds away */
56#define KEEP_EXPENSIVE_CACHE_SECS60 60

58typedef struct _SlideShow SlideShow;
59typedef struct _Slide Slide;

61struct _Slide {
double duration; /* in seconds */
gboolean fixed;

GSList* file1;
GSList* file2; /* NULL if fixed is TRUE */
67};

69typedef struct _FileSize FileSize;
70struct _FileSize {
gint width;
gint height;

char* file;
75};

77/* This is the size of the CdkRGB dither matrix, in order to avoid
* bad dithering when tiling the gradient
*/
80#define GRADIENT_PIXMAP_TILE_SIZE128 128
81#define THUMBNAIL_SIZE256 256

83typedef struct FileCacheEntry FileCacheEntry;
84#define CACHE_SIZE4 4

86/*
*   Implementation of the CafeBG class
*/
89struct _CafeBG {
GObject		 parent_instance;
char		*filename;
CafeBGPlacement	 placement;
CafeBGColorType	 color_type;
CdkRGBA	 	 primary;
CdkRGBA	 	 secondary;
gboolean	 is_enabled;

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;
111};

113struct _CafeBGClass {
GObjectClass parent_class;
115};

117enum {
CHANGED,
TRANSITIONED,
N_SIGNALS
121};

123static guint signals[N_SIGNALS] = {0};

125G_DEFINE_TYPE(CafeBG, cafe_bg, G_TYPE_OBJECT)static void cafe_bg_init (CafeBG *self); static void cafe_bg_class_init
 (CafeBGClass *klass); static GType cafe_bg_get_type_once (void
); static gpointer cafe_bg_parent_class = ((void*)0); static gint
 CafeBG_private_offset; static void cafe_bg_class_intern_init
 (gpointer klass) { cafe_bg_parent_class = g_type_class_peek_parent
 (klass); if (CafeBG_private_offset != 0) g_type_class_adjust_private_offset
 (klass, &CafeBG_private_offset); cafe_bg_class_init ((CafeBGClass
*) klass); } __attribute__ ((__unused__)) static inline gpointer
 cafe_bg_get_instance_private (CafeBG *self) { return (((gpointer
) ((guint8*) (self) + (glong) (CafeBG_private_offset)))); } GType
 cafe_bg_get_type (void) { static GType static_g_define_type_id
 = 0; if ((__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); (void
) (0 ? (gpointer) * (&static_g_define_type_id) : ((void*)
0)); (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
 ((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter_pointer (
&static_g_define_type_id)); })) ) { GType g_define_type_id
 = cafe_bg_get_type_once (); (__extension__ ({ _Static_assert
 (sizeof *(&static_g_define_type_id) == sizeof (gpointer)
, "Expression evaluates to false"); 0 ? (void) (*(&static_g_define_type_id
) = (g_define_type_id)) : (void) 0; g_once_init_leave_pointer
 ((&static_g_define_type_id), (gpointer) (guintptr) (g_define_type_id
)); })) ; } return static_g_define_type_id; } __attribute__ (
(__noinline__)) static GType cafe_bg_get_type_once (void) { GType
 g_define_type_id = g_type_register_static_simple (((GType) (
(20) << (2))), g_intern_static_string ("CafeBG"), sizeof
 (CafeBGClass), (GClassInitFunc)(void (*)(void)) cafe_bg_class_intern_init
, sizeof (CafeBG), (GInstanceInitFunc)(void (*)(void)) cafe_bg_init
, (GTypeFlags) 0); { {{};} } return g_define_type_id; }

127static cairo_surface_t *make_root_pixmap     (CdkWindow  *window,
                                            gint        width,
                                            gint        height);

131/* Pixbuf utils */
132static void       pixbuf_average_value (GdkPixbuf  *pixbuf,
                                      CdkRGBA    *result);
134static GdkPixbuf *pixbuf_scale_to_fit  (GdkPixbuf  *src,
			int         max_width,
			int         max_height);
137static GdkPixbuf *pixbuf_scale_to_min  (GdkPixbuf  *src,
			int         min_width,
			int         min_height);

141static void       pixbuf_draw_gradient (GdkPixbuf    *pixbuf,
			gboolean      horizontal,
			CdkRGBA     *c1,
			CdkRGBA     *c2,
			CdkRectangle *rect);

147static void       pixbuf_tile          (GdkPixbuf  *src,
			GdkPixbuf  *dest);
149static 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);

159/* Thumbnail utilities */
160static GdkPixbuf *create_thumbnail_for_filename (CafeDesktopThumbnailFactory *factory,
				 const char            *filename);
162static gboolean   get_thumb_annotations (GdkPixbuf             *thumb,
			 int                   *orig_width,
			 int                   *orig_height);

166/* Cache */
167static GdkPixbuf *get_pixbuf_for_size  (CafeBG               *bg,
			gint                  num_monitor,
			int                   width,
			int                   height);
171static void       clear_cache          (CafeBG               *bg);
172static gboolean   is_different         (CafeBG               *bg,
			const char            *filename);
174static time_t     get_mtime            (const char            *filename);
175static GdkPixbuf *create_img_thumbnail (CafeBG               *bg,
			CafeDesktopThumbnailFactory *factory,
			CdkScreen             *screen,
			int                    dest_width,
			int                    dest_height,
			int		       frame_num);
181static SlideShow * get_as_slideshow    (CafeBG               *bg,
			const char 	      *filename);
183static Slide *     get_current_slide   (SlideShow 	      *show,
   			double    	      *alpha);
185static gboolean    slideshow_has_multiple_sizes (SlideShow *show);

187static SlideShow *read_slideshow_file (const char *filename,
		       GError     **err);
189static SlideShow *slideshow_ref       (SlideShow  *show);
190static void       slideshow_unref     (SlideShow  *show);

192static FileSize   *find_best_size      (GSList                *sizes,
			gint                   width,
			gint                   height);

196static void
197color_from_string (const char *string,
   CdkRGBA   *colorp)
199{
/* If all else fails use black */
cdk_rgba_parse (colorp, "#000000");

if (!string)
return;

cdk_rgba_parse (colorp, string);
207}

209static char *
210color_to_string (const CdkRGBA *color)
211{
return g_strdup_printf ("#%02x%02x%02x",
		((guint) (color->red * 65535)) >> 8,
		((guint) (color->green * 65535)) >> 8,
		((guint) (color->blue * 65535)) >> 8);
216}

218static gboolean
219do_changed (CafeBG *bg)
220{
bg->changed_id = 0;

g_signal_emit (G_OBJECT (bg)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bg)), (((GType) ((20) << (2)))))))), signals[CHANGED], 0);

return FALSE(0);
226}

228static void
229queue_changed (CafeBG *bg)
230{
if (bg->changed_id > 0) {
g_source_remove (bg->changed_id);
}

bg->changed_id = g_timeout_add_full (G_PRIORITY_LOW300,
			     100,
			     (GSourceFunc)do_changed,
			     bg,
			     NULL((void*)0));
240}

242static gboolean
243do_transitioned (CafeBG *bg)
244{
bg->transitioned_id = 0;

if (bg->pixbuf_cache) {
g_object_unref (bg->pixbuf_cache);
bg->pixbuf_cache = NULL((void*)0);
}

g_signal_emit (G_OBJECT (bg)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bg)), (((GType) ((20) << (2)))))))), signals[TRANSITIONED], 0);

return FALSE(0);
255}

257static void
258queue_transitioned (CafeBG *bg)
259{
if (bg->transitioned_id > 0) {
g_source_remove (bg->transitioned_id);
}

bg->transitioned_id = g_timeout_add_full (G_PRIORITY_LOW300,
				  100,
				  (GSourceFunc)do_transitioned,
				  bg,
				  NULL((void*)0));
269}

271/* This function loads the user's preferences */
272void
273cafe_bg_load_from_preferences (CafeBG *bg)
274{
GSettings *settings;
settings = g_settings_new (CAFE_BG_SCHEMA"org.cafe.background");

cafe_bg_load_from_gsettings (bg, settings);
g_object_unref (settings);

/* Queue change to force background redraw */
queue_changed (bg);
283}

285/* This function loads default system settings */
286void
287cafe_bg_load_from_system_preferences (CafeBG *bg)
288{
GSettings *settings;

/* FIXME: we need to bind system settings instead of user but
* that's currently impossible, not implemented yet.
* Hence, reset to system default values.
*/
settings = g_settings_new (CAFE_BG_SCHEMA"org.cafe.background");

cafe_bg_load_from_system_gsettings (bg, settings, FALSE(0));

g_object_unref (settings);
300}

302/* This function loads (and optionally resets to) default system settings */
303void
304cafe_bg_load_from_system_gsettings (CafeBG    *bg,
		    GSettings *settings,
		    gboolean   reset_apply)
307{
GSettingsSchema *schema;
gchar **keys;
gchar **k;

g_return_if_fail (CAFE_IS_BG (bg))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((bg)); GType __t = ((cafe_bg_get_type ())); gboolean __r;
 if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("CafeDesktop", ((const char
*) (__func__)), "CAFE_IS_BG (bg)"); return; } } while (0);
g_return_if_fail (G_IS_SETTINGS (settings))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((settings)); GType __t = ((g_settings_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("CafeDesktop", ((const char
*) (__func__)), "G_IS_SETTINGS (settings)"); return; } } while
 (0);

g_settings_delay (settings);

g_object_get (settings, "settings-schema", &schema, NULL((void*)0));
keys = g_settings_schema_list_keys (schema);
g_settings_schema_unref (schema);

for (k = keys; *k; k++) {
g_settings_reset (settings, *k);
}
g_strfreev (keys);

if (reset_apply) {
/* Apply changes atomically. */
g_settings_apply (settings);
} else {
cafe_bg_load_from_gsettings (bg, settings);
g_settings_revert (settings);
}
333}

335void
336cafe_bg_load_from_gsettings (CafeBG    *bg,
	     GSettings *settings)
338{
char    *tmp;
char    *filename;
CafeBGColorType ctype;
CdkRGBA c1, c2;
CafeBGPlacement placement;

g_return_if_fail (CAFE_IS_BG (bg))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((bg)); GType __t = ((cafe_bg_get_type ())); gboolean __r;
 if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("CafeDesktop", ((const char
*) (__func__)), "CAFE_IS_BG (bg)"); return; } } while (0);
g_return_if_fail (G_IS_SETTINGS (settings))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((settings)); GType __t = ((g_settings_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("CafeDesktop", ((const char
*) (__func__)), "G_IS_SETTINGS (settings)"); return; } } while
 (0);

bg->is_enabled = g_settings_get_boolean (settings, CAFE_BG_KEY_DRAW_BACKGROUND"draw-background");

/* Filename */
filename = NULL((void*)0);
tmp = g_settings_get_string (settings, CAFE_BG_KEY_PICTURE_FILENAME"picture-filename");
if (tmp && *tmp != '\0') {
/* FIXME: UTF-8 checks should go away.
 * picture-filename is of type string, which can only be used for
 * UTF-8 strings, and some filenames are not, dependending on the
 * locale used.
 * It would be better (and simpler) to change to a URI instead,
 * as URIs are UTF-8 encoded strings.
 */
if (g_utf8_validate (tmp, -1, NULL((void*)0)) &&
    g_file_test (tmp, G_FILE_TEST_EXISTS)) {
	filename = g_strdup (tmp)g_strdup_inline (tmp);
} else {
	filename = g_filename_from_utf8 (tmp, -1, NULL((void*)0), NULL((void*)0), NULL((void*)0));
}

/* Fallback to default BG if the filename set is non-existent */
if (filename != NULL((void*)0) && !g_file_test (filename, G_FILE_TEST_EXISTS)) {

	g_free (filename);

	g_settings_delay (settings);
	g_settings_reset (settings, CAFE_BG_KEY_PICTURE_FILENAME"picture-filename");
	filename = g_settings_get_string (settings, CAFE_BG_KEY_PICTURE_FILENAME"picture-filename");
	g_settings_revert (settings);

	//* Check if default background exists, also */
	if (filename != NULL((void*)0) && !g_file_test (filename, G_FILE_TEST_EXISTS)) {
		g_free (filename);
		filename = NULL((void*)0);
	}
}
}
g_free (tmp);

/* Colors */
tmp = g_settings_get_string (settings, CAFE_BG_KEY_PRIMARY_COLOR"primary-color");
color_from_string (tmp, &c1);
g_free (tmp);

tmp = g_settings_get_string (settings, CAFE_BG_KEY_SECONDARY_COLOR"secondary-color");
color_from_string (tmp, &c2);
g_free (tmp);

/* Color type */
ctype = g_settings_get_enum (settings, CAFE_BG_KEY_COLOR_TYPE"color-shading-type");

/* Placement */
placement = g_settings_get_enum (settings, CAFE_BG_KEY_PICTURE_PLACEMENT"picture-options");

cafe_bg_set_color (bg, ctype, &c1, &c2);
cafe_bg_set_placement (bg, placement);
cafe_bg_set_filename (bg, filename);

if (filename != NULL((void*)0))
g_free (filename);
408}

410void
411cafe_bg_save_to_preferences (CafeBG *bg)
412{
GSettings *settings;
settings = g_settings_new (CAFE_BG_SCHEMA"org.cafe.background");

cafe_bg_save_to_gsettings (bg, settings);
g_object_unref (settings);
418}

420void
421cafe_bg_save_to_gsettings (CafeBG    *bg,
	   GSettings *settings)
423{
gchar *primary;
gchar *secondary;

g_return_if_fail (CAFE_IS_BG (bg))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((bg)); GType __t = ((cafe_bg_get_type ())); gboolean __r;
 if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("CafeDesktop", ((const char
*) (__func__)), "CAFE_IS_BG (bg)"); return; } } while (0);
g_return_if_fail (G_IS_SETTINGS (settings))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((settings)); GType __t = ((g_settings_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("CafeDesktop", ((const char
*) (__func__)), "G_IS_SETTINGS (settings)"); return; } } while
 (0);

primary = color_to_string (&bg->primary);
secondary = color_to_string (&bg->secondary);

g_settings_delay (settings);

g_settings_set_boolean (settings, CAFE_BG_KEY_DRAW_BACKGROUND"draw-background", bg->is_enabled);
g_settings_set_string (settings, CAFE_BG_KEY_PICTURE_FILENAME"picture-filename", bg->filename);
g_settings_set_enum (settings, CAFE_BG_KEY_PICTURE_PLACEMENT"picture-options", bg->placement);
g_settings_set_string (settings, CAFE_BG_KEY_PRIMARY_COLOR"primary-color", primary);
g_settings_set_string (settings, CAFE_BG_KEY_SECONDARY_COLOR"secondary-color", secondary);
g_settings_set_enum (settings, CAFE_BG_KEY_COLOR_TYPE"color-shading-type", bg->color_type);

/* Apply changes atomically. */
g_settings_apply (settings);

g_free (primary);
g_free (secondary);
447}


450static void
451cafe_bg_init (CafeBG *bg G_GNUC_UNUSED__attribute__ ((__unused__)))
452{
453}

455static void
456cafe_bg_dispose (GObject *object)
457{
CafeBG *bg = CAFE_BG (object)((((CafeBG*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((cafe_bg_get_type ()))))));

if (bg->file_monitor) {
g_object_unref (bg->file_monitor);
bg->file_monitor = NULL((void*)0);
}

clear_cache (bg);

G_OBJECT_CLASS (cafe_bg_parent_class)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((cafe_bg_parent_class)), (((GType) ((20) << (2)))))
)))->dispose (object);
468}

470static void
471cafe_bg_finalize (GObject *object)
472{
CafeBG *bg = CAFE_BG (object)((((CafeBG*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((cafe_bg_get_type ()))))));

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;
}

g_free (bg->filename);
bg->filename = NULL((void*)0);

G_OBJECT_CLASS (cafe_bg_parent_class)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((cafe_bg_parent_class)), (((GType) ((20) << (2)))))
)))->finalize (object);
494}

496static void
497cafe_bg_class_init (CafeBGClass *klass)
498{
GObjectClass *object_class = G_OBJECT_CLASS (klass)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((klass)), (((GType) ((20) << (2))))))));

object_class->dispose = cafe_bg_dispose;
object_class->finalize = cafe_bg_finalize;

signals[CHANGED] = g_signal_new ("changed",
			 G_OBJECT_CLASS_TYPE (object_class)((((GTypeClass*) (object_class))->g_type)),
			 G_SIGNAL_RUN_LAST,
			 0,
			 NULL((void*)0), NULL((void*)0),
			 g_cclosure_marshal_VOID__VOID,
			 G_TYPE_NONE((GType) ((1) << (2))), 0);

signals[TRANSITIONED] = g_signal_new ("transitioned",
			 G_OBJECT_CLASS_TYPE (object_class)((((GTypeClass*) (object_class))->g_type)),
			 G_SIGNAL_RUN_LAST,
			 0,
			 NULL((void*)0), NULL((void*)0),
			 g_cclosure_marshal_VOID__VOID,
			 G_TYPE_NONE((GType) ((1) << (2))), 0);
519}

521CafeBG *
522cafe_bg_new (void)
523{
return g_object_new (CAFE_TYPE_BG(cafe_bg_get_type ()), NULL((void*)0));
525}

527void
528cafe_bg_set_color (CafeBG *bg,
    CafeBGColorType type,
    CdkRGBA *primary,
    CdkRGBA *secondary)
532{
g_return_if_fail (bg != NULL)do { if ((bg != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "bg != NULL"); return
; } } while (0);
g_return_if_fail (primary != NULL)do { if ((primary != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "primary != NULL"
); return; } } while (0);

if (bg->color_type != type			||
   !cdk_rgba_equal (&bg->primary, primary)			||
   (secondary && !cdk_rgba_equal (&bg->secondary, secondary))) {
bg->color_type = type;
bg->primary = *primary;
if (secondary) {
	bg->secondary = *secondary;
}

queue_changed (bg);
}
547}

549void
550cafe_bg_set_placement (CafeBG		*bg,
       CafeBGPlacement	 placement)
552{
g_return_if_fail (bg != NULL)do { if ((bg != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "bg != NULL"); return
; } } while (0);

if (bg->placement != placement) {
bg->placement = placement;

queue_changed (bg);
}
560}

562CafeBGPlacement
563cafe_bg_get_placement (CafeBG *bg)
564{
g_return_val_if_fail (bg != NULL, -1)do { if ((bg != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "bg != NULL"); return
 (-1); } } while (0);

return bg->placement;
568}

570void
571cafe_bg_get_color (CafeBG		*bg,
   CafeBGColorType	*type,
   CdkRGBA		*primary,
   CdkRGBA		*secondary)
575{
g_return_if_fail (bg != NULL)do { if ((bg != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "bg != NULL"); return
; } } while (0);

if (type)
*type = bg->color_type;

if (primary)
*primary = bg->primary;

if (secondary)
*secondary = bg->secondary;
586}

588void
589cafe_bg_set_draw_background (CafeBG	*bg,
	     gboolean	 draw_background)
591{
g_return_if_fail (bg != NULL)do { if ((bg != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "bg != NULL"); return
; } } while (0);

if (bg->is_enabled != draw_background) {
bg->is_enabled = draw_background;

queue_changed (bg);
}
599}

601gboolean
602cafe_bg_get_draw_background (CafeBG *bg)
603{
g_return_val_if_fail (bg != NULL, FALSE)do { if ((bg != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "bg != NULL"); return
 ((0)); } } while (0);

return bg->is_enabled;
607}

609const gchar *
610cafe_bg_get_filename (CafeBG *bg)
611{
g_return_val_if_fail (bg != NULL, NULL)do { if ((bg != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "bg != NULL"); return
 (((void*)0)); } } while (0);

return bg->filename;
615}

617static inline gchar *
618get_wallpaper_cache_dir ()
619{
return g_build_filename (g_get_user_cache_dir(), CAFE_BG_CACHE_DIR"cafe/background", NULL((void*)0));
621}

623static inline gchar *
624get_wallpaper_cache_prefix_name (gint                     num_monitor,
		 CafeBGPlacement          placement,
		 gint                     width,
		 gint                     height)
628{
return g_strdup_printf ("%i_%i_%i_%i", num_monitor, (gint) placement, width, height);
630}

632static char *
633get_wallpaper_cache_filename (const char              *filename,
	      gint                     num_monitor,
	      CafeBGPlacement          placement,
	      gint                     width,
	      gint                     height)
638{
gchar *cache_filename;
gchar *cache_prefix_name;
gchar *md5_filename;
gchar *cache_basename;
gchar *cache_dir;

md5_filename = g_compute_checksum_for_data (G_CHECKSUM_MD5, (const guchar *) filename,
				    strlen (filename));
cache_prefix_name = get_wallpaper_cache_prefix_name (num_monitor, placement, width, height);
cache_basename = g_strdup_printf ("%s_%s", cache_prefix_name, md5_filename);
cache_dir = get_wallpaper_cache_dir ();
cache_filename = g_build_filename (cache_dir, cache_basename, NULL((void*)0));

g_free (cache_prefix_name);
g_free (md5_filename);
g_free (cache_basename);
g_free (cache_dir);

return cache_filename;
658}

660static void
661cleanup_cache_for_monitor (gchar *cache_dir,
	   gint   num_monitor)
663{
GDir            *g_cache_dir;
gchar           *monitor_prefix;
const gchar     *file;

g_cache_dir = g_dir_open (cache_dir, 0, NULL((void*)0));
monitor_prefix = g_strdup_printf ("%i_", num_monitor);

file = g_dir_read_name (g_cache_dir);
while (file != NULL((void*)0)) {
gchar *path = g_build_filename (cache_dir, file, NULL((void*)0));

/* purge files with same monitor id */
if (g_str_has_prefix (file, monitor_prefix)(__builtin_constant_p (monitor_prefix)? __extension__ ({ const
 char * const __str = (file); const char * const __prefix = (
monitor_prefix); gboolean __result = (0); if (__str == ((void
*)0) || __prefix == ((void*)0)) __result = (g_str_has_prefix)
 (__str, __prefix); else { const size_t __str_len = strlen ((
(__str) + !(__str))); const size_t __prefix_len = strlen (((__prefix
) + !(__prefix))); if (__str_len >= __prefix_len) __result
 = memcmp (((__str) + !(__str)), ((__prefix) + !(__prefix)), __prefix_len
) == 0; } __result; }) : (g_str_has_prefix) (file, monitor_prefix
) ) &&
    g_file_test (path, G_FILE_TEST_IS_REGULAR))
	g_unlink (path);

g_free (path);

file = g_dir_read_name (g_cache_dir);
}

g_free (monitor_prefix);
g_dir_close (g_cache_dir);
687}

689static gboolean
690cache_file_is_valid (const char *filename,
     const char *cache_filename)
692{
time_t mtime;
time_t cache_mtime;

if (!g_file_test (cache_filename, G_FILE_TEST_IS_REGULAR))
return FALSE(0);

mtime = get_mtime (filename);
cache_mtime = get_mtime (cache_filename);

return (mtime < cache_mtime);
703}

705static void
706refresh_cache_file (CafeBG     *bg,
    GdkPixbuf  *new_pixbuf,
    gint        num_monitor,
    gint        width,
    gint        height)
711{
gchar           *cache_filename;
gchar           *cache_dir;

if ((num_monitor == -1) || (width <= 300) || (height <= 300))
return;

cache_filename = get_wallpaper_cache_filename (bg->filename, num_monitor,
					bg->placement, width, height);
cache_dir = get_wallpaper_cache_dir ();

/* Only refresh scaled file on disk if useful (and don't cache slideshow) */
if (!cache_file_is_valid (bg->filename, cache_filename)) {
GdkPixbufFormat *format;

format = gdk_pixbuf_get_file_info (bg->filename, NULL((void*)0), NULL((void*)0));

if (format != NULL((void*)0)) {
	gchar *format_name;

	if (!g_file_test (cache_dir, G_FILE_TEST_IS_DIR)) {
		g_mkdir_with_parents (cache_dir, 0700);
	} else {
		cleanup_cache_for_monitor (cache_dir, num_monitor);
	}

	format_name = gdk_pixbuf_format_get_name (format);

	if (strcmp (format_name, "jpeg") == 0)
		gdk_pixbuf_save (new_pixbuf, cache_filename, format_name,
				 NULL((void*)0), "quality", "100", NULL((void*)0));
	else
		gdk_pixbuf_save (new_pixbuf, cache_filename, format_name,
				 NULL((void*)0), NULL((void*)0));

	g_free (format_name);
}
}

g_free (cache_filename);
g_free (cache_dir);
752}

754static void
755file_changed (GFileMonitor     *file_monitor G_GNUC_UNUSED__attribute__ ((__unused__)),
     GFile            *child G_GNUC_UNUSED__attribute__ ((__unused__)),
     GFile            *other_file G_GNUC_UNUSED__attribute__ ((__unused__)),
     GFileMonitorEvent event_type G_GNUC_UNUSED__attribute__ ((__unused__)),
     gpointer          user_data)
760{
CafeBG *bg = CAFE_BG (user_data)((((CafeBG*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((user_data)), ((cafe_bg_get_type ()))))));

clear_cache (bg);
queue_changed (bg);
765}

767void
768cafe_bg_set_filename (CafeBG	 *bg,
      const char *filename)
770{
g_return_if_fail (bg != NULL)do { if ((bg != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "bg != NULL"); return
; } } while (0);

if (is_different (bg, filename)) {
g_free (bg->filename);

bg->filename = g_strdup (filename)g_strdup_inline (filename);
bg->file_mtime = get_mtime (bg->filename);

if (bg->file_monitor) {
	g_object_unref (bg->file_monitor);
	bg->file_monitor = NULL((void*)0);
}

if (bg->filename) {
	GFile *f = g_file_new_for_path (bg->filename);

	bg->file_monitor = g_file_monitor_file (f, 0, NULL((void*)0), NULL((void*)0));
	g_signal_connect (bg->file_monitor, "changed",g_signal_connect_data ((bg->file_monitor), ("changed"), ((
(GCallback) (file_changed))), (bg), ((void*)0), (GConnectFlags
) 0)
			  G_CALLBACK (file_changed), bg)g_signal_connect_data ((bg->file_monitor), ("changed"), ((
(GCallback) (file_changed))), (bg), ((void*)0), (GConnectFlags
) 0);

	g_object_unref (f);
}

clear_cache (bg);

queue_changed (bg);
}
798}

800static void
801draw_color_area (CafeBG       *bg,
 GdkPixbuf    *dest,
 CdkRectangle *rect)
804{
guint32 pixel;
CdkRectangle extent;

      extent.x = 0;
      extent.y = 0;
      extent.width = gdk_pixbuf_get_width (dest);
      extent.height = gdk_pixbuf_get_height (dest);

cdk_rectangle_intersect (rect, &extent, rect);

switch (bg->color_type) {
case CAFE_BG_COLOR_SOLID:
/* not really a big deal to ignore the area of interest */
pixel = ((guint) (bg->primary.red * 0xff) << 24)   |
	((guint) (bg->primary.green * 0xff) << 16) |
	((guint) (bg->primary.blue * 0xff) << 8)   |
	(0xff);

gdk_pixbuf_fill (dest, pixel);
break;

case CAFE_BG_COLOR_H_GRADIENT:
pixbuf_draw_gradient (dest, TRUE(!(0)), &(bg->primary), &(bg->secondary), rect);
break;

case CAFE_BG_COLOR_V_GRADIENT:
pixbuf_draw_gradient (dest, FALSE(0), &(bg->primary), &(bg->secondary), rect);
break;

default:
break;
}
837}

839static void
840draw_color (CafeBG    *bg,
   GdkPixbuf *dest)
842{
CdkRectangle 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);
850}

852static void
853draw_color_each_monitor (CafeBG    *bg,
	 GdkPixbuf *dest,
	 CdkScreen *screen)
856{
CdkDisplay *display;
CdkRectangle rect;
gint num_monitors;
int monitor;

display = cdk_screen_get_display (screen);
num_monitors = cdk_display_get_n_monitors (display);
for (monitor = 0; monitor < num_monitors; monitor++) {
cdk_monitor_get_geometry (cdk_display_get_monitor (display, monitor), &rect);
draw_color_area (bg, dest, &rect);
}
868}

870static GdkPixbuf *
871pixbuf_clip_to_fit (GdkPixbuf *src,
    int        max_width,
    int        max_height)
874{
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)((__typeof__ (src)) (g_object_ref) (src));

w = MIN(src_width, max_width)(((src_width) < (max_width)) ? (src_width) : (max_width));
h = MIN(src_height, max_height)(((src_height) < (max_height)) ? (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;
901}

903static GdkPixbuf *
904get_scaled_pixbuf (CafeBGPlacement  placement,
   GdkPixbuf       *pixbuf,
   int width, int height,
   int *x, int *y,
   int *w, int *h)
909{
GdkPixbuf *new;

912#if 0
g_print ("original_width: %d %d\n",
 gdk_pixbuf_get_width (pixbuf),
 gdk_pixbuf_get_height (pixbuf));
916#endif

switch (placement) {
case CAFE_BG_PLACEMENT_SPANNED:
              new = pixbuf_scale_to_fit (pixbuf, width, height);
break;
case CAFE_BG_PLACEMENT_ZOOMED:
new = pixbuf_scale_to_min (pixbuf, width, height);
break;

case CAFE_BG_PLACEMENT_FILL_SCREEN:
new = gdk_pixbuf_scale_simple (pixbuf, width, height,
			       GDK_INTERP_BILINEAR);
break;

case CAFE_BG_PLACEMENT_SCALED:
new = pixbuf_scale_to_fit (pixbuf, width, height);
break;

case CAFE_BG_PLACEMENT_CENTERED:
case CAFE_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;
948}


951static void
952draw_image_area (CafeBG        *bg,
 gint           num_monitor,
 GdkPixbuf     *pixbuf,
 GdkPixbuf     *dest,
 CdkRectangle  *area)
957{
int dest_width = area->width;
int dest_height = area->height;
int x, y, w, h;
GdkPixbuf *scaled;

if (!pixbuf)
return;

scaled = get_scaled_pixbuf (bg->placement, pixbuf, dest_width, dest_height, &x, &y, &w, &h);

switch (bg->placement) {
case CAFE_BG_PLACEMENT_TILED:
pixbuf_tile (scaled, dest);
break;
case CAFE_BG_PLACEMENT_ZOOMED:
case CAFE_BG_PLACEMENT_CENTERED:
case CAFE_BG_PLACEMENT_FILL_SCREEN:
case CAFE_BG_PLACEMENT_SCALED:
pixbuf_blend (scaled, dest, 0, 0, w, h, x + area->x, y + area->y, 1.0);
break;
case CAFE_BG_PLACEMENT_SPANNED:
pixbuf_blend (scaled, dest, 0, 0, w, h, x, y, 1.0);
break;
default:
g_assert_not_reached ()do { g_assertion_message_expr ("CafeDesktop", "cafe-bg.c", 982
, ((const char*) (__func__)), ((void*)0)); } while (0);
break;
}

refresh_cache_file (bg, scaled, num_monitor, dest_width, dest_height);

g_object_unref (scaled);
989}

991static void
992draw_image_for_thumb (CafeBG     *bg,
      GdkPixbuf  *pixbuf,
      GdkPixbuf  *dest)
995{
CdkRectangle rect;

rect.x = 0;
rect.y = 0;
rect.width = gdk_pixbuf_get_width (dest);
rect.height = gdk_pixbuf_get_height (dest);

draw_image_area (bg, -1, pixbuf, dest, &rect);
1004}

1006static void
1007draw_once (CafeBG    *bg,
  GdkPixbuf *dest,
  gboolean   is_root)
1010{
CdkRectangle rect;
GdkPixbuf   *pixbuf;
gint         monitor;

/* whether we're drawing on root window or normal (Baul) window */
monitor = (is_root) ? 0 : -1;

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, monitor, rect.width, rect.height);
if (pixbuf) {
draw_image_area (bg, monitor, pixbuf, dest, &rect);

g_object_unref (pixbuf);
}
1029}

1031static void
1032draw_each_monitor (CafeBG    *bg,
   GdkPixbuf *dest,
   CdkScreen *screen)
1035{
CdkDisplay *display;

display = cdk_screen_get_display (screen);
gint num_monitors = cdk_display_get_n_monitors (display);
gint monitor = 0;

for (; monitor < num_monitors; monitor++) {
CdkRectangle rect;
GdkPixbuf *pixbuf;

cdk_monitor_get_geometry (cdk_display_get_monitor (display, monitor), &rect);

pixbuf = get_pixbuf_for_size (bg, monitor, rect.width, rect.height);
if (pixbuf) {
	draw_image_area (bg, monitor, pixbuf, dest, &rect);

	g_object_unref (pixbuf);
}
}
1055}

1057void
1058cafe_bg_draw (CafeBG     *bg,
      GdkPixbuf *dest,
      CdkScreen *screen,
      gboolean   is_root)
1062{
if (!bg)
return;

if (is_root && (bg->placement != CAFE_BG_PLACEMENT_SPANNED)) {
draw_color_each_monitor (bg, dest, screen);
if (bg->filename) {
	draw_each_monitor (bg, dest, screen);
}
} else {
draw_color (bg, dest);
if (bg->filename) {
	draw_once (bg, dest, is_root);
}
}
1077}

1079gboolean
1080cafe_bg_has_multiple_sizes (CafeBG *bg)
1081{
SlideShow *show;
gboolean ret;

g_return_val_if_fail (bg != NULL, FALSE)do { if ((bg != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "bg != NULL"); return
 ((0)); } } while (0);

ret = FALSE(0);

show = get_as_slideshow (bg, bg->filename);
if (show) {
ret = slideshow_has_multiple_sizes (show);
slideshow_unref (show);
}

return ret;
1096}

1098static void
1099cafe_bg_get_pixmap_size (CafeBG   *bg,
	  int        width,
	  int        height,
	  int       *pixmap_width,
	  int       *pixmap_height)
1104{
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 CAFE_BG_COLOR_SOLID:
	*pixmap_width = 1;
	*pixmap_height = 1;
	break;

case CAFE_BG_COLOR_H_GRADIENT:
case CAFE_BG_COLOR_V_GRADIENT:
	break;
}

return;
}
1129}

1131/**
* cafe_bg_create_surface:
* @bg: CafeBG
* @window:
* @width:
* @height:
* @root:
*
* Create a surface that can be set as background for @window. If @root is
* TRUE, the surface 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.
**/
1144cairo_surface_t *
1145cafe_bg_create_surface (CafeBG      *bg,
 	CdkWindow   *window,
	int	     width,
	int	     height,
	gboolean     root)
1150{
return cafe_bg_create_surface_scale (bg,
			     window,
			     width,
			     height,
			     1,
			     root);
1157}

1159/**
* cafe_bg_create_surface_scale:
* @bg: CafeBG
* @window:
* @width:
* @height:
* @scale:
* @root:
*
* Create a scaled surface that can be set as background for @window. If @root is
* TRUE, the surface 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.
**/
1173cairo_surface_t *
1174cafe_bg_create_surface_scale (CafeBG      *bg,
	      CdkWindow   *window,
	      int          width,
	      int          height,
	      int          scale,
	      gboolean     root)
1180{
int pm_width, pm_height;

cairo_surface_t *surface;
cairo_t *cr;

g_return_val_if_fail (bg != NULL, NULL)do { if ((bg != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "bg != NULL"); return
 (((void*)0)); } } while (0);
g_return_val_if_fail (window != NULL, NULL)do { if ((window != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "window != NULL"
); return (((void*)0)); } } while (0);

if (bg->pixbuf_cache &&
   (gdk_pixbuf_get_width (bg->pixbuf_cache) != width ||
    gdk_pixbuf_get_height (bg->pixbuf_cache) != height))
{
g_object_unref (bg->pixbuf_cache);
bg->pixbuf_cache = NULL((void*)0);
}

cafe_bg_get_pixmap_size (bg, width, height, &pm_width, &pm_height);

if (root)
{
surface = make_root_pixmap (window, pm_width * scale, pm_height * scale);
}
else
{
surface = cdk_window_create_similar_surface (window, CAIRO_CONTENT_COLOR,
					     pm_width, pm_height);
}

cr = cairo_create (surface);
cairo_scale (cr, (double)scale, (double)scale);

if (!bg->filename && bg->color_type == CAFE_BG_COLOR_SOLID) {
cdk_cairo_set_source_rgba (cr, &(bg->primary));
}
else
{
GdkPixbuf *pixbuf;

pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE(0), 8,
			 width, height);
cafe_bg_draw (bg, pixbuf, cdk_window_get_screen (window), root);
cdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
g_object_unref (pixbuf);
}

cairo_paint (cr);

cairo_destroy (cr);

return surface;
1231}


1234/* determine if a background is darker or lighter than average, to help
* clients know what colors to draw on top with
*/
1237gboolean
1238cafe_bg_is_dark (CafeBG *bg,
  int      width,
  int      height)
1241{
CdkRGBA color;
int intensity;
GdkPixbuf *pixbuf;

g_return_val_if_fail (bg != NULL, FALSE)do { if ((bg != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "bg != NULL"); return
 ((0)); } } while (0);

if (bg->color_type == CAFE_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, -1, width, height);
if (pixbuf) {
CdkRGBA argb;
guchar a, r, g, b;

pixbuf_average_value (pixbuf, &argb);
a = argb.alpha * 0xff;
r = argb.red * 0xff;
g = argb.green * 0xff;
b = argb.blue * 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 = ((guint) (color.red * 65535) * 77 +
     (guint) (color.green * 65535) * 150 +
     (guint) (color.blue * 65535) * 28) >> 16;

return intensity < 160; /* biased slightly to be dark */
1277}

1279/*
* Create a persistent pixmap. We create a separate display
* and set the closedown mode on it to RetainPermanent.
*/
1283static cairo_surface_t *
1284make_root_pixmap (CdkWindow *window, gint width, gint height)
1285{
CdkScreen *screen = cdk_window_get_screen(window);
char *disp_name = DisplayString (CDK_WINDOW_XDISPLAY (window))(((_XPrivDisplay)(((cdk_x11_display_get_xdisplay (cdk_window_get_display
 (window))))))->display_name);
Display *display;
Pixmap xpixmap;
cairo_surface_t *surface;
int depth;

/* Desktop background pixmap should be created from dummy X client since most
* applications will try to kill it with XKillClient later when changing pixmap
*/
display = XOpenDisplay (disp_name);

if (display == NULL((void*)0)) {
g_warning ("Unable to open display '%s' when setting background pixmap\n",
           (disp_name) ? disp_name : "NULL");
return NULL((void*)0);
}

depth = DefaultDepth (display, cdk_x11_screen_get_screen_number (screen))((&((_XPrivDisplay)(display))->screens[cdk_x11_screen_get_screen_number
 (screen)])->root_depth);
xpixmap = XCreatePixmap (display, CDK_WINDOW_XID (window)(cdk_x11_window_get_xid (window)), width, height, depth);

XFlush (display);
XSetCloseDownMode (display, RetainPermanent1);
XCloseDisplay (display);

surface = cairo_xlib_surface_create (CDK_SCREEN_XDISPLAY (screen)(cdk_x11_display_get_xdisplay (cdk_screen_get_display (screen
))), xpixmap,
                                           CDK_VISUAL_XVISUAL (cdk_screen_get_system_visual (screen))(cdk_x11_visual_get_xvisual (cdk_screen_get_system_visual (screen
))),
      				     width, height);

return surface;
1316}

1318static gboolean
1319get_original_size (const char *filename,
   int        *orig_width,
   int        *orig_height)
1322{
gboolean result;

      if (gdk_pixbuf_get_file_info (filename, orig_width, orig_height))
result = TRUE(!(0));
else
result = FALSE(0);

return result;
1331}

1333static const char *
1334get_filename_for_size (CafeBG *bg, gint best_width, gint best_height)
1335{
SlideShow *show;
Slide *slide;
FileSize *size;

if (!bg->filename)
return NULL((void*)0);

show = get_as_slideshow (bg, bg->filename);
if (!show) {
return bg->filename;
}

slide = get_current_slide (show, NULL((void*)0));
slideshow_unref (show);
size = find_best_size (slide->file1, best_width, best_height);
return size->file;
1352}

1354gboolean
1355cafe_bg_get_image_size (CafeBG	       *bg,
	 CafeDesktopThumbnailFactory *factory,
	 int                    best_width,
	 int                    best_height,
	 int		       *width,
	 int		       *height)
1361{
GdkPixbuf *thumb;
gboolean result = FALSE(0);
const gchar *filename;

g_return_val_if_fail (bg != NULL, FALSE)do { if ((bg != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "bg != NULL"); return
 ((0)); } } while (0);
g_return_val_if_fail (factory != NULL, FALSE)do { if ((factory != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "factory != NULL"
); return ((0)); } } while (0);

if (!bg->filename)
return FALSE(0);

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(!(0));

g_object_unref (thumb);
}

if (!result) {
if (get_original_size (filename, width, height))
	result = TRUE(!(0));
}

return result;
1387}

1389static double
1390fit_factor (int from_width, int from_height,
   int to_width,   int to_height)
1392{
return MIN (to_width  / (double) from_width, to_height / (double) from_height)(((to_width / (double) from_width) < (to_height / (double)
 from_height)) ? (to_width / (double) from_width) : (to_height
 / (double) from_height));
1394}

1396/**
* cafe_bg_create_thumbnail:
*
* Returns: (transfer full): a #GdkPixbuf showing the background as a thumbnail
*/
1401GdkPixbuf *
1402cafe_bg_create_thumbnail (CafeBG               *bg,
           CafeDesktopThumbnailFactory *factory,
	   CdkScreen             *screen,
	   int                    dest_width,
	   int                    dest_height)
1407{
GdkPixbuf *result;

g_return_val_if_fail (bg != NULL, NULL)do { if ((bg != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "bg != NULL"); return
 (((void*)0)); } } while (0);

result = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE(0), 8, dest_width, dest_height);

draw_color (bg, result);

if (bg->filename) {
GdkPixbuf *thumb;

thumb = create_img_thumbnail (bg, factory, screen, dest_width, dest_height, -1);

if (thumb) {
	draw_image_for_thumb (bg, thumb, result);
	g_object_unref (thumb);
}
}

return result;
1428}

1430/**
* cafe_bg_get_surface_from_root:
* @screen: a #CdkScreen
*
* This function queries the _XROOTPMAP_ID property from
* the root window associated with @screen to determine
* the current root window background surface and returns
* a copy of it. If the _XROOTPMAP_ID is not set, then
* a black surface is returned.
*
* Return value: a #cairo_surface_t if successful or %NULL
**/
1442cairo_surface_t *
1443cafe_bg_get_surface_from_root (CdkScreen *screen)
1444{
int result;
gint format;
gulong nitems;
gulong bytes_after;
guchar *data;
Atom type;
Display *display;
int screen_num;
cairo_surface_t *surface;
cairo_surface_t *source_pixmap;
int width, height;

display = CDK_DISPLAY_XDISPLAY (cdk_screen_get_display (screen))(cdk_x11_display_get_xdisplay (cdk_screen_get_display (screen
)));
screen_num = cdk_x11_screen_get_screen_number (screen);

result = XGetWindowProperty (display,
		     RootWindow (display, screen_num)((&((_XPrivDisplay)(display))->screens[screen_num])->
root),
		     cdk_x11_get_xatom_by_name ("_XROOTPMAP_ID"),
		     0L, 1L, False0, XA_PIXMAP((Atom) 20),
		     &type, &format, &nitems, &bytes_after,
		     &data);
surface = NULL((void*)0);
source_pixmap = NULL((void*)0);

if (result != Success0 || type != XA_PIXMAP((Atom) 20) ||
   format != 32 || nitems != 1) {
XFree (data);
data = NULL((void*)0);
}

if (data != NULL((void*)0)) {
CdkDisplay *cdkdisplay;

cdkdisplay = cdk_screen_get_display (screen);
cdk_x11_display_error_trap_push (cdkdisplay);

Pixmap xpixmap = *(Pixmap *) data;
Window root_return;
int x_ret, y_ret;
unsigned int w_ret, h_ret, bw_ret, depth_ret;

if (XGetGeometry (CDK_SCREEN_XDISPLAY (screen)(cdk_x11_display_get_xdisplay (cdk_screen_get_display (screen
))),
		  xpixmap,
		  &root_return,
		  &x_ret, &y_ret, &w_ret, &h_ret, &bw_ret, &depth_ret))
{
	source_pixmap = cairo_xlib_surface_create (CDK_SCREEN_XDISPLAY (screen)(cdk_x11_display_get_xdisplay (cdk_screen_get_display (screen
))),
						   xpixmap,
						   CDK_VISUAL_XVISUAL (cdk_screen_get_system_visual (screen))(cdk_x11_visual_get_xvisual (cdk_screen_get_system_visual (screen
))),
						   w_ret, h_ret);
}

cdk_x11_display_error_trap_pop_ignored (cdkdisplay);
}

width = WidthOfScreen (cdk_x11_screen_get_xscreen (screen))((cdk_x11_screen_get_xscreen (screen))->width);
height = HeightOfScreen (cdk_x11_screen_get_xscreen (screen))((cdk_x11_screen_get_xscreen (screen))->height);

if (source_pixmap) {
cairo_t *cr;

surface = cairo_surface_create_similar (source_pixmap,
					CAIRO_CONTENT_COLOR,
					width, height);

cr = cairo_create (surface);
cairo_set_source_surface (cr, source_pixmap, 0, 0);
cairo_paint (cr);

if (cairo_status (cr) != CAIRO_STATUS_SUCCESS) {
	cairo_surface_destroy (surface);
	surface = NULL((void*)0);
}

cairo_destroy (cr);
}

if (surface == NULL((void*)0)) {
surface = cdk_window_create_similar_surface (cdk_screen_get_root_window (screen),
					     CAIRO_CONTENT_COLOR,
					     width, height);
}

if (source_pixmap != NULL((void*)0))
cairo_surface_destroy (source_pixmap);

if (data != NULL((void*)0))
XFree (data);

return surface;
1535}

1537/* Sets the "ESETROOT_PMAP_ID" property to later be used to free the pixmap,
*/
1539static void
1540cafe_bg_set_root_pixmap_id (CdkScreen       *screen,
	    Display         *display,
	    Pixmap           xpixmap)
1543{
Window   xroot   = RootWindow (display, cdk_x11_screen_get_screen_number (screen))((&((_XPrivDisplay)(display))->screens[cdk_x11_screen_get_screen_number
 (screen)])->root);
char    *atom_names[] = {"_XROOTPMAP_ID", "ESETROOT_PMAP_ID"};
Atom     atoms[G_N_ELEMENTS(atom_names)(sizeof (atom_names) / sizeof ((atom_names)[0]))] = {0};

Atom     type;
int      format;
unsigned long nitems, after;
unsigned char *data_root, *data_esetroot;

/* Get atoms for both properties in an array, only if they exist.
* This method is to avoid multiple round-trips to Xserver
*/
if (XInternAtoms (display, atom_names, G_N_ELEMENTS(atom_names)(sizeof (atom_names) / sizeof ((atom_names)[0])), True1, atoms) &&
   atoms[0] != None0L && atoms[1] != None0L) {
int result;

result = XGetWindowProperty (display, xroot, atoms[0], 0L, 1L,
                             False0, AnyPropertyType0L,
                             &type, &format, &nitems, &after,
                             &data_root);

if (data_root != NULL((void*)0) && result == Success0 &&
    type == XA_PIXMAP((Atom) 20) && format == 32 && nitems == 1) {
	result = XGetWindowProperty (display, xroot, atoms[1],
	                             0L, 1L, False0,
	                             AnyPropertyType0L,
	                             &type, &format, &nitems,
	                             &after, &data_esetroot);

	if (data_esetroot != NULL((void*)0) && result == Success0 &&
	    type == XA_PIXMAP((Atom) 20) && format == 32 && nitems == 1) {
		CdkDisplay *cdkdisplay;

		Pixmap xrootpmap = *((Pixmap *) data_root);
		Pixmap esetrootpmap = *((Pixmap *) data_esetroot);

		cdkdisplay = cdk_screen_get_display (screen);
		cdk_x11_display_error_trap_push (cdkdisplay);
		if (xrootpmap && xrootpmap == esetrootpmap) {
			XKillClient (display, xrootpmap);
		}
		if (esetrootpmap && esetrootpmap != xrootpmap) {
			XKillClient (display, esetrootpmap);
		}
		cdk_x11_display_error_trap_pop_ignored (cdkdisplay);
	}
	if (data_esetroot != NULL((void*)0)) {
		XFree (data_esetroot);
	}
}
if (data_root != NULL((void*)0)) {
	XFree (data_root);
}
}

/* Get atoms for both properties in an array, create them if needed.
* This method is to avoid multiple round-trips to Xserver
*/
if (!XInternAtoms (display, atom_names, G_N_ELEMENTS(atom_names)(sizeof (atom_names) / sizeof ((atom_names)[0])), False0, atoms) ||
   atoms[0] == None0L || atoms[1] == None0L) {
   g_warning ("Could not create atoms needed to set root pixmap id/properties.\n");
   return;
}

/* Set new _XROOTMAP_ID and ESETROOT_PMAP_ID properties */
XChangeProperty (display, xroot, atoms[0], XA_PIXMAP((Atom) 20), 32,
	 PropModeReplace0, (unsigned char *) &xpixmap, 1);

XChangeProperty (display, xroot, atoms[1], XA_PIXMAP((Atom) 20), 32,
	 PropModeReplace0, (unsigned char *) &xpixmap, 1);
1614}

1616/**
* cafe_bg_set_surface_as_root:
* @screen: the #CdkScreen to change root background on
* @surface: the #cairo_surface_t to set root background from.
*   Must be an xlib surface backing a pixmap.
*
* 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).  @surface should come from a call
* to cafe_bg_create_surface().
**/
1629void
1630cafe_bg_set_surface_as_root (CdkScreen *screen, cairo_surface_t *surface)
1631{
g_return_if_fail (screen != NULL)do { if ((screen != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "screen != NULL"
); return; } } while (0);
g_return_if_fail (cairo_surface_get_type (surface) == CAIRO_SURFACE_TYPE_XLIB)do { if ((cairo_surface_get_type (surface) == CAIRO_SURFACE_TYPE_XLIB
)) { } else { g_return_if_fail_warning ("CafeDesktop", ((const
 char*) (__func__)), "cairo_surface_get_type (surface) == CAIRO_SURFACE_TYPE_XLIB"
); return; } } while (0);

/* Desktop background pixmap should be created from dummy X client since most
* applications will try to kill it with XKillClient later when changing pixmap
*/
Display    *display      = CDK_DISPLAY_XDISPLAY (cdk_screen_get_display (screen))(cdk_x11_display_get_xdisplay (cdk_screen_get_display (screen
)));
Pixmap      pixmap_id    = cairo_xlib_surface_get_drawable (surface);
Window      xroot        = RootWindow (display, cdk_x11_screen_get_screen_number (screen))((&((_XPrivDisplay)(display))->screens[cdk_x11_screen_get_screen_number
 (screen)])->root);

XGrabServer (display);
cafe_bg_set_root_pixmap_id (screen, display, pixmap_id);

XSetWindowBackgroundPixmap (display, xroot, pixmap_id);
XClearWindow (display, xroot);

XFlush (display);
XUngrabServer (display);
1650}

1652/**
* cafe_bg_set_surface_as_root_with_crossfade:
* @screen: the #CdkScreen to change root background on
* @surface: the cairo xlib surface to set root background from
*
* Set the root pixmap, and properties pointing to it.
* This function differs from cafe_bg_set_surface_as_root()
* in that it adds a subtle crossfade animation from the
* current root pixmap to the new one.
*
* Return value: (transfer full): a #CafeBGCrossfade object
**/
1664CafeBGCrossfade *
1665cafe_bg_set_surface_as_root_with_crossfade (CdkScreen       *screen,
 			    cairo_surface_t *surface)
1667{
CdkWindow       *root_window;
int              width, height;
CafeBGCrossfade *fade;
cairo_t         *cr;
cairo_surface_t *old_surface;

g_return_val_if_fail (screen != NULL, NULL)do { if ((screen != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "screen != NULL"
); return (((void*)0)); } } while (0);
g_return_val_if_fail (surface != NULL, NULL)do { if ((surface != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "surface != NULL"
); return (((void*)0)); } } while (0);

root_window = cdk_screen_get_root_window (screen);
width       = cdk_window_get_width (root_window);
height      = cdk_window_get_height (root_window);
fade        = cafe_bg_crossfade_new (width, height);
old_surface = cafe_bg_get_surface_from_root (screen);

cafe_bg_crossfade_set_start_surface (fade, old_surface);
cafe_bg_crossfade_set_end_surface (fade, surface);

/* Before setting the surface as a root pixmap, let's have it draw
* the old stuff, just so it won't be noticable
* (crossfade will later get it back)
*/
cr = cairo_create (surface);
cairo_set_source_surface (cr, old_surface, 0, 0);
cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
cairo_paint (cr);
cairo_destroy (cr);
cairo_surface_destroy (old_surface);

cafe_bg_set_surface_as_root (screen, surface);
cafe_bg_crossfade_start (fade, root_window);

return fade;
1701}

1703/* Implementation of the pixbuf cache */
1704struct _SlideShow
1705{
gint ref_count;
double start_time;
double total_duration;

GQueue *slides;

gboolean has_multiple_sizes;

/* used during parsing */
struct tm start_tm;
GQueue *stack;
1717};

1719static double
1720now (void)
1721{
const double microseconds_per_second = (double) G_USEC_PER_SEC1000000;
gint64 tv;

tv = g_get_real_time ();

return (double) (tv / microseconds_per_second);
1728}

1730static Slide *
1731get_current_slide (SlideShow *show,
   double    *alpha)
1733{
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((void*)0); 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 ()do { g_assertion_message_expr ("CafeDesktop", "cafe-bg.c", 1760
, ((const char*) (__func__)), ((void*)0)); } while (0);

return NULL((void*)0);
1763}

1765static GdkPixbuf *
1766blend (GdkPixbuf *p1,
     GdkPixbuf *p2,
     double alpha)
1769{
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)((__typeof__ (p2)) (g_object_ref) (p2));
}

pixbuf_blend (tmp, result, 0, 0, -1, -1, 0, 0, alpha);

      g_object_unref (tmp);

return result;
1789}

1791typedef	enum {
PIXBUF,
SLIDESHOW,
THUMBNAIL
1795} FileType;

1797struct FileCacheEntry
1798{
FileType type;
char *filename;
union {
GdkPixbuf *pixbuf;
SlideShow *slideshow;
GdkPixbuf *thumbnail;
} u;
1806};

1808static void
1809file_cache_entry_delete (FileCacheEntry *ent)
1810{
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);
1826}

1828static void
1829bound_cache (CafeBG *bg)
1830{
    while (g_list_length (bg->file_cache) >= CACHE_SIZE4) {
     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);
    }
1839}

1841static const FileCacheEntry *
1842file_cache_lookup (CafeBG *bg, FileType type, const char *filename)
1843{
GList *list;

for (list = bg->file_cache; list != NULL((void*)0); list = list->next) {
FileCacheEntry *ent = list->data;

if (ent && ent->type == type &&
    strcmp (ent->filename, filename) == 0) {
	return ent;
}
}

return NULL((void*)0);
1856}

1858static FileCacheEntry *
1859file_cache_entry_new (CafeBG *bg,
      FileType type,
      const char *filename)
1862{
FileCacheEntry *ent = g_new0 (FileCacheEntry, 1)((FileCacheEntry *) g_malloc0_n ((1), sizeof (FileCacheEntry)
));

g_assert (!file_cache_lookup (bg, type, filename))do { if (!file_cache_lookup (bg, type, filename)) ; else g_assertion_message_expr
 ("CafeDesktop", "cafe-bg.c", 1865, ((const char*) (__func__)
), "!file_cache_lookup (bg, type, filename)"); } while (0);

ent->type = type;
ent->filename = g_strdup (filename)g_strdup_inline (filename);

bg->file_cache = g_list_prepend (bg->file_cache, ent);

bound_cache (bg);

return ent;
1875}

1877static void
1878file_cache_add_pixbuf (CafeBG *bg,
       const char *filename,
       GdkPixbuf *pixbuf)
1881{
FileCacheEntry *ent = file_cache_entry_new (bg, PIXBUF, filename);
ent->u.pixbuf = g_object_ref (pixbuf)((__typeof__ (pixbuf)) (g_object_ref) (pixbuf));
1884}

1886static void
1887file_cache_add_thumbnail (CafeBG *bg,
	  const char *filename,
	  GdkPixbuf *pixbuf)
1890{
FileCacheEntry *ent = file_cache_entry_new (bg, THUMBNAIL, filename);
ent->u.thumbnail = g_object_ref (pixbuf)((__typeof__ (pixbuf)) (g_object_ref) (pixbuf));
1893}

1895static void
1896file_cache_add_slide_show (CafeBG *bg,
	   const char *filename,
	   SlideShow *show)
1899{
FileCacheEntry *ent = file_cache_entry_new (bg, SLIDESHOW, filename);
ent->u.slideshow = slideshow_ref (show);
1902}

1904static GdkPixbuf *
1905load_from_cache_file (CafeBG     *bg,
      const char *filename,
      gint        num_monitor,
      gint        best_width,
      gint        best_height)
1910{
GdkPixbuf *pixbuf = NULL((void*)0);
gchar *cache_filename;

cache_filename = get_wallpaper_cache_filename (filename, num_monitor, bg->placement,
					best_width, best_height);

if (cache_file_is_valid (filename, cache_filename))
pixbuf = gdk_pixbuf_new_from_file (cache_filename, NULL((void*)0));

g_free (cache_filename);

return pixbuf;
1923}

1925static GdkPixbuf *
1926get_as_pixbuf_for_size (CafeBG    *bg,
	const char *filename,
	gint         monitor,
	gint         best_width,
	gint         best_height)
1931{
const FileCacheEntry *ent;
if ((ent = file_cache_lookup (bg, PIXBUF, filename))) {
return g_object_ref (ent->u.pixbuf)((__typeof__ (ent->u.pixbuf)) (g_object_ref) (ent->u.pixbuf
));
} else {
GdkPixbuf *pixbuf = NULL((void*)0);
gchar *tmp = NULL((void*)0);
GdkPixbuf *tmp_pixbuf;

/* Try to hit local cache first if relevant */
if (monitor != -1)
	pixbuf = load_from_cache_file (bg, filename, monitor,
					best_width, best_height);

if (!pixbuf) {
	GdkPixbufFormat *format;

	/* If scalable choose maximum size */
	format = gdk_pixbuf_get_file_info (filename, NULL((void*)0), NULL((void*)0));
	if (format != NULL((void*)0))
		tmp = gdk_pixbuf_format_get_name (format);

	if (g_strcmp0 (tmp, "svg") == 0 &&
	    (best_width > 0 && best_height > 0) &&
	    (bg->placement == CAFE_BG_PLACEMENT_FILL_SCREEN ||
	     bg->placement == CAFE_BG_PLACEMENT_SCALED ||
	     bg->placement == CAFE_BG_PLACEMENT_ZOOMED))
	{
		pixbuf = gdk_pixbuf_new_from_file_at_size (filename,
							   best_width,
							   best_height, NULL((void*)0));
	} else {
		pixbuf = gdk_pixbuf_new_from_file (filename, NULL((void*)0));
	}

	if (tmp != NULL((void*)0))
		g_free (tmp);
}

if (pixbuf) {
	tmp_pixbuf = gdk_pixbuf_apply_embedded_orientation (pixbuf);
	g_object_unref (pixbuf);
	pixbuf = tmp_pixbuf;
	file_cache_add_pixbuf (bg, filename, pixbuf);
}

return pixbuf;
}
1979}

1981static SlideShow *
1982get_as_slideshow (CafeBG *bg, const char *filename)
1983{
const FileCacheEntry *ent;
if ((ent = file_cache_lookup (bg, SLIDESHOW, filename))) {
5
←
Assuming 'ent' is null→
6
←
Taking false branch→
46
←
Assuming 'ent' is non-null→
47
←
Taking true branch→
return slideshow_ref (ent->u.slideshow);
48
←
Returning pointer, which participates in a condition later→
}
else {
SlideShow *show = read_slideshow_file (filename, NULL((void*)0));
7
←
Calling 'read_slideshow_file'→
22
←
Returning from 'read_slideshow_file'→

if (show22.1
'show' is non-null
)
23
←
Taking true branch→
	file_cache_add_slide_show (bg, filename, show);

return show;
}
1996}

1998static GdkPixbuf *
1999get_as_thumbnail (CafeBG *bg, CafeDesktopThumbnailFactory *factory, const char *filename)
2000{
const FileCacheEntry *ent;
if ((ent = file_cache_lookup (bg, THUMBNAIL, filename))) {
39
←
Assuming 'ent' is non-null→
40
←
Taking true branch→
return g_object_ref (ent->u.thumbnail)((__typeof__ (ent->u.thumbnail)) (g_object_ref) (ent->u
.thumbnail));
41
←
Returning pointer, which participates in a condition later→
}
else {
GdkPixbuf *thumb = create_thumbnail_for_filename (factory, filename);

if (thumb)
	file_cache_add_thumbnail (bg, filename, thumb);

return thumb;
}
2013}

2015static gboolean
2016blow_expensive_caches (gpointer data)
2017{
CafeBG *bg = data;
GList *list;

bg->blow_caches_id = 0;

if (bg->file_cache) {
for (list = bg->file_cache; list != NULL((void*)0); list = list->next) {
	FileCacheEntry *ent = list->data;

	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((void*)0);
}

return FALSE(0);
2041}

2043static void
2044blow_expensive_caches_in_idle (CafeBG *bg)
2045{
if (bg->blow_caches_id == 0) {
bg->blow_caches_id =
	g_idle_add (blow_expensive_caches,
		    bg);
}
2051}


2054static gboolean
2055on_timeout (gpointer data)
2056{
CafeBG *bg = data;

bg->timeout_id = 0;

queue_transitioned (bg);

return FALSE(0);
2064}

2066static double
2067get_slide_timeout (Slide   *slide)
2068{
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;
2088}

2090static void
2091ensure_timeout (CafeBG *bg,
Slide   *slide)
2093{
if (!bg->timeout_id) {
double timeout = get_slide_timeout (slide);

/* G_MAXUINT means "only one slide" */
if (timeout < G_MAXUINT(2147483647 *2U +1U)) {
	bg->timeout_id = g_timeout_add_full (
		G_PRIORITY_LOW300,
		timeout * 1000, on_timeout, bg, NULL((void*)0));
}

}
2105}

2107static time_t
2108get_mtime (const char *filename)
2109{
time_t     mtime;

mtime = (time_t)-1;

if (filename) {
GFile     *file;
GFileInfo *info;

file = g_file_new_for_path (filename);
info = g_file_query_info (file, G_FILE_ATTRIBUTE_TIME_MODIFIED"time::modified",
			  G_FILE_QUERY_INFO_NONE, NULL((void*)0), NULL((void*)0));
if (info) {
	mtime = g_file_info_get_attribute_uint64 (info,
						  G_FILE_ATTRIBUTE_TIME_MODIFIED"time::modified");
	g_object_unref (info);
}
g_object_unref (file);
}

return mtime;
2130}

2132static GdkPixbuf *
2133scale_thumbnail (CafeBGPlacement placement,
 const char *filename,
 GdkPixbuf *thumb,
 CdkScreen *screen,
 int	    dest_width,
 int	    dest_height)
2139{
int o_width;
int o_height;

if (placement != CAFE_BG_PLACEMENT_TILED &&
   placement != CAFE_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)((__typeof__ (thumb)) (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 = HeightOfScreen (cdk_x11_screen_get_xscreen (screen))((cdk_x11_screen_get_xscreen (screen))->height);
int scr_width = WidthOfScreen (cdk_x11_screen_get_xscreen (screen))((cdk_x11_screen_get_xscreen (screen))->width);
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 == CAFE_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)((__typeof__ (thumb)) (g_object_ref) (thumb));

return thumb;
2192}

2194/* frame_num determines which slide to thumbnail.
* -1 means 'current slide'.
*/
2197static GdkPixbuf *
2198create_img_thumbnail (CafeBG                      *bg,
      CafeDesktopThumbnailFactory *factory,
      CdkScreen                    *screen,
      int                           dest_width,
      int                           dest_height,
      int                           frame_num)
2204{
if (bg->filename36.1
Field 'filename' is non-null
) {
37
←
Taking true branch→
GdkPixbuf *thumb;

thumb = get_as_thumbnail (bg, factory, bg->filename);
38
←
Calling 'get_as_thumbnail'→
42
←
Returning from 'get_as_thumbnail'→

if (thumb) {
43
←
Assuming 'thumb' is null→
44
←
Taking false branch→
	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);
45
←
Calling 'get_as_slideshow'→
49
←
Returning from 'get_as_slideshow'→

	if (show49.1
'show' is non-null
) {
50
←
Taking true branch→
		double alpha;
		Slide *slide;

		if (frame_num == -1)
51
←
Taking false branch→
			slide = get_current_slide (show, &alpha);
		else
			slide = g_queue_peek_nth (show->slides, frame_num);

		if (slide->fixed) {
52
←
Assuming field 'fixed' is not equal to 0→
53
←
Taking true branch→
			GdkPixbuf *tmp;
			FileSize *fs;
			fs = find_best_size (slide->file1, dest_width, dest_height);
54
←
Calling 'find_best_size'→
			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((void*)0);
2295}

2297/*
* 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.
*/
2305static FileSize *
2306find_best_size (GSList *sizes, gint width, gint height)
2307{
GSList *s;
gdouble a, d, distance;
FileSize *best = NULL((void*)0);
55
←
'best' initialized to a null pointer value→
gint pass;

a = width/(gdouble)height;
distance = 10000.0;

for (pass = 0; pass < 2; pass++) {
56
←
Loop condition is true.  Entering loop body→
for (s = sizes; s; s = s->next) {
57
←
Loop condition is true.  Entering loop body→
	FileSize *size = s->data;

	if (pass57.1
'pass' is equal to 0
 == 0 && (size->width < width || size->height < height))
58
←
Assuming 'width' is <= field 'width'→
59
←
Assuming 'height' is <= field 'height'→
60
←
Taking false branch→
		continue;

	d = fabs (a - size->width/(gdouble)size->height);
	if (d < distance) {
61
←
Assuming 'd' is >= 'distance'→
62
←
Taking false branch→
		distance = d;
		best = size;
	}
	else if (d == distance) {
63
←
Assuming 'd' is equal to 'distance'→
64
←
Taking true branch→
		if (abs (size->width - width) < abs (best->width - width)) {
65
←
Access to field 'width' results in a dereference of a null pointer (loaded from variable 'best')
			best = size;
		}
	}
}

if (best)
	break;
}

return best;
2340}

2342static GdkPixbuf *
2343get_pixbuf_for_size (CafeBG *bg,
     gint monitor,
     gint best_width,
     gint best_height)
2347{
guint time_until_next_change;
gboolean hit_cache = FALSE(0);

/* 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((void*)0);
}
}

if (!hit_cache && bg->filename) {
bg->file_mtime = get_mtime (bg->filename);

bg->pixbuf_cache = get_as_pixbuf_for_size (bg, bg->filename, monitor,
					   best_width, best_height);
time_until_next_change = G_MAXUINT(2147483647 *2U +1U);
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 = find_best_size (slide->file1,
							 best_width, best_height);
			bg->pixbuf_cache =
				get_as_pixbuf_for_size (bg, size->file, monitor,
							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, monitor,
						     best_width, best_height);

			size = find_best_size (slide->file2,
						best_width, best_height);
			p2 = get_as_pixbuf_for_size (bg, size->file, monitor,
						     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_SECS60)
    blow_expensive_caches_in_idle (bg);
}

if (bg->pixbuf_cache)
g_object_ref (bg->pixbuf_cache)((__typeof__ (bg->pixbuf_cache)) (g_object_ref) (bg->pixbuf_cache
));

return bg->pixbuf_cache;
2425}

2427static gboolean
2428is_different (CafeBG    *bg,
     const char *filename)
2430{
if (!filename && bg->filename) {
return TRUE(!(0));
}
else if (filename && !bg->filename) {
return TRUE(!(0));
}
else if (!filename && !bg->filename) {
return FALSE(0);
}
else {
time_t mtime = get_mtime (filename);

if (mtime != bg->file_mtime)
	return TRUE(!(0));

if (strcmp (filename, bg->filename) != 0)
	return TRUE(!(0));

return FALSE(0);
}
2451}

2453static void
2454clear_cache (CafeBG *bg)
2455{
GList *list;

if (bg->file_cache) {
for (list = bg->file_cache; list != NULL((void*)0); list = list->next) {
	FileCacheEntry *ent = list->data;

	file_cache_entry_delete (ent);
}
g_list_free (bg->file_cache);
bg->file_cache = NULL((void*)0);
}

if (bg->pixbuf_cache) {
g_object_unref (bg->pixbuf_cache);

bg->pixbuf_cache = NULL((void*)0);
}

if (bg->timeout_id) {
g_source_remove (bg->timeout_id);

bg->timeout_id = 0;
}
2479}

2481/* Pixbuf utilities */
2482static void
2483pixbuf_average_value (GdkPixbuf *pixbuf,
                    CdkRGBA   *result)
2485{
guint64 a_total, r_total, g_total, b_total;
guint row, column;
int row_stride;
const guchar *pixels, *p;
int r, g, b;
guint64 dividend;
guint width, height;
gdouble dd;

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++) {
		int a;

		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;
}

dd = dividend * 0xFF;
result->alpha = a_total / dd;
result->red = r_total / dd;
result->green = g_total / dd;
result->blue = b_total / dd;
2547}

2549static GdkPixbuf *
2550pixbuf_scale_to_fit (GdkPixbuf *src, int max_width, int max_height)
2551{
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)(((max_width / (double) src_width) < (max_height / (double
) src_height)) ? (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);
2565}

2567static GdkPixbuf *
2568pixbuf_scale_to_min (GdkPixbuf *src, int min_width, int min_height)
2569{
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)(((min_width / (double) src_width) > (min_height / (double
) src_height)) ? (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((void*)0);

/* 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;
2599}

2601static guchar *
2602create_gradient (const CdkRGBA *primary,
 const CdkRGBA *secondary,
 int	         n_pixels)
2605{
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] = (guchar) ((primary->red * (1 - ratio) + secondary->red * ratio) * 0x100);
result[3 * i + 1] = (guchar) ((primary->green * (1 - ratio) + secondary->green * ratio) * 0x100);
result[3 * i + 2] = (guchar) ((primary->blue * (1 - ratio) + secondary->blue * ratio) * 0x100);
}

return result;
2618}

2620static void
2621pixbuf_draw_gradient (GdkPixbuf    *pixbuf,
      gboolean      horizontal,
      CdkRGBA      *primary,
      CdkRGBA      *secondary,
      CdkRectangle *rect)
2626{
int width;
int height;
int rowstride;
guchar *dst;
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;

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);
}
2671}

2673static void
2674pixbuf_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)
2683{
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);
2715}

2717static void
2718pixbuf_tile (GdkPixbuf *src, GdkPixbuf *dest)
2719{
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);
}
}
2734}

2736static gboolean stack_is (SlideShow *parser, const char *s1, ...);

2738/* Parser for fading background */
2739static void
2740handle_start_element (GMarkupParseContext *context G_GNUC_UNUSED__attribute__ ((__unused__)),
      const gchar         *name,
      const gchar        **attr_names,
      const gchar        **attr_values,
      gpointer             user_data,
      GError             **err G_GNUC_UNUSED__attribute__ ((__unused__)))
2746{
SlideShow *parser = user_data;
gint i;

if (strcmp (name, "static") == 0 || strcmp (name, "transition") == 0) {
Slide *slide = g_new0 (Slide, 1)((Slide *) g_malloc0_n ((1), sizeof (Slide)));

if (strcmp (name, "static") == 0)
	slide->fixed = TRUE(!(0));

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)((FileSize *) g_malloc0_n ((1), sizeof (FileSize)));
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);
}
else
	g_free (size);
}
g_queue_push_tail (parser->stack, g_strdup (name)g_strdup_inline (name));
2780}

2782static void
2783handle_end_element (GMarkupParseContext *context G_GNUC_UNUSED__attribute__ ((__unused__)),
    const gchar         *name G_GNUC_UNUSED__attribute__ ((__unused__)),
    gpointer             user_data,
    GError             **err G_GNUC_UNUSED__attribute__ ((__unused__)))
2787{
SlideShow *parser = user_data;

g_free (g_queue_pop_tail (parser->stack));
2791}

2793static gboolean
2794stack_is (SlideShow *parser,
 const char *s1,
 ...)
2797{
GList *stack = NULL((void*)0);
const char *s;
GList *l1, *l2;
va_list args;

stack = g_list_prepend (stack, (gpointer)s1);

va_start (args, s1)__builtin_va_start(args, s1);

s = va_arg (args, const char *)__builtin_va_arg(args, const char *);
while (s) {
stack = g_list_prepend (stack, (gpointer)s);
s = va_arg (args, const char *)__builtin_va_arg(args, const char *);
}

va_end (args)__builtin_va_end(args);

l1 = stack;
l2 = parser->stack->head;

while (l1 && l2) {
if (strcmp (l1->data, l2->data) != 0) {
	g_list_free (stack);
	return FALSE(0);
}

l1 = l1->next;
l2 = l2->next;
}

g_list_free (stack);

return (!l1 && !l2);
2831}

2833static int
2834parse_int (const char *text)
2835{
return strtol (text, NULL((void*)0), 0);
2837}

2839static void
2840handle_text (GMarkupParseContext *context G_GNUC_UNUSED__attribute__ ((__unused__)),
    const gchar         *text,
    gsize                text_len G_GNUC_UNUSED__attribute__ ((__unused__)),
    gpointer             user_data,
    GError             **err G_GNUC_UNUSED__attribute__ ((__unused__)))
2845{
SlideShow *parser = user_data;
FileSize *fs;
gint i;

g_return_if_fail (parser != NULL)do { if ((parser != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "parser != NULL"
); return; } } while (0);
g_return_if_fail (parser->slides != NULL)do { if ((parser->slides != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "parser->slides != NULL"
); return; } } while (0);

Slide *slide = parser->slides->tail ? parser->slides->tail->data : NULL((void*)0);

if (stack_is (parser, "year", "starttime", "background", NULL((void*)0))) {
parser->start_tm.tm_year = parse_int (text) - 1900;
}
else if (stack_is (parser, "month", "starttime", "background", NULL((void*)0))) {
parser->start_tm.tm_mon = parse_int (text) - 1;
}
else if (stack_is (parser, "day", "starttime", "background", NULL((void*)0))) {
parser->start_tm.tm_mday = parse_int (text);
}
else if (stack_is (parser, "hour", "starttime", "background", NULL((void*)0))) {
parser->start_tm.tm_hour = parse_int (text) - 1;
}
else if (stack_is (parser, "minute", "starttime", "background", NULL((void*)0))) {
parser->start_tm.tm_min = parse_int (text);
}
else if (stack_is (parser, "second", "starttime", "background", NULL((void*)0))) {
parser->start_tm.tm_sec = parse_int (text);
}
else if (stack_is (parser, "duration", "static", "background", NULL((void*)0)) ||
 stack_is (parser, "duration", "transition", "background", NULL((void*)0))) {
g_return_if_fail (slide != NULL)do { if ((slide != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "slide != NULL")
; return; } } while (0);

slide->duration = g_strtod (text, NULL((void*)0));
parser->total_duration += slide->duration;
}
else if (stack_is (parser, "file", "static", "background", NULL((void*)0)) ||
 stack_is (parser, "from", "transition", "background", NULL((void*)0))) {
g_return_if_fail (slide != NULL)do { if ((slide != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "slide != NULL")
; return; } } while (0);

for (i = 0; text[i]; i++) {
	if (!g_ascii_isspace (text[i])((g_ascii_table[(guchar) (text[i])] & G_ASCII_SPACE) != 0
))
		break;
}
if (text[i] == 0)
	return;
fs = g_new (FileSize, 1)((FileSize *) g_malloc_n ((1), sizeof (FileSize)));
fs->width = -1;
fs->height = -1;
fs->file = g_strdup (text)g_strdup_inline (text);
slide->file1 = g_slist_prepend (slide->file1, fs);
if (slide->file1->next != NULL((void*)0))
	parser->has_multiple_sizes = TRUE(!(0));
}
else if (stack_is (parser, "size", "file", "static", "background", NULL((void*)0)) ||
 stack_is (parser, "size", "from", "transition", "background", NULL((void*)0))) {
g_return_if_fail (slide != NULL)do { if ((slide != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "slide != NULL")
; return; } } while (0);

fs = slide->file1->data;
fs->file = g_strdup (text)g_strdup_inline (text);
if (slide->file1->next != NULL((void*)0))
	parser->has_multiple_sizes = TRUE(!(0));
}
else if (stack_is (parser, "to", "transition", "background", NULL((void*)0))) {
g_return_if_fail (slide != NULL)do { if ((slide != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "slide != NULL")
; return; } } while (0);

for (i = 0; text[i]; i++) {
	if (!g_ascii_isspace (text[i])((g_ascii_table[(guchar) (text[i])] & G_ASCII_SPACE) != 0
))
		break;
}
if (text[i] == 0)
	return;
fs = g_new (FileSize, 1)((FileSize *) g_malloc_n ((1), sizeof (FileSize)));
fs->width = -1;
fs->height = -1;
fs->file = g_strdup (text)g_strdup_inline (text);
slide->file2 = g_slist_prepend (slide->file2, fs);
if (slide->file2->next != NULL((void*)0))
	parser->has_multiple_sizes = TRUE(!(0));
}
else if (stack_is (parser, "size", "to", "transition", "background", NULL((void*)0))) {
g_return_if_fail (slide != NULL)do { if ((slide != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "slide != NULL")
; return; } } while (0);

fs = slide->file2->data;
fs->file = g_strdup (text)g_strdup_inline (text);
if (slide->file2->next != NULL((void*)0))
	parser->has_multiple_sizes = TRUE(!(0));
}
2932}

2934static SlideShow *
2935slideshow_ref (SlideShow *show)
2936{
show->ref_count++;
return show;
2939}

2941static void
2942slideshow_unref (SlideShow *show)
2943{
GList *list;
GSList *slist;
FileSize *size;

show->ref_count--;
if (show->ref_count > 0)
return;

for (list = show->slides->head; list != NULL((void*)0); list = list->next) {
Slide *slide = list->data;

for (slist = slide->file1; slist != NULL((void*)0); slist = slist->next) {
	size = slist->data;
	g_free (size->file);
	g_free (size);
}
g_slist_free (slide->file1);

for (slist = slide->file2; slist != NULL((void*)0); 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((void*)0));
g_queue_free (show->stack);

g_free (show);
2978}

2980static void
2981dump_bg (SlideShow *show G_GNUC_UNUSED__attribute__ ((__unused__)))
2982{
2983#if 0
GList *list;
GSList *slist;

for (list = show->slides->head; list != NULL((void*)0); 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((void*)0); 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((void*)0); slist = slist->next) {
	FileSize *size = slist->data;
	g_print ("\t%s (%dx%d)\n",
		 size->file, size->width, size->height);
}
}
3006#endif
3007}

3009static void
3010threadsafe_localtime (time_t time, struct tm *tm)
3011{
struct tm *res;

G_LOCK_DEFINE_STATIC (localtime_mutex)static GMutex g__localtime_mutex_lock;

G_LOCK (localtime_mutex)g_mutex_lock (&g__localtime_mutex_lock);

res = localtime (&time);
if (tm) {
*tm = *res;
}

G_UNLOCK (localtime_mutex)g_mutex_unlock (&g__localtime_mutex_lock);
3024}

3026static SlideShow *
3027read_slideshow_file (const char *filename,
     GError     **err)
3029{
GMarkupParser parser = {
handle_start_element,
handle_end_element,
handle_text,
NULL((void*)0), /* passthrough */
NULL((void*)0), /* error */
};

GFile *file;
char *contents = NULL((void*)0);
gsize len;
SlideShow *show = NULL((void*)0);
GMarkupParseContext *context = NULL((void*)0);

if (!filename)
8
←
Assuming 'filename' is non-null→
9
←
Taking false branch→
return NULL((void*)0);

file = g_file_new_for_path (filename);
if (!g_file_load_contents (file, NULL((void*)0), &contents, &len, NULL((void*)0), NULL((void*)0))) {
10
←
Assuming the condition is false→
11
←
Taking false branch→
g_object_unref (file);
return NULL((void*)0);
}
g_object_unref (file);

show = g_new0 (SlideShow, 1)((SlideShow *) g_malloc0_n ((1), sizeof (SlideShow)));
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((void*)0));

if (!g_markup_parse_context_parse (context, contents, len, err)) {
12
←
Assuming the condition is false→
13
←
Taking false branch→
slideshow_unref (show);
show = NULL((void*)0);
}


if (show13.1
'show' is non-null
) {
14
←
Taking true branch→
if (!g_markup_parse_context_end_parse (context, err)) {
15
←
Assuming the condition is false→
16
←
Taking false branch→
	slideshow_unref (show);
	show = NULL((void*)0);
}
}

g_markup_parse_context_free (context);

if (show16.1
'show' is non-null
) {
17
←
Taking true branch→
time_t t;
int len;

t = mktime (&show->start_tm);

show->start_time = (double)t;

dump_bg (show);

len = g_queue_get_length (show->slides);

/* no slides, that's not a slideshow */
if (len == 0) {
18
←
Assuming 'len' is not equal to 0→
19
←
Taking false branch→
	slideshow_unref (show);
	show = NULL((void*)0);
/* one slide, there's no transition */
} else if (len == 1) {
20
←
Assuming 'len' is not equal to 1→
21
←
Taking false branch→
	Slide *slide = show->slides->head->data;
	slide->duration = show->total_duration = G_MAXUINT(2147483647 *2U +1U);
}
}

g_free (contents);

return show;
3103}

3105/* Thumbnail utilities */
3106static GdkPixbuf *
3107create_thumbnail_for_filename (CafeDesktopThumbnailFactory *factory,
	       const char            *filename)
3109{
char *thumb;
time_t mtime;
GdkPixbuf *result = NULL((void*)0);
char *uri;

mtime = get_mtime (filename);

if (mtime == (time_t)-1)
return NULL((void*)0);

uri = g_filename_to_uri (filename, NULL((void*)0), NULL((void*)0));

if (uri == NULL((void*)0))
return NULL((void*)0);

thumb = cafe_desktop_thumbnail_factory_lookup (factory, uri, mtime);

if (thumb) {
result = gdk_pixbuf_new_from_file (thumb, NULL((void*)0));
g_free (thumb);
}
else {
GdkPixbuf *orig;

orig = gdk_pixbuf_new_from_file (filename, NULL((void*)0));
if (orig) {
	int orig_width = gdk_pixbuf_get_width (orig);
	int orig_height = gdk_pixbuf_get_height (orig);

	result = pixbuf_scale_to_fit (orig, THUMBNAIL_SIZE256, THUMBNAIL_SIZE256);


	g_object_set_data_full (G_OBJECT (result)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((result)), (((GType) ((20) << (2)))))))), "cafe-thumbnail-height",
				g_strdup_printf ("%d", orig_height), g_free);
	g_object_set_data_full (G_OBJECT (result)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((result)), (((GType) ((20) << (2)))))))), "cafe-thumbnail-width",
				g_strdup_printf ("%d", orig_width), g_free);

	g_object_unref (orig);

	cafe_desktop_thumbnail_factory_save_thumbnail (factory, result, uri, mtime);
}
else {
	cafe_desktop_thumbnail_factory_create_failed_thumbnail (factory, uri, mtime);
}
}

g_free (uri);

return result;
3159}

3161static gboolean
3162get_thumb_annotations (GdkPixbuf *thumb,
       int	 *orig_width,
       int	 *orig_height)
3165{
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(0);

*orig_height = strtol (hstr, &end, 10);
if (*end != 0)
	return FALSE(0);

return TRUE(!(0));
}

return FALSE(0);
3185}

3187static gboolean
3188slideshow_has_multiple_sizes (SlideShow *show)
3189{
return show->has_multiple_sizes;
3191}

3193/*
* Returns whether the background is a slideshow.
*/
3196gboolean
3197cafe_bg_changes_with_time (CafeBG *bg)
3198{
SlideShow *show;

g_return_val_if_fail (bg != NULL, FALSE)do { if ((bg != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "bg != NULL"); return
 ((0)); } } while (0);

if (!bg->filename)
return FALSE(0);

show = get_as_slideshow (bg, bg->filename);
if (show)
return g_queue_get_length (show->slides) > 1;

return FALSE(0);
3211}

3213/**
* cafe_bg_create_frame_thumbnail:
*
* 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: (transfer full): the newly created thumbnail or
* or NULL if frame_num is out of bounds.
*/
3223GdkPixbuf *
3224cafe_bg_create_frame_thumbnail (CafeBG			*bg,
		 CafeDesktopThumbnailFactory	*factory,
		 CdkScreen			*screen,
		 int				 dest_width,
		 int				 dest_height,
		 int				 frame_num)
3230{
SlideShow *show;
GdkPixbuf *result;
      GList *l;
      int i, skipped;
      gboolean found;

g_return_val_if_fail (bg != NULL, FALSE)do { if ((bg != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "bg != NULL"); return
 ((0)); } } while (0);
1
Assuming 'bg' is not equal to null→
2
←
Taking true branch→
3
←
Loop condition is false.  Exiting loop→

show = get_as_slideshow (bg, bg->filename);
4
←
Calling 'get_as_slideshow'→
24
←
Returning from 'get_as_slideshow'→

if (!show24.1
'show' is non-null
)
return NULL((void*)0);


if (frame_num < 0 || frame_num >= g_queue_get_length (show->slides))
25
←
Assuming 'frame_num' is >= 0→
26
←
Assuming the condition is false→
27
←
Taking false branch→
return NULL((void*)0);

i = 0;
skipped = 0;
found = FALSE(0);
for (l = show->slides->head; l; l = l->next) {
28
←
Loop condition is true.  Entering loop body→
Slide *slide = l->data;
if (!slide->fixed) {
29
←
Assuming field 'fixed' is not equal to 0→
30
←
Taking false branch→
	skipped++;
	continue;
}
if (i == frame_num) {
31
←
Assuming 'i' is equal to 'frame_num'→
32
←
Taking true branch→
	found = TRUE(!(0));
	break;
}
i++;
}
if (!found33.1
'found' is 1
)
33
←
 Execution continues on line 3263→
34
←
Taking false branch→
return NULL((void*)0);


result = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE(0), 8, dest_width, dest_height);

draw_color (bg, result);

if (bg->filename34.1
Field 'filename' is non-null
) {
35
←
Taking true branch→
GdkPixbuf *thumb;

thumb = create_img_thumbnail (bg, factory, screen,
36
←
Calling 'create_img_thumbnail'→
			      dest_width, dest_height,
			      frame_num + skipped);

if (thumb) {
	draw_image_for_thumb (bg, thumb, result);
	g_object_unref (thumb);
}
}

return result;
3285}
