first commit

1 files changed, 1269 insertions, 0 deletions

diff --git a/savers/floaters.c b/savers/floaters.c
new file mode 100644
index 0000000..8052e95
--- /dev/null
+++ b/savers/floaters.c
@@ -0,0 +1,1269 @@
+/*
+ * Copyright (C) 2005 Ray Strode <[email protected]>,
+ *                    Matthias Clasen <[email protected]>,
+ *                    Søren Sandmann <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser 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.
+ *
+ * Originally written by: Ray Strode <[email protected]>
+ *
+ * Later contributions by: Matthias Clasen <[email protected]>
+ *                         Søren Sandmann <[email protected]>
+ */
+
+#include "config.h"
+
+#include <math.h>
+#include <stdlib.h>
+#include <sysexits.h>
+#include <time.h>
+
+#include <glib.h>
+#include <glib/gi18n.h>
+
+#include <gdk/gdk.h>
+#include <gdk/gdkx.h>
+
+#include <gtk/gtk.h>
+
+#include "gs-theme-window.h"
+
+#ifndef trunc
+#define trunc(x) (((x) > 0.0) ? floor((x)) : -floor(-(x)))
+#endif
+
+#ifndef OPTIMAL_FRAME_RATE
+#define OPTIMAL_FRAME_RATE (25.0)
+#endif
+
+#ifndef STAT_PRINT_FREQUENCY
+#define STAT_PRINT_FREQUENCY (2000)
+#endif
+
+#ifndef FLOATER_MAX_SIZE
+#define FLOATER_MAX_SIZE (128.0)
+#endif
+
+#ifndef FLOATER_MIN_SIZE
+#define FLOATER_MIN_SIZE (16.0)
+#endif
+#ifndef FLOATER_DEFAULT_COUNT
+#define FLOATER_DEFAULT_COUNT (5)
+#endif
+
+#ifndef SMALL_ANGLE
+#define SMALL_ANGLE (0.025 * G_PI)
+#endif
+
+#ifndef BIG_ANGLE
+#define BIG_ANGLE (0.125 * G_PI)
+#endif
+
+#ifndef GAMMA
+#define GAMMA 2.2
+#endif
+
+static gboolean should_show_paths = FALSE;
+static gboolean should_do_rotations = FALSE;
+static gboolean should_print_stats = FALSE;
+static gint max_floater_count = FLOATER_DEFAULT_COUNT;
+static gchar *geometry = NULL;
+static gchar **filenames = NULL;
+
+static GOptionEntry options[] =
+{
+	{
+		"show-paths", 'p', 0, G_OPTION_ARG_NONE, &should_show_paths,
+		N_("Show paths that images follow"), NULL
+	},
+
+	{
+		"do-rotations", 'r', 0, G_OPTION_ARG_NONE, &should_do_rotations,
+		N_("Occasionally rotate images as they move"), NULL
+	},
+
+	{
+		"print-stats", 's', 0, G_OPTION_ARG_NONE, &should_print_stats,
+		N_("Print out frame rate and other statistics"), NULL
+	},
+
+	{
+		"number-of-images", 'n', 0, G_OPTION_ARG_INT, &max_floater_count,
+		N_("The maximum number of images to keep on screen"), N_("MAX_IMAGES")
+	},
+
+	{
+		"geometry", 0, 0, G_OPTION_ARG_STRING, &geometry,
+		N_("The initial size and position of window"), N_("WIDTHxHEIGHT+X+Y")
+	},
+
+	{
+		G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &filenames,
+		N_("The source image to use"), NULL
+	},
+
+	{NULL}
+};
+
+
+typedef struct _Point Point;
+typedef struct _Path Path;
+typedef struct _Rectangle Rectangle;
+typedef struct _ScreenSaverFloater ScreenSaverFloater;
+typedef struct _CachedSource CachedSource;
+typedef struct _ScreenSaver ScreenSaver;
+
+struct _Point
+{
+	gdouble x, y;
+};
+
+struct _Path
+{
+	Point start_point;
+	Point start_control_point;
+	Point end_control_point;
+	Point end_point;
+
+	gdouble x_linear_coefficient,
+	        y_linear_coefficient;
+
+	gdouble x_quadratic_coefficient,
+	        y_quadratic_coefficient;
+
+	gdouble x_cubic_coefficient,
+	        y_cubic_coefficient;
+
+	gdouble duration;
+};
+
+struct _CachedSource
+{
+	cairo_pattern_t *pattern;
+	gint width, height;
+};
+
+struct _Rectangle
+{
+	Point top_left_point;
+	Point bottom_right_point;
+};
+
+struct _ScreenSaverFloater
+{
+	GdkRectangle bounds;
+
+	Point start_position;
+	Point position;
+
+	gdouble scale;
+	gdouble opacity;
+
+	Path *path;
+	gdouble path_start_time;
+	gdouble path_start_scale;
+	gdouble path_end_scale;
+
+	gdouble angle;
+	gdouble angle_increment;
+};
+
+struct _ScreenSaver
+{
+	GtkWidget  *drawing_area;
+	Rectangle canvas_rectangle;
+	GHashTable *cached_sources;
+
+	char *filename;
+
+	gdouble first_update_time;
+
+	gdouble last_calculated_stats_time,
+	        current_calculated_stats_time;
+	gint update_count, frame_count;
+
+	gdouble updates_per_second;
+	gdouble frames_per_second;
+
+	guint state_update_timeout_id;
+	guint stats_update_timeout_id;
+
+	GList *floaters;
+	gint max_floater_count;
+
+	guint should_do_rotations: 1;
+	guint should_show_paths : 1;
+	guint draw_ops_pending : 1;
+};
+
+static Path *path_new (Point *start_point,
+                       Point *start_control_point,
+                       Point *end_control_point,
+                       Point *end_point,
+                       gdouble duration);
+static void path_free (Path *path);
+
+static ScreenSaverFloater *screen_saver_floater_new (ScreenSaver *screen_saver,
+        Point       *position,
+        gdouble      scale);
+static void screen_saver_floater_free (ScreenSaver        *screen_saver,
+                                       ScreenSaverFloater *floater);
+static gboolean screen_saver_floater_is_off_canvas (ScreenSaver        *screen_saver,
+        ScreenSaverFloater *floater);
+static gboolean screen_saver_floater_should_bubble_up (ScreenSaver        *screen_saver,
+        ScreenSaverFloater *floater,
+        gdouble             performance_ratio,
+        gdouble            *duration);
+static gboolean screen_saver_floater_should_come_on_screen (ScreenSaver   *screen_saver,
+        ScreenSaverFloater *floater,
+        gdouble             performance_ratio,
+        gdouble            *duration);
+static Point screen_saver_floater_get_position_from_time (ScreenSaver        *screen_saver,
+        ScreenSaverFloater *floater,
+        gdouble             time);
+static gdouble screen_saver_floater_get_scale_from_time (ScreenSaver        *screen_saver,
+        ScreenSaverFloater *floater,
+        gdouble             time);
+static gdouble screen_saver_floater_get_angle_from_time (ScreenSaver        *screen_saver,
+        ScreenSaverFloater *floater,
+        gdouble             time);
+
+static Path *screen_saver_floater_create_path_to_on_screen (ScreenSaver        *screen_saver,
+        ScreenSaverFloater *floater,
+        gdouble             duration);
+static Path *screen_saver_floater_create_path_to_bubble_up (ScreenSaver        *screen_saver,
+        ScreenSaverFloater *floater,
+        gdouble             duration);
+static Path *screen_saver_floater_create_path_to_random_point (ScreenSaver        *screen_saver,
+        ScreenSaverFloater *floater,
+        gdouble             duration);
+static Path *screen_saver_floater_create_path (ScreenSaver        *screen_saver,
+        ScreenSaverFloater *floater);
+static void screen_saver_floater_update_state (ScreenSaver        *screen_saver,
+        ScreenSaverFloater *floater,
+        gdouble             time);
+
+static gboolean screen_saver_floater_do_draw (ScreenSaver        *screen_saver,
+        ScreenSaverFloater *floater,
+        cairo_t            *context);
+
+static CachedSource *cached_source_new (cairo_pattern_t *pattern,
+                                        gint             width,
+                                        gint             height);
+static void cached_source_free (CachedSource *source);
+
+static ScreenSaver *screen_saver_new (GtkDrawingArea  *drawing_area,
+                                      const gchar     *filename,
+                                      gint             max_floater_count,
+                                      gboolean         should_do_rotations,
+                                      gboolean         should_show_paths);
+static void screen_saver_free (ScreenSaver *screen_saver);
+static gdouble screen_saver_get_timestamp (ScreenSaver *screen_saver);
+static void screen_saver_get_initial_state (ScreenSaver *screen_saver);
+static void screen_saver_update_state (ScreenSaver *screen_saver,
+                                       gdouble      time);
+static gboolean screen_saver_do_update_state (ScreenSaver *screen_saver);
+static gboolean screen_saver_do_update_stats (ScreenSaver *screen_saver);
+static gdouble screen_saver_get_updates_per_second (ScreenSaver *screen_saver);
+static gdouble screen_saver_get_frames_per_second (ScreenSaver *screen_saver);
+static gdouble screen_saver_get_image_cache_usage (ScreenSaver *screen_saver);
+static void screen_saver_create_floaters (ScreenSaver *screen_saver);
+static void screen_saver_destroy_floaters (ScreenSaver *screen_saver);
+static void screen_saver_on_size_allocate (ScreenSaver   *screen_saver,
+        GtkAllocation *allocation);
+static void screen_saver_on_expose_event (ScreenSaver    *screen_saver,
+        GdkEventExpose *event);
+static gboolean do_print_screen_saver_stats (ScreenSaver *screen_saver);
+static GdkPixbuf *gamma_correct (const GdkPixbuf *input_pixbuf);
+
+static CachedSource*
+cached_source_new (cairo_pattern_t *pattern,
+                   gint              width,
+                   gint             height)
+{
+	CachedSource *source;
+
+	source = g_new (CachedSource, 1);
+	source->pattern = cairo_pattern_reference (pattern);
+	source->width = width;
+	source->height = height;
+
+	return source;
+}
+
+static void
+cached_source_free (CachedSource *source)
+{
+	if (source == NULL)
+		return;
+
+	cairo_pattern_destroy (source->pattern);
+
+	g_free (source);
+}
+
+static Path *
+path_new (Point *start_point,
+          Point *start_control_point,
+          Point *end_control_point,
+          Point *end_point,
+          gdouble duration)
+{
+	Path *path;
+
+	path = g_new (Path, 1);
+	path->start_point = *start_point;
+	path->start_control_point = *start_control_point;
+	path->end_control_point = *end_control_point;
+	path->end_point = *end_point;
+	path->duration = duration;
+
+	/* we precompute the coefficients to the cubic bezier curve here
+	 * so that we don't have to do it repeatedly later The equation is:
+	 *
+	 * B(t) = A * t^3 + B * t^2 + C * t + start_point
+	 */
+	path->x_linear_coefficient = 3 * (start_control_point->x - start_point->x);
+	path->x_quadratic_coefficient = 3 * (end_control_point->x -
+	                                     start_control_point->x) -
+	                                path->x_linear_coefficient;
+	path->x_cubic_coefficient = end_point->x - start_point->x -
+	                            path->x_linear_coefficient -
+	                            path->x_quadratic_coefficient;
+
+	path->y_linear_coefficient = 3 * (start_control_point->y - start_point->y);
+	path->y_quadratic_coefficient = 3 * (end_control_point->y -
+	                                     start_control_point->y) -
+	                                path->y_linear_coefficient;
+	path->y_cubic_coefficient = end_point->y - start_point->y -
+	                            path->y_linear_coefficient -
+	                            path->y_quadratic_coefficient;
+	return path;
+}
+
+static void
+path_free (Path *path)
+{
+	g_free (path);
+}
+
+static ScreenSaverFloater*
+screen_saver_floater_new (ScreenSaver *screen_saver,
+                          Point       *position,
+                          gdouble      scale)
+{
+	ScreenSaverFloater *floater;
+
+	floater = g_new (ScreenSaverFloater, 1);
+	floater->bounds.width = 0;
+	floater->start_position = *position;
+	floater->position = *position;
+	floater->scale = scale;
+	floater->opacity = pow (scale, 1.0 / GAMMA);
+	floater->path = NULL;
+	floater->path_start_time = 0.0;
+	floater->path_start_scale = 1.0;
+	floater->path_end_scale = 0.0;
+
+	floater->angle = 0.0;
+	floater->angle_increment = 0.0;
+
+	return floater;
+}
+
+void
+screen_saver_floater_free (ScreenSaver        *screen_saver,
+                           ScreenSaverFloater *floater)
+{
+	if (floater == NULL)
+		return;
+
+	path_free (floater->path);
+
+	g_free (floater);
+}
+
+static gboolean
+screen_saver_floater_is_off_canvas (ScreenSaver        *screen_saver,
+                                    ScreenSaverFloater *floater)
+{
+	if ((floater->position.x < screen_saver->canvas_rectangle.top_left_point.x) ||
+	        (floater->position.x > screen_saver->canvas_rectangle.bottom_right_point.x) ||
+	        (floater->position.y < screen_saver->canvas_rectangle.top_left_point.y) ||
+	        (floater->position.y > screen_saver->canvas_rectangle.bottom_right_point.y))
+		return TRUE;
+
+	return FALSE;
+}
+
+static gboolean
+screen_saver_floater_should_come_on_screen (ScreenSaver        *screen_saver,
+        ScreenSaverFloater *floater,
+        gdouble             performance_ratio,
+        gdouble            *duration)
+{
+
+	if (!screen_saver_floater_is_off_canvas (screen_saver, floater))
+		return FALSE;
+
+	if ((abs (performance_ratio - .5) >= G_MINDOUBLE) &&
+	        (g_random_double () > .5))
+	{
+		if (duration)
+			*duration = g_random_double_range (3.0, 7.0);
+
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+static gboolean
+screen_saver_floater_should_bubble_up (ScreenSaver        *screen_saver,
+                                       ScreenSaverFloater *floater,
+                                       gdouble             performance_ratio,
+                                       gdouble            *duration)
+{
+
+	if ((performance_ratio < .5) && (g_random_double () > .5))
+	{
+		if (duration)
+			*duration = performance_ratio * 30.0;
+
+		return TRUE;
+	}
+
+	if ((floater->scale < .3) && (g_random_double () > .6))
+	{
+		if (duration)
+			*duration = 30.0;
+
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+static Point
+screen_saver_floater_get_position_from_time (ScreenSaver        *screen_saver,
+        ScreenSaverFloater *floater,
+        gdouble             time)
+{
+	Point point;
+
+	time = time / floater->path->duration;
+
+	point.x = floater->path->x_cubic_coefficient * (time * time * time) +
+	          floater->path->x_quadratic_coefficient * (time * time) +
+	          floater->path->x_linear_coefficient * (time) +
+	          floater->path->start_point.x;
+	point.y = floater->path->y_cubic_coefficient * (time * time * time) +
+	          floater->path->y_quadratic_coefficient * (time * time) +
+	          floater->path->y_linear_coefficient * (time) +
+	          floater->path->start_point.y;
+
+	return point;
+}
+
+static gdouble
+screen_saver_floater_get_scale_from_time (ScreenSaver        *screen_saver,
+        ScreenSaverFloater *floater,
+        gdouble             time)
+{
+	gdouble completion_ratio, total_scale_growth, new_scale;
+
+	completion_ratio = time / floater->path->duration;
+	total_scale_growth = (floater->path_end_scale - floater->path_start_scale);
+	new_scale = floater->path_start_scale + total_scale_growth * completion_ratio;
+
+	return CLAMP (new_scale, 0.0, 1.0);
+}
+
+static gdouble
+screen_saver_floater_get_angle_from_time (ScreenSaver        *screen_saver,
+        ScreenSaverFloater *floater,
+        gdouble             time)
+{
+	gdouble completion_ratio;
+	gdouble total_rotation;
+
+	completion_ratio = time / floater->path->duration;
+	total_rotation = floater->angle_increment * floater->path->duration;
+
+	return floater->angle + total_rotation * completion_ratio;
+}
+
+static Path *
+screen_saver_floater_create_path_to_on_screen (ScreenSaver        *screen_saver,
+        ScreenSaverFloater *floater,
+        gdouble             duration)
+{
+	Point start_position, end_position, start_control_point, end_control_point;
+	start_position = floater->position;
+
+	end_position.x = g_random_double_range (.25, .75) *
+	                 (screen_saver->canvas_rectangle.top_left_point.x +
+	                  screen_saver->canvas_rectangle.bottom_right_point.x);
+	end_position.y = g_random_double_range (.25, .75) *
+	                 (screen_saver->canvas_rectangle.top_left_point.y +
+	                  screen_saver->canvas_rectangle.bottom_right_point.y);
+
+	start_control_point.x = start_position.x + .9 * (end_position.x - start_position.x);
+	start_control_point.y = start_position.y + .9 * (end_position.y - start_position.y);
+
+	end_control_point.x = start_position.x + 1.0 * (end_position.x - start_position.x);
+	end_control_point.y = start_position.y + 1.0 * (end_position.y - start_position.y);
+
+	return path_new (&start_position, &start_control_point, &end_control_point,
+	                 &end_position, duration);
+}
+
+static Path *
+screen_saver_floater_create_path_to_bubble_up (ScreenSaver        *screen_saver,
+        ScreenSaverFloater *floater,
+        gdouble             duration)
+{
+	Point start_position, end_position, start_control_point, end_control_point;
+
+	start_position = floater->position;
+	end_position.x = start_position.x;
+	end_position.y = screen_saver->canvas_rectangle.top_left_point.y - FLOATER_MAX_SIZE;
+	start_control_point.x = .5 * start_position.x;
+	start_control_point.y = .5 * start_position.y;
+	end_control_point.x = 1.5 * end_position.x;
+	end_control_point.y = .5 * end_position.y;
+
+	return path_new (&start_position, &start_control_point, &end_control_point,
+	                 &end_position, duration);
+}
+
+static Path *
+screen_saver_floater_create_path_to_random_point (ScreenSaver        *screen_saver,
+        ScreenSaverFloater *floater,
+        gdouble             duration)
+{
+	Point start_position, end_position, start_control_point, end_control_point;
+
+	start_position = floater->position;
+
+	end_position.x = start_position.x +
+	                 (g_random_double_range (-.5, .5) * 4 * FLOATER_MAX_SIZE);
+	end_position.y = start_position.y +
+	                 (g_random_double_range (-.5, .5) * 4 * FLOATER_MAX_SIZE);
+
+	start_control_point.x = start_position.x + .95 * (end_position.x - start_position.x);
+	start_control_point.y = start_position.y + .95 * (end_position.y - start_position.y);
+
+	end_control_point.x = start_position.x + 1.0 * (end_position.x - start_position.x);
+	end_control_point.y = start_position.y + 1.0 * (end_position.y - start_position.y);
+
+	return path_new (&start_position, &start_control_point, &end_control_point,
+	                 &end_position, duration);
+}
+
+static Path *
+screen_saver_floater_create_path (ScreenSaver        *screen_saver,
+                                  ScreenSaverFloater *floater)
+{
+	gdouble performance_ratio;
+	gdouble duration;
+
+	performance_ratio =
+	    screen_saver_get_frames_per_second (screen_saver) / OPTIMAL_FRAME_RATE;
+
+	if (abs (performance_ratio) <= G_MINDOUBLE)
+		performance_ratio = 1.0;
+
+	if (screen_saver_floater_should_bubble_up (screen_saver, floater, performance_ratio, &duration))
+		return screen_saver_floater_create_path_to_bubble_up (screen_saver, floater, duration);
+
+	if (screen_saver_floater_should_come_on_screen (screen_saver, floater, performance_ratio, &duration))
+		return screen_saver_floater_create_path_to_on_screen (screen_saver, floater, duration);
+
+	return screen_saver_floater_create_path_to_random_point (screen_saver, floater,
+	        g_random_double_range (3.0, 7.0));
+}
+
+static void
+screen_saver_floater_update_state (ScreenSaver        *screen_saver,
+                                   ScreenSaverFloater *floater,
+                                   gdouble             time)
+{
+	gdouble performance_ratio;
+
+	performance_ratio =
+	    screen_saver_get_frames_per_second (screen_saver) / OPTIMAL_FRAME_RATE;
+
+	if (floater->path == NULL)
+	{
+		floater->path = screen_saver_floater_create_path (screen_saver, floater);
+		floater->path_start_time = time;
+
+		floater->path_start_scale = floater->scale;
+
+		if (g_random_double () > .5)
+			floater->path_end_scale = g_random_double_range (0.10, performance_ratio);
+
+		/* poor man's distribution */
+		if (screen_saver->should_do_rotations &&
+		        (g_random_double () < .75 * performance_ratio))
+		{
+			gint r;
+
+			r = g_random_int_range (0, 100);
+			if (r < 80)
+				floater->angle_increment = 0.0;
+			else if (r < 95)
+				floater->angle_increment = g_random_double_range (-SMALL_ANGLE, SMALL_ANGLE);
+			else
+				floater->angle_increment = g_random_double_range (-BIG_ANGLE, BIG_ANGLE);
+		}
+	}
+
+	if (time < (floater->path_start_time + floater->path->duration))
+	{
+		gdouble path_time;
+
+		path_time = time - floater->path_start_time;
+
+		floater->position =
+		    screen_saver_floater_get_position_from_time (screen_saver, floater,
+		            path_time);
+		floater->scale =
+		    screen_saver_floater_get_scale_from_time (screen_saver, floater, path_time);
+
+		floater->angle =
+		    screen_saver_floater_get_angle_from_time (screen_saver, floater, path_time);
+
+		floater->opacity = pow (floater->scale, 1.0 / GAMMA);
+	}
+	else
+	{
+		path_free (floater->path);
+
+		floater->path = NULL;
+		floater->path_start_time = 0.0;
+	}
+}
+
+static GdkPixbuf *
+gamma_correct (const GdkPixbuf *input_pixbuf)
+{
+	gint x, y, width, height, rowstride;
+	GdkPixbuf *output_pixbuf;
+	guchar *pixels;
+
+	output_pixbuf = gdk_pixbuf_copy (input_pixbuf);
+	pixels = gdk_pixbuf_get_pixels (output_pixbuf);
+
+	width = gdk_pixbuf_get_width (output_pixbuf);
+	height = gdk_pixbuf_get_height (output_pixbuf);
+	rowstride = gdk_pixbuf_get_rowstride (output_pixbuf);
+
+	for (y = 0; y < height; y++)
+		for (x = 0; x < width; x++)
+		{
+			guchar *alpha_channel;
+			guchar opacity;
+
+			alpha_channel = pixels + y * (rowstride / 4) + x + 3;
+			opacity = (guchar) (255 * pow ((*alpha_channel / 255.0), 1.0 / GAMMA));
+
+			*alpha_channel = opacity;
+		}
+
+	return output_pixbuf;
+}
+
+static gboolean
+screen_saver_floater_do_draw (ScreenSaver        *screen_saver,
+                              ScreenSaverFloater *floater,
+                              cairo_t            *context)
+{
+	gint size;
+	CachedSource *source;
+
+	size = CLAMP ((int) (FLOATER_MAX_SIZE * floater->scale),
+	              FLOATER_MIN_SIZE, FLOATER_MAX_SIZE);
+
+	source = g_hash_table_lookup (screen_saver->cached_sources, GINT_TO_POINTER (size));
+
+	if (source == NULL)
+	{
+		GdkPixbuf *pixbuf;
+		GError *error;
+
+		pixbuf = NULL;
+		error = NULL;
+
+		pixbuf = gdk_pixbuf_new_from_file_at_size (screen_saver->filename, size, -1,
+		         &error);
+		if (pixbuf == NULL)
+		{
+			g_assert (error != NULL);
+			g_printerr ("%s", _(error->message));
+			g_error_free (error);
+			return FALSE;
+		}
+
+		if (gdk_pixbuf_get_has_alpha (pixbuf))
+			gamma_correct (pixbuf);
+
+		gdk_cairo_set_source_pixbuf (context, pixbuf, 0.0, 0.0);
+
+		source = cached_source_new (cairo_get_source (context),
+		                            gdk_pixbuf_get_width (pixbuf),
+		                            gdk_pixbuf_get_height (pixbuf));
+		g_object_unref (pixbuf);
+		g_hash_table_insert (screen_saver->cached_sources, GINT_TO_POINTER (size),
+		                     source);
+	}
+
+	cairo_save (context);
+
+	if (screen_saver->should_do_rotations && (abs (floater->angle) > G_MINDOUBLE))
+	{
+		floater->bounds.width = G_SQRT2 * source->width + 2;
+		floater->bounds.height = G_SQRT2 * source->height + 2;
+		floater->bounds.x = (int) (floater->position.x - .5 * G_SQRT2 * source->width) - 1;
+		floater->bounds.y = (int) (floater->position.y - .5 * G_SQRT2 * source->height) - 1;
+
+		cairo_translate (context,
+		                 trunc (floater->position.x),
+		                 trunc (floater->position.y));
+		cairo_rotate (context, floater->angle);
+		cairo_translate (context,
+		                 -trunc (floater->position.x),
+		                 -trunc (floater->position.y));
+	}
+	else
+	{
+		floater->bounds.width = source->width + 2;
+		floater->bounds.height = source->height + 2;
+		floater->bounds.x = (int) (floater->position.x - .5 * source->width) - 1;
+		floater->bounds.y = (int) (floater->position.y - .5 * source->height) - 1;
+	}
+
+	cairo_translate (context,
+	                 trunc (floater->position.x - .5 * source->width),
+	                 trunc (floater->position.y - .5 * source->height));
+
+	cairo_set_source (context, source->pattern);
+
+	cairo_rectangle (context,
+	                 trunc (.5 * (source->width - floater->bounds.width)),
+	                 trunc (.5 * (source->height - floater->bounds.height)),
+	                 floater->bounds.width, floater->bounds.height);
+
+	cairo_clip (context);
+	cairo_paint_with_alpha (context, floater->opacity);
+	cairo_restore (context);
+
+	if (screen_saver->should_show_paths && (floater->path != NULL))
+	{
+		gdouble dash_pattern[] = { 5.0 };
+		gint size;
+
+		size = CLAMP ((int) (FLOATER_MAX_SIZE * floater->path_start_scale),
+		              FLOATER_MIN_SIZE, FLOATER_MAX_SIZE);
+
+		cairo_save (context);
+		cairo_set_source_rgba (context, 1.0, 1.0, 1.0, .2 * floater->opacity);
+		cairo_move_to (context,
+		               floater->path->start_point.x,
+		               floater->path->start_point.y);
+		cairo_curve_to (context,
+		                floater->path->start_control_point.x,
+		                floater->path->start_control_point.y,
+		                floater->path->end_control_point.x,
+		                floater->path->end_control_point.y,
+		                floater->path->end_point.x,
+		                floater->path->end_point.y);
+		cairo_set_line_cap (context, CAIRO_LINE_CAP_ROUND);
+		cairo_stroke (context);
+		cairo_set_source_rgba (context, 1.0, 0.0, 0.0, .5 * floater->opacity);
+		cairo_rectangle (context,
+		                 floater->path->start_point.x - 3,
+		                 floater->path->start_point.y - 3,
+		                 6, 6);
+		cairo_fill (context);
+		cairo_set_source_rgba (context, 0.0, 0.5, 0.0, .5 * floater->opacity);
+		cairo_arc (context,
+		           floater->path->start_control_point.x,
+		           floater->path->start_control_point.y,
+		           3, 0.0, 2.0 * G_PI);
+		cairo_stroke (context);
+		cairo_set_source_rgba (context, 0.5, 0.0, 0.5, .5 * floater->opacity);
+		cairo_arc (context,
+		           floater->path->end_control_point.x,
+		           floater->path->end_control_point.y,
+		           3, 0.0, 2.0 * G_PI);
+		cairo_stroke (context);
+		cairo_set_source_rgba (context, 0.0, 0.0, 1.0, .5 * floater->opacity);
+		cairo_rectangle (context,
+		                 floater->path->end_point.x - 3,
+		                 floater->path->end_point.y - 3,
+		                 6, 6);
+		cairo_fill (context);
+
+		cairo_set_dash (context, dash_pattern, G_N_ELEMENTS (dash_pattern), 0);
+		cairo_set_source_rgba (context, .5, .5, .5, .2 * floater->scale);
+		cairo_move_to (context, floater->path->start_point.x,
+		               floater->path->start_point.y);
+		cairo_line_to (context, floater->path->start_control_point.x,
+		               floater->path->start_control_point.y);
+		cairo_stroke (context);
+
+		cairo_move_to (context, floater->path->end_point.x,
+		               floater->path->end_point.y);
+		cairo_line_to (context, floater->path->end_control_point.x,
+		               floater->path->end_control_point.y);
+		cairo_stroke (context);
+
+		cairo_restore (context);
+	}
+
+	return TRUE;
+}
+
+static ScreenSaver *
+screen_saver_new (GtkDrawingArea  *drawing_area,
+                  const gchar     *filename,
+                  gint             max_floater_count,
+                  gboolean         should_do_rotations,
+                  gboolean         should_show_paths)
+{
+	ScreenSaver *screen_saver;
+
+	screen_saver = g_new (ScreenSaver, 1);
+	screen_saver->filename = g_strdup (filename);
+	screen_saver->drawing_area = GTK_WIDGET (drawing_area);
+	screen_saver->cached_sources =
+	    g_hash_table_new_full (NULL, NULL, NULL,
+	                           (GDestroyNotify) cached_source_free);
+
+	g_signal_connect_swapped (G_OBJECT (drawing_area), "size-allocate",
+	                          G_CALLBACK (screen_saver_on_size_allocate),
+	                          screen_saver);
+
+	g_signal_connect_swapped (G_OBJECT (drawing_area), "expose-event",
+	                          G_CALLBACK (screen_saver_on_expose_event),
+	                          screen_saver);
+
+	screen_saver->first_update_time = 0.0;
+	screen_saver->current_calculated_stats_time = 0.0;
+	screen_saver->last_calculated_stats_time = 0.0;
+	screen_saver->update_count = 0;
+	screen_saver->frame_count = 0;
+	screen_saver->updates_per_second = 0.0;
+	screen_saver->frames_per_second = 0.0;
+	screen_saver->floaters = NULL;
+	screen_saver->max_floater_count = max_floater_count;
+
+	screen_saver->should_show_paths = should_show_paths;
+	screen_saver->should_do_rotations = should_do_rotations;
+
+	screen_saver_get_initial_state (screen_saver);
+
+	screen_saver->state_update_timeout_id =
+	    g_timeout_add (1000 / (2.0 * OPTIMAL_FRAME_RATE),
+	                   (GSourceFunc) screen_saver_do_update_state, screen_saver);
+
+	screen_saver->stats_update_timeout_id =
+	    g_timeout_add (1000, (GSourceFunc) screen_saver_do_update_stats,
+	                   screen_saver);
+
+	return screen_saver;
+}
+
+static void
+screen_saver_free (ScreenSaver *screen_saver)
+{
+	if (screen_saver == NULL)
+		return;
+
+	g_free (screen_saver->filename);
+
+	g_hash_table_destroy (screen_saver->cached_sources);
+
+	if (screen_saver->state_update_timeout_id != 0)
+		g_source_remove (screen_saver->state_update_timeout_id);
+
+	if (screen_saver->stats_update_timeout_id != 0)
+		g_source_remove (screen_saver->stats_update_timeout_id);
+
+	screen_saver_destroy_floaters (screen_saver);
+
+	g_free (screen_saver);
+}
+
+static gdouble
+screen_saver_get_timestamp (ScreenSaver *screen_saver)
+{
+	const gdouble microseconds_per_second = (gdouble ) G_USEC_PER_SEC;
+	gdouble timestamp;
+	GTimeVal now = { 0L, /* zero-filled */ };
+
+	g_get_current_time (&now);
+	timestamp = ((microseconds_per_second * now.tv_sec) + now.tv_usec) /
+	            microseconds_per_second;
+
+	return timestamp;
+}
+
+static void
+screen_saver_create_floaters (ScreenSaver *screen_saver)
+{
+	gint i;
+
+	for (i = 0; i < screen_saver->max_floater_count; i++)
+	{
+		ScreenSaverFloater *floater;
+		Point position;
+		gdouble scale;
+
+		position.x = g_random_double_range (screen_saver->canvas_rectangle.top_left_point.x,
+		                                    screen_saver->canvas_rectangle.bottom_right_point.x);
+		position.y = g_random_double_range (screen_saver->canvas_rectangle.top_left_point.y,
+		                                    screen_saver->canvas_rectangle.bottom_right_point.y);
+
+		scale = g_random_double ();
+
+		floater = screen_saver_floater_new (screen_saver, &position, scale);
+
+		screen_saver->floaters = g_list_prepend (screen_saver->floaters,
+		                         floater);
+	}
+}
+
+static gdouble
+screen_saver_get_updates_per_second (ScreenSaver *screen_saver)
+{
+	return screen_saver->updates_per_second;
+}
+
+static gdouble
+screen_saver_get_frames_per_second (ScreenSaver *screen_saver)
+{
+	return screen_saver->frames_per_second;
+}
+
+static gdouble
+screen_saver_get_image_cache_usage (ScreenSaver *screen_saver)
+{
+	static const gdouble cache_capacity = (FLOATER_MAX_SIZE - FLOATER_MIN_SIZE + 1);
+
+	return g_hash_table_size (screen_saver->cached_sources) / cache_capacity;
+}
+
+static void
+screen_saver_destroy_floaters (ScreenSaver *screen_saver)
+{
+	if (screen_saver->floaters == NULL)
+		return;
+
+	g_list_foreach (screen_saver->floaters, (GFunc) screen_saver_floater_free,
+	                NULL);
+	g_list_free (screen_saver->floaters);
+
+	screen_saver->floaters = NULL;
+}
+
+static void
+screen_saver_on_size_allocate (ScreenSaver   *screen_saver,
+                               GtkAllocation *allocation)
+{
+	Rectangle canvas_rectangle;
+
+	canvas_rectangle.top_left_point.x = allocation->x - .1 * allocation->width;
+	canvas_rectangle.top_left_point.y = allocation->y - .1 * allocation->height;
+
+	canvas_rectangle.bottom_right_point.x = allocation->x + (1.1 * allocation->width);
+	canvas_rectangle.bottom_right_point.y = allocation->y + (1.1 * allocation->height);
+
+	screen_saver->canvas_rectangle = canvas_rectangle;
+}
+
+static gint
+compare_floaters (ScreenSaverFloater *a,
+                  ScreenSaverFloater *b)
+{
+	if (a->scale > b->scale)
+		return 1;
+	else if (abs (a->scale - b->scale) <= G_MINDOUBLE)
+		return 0;
+	else
+		return -1;
+}
+
+static void
+screen_saver_on_expose_event (ScreenSaver    *screen_saver,
+                              GdkEventExpose *event)
+{
+	GList *tmp;
+	cairo_t *context;
+
+	if (screen_saver->floaters == NULL)
+		screen_saver_create_floaters (screen_saver);
+
+	context = gdk_cairo_create (screen_saver->drawing_area->window);
+
+	cairo_rectangle (context,
+	                 (double) event->area.x,
+	                 (double) event->area.y,
+	                 (double) event->area.width,
+	                 (double) event->area.height);
+	cairo_clip (context);
+
+	screen_saver->floaters = g_list_sort (screen_saver->floaters,
+	                                      (GCompareFunc)compare_floaters);
+
+	for (tmp = screen_saver->floaters; tmp != NULL; tmp = tmp->next)
+	{
+		ScreenSaverFloater *floater;
+		GdkRectangle rect;
+		gint size;
+
+		floater = (ScreenSaverFloater *) tmp->data;
+
+		size = CLAMP ((int) (FLOATER_MAX_SIZE * floater->scale),
+		              FLOATER_MIN_SIZE, FLOATER_MAX_SIZE);
+
+		rect.x = (int) (floater->position.x - .5 * G_SQRT2 * size);
+		rect.y = (int) (floater->position.y - .5 * G_SQRT2 * size);
+		rect.width = G_SQRT2 * size;
+		rect.height = G_SQRT2 * size;
+
+		if (!gdk_region_rect_in (event->region, &rect))
+			continue;
+
+		if (!screen_saver_floater_do_draw (screen_saver, floater, context))
+		{
+			gtk_main_quit ();
+			break;
+		}
+	}
+
+	cairo_destroy (context);
+
+	screen_saver->draw_ops_pending = TRUE;
+	screen_saver->frame_count++;
+}
+
+static void
+screen_saver_update_state (ScreenSaver *screen_saver,
+                           gdouble      time)
+{
+	GList *tmp;
+
+	tmp = screen_saver->floaters;
+	while (tmp != NULL)
+	{
+		ScreenSaverFloater *floater;
+		floater = (ScreenSaverFloater *) tmp->data;
+
+		screen_saver_floater_update_state (screen_saver, floater, time);
+
+		if (GTK_WIDGET_REALIZED (screen_saver->drawing_area)
+		        && (floater->bounds.width > 0) && (floater->bounds.height > 0))
+		{
+			gint size;
+			size = CLAMP ((int) (FLOATER_MAX_SIZE * floater->scale),
+			              FLOATER_MIN_SIZE, FLOATER_MAX_SIZE);
+
+			gtk_widget_queue_draw_area (screen_saver->drawing_area,
+			                            floater->bounds.x,
+			                            floater->bounds.y,
+			                            floater->bounds.width,
+			                            floater->bounds.height);
+
+			/* the edges could concievably be spread across two
+			 * pixels so we add +2 to invalidated region
+			 */
+			if (screen_saver->should_do_rotations)
+				gtk_widget_queue_draw_area (screen_saver->drawing_area,
+				                            (int) (floater->position.x -
+				                                   .5 * G_SQRT2 * size),
+				                            (int) (floater->position.y -
+				                                   .5 * G_SQRT2 * size),
+				                            G_SQRT2 * size + 2,
+				                            G_SQRT2 * size + 2);
+			else
+				gtk_widget_queue_draw_area (screen_saver->drawing_area,
+				                            (int) (floater->position.x -
+				                                   .5 * size),
+				                            (int) (floater->position.y -
+				                                   .5 * size),
+				                            size + 2, size + 2);
+
+			if  (screen_saver->should_show_paths)
+				gtk_widget_queue_draw (screen_saver->drawing_area);
+		}
+
+		tmp = tmp->next;
+	}
+}
+
+static void
+screen_saver_get_initial_state (ScreenSaver *screen_saver)
+{
+	screen_saver->first_update_time = screen_saver_get_timestamp (screen_saver);
+	screen_saver_update_state (screen_saver, 0.0);
+}
+
+static gboolean
+screen_saver_do_update_state (ScreenSaver *screen_saver)
+{
+	gdouble current_update_time;
+
+	/* flush pending requests to the X server and block for
+	 * replies before proceeding to help prevent the X server from
+	 * getting overrun with requests
+	 */
+	if (screen_saver->draw_ops_pending)
+	{
+		gdk_flush ();
+		screen_saver->draw_ops_pending = FALSE;
+	}
+
+	current_update_time = screen_saver_get_timestamp (screen_saver);
+	screen_saver_update_state (screen_saver, current_update_time -
+	                           screen_saver->first_update_time);
+	screen_saver->update_count++;
+	return TRUE;
+}
+
+static gboolean
+screen_saver_do_update_stats (ScreenSaver *screen_saver)
+{
+	gdouble last_calculated_stats_time, seconds_since_last_stats_update;
+
+	last_calculated_stats_time = screen_saver->current_calculated_stats_time;
+	screen_saver->current_calculated_stats_time =
+	    screen_saver_get_timestamp (screen_saver);
+	screen_saver->last_calculated_stats_time = last_calculated_stats_time;
+
+	if (abs (last_calculated_stats_time) <= G_MINDOUBLE)
+		return TRUE;
+
+	seconds_since_last_stats_update =
+	    screen_saver->current_calculated_stats_time - last_calculated_stats_time;
+
+	screen_saver->updates_per_second =
+	    screen_saver->update_count / seconds_since_last_stats_update;
+	screen_saver->frames_per_second =
+	    screen_saver->frame_count / seconds_since_last_stats_update;
+
+	screen_saver->update_count = 0;
+	screen_saver->frame_count = 0;
+
+	return TRUE;
+}
+
+static gboolean
+do_print_screen_saver_stats (ScreenSaver *screen_saver)
+{
+
+	g_print ("updates per second: %.2f, frames per second: %.2f, "
+	         "image cache %.0f%% full\n",
+	         screen_saver_get_updates_per_second (screen_saver),
+	         screen_saver_get_frames_per_second (screen_saver),
+	         screen_saver_get_image_cache_usage (screen_saver) * 100.0);
+
+	return TRUE;
+}
+
+int
+main (int   argc,
+      char *argv[])
+{
+	ScreenSaver *screen_saver;
+	GtkWidget *window;
+	GtkWidget *drawing_area;
+
+	GtkStateType state;
+
+	GError *error;
+
+	error = NULL;
+
+	bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR);
+	bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+	textdomain (GETTEXT_PACKAGE);
+
+	gtk_init_with_args (&argc, &argv,
+	                    /* translators: the word "image" here
+	                     * represents a command line argument
+	                     */
+	                    _("image - floats images around the screen"),
+	                    options, GETTEXT_PACKAGE, &error);
+
+
+	if (error != NULL)
+	{
+		g_printerr (_("%s. See --help for usage information.\n"),
+		            _(error->message));
+		g_error_free (error);
+		return EX_SOFTWARE;
+	}
+
+	if ((filenames == NULL) || (filenames[0] == NULL) ||
+	        (filenames[1] != NULL))
+	{
+		g_printerr (_("You must specify one image.  See --help for usage "
+		              "information.\n"));
+		return EX_USAGE;
+	}
+
+	window = gs_theme_window_new ();
+
+	g_signal_connect (G_OBJECT (window), "delete-event",
+	                  G_CALLBACK (gtk_main_quit), NULL);
+
+	drawing_area = gtk_drawing_area_new ();
+
+	state = (GtkStateType) 0;
+	while (state < (GtkStateType) G_N_ELEMENTS (drawing_area->style->bg))
+	{
+		gtk_widget_modify_bg (drawing_area, state, &drawing_area->style->mid[state]);
+		state++;
+	}
+
+	gtk_widget_show (drawing_area);
+	gtk_container_add (GTK_CONTAINER (window), drawing_area);
+
+	screen_saver = screen_saver_new (GTK_DRAWING_AREA (drawing_area),
+	                                 filenames[0], max_floater_count,
+	                                 should_do_rotations, should_show_paths);
+	g_strfreev (filenames);
+
+	if (should_print_stats)
+		g_timeout_add (STAT_PRINT_FREQUENCY,
+		               (GSourceFunc) do_print_screen_saver_stats,
+		               screen_saver);
+
+	if ((geometry == NULL)
+	        || !gtk_window_parse_geometry (GTK_WINDOW (window), geometry))
+		gtk_window_set_default_size (GTK_WINDOW (window), 640, 480);
+
+	gtk_widget_show (window);
+
+	gtk_main ();
+
+	screen_saver_free (screen_saver);
+
+	return EX_OK;
+}