first commit

1 files changed, 1001 insertions, 0 deletions

diff --git a/savers/gste-slideshow.c.orig b/savers/gste-slideshow.c.orig
new file mode 100644
index 0000000..8ea83bd
--- /dev/null
+++ b/savers/gste-slideshow.c.orig
@@ -0,0 +1,1001 @@
+/* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 8; tab-width: 8 -*-
+ *
+ * Copyright (C) 2005-2006 William Jon McCann <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ */
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+
+#include <glib.h>
+#include <gtk/gtk.h>
+
+#include "gs-theme-engine.h"
+#include "gste-slideshow.h"
+
+static void     gste_slideshow_class_init (GSTESlideshowClass *klass);
+static void     gste_slideshow_init       (GSTESlideshow      *engine);
+static void     gste_slideshow_finalize   (GObject            *object);
+
+struct GSTESlideshowPrivate
+{
+        /* Image at full opacity */
+        cairo_pattern_t *pat1;
+        /* Image at partial opacity */
+        cairo_pattern_t *pat2;
+        /* Alpha of pat2 */
+        gdouble          alpha2;
+        /* edges of pat2 */
+        int              pat2top;
+        int              pat2bottom;
+        int              pat2left;
+        int              pat2right;
+
+        /* backbuffer that we do all the alpha drawing into (no round
+         * trips to the X server when the server doesn't support drawing
+         * pixmaps with alpha?) */
+        cairo_surface_t *surf;
+
+        gint64           fade_ticks;
+
+        GThread         *load_thread;
+        GAsyncQueue     *op_q;
+        GAsyncQueue     *results_q;
+
+        guint           results_pull_id;
+        guint           update_image_id;
+
+        GSList         *filename_list;
+        char           *images_location;
+        gboolean        sort_images;
+        int             window_width;
+        int             window_height;
+        PangoColor     *background_color;
+        gboolean        no_stretch_hint;
+
+        guint           timeout_id;
+
+        GTimer         *timer;
+        gboolean        fade_disabled;
+};
+
+enum {
+        PROP_0,
+        PROP_IMAGES_LOCATION,
+        PROP_SORT_IMAGES,
+        PROP_SOLID_BACKGROUND,
+        PROP_NO_STRETCH_HINT
+};
+
+#define GSTE_SLIDESHOW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GSTE_TYPE_SLIDESHOW, GSTESlideshowPrivate))
+
+static GObjectClass *parent_class = NULL;
+
+G_DEFINE_TYPE (GSTESlideshow, gste_slideshow, GS_TYPE_THEME_ENGINE)
+
+#define N_FADE_TICKS 10
+#define MINIMUM_FPS 3.0
+#define DEFAULT_IMAGES_LOCATION DATADIR "/pixmaps/backgrounds"
+#define IMAGE_LOAD_TIMEOUT 10000
+
+typedef struct _Op
+{
+        char          *location;
+        GSTESlideshow *slideshow;
+} Op;
+
+typedef struct _OpResult
+{
+        GdkPixbuf *pixbuf;
+} OpResult;
+
+static gboolean
+push_load_image_func (GSTESlideshow *show)
+{
+        Op *op;
+
+        gs_theme_engine_profile_msg ("Starting a new image load");
+
+        op = g_new (Op, 1);
+
+        op->location = g_strdup (show->priv->images_location);
+        op->slideshow = g_object_ref (show);
+
+        g_async_queue_push (show->priv->op_q, op);
+
+        show->priv->update_image_id = 0;
+
+        return FALSE;
+}
+
+static void
+start_new_load (GSTESlideshow *show,
+                guint          timeout)
+{
+        gs_theme_engine_profile_msg ("Scheduling a new image load");
+
+        /* queue a new load */
+        if (show->priv->update_image_id <= 0) {
+                show->priv->update_image_id = g_timeout_add_full (G_PRIORITY_LOW, timeout,
+                                                                  (GSourceFunc)push_load_image_func,
+                                                                  show, NULL);
+        }
+}
+
+static void
+start_fade (GSTESlideshow *show,
+            GdkPixbuf     *pixbuf)
+{
+        int      pw;
+        int      ph;
+        int      x;
+        int      y;
+        cairo_t *cr;
+        int      window_width;
+        int      window_height;
+
+        gs_theme_engine_profile_start ("start");
+
+        window_width = show->priv->window_width;
+        window_height = show->priv->window_height;
+
+        if (show->priv->pat2 != NULL) {
+                cairo_pattern_destroy (show->priv->pat2);
+        }
+
+        pw = gdk_pixbuf_get_width (pixbuf);
+        ph = gdk_pixbuf_get_height (pixbuf);
+        x = (window_width - pw) / 2;
+        y = (window_height - ph) / 2;
+
+        if (gdk_pixbuf_get_has_alpha (pixbuf) && show->priv->background_color) {
+                GdkPixbuf *colored;
+                guint32    color;
+                GdkPixmap *pixmap;
+
+                color = (show->priv->background_color->red << 16)
+                        + (show->priv->background_color->green / 256 << 8)
+                        + show->priv->background_color->blue / 256;
+                colored = gdk_pixbuf_composite_color_simple (pixbuf,
+                                                             pw, ph,
+                                                             GDK_INTERP_BILINEAR,
+                                                             255,
+                                                             256,
+                                                             color,
+                                                             color);
+                pixmap = gdk_pixmap_new (NULL, ph, pw,  gdk_visual_get_system ()->depth);
+
+                gdk_draw_pixbuf (pixmap, NULL, colored, 0, 0, 0, 0, -1, -1, GDK_RGB_DITHER_MAX, 0, 0);
+                gdk_pixbuf_get_from_drawable (pixbuf, pixmap, NULL, 0, 0, 0, 0, -1, -1);
+
+                g_object_unref (pixmap);
+
+                g_object_unref(colored);
+        }
+
+        cr = cairo_create (show->priv->surf);
+
+        /* XXX Handle out of memory? */
+        gdk_cairo_set_source_pixbuf (cr, pixbuf, x, y);
+        show->priv->pat2 = cairo_pattern_reference (cairo_get_source (cr));
+        show->priv->pat2top = y;
+        show->priv->pat2bottom = y + ph;
+        show->priv->pat2left = x;
+        show->priv->pat2right = x + pw;
+
+        cairo_destroy (cr);
+
+        show->priv->fade_ticks = 0;
+        g_timer_start (show->priv->timer);
+
+        gs_theme_engine_profile_end ("end");
+}
+
+static void
+finish_fade (GSTESlideshow *show)
+{
+        gs_theme_engine_profile_start ("start");
+
+        if (show->priv->pat1 != NULL) {
+                cairo_pattern_destroy (show->priv->pat1);
+        }
+
+        show->priv->pat1 = show->priv->pat2;
+        show->priv->pat2 = NULL;
+
+        start_new_load (show, IMAGE_LOAD_TIMEOUT);
+
+        gs_theme_engine_profile_end ("end");
+}
+
+static void
+update_display (GSTESlideshow *show)
+{
+        int      window_width;
+        int      window_height;
+        cairo_t *cr;
+
+        gs_theme_engine_profile_start ("start");
+
+        cr = cairo_create (show->priv->surf);
+
+        gs_theme_engine_get_window_size (GS_THEME_ENGINE (show),
+                                         &window_width,
+                                         &window_height);
+
+        if (show->priv->pat2 != NULL) {
+                /* fade out areas not covered by the new image */
+                /* top */
+                cairo_rectangle (cr, 0, 0, window_width, show->priv->pat2top);
+                if (show->priv->background_color) {
+                        cairo_set_source_rgba (cr, show->priv->background_color->red / 65535.0,
+                               show->priv->background_color->green / 65535.0,
+                               show->priv->background_color->blue / 65535.0, show->priv->alpha2);
+                } else {
+                        cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, show->priv->alpha2);
+                }
+                cairo_fill (cr);
+                /* left (excluding what's covered by top and bottom) */
+                cairo_rectangle (cr, 0, show->priv->pat2top,
+                                 show->priv->pat2left,
+                                 show->priv->pat2bottom - show->priv->pat2top);
+                if (show->priv->background_color) {
+                        cairo_set_source_rgba (cr, show->priv->background_color->red / 65535.0,
+                               show->priv->background_color->green / 65535.0,
+                               show->priv->background_color->blue / 65535.0, show->priv->alpha2);
+                } else {
+                        cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, show->priv->alpha2);
+                }
+                cairo_fill (cr);
+                /* bottom */
+                cairo_rectangle (cr, 0, show->priv->pat2bottom, window_width,
+                                 window_height - show->priv->pat2bottom);
+                if (show->priv->background_color) {
+                        cairo_set_source_rgba (cr, show->priv->background_color->red / 65535.0,
+                               show->priv->background_color->green / 65535.0,
+                               show->priv->background_color->blue / 65535.0, show->priv->alpha2);
+                } else {
+                        cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, show->priv->alpha2);
+                }
+                cairo_fill (cr);
+                /* right (excluding what's covered by top and bottom) */
+                cairo_rectangle (cr, show->priv->pat2right,
+                                 show->priv->pat2top,
+                                 window_width - show->priv->pat2right,
+                                 show->priv->pat2bottom - show->priv->pat2top);
+                if (show->priv->background_color)  {
+                        cairo_set_source_rgba (cr, show->priv->background_color->red / 65535.0,
+                               show->priv->background_color->green / 65535.0,
+                               show->priv->background_color->blue / 65535.0, show->priv->alpha2);
+                } else {
+                        cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, show->priv->alpha2);
+                }
+                cairo_fill (cr);
+
+                gs_theme_engine_profile_start ("paint pattern to surface");
+                cairo_set_source (cr, show->priv->pat2);
+
+                cairo_paint_with_alpha (cr, show->priv->alpha2);
+                gs_theme_engine_profile_end ("paint pattern to surface");
+        } else {
+                if (show->priv->pat1 != NULL) {
+                        cairo_set_source (cr, show->priv->pat1);
+                        cairo_paint (cr);
+                }
+        }
+
+        cairo_destroy (cr);
+
+        /* paint the image buffer into the window */
+        cr = gdk_cairo_create (GTK_WIDGET (show)->window);
+
+        cairo_set_source_surface (cr, show->priv->surf, 0, 0);
+
+        gs_theme_engine_profile_start ("paint surface to window");
+        cairo_paint (cr);
+        gs_theme_engine_profile_end ("paint surface to window");
+
+        cairo_destroy (cr);
+
+        gs_theme_engine_profile_end ("end");
+}
+
+static gboolean
+draw_iter (GSTESlideshow *show)
+{
+        double old_opacity;
+        double new_opacity;
+
+        if (show->priv->pat2 != NULL) {
+                gdouble fps;
+                gdouble elapsed;
+
+                if (show->priv->fade_disabled) {
+                        show->priv->alpha2 = 1.0;
+                        update_display (show);
+                        finish_fade (show);
+                        return TRUE;
+                }
+
+                /* we are in a fade */
+                show->priv->fade_ticks++;
+
+                /*
+                 * We have currently drawn pat2 with old_opacity, and we
+                 * want to set alpha2 so that drawing pat2 at alpha2
+                 * yields it drawn with new_opacity
+                 *
+                 * Solving
+                 *   new_opacity = 1 - (1 - alpha2) * (1 - old_opacity)
+                 * yields
+                 *   alpha2 = 1 - (1 - new_opacity) / (1 - old_opacity)
+                 *
+                 * XXX This assumes that cairo doesn't correct alpha for
+                 * the color profile.  However, any error is guaranteed
+                 * to be cleaned up by the last iteration, where alpha2
+                 * becomes 1 because new_opacity is 1.
+                 */
+                old_opacity = (double) (show->priv->fade_ticks - 1) /
+                              (double) N_FADE_TICKS;
+                new_opacity = (double) show->priv->fade_ticks /
+                              (double) N_FADE_TICKS;
+                show->priv->alpha2 = 1.0 - (1.0 - new_opacity) /
+                                           (1.0 - old_opacity);
+
+                update_display (show);
+
+                elapsed = g_timer_elapsed (show->priv->timer, NULL);
+                fps = (gdouble)show->priv->fade_ticks / elapsed;
+                if (fps < MINIMUM_FPS) {
+                        g_warning ("Getting less than %.2f frames per second, disabling fade", MINIMUM_FPS);
+                        show->priv->fade_ticks = N_FADE_TICKS - 1;
+                        show->priv->fade_disabled = TRUE;
+                }
+
+                if (show->priv->fade_ticks >= N_FADE_TICKS) {
+                        finish_fade (show);
+                }
+        }
+
+        return TRUE;
+}
+
+static void
+process_new_pixbuf (GSTESlideshow *show,
+                    GdkPixbuf     *pixbuf)
+{
+        gs_theme_engine_profile_msg ("Processing a new image");
+
+        if (pixbuf != NULL) {
+                start_fade (show, pixbuf);
+        } else {
+                start_new_load (show, 10);
+        }
+}
+
+static void
+op_result_free (OpResult *result)
+{
+        if (result == NULL) {
+                return;
+        }
+
+        if (result->pixbuf != NULL) {
+                g_object_unref (result->pixbuf);
+        }
+
+        g_free (result);
+}
+
+static gboolean
+results_pull_func (GSTESlideshow *show)
+{
+        OpResult *result;
+
+        GDK_THREADS_ENTER ();
+
+        g_async_queue_lock (show->priv->results_q);
+
+        result = g_async_queue_try_pop_unlocked (show->priv->results_q);
+        g_assert (result);
+
+        while (result != NULL) {
+                process_new_pixbuf (show, result->pixbuf);
+                op_result_free (result);
+
+                result = g_async_queue_try_pop_unlocked (show->priv->results_q);
+        }
+
+        show->priv->results_pull_id = 0;
+
+        g_async_queue_unlock (show->priv->results_q);
+
+        GDK_THREADS_LEAVE ();
+
+        return FALSE;
+}
+
+static GdkPixbuf *
+scale_pixbuf (GdkPixbuf *pixbuf,
+              int        max_width,
+              int        max_height,
+              gboolean   no_stretch_hint)
+{
+        int        pw;
+        int        ph;
+        float      scale_factor_x = 1.0;
+        float      scale_factor_y = 1.0;
+        float      scale_factor = 1.0;
+
+        pw = gdk_pixbuf_get_width (pixbuf);
+        ph = gdk_pixbuf_get_height (pixbuf);
+
+        /* If the image is less than 256 wide or high then it
+           is probably a thumbnail and we should ignore it */
+        if (pw < 256 || ph < 256) {
+                return NULL;
+        }
+
+        /* Determine which dimension requires the smallest scale. */
+        scale_factor_x = (float) max_width / (float) pw;
+        scale_factor_y = (float) max_height / (float) ph;
+
+        if (scale_factor_x > scale_factor_y) {
+                scale_factor = scale_factor_y;
+        } else {
+                scale_factor = scale_factor_x;
+        }
+
+        /* always scale down, allow to disable scaling up */
+        if (scale_factor < 1.0 || !no_stretch_hint) {
+                int scale_x;
+                int scale_y;
+
+                scale_x = (int) (pw * scale_factor);
+                scale_y = (int) (ph * scale_factor);
+                return gdk_pixbuf_scale_simple (pixbuf,
+                                                scale_x,
+                                                scale_y,
+                                                GDK_INTERP_BILINEAR);
+        } else {
+                return g_object_ref (pixbuf);
+        }
+}
+
+static void
+add_files_to_list (GSList    **list,
+                   const char *base)
+{
+        GDir       *d;
+        const char *d_name;
+
+        d = g_dir_open (base, 0, NULL);
+        if (d == NULL) {
+                g_warning ("Could not open directory: %s", base);
+                return;
+        }
+
+        while ((d_name = g_dir_read_name (d)) != NULL) {
+                char *path;
+
+                /* skip hidden files */
+                if (d_name[0] == '.') {
+                        continue;
+                }
+
+                path = g_build_filename (base, d_name, NULL);
+                if (g_file_test (path, G_FILE_TEST_IS_DIR)) {
+                        add_files_to_list (list, path);
+                        g_free (path);
+                } else {
+                        *list = g_slist_prepend (*list, path);
+                }
+        }
+
+        g_dir_close (d);
+}
+
+static GSList *
+build_filename_list_local_dir (const char *base)
+{
+        GSList *list = NULL;
+
+        add_files_to_list (&list, base);
+
+        return list;
+}
+
+static int
+gste_strcmp_compare_func (gconstpointer string_a, gconstpointer string_b)
+{
+        return strcmp (string_a == NULL ? "" : string_a,
+                       string_b == NULL ? "" : string_b);
+}
+
+
+static GdkPixbuf *
+get_pixbuf_from_local_dir (GSTESlideshow *show,
+                           const char    *location)
+{
+        GdkPixbuf *pixbuf, *transformed_pixbuf;
+        char      *filename;
+        int        i;
+        GSList    *l;
+
+        /* rebuild the cache */
+        if (show->priv->filename_list == NULL) {
+                show->priv->filename_list = build_filename_list_local_dir (location);
+        }
+
+        if (show->priv->filename_list == NULL) {
+                return NULL;
+        } else {
+                if (show->priv->sort_images) {
+                        show->priv->filename_list = g_slist_sort (show->priv->filename_list, gste_strcmp_compare_func);
+                }
+        }
+
+        /* get a random filename if needed */
+        if (! show->priv->sort_images) {
+                i = g_random_int_range (0, g_slist_length (show->priv->filename_list));
+                l = g_slist_nth (show->priv->filename_list, i);
+        } else {
+                l = show->priv->filename_list;
+        }
+        filename = l->data;
+
+        pixbuf = gdk_pixbuf_new_from_file (filename, NULL);
+
+        if (pixbuf != NULL) {
+                transformed_pixbuf = gdk_pixbuf_apply_embedded_orientation (pixbuf);
+                g_object_unref (pixbuf);
+        } else {
+                transformed_pixbuf = NULL;
+        }
+
+        g_free (filename);
+        show->priv->filename_list = g_slist_delete_link (show->priv->filename_list, l);
+
+        return transformed_pixbuf;
+}
+
+static GdkPixbuf *
+get_pixbuf_from_location (GSTESlideshow *show,
+                          const char    *location)
+{
+        GdkPixbuf *pixbuf = NULL;
+        gboolean   is_dir;
+
+        if (location == NULL) {
+                return NULL;
+        }
+
+        is_dir = g_file_test (location, G_FILE_TEST_IS_DIR);
+
+        if (is_dir) {
+                pixbuf = get_pixbuf_from_local_dir (show, location);
+        }
+
+        return pixbuf;
+}
+
+static GdkPixbuf *
+get_pixbuf (GSTESlideshow *show,
+            const char    *location,
+            int            width,
+            int            height)
+{
+        GdkPixbuf *pixbuf;
+        GdkPixbuf *scaled = NULL;
+
+        if (location == NULL) {
+                return NULL;
+        }
+
+        pixbuf = get_pixbuf_from_location (show, location);
+
+        if (pixbuf != NULL) {
+                scaled = scale_pixbuf (pixbuf, width, height, show->priv->no_stretch_hint);
+                g_object_unref (pixbuf);
+        }
+
+        return scaled;
+}
+
+static void
+op_load_image (GSTESlideshow *show,
+               const char    *location)
+{
+        OpResult *op_result;
+        int       window_width;
+        int       window_height;
+
+        window_width = show->priv->window_width;
+        window_height = show->priv->window_height;
+
+        op_result = g_new0 (OpResult, 1);
+
+        op_result->pixbuf = get_pixbuf (show,
+                                        location,
+                                        window_width,
+                                        window_height);
+
+        GDK_THREADS_ENTER ();
+        g_async_queue_lock (show->priv->results_q);
+        g_async_queue_push_unlocked (show->priv->results_q, op_result);
+
+        if (show->priv->results_pull_id == 0) {
+                show->priv->results_pull_id = g_idle_add_full (G_PRIORITY_HIGH_IDLE,
+                                                               (GSourceFunc)results_pull_func,
+                                                               show, NULL);
+        }
+
+        g_async_queue_unlock (show->priv->results_q);
+        GDK_THREADS_LEAVE ();
+}
+
+static gpointer
+load_threadfunc (GAsyncQueue *op_q)
+{
+        Op *op;
+
+        op = g_async_queue_pop (op_q);
+        while (op) {
+                op_load_image (op->slideshow,
+                               op->location);
+
+                if (op->slideshow != NULL) {
+                        g_object_unref (op->slideshow);
+                }
+                g_free (op->location);
+                g_free (op);
+
+                op = g_async_queue_pop (op_q);
+        }
+
+        return NULL;
+}
+
+void
+gste_slideshow_set_images_location (GSTESlideshow *show,
+                                    const char    *location)
+{
+        g_return_if_fail (GSTE_IS_SLIDESHOW (show));
+
+        g_free (show->priv->images_location);
+        show->priv->images_location = g_strdup (location);
+}
+
+
+void
+gste_slideshow_set_sort_images (GSTESlideshow *show,
+                                gboolean       sort_images)
+{
+        g_return_if_fail (GSTE_IS_SLIDESHOW (show));
+
+        show->priv->sort_images = sort_images;
+}
+
+void
+gste_slideshow_set_no_stretch_hint (GSTESlideshow *show,
+                                     gboolean       no_stretch_hint)
+{
+        g_return_if_fail (GSTE_IS_SLIDESHOW (show));
+
+        show->priv->no_stretch_hint = no_stretch_hint;
+}
+
+void
+gste_slideshow_set_background_color (GSTESlideshow *show,
+                                     const char    *background_color)
+{
+        g_return_if_fail (GSTE_IS_SLIDESHOW (show));
+
+        if (show->priv->background_color != NULL) {
+                g_slice_free (PangoColor, show->priv->background_color);
+                show->priv->background_color = NULL;
+        }
+
+        if (background_color != NULL) {
+               show->priv->background_color = g_slice_new (PangoColor);
+
+               if (pango_color_parse (show->priv->background_color, background_color) == FALSE) {
+                       g_slice_free (PangoColor, show->priv->background_color);
+                       show->priv->background_color = NULL;
+               }
+        }
+}
+
+static void
+gste_slideshow_set_property (GObject            *object,
+                             guint               prop_id,
+                             const GValue       *value,
+                             GParamSpec         *pspec)
+{
+        GSTESlideshow *self;
+
+        self = GSTE_SLIDESHOW (object);
+
+        switch (prop_id) {
+        case PROP_IMAGES_LOCATION:
+                gste_slideshow_set_images_location (self, g_value_get_string (value));
+                break;
+        case PROP_SORT_IMAGES:
+                gste_slideshow_set_sort_images (self, g_value_get_boolean (value));
+                break;
+        case PROP_SOLID_BACKGROUND:
+                gste_slideshow_set_background_color (self, g_value_get_string (value));
+                break;
+        case PROP_NO_STRETCH_HINT:
+                gste_slideshow_set_no_stretch_hint (self, g_value_get_boolean (value));
+                break;
+        default:
+                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+                break;
+        }
+}
+
+static void
+gste_slideshow_get_property (GObject            *object,
+                             guint               prop_id,
+                             GValue             *value,
+                             GParamSpec         *pspec)
+{
+        GSTESlideshow *self;
+
+        self = GSTE_SLIDESHOW (object);
+
+        switch (prop_id) {
+        case PROP_IMAGES_LOCATION:
+                g_value_set_string (value, self->priv->images_location);
+                break;
+        case PROP_SORT_IMAGES:
+                g_value_set_boolean (value, self->priv->sort_images);
+                break;
+        case PROP_SOLID_BACKGROUND:
+                {
+                        char *color = NULL;
+                        color = pango_color_to_string (self->priv->background_color);
+                        g_value_set_string (value, color);
+                        g_free (color);
+                        break;
+                }
+        case PROP_NO_STRETCH_HINT:
+                g_value_set_boolean (value, self->priv->no_stretch_hint);
+                break;
+        default:
+                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+                break;
+        }
+}
+
+static void
+gste_slideshow_real_show (GtkWidget *widget)
+{
+        GSTESlideshow *show = GSTE_SLIDESHOW (widget);
+        int            delay;
+
+        if (GTK_WIDGET_CLASS (parent_class)->show) {
+                GTK_WIDGET_CLASS (parent_class)->show (widget);
+        }
+
+        start_new_load (show, 10);
+
+        delay = 25;
+        show->priv->timeout_id = g_timeout_add (delay, (GSourceFunc)draw_iter, show);
+
+        if (show->priv->timer != NULL) {
+                g_timer_destroy (show->priv->timer);
+        }
+        show->priv->timer = g_timer_new ();
+}
+
+static gboolean
+gste_slideshow_real_expose (GtkWidget      *widget,
+                            GdkEventExpose *event)
+{
+        GSTESlideshow *show = GSTE_SLIDESHOW (widget);
+        gboolean       handled = FALSE;
+
+        update_display (show);
+
+        if (GTK_WIDGET_CLASS (parent_class)->expose_event) {
+                handled = GTK_WIDGET_CLASS (parent_class)->expose_event (widget, event);
+        }
+
+        return handled;
+}
+
+static gboolean
+gste_slideshow_real_configure (GtkWidget         *widget,
+                               GdkEventConfigure *event)
+{
+        GSTESlideshow *show = GSTE_SLIDESHOW (widget);
+        gboolean       handled = FALSE;
+        cairo_t       *cr;
+
+        /* resize */
+        gs_theme_engine_get_window_size (GS_THEME_ENGINE (show),
+                                         &show->priv->window_width,
+                                         &show->priv->window_height);
+
+        gs_theme_engine_profile_msg ("Resize to x:%d y:%d",
+                                     show->priv->window_width,
+                                     show->priv->window_height);
+
+        if (show->priv->surf != NULL) {
+                cairo_surface_destroy (show->priv->surf);
+        }
+
+        cr = gdk_cairo_create (widget->window);
+        show->priv->surf = cairo_surface_create_similar (cairo_get_target (cr),
+                                                         CAIRO_CONTENT_COLOR,
+                                                         show->priv->window_width,
+                                                         show->priv->window_height);
+        cairo_destroy (cr);
+
+        /* schedule a redraw */
+        gtk_widget_queue_draw (widget);
+
+        if (GTK_WIDGET_CLASS (parent_class)->configure_event) {
+                handled = GTK_WIDGET_CLASS (parent_class)->configure_event (widget, event);
+        }
+
+        return handled;
+}
+
+static void
+gste_slideshow_class_init (GSTESlideshowClass *klass)
+{
+        GObjectClass   *object_class = G_OBJECT_CLASS (klass);
+        GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+        parent_class = g_type_class_peek_parent (klass);
+
+        object_class->finalize = gste_slideshow_finalize;
+        object_class->get_property = gste_slideshow_get_property;
+        object_class->set_property = gste_slideshow_set_property;
+
+        widget_class->show = gste_slideshow_real_show;
+        widget_class->expose_event = gste_slideshow_real_expose;
+        widget_class->configure_event = gste_slideshow_real_configure;
+
+        g_type_class_add_private (klass, sizeof (GSTESlideshowPrivate));
+
+        g_object_class_install_property (object_class,
+                                         PROP_IMAGES_LOCATION,
+                                         g_param_spec_string ("images-location",
+                                                              NULL,
+                                                              NULL,
+                                                              NULL,
+                                                              G_PARAM_READWRITE));
+        g_object_class_install_property (object_class,
+                                         PROP_SORT_IMAGES,
+                                         g_param_spec_boolean ("sort-images",
+                                                               NULL,
+                                                               NULL,
+                                                               FALSE,
+                                                               G_PARAM_READWRITE));
+        g_object_class_install_property (object_class,
+                                         PROP_SOLID_BACKGROUND,
+                                         g_param_spec_string ("background-color",
+                                                              NULL,
+                                                              NULL,
+                                                              NULL,
+                                                              G_PARAM_READWRITE));
+        g_object_class_install_property (object_class,
+                                         PROP_NO_STRETCH_HINT,
+                                         g_param_spec_boolean ("no-stretch",
+                                                               NULL,
+                                                               NULL,
+                                                               FALSE,
+                                                               G_PARAM_READWRITE));
+}
+
+static void
+set_colormap (GtkWidget *widget)
+{
+        GdkScreen   *screen;
+        GdkColormap *colormap;
+
+        screen = gtk_widget_get_screen (widget);
+        colormap = gdk_screen_get_rgba_colormap (screen);
+        if (colormap == NULL) {
+                colormap = gdk_screen_get_rgb_colormap (screen);
+        }
+
+        gtk_widget_set_colormap (widget, colormap);
+}
+
+static void
+gste_slideshow_init (GSTESlideshow *show)
+{
+        GError *error;
+
+        show->priv = GSTE_SLIDESHOW_GET_PRIVATE (show);
+
+        show->priv->images_location = g_strdup (DEFAULT_IMAGES_LOCATION);
+
+        show->priv->op_q = g_async_queue_new ();
+        show->priv->results_q = g_async_queue_new ();
+
+        error = NULL;
+        show->priv->load_thread = g_thread_create ((GThreadFunc)load_threadfunc, show->priv->op_q, FALSE, &error);
+        if (show->priv->load_thread == NULL) {
+                g_error ("Could not create a thread to load images: %s",
+                         error->message);
+                g_error_free (error);
+                exit (-1);
+        }
+
+        set_colormap (GTK_WIDGET (show));
+}
+
+static void
+gste_slideshow_finalize (GObject *object)
+{
+        GSTESlideshow *show;
+        gpointer       result;
+
+        g_return_if_fail (object != NULL);
+        g_return_if_fail (GSTE_IS_SLIDESHOW (object));
+
+        show = GSTE_SLIDESHOW (object);
+
+        g_return_if_fail (show->priv != NULL);
+
+        if (show->priv->surf) {
+                cairo_surface_destroy (show->priv->surf);
+        }
+
+        if (show->priv->timeout_id > 0) {
+                g_source_remove (show->priv->timeout_id);
+                show->priv->timeout_id = 0;
+        }
+
+        if (show->priv->results_pull_id > 0) {
+                g_source_remove (show->priv->results_pull_id);
+        }
+
+        if (show->priv->results_q != NULL) {
+                result = g_async_queue_try_pop (show->priv->results_q);
+
+                while (result) {
+                        result = g_async_queue_try_pop (show->priv->results_q);
+                }
+                g_async_queue_unref (show->priv->results_q);
+        }
+
+        g_free (show->priv->images_location);
+        show->priv->images_location = NULL;
+
+        if (show->priv->background_color) {
+                g_slice_free (PangoColor, show->priv->background_color);
+                show->priv->background_color = NULL;
+        }
+
+        if (show->priv->timer != NULL) {
+                g_timer_destroy (show->priv->timer);
+        }
+
+        G_OBJECT_CLASS (parent_class)->finalize (object);
+}