Merge lp:~penginsbacon/inkscape/fill-n-stroke-cppify into lp:~inkscape.dev/inkscape/trunk

[Tomasz Boczkowski]

> I've fixed the bugs detected by Tav and suv.

This branch merges the c++-sification effort from GSOC 2014 project.

Refactored classes are related to fill'n'stroke dialog. The list includes:
SPColorSelector
SPColorWheelSelector
SPColorICCSelector
SPColorScales
SPNotebook
SPColorSlider

SPPattern

[Tavmjong Bah (tavmjong-free)]

Mostly looks good. We reviewed the first 5000 lines (the view was truncated there). Saw a bunch of minor white space issues. Reviewed at hackfest.

We are really looking forward to getting this in for 0.92!

review: Needs Fixing (code)

[Tavmjong Bah (tavmjong-free)]

Bugs:

1. Crash when selecting an object with a gradient and then clicking the solid color icon.

2. Color selection dialog doesn't remember last open tab (always opens in HSL even if RGB was last used tab).

3. First time dialog opened, there is an extra row in the RGB and HSL tabs.

At least #1 needs fixing before the code can be checked in.

review: Needs Fixing

[Tomasz Boczkowski (penginsbacon)]

I've fixed the bugs #1 and #2 in fill-n-stroke-cppify branch.
I cannot reproduce #3 on my computer. Could you please send me a screenshot?

On Sun, May 3, 2015 at 9:32 PM, Tavmjong Bah <email address hidden> wrote:

> Review: Needs Fixing
>
> Bugs:
>
> 1. Crash when selecting an object with a gradient and then clicking the
> solid color icon.
>
> 2. Color selection dialog doesn't remember last open tab (always opens in
> HSL even if RGB was last used tab).
>
> 3. First time dialog opened, there is an extra row in the RGB and HSL tabs.
>
> At least #1 needs fixing before the code can be checked in.
>
>
> --
>
> https://code.launchpad.net/~penginsbacon/inkscape/fill-n-stroke-cppify/+merge/258120
> You are the owner of lp:~penginsbacon/inkscape/fill-n-stroke-cppify.
>

[su_v (suv-lp)]

On 2015-05-12 24:42 (+0200), Tomasz Boczkowski wrote:
>> 3. First time dialog opened, there is an extra row in the RGB and
>> HSL tabs.
>
> I cannot reproduce #3 on my computer. Could you please send me a
> screenshot?

Steps to reproduce:
1) launch branch build with default (new) prefs
2) draw a rectangle
3) open Fill & Stroke

--> there's an additional color slider below the regular ones.

Screenshot:
https://www.dropbox.com/sh/b1h0t3fb0heuzc3/AAACYs48cTYY6FeXKiz_j19ga?dl=0

Does not happen if nothing is selected when opening Fill & Stroke for the first time in the current session.

[su_v (suv-lp)]

Another regression (reproduced with r14085):
Steps to reproduce:
1) launch branch build with default (new) prefs
2) draw a rect
3) draw an ellipse
4) group ellipse (Ctrl+G)
5) deselect everything (<esc>)
6) open fill&stroke dialog
7) select rect
--> fill shows blue paint as expected
8) select group
--> fill shows 'Paint is undefined' as expected
9) select again the rectangle
--> fill shows solid white paint (incorrect)

Seems to be triggered after having selected an object with undefined style property (can be reproduced e.g. with clones, and with stroke paint, too).

[Tavmjong Bah (tavmjong-free)]

Looks good when compiled directly. But when I try to merge with trunk I get:

Conflict adding file src/ui/selected-color.cpp. Moved existing file to src/ui/selected-color.cpp.moved.
Conflict adding file src/ui/selected-color.h. Moved existing file to src/ui/selected-color.h.moved.
Conflict adding file src/ui/widget/color-entry.cpp. Moved existing file to src/ui/widget/color-entry.cpp.moved.
Conflict adding file src/ui/widget/color-entry.h. Moved existing file to src/ui/widget/color-entry.h.moved.
4 conflicts encountered.
The moved files are identical to the added files.

When running 'make check':

make[1]: *** No rule to make target '../src/widgets/sp-color-icc-selector.cpp', needed by 'inkscape.pot'. Stop.

This is due to not renaming the files in po/POTFILES.in

I've fixed the POT files and taken care of the merge conflicts.

Branch merged into trunk in revision 14160.

One possible bug still present:

Error message when trying to select mesh gradient:

** (inkscape:8619): WARNING **: file widgets/fill-style.cpp: line 711: Paint selector should not be in mode 6

review: Approve

=== modified file 'src/desktop-style.cpp'
--- src/desktop-style.cpp	2015-05-16 12:50:10 +0000
+++ src/desktop-style.cpp	2015-05-17 12:22:15 +0000
@@ -576,8 +576,8 @@
                    return QUERY_STYLE_MULTIPLE_DIFFERENT;  // different kind of server
                 }
 
-                SPPattern *pat = pattern_getroot (pattern);
-                SPPattern *pat_res = pattern_getroot (pattern_res);
+                SPPattern *pat = SP_PATTERN (server)->rootPattern();
+                SPPattern *pat_res = SP_PATTERN (server_res)->rootPattern();
                 if (pat_res != pat) {
                    return QUERY_STYLE_MULTIPLE_DIFFERENT;  // different pattern roots
                 }

=== modified file 'src/extension/internal/cairo-render-context.cpp'
--- src/extension/internal/cairo-render-context.cpp	2015-05-08 13:46:25 +0000
+++ src/extension/internal/cairo-render-context.cpp	2015-05-17 12:22:15 +0000
@@ -1008,17 +1008,16 @@
     ps2user = Geom::identity();
     pcs2dev = Geom::identity();
 
-    double x = pattern_x(pat);
-    double y = pattern_y(pat);
-    double width = pattern_width(pat);
-    double height = pattern_height(pat);
+    double x = pat->x();
+    double y = pat->y();
+    double width = pat->width();
+    double height = pat->height();
     double bbox_width_scaler;
     double bbox_height_scaler;
 
     TRACE(("%f x %f pattern\n", width, height));
 
-    if (pbox && pattern_patternUnits(pat) == SP_PATTERN_UNITS_OBJECTBOUNDINGBOX) {
-        //Geom::Affine bbox2user (pbox->x1 - pbox->x0, 0.0, 0.0, pbox->y1 - pbox->y0, pbox->x0, pbox->y0);
+    if (pbox && pat->patternUnits() == SPPattern::UNITS_OBJECTBOUNDINGBOX) {
         bbox_width_scaler = pbox->width();
         bbox_height_scaler = pbox->height();
         ps2user[4] = x * bbox_width_scaler + pbox->left();
@@ -1031,13 +1030,13 @@
     }
 
     // apply pattern transformation
-    Geom::Affine pattern_transform(pattern_patternTransform(pat));
+    Geom::Affine pattern_transform(pat->getTransform());
     ps2user *= pattern_transform;
     Geom::Point ori (ps2user[4], ps2user[5]);
 
     // create pattern contents coordinate system
     if (pat->viewBox_set) {
-        Geom::Rect view_box = *pattern_viewBox(pat);
+        Geom::Rect view_box = *pat->viewbox();
 
         double x, y, w, h;
         x = 0;
@@ -1050,7 +1049,7 @@
         pcs2dev[3] = h / view_box.height();
         pcs2dev[4] = x - view_box.left() * pcs2dev[0];
         pcs2dev[5] = y - view_box.top() * pcs2dev[3];
-    } else if (pbox && pattern_patternContentUnits(pat) == SP_PATTERN_UNITS_OBJECTBOUNDINGBOX) {
+    } else if (pbox && pat->patternContentUnits() == SPPattern::UNITS_OBJECTBOUNDINGBOX) {
         pcs2dev[0] = pbox->width();
         pcs2dev[3] = pbox->height();
     }

=== modified file 'src/extension/internal/emf-print.cpp'
--- src/extension/internal/emf-print.cpp	2015-04-27 18:49:22 +0000
+++ src/extension/internal/emf-print.cpp	2015-05-17 12:22:15 +0000
@@ -388,8 +388,8 @@
         } else if (SP_IS_PATTERN(SP_STYLE_FILL_SERVER(style))) { // must be paint-server
             SPPaintServer *paintserver = style->fill.value.href->getObject();
             SPPattern *pat = SP_PATTERN(paintserver);
-            double dwidth  = pattern_width(pat);
-            double dheight = pattern_height(pat);
+            double dwidth  = pat->width();
+            double dheight = pat->height();
             width  = dwidth;
             height = dheight;
             brush_classify(pat, 0, &pixbuf, &hatchType, &hatchColor, &bkColor);
@@ -573,8 +573,8 @@
         if (SP_IS_PATTERN(SP_STYLE_STROKE_SERVER(style))) { // must be paint-server
             SPPaintServer *paintserver = style->stroke.value.href->getObject();
             SPPattern *pat = SP_PATTERN(paintserver);
-            double dwidth  = pattern_width(pat);
-            double dheight = pattern_height(pat);
+            double dwidth  = pat->width();
+            double dheight = pat->height();
             width  = dwidth;
             height = dheight;
             brush_classify(pat, 0, &pixbuf, &hatchType, &hatchColor, &bkColor);

=== modified file 'src/extension/internal/wmf-print.cpp'
--- src/extension/internal/wmf-print.cpp	2015-04-27 18:49:22 +0000
+++ src/extension/internal/wmf-print.cpp	2015-05-17 12:22:15 +0000
@@ -380,8 +380,8 @@
         } else if (SP_IS_PATTERN(SP_STYLE_FILL_SERVER(style))) { // must be paint-server
             SPPaintServer *paintserver = style->fill.value.href->getObject();
             SPPattern *pat = SP_PATTERN(paintserver);
-            double dwidth  = pattern_width(pat);
-            double dheight = pattern_height(pat);
+            double dwidth  = pat->width();
+            double dheight = pat->height();
             width  = dwidth;
             height = dheight;
             brush_classify(pat, 0, &pixbuf, &hatchType, &hatchColor, &bkColor);

=== modified file 'src/extension/param/color.cpp'
--- src/extension/param/color.cpp	2015-04-27 23:38:31 +0000
+++ src/extension/param/color.cpp	2015-05-17 12:22:15 +0000
@@ -24,41 +24,37 @@
 #include "color.h"
 
 #include <color.h>
-#include "widgets/sp-color-selector.h"
-#include "widgets/sp-color-notebook.h"
+#include "ui/widget/color-notebook.h"
 #include "preferences.h"
 
-
 namespace Inkscape {
 namespace Extension {
 
-void sp_color_param_changed(SPColorSelector *csel, GObject *cp);
-
-
 ParamColor::~ParamColor(void)
 {
-
+    _color_changed.disconnect();
 }
 
 guint32 ParamColor::set( guint32 in, SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/ )
 {
-    _value = in;
+    _color_changed.block(true);
+    _color.setValue(in);
+    _color_changed.block(false);
 
     gchar * prefname = this->pref_name();
     std::string value;
     string(value);
-    
+
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     prefs->setString(extension_pref_root + prefname, value);
     g_free(prefname);
 
-    return _value;
+    return in;
 }
 
-ParamColor::ParamColor(const gchar *name, const gchar *guitext, const gchar *desc, const Parameter::_scope_t scope,
-                       bool gui_hidden, const gchar *gui_tip, Inkscape::Extension::Extension *ext,
-                       Inkscape::XML::Node *xml)
-    : Parameter(name, guitext, desc, scope, gui_hidden, gui_tip, ext), _value(0), _changeSignal(0)
+ParamColor::ParamColor (const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml) :
+    Parameter(name, guitext, desc, scope, gui_hidden, gui_tip, ext),
+    _changeSignal(0)
 {
     const char * defaulthex = NULL;
     if (xml->firstChild() != NULL)
@@ -72,51 +68,46 @@
     if (!paramval.empty())
         defaulthex = paramval.data();
 
-    if (defaulthex)
-        _value = atoi(defaulthex);
+    if (defaulthex) {
+        _color.setValue(atoi(defaulthex));
+    }
+    _color_changed = _color.signal_changed.connect(sigc::mem_fun(this, &ParamColor::_onColorChanged));
+
 }
 
 void ParamColor::string(std::string &string) const
 {
     char str[16];
-    sprintf(str, "%i", _value);
+    snprintf(str, 16, "%i", _color.value());
     string += str;
 }
 
 Gtk::Widget *ParamColor::get_widget( SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/, sigc::signal<void> * changeSignal )
 {
-    if (_gui_hidden) return NULL;
+    using Inkscape::UI::Widget::ColorNotebook;
+
+	if (_gui_hidden) return NULL;
 
     _changeSignal = new sigc::signal<void>(*changeSignal);
-    Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false, 4));
-    SPColorSelector* spColorSelector = (SPColorSelector*)sp_color_selector_new(SP_TYPE_COLOR_NOTEBOOK);
 
-    ColorSelector* colorSelector = spColorSelector->base;
-    if (_value < 1) {
-        _value = 0xFF000000;
+    if (_color.value() < 1) {
+        _color_changed.block(true);
+        _color.setValue(0xFF000000);
+        _color_changed.block(false);
     }
-    SPColor *color = new SPColor( _value );
-    float alpha = (_value & 0xff) / 255.0F;
-    colorSelector->setColorAlpha(*color, alpha);
-
-    hbox->pack_start (*Glib::wrap(&spColorSelector->vbox), true, true, 0);
-    g_signal_connect(G_OBJECT(spColorSelector), "changed",  G_CALLBACK(sp_color_param_changed), (void*)this);
-
-    gtk_widget_show(GTK_WIDGET(spColorSelector));
+
+    Gtk::HBox *hbox = Gtk::manage(new Gtk::HBox(false, 4));
+    Gtk::Widget *selector = Gtk::manage(new ColorNotebook(_color));
+    hbox->pack_start (*selector, true, true, 0);
+    selector->show();
     hbox->show();
-
-    return dynamic_cast<Gtk::Widget *>(hbox);
+    return hbox;
 }
 
-void sp_color_param_changed(SPColorSelector *csel, GObject *obj)
+void ParamColor::_onColorChanged()
 {
-    const SPColor color = csel->base->getColor();
-    float alpha = csel->base->getAlpha();
-
-    ParamColor* ptr = reinterpret_cast<ParamColor*>(obj);
-    ptr->set(color.toRGBA32( alpha ), NULL, NULL);
-
-    ptr->_changeSignal->emit();
+    if (_changeSignal)
+        _changeSignal->emit();
 }
 
 };  /* namespace Extension */

=== modified file 'src/extension/param/color.h'
--- src/extension/param/color.h	2012-02-29 01:16:51 +0000
+++ src/extension/param/color.h	2015-05-17 12:22:15 +0000
@@ -9,6 +9,7 @@
  */
 
 #include "parameter.h"
+#include "ui/selected-color.h"
 
 class SPDocument;
 
@@ -25,14 +26,17 @@
 
 class ParamColor : public Parameter {
 private:
-    guint32 _value;
+    void _onColorChanged();
+
+    Inkscape::UI::SelectedColor _color;
+    sigc::connection _color_changed;
 public:
     ParamColor(const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml);
 
     virtual ~ParamColor(void);
 
     /** Returns \c _value, with a \i const to protect it. */
-    guint32 get( SPDocument const * /*doc*/, Inkscape::XML::Node const * /*node*/ ) const { return _value; }
+    guint32 get( SPDocument const * /*doc*/, Inkscape::XML::Node const * /*node*/ ) const { return _color.value(); }
 
     guint32 set (guint32 in, SPDocument * doc, Inkscape::XML::Node * node);
 
@@ -44,6 +48,7 @@
     virtual void string (std::string &string) const;
 
     sigc::signal<void> * _changeSignal;
+
 }; // class ParamColor
 
 }  // namespace Extension

=== modified file 'src/extension/param/parameter.cpp'
--- src/extension/param/parameter.cpp	2014-03-27 01:33:44 +0000
+++ src/extension/param/parameter.cpp	2015-05-17 12:22:15 +0000
@@ -15,6 +15,10 @@
 # include "config.h"
 #endif
 
+#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H
+#include <glibmm/threads.h>
+#endif
+
 #ifdef linux  // does the dollar sign need escaping when passed as string parameter?
 # define ESCAPE_DOLLAR_COMMANDLINE
 #endif
@@ -26,8 +30,7 @@
 #include "document-private.h"
 #include "sp-object.h"
 #include <color.h>
-#include "widgets/sp-color-selector.h"
-#include "widgets/sp-color-notebook.h"
+#include "ui/widget/color-notebook.h"
 
 #include "parameter.h"
 #include "bool.h"

=== modified file 'src/knot-holder-entity.cpp'
--- src/knot-holder-entity.cpp	2014-08-04 16:10:37 +0000
+++ src/knot-holder-entity.cpp	2015-05-17 12:22:15 +0000
@@ -140,19 +140,19 @@
 
 static gdouble sp_pattern_extract_theta(SPPattern const *pat)
 {
-    Geom::Affine transf = pat->patternTransform;
+    Geom::Affine transf = pat->getTransform();
     return Geom::atan2(transf.xAxis());
 }
 
 static Geom::Point sp_pattern_extract_scale(SPPattern const *pat)
 {
-    Geom::Affine transf = pat->patternTransform;
+    Geom::Affine transf = pat->getTransform();
     return Geom::Point( transf.expansionX(), transf.expansionY() );
 }
 
 static Geom::Point sp_pattern_extract_trans(SPPattern const *pat)
 {
-    return Geom::Point(pat->patternTransform[4], pat->patternTransform[5]);
+    return Geom::Point(pat->getTransform()[4], pat->getTransform()[5]);
 }
 
 void
@@ -191,7 +191,7 @@
 {
     SPPattern *pat = _fill ? SP_PATTERN(item->style->getFillPaintServer()) : SP_PATTERN(item->style->getStrokePaintServer());
 
-    gdouble x = pattern_width(pat);
+    gdouble x = pat->width();
     gdouble y = 0;
     Geom::Point delta = Geom::Point(x,y);
     Geom::Point scale = sp_pattern_extract_scale(pat);
@@ -240,8 +240,8 @@
 
     // Get the new scale from the position of the knotholder
     Geom::Point d = p_snapped - sp_pattern_extract_trans(pat);
-    gdouble pat_x = pattern_width(pat);
-    gdouble pat_y = pattern_height(pat);
+    gdouble pat_x = pat->width();
+    gdouble pat_y = pat->height();
     Geom::Scale scl(1);
     if ( state & GDK_CONTROL_MASK ) {
         // if ctrl is pressed: use 1:1 scaling
@@ -267,10 +267,10 @@
 {
     SPPattern *pat = _fill ? SP_PATTERN(item->style->getFillPaintServer()) : SP_PATTERN(item->style->getStrokePaintServer());
 
-    gdouble x = pattern_width(pat);
-    gdouble y = pattern_height(pat);
+    gdouble x = pat->width();
+    gdouble y = pat->height();
     Geom::Point delta = Geom::Point(x,y);
-    Geom::Affine a = pat->patternTransform;
+    Geom::Affine a = pat->getTransform();
     a[4] = 0;
     a[5] = 0;
     delta = delta * a;

=== modified file 'src/selection-chemistry.cpp'
--- src/selection-chemistry.cpp	2015-05-09 12:59:00 +0000
+++ src/selection-chemistry.cpp	2015-05-17 12:22:15 +0000
@@ -1963,8 +1963,8 @@
                     }
 
                 } else if (dynamic_cast<SPPattern *>(sel_server) && dynamic_cast<SPPattern *>(iter_server)) {
-                    SPPattern *sel_pat = pattern_getroot(dynamic_cast<SPPattern *>(sel_server));
-                    SPPattern *iter_pat = pattern_getroot(dynamic_cast<SPPattern *>(iter_server));
+                    SPPattern *sel_pat = dynamic_cast<SPPattern *>(sel_server)->rootPattern();
+                    SPPattern *iter_pat = dynamic_cast<SPPattern *>(iter_server)->rootPattern();
                     if (sel_pat == iter_pat) {
                         match = true;
                     }
@@ -3312,7 +3312,7 @@
     int saved_compensation = prefs->getInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_UNMOVED);
     prefs->setInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_UNMOVED);
 
-    gchar const *pat_id = pattern_tile(repr_copies, bbox, doc,
+    gchar const *pat_id = SPPattern::produce(repr_copies, bbox, doc,
                                        ( Geom::Affine(Geom::Translate(desktop->dt2doc(Geom::Point(r->min()[Geom::X],
                                                                                             r->max()[Geom::Y]))))
                                          * parent_transform.inverse() ),
@@ -3390,9 +3390,9 @@
 
         did = true;
 
-        SPPattern *pattern = pattern_getroot(basePat);
+        SPPattern *pattern = basePat->rootPattern();
 
-        Geom::Affine pat_transform = pattern_patternTransform(basePat);
+        Geom::Affine pat_transform = basePat->getTransform();
         pat_transform *= item->transform;
 
         for (SPObject *child = pattern->firstChild() ; child != NULL; child = child->next ) {

=== modified file 'src/sp-item.cpp'
--- src/sp-item.cpp	2015-05-10 21:55:55 +0000
+++ src/sp-item.cpp	2015-05-17 12:22:15 +0000
@@ -1222,8 +1222,8 @@
         SPObject *server = style->getFillPaintServer();
         SPPattern *serverPatt = dynamic_cast<SPPattern *>(server);
         if ( serverPatt ) {
-            SPPattern *pattern = sp_pattern_clone_if_necessary(this, serverPatt, "fill");
-            sp_pattern_transform_multiply(pattern, postmul, set);
+            SPPattern *pattern = serverPatt->clone_if_necessary(this, "fill");
+            pattern->transform_multiply(postmul, set);
         }
     }
 
@@ -1232,8 +1232,8 @@
         SPObject *server = style->getStrokePaintServer();
         SPPattern *serverPatt = dynamic_cast<SPPattern *>(server);
         if ( serverPatt ) {
-            SPPattern *pattern = sp_pattern_clone_if_necessary(this, serverPatt, "stroke");
-            sp_pattern_transform_multiply(pattern, postmul, set);
+            SPPattern *pattern = serverPatt->clone_if_necessary(this, "stroke");
+            pattern->transform_multiply(postmul, set);
         }
     }
 }

=== modified file 'src/sp-pattern.cpp'
--- src/sp-pattern.cpp	2015-04-26 09:44:42 +0000
+++ src/sp-pattern.cpp	2015-05-17 12:22:15 +0000
@@ -5,7 +5,7 @@
  *   Lauris Kaplinski <[e-mail]>
  *   bulia byak <[e-mail]>
  *   Jon A. Cruz <[e-mail]>
- *   Abhishek Sharma 
+ *   Abhishek Sharma
  *
  * Copyright (C) 2002 Lauris Kaplinski
  *
@@ -13,15 +13,15 @@
  */
 
 #ifdef HAVE_CONFIG_H
-# include "config.h"
+#include "config.h"
 #endif
 
 #include <cstring>
 #include <string>
 #include <glibmm.h>
 #include <2geom/transforms.h>
+#include <sigc++/functors/mem_fun.h>
 
-#include "macros.h"
 #include "svg/svg.h"
 #include "display/cairo-utils.h"
 #include "display/drawing-context.h"
@@ -34,67 +34,61 @@
 #include "style.h"
 #include "sp-pattern.h"
 #include "xml/repr.h"
-#include "display/grayscale.h"
-
-#include <sigc++/functors/ptr_fun.h>
-#include <sigc++/adaptors/bind.h>
-
-/*
- * Pattern
- */
-static void pattern_ref_changed(SPObject *old_ref, SPObject *ref, SPPattern *pat);
-static void pattern_ref_modified (SPObject *ref, guint flags, SPPattern *pattern);
-
-SPPattern::SPPattern() : SPPaintServer(), SPViewBox() {
-	this->href = NULL;
-
-	this->ref = new SPPatternReference(this);
-	this->ref->changedSignal().connect(sigc::bind(sigc::ptr_fun(pattern_ref_changed), this));
-
-	this->patternUnits = SP_PATTERN_UNITS_OBJECTBOUNDINGBOX;
-	this->patternUnits_set = FALSE;
-
-	this->patternContentUnits = SP_PATTERN_UNITS_USERSPACEONUSE;
-	this->patternContentUnits_set = FALSE;
-
-	this->patternTransform = Geom::identity();
-	this->patternTransform_set = FALSE;
-
-	this->x.unset();
-	this->y.unset();
-	this->width.unset();
-	this->height.unset();
-}
-
-SPPattern::~SPPattern() {
-}
-
-void SPPattern::build(SPDocument* doc, Inkscape::XML::Node* repr) {
-	SPPaintServer::build(doc, repr);
-
-	this->readAttr( "patternUnits" );
-	this->readAttr( "patternContentUnits" );
-	this->readAttr( "patternTransform" );
-	this->readAttr( "x" );
-	this->readAttr( "y" );
-	this->readAttr( "width" );
-	this->readAttr( "height" );
-	this->readAttr( "viewBox" );
-        this->readAttr( "preserveAspectRatio" );
-	this->readAttr( "xlink:href" );
-
-	/* Register ourselves */
-	doc->addResource("pattern", this);
-}
-
-void SPPattern::release() {
+
+#include "sp-factory.h"
+
+SPPattern::SPPattern()
+    : SPPaintServer()
+    , SPViewBox()
+{
+    this->ref = new SPPatternReference(this);
+    this->ref->changedSignal().connect(sigc::mem_fun(this, &SPPattern::_onRefChanged));
+
+    this->_pattern_units = UNITS_OBJECTBOUNDINGBOX;
+    this->_pattern_units_set = false;
+
+    this->_pattern_content_units = UNITS_USERSPACEONUSE;
+    this->_pattern_content_units_set = false;
+
+    this->_pattern_transform = Geom::identity();
+    this->_pattern_transform_set = false;
+
+    this->_x.unset();
+    this->_y.unset();
+    this->_width.unset();
+    this->_height.unset();
+}
+
+SPPattern::~SPPattern() {}
+
+void SPPattern::build(SPDocument *doc, Inkscape::XML::Node *repr)
+{
+    SPPaintServer::build(doc, repr);
+
+    this->readAttr("patternUnits");
+    this->readAttr("patternContentUnits");
+    this->readAttr("patternTransform");
+    this->readAttr("x");
+    this->readAttr("y");
+    this->readAttr("width");
+    this->readAttr("height");
+    this->readAttr("viewBox");
+    this->readAttr("preserveAspectRatio");
+    this->readAttr("xlink:href");
+
+    /* Register ourselves */
+    doc->addResource("pattern", this);
+}
+
+void SPPattern::release()
+{
     if (this->document) {
         // Unregister ourselves
         this->document->removeResource("pattern", this);
     }
 
     if (this->ref) {
-        this->modified_connection.disconnect();
+        this->_modified_connection.disconnect();
         this->ref->detach();
         delete this->ref;
         this->ref = NULL;
@@ -103,113 +97,121 @@
     SPPaintServer::release();
 }
 
-void SPPattern::set(unsigned int key, const gchar* value) {
-	switch (key) {
-	case SP_ATTR_PATTERNUNITS:
-		if (value) {
-			if (!strcmp (value, "userSpaceOnUse")) {
-				this->patternUnits = SP_PATTERN_UNITS_USERSPACEONUSE;
-			} else {
-				this->patternUnits = SP_PATTERN_UNITS_OBJECTBOUNDINGBOX;
-			}
-
-			this->patternUnits_set = TRUE;
-		} else {
-			this->patternUnits_set = FALSE;
-		}
-
-		this->requestModified(SP_OBJECT_MODIFIED_FLAG);
-		break;
-
-	case SP_ATTR_PATTERNCONTENTUNITS:
-		if (value) {
-			if (!strcmp (value, "userSpaceOnUse")) {
-				this->patternContentUnits = SP_PATTERN_UNITS_USERSPACEONUSE;
-			} else {
-				this->patternContentUnits = SP_PATTERN_UNITS_OBJECTBOUNDINGBOX;
-			}
-
-			this->patternContentUnits_set = TRUE;
-		} else {
-			this->patternContentUnits_set = FALSE;
-		}
-
-		this->requestModified(SP_OBJECT_MODIFIED_FLAG);
-		break;
-
-	case SP_ATTR_PATTERNTRANSFORM: {
-		Geom::Affine t;
-
-		if (value && sp_svg_transform_read (value, &t)) {
-			this->patternTransform = t;
-			this->patternTransform_set = TRUE;
-		} else {
-			this->patternTransform = Geom::identity();
-			this->patternTransform_set = FALSE;
-		}
-
-		this->requestModified(SP_OBJECT_MODIFIED_FLAG);
-		break;
-	}
-	case SP_ATTR_X:
-	    this->x.readOrUnset(value);
-		this->requestModified(SP_OBJECT_MODIFIED_FLAG);
-		break;
-
-	case SP_ATTR_Y:
-	    this->y.readOrUnset(value);
-		this->requestModified(SP_OBJECT_MODIFIED_FLAG);
-		break;
-
-	case SP_ATTR_WIDTH:
-	    this->width.readOrUnset(value);
-		this->requestModified(SP_OBJECT_MODIFIED_FLAG);
-		break;
-
-	case SP_ATTR_HEIGHT:
-	    this->height.readOrUnset(value);
-		this->requestModified(SP_OBJECT_MODIFIED_FLAG);
-		break;
-
-	case SP_ATTR_VIEWBOX:
-            set_viewBox( value );
+void SPPattern::set(unsigned int key, const gchar *value)
+{
+    switch (key) {
+        case SP_ATTR_PATTERNUNITS:
+            if (value) {
+                if (!strcmp(value, "userSpaceOnUse")) {
+                    this->_pattern_units = UNITS_USERSPACEONUSE;
+                }
+                else {
+                    this->_pattern_units = UNITS_OBJECTBOUNDINGBOX;
+                }
+
+                this->_pattern_units_set = true;
+            }
+            else {
+                this->_pattern_units_set = false;
+            }
+
+            this->requestModified(SP_OBJECT_MODIFIED_FLAG);
+            break;
+
+        case SP_ATTR_PATTERNCONTENTUNITS:
+            if (value) {
+                if (!strcmp(value, "userSpaceOnUse")) {
+                    this->_pattern_content_units = UNITS_USERSPACEONUSE;
+                }
+                else {
+                    this->_pattern_content_units = UNITS_OBJECTBOUNDINGBOX;
+                }
+
+                this->_pattern_content_units_set = true;
+            }
+            else {
+                this->_pattern_content_units_set = false;
+            }
+
+            this->requestModified(SP_OBJECT_MODIFIED_FLAG);
+            break;
+
+        case SP_ATTR_PATTERNTRANSFORM: {
+            Geom::Affine t;
+
+            if (value && sp_svg_transform_read(value, &t)) {
+                this->_pattern_transform = t;
+                this->_pattern_transform_set = true;
+            }
+            else {
+                this->_pattern_transform = Geom::identity();
+                this->_pattern_transform_set = false;
+            }
+
+            this->requestModified(SP_OBJECT_MODIFIED_FLAG);
+            break;
+        }
+        case SP_ATTR_X:
+            this->_x.readOrUnset(value);
+            this->requestModified(SP_OBJECT_MODIFIED_FLAG);
+            break;
+
+        case SP_ATTR_Y:
+            this->_y.readOrUnset(value);
+            this->requestModified(SP_OBJECT_MODIFIED_FLAG);
+            break;
+
+        case SP_ATTR_WIDTH:
+            this->_width.readOrUnset(value);
+            this->requestModified(SP_OBJECT_MODIFIED_FLAG);
+            break;
+
+        case SP_ATTR_HEIGHT:
+            this->_height.readOrUnset(value);
+            this->requestModified(SP_OBJECT_MODIFIED_FLAG);
+            break;
+
+        case SP_ATTR_VIEWBOX:
+            set_viewBox(value);
             this->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_VIEWPORT_MODIFIED_FLAG);
             break;
 
         case SP_ATTR_PRESERVEASPECTRATIO:
-            set_preserveAspectRatio( value );
+            set_preserveAspectRatio(value);
             this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_VIEWPORT_MODIFIED_FLAG);
             break;
 
-	case SP_ATTR_XLINK_HREF:
-		if ( value && this->href && ( strcmp(value, this->href) == 0 ) ) {
-			/* Href unchanged, do nothing. */
-		} else {
-			g_free(this->href);
-			this->href = NULL;
-
-			if (value) {
-				// First, set the href field; it's only used in the "unchanged" check above.
-				this->href = g_strdup(value);
-				// Now do the attaching, which emits the changed signal.
-				if (value) {
-					try {
-						this->ref->attach(Inkscape::URI(value));
-					} catch (Inkscape::BadURIException &e) {
-						g_warning("%s", e.what());
-						this->ref->detach();
-					}
-				} else {
-					this->ref->detach();
-				}
-			}
-		}
-		break;
-
-	default:
-		SPPaintServer::set(key, value);
-		break;
-	}
+        case SP_ATTR_XLINK_HREF:
+            if (value && this->href == value) {
+                /* Href unchanged, do nothing. */
+            }
+            else {
+                this->href.clear();
+
+                if (value) {
+                    // First, set the href field; it's only used in the "unchanged" check above.
+                    this->href = value;
+                    // Now do the attaching, which emits the changed signal.
+                    if (value) {
+                        try {
+                            this->ref->attach(Inkscape::URI(value));
+                        }
+                        catch (Inkscape::BadURIException &e) {
+                            g_warning("%s", e.what());
+                            this->ref->detach();
+                        }
+                    }
+                    else {
+                        this->ref->detach();
+                    }
+                }
+            }
+            break;
+
+        default:
+            SPPaintServer::set(key, value);
+            break;
+    }
 }
 
 
@@ -217,104 +219,90 @@
 
 /* fixme: We need ::order_changed handler too (Lauris) */
 
-static GSList *pattern_getchildren(SPPattern *pat)
+void SPPattern::_getChildren(std::list<SPObject *> &l)
 {
-    GSList *l = NULL;
-
-    for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
+    for (SPPattern *pat_i = this; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
         if (pat_i->firstChild()) { // find the first one with children
-			for (SPObject *child = pat->firstChild() ; child ; child = child->getNext() ) {
-				l = g_slist_prepend (l, child);
-			}
-			break; // do not go further up the chain if children are found
-        }
-    }
-
-    return l;
-}
-
-void SPPattern::update(SPCtx* ctx, unsigned int flags) {
-	if (flags & SP_OBJECT_MODIFIED_FLAG) {
-		flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
-	}
-
-	flags &= SP_OBJECT_MODIFIED_CASCADE;
-
-	GSList *l = pattern_getchildren (this);
-	l = g_slist_reverse (l);
-
-	while (l) {
-		SPObject *child = SP_OBJECT (l->data);
-
-		sp_object_ref (child, NULL);
-		l = g_slist_remove (l, child);
-
-		if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
-			child->updateDisplay(ctx, flags);
-		}
-
-		sp_object_unref (child, NULL);
-	}
-}
-
-void SPPattern::modified(unsigned int flags) {
-	if (flags & SP_OBJECT_MODIFIED_FLAG) {
-		flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
-	}
-
-	flags &= SP_OBJECT_MODIFIED_CASCADE;
-
-	GSList *l = pattern_getchildren (this);
-	l = g_slist_reverse (l);
-
-	while (l) {
-		SPObject *child = SP_OBJECT (l->data);
-
-		sp_object_ref (child, NULL);
-		l = g_slist_remove (l, child);
-
-		if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
-			child->emitModified(flags);
-		}
-
-		sp_object_unref (child, NULL);
-	}
-}
-
-/**
-Gets called when the pattern is reattached to another <pattern>
-*/
-static void
-pattern_ref_changed(SPObject *old_ref, SPObject *ref, SPPattern *pat)
-{
-	if (old_ref) {
-		pat->modified_connection.disconnect();
-	}
-
-	if (SP_IS_PATTERN (ref)) {
-		pat->modified_connection = ref->connectModified(sigc::bind<2>(sigc::ptr_fun(&pattern_ref_modified), pat));
-	}
-
-    pattern_ref_modified (ref, 0, pat);
-}
-
-/**
-Gets called when the referenced <pattern> is changed
-*/
-static void pattern_ref_modified (SPObject */*ref*/, guint /*flags*/, SPPattern *pattern)
-{
-    if ( SP_IS_OBJECT(pattern) ) {
-        pattern->requestModified(SP_OBJECT_MODIFIED_FLAG);
-    }
+            for (SPObject *child = pat_i->firstChild(); child; child = child->getNext()) {
+                l.push_back(child);
+            }
+            break; // do not go further up the chain if children are found
+        }
+    }
+}
+
+void SPPattern::update(SPCtx *ctx, unsigned int flags)
+{
+    typedef std::list<SPObject *>::iterator SPObjectIterator;
+
+    if (flags & SP_OBJECT_MODIFIED_FLAG) {
+        flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
+    }
+
+    flags &= SP_OBJECT_MODIFIED_CASCADE;
+
+    std::list<SPObject *> l;
+    _getChildren(l);
+
+    for (SPObjectIterator it = l.begin(); it != l.end(); it++) {
+        SPObject *child = *it;
+
+        sp_object_ref(child, NULL);
+
+        if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
+            child->updateDisplay(ctx, flags);
+        }
+
+        sp_object_unref(child, NULL);
+    }
+}
+
+void SPPattern::modified(unsigned int flags)
+{
+    typedef std::list<SPObject *>::iterator SPObjectIterator;
+
+    if (flags & SP_OBJECT_MODIFIED_FLAG) {
+        flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
+    }
+
+    flags &= SP_OBJECT_MODIFIED_CASCADE;
+
+    std::list<SPObject *> l;
+    _getChildren(l);
+
+    for (SPObjectIterator it = l.begin(); it != l.end(); it++) {
+        SPObject *child = *it;
+
+        sp_object_ref(child, NULL);
+
+        if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
+            child->emitModified(flags);
+        }
+
+        sp_object_unref(child, NULL);
+    }
+}
+
+void SPPattern::_onRefChanged(SPObject *old_ref, SPObject *ref)
+{
+    if (old_ref) {
+        _modified_connection.disconnect();
+    }
+
+    if (SP_IS_PATTERN(ref)) {
+        _modified_connection = ref->connectModified(sigc::mem_fun(this, &SPPattern::_onRefModified));
+    }
+
+    _onRefModified(ref, 0);
+}
+
+void SPPattern::_onRefModified(SPObject * /*ref*/, guint /*flags*/)
+{
+    requestModified(SP_OBJECT_MODIFIED_FLAG);
     // Conditional to avoid causing infinite loop if there's a cycle in the href chain.
 }
 
-
-/**
-Count how many times pat is used by the styles of o and its descendants
-*/
-static guint
-count_pattern_hrefs(SPObject *o, SPPattern *pat)
+guint SPPattern::_countHrefs(SPObject *o) const
 {
     if (!o)
         return 1;
@@ -322,84 +310,79 @@
     guint i = 0;
 
     SPStyle *style = o->style;
-    if (style
-        && style->fill.isPaintserver()
-        && SP_IS_PATTERN(SP_STYLE_FILL_SERVER(style))
-        && SP_PATTERN(SP_STYLE_FILL_SERVER(style)) == pat)
-    {
-        i ++;
+    if (style && style->fill.isPaintserver() && SP_IS_PATTERN(SP_STYLE_FILL_SERVER(style)) &&
+        SP_PATTERN(SP_STYLE_FILL_SERVER(style)) == this) {
+        i++;
     }
-    if (style
-        && style->stroke.isPaintserver()
-        && SP_IS_PATTERN(SP_STYLE_STROKE_SERVER(style))
-        && SP_PATTERN(SP_STYLE_STROKE_SERVER(style)) == pat)
-    {
-        i ++;
+    if (style && style->stroke.isPaintserver() && SP_IS_PATTERN(SP_STYLE_STROKE_SERVER(style)) &&
+        SP_PATTERN(SP_STYLE_STROKE_SERVER(style)) == this) {
+        i++;
     }
 
-    for ( SPObject *child = o->firstChild(); child != NULL; child = child->next ) {
-        i += count_pattern_hrefs(child, pat);
+    for (SPObject *child = o->firstChild(); child != NULL; child = child->next) {
+        i += _countHrefs(child);
     }
 
     return i;
 }
 
-SPPattern *pattern_chain(SPPattern *pattern)
+SPPattern *SPPattern::_chain() const
 {
-    SPDocument *document = pattern->document;
-        Inkscape::XML::Document *xml_doc = document->getReprDoc();
+    Inkscape::XML::Document *xml_doc = document->getReprDoc();
     Inkscape::XML::Node *defsrepr = document->getDefs()->getRepr();
 
     Inkscape::XML::Node *repr = xml_doc->createElement("svg:pattern");
     repr->setAttribute("inkscape:collect", "always");
-    gchar *parent_ref = g_strconcat("#", pattern->getRepr()->attribute("id"), NULL);
-    repr->setAttribute("xlink:href",  parent_ref);
-    g_free (parent_ref);
+    Glib::ustring parent_ref = Glib::ustring::compose("#%1", getRepr()->attribute("id"));
+    repr->setAttribute("xlink:href", parent_ref);
 
     defsrepr->addChild(repr, NULL);
     const gchar *child_id = repr->attribute("id");
     SPObject *child = document->getObjectById(child_id);
-    g_assert (SP_IS_PATTERN (child));
+    g_assert(SP_IS_PATTERN(child));
 
-    return SP_PATTERN (child);
+    return SP_PATTERN(child);
 }
 
-SPPattern *
-sp_pattern_clone_if_necessary (SPItem *item, SPPattern *pattern, const gchar *property)
+SPPattern *SPPattern::clone_if_necessary(SPItem *item, const gchar *property)
 {
-    if (!pattern->href || pattern->hrefcount > count_pattern_hrefs(item, pattern)) {
-        pattern = pattern_chain (pattern);
-        gchar *href = g_strconcat("url(#", pattern->getRepr()->attribute("id"), ")", NULL);
+    SPPattern *pattern = this;
+    if (pattern->href.empty() || pattern->hrefcount > _countHrefs(item)) {
+        pattern = _chain();
+        Glib::ustring href = Glib::ustring::compose("url(#%1)", pattern->getRepr()->attribute("id"));
 
-        SPCSSAttr *css = sp_repr_css_attr_new ();
-        sp_repr_css_set_property (css, property, href);
+        SPCSSAttr *css = sp_repr_css_attr_new();
+        sp_repr_css_set_property(css, property, href.c_str());
         sp_repr_css_change_recursive(item->getRepr(), css, "style");
     }
     return pattern;
 }
 
-void
-sp_pattern_transform_multiply (SPPattern *pattern, Geom::Affine postmul, bool set)
+void SPPattern::transform_multiply(Geom::Affine postmul, bool set)
 {
     // this formula is for a different interpretation of pattern transforms as described in (*) in sp-pattern.cpp
     // for it to work, we also need    sp_object_read_attr( item, "transform");
-    //pattern->patternTransform = premul * item->transform * pattern->patternTransform * item->transform.inverse() * postmul;
+    // pattern->patternTransform = premul * item->transform * pattern->patternTransform * item->transform.inverse() *
+    // postmul;
 
     // otherwise the formula is much simpler
     if (set) {
-        pattern->patternTransform = postmul;
-    } else {
-        pattern->patternTransform = pattern_patternTransform(pattern) * postmul;
-    }
-    pattern->patternTransform_set = TRUE;
+        _pattern_transform = postmul;
+    }
+    else {
+        _pattern_transform = getTransform() * postmul;
+    }
+    _pattern_transform_set = true;
 
-    gchar *c=sp_svg_transform_write(pattern->patternTransform);
-    pattern->getRepr()->setAttribute("patternTransform", c);
-    g_free(c);
+    Glib::ustring c = sp_svg_transform_write(_pattern_transform);
+    getRepr()->setAttribute("patternTransform", c);
 }
 
-const gchar *pattern_tile(const std::vector<Inkscape::XML::Node*> &reprs, Geom::Rect bounds, SPDocument *document, Geom::Affine transform, Geom::Affine move)
+const gchar *SPPattern::produce(const std::vector<Inkscape::XML::Node *> &reprs, Geom::Rect bounds,
+                                SPDocument *document, Geom::Affine transform, Geom::Affine move)
 {
+    typedef std::vector<Inkscape::XML::Node *>::const_iterator NodePtrIterator;
+
     Inkscape::XML::Document *xml_doc = document->getReprDoc();
     Inkscape::XML::Node *defsrepr = document->getDefs()->getRepr();
 
@@ -408,20 +391,19 @@
     sp_repr_set_svg_double(repr, "width", bounds.dimensions()[Geom::X]);
     sp_repr_set_svg_double(repr, "height", bounds.dimensions()[Geom::Y]);
 
-    gchar *t=sp_svg_transform_write(transform);
+    Glib::ustring t = sp_svg_transform_write(transform);
     repr->setAttribute("patternTransform", t);
-    g_free(t);
 
     defsrepr->appendChild(repr);
     const gchar *pat_id = repr->attribute("id");
     SPObject *pat_object = document->getObjectById(pat_id);
 
-    for (std::vector<Inkscape::XML::Node*>::const_iterator i=reprs.begin();i!=reprs.end();i++){
+    for (NodePtrIterator i = reprs.begin(); i != reprs.end(); i++) {
         Inkscape::XML::Node *node = *i;
         SPItem *copy = SP_ITEM(pat_object->appendChildRepr(node));
 
         Geom::Affine dup_transform;
-        if (!sp_svg_transform_read (node->attribute("transform"), &dup_transform))
+        if (!sp_svg_transform_read(node->attribute("transform"), &dup_transform))
             dup_transform = Geom::identity();
         dup_transform *= move;
 
@@ -432,14 +414,15 @@
     return pat_id;
 }
 
-SPPattern *pattern_getroot(SPPattern *pat)
+SPPattern *SPPattern::rootPattern()
 {
-    for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
-        if ( pat_i->firstChild() ) { // find the first one with children
+    for (SPPattern *pat_i = this; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
+        if (pat_i->firstChild()) { // find the first one with children
             return pat_i;
         }
     }
-    return pat; // document is broken, we can't get to root; but at least we can return pat which is supposedly a valid pattern
+    return this; // document is broken, we can't get to root; but at least we can return pat which is supposedly a valid
+                 // pattern
 }
 
 
@@ -447,73 +430,73 @@
 // Access functions that look up fields up the chain of referenced patterns and return the first one which is set
 // FIXME: all of them must use chase_hrefs the same as in SPGradient, to avoid lockup on circular refs
 
-guint pattern_patternUnits (SPPattern const *pat)
-{
-    for (SPPattern const *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
-        if (pat_i->patternUnits_set)
-            return pat_i->patternUnits;
-    }
-    return pat->patternUnits;
-}
-
-guint pattern_patternContentUnits (SPPattern const *pat)
-{
-    for (SPPattern const *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
-        if (pat_i->patternContentUnits_set)
-            return pat_i->patternContentUnits;
-    }
-    return pat->patternContentUnits;
-}
-
-Geom::Affine const &pattern_patternTransform(SPPattern const *pat)
-{
-    for (SPPattern const *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
-        if (pat_i->patternTransform_set)
-            return pat_i->patternTransform;
-    }
-    return pat->patternTransform;
-}
-
-gdouble pattern_x (SPPattern const *pat)
-{
-    for (SPPattern const *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
-        if (pat_i->x._set)
-            return pat_i->x.computed;
-    }
-    return 0;
-}
-
-gdouble pattern_y (SPPattern const *pat)
-{
-    for (SPPattern const *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
-        if (pat_i->y._set)
-            return pat_i->y.computed;
-    }
-    return 0;
-}
-
-gdouble pattern_width (SPPattern const* pat)
-{
-    for (SPPattern const *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
-        if (pat_i->width._set)
-            return pat_i->width.computed;
-    }
-    return 0;
-}
-
-gdouble pattern_height (SPPattern const *pat)
-{
-    for (SPPattern const *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
-        if (pat_i->height._set)
-            return pat_i->height.computed;
-    }
-    return 0;
-}
-
-Geom::OptRect pattern_viewBox (SPPattern const *pat)
+SPPattern::PatternUnits SPPattern::patternUnits() const
+{
+    for (SPPattern const *pat_i = this; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
+        if (pat_i->_pattern_units_set)
+            return pat_i->_pattern_units;
+    }
+    return _pattern_units;
+}
+
+SPPattern::PatternUnits SPPattern::patternContentUnits() const
+{
+    for (SPPattern const *pat_i = this; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
+        if (pat_i->_pattern_content_units_set)
+            return pat_i->_pattern_content_units;
+    }
+    return _pattern_content_units;
+}
+
+Geom::Affine const &SPPattern::getTransform() const
+{
+    for (SPPattern const *pat_i = this; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
+        if (pat_i->_pattern_transform_set)
+            return pat_i->_pattern_transform;
+    }
+    return _pattern_transform;
+}
+
+gdouble SPPattern::x() const
+{
+    for (SPPattern const *pat_i = this; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
+        if (pat_i->_x._set)
+            return pat_i->_x.computed;
+    }
+    return 0;
+}
+
+gdouble SPPattern::y() const
+{
+    for (SPPattern const *pat_i = this; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
+        if (pat_i->_y._set)
+            return pat_i->_y.computed;
+    }
+    return 0;
+}
+
+gdouble SPPattern::width() const
+{
+    for (SPPattern const *pat_i = this; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
+        if (pat_i->_width._set)
+            return pat_i->_width.computed;
+    }
+    return 0;
+}
+
+gdouble SPPattern::height() const
+{
+    for (SPPattern const *pat_i = this; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
+        if (pat_i->_height._set)
+            return pat_i->_height.computed;
+    }
+    return 0;
+}
+
+Geom::OptRect SPPattern::viewbox() const
 {
     Geom::OptRect viewbox;
-    for (SPPattern const *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
+    for (SPPattern const *pat_i = this; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
         if (pat_i->viewBox_set) {
             viewbox = pat_i->viewBox;
             break;
@@ -522,10 +505,10 @@
     return viewbox;
 }
 
-static bool pattern_hasItemChildren (SPPattern const *pat)
+bool SPPattern::_hasItemChildren() const
 {
     bool hasChildren = false;
-    for (SPObject const *child = pat->firstChild() ; child && !hasChildren ; child = child->getNext() ) {
+    for (SPObject const *child = firstChild(); child && !hasChildren; child = child->getNext()) {
         if (SP_IS_ITEM(child)) {
             hasChildren = true;
         }
@@ -535,15 +518,16 @@
 
 bool SPPattern::isValid() const
 {
-	double tile_width = pattern_width(this);
-	double tile_height = pattern_height(this);
+    double tile_width = width();
+    double tile_height = height();
 
-	if (tile_width <= 0 || tile_height <= 0)
-		return false;
-	return true;
+    if (tile_width <= 0 || tile_height <= 0)
+        return false;
+    return true;
 }
 
-cairo_pattern_t* SPPattern::pattern_new(cairo_t *base_ct, Geom::OptRect const &bbox, double opacity) {
+cairo_pattern_t *SPPattern::pattern_new(cairo_t *base_ct, Geom::OptRect const &bbox, double opacity)
+{
 
     bool needs_opacity = (1.0 - opacity) >= 1e-3;
     bool visible = opacity >= 1e-3;
@@ -557,28 +541,28 @@
 
     for (SPPattern *pat_i = this; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
         // find the first one with item children
-        if (pat_i && SP_IS_OBJECT(pat_i) && pattern_hasItemChildren(pat_i)) {
+        if (pat_i && SP_IS_OBJECT(pat_i) && pat_i->_hasItemChildren()) {
             shown = pat_i;
             break; // do not go further up the chain if children are found
         }
     }
 
     if (!shown) {
-        return cairo_pattern_create_rgba(0,0,0,0);
+        return cairo_pattern_create_rgba(0, 0, 0, 0);
     }
 
     /* Create drawing for rendering */
     Inkscape::Drawing drawing;
-    unsigned int dkey = SPItem::display_key_new (1);
+    unsigned int dkey = SPItem::display_key_new(1);
     Inkscape::DrawingGroup *root = new Inkscape::DrawingGroup(drawing);
     drawing.setRoot(root);
 
-    for (SPObject *child = shown->firstChild(); child != NULL; child = child->getNext() ) {
-        if (SP_IS_ITEM (child)) {
+    for (SPObject *child = shown->firstChild(); child != NULL; child = child->getNext()) {
+        if (SP_IS_ITEM(child)) {
             // for each item in pattern, show it on our drawing, add to the group,
             // and connect to the release signal in case the item gets deleted
             Inkscape::DrawingItem *cai;
-            cai = SP_ITEM(child)->invoke_show (drawing, dkey, SP_ITEM_SHOW_DISPLAY);
+            cai = SP_ITEM(child)->invoke_show(drawing, dkey, SP_ITEM_SHOW_DISPLAY);
             root->appendChild(cai);
         }
     }
@@ -591,40 +575,41 @@
     // * "x", "y", and "patternTransform" transform tile to user space after tile is generated.
 
     // These functions recursively search up the tree to find the values.
-    double tile_x      = pattern_x(this);
-    double tile_y      = pattern_y(this);
-    double tile_width  = pattern_width(this);
-    double tile_height = pattern_height(this);
-    if ( bbox && (pattern_patternUnits(this) == SP_PATTERN_UNITS_OBJECTBOUNDINGBOX) ) {
-        tile_x      *= bbox->width();
-        tile_y      *= bbox->height();
-        tile_width  *= bbox->width();
+    double tile_x = x();
+    double tile_y = y();
+    double tile_width = width();
+    double tile_height = height();
+    if (bbox && (patternUnits() == UNITS_OBJECTBOUNDINGBOX)) {
+        tile_x *= bbox->width();
+        tile_y *= bbox->height();
+        tile_width *= bbox->width();
         tile_height *= bbox->height();
     }
 
     // Pattern size in pattern space
     Geom::Rect pattern_tile = Geom::Rect::from_xywh(0, 0, tile_width, tile_height);
- 
+
     // Content to tile (pattern space)
     Geom::Affine content2ps;
-    Geom::OptRect effective_view_box = pattern_viewBox(this);
+    Geom::OptRect effective_view_box = viewbox();
     if (effective_view_box) {
-        // viewBox to pattern server (using SPViewBox) 
+        // viewBox to pattern server (using SPViewBox)
         viewBox = *effective_view_box;
         c2p.setIdentity();
-        apply_viewbox( pattern_tile );
+        apply_viewbox(pattern_tile);
         content2ps = c2p;
-    } else {
+    }
+    else {
 
         // Content to bbox
-        if (bbox && (pattern_patternContentUnits(this) == SP_PATTERN_UNITS_OBJECTBOUNDINGBOX) ) {
-            content2ps = Geom::Affine(bbox->width(), 0.0, 0.0, bbox->height(), 0,0);
+        if (bbox && (patternContentUnits() == UNITS_OBJECTBOUNDINGBOX)) {
+            content2ps = Geom::Affine(bbox->width(), 0.0, 0.0, bbox->height(), 0, 0);
         }
     }
 
 
     // Tile (pattern space) to user.
-    Geom::Affine ps2user = Geom::Translate(tile_x,tile_y) * pattern_patternTransform(this);
+    Geom::Affine ps2user = Geom::Translate(tile_x, tile_y) * getTransform();
 
 
     // Transform of object with pattern (includes screen scaling)
@@ -644,7 +629,7 @@
     //       to find the optimum tile size for rendering
     // c is number of pixels in buffer x and y.
     // Scale factor of 1.1 is too small... see bug #1251039
-    Geom::Point c(pattern_tile.dimensions()*ps2user.descrim()*full.descrim()*2.0);
+    Geom::Point c(pattern_tile.dimensions() * ps2user.descrim() * full.descrim() * 2.0);
 
     // Create drawing surface with size of pattern tile (in pattern space) but with number of pixels
     // based on required resolution (c).
@@ -660,16 +645,16 @@
     }
 
     // TODO: make sure there are no leaks.
-    Inkscape::UpdateContext ctx;  // UpdateContext is structure with only ctm!
+    Inkscape::UpdateContext ctx; // UpdateContext is structure with only ctm!
     ctx.ctm = content2ps * pattern_surface.drawingTransform();
-    dc.transform( pattern_surface.drawingTransform().inverse() );
+    dc.transform(pattern_surface.drawingTransform().inverse());
     drawing.update(Geom::IntRect::infinite(), ctx);
 
     // Render drawing to pattern_surface via drawing context, this calls root->render
     // which is really DrawingItem->render().
     drawing.render(dc, one_tile);
-    for (SPObject *child = shown->firstChild() ; child != NULL; child = child->getNext() ) {
-        if (SP_IS_ITEM (child)) {
+    for (SPObject *child = shown->firstChild(); child != NULL; child = child->getNext()) {
+        if (SP_IS_ITEM(child)) {
             SP_ITEM(child)->invoke_hide(dkey);
         }
     }
@@ -685,12 +670,12 @@
 
     if (needs_opacity) {
         dc.popGroupToSource(); // pop raw pattern
-        dc.paint(opacity); // apply opacity
+        dc.paint(opacity);     // apply opacity
     }
 
     cairo_pattern_t *cp = cairo_pattern_create_for_surface(pattern_surface.raw());
     // Apply transformation to user space. Also compensate for oversampling.
-    ink_cairo_pattern_set_matrix(cp, ps2user.inverse() * pattern_surface.drawingTransform() );
+    ink_cairo_pattern_set_matrix(cp, ps2user.inverse() * pattern_surface.drawingTransform());
 
     cairo_pattern_set_extend(cp, CAIRO_EXTEND_REPEAT);
 

=== modified file 'src/sp-pattern.h'
--- src/sp-pattern.h	2015-02-19 03:25:21 +0000
+++ src/sp-pattern.h	2015-05-17 12:22:15 +0000
@@ -1,9 +1,6 @@
-#ifndef SEEN_SP_PATTERN_H
-#define SEEN_SP_PATTERN_H
-
-/*
+/** @file
  * SVG <pattern> implementation
- *
+ *//*
  * Author:
  *   Lauris Kaplinski <[e-mail]>
  *   Abhishek Sharma
@@ -13,95 +10,131 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#define SP_PATTERN(obj) (dynamic_cast<SPPattern*>((SPObject*)obj))
-#define SP_IS_PATTERN(obj) (dynamic_cast<const SPPattern*>((SPObject*)obj) != NULL)
+#ifndef SEEN_SP_PATTERN_H
+#define SEEN_SP_PATTERN_H
 
-class SPPatternReference;
-class SPItem;
-typedef struct _GSList GSList;
+#include <list>
+#include <stddef.h>
+#include <glibmm/ustring.h>
+#include <sigc++/connection.h>
 
 #include "svg/svg-length.h"
 #include "sp-paint-server.h"
 #include "uri-references.h"
 #include "viewbox.h"
 
-#include <sigc++/connection.h>
-
+class SPPatternReference;
+class SPItem;
+
+namespace Inkscape {
+namespace XML {
+
+class Node;
+}
+}
+
+#define SP_PATTERN(obj) (dynamic_cast<SPPattern *>((SPObject *)obj))
+#define SP_IS_PATTERN(obj) (dynamic_cast<const SPPattern *>((SPObject *)obj) != NULL)
 
 class SPPattern : public SPPaintServer, public SPViewBox {
 public:
-	SPPattern();
-	virtual ~SPPattern();
+    enum PatternUnits { UNITS_USERSPACEONUSE, UNITS_OBJECTBOUNDINGBOX };
+
+    SPPattern();
+    virtual ~SPPattern();
 
     /* Reference (href) */
-    char *href;
+    Glib::ustring href;
     SPPatternReference *ref;
 
+    gdouble x() const;
+    gdouble y() const;
+    gdouble width() const;
+    gdouble height() const;
+    Geom::OptRect viewbox() const;
+    SPPattern::PatternUnits patternUnits() const;
+    SPPattern::PatternUnits patternContentUnits() const;
+    Geom::Affine const &getTransform() const;
+    SPPattern *rootPattern(); // TODO: const
+
+    SPPattern *clone_if_necessary(SPItem *item, const gchar *property);
+    void transform_multiply(Geom::Affine postmul, bool set);
+
+    /**
+     * @brief create a new pattern in XML tree
+     * @return created pattern id
+     */
+    static const gchar *produce(const std::vector<Inkscape::XML::Node *> &reprs, Geom::Rect bounds,
+                                SPDocument *document, Geom::Affine transform, Geom::Affine move);
+
+    bool isValid() const;
+
+    virtual cairo_pattern_t *pattern_new(cairo_t *ct, Geom::OptRect const &bbox, double opacity);
+
+protected:
+    virtual void build(SPDocument *doc, Inkscape::XML::Node *repr);
+    virtual void release();
+    virtual void set(unsigned int key, const gchar *value);
+    virtual void update(SPCtx *ctx, unsigned int flags);
+    virtual void modified(unsigned int flags);
+
+private:
+    bool _hasItemChildren() const;
+    void _getChildren(std::list<SPObject *> &l);
+    SPPattern *_chain() const;
+
+    /**
+    Count how many times pattern is used by the styles of o and its descendants
+    */
+    guint _countHrefs(SPObject *o) const;
+
+    /**
+    Gets called when the pattern is reattached to another <pattern>
+    */
+    void _onRefChanged(SPObject *old_ref, SPObject *ref);
+
+    /**
+    Gets called when the referenced <pattern> is changed
+    */
+    void _onRefModified(SPObject *ref, guint flags);
+
     /* patternUnits and patternContentUnits attribute */
-    unsigned int patternUnits : 1;
-    unsigned int patternUnits_set : 1;
-    unsigned int patternContentUnits : 1;
-    unsigned int patternContentUnits_set : 1;
+    PatternUnits _pattern_units : 1;
+    bool _pattern_units_set : 1;
+    PatternUnits _pattern_content_units : 1;
+    bool _pattern_content_units_set : 1;
     /* patternTransform attribute */
-    Geom::Affine patternTransform;
-    unsigned int patternTransform_set : 1;
+    Geom::Affine _pattern_transform;
+    bool _pattern_transform_set : 1;
     /* Tile rectangle */
-    SVGLength x;
-    SVGLength y;
-    SVGLength width;
-    SVGLength height;
-
-    sigc::connection modified_connection;
-
-    bool isValid() const;
-
-	virtual cairo_pattern_t* pattern_new(cairo_t *ct, Geom::OptRect const &bbox, double opacity);
-
-protected:
-	virtual void build(SPDocument* doc, Inkscape::XML::Node* repr);
-	virtual void release();
-	virtual void set(unsigned int key, const gchar* value);
-	virtual void update(SPCtx* ctx, unsigned int flags);
-	virtual void modified(unsigned int flags);
+    SVGLength _x;
+    SVGLength _y;
+    SVGLength _width;
+    SVGLength _height;
+
+    sigc::connection _modified_connection;
 };
 
 
 class SPPatternReference : public Inkscape::URIReference {
 public:
-    SPPatternReference (SPObject *obj) : URIReference(obj) {}
-    SPPattern *getObject() const {
+    SPPatternReference(SPObject *obj)
+        : URIReference(obj)
+    {
+    }
+
+    SPPattern *getObject() const
+    {
         return reinterpret_cast<SPPattern *>(URIReference::getObject());
     }
 
 protected:
-    virtual bool _acceptObject(SPObject *obj) const {
-        return SP_IS_PATTERN (obj);
+    virtual bool _acceptObject(SPObject *obj) const
+    {
+        return SP_IS_PATTERN(obj);
     }
 };
 
-enum {
-    SP_PATTERN_UNITS_USERSPACEONUSE,
-    SP_PATTERN_UNITS_OBJECTBOUNDINGBOX
-};
-
-unsigned int pattern_users (SPPattern *pattern);
-SPPattern *pattern_chain (SPPattern *pattern);
-SPPattern *sp_pattern_clone_if_necessary (SPItem *item, SPPattern *pattern, const char *property);
-void sp_pattern_transform_multiply (SPPattern *pattern, Geom::Affine postmul, bool set);
-
-const char *pattern_tile (const std::vector<Inkscape::XML::Node*> &reprs, Geom::Rect bounds, SPDocument *document, Geom::Affine transform, Geom::Affine move);
-
-SPPattern *pattern_getroot (SPPattern *pat);
-
-unsigned int pattern_patternUnits (SPPattern const *pat);
-unsigned int pattern_patternContentUnits (SPPattern const *pat);
-Geom::Affine const &pattern_patternTransform(SPPattern const *pat);
-double pattern_x (SPPattern const *pat);
-double pattern_y (SPPattern const *pat);
-double pattern_width (SPPattern const *pat);
-double pattern_height (SPPattern const *pat);
-Geom::OptRect pattern_viewBox (SPPattern const *pat);
-
 #endif // SEEN_SP_PATTERN_H
 
 /*

=== modified file 'src/ui/CMakeLists.txt'
--- src/ui/CMakeLists.txt	2015-05-12 20:23:05 +0000
+++ src/ui/CMakeLists.txt	2015-05-17 12:22:15 +0000
@@ -6,6 +6,7 @@
 	interface.cpp
 	object-edit.cpp
 	previewholder.cpp
+	selected-color.cpp
 	shape-editor.cpp
 	tool-factory.cpp
 	tools-switch.cpp
@@ -115,8 +116,14 @@
 	widget/anchor-selector.cpp
 	widget/button.cpp
 	widget/clipmaskicon.cpp
+	widget/color-entry.cpp
+	widget/color-icc-selector.cpp
+	widget/color-notebook.cpp
 	widget/color-picker.cpp
 	widget/color-preview.cpp
+	widget/color-scales.cpp
+	widget/color-slider.cpp
+	widget/color-wheel-selector.cpp
 	widget/dock-item.cpp
 	widget/dock.cpp
 	widget/entity-entry.cpp
@@ -175,6 +182,7 @@
 	previewable.h
 	previewfillable.h
 	previewholder.h
+	selected-color.h
 	shape-editor.h
 	tool-factory.h
 	tools-switch.h
@@ -288,8 +296,14 @@
 	widget/anchor-selector.h
 	widget/attr-widget.h
 	widget/button.h
+	widget/color-entry.h
+	widget/color-icc-selector.h
+	widget/color-notebook.h
 	widget/color-picker.h
 	widget/color-preview.h
+	widget/color-scales.h
+	widget/color-slider.h
+	widget/color-wheel-selector.h
 	widget/combo-enums.h
 	widget/dock-item.h
 	widget/dock.h

=== modified file 'src/ui/Makefile_insert'
--- src/ui/Makefile_insert	2015-02-25 01:04:28 +0000
+++ src/ui/Makefile_insert	2015-05-17 12:22:15 +0000
@@ -19,6 +19,8 @@
 	ui/previewfillable.h	\
 	ui/previewholder.cpp	\
 	ui/previewholder.h	\
+	ui/selected-color.h     \
+	ui/selected-color.cpp   \
 	ui/shape-editor.cpp	\
 	ui/shape-editor.h	\
 	ui/tool-factory.cpp	\

=== modified file 'src/ui/dialog/objects.cpp'
--- src/ui/dialog/objects.cpp	2015-02-27 02:10:36 +0000
+++ src/ui/dialog/objects.cpp	2015-05-17 12:22:15 +0000
@@ -45,6 +45,7 @@
 #include "style.h"
 #include "ui/tools-switch.h"
 #include "ui/icon-names.h"
+#include "ui/selected-color.h"
 #include "ui/widget/imagetoggler.h"
 #include "ui/widget/layertypeicon.h"
 #include "ui/widget/insertordericon.h"
@@ -53,7 +54,7 @@
 #include "ui/tools/node-tool.h"
 #include "ui/tools/tool-base.h"
 #include "verbs.h"
-#include "widgets/sp-color-notebook.h"
+#include "ui/widget/color-notebook.h"
 #include "widgets/icon.h"
 #include "xml/node.h"
 #include "xml/node-observer.h"
@@ -928,12 +929,12 @@
                             //If the current item is not selected, store only it in the highlight source
                             _storeHighlightTarget(iter);
                         }
-                        if (_colorSelector)
+                        if (_selectedColor)
                         {
                             //Set up the color selector
                             SPColor color;
                             color.set( row[_model->_colHighlight] );
-                            _colorSelector->base->setColorAlpha(color, SP_RGBA32_A_F(row[_model->_colHighlight]));
+                            _selectedColor->setColorAlpha(color, SP_RGBA32_A_F(row[_model->_colHighlight]));
                         }
                         //Show the color selector dialog
                         _colorSelectorDialog.show();
@@ -1440,17 +1441,16 @@
  * @param csel Color selector
  * @param cp Objects panel
  */
-void sp_highlight_picker_color_mod(SPColorSelector *csel, GObject * cp)
+void ObjectsPanel::_highlightPickerColorMod()
 {
     SPColor color;
     float alpha = 0;
-    csel->base->getColorAlpha(color, alpha);
+    _selectedColor->colorAlpha(color, alpha);
+
     guint32 rgba = color.toRGBA32( alpha );
-    
-    ObjectsPanel *ptr = reinterpret_cast<ObjectsPanel *>(cp);
 
     //Set the highlight color for all items in the _highlight_target (all selected items)
-    for (std::vector<SPItem *>::iterator iter = ptr->_highlight_target.begin(); iter != ptr->_highlight_target.end(); ++iter)
+    for (std::vector<SPItem *>::iterator iter = _highlight_target.begin(); iter != _highlight_target.end(); ++iter)
     {
         SPItem * target = *iter;
         target->setHighlightColor(rgba);
@@ -1922,18 +1922,16 @@
     _colorSelectorDialog.set_title (_("Select Highlight Color"));
     _colorSelectorDialog.set_border_width (4);
     _colorSelectorDialog.property_modal() = true;
-    _colorSelector = SP_COLOR_SELECTOR(sp_color_selector_new(SP_TYPE_COLOR_NOTEBOOK));
+    _selectedColor.reset(new Inkscape::UI::SelectedColor);
+    Gtk::Widget *color_selector = Gtk::manage(new Inkscape::UI::Widget::ColorNotebook(*_selectedColor));
     _colorSelectorDialog.get_vbox()->pack_start (
-              *Glib::wrap(&_colorSelector->vbox), true, true, 0);
-
-    g_signal_connect(G_OBJECT(_colorSelector), "dragged",
-                         G_CALLBACK(sp_highlight_picker_color_mod), (void *)this);
-    g_signal_connect(G_OBJECT(_colorSelector), "released",
-                         G_CALLBACK(sp_highlight_picker_color_mod), (void *)this);
-    g_signal_connect(G_OBJECT(_colorSelector), "changed",
-                         G_CALLBACK(sp_highlight_picker_color_mod), (void *)this);
-
-    gtk_widget_show(GTK_WIDGET(_colorSelector));
+              *color_selector, true, true, 0);
+
+    _selectedColor->signal_dragged.connect(sigc::mem_fun(*this, &ObjectsPanel::_highlightPickerColorMod));
+    _selectedColor->signal_released.connect(sigc::mem_fun(*this, &ObjectsPanel::_highlightPickerColorMod));
+    _selectedColor->signal_changed.connect(sigc::mem_fun(*this, &ObjectsPanel::_highlightPickerColorMod));
+
+    color_selector->show();
     
     setDesktop( targetDesktop );
 
@@ -1951,7 +1949,6 @@
 {
     //Close the highlight selection dialog
     _colorSelectorDialog.hide();
-    _colorSelector = NULL;
     
     //Set the desktop to null, which will disconnect all object watchers
     setDesktop(NULL);

=== modified file 'src/ui/dialog/objects.h'
--- src/ui/dialog/objects.h	2015-04-27 23:38:31 +0000
+++ src/ui/dialog/objects.h	2015-05-17 12:22:15 +0000
@@ -16,6 +16,7 @@
 # include <config.h>
 #endif
 
+#include <boost/scoped_ptr.hpp>
 #include <gtkmm/box.h>
 #include <gtkmm/treeview.h>
 #include <gtkmm/treestore.h>
@@ -36,6 +37,9 @@
 namespace Inkscape {
 
 namespace UI {
+
+class SelectedColor;
+
 namespace Dialog {
 
 
@@ -166,8 +170,7 @@
     Gtk::Alignment  _blur_alignment;
 
     Gtk::Dialog _colorSelectorDialog;
-    SPColorSelector *_colorSelector;
-
+    boost::scoped_ptr<Inkscape::UI::SelectedColor> _selectedColor;
     
     //Methods:
     
@@ -233,7 +236,7 @@
     
     void setupDialog(const Glib::ustring &title);
     
-    friend void sp_highlight_picker_color_mod(SPColorSelector *csel, GObject *cp);
+    void _highlightPickerColorMod();
 
 };
 

=== modified file 'src/ui/dialog/tags.cpp'
--- src/ui/dialog/tags.cpp	2015-02-27 03:21:48 +0000
+++ src/ui/dialog/tags.cpp	2015-05-17 12:22:15 +0000
@@ -51,7 +51,7 @@
 #include "ui/tools/tool-base.h" //"event-context.h"
 #include "selection.h"
 //#include "dialogs/dialog-events.h"
-#include "widgets/sp-color-notebook.h"
+#include "ui/widget/color-notebook.h"
 #include "style.h"
 #include "filter-chemistry.h"
 #include "filters/blend.h"

=== added file 'src/ui/selected-color.cpp'
--- src/ui/selected-color.cpp	1970-01-01 00:00:00 +0000
+++ src/ui/selected-color.cpp	2015-05-17 12:22:15 +0000
@@ -0,0 +1,163 @@
+/** @file
+ * Color selected in color selector widget.
+ * This file was created during the refactoring of SPColorSelector
+ *//*
+ * Authors:
+ *	 bulia byak <[e-mail]>
+ *   Jon A. Cruz <[e-mail]>
+ *   Tomasz Boczkowski <[e-mail]>
+ *
+ * Copyright (C) 2014 Authors
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <glibmm/ustring.h>
+#include <cmath>
+
+#include "svg/svg-icc-color.h"
+#include "ui/selected-color.h"
+
+namespace Inkscape {
+namespace UI {
+
+double const SelectedColor::_EPSILON = 1e-4;
+
+SelectedColor::SelectedColor()
+	: _color(0)
+    , _alpha(1.0)
+    , _held(false)
+    , _virgin(true)
+    , _updating(false)
+{
+
+}
+
+SelectedColor::~SelectedColor() {
+
+}
+
+void SelectedColor::setColor(SPColor const &color)
+{
+    setColorAlpha( color, _alpha);
+}
+
+SPColor SelectedColor::color() const
+{
+    return _color;
+}
+
+void SelectedColor::setAlpha(gfloat alpha)
+{
+    g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
+    setColorAlpha( _color, alpha);
+}
+
+gfloat SelectedColor::alpha() const
+{
+    return _alpha;
+}
+
+void SelectedColor::setValue(guint32 value)
+{
+    SPColor color(value);
+    gfloat alpha = SP_RGBA32_A_F(value);
+    setColorAlpha(color, alpha);
+}
+
+guint32 SelectedColor::value() const
+{
+    return color().toRGBA32(_alpha);
+}
+
+void SelectedColor::setColorAlpha(SPColor const &color, gfloat alpha, bool emit_signal)
+{
+#ifdef DUMP_CHANGE_INFO
+    g_message("SelectedColor::setColorAlpha( this=%p, %f, %f, %f, %s,   %f,   %s)", this, color.v.c[0], color.v.c[1], color.v.c[2], (color.icc?color.icc->colorProfile.c_str():"<null>"), alpha, (emit_signal?"YES":"no"));
+#endif
+    g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
+
+    if (_updating) {
+        return;
+    }
+
+#ifdef DUMP_CHANGE_INFO
+    g_message("---- SelectedColor::setColorAlpha    virgin:%s   !close:%s    alpha is:%s",
+              (_virgin?"YES":"no"),
+              (!color.isClose( _color, _EPSILON )?"YES":"no"),
+              ((fabs((_alpha) - (alpha)) >= _EPSILON )?"YES":"no")
+              );
+#endif
+
+    if ( _virgin || !color.isClose( _color, _EPSILON ) ||
+         (fabs((_alpha) - (alpha)) >= _EPSILON )) {
+
+        _virgin = false;
+
+        _color = color;
+        _alpha = alpha;
+
+        if (emit_signal)
+        {
+            _updating = true;
+            if (_held) {
+                signal_dragged.emit();
+            } else {
+                signal_changed.emit();
+            }
+            _updating = false;
+        }
+
+#ifdef DUMP_CHANGE_INFO
+    } else {
+        g_message("++++ SelectedColor::setColorAlpha   color:%08x  ==>  _color:%08X   isClose:%s", color.toRGBA32(alpha), _color.toRGBA32(_alpha),
+                  (color.isClose( _color, _EPSILON )?"YES":"no"));
+#endif
+    }
+}
+
+void SelectedColor::colorAlpha(SPColor &color, gfloat &alpha) const {
+	color = _color;
+	alpha = _alpha;
+}
+
+void SelectedColor::setHeld(bool held) {
+    if (_updating) {
+        return;
+    }
+    bool grabbed = held && !_held;
+    bool released = !held && _held;
+
+    _held = held;
+
+    _updating = true;
+    if (grabbed) {
+        signal_grabbed.emit();
+    }
+
+    if (released) {
+        signal_released.emit();
+        signal_changed.emit();
+    }
+    _updating = false;
+}
+
+void SelectedColor::preserveICC() {
+    _color.icc = _color.icc ? new SVGICCColor(*_color.icc) : 0;
+}
+
+}
+}
+
+/*
+  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 :

=== added file 'src/ui/selected-color.h'
--- src/ui/selected-color.h	1970-01-01 00:00:00 +0000
+++ src/ui/selected-color.h	2015-05-17 12:22:15 +0000
@@ -0,0 +1,96 @@
+/** @file
+ * Color selected in color selector widget.
+ * This file was created during the refactoring of SPColorSelector
+ *//*
+ * Authors:
+ *	 bulia byak <[e-mail]>
+ *   Jon A. Cruz <[e-mail]>
+ *   Tomasz Boczkowski <[e-mail]>
+ *
+ * Copyright (C) 2014 Authors
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+#ifndef SEEN_SELECTED_COLOR
+#define SEEN_SELECTED_COLOR
+
+#include <sigc++/signal.h>
+#include "color.h"
+
+namespace Gtk
+{
+  class Widget;
+}
+
+namespace Inkscape {
+namespace UI {
+
+class SelectedColor {
+public:
+    SelectedColor();
+    virtual ~SelectedColor();
+
+    void setColor(SPColor const &color);
+    SPColor color() const;
+
+    void setAlpha(gfloat alpha);
+    gfloat alpha() const;
+
+    void setValue(guint32 value);
+    guint32 value() const;
+
+    void setColorAlpha(SPColor const &color, gfloat alpha, bool emit_signal = true);
+    void colorAlpha(SPColor &color, gfloat &alpha) const;
+
+    void setHeld(bool held);
+
+    void preserveICC();
+
+    sigc::signal<void> signal_grabbed;
+    sigc::signal<void> signal_dragged;
+    sigc::signal<void> signal_released;
+    sigc::signal<void> signal_changed;
+private:
+    // By default, disallow copy constructor and assignment operator
+    SelectedColor(SelectedColor const &obj);
+    SelectedColor& operator=(SelectedColor const &obj);
+
+    SPColor _color;
+    /**
+     * Color alpha value guaranteed to be in [0, 1].
+     */
+    gfloat _alpha;
+
+    bool _held;
+    /**
+     * This flag is true if no color is set yet
+     */
+    bool _virgin;
+
+    bool _updating;
+
+    static double const _EPSILON;
+};
+
+class ColorSelectorFactory {
+public:
+    virtual ~ColorSelectorFactory() {
+    }
+
+    virtual Gtk::Widget* createWidget(SelectedColor &color) const = 0;
+    virtual Glib::ustring modeName() const = 0;
+};
+
+}
+}
+
+#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 :

=== modified file 'src/ui/widget/Makefile_insert'
--- src/ui/widget/Makefile_insert	2015-05-12 19:43:24 +0000
+++ src/ui/widget/Makefile_insert	2015-05-17 12:22:15 +0000
@@ -6,10 +6,22 @@
 	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		\

=== added file 'src/ui/widget/color-entry.cpp'
--- src/ui/widget/color-entry.cpp	1970-01-01 00:00:00 +0000
+++ src/ui/widget/color-entry.cpp	2015-05-17 12:22:15 +0000
@@ -0,0 +1,104 @@
+/** @file
+ * Entry widget for typing color value in css form
+ *//*
+ * Authors:
+ *   Tomasz Boczkowski <[e-mail]>
+ *
+ * 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)
+{
+    _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;
+    }
+
+    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));
+        }
+        if (changed) {
+            set_text(str);
+        }
+        SPColor color(rgba);
+        _color.setColorAlpha(color, SP_RGBA32_A_F(rgba));
+    }
+    g_free(str);
+}
+
+
+void ColorEntry::_onColorChanged()
+{
+    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 :

=== added file 'src/ui/widget/color-entry.h'
--- src/ui/widget/color-entry.h	1970-01-01 00:00:00 +0000
+++ src/ui/widget/color-entry.h	2015-05-17 12:22:15 +0000
@@ -0,0 +1,53 @@
+/** @file
+ * Entry widget for typing color value in css form
+ *//*
+ * Authors:
+ *   Tomasz Boczkowski <[e-mail]>
+ *
+ * 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;
+};
+
+}
+}
+}
+
+#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 :

=== renamed file 'src/widgets/sp-color-icc-selector.cpp' => 'src/ui/widget/color-icc-selector.cpp'
--- src/widgets/sp-color-icc-selector.cpp	2014-10-08 02:22:03 +0000
+++ src/ui/widget/color-icc-selector.cpp	2015-05-17 12:22:15 +0000
@@ -1,24 +1,26 @@
 #ifdef HAVE_CONFIG_H
-# include "config.h"
+#include "config.h"
 #endif
 
-#include "gradient-vector.h"
 #include <math.h>
+#include <gtkmm/adjustment.h>
+#include <glibmm/i18n.h>
+
 #include <gtk/gtk.h>
-#include <glibmm/i18n.h>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "ui/dialog-events.h"
-#include "sp-color-icc-selector.h"
-#include "sp-color-scales.h"
-#include "sp-color-slider.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
 
@@ -32,137 +34,32 @@
 #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 );\
-    }\
-}
+#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
 
 
-
-G_BEGIN_DECLS
-
-static void sp_color_icc_selector_dispose(GObject *object);
-static void sp_color_icc_selector_show_all (GtkWidget *widget);
-static void sp_color_icc_selector_hide(GtkWidget *widget);
-
-G_END_DECLS
-
-/**
- * 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
-    GtkWidget *_slider;
-    GtkWidget *_btn;     // spinbutton
-    GtkWidget *_label;   // Label
-    guchar *_map;    
-};
-
-/**
- * Class that implements the internals of the selector.
- */
-class ColorICCSelectorImpl
-{
-public:
-
-    ColorICCSelectorImpl( ColorICCSelector *owner);
-
-    ~ColorICCSelectorImpl();
-
-    static void _adjustmentChanged ( GtkAdjustment *adjustment, SPColorICCSelector *cs );
-
-    static void _sliderGrabbed( SPColorSlider *slider, SPColorICCSelector *cs );
-    static void _sliderReleased( SPColorSlider *slider, SPColorICCSelector *cs );
-    static void _sliderChanged( SPColorSlider *slider, SPColorICCSelector *cs );
-
-    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;
-
-    gboolean _updating : 1;
-    gboolean _dragging : 1;
-
-    guint32 _fixupNeeded;
-    GtkWidget* _fixupBtn;
-    GtkWidget* _profileSel;
-
-    std::vector<ComponentUI> _compUI;
-
-    GtkAdjustment* _adj; // Channel adjustment
-    GtkWidget* _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)
-};
-
 #define XPAD 4
 #define YPAD 1
 
-namespace
-{
+namespace {
 
 size_t maxColorspaceComponentCount = 0;
 
@@ -187,91 +84,40 @@
 /**
  * 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)
+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
+#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 );
+    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_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 );
+    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 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 );
+    gtk_table_attach(GTK_TABLE(parent), child, left, left + width, top, top + height, xoptions, yoptions, xpadding,
+                     ypadding);
 #endif
 }
 
 } // namespace
 
-G_DEFINE_TYPE(SPColorICCSelector, sp_color_icc_selector, SP_TYPE_COLOR_SELECTOR);
-
-static void sp_color_icc_selector_class_init(SPColorICCSelectorClass *klass)
-{
-    static const gchar* nameset[] = {N_("CMS"), 0};
-    GObjectClass   *object_class = G_OBJECT_CLASS(klass);
-    GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass);
-    SPColorSelectorClass *selector_class = SP_COLOR_SELECTOR_CLASS (klass);
-
-    selector_class->name = nameset;
-    selector_class->submode_count = 1;
-
-    object_class->dispose = sp_color_icc_selector_dispose;
-
-    widget_class->show_all = sp_color_icc_selector_show_all;
-    widget_class->hide = sp_color_icc_selector_hide;
-}
-
-
-ColorICCSelector::ColorICCSelector( SPColorSelector* csel )
-    : ColorSelector( csel ),
-      _impl(NULL)
-{
-}
-
-ColorICCSelector::~ColorICCSelector()
-{
-    if (_impl)
-    {
-        delete _impl;
-        _impl = 0;
-    }
-}
-
-void sp_color_icc_selector_init(SPColorICCSelector *cs)
-{
-    SP_COLOR_SELECTOR(cs)->base = new ColorICCSelector( SP_COLOR_SELECTOR(cs) );
-
-    if ( SP_COLOR_SELECTOR(cs)->base )
-    {
-        SP_COLOR_SELECTOR(cs)->base->init();
-    }
-}
-
-
 /*
 icSigRgbData
 icSigCmykData
@@ -283,32 +129,32 @@
 
 
 #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
-static cmsUInt16Number* getScratch() {
+static cmsUInt16Number *getScratch()
+{
     // bytes per pixel * input channels * width
-    static cmsUInt16Number* scritch = static_cast<cmsUInt16Number*>(g_new(cmsUInt16Number, 4 * 1024));
+    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 )
+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())
-    {
+    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));
@@ -317,7 +163,7 @@
         sets[cmsSigLabData].push_back(Component("_a", "a", 256));
         sets[cmsSigLabData].push_back(Component("_b", "b", 256));
 
-        //cmsSigLuvData
+        // cmsSigLuvData
 
         sets[cmsSigYCbCrData].push_back(Component("_Y", "Y", 1)); // TYPE_YCbCr_16
         sets[cmsSigYCbCrData].push_back(Component("C_b", "Cb", 1));
@@ -350,8 +196,7 @@
         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)
-        {
+        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());
         }
@@ -359,39 +204,148 @@
 
     std::vector<Component> target;
 
-    if (sets.find(space) != sets.end())
-    {
+    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)
-
-ColorICCSelectorImpl::ColorICCSelectorImpl(ColorICCSelector *owner) :
-    _owner(owner),
-    _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)
+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)
 {
 }
@@ -405,21 +359,12 @@
 
 void ColorICCSelector::init()
 {
-    if (_impl) delete(_impl);
-	_impl = new ColorICCSelectorImpl(this);
     gint row = 0;
 
     _impl->_updating = FALSE;
     _impl->_dragging = FALSE;
 
-#if GTK_CHECK_VERSION(3,0,0)
-    GtkWidget *t = gtk_grid_new();
-#else
-    GtkWidget *t = gtk_table_new(5, 3, FALSE);
-#endif
-
-    gtk_widget_show (t);
-    gtk_box_pack_start (GTK_BOX (_csel), t, TRUE, TRUE, 4);
+    GtkWidget *t = GTK_WIDGET(gobj());
 
     _impl->_compUI.clear();
 
@@ -428,50 +373,53 @@
 
 
     _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 );
+    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));
+    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 ();
+    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_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 );
+    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 );
+    _impl->_profChangedID = g_signal_connect(G_OBJECT(_impl->_profileSel), "changed",
+                                             G_CALLBACK(ColorICCSelectorImpl::_profileSelected), (gpointer)_impl);
 #else
-    gtk_widget_set_sensitive( _impl->_profileSel, false );
+    gtk_widget_set_sensitive(_impl->_profileSel, false);
 #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
 
 
     row++;
 
-    // populate the data for colorspaces and channels:
+// populate the data for colorspaces and channels:
 #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
-    std::vector<colorspace::Component> things = colorspace::getColorSpaceInfo( cmsSigRgbData );
+    std::vector<colorspace::Component> things = colorspace::getColorSpaceInfo(cmsSigRgbData);
 #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
 
-    for ( size_t i = 0; i < maxColorspaceComponentCount; i++ ) {
+    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 {
+        }
+        else {
             _impl->_compUI.push_back(ComponentUI());
         }
 
@@ -482,9 +430,10 @@
         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 );
+        _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);
 
@@ -493,41 +442,47 @@
         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 ) );
+        _impl->_compUI[i]._adj = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, scaleValue, step, page, page));
 
         // Slider
-        _impl->_compUI[i]._slider = sp_color_slider_new( _impl->_compUI[i]._adj );
-#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
-        gtk_widget_set_tooltip_text( _impl->_compUI[i]._slider, (i < things.size()) ? things[i].tip.c_str() : "" );
-#else
-        gtk_widget_set_tooltip_text( _impl->_compUI[i]._slider, "." );
-#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
-        gtk_widget_show( _impl->_compUI[i]._slider );
-
-        attachToGridOrTable(t, _impl->_compUI[i]._slider, 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 );
+        _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 );
+        _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 ), _csel );
+        g_signal_connect(G_OBJECT(_impl->_compUI[i]._adj), "value_changed",
+                         G_CALLBACK(ColorICCSelectorImpl::_adjustmentChanged), _impl);
 
-        g_signal_connect( G_OBJECT( _impl->_compUI[i]._slider ), "grabbed", G_CALLBACK( ColorICCSelectorImpl::_sliderGrabbed ), _csel );
-        g_signal_connect( G_OBJECT( _impl->_compUI[i]._slider ), "released", G_CALLBACK( ColorICCSelectorImpl::_sliderReleased ), _csel );
-        g_signal_connect( G_OBJECT( _impl->_compUI[i]._slider ), "changed", G_CALLBACK( ColorICCSelectorImpl::_sliderChanged ), _csel );
+        _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++;
     }
@@ -543,16 +498,14 @@
     _impl->_adj = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 255.0, 1.0, 10.0, 10.0));
 
     // Slider
-    _impl->_slider = sp_color_slider_new(_impl->_adj);
-    gtk_widget_set_tooltip_text(_impl->_slider, _("Alpha (opacity)"));
-    gtk_widget_show(_impl->_slider);
-
-    attachToGridOrTable(t, _impl->_slider, 1, row, 1, 1, true);
-
-    sp_color_slider_set_colors( SP_COLOR_SLIDER( _impl->_slider ),
-                                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 ) );
+    _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
@@ -565,96 +518,72 @@
     attachToGridOrTable(t, _impl->_sbtn, 2, row, 1, 1, false, true);
 
     // Signals
-    g_signal_connect(G_OBJECT(_impl->_adj), "value_changed", G_CALLBACK(ColorICCSelectorImpl::_adjustmentChanged), _csel);
-
-    g_signal_connect(G_OBJECT(_impl->_slider), "grabbed", G_CALLBACK(ColorICCSelectorImpl::_sliderGrabbed), _csel);
-    g_signal_connect(G_OBJECT(_impl->_slider), "released", G_CALLBACK(ColorICCSelectorImpl::_sliderReleased), _csel);
-    g_signal_connect(G_OBJECT(_impl->_slider), "changed", G_CALLBACK(ColorICCSelectorImpl::_sliderChanged), _csel);
-}
-
-static void sp_color_icc_selector_dispose(GObject *object)
-{
-    if (G_OBJECT_CLASS(sp_color_icc_selector_parent_class)->dispose) {
-        G_OBJECT_CLASS(sp_color_icc_selector_parent_class)->dispose(object);
-    }
-}
-
-static void
-sp_color_icc_selector_show_all (GtkWidget *widget)
-{
-    gtk_widget_show (widget);
-}
-
-static void sp_color_icc_selector_hide(GtkWidget *widget)
-{
-    gtk_widget_hide(widget);
-}
-
-GtkWidget *
-sp_color_icc_selector_new (void)
-{
-    SPColorICCSelector *csel;
-
-    csel = static_cast<SPColorICCSelector*>(g_object_new (SP_TYPE_COLOR_ICC_SELECTOR, NULL));
-
-    return GTK_WIDGET (csel);
-}
-
-
-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, SP_COLOR_ICC_SELECTOR(self->_owner->_csel) );
+    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 )
+void ColorICCSelectorImpl::_profileSelected(GtkWidget * /*src*/, gpointer data)
 {
-    ColorICCSelectorImpl* self = reinterpret_cast<ColorICCSelectorImpl*>(data);
+    ColorICCSelectorImpl *self = reinterpret_cast<ColorICCSelectorImpl *>(data);
 
-    GtkTreeIter  iter;
+    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;
+        gchar *name = 0;
 
         gtk_tree_model_get(store, &iter, 1, &name, -1);
-        self->_switchToProfile( name );
-        gtk_widget_set_tooltip_text(self->_profileSel, name );
+        self->_switchToProfile(name);
+        gtk_widget_set_tooltip_text(self->_profileSel, name);
 
-        if ( name ) {
-            g_free( 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 )
+void ColorICCSelectorImpl::_switchToProfile(gchar const *name)
 {
     bool dirty = false;
-    SPColor tmp( _owner->_color );
+    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 ) {
+    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 {
+            }
+            else {
                 tmp.icc = new SVGICCColor();
             }
             tmp.icc->colorProfile = name;
-            Inkscape::ColorProfile* newProf = SP_ACTIVE_DOCUMENT->profileManager->find(name);
-            if ( newProf ) {
+            Inkscape::ColorProfile *newProf = SP_ACTIVE_DOCUMENT->profileManager->find(name);
+            if (newProf) {
                 cmsHTRANSFORM trans = newProf->getTransfFromSRGB8();
-                if ( trans ) {
-                    guint32 val = _owner->_color.toRGBA32(0);
+                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)),
@@ -663,29 +592,31 @@
 #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 );
+                    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()) );
+                    guint count = _cmsChannelsOf(asICColorSpaceSig(newProf->getColorSpace()));
 #elif HAVE_LIBLCMS2
-                    guint count = cmsChannelsOf( asICColorSpaceSig(newProf->getColorSpace()) );
+                    guint count = cmsChannelsOf(asICColorSpaceSig(newProf->getColorSpace()));
 #endif
 
-                    std::vector<colorspace::Component> things = colorspace::getColorSpaceInfo(asICColorSpaceSig(newProf->getColorSpace()));
+                    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);
+                    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 );
+                    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
@@ -695,30 +626,32 @@
             }
             dirty = true;
         }
-    } else {
+    }
+    else {
 #ifdef DEBUG_LCMS
-         g_message("NUKE THE ICC");
+        g_message("NUKE THE ICC");
 #endif // DEBUG_LCMS
-        if ( tmp.icc ) {
+        if (tmp.icc) {
             delete tmp.icc;
             tmp.icc = 0;
             dirty = true;
-            _fixupHit( 0, this );
-        } else {
+            _fixupHit(0, this);
+        }
+        else {
 #ifdef DEBUG_LCMS
-             g_message("No icc to nuke");
+            g_message("No icc to nuke");
 #endif // DEBUG_LCMS
         }
     }
 
-    if ( dirty ) {
+    if (dirty) {
 #ifdef DEBUG_LCMS
         g_message("+----------------");
         g_message("+   new color is [%s]", tmp.toString().c_str());
 #endif // DEBUG_LCMS
-        _setProfile( tmp.icc );
+        _setProfile(tmp.icc);
         //_adjustmentChanged( _compUI[0]._adj, SP_COLOR_ICC_SELECTOR(_csel) );
-        _owner->setColorAlpha( tmp, _owner->_alpha, true );
+        _color.setColor(tmp);
 #ifdef DEBUG_LCMS
         g_message("+_________________");
 #endif // DEBUG_LCMS
@@ -727,238 +660,257 @@
 #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
 
 #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
-void ColorICCSelectorImpl::_profilesChanged( std::string const & name )
+void ColorICCSelectorImpl::_profilesChanged(std::string const &name)
 {
-    GtkComboBox* combo = GTK_COMBO_BOX(_profileSel);
+    GtkComboBox *combo = GTK_COMBO_BOX(_profileSel);
 
-    g_signal_handler_block( G_OBJECT(_profileSel), _profChangedID );
+    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_append(store, &iter);
     gtk_list_store_set(store, &iter, 0, _("<none>"), 1, _("<none>"), -1);
 
-    gtk_combo_box_set_active( combo, 0 );
+    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);
+    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_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 );
+        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 );
+    g_signal_handler_unblock(G_OBJECT(_profileSel), _profChangedID);
 }
 #else
-void ColorICCSelectorImpl::_profilesChanged( std::string const & /*name*/ )
+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();
 }
-#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
 
 // 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,
-               _color.toRGBA32(_alpha), ( (_color.icc) ? _color.icc->colorProfile.c_str(): "<null>" )
-               );
-#endif // DEBUG_LCMS
-
-#ifdef DEBUG_LCMS
-    g_message("FLIPPIES!!!!     %p   '%s'", _color.icc, (_color.icc ? _color.icc->colorProfile.c_str():"<null>"));
-#endif // DEBUG_LCMS
-
-    _impl->_profilesChanged( (_color.icc) ? _color.icc->colorProfile : std::string("") );
-    ColorScales::setScaled( _impl->_adj, _alpha );
+// 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( _color.icc );
+    _impl->_setProfile(_impl->_color.color().icc);
     _impl->_fixupNeeded = 0;
-    gtk_widget_set_sensitive( _impl->_fixupBtn, FALSE );
+    gtk_widget_set_sensitive(_impl->_fixupBtn, FALSE);
 
     if (_impl->_prof) {
-        if (_impl->_prof->getTransfToSRGB8() ) {
+        if (_impl->_prof->getTransfToSRGB8()) {
             cmsUInt16Number tmp[4];
-            for ( guint i = 0; i < _impl->_profChannelCount; i++ ) {
+            for (guint i = 0; i < _impl->_profChannelCount; i++) {
                 gdouble val = 0.0;
-                if ( _color.icc->colors.size() > i ) {
-                    if ( _impl->_compUI[i]._component.scale == 256 ) {
-                        val = (_color.icc->colors[i] + 128.0) / static_cast<gdouble>(_impl->_compUI[i]._component.scale);
-                    } else {
-                        val = _color.icc->colors[i] / static_cast<gdouble>(_impl->_compUI[i]._component.scale);
+                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};
+            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 != _color.toRGBA32(255) ) {
+            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 );
+                    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 );
+                    g_message("Color needs to change 0x%06x to 0x%06x", _color.toRGBA32(255) >> 8, other >> 8);
 #endif // DEBUG_LCMS
                 }
             }
         }
     }
 #else
-    //(void)color;
+//(void)color;
 #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
-    _impl->_updateSliders( -1 );
+    _impl->_updateSliders(-1);
 
 
     _impl->_updating = FALSE;
 #ifdef DEBUG_LCMS
-    g_message( "\\_________  %p::_colorChanged()", this );
+    g_message("\\_________  %p::_colorChanged()", this);
 #endif // DEBUG_LCMS
 }
 
 #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
-void ColorICCSelectorImpl::_setProfile( SVGICCColor* profile )
+void ColorICCSelectorImpl::_setProfile(SVGICCColor *profile)
 {
 #ifdef DEBUG_LCMS
-    g_message( "/^^^^^^^^^  %p::_setProfile(%s)", this,
-               ( (profile) ? profile->colorProfile.c_str() : "<null>")
-               );
+    g_message("/^^^^^^^^^  %p::_setProfile(%s)", this, ((profile) ? profile->colorProfile.c_str() : "<null>"));
 #endif // DEBUG_LCMS
     bool profChanged = false;
-    if ( _prof && (!profile || (_profileName != profile->colorProfile) ) ) {
+    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 ) {
+    }
+    else if (profile && !_prof) {
         profChanged = true;
     }
 
-    for ( size_t i = 0; i < _compUI.size(); i++ ) {
-        gtk_widget_hide( _compUI[i]._label );
-        gtk_widget_hide( _compUI[i]._slider );
-        gtk_widget_hide( _compUI[i]._btn );
+    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 ) {
+    if (profile) {
         _prof = SP_ACTIVE_DOCUMENT->profileManager->find(profile->colorProfile.c_str());
-        if ( _prof && (asICColorProfileClassSig(_prof->getProfileClass()) != cmsSigNamedColorClass) ) {
+        if (_prof && (asICColorProfileClassSig(_prof->getProfileClass()) != cmsSigNamedColorClass)) {
 #if HAVE_LIBLCMS1
-            _profChannelCount = _cmsChannelsOf( asICColorSpaceSig(_prof->getColorSpace()) );
+            _profChannelCount = _cmsChannelsOf(asICColorSpaceSig(_prof->getColorSpace()));
 #elif HAVE_LIBLCMS2
-            _profChannelCount = cmsChannelsOf( asICColorSpaceSig(_prof->getColorSpace()) );
+            _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)
-                {
+            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() : "");
-
-                    gtk_widget_set_tooltip_text( _compUI[i]._slider, (i < things.size()) ?  things[i].tip.c_str() : "" );
-                    gtk_widget_set_tooltip_text( _compUI[i]._btn, (i < things.size()) ?  things[i].tip.c_str() : "" );
-
-                    sp_color_slider_set_colors( SP_COLOR_SLIDER(_compUI[i]._slider),
-                                                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 );
-                    gtk_widget_show( _compUI[i]._slider );
-                    gtk_widget_show( _compUI[i]._btn );
-                    //gtk_adjustment_set_value( _compUI[i]._adj, 0.0 );
-                    //gtk_adjustment_set_value( _compUI[i]._adj, val );
+                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 );
-                    gtk_widget_hide( _compUI[i]._slider );
-                    gtk_widget_hide( _compUI[i]._btn );
+                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 {
+        }
+        else {
             // Give up for now on named colors
             _prof = 0;
         }
     }
 
 #ifdef DEBUG_LCMS
-    g_message( "\\_________  %p::_setProfile()", this );
+    g_message("\\_________  %p::_setProfile()", this);
 #endif // DEBUG_LCMS
 }
 #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
 
-void ColorICCSelectorImpl::_updateSliders( gint ignore )
+void ColorICCSelectorImpl::_updateSliders(gint ignore)
 {
 #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
-    if ( _owner->_color.icc )
-    {
-        for ( guint i = 0; i < _profChannelCount; i++ ) {
+    if (_color.color().icc) {
+        for (guint i = 0; i < _profChannelCount; i++) {
             gdouble val = 0.0;
-            if ( _owner->_color.icc->colors.size() > i ) {
-                if ( _compUI[i]._component.scale == 256 ) {
-                    val = (_owner->_color.icc->colors[i] + 128.0) / static_cast<gdouble>(_compUI[i]._component.scale);
-                } else {
-                    val = _owner->_color.icc->colors[i] / static_cast<gdouble>(_compUI[i]._component.scale);
+            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 );
+            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 );
+        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 ) {
+
+                        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 {
+                                }
+                                else {
                                     *p++ = filler[j];
                                 }
                             }
                         }
-                        
+
                         cmsHTRANSFORM trans = _prof->getTransfToSRGB8();
-                        if ( trans ) {
-                            cmsDoTransform( trans, scratch, _compUI[i]._map, 1024 );
-                            sp_color_slider_set_map( SP_COLOR_SLIDER(_compUI[i]._slider), _compUI[i]._map );
+                        if (trans) {
+                            cmsDoTransform(trans, scratch, _compUI[i]._map, 1024);
+                            if (_compUI[i]._slider)
+                            {
+                                _compUI[i]._slider->setMap(_compUI[i]._map);
+                            }
                         }
                     }
                 }
@@ -969,15 +921,15 @@
     (void)ignore;
 #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
 
-    guint32 start = _owner->_color.toRGBA32( 0x00 );
-    guint32 mid = _owner->_color.toRGBA32( 0x7f );
-    guint32 end = _owner->_color.toRGBA32( 0xff );
+    guint32 start = _color.color().toRGBA32(0x00);
+    guint32 mid = _color.color().toRGBA32(0x7f);
+    guint32 end = _color.color().toRGBA32(0xff);
 
-    sp_color_slider_set_colors( SP_COLOR_SLIDER(_slider), start, mid, end );
+    _slider->setColors(start, mid, end);
 }
 
 
-void ColorICCSelectorImpl::_adjustmentChanged( GtkAdjustment *adjustment, SPColorICCSelector *cs )
+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
@@ -986,121 +938,135 @@
 //     }
 
 #ifdef DEBUG_LCMS
-    g_message( "/^^^^^^^^^  %p::_adjustmentChanged()", cs );
+    g_message("/^^^^^^^^^  %p::_adjustmentChanged()", cs);
 #endif // DEBUG_LCMS
 
-     ColorICCSelector* iccSelector = static_cast<ColorICCSelector*>(SP_COLOR_SELECTOR(cs)->base);
-     if (iccSelector->_impl->_updating) {
-         return;
-     }
-
-     iccSelector->_impl->_updating = TRUE;
-
-     gint match = -1;
-
-     SPColor newColor( iccSelector->_color );
-     gfloat scaled = ColorScales::getScaled( iccSelector->_impl->_adj );
-     if ( iccSelector->_impl->_adj == adjustment ) {
+    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");
+        g_message("ALPHA");
 #endif // DEBUG_LCMS
-     } else {
+    }
+    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->_color.icc ) {
-             other.icc->colorProfile = iccSelector->_color.icc->colorProfile;
-         }
-
-         guint32 prior = iccSelector->_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 );
-             }
-         }
+        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->_updateInternals( newColor, scaled, iccSelector->_impl->_dragging );
-     iccSelector->_impl->_updateSliders( match );
+    }
+    iccSelector->_impl->_color.setColorAlpha(newColor, scaled);
+    // iccSelector->_updateInternals( newColor, scaled, iccSelector->_impl->_dragging );
+    iccSelector->_impl->_updateSliders(match);
 
-     iccSelector->_impl->_updating = FALSE;
+    iccSelector->_impl->_updating = FALSE;
 #ifdef DEBUG_LCMS
-     g_message( "\\_________  %p::_adjustmentChanged()", cs );
+    g_message("\\_________  %p::_adjustmentChanged()", cs);
 #endif // DEBUG_LCMS
 }
 
-void ColorICCSelectorImpl::_sliderGrabbed( SPColorSlider * /*slider*/, SPColorICCSelector * /*cs*/ )
+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 );
-//     }
+    //    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( SPColorSlider * /*slider*/, SPColorICCSelector * /*cs*/ )
+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 );
-//     }
+    //     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 )
+void ColorICCSelectorImpl::_sliderChanged(SPColorSlider *slider, SPColorICCSelector *cs)
 #else
-void ColorICCSelectorImpl::_sliderChanged( SPColorSlider * /*slider*/, SPColorICCSelector * /*cs*/ )
+void ColorICCSelectorImpl::_sliderChanged()
 #endif // DEBUG_LCMS
 {
 #ifdef DEBUG_LCMS
-    g_message("Changed  %p and %p", slider, cs );
+    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 );
-}
-
-
+    //     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++

=== renamed file 'src/widgets/sp-color-icc-selector.h' => 'src/ui/widget/color-icc-selector.h'
--- src/widgets/sp-color-icc-selector.h	2014-10-08 02:22:03 +0000
+++ src/ui/widget/color-icc-selector.h	2015-05-17 12:22:15 +0000
@@ -1,63 +1,69 @@
 #ifndef SEEN_SP_COLOR_ICC_SELECTOR_H
 #define SEEN_SP_COLOR_ICC_SELECTOR_H
 
-#include <glib.h>
-#include "sp-color-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;
-}
 
-struct SPColorICCSelector;
-struct SPColorICCSelectorClass;
+namespace UI {
+namespace Widget {
 
 class ColorICCSelectorImpl;
 
-class ColorICCSelector: public ColorSelector
-{
-public:
-    ColorICCSelector( SPColorSelector* csel );
+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:
+  protected:
+    void on_show();
+
     virtual void _colorChanged();
 
-    void _recalcColor( gboolean changing );
+    void _recalcColor(gboolean changing);
 
-private:
+  private:
     friend class ColorICCSelectorImpl;
 
     // By default, disallow copy constructor and assignment operator
-    ColorICCSelector( const ColorICCSelector& obj );
-    ColorICCSelector& operator=( const ColorICCSelector& obj );
+    ColorICCSelector(const ColorICCSelector &obj);
+    ColorICCSelector &operator=(const ColorICCSelector &obj);
 
     ColorICCSelectorImpl *_impl;
 };
 
 
-
-#define SP_TYPE_COLOR_ICC_SELECTOR (sp_color_icc_selector_get_type())
-#define SP_COLOR_ICC_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_CAST((o), SP_TYPE_COLOR_ICC_SELECTOR, SPColorICCSelector))
-#define SP_COLOR_ICC_SELECTOR_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), SP_TYPE_COLOR_ICC_SELECTOR, SPColorICCSelectorClass))
-#define SP_IS_COLOR_ICC_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_TYPE((o), SP_TYPE_COLOR_ICC_SELECTOR))
-#define SP_IS_COLOR_ICC_SELECTOR_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE((k), SP_TYPE_COLOR_ICC_SELECTOR))
-
-struct SPColorICCSelector {
-    SPColorSelector parent;
-};
-
-struct SPColorICCSelectorClass {
-    SPColorSelectorClass parent_class;
-};
-
-GType sp_color_icc_selector_get_type(void);
-
-GtkWidget *sp_color_icc_selector_new(void);
-
-
-
+class ColorICCSelectorFactory : public ColorSelectorFactory {
+  public:
+    Gtk::Widget *createWidget(SelectedColor &color) const;
+    Glib::ustring modeName() const;
+};
+}
+}
+}
 #endif // SEEN_SP_COLOR_ICC_SELECTOR_H
 
 /*

=== renamed file 'src/widgets/sp-color-notebook.cpp' => 'src/ui/widget/color-notebook.cpp'
--- src/widgets/sp-color-notebook.cpp	2014-10-08 02:22:03 +0000
+++ src/ui/widget/color-notebook.cpp	2015-05-17 12:22:15 +0000
@@ -1,11 +1,13 @@
-/*
- * A notebook with RGB, CMYK, CMS, HSL, and Wheel pages
- *
- * Author:
+/**
+ * @file
+ * A notebook with RGB, CMYK, CMS, HSL, and Wheel pages - implementation
+ */
+/* Authors:
  *   Lauris Kaplinski <[e-mail]>
  *   bulia byak <[e-mail]>
+ *   Tomasz Boczkowski <[e-mail]> (c++-sification)
  *
- * Copyright (C) 2001-2002 Lauris Kaplinski
+ * Copyright (C) 2001-2014 Authors
  *
  * This code is in public domain
  */
@@ -14,7 +16,7 @@
 #define noDUMP_CHANGE_INFO
 
 #ifdef HAVE_CONFIG_H
-# include "config.h"
+#include "config.h"
 #endif
 
 #include "widgets/icon.h"
@@ -22,512 +24,233 @@
 #include <string>
 #include <cstdlib>
 #include <cstddef>
-#include <gtk/gtk.h>
 #include <glibmm/i18n.h>
+#include <gtkmm/label.h>
+#include <gtkmm/notebook.h>
 
-#include "ui/dialog-events.h"
-#include "../preferences.h"
-#include "sp-color-notebook.h"
-#include "spw-utilities.h"
-#include "sp-color-scales.h"
-#include "sp-color-icc-selector.h"
-#include "sp-color-wheel-selector.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 "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;
 
-struct SPColorNotebookTracker {
-    const gchar* name;
-    const gchar* className;
-    GType type;
-    guint submode;
-    gboolean enabledFull;
-    gboolean enabledBrief;
-    SPColorNotebook *backPointer;
-};
-
-static void sp_color_notebook_dispose(GObject *object);
-
-static void sp_color_notebook_show_all (GtkWidget *widget);
-static void sp_color_notebook_hide(GtkWidget *widget);
-
 #define XPAD 4
 #define YPAD 1
 
-G_DEFINE_TYPE(SPColorNotebook, sp_color_notebook, SP_TYPE_COLOR_SELECTOR);
-
-static void sp_color_notebook_class_init(SPColorNotebookClass *klass)
-{
-    GObjectClass *object_class = reinterpret_cast<GObjectClass *>(klass);
-    GtkWidgetClass *widget_class = reinterpret_cast<GtkWidgetClass *>(klass);
-
-    object_class->dispose = sp_color_notebook_dispose;
-
-    widget_class->show_all = sp_color_notebook_show_all;
-    widget_class->hide = sp_color_notebook_hide;
-}
-
-static void
-sp_color_notebook_switch_page(GtkNotebook *notebook,
-                              GtkWidget   *page,
-                              guint page_num,
-                              SPColorNotebook *colorbook)
-{
-    if ( colorbook )
-    {
-        ColorNotebook* nb = dynamic_cast<ColorNotebook*>(SP_COLOR_SELECTOR(colorbook)->base);
-        nb->switchPage( notebook, page, page_num );
-
-        // remember the page we switched to
-        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setInt("/colorselector/page", page_num);
-    }
-}
-
-void ColorNotebook::switchPage(GtkNotebook*,
-                              GtkWidget*,
-                              guint page_num)
-{
-    SPColorSelector* csel;
-    GtkWidget* widget;
-
-    if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (_book)) >= 0 )
-    {
-        csel = getCurrentSelector();
-        csel->base->getColorAlpha(_color, _alpha);
-    }
-    widget = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), page_num);
-    if ( widget && SP_IS_COLOR_SELECTOR(widget) )
-    {
-        csel = SP_COLOR_SELECTOR (widget);
-        csel->base->setColorAlpha( _color, _alpha );
-
-        // Temporary workaround to undo a spurious GRABBED
-        _released();
-    }
-}
-
-static gint sp_color_notebook_menu_handler( GtkWidget *widget, GdkEvent *event )
-{
-    if (event->type == GDK_BUTTON_PRESS)
-    {
-        SPColorSelector* csel = SP_COLOR_SELECTOR(widget);
-        (dynamic_cast<ColorNotebook*>(csel->base))->menuHandler( event );
-
-        /* Tell calling code that we have handled this event; the buck
-         * stops here. */
-        return TRUE;
-    }
-
-    /* Tell calling code that we have not handled this event; pass it on. */
-    return FALSE;
-}
-
-gint ColorNotebook::menuHandler( GdkEvent* event )
-{
-    GdkEventButton *bevent = (GdkEventButton *) event;
-    gtk_menu_popup (GTK_MENU( _popup ), NULL, NULL, NULL, NULL,
-                    bevent->button, bevent->time);
-    return TRUE;
-}
-
-static void sp_color_notebook_menuitem_response (GtkMenuItem *menuitem, gpointer user_data)
-{
-    gboolean active = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem));
-    SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (user_data);
-    if ( entry )
-    {
-        if ( active )
-        {
-            (dynamic_cast<ColorNotebook*>(SP_COLOR_SELECTOR(entry->backPointer)->base))->addPage(entry->type, entry->submode);
-        }
-        else
-        {
-            (dynamic_cast<ColorNotebook*>(SP_COLOR_SELECTOR(entry->backPointer)->base))->removePage(entry->type, entry->submode);
-        }
-    }
-}
-
-static void
-sp_color_notebook_init (SPColorNotebook *colorbook)
-{
-    SP_COLOR_SELECTOR(colorbook)->base = new ColorNotebook( SP_COLOR_SELECTOR(colorbook) );
-
-    if ( SP_COLOR_SELECTOR(colorbook)->base )
-    {
-        SP_COLOR_SELECTOR(colorbook)->base->init();
-    }
-}
-
-void ColorNotebook::init()
+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;
-    guint i = 0;
-    guint j = 0;
-    GType *selector_types = 0;
-    guint selector_type_count = 0;
-
-    /* tempory hardcoding to get types loaded */
-    SP_TYPE_COLOR_SCALES;
-    SP_TYPE_COLOR_WHEEL_SELECTOR;
-#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
-    SP_TYPE_COLOR_ICC_SELECTOR;
-#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
-
-    /* REJON: Comment out the next line to not use the normal GTK Color
-           wheel. */
-
-//        SP_TYPE_COLOR_GTKSELECTOR;
-
-    _updating = FALSE;
-    _updatingrgba = FALSE;
-    _btn = 0;
-    _popup = 0;
-    _trackerList = g_ptr_array_new ();
-
-    _book = gtk_notebook_new ();
-    gtk_widget_show (_book);
-
-    // Dont show the notebook tabs, use radiobuttons instead
-    gtk_notebook_set_show_border (GTK_NOTEBOOK (_book), false);
-    gtk_notebook_set_show_tabs (GTK_NOTEBOOK (_book), false);
-
-    selector_types = g_type_children (SP_TYPE_COLOR_SELECTOR, &selector_type_count);
-
-    for ( i = 0; i < selector_type_count; i++ )
-    {
-        if (!g_type_is_a (selector_types[i], SP_TYPE_COLOR_NOTEBOOK))
-        {
-            guint howmany = 1;
-            gpointer klass = g_type_class_ref (selector_types[i]);
-            if ( klass && SP_IS_COLOR_SELECTOR_CLASS(klass) )
-            {
-                SPColorSelectorClass *ck = SP_COLOR_SELECTOR_CLASS (klass);
-                howmany = MAX (1, ck->submode_count);
-                for ( j = 0; j < howmany; j++ )
-                {
-                    SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (malloc(sizeof(SPColorNotebookTracker)));
-                    if ( entry )
-                    {
-                        memset( entry, 0, sizeof(SPColorNotebookTracker) );
-                        entry->name = ck->name[j];
-                        entry->type = selector_types[i];
-                        entry->submode = j;
-                        entry->enabledFull = TRUE;
-                        entry->enabledBrief = TRUE;
-                        entry->backPointer = SP_COLOR_NOTEBOOK(_csel);
-
-                        g_ptr_array_add (_trackerList, entry);
-                    }
-                }
-            }
-        }
-    }
-
-#if GTK_CHECK_VERSION(3,0,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);
+    _buttonbox = gtk_hbox_new(TRUE, 2);
 #endif
 
-    gtk_widget_show (_buttonbox);
-    _buttons = new GtkWidget *[_trackerList->len];
+    gtk_widget_show(_buttonbox);
+    _buttons = new GtkWidget *[_available_pages.size()];
 
-    for ( i = 0; i < _trackerList->len; i++ )
-    {
-        SPColorNotebookTracker *entry =
-            reinterpret_cast< SPColorNotebookTracker* > (g_ptr_array_index (_trackerList, i));
-        if ( entry )
-        {
-            addPage(entry->type, entry->submode);
-        }
+    for (int i = 0; static_cast<size_t>(i) < _available_pages.size(); i++) {
+        _addPage(_available_pages[i]);
     }
 
-#if GTK_CHECK_VERSION(3,0,0)
-    GtkWidget* table = gtk_grid_new();
-#else
-    GtkWidget* table = gtk_table_new(2, 3, FALSE);
-#endif
-
-    gtk_widget_show (table);
-
-    gtk_box_pack_start (GTK_BOX (_csel), table, TRUE, TRUE, 0);
-
-    sp_set_font_size_smaller (_buttonbox);
-
-#if GTK_CHECK_VERSION(3,0,0)
-    #if GTK_CHECK_VERSION(3,12,0)
+    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
+  #else
     gtk_widget_set_margin_left(_buttonbox, XPAD);
     gtk_widget_set_margin_right(_buttonbox, XPAD);
-    #endif
+  #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);
-    gtk_grid_attach(GTK_GRID(table), _buttonbox, 0, row, 2, 1);
+    attach(*Glib::wrap(_buttonbox), 0, row, 2, 1);
 #else
-    gtk_table_attach (GTK_TABLE (table), _buttonbox, 0, 2, row, row + 1,
-                      static_cast<GtkAttachOptions>(GTK_EXPAND|GTK_FILL),
-                      static_cast<GtkAttachOptions>(0),
-                      XPAD, YPAD);
+    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
+#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);
-    gtk_grid_attach(GTK_GRID(table), _book, 0, row, 2, 1);
+    attach(*notebook, 0, row, 2, 1);
 #else
-    gtk_table_attach (GTK_TABLE (table), _book, 0, 2, row, row + 1,
-                      static_cast<GtkAttachOptions>(GTK_EXPAND|GTK_FILL),
-                      static_cast<GtkAttachOptions>(GTK_EXPAND|GTK_FILL),
-                      XPAD*2, YPAD);
+    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));
-
-    {
-        gboolean found = FALSE;
-
-        _popup = gtk_menu_new();
-        GtkMenu *menu = GTK_MENU (_popup);
-
-        for ( i = 0; i < _trackerList->len; i++ )
-        {
-            SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (g_ptr_array_index (_trackerList, i));
-            if ( entry )
-            {
-                GtkWidget *item = gtk_check_menu_item_new_with_label (_(entry->name));
-                gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), entry->enabledFull);
-                gtk_widget_show (item);
-                gtk_menu_shell_append (GTK_MENU_SHELL(menu), item);
-
-                g_signal_connect (G_OBJECT (item), "activate",
-                                  G_CALLBACK (sp_color_notebook_menuitem_response),
-                                  reinterpret_cast< gpointer > (entry) );
-                found = TRUE;
-            }
-        }
-
-        GtkWidget *arrow = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_NONE);
-        gtk_widget_show (arrow);
-
-        _btn = gtk_button_new ();
-        gtk_widget_show (_btn);
-        gtk_container_add (GTK_CONTAINER (_btn), arrow);
-
-        GtkWidget *align = gtk_alignment_new (1.0, 0.0, 0.0, 0.0);
-        gtk_widget_show (align);
-        gtk_container_add (GTK_CONTAINER (align), _btn);
-
-        // uncomment to reenable the "show/hide modes" menu,
-        // but first fix it so it remembers its settings in prefs and does not take that much space (entire vertical column!)
-        //gtk_table_attach (GTK_TABLE (table), align, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
-
-        g_signal_connect_swapped(G_OBJECT(_btn), "event", G_CALLBACK (sp_color_notebook_menu_handler), G_OBJECT(_csel));
-        if ( !found )
-        {
-            gtk_widget_set_sensitive (_btn, FALSE);
-        }
-    }
-
     row++;
 
-#if GTK_CHECK_VERSION(3,0,0)
+#if GTK_CHECK_VERSION(3, 0, 0)
     GtkWidget *rgbabox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 #else
-    GtkWidget *rgbabox = gtk_hbox_new (FALSE, 0);
+    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);
+    _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);
+    _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);
+    _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)
+#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 ();
+    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_widget_show (_btn);
-    gtk_container_add (GTK_CONTAINER (_btn_picker), picker);
-    gtk_widget_set_tooltip_text (_btn_picker, _("Pick colors from image"));
+    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::_picker_clicked), _csel);
+    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);
+    _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);
 
-    _rgbae = gtk_entry_new ();
-    sp_dialog_defocus_on_enter (_rgbae);
-    gtk_entry_set_max_length (GTK_ENTRY (_rgbae), 8);
-    gtk_entry_set_width_chars (GTK_ENTRY (_rgbae), 8);
-    gtk_widget_set_tooltip_text (_rgbae, _("Hexadecimal RGBA value of the color"));
-    gtk_box_pack_start(GTK_BOX(rgbabox), _rgbae, FALSE, FALSE, 0);
-    gtk_label_set_mnemonic_widget (GTK_LABEL(_rgbal), _rgbae);
+    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);
+    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
+    // the "too much ink" icon is initially hidden
     gtk_widget_hide(GTK_WIDGET(_box_toomuchink));
-#endif //defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
 
-#if GTK_CHECK_VERSION(3,0,0)
-    #if GTK_CHECK_VERSION(3,12,0)
+#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
+  #else
     gtk_widget_set_margin_left(rgbabox, XPAD);
     gtk_widget_set_margin_right(rgbabox, XPAD);
-    #endif
+  #endif
     gtk_widget_set_margin_top(rgbabox, YPAD);
     gtk_widget_set_margin_bottom(rgbabox, YPAD);
-    gtk_grid_attach(GTK_GRID(table), rgbabox, 0, row, 2, 1);
+    attach(*Glib::wrap(rgbabox), 0, row, 2, 1);
 #else
-    gtk_table_attach (GTK_TABLE (table), rgbabox, 0, 2, row, row + 1, GTK_FILL, GTK_SHRINK, XPAD, YPAD);
+    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);
-    gtk_table_attach (GTK_TABLE (table), _p, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
+    _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
 
-    _switchId = g_signal_connect(G_OBJECT (_book), "switch-page",
-                                 G_CALLBACK (sp_color_notebook_switch_page), SP_COLOR_NOTEBOOK(_csel));
-
-    _entryId = g_signal_connect (G_OBJECT (_rgbae), "changed", G_CALLBACK (ColorNotebook::_rgbaEntryChangedHook), _csel);
-}
-
-static void sp_color_notebook_dispose(GObject *object)
-{
-    if (G_OBJECT_CLASS(sp_color_notebook_parent_class)->dispose)
-        G_OBJECT_CLASS(sp_color_notebook_parent_class)->dispose(object);
-}
-
-ColorNotebook::~ColorNotebook()
-{
-    if ( _trackerList )
-    {
-        g_ptr_array_free (_trackerList, TRUE);
-        _trackerList = 0;
-    }
-
-    if ( _switchId )
-    {
-        if ( _book )
-        {
-            g_signal_handler_disconnect (_book, _switchId);
-            _switchId = 0;
-        }
-    }
-
-    if ( _buttons )
-    {
-        delete [] _buttons;
-        _buttons = 0;
-    }
-
-}
-
-static void
-sp_color_notebook_show_all (GtkWidget *widget)
-{
-    gtk_widget_show (widget);
-}
-
-static void sp_color_notebook_hide(GtkWidget *widget)
-{
-    gtk_widget_hide(widget);
-}
-
-GtkWidget *sp_color_notebook_new()
-{
-    SPColorNotebook *colorbook = SP_COLOR_NOTEBOOK(g_object_new (SP_TYPE_COLOR_NOTEBOOK, NULL));
-
-    return GTK_WIDGET(colorbook);
-}
-
-ColorNotebook::ColorNotebook( SPColorSelector* csel )
-    : ColorSelector( csel )
-{
-}
-
-SPColorSelector* ColorNotebook::getCurrentSelector()
-{
-    SPColorSelector* csel = NULL;
-    gint current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK (_book));
-
-    if ( current_page >= 0 )
-    {
-        GtkWidget* widget = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), current_page);
-        if ( SP_IS_COLOR_SELECTOR (widget) )
-        {
-            csel = SP_COLOR_SELECTOR (widget);
-        }
-    }
-
-    return csel;
-}
-
-void ColorNotebook::_colorChanged()
-{
-    SPColorSelector* cselPage = getCurrentSelector();
-    if ( cselPage )
-    {
-        cselPage->base->setColorAlpha( _color, _alpha );
-    }
-
-    _updateRgbaEntry( _color, _alpha );
-}
-
-void ColorNotebook::_picker_clicked(GtkWidget * /*widget*/, SPColorNotebook * /*colorbook*/)
+    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();
@@ -535,283 +258,113 @@
     Inkscape::UI::Tools::sp_toggle_dropper(SP_ACTIVE_DESKTOP);
 }
 
-void ColorNotebook::_rgbaEntryChangedHook(GtkEntry *entry, SPColorNotebook *colorbook)
-{
-    (dynamic_cast<ColorNotebook*>(SP_COLOR_SELECTOR(colorbook)->base))->_rgbaEntryChanged( entry );
-}
-
-void ColorNotebook::_rgbaEntryChanged(GtkEntry* entry)
-{
-    if (_updating) return;
-    if (_updatingrgba) return;
-
-    const gchar *t = gtk_entry_get_text( entry );
-
-    if (t) {
-        Glib::ustring text = t;
-        bool changed = false;
-        if (!text.empty() && text[0] == '#') {
-            changed = true;
-            text.erase(0,1);
-            if (text.size() == 6) {
-                // it was a standard RGB hex
-                unsigned int alph = SP_COLOR_F_TO_U(_alpha);
-                gchar* tmp = g_strdup_printf("%02x", alph);
-                text += tmp;
-                g_free(tmp);
-            }
-        }
-        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 ) {
-                gtk_entry_set_text( entry, str );
-            }
-            SPColor color( rgba );
-            setColorAlpha( color, SP_RGBA32_A_F(rgba), true );
-            _updatingrgba = FALSE;
-        }
-        g_free(str);
-    }
-}
+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::_updateRgbaEntry( const SPColor& color, gfloat alpha )
+void ColorNotebook::_updateICCButtons()
 {
-    g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
+    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);
+    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, 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_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++){
+            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
+            /* 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 {
+            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)
-
-    if ( !_updatingrgba )
-    {
-        gchar s[32];
-        guint32 rgba;
-
-        /* Update RGBA entry */
-        rgba = color.toRGBA32( alpha );
-
-        g_snprintf (s, 32, "%08x", rgba);
-        const gchar* oldText = gtk_entry_get_text( GTK_ENTRY( _rgbae ) );
-        if ( strcmp( oldText, s ) != 0 )
-        {
-            g_signal_handler_block( _rgbae, _entryId );
-            gtk_entry_set_text( GTK_ENTRY(_rgbae), s );
-            g_signal_handler_unblock( _rgbae, _entryId );
-        }
-    }
+#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
 }
 
 void ColorNotebook::_setCurrentPage(int i)
 {
     gtk_notebook_set_current_page(GTK_NOTEBOOK(_book), i);
 
-    if (_buttons && _trackerList && (static_cast<size_t>(i) < _trackerList->len) ) {
+    if (_buttons && (static_cast<size_t>(i) < _available_pages.size())) {
         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(_buttons[i]), TRUE);
     }
 }
 
-void ColorNotebook::_buttonClicked(GtkWidget *widget,  SPColorNotebook *colorbook)
-{
-    ColorNotebook* nb = dynamic_cast<ColorNotebook*>(SP_COLOR_SELECTOR(colorbook)->base);
-
-    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::_entryGrabbed (SPColorSelector *, SPColorNotebook *colorbook)
-{
-    ColorNotebook* nb = dynamic_cast<ColorNotebook*>(SP_COLOR_SELECTOR(colorbook)->base);
-    nb->_grabbed();
-}
-
-void ColorNotebook::_entryDragged (SPColorSelector *csel, SPColorNotebook *colorbook)
-{
-    gboolean oldState;
-    ColorNotebook* nb = dynamic_cast<ColorNotebook*>(SP_COLOR_SELECTOR(colorbook)->base);
-
-    oldState = nb->_dragging;
-
-    nb->_dragging = TRUE;
-    nb->_entryModified( csel, colorbook );
-
-    nb->_dragging = oldState;
-}
-
-void ColorNotebook::_entryReleased (SPColorSelector *, SPColorNotebook *colorbook)
-{
-    ColorNotebook* nb = dynamic_cast<ColorNotebook*>(SP_COLOR_SELECTOR(colorbook)->base);
-    nb->_released();
-}
-
-void ColorNotebook::_entryChanged (SPColorSelector *csel, SPColorNotebook *colorbook)
-{
-    gboolean oldState;
-    ColorNotebook* nb = dynamic_cast<ColorNotebook*>(SP_COLOR_SELECTOR(colorbook)->base);
-
-    oldState = nb->_dragging;
-
-    nb->_dragging = FALSE;
-    nb->_entryModified( csel, colorbook );
-
-    nb->_dragging = oldState;
-}
-
-void ColorNotebook::_entryModified (SPColorSelector *csel, SPColorNotebook *colorbook)
-{
-    g_return_if_fail (colorbook != NULL);
-    g_return_if_fail (SP_IS_COLOR_NOTEBOOK (colorbook));
-    g_return_if_fail (csel != NULL);
-    g_return_if_fail (SP_IS_COLOR_SELECTOR (csel));
-
-    ColorNotebook* nb = dynamic_cast<ColorNotebook*>(SP_COLOR_SELECTOR(colorbook)->base);
-    SPColor color;
-    gfloat alpha = 1.0;
-
-    csel->base->getColorAlpha( color, alpha );
-    nb->_updateRgbaEntry( color, alpha );
-    nb->_updateInternals( color, alpha, nb->_dragging );
-}
-
-GtkWidget* ColorNotebook::addPage(GType page_type, guint submode)
-{
-    GtkWidget *page;
-
-    page = sp_color_selector_new( page_type );
-    if ( page )
-    {
-        GtkWidget* tab_label = 0;
-        SPColorSelector* csel;
-
-        csel = SP_COLOR_SELECTOR (page);
-        if ( submode > 0 )
-        {
-            csel->base->setSubmode( submode );
-        }
-        gtk_widget_show (page);
-        int index = csel->base ? csel->base->getSubmode() : 0;