prolooks helper code from hans, enabling new knob drawing based on Thorsten Wilm's lovely knob/dial design. To Be Tweaked

git-svn-id: svn://localhost/ardour2/branches/3.0@7074 d708f5d6-7413-0410-9779-e7cbd77b26cf

9 files changed, 1879 insertions, 123 deletions

diff --git a/libs/ardour/ardour/route.h b/libs/ardour/ardour/route.h
index 689090cd57..e371059a74 100644
--- a/libs/ardour/ardour/route.h
+++ b/libs/ardour/ardour/route.h
@@ -370,12 +370,6 @@ class Route : public SessionObject, public AutomatableControls, public RouteGrou
   protected:
 	friend class Session;
 
-        void set_graph_level (int32_t);
-        int32_t graph_level() const { return _graph_level; } 
-        void check_physical_connections ();
-        // this functions may ONLY be called during a route resort
-        bool physically_connected () const { return _physically_connected; }
-
 	void catch_up_on_solo_mute_override ();
 	void mod_solo_by_others_upstream (int32_t);
 	void mod_solo_by_others_downstream (int32_t);
@@ -433,8 +427,6 @@ class Route : public SessionObject, public AutomatableControls, public RouteGrou
     
 	std::string    _comment;
 	bool           _have_internal_generator;
-        bool           _physically_connected; // valid ONLY during a route resort
-        int32_t        _graph_level;
 	bool           _solo_safe;
 	DataType       _default_type;
         FedBy          _fed_by;
diff --git a/libs/ardour/ardour/session.h b/libs/ardour/ardour/session.h
index a321d1ffcc..4182ce1ea1 100644
--- a/libs/ardour/ardour/session.h
+++ b/libs/ardour/ardour/session.h
@@ -415,16 +415,12 @@ class Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionLi
 	void   remove_route (boost::shared_ptr<Route>);
 	void   resort_routes ();
 	void   resort_routes_using (boost::shared_ptr<RouteList>);
-        void   find_route_levels (boost::shared_ptr<RouteList>);
 
 	void   set_remote_control_ids();
 
 	AudioEngine & engine() { return _engine; }
 	AudioEngine const & engine () const { return _engine; }
 
-	int32_t  max_level;
-	int32_t  min_level;
-
 	/* Time */
 
         nframes64_t transport_frame () const {return _transport_frame; }
diff --git a/libs/ardour/route.cc b/libs/ardour/route.cc
index e5a4b01fd1..bf0b4db5b5 100644
--- a/libs/ardour/route.cc
+++ b/libs/ardour/route.cc
@@ -92,8 +92,6 @@ Route::Route (Session& sess, string name, Flag flg, DataType default_type)
 	, _mute_master (new MuteMaster (sess, name))
         , _mute_points (MuteMaster::AllPoints)
         , _have_internal_generator (false)
-        , _physically_connected (false)
-        , _graph_level (-1)
         , _solo_safe (false)
 	, _default_type (default_type)
         , _remote_control_id (0)
@@ -2585,12 +2583,6 @@ Route::direct_feeds (boost::shared_ptr<Route> other, bool* only_send)
 }
 
 void
-Route::check_physical_connections ()
-{
-        _physically_connected = _output->physically_connected ();
-}
-
-void
 Route::handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
 {
 	nframes_t now = _session.transport_frame();
@@ -3361,8 +3353,3 @@ Route::has_io_processor_named (const string& name)
         return false;
 }
 
-void
-Route::set_graph_level (int32_t l)
-{
-        _graph_level = l;
-}
diff --git a/libs/ardour/session.cc b/libs/ardour/session.cc
index 3e22150762..f0aaf054ff 100644
--- a/libs/ardour/session.cc
+++ b/libs/ardour/session.cc
@@ -1354,10 +1354,6 @@ Session::resort_routes_using (shared_ptr<RouteList> r)
 	RouteList::iterator i, j;
 
 	for (i = r->begin(); i != r->end(); ++i) {
-                (*i)->check_physical_connections ();
-        }
-
-	for (i = r->begin(); i != r->end(); ++i) {
 
 		(*i)->clear_fed_by ();
 
@@ -1388,102 +1384,16 @@ Session::resort_routes_using (shared_ptr<RouteList> r)
 	RouteSorter cmp;
 	r->sort (cmp);
 
-        find_route_levels (r);
-
 #ifndef NDEBUG
         DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
 	for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
-		DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 signal order %2 level %3\n", 
-                                                           (*i)->name(), (*i)->order_key ("signal"),
-                                                           (*i)->graph_level()));
+		DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 signal order %2\n", 
+                                                           (*i)->name(), (*i)->order_key ("signal")));
 	}
 #endif
 
 }
 
-void
-Session::find_route_levels (shared_ptr<RouteList> rl)
-{
-        uint32_t setcnt = 0;
-        uint32_t limit = rl->size();
-        RouteList last_level;
-        RouteList this_level;
-
-        for (RouteList::iterator r = rl->begin(); r != rl->end(); ++r) {
-                
-                /* find routes with direct physical connections,
-                   or routes with no connections at all. Mark them
-                   with "special" level values, and push them into
-                   the "last_level" set.
-                
-                   All other routes get marked with a graph level
-                   of -1, which indicates that it needs to be set.
-
-                */
-                
-                if ((*r)->physically_connected()) {
-                        last_level.push_back (*r);
-                        (*r)->set_graph_level (0);
-                        setcnt++;
-                } else if (!(*r)->output()->connected()) {
-                        last_level.push_back (*r);
-                        (*r)->set_graph_level (INT32_MAX/2);
-                        setcnt++;
-                } else {
-                        (*r)->set_graph_level (-1);
-                }
-        }
-
-        // until we've set the graph level for every route ... 
-
-        while (setcnt < limit) {
-
-                for (RouteList::reverse_iterator r = rl->rbegin(); r != rl->rend(); ++r) {
-
-                        int32_t l = INT32_MAX;
-                        bool found = false;
-
-                        if ((*r)->graph_level() != -1) {
-                                // we already have the graph level for this route
-                                continue;
-                        }
-
-                        /* check if this route (r) has a direction connection to anything in
-                           the set of routes we processed last time. On the first pass
-                           through this, last_level will contain routes with either
-                           no connections or direct "physical" connections. If there is
-                           at least 1 connection, store the lowest graph level of whatever
-                           r is connected to.
-                        */
-
-                        for (RouteList::iterator o = last_level.begin(); o != last_level.end(); ++o) {
-                                bool sends_only;
-                                if ((*r)->direct_feeds (*o, &sends_only)) {
-                                        if (!sends_only) {
-                                                l = min (l, (*o)->graph_level());
-                                                found = true;
-                                        }
-                                }
-                        }
-
-                        /* if we found any connections, then mark the graph level of r, and push
-                           it into the "this_level" set that will become "last_level" next time
-                           around the while() loop.
-                        */
-
-                        if (found) {
-                                (*r)->set_graph_level (l + 1);
-                                this_level.push_back (*r);
-                                setcnt++;
-                        }
-                }
-
-                last_level = this_level;
-                this_level.clear ();
-        }
-}
-
-
 /** Find the route name starting with \a base with the lowest \a id.
  *
  * Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
diff --git a/libs/gtkmm2ext/gtkmm2ext/motionfeedback.h b/libs/gtkmm2ext/gtkmm2ext/motionfeedback.h
index cb256bed22..348cfbc25f 100644
--- a/libs/gtkmm2ext/gtkmm2ext/motionfeedback.h
+++ b/libs/gtkmm2ext/gtkmm2ext/motionfeedback.h
@@ -25,6 +25,7 @@
 #include <gtkmm/eventbox.h>
 
 #include "gtkmm2ext/binding_proxy.h"
+#include "gtkmm2ext/prolooks-helpers.h"
 
 namespace Gtk {
 	class Adjustment;
@@ -62,6 +63,7 @@ class MotionFeedback : public Gtk::VBox
 	gfloat range () { return _range; }
 
 	void set_controllable (boost::shared_ptr<PBD::Controllable> c) { binding_proxy.set_controllable (c); }
+        void set_lamp_color (const Gdk::Color&);
 
  protected:
 	gfloat _range;
@@ -100,6 +102,11 @@ class MotionFeedback : public Gtk::VBox
         int subwidth;
         int subheight;
 	void adjustment_changed ();
+
+	ProlooksHSV* lamp_hsv;
+        Gdk::Color _lamp_color;
+
+        void core_draw (cairo_t*, int, double, double, double);
 };
 
 } /* namespace */
diff --git a/libs/gtkmm2ext/gtkmm2ext/prolooks-helpers.h b/libs/gtkmm2ext/gtkmm2ext/prolooks-helpers.h
new file mode 100644
index 0000000000..4f1ed780e3
--- /dev/null
+++ b/libs/gtkmm2ext/gtkmm2ext/prolooks-helpers.h
@@ -0,0 +1,257 @@
+/* Helpers.c generated by valac, the Vala compiler */
+
+/* 
+    Copyright 2009 by Hans Baier
+    License: LGPLv2+ 
+*/
+
+#ifndef __prolooks_helpers_h__
+#define __prolooks_helpers_h__
+
+#include <glib.h>
+#include <glib-object.h>
+#include <float.h>
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+#include <cairo.h>
+#include <gdk/gdk.h>
+#include <gdk-pixbuf/gdk-pixdata.h>
+#include <gobject/gvaluecollector.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CAIRO_TYPE_COLOR (cairo_color_get_type ())
+#define CAIRO_COLOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CAIRO_TYPE_COLOR, CairoColor))
+#define CAIRO_COLOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CAIRO_TYPE_COLOR, CairoColorClass))
+#define CAIRO_IS_COLOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CAIRO_TYPE_COLOR))
+#define CAIRO_IS_COLOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CAIRO_TYPE_COLOR))
+#define CAIRO_COLOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CAIRO_TYPE_COLOR, CairoColorClass))
+
+typedef struct _CairoColor CairoColor;
+typedef struct _CairoColorClass CairoColorClass;
+typedef struct _CairoColorPrivate CairoColorPrivate;
+
+#define PROLOOKS_TYPE_HSL (prolooks_hsl_get_type ())
+#define PROLOOKS_HSL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PROLOOKS_TYPE_HSL, ProlooksHSL))
+#define PROLOOKS_HSL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PROLOOKS_TYPE_HSL, ProlooksHSLClass))
+#define PROLOOKS_IS_HSL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PROLOOKS_TYPE_HSL))
+#define PROLOOKS_IS_HSL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PROLOOKS_TYPE_HSL))
+#define PROLOOKS_HSL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PROLOOKS_TYPE_HSL, ProlooksHSLClass))
+
+typedef struct _ProlooksHSL ProlooksHSL;
+typedef struct _ProlooksHSLClass ProlooksHSLClass;
+#define _prolooks_hsl_unref0(var) ((var == NULL) ? NULL : (var = (prolooks_hsl_unref (var), NULL)))
+#define _cairo_color_unref0(var) ((var == NULL) ? NULL : (var = (cairo_color_unref (var), NULL)))
+typedef struct _CairoParamSpecColor CairoParamSpecColor;
+
+#define PROLOOKS_TYPE_BUTTON_STATE (prolooks_button_state_get_type ())
+
+#define PROLOOKS_TYPE_BUTTON_TYPE (prolooks_button_type_get_type ())
+#define _cairo_pattern_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_pattern_destroy (var), NULL)))
+typedef struct _ProlooksHSLPrivate ProlooksHSLPrivate;
+typedef struct _ProlooksParamSpecHSL ProlooksParamSpecHSL;
+
+#define PROLOOKS_TYPE_HSV (prolooks_hsv_get_type ())
+#define PROLOOKS_HSV(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PROLOOKS_TYPE_HSV, ProlooksHSV))
+#define PROLOOKS_HSV_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PROLOOKS_TYPE_HSV, ProlooksHSVClass))
+#define PROLOOKS_IS_HSV(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PROLOOKS_TYPE_HSV))
+#define PROLOOKS_IS_HSV_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PROLOOKS_TYPE_HSV))
+#define PROLOOKS_HSV_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PROLOOKS_TYPE_HSV, ProlooksHSVClass))
+
+typedef struct _ProlooksHSV ProlooksHSV;
+typedef struct _ProlooksHSVClass ProlooksHSVClass;
+typedef struct _ProlooksHSVPrivate ProlooksHSVPrivate;
+typedef struct _ProlooksParamSpecHSV ProlooksParamSpecHSV;
+
+struct _CairoColor {
+	GTypeInstance parent_instance;
+	volatile int ref_count;
+	CairoColorPrivate * priv;
+};
+
+struct _CairoColorClass {
+	GTypeClass parent_class;
+	void (*finalize) (CairoColor *self);
+};
+
+struct _CairoColorPrivate {
+	double _red;
+	double _green;
+	double _blue;
+	double _alpha;
+};
+
+struct _CairoParamSpecColor {
+	GParamSpec parent_instance;
+};
+
+typedef enum  {
+	PROLOOKS_BUTTON_STATE_NORMAL,
+	PROLOOKS_BUTTON_STATE_PRESSED
+} ProlooksButtonState;
+
+typedef enum  {
+	PROLOOKS_BUTTON_TYPE_PRESS_BUTTON,
+	PROLOOKS_BUTTON_TYPE_TOGGLE_BUTTON
+} ProlooksButtonType;
+
+struct _ProlooksHSL {
+	GTypeInstance parent_instance;
+	volatile int ref_count;
+	ProlooksHSLPrivate * priv;
+};
+
+struct _ProlooksHSLClass {
+	GTypeClass parent_class;
+	void (*finalize) (ProlooksHSL *self);
+};
+
+struct _ProlooksHSLPrivate {
+	double _hue;
+	double _saturation;
+	double _lightness;
+};
+
+struct _ProlooksParamSpecHSL {
+	GParamSpec parent_instance;
+};
+
+struct _ProlooksHSV {
+	GTypeInstance parent_instance;
+	volatile int ref_count;
+	ProlooksHSVPrivate * priv;
+};
+
+struct _ProlooksHSVClass {
+	GTypeClass parent_class;
+	void (*finalize) (ProlooksHSV *self);
+};
+
+struct _ProlooksHSVPrivate {
+	double _hue;
+	double _saturation;
+	double _value;
+};
+
+struct _ProlooksParamSpecHSV {
+	GParamSpec parent_instance;
+};
+
+
+static gpointer cairo_color_parent_class = NULL;
+static gpointer prolooks_hsl_parent_class = NULL;
+static gpointer prolooks_hsv_parent_class = NULL;
+
+gpointer cairo_color_ref (gpointer instance);
+void cairo_color_unref (gpointer instance);
+GParamSpec* cairo_param_spec_color (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
+void cairo_value_set_color (GValue* value, gpointer v_object);
+void cairo_value_take_color (GValue* value, gpointer v_object);
+gpointer cairo_value_get_color (const GValue* value);
+GType cairo_color_get_type (void);
+#define CAIRO_COLOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), CAIRO_TYPE_COLOR, CairoColorPrivate))
+enum  {
+	CAIRO_COLOR_DUMMY_PROPERTY
+};
+void cairo_color_set_red (CairoColor* self, double value);
+void cairo_color_set_green (CairoColor* self, double value);
+void cairo_color_set_blue (CairoColor* self, double value);
+void cairo_color_set_alpha (CairoColor* self, double value);
+CairoColor* cairo_color_new (double red, double green, double blue, double alpha);
+CairoColor* cairo_color_construct (GType object_type, double red, double green, double blue, double alpha);
+double cairo_color_get_red (CairoColor* self);
+double cairo_color_get_green (CairoColor* self);
+double cairo_color_get_blue (CairoColor* self);
+double cairo_color_get_alpha (CairoColor* self);
+CairoColor* cairo_color_copy (CairoColor* self);
+void cairo_color_set_from_string (CairoColor* self, const char* webcolor);
+CairoColor* cairo_color_new_from_string (const char* webcolor);
+CairoColor* cairo_color_construct_from_string (GType object_type, const char* webcolor);
+ProlooksHSL* prolooks_hsl_new (void);
+ProlooksHSL* prolooks_hsl_construct (GType object_type);
+gpointer prolooks_hsl_ref (gpointer instance);
+void prolooks_hsl_unref (gpointer instance);
+GParamSpec* prolooks_param_spec_hsl (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
+void prolooks_value_set_hsl (GValue* value, gpointer v_object);
+void prolooks_value_take_hsl (GValue* value, gpointer v_object);
+gpointer prolooks_value_get_hsl (const GValue* value);
+GType prolooks_hsl_get_type (void);
+void prolooks_hsl_from_cairo_color (ProlooksHSL* self, CairoColor* color);
+double prolooks_hsl_get_lightness (ProlooksHSL* self);
+void prolooks_hsl_set_lightness (ProlooksHSL* self, double value);
+double prolooks_hsl_get_saturation (ProlooksHSL* self);
+void prolooks_hsl_set_saturation (ProlooksHSL* self, double value);
+CairoColor* prolooks_hsl_to_cairo_color (ProlooksHSL* self);
+CairoColor* cairo_color_shade (CairoColor* self, double shade_factor);
+void cairo_color_set_to (CairoColor* self, CairoColor* a_color);
+void cairo_color_set_as_source_in (CairoColor* self, cairo_t* cr);
+void cairo_color_add_color_stop_to (CairoColor* self, cairo_pattern_t* p, double offset);
+CairoColor* prolooks_gdk_color_to_cairo (GdkColor* color);
+void prolooks_color_from_string (const char* webcolor, GdkColor* result);
+static void cairo_color_finalize (CairoColor* obj);
+GType prolooks_button_state_get_type (void);
+GType prolooks_button_type_get_type (void);
+void prolooks_set_line_width_from_device (cairo_t* cr);
+char* prolooks_color_to_string (GdkColor* color);
+CairoColor* prolooks_cairo_color_from_string (const char* webcolor);
+void prolooks_set_source_color (cairo_t* cr, GdkColor* color, double alpha);
+void prolooks_gdk_color_to_cairo_color (GdkColor* color, double* red, double* green, double* blue);
+void prolooks_cairo_color_to_gdk (CairoColor* cairo_color, GdkColor* result);
+void prolooks_set_source_color_string (cairo_t* cr, const char* color, double alpha);
+void prolooks_add_color_stop (cairo_pattern_t* p, double offset, GdkColor* color, double alpha);
+void prolooks_add_color_stop_str (cairo_pattern_t* p, double offset, const char* color, double alpha);
+cairo_pattern_t* prolooks_create_gradient (double x1, double y1, double x2, double y2, GdkColor* start, GdkColor* stop, double alpha_start, double alpha_stop);
+cairo_pattern_t* prolooks_create_gradient_str (double x1, double y1, double x2, double y2, const char* start, const char* stop, double alpha_start, double alpha_stop);
+void prolooks_rounded_rect (cairo_t* cr, double x, double y, double w, double h, double radius_x, double radius_y);
+void prolooks_background_gradient (cairo_t* cr, double w, double h);
+double prolooks_modula (double number, double divisor);
+#define PROLOOKS_HSL_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), PROLOOKS_TYPE_HSL, ProlooksHSLPrivate))
+enum  {
+	PROLOOKS_HSL_DUMMY_PROPERTY
+};
+double prolooks_hsl_get_hue (ProlooksHSL* self);
+char* prolooks_hsl_to_string (ProlooksHSL* self);
+void prolooks_hsl_to_gdk_color (ProlooksHSL* self, GdkColor* result);
+void prolooks_hsl_from_gdk_color (ProlooksHSL* self, GdkColor* color);
+void prolooks_hsl_set_hue (ProlooksHSL* self, double value);
+static void prolooks_hsl_finalize (ProlooksHSL* obj);
+gpointer prolooks_hsv_ref (gpointer instance);
+void prolooks_hsv_unref (gpointer instance);
+GParamSpec* prolooks_param_spec_hsv (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
+void prolooks_value_set_hsv (GValue* value, gpointer v_object);
+void prolooks_value_take_hsv (GValue* value, gpointer v_object);
+gpointer prolooks_value_get_hsv (const GValue* value);
+GType prolooks_hsv_get_type (void);
+#define PROLOOKS_HSV_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), PROLOOKS_TYPE_HSV, ProlooksHSVPrivate))
+enum  {
+	PROLOOKS_HSV_DUMMY_PROPERTY
+};
+double prolooks_hsv_get_hue (ProlooksHSV* self);
+double prolooks_hsv_get_saturation (ProlooksHSV* self);
+double prolooks_hsv_get_value (ProlooksHSV* self);
+char* prolooks_hsv_to_string (ProlooksHSV* self);
+void prolooks_hsv_from_gdk_color (ProlooksHSV* self, GdkColor* color);
+ProlooksHSV* prolooks_hsv_new_for_gdk_color (GdkColor* color);
+ProlooksHSV* prolooks_hsv_construct_for_gdk_color (GType object_type, GdkColor* color);
+void prolooks_hsv_from_cairo_color (ProlooksHSV* self, CairoColor* color);
+ProlooksHSV* prolooks_hsv_new_for_cairo_color (CairoColor* color);
+ProlooksHSV* prolooks_hsv_construct_for_cairo_color (GType object_type, CairoColor* color);
+CairoColor* prolooks_hsv_to_cairo_color (ProlooksHSV* self);
+void prolooks_hsv_to_gdk_color (ProlooksHSV* self, GdkColor* result);
+void prolooks_hsv_set_value (ProlooksHSV* self, double value);
+void prolooks_hsv_set_hue (ProlooksHSV* self, double value);
+void prolooks_hsv_set_saturation (ProlooksHSV* self, double value);
+ProlooksHSV* prolooks_hsv_new (void);
+ProlooksHSV* prolooks_hsv_construct (GType object_type);
+static void prolooks_hsv_finalize (ProlooksHSV* obj);
+void prolooks_shade_color (GdkColor* orig, double shade_ratio, GdkColor* result);
+GdkPixbuf* prolooks_cairo_image_surface_to_pixbuf (cairo_surface_t* surface);
+
+#ifdef __cplusplus
+} // extern "C" 
+#endif
+
+#endif /* __prolooks_helpers_h__ */
diff --git a/libs/gtkmm2ext/motionfeedback.cc b/libs/gtkmm2ext/motionfeedback.cc
index 06aa2e507e..bd08588de3 100644
--- a/libs/gtkmm2ext/motionfeedback.cc
+++ b/libs/gtkmm2ext/motionfeedback.cc
@@ -27,6 +27,7 @@
 
 #include "gtkmm2ext/motionfeedback.h"
 #include "gtkmm2ext/keyboard.h"
+#include "gtkmm2ext/prolooks-helpers.h"
 
 using namespace Gtk;
 using namespace Gtkmm2ext;
@@ -62,6 +63,8 @@ MotionFeedback::MotionFeedback (Glib::RefPtr<Gdk::Pixbuf> pix,
 	pack_start (*hpacker, false, false);
 	pixwin.show ();
 
+        set_lamp_color (Gdk::Color ("#b9feff"));
+
 	if (with_numeric_display) {
 
                 value_packer = new HBox;
@@ -296,10 +299,225 @@ MotionFeedback::adjustment_changed ()
 	pixwin.queue_draw ();
 }
 
+void
+MotionFeedback::core_draw (cairo_t* cr, int phase, double radius, double x, double y)
+{
+	double width;
+	double height;
+	double xc;
+	double yc;
+	double start_angle;
+	double end_angle;
+	double value_angle;
+	double value;
+	double value_x;
+	double value_y;
+	double start_angle_x;
+	double start_angle_y;
+	double end_angle_x;
+	double end_angle_y;
+	double progress_width;
+	double progress_radius;
+	double progress_radius_inner;
+	double progress_radius_outer;
+	double knob_disc_radius;
+	cairo_pattern_t* pattern;
+	GdkColor col2 = {0,0,0,0};
+	GdkColor lamp_bright;
+	GdkColor col3 = {0,0,0,0};
+	GdkColor lamp_dark;
+	double progress_rim_width;
+	cairo_pattern_t* progress_shine;
+	double degrees;
+	cairo_pattern_t* knob_ripples;
+
+	g_return_if_fail (cr != NULL);
+
+	cairo_set_source_rgba (cr, 0.75, 0.75, 0.75, (double) 0);
+	cairo_rectangle (cr, (double) 0, (double) 0, subwidth, subheight);
+	cairo_fill (cr);
+
+	width = 105.0;
+	height = 105.0;
+	xc = width / 2.0;
+	yc = height / 2.0;
+	start_angle = 0.0;
+	end_angle = 0.0;
+	value_angle = 0.0;
+	value = (phase * 1.0) / (65 - 1);
+
+        start_angle = ((180 - 45) * G_PI) / 180;
+        end_angle = ((360 + 45) * G_PI) / 180;
+
+	value_angle = start_angle + (value * (end_angle - start_angle));
+	value_x = cos (value_angle);
+	value_y = sin (value_angle);
+	start_angle_x = cos (start_angle);
+	start_angle_y = sin (start_angle);
+	end_angle_x = cos (end_angle);
+	end_angle_y = sin (end_angle);
+	cairo_save (cr);
+	//cairo_translate (cr, x, (double) 0);
+	cairo_scale (cr, (2.0 * radius) / width, (2.0 * radius) / height);
+	//cairo_translate (cr, -xc, (double) 0);
+
+        pattern = prolooks_create_gradient_str ((double) 32, (double) 16, (double) 75, (double) 16, "#d4c8b9", "#ae977b", 1.0, 1.0);
+        cairo_set_source (cr, pattern);
+	cairo_pattern_destroy (pattern);
+	cairo_set_line_width (cr, 2.0);
+	cairo_arc (cr, xc, yc, 31.5, 0.0, 2 * G_PI);
+	cairo_stroke (cr);
+
+	progress_width = 20.0;
+	progress_radius = 40.0;
+	progress_radius_inner = progress_radius - (progress_width / 2.0);
+	progress_radius_outer = progress_radius + (progress_width / 2.0);
+	knob_disc_radius = progress_radius_inner - 5.0;
+
+        pattern = prolooks_create_gradient_str ((double) 20, (double) 20, (double) 89, (double) 87, "#2f2f4c", "#090a0d", 1.0, 1.0);
+	cairo_set_source (cr, pattern);
+	cairo_pattern_destroy (pattern);
+	cairo_set_line_width (cr, progress_width);
+	cairo_arc (cr, xc, yc, progress_radius, start_angle, end_angle);
+	cairo_stroke (cr);
+
+	lamp_bright = (prolooks_hsv_to_gdk_color (lamp_hsv, &col2), col2);
+	prolooks_hsv_set_saturation (lamp_hsv, 0.66);
+	prolooks_hsv_set_value (lamp_hsv, 0.67);
+	lamp_dark = (prolooks_hsv_to_gdk_color (lamp_hsv, &col3), col3);
+
+        pattern = prolooks_create_gradient ((double) 20, (double) 20, (double) 89, (double) 87, &lamp_bright, &lamp_dark, 1.0, 1.0);
+	cairo_set_source (cr, pattern);
+	cairo_pattern_destroy (pattern);
+	cairo_set_line_width (cr, progress_width);
+	cairo_arc (cr, xc, yc, progress_radius, start_angle, value_angle);
+	cairo_stroke (cr);
+
+	cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
+	progress_rim_width = 2.0;
+	cairo_set_line_width (cr, progress_rim_width);
+        pattern = prolooks_create_gradient_str ((double) 18, (double) 79, (double) 35, (double) 79, "#dfd5c9", "#dfd5c9", 1.0, 0.0);
+	cairo_set_source (cr, pattern);
+	cairo_pattern_destroy (pattern);
+	cairo_move_to (cr, xc + (progress_radius_outer * start_angle_x), yc + (progress_radius_outer * start_angle_y));
+	cairo_line_to (cr, xc + (progress_radius_inner * start_angle_x), yc + (progress_radius_inner * start_angle_y));
+	cairo_stroke (cr);
+
+	prolooks_set_source_color_string (cr, "#b3a190", 1.0);
+	cairo_move_to (cr, xc + (progress_radius_outer * end_angle_x), yc + (progress_radius_outer * end_angle_y));
+	cairo_line_to (cr, xc + (progress_radius_inner * end_angle_x), yc + (progress_radius_inner * end_angle_y));
+	cairo_stroke (cr);
+
+        pattern = prolooks_create_gradient_str ((double) 95, (double) 6, (double) 5, (double) 44, "#dfd5c9", "#b0a090", 1.0, 1.0);
+	cairo_set_source (cr, pattern);
+	cairo_pattern_destroy (pattern);
+	cairo_arc (cr, xc, yc, progress_radius_outer, start_angle, end_angle);
+	cairo_stroke (cr);
+
+	cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT);
+        pattern = prolooks_create_gradient ((double) 20, (double) 20, (double) 89, (double) 87, &lamp_bright, &lamp_dark, 0.25, 0.25);
+	cairo_set_source (cr, pattern);
+	cairo_pattern_destroy (pattern);
+	cairo_set_line_width (cr, progress_width);
+	cairo_arc (cr, xc, yc, progress_radius, start_angle, value_angle + (G_PI / 180.0));
+	cairo_stroke (cr);
+
+	progress_shine = prolooks_create_gradient_str ((double) 89, (double) 73, (double) 34, (double) 16, "#ffffff", "#ffffff", 0.3, 0.04);
+	cairo_pattern_add_color_stop_rgba (progress_shine, 0.5, 1.0, 1.0, 1.0, 0.0);
+	cairo_pattern_add_color_stop_rgba (progress_shine, 0.75, 1.0, 1.0, 1.0, 0.3);
+	cairo_set_source (cr, progress_shine);
+	cairo_set_line_width (cr, progress_width);
+	cairo_arc (cr, xc, yc, progress_radius, start_angle, end_angle);
+	cairo_stroke (cr);
+
+	cairo_set_line_width (cr, 1.0);
+	cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
+	cairo_arc (cr, xc, yc, progress_radius_inner, (double) 0, 2 * G_PI);
+        pattern = prolooks_create_gradient_str ((double) 35, (double) 31, (double) 75, (double) 72, "#68625c", "#44494b", 1.0, 1.0);
+	cairo_set_source (cr, pattern);
+	cairo_pattern_destroy (pattern);
+	cairo_fill (cr);
+	cairo_set_source_rgb (cr, (double) 0, (double) 0, (double) 0);
+	cairo_arc (cr, xc, yc, progress_radius_inner, (double) 0, 2 * G_PI);
+	cairo_stroke (cr);
+
+        pattern = prolooks_create_gradient_str ((double) 42, (double) 34, (double) 68, (double) 70, "#e7ecef", "#9cafb8", 1.0, 1.0);
+	cairo_set_source (cr, pattern);
+	cairo_pattern_destroy (pattern);
+	cairo_arc (cr, xc, yc, knob_disc_radius, (double) 0, 2 * G_PI);
+	cairo_fill (cr);
+
+	cairo_set_line_width (cr, 2.0);
+	degrees = G_PI / 180.0;
+        pattern = prolooks_create_gradient_str ((double) 38, (double) 34, (double) 70, (double) 68, "#ffffff", "#caddf2", 0.2, 0.2);
+	cairo_set_source (cr, pattern);
+	cairo_pattern_destroy (pattern);
+	cairo_move_to (cr, xc, yc);
+	cairo_arc (cr, xc, yc, knob_disc_radius - 1, (-154) * degrees, (-120) * degrees);
+	cairo_move_to (cr, xc, yc);
+	cairo_arc (cr, xc, yc, knob_disc_radius - 1, (G_PI / 2.0) - (60 * degrees), (G_PI / 2.0) - (29 * degrees));
+	cairo_fill (cr);
+
+        pattern = prolooks_create_gradient_str ((double) 50, (double) 40, (double) 62, (double) 60, "#a1adb6", "#47535c", 0.07, 0.15);
+	cairo_set_source (cr, pattern);
+	cairo_pattern_destroy (pattern);
+	cairo_move_to (cr, xc, yc);
+	cairo_arc (cr, xc, yc, knob_disc_radius - 1, (-67) * degrees, (-27) * degrees);
+	cairo_move_to (cr, xc, yc);
+	cairo_arc (cr, xc, yc, knob_disc_radius - 1, G_PI - (67 * degrees), G_PI - (27 * degrees));
+	cairo_fill (cr);
+
+	knob_ripples = cairo_pattern_create_radial (xc, yc, (double) 0, xc, yc, (double) 4);
+	prolooks_add_color_stop_str (knob_ripples, 0.0, "#e7ecef", 0.05);
+	prolooks_add_color_stop_str (knob_ripples, 0.5, "#58717d", 0.05);
+	prolooks_add_color_stop_str (knob_ripples, 0.75, "#d1d9de", 0.05);
+	prolooks_add_color_stop_str (knob_ripples, 1.0, "#5d7682", 0.05);
+	cairo_pattern_set_extend (knob_ripples, CAIRO_EXTEND_REPEAT);
+	cairo_set_line_width (cr, 0.0);
+	cairo_set_source (cr, knob_ripples);
+	cairo_arc (cr, xc, yc, knob_disc_radius, (double) 0, 2 * G_PI);
+	cairo_fill (cr);
+
+	cairo_save (cr);
+	cairo_translate (cr, xc + (knob_disc_radius * value_x), yc + (knob_disc_radius * value_y));
+	cairo_rotate (cr, value_angle - G_PI);
+	cairo_set_source (cr, pattern = prolooks_create_gradient_str ((double) 16, (double) (-2), (double) 9, (double) 13, "#e7ecef", "#9cafb8", 0.8, 0.8));
+	cairo_pattern_destroy (pattern);
+	cairo_move_to (cr, (double) 0, (double) 4);
+	cairo_line_to (cr, (double) 17, (double) 4);
+	cairo_curve_to (cr, (double) 19, (double) 4, (double) 21, (double) 2, (double) 21, (double) 0);
+	cairo_curve_to (cr, (double) 21, (double) (-2), (double) 19, (double) (-4), (double) 17, (double) (-4));
+	cairo_line_to (cr, (double) 0, (double) (-4));
+	cairo_close_path (cr);
+	cairo_fill (cr);
+
+        pattern = prolooks_create_gradient_str ((double) 9, (double) (-2), (double) 9, (double) 2, "#68625c", "#44494b", 1.0, 1.0);
+	cairo_set_source (cr, pattern);
+	cairo_pattern_destroy (pattern);
+	cairo_move_to (cr, (double) 0, (double) 2);
+	cairo_line_to (cr, (double) 16, (double) 2);
+	cairo_curve_to (cr, (double) 17, (double) 2, (double) 18, (double) 1, (double) 18, (double) 0);
+	cairo_curve_to (cr, (double) 18, (double) (-1), (double) 17, (double) (-2), (double) 16, (double) (-2));
+	cairo_line_to (cr, (double) 0, (double) (-2));
+	cairo_close_path (cr);
+	cairo_fill (cr);
+
+	cairo_restore (cr);
+	cairo_set_line_width (cr, 2.0);
+        pattern = prolooks_create_gradient_str ((double) 38, (double) 32, (double) 70, (double) 67, "#3d3d3d", "#000000", 1.0, 1.0);
+        cairo_set_source (cr, pattern);
+	cairo_pattern_destroy (pattern);
+	cairo_arc (cr, xc, yc, knob_disc_radius, (double) 0, 2 * G_PI);
+	cairo_stroke (cr);
+	cairo_restore (cr);
+
+	cairo_pattern_destroy (progress_shine);
+	cairo_pattern_destroy (knob_ripples);
+}
+
 bool
 MotionFeedback::pixwin_expose_event (GdkEventExpose* ev)
 {
-	GtkWidget* widget = GTK_WIDGET(pixwin.gobj());
 	GdkWindow *window = pixwin.get_window()->gobj();
 	GtkAdjustment* adj = adjustment->gobj();
 
@@ -333,11 +551,14 @@ MotionFeedback::pixwin_expose_event (GdkEventExpose* ev)
 			phase = (phase + 63) % 64;
 	}
 
-	gdk_draw_pixbuf (GDK_DRAWABLE(window), widget->style->fg_gc[0], 
-			 pixbuf->gobj(), 
-			 phase * subwidth, type * subheight, 
-			 0, 0, subwidth, subheight, GDK_RGB_DITHER_NORMAL, 0, 0);
-	
+	cairo_t* cr = gdk_cairo_create (GDK_DRAWABLE (window));
+
+	gdk_cairo_rectangle (cr, &ev->area);
+	cairo_clip (cr);
+
+        core_draw (cr, phase, subheight/2, subwidth/2, subheight/2);
+        cairo_destroy (cr);
+
 	return true;
 }
 
@@ -375,3 +596,10 @@ MotionFeedback::pixwin_size_request (GtkRequisition* req)
 	req->width = subwidth;
 	req->height = subheight;
 }
+
+void
+MotionFeedback::set_lamp_color (const Gdk::Color& c)
+{
+	_lamp_color = c;
+	lamp_hsv = prolooks_hsv_new_for_gdk_color (_lamp_color.gobj());
+}
diff --git a/libs/gtkmm2ext/prolooks_helpers.c b/libs/gtkmm2ext/prolooks_helpers.c
new file mode 100644
index 0000000000..2795b29c6c
--- /dev/null
+++ b/libs/gtkmm2ext/prolooks_helpers.c
@@ -0,0 +1,1378 @@
+/* Helpers.c generated by valac, the Vala compiler
+ * generated from Helpers.vala, do not modify */
+
+/* 
+    Copyright 2009 by Hans Baier
+    License: LGPLv2+ 
+*/
+
+#include "gtkmm2ext/prolooks-helpers.h"
+
+CairoColor* cairo_color_construct (GType object_type, double red, double green, double blue, double alpha) {
+	CairoColor* self;
+	self = (CairoColor*) g_type_create_instance (object_type);
+	cairo_color_set_red (self, red);
+	cairo_color_set_green (self, green);
+	cairo_color_set_blue (self, blue);
+	cairo_color_set_alpha (self, alpha);
+	return self;
+}
+
+
+CairoColor* cairo_color_new (double red, double green, double blue, double alpha) {
+	return cairo_color_construct (CAIRO_TYPE_COLOR, red, green, blue, alpha);
+}
+
+
+CairoColor* cairo_color_copy (CairoColor* self) {
+	CairoColor* result = NULL;
+	g_return_val_if_fail (self != NULL, NULL);
+	result = cairo_color_new (self->priv->_red, self->priv->_green, self->priv->_blue, self->priv->_alpha);
+	return result;
+}
+
+
+CairoColor* cairo_color_construct_from_string (GType object_type, const char* webcolor) {
+	CairoColor* self;
+	g_return_val_if_fail (webcolor != NULL, NULL);
+	self = (CairoColor*) g_type_create_instance (object_type);
+	cairo_color_set_from_string (self, webcolor);
+	return self;
+}
+
+
+CairoColor* cairo_color_new_from_string (const char* webcolor) {
+	return cairo_color_construct_from_string (CAIRO_TYPE_COLOR, webcolor);
+}
+
+
+CairoColor* cairo_color_shade (CairoColor* self, double shade_factor) {
+	CairoColor* result = NULL;
+	ProlooksHSL* hsl;
+	g_return_val_if_fail (self != NULL, NULL);
+	hsl = prolooks_hsl_new ();
+	prolooks_hsl_from_cairo_color (hsl, self);
+	prolooks_hsl_set_lightness (hsl, fmin (prolooks_hsl_get_lightness (hsl) * shade_factor, 1.0));
+	prolooks_hsl_set_lightness (hsl, fmax (prolooks_hsl_get_lightness (hsl), 0.0));
+	prolooks_hsl_set_saturation (hsl, fmin (prolooks_hsl_get_saturation (hsl) * shade_factor, 1.0));
+	prolooks_hsl_set_saturation (hsl, fmax (prolooks_hsl_get_saturation (hsl), 0.0));
+	result = prolooks_hsl_to_cairo_color (hsl);
+	_prolooks_hsl_unref0 (hsl);
+	return result;
+}
+
+
+void cairo_color_set_to (CairoColor* self, CairoColor* a_color) {
+	g_return_if_fail (self != NULL);
+	g_return_if_fail (a_color != NULL);
+	cairo_color_set_red (self, a_color->priv->_red);
+	cairo_color_set_green (self, a_color->priv->_green);
+	cairo_color_set_blue (self, a_color->priv->_blue);
+	cairo_color_set_alpha (self, a_color->priv->_alpha);
+}
+
+
+void cairo_color_set_as_source_in (CairoColor* self, cairo_t* cr) {
+	g_return_if_fail (self != NULL);
+	g_return_if_fail (cr != NULL);
+	cairo_set_source_rgba (cr, self->priv->_red, self->priv->_green, self->priv->_blue, self->priv->_alpha);
+}
+
+
+void cairo_color_add_color_stop_to (CairoColor* self, cairo_pattern_t* p, double offset) {
+	g_return_if_fail (self != NULL);
+	g_return_if_fail (p != NULL);
+	cairo_pattern_add_color_stop_rgba (p, offset, self->priv->_red, self->priv->_green, self->priv->_blue, self->priv->_alpha);
+}
+
+
+void cairo_color_set_from_string (CairoColor* self, const char* webcolor) {
+	CairoColor* _tmp2_;
+	GdkColor _tmp1_;
+	GdkColor _tmp0_ = {0,0,0,0};
+	g_return_if_fail (self != NULL);
+	g_return_if_fail (webcolor != NULL);
+	cairo_color_set_to (self, _tmp2_ = prolooks_gdk_color_to_cairo ((_tmp1_ = (prolooks_color_from_string (webcolor, &_tmp0_), _tmp0_), &_tmp1_)));
+	_cairo_color_unref0 (_tmp2_);
+}
+
+
+double cairo_color_get_red (CairoColor* self) {
+	double result;
+	g_return_val_if_fail (self != NULL, 0.0);
+	result = self->priv->_red;
+	return result;
+}
+
+
+void cairo_color_set_red (CairoColor* self, double value) {
+	g_return_if_fail (self != NULL);
+	self->priv->_red = value;
+}
+
+
+double cairo_color_get_green (CairoColor* self) {
+	double result;
+	g_return_val_if_fail (self != NULL, 0.0);
+	result = self->priv->_green;
+	return result;
+}
+
+
+void cairo_color_set_green (CairoColor* self, double value) {
+	g_return_if_fail (self != NULL);
+	self->priv->_green = value;
+}
+
+
+double cairo_color_get_blue (CairoColor* self) {
+	double result;
+	g_return_val_if_fail (self != NULL, 0.0);
+	result = self->priv->_blue;
+	return result;
+}
+
+
+void cairo_color_set_blue (CairoColor* self, double value) {
+	g_return_if_fail (self != NULL);
+	self->priv->_blue = value;
+}
+
+
+double cairo_color_get_alpha (CairoColor* self) {
+	double result;
+	g_return_val_if_fail (self != NULL, 0.0);
+	result = self->priv->_alpha;
+	return result;
+}
+
+
+void cairo_color_set_alpha (CairoColor* self, double value) {
+	g_return_if_fail (self != NULL);
+	self->priv->_alpha = value;
+}
+
+
+static void cairo_value_color_init (GValue* value) {
+	value->data[0].v_pointer = NULL;
+}
+
+
+static void cairo_value_color_free_value (GValue* value) {
+	if (value->data[0].v_pointer) {
+		cairo_color_unref (value->data[0].v_pointer);
+	}
+}
+
+
+static void cairo_value_color_copy_value (const GValue* src_value, GValue* dest_value) {
+	if (src_value->data[0].v_pointer) {
+		dest_value->data[0].v_pointer = cairo_color_ref (src_value->data[0].v_pointer);
+	} else {
+		dest_value->data[0].v_pointer = NULL;
+	}
+}
+
+
+static gpointer cairo_value_color_peek_pointer (const GValue* value) {
+	return value->data[0].v_pointer;
+}
+
+
+static gchar* cairo_value_color_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
+	if (collect_values[0].v_pointer) {
+		CairoColor* object;
+		object = collect_values[0].v_pointer;
+		if (object->parent_instance.g_class == NULL) {
+			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
+		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
+			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
+		}
+		value->data[0].v_pointer = cairo_color_ref (object);
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	return NULL;
+}
+
+
+static gchar* cairo_value_color_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
+	CairoColor** object_p;
+	object_p = collect_values[0].v_pointer;
+	if (!object_p) {
+		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+	}
+	if (!value->data[0].v_pointer) {
+		*object_p = NULL;
+	} else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) {
+		*object_p = value->data[0].v_pointer;
+	} else {
+		*object_p = cairo_color_ref (value->data[0].v_pointer);
+	}
+	return NULL;
+}
+
+
+GParamSpec* cairo_param_spec_color (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
+	CairoParamSpecColor* spec;
+	g_return_val_if_fail (g_type_is_a (object_type, CAIRO_TYPE_COLOR), NULL);
+	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
+	G_PARAM_SPEC (spec)->value_type = object_type;
+	return G_PARAM_SPEC (spec);
+}
+
+
+gpointer cairo_value_get_color (const GValue* value) {
+	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, CAIRO_TYPE_COLOR), NULL);
+	return value->data[0].v_pointer;
+}
+
+
+void cairo_value_set_color (GValue* value, gpointer v_object) {
+	CairoColor* old;
+	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, CAIRO_TYPE_COLOR));
+	old = value->data[0].v_pointer;
+	if (v_object) {
+		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, CAIRO_TYPE_COLOR));
+		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
+		value->data[0].v_pointer = v_object;
+		cairo_color_ref (value->data[0].v_pointer);
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	if (old) {
+		cairo_color_unref (old);
+	}
+}
+
+
+void cairo_value_take_color (GValue* value, gpointer v_object) {
+	CairoColor* old;
+	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, CAIRO_TYPE_COLOR));
+	old = value->data[0].v_pointer;
+	if (v_object) {
+		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, CAIRO_TYPE_COLOR));
+		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
+		value->data[0].v_pointer = v_object;
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	if (old) {
+		cairo_color_unref (old);
+	}
+}
+
+
+static void cairo_color_class_init (CairoColorClass * klass) {
+	cairo_color_parent_class = g_type_class_peek_parent (klass);
+	CAIRO_COLOR_CLASS (klass)->finalize = cairo_color_finalize;
+	g_type_class_add_private (klass, sizeof (CairoColorPrivate));
+}
+
+
+static void cairo_color_instance_init (CairoColor * self) {
+	self->priv = CAIRO_COLOR_GET_PRIVATE (self);
+	self->ref_count = 1;
+}
+
+
+static void cairo_color_finalize (CairoColor* obj) {
+	CairoColor * self;
+	self = CAIRO_COLOR (obj);
+}
+
+
+GType cairo_color_get_type (void) {
+	static volatile gsize cairo_color_type_id__volatile = 0;
+	if (g_once_init_enter (&cairo_color_type_id__volatile)) {
+		static const GTypeValueTable g_define_type_value_table = { cairo_value_color_init, cairo_value_color_free_value, cairo_value_color_copy_value, cairo_value_color_peek_pointer, "p", cairo_value_color_collect_value, "p", cairo_value_color_lcopy_value };
+		static const GTypeInfo g_define_type_info = { sizeof (CairoColorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) cairo_color_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (CairoColor), 0, (GInstanceInitFunc) cairo_color_instance_init, &g_define_type_value_table };
+		static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
+		GType cairo_color_type_id;
+		cairo_color_type_id = g_type_register_fundamental (g_type_fundamental_next (), "CairoColor", &g_define_type_info, &g_define_type_fundamental_info, 0);
+		g_once_init_leave (&cairo_color_type_id__volatile, cairo_color_type_id);
+	}
+	return cairo_color_type_id__volatile;
+}
+
+
+gpointer cairo_color_ref (gpointer instance) {
+	CairoColor* self;
+	self = instance;
+	g_atomic_int_inc (&self->ref_count);
+	return instance;
+}
+
+
+void cairo_color_unref (gpointer instance) {
+	CairoColor* self;
+	self = instance;
+	if (g_atomic_int_dec_and_test (&self->ref_count)) {
+		CAIRO_COLOR_GET_CLASS (self)->finalize (self);
+		g_type_free_instance ((GTypeInstance *) self);
+	}
+}
+
+
+GType prolooks_button_state_get_type (void) {
+	static volatile gsize prolooks_button_state_type_id__volatile = 0;
+	if (g_once_init_enter (&prolooks_button_state_type_id__volatile)) {
+		static const GEnumValue values[] = {{PROLOOKS_BUTTON_STATE_NORMAL, "PROLOOKS_BUTTON_STATE_NORMAL", "normal"}, {PROLOOKS_BUTTON_STATE_PRESSED, "PROLOOKS_BUTTON_STATE_PRESSED", "pressed"}, {0, NULL, NULL}};
+		GType prolooks_button_state_type_id;
+		prolooks_button_state_type_id = g_enum_register_static ("ProlooksButtonState", values);
+		g_once_init_leave (&prolooks_button_state_type_id__volatile, prolooks_button_state_type_id);
+	}
+	return prolooks_button_state_type_id__volatile;
+}
+
+
+GType prolooks_button_type_get_type (void) {
+	static volatile gsize prolooks_button_type_type_id__volatile = 0;
+	if (g_once_init_enter (&prolooks_button_type_type_id__volatile)) {
+		static const GEnumValue values[] = {{PROLOOKS_BUTTON_TYPE_PRESS_BUTTON, "PROLOOKS_BUTTON_TYPE_PRESS_BUTTON", "press-button"}, {PROLOOKS_BUTTON_TYPE_TOGGLE_BUTTON, "PROLOOKS_BUTTON_TYPE_TOGGLE_BUTTON", "toggle-button"}, {0, NULL, NULL}};
+		GType prolooks_button_type_type_id;
+		prolooks_button_type_type_id = g_enum_register_static ("ProlooksButtonType", values);
+		g_once_init_leave (&prolooks_button_type_type_id__volatile, prolooks_button_type_type_id);
+	}
+	return prolooks_button_type_type_id__volatile;
+}
+
+
+void prolooks_set_line_width_from_device (cairo_t* cr) {
+	double ux;
+	double uy;
+	g_return_if_fail (cr != NULL);
+	ux = (double) 1;
+	uy = (double) 1;
+	cairo_device_to_user (cr, &ux, &uy);
+	if (ux < uy) {
+		ux = uy;
+	}
+	cairo_set_line_width (cr, ux);
+}
+
+
+void prolooks_color_from_string (const char* webcolor, GdkColor* result) {
+	GdkColor color = {0,0,0,0};
+	g_return_if_fail (webcolor != NULL);
+	gdk_color_parse (webcolor, &color);
+	*result = color;
+	return;
+}
+
+
+char* prolooks_color_to_string (GdkColor* color) {
+	char* result = NULL;
+	guint16 scale;
+	scale = G_MAXUINT16 / G_MAXUINT8;
+	result = g_strdup_printf ("#%02x%02x%02x", (guint) ((*color).red / scale), (guint) ((*color).green / scale), (guint) ((*color).blue / scale));
+	return result;
+}
+
+
+CairoColor* prolooks_cairo_color_from_string (const char* webcolor) {
+	CairoColor* result = NULL;
+	GdkColor _tmp1_;
+	GdkColor _tmp0_ = {0,0,0,0};
+	g_return_val_if_fail (webcolor != NULL, NULL);
+	result = prolooks_gdk_color_to_cairo ((_tmp1_ = (prolooks_color_from_string (webcolor, &_tmp0_), _tmp0_), &_tmp1_));
+	return result;
+}
+
+
+void prolooks_set_source_color (cairo_t* cr, GdkColor* color, double alpha) {
+	g_return_if_fail (cr != NULL);
+	cairo_set_source_rgba (cr, ((double) (*color).red) / ((double) G_MAXUINT16), ((double) (*color).green) / ((double) G_MAXUINT16), ((double) (*color).blue) / ((double) G_MAXUINT16), alpha);
+}
+
+
+void prolooks_gdk_color_to_cairo_color (GdkColor* color, double* red, double* green, double* blue) {
+	*red = ((double) (*color).red) / ((double) G_MAXUINT16);
+	*green = ((double) (*color).green) / ((double) G_MAXUINT16);
+	*blue = ((double) (*color).blue) / ((double) G_MAXUINT16);
+}
+
+
+CairoColor* prolooks_gdk_color_to_cairo (GdkColor* color) {
+	CairoColor* result = NULL;
+	double r;
+	double g;
+	double b;
+	r = (double) 0;
+	g = (double) 0;
+	b = (double) 0;
+	prolooks_gdk_color_to_cairo_color (color, &r, &g, &b);
+	result = cairo_color_new (r, g, b, 1.0);
+	return result;
+}
+
+
+void prolooks_cairo_color_to_gdk (CairoColor* cairo_color, GdkColor* result) {
+	GdkColor color = {0,0,0,0};
+	g_return_if_fail (cairo_color != NULL);
+	memset (&color, 0, sizeof (GdkColor));
+	color.red = (guint16) (cairo_color_get_red (cairo_color) * ((double) G_MAXUINT16));
+	color.green = (guint16) (cairo_color_get_green (cairo_color) * ((double) G_MAXUINT16));
+	color.blue = (guint16) (cairo_color_get_blue (cairo_color) * ((double) G_MAXUINT16));
+	*result = color;
+	return;
+}
+
+
+void prolooks_set_source_color_string (cairo_t* cr, const char* color, double alpha) {
+	GdkColor _tmp1_;
+	GdkColor _tmp0_ = {0,0,0,0};
+	g_return_if_fail (cr != NULL);
+	g_return_if_fail (color != NULL);
+	prolooks_set_source_color (cr, (_tmp1_ = (prolooks_color_from_string (color, &_tmp0_), _tmp0_), &_tmp1_), alpha);
+}
+
+
+void prolooks_add_color_stop (cairo_pattern_t* p, double offset, GdkColor* color, double alpha) {
+	g_return_if_fail (p != NULL);
+	cairo_pattern_add_color_stop_rgba (p, offset, ((double) (*color).red) / ((double) G_MAXUINT16), ((double) (*color).green) / ((double) G_MAXUINT16), ((double) (*color).blue) / ((double) G_MAXUINT16), alpha);
+}
+
+
+void prolooks_add_color_stop_str (cairo_pattern_t* p, double offset, const char* color, double alpha) {
+	GdkColor _tmp1_;
+	GdkColor _tmp0_ = {0,0,0,0};
+	g_return_if_fail (p != NULL);
+	g_return_if_fail (color != NULL);
+	prolooks_add_color_stop (p, offset, (_tmp1_ = (prolooks_color_from_string (color, &_tmp0_), _tmp0_), &_tmp1_), alpha);
+}
+
+
+cairo_pattern_t* prolooks_create_gradient (double x1, double y1, double x2, double y2, GdkColor* start, GdkColor* stop, double alpha_start, double alpha_stop) {
+	cairo_pattern_t* result = NULL;
+	cairo_pattern_t* gradient;
+	gradient = cairo_pattern_create_linear (x1, y1, x2, y2);
+	prolooks_add_color_stop (gradient, (double) 0, start, alpha_start);
+	prolooks_add_color_stop (gradient, (double) 1, stop, alpha_stop);
+	result = gradient;
+	return result;
+}
+
+
+cairo_pattern_t* prolooks_create_gradient_str (double x1, double y1, double x2, double y2, const char* start, const char* stop, double alpha_start, double alpha_stop) {
+	cairo_pattern_t* result = NULL;
+	GdkColor _tmp3_;
+	GdkColor _tmp2_;
+	GdkColor _tmp1_ = {0,0,0,0};
+	GdkColor _tmp0_ = {0,0,0,0};
+	g_return_val_if_fail (start != NULL, NULL);
+	g_return_val_if_fail (stop != NULL, NULL);
+	result = prolooks_create_gradient (x1, y1, x2, y2, (_tmp2_ = (prolooks_color_from_string (start, &_tmp0_), _tmp0_), &_tmp2_), (_tmp3_ = (prolooks_color_from_string (stop, &_tmp1_), _tmp1_), &_tmp3_), alpha_start, alpha_stop);
+	return result;
+}
+
+
+void prolooks_rounded_rect (cairo_t* cr, double x, double y, double w, double h, double radius_x, double radius_y) {
+	double ARC_TO_BEZIER;
+	double c1;
+	double c2;
+	g_return_if_fail (cr != NULL);
+	ARC_TO_BEZIER = 0.55228475;
+	if (radius_x > (w - radius_x)) {
+		radius_x = w / 2;
+	}
+	if (radius_y > (h - radius_y)) {
+		radius_y = h / 2;
+	}
+	c1 = ARC_TO_BEZIER * radius_x;
+	c2 = ARC_TO_BEZIER * radius_y;
+	cairo_new_path (cr);
+	cairo_move_to (cr, x + radius_x, y);
+	cairo_rel_line_to (cr, w - (2 * radius_x), 0.0);
+	cairo_rel_curve_to (cr, c1, 0.0, radius_x, c2, radius_x, radius_y);
+	cairo_rel_line_to (cr, (double) 0, h - (2 * radius_y));
+	cairo_rel_curve_to (cr, 0.0, c2, c1 - radius_x, radius_y, -radius_x, radius_y);
+	cairo_rel_line_to (cr, (-w) + (2 * radius_x), (double) 0);
+	cairo_rel_curve_to (cr, -c1, (double) 0, -radius_x, -c2, -radius_x, -radius_y);
+	cairo_rel_line_to (cr, (double) 0, (-h) + (2 * radius_y));
+	cairo_rel_curve_to (cr, 0.0, -c2, radius_x - c1, -radius_y, radius_x, -radius_y);
+	cairo_close_path (cr);
+}
+
+
+void prolooks_background_gradient (cairo_t* cr, double w, double h) {
+	GdkColor background_gradient_start = {0,0,0,0};
+	GdkColor background_gradient_stop = {0,0,0,0};
+	cairo_pattern_t* background_gradient;
+	g_return_if_fail (cr != NULL);
+	gdk_color_parse ("#bebdc2", &background_gradient_start);
+	gdk_color_parse ("#b1b4b9", &background_gradient_stop);
+	cairo_rectangle (cr, (double) 0, (double) 0, w, h);
+	background_gradient = cairo_pattern_create_linear ((double) 0, (double) 0, (double) 0, h);
+	prolooks_add_color_stop (background_gradient, (double) 0, &background_gradient_start, 1.0);
+	prolooks_add_color_stop (background_gradient, (double) 1, &background_gradient_stop, 1.0);
+	cairo_set_source (cr, background_gradient);
+	cairo_fill (cr);
+	_cairo_pattern_destroy0 (background_gradient);
+}
+
+
+double prolooks_modula (double number, double divisor) {
+	double result = 0.0;
+	result = (((gint) number) % ((gint) divisor)) + (number - ((gint) number));
+	return result;
+}
+
+
+char* prolooks_hsl_to_string (ProlooksHSL* self) {
+	char* result = NULL;
+	g_return_val_if_fail (self != NULL, NULL);
+	result = g_strdup_printf ("HSL (%f, %f, %f)", self->priv->_hue, self->priv->_saturation, self->priv->_lightness);
+	return result;
+}
+
+
+CairoColor* prolooks_hsl_to_cairo_color (ProlooksHSL* self) {
+	CairoColor* result = NULL;
+	gint i = 0;
+	double* _tmp0_;
+	gint _hue_shift_size_;
+	gint hue_shift_length1;
+	double* hue_shift;
+	double* _tmp1_;
+	gint _color_shift_size_;
+	gint color_shift_length1;
+	double* color_shift;
+	double m1 = 0.0;
+	double m2 = 0.0;
+	double m3 = 0.0;
+	gint _tmp2_ = 0;
+	CairoColor* color;
+	g_return_val_if_fail (self != NULL, NULL);
+	hue_shift = (_tmp0_ = g_new0 (double, 3), hue_shift_length1 = 3, _hue_shift_size_ = hue_shift_length1, _tmp0_);
+	color_shift = (_tmp1_ = g_new0 (double, 3), color_shift_length1 = 3, _color_shift_size_ = color_shift_length1, _tmp1_);
+	if (self->priv->_lightness <= 0.5) {
+		m2 = self->priv->_lightness * (1 + self->priv->_saturation);
+	} else {
+		m2 = (self->priv->_lightness + self->priv->_saturation) - (self->priv->_lightness * self->priv->_saturation);
+	}
+	m1 = (2 * self->priv->_lightness) - m2;
+	hue_shift[0] = self->priv->_hue + 120;
+	hue_shift[1] = self->priv->_hue;
+	hue_shift[2] = self->priv->_hue - 120;
+	color_shift[0] = color_shift[1] = color_shift[2] = self->priv->_lightness;
+	if (self->priv->_saturation == 0) {
+		_tmp2_ = 3;
+	} else {
+		_tmp2_ = 0;
+	}
+	i = _tmp2_;
+	{
+		gboolean _tmp3_;
+		_tmp3_ = TRUE;
+		while (TRUE) {
+			if (!_tmp3_) {
+				i++;
+			}
+			_tmp3_ = FALSE;
+			if (!(i < 3)) {
+				break;
+			}
+			m3 = hue_shift[i];
+			if (m3 > 360) {
+				m3 = prolooks_modula (m3, (double) 360);
+			} else {
+				if (m3 < 0) {
+					m3 = 360 - prolooks_modula (fabs (m3), (double) 360);
+				}
+			}
+			if (m3 < 60) {
+				color_shift[i] = m1 + (((m2 - m1) * m3) / 60.0);
+			} else {
+				if (m3 < 180) {
+					color_shift[i] = m2;
+				} else {
+					if (m3 < 240) {
+						color_shift[i] = m1 + (((m2 - m1) * (240 - m3)) / 60.0);
+					} else {
+						color_shift[i] = m1;
+					}
+				}
+			}
+		}
+	}
+	color = cairo_color_new (color_shift[0], color_shift[1], color_shift[2], 1.0);
+	result = color;
+	hue_shift = (g_free (hue_shift), NULL);
+	color_shift = (g_free (color_shift), NULL);
+	return result;
+}
+
+
+void prolooks_hsl_to_gdk_color (ProlooksHSL* self, GdkColor* result) {
+	GdkColor _tmp1_ = {0,0,0,0};
+	CairoColor* _tmp0_;
+	GdkColor _tmp2_;
+	g_return_if_fail (self != NULL);
+	*result = (_tmp2_ = (prolooks_cairo_color_to_gdk (_tmp0_ = prolooks_hsl_to_cairo_color (self), &_tmp1_), _tmp1_), _cairo_color_unref0 (_tmp0_), _tmp2_);
+	return;
+}
+
+
+void prolooks_hsl_from_gdk_color (ProlooksHSL* self, GdkColor* color) {
+	CairoColor* _tmp0_;
+	g_return_if_fail (self != NULL);
+	prolooks_hsl_from_cairo_color (self, _tmp0_ = prolooks_gdk_color_to_cairo (color));
+	_cairo_color_unref0 (_tmp0_);
+}
+
+
+void prolooks_hsl_from_cairo_color (ProlooksHSL* self, CairoColor* color) {
+	double min = 0.0;
+	double max = 0.0;
+	double delta = 0.0;
+	double red;
+	double green;
+	double blue;
+	g_return_if_fail (self != NULL);
+	g_return_if_fail (color != NULL);
+	red = cairo_color_get_red (color);
+	green = cairo_color_get_green (color);
+	blue = cairo_color_get_blue (color);
+	if (red > green) {
+		if (red > blue) {
+			max = red;
+		} else {
+			max = blue;
+		}
+		if (green < blue) {
+			min = green;
+		} else {
+			min = blue;
+		}
+	} else {
+		if (green > blue) {
+			max = green;
+		} else {
+			max = blue;
+		}
+		if (red < blue) {
+			min = red;
+		} else {
+			min = blue;
+		}
+	}
+	prolooks_hsl_set_lightness (self, (max + min) / 2.0);
+	if (fabs (max - min) < 0.0001) {
+		prolooks_hsl_set_hue (self, 0.0);
+		prolooks_hsl_set_saturation (self, 0.0);
+	} else {
+		if (self->priv->_lightness <= 0.5) {
+			prolooks_hsl_set_saturation (self, (max - min) / (max + min));
+		} else {
+			prolooks_hsl_set_saturation (self, (max - min) / ((2.0 - max) - min));
+		}
+		delta = max - min;
+		if (red == max) {
+			prolooks_hsl_set_hue (self, (green - blue) / delta);
+		} else {
+			if (green == max) {
+				prolooks_hsl_set_hue (self, 2.0 + ((blue - red) / delta));
+			} else {
+				if (blue == max) {
+					prolooks_hsl_set_hue (self, 4.0 + ((red - green) / delta));
+				}
+			}
+		}
+		prolooks_hsl_set_hue (self, self->priv->_hue * 60.0);
+		if (self->priv->_hue < 0.0) {
+			prolooks_hsl_set_hue (self, self->priv->_hue + 360.0);
+		}
+	}
+}
+
+
+ProlooksHSL* prolooks_hsl_construct (GType object_type) {
+	ProlooksHSL* self;
+	self = (ProlooksHSL*) g_type_create_instance (object_type);
+	return self;
+}
+
+
+ProlooksHSL* prolooks_hsl_new (void) {
+	return prolooks_hsl_construct (PROLOOKS_TYPE_HSL);
+}
+
+
+double prolooks_hsl_get_hue (ProlooksHSL* self) {
+	double result;
+	g_return_val_if_fail (self != NULL, 0.0);
+	result = self->priv->_hue;
+	return result;
+}
+
+
+void prolooks_hsl_set_hue (ProlooksHSL* self, double value) {
+	g_return_if_fail (self != NULL);
+	self->priv->_hue = value;
+}
+
+
+double prolooks_hsl_get_saturation (ProlooksHSL* self) {
+	double result;
+	g_return_val_if_fail (self != NULL, 0.0);
+	result = self->priv->_saturation;
+	return result;
+}
+
+
+void prolooks_hsl_set_saturation (ProlooksHSL* self, double value) {
+	g_return_if_fail (self != NULL);
+	self->priv->_saturation = value;
+}
+
+
+double prolooks_hsl_get_lightness (ProlooksHSL* self) {
+	double result;
+	g_return_val_if_fail (self != NULL, 0.0);
+	result = self->priv->_lightness;
+	return result;
+}
+
+
+void prolooks_hsl_set_lightness (ProlooksHSL* self, double value) {
+	g_return_if_fail (self != NULL);
+	self->priv->_lightness = value;
+}
+
+
+static void prolooks_value_hsl_init (GValue* value) {
+	value->data[0].v_pointer = NULL;
+}
+
+
+static void prolooks_value_hsl_free_value (GValue* value) {
+	if (value->data[0].v_pointer) {
+		prolooks_hsl_unref (value->data[0].v_pointer);
+	}
+}
+
+
+static void prolooks_value_hsl_copy_value (const GValue* src_value, GValue* dest_value) {
+	if (src_value->data[0].v_pointer) {
+		dest_value->data[0].v_pointer = prolooks_hsl_ref (src_value->data[0].v_pointer);
+	} else {
+		dest_value->data[0].v_pointer = NULL;
+	}
+}
+
+
+static gpointer prolooks_value_hsl_peek_pointer (const GValue* value) {
+	return value->data[0].v_pointer;
+}
+
+
+static gchar* prolooks_value_hsl_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
+	if (collect_values[0].v_pointer) {
+		ProlooksHSL* object;
+		object = collect_values[0].v_pointer;
+		if (object->parent_instance.g_class == NULL) {
+			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
+		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
+			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
+		}
+		value->data[0].v_pointer = prolooks_hsl_ref (object);
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	return NULL;
+}
+
+
+static gchar* prolooks_value_hsl_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
+	ProlooksHSL** object_p;
+	object_p = collect_values[0].v_pointer;
+	if (!object_p) {
+		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+	}
+	if (!value->data[0].v_pointer) {
+		*object_p = NULL;
+	} else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) {
+		*object_p = value->data[0].v_pointer;
+	} else {
+		*object_p = prolooks_hsl_ref (value->data[0].v_pointer);
+	}
+	return NULL;
+}
+
+
+GParamSpec* prolooks_param_spec_hsl (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
+	ProlooksParamSpecHSL* spec;
+	g_return_val_if_fail (g_type_is_a (object_type, PROLOOKS_TYPE_HSL), NULL);
+	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
+	G_PARAM_SPEC (spec)->value_type = object_type;
+	return G_PARAM_SPEC (spec);
+}
+
+
+gpointer prolooks_value_get_hsl (const GValue* value) {
+	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, PROLOOKS_TYPE_HSL), NULL);
+	return value->data[0].v_pointer;
+}
+
+
+void prolooks_value_set_hsl (GValue* value, gpointer v_object) {
+	ProlooksHSL* old;
+	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, PROLOOKS_TYPE_HSL));
+	old = value->data[0].v_pointer;
+	if (v_object) {
+		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, PROLOOKS_TYPE_HSL));
+		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
+		value->data[0].v_pointer = v_object;
+		prolooks_hsl_ref (value->data[0].v_pointer);
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	if (old) {
+		prolooks_hsl_unref (old);
+	}
+}
+
+
+void prolooks_value_take_hsl (GValue* value, gpointer v_object) {
+	ProlooksHSL* old;
+	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, PROLOOKS_TYPE_HSL));
+	old = value->data[0].v_pointer;
+	if (v_object) {
+		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, PROLOOKS_TYPE_HSL));
+		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
+		value->data[0].v_pointer = v_object;
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	if (old) {
+		prolooks_hsl_unref (old);
+	}
+}
+
+
+static void prolooks_hsl_class_init (ProlooksHSLClass * klass) {
+	prolooks_hsl_parent_class = g_type_class_peek_parent (klass);
+	PROLOOKS_HSL_CLASS (klass)->finalize = prolooks_hsl_finalize;
+	g_type_class_add_private (klass, sizeof (ProlooksHSLPrivate));
+}
+
+
+static void prolooks_hsl_instance_init (ProlooksHSL * self) {
+	self->priv = PROLOOKS_HSL_GET_PRIVATE (self);
+	self->ref_count = 1;
+}
+
+
+static void prolooks_hsl_finalize (ProlooksHSL* obj) {
+	ProlooksHSL * self;
+	self = PROLOOKS_HSL (obj);
+}
+
+
+GType prolooks_hsl_get_type (void) {
+	static volatile gsize prolooks_hsl_type_id__volatile = 0;
+	if (g_once_init_enter (&prolooks_hsl_type_id__volatile)) {
+		static const GTypeValueTable g_define_type_value_table = { prolooks_value_hsl_init, prolooks_value_hsl_free_value, prolooks_value_hsl_copy_value, prolooks_value_hsl_peek_pointer, "p", prolooks_value_hsl_collect_value, "p", prolooks_value_hsl_lcopy_value };
+		static const GTypeInfo g_define_type_info = { sizeof (ProlooksHSLClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) prolooks_hsl_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ProlooksHSL), 0, (GInstanceInitFunc) prolooks_hsl_instance_init, &g_define_type_value_table };
+		static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
+		GType prolooks_hsl_type_id;
+		prolooks_hsl_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ProlooksHSL", &g_define_type_info, &g_define_type_fundamental_info, 0);
+		g_once_init_leave (&prolooks_hsl_type_id__volatile, prolooks_hsl_type_id);
+	}
+	return prolooks_hsl_type_id__volatile;
+}
+
+
+gpointer prolooks_hsl_ref (gpointer instance) {
+	ProlooksHSL* self;
+	self = instance;
+	g_atomic_int_inc (&self->ref_count);
+	return instance;
+}
+
+
+void prolooks_hsl_unref (gpointer instance) {
+	ProlooksHSL* self;
+	self = instance;
+	if (g_atomic_int_dec_and_test (&self->ref_count)) {
+		PROLOOKS_HSL_GET_CLASS (self)->finalize (self);
+		g_type_free_instance ((GTypeInstance *) self);
+	}
+}
+
+
+char* prolooks_hsv_to_string (ProlooksHSV* self) {
+	char* result = NULL;
+	g_return_val_if_fail (self != NULL, NULL);
+	result = g_strdup_printf ("HSV (%f, %f, %f)", self->priv->_hue, self->priv->_saturation, self->priv->_value);
+	return result;
+}
+
+
+ProlooksHSV* prolooks_hsv_construct_for_gdk_color (GType object_type, GdkColor* color) {
+	ProlooksHSV* self;
+	self = (ProlooksHSV*) g_type_create_instance (object_type);
+	prolooks_hsv_from_gdk_color (self, color);
+	return self;
+}
+
+
+ProlooksHSV* prolooks_hsv_new_for_gdk_color (GdkColor* color) {
+	return prolooks_hsv_construct_for_gdk_color (PROLOOKS_TYPE_HSV, color);
+}
+
+
+ProlooksHSV* prolooks_hsv_construct_for_cairo_color (GType object_type, CairoColor* color) {
+	ProlooksHSV* self;
+	g_return_val_if_fail (color != NULL, NULL);
+	self = (ProlooksHSV*) g_type_create_instance (object_type);
+	prolooks_hsv_from_cairo_color (self, color);
+	return self;
+}
+
+
+ProlooksHSV* prolooks_hsv_new_for_cairo_color (CairoColor* color) {
+	return prolooks_hsv_construct_for_cairo_color (PROLOOKS_TYPE_HSV, color);
+}
+
+
+CairoColor* prolooks_hsv_to_cairo_color (ProlooksHSV* self) {
+	CairoColor* result = NULL;
+	double r;
+	double g;
+	double b;
+	double v;
+	gint hi = 0;
+	double f = 0.0;
+	double p = 0.0;
+	double q = 0.0;
+	double t = 0.0;
+	CairoColor* color;
+	g_return_val_if_fail (self != NULL, NULL);
+	r = 0.0;
+	g = 0.0;
+	b = 0.0;
+	v = self->priv->_value;
+	hi = (gint) prolooks_modula (floor (self->priv->_hue / 60.0), (double) 6);
+	f = (self->priv->_hue / 60.0) - floor (self->priv->_hue / 60.0);
+	p = self->priv->_value * (1.0 - self->priv->_saturation);
+	q = self->priv->_value * (1.0 - (f * self->priv->_saturation));
+	t = self->priv->_value * (1.0 - ((1.0 - f) * self->priv->_saturation));
+	switch (hi) {
+		case 0:
+		{
+			r = self->priv->_value;
+			g = t;
+			b = p;
+			break;
+		}
+		case 1:
+		{
+			r = q;
+			g = self->priv->_value;
+			b = p;
+			break;
+		}
+		case 2:
+		{
+			r = p;
+			g = self->priv->_value;
+			b = t;
+			break;
+		}
+		case 3:
+		{
+			r = p;
+			g = q;
+			b = self->priv->_value;
+			break;
+		}
+		case 4:
+		{
+			r = t;
+			g = p;
+			b = self->priv->_value;
+			break;
+		}
+		case 5:
+		{
+			r = self->priv->_value;
+			g = p;
+			b = q;
+			break;
+		}
+		default:
+		{
+			break;
+		}
+	}
+	color = cairo_color_new (r, g, b, 1.0);
+	result = color;
+	return result;
+}
+
+
+void prolooks_hsv_to_gdk_color (ProlooksHSV* self, GdkColor* result) {
+	GdkColor _tmp1_ = {0,0,0,0};
+	CairoColor* _tmp0_;
+	GdkColor _tmp2_;
+	g_return_if_fail (self != NULL);
+	*result = (_tmp2_ = (prolooks_cairo_color_to_gdk (_tmp0_ = prolooks_hsv_to_cairo_color (self), &_tmp1_), _tmp1_), _cairo_color_unref0 (_tmp0_), _tmp2_);
+	return;
+}
+
+
+void prolooks_hsv_from_gdk_color (ProlooksHSV* self, GdkColor* color) {
+	CairoColor* _tmp0_;
+	g_return_if_fail (self != NULL);
+	prolooks_hsv_from_cairo_color (self, _tmp0_ = prolooks_gdk_color_to_cairo (color));
+	_cairo_color_unref0 (_tmp0_);
+}
+
+
+void prolooks_hsv_from_cairo_color (ProlooksHSV* self, CairoColor* color) {
+	double min = 0.0;
+	double max = 0.0;
+	double delta = 0.0;
+	double red;
+	double green;
+	double blue;
+	g_return_if_fail (self != NULL);
+	g_return_if_fail (color != NULL);
+	red = cairo_color_get_red (color);
+	green = cairo_color_get_green (color);
+	blue = cairo_color_get_blue (color);
+	if (red > green) {
+		if (red > blue) {
+			max = red;
+		} else {
+			max = blue;
+		}
+		if (green < blue) {
+			min = green;
+		} else {
+			min = blue;
+		}
+	} else {
+		if (green > blue) {
+			max = green;
+		} else {
+			max = blue;
+		}
+		if (red < blue) {
+			min = red;
+		} else {
+			min = blue;
+		}
+	}
+	prolooks_hsv_set_value (self, max);
+	if (fabs (max - min) < 0.0001) {
+		prolooks_hsv_set_hue (self, 0.0);
+		prolooks_hsv_set_saturation (self, 0.0);
+	} else {
+		if (max < 0.0001) {
+			prolooks_hsv_set_saturation (self, (double) 0);
+		} else {
+			prolooks_hsv_set_saturation (self, (max - min) / max);
+		}
+		delta = max - min;
+		if (red == max) {
+			prolooks_hsv_set_hue (self, (green - blue) / delta);
+		} else {
+			if (green == max) {
+				prolooks_hsv_set_hue (self, 2.0 + ((blue - red) / delta));
+			} else {
+				if (blue == max) {
+					prolooks_hsv_set_hue (self, 4.0 + ((red - green) / delta));
+				}
+			}
+		}
+		prolooks_hsv_set_hue (self, self->priv->_hue * 60.0);
+		if (self->priv->_hue < 0.0) {
+			prolooks_hsv_set_hue (self, self->priv->_hue + 360.0);
+		}
+	}
+}
+
+
+ProlooksHSV* prolooks_hsv_construct (GType object_type) {
+	ProlooksHSV* self;
+	self = (ProlooksHSV*) g_type_create_instance (object_type);
+	return self;
+}
+
+
+ProlooksHSV* prolooks_hsv_new (void) {
+	return prolooks_hsv_construct (PROLOOKS_TYPE_HSV);
+}
+
+
+double prolooks_hsv_get_hue (ProlooksHSV* self) {
+	double result;
+	g_return_val_if_fail (self != NULL, 0.0);
+	result = self->priv->_hue;
+	return result;
+}
+
+
+void prolooks_hsv_set_hue (ProlooksHSV* self, double value) {
+	g_return_if_fail (self != NULL);
+	self->priv->_hue = value;
+}
+
+
+double prolooks_hsv_get_saturation (ProlooksHSV* self) {
+	double result;
+	g_return_val_if_fail (self != NULL, 0.0);
+	result = self->priv->_saturation;
+	return result;
+}
+
+
+void prolooks_hsv_set_saturation (ProlooksHSV* self, double value) {
+	g_return_if_fail (self != NULL);
+	self->priv->_saturation = value;
+}
+
+
+double prolooks_hsv_get_value (ProlooksHSV* self) {
+	double result;
+	g_return_val_if_fail (self != NULL, 0.0);
+	result = self->priv->_value;
+	return result;
+}
+
+
+void prolooks_hsv_set_value (ProlooksHSV* self, double value) {
+	g_return_if_fail (self != NULL);
+	self->priv->_value = value;
+}
+
+
+static void prolooks_value_hsv_init (GValue* value) {
+	value->data[0].v_pointer = NULL;
+}
+
+
+static void prolooks_value_hsv_free_value (GValue* value) {
+	if (value->data[0].v_pointer) {
+		prolooks_hsv_unref (value->data[0].v_pointer);
+	}
+}
+
+
+static void prolooks_value_hsv_copy_value (const GValue* src_value, GValue* dest_value) {
+	if (src_value->data[0].v_pointer) {
+		dest_value->data[0].v_pointer = prolooks_hsv_ref (src_value->data[0].v_pointer);
+	} else {
+		dest_value->data[0].v_pointer = NULL;
+	}
+}
+
+
+static gpointer prolooks_value_hsv_peek_pointer (const GValue* value) {
+	return value->data[0].v_pointer;
+}
+
+
+static gchar* prolooks_value_hsv_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
+	if (collect_values[0].v_pointer) {
+		ProlooksHSV* object;
+		object = collect_values[0].v_pointer;
+		if (object->parent_instance.g_class == NULL) {
+			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
+		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
+			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
+		}
+		value->data[0].v_pointer = prolooks_hsv_ref (object);
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	return NULL;
+}
+
+
+static gchar* prolooks_value_hsv_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
+	ProlooksHSV** object_p;
+	object_p = collect_values[0].v_pointer;
+	if (!object_p) {
+		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+	}
+	if (!value->data[0].v_pointer) {
+		*object_p = NULL;
+	} else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) {
+		*object_p = value->data[0].v_pointer;
+	} else {
+		*object_p = prolooks_hsv_ref (value->data[0].v_pointer);
+	}
+	return NULL;
+}
+
+
+GParamSpec* prolooks_param_spec_hsv (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
+	ProlooksParamSpecHSV* spec;
+	g_return_val_if_fail (g_type_is_a (object_type, PROLOOKS_TYPE_HSV), NULL);
+	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
+	G_PARAM_SPEC (spec)->value_type = object_type;
+	return G_PARAM_SPEC (spec);
+}
+
+
+gpointer prolooks_value_get_hsv (const GValue* value) {
+	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, PROLOOKS_TYPE_HSV), NULL);
+	return value->data[0].v_pointer;
+}
+
+
+void prolooks_value_set_hsv (GValue* value, gpointer v_object) {
+	ProlooksHSV* old;
+	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, PROLOOKS_TYPE_HSV));
+	old = value->data[0].v_pointer;
+	if (v_object) {
+		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, PROLOOKS_TYPE_HSV));
+		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
+		value->data[0].v_pointer = v_object;
+		prolooks_hsv_ref (value->data[0].v_pointer);
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	if (old) {
+		prolooks_hsv_unref (old);
+	}
+}
+
+
+void prolooks_value_take_hsv (GValue* value, gpointer v_object) {
+	ProlooksHSV* old;
+	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, PROLOOKS_TYPE_HSV));
+	old = value->data[0].v_pointer;
+	if (v_object) {
+		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, PROLOOKS_TYPE_HSV));
+		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
+		value->data[0].v_pointer = v_object;
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	if (old) {
+		prolooks_hsv_unref (old);
+	}
+}
+
+
+static void prolooks_hsv_class_init (ProlooksHSVClass * klass) {
+	prolooks_hsv_parent_class = g_type_class_peek_parent (klass);
+	PROLOOKS_HSV_CLASS (klass)->finalize = prolooks_hsv_finalize;
+	g_type_class_add_private (klass, sizeof (ProlooksHSVPrivate));
+}
+
+
+static void prolooks_hsv_instance_init (ProlooksHSV * self) {
+	self->priv = PROLOOKS_HSV_GET_PRIVATE (self);
+	self->ref_count = 1;
+}
+
+
+static void prolooks_hsv_finalize (ProlooksHSV* obj) {
+	ProlooksHSV * self;
+	self = PROLOOKS_HSV (obj);
+}
+
+
+GType prolooks_hsv_get_type (void) {
+	static volatile gsize prolooks_hsv_type_id__volatile = 0;
+	if (g_once_init_enter (&prolooks_hsv_type_id__volatile)) {
+		static const GTypeValueTable g_define_type_value_table = { prolooks_value_hsv_init, prolooks_value_hsv_free_value, prolooks_value_hsv_copy_value, prolooks_value_hsv_peek_pointer, "p", prolooks_value_hsv_collect_value, "p", prolooks_value_hsv_lcopy_value };
+		static const GTypeInfo g_define_type_info = { sizeof (ProlooksHSVClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) prolooks_hsv_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ProlooksHSV), 0, (GInstanceInitFunc) prolooks_hsv_instance_init, &g_define_type_value_table };
+		static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
+		GType prolooks_hsv_type_id;
+		prolooks_hsv_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ProlooksHSV", &g_define_type_info, &g_define_type_fundamental_info, 0);
+		g_once_init_leave (&prolooks_hsv_type_id__volatile, prolooks_hsv_type_id);
+	}
+	return prolooks_hsv_type_id__volatile;
+}
+
+
+gpointer prolooks_hsv_ref (gpointer instance) {
+	ProlooksHSV* self;
+	self = instance;
+	g_atomic_int_inc (&self->ref_count);
+	return instance;
+}
+
+
+void prolooks_hsv_unref (gpointer instance) {
+	ProlooksHSV* self;
+	self = instance;
+	if (g_atomic_int_dec_and_test (&self->ref_count)) {
+		PROLOOKS_HSV_GET_CLASS (self)->finalize (self);
+		g_type_free_instance ((GTypeInstance *) self);
+	}
+}
+
+
+void prolooks_shade_color (GdkColor* orig, double shade_ratio, GdkColor* result) {
+	ProlooksHSL* HSL;
+	GdkColor _tmp0_ = {0,0,0,0};
+	GdkColor _result_;
+	HSL = prolooks_hsl_new ();
+	prolooks_hsl_from_gdk_color (HSL, orig);
+	prolooks_hsl_set_lightness (HSL, fmin (prolooks_hsl_get_lightness (HSL) * shade_ratio, 1.0));
+	prolooks_hsl_set_lightness (HSL, fmax (prolooks_hsl_get_lightness (HSL), 0.0));
+	prolooks_hsl_set_saturation (HSL, fmin (prolooks_hsl_get_saturation (HSL) * shade_ratio, 1.0));
+	prolooks_hsl_set_saturation (HSL, fmax (prolooks_hsl_get_saturation (HSL), 0.0));
+	_result_ = (prolooks_hsl_to_gdk_color (HSL, &_tmp0_), _tmp0_);
+	*result = _result_;
+	_prolooks_hsl_unref0 (HSL);
+	return;
+}
+
+
+GdkPixbuf* prolooks_cairo_image_surface_to_pixbuf (cairo_surface_t* surface) {
+	GdkPixbuf* result = NULL;
+	guchar* _tmp0_;
+	gint _knob_data_size_;
+	gint knob_data_length1;
+	guchar* knob_data;
+	g_return_val_if_fail (surface != NULL, NULL);
+	if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_ARGB32) {
+		result = NULL;
+		return result;
+	}
+	knob_data = (_tmp0_ = cairo_image_surface_get_data (surface), knob_data_length1 = -1, _knob_data_size_ = knob_data_length1, _tmp0_);
+	{
+		gint i;
+		i = 0;
+		{
+			gboolean _tmp1_;
+			_tmp1_ = TRUE;
+			while (TRUE) {
+				guchar r;
+				guchar g;
+				guchar b;
+				guchar a;
+				if (!_tmp1_) {
+					i = i + 4;
+				}
+				_tmp1_ = FALSE;
+				if (!(i < (cairo_image_surface_get_height (surface) * cairo_image_surface_get_stride (surface)))) {
+					break;
+				}
+				r = knob_data[i + 0];
+				g = knob_data[i + 1];
+				b = knob_data[i + 2];
+				a = knob_data[i + 3];
+				knob_data[i + 0] = b;
+				knob_data[i + 1] = g;
+				knob_data[i + 2] = r;
+				knob_data[i + 3] = a;
+			}
+		}
+	}
+	result = gdk_pixbuf_new_from_data (knob_data, GDK_COLORSPACE_RGB, TRUE, 8, cairo_image_surface_get_width (surface), cairo_image_surface_get_height (surface), cairo_image_surface_get_stride (surface), NULL, NULL);
+	return result;
+}
+
+
+
+
diff --git a/libs/gtkmm2ext/wscript b/libs/gtkmm2ext/wscript
index 1db7016a24..dc8dbff76f 100644
--- a/libs/gtkmm2ext/wscript
+++ b/libs/gtkmm2ext/wscript
@@ -37,6 +37,7 @@ gtkmm2ext_sources = [
 	'idle_adjustment.cc',
 	'keyboard.cc',
         'motionfeedback.cc',
+        'prolooks_helpers.c',
 	'pixfader.cc',
 	'pixscroller.cc',
 	'popup.cc',