Merge from trunk

(bzr r14059.2.15)

17 files changed, 4453 insertions, 45 deletions

diff --git a/src/ui/widget/Makefile_insert b/src/ui/widget/Makefile_insert
index e18b790bd..eb98e6872 100644
--- a/src/ui/widget/Makefile_insert
+++ b/src/ui/widget/Makefile_insert
@@ -6,10 +6,22 @@ ink_common_sources +=	\
 	ui/widget/attr-widget.h	\
 	ui/widget/button.h	\
 	ui/widget/button.cpp	\
+	ui/widget/color-entry.cpp    \
+	ui/widget/color-entry.h     \
+	ui/widget/color-icc-selector.cpp	\
+	ui/widget/color-icc-selector.h	\
+	ui/widget/color-notebook.cpp   \
+	ui/widget/color-notebook.h  \
+	ui/widget/color-wheel-selector.cpp    \
+	ui/widget/color-wheel-selector.h    \
 	ui/widget/color-picker.cpp     \
 	ui/widget/color-picker.h        \
 	ui/widget/color-preview.cpp     \
 	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		\
@@ -21,8 +33,10 @@ ink_common_sources +=	\
 	ui/widget/entry.h        \
 	ui/widget/filter-effect-chooser.h \
 	ui/widget/filter-effect-chooser.cpp \
-	ui/widget/gimpspinscale.c      \
-	ui/widget/gimpspinscale.h        \
+	ui/widget/font-variants.h      	\
+	ui/widget/font-variants.cpp     \
+	ui/widget/gimpspinscale.c	\
+	ui/widget/gimpspinscale.h       \
 	ui/widget/gimpcolorwheel.c \
 	ui/widget/gimpcolorwheel.h \
 	ui/widget/frame.cpp      \
diff --git a/src/ui/widget/color-entry.cpp b/src/ui/widget/color-entry.cpp
new file mode 100644
index 000000000..f5658c3a6
--- /dev/null
+++ b/src/ui/widget/color-entry.cpp
@@ -0,0 +1,114 @@
+/** @file
+ * Entry widget for typing color value in css form
+ *//*
+ * Authors:
+ *   Tomasz Boczkowski <penginsbacon@gmail.com>
+ *
+ * Copyright (C) 2014 Authors
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+#include <glibmm.h>
+#include <glibmm/i18n.h>
+#include <iomanip>
+
+#include "color-entry.h"
+
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+
+ColorEntry::ColorEntry(SelectedColor &color)
+    : _color(color)
+    , _updating(false)
+    , _updatingrgba(false)
+{
+    _color_changed_connection = color.signal_changed.connect(sigc::mem_fun(this, &ColorEntry::_onColorChanged));
+    _color_dragged_connection = color.signal_dragged.connect(sigc::mem_fun(this, &ColorEntry::_onColorChanged));
+    _onColorChanged();
+
+    set_max_length(8);
+    set_width_chars(8);
+    set_tooltip_text(_("Hexadecimal RGBA value of the color"));
+}
+
+ColorEntry::~ColorEntry()
+{
+    _color_changed_connection.disconnect();
+    _color_dragged_connection.disconnect();
+}
+
+void ColorEntry::on_changed()
+{
+    if (_updating) {
+        return;
+    }
+    if (_updatingrgba) {
+        return;  // Typing text into entry box
+    }
+
+    Glib::ustring text = get_text();
+    bool changed = false;
+
+    // Coerce the value format to eight hex digits
+    if (!text.empty() && text[0] == '#') {
+        changed = true;
+        text.erase(0, 1);
+        if (text.size() == 6) {
+            // it was a standard RGB hex
+            unsigned int alpha = SP_COLOR_F_TO_U(_color.alpha());
+            text += Glib::ustring::format(std::hex, std::setw(2), std::setfill(L'0'), alpha);
+        }
+    }
+
+    gchar *str = g_strdup(text.c_str());
+    gchar *end = 0;
+    guint64 rgba = g_ascii_strtoull(str, &end, 16);
+    if (end != str) {
+        ptrdiff_t len = end - str;
+        if (len < 8) {
+            rgba = rgba << (4 * (8 - len));
+        }
+        _updatingrgba = true;
+        if (changed) {
+            set_text(str);
+        }
+        SPColor color(rgba);
+        _color.setColorAlpha(color, SP_RGBA32_A_F(rgba));
+        _updatingrgba = false;
+    }
+    g_free(str);
+}
+
+
+void ColorEntry::_onColorChanged()
+{
+    if (_updatingrgba) {
+        return;
+    }
+
+    SPColor color = _color.color();
+    gdouble alpha = _color.alpha();
+
+    guint32 rgba = color.toRGBA32(alpha);
+    Glib::ustring text = Glib::ustring::format(std::hex, std::setw(8), std::setfill(L'0'), rgba);
+
+    Glib::ustring old_text = get_text();
+    if (old_text != text) {
+        _updating = true;
+        set_text(text);
+        _updating = false;
+    }
+}
+}
+}
+}
+/*
+  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:fileencoding=utf-8:textwidth=99 :
diff --git a/src/ui/widget/color-entry.h b/src/ui/widget/color-entry.h
new file mode 100644
index 000000000..edabe1980
--- /dev/null
+++ b/src/ui/widget/color-entry.h
@@ -0,0 +1,54 @@
+/** @file
+ * Entry widget for typing color value in css form
+ *//*
+ * Authors:
+ *   Tomasz Boczkowski <penginsbacon@gmail.com>
+ *
+ * Copyright (C) 2014 Authors
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#ifndef SEEN_COLOR_ENTRY_H
+#define SEEN_COLOR_ENTRY_H_
+
+#include <gtkmm/entry.h>
+#include "ui/selected-color.h"
+
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+
+class ColorEntry : public Gtk::Entry
+{
+public:
+    ColorEntry(SelectedColor &color);
+    virtual ~ColorEntry();
+
+protected:
+    void on_changed();
+
+private:
+    void _onColorChanged();
+
+    SelectedColor &_color;
+    sigc::connection _color_changed_connection;
+    sigc::connection _color_dragged_connection;
+    bool _updating;
+    bool _updatingrgba;
+};
+
+}
+}
+}
+
+#endif
+/*
+  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:fileencoding=utf-8:textwidth=99 :
diff --git a/src/ui/widget/color-icc-selector.cpp b/src/ui/widget/color-icc-selector.cpp
new file mode 100644
index 000000000..1c31ae33a
--- /dev/null
+++ b/src/ui/widget/color-icc-selector.cpp
@@ -0,0 +1,1079 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <math.h>
+#include <gtkmm/adjustment.h>
+#include <glibmm/i18n.h>
+
+#include <gtk/gtk.h>
+#include <map>
+#include <set>
+#include <vector>
+
+#include "ui/dialog-events.h"
+#include "ui/widget/color-icc-selector.h"
+#include "ui/widget/color-scales.h"
+#include "ui/widget/color-slider.h"
+#include "svg/svg-icc-color.h"
+#include "colorspace.h"
+#include "document.h"
+#include "inkscape.h"
+#include "profile-manager.h"
+#include "widgets/gradient-vector.h"
+
+#define noDEBUG_LCMS
+
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+#include "color-profile.h"
+#include "cms-system.h"
+#include "color-profile-cms-fns.h"
+
+#ifdef DEBUG_LCMS
+#include "preferences.h"
+#endif // DEBUG_LCMS
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+
+#ifdef DEBUG_LCMS
+extern guint update_in_progress;
+#define DEBUG_MESSAGE(key, ...)                                                                                        \
+    {                                                                                                                  \
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();                                                   \
+        bool dump = prefs->getBool("/options/scislac/" #key);                                                          \
+        bool dumpD = prefs->getBool("/options/scislac/" #key "D");                                                     \
+        bool dumpD2 = prefs->getBool("/options/scislac/" #key "D2");                                                   \
+        dumpD && = ((update_in_progress == 0) || dumpD2);                                                              \
+        if (dump) {                                                                                                    \
+            g_message(__VA_ARGS__);                                                                                    \
+        }                                                                                                              \
+        if (dumpD) {                                                                                                   \
+            GtkWidget *dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO,         \
+                                                       GTK_BUTTONS_OK, __VA_ARGS__);                                   \
+            g_signal_connect_swapped(dialog, "response", G_CALLBACK(gtk_widget_destroy), dialog);                      \
+            gtk_widget_show_all(dialog);                                                                               \
+        }                                                                                                              \
+    }
+#endif // DEBUG_LCMS
+
+
+#define XPAD 4
+#define YPAD 1
+
+namespace {
+
+size_t maxColorspaceComponentCount = 0;
+
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+
+/**
+ * Internal variable to track all known colorspaces.
+ */
+std::set<cmsUInt32Number> knownColorspaces;
+
+#endif
+
+
+/**
+ * Simple helper to allow bitwise or on GtkAttachOptions.
+ */
+GtkAttachOptions operator|(GtkAttachOptions lhs, GtkAttachOptions rhs)
+{
+    return static_cast<GtkAttachOptions>(static_cast<int>(lhs) | static_cast<int>(rhs));
+}
+
+/**
+ * Helper function to handle GTK2/GTK3 attachment #ifdef code.
+ */
+void attachToGridOrTable(GtkWidget *parent, GtkWidget *child, guint left, guint top, guint width, guint height,
+                         bool hexpand = false, bool centered = false, guint xpadding = XPAD, guint ypadding = YPAD)
+{
+#if GTK_CHECK_VERSION(3, 0, 0)
+  #if GTK_CHECK_VERSION(3, 12, 0)
+    gtk_widget_set_margin_start(child, xpadding);
+    gtk_widget_set_margin_end(child, xpadding);
+  #else
+    gtk_widget_set_margin_left(child, xpadding);
+    gtk_widget_set_margin_right(child, xpadding);
+  #endif
+
+    gtk_widget_set_margin_top(child, ypadding);
+    gtk_widget_set_margin_bottom(child, ypadding);
+    if (hexpand) {
+        gtk_widget_set_hexpand(child, TRUE);
+    }
+    if (centered) {
+        gtk_widget_set_halign(child, GTK_ALIGN_CENTER);
+        gtk_widget_set_valign(child, GTK_ALIGN_CENTER);
+    }
+    gtk_grid_attach(GTK_GRID(parent), child, left, top, width, height);
+#else
+    GtkAttachOptions xoptions =
+        centered ? static_cast<GtkAttachOptions>(0) : hexpand ? (GTK_EXPAND | GTK_FILL) : GTK_FILL;
+    GtkAttachOptions yoptions = centered ? static_cast<GtkAttachOptions>(0) : GTK_FILL;
+
+    gtk_table_attach(GTK_TABLE(parent), child, left, left + width, top, top + height, xoptions, yoptions, xpadding,
+                     ypadding);
+#endif
+}
+
+} // namespace
+
+/*
+icSigRgbData
+icSigCmykData
+icSigCmyData
+*/
+#define SPACE_ID_RGB 0
+#define SPACE_ID_CMY 1
+#define SPACE_ID_CMYK 2
+
+
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+static cmsUInt16Number *getScratch()
+{
+    // bytes per pixel * input channels * width
+    static cmsUInt16Number *scritch = static_cast<cmsUInt16Number *>(g_new(cmsUInt16Number, 4 * 1024));
+
+    return scritch;
+}
+
+colorspace::Component::Component()
+    : name()
+    , tip()
+    , scale(1)
+{
+}
+
+colorspace::Component::Component(std::string const &name, std::string const &tip, guint scale)
+    : name(name)
+    , tip(tip)
+    , scale(scale)
+{
+}
+
+std::vector<colorspace::Component> colorspace::getColorSpaceInfo(uint32_t space)
+{
+    static std::map<cmsUInt32Number, std::vector<Component> > sets;
+    if (sets.empty()) {
+        sets[cmsSigXYZData].push_back(Component("_X", "X", 2)); //  TYPE_XYZ_16
+        sets[cmsSigXYZData].push_back(Component("_Y", "Y", 1));
+        sets[cmsSigXYZData].push_back(Component("_Z", "Z", 2));
+
+        sets[cmsSigLabData].push_back(Component("_L", "L", 100)); // TYPE_Lab_16
+        sets[cmsSigLabData].push_back(Component("_a", "a", 256));
+        sets[cmsSigLabData].push_back(Component("_b", "b", 256));
+
+        // cmsSigLuvData
+
+        sets[cmsSigYCbCrData].push_back(Component("_Y", "Y", 1)); // TYPE_YCbCr_16
+        sets[cmsSigYCbCrData].push_back(Component("C_b", "Cb", 1));
+        sets[cmsSigYCbCrData].push_back(Component("C_r", "Cr", 1));
+
+        sets[cmsSigYxyData].push_back(Component("_Y", "Y", 1)); // TYPE_Yxy_16
+        sets[cmsSigYxyData].push_back(Component("_x", "x", 1));
+        sets[cmsSigYxyData].push_back(Component("y", "y", 1));
+
+        sets[cmsSigRgbData].push_back(Component(_("_R:"), _("Red"), 1)); // TYPE_RGB_16
+        sets[cmsSigRgbData].push_back(Component(_("_G:"), _("Green"), 1));
+        sets[cmsSigRgbData].push_back(Component(_("_B:"), _("Blue"), 1));
+
+        sets[cmsSigGrayData].push_back(Component(_("G:"), _("Gray"), 1)); // TYPE_GRAY_16
+
+        sets[cmsSigHsvData].push_back(Component(_("_H:"), _("Hue"), 360)); // TYPE_HSV_16
+        sets[cmsSigHsvData].push_back(Component(_("_S:"), _("Saturation"), 1));
+        sets[cmsSigHsvData].push_back(Component("_V:", "Value", 1));
+
+        sets[cmsSigHlsData].push_back(Component(_("_H:"), _("Hue"), 360)); // TYPE_HLS_16
+        sets[cmsSigHlsData].push_back(Component(_("_L:"), _("Lightness"), 1));
+        sets[cmsSigHlsData].push_back(Component(_("_S:"), _("Saturation"), 1));
+
+        sets[cmsSigCmykData].push_back(Component(_("_C:"), _("Cyan"), 1)); // TYPE_CMYK_16
+        sets[cmsSigCmykData].push_back(Component(_("_M:"), _("Magenta"), 1));
+        sets[cmsSigCmykData].push_back(Component(_("_Y:"), _("Yellow"), 1));
+        sets[cmsSigCmykData].push_back(Component(_("_K:"), _("Black"), 1));
+
+        sets[cmsSigCmyData].push_back(Component(_("_C:"), _("Cyan"), 1)); // TYPE_CMY_16
+        sets[cmsSigCmyData].push_back(Component(_("_M:"), _("Magenta"), 1));
+        sets[cmsSigCmyData].push_back(Component(_("_Y:"), _("Yellow"), 1));
+
+        for (std::map<cmsUInt32Number, std::vector<Component> >::iterator it = sets.begin(); it != sets.end(); ++it) {
+            knownColorspaces.insert(it->first);
+            maxColorspaceComponentCount = std::max(maxColorspaceComponentCount, it->second.size());
+        }
+    }
+
+    std::vector<Component> target;
+
+    if (sets.find(space) != sets.end()) {
+        target = sets[space];
+    }
+    return target;
+}
+
+
+std::vector<colorspace::Component> colorspace::getColorSpaceInfo(Inkscape::ColorProfile *prof)
+{
+    return getColorSpaceInfo(asICColorSpaceSig(prof->getColorSpace()));
+}
+
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+
+/**
+ * Class containing the parts for a single color component's UI presence.
+ */
+class ComponentUI {
+  public:
+    ComponentUI()
+        : _component()
+        , _adj(0)
+        , _slider(0)
+        , _btn(0)
+        , _label(0)
+        , _map(0)
+    {
+    }
+
+    ComponentUI(colorspace::Component const &component)
+        : _component(component)
+        , _adj(0)
+        , _slider(0)
+        , _btn(0)
+        , _label(0)
+        , _map(0)
+    {
+    }
+
+    colorspace::Component _component;
+    GtkAdjustment *_adj; // Component adjustment
+    Inkscape::UI::Widget::ColorSlider *_slider;
+    GtkWidget *_btn;   // spinbutton
+    GtkWidget *_label; // Label
+    guchar *_map;
+};
+
+/**
+ * Class that implements the internals of the selector.
+ */
+class ColorICCSelectorImpl {
+  public:
+    ColorICCSelectorImpl(ColorICCSelector *owner, SelectedColor &color);
+
+    ~ColorICCSelectorImpl();
+
+    static void _adjustmentChanged(GtkAdjustment *adjustment, ColorICCSelectorImpl *cs);
+
+    void _sliderGrabbed();
+    void _sliderReleased();
+    void _sliderChanged();
+
+    static void _profileSelected(GtkWidget *src, gpointer data);
+    static void _fixupHit(GtkWidget *src, gpointer data);
+
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    void _setProfile(SVGICCColor *profile);
+    void _switchToProfile(gchar const *name);
+#endif
+    void _updateSliders(gint ignore);
+    void _profilesChanged(std::string const &name);
+
+    ColorICCSelector *_owner;
+    SelectedColor &_color;
+
+    gboolean _updating : 1;
+    gboolean _dragging : 1;
+
+    guint32 _fixupNeeded;
+    GtkWidget *_fixupBtn;
+    GtkWidget *_profileSel;
+
+    std::vector<ComponentUI> _compUI;
+
+    GtkAdjustment *_adj; // Channel adjustment
+    Inkscape::UI::Widget::ColorSlider *_slider;
+    GtkWidget *_sbtn;  // Spinbutton
+    GtkWidget *_label; // Label
+
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    std::string _profileName;
+    Inkscape::ColorProfile *_prof;
+    guint _profChannelCount;
+    gulong _profChangedID;
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+};
+
+
+
+const gchar *ColorICCSelector::MODE_NAME = N_("CMS");
+
+ColorICCSelector::ColorICCSelector(SelectedColor &color)
+    : _impl(NULL)
+{
+    _impl = new ColorICCSelectorImpl(this, color);
+    init();
+    color.signal_changed.connect(sigc::mem_fun(this, &ColorICCSelector::_colorChanged));
+    // color.signal_dragged.connect(sigc::mem_fun(this, &ColorICCSelector::_colorChanged));
+}
+
+ColorICCSelector::~ColorICCSelector()
+{
+    if (_impl) {
+        delete _impl;
+        _impl = 0;
+    }
+}
+
+
+
+ColorICCSelectorImpl::ColorICCSelectorImpl(ColorICCSelector *owner, SelectedColor &color)
+    : _owner(owner)
+    , _color(color)
+    , _updating(FALSE)
+    , _dragging(FALSE)
+    , _fixupNeeded(0)
+    , _fixupBtn(0)
+    , _profileSel(0)
+    , _compUI()
+    , _adj(0)
+    , _slider(0)
+    , _sbtn(0)
+    , _label(0)
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    , _profileName()
+    , _prof(0)
+    , _profChannelCount(0)
+    , _profChangedID(0)
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+{
+}
+
+ColorICCSelectorImpl::~ColorICCSelectorImpl()
+{
+    _adj = 0;
+    _sbtn = 0;
+    _label = 0;
+}
+
+void ColorICCSelector::init()
+{
+    gint row = 0;
+
+    _impl->_updating = FALSE;
+    _impl->_dragging = FALSE;
+
+    GtkWidget *t = GTK_WIDGET(gobj());
+
+    _impl->_compUI.clear();
+
+    // Create components
+    row = 0;
+
+
+    _impl->_fixupBtn = gtk_button_new_with_label(_("Fix"));
+    g_signal_connect(G_OBJECT(_impl->_fixupBtn), "clicked", G_CALLBACK(ColorICCSelectorImpl::_fixupHit),
+                     (gpointer)_impl);
+    gtk_widget_set_sensitive(_impl->_fixupBtn, FALSE);
+    gtk_widget_set_tooltip_text(_impl->_fixupBtn, _("Fix RGB fallback to match icc-color() value."));
+    // gtk_misc_set_alignment( GTK_MISC (_impl->_fixupBtn), 1.0, 0.5 );
+    gtk_widget_show(_impl->_fixupBtn);
+
+    attachToGridOrTable(t, _impl->_fixupBtn, 0, row, 1, 1);
+
+    // Combobox and store with 2 columns : label (0) and full name (1)
+    GtkListStore *store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
+    _impl->_profileSel = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
+
+    GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
+    gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(_impl->_profileSel), renderer, TRUE);
+    gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(_impl->_profileSel), renderer, "text", 0, NULL);
+
+    GtkTreeIter iter;
+    gtk_list_store_append(store, &iter);
+    gtk_list_store_set(store, &iter, 0, _("<none>"), 1, _("<none>"), -1);
+
+    gtk_widget_show(_impl->_profileSel);
+    gtk_combo_box_set_active(GTK_COMBO_BOX(_impl->_profileSel), 0);
+
+    attachToGridOrTable(t, _impl->_profileSel, 1, row, 1, 1);
+
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    _impl->_profChangedID = g_signal_connect(G_OBJECT(_impl->_profileSel), "changed",
+                                             G_CALLBACK(ColorICCSelectorImpl::_profileSelected), (gpointer)_impl);
+#else
+    gtk_widget_set_sensitive(_impl->_profileSel, false);
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+
+
+    row++;
+
+// populate the data for colorspaces and channels:
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    std::vector<colorspace::Component> things = colorspace::getColorSpaceInfo(cmsSigRgbData);
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+
+    for (size_t i = 0; i < maxColorspaceComponentCount; i++) {
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+        if (i < things.size()) {
+            _impl->_compUI.push_back(ComponentUI(things[i]));
+        }
+        else {
+            _impl->_compUI.push_back(ComponentUI());
+        }
+
+        std::string labelStr = (i < things.size()) ? things[i].name.c_str() : "";
+#else
+        _impl->_compUI.push_back(ComponentUI());
+
+        std::string labelStr = ".";
+#endif
+
+        _impl->_compUI[i]._label = gtk_label_new_with_mnemonic(labelStr.c_str());
+        gtk_misc_set_alignment(GTK_MISC(_impl->_compUI[i]._label), 1.0, 0.5);
+        gtk_widget_show(_impl->_compUI[i]._label);
+        gtk_widget_set_no_show_all(_impl->_compUI[i]._label, TRUE);
+
+        attachToGridOrTable(t, _impl->_compUI[i]._label, 0, row, 1, 1);
+
+        // Adjustment
+        guint scaleValue = _impl->_compUI[i]._component.scale;
+        gdouble step = static_cast<gdouble>(scaleValue) / 100.0;
+        gdouble page = static_cast<gdouble>(scaleValue) / 10.0;
+        gint digits = (step > 0.9) ? 0 : 2;
+        _impl->_compUI[i]._adj = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, scaleValue, step, page, page));
+
+        // Slider
+        _impl->_compUI[i]._slider =
+            Gtk::manage(new Inkscape::UI::Widget::ColorSlider(Glib::wrap(_impl->_compUI[i]._adj, true)));
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+        _impl->_compUI[i]._slider->set_tooltip_text((i < things.size()) ? things[i].tip.c_str() : "");
+#else
+        _impl->_compUI[i]._slider->set_tooltip_text(".");
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+        _impl->_compUI[i]._slider->show();
+        _impl->_compUI[i]._slider->set_no_show_all();
+
+        attachToGridOrTable(t, _impl->_compUI[i]._slider->gobj(), 1, row, 1, 1, true);
+
+        _impl->_compUI[i]._btn = gtk_spin_button_new(_impl->_compUI[i]._adj, step, digits);
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+        gtk_widget_set_tooltip_text(_impl->_compUI[i]._btn, (i < things.size()) ? things[i].tip.c_str() : "");
+#else
+        gtk_widget_set_tooltip_text(_impl->_compUI[i]._btn, ".");
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+        sp_dialog_defocus_on_enter(_impl->_compUI[i]._btn);
+        gtk_label_set_mnemonic_widget(GTK_LABEL(_impl->_compUI[i]._label), _impl->_compUI[i]._btn);
+        gtk_widget_show(_impl->_compUI[i]._btn);
+        gtk_widget_set_no_show_all(_impl->_compUI[i]._btn, TRUE);
+
+        attachToGridOrTable(t, _impl->_compUI[i]._btn, 2, row, 1, 1, false, true);
+
+        _impl->_compUI[i]._map = g_new(guchar, 4 * 1024);
+        memset(_impl->_compUI[i]._map, 0x0ff, 1024 * 4);
+
+
+        // Signals
+        g_signal_connect(G_OBJECT(_impl->_compUI[i]._adj), "value_changed",
+                         G_CALLBACK(ColorICCSelectorImpl::_adjustmentChanged), _impl);
+
+        _impl->_compUI[i]._slider->signal_grabbed.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderGrabbed));
+        _impl->_compUI[i]._slider->signal_released.connect(
+            sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderReleased));
+        _impl->_compUI[i]._slider->signal_value_changed.connect(
+            sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderChanged));
+
+        row++;
+    }
+
+    // Label
+    _impl->_label = gtk_label_new_with_mnemonic(_("_A:"));
+    gtk_misc_set_alignment(GTK_MISC(_impl->_label), 1.0, 0.5);
+    gtk_widget_show(_impl->_label);
+
+    attachToGridOrTable(t, _impl->_label, 0, row, 1, 1);
+
+    // Adjustment
+    _impl->_adj = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 255.0, 1.0, 10.0, 10.0));
+
+    // Slider
+    _impl->_slider = Gtk::manage(new Inkscape::UI::Widget::ColorSlider(Glib::wrap(_impl->_adj, true)));
+    _impl->_slider->set_tooltip_text(_("Alpha (opacity)"));
+    _impl->_slider->show();
+
+    attachToGridOrTable(t, _impl->_slider->gobj(), 1, row, 1, 1, true);
+
+    _impl->_slider->setColors(SP_RGBA32_F_COMPOSE(1.0, 1.0, 1.0, 0.0), SP_RGBA32_F_COMPOSE(1.0, 1.0, 1.0, 0.5),
+                              SP_RGBA32_F_COMPOSE(1.0, 1.0, 1.0, 1.0));
+
+
+    // Spinbutton
+    _impl->_sbtn = gtk_spin_button_new(GTK_ADJUSTMENT(_impl->_adj), 1.0, 0);
+    gtk_widget_set_tooltip_text(_impl->_sbtn, _("Alpha (opacity)"));
+    sp_dialog_defocus_on_enter(_impl->_sbtn);
+    gtk_label_set_mnemonic_widget(GTK_LABEL(_impl->_label), _impl->_sbtn);
+    gtk_widget_show(_impl->_sbtn);
+
+    attachToGridOrTable(t, _impl->_sbtn, 2, row, 1, 1, false, true);
+
+    // Signals
+    g_signal_connect(G_OBJECT(_impl->_adj), "value_changed", G_CALLBACK(ColorICCSelectorImpl::_adjustmentChanged),
+                     _impl);
+
+    _impl->_slider->signal_grabbed.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderGrabbed));
+    _impl->_slider->signal_released.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderReleased));
+    _impl->_slider->signal_value_changed.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderChanged));
+
+    gtk_widget_show(t);
+}
+
+void ColorICCSelectorImpl::_fixupHit(GtkWidget * /*src*/, gpointer data)
+{
+    ColorICCSelectorImpl *self = reinterpret_cast<ColorICCSelectorImpl *>(data);
+    gtk_widget_set_sensitive(self->_fixupBtn, FALSE);
+    self->_adjustmentChanged(self->_compUI[0]._adj, self);
+}
+
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+void ColorICCSelectorImpl::_profileSelected(GtkWidget * /*src*/, gpointer data)
+{
+    ColorICCSelectorImpl *self = reinterpret_cast<ColorICCSelectorImpl *>(data);
+
+    GtkTreeIter iter;
+    if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(self->_profileSel), &iter)) {
+        GtkTreeModel *store = gtk_combo_box_get_model(GTK_COMBO_BOX(self->_profileSel));
+        gchar *name = 0;
+
+        gtk_tree_model_get(store, &iter, 1, &name, -1);
+        self->_switchToProfile(name);
+        gtk_widget_set_tooltip_text(self->_profileSel, name);
+
+        if (name) {
+            g_free(name);
+        }
+    }
+}
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+void ColorICCSelectorImpl::_switchToProfile(gchar const *name)
+{
+    bool dirty = false;
+    SPColor tmp(_color.color());
+
+    if (name) {
+        if (tmp.icc && tmp.icc->colorProfile == name) {
+#ifdef DEBUG_LCMS
+            g_message("Already at name [%s]", name);
+#endif // DEBUG_LCMS
+        }
+        else {
+#ifdef DEBUG_LCMS
+            g_message("Need to switch to profile [%s]", name);
+#endif // DEBUG_LCMS
+            if (tmp.icc) {
+                tmp.icc->colors.clear();
+            }
+            else {
+                tmp.icc = new SVGICCColor();
+            }
+            tmp.icc->colorProfile = name;
+            Inkscape::ColorProfile *newProf = SP_ACTIVE_DOCUMENT->profileManager->find(name);
+            if (newProf) {
+                cmsHTRANSFORM trans = newProf->getTransfFromSRGB8();
+                if (trans) {
+                    guint32 val = _color.color().toRGBA32(0);
+                    guchar pre[4] = {
+                        static_cast<guchar>(SP_RGBA32_R_U(val)),
+                        static_cast<guchar>(SP_RGBA32_G_U(val)),
+                        static_cast<guchar>(SP_RGBA32_B_U(val)),
+                        255};
+#ifdef DEBUG_LCMS
+                    g_message("Shoving in [%02x] [%02x] [%02x]", pre[0], pre[1], pre[2]);
+#endif // DEBUG_LCMS
+                    cmsUInt16Number post[4] = { 0, 0, 0, 0 };
+                    cmsDoTransform(trans, pre, post, 1);
+#ifdef DEBUG_LCMS
+                    g_message("got on out [%04x] [%04x] [%04x] [%04x]", post[0], post[1], post[2], post[3]);
+#endif // DEBUG_LCMS
+#if HAVE_LIBLCMS1
+                    guint count = _cmsChannelsOf(asICColorSpaceSig(newProf->getColorSpace()));
+#elif HAVE_LIBLCMS2
+                    guint count = cmsChannelsOf(asICColorSpaceSig(newProf->getColorSpace()));
+#endif
+
+                    std::vector<colorspace::Component> things =
+                        colorspace::getColorSpaceInfo(asICColorSpaceSig(newProf->getColorSpace()));
+
+                    for (guint i = 0; i < count; i++) {
+                        gdouble val =
+                            (((gdouble)post[i]) / 65535.0) * (gdouble)((i < things.size()) ? things[i].scale : 1);
+#ifdef DEBUG_LCMS
+                        g_message("     scaled %d by %d to be %f", i, ((i < things.size()) ? things[i].scale : 1), val);
+#endif // DEBUG_LCMS
+                        tmp.icc->colors.push_back(val);
+                    }
+                    cmsHTRANSFORM retrans = newProf->getTransfToSRGB8();
+                    if (retrans) {
+                        cmsDoTransform(retrans, post, pre, 1);
+#ifdef DEBUG_LCMS
+                        g_message("  back out [%02x] [%02x] [%02x]", pre[0], pre[1], pre[2]);
+#endif // DEBUG_LCMS
+                        tmp.set(SP_RGBA32_U_COMPOSE(pre[0], pre[1], pre[2], 0xff));
+                    }
+                }
+            }
+            dirty = true;
+        }
+    }
+    else {
+#ifdef DEBUG_LCMS
+        g_message("NUKE THE ICC");
+#endif // DEBUG_LCMS
+        if (tmp.icc) {
+            delete tmp.icc;
+            tmp.icc = 0;
+            dirty = true;
+            _fixupHit(0, this);
+        }
+        else {
+#ifdef DEBUG_LCMS
+            g_message("No icc to nuke");
+#endif // DEBUG_LCMS
+        }
+    }
+
+    if (dirty) {
+#ifdef DEBUG_LCMS
+        g_message("+----------------");
+        g_message("+   new color is [%s]", tmp.toString().c_str());
+#endif // DEBUG_LCMS
+        _setProfile(tmp.icc);
+        //_adjustmentChanged( _compUI[0]._adj, SP_COLOR_ICC_SELECTOR(_csel) );
+        _color.setColor(tmp);
+#ifdef DEBUG_LCMS
+        g_message("+_________________");
+#endif // DEBUG_LCMS
+    }
+}
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+void ColorICCSelectorImpl::_profilesChanged(std::string const &name)
+{
+    GtkComboBox *combo = GTK_COMBO_BOX(_profileSel);
+
+    g_signal_handler_block(G_OBJECT(_profileSel), _profChangedID);
+
+    GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model(combo));
+    gtk_list_store_clear(store);
+
+    GtkTreeIter iter;
+    gtk_list_store_append(store, &iter);
+    gtk_list_store_set(store, &iter, 0, _("<none>"), 1, _("<none>"), -1);
+
+    gtk_combo_box_set_active(combo, 0);
+
+    int index = 1;
+    const GSList *current = SP_ACTIVE_DOCUMENT->getResourceList("iccprofile");
+    while (current) {
+        SPObject *obj = SP_OBJECT(current->data);
+        Inkscape::ColorProfile *prof = reinterpret_cast<Inkscape::ColorProfile *>(obj);
+
+        gtk_list_store_append(store, &iter);
+        gtk_list_store_set(store, &iter, 0, gr_ellipsize_text(prof->name, 25).c_str(), 1, prof->name, -1);
+
+        if (name == prof->name) {
+            gtk_combo_box_set_active(combo, index);
+            gtk_widget_set_tooltip_text(_profileSel, prof->name);
+        }
+
+        index++;
+        current = g_slist_next(current);
+    }
+
+    g_signal_handler_unblock(G_OBJECT(_profileSel), _profChangedID);
+}
+#else
+void ColorICCSelectorImpl::_profilesChanged(std::string const & /*name*/) {}
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+
+void ColorICCSelector::on_show()
+{
+#if GTK_CHECK_VERSION(3, 0, 0)
+    Gtk::Grid::on_show();
+#else
+    Gtk::Table::on_show();
+#endif
+    _colorChanged();
+}
+
+// Helpers for setting color value
+
+void ColorICCSelector::_colorChanged()
+{
+    _impl->_updating = TRUE;
+// sp_color_icc_set_color( SP_COLOR_ICC( _icc ), &color );
+
+#ifdef DEBUG_LCMS
+    g_message("/^^^^^^^^^  %p::_colorChanged(%08x:%s)", this, _impl->_color.color().toRGBA32(_impl->_color.alpha()),
+              ((_impl->_color.color().icc) ? _impl->_color.color().icc->colorProfile.c_str() : "<null>"));
+#endif // DEBUG_LCMS
+
+#ifdef DEBUG_LCMS
+    g_message("FLIPPIES!!!!     %p   '%s'", _impl->_color.color().icc,
+              (_impl->_color.color().icc ? _impl->_color.color().icc->colorProfile.c_str() : "<null>"));
+#endif // DEBUG_LCMS
+
+    _impl->_profilesChanged((_impl->_color.color().icc) ? _impl->_color.color().icc->colorProfile : std::string(""));
+    ColorScales::setScaled(_impl->_adj, _impl->_color.alpha());
+
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    _impl->_setProfile(_impl->_color.color().icc);
+    _impl->_fixupNeeded = 0;
+    gtk_widget_set_sensitive(_impl->_fixupBtn, FALSE);
+
+    if (_impl->_prof) {
+        if (_impl->_prof->getTransfToSRGB8()) {
+            cmsUInt16Number tmp[4];
+            for (guint i = 0; i < _impl->_profChannelCount; i++) {
+                gdouble val = 0.0;
+                if (_impl->_color.color().icc->colors.size() > i) {
+                    if (_impl->_compUI[i]._component.scale == 256) {
+                        val = (_impl->_color.color().icc->colors[i] + 128.0) /
+                              static_cast<gdouble>(_impl->_compUI[i]._component.scale);
+                    }
+                    else {
+                        val = _impl->_color.color().icc->colors[i] /
+                              static_cast<gdouble>(_impl->_compUI[i]._component.scale);
+                    }
+                }
+                tmp[i] = val * 0x0ffff;
+            }
+            guchar post[4] = { 0, 0, 0, 0 };
+            cmsHTRANSFORM trans = _impl->_prof->getTransfToSRGB8();
+            if (trans) {
+                cmsDoTransform(trans, tmp, post, 1);
+                guint32 other = SP_RGBA32_U_COMPOSE(post[0], post[1], post[2], 255);
+                if (other != _impl->_color.color().toRGBA32(255)) {
+                    _impl->_fixupNeeded = other;
+                    gtk_widget_set_sensitive(_impl->_fixupBtn, TRUE);
+#ifdef DEBUG_LCMS
+                    g_message("Color needs to change 0x%06x to 0x%06x", _color.toRGBA32(255) >> 8, other >> 8);
+#endif // DEBUG_LCMS
+                }
+            }
+        }
+    }
+#else
+//(void)color;
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    _impl->_updateSliders(-1);
+
+
+    _impl->_updating = FALSE;
+#ifdef DEBUG_LCMS
+    g_message("\\_________  %p::_colorChanged()", this);
+#endif // DEBUG_LCMS
+}
+
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+void ColorICCSelectorImpl::_setProfile(SVGICCColor *profile)
+{
+#ifdef DEBUG_LCMS
+    g_message("/^^^^^^^^^  %p::_setProfile(%s)", this, ((profile) ? profile->colorProfile.c_str() : "<null>"));
+#endif // DEBUG_LCMS
+    bool profChanged = false;
+    if (_prof && (!profile || (_profileName != profile->colorProfile))) {
+        // Need to clear out the prior one
+        profChanged = true;
+        _profileName.clear();
+        _prof = 0;
+        _profChannelCount = 0;
+    }
+    else if (profile && !_prof) {
+        profChanged = true;
+    }
+
+    for (size_t i = 0; i < _compUI.size(); i++) {
+        gtk_widget_hide(_compUI[i]._label);
+        _compUI[i]._slider->hide();
+        gtk_widget_hide(_compUI[i]._btn);
+    }
+
+    if (profile) {
+        _prof = SP_ACTIVE_DOCUMENT->profileManager->find(profile->colorProfile.c_str());
+        if (_prof && (asICColorProfileClassSig(_prof->getProfileClass()) != cmsSigNamedColorClass)) {
+#if HAVE_LIBLCMS1
+            _profChannelCount = _cmsChannelsOf(asICColorSpaceSig(_prof->getColorSpace()));
+#elif HAVE_LIBLCMS2
+            _profChannelCount = cmsChannelsOf(asICColorSpaceSig(_prof->getColorSpace()));
+#endif
+
+            if (profChanged) {
+                std::vector<colorspace::Component> things =
+                    colorspace::getColorSpaceInfo(asICColorSpaceSig(_prof->getColorSpace()));
+                for (size_t i = 0; (i < things.size()) && (i < _profChannelCount); ++i) {
+                    _compUI[i]._component = things[i];
+                }
+
+                for (guint i = 0; i < _profChannelCount; i++) {
+                    gtk_label_set_text_with_mnemonic(GTK_LABEL(_compUI[i]._label),
+                                                     (i < things.size()) ? things[i].name.c_str() : "");
+
+                    _compUI[i]._slider->set_tooltip_text((i < things.size()) ? things[i].tip.c_str() : "");
+                    gtk_widget_set_tooltip_text(_compUI[i]._btn, (i < things.size()) ? things[i].tip.c_str() : "");
+
+                    _compUI[i]._slider->setColors(SPColor(0.0, 0.0, 0.0).toRGBA32(0xff),
+                                                  SPColor(0.5, 0.5, 0.5).toRGBA32(0xff),
+                                                  SPColor(1.0, 1.0, 1.0).toRGBA32(0xff));
+                    /*
+                                        _compUI[i]._adj = GTK_ADJUSTMENT( gtk_adjustment_new( val, 0.0, _fooScales[i],
+                       step, page, page ) );
+                                        g_signal_connect( G_OBJECT( _compUI[i]._adj ), "value_changed", G_CALLBACK(
+                       _adjustmentChanged ), _csel );
+
+                                        sp_color_slider_set_adjustment( SP_COLOR_SLIDER(_compUI[i]._slider),
+                       _compUI[i]._adj );
+                                        gtk_spin_button_set_adjustment( GTK_SPIN_BUTTON(_compUI[i]._btn),
+                       _compUI[i]._adj );
+                                        gtk_spin_button_set_digits( GTK_SPIN_BUTTON(_compUI[i]._btn), digits );
+                    */
+                    gtk_widget_show(_compUI[i]._label);
+                    _compUI[i]._slider->show();
+                    gtk_widget_show(_compUI[i]._btn);
+                    // gtk_adjustment_set_value( _compUI[i]._adj, 0.0 );
+                    // gtk_adjustment_set_value( _compUI[i]._adj, val );
+                }
+                for (size_t i = _profChannelCount; i < _compUI.size(); i++) {
+                    gtk_widget_hide(_compUI[i]._label);
+                    _compUI[i]._slider->hide();
+                    gtk_widget_hide(_compUI[i]._btn);
+                }
+            }
+        }
+        else {
+            // Give up for now on named colors
+            _prof = 0;
+        }
+    }
+
+#ifdef DEBUG_LCMS
+    g_message("\\_________  %p::_setProfile()", this);
+#endif // DEBUG_LCMS
+}
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+
+void ColorICCSelectorImpl::_updateSliders(gint ignore)
+{
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    if (_color.color().icc) {
+        for (guint i = 0; i < _profChannelCount; i++) {
+            gdouble val = 0.0;
+            if (_color.color().icc->colors.size() > i) {
+                if (_compUI[i]._component.scale == 256) {
+                    val = (_color.color().icc->colors[i] + 128.0) / static_cast<gdouble>(_compUI[i]._component.scale);
+                }
+                else {
+                    val = _color.color().icc->colors[i] / static_cast<gdouble>(_compUI[i]._component.scale);
+                }
+            }
+            gtk_adjustment_set_value(_compUI[i]._adj, val);
+        }
+
+        if (_prof) {
+            if (_prof->getTransfToSRGB8()) {
+                for (guint i = 0; i < _profChannelCount; i++) {
+                    if (static_cast<gint>(i) != ignore) {
+                        cmsUInt16Number *scratch = getScratch();
+                        cmsUInt16Number filler[4] = { 0, 0, 0, 0 };
+                        for (guint j = 0; j < _profChannelCount; j++) {
+                            filler[j] = 0x0ffff * ColorScales::getScaled(_compUI[j]._adj);
+                        }
+
+                        cmsUInt16Number *p = scratch;
+                        for (guint x = 0; x < 1024; x++) {
+                            for (guint j = 0; j < _profChannelCount; j++) {
+                                if (j == i) {
+                                    *p++ = x * 0x0ffff / 1024;
+                                }
+                                else {
+                                    *p++ = filler[j];
+                                }
+                            }
+                        }
+
+                        cmsHTRANSFORM trans = _prof->getTransfToSRGB8();
+                        if (trans) {
+                            cmsDoTransform(trans, scratch, _compUI[i]._map, 1024);
+                            if (_compUI[i]._slider)
+                            {
+                                _compUI[i]._slider->setMap(_compUI[i]._map);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+#else
+    (void)ignore;
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+
+    guint32 start = _color.color().toRGBA32(0x00);
+    guint32 mid = _color.color().toRGBA32(0x7f);
+    guint32 end = _color.color().toRGBA32(0xff);
+
+    _slider->setColors(start, mid, end);
+}
+
+
+void ColorICCSelectorImpl::_adjustmentChanged(GtkAdjustment *adjustment, ColorICCSelectorImpl *cs)
+{
+// // TODO check this. It looks questionable:
+//     // if a value is entered between 0 and 1 exclusive, normalize it to (int) 0..255  or 0..100
+//     if (adjustment->value > 0.0 && adjustment->value < 1.0) {
+//         gtk_adjustment_set_value( adjustment, floor ((adjustment->value) * adjustment->upper + 0.5) );
+//     }
+
+#ifdef DEBUG_LCMS
+    g_message("/^^^^^^^^^  %p::_adjustmentChanged()", cs);
+#endif // DEBUG_LCMS
+
+    ColorICCSelector *iccSelector = cs->_owner;
+    if (iccSelector->_impl->_updating) {
+        return;
+    }
+
+    iccSelector->_impl->_updating = TRUE;
+
+    gint match = -1;
+
+    SPColor newColor(iccSelector->_impl->_color.color());
+    gfloat scaled = ColorScales::getScaled(iccSelector->_impl->_adj);
+    if (iccSelector->_impl->_adj == adjustment) {
+#ifdef DEBUG_LCMS
+        g_message("ALPHA");
+#endif // DEBUG_LCMS
+    }
+    else {
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+        for (size_t i = 0; i < iccSelector->_impl->_compUI.size(); i++) {
+            if (iccSelector->_impl->_compUI[i]._adj == adjustment) {
+                match = i;
+                break;
+            }
+        }
+        if (match >= 0) {
+#ifdef DEBUG_LCMS
+            g_message(" channel %d", match);
+#endif // DEBUG_LCMS
+        }
+
+
+        cmsUInt16Number tmp[4];
+        for (guint i = 0; i < 4; i++) {
+            tmp[i] = ColorScales::getScaled(iccSelector->_impl->_compUI[i]._adj) * 0x0ffff;
+        }
+        guchar post[4] = { 0, 0, 0, 0 };
+
+        cmsHTRANSFORM trans = iccSelector->_impl->_prof->getTransfToSRGB8();
+        if (trans) {
+            cmsDoTransform(trans, tmp, post, 1);
+        }
+
+        SPColor other(SP_RGBA32_U_COMPOSE(post[0], post[1], post[2], 255));
+        other.icc = new SVGICCColor();
+        if (iccSelector->_impl->_color.color().icc) {
+            other.icc->colorProfile = iccSelector->_impl->_color.color().icc->colorProfile;
+        }
+
+        guint32 prior = iccSelector->_impl->_color.color().toRGBA32(255);
+        guint32 newer = other.toRGBA32(255);
+
+        if (prior != newer) {
+#ifdef DEBUG_LCMS
+            g_message("Transformed color from 0x%08x to 0x%08x", prior, newer);
+            g_message("      ~~~~ FLIP");
+#endif // DEBUG_LCMS
+            newColor = other;
+            newColor.icc->colors.clear();
+            for (guint i = 0; i < iccSelector->_impl->_profChannelCount; i++) {
+                gdouble val = ColorScales::getScaled(iccSelector->_impl->_compUI[i]._adj);
+                val *= iccSelector->_impl->_compUI[i]._component.scale;
+                if (iccSelector->_impl->_compUI[i]._component.scale == 256) {
+                    val -= 128;
+                }
+                newColor.icc->colors.push_back(val);
+            }
+        }
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    }
+    iccSelector->_impl->_color.setColorAlpha(newColor, scaled);
+    // iccSelector->_updateInternals( newColor, scaled, iccSelector->_impl->_dragging );
+    iccSelector->_impl->_updateSliders(match);
+
+    iccSelector->_impl->_updating = FALSE;
+#ifdef DEBUG_LCMS
+    g_message("\\_________  %p::_adjustmentChanged()", cs);
+#endif // DEBUG_LCMS
+}
+
+void ColorICCSelectorImpl::_sliderGrabbed()
+{
+    //    ColorICCSelector* iccSelector = dynamic_cast<ColorICCSelector*>(SP_COLOR_SELECTOR(cs)->base);
+    //     if (!iccSelector->_dragging) {
+    //         iccSelector->_dragging = TRUE;
+    //         iccSelector->_grabbed();
+    //         iccSelector->_updateInternals( iccSelector->_color, ColorScales::getScaled( iccSelector->_impl->_adj ),
+    //         iccSelector->_dragging );
+    //     }
+}
+
+void ColorICCSelectorImpl::_sliderReleased()
+{
+    //     ColorICCSelector* iccSelector = dynamic_cast<ColorICCSelector*>(SP_COLOR_SELECTOR(cs)->base);
+    //     if (iccSelector->_dragging) {
+    //         iccSelector->_dragging = FALSE;
+    //         iccSelector->_released();
+    //         iccSelector->_updateInternals( iccSelector->_color, ColorScales::getScaled( iccSelector->_adj ),
+    //         iccSelector->_dragging );
+    //     }
+}
+
+#ifdef DEBUG_LCMS
+void ColorICCSelectorImpl::_sliderChanged(SPColorSlider *slider, SPColorICCSelector *cs)
+#else
+void ColorICCSelectorImpl::_sliderChanged()
+#endif // DEBUG_LCMS
+{
+#ifdef DEBUG_LCMS
+    g_message("Changed  %p and %p", slider, cs);
+#endif // DEBUG_LCMS
+    //     ColorICCSelector* iccSelector = dynamic_cast<ColorICCSelector*>(SP_COLOR_SELECTOR(cs)->base);
+
+    //     iccSelector->_updateInternals( iccSelector->_color, ColorScales::getScaled( iccSelector->_adj ),
+    //     iccSelector->_dragging );
+}
+
+Gtk::Widget *ColorICCSelectorFactory::createWidget(Inkscape::UI::SelectedColor &color) const
+{
+    Gtk::Widget *w = Gtk::manage(new ColorICCSelector(color));
+    return w;
+}
+
+Glib::ustring ColorICCSelectorFactory::modeName() const { return gettext(ColorICCSelector::MODE_NAME); }
+}
+}
+}
+/*
+  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:fileencoding=utf-8:textwidth=99 :
diff --git a/src/ui/widget/color-icc-selector.h b/src/ui/widget/color-icc-selector.h
new file mode 100644
index 000000000..1bcb0a540
--- /dev/null
+++ b/src/ui/widget/color-icc-selector.h
@@ -0,0 +1,78 @@
+#ifndef SEEN_SP_COLOR_ICC_SELECTOR_H
+#define SEEN_SP_COLOR_ICC_SELECTOR_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <gtkmm/widget.h>
+#if WITH_GTKMM_3_0
+#include <gtkmm/grid.h>
+#else
+#include <gtkmm/table.h>
+#endif
+
+#include "ui/selected-color.h"
+
+namespace Inkscape {
+
+class ColorProfile;
+
+namespace UI {
+namespace Widget {
+
+class ColorICCSelectorImpl;
+
+class ColorICCSelector
+#if GTK_CHECK_VERSION(3, 0, 0)
+    : public Gtk::Grid
+#else
+    : public Gtk::Table
+#endif
+      {
+  public:
+    static const gchar *MODE_NAME;
+
+    ColorICCSelector(SelectedColor &color);
+    virtual ~ColorICCSelector();
+
+    virtual void init();
+
+  protected:
+    void on_show();
+
+    virtual void _colorChanged();
+
+    void _recalcColor(gboolean changing);
+
+  private:
+    friend class ColorICCSelectorImpl;
+
+    // By default, disallow copy constructor and assignment operator
+    ColorICCSelector(const ColorICCSelector &obj);
+    ColorICCSelector &operator=(const ColorICCSelector &obj);
+
+    ColorICCSelectorImpl *_impl;
+};
+
+
+class ColorICCSelectorFactory : public ColorSelectorFactory {
+  public:
+    Gtk::Widget *createWidget(SelectedColor &color) const;
+    Glib::ustring modeName() const;
+};
+}
+}
+}
+#endif // SEEN_SP_COLOR_ICC_SELECTOR_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:fileencoding=utf-8:textwidth=99 :
diff --git a/src/ui/widget/color-notebook.cpp b/src/ui/widget/color-notebook.cpp
new file mode 100644
index 000000000..60abf43bf
--- /dev/null
+++ b/src/ui/widget/color-notebook.cpp
@@ -0,0 +1,379 @@
+/**
+ * @file
+ * A notebook with RGB, CMYK, CMS, HSL, and Wheel pages - implementation
+ */
+/* Authors:
+ *   Lauris Kaplinski <lauris@kaplinski.com>
+ *   bulia byak <buliabyak@users.sf.net>
+ *   Tomasz Boczkowski <penginsbacon@gmail.com> (c++-sification)
+ *
+ * Copyright (C) 2001-2014 Authors
+ *
+ * This code is in public domain
+ */
+
+#undef SPCS_PREVIEW
+#define noDUMP_CHANGE_INFO
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "widgets/icon.h"
+#include <cstring>
+#include <string>
+#include <cstdlib>
+#include <cstddef>
+#include <glibmm/i18n.h>
+#include <gtkmm/label.h>
+#include <gtkmm/notebook.h>
+
+#include "preferences.h"
+#include "widgets/spw-utilities.h"
+#include "svg/svg-icc-color.h"
+#include "inkscape.h"
+#include "document.h"
+#include "profile-manager.h"
+#include "color-profile.h"
+#include "cms-system.h"
+#include "ui/dialog-events.h"
+#include "ui/tools-switch.h"
+#include "ui/tools/tool-base.h"
+#include "ui/widget/color-entry.h"
+#include "ui/widget/color-icc-selector.h"
+#include "ui/widget/color-notebook.h"
+#include "ui/widget/color-scales.h"
+#include "ui/widget/color-wheel-selector.h"
+
+using Inkscape::CMSSystem;
+
+#define XPAD 4
+#define YPAD 1
+
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+
+
+ColorNotebook::ColorNotebook(SelectedColor &color)
+#if GTK_CHECK_VERSION(3, 0, 0)
+    : Gtk::Grid()
+#else
+    : Gtk::Table(2, 3, false)
+#endif
+    , _selected_color(color)
+
+{
+    Page *page;
+
+    page = new Page(new ColorScalesFactory(SP_COLOR_SCALES_MODE_RGB), true);
+    _available_pages.push_back(page);
+    page = new Page(new ColorScalesFactory(SP_COLOR_SCALES_MODE_HSV), true);
+    _available_pages.push_back(page);
+    page = new Page(new ColorScalesFactory(SP_COLOR_SCALES_MODE_CMYK), true);
+    _available_pages.push_back(page);
+    page = new Page(new ColorWheelSelectorFactory, true);
+    _available_pages.push_back(page);
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    page = new Page(new ColorICCSelectorFactory, true);
+    _available_pages.push_back(page);
+#endif
+
+    _initUI();
+
+    _selected_color.signal_changed.connect(sigc::mem_fun(this, &ColorNotebook::_onSelectedColorChanged));
+    _selected_color.signal_dragged.connect(sigc::mem_fun(this, &ColorNotebook::_onSelectedColorChanged));
+}
+
+ColorNotebook::~ColorNotebook()
+{
+    if (_buttons) {
+        delete[] _buttons;
+        _buttons = 0;
+    }
+}
+
+ColorNotebook::Page::Page(Inkscape::UI::ColorSelectorFactory *selector_factory, bool enabled_full)
+    : selector_factory(selector_factory)
+    , enabled_full(enabled_full)
+{
+}
+
+
+void ColorNotebook::_initUI()
+{
+    guint row = 0;
+
+    Gtk::Notebook *notebook = Gtk::manage(new Gtk::Notebook);
+    notebook->show();
+    notebook->set_show_border(false);
+    notebook->set_show_tabs(false);
+    _book = GTK_WIDGET(notebook->gobj());
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+    _buttonbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
+    gtk_box_set_homogeneous(GTK_BOX(_buttonbox), TRUE);
+#else
+    _buttonbox = gtk_hbox_new(TRUE, 2);
+#endif
+
+    gtk_widget_show(_buttonbox);
+    _buttons = new GtkWidget *[_available_pages.size()];
+
+    for (int i = 0; static_cast<size_t>(i) < _available_pages.size(); i++) {
+        _addPage(_available_pages[i]);
+    }
+
+    sp_set_font_size_smaller(_buttonbox);
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+  #if GTK_CHECK_VERSION(3, 12, 0)
+    gtk_widget_set_margin_start(_buttonbox, XPAD);
+    gtk_widget_set_margin_end(_buttonbox, XPAD);
+  #else
+    gtk_widget_set_margin_left(_buttonbox, XPAD);
+    gtk_widget_set_margin_right(_buttonbox, XPAD);
+  #endif
+    gtk_widget_set_margin_top(_buttonbox, YPAD);
+    gtk_widget_set_margin_bottom(_buttonbox, YPAD);
+    gtk_widget_set_hexpand(_buttonbox, TRUE);
+    gtk_widget_set_valign(_buttonbox, GTK_ALIGN_CENTER);
+    attach(*Glib::wrap(_buttonbox), 0, row, 2, 1);
+#else
+    attach(*Glib::wrap(_buttonbox), 0, 2, row, row + 1, Gtk::EXPAND | Gtk::FILL, static_cast<Gtk::AttachOptions>(0),
+           XPAD, YPAD);
+#endif
+
+    row++;
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+#if GTK_CHECK_VERSION(3, 12, 0)
+    gtk_widget_set_margin_start(_book, XPAD * 2);
+    gtk_widget_set_margin_end(_book, XPAD * 2);
+#else
+    gtk_widget_set_margin_left(_book, XPAD * 2);
+    gtk_widget_set_margin_right(_book, XPAD * 2);
+#endif
+    gtk_widget_set_margin_top(_book, YPAD);
+    gtk_widget_set_margin_bottom(_book, YPAD);
+    gtk_widget_set_hexpand(_book, TRUE);
+    gtk_widget_set_vexpand(_book, TRUE);
+    attach(*notebook, 0, row, 2, 1);
+#else
+    attach(*notebook, 0, 2, row, row + 1, Gtk::EXPAND | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, XPAD * 2, YPAD);
+#endif
+
+    // restore the last active page
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    _setCurrentPage(prefs->getInt("/colorselector/page", 0));
+    row++;
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+    GtkWidget *rgbabox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+#else
+    GtkWidget *rgbabox = gtk_hbox_new(FALSE, 0);
+#endif
+
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    /* Create color management icons */
+    _box_colormanaged = gtk_event_box_new();
+    GtkWidget *colormanaged = gtk_image_new_from_icon_name("color-management-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
+    gtk_container_add(GTK_CONTAINER(_box_colormanaged), colormanaged);
+    gtk_widget_set_tooltip_text(_box_colormanaged, _("Color Managed"));
+    gtk_widget_set_sensitive(_box_colormanaged, false);
+    gtk_box_pack_start(GTK_BOX(rgbabox), _box_colormanaged, FALSE, FALSE, 2);
+
+    _box_outofgamut = gtk_event_box_new();
+    GtkWidget *outofgamut = gtk_image_new_from_icon_name("out-of-gamut-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
+    gtk_container_add(GTK_CONTAINER(_box_outofgamut), outofgamut);
+    gtk_widget_set_tooltip_text(_box_outofgamut, _("Out of gamut!"));
+    gtk_widget_set_sensitive(_box_outofgamut, false);
+    gtk_box_pack_start(GTK_BOX(rgbabox), _box_outofgamut, FALSE, FALSE, 2);
+
+    _box_toomuchink = gtk_event_box_new();
+    GtkWidget *toomuchink = gtk_image_new_from_icon_name("too-much-ink-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
+    gtk_container_add(GTK_CONTAINER(_box_toomuchink), toomuchink);
+    gtk_widget_set_tooltip_text(_box_toomuchink, _("Too much ink!"));
+    gtk_widget_set_sensitive(_box_toomuchink, false);
+    gtk_box_pack_start(GTK_BOX(rgbabox), _box_toomuchink, FALSE, FALSE, 2);
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+
+
+    /* Color picker */
+    GtkWidget *picker = gtk_image_new_from_icon_name("color-picker", GTK_ICON_SIZE_SMALL_TOOLBAR);
+    _btn_picker = gtk_button_new();
+    gtk_button_set_relief(GTK_BUTTON(_btn_picker), GTK_RELIEF_NONE);
+    gtk_container_add(GTK_CONTAINER(_btn_picker), picker);
+    gtk_widget_set_tooltip_text(_btn_picker, _("Pick colors from image"));
+    gtk_box_pack_start(GTK_BOX(rgbabox), _btn_picker, FALSE, FALSE, 2);
+    g_signal_connect(G_OBJECT(_btn_picker), "clicked", G_CALLBACK(ColorNotebook::_onPickerClicked), this);
+
+    /* Create RGBA entry and color preview */
+    _rgbal = gtk_label_new_with_mnemonic(_("RGBA_:"));
+    gtk_misc_set_alignment(GTK_MISC(_rgbal), 1.0, 0.5);
+    gtk_box_pack_start(GTK_BOX(rgbabox), _rgbal, TRUE, TRUE, 2);
+
+    ColorEntry *rgba_entry = Gtk::manage(new ColorEntry(_selected_color));
+    sp_dialog_defocus_on_enter(GTK_WIDGET(rgba_entry->gobj()));
+    gtk_box_pack_start(GTK_BOX(rgbabox), GTK_WIDGET(rgba_entry->gobj()), FALSE, FALSE, 0);
+    gtk_label_set_mnemonic_widget(GTK_LABEL(_rgbal), GTK_WIDGET(rgba_entry->gobj()));
+
+    sp_set_font_size_smaller(rgbabox);
+    gtk_widget_show_all(rgbabox);
+
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    // the "too much ink" icon is initially hidden
+    gtk_widget_hide(GTK_WIDGET(_box_toomuchink));
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+  #if GTK_CHECK_VERSION(3, 12, 0)
+    gtk_widget_set_margin_start(rgbabox, XPAD);
+    gtk_widget_set_margin_end(rgbabox, XPAD);
+  #else
+    gtk_widget_set_margin_left(rgbabox, XPAD);
+    gtk_widget_set_margin_right(rgbabox, XPAD);
+  #endif
+    gtk_widget_set_margin_top(rgbabox, YPAD);
+    gtk_widget_set_margin_bottom(rgbabox, YPAD);
+    attach(*Glib::wrap(rgbabox), 0, row, 2, 1);
+#else
+    attach(*Glib::wrap(rgbabox), 0, 2, row, row + 1, Gtk::FILL, Gtk::SHRINK, XPAD, YPAD);
+#endif
+
+#ifdef SPCS_PREVIEW
+    _p = sp_color_preview_new(0xffffffff);
+    gtk_widget_show(_p);
+    attach(*Glib::wrap(_p), 2, 3, row, row + 1, Gtk::FILL, Gtk::FILL, XPAD, YPAD);
+#endif
+
+    g_signal_connect(G_OBJECT(_book), "switch-page", G_CALLBACK(ColorNotebook::_onPageSwitched), this);
+}
+
+void ColorNotebook::_onPickerClicked(GtkWidget * /*widget*/, ColorNotebook * /*colorbook*/)
+{
+    // Set the dropper into a "one click" mode, so it reverts to the previous tool after a click
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setBool("/tools/dropper/onetimepick", true);
+    Inkscape::UI::Tools::sp_toggle_dropper(SP_ACTIVE_DESKTOP);
+}
+
+void ColorNotebook::_onButtonClicked(GtkWidget *widget, ColorNotebook *nb)
+{
+    if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) {
+        return;
+    }
+
+    for (gint i = 0; i < gtk_notebook_get_n_pages(GTK_NOTEBOOK(nb->_book)); i++) {
+        if (nb->_buttons[i] == widget) {
+            gtk_notebook_set_current_page(GTK_NOTEBOOK(nb->_book), i);
+        }
+    }
+}
+
+void ColorNotebook::_onSelectedColorChanged() { _updateICCButtons(); }
+
+void ColorNotebook::_onPageSwitched(GtkNotebook *notebook, GtkWidget *page, guint page_num, ColorNotebook *colorbook)
+{
+    if (colorbook->get_visible()) {
+        // remember the page we switched to
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        prefs->setInt("/colorselector/page", page_num);
+    }
+}
+
+
+// TODO pass in param so as to avoid the need for SP_ACTIVE_DOCUMENT
+void ColorNotebook::_updateICCButtons()
+{
+    SPColor color = _selected_color.color();
+    gfloat alpha = _selected_color.alpha();
+
+    g_return_if_fail((0.0 <= alpha) && (alpha <= 1.0));
+
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    /* update color management icon*/
+    gtk_widget_set_sensitive(_box_colormanaged, color.icc != NULL);
+
+    /* update out-of-gamut icon */
+    gtk_widget_set_sensitive(_box_outofgamut, false);
+    if (color.icc) {
+        Inkscape::ColorProfile *target_profile =
+            SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str());
+        if (target_profile)
+            gtk_widget_set_sensitive(_box_outofgamut, target_profile->GamutCheck(color));
+    }
+
+    /* update too-much-ink icon */
+    gtk_widget_set_sensitive(_box_toomuchink, false);
+    if (color.icc) {
+        Inkscape::ColorProfile *prof = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str());
+        if (prof && CMSSystem::isPrintColorSpace(prof)) {
+            gtk_widget_show(GTK_WIDGET(_box_toomuchink));
+            double ink_sum = 0;
+            for (unsigned int i = 0; i < color.icc->colors.size(); i++) {
+                ink_sum += color.icc->colors[i];
+            }
+
+            /* Some literature states that when the sum of paint values exceed 320%, it is considered to be a satured
+               color,
+                which means the paper can get too wet due to an excessive ammount of ink. This may lead to several
+               issues
+                such as misalignment and poor quality of printing in general.*/
+            if (ink_sum > 3.2)
+                gtk_widget_set_sensitive(_box_toomuchink, true);
+        }
+        else {
+            gtk_widget_hide(GTK_WIDGET(_box_toomuchink));
+        }
+    }
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+}
+
+void ColorNotebook::_setCurrentPage(int i)
+{
+    gtk_notebook_set_current_page(GTK_NOTEBOOK(_book), i);
+
+    if (_buttons && (static_cast<size_t>(i) < _available_pages.size())) {
+        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(_buttons[i]), TRUE);
+    }
+}
+
+void ColorNotebook::_addPage(Page &page)
+{
+    Gtk::Widget *selector_widget;
+
+    selector_widget = page.selector_factory->createWidget(_selected_color);
+    if (selector_widget) {
+        selector_widget->show();
+
+        Glib::ustring mode_name = page.selector_factory->modeName();
+        Gtk::Widget *tab_label = Gtk::manage(new Gtk::Label(mode_name));
+        gint page_num = gtk_notebook_append_page(GTK_NOTEBOOK(_book), selector_widget->gobj(), tab_label->gobj());
+
+        _buttons[page_num] = gtk_radio_button_new_with_label(NULL, mode_name.c_str());
+        gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(_buttons[page_num]), FALSE);
+        if (page_num > 0) {
+            GSList *group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(_buttons[0]));
+            gtk_radio_button_set_group(GTK_RADIO_BUTTON(_buttons[page_num]), group);
+        }
+        gtk_widget_show(_buttons[page_num]);
+        gtk_box_pack_start(GTK_BOX(_buttonbox), _buttons[page_num], TRUE, TRUE, 0);
+
+        g_signal_connect(G_OBJECT(_buttons[page_num]), "clicked", G_CALLBACK(_onButtonClicked), this);
+    }
+}
+}
+}
+}
+
+/*
+  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:fileencoding=utf-8:textwidth=99 :
diff --git a/src/ui/widget/color-notebook.h b/src/ui/widget/color-notebook.h
new file mode 100644
index 000000000..d28028c72
--- /dev/null
+++ b/src/ui/widget/color-notebook.h
@@ -0,0 +1,99 @@
+/**
+ * @file
+ * A notebook with RGB, CMYK, CMS, HSL, and Wheel pages
+ */
+/* Authors:
+ *   Lauris Kaplinski <lauris@kaplinski.com>
+ *   bulia byak <buliabyak@users.sf.net>
+ *   Tomasz Boczkowski <penginsbacon@gmail.com> (c++-sification)
+ *
+ * Copyright (C) 2001-2014 Authors
+ *
+ * This code is in public domain
+ */
+#ifndef SEEN_SP_COLOR_NOTEBOOK_H
+#define SEEN_SP_COLOR_NOTEBOOK_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <boost/ptr_container/ptr_vector.hpp>
+#if WITH_GTKMM_3_0
+#include <gtkmm/grid.h>
+#else
+#include <gtkmm/table.h>
+#endif
+#include <gtk/gtk.h>
+#include <glib.h>
+
+#include "color.h"
+#include "ui/selected-color.h"
+
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+
+class ColorNotebook
+#if GTK_CHECK_VERSION(3, 0, 0)
+    : public Gtk::Grid
+#else
+    : public Gtk::Table
+#endif
+{
+public:
+    ColorNotebook(SelectedColor &color);
+    virtual ~ColorNotebook();
+
+protected:
+    struct Page {
+        Page(Inkscape::UI::ColorSelectorFactory *selector_factory, bool enabled_full);
+
+        Inkscape::UI::ColorSelectorFactory *selector_factory;
+        bool enabled_full;
+    };
+
+    virtual void _initUI();
+    void _addPage(Page &page);
+
+    static void _onButtonClicked(GtkWidget *widget, ColorNotebook *colorbook);
+    static void _onPickerClicked(GtkWidget *widget, ColorNotebook *colorbook);
+    static void _onPageSwitched(GtkNotebook *notebook, GtkWidget *page, guint page_num, ColorNotebook *colorbook);
+    virtual void _onSelectedColorChanged();
+
+    void _updateICCButtons();
+    void _setCurrentPage(int i);
+
+    Inkscape::UI::SelectedColor &_selected_color;
+    gulong _entryId;
+    GtkWidget *_book;
+    GtkWidget *_buttonbox;
+    GtkWidget **_buttons;
+    GtkWidget *_rgbal; /* RGBA entry */
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    GtkWidget *_box_outofgamut, *_box_colormanaged, *_box_toomuchink;
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    GtkWidget *_btn_picker;
+    GtkWidget *_p; /* Color preview */
+    boost::ptr_vector<Page> _available_pages;
+
+private:
+    // By default, disallow copy constructor and assignment operator
+    ColorNotebook(const ColorNotebook &obj);
+    ColorNotebook &operator=(const ColorNotebook &obj);
+};
+}
+}
+}
+#endif // SEEN_SP_COLOR_NOTEBOOK_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:fileencoding=utf-8:textwidth=99 :
+
diff --git a/src/ui/widget/color-picker.cpp b/src/ui/widget/color-picker.cpp
index d4c4d394e..a66fbfc9c 100644
--- a/src/ui/widget/color-picker.cpp
+++ b/src/ui/widget/color-picker.cpp
@@ -17,7 +17,7 @@
 #include "document-undo.h"
 #include "ui/dialog-events.h"
 
-#include "widgets/sp-color-notebook.h"
+#include "ui/widget/color-notebook.h"
 #include "verbs.h"
 
 
@@ -27,8 +27,6 @@ namespace Inkscape {
 namespace UI {
 namespace Widget {
 
-void sp_color_picker_color_mod(SPColorSelector *csel, GObject *cp);
-
 ColorPicker::ColorPicker (const Glib::ustring& title, const Glib::ustring& tip,
                           guint32 rgba, bool undo)
           : _preview(rgba), _title(title), _rgba(rgba), _undo(undo),
@@ -39,12 +37,15 @@ ColorPicker::ColorPicker (const Glib::ustring& title, const Glib::ustring& tip,
     _preview.show();
     add (_preview);
     set_tooltip_text (tip);
+
+    _selected_color.signal_changed.connect(sigc::mem_fun(this, &ColorPicker::_onSelectedColorChanged));
+    _selected_color.signal_dragged.connect(sigc::mem_fun(this, &ColorPicker::_onSelectedColorChanged));
+    _selected_color.signal_released.connect(sigc::mem_fun(this, &ColorPicker::_onSelectedColorChanged));
 }
 
 ColorPicker::~ColorPicker()
 {
     closeWindow();
-    _colorSelector = NULL;
 }
 
 void ColorPicker::setupDialog(const Glib::ustring &title)
@@ -55,25 +56,17 @@ void ColorPicker::setupDialog(const Glib::ustring &title)
     _colorSelectorDialog.hide();
     _colorSelectorDialog.set_title (title);
     _colorSelectorDialog.set_border_width (4);
-    _colorSelector = SP_COLOR_SELECTOR(sp_color_selector_new(SP_TYPE_COLOR_NOTEBOOK));
+
+    _color_selector = Gtk::manage(new ColorNotebook(_selected_color));
 
 #if WITH_GTKMM_3_0
     _colorSelectorDialog.get_content_area()->pack_start (
-              *Glib::wrap(&_colorSelector->vbox), true, true, 0);
+              *_color_selector, true, true, 0);
 #else
     _colorSelectorDialog.get_vbox()->pack_start (
-              *Glib::wrap(&_colorSelector->vbox), true, true, 0);
+              *_color_selector, true, true, 0);
 #endif
-
-    g_signal_connect(G_OBJECT(_colorSelector), "dragged",
-                         G_CALLBACK(sp_color_picker_color_mod), (void *)this);
-    g_signal_connect(G_OBJECT(_colorSelector), "released",
-                         G_CALLBACK(sp_color_picker_color_mod), (void *)this);
-    g_signal_connect(G_OBJECT(_colorSelector), "changed",
-                         G_CALLBACK(sp_color_picker_color_mod), (void *)this);
-
-    gtk_widget_show(GTK_WIDGET(_colorSelector));
-
+    _color_selector->show();
 }
 
 void ColorPicker::setRgba32 (guint32 rgba)
@@ -82,11 +75,11 @@ void ColorPicker::setRgba32 (guint32 rgba)
 
     _preview.setRgba32 (rgba);
     _rgba = rgba;
-    if (_colorSelector)
+    if (_color_selector)
     {
-        SPColor color;
-        color.set( rgba );
-        _colorSelector->base->setColorAlpha(color, SP_RGBA32_A_F(rgba));
+        _updating = true;
+        _selected_color.setValue(rgba);
+        _updating = false;
     }
 }
 
@@ -97,11 +90,11 @@ void ColorPicker::closeWindow()
 
 void ColorPicker::on_clicked()
 {
-    if (_colorSelector)
+    if (_color_selector)
     {
-        SPColor color;
-        color.set( _rgba );
-        _colorSelector->base->setColorAlpha(color, SP_RGBA32_A_F(_rgba));
+        _updating = true;
+        _selected_color.setValue(_rgba);
+        _updating = false;
     }
     _colorSelectorDialog.show();
 }
@@ -110,34 +103,31 @@ void ColorPicker::on_changed (guint32)
 {
 }
 
-void sp_color_picker_color_mod(SPColorSelector *csel, GObject *cp)
-{
+void ColorPicker::_onSelectedColorChanged() {
+    if (_updating) {
+        return;
+    }
+
     if (_in_use) {
         return;
     } else {
         _in_use = true;
     }
 
-    SPColor color;
-    float alpha = 0;
-    csel->base->getColorAlpha(color, alpha);
-    guint32 rgba = color.toRGBA32( alpha );
-
-    ColorPicker *ptr = reinterpret_cast<ColorPicker *>(cp);
-
-    (ptr->_preview).setRgba32 (rgba);
+    guint32 rgba = _selected_color.value();
+    _preview.setRgba32(rgba);
 
-    if (ptr->_undo && SP_ACTIVE_DESKTOP)
+    if (_undo && SP_ACTIVE_DESKTOP) {
         DocumentUndo::done(SP_ACTIVE_DESKTOP->getDocument(), SP_VERB_NONE,
                            /* TODO: annotate */ "color-picker.cpp:130");
+    }
 
-    ptr->on_changed (rgba);
+    on_changed(rgba);
     _in_use = false;
-    ptr->_changed_signal.emit (rgba);
-    ptr->_rgba = rgba;
+    _changed_signal.emit(rgba);
+    _rgba = rgba;
 }
 
-
 }//namespace Widget
 }//namespace UI
 }//namespace Inkscape
diff --git a/src/ui/widget/color-picker.h b/src/ui/widget/color-picker.h
index 99904b081..e8a738b5b 100644
--- a/src/ui/widget/color-picker.h
+++ b/src/ui/widget/color-picker.h
@@ -18,6 +18,7 @@
 #include <gtkmm/dialog.h>
 #include <gtkmm/button.h>
 #include <sigc++/sigc++.h>
+#include "ui/selected-color.h"
 #include "ui/widget/color-preview.h"
 
 struct SPColorSelector;
@@ -49,7 +50,7 @@ public:
 
 protected:
 
-    friend void sp_color_picker_color_mod(SPColorSelector *csel, GObject *cp);
+    void _onSelectedColorChanged();
     virtual void on_clicked();
     virtual void on_changed (guint32);
 
@@ -59,13 +60,14 @@ protected:
     sigc::signal<void,guint32> _changed_signal;
     guint32             _rgba;
     bool                _undo;
-
+    bool                _updating;
 
     //Dialog
     void setupDialog(const Glib::ustring &title);
     //Inkscape::UI::Dialog::Dialog _colorSelectorDialog;
     Gtk::Dialog _colorSelectorDialog;
-    SPColorSelector *_colorSelector;
+    SelectedColor _selected_color;
+    Gtk::Widget *_color_selector;
 };
 
 }//namespace Widget
diff --git a/src/ui/widget/color-scales.cpp b/src/ui/widget/color-scales.cpp
new file mode 100644
index 000000000..170f83887
--- /dev/null
+++ b/src/ui/widget/color-scales.cpp
@@ -0,0 +1,677 @@
+/*
+ *   bulia byak <buliabyak@users.sf.net>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <math.h>
+#include <gtkmm/adjustment.h>
+#include <glibmm/i18n.h>
+#include <gtk/gtk.h>
+
+#include "svg/svg-icc-color.h"
+#include "ui/dialog-events.h"
+#include "ui/widget/color-scales.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
+
+#define XPAD 4
+#define YPAD 1
+
+#define noDUMP_CHANGE_INFO 1
+
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+
+
+static const gchar *sp_color_scales_hue_map();
+
+const gchar *ColorScales::SUBMODE_NAMES[] = { N_("None"), N_("RGB"), N_("HSL"), N_("CMYK") };
+
+ColorScales::ColorScales(SelectedColor &color, SPColorScalesMode mode)
+#if GTK_CHECK_VERSION(3, 0, 0)
+    : Gtk::Grid()
+#else
+    : Gtk::Table(5, 3, false)
+#endif
+    , _color(color)
+    , _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;
+    }
+
+    _initUI(mode);
+
+    _color.signal_changed.connect(sigc::mem_fun(this, &ColorScales::_onColorChanged));
+    _color.signal_dragged.connect(sigc::mem_fun(this, &ColorScales::_onColorChanged));
+}
+
+ColorScales::~ColorScales()
+{
+    for (gint i = 0; i < 5; i++) {
+        _l[i] = 0;
+        _a[i] = 0;
+        _s[i] = 0;
+        _b[i] = 0;
+    }
+}
+
+void ColorScales::_initUI(SPColorScalesMode mode)
+{
+    gint i;
+
+    _updating = FALSE;
+    _dragging = FALSE;
+
+    GtkWidget *t = GTK_WIDGET(gobj());
+
+    /* 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)
+  #if GTK_CHECK_VERSION(3, 12, 0)
+        gtk_widget_set_margin_start(_l[i], XPAD);
+        gtk_widget_set_margin_end(_l[i], XPAD);
+  #else
+        gtk_widget_set_margin_left(_l[i], XPAD);
+        gtk_widget_set_margin_right(_l[i], XPAD);
+  #endif
+        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)
+  #if GTK_CHECK_VERSION(3, 12, 0)
+        _s[i]->set_margin_start(XPAD);
+        _s[i]->set_margin_end(XPAD);
+  #else
+        _s[i]->set_margin_left(XPAD);
+        _s[i]->set_margin_right(XPAD);
+  #endif
+        _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)
+  #if GTK_CHECK_VERSION(3, 12, 0)
+        gtk_widget_set_margin_start(_b[i], XPAD);
+        gtk_widget_set_margin_end(_b[i], XPAD);
+  #else
+        gtk_widget_set_margin_left(_b[i], XPAD);
+        gtk_widget_set_margin_right(_b[i], XPAD);
+  #endif
+        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), this);
+        _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));
+    }
+
+    //Prevent 5th bar from being shown by PanelDialog::show_all_children
+    gtk_widget_set_no_show_all(_l[4], TRUE);
+    _s[4]->set_no_show_all(true);
+    gtk_widget_set_no_show_all(_b[4], TRUE);
+
+    /* Initial mode is none, so it works */
+    setMode(mode);
+}
+
+void ColorScales::_recalcColor()
+{
+    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;
+    }
+
+    _color.preserveICC();
+    _color.setColorAlpha(color, alpha);
+}
+
+void ColorScales::_updateDisplay()
+{
+#ifdef DUMP_CHANGE_INFO
+    g_message("ColorScales::_onColorChanged( this=%p, %f, %f, %f,   %f)", this, _color.color().v.c[0],
+              _color.color().v.c[1], _color.color().v.c[2], _color.alpha());
+#endif
+    gfloat tmp[3];
+    gfloat c[5] = { 0.0, 0.0, 0.0, 0.0 };
+
+    SPColor color = _color.color();
+
+    switch (_mode) {
+        case SP_COLOR_SCALES_MODE_RGB:
+            sp_color_get_rgb_floatv(&color, c);
+            c[3] = _color.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] = _color.alpha();
+            c[4] = 0.0;
+            break;
+        case SP_COLOR_SCALES_MODE_CMYK:
+            sp_color_get_cmyk_floatv(&color, c);
+            c[4] = _color.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;
+}
+
+/* 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::_onColorChanged()
+{
+    if (!get_visible()) {
+        return;
+    }
+    _updateDisplay();
+}
+
+void ColorScales::on_show()
+{
+#if GTK_CHECK_VERSION(3, 0, 0)
+    Gtk::Grid::on_show();
+#else
+    Gtk::Table::on_show();
+#endif
+    _updateDisplay();
+}
+
+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]);
+            _updateSliders(CSC_CHANNELS_ALL);
+            _updating = FALSE;
+            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]);
+            _updateSliders(CSC_CHANNELS_ALL);
+            _updating = FALSE;
+            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]);
+            _updateSliders(CSC_CHANNELS_ALL);
+            _updating = FALSE;
+            break;
+        default:
+            g_warning("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__);
+            break;
+    }
+}
+
+SPColorScalesMode ColorScales::getMode() const { return _mode; }
+
+void ColorScales::_adjustmentAnyChanged(GtkAdjustment *adjustment, ColorScales *cs)
+{
+    gint channel = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(adjustment), "channel"));
+
+    _adjustmentChanged(cs, channel);
+}
+
+void ColorScales::_sliderAnyGrabbed()
+{
+    if (_updating) {
+        return;
+    }
+    if (!_dragging) {
+        _dragging = TRUE;
+        _color.setHeld(true);
+    }
+}
+
+void ColorScales::_sliderAnyReleased()
+{
+    if (_updating) {
+        return;
+    }
+    if (_dragging) {
+        _dragging = FALSE;
+        _color.setHeld(false);
+    }
+}
+
+void ColorScales::_sliderAnyChanged()
+{
+    if (_updating) {
+        return;
+    }
+    _recalcColor();
+}
+
+void ColorScales::_adjustmentChanged(ColorScales *scales, guint channel)
+{
+    if (scales->_updating) {
+        return;
+    }
+
+    scales->_updateSliders((1 << channel));
+    scales->_recalcColor();
+}
+
+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;
+    }
+
+#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
+{
+    Gtk::Widget *w = Gtk::manage(new ColorScales(color, _submode));
+    return w;
+}
+
+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..aeacfbcc1
--- /dev/null
+++ b/src/ui/widget/color-scales.h
@@ -0,0 +1,112 @@
+#ifndef SEEN_SP_COLOR_SCALES_H
+#define SEEN_SP_COLOR_SCALES_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#if WITH_GTKMM_3_0
+#include <gtkmm/grid.h>
+#else
+#include <gtkmm/table.h>
+#endif
+
+#include "ui/selected-color.h"
+
+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
+#if GTK_CHECK_VERSION(3, 0, 0)
+    : public Gtk::Grid
+#else
+    : public Gtk::Table
+#endif
+{
+public:
+    static const gchar *SUBMODE_NAMES[];
+
+    static gfloat getScaled(const GtkAdjustment *a);
+    static void setScaled(GtkAdjustment *a, gfloat v);
+
+    ColorScales(SelectedColor &color, SPColorScalesMode mode);
+    virtual ~ColorScales();
+
+    virtual void _initUI(SPColorScalesMode mode);
+
+    void setMode(SPColorScalesMode mode);
+    SPColorScalesMode getMode() const;
+
+protected:
+    void _onColorChanged();
+    void on_show();
+
+    static void _adjustmentAnyChanged(GtkAdjustment *adjustment, ColorScales *cs);
+    void _sliderAnyGrabbed();
+    void _sliderAnyReleased();
+    void _sliderAnyChanged();
+    static void _adjustmentChanged(ColorScales *cs, guint channel);
+
+    void _getRgbaFloatv(gfloat *rgba);
+    void _getCmykaFloatv(gfloat *cmyka);
+    guint32 _getRgba32();
+    void _updateSliders(guint channels);
+    void _recalcColor();
+    void _updateDisplay();
+
+    void _setRangeLimit(gdouble upper);
+
+    SelectedColor &_color;
+    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);
+};
+
+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
new file mode 100644
index 000000000..0c9586a67
--- /dev/null
+++ b/src/ui/widget/color-slider.cpp
@@ -0,0 +1,633 @@
+/**
+ * @file
+ * A slider with colored background - implementation.
+ */
+/* Author:
+ *   Lauris Kaplinski <lauris@kaplinski.com>
+ *   bulia byak <buliabyak@users.sf.net>
+ *
+ * Copyright (C) 2001-2002 Lauris Kaplinski
+ *
+ * This code is in public domain
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <gdkmm/cursor.h>
+#include <gdkmm/screen.h>
+#include <gdkmm/general.h>
+#include <gtkmm/adjustment.h>
+#if WITH_GTKMM_3_0
+#include <gtkmm/stylecontext.h>
+#else
+#include <gtkmm/style.h>
+#endif
+#include <gtk/gtk.h>
+
+#include "ui/widget/color-scales.h"
+#include "ui/widget/color-slider.h"
+#include "preferences.h"
+
+static const gint SLIDER_WIDTH = 96;
+static const gint SLIDER_HEIGHT = 8;
+static const gint ARROW_SIZE = 7;
+
+static const guchar *sp_color_slider_render_gradient(gint x0, gint y0, gint width, gint height, gint c[], gint dc[],
+                                                     guint b0, guint b1, guint mask);
+static const guchar *sp_color_slider_render_map(gint x0, gint y0, gint width, gint height, guchar *map, gint start,
+                                                gint step, guint b0, guint b1, guint mask);
+
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+ColorSlider::ColorSlider(Glib::RefPtr<Gtk::Adjustment> adjustment)
+    : _dragging(false)
+#else
+ColorSlider::ColorSlider(Gtk::Adjustment *adjustment)
+    : _dragging(false)
+    , _adjustment(NULL)
+#endif
+    , _value(0.0)
+    , _oldvalue(0.0)
+    , _mapsize(0)
+    , _map(NULL)
+{
+    _c0[0] = 0x00;
+    _c0[1] = 0x00;
+    _c0[2] = 0x00;
+    _c0[3] = 0xff;
+
+    _cm[0] = 0xff;
+    _cm[1] = 0x00;
+    _cm[2] = 0x00;
+    _cm[3] = 0xff;
+
+    _c0[0] = 0xff;
+    _c0[1] = 0xff;
+    _c0[2] = 0xff;
+    _c0[3] = 0xff;
+
+    _b0 = 0x5f;
+    _b1 = 0xa0;
+    _bmask = 0x08;
+
+    setAdjustment(adjustment);
+}
+
+ColorSlider::~ColorSlider()
+{
+    if (_adjustment) {
+        _adjustment_changed_connection.disconnect();
+        _adjustment_value_changed_connection.disconnect();
+#if GTK_CHECK_VERSION(3, 0, 0)
+        _adjustment.reset();
+#else
+        _adjustment->unreference();
+        _adjustment = NULL;
+#endif
+    }
+}
+
+void ColorSlider::on_realize()
+{
+    set_realized();
+
+    if (!_gdk_window) {
+        GdkWindowAttr attributes;
+        gint attributes_mask;
+        Gtk::Allocation allocation = get_allocation();
+
+        memset(&attributes, 0, sizeof(attributes));
+        attributes.x = allocation.get_x();
+        attributes.y = allocation.get_y();
+        attributes.width = allocation.get_width();
+        attributes.height = allocation.get_height();
+        attributes.window_type = GDK_WINDOW_CHILD;
+        attributes.wclass = GDK_INPUT_OUTPUT;
+        attributes.visual = gdk_screen_get_system_visual(gdk_screen_get_default());
+#if !GTK_CHECK_VERSION(3, 0, 0)
+        attributes.colormap = gdk_screen_get_system_colormap(gdk_screen_get_default());
+#endif
+        attributes.event_mask = get_events();
+        attributes.event_mask |= (Gdk::EXPOSURE_MASK | Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK |
+                                  Gdk::POINTER_MOTION_MASK | Gdk::ENTER_NOTIFY_MASK | Gdk::LEAVE_NOTIFY_MASK);
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+        attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
+#else
+        attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+#endif
+
+        _gdk_window = Gdk::Window::create(get_parent_window(), &attributes, attributes_mask);
+        set_window(_gdk_window);
+        _gdk_window->set_user_data(gobj());
+
+#if !GTK_CHECK_VERSION(3, 0, 0)
+        style_attach();
+#endif
+    }
+}
+
+void ColorSlider::on_unrealize()
+{
+    _gdk_window.reset();
+
+    Gtk::Widget::on_unrealize();
+}
+
+void ColorSlider::on_size_allocate(Gtk::Allocation &allocation)
+{
+    set_allocation(allocation);
+
+    if (get_realized()) {
+        _gdk_window->move_resize(allocation.get_x(), allocation.get_y(), allocation.get_width(),
+                                 allocation.get_height());
+    }
+}
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+
+void ColorSlider::get_preferred_width_vfunc(int &minimum_width, int &natural_width) const
+{
+    Glib::RefPtr<Gtk::StyleContext> style_context = get_style_context();
+    Gtk::Border padding = style_context->get_padding(get_state_flags());
+    int width = SLIDER_WIDTH + padding.get_left() + padding.get_right();
+    minimum_width = natural_width = width;
+}
+
+void ColorSlider::get_preferred_width_for_height_vfunc(int /*height*/, int &minimum_width, int &natural_width) const
+{
+    get_preferred_width(minimum_width, natural_width);
+}
+
+void ColorSlider::get_preferred_height_vfunc(int &minimum_height, int &natural_height) const
+{
+    Glib::RefPtr<Gtk::StyleContext> style_context = get_style_context();
+    Gtk::Border padding = style_context->get_padding(get_state_flags());
+    int height = SLIDER_HEIGHT + padding.get_top() + padding.get_bottom();
+    minimum_height = natural_height = height;
+}
+
+void ColorSlider::get_preferred_height_for_width_vfunc(int /*width*/, int &minimum_height, int &natural_height) const
+{
+    get_preferred_height(minimum_height, natural_height);
+}
+
+#else
+
+void ColorSlider::on_size_request(Gtk::Requisition *requisition)
+{
+    GtkStyle *style = gtk_widget_get_style(gobj());
+    requisition->width = SLIDER_WIDTH + style->xthickness * 2;
+    requisition->height = SLIDER_HEIGHT + style->ythickness * 2;
+}
+
+bool ColorSlider::on_expose_event(GdkEventExpose *event)
+{
+    bool result = false;
+
+    if (get_is_drawable()) {
+        Cairo::RefPtr<Cairo::Context> cr = _gdk_window->create_cairo_context();
+        result = on_draw(cr);
+    }
+    return result;
+}
+
+#endif
+
+bool ColorSlider::on_button_press_event(GdkEventButton *event)
+{
+    if (event->button == 1) {
+        Gtk::Allocation allocation = get_allocation();
+        gint cx, cw;
+#if GTK_CHECK_VERSION(3, 0, 0)
+        cx = get_style_context()->get_padding(get_state_flags()).get_left();
+#else
+        cx = get_style()->get_xthickness();
+#endif
+        cw = allocation.get_width() - 2 * cx;
+        signal_grabbed.emit();
+        _dragging = true;
+        _oldvalue = _value;
+        ColorScales::setScaled(_adjustment->gobj(), CLAMP((gfloat)(event->x - cx) / cw, 0.0, 1.0));
+        signal_dragged.emit();
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+        gdk_device_grab(
+            gdk_event_get_device(reinterpret_cast<GdkEvent *>(event)), _gdk_window->gobj(), GDK_OWNERSHIP_NONE, FALSE,
+            static_cast<GdkEventMask>(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK), NULL, event->time);
+#else
+        gdk_pointer_grab(get_window()->gobj(), FALSE,
+                         static_cast<GdkEventMask>(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK), NULL, NULL,
+                         event->time);
+#endif
+    }
+
+    return false;
+}
+
+bool ColorSlider::on_button_release_event(GdkEventButton *event)
+{
+    if (event->button == 1) {
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+        gdk_device_ungrab(gdk_event_get_device(reinterpret_cast<GdkEvent *>(event)),
+                          gdk_event_get_time(reinterpret_cast<GdkEvent *>(event)));
+#else
+        get_window()->pointer_ungrab(event->time);
+#endif
+
+        _dragging = false;
+        signal_released.emit();
+        if (_value != _oldvalue) {
+            signal_value_changed.emit();
+        }
+    }
+
+    return false;
+}
+
+bool ColorSlider::on_motion_notify_event(GdkEventMotion *event)
+{
+    if (_dragging) {
+        gint cx, cw;
+        Gtk::Allocation allocation = get_allocation();
+#if GTK_CHECK_VERSION(3, 0, 0)
+        cx = get_style_context()->get_padding(get_state_flags()).get_left();
+#else
+        cx = get_style()->get_xthickness();
+#endif
+        cw = allocation.get_width() - 2 * cx;
+        ColorScales::setScaled(_adjustment->gobj(), CLAMP((gfloat)(event->x - cx) / cw, 0.0, 1.0));
+        signal_dragged.emit();
+    }
+
+    return false;
+}
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+void ColorSlider::setAdjustment(Glib::RefPtr<Gtk::Adjustment> adjustment)
+{
+#else
+void ColorSlider::setAdjustment(Gtk::Adjustment *adjustment)
+{
+#endif
+    if (!adjustment) {
+#if GTK_CHECK_VERSION(3, 0, 0)
+        _adjustment = Gtk::Adjustment::create(0.0, 0.0, 1.0, 0.01, 0.0, 0.0);
+#else
+        _adjustment = Gtk::manage(new Gtk::Adjustment(0.0, 0.0, 1.0, 0.01, 0.0, 0.0));
+#endif
+    }
+    else {
+        adjustment->set_page_increment(0.0);
+        adjustment->set_page_size(0.0);
+    }
+
+    if (_adjustment != adjustment) {
+        if (_adjustment) {
+            _adjustment_changed_connection.disconnect();
+            _adjustment_value_changed_connection.disconnect();
+#if !GTK_CHECK_VERSION(3, 0, 0)
+            _adjustment->unreference();
+#endif
+        }
+
+        _adjustment = adjustment;
+        _adjustment_changed_connection =
+            _adjustment->signal_changed().connect(sigc::mem_fun(this, &ColorSlider::_onAdjustmentChanged));
+        _adjustment_value_changed_connection =
+            _adjustment->signal_value_changed().connect(sigc::mem_fun(this, &ColorSlider::_onAdjustmentValueChanged));
+
+        _value = ColorScales::getScaled(_adjustment->gobj());
+
+        _onAdjustmentChanged();
+    }
+}
+
+void ColorSlider::_onAdjustmentChanged() { queue_draw(); }
+
+void ColorSlider::_onAdjustmentValueChanged()
+{
+    if (_value != ColorScales::getScaled(_adjustment->gobj())) {
+        gint cx, cy, cw, ch;
+#if GTK_CHECK_VERSION(3, 0, 0)
+        Glib::RefPtr<Gtk::StyleContext> style_context = get_style_context();
+        Gtk::Allocation allocation = get_allocation();
+        Gtk::Border padding = style_context->get_padding(get_state_flags());
+        cx = padding.get_left();
+        cy = padding.get_top();
+#else
+        Glib::RefPtr<Gtk::Style> style = get_style();
+        Gtk::Allocation allocation = get_allocation();
+        cx = style->get_xthickness();
+        cy = style->get_ythickness();
+#endif
+        cw = allocation.get_width() - 2 * cx;
+        ch = allocation.get_height() - 2 * cy;
+        if ((gint)(ColorScales::getScaled(_adjustment->gobj()) * cw) != (gint)(_value * cw)) {
+            gint ax, ay;
+            gfloat value;
+            value = _value;
+            _value = ColorScales::getScaled(_adjustment->gobj());
+            ax = (int)(cx + value * cw - ARROW_SIZE / 2 - 2);
+            ay = cy;
+            queue_draw_area(ax, ay, ARROW_SIZE + 4, ch);
+            ax = (int)(cx + _value * cw - ARROW_SIZE / 2 - 2);
+            ay = cy;
+            queue_draw_area(ax, ay, ARROW_SIZE + 4, ch);
+        }
+        else {
+            _value = ColorScales::getScaled(_adjustment->gobj());
+        }
+    }
+}
+
+void ColorSlider::setColors(guint32 start, guint32 mid, guint32 end)
+{
+    // Remove any map, if set
+    _map = 0;
+
+    _c0[0] = start >> 24;
+    _c0[1] = (start >> 16) & 0xff;
+    _c0[2] = (start >> 8) & 0xff;
+    _c0[3] = start & 0xff;
+
+    _cm[0] = mid >> 24;
+    _cm[1] = (mid >> 16) & 0xff;
+    _cm[2] = (mid >> 8) & 0xff;
+    _cm[3] = mid & 0xff;
+
+    _c1[0] = end >> 24;
+    _c1[1] = (end >> 16) & 0xff;
+    _c1[2] = (end >> 8) & 0xff;
+    _c1[3] = end & 0xff;
+
+    queue_draw();
+}
+
+void ColorSlider::setMap(const guchar *map)
+{
+    _map = const_cast<guchar *>(map);
+
+    queue_draw();
+}
+
+void ColorSlider::setBackground(guint dark, guint light, guint size)
+{
+    _b0 = dark;
+    _b1 = light;
+    _bmask = size;
+
+    queue_draw();
+}
+
+bool ColorSlider::on_draw(const Cairo::RefPtr<Cairo::Context> &cr)
+{
+    gboolean colorsOnTop = Inkscape::Preferences::get()->getBool("/options/workarounds/colorsontop", false);
+
+    Gtk::Allocation allocation = get_allocation();
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+    Glib::RefPtr<Gtk::StyleContext> style_context = get_style_context();
+#else
+    Glib::RefPtr<Gdk::Window> window = get_window();
+    Glib::RefPtr<Gtk::Style> style = get_style();
+#endif
+
+    // Draw shadow
+    if (colorsOnTop) {
+#if GTK_CHECK_VERSION(3, 0, 0)
+        style_context->render_frame(cr, 0, 0, allocation.get_width(), allocation.get_height());
+#else
+        gtk_paint_shadow(style->gobj(), window->gobj(), gtk_widget_get_state(gobj()), GTK_SHADOW_IN, NULL, gobj(),
+                         "colorslider", 0, 0, allocation.get_width(), allocation.get_height());
+#endif
+    }
+
+    /* Paintable part of color gradient area */
+    Gdk::Rectangle carea;
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+    Gtk::Border padding;
+
+    padding = style_context->get_padding(get_state_flags());
+
+    carea.set_x(padding.get_left());
+    carea.set_y(padding.get_top());
+    ;
+#else
+    carea.set_x(style->get_xthickness());
+    carea.set_y(style->get_ythickness());
+#endif
+
+    carea.set_width(allocation.get_width() - 2 * carea.get_x());
+    carea.set_height(allocation.get_height() - 2 * carea.get_y());
+
+    if (_map) {
+        /* Render map pixelstore */
+        gint d = (1024 << 16) / carea.get_width();
+        gint s = 0;
+
+        const guchar *b =
+            sp_color_slider_render_map(0, 0, carea.get_width(), carea.get_height(), _map, s, d, _b0, _b1, _bmask);
+
+        if (b != NULL && carea.get_width() > 0) {
+            Glib::RefPtr<Gdk::Pixbuf> pb = Gdk::Pixbuf::create_from_data(
+                b, Gdk::COLORSPACE_RGB, false, 8, carea.get_width(), carea.get_height(), carea.get_width() * 3);
+
+            Gdk::Cairo::set_source_pixbuf(cr, pb, carea.get_x(), carea.get_y());
+            cr->paint();
+        }
+    }
+    else {
+        gint c[4], dc[4];
+
+        /* Render gradient */
+
+        // part 1: from c0 to cm
+        if (carea.get_width() > 0) {
+            for (gint i = 0; i < 4; i++) {
+                c[i] = _c0[i] << 16;
+                dc[i] = ((_cm[i] << 16) - c[i]) / (carea.get_width() / 2);
+            }
+            guint wi = carea.get_width() / 2;
+            const guchar *b = sp_color_slider_render_gradient(0, 0, wi, carea.get_height(), c, dc, _b0, _b1, _bmask);
+
+            /* Draw pixelstore 1 */
+            if (b != NULL && wi > 0) {
+                Glib::RefPtr<Gdk::Pixbuf> pb =
+                    Gdk::Pixbuf::create_from_data(b, Gdk::COLORSPACE_RGB, false, 8, wi, carea.get_height(), wi * 3);
+
+                Gdk::Cairo::set_source_pixbuf(cr, pb, carea.get_x(), carea.get_y());
+                cr->paint();
+            }
+        }
+
+        // part 2: from cm to c1
+        if (carea.get_width() > 0) {
+            for (gint i = 0; i < 4; i++) {
+                c[i] = _cm[i] << 16;
+                dc[i] = ((_c1[i] << 16) - c[i]) / (carea.get_width() / 2);
+            }
+            guint wi = carea.get_width() / 2;
+            const guchar *b = sp_color_slider_render_gradient(carea.get_width() / 2, 0, wi, carea.get_height(), c, dc,
+                                                              _b0, _b1, _bmask);
+
+            /* Draw pixelstore 2 */
+            if (b != NULL && wi > 0) {
+                Glib::RefPtr<Gdk::Pixbuf> pb =
+                    Gdk::Pixbuf::create_from_data(b, Gdk::COLORSPACE_RGB, false, 8, wi, carea.get_height(), wi * 3);
+
+                Gdk::Cairo::set_source_pixbuf(cr, pb, carea.get_width() / 2 + carea.get_x(), carea.get_y());
+                cr->paint();
+            }
+        }
+    }
+
+    /* Draw shadow */
+    if (!colorsOnTop) {
+#if GTK_CHECK_VERSION(3, 0, 0)
+        style_context->render_frame(cr, 0, 0, allocation.get_width(), allocation.get_height());
+#else
+        gtk_paint_shadow(style->gobj(), window->gobj(), gtk_widget_get_state(gobj()), GTK_SHADOW_IN, NULL, gobj(),
+                         "colorslider", 0, 0, allocation.get_width(), allocation.get_height());
+#endif
+    }
+
+    /* Draw arrow */
+    gint x = (int)(_value * (carea.get_width() - 1) - ARROW_SIZE / 2 + carea.get_x());
+    gint y1 = carea.get_y();
+    gint y2 = carea.get_y() + carea.get_height() - 1;
+    cr->set_line_width(1.0);
+
+    // Define top arrow
+    cr->move_to(x - 0.5, y1 + 0.5);
+    cr->line_to(x + ARROW_SIZE - 0.5, y1 + 0.5);
+    cr->line_to(x + (ARROW_SIZE - 1) / 2.0, y1 + ARROW_SIZE / 2.0 + 0.5);
+    cr->line_to(x - 0.5, y1 + 0.5);
+
+    // Define bottom arrow
+    cr->move_to(x - 0.5, y2 + 0.5);
+    cr->line_to(x + ARROW_SIZE - 0.5, y2 + 0.5);
+    cr->line_to(x + (ARROW_SIZE - 1) / 2.0, y2 - ARROW_SIZE / 2.0 + 0.5);
+    cr->line_to(x - 0.5, y2 + 0.5);
+
+    // Render both arrows
+    cr->set_source_rgb(1.0, 1.0, 1.0);
+    cr->stroke_preserve();
+    cr->set_source_rgb(0.0, 0.0, 0.0);
+    cr->fill();
+
+    return false;
+}
+
+} // namespace Widget
+} // namespace UI
+} // namespace Inkscape
+
+/* Colors are << 16 */
+
+static const guchar *sp_color_slider_render_gradient(gint x0, gint y0, gint width, gint height, gint c[], gint dc[],
+                                                     guint b0, guint b1, guint mask)
+{
+    static guchar *buf = NULL;
+    static gint bs = 0;
+    guchar *dp;
+    gint x, y;
+    guint r, g, b, a;
+
+    if (buf && (bs < width * height)) {
+        g_free(buf);
+        buf = NULL;
+    }
+    if (!buf) {
+        buf = g_new(guchar, width * height * 3);
+        bs = width * height;
+    }
+
+    dp = buf;
+    r = c[0];
+    g = c[1];
+    b = c[2];
+    a = c[3];
+    for (x = x0; x < x0 + width; x++) {
+        gint cr, cg, cb, ca;
+        guchar *d;
+        cr = r >> 16;
+        cg = g >> 16;
+        cb = b >> 16;
+        ca = a >> 16;
+        d = dp;
+        for (y = y0; y < y0 + height; y++) {
+            guint bg, fc;
+            /* Background value */
+            bg = ((x & mask) ^ (y & mask)) ? b0 : b1;
+            fc = (cr - bg) * ca;
+            d[0] = bg + ((fc + (fc >> 8) + 0x80) >> 8);
+            fc = (cg - bg) * ca;
+            d[1] = bg + ((fc + (fc >> 8) + 0x80) >> 8);
+            fc = (cb - bg) * ca;
+            d[2] = bg + ((fc + (fc >> 8) + 0x80) >> 8);
+            d += 3 * width;
+        }
+        r += dc[0];
+        g += dc[1];
+        b += dc[2];
+        a += dc[3];
+        dp += 3;
+    }
+
+    return buf;
+}
+
+/* Positions are << 16 */
+
+static const guchar *sp_color_slider_render_map(gint x0, gint y0, gint width, gint height, guchar *map, gint start,
+                                                gint step, guint b0, guint b1, guint mask)
+{
+    static guchar *buf = NULL;
+    static gint bs = 0;
+    guchar *dp;
+    gint x, y;
+
+    if (buf && (bs < width * height)) {
+        g_free(buf);
+        buf = NULL;
+    }
+    if (!buf) {
+        buf = g_new(guchar, width * height * 3);
+        bs = width * height;
+    }
+
+    dp = buf;
+    for (x = x0; x < x0 + width; x++) {
+        gint cr, cg, cb, ca;
+        guchar *d = dp;
+        guchar *sp = map + 4 * (start >> 16);
+        cr = *sp++;
+        cg = *sp++;
+        cb = *sp++;
+        ca = *sp++;
+        for (y = y0; y < y0 + height; y++) {
+            guint bg, fc;
+            /* Background value */
+            bg = ((x & mask) ^ (y & mask)) ? b0 : b1;
+            fc = (cr - bg) * ca;
+            d[0] = bg + ((fc + (fc >> 8) + 0x80) >> 8);
+            fc = (cg - bg) * ca;
+            d[1] = bg + ((fc + (fc >> 8) + 0x80) >> 8);
+            fc = (cb - bg) * ca;
+            d[2] = bg + ((fc + (fc >> 8) + 0x80) >> 8);
+            d += 3 * width;
+        }
+        dp += 3;
+        start += step;
+    }
+
+    return buf;
+}
diff --git a/src/ui/widget/color-slider.h b/src/ui/widget/color-slider.h
new file mode 100644
index 000000000..253f3123c
--- /dev/null
+++ b/src/ui/widget/color-slider.h
@@ -0,0 +1,110 @@
+/*
+ * A slider with colored background
+ *
+ * Author:
+ *   Lauris Kaplinski <lauris@kaplinski.com>
+ *
+ * Copyright (C) 2001-2002 Lauris Kaplinski
+ *
+ * This code is in public domain
+ */
+
+#ifndef SEEN_COLOR_SLIDER_H
+#define SEEN_COLOR_SLIDER_H
+
+#include <gtkmm/widget.h>
+#include <sigc++/signal.h>
+
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+
+/*
+ * A slider with colored background
+ */
+class ColorSlider : public Gtk::Widget {
+public:
+#if GTK_CHECK_VERSION(3, 0, 0)
+    ColorSlider(Glib::RefPtr<Gtk::Adjustment> adjustment);
+#else
+    ColorSlider(Gtk::Adjustment *adjustment);
+#endif
+    ~ColorSlider();
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+    void setAdjustment(Glib::RefPtr<Gtk::Adjustment> adjustment);
+#else
+    void setAdjustment(Gtk::Adjustment *adjustment);
+#endif
+
+    void setColors(guint32 start, guint32 mid, guint32 end);
+
+    void setMap(const guchar *map);
+
+    void setBackground(guint dark, guint light, guint size);
+
+    sigc::signal<void> signal_grabbed;
+    sigc::signal<void> signal_dragged;
+    sigc::signal<void> signal_released;
+    sigc::signal<void> signal_value_changed;
+
+protected:
+    void on_size_allocate(Gtk::Allocation &allocation);
+    void on_realize();
+    void on_unrealize();
+    bool on_button_press_event(GdkEventButton *event);
+    bool on_button_release_event(GdkEventButton *event);
+    bool on_motion_notify_event(GdkEventMotion *event);
+    bool on_draw(const Cairo::RefPtr<Cairo::Context> &cr);
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+    void get_preferred_width_vfunc(int &minimum_width, int &natural_width) const;
+    void get_preferred_width_for_height_vfunc(int height, int &minimum_width, int &natural_width) const;
+    void get_preferred_height_vfunc(int &minimum_height, int &natural_height) const;
+    void get_preferred_height_for_width_vfunc(int width, int &minimum_height, int &natural_height) const;
+#else
+    void on_size_request(Gtk::Requisition *requisition);
+    bool on_expose_event(GdkEventExpose *event);
+#endif
+
+private:
+    void _onAdjustmentChanged();
+    void _onAdjustmentValueChanged();
+
+    bool _dragging;
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+    Glib::RefPtr<Gtk::Adjustment> _adjustment;
+#else
+    Gtk::Adjustment *_adjustment;
+#endif
+    sigc::connection _adjustment_changed_connection;
+    sigc::connection _adjustment_value_changed_connection;
+
+    gfloat _value;
+    gfloat _oldvalue;
+    guchar _c0[4], _cm[4], _c1[4];
+    guchar _b0, _b1;
+    guchar _bmask;
+
+    gint _mapsize;
+    guchar *_map;
+
+    Glib::RefPtr<Gdk::Window> _gdk_window;
+};
+
+} // namespace Widget
+} // namespace UI
+} // namespace Inkscape
+
+#endif
+/*
+  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:fileencoding=utf-8:textwidth=99 :
diff --git a/src/ui/widget/color-wheel-selector.cpp b/src/ui/widget/color-wheel-selector.cpp
new file mode 100644
index 000000000..ed3400bb5
--- /dev/null
+++ b/src/ui/widget/color-wheel-selector.cpp
@@ -0,0 +1,302 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "color-wheel-selector.h"
+
+#include <math.h>
+#include <gtk/gtk.h>
+#include <glibmm/i18n.h>
+#include <gtkmm/adjustment.h>
+#include <gtkmm/label.h>
+#include <gtkmm/spinbutton.h>
+#include "svg/svg-icc-color.h"
+#include "ui/dialog-events.h"
+#include "ui/selected-color.h"
+#include "ui/widget/color-scales.h"
+#include "ui/widget/color-slider.h"
+#include "ui/widget/gimpcolorwheel.h"
+
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+
+
+#define XPAD 4
+#define YPAD 1
+
+
+const gchar *ColorWheelSelector::MODE_NAME = N_("Wheel");
+
+ColorWheelSelector::ColorWheelSelector(SelectedColor &color)
+#if GTK_CHECK_VERSION(3, 0, 0)
+    : Gtk::Grid()
+#else
+    : Gtk::Table(5, 3, false)
+#endif
+    , _color(color)
+    , _updating(false)
+#if !GTK_CHECK_VERSION(3, 0, 0)
+    , _alpha_adjustment(NULL)
+#endif
+    , _wheel(0)
+    , _slider(0)
+{
+    _initUI();
+    _color_changed_connection = color.signal_changed.connect(sigc::mem_fun(this, &ColorWheelSelector::_colorChanged));
+    _color_dragged_connection = color.signal_dragged.connect(sigc::mem_fun(this, &ColorWheelSelector::_colorChanged));
+}
+
+ColorWheelSelector::~ColorWheelSelector()
+{
+    _wheel = 0;
+#if !GTK_CHECK_VERSION(3, 0, 0)
+    delete _alpha_adjustment;
+#endif
+
+    _color_changed_connection.disconnect();
+    _color_dragged_connection.disconnect();
+}
+
+void ColorWheelSelector::_initUI()
+{
+    /* Create components */
+    gint row = 0;
+
+    _wheel = gimp_color_wheel_new();
+    gtk_widget_show(_wheel);
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+    gtk_widget_set_halign(_wheel, GTK_ALIGN_FILL);
+    gtk_widget_set_valign(_wheel, GTK_ALIGN_FILL);
+    gtk_widget_set_hexpand(_wheel, TRUE);
+    gtk_widget_set_vexpand(_wheel, TRUE);
+    gtk_grid_attach(GTK_GRID(gobj()), _wheel, 0, row, 3, 1);
+#else
+    gtk_table_attach(GTK_TABLE(gobj()), _wheel, 0, 3, row, row + 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
+                     (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0);
+#endif
+
+    row++;
+
+    /* Label */
+    Gtk::Label *label = Gtk::manage(new Gtk::Label(_("_A:"), true));
+    label->set_alignment(1.0, 0.5);
+    label->show();
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+  #if GTK_CHECK_VERSION(3, 12, 0)
+    label->set_margin_start(XPAD);
+    label->set_margin_end(XPAD);
+  #else
+    label->set_margin_left(XPAD);
+    label->set_margin_right(XPAD);
+  #endif
+    label->set_margin_top(YPAD);
+    label->set_margin_bottom(YPAD);
+    label->set_halign(Gtk::ALIGN_FILL);
+    label->set_valign(Gtk::ALIGN_FILL);
+    attach(*label, 0, row, 1, 1);
+#else
+    attach(*label, 0, 1, row, row + 1, Gtk::FILL, Gtk::FILL, XPAD, YPAD);
+#endif
+
+/* Adjustment */
+#if GTK_CHECK_VERSION(3, 0, 0)
+    _alpha_adjustment = Gtk::Adjustment::create(0.0, 0.0, 255.0, 1.0, 10.0, 10.0);
+#else
+    _alpha_adjustment = new Gtk::Adjustment(0.0, 0.0, 255.0, 1.0, 10.0, 10.0);
+#endif
+    /* Slider */
+    _slider = Gtk::manage(new Inkscape::UI::Widget::ColorSlider(_alpha_adjustment));
+    _slider->set_tooltip_text(_("Alpha (opacity)"));
+    _slider->show();
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+  #if GTK_CHECK_VERSION(3, 12, 0)
+    _slider->set_margin_start(XPAD);
+    _slider->set_margin_end(XPAD);
+  #else
+    _slider->set_margin_left(XPAD);
+    _slider->set_margin_right(XPAD);
+  #endif
+    _slider->set_margin_top(YPAD);
+    _slider->set_margin_bottom(YPAD);
+    _slider->set_hexpand(true);
+    _slider->set_halign(Gtk::ALIGN_FILL);
+    _slider->set_valign(Gtk::ALIGN_FILL);
+    attach(*_slider, 1, row, 1, 1);
+#else
+    attach(*_slider, 1, 2, row, row + 1, Gtk::EXPAND | Gtk::FILL, Gtk::FILL, XPAD, YPAD);
+#endif
+
+    _slider->setColors(SP_RGBA32_F_COMPOSE(1.0, 1.0, 1.0, 0.0), SP_RGBA32_F_COMPOSE(1.0, 1.0, 1.0, 0.5),
+                       SP_RGBA32_F_COMPOSE(1.0, 1.0, 1.0, 1.0));
+
+/* Spinbutton */
+#if GTK_CHECK_VERSION(3, 0, 0)
+    Gtk::SpinButton *spin_button = Gtk::manage(new Gtk::SpinButton(_alpha_adjustment, 1.0, 0));
+#else
+    Gtk::SpinButton *spin_button = Gtk::manage(new Gtk::SpinButton(*_alpha_adjustment, 1.0, 0));
+#endif
+    spin_button->set_tooltip_text(_("Alpha (opacity)"));
+    sp_dialog_defocus_on_enter(GTK_WIDGET(spin_button->gobj()));
+    label->set_mnemonic_widget(*spin_button);
+    spin_button->show();
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+  #if GTK_CHECK_VERSION(3, 12, 0)
+    spin_button->set_margin_start(XPAD);
+    spin_button->set_margin_end(XPAD);
+  #else
+    spin_button->set_margin_left(XPAD);
+    spin_button->set_margin_right(XPAD);
+  #endif
+    spin_button->set_margin_top(YPAD);
+    spin_button->set_margin_bottom(YPAD);
+    spin_button->set_halign(Gtk::ALIGN_CENTER);
+    spin_button->set_valign(Gtk::ALIGN_CENTER);
+    attach(*spin_button, 2, row, 1, 1);
+#else
+    attach(*spin_button, 2, 3, row, row + 1, (Gtk::AttachOptions)0, (Gtk::AttachOptions)0, XPAD, YPAD);
+#endif
+
+    /* Signals */
+    _alpha_adjustment->signal_value_changed().connect(sigc::mem_fun(this, &ColorWheelSelector::_adjustmentChanged));
+    _slider->signal_grabbed.connect(sigc::mem_fun(*this, &ColorWheelSelector::_sliderGrabbed));
+    _slider->signal_released.connect(sigc::mem_fun(*this, &ColorWheelSelector::_sliderReleased));
+    _slider->signal_value_changed.connect(sigc::mem_fun(*this, &ColorWheelSelector::_sliderChanged));
+
+    g_signal_connect(G_OBJECT(_wheel), "changed", G_CALLBACK(_wheelChanged), this);
+}
+
+void ColorWheelSelector::on_show()
+{
+#if GTK_CHECK_VERSION(3, 0, 0)
+    Gtk::Grid::on_show();
+#else
+    Gtk::Table::on_show();
+#endif
+    _updateDisplay();
+}
+
+void ColorWheelSelector::_colorChanged()
+{
+    _updateDisplay();
+}
+
+void ColorWheelSelector::_adjustmentChanged()
+{
+    if (_updating) {
+        return;
+    }
+
+    // TODO check this. It looks questionable:
+    // if a value is entered between 0 and 1 exclusive, normalize it to (int) 0..255  or 0..100
+    gdouble value = _alpha_adjustment->get_value();
+    gdouble upper = _alpha_adjustment->get_upper();
+    if (value > 0.0 && value < 1.0) {
+        _alpha_adjustment->set_value(floor(value * upper + 0.5));
+    }
+
+    _color.preserveICC();
+    _color.setAlpha(ColorScales::getScaled(_alpha_adjustment->gobj()));
+}
+
+void ColorWheelSelector::_sliderGrabbed()
+{
+    _color.preserveICC();
+    _color.setHeld(true);
+}
+
+void ColorWheelSelector::_sliderReleased()
+{
+    _color.preserveICC();
+    _color.setHeld(false);
+}
+
+void ColorWheelSelector::_sliderChanged()
+{
+    if (_updating) {
+        return;
+    }
+
+    _color.preserveICC();
+    _color.setAlpha(ColorScales::getScaled(_alpha_adjustment->gobj()));
+}
+
+void ColorWheelSelector::_wheelChanged(GimpColorWheel *wheel, ColorWheelSelector *wheelSelector)
+{
+    if (wheelSelector->_updating) {
+        return;
+    }
+
+    gdouble h = 0;
+    gdouble s = 0;
+    gdouble v = 0;
+    gimp_color_wheel_get_color(wheel, &h, &s, &v);
+
+    float rgb[3] = { 0, 0, 0 };
+    sp_color_hsv_to_rgb_floatv(rgb, h, s, v);
+
+    SPColor color(rgb[0], rgb[1], rgb[2]);
+
+    guint32 start = color.toRGBA32(0x00);
+    guint32 mid = color.toRGBA32(0x7f);
+    guint32 end = color.toRGBA32(0xff);
+
+    wheelSelector->_slider->setColors(start, mid, end);
+
+    wheelSelector->_color.preserveICC();
+
+    wheelSelector->_color.setHeld(gimp_color_wheel_is_adjusting(wheel));
+    wheelSelector->_color.setColor(color);
+}
+
+void ColorWheelSelector::_updateDisplay()
+{
+#ifdef DUMP_CHANGE_INFO
+    g_message("ColorWheelSelector::_colorChanged( this=%p, %f, %f, %f,   %f)", this, _color.color().v.c[0],
+              _color.color().v.c[1], _color.color().v.c[2], alpha);
+#endif
+
+    bool oldval = _updating;
+    _updating = true;
+    {
+        float hsv[3] = { 0, 0, 0 };
+        sp_color_rgb_to_hsv_floatv(hsv, _color.color().v.c[0], _color.color().v.c[1], _color.color().v.c[2]);
+        gimp_color_wheel_set_color(GIMP_COLOR_WHEEL(_wheel), hsv[0], hsv[1], hsv[2]);
+    }
+
+    guint32 start = _color.color().toRGBA32(0x00);
+    guint32 mid = _color.color().toRGBA32(0x7f);
+    guint32 end = _color.color().toRGBA32(0xff);
+
+    _slider->setColors(start, mid, end);
+
+    ColorScales::setScaled(_alpha_adjustment->gobj(), _color.alpha());
+
+    _updating = oldval;
+}
+
+
+Gtk::Widget *ColorWheelSelectorFactory::createWidget(Inkscape::UI::SelectedColor &color) const
+{
+    Gtk::Widget *w = Gtk::manage(new ColorWheelSelector(color));
+    return w;
+}
+
+Glib::ustring ColorWheelSelectorFactory::modeName() const { return gettext(ColorWheelSelector::MODE_NAME); }
+}
+}
+}
+/*
+  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:fileencoding=utf-8:textwidth=99 :
diff --git a/src/ui/widget/color-wheel-selector.h b/src/ui/widget/color-wheel-selector.h
new file mode 100644
index 000000000..5711d417c
--- /dev/null
+++ b/src/ui/widget/color-wheel-selector.h
@@ -0,0 +1,101 @@
+/**
+ * @file
+ * Color selector widget containing GIMP color wheel and slider
+ */
+/* Authors:
+ *   Tomasz Boczkowski <penginsbacon@gmail.com> (c++-sification)
+ *
+ * Copyright (C) 2014 Authors
+ *
+ * This code is in public domain
+ */
+#ifndef SEEN_SP_COLOR_WHEEL_SELECTOR_H
+#define SEEN_SP_COLOR_WHEEL_SELECTOR_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#if WITH_GTKMM_3_0
+#include <gtkmm/grid.h>
+#else
+#include <gtkmm/table.h>
+#endif
+
+#include "ui/selected-color.h"
+
+typedef struct _GimpColorWheel GimpColorWheel;
+
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+
+class ColorSlider;
+
+class ColorWheelSelector
+#if GTK_CHECK_VERSION(3, 0, 0)
+    : public Gtk::Grid
+#else
+    : public Gtk::Table
+#endif
+{
+public:
+    static const gchar *MODE_NAME;
+
+    ColorWheelSelector(SelectedColor &color);
+    virtual ~ColorWheelSelector();
+
+protected:
+    void _initUI();
+
+    void on_show();
+
+    void _colorChanged();
+    void _adjustmentChanged();
+    void _sliderGrabbed();
+    void _sliderReleased();
+    void _sliderChanged();
+    static void _wheelChanged(GimpColorWheel *wheel, ColorWheelSelector *cs);
+
+    void _updateDisplay();
+
+    SelectedColor &_color;
+    bool _updating;
+#if GTK_CHECK_VERSION(3, 0, 0)
+    Glib::RefPtr<Gtk::Adjustment> _alpha_adjustment;
+#else
+    Gtk::Adjustment *_alpha_adjustment;
+#endif
+    GtkWidget *_wheel;
+    Inkscape::UI::Widget::ColorSlider *_slider;
+
+private:
+    // By default, disallow copy constructor and assignment operator
+    ColorWheelSelector(const ColorWheelSelector &obj);
+    ColorWheelSelector &operator=(const ColorWheelSelector &obj);
+
+    sigc::connection _color_changed_connection;
+    sigc::connection _color_dragged_connection;
+};
+
+class ColorWheelSelectorFactory : public ColorSelectorFactory {
+public:
+    Gtk::Widget *createWidget(SelectedColor &color) const;
+    Glib::ustring modeName() const;
+};
+}
+}
+}
+
+#endif // SEEN_SP_COLOR_WHEEL_SELECTOR_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:fileencoding=utf-8:textwidth=99 :
diff --git a/src/ui/widget/font-variants.cpp b/src/ui/widget/font-variants.cpp
new file mode 100644
index 000000000..637631fda
--- /dev/null
+++ b/src/ui/widget/font-variants.cpp
@@ -0,0 +1,512 @@
+/*
+ * Author:
+ *   Tavmjong Bah <tavmjong@free.fr>
+ *
+ * Copyright (C) 2015 Tavmong Bah
+ *
+ * Released under GNU GPL.  Read the file 'COPYING' for more information.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <gtkmm.h>
+#include <glibmm/i18n.h>
+
+#include <iostream>
+
+#include "font-variants.h"
+
+// For updating from selection
+#include "desktop.h"
+#include "selection.h"
+#include "style.h"
+#include "sp-text.h"
+#include "sp-tspan.h"
+#include "sp-tref.h"
+#include "sp-textpath.h"
+#include "sp-item-group.h"
+#include "xml/repr.h"
+
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+
+  FontVariants::FontVariants () :
+    Gtk::VBox (),
+    _ligatures_frame          ( Glib::ustring(_("Ligatures"    )) ),
+    _ligatures_common         ( Glib::ustring(_("Common"       )) ),
+    _ligatures_discretionary  ( Glib::ustring(_("Discretionary")) ),
+    _ligatures_historical     ( Glib::ustring(_("Historical"   )) ),
+    _ligatures_contextual     ( Glib::ustring(_("Contextual"   )) ),
+
+    _position_frame           ( Glib::ustring(_("Position"     )) ),
+    _position_normal          ( Glib::ustring(_("Normal"       )) ),
+    _position_sub             ( Glib::ustring(_("Subscript"    )) ),
+    _position_super           ( Glib::ustring(_("Superscript"  )) ),
+
+    _caps_frame               ( Glib::ustring(_("Capitals"     )) ),
+    _caps_normal              ( Glib::ustring(_("Normal"       )) ),
+    _caps_small               ( Glib::ustring(_("Small"        )) ),
+    _caps_all_small           ( Glib::ustring(_("All small"    )) ),
+    _caps_petite              ( Glib::ustring(_("Petite"       )) ),
+    _caps_all_petite          ( Glib::ustring(_("All petite"   )) ),
+    _caps_unicase             ( Glib::ustring(_("Unicase"      )) ),
+    _caps_titling             ( Glib::ustring(_("Titling"      )) ),
+
+    _numeric_frame            ( Glib::ustring(_("Numeric"      )) ),
+    _numeric_lining           ( Glib::ustring(_("Lining"       )) ),
+    _numeric_old_style        ( Glib::ustring(_("Old Style"    )) ),
+    _numeric_default_style    ( Glib::ustring(_("Default Style")) ),
+    _numeric_proportional     ( Glib::ustring(_("Proportional" )) ),
+    _numeric_tabular          ( Glib::ustring(_("Tabular"      )) ),
+    _numeric_default_width    ( Glib::ustring(_("Default Width")) ),
+    _numeric_diagonal         ( Glib::ustring(_("Diagonal"     )) ),
+    _numeric_stacked          ( Glib::ustring(_("Stacked"      )) ),
+    _numeric_default_fractions( Glib::ustring(_("Default Fractions")) ),
+    _numeric_ordinal          ( Glib::ustring(_("Ordinal"      )) ),
+    _numeric_slashed_zero     ( Glib::ustring(_("Slashed Zero" )) ),
+
+    _ligatures_changed( false ),
+    _position_changed( false ),
+    _caps_changed( false ),
+    _numeric_changed( false )
+
+  {
+
+    // Ligatures --------------------------
+
+    // Add tooltips
+    _ligatures_common.set_tooltip_text(
+      _("Common ligatures. On by default. OpenType tables: 'liga', 'clig'"));
+    _ligatures_discretionary.set_tooltip_text(
+      _("Discretionary ligatures. Off by default. OpenType table: 'dlig'"));
+    _ligatures_historical.set_tooltip_text(
+      _("Historical ligatures. Off by default. OpenType table: 'hlig'"));
+    _ligatures_contextual.set_tooltip_text(
+      _("Contextual forms. On by default. OpenType table: 'calt'"));
+
+    // Add signals
+    _ligatures_common.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::ligatures_callback) );
+    _ligatures_discretionary.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::ligatures_callback) );
+    _ligatures_historical.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::ligatures_callback) );
+    _ligatures_contextual.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::ligatures_callback) );
+
+    // Add to frame
+    _ligatures_vbox.add( _ligatures_common );
+    _ligatures_vbox.add( _ligatures_discretionary );
+    _ligatures_vbox.add( _ligatures_historical );
+    _ligatures_vbox.add( _ligatures_contextual );
+    _ligatures_frame.add( _ligatures_vbox );
+    add( _ligatures_frame );
+
+    ligatures_init();
+    
+    // Position ----------------------------------
+
+    // Add tooltips
+    _position_normal.set_tooltip_text( _("Normal position."));
+    _position_sub.set_tooltip_text( _("Subscript. OpenType table: 'subs'") );
+    _position_super.set_tooltip_text( _("Superscript. OpenType table: 'sups'") );
+
+    // Group buttons
+    Gtk::RadioButton::Group position_group = _position_normal.get_group();
+    _position_sub.set_group(position_group);
+    _position_super.set_group(position_group);
+
+    // Add signals
+    _position_normal.signal_pressed().connect ( sigc::mem_fun(*this, &FontVariants::position_callback) );
+    _position_sub.signal_pressed().connect ( sigc::mem_fun(*this, &FontVariants::position_callback) );
+    _position_super.signal_pressed().connect ( sigc::mem_fun(*this, &FontVariants::position_callback) );
+
+    // Add to frame
+    _position_vbox.add( _position_normal );
+    _position_vbox.add( _position_sub );
+    _position_vbox.add( _position_super );
+    _position_frame.add( _position_vbox );
+    add( _position_frame );
+
+    position_init();
+
+    // Caps ----------------------------------
+
+    // Add tooltips
+    _caps_normal.set_tooltip_text( _("Normal capitalization."));
+    _caps_small.set_tooltip_text( _("Small-caps (lowercase). OpenType table: 'smcp'"));
+    _caps_all_small.set_tooltip_text( _("All small-caps (uppercase and lowercase). OpenType tables: 'c2sc' and 'smcp'"));
+    _caps_petite.set_tooltip_text( _("Petite-caps (lowercase). OpenType table: 'pcap'"));
+    _caps_all_petite.set_tooltip_text( _("All petite-caps (uppercase and lowercase). OpenType tables: 'c2sc' and 'pcap'"));
+    _caps_unicase.set_tooltip_text( _("Unicase (small caps for uppercase, normal for lowercase). OpenType table: 'unic'"));
+    _caps_titling.set_tooltip_text( _("Titling caps (lighter-weight uppercase for use in titles). OpenType table: 'titl'"));
+
+    // Group buttons
+    Gtk::RadioButton::Group caps_group = _caps_normal.get_group();
+    _caps_small.set_group(caps_group);
+    _caps_all_small.set_group(caps_group);
+    _caps_petite.set_group(caps_group);
+    _caps_all_petite.set_group(caps_group);
+    _caps_unicase.set_group(caps_group);
+    _caps_titling.set_group(caps_group);
+
+    // Add signals
+    _caps_normal.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) );
+    _caps_small.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) );
+    _caps_all_small.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) );
+    _caps_petite.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) );
+    _caps_all_petite.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) );
+    _caps_unicase.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) );
+    _caps_titling.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) );
+
+    // Add to frame
+    _caps_vbox.add( _caps_normal );
+    _caps_vbox.add( _caps_small );
+    _caps_vbox.add( _caps_all_small );
+    _caps_vbox.add( _caps_petite );
+    _caps_vbox.add( _caps_all_petite );
+    _caps_vbox.add( _caps_unicase );
+    _caps_vbox.add( _caps_titling );
+    _caps_frame.add( _caps_vbox );
+    add( _caps_frame );
+
+    caps_init();
+
+    // Numeric ------------------------------
+
+    // Add tooltips
+    _numeric_default_style.set_tooltip_text( _("Normal style."));
+    _numeric_lining.set_tooltip_text( _("Lining numerals. OpenType table: 'lnum'"));
+    _numeric_old_style.set_tooltip_text( _("Old style numerals. OpenType table: 'onum'"));
+    _numeric_default_width.set_tooltip_text( _("Normal widths."));
+    _numeric_proportional.set_tooltip_text( _("Proportional width numerals. OpenType table: 'pnum'"));
+    _numeric_tabular.set_tooltip_text( _("Same width numerals. OpenType table: 'tnum'"));
+    _numeric_default_fractions.set_tooltip_text( _("Normal fractions."));
+    _numeric_diagonal.set_tooltip_text( _("Diagonal fractions. OpenType table: 'frac'"));
+    _numeric_stacked.set_tooltip_text( _("Stacked fractions. OpenType table: 'afrc'"));
+    _numeric_ordinal.set_tooltip_text( _("Ordinals (raised 'th', etc.). OpenType table: 'ordn'"));
+    _numeric_slashed_zero.set_tooltip_text( _("Slashed zeros. OpenType table: 'zero'"));
+
+    // Group buttons
+    Gtk::RadioButton::Group style_group = _numeric_default_style.get_group();
+    _numeric_lining.set_group(style_group);
+    _numeric_old_style.set_group(style_group);
+
+    Gtk::RadioButton::Group width_group = _numeric_default_width.get_group();
+    _numeric_proportional.set_group(width_group);
+    _numeric_tabular.set_group(width_group);
+
+    Gtk::RadioButton::Group fraction_group = _numeric_default_fractions.get_group();
+    _numeric_diagonal.set_group(fraction_group);
+    _numeric_stacked.set_group(fraction_group);
+
+    // Add signals
+    _numeric_default_style.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::numeric_callback) );
+    _numeric_lining.signal_clicked().connect (        sigc::mem_fun(*this, &FontVariants::numeric_callback) );
+    _numeric_old_style.signal_clicked().connect (     sigc::mem_fun(*this, &FontVariants::numeric_callback) );
+    _numeric_default_width.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::numeric_callback) );
+    _numeric_proportional.signal_clicked().connect (  sigc::mem_fun(*this, &FontVariants::numeric_callback) );
+    _numeric_tabular.signal_clicked().connect (       sigc::mem_fun(*this, &FontVariants::numeric_callback) );
+    _numeric_default_fractions.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::numeric_callback) );
+    _numeric_diagonal.signal_clicked().connect (      sigc::mem_fun(*this, &FontVariants::numeric_callback) );
+    _numeric_stacked.signal_clicked().connect (       sigc::mem_fun(*this, &FontVariants::numeric_callback) );
+    _numeric_ordinal.signal_clicked().connect (       sigc::mem_fun(*this, &FontVariants::numeric_callback) );
+    _numeric_slashed_zero.signal_clicked().connect (  sigc::mem_fun(*this, &FontVariants::numeric_callback) );
+
+    // Add to frame
+    _numeric_stylebox.add( _numeric_default_style );
+    _numeric_stylebox.add( _numeric_lining );
+    _numeric_stylebox.add( _numeric_old_style );
+    _numeric_vbox.add( _numeric_stylebox );
+    _numeric_widthbox.add( _numeric_default_width );
+    _numeric_widthbox.add( _numeric_proportional );
+    _numeric_widthbox.add( _numeric_tabular );
+    _numeric_vbox.add( _numeric_widthbox );
+    _numeric_fractionbox.add( _numeric_default_fractions );
+    _numeric_fractionbox.add( _numeric_diagonal );
+    _numeric_fractionbox.add( _numeric_stacked );
+    _numeric_vbox.add( _numeric_fractionbox );
+    _numeric_vbox.add( _numeric_ordinal );
+    _numeric_vbox.add( _numeric_slashed_zero );
+    _numeric_frame.add( _numeric_vbox );
+    add( _numeric_frame );
+    
+
+    show_all_children();
+
+  }
+
+  void
+  FontVariants::ligatures_init() {
+      // std::cout << "FontVariants::ligatures_init()" << std::endl;
+  }
+  
+  void
+  FontVariants::ligatures_callback() {
+      // std::cout << "FontVariants::ligatures_callback()" << std::endl;
+      _ligatures_changed = true;
+      _changed_signal.emit();
+  }
+
+  void
+  FontVariants::position_init() {
+      // std::cout << "FontVariants::position_init()" << std::endl;
+  }
+  
+  void
+  FontVariants::position_callback() {
+      // std::cout << "FontVariants::position_callback()" << std::endl;
+      _position_changed = true;
+      _changed_signal.emit();
+  }
+
+  void
+  FontVariants::caps_init() {
+      // std::cout << "FontVariants::caps_init()" << std::endl;
+  }
+  
+  void
+  FontVariants::caps_callback() {
+      // std::cout << "FontVariants::caps_callback()" << std::endl;
+      _caps_changed = true;
+      _changed_signal.emit();
+  }
+
+  void
+  FontVariants::numeric_init() {
+      // std::cout << "FontVariants::numeric_init()" << std::endl;
+  }
+  
+  void
+  FontVariants::numeric_callback() {
+      // std::cout << "FontVariants::numeric_callback()" << std::endl;
+      _numeric_changed = true;
+      _changed_signal.emit();
+  }
+
+  // Update GUI based on query.
+  void
+  FontVariants::update( SPStyle const *query ) {
+
+      _ligatures_all = query->font_variant_ligatures.computed;
+      _ligatures_mix = query->font_variant_ligatures.value;
+
+      _ligatures_common.set_active(       _ligatures_all & SP_CSS_FONT_VARIANT_LIGATURES_COMMON );
+      _ligatures_discretionary.set_active(_ligatures_all & SP_CSS_FONT_VARIANT_LIGATURES_DISCRETIONARY );
+      _ligatures_historical.set_active(   _ligatures_all & SP_CSS_FONT_VARIANT_LIGATURES_HISTORICAL );
+      _ligatures_contextual.set_active(   _ligatures_all & SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL );
+      
+      _ligatures_common.set_inconsistent(        _ligatures_mix & SP_CSS_FONT_VARIANT_LIGATURES_COMMON );
+      _ligatures_discretionary.set_inconsistent( _ligatures_mix & SP_CSS_FONT_VARIANT_LIGATURES_DISCRETIONARY );
+      _ligatures_historical.set_inconsistent(    _ligatures_mix & SP_CSS_FONT_VARIANT_LIGATURES_HISTORICAL );
+      _ligatures_contextual.set_inconsistent(    _ligatures_mix & SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL );
+
+      _position_all = query->font_variant_position.computed;
+      _position_mix = query->font_variant_position.value;
+      
+      _position_normal.set_active( _position_all & SP_CSS_FONT_VARIANT_POSITION_NORMAL );
+      _position_sub.set_active(    _position_all & SP_CSS_FONT_VARIANT_POSITION_SUB );
+      _position_super.set_active(  _position_all & SP_CSS_FONT_VARIANT_POSITION_SUPER );
+
+      _position_normal.set_inconsistent( _position_mix & SP_CSS_FONT_VARIANT_POSITION_NORMAL );
+      _position_sub.set_inconsistent(    _position_mix & SP_CSS_FONT_VARIANT_POSITION_SUB );
+      _position_super.set_inconsistent(  _position_mix & SP_CSS_FONT_VARIANT_POSITION_SUPER );
+
+      _caps_all = query->font_variant_caps.computed;
+      _caps_mix = query->font_variant_caps.value;
+
+      _caps_normal.set_active(     _caps_all & SP_CSS_FONT_VARIANT_CAPS_NORMAL );
+      _caps_small.set_active(      _caps_all & SP_CSS_FONT_VARIANT_CAPS_SMALL );
+      _caps_all_small.set_active(  _caps_all & SP_CSS_FONT_VARIANT_CAPS_ALL_SMALL );
+      _caps_petite.set_active(     _caps_all & SP_CSS_FONT_VARIANT_CAPS_PETITE );
+      _caps_all_petite.set_active( _caps_all & SP_CSS_FONT_VARIANT_CAPS_ALL_PETITE );
+      _caps_unicase.set_active(    _caps_all & SP_CSS_FONT_VARIANT_CAPS_UNICASE );
+      _caps_titling.set_active(    _caps_all & SP_CSS_FONT_VARIANT_CAPS_TITLING );
+
+      _caps_normal.set_inconsistent(     _caps_mix & SP_CSS_FONT_VARIANT_CAPS_NORMAL );
+      _caps_small.set_inconsistent(      _caps_mix & SP_CSS_FONT_VARIANT_CAPS_SMALL );
+      _caps_all_small.set_inconsistent(  _caps_mix & SP_CSS_FONT_VARIANT_CAPS_ALL_SMALL );
+      _caps_petite.set_inconsistent(     _caps_mix & SP_CSS_FONT_VARIANT_CAPS_PETITE );
+      _caps_all_petite.set_inconsistent( _caps_mix & SP_CSS_FONT_VARIANT_CAPS_ALL_PETITE );
+      _caps_unicase.set_inconsistent(    _caps_mix & SP_CSS_FONT_VARIANT_CAPS_UNICASE );
+      _caps_titling.set_inconsistent(    _caps_mix & SP_CSS_FONT_VARIANT_CAPS_TITLING );
+
+      _numeric_all = query->font_variant_numeric.computed;
+      _numeric_mix = query->font_variant_numeric.value;
+
+      if (_numeric_all & SP_CSS_FONT_VARIANT_NUMERIC_LINING_NUMS) {
+          _numeric_lining.set_active();
+      } else if (_numeric_all & SP_CSS_FONT_VARIANT_NUMERIC_OLDSTYLE_NUMS) {
+          _numeric_old_style.set_active();
+      } else {
+          _numeric_default_style.set_active();
+      }
+
+      if (_numeric_all & SP_CSS_FONT_VARIANT_NUMERIC_PROPORTIONAL_NUMS) {
+          _numeric_proportional.set_active();
+      } else if (_numeric_all & SP_CSS_FONT_VARIANT_NUMERIC_TABULAR_NUMS) {
+          _numeric_tabular.set_active();
+      } else {
+          _numeric_default_width.set_active();
+      }
+
+      if (_numeric_all & SP_CSS_FONT_VARIANT_NUMERIC_DIAGONAL_FRACTIONS) {
+          _numeric_diagonal.set_active();
+      } else if (_numeric_all & SP_CSS_FONT_VARIANT_NUMERIC_STACKED_FRACTIONS) {
+          _numeric_stacked.set_active();
+      } else {
+          _numeric_default_fractions.set_active();
+      }
+
+      _numeric_ordinal.set_active(      _numeric_all & SP_CSS_FONT_VARIANT_NUMERIC_ORDINAL );
+      _numeric_slashed_zero.set_active( _numeric_all & SP_CSS_FONT_VARIANT_NUMERIC_SLASHED_ZERO );
+
+
+      _numeric_lining.set_inconsistent(       _numeric_mix & SP_CSS_FONT_VARIANT_NUMERIC_LINING_NUMS );
+      _numeric_old_style.set_inconsistent(    _numeric_mix & SP_CSS_FONT_VARIANT_NUMERIC_OLDSTYLE_NUMS );
+      _numeric_proportional.set_inconsistent( _numeric_mix & SP_CSS_FONT_VARIANT_NUMERIC_PROPORTIONAL_NUMS );
+      _numeric_tabular.set_inconsistent(      _numeric_mix & SP_CSS_FONT_VARIANT_NUMERIC_TABULAR_NUMS );
+      _numeric_diagonal.set_inconsistent(     _numeric_mix & SP_CSS_FONT_VARIANT_NUMERIC_DIAGONAL_FRACTIONS );
+      _numeric_stacked.set_inconsistent(      _numeric_mix & SP_CSS_FONT_VARIANT_NUMERIC_STACKED_FRACTIONS );
+      _numeric_ordinal.set_inconsistent(      _numeric_mix & SP_CSS_FONT_VARIANT_NUMERIC_ORDINAL );
+      _numeric_slashed_zero.set_inconsistent( _numeric_mix & SP_CSS_FONT_VARIANT_NUMERIC_SLASHED_ZERO );
+
+      _ligatures_changed = false;
+      _position_changed  = false;
+      _caps_changed      = false;
+      _numeric_changed   = false;
+  }
+
+  void
+  FontVariants::fill_css( SPCSSAttr *css ) {
+
+      // Ligatures
+      bool common        = _ligatures_common.get_active();
+      bool discretionary = _ligatures_discretionary.get_active();
+      bool historical    = _ligatures_historical.get_active();
+      bool contextual    = _ligatures_contextual.get_active();
+
+      if( !common && !discretionary && !historical && !contextual ) {
+          sp_repr_css_set_property(css, "font-variant-ligatures", "none" );
+      } else if ( common && !discretionary && !historical && contextual ) {
+          sp_repr_css_set_property(css, "font-variant-ligatures", "normal" );
+      } else {
+          Glib::ustring css_string;
+          if ( !common )
+              css_string += "no-common-ligatures ";
+          if ( discretionary )
+              css_string += "discretionary-ligatures ";
+          if ( historical )
+              css_string += "historical-ligatures ";
+          if ( !contextual )
+              css_string += "no-contextual ";
+          sp_repr_css_set_property(css, "font-variant-ligatures", css_string.c_str() );
+      }
+
+      // Position
+      {
+          unsigned position_new = SP_CSS_FONT_VARIANT_POSITION_NORMAL;
+          Glib::ustring css_string;
+          if( _position_normal.get_active() ) {
+              css_string = "normal";
+          } else if( _position_sub.get_active() ) {
+              css_string = "sub";
+              position_new = SP_CSS_FONT_VARIANT_POSITION_SUB;
+          } else if( _position_super.get_active() ) {
+              css_string = "super";
+              position_new = SP_CSS_FONT_VARIANT_POSITION_SUPER;
+          }
+
+          // 'if' may not be necessary... need to test.
+          if( (_position_all != position_new) || ((_position_mix != 0) && _position_changed) ) {
+              sp_repr_css_set_property(css, "font-variant-position", css_string.c_str() );
+          }
+      }
+      
+      // Caps
+      {
+          unsigned caps_new = SP_CSS_FONT_VARIANT_CAPS_NORMAL;
+          Glib::ustring css_string;
+          if( _caps_normal.get_active() ) {
+              css_string = "normal";
+              caps_new = SP_CSS_FONT_VARIANT_CAPS_NORMAL;
+          } else if( _caps_small.get_active() ) {
+              css_string = "small-caps";
+              caps_new = SP_CSS_FONT_VARIANT_CAPS_SMALL;
+          } else if( _caps_all_small.get_active() ) {
+              css_string = "all-small-caps";
+              caps_new = SP_CSS_FONT_VARIANT_CAPS_ALL_SMALL;
+          } else if( _caps_all_petite.get_active() ) {
+              css_string = "petite";
+              caps_new = SP_CSS_FONT_VARIANT_CAPS_PETITE;
+          } else if( _caps_all_petite.get_active() ) {
+              css_string = "all-petite";
+              caps_new = SP_CSS_FONT_VARIANT_CAPS_ALL_PETITE;
+          } else if( _caps_unicase.get_active() ) {
+              css_string = "unicase";
+              caps_new = SP_CSS_FONT_VARIANT_CAPS_UNICASE;
+          } else if( _caps_titling.get_active() ) {
+              css_string = "titling";
+              caps_new = SP_CSS_FONT_VARIANT_CAPS_TITLING;
+          }
+
+          // May not be necessary... need to test.
+          //if( (_caps_all != caps_new) || ((_caps_mix != 0) && _caps_changed) ) {
+          sp_repr_css_set_property(css, "font-variant-caps", css_string.c_str() );
+          //}
+      }
+
+      // Numeric
+      bool default_style = _numeric_default_style.get_active();
+      bool lining        = _numeric_lining.get_active();
+      bool old_style     = _numeric_old_style.get_active();
+
+      bool default_width = _numeric_default_width.get_active();
+      bool proportional  = _numeric_proportional.get_active();
+      bool tabular       = _numeric_tabular.get_active();
+
+      bool default_fractions = _numeric_default_fractions.get_active();
+      bool diagonal          = _numeric_diagonal.get_active();
+      bool stacked           = _numeric_stacked.get_active();
+
+      bool ordinal           = _numeric_ordinal.get_active();
+      bool slashed_zero      = _numeric_slashed_zero.get_active();
+
+      if (default_style & default_width & default_fractions & !ordinal & !slashed_zero) {
+          sp_repr_css_set_property(css, "font-variant-numeric", "normal");
+      } else {
+          Glib::ustring css_string;
+          if ( lining )
+              css_string += "lining-nums ";
+          if ( old_style )
+              css_string += "oldstyle-nums ";
+          if ( proportional )
+              css_string += "proportional-nums ";
+          if ( tabular )
+              css_string += "tabular-nums ";
+          if ( diagonal )
+              css_string += "diagonal-fractions ";
+          if ( stacked )
+              css_string += "stacked-fractions ";
+          if ( ordinal )
+              css_string += "ordinal ";
+          if ( slashed_zero )
+              css_string += "slashed-zero ";
+          sp_repr_css_set_property(css, "font-variant-numeric", css_string.c_str() );
+      }
+
+  }
+   
+} // namespace Widget
+} // namespace UI
+} // namespace Inkscape
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/ui/widget/font-variants.h b/src/ui/widget/font-variants.h
new file mode 100644
index 000000000..e6a9dd68b
--- /dev/null
+++ b/src/ui/widget/font-variants.h
@@ -0,0 +1,152 @@
+/*
+ * Author:
+ *   Tavmjong Bah <tavmjong@free.fr>
+ *
+ * Copyright (C) 2015 Tavmong Bah
+ *
+ * Released under GNU GPL.  Read the file 'COPYING' for more information.
+ */
+
+#ifndef INKSCAPE_UI_WIDGET_FONT_VARIANT_H
+#define INKSCAPE_UI_WIDGET_FONT_VARIANT_H
+
+#include <gtkmm/expander.h>
+#include <gtkmm/checkbutton.h>
+#include <gtkmm/radiobutton.h>
+
+class SPDesktop;
+class SPObject;
+class SPStyle;
+class SPCSSAttr;
+
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+
+/**
+ * A container for selecting font variants (OpenType Features).
+ */
+class FontVariants : public Gtk::VBox
+{
+
+public:
+
+    /**
+     * Constructor
+     */
+    FontVariants();
+
+protected:
+    // To start, use four check buttons.
+    Gtk::Expander       _ligatures_frame;
+    Gtk::VBox           _ligatures_vbox;
+    Gtk::CheckButton    _ligatures_common;
+    Gtk::CheckButton    _ligatures_discretionary;
+    Gtk::CheckButton    _ligatures_historical;
+    Gtk::CheckButton    _ligatures_contextual;
+
+    // Exclusive options
+    Gtk::Expander       _position_frame;
+    Gtk::VBox           _position_vbox;
+    Gtk::RadioButton    _position_normal;
+    Gtk::RadioButton    _position_sub;
+    Gtk::RadioButton    _position_super;
+    
+    // Exclusive options (maybe a dropdown menu to save space?)
+    Gtk::Expander       _caps_frame;
+    Gtk::VBox           _caps_vbox;
+    Gtk::RadioButton    _caps_normal;
+    Gtk::RadioButton    _caps_small;
+    Gtk::RadioButton    _caps_all_small;
+    Gtk::RadioButton    _caps_petite;
+    Gtk::RadioButton    _caps_all_petite;
+    Gtk::RadioButton    _caps_unicase;
+    Gtk::RadioButton    _caps_titling;
+
+    // Complicated!
+    Gtk::Expander       _numeric_frame;
+    Gtk::VBox           _numeric_vbox;
+    Gtk::HBox           _numeric_stylebox;
+    Gtk::RadioButton    _numeric_lining;
+    Gtk::RadioButton    _numeric_old_style;
+    Gtk::RadioButton    _numeric_default_style;
+    Gtk::HBox           _numeric_widthbox;
+    Gtk::RadioButton    _numeric_proportional;
+    Gtk::RadioButton    _numeric_tabular;
+    Gtk::RadioButton    _numeric_default_width;
+    Gtk::HBox           _numeric_fractionbox;
+    Gtk::RadioButton    _numeric_diagonal;
+    Gtk::RadioButton    _numeric_stacked;
+    Gtk::RadioButton    _numeric_default_fractions;
+    Gtk::CheckButton    _numeric_ordinal;
+    Gtk::CheckButton    _numeric_slashed_zero;
+
+private:
+    void ligatures_init();
+    void ligatures_callback();
+
+    void position_init();
+    void position_callback();
+
+    void caps_init();
+    void caps_callback();
+
+    void numeric_init();
+    void numeric_callback();
+
+    // To determine if we need to write out property (may not be necessary)
+    unsigned _ligatures_all;
+    unsigned _position_all;
+    unsigned _caps_all;
+    unsigned _numeric_all;
+    
+    unsigned _ligatures_mix;
+    unsigned _position_mix;
+    unsigned _caps_mix;
+    unsigned _numeric_mix;
+
+    bool _ligatures_changed;
+    bool _position_changed;
+    bool _caps_changed;
+    bool _numeric_changed;
+
+    sigc::signal<void> _changed_signal;
+
+public:
+
+    /**
+     * Update GUI based on query results.
+     */
+    void update( SPStyle const *query );
+
+    /**
+     * Fill SPCSSAttr based on settings of buttons.
+     */
+    void fill_css( SPCSSAttr* css );
+
+    /**
+     * Let others know that user has changed GUI settings.
+     * (Used to enable 'Apply' and 'Default' buttons.)
+     */
+    sigc::connection connectChanged(sigc::slot<void> slot) {
+        return _changed_signal.connect(slot);
+    }
+};
+
+ 
+} // namespace Widget
+} // namespace UI
+} // namespace Inkscape
+
+#endif // INKSCAPE_UI_WIDGET_FONT_VARIANT_H
+
+/* 
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :