SPColorScales c++-sification - move to ui/widget

(bzr r13341.6.38)

5 files changed, 931 insertions, 2 deletions

diff --git a/src/ui/widget/Makefile_insert b/src/ui/widget/Makefile_insert
index 97625f04e..039e2a8d9 100644
--- a/src/ui/widget/Makefile_insert
+++ b/src/ui/widget/Makefile_insert
@@ -16,6 +16,8 @@ ink_common_sources +=	\
 	ui/widget/color-preview.h       \
 	ui/widget/color-slider.cpp      \
 	ui/widget/color-slider.h       \
+	ui/widget/color-scales.cpp   \
+	ui/widget/color-scales.h    \
 	ui/widget/combo-enums.h \
 	ui/widget/dock.h		\
 	ui/widget/dock.cpp		\
diff --git a/src/ui/widget/color-scales.cpp b/src/ui/widget/color-scales.cpp
new file mode 100644
index 000000000..bba44034a
--- /dev/null
+++ b/src/ui/widget/color-scales.cpp
@@ -0,0 +1,788 @@
+/*
+ *   bulia byak <buliabyak@users.sf.net>
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include "ui/widget/color-scales.h"
+
+#include <math.h>
+#include <gtk/gtk.h>
+#include <glibmm/i18n.h>
+#include <gtkmm/adjustment.h>
+
+#include "dialogs/dialog-events.h"
+#include "svg/svg-icc-color.h"
+#include "ui/widget/color-slider.h"
+
+#define CSC_CHANNEL_R (1 << 0)
+#define CSC_CHANNEL_G (1 << 1)
+#define CSC_CHANNEL_B (1 << 2)
+#define CSC_CHANNEL_A (1 << 3)
+#define CSC_CHANNEL_H (1 << 0)
+#define CSC_CHANNEL_S (1 << 1)
+#define CSC_CHANNEL_V (1 << 2)
+#define CSC_CHANNEL_C (1 << 0)
+#define CSC_CHANNEL_M (1 << 1)
+#define CSC_CHANNEL_Y (1 << 2)
+#define CSC_CHANNEL_K (1 << 3)
+#define CSC_CHANNEL_CMYKA (1 << 4)
+
+#define CSC_CHANNELS_ALL 0
+
+
+G_BEGIN_DECLS
+
+static void sp_color_scales_class_init (SPColorScalesClass *klass);
+static void sp_color_scales_init (SPColorScales *cs);
+static void sp_color_scales_dispose(GObject *object);
+
+static void sp_color_scales_show_all (GtkWidget *widget);
+static void sp_color_scales_hide(GtkWidget *widget);
+
+static const gchar *sp_color_scales_hue_map (void);
+
+G_END_DECLS
+
+static SPColorSelectorClass *parent_class;
+
+#define XPAD 4
+#define YPAD 1
+
+#define noDUMP_CHANGE_INFO 1
+
+const gchar* ColorScales::SUBMODE_NAMES[] = {
+    N_("None"),
+    N_("RGB"),
+    N_("HSL"),
+    N_("CMYK")
+};
+
+GType
+sp_color_scales_get_type (void)
+{
+	static GType type = 0;
+	if (!type) {
+		static const GTypeInfo info = {
+			sizeof (SPColorScalesClass),
+			NULL, /* base_init */
+			NULL, /* base_finalize */
+			(GClassInitFunc) sp_color_scales_class_init,
+			NULL, /* class_finalize */
+			NULL, /* class_data */
+			sizeof (SPColorScales),
+			0,	  /* n_preallocs */
+			(GInstanceInitFunc) sp_color_scales_init,
+			NULL
+		};
+
+		type = g_type_register_static (SP_TYPE_COLOR_SELECTOR,
+									   "SPColorScales",
+									   &info,
+									   static_cast< GTypeFlags > (0) );
+	}
+	return type;
+}
+
+static void
+sp_color_scales_class_init (SPColorScalesClass *klass)
+{
+	static const gchar* nameset[] = {N_("RGB"), N_("HSL"), N_("CMYK"), 0};
+	GObjectClass *object_class = G_OBJECT_CLASS(klass);
+	GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass);
+	SPColorSelectorClass *selector_class = SP_COLOR_SELECTOR_CLASS (klass);
+
+	parent_class = SP_COLOR_SELECTOR_CLASS (g_type_class_peek_parent (klass));
+
+	selector_class->name = nameset;
+	selector_class->submode_count = 3;
+
+	object_class->dispose = sp_color_scales_dispose;
+
+	widget_class->show_all = sp_color_scales_show_all;
+	widget_class->hide = sp_color_scales_hide;
+}
+
+ColorScales::ColorScales( SPColorSelector* csel )
+    : ColorSelector( csel ),
+      _mode( SP_COLOR_SCALES_MODE_NONE ),
+      _rangeLimit( 255.0 ),
+      _updating( FALSE ),
+      _dragging( FALSE )
+{
+    for (gint i = 0; i < 5; i++) {
+        _l[i] = 0;
+        _a[i] = 0;
+        _s[i] = 0;
+        _b[i] = 0;
+    }
+}
+
+ColorScales::~ColorScales()
+{
+    for (gint i = 0; i < 5; i++) {
+        _l[i] = 0;
+        _a[i] = 0;
+        _s[i] = 0;
+        _b[i] = 0;
+    }
+}
+
+void sp_color_scales_init (SPColorScales *cs)
+{
+    SP_COLOR_SELECTOR(cs)->base = new ColorScales( SP_COLOR_SELECTOR(cs) );
+
+    if ( SP_COLOR_SELECTOR(cs)->base )
+    {
+        SP_COLOR_SELECTOR(cs)->base->init();
+    }
+}
+
+void ColorScales::init()
+{
+	gint i;
+
+	_updating = FALSE;
+	_dragging = FALSE;
+
+#if GTK_CHECK_VERSION(3,0,0)
+	GtkWidget *t = gtk_grid_new();
+#else
+	GtkWidget *t = gtk_table_new (5, 3, FALSE);
+#endif
+	gtk_widget_show (t);
+	gtk_box_pack_start (GTK_BOX (_csel), t, TRUE, TRUE, 4);
+
+	/* Create components */
+	for (i = 0; i < static_cast< gint > (G_N_ELEMENTS(_a)) ; i++) {
+		/* Label */
+		_l[i] = gtk_label_new("");
+		gtk_misc_set_alignment (GTK_MISC (_l[i]), 1.0, 0.5);
+		gtk_widget_show (_l[i]);
+
+#if GTK_CHECK_VERSION(3,0,0)
+		gtk_widget_set_margin_left(_l[i], XPAD);
+		gtk_widget_set_margin_right(_l[i], XPAD);
+		gtk_widget_set_margin_top(_l[i], YPAD);
+		gtk_widget_set_margin_bottom(_l[i], YPAD);
+		gtk_grid_attach(GTK_GRID(t), _l[i], 0, i, 1, 1);
+#else
+		gtk_table_attach (GTK_TABLE (t), _l[i], 0, 1, i, i + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
+#endif
+
+		/* Adjustment */
+		_a[i] = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, _rangeLimit, 1.0, 10.0, 10.0));
+		/* Slider */
+		_s[i] = Gtk::manage(new Inkscape::UI::Widget::ColorSlider(Glib::wrap(_a[i], true)));
+		_s[i]->show();
+
+#if GTK_CHECK_VERSION(3,0,0)
+		_s[i]->set_margin_left(XPAD);
+		_s[i]->set_margin_right(XPAD);
+		_s[i]->set_margin_top(YPAD);
+		_s[i]->set_margin_bottom(YPAD);
+		_s[i]->set_hexpand(true);
+		gtk_grid_attach(GTK_GRID(t), _s[i]->gobj(), 1, i, 1, 1);
+#else
+		gtk_table_attach (GTK_TABLE (t), _s[i]->gobj(), 1, 2, i, i + 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, XPAD, YPAD);
+#endif
+
+		/* Spinbutton */
+		_b[i] = gtk_spin_button_new (GTK_ADJUSTMENT (_a[i]), 1.0, 0);
+		sp_dialog_defocus_on_enter (_b[i]);
+		gtk_label_set_mnemonic_widget (GTK_LABEL(_l[i]), _b[i]);
+		gtk_widget_show (_b[i]);
+
+#if GTK_CHECK_VERSION(3,0,0)
+		gtk_widget_set_margin_left(_b[i], XPAD);
+		gtk_widget_set_margin_right(_b[i], XPAD);
+		gtk_widget_set_margin_top(_b[i], YPAD);
+		gtk_widget_set_margin_bottom(_b[i], YPAD);
+		gtk_widget_set_halign(_b[i], GTK_ALIGN_CENTER);
+		gtk_widget_set_valign(_b[i], GTK_ALIGN_CENTER);
+		gtk_grid_attach(GTK_GRID(t), _b[i], 2, i, 1, 1);
+#else
+		gtk_table_attach (GTK_TABLE (t), _b[i], 2, 3, i, i + 1, (GtkAttachOptions)0, (GtkAttachOptions)0, XPAD, YPAD);
+#endif
+
+		/* Attach channel value to adjustment */
+		g_object_set_data (G_OBJECT (_a[i]), "channel", GINT_TO_POINTER (i));
+		/* Signals */
+		g_signal_connect (G_OBJECT (_a[i]), "value_changed",
+					G_CALLBACK (_adjustmentAnyChanged), _csel);
+		_s[i]->signal_grabbed.connect(sigc::mem_fun(this, &ColorScales::_sliderAnyGrabbed));
+		_s[i]->signal_released.connect(sigc::mem_fun(this, &ColorScales::_sliderAnyReleased));
+		_s[i]->signal_value_changed.connect(sigc::mem_fun(this, &ColorScales::_sliderAnyChanged));
+	}
+
+	/* Initial mode is none, so it works */
+	setMode(SP_COLOR_SCALES_MODE_RGB);
+}
+
+static void sp_color_scales_dispose(GObject *object)
+{
+	if ((G_OBJECT_CLASS(parent_class))->dispose)
+		(* (G_OBJECT_CLASS(parent_class))->dispose) (object);
+}
+
+static void
+sp_color_scales_show_all (GtkWidget *widget)
+{
+	gtk_widget_show (widget);
+}
+
+static void sp_color_scales_hide(GtkWidget *widget)
+{
+	gtk_widget_hide(widget);
+}
+
+GtkWidget *sp_color_scales_new()
+{
+	SPColorScales *csel = SP_COLOR_SCALES(g_object_new (SP_TYPE_COLOR_SCALES, NULL));
+
+	return GTK_WIDGET (csel);
+}
+
+void ColorScales::_recalcColor( gboolean changing )
+{
+    if ( changing )
+    {
+        SPColor color;
+        gfloat alpha = 1.0;
+        gfloat c[5];
+
+        switch (_mode) {
+        case SP_COLOR_SCALES_MODE_RGB:
+        case SP_COLOR_SCALES_MODE_HSV:
+            _getRgbaFloatv(c);
+            color.set( c[0], c[1], c[2] );
+            alpha = c[3];
+            break;
+        case SP_COLOR_SCALES_MODE_CMYK:
+        {
+            _getCmykaFloatv( c );
+
+            float rgb[3];
+            sp_color_cmyk_to_rgb_floatv( rgb, c[0], c[1], c[2], c[3] );
+            color.set( rgb[0], rgb[1], rgb[2] );
+            alpha = c[4];
+            break;
+        }
+        default:
+            g_warning ("file %s: line %d: Illegal color selector mode %d", __FILE__, __LINE__, _mode);
+            break;
+        }
+
+        /* Preserve ICC */
+        color.icc = _color.icc ? new SVGICCColor(*_color.icc) : 0;
+
+        _updateInternals( color, alpha, _dragging );
+    }
+    else
+    {
+        _updateInternals( _color, _alpha, _dragging );
+    }
+}
+
+/* Helpers for setting color value */
+gfloat ColorScales::getScaled( const GtkAdjustment *a )
+{
+    gfloat val = gtk_adjustment_get_value (const_cast<GtkAdjustment*>(a)) 
+	    / gtk_adjustment_get_upper (const_cast<GtkAdjustment*>(a));
+    return val;
+}
+
+void ColorScales::setScaled( GtkAdjustment *a, gfloat v )
+{
+    gfloat val = v * gtk_adjustment_get_upper (a);
+    gtk_adjustment_set_value( a, val );
+}
+
+void ColorScales::_setRangeLimit( gdouble upper )
+{
+    _rangeLimit = upper;
+    for ( gint i = 0; i < static_cast<gint>(G_N_ELEMENTS(_a)); i++ ) {
+        gtk_adjustment_set_upper (_a[i], upper);
+        gtk_adjustment_changed( _a[i] );
+    }
+}
+
+void ColorScales::_colorChanged()
+{
+#ifdef DUMP_CHANGE_INFO
+    g_message("ColorScales::_colorChanged( this=%p, %f, %f, %f,   %f)", this, _color.v.c[0], _color.v.c[1], _color.v.c[2], _alpha );
+#endif
+    gfloat tmp[3];
+    gfloat c[5] = {0.0, 0.0, 0.0, 0.0};
+
+    switch (_mode) {
+    case SP_COLOR_SCALES_MODE_RGB:
+        sp_color_get_rgb_floatv( &_color, c );
+        c[3] = _alpha;
+        c[4] = 0.0;
+        break;
+    case SP_COLOR_SCALES_MODE_HSV:
+        sp_color_get_rgb_floatv( &_color, tmp );
+        sp_color_rgb_to_hsl_floatv (c, tmp[0], tmp[1], tmp[2]);
+        c[3] = _alpha;
+        c[4] = 0.0;
+        break;
+    case SP_COLOR_SCALES_MODE_CMYK:
+        sp_color_get_cmyk_floatv( &_color, c );
+        c[4] = _alpha;
+        break;
+    default:
+        g_warning ("file %s: line %d: Illegal color selector mode %d", __FILE__, __LINE__, _mode);
+        break;
+    }
+
+    _updating = TRUE;
+    setScaled( _a[0], c[0] );
+    setScaled( _a[1], c[1] );
+    setScaled( _a[2], c[2] );
+    setScaled( _a[3], c[3] );
+    setScaled( _a[4], c[4] );
+    _updateSliders( CSC_CHANNELS_ALL );
+    _updating = FALSE;
+}
+
+void ColorScales::_getRgbaFloatv( gfloat *rgba )
+{
+	g_return_if_fail (rgba != NULL);
+
+	switch (_mode) {
+	case SP_COLOR_SCALES_MODE_RGB:
+		rgba[0] = getScaled(_a[0]);
+		rgba[1] = getScaled(_a[1]);
+		rgba[2] = getScaled(_a[2]);
+		rgba[3] = getScaled(_a[3]);
+		break;
+	case SP_COLOR_SCALES_MODE_HSV:
+		sp_color_hsl_to_rgb_floatv (rgba, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]));
+		rgba[3] = getScaled(_a[3]);
+		break;
+	case SP_COLOR_SCALES_MODE_CMYK:
+		sp_color_cmyk_to_rgb_floatv (rgba, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3]));
+		rgba[3] = getScaled(_a[4]);
+		break;
+	default:
+		g_warning ("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__);
+		break;
+	}
+}
+
+void ColorScales::_getCmykaFloatv( gfloat *cmyka )
+{
+	gfloat rgb[3];
+
+	g_return_if_fail (cmyka != NULL);
+
+	switch (_mode) {
+	case SP_COLOR_SCALES_MODE_RGB:
+		sp_color_rgb_to_cmyk_floatv (cmyka, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]));
+		cmyka[4] = getScaled(_a[3]);
+		break;
+	case SP_COLOR_SCALES_MODE_HSV:
+		sp_color_hsl_to_rgb_floatv (rgb, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]));
+		sp_color_rgb_to_cmyk_floatv (cmyka, rgb[0], rgb[1], rgb[2]);
+		cmyka[4] = getScaled(_a[3]);
+		break;
+	case SP_COLOR_SCALES_MODE_CMYK:
+		cmyka[0] = getScaled(_a[0]);
+		cmyka[1] = getScaled(_a[1]);
+		cmyka[2] = getScaled(_a[2]);
+		cmyka[3] = getScaled(_a[3]);
+		cmyka[4] = getScaled(_a[4]);
+		break;
+	default:
+		g_warning ("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__);
+		break;
+	}
+}
+
+guint32 ColorScales::_getRgba32()
+{
+	gfloat c[4];
+	guint32 rgba;
+
+	_getRgbaFloatv(c);
+
+	rgba = SP_RGBA32_F_COMPOSE (c[0], c[1], c[2], c[3]);
+
+	return rgba;
+}
+
+void ColorScales::setMode(SPColorScalesMode mode)
+{
+	gfloat rgba[4];
+	gfloat c[4];
+
+	if (_mode == mode) return;
+
+	if ((_mode == SP_COLOR_SCALES_MODE_RGB) ||
+		(_mode == SP_COLOR_SCALES_MODE_HSV) ||
+		(_mode == SP_COLOR_SCALES_MODE_CMYK)) {
+		_getRgbaFloatv(rgba);
+	} else {
+		rgba[0] = rgba[1] = rgba[2] = rgba[3] = 1.0;
+	}
+
+	_mode = mode;
+
+	switch (mode) {
+	case SP_COLOR_SCALES_MODE_RGB:
+		_setRangeLimit(255.0);
+		gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[0]), _("_R:"));
+		_s[0]->set_tooltip_text(_("Red"));
+		gtk_widget_set_tooltip_text (_b[0], _("Red"));
+		gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[1]), _("_G:"));
+		_s[1]->set_tooltip_text(_("Green"));
+		gtk_widget_set_tooltip_text (_b[1], _("Green"));
+		gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[2]), _("_B:"));
+		_s[2]->set_tooltip_text(_("Blue"));
+		gtk_widget_set_tooltip_text (_b[2], _("Blue"));
+		gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[3]), _("_A:"));
+		_s[3]->set_tooltip_text(_("Alpha (opacity)"));
+		gtk_widget_set_tooltip_text (_b[3], _("Alpha (opacity)"));
+		_s[0]->setMap(NULL);
+		gtk_widget_hide (_l[4]);
+		_s[4]->hide();
+		gtk_widget_hide (_b[4]);
+		_updating = TRUE;
+		setScaled( _a[0], rgba[0] );
+		setScaled( _a[1], rgba[1] );
+		setScaled( _a[2], rgba[2] );
+		setScaled( _a[3], rgba[3] );
+		_updating = FALSE;
+		_updateSliders( CSC_CHANNELS_ALL );
+		break;
+	case SP_COLOR_SCALES_MODE_HSV:
+		_setRangeLimit(255.0);
+		gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[0]), _("_H:"));
+		_s[0]->set_tooltip_text(_("Hue"));
+		gtk_widget_set_tooltip_text (_b[0], _("Hue"));
+		gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[1]), _("_S:"));
+		_s[1]->set_tooltip_text(_("Saturation"));
+		gtk_widget_set_tooltip_text (_b[1], _("Saturation"));
+		gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[2]), _("_L:"));
+		_s[2]->set_tooltip_text(_("Lightness"));
+		gtk_widget_set_tooltip_text (_b[2], _("Lightness"));
+		gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[3]), _("_A:"));
+		_s[3]->set_tooltip_text(_("Alpha (opacity)"));
+		gtk_widget_set_tooltip_text (_b[3], _("Alpha (opacity)"));
+		_s[0]->setMap((guchar *)(sp_color_scales_hue_map()));
+		gtk_widget_hide (_l[4]);
+		_s[4]->hide();
+		gtk_widget_hide (_b[4]);
+		_updating = TRUE;
+		c[0] = 0.0;
+		sp_color_rgb_to_hsl_floatv (c, rgba[0], rgba[1], rgba[2]);
+		setScaled( _a[0], c[0] );
+		setScaled( _a[1], c[1] );
+		setScaled( _a[2], c[2] );
+		setScaled( _a[3], rgba[3] );
+		_updating = FALSE;
+		_updateSliders( CSC_CHANNELS_ALL );
+		break;
+	case SP_COLOR_SCALES_MODE_CMYK:
+		_setRangeLimit(100.0);
+		gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[0]), _("_C:"));
+		_s[0]->set_tooltip_text(_("Cyan"));
+		gtk_widget_set_tooltip_text (_b[0], _("Cyan"));
+		gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[1]), _("_M:"));
+		_s[1]->set_tooltip_text(_("Magenta"));
+		gtk_widget_set_tooltip_text (_b[1], _("Magenta"));
+		gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[2]), _("_Y:"));
+		_s[2]->set_tooltip_text(_("Yellow"));
+		gtk_widget_set_tooltip_text (_b[2], _("Yellow"));
+		gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[3]), _("_K:"));
+		_s[3]->set_tooltip_text(_("Black"));
+		gtk_widget_set_tooltip_text (_b[3], _("Black"));
+		gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[4]), _("_A:"));
+		_s[4]->set_tooltip_text(_("Alpha (opacity)"));
+		gtk_widget_set_tooltip_text (_b[4], _("Alpha (opacity)"));
+		_s[0]->setMap(NULL);
+		gtk_widget_show (_l[4]);
+		_s[4]->show();
+		gtk_widget_show (_b[4]);
+		_updating = TRUE;
+
+                sp_color_rgb_to_cmyk_floatv (c, rgba[0], rgba[1], rgba[2]);
+                setScaled( _a[0], c[0] );
+                setScaled( _a[1], c[1] );
+                setScaled( _a[2], c[2] );
+                setScaled( _a[3], c[3] );
+
+		setScaled( _a[4], rgba[3] );
+		_updating = FALSE;
+		_updateSliders( CSC_CHANNELS_ALL );
+		break;
+	default:
+		g_warning ("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__);
+		break;
+	}
+}
+
+SPColorScalesMode ColorScales::getMode() const
+{
+	return _mode;
+}
+
+void ColorScales::setSubmode( guint submode )
+{
+	g_return_if_fail (_csel != NULL);
+	g_return_if_fail (SP_IS_COLOR_SCALES (_csel));
+	g_return_if_fail (submode < 3);
+
+	switch ( submode )
+	{
+	default:
+	case 0:
+		setMode(SP_COLOR_SCALES_MODE_RGB);
+		break;
+	case 1:
+		setMode(SP_COLOR_SCALES_MODE_HSV);
+		break;
+	case 2:
+		setMode(SP_COLOR_SCALES_MODE_CMYK);
+		break;
+	}
+}
+
+guint ColorScales::getSubmode() const
+{
+	guint submode = 0;
+
+	switch ( _mode )
+	{
+	case SP_COLOR_SCALES_MODE_HSV:
+		submode = 1;
+		break;
+	case SP_COLOR_SCALES_MODE_CMYK:
+		submode = 2;
+		break;
+	case SP_COLOR_SCALES_MODE_RGB:
+	default:
+		submode = 0;
+	}
+
+	return submode;
+}
+
+void ColorScales::_adjustmentAnyChanged( GtkAdjustment *adjustment, SPColorScales *cs )
+{
+	gint channel = GPOINTER_TO_INT (g_object_get_data(G_OBJECT (adjustment), "channel"));
+
+	_adjustmentChanged(cs, channel);
+}
+
+void ColorScales::_sliderAnyGrabbed()
+{
+	if (!_dragging) {
+		_dragging = TRUE;
+        _grabbed();
+        _recalcColor( FALSE );
+	}
+}
+
+void ColorScales::_sliderAnyReleased()
+{
+	if (_dragging) {
+		_dragging = FALSE;
+        _released();
+        _recalcColor( FALSE );
+	}
+}
+
+void ColorScales::_sliderAnyChanged()
+{
+    _recalcColor( TRUE );
+}
+
+void ColorScales::_adjustmentChanged( SPColorScales *cs, guint channel )
+{
+	ColorScales* scales = static_cast<ColorScales*>(SP_COLOR_SELECTOR(cs)->base);
+	if (scales->_updating) return;
+
+	scales->_updating = TRUE;
+
+	scales->_updateSliders( (1 << channel) );
+
+	scales->_recalcColor (TRUE);
+
+	scales->_updating = FALSE;
+}
+
+void ColorScales::_updateSliders( guint channels )
+{
+	gfloat rgb0[3], rgbm[3], rgb1[3];
+#ifdef SPCS_PREVIEW
+	guint32 rgba;
+#endif
+	switch (_mode) {
+	case SP_COLOR_SCALES_MODE_RGB:
+		if ((channels != CSC_CHANNEL_R) && (channels != CSC_CHANNEL_A)) {
+			/* Update red */
+		    _s[0]->setColors(SP_RGBA32_F_COMPOSE (0.0, getScaled(_a[1]), getScaled(_a[2]), 1.0),
+							  SP_RGBA32_F_COMPOSE (0.5, getScaled(_a[1]), getScaled(_a[2]), 1.0),
+							  SP_RGBA32_F_COMPOSE (1.0, getScaled(_a[1]), getScaled(_a[2]), 1.0));
+		}
+		if ((channels != CSC_CHANNEL_G) && (channels != CSC_CHANNEL_A)) {
+			/* Update green */
+            _s[1]->setColors(SP_RGBA32_F_COMPOSE(getScaled(_a[0]), 0.0, getScaled(_a[2]), 1.0),
+                              SP_RGBA32_F_COMPOSE(getScaled(_a[0]), 0.5, getScaled(_a[2]), 1.0),
+                              SP_RGBA32_F_COMPOSE(getScaled(_a[0]), 1.0, getScaled(_a[2]), 1.0));
+		}
+		if ((channels != CSC_CHANNEL_B) && (channels != CSC_CHANNEL_A)) {
+			/* Update blue */
+		    _s[2]->setColors(SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), 0.0, 1.0),
+                              SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), 0.5, 1.0),
+                              SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), 1.0, 1.0));
+		}
+		if (channels != CSC_CHANNEL_A) {
+			/* Update alpha */
+		    _s[3]->setColors(SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 0.0),
+                              SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 0.5),
+                              SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 1.0));
+		}
+		break;
+	case SP_COLOR_SCALES_MODE_HSV:
+		/* Hue is never updated */
+		if ((channels != CSC_CHANNEL_S) && (channels != CSC_CHANNEL_A)) {
+			/* Update saturation */
+			sp_color_hsl_to_rgb_floatv (rgb0, getScaled(_a[0]), 0.0, getScaled(_a[2]));
+			sp_color_hsl_to_rgb_floatv (rgbm, getScaled(_a[0]), 0.5, getScaled(_a[2]));
+			sp_color_hsl_to_rgb_floatv (rgb1, getScaled(_a[0]), 1.0, getScaled(_a[2]));
+			_s[1]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0),
+                              SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0),
+                              SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0));
+		}
+		if ((channels != CSC_CHANNEL_V) && (channels != CSC_CHANNEL_A)) {
+			/* Update value */
+			sp_color_hsl_to_rgb_floatv (rgb0, getScaled(_a[0]), getScaled(_a[1]), 0.0);
+			sp_color_hsl_to_rgb_floatv (rgbm, getScaled(_a[0]), getScaled(_a[1]), 0.5);
+			sp_color_hsl_to_rgb_floatv (rgb1, getScaled(_a[0]), getScaled(_a[1]), 1.0);
+			_s[2]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0),
+			                  SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0),
+                              SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0));
+		}
+		if (channels != CSC_CHANNEL_A) {
+			/* Update alpha */
+			sp_color_hsl_to_rgb_floatv (rgb0, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]));
+			_s[3]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 0.0),
+                              SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 0.5),
+                              SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0));
+		}
+		break;
+	case SP_COLOR_SCALES_MODE_CMYK:
+		if ((channels != CSC_CHANNEL_C) && (channels != CSC_CHANNEL_CMYKA)) {
+			/* Update C */
+			sp_color_cmyk_to_rgb_floatv (rgb0, 0.0, getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3]));
+			sp_color_cmyk_to_rgb_floatv (rgbm, 0.5, getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3]));
+			sp_color_cmyk_to_rgb_floatv (rgb1, 1.0, getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3]));
+			_s[0]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0),
+                              SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0),
+                              SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0));
+		}
+		if ((channels != CSC_CHANNEL_M) && (channels != CSC_CHANNEL_CMYKA)) {
+			/* Update M */
+			sp_color_cmyk_to_rgb_floatv (rgb0, getScaled(_a[0]), 0.0, getScaled(_a[2]), getScaled(_a[3]));
+			sp_color_cmyk_to_rgb_floatv (rgbm, getScaled(_a[0]), 0.5, getScaled(_a[2]), getScaled(_a[3]));
+			sp_color_cmyk_to_rgb_floatv (rgb1, getScaled(_a[0]), 1.0, getScaled(_a[2]), getScaled(_a[3]));
+			_s[1]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0),
+                              SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0),
+                              SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0));
+		}
+		if ((channels != CSC_CHANNEL_Y) && (channels != CSC_CHANNEL_CMYKA)) {
+			/* Update Y */
+			sp_color_cmyk_to_rgb_floatv (rgb0, getScaled(_a[0]), getScaled(_a[1]), 0.0, getScaled(_a[3]));
+			sp_color_cmyk_to_rgb_floatv (rgbm, getScaled(_a[0]), getScaled(_a[1]), 0.5, getScaled(_a[3]));
+			sp_color_cmyk_to_rgb_floatv (rgb1, getScaled(_a[0]), getScaled(_a[1]), 1.0, getScaled(_a[3]));
+			_s[2]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0),
+                              SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0),
+                              SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0));
+		}
+		if ((channels != CSC_CHANNEL_K) && (channels != CSC_CHANNEL_CMYKA)) {
+			/* Update K */
+			sp_color_cmyk_to_rgb_floatv (rgb0, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 0.0);
+			sp_color_cmyk_to_rgb_floatv (rgbm, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 0.5);
+			sp_color_cmyk_to_rgb_floatv (rgb1, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 1.0);
+			_s[3]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0),
+                              SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0),
+                              SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0));
+		}
+		if (channels != CSC_CHANNEL_CMYKA) {
+			/* Update alpha */
+			sp_color_cmyk_to_rgb_floatv (rgb0, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3]));
+			_s[4]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 0.0),
+                              SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 0.5),
+                              SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0));
+		}
+		break;
+	default:
+		g_warning ("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__);
+		break;
+	}
+
+	// Force the internal color to be updated
+    if ( !_updating )
+    {
+        _recalcColor( TRUE );
+    }
+
+#ifdef SPCS_PREVIEW
+	rgba = sp_color_scales_get_rgba32 (cs);
+	sp_color_preview_set_rgba32 (SP_COLOR_PREVIEW (_p), rgba);
+#endif
+}
+
+static const gchar *
+sp_color_scales_hue_map (void)
+{
+	static gchar *map = NULL;
+
+	if (!map) {
+		gchar *p;
+		gint h;
+		map = g_new (gchar, 4 * 1024);
+		p = map;
+		for (h = 0; h < 1024; h++) {
+			gfloat rgb[3];
+			sp_color_hsl_to_rgb_floatv (rgb, h / 1024.0, 1.0, 0.5);
+			*p++ = SP_COLOR_F_TO_U (rgb[0]);
+			*p++ = SP_COLOR_F_TO_U (rgb[1]);
+			*p++ = SP_COLOR_F_TO_U (rgb[2]);
+			*p++ = 255;
+		}
+	}
+
+	return map;
+}
+
+ColorScalesFactory::ColorScalesFactory(SPColorScalesMode submode)
+    : _submode(submode)
+{
+}
+
+ColorScalesFactory::~ColorScalesFactory() {
+}
+
+Gtk::Widget *ColorScalesFactory::createWidget(Inkscape::UI::SelectedColor &color) const {
+    GtkWidget *w = sp_color_selector_new(SP_TYPE_COLOR_SCALES);
+    SPColorSelector* csel;
+
+    csel = SP_COLOR_SELECTOR (w);
+    if ( _submode > 0 )
+    {
+        csel->base->setSubmode( _submode - 1 );
+    }
+
+    Gtk::Widget *wrapped = Gtk::manage(Glib::wrap(w));
+    return wrapped;
+}
+
+Glib::ustring ColorScalesFactory::modeName() const {
+    return gettext(ColorScales::SUBMODE_NAMES[_submode]);
+}
diff --git a/src/ui/widget/color-scales.h b/src/ui/widget/color-scales.h
new file mode 100644
index 000000000..946f0935e
--- /dev/null
+++ b/src/ui/widget/color-scales.h
@@ -0,0 +1,139 @@
+#ifndef SEEN_SP_COLOR_SCALES_H
+#define SEEN_SP_COLOR_SCALES_H
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H
+#include <glibmm/threads.h>
+#endif
+
+#include <glib.h>
+#include <gtk/gtk.h>
+
+#include <color.h>
+#include <widgets/sp-color-selector.h>
+
+#include "ui/selected-color.h"
+
+struct SPColorScales;
+struct SPColorScalesClass;
+
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+
+class ColorSlider;
+
+}
+}
+}
+
+typedef enum {
+    SP_COLOR_SCALES_MODE_NONE = 0,
+    SP_COLOR_SCALES_MODE_RGB = 1,
+    SP_COLOR_SCALES_MODE_HSV = 2,
+    SP_COLOR_SCALES_MODE_CMYK = 3
+} SPColorScalesMode;
+
+
+
+class ColorScales: public ColorSelector
+{
+public:
+    static const gchar* SUBMODE_NAMES[];
+
+    static gfloat getScaled( const GtkAdjustment *a );
+    static void setScaled( GtkAdjustment *a, gfloat v);
+
+    ColorScales(SPColorSelector *csel);
+    virtual ~ColorScales();
+
+    virtual void init();
+
+    virtual void setSubmode(guint submode);
+    virtual guint getSubmode() const;
+
+    void setMode(SPColorScalesMode mode);
+    SPColorScalesMode getMode() const;
+
+
+protected:
+    virtual void _colorChanged();
+
+    static void _adjustmentAnyChanged(GtkAdjustment *adjustment, SPColorScales *cs);
+    void _sliderAnyGrabbed();
+    void _sliderAnyReleased();
+    void _sliderAnyChanged();
+    static void _adjustmentChanged(SPColorScales *cs, guint channel);
+
+    void _getRgbaFloatv(gfloat *rgba);
+    void _getCmykaFloatv(gfloat *cmyka);
+    guint32 _getRgba32();
+    void _updateSliders(guint channels);
+    void _recalcColor(gboolean changing);
+
+    void _setRangeLimit( gdouble upper );
+
+    SPColorScalesMode _mode;
+    gdouble _rangeLimit;
+    gboolean _updating : 1;
+    gboolean _dragging : 1;
+    GtkAdjustment *_a[5]; /* Channel adjustments */
+    Inkscape::UI::Widget::ColorSlider *_s[5]; /* Channel sliders */
+    GtkWidget *_b[5]; /* Spinbuttons */
+    GtkWidget *_l[5]; /* Labels */
+
+private:
+    // By default, disallow copy constructor and assignment operator
+    ColorScales(ColorScales const &obj);
+    ColorScales &operator=(ColorScales const &obj );
+};
+
+
+
+#define SP_TYPE_COLOR_SCALES (sp_color_scales_get_type())
+#define SP_COLOR_SCALES(o) (G_TYPE_CHECK_INSTANCE_CAST((o), SP_TYPE_COLOR_SCALES, SPColorScales))
+#define SP_COLOR_SCALES_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), SP_TYPE_COLOR_SCALES, SPColorScalesClass))
+#define SP_IS_COLOR_SCALES(o) (G_TYPE_CHECK_INSTANCE_TYPE((o), SP_TYPE_COLOR_SCALES))
+#define SP_IS_COLOR_SCALES_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE((k), SP_TYPE_COLOR_SCALES))
+
+struct SPColorScales {
+    SPColorSelector parent;
+};
+
+struct SPColorScalesClass {
+    SPColorSelectorClass parent_class;
+};
+
+GType sp_color_scales_get_type();
+
+GtkWidget *sp_color_scales_new();
+
+
+class ColorScalesFactory: public Inkscape::UI::ColorSelectorFactory {
+public:
+    ColorScalesFactory(SPColorScalesMode submode);
+    ~ColorScalesFactory();
+
+    Gtk::Widget *createWidget(Inkscape::UI::SelectedColor &color) const;
+    Glib::ustring modeName() const;
+
+private:
+    SPColorScalesMode _submode;
+};
+
+
+#endif /* !SEEN_SP_COLOR_SCALES_H */
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp
index 711942e28..ad9662c6c 100644
--- a/src/ui/widget/color-slider.cpp
+++ b/src/ui/widget/color-slider.cpp
@@ -28,7 +28,7 @@
 #include <gtkmm/style.h>
 #endif
 
-#include "widgets/sp-color-scales.h"
+#include "ui/widget/color-scales.h"
 #include "preferences.h"
 
 static const gint SLIDER_WIDTH = 96;
diff --git a/src/ui/widget/color-wheel-selector.cpp b/src/ui/widget/color-wheel-selector.cpp
index e49e4ba16..4bf40dbb6 100644
--- a/src/ui/widget/color-wheel-selector.cpp
+++ b/src/ui/widget/color-wheel-selector.cpp
@@ -11,9 +11,9 @@
 #include <gtkmm/label.h>
 #include <gtkmm/spinbutton.h>
 #include "dialogs/dialog-events.h"
-#include "widgets/sp-color-scales.h"
 #include "svg/svg-icc-color.h"
 #include "ui/selected-color.h"
+#include "ui/widget/color-scales.h"
 #include "ui/widget/color-slider.h"
 #include "ui/widget/gimpcolorwheel.h"