Merge from trunk

(bzr r8254.1.53)

22 files changed, 2321 insertions, 1714 deletions

diff --git a/src/widgets/CMakeLists.txt b/src/widgets/CMakeLists.txt
index 45f013f16..9af325926 100644
--- a/src/widgets/CMakeLists.txt
+++ b/src/widgets/CMakeLists.txt
@@ -29,8 +29,9 @@ spw-utilities.cpp
 sp-xmlview-attr-list.cpp
 sp-xmlview-content.cpp
 sp-xmlview-tree.cpp
+swatch-selector.cpp
 toolbox.cpp
 )
 ADD_LIBRARY(widgets STATIC ${widgets_SRC})
 TARGET_LINK_LIBRARIES(widgets
-2geom ${INKSCAPE_LIBS})
\ No newline at end of file
+2geom ${INKSCAPE_LIBS})
diff --git a/src/widgets/Makefile_insert b/src/widgets/Makefile_insert
index 08b2433ea..5d327d8a3 100644
--- a/src/widgets/Makefile_insert
+++ b/src/widgets/Makefile_insert
@@ -67,6 +67,8 @@ ink_common_sources +=	\
 	widgets/sp-xmlview-tree.h	\
 	widgets/stroke-style.cpp	\
 	widgets/stroke-style.h		\
+	widgets/swatch-selector.cpp	\
+	widgets/swatch-selector.h	\
 	widgets/toolbox.cpp		\
 	widgets/toolbox.h		\
 	widgets/widget-sizes.h
diff --git a/src/widgets/desktop-widget.cpp b/src/widgets/desktop-widget.cpp
index b63992afe..ab440595f 100644
--- a/src/widgets/desktop-widget.cpp
+++ b/src/widgets/desktop-widget.cpp
@@ -48,25 +48,31 @@
 #include "sp-image.h"
 #include "sp-item.h"
 #include "sp-namedview.h"
-#include "toolbox.h"
 #include "ui/dialog/dialog-manager.h"
 #include "ui/dialog/swatches.h"
 #include "ui/icon-names.h"
 #include "ui/widget/dock.h"
 #include "ui/widget/layer-selector.h"
 #include "ui/widget/selected-style.h"
-#include "widgets/button.h"
-#include "widgets/ruler.h"
-#include "widgets/spinbutton-events.h"
-#include "widgets/spw-utilities.h"
-#include "widgets/toolbox.h"
-#include "widgets/widget-sizes.h"
+#include "ui/uxmanager.h"
+
+// We're in the "widgets" directory, so no need to explicitly prefix these:
+#include "button.h"
+#include "ruler.h"
+#include "spinbutton-events.h"
+#include "spw-utilities.h"
+#include "toolbox.h"
+#include "widget-sizes.h"
 
 #if defined (SOLARIS) && (SOLARIS == 8)
 #include "round.h"
 using Inkscape::round;
 #endif
 
+
+using Inkscape::UI::UXManager;
+using Inkscape::UI::ToolboxFactory;
+
 #ifdef WITH_INKBOARD
 #endif
 
@@ -85,7 +91,6 @@ enum {
 /* SPDesktopWidget */
 
 static void sp_desktop_widget_class_init (SPDesktopWidgetClass *klass);
-static void sp_desktop_widget_init (SPDesktopWidget *widget);
 static void sp_desktop_widget_destroy (GtkObject *object);
 
 static void sp_desktop_widget_size_allocate (GtkWidget *widget, GtkAllocation *allocation);
@@ -97,7 +102,6 @@ static void sp_dtw_color_profile_event(EgeColorProfTracker *widget, SPDesktopWid
 static void cms_adjust_toggled( GtkWidget *button, gpointer data );
 static void cms_adjust_set_sensitive( SPDesktopWidget *dtw, bool enabled );
 static void sp_desktop_widget_adjustment_value_changed (GtkAdjustment *adj, SPDesktopWidget *dtw);
-static void sp_desktop_widget_namedview_modified (SPObject *obj, guint flags, SPDesktopWidget *dtw);
 
 static gdouble sp_dtw_zoom_value_to_display (gdouble value);
 static gdouble sp_dtw_zoom_display_to_value (gdouble value);
@@ -241,7 +245,7 @@ SPDesktopWidget::window_get_pointer()
 /**
  * Registers SPDesktopWidget class and returns its type number.
  */
-GType sp_desktop_widget_get_type(void)
+GType SPDesktopWidget::getType(void)
 {
     static GtkType type = 0;
     if (!type) {
@@ -254,7 +258,7 @@ GType sp_desktop_widget_get_type(void)
             0, // class_data
             sizeof(SPDesktopWidget),
             0, // n_preallocs
-            (GInstanceInitFunc)sp_desktop_widget_init,
+            (GInstanceInitFunc)SPDesktopWidget::init,
             0 // value_table
         };
         type = g_type_register_static(SP_TYPE_VIEW_WIDGET, "SPDesktopWidget", &info, static_cast<GTypeFlags>(0));
@@ -282,14 +286,12 @@ sp_desktop_widget_class_init (SPDesktopWidgetClass *klass)
 /**
  * Callback for SPDesktopWidget object initialization.
  */
-static void
-sp_desktop_widget_init (SPDesktopWidget *dtw)
+void SPDesktopWidget::init( SPDesktopWidget *dtw )
 {
     GtkWidget *widget;
     GtkWidget *tbl;
     GtkWidget *canvas_tbl;
 
-    GtkWidget *hbox;
     GtkWidget *eventbox;
     GtkStyle *style;
 
@@ -320,24 +322,26 @@ sp_desktop_widget_init (SPDesktopWidget *dtw)
         gtk_box_pack_end( GTK_BOX( dtw->vbox ), GTK_WIDGET(dtw->panels->gobj()), FALSE, TRUE, 0 );
     }
 
-    hbox = gtk_hbox_new (FALSE, 0);
-    gtk_box_pack_end (GTK_BOX (dtw->vbox), hbox, TRUE, TRUE, 0);
-    gtk_widget_show (hbox);
+    dtw->hbox = gtk_hbox_new(FALSE, 0);
+    gtk_box_pack_end( GTK_BOX (dtw->vbox), dtw->hbox, TRUE, TRUE, 0 );
+    gtk_widget_show(dtw->hbox);
 
-    dtw->aux_toolbox = sp_aux_toolbox_new ();
+    dtw->aux_toolbox = ToolboxFactory::createAuxToolbox();
     gtk_box_pack_end (GTK_BOX (dtw->vbox), dtw->aux_toolbox, FALSE, TRUE, 0);
 
-    dtw->snap_toolbox = sp_snap_toolbox_new ();
-    gtk_box_pack_end (GTK_BOX (dtw->vbox), dtw->snap_toolbox, FALSE, TRUE, 0);
+    dtw->snap_toolbox = ToolboxFactory::createSnapToolbox();
+    ToolboxFactory::setOrientation( dtw->snap_toolbox, GTK_ORIENTATION_VERTICAL );
+    gtk_box_pack_end( GTK_BOX(dtw->hbox), dtw->snap_toolbox, FALSE, TRUE, 0 );
 
-    dtw->commands_toolbox = sp_commands_toolbox_new ();
+    dtw->commands_toolbox = ToolboxFactory::createCommandsToolbox();
     gtk_box_pack_end (GTK_BOX (dtw->vbox), dtw->commands_toolbox, FALSE, TRUE, 0);
 
-    dtw->tool_toolbox = sp_tool_toolbox_new ();
-    gtk_box_pack_start (GTK_BOX (hbox), dtw->tool_toolbox, FALSE, TRUE, 0);
+    dtw->tool_toolbox = ToolboxFactory::createToolToolbox();
+    ToolboxFactory::setOrientation( dtw->tool_toolbox, GTK_ORIENTATION_VERTICAL );
+    gtk_box_pack_start( GTK_BOX(dtw->hbox), dtw->tool_toolbox, FALSE, TRUE, 0 );
 
     tbl = gtk_table_new (2, 3, FALSE);
-    gtk_box_pack_start (GTK_BOX (hbox), tbl, TRUE, TRUE, 1);
+    gtk_box_pack_start( GTK_BOX(dtw->hbox), tbl, TRUE, TRUE, 1 );
 
     canvas_tbl = gtk_table_new (3, 3, FALSE);
 
@@ -528,8 +532,10 @@ sp_desktop_widget_init (SPDesktopWidget *dtw)
 
     dtw->_tracker = ege_color_prof_tracker_new(GTK_WIDGET(dtw->layer_selector->gobj()));
 #if ENABLE_LCMS
-    {
+    bool fromDisplay = prefs->getBool( "/options/displayprofile/from_display");
+    if ( fromDisplay ) {
         Glib::ustring id = Inkscape::colorprofile_get_display_id( 0, 0 );
+
         bool enabled = false;
         if ( dtw->canvas->cms_key ) {
             *(dtw->canvas->cms_key) = id;
@@ -567,6 +573,8 @@ sp_desktop_widget_destroy (GtkObject *object)
 {
     SPDesktopWidget *dtw = SP_DESKTOP_WIDGET (object);
 
+    UXManager::getInstance()->delTrack(dtw);
+
     if (dtw->desktop) {
         if ( watcher ) {
             watcher->remove(dtw);
@@ -707,23 +715,22 @@ sp_desktop_widget_realize (GtkWidget *widget)
 
     dtw->desktop->set_display_area (d.x0, d.y0, d.x1, d.y1, 10);
 
-    sp_desktop_widget_update_namedview(dtw);
+    dtw->updateNamedview();
 }
 
 /* This is just to provide access to common functionality from sp_desktop_widget_realize() above
    as well as from SPDesktop::change_document() */
-void
-sp_desktop_widget_update_namedview (SPDesktopWidget *dtw) {
-    g_return_if_fail(dtw);
-
-    /* Listen on namedview modification */
+void SPDesktopWidget::updateNamedview()
+{
+    // Listen on namedview modification
     // originally (prior to the sigc++ conversion) the signal was simply
     // connected twice rather than disconnecting the first connection
-    dtw->modified_connection.disconnect();
-    dtw->modified_connection = dtw->desktop->namedview->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_desktop_widget_namedview_modified), dtw));
-    sp_desktop_widget_namedview_modified (dtw->desktop->namedview, SP_OBJECT_MODIFIED_FLAG, dtw);
+    modified_connection.disconnect();
 
-    dtw->updateTitle(SP_DOCUMENT_NAME (dtw->desktop->doc()));
+    modified_connection = desktop->namedview->connectModified(sigc::mem_fun(*this, &SPDesktopWidget::namedviewModified));
+    namedviewModified(desktop->namedview, SP_OBJECT_MODIFIED_FLAG);
+
+    updateTitle(SP_DOCUMENT_NAME (desktop->doc()));
 }
 
 /**
@@ -790,6 +797,11 @@ void cms_adjust_toggled( GtkWidget */*button*/, gpointer data )
         dtw->requestCanvasUpdate();
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
         prefs->setBool("/options/displayprofile/enable", down);
+        if (down) {
+            dtw->setMessage (Inkscape::NORMAL_MESSAGE, _("Color-managed display is <b>enabled</b> in this window"));
+        } else {
+            dtw->setMessage (Inkscape::NORMAL_MESSAGE, _("Color-managed display is <b>disabled</b> in this window"));
+        }
     }
 #endif // ENABLE_LCMS
 }
@@ -900,8 +912,8 @@ SPDesktopWidget::shutdown()
                 GTK_MESSAGE_WARNING,
                 GTK_BUTTONS_NONE,
                 _("<span weight=\"bold\" size=\"larger\">The file \"%s\" was saved with a format (%s) that may cause data loss!</span>\n\n"
-                  "Do you want to save this file as an Inkscape SVG?"),
-                SP_DOCUMENT_NAME(doc),
+                  "Do you want to save this file as Inkscape SVG?"),
+                SP_DOCUMENT_NAME(doc)? SP_DOCUMENT_NAME(doc) : "Unnamed",
                 SP_MODULE_KEY_OUTPUT_SVG_INKSCAPE);
             // fix for bug 1767940:
             GTK_WIDGET_UNSET_FLAGS(GTK_WIDGET(GTK_MESSAGE_DIALOG(dialog)->label), GTK_CAN_FOCUS);
@@ -1199,18 +1211,18 @@ sp_desktop_widget_fullscreen(SPDesktopWidget *dtw)
 /**
  * Hide whatever the user does not want to see in the window
  */
-void
-sp_desktop_widget_layout (SPDesktopWidget *dtw)
+void SPDesktopWidget::layoutWidgets()
 {
+    SPDesktopWidget *dtw = this;
     Glib::ustring pref_root;
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
     if (dtw->desktop->is_focusMode()) {
-	    pref_root = "/focus/";
+        pref_root = "/focus/";
     } else if (dtw->desktop->is_fullscreen()) {
-	    pref_root = "/fullscreen/";
+        pref_root = "/fullscreen/";
     } else {
-	    pref_root = "/window/";
+        pref_root = "/window/";
     }
 
 #ifndef GDK_WINDOWING_QUARTZ
@@ -1228,17 +1240,17 @@ sp_desktop_widget_layout (SPDesktopWidget *dtw)
     }
 
     if (!prefs->getBool(pref_root + "snaptoolbox/state", true)) {
-		gtk_widget_hide_all (dtw->snap_toolbox);
-	} else {
-		gtk_widget_show_all (dtw->snap_toolbox);
-	}
+        gtk_widget_hide_all (dtw->snap_toolbox);
+    } else {
+        gtk_widget_show_all (dtw->snap_toolbox);
+    }
 
     if (!prefs->getBool(pref_root + "toppanel/state", true)) {
         gtk_widget_hide_all (dtw->aux_toolbox);
     } else {
         // we cannot just show_all because that will show all tools' panels;
         // this is a function from toolbox.cpp that shows only the current tool's panel
-        show_aux_toolbox (dtw->aux_toolbox);
+        ToolboxFactory::showAuxToolbox(dtw->aux_toolbox);
     }
 
     if (!prefs->getBool(pref_root + "toolbox/state", true)) {
@@ -1336,8 +1348,57 @@ SPDesktopWidget::isToolboxButtonActive (const gchar* id)
     return isActive;
 }
 
-SPViewWidget *
-sp_desktop_widget_new (SPNamedView *namedview)
+void SPDesktopWidget::setToolboxPosition(Glib::ustring const& id, GtkPositionType pos)
+{
+    // Note - later on these won't be individual member variables.
+    GtkWidget* toolbox = 0;
+    if (id == "ToolToolbar") {
+        toolbox = tool_toolbox;
+    } else if (id == "AuxToolbar") {
+        toolbox = aux_toolbox;
+    } else if (id == "CommandsToolbar") {
+        toolbox = commands_toolbox;
+    } else if (id == "SnapToolbar") {
+        toolbox = snap_toolbox;
+    }
+
+
+    if (toolbox) {
+        switch(pos) {
+            case GTK_POS_TOP:
+            case GTK_POS_BOTTOM:
+                if ( gtk_widget_is_ancestor(toolbox, hbox) ) {
+                    gtk_widget_reparent( toolbox, vbox );
+                    gtk_box_set_child_packing(GTK_BOX(vbox), toolbox, FALSE, TRUE, 0, GTK_PACK_START);
+                }
+                ToolboxFactory::setOrientation(toolbox, GTK_ORIENTATION_HORIZONTAL);
+                break;
+            case GTK_POS_LEFT:
+            case GTK_POS_RIGHT:
+                if ( !gtk_widget_is_ancestor(toolbox, hbox) ) {
+                    gtk_widget_reparent( toolbox, hbox );
+                    gtk_box_set_child_packing(GTK_BOX(hbox), toolbox, FALSE, TRUE, 0, GTK_PACK_START);
+                    if (pos == GTK_POS_LEFT) {
+                        gtk_box_reorder_child( GTK_BOX(hbox), toolbox, 0 );
+                    }
+                }
+                ToolboxFactory::setOrientation(toolbox, GTK_ORIENTATION_VERTICAL);
+                break;
+        }
+    }
+}
+
+
+SPViewWidget *sp_desktop_widget_new( SPNamedView *namedview )
+{
+    SPDesktopWidget* dtw = SPDesktopWidget::createInstance(namedview);
+
+    UXManager::getInstance()->addTrack(dtw);
+
+    return SP_VIEW_WIDGET(dtw);
+}
+
+SPDesktopWidget* SPDesktopWidget::createInstance(SPNamedView *namedview)
 {
     SPDesktopWidget *dtw = (SPDesktopWidget*)g_object_new(SP_TYPE_DESKTOP_WIDGET, NULL);
 
@@ -1362,7 +1423,7 @@ sp_desktop_widget_new (SPNamedView *namedview)
     sp_view_widget_set_view (SP_VIEW_WIDGET (dtw), dtw->desktop);
 
     /* Listen on namedview modification */
-    dtw->modified_connection = namedview->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_desktop_widget_namedview_modified), dtw));
+    dtw->modified_connection = namedview->connectModified(sigc::mem_fun(*dtw, &SPDesktopWidget::namedviewModified));
 
     dtw->layer_selector->setDesktop(dtw->desktop);
 
@@ -1372,16 +1433,18 @@ sp_desktop_widget_new (SPNamedView *namedview)
     gtk_box_pack_start (GTK_BOX (dtw->vbox), dtw->menubar, FALSE, FALSE, 0);
 #endif
 
-    sp_desktop_widget_layout (dtw);
+    dtw->layoutWidgets();
 
-    sp_tool_toolbox_set_desktop (dtw->tool_toolbox, dtw->desktop);
-    sp_aux_toolbox_set_desktop (dtw->aux_toolbox, dtw->desktop);
-    sp_commands_toolbox_set_desktop (dtw->commands_toolbox, dtw->desktop);
-    sp_snap_toolbox_set_desktop (dtw->snap_toolbox, dtw->desktop);
+    std::vector<GtkWidget *> toolboxes;
+    toolboxes.push_back(dtw->tool_toolbox);
+    toolboxes.push_back(dtw->aux_toolbox);
+    toolboxes.push_back(dtw->commands_toolbox);
+    toolboxes.push_back(dtw->snap_toolbox);
+    UXManager::getInstance()->connectToDesktop( toolboxes, dtw->desktop );
 
     dtw->panels->setDesktop( dtw->desktop );
 
-    return SP_VIEW_WIDGET (dtw);
+    return dtw;
 }
 
 void
@@ -1436,22 +1499,22 @@ sp_desktop_widget_update_vruler (SPDesktopWidget *dtw)
 }
 
 
-static void
-sp_desktop_widget_namedview_modified (SPObject *obj, guint flags, SPDesktopWidget *dtw)
+void SPDesktopWidget::namedviewModified(SPObject *obj, guint flags)
 {
     SPNamedView *nv=SP_NAMEDVIEW(obj);
+
     if (flags & SP_OBJECT_MODIFIED_FLAG) {
-    	dtw->dt2r = 1.0 / nv->doc_units->unittobase;
-        dtw->ruler_origin = Geom::Point(0,0); //nv->gridorigin;   Why was the grid origin used here?
+        this->dt2r = 1.0 / nv->doc_units->unittobase;
+        this->ruler_origin = Geom::Point(0,0); //nv->gridorigin;   Why was the grid origin used here?
 
-        sp_ruler_set_metric (GTK_RULER (dtw->vruler), nv->getDefaultMetric());
-        sp_ruler_set_metric (GTK_RULER (dtw->hruler), nv->getDefaultMetric());
+        sp_ruler_set_metric(GTK_RULER (this->vruler), nv->getDefaultMetric());
+        sp_ruler_set_metric(GTK_RULER (this->hruler), nv->getDefaultMetric());
 
-        gtk_tooltips_set_tip (dtw->tt, dtw->hruler_box, gettext(sp_unit_get_plural (nv->doc_units)), NULL);
-        gtk_tooltips_set_tip (dtw->tt, dtw->vruler_box, gettext(sp_unit_get_plural (nv->doc_units)), NULL);
+        gtk_tooltips_set_tip(this->tt, this->hruler_box, gettext(sp_unit_get_plural (nv->doc_units)), NULL);
+        gtk_tooltips_set_tip(this->tt, this->vruler_box, gettext(sp_unit_get_plural (nv->doc_units)), NULL);
 
-        sp_desktop_widget_update_rulers (dtw);
-        update_snap_toolbox(dtw->desktop, NULL, dtw->snap_toolbox);
+        sp_desktop_widget_update_rulers(this);
+        ToolboxFactory::updateSnapToolbox(this->desktop, 0, this->snap_toolbox);
     }
 }
 
diff --git a/src/widgets/desktop-widget.h b/src/widgets/desktop-widget.h
index 04146cac6..33f2a6ae7 100644
--- a/src/widgets/desktop-widget.h
+++ b/src/widgets/desktop-widget.h
@@ -5,6 +5,7 @@
  * SPDesktopWidget: handling Gtk events on a desktop.
  *
  * Authors:
+ *      Jon A. Cruz <jon@joncruz.org> (c) 2010
  *      John Bintz <jcoswell@coswellproductions.org> (c) 2006
  *      Ralf Stephan <ralf@ark.in-berlin.de> (c) 2005, distrib. under GPL2
  *      ? -2004
@@ -26,28 +27,23 @@
 typedef struct _EgeColorProfTracker EgeColorProfTracker;
 
 
-#define SP_TYPE_DESKTOP_WIDGET (sp_desktop_widget_get_type ())
+#define SP_TYPE_DESKTOP_WIDGET SPDesktopWidget::getType()
 #define SP_DESKTOP_WIDGET(o) (GTK_CHECK_CAST ((o), SP_TYPE_DESKTOP_WIDGET, SPDesktopWidget))
 #define SP_DESKTOP_WIDGET_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), SP_TYPE_DESKTOP_WIDGET, SPDesktopWidgetClass))
 #define SP_IS_DESKTOP_WIDGET(o) (GTK_CHECK_TYPE ((o), SP_TYPE_DESKTOP_WIDGET))
 #define SP_IS_DESKTOP_WIDGET_CLASS(k) (GTK_CHECK_CLASS_TYPE ((k), SP_TYPE_DESKTOP_WIDGET))
 
-GtkType sp_desktop_widget_get_type();
-
 void sp_desktop_widget_destroy (SPDesktopWidget* dtw);
 
 void sp_desktop_widget_show_decorations(SPDesktopWidget *dtw, gboolean show);
 void sp_desktop_widget_iconify(SPDesktopWidget *dtw);
 void sp_desktop_widget_maximize(SPDesktopWidget *dtw);
 void sp_desktop_widget_fullscreen(SPDesktopWidget *dtw);
-void sp_desktop_widget_layout(SPDesktopWidget *dtw);
 void sp_desktop_widget_update_zoom(SPDesktopWidget *dtw);
 void sp_desktop_widget_update_rulers (SPDesktopWidget *dtw);
 void sp_desktop_widget_update_hruler (SPDesktopWidget *dtw);
 void sp_desktop_widget_update_vruler (SPDesktopWidget *dtw);
 
-void sp_desktop_widget_update_namedview (SPDesktopWidget *dtw);
-
 /* Show/hide rulers & scrollbars */
 void sp_desktop_widget_toggle_rulers (SPDesktopWidget *dtw);
 void sp_desktop_widget_toggle_scrollbars (SPDesktopWidget *dtw);
@@ -80,14 +76,14 @@ struct SPDesktopWidget {
     // The root vbox of the window layout.
     GtkWidget *vbox;
 
+    GtkWidget *hbox;
+
     GtkWidget *menubar, *statusbar;
 
     Inkscape::UI::Dialogs::SwatchesPanel *panels;
 
     GtkWidget *hscrollbar, *vscrollbar, *vscrollbar_box;
 
-    GtkWidget *tool_toolbox, *aux_toolbox, *commands_toolbox, *snap_toolbox;
-
     /* Rulers */
     GtkWidget *hruler, *vruler;
     GtkWidget *hruler_box, *vruler_box; // eventboxes for setting tooltips
@@ -129,8 +125,11 @@ struct SPDesktopWidget {
             { _dtw->updateTitle (uri); }
         virtual Gtk::Window* getWindow()
             { return _dtw->window; }
-        virtual void layout()
-            { sp_desktop_widget_layout (_dtw); }
+
+        virtual void layout() {
+            _dtw->layoutWidgets();
+        }
+
         virtual void present()
             { _dtw->presentWindow(); }
         virtual void getGeometry (gint &x, gint &y, gint &w, gint &h)
@@ -221,6 +220,7 @@ struct SPDesktopWidget {
     void setToolboxAdjustmentValue (gchar const * id, double value);
     void setToolboxSelectOneValue (gchar const * id, gint value);
     bool isToolboxButtonActive (gchar const *id);
+    void setToolboxPosition(Glib::ustring const& id, GtkPositionType pos);
     void setCoordinateStatus(Geom::Point p);
     void requestCanvasUpdate();
     void requestCanvasUpdateAndWait();
@@ -231,6 +231,22 @@ struct SPDesktopWidget {
 
     Inkscape::UI::Widget::Dock* getDock();
 
+    static GtkType getType();
+    static SPDesktopWidget* createInstance(SPNamedView *namedview);
+
+    void updateNamedview();
+
+private:
+    GtkWidget *tool_toolbox;
+    GtkWidget *aux_toolbox;
+    GtkWidget *commands_toolbox,;
+    GtkWidget *snap_toolbox;
+
+    static void init(SPDesktopWidget *widget);
+    void layoutWidgets();
+
+    void namedviewModified(SPObject *obj, guint flags);
+
 };
 
 /// The SPDesktopWidget vtable
diff --git a/src/widgets/fill-style.cpp b/src/widgets/fill-style.cpp
index 5e9d30bcd..3f2018b91 100644
--- a/src/widgets/fill-style.cpp
+++ b/src/widgets/fill-style.cpp
@@ -58,12 +58,12 @@ static void sp_fill_style_widget_change_selection   ( SPWidget *spw,
 
 static void sp_fill_style_widget_update (SPWidget *spw);
 
-static void sp_fill_style_widget_paint_mode_changed ( SPPaintSelector *psel,
-                                                      SPPaintSelectorMode mode,
-                                                      SPWidget *spw );
-static void sp_fill_style_widget_fillrule_changed ( SPPaintSelector *psel,
-                                          SPPaintSelectorFillRule mode,
-                                                    SPWidget *spw );
+static void sp_fill_style_widget_paint_mode_changed( SPPaintSelector *psel,
+                                                     SPPaintSelector::Mode mode,
+                                                     SPWidget *spw );
+static void sp_fill_style_widget_fillrule_changed( SPPaintSelector *psel,
+                                                   SPPaintSelector::FillRule mode,
+                                                   SPWidget *spw );
 
 static void sp_fill_style_widget_paint_dragged (SPPaintSelector *psel, SPWidget *spw );
 static void sp_fill_style_widget_paint_changed (SPPaintSelector *psel, SPWidget *spw );
@@ -124,8 +124,8 @@ static void
 sp_fill_style_widget_construct( SPWidget *spw, SPPaintSelector */*psel*/ )
 {
 #ifdef SP_FS_VERBOSE
-    g_print ( "Fill style widget constructed: inkscape %p repr %p\n",
-              spw->inkscape, spw->repr );
+    g_print ( "Fill style widget constructed: inkscape %p\n",
+              spw->inkscape );
 #endif
     if (spw->inkscape) {
         sp_fill_style_widget_update (spw);
@@ -143,6 +143,9 @@ sp_fill_style_widget_modify_selection( SPWidget *spw,
                   SP_OBJECT_PARENT_MODIFIED_FLAG |
                   SP_OBJECT_STYLE_MODIFIED_FLAG) )
     {
+#ifdef SP_FS_VERBOSE
+        g_message("sp_fill_style_widget_modify_selection()");
+#endif
         sp_fill_style_widget_update (spw);
     }
 }
@@ -184,51 +187,52 @@ sp_fill_style_widget_update (SPWidget *spw)
     // create temporary style
     SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT);
     // query style from desktop into it. This returns a result flag and fills query with the style of subselection, if any, or selection
-    int result = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FILL); 
+    int result = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FILL);
 
     switch (result) {
         case QUERY_STYLE_NOTHING:
         {
             /* No paint at all */
-            sp_paint_selector_set_mode (psel, SP_PAINT_SELECTOR_MODE_EMPTY);
+            psel->setMode(SPPaintSelector::MODE_EMPTY);
             break;
         }
 
         case QUERY_STYLE_SINGLE:
         case QUERY_STYLE_MULTIPLE_AVERAGED: // TODO: treat this slightly differently, e.g. display "averaged" somewhere in paint selector
-        case QUERY_STYLE_MULTIPLE_SAME: 
+        case QUERY_STYLE_MULTIPLE_SAME:
         {
-            SPPaintSelectorMode pselmode = sp_style_determine_paint_selector_mode (query, true);
-            sp_paint_selector_set_mode (psel, pselmode);
+            SPPaintSelector::Mode pselmode = SPPaintSelector::getModeForStyle(*query, true);
+            psel->setMode(pselmode);
 
-            sp_paint_selector_set_fillrule (psel, query->fill_rule.computed == ART_WIND_RULE_NONZERO? 
-                                     SP_PAINT_SELECTOR_FILLRULE_NONZERO : SP_PAINT_SELECTOR_FILLRULE_EVENODD);
+            psel->setFillrule(query->fill_rule.computed == ART_WIND_RULE_NONZERO?
+                              SPPaintSelector::FILLRULE_NONZERO : SPPaintSelector::FILLRULE_EVENODD);
 
             if (query->fill.set && query->fill.isColor()) {
-                sp_paint_selector_set_color_alpha (psel, &query->fill.value.color, SP_SCALE24_TO_FLOAT (query->fill_opacity.value));
+                psel->setColorAlpha(query->fill.value.color, SP_SCALE24_TO_FLOAT(query->fill_opacity.value));
             } else if (query->fill.set && query->fill.isPaintserver()) {
 
-                SPPaintServer *server = SP_STYLE_FILL_SERVER (query);
+                SPPaintServer *server = query->getFillPaintServer();
 
-                if (SP_IS_LINEARGRADIENT (server)) {
-                    SPGradient *vector = sp_gradient_get_vector (SP_GRADIENT (server), FALSE);
-                    sp_paint_selector_set_gradient_linear (psel, vector);
+                if (server && SP_IS_GRADIENT(server) && SP_GRADIENT(server)->getVector()->isSwatch()) {
+                    SPGradient *vector = SP_GRADIENT(server)->getVector();
+                    psel->setSwatch( vector );
+                } else if (SP_IS_LINEARGRADIENT (server)) {
+                    SPGradient *vector = SP_GRADIENT(server)->getVector();
+                    psel->setGradientLinear( vector );
 
                     SPLinearGradient *lg = SP_LINEARGRADIENT (server);
-                    sp_paint_selector_set_gradient_properties (psel,
-                                                       SP_GRADIENT_UNITS (lg),
-                                                       SP_GRADIENT_SPREAD (lg));
+                    psel->setGradientProperties( SP_GRADIENT_UNITS(lg),
+                                                 SP_GRADIENT_SPREAD(lg) );
                 } else if (SP_IS_RADIALGRADIENT (server)) {
-                    SPGradient *vector = sp_gradient_get_vector (SP_GRADIENT (server), FALSE);
-                    sp_paint_selector_set_gradient_radial (psel, vector);
+                    SPGradient *vector = SP_GRADIENT(server)->getVector();
+                    psel->setGradientRadial( vector );
 
                     SPRadialGradient *rg = SP_RADIALGRADIENT (server);
-                    sp_paint_selector_set_gradient_properties (psel,
-                                                       SP_GRADIENT_UNITS (rg),
-                                                       SP_GRADIENT_SPREAD (rg));
+                    psel->setGradientProperties( SP_GRADIENT_UNITS (rg),
+                                                 SP_GRADIENT_SPREAD (rg) );
                 } else if (SP_IS_PATTERN (server)) {
                     SPPattern *pat = pattern_getroot (SP_PATTERN (server));
-                    sp_update_pattern_list (psel, pat);
+                    psel->updatePatternList( pat );
                 }
             }
             break;
@@ -236,7 +240,7 @@ sp_fill_style_widget_update (SPWidget *spw)
 
         case QUERY_STYLE_MULTIPLE_DIFFERENT:
         {
-            sp_paint_selector_set_mode (psel, SP_PAINT_SELECTOR_MODE_MULTIPLE);
+            psel->setMode(SPPaintSelector::MODE_MULTIPLE);
             break;
         }
     }
@@ -249,23 +253,26 @@ sp_fill_style_widget_update (SPWidget *spw)
 
 
 static void
-sp_fill_style_widget_paint_mode_changed ( SPPaintSelector *psel,
-                                          SPPaintSelectorMode /*mode*/,
-                                          SPWidget *spw )
+sp_fill_style_widget_paint_mode_changed( SPPaintSelector *psel,
+                                         SPPaintSelector::Mode /*mode*/,
+                                         SPWidget *spw )
 {
     if (g_object_get_data (G_OBJECT (spw), "update"))
         return;
 
+#ifdef SP_FS_VERBOSE
+    g_message("sp_fill_style_widget_paint_mode_changed(psel:%p, mode, spw:%p)", psel, spw);
+#endif
+
     /* TODO: Does this work? */
     /* TODO: Not really, here we have to get old color back from object */
     /* Instead of relying on paint widget having meaningful colors set */
     sp_fill_style_widget_paint_changed (psel, spw);
 }
 
-static void
-sp_fill_style_widget_fillrule_changed ( SPPaintSelector */*psel*/,
-                                          SPPaintSelectorFillRule mode,
-                                          SPWidget *spw )
+static void sp_fill_style_widget_fillrule_changed( SPPaintSelector */*psel*/,
+                                                   SPPaintSelector::FillRule mode,
+                                                   SPWidget *spw )
 {
     if (g_object_get_data (G_OBJECT (spw), "update"))
         return;
@@ -273,13 +280,13 @@ sp_fill_style_widget_fillrule_changed ( SPPaintSelector */*psel*/,
     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
 
     SPCSSAttr *css = sp_repr_css_attr_new ();
-    sp_repr_css_set_property (css, "fill-rule", mode == SP_PAINT_SELECTOR_FILLRULE_EVENODD? "evenodd":"nonzero");
+    sp_repr_css_set_property(css, "fill-rule", mode == SPPaintSelector::FILLRULE_EVENODD? "evenodd":"nonzero");
 
     sp_desktop_set_style (desktop, css);
 
     sp_repr_css_attr_unref (css);
 
-    sp_document_done (SP_ACTIVE_DOCUMENT, SP_VERB_DIALOG_FILL_STROKE, 
+    sp_document_done (SP_ACTIVE_DOCUMENT, SP_VERB_DIALOG_FILL_STROKE,
                       _("Change fill rule"));
 }
 
@@ -305,8 +312,8 @@ sp_fill_style_widget_paint_dragged (SPPaintSelector *psel, SPWidget *spw)
     }
 
     if (g_object_get_data (G_OBJECT (spw), "local")) {
-        // previous local flag not cleared yet; 
-        // this means dragged events come too fast, so we better skip this one to speed up display 
+        // previous local flag not cleared yet;
+        // this means dragged events come too fast, so we better skip this one to speed up display
         // (it's safe to do this in any case)
         return;
     }
@@ -315,11 +322,11 @@ sp_fill_style_widget_paint_dragged (SPPaintSelector *psel, SPWidget *spw)
 
     switch (psel->mode) {
 
-        case SP_PAINT_SELECTOR_MODE_COLOR_RGB:
-        case SP_PAINT_SELECTOR_MODE_COLOR_CMYK:
+        case SPPaintSelector::MODE_COLOR_RGB:
+        case SPPaintSelector::MODE_COLOR_CMYK:
         {
-            sp_paint_selector_set_flat_color (psel, SP_ACTIVE_DESKTOP, "fill", "fill-opacity");
-            sp_document_maybe_done (sp_desktop_document(SP_ACTIVE_DESKTOP), undo_label, SP_VERB_DIALOG_FILL_STROKE, 
+            psel->setFlatColor( SP_ACTIVE_DESKTOP, "fill", "fill-opacity" );
+            sp_document_maybe_done (sp_desktop_document(SP_ACTIVE_DESKTOP), undo_label, SP_VERB_DIALOG_FILL_STROKE,
                                     _("Set fill color"));
             g_object_set_data (G_OBJECT (spw), "local", GINT_TO_POINTER (TRUE)); // local change, do not update from selection
             break;
@@ -346,6 +353,9 @@ static void
 sp_fill_style_widget_paint_changed ( SPPaintSelector *psel,
                                      SPWidget *spw )
 {
+#ifdef SP_FS_VERBOSE
+    g_message("sp_fill_style_widget_paint_changed(psel:%p, spw:%p)", psel, spw);
+#endif
     if (g_object_get_data (G_OBJECT (spw), "update")) {
         return;
     }
@@ -362,17 +372,17 @@ sp_fill_style_widget_paint_changed ( SPPaintSelector *psel,
 
     switch (psel->mode) {
 
-        case SP_PAINT_SELECTOR_MODE_EMPTY:
+        case SPPaintSelector::MODE_EMPTY:
             // This should not happen.
             g_warning ( "file %s: line %d: Paint %d should not emit 'changed'",
                         __FILE__, __LINE__, psel->mode);
             break;
-        case SP_PAINT_SELECTOR_MODE_MULTIPLE:
+        case SPPaintSelector::MODE_MULTIPLE:
             // This happens when you switch multiple objects with different gradients to flat color;
             // nothing to do here.
             break;
 
-        case SP_PAINT_SELECTOR_MODE_NONE:
+        case SPPaintSelector::MODE_NONE:
         {
             SPCSSAttr *css = sp_repr_css_attr_new ();
             sp_repr_css_set_property (css, "fill", "none");
@@ -381,18 +391,18 @@ sp_fill_style_widget_paint_changed ( SPPaintSelector *psel,
 
             sp_repr_css_attr_unref (css);
 
-            sp_document_done (document, SP_VERB_DIALOG_FILL_STROKE, 
+            sp_document_done (document, SP_VERB_DIALOG_FILL_STROKE,
                               _("Remove fill"));
             break;
         }
 
-        case SP_PAINT_SELECTOR_MODE_COLOR_RGB:
-        case SP_PAINT_SELECTOR_MODE_COLOR_CMYK:
+        case SPPaintSelector::MODE_COLOR_RGB:
+        case SPPaintSelector::MODE_COLOR_CMYK:
         {
             // FIXME: fix for GTK breakage, see comment in SelectedStyle::on_opacity_changed; here it results in losing release events
             sp_canvas_force_full_redraw_after_interruptions(sp_desktop_canvas(desktop), 0);
 
-            sp_paint_selector_set_flat_color (psel, desktop, "fill", "fill-opacity");
+            psel->setFlatColor( desktop, "fill", "fill-opacity" );
             sp_document_maybe_done (sp_desktop_document(desktop), undo_label, SP_VERB_DIALOG_FILL_STROKE,
                                     _("Set fill color"));
             // resume interruptibility
@@ -407,10 +417,11 @@ sp_fill_style_widget_paint_changed ( SPPaintSelector *psel,
             break;
         }
 
-        case SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR:
-        case SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL:
+        case SPPaintSelector::MODE_GRADIENT_LINEAR:
+        case SPPaintSelector::MODE_GRADIENT_RADIAL:
+        case SPPaintSelector::MODE_SWATCH:
             if (items) {
-                SPGradientType const gradient_type = ( psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR
+                SPGradientType const gradient_type = ( psel->mode != SPPaintSelector::MODE_GRADIENT_RADIAL
                                                        ? SP_GRADIENT_TYPE_LINEAR
                                                        : SP_GRADIENT_TYPE_RADIAL );
 
@@ -418,7 +429,7 @@ sp_fill_style_widget_paint_changed ( SPPaintSelector *psel,
                 SPCSSAttr *css = sp_repr_css_attr_new();
                 sp_repr_css_set_property(css, "fill-opacity", "1.0");
 
-                SPGradient *vector = sp_paint_selector_get_gradient_vector(psel);
+                SPGradient *vector = psel->getGradientVector();
                 if (!vector) {
                     /* No vector in paint selector should mean that we just changed mode */
 
@@ -456,22 +467,22 @@ sp_fill_style_widget_paint_changed ( SPPaintSelector *psel,
                         sp_repr_css_change_recursive (SP_OBJECT_REPR (i->data), css, "style");
 
                         SPGradient *gr = sp_item_set_gradient(SP_ITEM(i->data), vector, gradient_type, true);
-                        sp_gradient_selector_attrs_to_gradient (gr, psel);
+                        psel->pushAttrsToGradient( gr );
                     }
                 }
 
                 sp_repr_css_attr_unref (css);
 
-                sp_document_done (document, SP_VERB_DIALOG_FILL_STROKE, 
+                sp_document_done (document, SP_VERB_DIALOG_FILL_STROKE,
                                   _("Set gradient on fill"));
             }
             break;
 
-        case SP_PAINT_SELECTOR_MODE_PATTERN:
+        case SPPaintSelector::MODE_PATTERN:
 
             if (items) {
 
-                SPPattern *pattern = sp_paint_selector_get_pattern (psel);
+                SPPattern *pattern = psel->getPattern();
                 if (!pattern) {
 
                     /* No Pattern in paint selector should mean that we just
@@ -509,14 +520,14 @@ sp_fill_style_widget_paint_changed ( SPPaintSelector *psel,
 
                 } // end if
 
-                sp_document_done (document, SP_VERB_DIALOG_FILL_STROKE, 
+                sp_document_done (document, SP_VERB_DIALOG_FILL_STROKE,
                                   _("Set pattern on fill"));
 
             } // end if
 
             break;
 
-        case SP_PAINT_SELECTOR_MODE_UNSET:
+        case SPPaintSelector::MODE_UNSET:
             if (items) {
                     SPCSSAttr *css = sp_repr_css_attr_new ();
                     sp_repr_css_unset_property (css, "fill");
@@ -524,7 +535,7 @@ sp_fill_style_widget_paint_changed ( SPPaintSelector *psel,
                     sp_desktop_set_style (desktop, css);
                     sp_repr_css_attr_unref (css);
 
-                    sp_document_done (document, SP_VERB_DIALOG_FILL_STROKE, 
+                    sp_document_done (document, SP_VERB_DIALOG_FILL_STROKE,
                                       _("Unset fill"));
             }
             break;
diff --git a/src/widgets/gradient-selector.cpp b/src/widgets/gradient-selector.cpp
index f24a6781b..bc2413730 100644
--- a/src/widgets/gradient-selector.cpp
+++ b/src/widgets/gradient-selector.cpp
@@ -4,9 +4,11 @@
  * Authors:
  *   Lauris Kaplinski <lauris@kaplinski.com>
  *   bulia byak <buliabyak@users.sf.net>
+ *   Jon A. Cruz <jon@joncruz.org>
  *
  * Copyright (C) 2001-2002 Lauris Kaplinski
  * Copyright (C) 2001 Ximian, Inc.
+ * Copyright (C) 2010 Jon A. Cruz
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
@@ -118,9 +120,9 @@ sp_gradient_selector_class_init (SPGradientSelectorClass *klass)
 static void
 sp_gradient_selector_init (SPGradientSelector *sel)
 {
-    GtkWidget *hb, *l, *m, *mi;
+    GtkWidget *hb, *m, *mi;
 
-    sel->mode = SP_GRADIENT_SELECTOR_MODE_LINEAR;
+    sel->mode = SPGradientSelector::MODE_LINEAR;
 
     sel->gradientUnits = SP_GRADIENT_UNITS_USERSPACEONUSE;
     sel->gradientSpread = SP_GRADIENT_SPREAD_PAD;
@@ -180,9 +182,9 @@ sp_gradient_selector_init (SPGradientSelector *sel)
 
     gtk_option_menu_set_menu (GTK_OPTION_MENU (sel->spread), m);
 
-    l = gtk_label_new (_("Repeat:"));
-    gtk_widget_show (l);
-    gtk_box_pack_end (GTK_BOX (hb), l, FALSE, FALSE, 4);
+    sel->spreadLbl = gtk_label_new (_("Repeat:"));
+    gtk_widget_show(sel->spreadLbl);
+    gtk_box_pack_end(GTK_BOX(hb), sel->spreadLbl, FALSE, FALSE, 4);
 }
 
 static void
@@ -206,77 +208,78 @@ sp_gradient_selector_new (void)
     return (GtkWidget *) sel;
 }
 
-void
-sp_gradient_selector_set_mode (SPGradientSelector *sel, guint mode)
+void SPGradientSelector::setMode(SelectorMode mode)
 {
-    g_return_if_fail (sel != NULL);
-    g_return_if_fail (SP_IS_GRADIENT_SELECTOR (sel));
-
-    sel->mode = mode;
+    if (mode != this->mode) {
+        this->mode = mode;
+        if (mode == MODE_SWATCH) {
+            if (spread) {
+                GtkWidget *parent = gtk_widget_get_parent(spread);
+                if (parent) {
+                    gtk_container_remove(GTK_CONTAINER(parent), spread);
+                    spread = 0;
+                }
+            }
+            if (spreadLbl) {
+                GtkWidget *parent = gtk_widget_get_parent(spreadLbl);
+                if (parent) {
+                    gtk_container_remove(GTK_CONTAINER(parent), spreadLbl);
+                    spreadLbl = 0;
+                }
+            }
+
+            SPGradientVectorSelector* vs = SP_GRADIENT_VECTOR_SELECTOR(vectors);
+            vs->setSwatched();
+        }
+    }
 }
 
-void
-sp_gradient_selector_set_units (SPGradientSelector *sel, guint units)
+void SPGradientSelector::setUnits(SPGradientUnits units)
 {
-    g_return_if_fail (sel != NULL);
-    g_return_if_fail (SP_IS_GRADIENT_SELECTOR (sel));
-
-    sel->gradientUnits = (SPGradientUnits)units;
+    gradientUnits = units;
 }
 
-void
-sp_gradient_selector_set_spread (SPGradientSelector *sel, guint spread)
+void SPGradientSelector::setSpread(SPGradientSpread spread)
 {
-    g_return_if_fail (sel != NULL);
-    g_return_if_fail (SP_IS_GRADIENT_SELECTOR (sel));
+    gradientSpread = spread;
 
-    sel->gradientSpread = (SPGradientSpread)spread;
-
-    gtk_option_menu_set_history (GTK_OPTION_MENU (sel->spread), sel->gradientSpread);
+    gtk_option_menu_set_history(GTK_OPTION_MENU(this->spread), gradientSpread);
 }
 
-SPGradientUnits
-sp_gradient_selector_get_units (SPGradientSelector *sel)
+SPGradientUnits SPGradientSelector::getUnits()
 {
-    return (SPGradientUnits) sel->gradientUnits;
+    return gradientUnits;
 }
 
-SPGradientSpread
-sp_gradient_selector_get_spread (SPGradientSelector *sel)
+SPGradientSpread SPGradientSelector::getSpread()
 {
-    return (SPGradientSpread) sel->gradientSpread;
+    return gradientSpread;
 }
 
-void
-sp_gradient_selector_set_vector (SPGradientSelector *sel, SPDocument *doc, SPGradient *vector)
+void SPGradientSelector::setVector(SPDocument *doc, SPGradient *vector)
 {
-    g_return_if_fail (sel != NULL);
-    g_return_if_fail (SP_IS_GRADIENT_SELECTOR (sel));
-    g_return_if_fail (!vector || SP_IS_GRADIENT (vector));
-    g_return_if_fail (!vector || (SP_OBJECT_DOCUMENT (vector) == doc));
+    g_return_if_fail(!vector || SP_IS_GRADIENT(vector));
+    g_return_if_fail(!vector || (SP_OBJECT_DOCUMENT(vector) == doc));
 
-    if (vector && !SP_GRADIENT_HAS_STOPS (vector))
+    if (vector && !SP_GRADIENT_HAS_STOPS(vector)) {
         return;
+    }
 
-    sp_gradient_vector_selector_set_gradient (SP_GRADIENT_VECTOR_SELECTOR (sel->vectors), doc, vector);
+    sp_gradient_vector_selector_set_gradient(SP_GRADIENT_VECTOR_SELECTOR(vectors), doc, vector);
 
     if (vector) {
-        gtk_widget_set_sensitive (sel->edit, TRUE);
-        gtk_widget_set_sensitive (sel->add, TRUE);
+        gtk_widget_set_sensitive(edit, TRUE);
+        gtk_widget_set_sensitive(add, TRUE);
     } else {
-        gtk_widget_set_sensitive (sel->edit, FALSE);
-        gtk_widget_set_sensitive (sel->add, (doc != NULL));
+        gtk_widget_set_sensitive(edit, FALSE);
+        gtk_widget_set_sensitive(add, (doc != NULL));
     }
 }
 
-SPGradient *
-sp_gradient_selector_get_vector (SPGradientSelector *sel)
+SPGradient *SPGradientSelector::getVector()
 {
-    if (sel == NULL || !SP_IS_GRADIENT_SELECTOR (sel))
-        return NULL;
-
     /* fixme: */
-    return SP_GRADIENT_VECTOR_SELECTOR (sel->vectors)->gr;
+    return SP_GRADIENT_VECTOR_SELECTOR(vectors)->gr;
 }
 
 static void
@@ -287,7 +290,7 @@ sp_gradient_selector_vector_set (SPGradientVectorSelector */*gvs*/, SPGradient *
     if (!blocked) {
         blocked = TRUE;
         gr = sp_gradient_ensure_vector_normalized (gr);
-        sp_gradient_selector_set_vector (sel, (gr) ? SP_OBJECT_DOCUMENT (gr) : NULL, gr);
+        sel->setVector((gr) ? SP_OBJECT_DOCUMENT (gr) : 0, gr);
         g_signal_emit (G_OBJECT (sel), signals[CHANGED], 0, gr);
         blocked = FALSE;
     }
diff --git a/src/widgets/gradient-selector.h b/src/widgets/gradient-selector.h
index e68dfecfc..25f561a6e 100644
--- a/src/widgets/gradient-selector.h
+++ b/src/widgets/gradient-selector.h
@@ -6,16 +6,21 @@
  *
  * Authors:
  *   Lauris Kaplinski <lauris@kaplinski.com>
+ *   Jon A. Cruz <jon@joncruz.org>
  *
  * Copyright (C) 2001-2002 Lauris Kaplinski
  * Copyright (C) 2001 Ximian, Inc.
+ * Copyright (C) 2010 Jon A. Cruz
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
 #include <glib.h>
+#include <gtk/gtkvbox.h>
+#include "sp-gradient.h"
 #include "sp-gradient-spread.h"
 #include "sp-gradient-units.h"
+
 class SPGradient;
 
 #define SP_TYPE_GRADIENT_SELECTOR (sp_gradient_selector_get_type ())
@@ -24,32 +29,43 @@ class SPGradient;
 #define SP_IS_GRADIENT_SELECTOR(o) (GTK_CHECK_TYPE ((o), SP_TYPE_GRADIENT_SELECTOR))
 #define SP_IS_GRADIENT_SELECTOR_CLASS(k) (GTK_CHECK_CLASS_TYPE ((k), SP_TYPE_GRADIENT_SELECTOR))
 
-#include <libnr/nr-forward.h>
-#include <gtk/gtkvbox.h>
-#include "../forward.h"
-#include <sp-gradient.h>
 
-enum {
-    SP_GRADIENT_SELECTOR_MODE_LINEAR,
-    SP_GRADIENT_SELECTOR_MODE_RADIAL
-};
 
 struct SPGradientSelector {
     GtkVBox vbox;
 
-    guint mode : 1;
+    enum SelectorMode {
+        MODE_LINEAR,
+        MODE_RADIAL,
+        MODE_SWATCH
+    };
+
+    SelectorMode mode;
 
-    SPGradientUnits gradientUnits : 1;
-    SPGradientSpread gradientSpread : 2;
+    SPGradientUnits gradientUnits;
+    SPGradientSpread gradientSpread;
 
     /* Vector selector */
     GtkWidget *vectors;
+
     /* Editing buttons */
-    GtkWidget *edit, *add;
+    GtkWidget *edit;
+    GtkWidget *add;
+
     /* Position widget */
     GtkWidget *position;
+
     /* Spread selector */
     GtkWidget *spread;
+    GtkWidget *spreadLbl;
+
+    void setMode(SelectorMode mode);
+    void setUnits(SPGradientUnits units);
+    void setSpread(SPGradientSpread spread);
+    void setVector(SPDocument *doc, SPGradient *vector);
+    SPGradientUnits getUnits();
+    SPGradientSpread getSpread();
+    SPGradient *getVector();
 };
 
 struct SPGradientSelectorClass {
@@ -65,17 +81,8 @@ GType sp_gradient_selector_get_type(void);
 
 GtkWidget *sp_gradient_selector_new (void);
 
-void sp_gradient_selector_set_mode (SPGradientSelector *sel, guint mode);
-void sp_gradient_selector_set_units (SPGradientSelector *sel, guint units);
-void sp_gradient_selector_set_spread (SPGradientSelector *sel, guint spread);
-void sp_gradient_selector_set_vector (SPGradientSelector *sel, SPDocument *doc, SPGradient *vector);
 void sp_gradient_selector_set_bbox (SPGradientSelector *sel, gdouble x0, gdouble y0, gdouble x1, gdouble y1);
 
-SPGradientUnits sp_gradient_selector_get_units (SPGradientSelector *sel);
-SPGradientSpread sp_gradient_selector_get_spread (SPGradientSelector *sel);
-
-SPGradient *sp_gradient_selector_get_vector (SPGradientSelector *sel);
-
 #endif // SEEN_GRADIENT_SELECTOR_H
 
 
diff --git a/src/widgets/gradient-toolbar.cpp b/src/widgets/gradient-toolbar.cpp
index ddd9fd96a..077e038e7 100644
--- a/src/widgets/gradient-toolbar.cpp
+++ b/src/widgets/gradient-toolbar.cpp
@@ -164,8 +164,7 @@ gr_prepare_label (SPObject *obj)
     return g_strdup_printf ("<small>%s</small>", id);
 }
 
-GtkWidget *
-gr_vector_list (SPDesktop *desktop, bool selection_empty, SPGradient *gr_selected, bool gr_multi)
+GtkWidget *gr_vector_list(SPDesktop *desktop, bool selection_empty, SPGradient *gr_selected, bool gr_multi)
 {
     SPDocument *document = sp_desktop_document (desktop);
 
@@ -175,7 +174,8 @@ gr_vector_list (SPDesktop *desktop, bool selection_empty, SPGradient *gr_selecte
     GSList *gl = NULL;
     const GSList *gradients = sp_document_get_resource_list (document, "gradient");
     for (const GSList *i = gradients; i != NULL; i = i->next) {
-        if (SP_GRADIENT_HAS_STOPS (i->data)) {
+        SPGradient *grad = SP_GRADIENT(i->data);
+        if (SP_GRADIENT_HAS_STOPS(grad) && !grad->isSolid()) {
             gl = g_slist_prepend (gl, i->data);
         }
     }
@@ -185,6 +185,7 @@ gr_vector_list (SPDesktop *desktop, bool selection_empty, SPGradient *gr_selecte
     guint idx = 0;
 
     if (!gl) {
+        // The document has no gradients
         GtkWidget *l = gtk_label_new("");
         gtk_label_set_markup (GTK_LABEL(l), _("<small>No gradients</small>"));
         GtkWidget *i = gtk_menu_item_new ();
@@ -194,6 +195,7 @@ gr_vector_list (SPDesktop *desktop, bool selection_empty, SPGradient *gr_selecte
         gtk_menu_append (GTK_MENU (m), i);
         gtk_widget_set_sensitive (om, FALSE);
     } else if (selection_empty) {
+        // Document has gradients, but nothing is currently selected.
         GtkWidget *l = gtk_label_new("");
         gtk_label_set_markup (GTK_LABEL(l), _("<small>Nothing selected</small>"));
         GtkWidget *i = gtk_menu_item_new ();
@@ -268,29 +270,37 @@ gr_vector_list (SPDesktop *desktop, bool selection_empty, SPGradient *gr_selecte
 }
 
 
-void
-gr_read_selection (Inkscape::Selection *selection, GrDrag *drag, SPGradient **gr_selected, bool *gr_multi, SPGradientSpread *spr_selected, bool *spr_multi)
+void gr_read_selection( Inkscape::Selection *selection,
+                        GrDrag *drag,
+                        SPGradient *&gr_selected,
+                        bool &gr_multi,
+                        SPGradientSpread &spr_selected,
+                        bool &spr_multi )
 {
     if (drag && drag->selected) {
         // GRADIENTFIXME: make this work for more than one selected dragger?
-        GrDragger *dragger = (GrDragger*) drag->selected->data;
-        for (GSList const* i = dragger->draggables; i != NULL; i = i->next) { // for all draggables of dragger
-            GrDraggable *draggable = (GrDraggable *) i->data;
-            SPGradient *gradient = sp_item_gradient_get_vector (draggable->item, draggable->fill_or_stroke);
-            SPGradientSpread spread = sp_item_gradient_get_spread (draggable->item, draggable->fill_or_stroke);
+        GrDragger *dragger = static_cast<GrDragger*>(drag->selected->data);
+        for (GSList const* i = dragger->draggables; i; i = i->next) { // for all draggables of dragger
+            GrDraggable *draggable = static_cast<GrDraggable *>(i->data);
+            SPGradient *gradient = sp_item_gradient_get_vector(draggable->item, draggable->fill_or_stroke);
+            SPGradientSpread spread = sp_item_gradient_get_spread(draggable->item, draggable->fill_or_stroke);
+
+            if (gradient && gradient->isSolid()) {
+                gradient = 0;
+            }
 
-            if (gradient != *gr_selected) {
-                if (*gr_selected != NULL) {
-                    *gr_multi = true;
+            if (gradient && (gradient != gr_selected)) {
+                if (gr_selected) {
+                    gr_multi = true;
                 } else {
-                    *gr_selected = gradient;
+                    gr_selected = gradient;
                 }
             }
-            if (spread != *spr_selected) {
-                if (*spr_selected != INT_MAX) {
-                    *spr_multi = true;
+            if (spread != spr_selected) {
+                if (spr_selected != INT_MAX) {
+                    spr_multi = true;
                 } else {
-                    *spr_selected = spread;
+                    spr_selected = spread;
                 }
             }
          }
@@ -298,48 +308,59 @@ gr_read_selection (Inkscape::Selection *selection, GrDrag *drag, SPGradient **gr
     }
 
    // If no selected dragger, read desktop selection
-   for (GSList const* i = selection->itemList(); i != NULL; i = i->next) {
+   for (GSList const* i = selection->itemList(); i; i = i->next) {
         SPItem *item = SP_ITEM(i->data);
         SPStyle *style = SP_OBJECT_STYLE (item);
 
         if (style && (style->fill.isPaintserver())) {
             SPObject *server = SP_OBJECT_STYLE_FILL_SERVER (item);
-            if (SP_IS_GRADIENT (server)) {
-                SPGradient *gradient = sp_gradient_get_vector (SP_GRADIENT (server), false);
+            if (SP_IS_GRADIENT(server)) {
+                SPGradient *gradient = SP_GRADIENT(server)->getVector();
                 SPGradientSpread spread = sp_gradient_get_spread (SP_GRADIENT (server));
-                if (gradient != *gr_selected) {
-                    if (*gr_selected != NULL) {
-                        *gr_multi = true;
+
+                if (gradient && gradient->isSolid()) {
+                    gradient = 0;
+                }
+
+                if (gradient && (gradient != gr_selected)) {
+                    if (gr_selected) {
+                        gr_multi = true;
                     } else {
-                        *gr_selected = gradient;
+                        gr_selected = gradient;
                     }
                 }
-                if (spread != *spr_selected) {
-                    if (*spr_selected != INT_MAX) {
-                        *spr_multi = true;
+                if (spread != spr_selected) {
+                    if (spr_selected != INT_MAX) {
+                        spr_multi = true;
                     } else {
-                        *spr_selected = spread;
+                        spr_selected = spread;
                     }
                 }
             }
         }
         if (style && (style->stroke.isPaintserver())) {
             SPObject *server = SP_OBJECT_STYLE_STROKE_SERVER (item);
-            if (SP_IS_GRADIENT (server)) {
-                SPGradient *gradient = sp_gradient_get_vector (SP_GRADIENT (server), false);
+            if (SP_IS_GRADIENT(server)) {
+                SPGradient *gradient = SP_GRADIENT(server)->getVector();
                 SPGradientSpread spread = sp_gradient_get_spread (SP_GRADIENT (server));
-                if (gradient != *gr_selected) {
-                    if (*gr_selected != NULL) {
-                        *gr_multi = true;
+
+                if (gradient && gradient->isSolid()) {
+                    gradient = 0;
+
+                }
+
+                if (gradient && (gradient != gr_selected)) {
+                    if (gr_selected) {
+                        gr_multi = true;
                     } else {
-                        *gr_selected = gradient;
+                        gr_selected = gradient;
                     }
                 }
-                if (spread != *spr_selected) {
-                    if (*spr_selected != INT_MAX) {
-                        *spr_multi = true;
+                if (spread != spr_selected) {
+                    if (spr_selected != INT_MAX) {
+                        spr_multi = true;
                     } else {
-                        *spr_selected = spread;
+                        spr_selected = spread;
                     }
                 }
             }
@@ -347,41 +368,41 @@ gr_read_selection (Inkscape::Selection *selection, GrDrag *drag, SPGradient **gr
     }
  }
 
-static void
-gr_tb_selection_changed (Inkscape::Selection *, gpointer data)
+static void gr_tb_selection_changed(Inkscape::Selection * /*selection*/, gpointer data)
 {
-    GtkWidget *widget = (GtkWidget *) data;
-
-    SPDesktop *desktop = (SPDesktop *) g_object_get_data (G_OBJECT(widget), "desktop");
-    if (!desktop)
-        return;
+    GtkWidget *widget = GTK_WIDGET(data);
+
+    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(G_OBJECT(widget), "desktop"));
+    if (desktop) {
+        Inkscape::Selection *selection = sp_desktop_selection(desktop); // take from desktop, not from args
+        if (selection) {
+            SPEventContext *ev = sp_desktop_event_context(desktop);
+
+            GtkWidget *om = (GtkWidget *) g_object_get_data(G_OBJECT(widget), "menu");
+            if (om) {
+                gtk_widget_destroy(om);
+                om = 0;
+            }
 
-    Inkscape::Selection *selection = sp_desktop_selection (desktop); // take from desktop, not from args
-    if (!selection)
-        return;
+            SPGradient *gr_selected = 0;
+            bool gr_multi = false;
 
-    SPEventContext *ev = sp_desktop_event_context (desktop);
+            SPGradientSpread spr_selected = static_cast<SPGradientSpread>(INT_MAX); // meaning undefined
+            bool spr_multi = false;
 
-    GtkWidget *om = (GtkWidget *) g_object_get_data (G_OBJECT (widget), "menu");
-    if (om) gtk_widget_destroy (om);
+            gr_read_selection(selection, ev ? ev->get_drag() : 0, gr_selected, gr_multi, spr_selected, spr_multi);
 
-    SPGradient *gr_selected = NULL;
-    bool gr_multi = false;
+            om = gr_vector_list(desktop, selection->isEmpty(), gr_selected, gr_multi);
+            g_object_set_data(G_OBJECT(widget), "menu", om);
 
-    SPGradientSpread spr_selected = (SPGradientSpread) INT_MAX; // meaning undefined
-    bool spr_multi = false;
+            GtkWidget *buttons = (GtkWidget *) g_object_get_data(G_OBJECT(widget), "buttons");
+            gtk_widget_set_sensitive(buttons, (gr_selected && !gr_multi));
 
-    gr_read_selection (selection, ev? ev->get_drag() : NULL, &gr_selected, &gr_multi, &spr_selected, &spr_multi);
-
-    om = gr_vector_list (desktop, selection->isEmpty(), gr_selected, gr_multi);
-    g_object_set_data (G_OBJECT (widget), "menu", om);
+            gtk_box_pack_start(GTK_BOX(widget), om, TRUE, TRUE, 0);
 
-    GtkWidget *buttons = (GtkWidget *) g_object_get_data (G_OBJECT(widget), "buttons");
-    gtk_widget_set_sensitive (buttons, (gr_selected && !gr_multi));
-
-    gtk_box_pack_start (GTK_BOX (widget), om, TRUE, TRUE, 0);
-
-    gtk_widget_show_all (widget);
+            gtk_widget_show_all(widget);
+        }
+    }
 }
 
 static void
@@ -431,8 +452,7 @@ gr_edit (GtkWidget */*button*/, GtkWidget *widget)
     }
 }
 
-GtkWidget *
-gr_change_widget (SPDesktop *desktop)
+GtkWidget * gr_change_widget(SPDesktop *desktop)
 {
     Inkscape::Selection *selection = sp_desktop_selection (desktop);
     SPDocument *document = sp_desktop_document (desktop);
@@ -446,7 +466,7 @@ gr_change_widget (SPDesktop *desktop)
 
     GtkTooltips *tt = gtk_tooltips_new();
 
-    gr_read_selection (selection, ev? ev->get_drag() : NULL, &gr_selected, &gr_multi, &spr_selected, &spr_multi);
+    gr_read_selection (selection, ev? ev->get_drag() : 0, gr_selected, gr_multi, spr_selected, spr_multi);
 
     GtkWidget *widget = gtk_hbox_new(FALSE, FALSE);
     gtk_object_set_data(GTK_OBJECT(widget), "dtw", desktop->canvas);
diff --git a/src/widgets/gradient-vector.cpp b/src/widgets/gradient-vector.cpp
index c884604a2..7bfe27310 100644
--- a/src/widgets/gradient-vector.cpp
+++ b/src/widgets/gradient-vector.cpp
@@ -5,12 +5,14 @@
  *   Lauris Kaplinski <lauris@kaplinski.com>
  *   bulia byak <buliabyak@users.sf.net>
  *   MenTaLguY <mental@rydia.net>
+ *   Jon A. Cruz <jon@joncruz.org>
  *
  * Copyright (C) 2001-2002 Lauris Kaplinski
  * Copyright (C) 2001 Ximian, Inc.
  * Copyright (C) 2004 Monash University
  * Copyright (C) 2004 David Turner
  * Copyright (C) 2006 MenTaLguY
+ * Copyright (C) 2010 Jon A. Cruz
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  *
@@ -46,16 +48,16 @@ enum {
     LAST_SIGNAL
 };
 
-static void sp_gradient_vector_selector_class_init (SPGradientVectorSelectorClass *klass);
-static void sp_gradient_vector_selector_init (SPGradientVectorSelector *gvs);
-static void sp_gradient_vector_selector_destroy (GtkObject *object);
+static void sp_gradient_vector_selector_class_init(SPGradientVectorSelectorClass *klass);
+static void sp_gradient_vector_selector_init(SPGradientVectorSelector *gvs);
+static void sp_gradient_vector_selector_destroy(GtkObject *object);
 
-static void sp_gvs_gradient_release (SPObject *obj, SPGradientVectorSelector *gvs);
-static void sp_gvs_defs_release (SPObject *defs, SPGradientVectorSelector *gvs);
-static void sp_gvs_defs_modified (SPObject *defs, guint flags, SPGradientVectorSelector *gvs);
+static void sp_gvs_gradient_release(SPObject *obj, SPGradientVectorSelector *gvs);
+static void sp_gvs_defs_release(SPObject *defs, SPGradientVectorSelector *gvs);
+static void sp_gvs_defs_modified(SPObject *defs, guint flags, SPGradientVectorSelector *gvs);
 
-static void sp_gvs_rebuild_gui_full (SPGradientVectorSelector *gvs);
-static void sp_gvs_gradient_activate (GtkMenuItem *mi, SPGradientVectorSelector *gvs);
+static void sp_gvs_rebuild_gui_full(SPGradientVectorSelector *gvs);
+static void sp_gvs_gradient_activate(GtkMenuItem *mi, SPGradientVectorSelector *gvs);
 
 static GtkVBoxClass *parent_class;
 static guint signals[LAST_SIGNAL] = {0};
@@ -74,36 +76,35 @@ GType sp_gradient_vector_selector_get_type(void)
             sizeof(SPGradientVectorSelectorClass),
             NULL, /* base_init */
             NULL, /* base_finalize */
-            (GClassInitFunc) sp_gradient_vector_selector_class_init,
+            reinterpret_cast<GClassInitFunc>(sp_gradient_vector_selector_class_init),
             NULL, /* class_finalize */
             NULL, /* class_data */
             sizeof(SPGradientVectorSelector),
             0,    /* n_preallocs */
-            (GInstanceInitFunc) sp_gradient_vector_selector_init,
+            reinterpret_cast<GInstanceInitFunc>(sp_gradient_vector_selector_init),
             0,    /* value_table */
         };
 
         type = g_type_register_static( GTK_TYPE_VBOX,
                                        "SPGradientVectorSelector",
                                        &info,
-                                       static_cast< GTypeFlags > (0) );
+                                       static_cast< GTypeFlags >(0) );
     }
     return type;
 }
 
-static void
-sp_gradient_vector_selector_class_init (SPGradientVectorSelectorClass *klass)
+static void sp_gradient_vector_selector_class_init(SPGradientVectorSelectorClass *klass)
 {
     GtkObjectClass *object_class;
 
-    object_class = GTK_OBJECT_CLASS (klass);
+    object_class = GTK_OBJECT_CLASS(klass);
 
-    parent_class = (GtkVBoxClass*)gtk_type_class (GTK_TYPE_VBOX);
+    parent_class = static_cast<GtkVBoxClass*>(gtk_type_class(GTK_TYPE_VBOX));
 
-    signals[VECTOR_SET] = gtk_signal_new ("vector_set",
+    signals[VECTOR_SET] = gtk_signal_new( "vector_set",
                                           GTK_RUN_LAST,
                                           GTK_CLASS_TYPE(object_class),
-                                          GTK_SIGNAL_OFFSET (SPGradientVectorSelectorClass, vector_set),
+                                          GTK_SIGNAL_OFFSET(SPGradientVectorSelectorClass, vector_set),
                                           gtk_marshal_NONE__POINTER,
                                           GTK_TYPE_NONE, 1,
                                           GTK_TYPE_POINTER);
@@ -111,11 +112,12 @@ sp_gradient_vector_selector_class_init (SPGradientVectorSelectorClass *klass)
     object_class->destroy = sp_gradient_vector_selector_destroy;
 }
 
-static void
-sp_gradient_vector_selector_init (SPGradientVectorSelector *gvs)
+static void sp_gradient_vector_selector_init(SPGradientVectorSelector *gvs)
 {
     gvs->idlabel = TRUE;
 
+    gvs->swatched = false;
+
     gvs->doc = NULL;
     gvs->gr = NULL;
 
@@ -123,17 +125,14 @@ sp_gradient_vector_selector_init (SPGradientVectorSelector *gvs)
     new (&gvs->defs_release_connection) sigc::connection();
     new (&gvs->defs_modified_connection) sigc::connection();
 
-    gvs->menu = gtk_option_menu_new ();
-    gtk_widget_show (gvs->menu);
-    gtk_box_pack_start (GTK_BOX (gvs), gvs->menu, TRUE, TRUE, 0);
+    gvs->menu = gtk_option_menu_new();
+    gtk_widget_show(gvs->menu);
+    gtk_box_pack_start(GTK_BOX(gvs), gvs->menu, TRUE, TRUE, 0);
 }
 
-static void
-sp_gradient_vector_selector_destroy (GtkObject *object)
+static void sp_gradient_vector_selector_destroy(GtkObject *object)
 {
-    SPGradientVectorSelector *gvs;
-
-    gvs = SP_GRADIENT_VECTOR_SELECTOR (object);
+    SPGradientVectorSelector *gvs = SP_GRADIENT_VECTOR_SELECTOR(object);
 
     if (gvs->gr) {
         gvs->gradient_release_connection.disconnect();
@@ -150,40 +149,39 @@ sp_gradient_vector_selector_destroy (GtkObject *object)
     gvs->defs_release_connection.~connection();
     gvs->defs_modified_connection.~connection();
 
-    if (((GtkObjectClass *) (parent_class))->destroy)
-        (* ((GtkObjectClass *) (parent_class))->destroy) (object);
+    if ((reinterpret_cast<GtkObjectClass *>(parent_class))->destroy) {
+        (* (reinterpret_cast<GtkObjectClass *>(parent_class))->destroy) (object);
+    }
 }
 
-GtkWidget *
-sp_gradient_vector_selector_new (SPDocument *doc, SPGradient *gr)
+GtkWidget *sp_gradient_vector_selector_new(SPDocument *doc, SPGradient *gr)
 {
     GtkWidget *gvs;
 
-    g_return_val_if_fail (!gr || SP_IS_GRADIENT (gr), NULL);
-    g_return_val_if_fail (!gr || (SP_OBJECT_DOCUMENT (gr) == doc), NULL);
+    g_return_val_if_fail(!gr || SP_IS_GRADIENT(gr), NULL);
+    g_return_val_if_fail(!gr || (SP_OBJECT_DOCUMENT(gr) == doc), NULL);
 
-    gvs = (GtkWidget*)gtk_type_new (SP_TYPE_GRADIENT_VECTOR_SELECTOR);
+    gvs = static_cast<GtkWidget*>(gtk_type_new(SP_TYPE_GRADIENT_VECTOR_SELECTOR));
 
     if (doc) {
-        sp_gradient_vector_selector_set_gradient (SP_GRADIENT_VECTOR_SELECTOR (gvs), doc, gr);
+        sp_gradient_vector_selector_set_gradient(SP_GRADIENT_VECTOR_SELECTOR(gvs), doc, gr);
     } else {
-        sp_gvs_rebuild_gui_full (SP_GRADIENT_VECTOR_SELECTOR (gvs));
+        sp_gvs_rebuild_gui_full(SP_GRADIENT_VECTOR_SELECTOR(gvs));
     }
 
     return gvs;
 }
 
-void
-sp_gradient_vector_selector_set_gradient (SPGradientVectorSelector *gvs, SPDocument *doc, SPGradient *gr)
+void sp_gradient_vector_selector_set_gradient(SPGradientVectorSelector *gvs, SPDocument *doc, SPGradient *gr)
 {
     static gboolean suppress = FALSE;
 
-    g_return_if_fail (gvs != NULL);
-    g_return_if_fail (SP_IS_GRADIENT_VECTOR_SELECTOR (gvs));
-    g_return_if_fail (!gr || (doc != NULL));
-    g_return_if_fail (!gr || SP_IS_GRADIENT (gr));
-    g_return_if_fail (!gr || (SP_OBJECT_DOCUMENT (gr) == doc));
-    g_return_if_fail (!gr || SP_GRADIENT_HAS_STOPS (gr));
+    g_return_if_fail(gvs != NULL);
+    g_return_if_fail(SP_IS_GRADIENT_VECTOR_SELECTOR(gvs));
+    g_return_if_fail(!gr || (doc != NULL));
+    g_return_if_fail(!gr || SP_IS_GRADIENT(gr));
+    g_return_if_fail(!gr || (SP_OBJECT_DOCUMENT(gr) == doc));
+    g_return_if_fail(!gr || SP_GRADIENT_HAS_STOPS(gr));
 
     if (doc != gvs->doc) {
         /* Disconnect signals */
@@ -196,7 +194,8 @@ sp_gradient_vector_selector_set_gradient (SPGradientVectorSelector *gvs, SPDocum
             gvs->defs_modified_connection.disconnect();
             gvs->doc = NULL;
         }
-        /* Connect signals */
+
+        // Connect signals
         if (doc) {
             gvs->defs_release_connection = SP_DOCUMENT_DEFS(doc)->connectRelease(sigc::bind<1>(sigc::ptr_fun(&sp_gvs_defs_release), gvs));
             gvs->defs_modified_connection = SP_DOCUMENT_DEFS(doc)->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_gvs_defs_modified), gvs));
@@ -206,145 +205,144 @@ sp_gradient_vector_selector_set_gradient (SPGradientVectorSelector *gvs, SPDocum
         }
         gvs->doc = doc;
         gvs->gr = gr;
-        sp_gvs_rebuild_gui_full (gvs);
-        if (!suppress) g_signal_emit (G_OBJECT (gvs), signals[VECTOR_SET], 0, gr);
+        sp_gvs_rebuild_gui_full(gvs);
+        if (!suppress) g_signal_emit(G_OBJECT(gvs), signals[VECTOR_SET], 0, gr);
     } else if (gr != gvs->gr) {
-        /* Harder case - keep document, rebuild menus and stuff */
-        /* fixme: (Lauris) */
+        // Harder case - keep document, rebuild menus and stuff
+        // fixme: (Lauris)
         suppress = TRUE;
-        sp_gradient_vector_selector_set_gradient (gvs, NULL, NULL);
-        sp_gradient_vector_selector_set_gradient (gvs, doc, gr);
+        sp_gradient_vector_selector_set_gradient(gvs, NULL, NULL);
+        sp_gradient_vector_selector_set_gradient(gvs, doc, gr);
         suppress = FALSE;
-        g_signal_emit (G_OBJECT (gvs), signals[VECTOR_SET], 0, gr);
+        g_signal_emit(G_OBJECT(gvs), signals[VECTOR_SET], 0, gr);
     }
     /* The case of setting NULL -> NULL is not very interesting */
 }
 
-SPDocument *
-sp_gradient_vector_selector_get_document (SPGradientVectorSelector *gvs)
+SPDocument *sp_gradient_vector_selector_get_document(SPGradientVectorSelector *gvs)
 {
-    g_return_val_if_fail (gvs != NULL, NULL);
-    g_return_val_if_fail (SP_IS_GRADIENT_VECTOR_SELECTOR (gvs), NULL);
+    g_return_val_if_fail(gvs != NULL, NULL);
+    g_return_val_if_fail(SP_IS_GRADIENT_VECTOR_SELECTOR(gvs), NULL);
 
     return gvs->doc;
 }
 
-SPGradient *
-sp_gradient_vector_selector_get_gradient (SPGradientVectorSelector *gvs)
+SPGradient *sp_gradient_vector_selector_get_gradient(SPGradientVectorSelector *gvs)
 {
-    g_return_val_if_fail (gvs != NULL, NULL);
-    g_return_val_if_fail (SP_IS_GRADIENT_VECTOR_SELECTOR (gvs), NULL);
+    g_return_val_if_fail(gvs != NULL, NULL);
+    g_return_val_if_fail(SP_IS_GRADIENT_VECTOR_SELECTOR(gvs), NULL);
 
     return gvs->gr;
 }
 
-static void
-sp_gvs_rebuild_gui_full (SPGradientVectorSelector *gvs)
+static void sp_gvs_rebuild_gui_full(SPGradientVectorSelector *gvs)
 {
     /* Clear old menu, if there is any */
-    if (gtk_option_menu_get_menu (GTK_OPTION_MENU (gvs->menu))) {
-        gtk_option_menu_remove_menu (GTK_OPTION_MENU (gvs->menu));
+    if (gtk_option_menu_get_menu(GTK_OPTION_MENU(gvs->menu))) {
+        gtk_option_menu_remove_menu(GTK_OPTION_MENU(gvs->menu));
     }
 
     /* Create new menu widget */
-    GtkWidget *m = gtk_menu_new ();
-    gtk_widget_show (m);
+    GtkWidget *m = gtk_menu_new();
+    gtk_widget_show(m);
 
     /* Pick up all gradients with vectors */
     GSList *gl = NULL;
     if (gvs->gr) {
-        const GSList *gradients = sp_document_get_resource_list (SP_OBJECT_DOCUMENT (gvs->gr), "gradient");
-        for (const GSList *l = gradients; l != NULL; l = l->next) {
-            if (SP_GRADIENT_HAS_STOPS (l->data)) {
-                gl = g_slist_prepend (gl, l->data);
+        const GSList *gradients = sp_document_get_resource_list(SP_OBJECT_DOCUMENT(gvs->gr), "gradient");
+        for (const GSList *curr = gradients; curr; curr = curr->next) {
+            SPGradient* grad = SP_GRADIENT(curr->data);
+            if (SP_GRADIENT_HAS_STOPS(grad) && (grad->isSwatch() == gvs->swatched)) {
+                gl = g_slist_prepend(gl, curr->data);
             }
         }
     }
-    gl = g_slist_reverse (gl);
+    gl = g_slist_reverse(gl);
 
     gint pos = 0;
     gint idx = 0;
 
     if (!gvs->doc) {
         GtkWidget *i;
-        i = gtk_menu_item_new_with_label (_("No document selected"));
-        gtk_widget_show (i);
-        gtk_menu_append (GTK_MENU (m), i);
-        gtk_widget_set_sensitive (gvs->menu, FALSE);
+        i = gtk_menu_item_new_with_label(_("No document selected"));
+        gtk_widget_show(i);
+        gtk_menu_append(GTK_MENU(m), i);
+        gtk_widget_set_sensitive(gvs->menu, FALSE);
     } else if (!gl) {
         GtkWidget *i;
-        i = gtk_menu_item_new_with_label (_("No gradients in document"));
-        gtk_widget_show (i);
-        gtk_menu_append (GTK_MENU (m), i);
-        gtk_widget_set_sensitive (gvs->menu, FALSE);
+        i = gtk_menu_item_new_with_label(_("No gradients in document"));
+        gtk_widget_show(i);
+        gtk_menu_append(GTK_MENU(m), i);
+        gtk_widget_set_sensitive(gvs->menu, FALSE);
     } else if (!gvs->gr) {
         GtkWidget *i;
-        i = gtk_menu_item_new_with_label (_("No gradient selected"));
-        gtk_widget_show (i);
-        gtk_menu_append (GTK_MENU (m), i);
-        gtk_widget_set_sensitive (gvs->menu, FALSE);
+        i = gtk_menu_item_new_with_label(_("No gradient selected"));
+        gtk_widget_show(i);
+        gtk_menu_append(GTK_MENU(m), i);
+        gtk_widget_set_sensitive(gvs->menu, FALSE);
     } else {
         while (gl) {
             SPGradient *gr;
             GtkWidget *i, *w;
-            gr = SP_GRADIENT (gl->data);
-            gl = g_slist_remove (gl, gr);
+            gr = SP_GRADIENT(gl->data);
+            gl = g_slist_remove(gl, gr);
 
             /* We have to know: */
             /* Gradient destroy */
             /* Gradient name change */
-            i = gtk_menu_item_new ();
-            gtk_widget_show (i);
-            g_object_set_data (G_OBJECT (i), "gradient", gr);
-            g_signal_connect (G_OBJECT (i), "activate", G_CALLBACK (sp_gvs_gradient_activate), gvs);
+            i = gtk_menu_item_new();
+            gtk_widget_show(i);
+            g_object_set_data(G_OBJECT(i), "gradient", gr);
+            g_signal_connect(G_OBJECT(i), "activate", G_CALLBACK(sp_gvs_gradient_activate), gvs);
 
-            w = sp_gradient_image_new (gr);
-            gtk_widget_show (w);
+            w = sp_gradient_image_new(gr);
+            gtk_widget_show(w);
 
             if (gvs->idlabel) {
                 GtkWidget *hb, *l;
-                hb = gtk_hbox_new (FALSE, 4);
-                gtk_widget_show (hb);
-                l = gtk_label_new (SP_OBJECT_ID (gr));
-                gtk_widget_show (l);
-                gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
-                gtk_box_pack_start (GTK_BOX (hb), l, TRUE, TRUE, 0);
-                gtk_box_pack_start (GTK_BOX (hb), w, FALSE, FALSE, 0);
+                hb = gtk_hbox_new(FALSE, 4);
+                gtk_widget_show(hb);
+                l = gtk_label_new(gr->getId());
+                gtk_widget_show(l);
+                gtk_misc_set_alignment(GTK_MISC(l), 1.0, 0.5);
+                gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, 0);
+                gtk_box_pack_start(GTK_BOX(hb), w, FALSE, FALSE, 0);
                 w = hb;
             }
 
-            gtk_container_add (GTK_CONTAINER (i), w);
+            gtk_container_add(GTK_CONTAINER(i), w);
 
-            gtk_menu_append (GTK_MENU (m), i);
+            gtk_menu_append(GTK_MENU(m), i);
 
-            if (gr == gvs->gr) pos = idx;
+            if (gr == gvs->gr) {
+                pos = idx;
+            }
             idx += 1;
         }
-        gtk_widget_set_sensitive (gvs->menu, TRUE);
+        gtk_widget_set_sensitive(gvs->menu, TRUE);
     }
 
-    gtk_option_menu_set_menu (GTK_OPTION_MENU (gvs->menu), m);
+    gtk_option_menu_set_menu(GTK_OPTION_MENU(gvs->menu), m);
     /* Set history */
-    gtk_option_menu_set_history (GTK_OPTION_MENU (gvs->menu), pos);
+    gtk_option_menu_set_history(GTK_OPTION_MENU(gvs->menu), pos);
 }
 
-static void
-sp_gvs_gradient_activate (GtkMenuItem *mi, SPGradientVectorSelector *gvs)
+static void sp_gvs_gradient_activate(GtkMenuItem *mi, SPGradientVectorSelector *gvs)
 {
     SPGradient *gr, *norm;
 
-    gr = (SPGradient*)g_object_get_data (G_OBJECT (mi), "gradient");
+    gr = (SPGradient*)g_object_get_data(G_OBJECT(mi), "gradient");
     /* Hmmm... bad things may happen here, if actual gradient is something new */
     /* Namely - menuitems etc. will be fucked up */
     /* Hmmm - probably we can just re-set it as menuitem data (Lauris) */
 
-    //g_print ("SPGradientVectorSelector: gradient %s activated\n", SP_OBJECT_ID (gr));
+    //g_print("SPGradientVectorSelector: gradient %s activated\n", SP_OBJECT_ID(gr));
 
-    norm = sp_gradient_ensure_vector_normalized (gr);
+    norm = sp_gradient_ensure_vector_normalized(gr);
     if (norm != gr) {
-        //g_print ("SPGradientVectorSelector: become %s after normalization\n", SP_OBJECT_ID (norm));
+        //g_print("SPGradientVectorSelector: become %s after normalization\n", SP_OBJECT_ID(norm));
         /* But be careful that we do not have gradient saved anywhere else */
-        g_object_set_data (G_OBJECT (mi), "gradient", norm);
+        g_object_set_data(G_OBJECT(mi), "gradient", norm);
     }
 
     /* fixme: Really we would want to use _set_vector */
@@ -359,19 +357,18 @@ sp_gvs_gradient_activate (GtkMenuItem *mi, SPGradientVectorSelector *gvs)
         gvs->gr = norm;
     }
 
-    g_signal_emit (G_OBJECT (gvs), signals[VECTOR_SET], 0, norm);
+    g_signal_emit(G_OBJECT(gvs), signals[VECTOR_SET], 0, norm);
 
     if (norm != gr) {
         /* We do extra undo push here */
         /* If handler has already done it, it is just NOP */
         // FIXME: looks like this is never a valid undo step, consider removing this
-        sp_document_done (SP_OBJECT_DOCUMENT (norm), SP_VERB_CONTEXT_GRADIENT,
+        sp_document_done(SP_OBJECT_DOCUMENT(norm), SP_VERB_CONTEXT_GRADIENT,
                           /* TODO: annotate */ "gradient-vector.cpp:350");
     }
 }
 
-static void
-sp_gvs_gradient_release (SPObject */*obj*/, SPGradientVectorSelector *gvs)
+static void sp_gvs_gradient_release(SPObject */*obj*/, SPGradientVectorSelector *gvs)
 {
     /* Disconnect gradient */
     if (gvs->gr) {
@@ -380,11 +377,10 @@ sp_gvs_gradient_release (SPObject */*obj*/, SPGradientVectorSelector *gvs)
     }
 
     /* Rebuild GUI */
-    sp_gvs_rebuild_gui_full (gvs);
+    sp_gvs_rebuild_gui_full(gvs);
 }
 
-static void
-sp_gvs_defs_release (SPObject */*defs*/, SPGradientVectorSelector *gvs)
+static void sp_gvs_defs_release(SPObject */*defs*/, SPGradientVectorSelector *gvs)
 {
     gvs->doc = NULL;
 
@@ -398,15 +394,20 @@ sp_gvs_defs_release (SPObject */*defs*/, SPGradientVectorSelector *gvs)
     }
 
     /* Rebuild GUI */
-    sp_gvs_rebuild_gui_full (gvs);
+    sp_gvs_rebuild_gui_full(gvs);
 }
 
-static void
-sp_gvs_defs_modified (SPObject */*defs*/, guint /*flags*/, SPGradientVectorSelector *gvs)
+static void sp_gvs_defs_modified(SPObject */*defs*/, guint /*flags*/, SPGradientVectorSelector *gvs)
 {
     /* fixme: We probably have to check some flags here (Lauris) */
 
-    sp_gvs_rebuild_gui_full (gvs);
+    sp_gvs_rebuild_gui_full(gvs);
+}
+
+void SPGradientVectorSelector::setSwatched()
+{
+    swatched = true;
+    sp_gvs_rebuild_gui_full(this);
 }
 
 /*##################################################################
@@ -422,27 +423,27 @@ sp_gvs_defs_modified (SPObject */*defs*/, guint /*flags*/, SPGradientVectorSelec
 
 #define PAD 4
 
-static GtkWidget *sp_gradient_vector_widget_new (SPGradient *gradient, SPStop *stop);
+static GtkWidget *sp_gradient_vector_widget_new(SPGradient *gradient, SPStop *stop);
 
-static void sp_gradient_vector_widget_load_gradient (GtkWidget *widget, SPGradient *gradient);
-static gint sp_gradient_vector_dialog_delete (GtkWidget *widget, GdkEvent *event, GtkWidget *dialog);
-static void sp_gradient_vector_dialog_destroy (GtkObject *object, gpointer data);
+static void sp_gradient_vector_widget_load_gradient(GtkWidget *widget, SPGradient *gradient);
+static gint sp_gradient_vector_dialog_delete(GtkWidget *widget, GdkEvent *event, GtkWidget *dialog);
+static void sp_gradient_vector_dialog_destroy(GtkObject *object, gpointer data);
 
-static void sp_gradient_vector_widget_destroy (GtkObject *object, gpointer data);
-static void sp_gradient_vector_gradient_release (SPObject *obj, GtkWidget *widget);
-static void sp_gradient_vector_gradient_modified (SPObject *obj, guint flags, GtkWidget *widget);
-static void sp_gradient_vector_color_dragged (SPColorSelector *csel, GtkObject *object);
-static void sp_gradient_vector_color_changed (SPColorSelector *csel, GtkObject *object);
+static void sp_gradient_vector_widget_destroy(GtkObject *object, gpointer data);
+static void sp_gradient_vector_gradient_release(SPObject *obj, GtkWidget *widget);
+static void sp_gradient_vector_gradient_modified(SPObject *obj, guint flags, GtkWidget *widget);
+static void sp_gradient_vector_color_dragged(SPColorSelector *csel, GtkObject *object);
+static void sp_gradient_vector_color_changed(SPColorSelector *csel, GtkObject *object);
 static void update_stop_list( GtkWidget *mnu, SPGradient *gradient, SPStop *new_stop);
 
 static gboolean blocked = FALSE;
 
-static void grad_edit_dia_stop_added_or_removed (Inkscape::XML::Node */*repr*/, Inkscape::XML::Node */*child*/, Inkscape::XML::Node */*ref*/, gpointer data)
+static void grad_edit_dia_stop_added_or_removed(Inkscape::XML::Node */*repr*/, Inkscape::XML::Node */*child*/, Inkscape::XML::Node */*ref*/, gpointer data)
 {
     GtkWidget *vb = GTK_WIDGET(data);
-    GtkWidget *mnu = (GtkWidget *)g_object_get_data (G_OBJECT(vb), "stopmenu");
-    SPGradient *gradient = (SPGradient *)g_object_get_data (G_OBJECT(vb), "gradient");
-    update_stop_list (mnu, gradient, NULL);
+    GtkWidget *mnu = (GtkWidget *)g_object_get_data(G_OBJECT(vb), "stopmenu");
+    SPGradient *gradient = (SPGradient *)g_object_get_data(G_OBJECT(vb), "gradient");
+    update_stop_list(mnu, gradient, NULL);
 }
 
 //FIXME!!! We must also listen to attr changes on all children (i.e. stops) too,
@@ -457,14 +458,13 @@ static Inkscape::XML::NodeEventVector grad_edit_dia_repr_events =
     NULL  /* order_changed */
 };
 
-static void
-verify_grad(SPGradient *gradient)
+static void verify_grad(SPGradient *gradient)
 {
     int i = 0;
     SPStop *stop = NULL;
     /* count stops */
     for ( SPObject *ochild = sp_object_first_child(SP_OBJECT(gradient)) ; ochild != NULL ; ochild = SP_OBJECT_NEXT(ochild) ) {
-        if (SP_IS_STOP (ochild)) {
+        if (SP_IS_STOP(ochild)) {
             i++;
             stop = SP_STOP(ochild);
         }
@@ -475,7 +475,7 @@ verify_grad(SPGradient *gradient)
 
     if (i < 1) {
         gchar c[64];
-        sp_svg_write_color (c, sizeof(c), 0x00000000);
+        sp_svg_write_color(c, sizeof(c), 0x00000000);
 
         Inkscape::CSSOStringStream os;
         os << "stop-color:" << c << ";stop-opacity:" << 1.0 << ";";
@@ -485,32 +485,31 @@ verify_grad(SPGradient *gradient)
         child = xml_doc->createElement("svg:stop");
         sp_repr_set_css_double(child, "offset", 0.0);
         child->setAttribute("style", os.str().c_str());
-        SP_OBJECT_REPR (gradient)->addChild(child, NULL);
+        SP_OBJECT_REPR(gradient)->addChild(child, NULL);
         Inkscape::GC::release(child);
 
         child = xml_doc->createElement("svg:stop");
         sp_repr_set_css_double(child, "offset", 1.0);
         child->setAttribute("style", os.str().c_str());
-        SP_OBJECT_REPR (gradient)->addChild(child, NULL);
+        SP_OBJECT_REPR(gradient)->addChild(child, NULL);
         Inkscape::GC::release(child);
     }
     if (i < 2) {
         sp_repr_set_css_double(SP_OBJECT_REPR(stop), "offset", 0.0);
         Inkscape::XML::Node *child = SP_OBJECT_REPR(stop)->duplicate(SP_OBJECT_REPR(gradient)->document());
         sp_repr_set_css_double(child, "offset", 1.0);
-        SP_OBJECT_REPR(gradient)->addChild(child, SP_OBJECT_REPR (stop));
+        SP_OBJECT_REPR(gradient)->addChild(child, SP_OBJECT_REPR(stop));
         Inkscape::GC::release(child);
     }
 }
 
-static void
-select_stop_in_list( GtkWidget *mnu, SPGradient *gradient, SPStop *new_stop)
+static void select_stop_in_list( GtkWidget *mnu, SPGradient *gradient, SPStop *new_stop)
 {
     int i = 0;
     for ( SPObject *ochild = sp_object_first_child(SP_OBJECT(gradient)) ; ochild != NULL ; ochild = SP_OBJECT_NEXT(ochild) ) {
-        if (SP_IS_STOP (ochild)) {
-            if (SP_OBJECT (ochild) == SP_OBJECT(new_stop)) {
-                gtk_option_menu_set_history (GTK_OPTION_MENU (mnu), i);
+        if (SP_IS_STOP(ochild)) {
+            if (SP_OBJECT(ochild) == SP_OBJECT(new_stop)) {
+                gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), i);
                 break;
             }
             i++;
@@ -518,104 +517,103 @@ select_stop_in_list( GtkWidget *mnu, SPGradient *gradient, SPStop *new_stop)
     }
 }
 
-static void
-update_stop_list( GtkWidget *mnu, SPGradient *gradient, SPStop *new_stop)
+static void update_stop_list( GtkWidget *mnu, SPGradient *gradient, SPStop *new_stop)
 {
 
-    if (!SP_IS_GRADIENT (gradient))
+    if (!SP_IS_GRADIENT(gradient)) {
         return;
+    }
 
     blocked = TRUE;
 
     /* Clear old menu, if there is any */
-    if (gtk_option_menu_get_menu (GTK_OPTION_MENU (mnu))) {
-        gtk_option_menu_remove_menu (GTK_OPTION_MENU (mnu));
+    if (gtk_option_menu_get_menu(GTK_OPTION_MENU(mnu))) {
+        gtk_option_menu_remove_menu(GTK_OPTION_MENU(mnu));
     }
 
     /* Create new menu widget */
-    GtkWidget *m = gtk_menu_new ();
-    gtk_widget_show (m);
+    GtkWidget *m = gtk_menu_new();
+    gtk_widget_show(m);
     GSList *sl = NULL;
     if (gradient->has_stops) {
-        for ( SPObject *ochild = sp_object_first_child (SP_OBJECT(gradient)) ; ochild != NULL ; ochild = SP_OBJECT_NEXT(ochild) ) {
-            if (SP_IS_STOP (ochild)) {
-                sl = g_slist_append (sl, ochild);
+        for ( SPObject *ochild = sp_object_first_child(SP_OBJECT(gradient)) ; ochild != NULL ; ochild = SP_OBJECT_NEXT(ochild) ) {
+            if (SP_IS_STOP(ochild)) {
+                sl = g_slist_append(sl, ochild);
             }
         }
     }
     if (!sl) {
-        GtkWidget *i = gtk_menu_item_new_with_label (_("No stops in gradient"));
-        gtk_widget_show (i);
-        gtk_menu_append (GTK_MENU (m), i);
-        gtk_widget_set_sensitive (mnu, FALSE);
+        GtkWidget *i = gtk_menu_item_new_with_label(_("No stops in gradient"));
+        gtk_widget_show(i);
+        gtk_menu_append(GTK_MENU(m), i);
+        gtk_widget_set_sensitive(mnu, FALSE);
     } else {
 
         for (; sl != NULL; sl = sl->next){
             SPStop *stop;
             GtkWidget *i;
             if (SP_IS_STOP(sl->data)){
-                stop = SP_STOP (sl->data);
-                i = gtk_menu_item_new ();
-                gtk_widget_show (i);
-                g_object_set_data (G_OBJECT (i), "stop", stop);
-                GtkWidget *hb = gtk_hbox_new (FALSE, 4);
+                stop = SP_STOP(sl->data);
+                i = gtk_menu_item_new();
+                gtk_widget_show(i);
+                g_object_set_data(G_OBJECT(i), "stop", stop);
+                GtkWidget *hb = gtk_hbox_new(FALSE, 4);
                 GtkWidget *cpv = sp_color_preview_new(sp_stop_get_rgba32(stop));
-                gtk_widget_show (cpv);
-                gtk_container_add ( GTK_CONTAINER (hb), cpv );
-                g_object_set_data ( G_OBJECT (i), "preview", cpv );
+                gtk_widget_show(cpv);
+                gtk_container_add( GTK_CONTAINER(hb), cpv );
+                g_object_set_data( G_OBJECT(i), "preview", cpv );
                 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) sl->data);
-                GtkWidget *l = gtk_label_new (repr->attribute("id"));
-                gtk_widget_show (l);
-                gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
-                gtk_box_pack_start (GTK_BOX (hb), l, TRUE, TRUE, 0);
-                gtk_widget_show (hb);
-                gtk_container_add (GTK_CONTAINER (i), hb);
-                gtk_menu_append (GTK_MENU (m), i);
+                GtkWidget *l = gtk_label_new(repr->attribute("id"));
+                gtk_widget_show(l);
+                gtk_misc_set_alignment(GTK_MISC(l), 1.0, 0.5);
+                gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, 0);
+                gtk_widget_show(hb);
+                gtk_container_add(GTK_CONTAINER(i), hb);
+                gtk_menu_append(GTK_MENU(m), i);
             }
         }
 
-        gtk_widget_set_sensitive (mnu, TRUE);
+        gtk_widget_set_sensitive(mnu, TRUE);
     }
-    gtk_option_menu_set_menu (GTK_OPTION_MENU (mnu), m);
+    gtk_option_menu_set_menu(GTK_OPTION_MENU(mnu), m);
 
     /* Set history */
     if (new_stop == NULL) {
-        gtk_option_menu_set_history (GTK_OPTION_MENU (mnu), 0);
+        gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
     } else {
-        select_stop_in_list (mnu, gradient, new_stop);
+        select_stop_in_list(mnu, gradient, new_stop);
     }
 
     blocked = FALSE;
 }
 
 
-/*user selected existing stop from list*/
-static void
-sp_grad_edit_select (GtkOptionMenu *mnu,  GtkWidget *tbl)
+// user selected existing stop from list
+static void sp_grad_edit_select(GtkOptionMenu *mnu, GtkWidget *tbl)
 {
-    SPGradient *gradient = (SPGradient *)g_object_get_data (G_OBJECT(tbl), "gradient");
-
-    GObject *item = G_OBJECT(gtk_menu_get_active (GTK_MENU(gtk_option_menu_get_menu (mnu))));
-    SPStop *stop = SP_STOP (g_object_get_data (item, "stop"));
-    if (!stop) return;
+    GObject *item = G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu))));
+    SPStop *stop = SP_STOP(g_object_get_data(item, "stop"));
+    if (!stop) {
+        return;
+    }
 
     blocked = TRUE;
 
-    SPColorSelector *csel = (SPColorSelector*)g_object_get_data (G_OBJECT (tbl), "cselector");
+    SPColorSelector *csel = (SPColorSelector*)g_object_get_data(G_OBJECT(tbl), "cselector");
     guint32 const c = sp_stop_get_rgba32(stop);
-    csel->base->setAlpha(SP_RGBA32_A_F (c));
-    SPColor color( SP_RGBA32_R_F (c), SP_RGBA32_G_F (c), SP_RGBA32_B_F (c) );
+    csel->base->setAlpha(SP_RGBA32_A_F(c));
+    SPColor color( SP_RGBA32_R_F(c), SP_RGBA32_G_F(c), SP_RGBA32_B_F(c) );
     // set its color, from the stored array
     csel->base->setColor( color );
-    GtkWidget *offspin = GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "offspn"));
-    GtkWidget *offslide =GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "offslide"));
+    GtkWidget *offspin = GTK_WIDGET(g_object_get_data(G_OBJECT(tbl), "offspn"));
+    GtkWidget *offslide =GTK_WIDGET(g_object_get_data(G_OBJECT(tbl), "offslide"));
 
-    GtkAdjustment *adj = (GtkAdjustment*)gtk_object_get_data (GTK_OBJECT (tbl), "offset");
+    GtkAdjustment *adj = static_cast<GtkAdjustment*>(gtk_object_get_data(GTK_OBJECT(tbl), "offset"));
 
     bool isEndStop = false;
 
     SPStop *prev = NULL;
-    prev = sp_prev_stop(stop, gradient);
+    prev = stop->getPrevStop();
     if (prev != NULL )  {
         adj->lower = prev->offset;
     } else {
@@ -624,7 +622,7 @@ sp_grad_edit_select (GtkOptionMenu *mnu,  GtkWidget *tbl)
     }
 
     SPStop *next = NULL;
-    next = sp_next_stop(stop);
+    next = stop->getNextStop();
     if (next != NULL ) {
         adj->upper = next->offset;
     } else {
@@ -634,16 +632,16 @@ sp_grad_edit_select (GtkOptionMenu *mnu,  GtkWidget *tbl)
 
     //fixme: does this work on all possible input gradients?
     if (!isEndStop) {
-        gtk_widget_set_sensitive (offslide, TRUE);
-        gtk_widget_set_sensitive (GTK_WIDGET (offspin), TRUE);
+        gtk_widget_set_sensitive(offslide, TRUE);
+        gtk_widget_set_sensitive(GTK_WIDGET(offspin), TRUE);
     } else {
-        gtk_widget_set_sensitive (offslide, FALSE);
-        gtk_widget_set_sensitive (GTK_WIDGET (offspin), FALSE);
+        gtk_widget_set_sensitive(offslide, FALSE);
+        gtk_widget_set_sensitive(GTK_WIDGET(offspin), FALSE);
     }
 
-    gtk_adjustment_set_value (adj, stop->offset);
+    gtk_adjustment_set_value(adj, stop->offset);
 
-    gtk_adjustment_changed (adj);
+    gtk_adjustment_changed(adj);
 
     blocked = FALSE;
 }
@@ -651,57 +649,58 @@ sp_grad_edit_select (GtkOptionMenu *mnu,  GtkWidget *tbl)
 
 
 
-static void
-offadjustmentChanged( GtkAdjustment *adjustment, GtkWidget *vb)
+static void offadjustmentChanged( GtkAdjustment *adjustment, GtkWidget *vb)
 {
-    if (blocked)
+    if (blocked) {
         return;
+    }
 
     blocked = TRUE;
 
-    GtkOptionMenu *mnu = (GtkOptionMenu *)g_object_get_data (G_OBJECT(vb), "stopmenu");
-    if (!g_object_get_data (G_OBJECT(gtk_menu_get_active (GTK_MENU(gtk_option_menu_get_menu (mnu)))), "stop")) return;
-    SPStop *stop = SP_STOP(g_object_get_data (G_OBJECT(gtk_menu_get_active (GTK_MENU(gtk_option_menu_get_menu (mnu)))), "stop"));
+    GtkOptionMenu *mnu = static_cast<GtkOptionMenu *>(g_object_get_data(G_OBJECT(vb), "stopmenu"));
+    if (!g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))), "stop")) {
+        return;
+    }
+    SPStop *stop = SP_STOP(g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))), "stop"));
 
     stop->offset = adjustment->value;
     sp_repr_set_css_double(SP_OBJECT_REPR(stop), "offset", stop->offset);
 
-    sp_document_done (SP_OBJECT_DOCUMENT (stop), SP_VERB_CONTEXT_GRADIENT,
+    sp_document_done(SP_OBJECT_DOCUMENT(stop), SP_VERB_CONTEXT_GRADIENT,
                       _("Change gradient stop offset"));
 
     blocked = FALSE;
 }
 
-guint32
-sp_average_color (guint32 c1, guint32 c2, gdouble p = 0.5)
+guint32 sp_average_color(guint32 c1, guint32 c2, gdouble p = 0.5)
 {
-    guint32 r = (guint32) (SP_RGBA32_R_U (c1) * p + SP_RGBA32_R_U (c2) * (1 - p));
-    guint32 g = (guint32) (SP_RGBA32_G_U (c1) * p + SP_RGBA32_G_U (c2) * (1 - p));
-    guint32 b = (guint32) (SP_RGBA32_B_U (c1) * p + SP_RGBA32_B_U (c2) * (1 - p));
-    guint32 a = (guint32) (SP_RGBA32_A_U (c1) * p + SP_RGBA32_A_U (c2) * (1 - p));
+    guint32 r = (guint32) (SP_RGBA32_R_U(c1) * p + SP_RGBA32_R_U(c2) * (1 - p));
+    guint32 g = (guint32) (SP_RGBA32_G_U(c1) * p + SP_RGBA32_G_U(c2) * (1 - p));
+    guint32 b = (guint32) (SP_RGBA32_B_U(c1) * p + SP_RGBA32_B_U(c2) * (1 - p));
+    guint32 a = (guint32) (SP_RGBA32_A_U(c1) * p + SP_RGBA32_A_U(c2) * (1 - p));
 
-    return SP_RGBA32_U_COMPOSE (r, g, b, a);
+    return SP_RGBA32_U_COMPOSE(r, g, b, a);
 }
 
 
-static void
-sp_grd_ed_add_stop (GtkWidget */*widget*/,  GtkWidget *vb)
+static void sp_grd_ed_add_stop(GtkWidget */*widget*/,  GtkWidget *vb)
 {
-    SPGradient *gradient = (SPGradient *) g_object_get_data (G_OBJECT(vb), "gradient");
-    verify_grad (gradient);
-    GtkOptionMenu *mnu = (GtkOptionMenu *)g_object_get_data (G_OBJECT(vb), "stopmenu");
+    SPGradient *gradient = static_cast<SPGradient *>(g_object_get_data(G_OBJECT(vb), "gradient"));
+    verify_grad(gradient);
+    GtkOptionMenu *mnu = static_cast<GtkOptionMenu *>(g_object_get_data(G_OBJECT(vb), "stopmenu"));
 
-    SPStop *stop = (SPStop *) g_object_get_data (G_OBJECT(gtk_menu_get_active (GTK_MENU(gtk_option_menu_get_menu (mnu)))), "stop");
+    SPStop *stop = static_cast<SPStop *>(g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))), "stop"));
 
-    if (stop == NULL)
+    if (stop == NULL) {
         return;
+    }
 
     Inkscape::XML::Node *new_stop_repr = NULL;
 
-    SPStop *next = sp_next_stop (stop);
+    SPStop *next = stop->getNextStop();
 
     if (next == NULL) {
-        SPStop *prev = sp_prev_stop (stop, gradient);
+        SPStop *prev = stop->getPrevStop();
         if (prev != NULL) {
             next = stop;
             stop = prev;
@@ -713,8 +712,8 @@ sp_grd_ed_add_stop (GtkWidget */*widget*/,  GtkWidget *vb)
         SP_OBJECT_REPR(gradient)->addChild(new_stop_repr, SP_OBJECT_REPR(stop));
     } else {
         next = stop;
-        new_stop_repr = SP_OBJECT_REPR(sp_prev_stop(stop, gradient))->duplicate(SP_OBJECT_REPR(gradient)->document());
-        SP_OBJECT_REPR(gradient)->addChild(new_stop_repr, SP_OBJECT_REPR(sp_prev_stop(stop, gradient)));
+        new_stop_repr = SP_OBJECT_REPR(stop->getPrevStop())->duplicate(SP_OBJECT_REPR(gradient)->document());
+        SP_OBJECT_REPR(gradient)->addChild(new_stop_repr, SP_OBJECT_REPR(stop->getPrevStop()));
     }
 
     SPStop *newstop = (SPStop *) SP_OBJECT_DOCUMENT(gradient)->getObjectByRepr(new_stop_repr);
@@ -723,186 +722,184 @@ sp_grd_ed_add_stop (GtkWidget */*widget*/,  GtkWidget *vb)
 
     guint32 const c1 = sp_stop_get_rgba32(stop);
     guint32 const c2 = sp_stop_get_rgba32(next);
-    guint32 cnew = sp_average_color (c1, c2);
+    guint32 cnew = sp_average_color(c1, c2);
 
     Inkscape::CSSOStringStream os;
     gchar c[64];
-    sp_svg_write_color (c, sizeof(c), cnew);
-    gdouble opacity = (gdouble) SP_RGBA32_A_F (cnew);
+    sp_svg_write_color(c, sizeof(c), cnew);
+    gdouble opacity = static_cast<gdouble>(SP_RGBA32_A_F(cnew));
     os << "stop-color:" << c << ";stop-opacity:" << opacity <<";";
     SP_OBJECT_REPR (newstop)->setAttribute("style", os.str().c_str());
     sp_repr_set_css_double( SP_OBJECT_REPR(newstop), "offset", (double)newstop->offset);
 
-    sp_gradient_vector_widget_load_gradient (vb, gradient);
+    sp_gradient_vector_widget_load_gradient(vb, gradient);
     Inkscape::GC::release(new_stop_repr);
     update_stop_list(GTK_WIDGET(mnu), gradient, newstop);
-    GtkWidget *offspin = GTK_WIDGET (g_object_get_data (G_OBJECT (vb), "offspn"));
-    GtkWidget *offslide =GTK_WIDGET (g_object_get_data (G_OBJECT (vb), "offslide"));
-    gtk_widget_set_sensitive (offslide, TRUE);
-    gtk_widget_set_sensitive (GTK_WIDGET (offspin), TRUE);
-    sp_document_done (SP_OBJECT_DOCUMENT (gradient), SP_VERB_CONTEXT_GRADIENT,
+    GtkWidget *offspin = GTK_WIDGET(g_object_get_data(G_OBJECT(vb), "offspn"));
+    GtkWidget *offslide =GTK_WIDGET(g_object_get_data(G_OBJECT(vb), "offslide"));
+    gtk_widget_set_sensitive(offslide, TRUE);
+    gtk_widget_set_sensitive(GTK_WIDGET(offspin), TRUE);
+    sp_document_done(SP_OBJECT_DOCUMENT(gradient), SP_VERB_CONTEXT_GRADIENT,
                       _("Add gradient stop"));
 }
 
-static void
-sp_grd_ed_del_stop (GtkWidget */*widget*/,  GtkWidget *vb)
+static void sp_grd_ed_del_stop(GtkWidget */*widget*/,  GtkWidget *vb)
 {
-    SPGradient *gradient = (SPGradient *)g_object_get_data (G_OBJECT(vb), "gradient");
+    SPGradient *gradient = static_cast<SPGradient *>(g_object_get_data(G_OBJECT(vb), "gradient"));
 
-    GtkOptionMenu *mnu = (GtkOptionMenu *)g_object_get_data (G_OBJECT(vb), "stopmenu");
-    if (!g_object_get_data (G_OBJECT(gtk_menu_get_active (GTK_MENU(gtk_option_menu_get_menu (mnu)))), "stop")) return;
-    SPStop *stop = SP_STOP(g_object_get_data (G_OBJECT(gtk_menu_get_active (GTK_MENU(gtk_option_menu_get_menu (mnu)))), "stop"));
+    GtkOptionMenu *mnu = static_cast<GtkOptionMenu *>(g_object_get_data(G_OBJECT(vb), "stopmenu"));
+    if (!g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))), "stop")) return;
+    SPStop *stop = SP_STOP(g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))), "stop"));
     if (gradient->vector.stops.size() > 2) { // 2 is the minimum
 
         // if we delete first or last stop, move the next/previous to the edge
         if (stop->offset == 0) {
-            SPStop *next = sp_next_stop (stop);
+            SPStop *next = stop->getNextStop();
             if (next) {
                 next->offset = 0;
-                sp_repr_set_css_double (SP_OBJECT_REPR (next), "offset", 0);
+                sp_repr_set_css_double(SP_OBJECT_REPR(next), "offset", 0);
             }
         } else if (stop->offset == 1) {
-            SPStop *prev = sp_prev_stop (stop, gradient);
+            SPStop *prev = stop->getPrevStop();
             if (prev) {
                 prev->offset = 1;
-                sp_repr_set_css_double (SP_OBJECT_REPR (prev), "offset", 1);
+                sp_repr_set_css_double(SP_OBJECT_REPR(prev), "offset", 1);
             }
         }
 
         SP_OBJECT_REPR(gradient)->removeChild(SP_OBJECT_REPR(stop));
-        sp_gradient_vector_widget_load_gradient (vb, gradient);
+        sp_gradient_vector_widget_load_gradient(vb, gradient);
         update_stop_list(GTK_WIDGET(mnu), gradient, NULL);
-        sp_document_done (SP_OBJECT_DOCUMENT (gradient), SP_VERB_CONTEXT_GRADIENT,
+        sp_document_done(SP_OBJECT_DOCUMENT(gradient), SP_VERB_CONTEXT_GRADIENT,
                           _("Delete gradient stop"));
     }
 
 }
 
-static GtkWidget *
-sp_gradient_vector_widget_new (SPGradient *gradient, SPStop *select_stop)
+static GtkWidget * sp_gradient_vector_widget_new(SPGradient *gradient, SPStop *select_stop)
 {
     GtkWidget *vb, *w, *f, *csel;
 
-    g_return_val_if_fail (!gradient || SP_IS_GRADIENT (gradient), NULL);
+    g_return_val_if_fail(!gradient || SP_IS_GRADIENT(gradient), NULL);
 
-    vb = gtk_vbox_new (FALSE, PAD);
-    g_signal_connect (G_OBJECT (vb), "destroy", G_CALLBACK (sp_gradient_vector_widget_destroy), NULL);
+    vb = gtk_vbox_new(FALSE, PAD);
+    g_signal_connect(G_OBJECT(vb), "destroy", G_CALLBACK(sp_gradient_vector_widget_destroy), NULL);
 
-    w = sp_gradient_image_new (gradient);
-    g_object_set_data (G_OBJECT (vb), "preview", w);
-    gtk_widget_show (w);
-    gtk_box_pack_start (GTK_BOX (vb), w, TRUE, TRUE, PAD);
+    w = sp_gradient_image_new(gradient);
+    g_object_set_data(G_OBJECT(vb), "preview", w);
+    gtk_widget_show(w);
+    gtk_box_pack_start(GTK_BOX(vb), w, TRUE, TRUE, PAD);
 
-    sp_repr_add_listener (SP_OBJECT_REPR(gradient), &grad_edit_dia_repr_events, vb);
-    GtkTooltips *tt = gtk_tooltips_new ();
+    sp_repr_add_listener(SP_OBJECT_REPR(gradient), &grad_edit_dia_repr_events, vb);
+    GtkTooltips *tt = gtk_tooltips_new();
 
     /* Stop list */
-    GtkWidget *mnu = gtk_option_menu_new ();
+    GtkWidget *mnu = gtk_option_menu_new();
     /* Create new menu widget */
-    update_stop_list (GTK_WIDGET(mnu), gradient, NULL);
-    gtk_signal_connect (GTK_OBJECT (mnu), "changed", GTK_SIGNAL_FUNC (sp_grad_edit_select), vb);
-    gtk_widget_show (mnu);
-    gtk_object_set_data (GTK_OBJECT (vb), "stopmenu", mnu);
-    gtk_box_pack_start (GTK_BOX (vb), mnu, FALSE, FALSE, 0);
+    update_stop_list(GTK_WIDGET(mnu), gradient, NULL);
+    gtk_signal_connect(GTK_OBJECT(mnu), "changed", GTK_SIGNAL_FUNC(sp_grad_edit_select), vb);
+    gtk_widget_show(mnu);
+    gtk_object_set_data(GTK_OBJECT(vb), "stopmenu", mnu);
+    gtk_box_pack_start(GTK_BOX(vb), mnu, FALSE, FALSE, 0);
 
     /* Add and Remove buttons */
-    GtkWidget *hb = gtk_hbox_new (FALSE, 1);
+    GtkWidget *hb = gtk_hbox_new(FALSE, 1);
     // TRANSLATORS: "Stop" means: a "phase" of a gradient
-    GtkWidget *b = gtk_button_new_with_label (_("Add stop"));
-    gtk_widget_show (b);
-    gtk_container_add (GTK_CONTAINER (hb), b);
-    gtk_tooltips_set_tip (tt, b, _("Add another control stop to gradient"), NULL);
-    gtk_signal_connect (GTK_OBJECT (b), "clicked", GTK_SIGNAL_FUNC (sp_grd_ed_add_stop), vb);
-    b = gtk_button_new_with_label (_("Delete stop"));
-    gtk_widget_show (b);
-    gtk_container_add (GTK_CONTAINER (hb), b);
-    gtk_tooltips_set_tip (tt, b, _("Delete current control stop from gradient"), NULL);
-    gtk_signal_connect (GTK_OBJECT (b), "clicked", GTK_SIGNAL_FUNC (sp_grd_ed_del_stop), vb);
+    GtkWidget *b = gtk_button_new_with_label(_("Add stop"));
+    gtk_widget_show(b);
+    gtk_container_add(GTK_CONTAINER(hb), b);
+    gtk_tooltips_set_tip(tt, b, _("Add another control stop to gradient"), NULL);
+    gtk_signal_connect(GTK_OBJECT(b), "clicked", GTK_SIGNAL_FUNC(sp_grd_ed_add_stop), vb);
+    b = gtk_button_new_with_label(_("Delete stop"));
+    gtk_widget_show(b);
+    gtk_container_add(GTK_CONTAINER(hb), b);
+    gtk_tooltips_set_tip(tt, b, _("Delete current control stop from gradient"), NULL);
+    gtk_signal_connect(GTK_OBJECT(b), "clicked", GTK_SIGNAL_FUNC(sp_grd_ed_del_stop), vb);
 
-    gtk_widget_show (hb);
-    gtk_box_pack_start (GTK_BOX (vb),hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
+    gtk_widget_show(hb);
+    gtk_box_pack_start(GTK_BOX(vb),hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
 
 
     /*  Offset Slider and stuff   */
-    hb = gtk_hbox_new (FALSE, 0);
+    hb = gtk_hbox_new(FALSE, 0);
 
     /* Label */
-    GtkWidget *l = gtk_label_new (_("Offset:"));
-    gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
-    gtk_box_pack_start (GTK_BOX (hb),l, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
-    gtk_widget_show (l);
+    GtkWidget *l = gtk_label_new(_("Offset:"));
+    gtk_misc_set_alignment(GTK_MISC(l), 1.0, 0.5);
+    gtk_box_pack_start(GTK_BOX(hb),l, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
+    gtk_widget_show(l);
 
     /* Adjustment */
     GtkAdjustment *Offset_adj = NULL;
-    Offset_adj= (GtkAdjustment *) gtk_adjustment_new (0.0, 0.0, 1.0, 0.01, 0.01, 0.0);
-    gtk_object_set_data (GTK_OBJECT (vb), "offset", Offset_adj);
-    GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu (GTK_OPTION_MENU(mnu)));
-    SPStop *stop = SP_STOP (g_object_get_data (G_OBJECT (gtk_menu_get_active (m)), "stop"));
-    gtk_adjustment_set_value (Offset_adj, stop->offset);
+    Offset_adj= (GtkAdjustment *) gtk_adjustment_new(0.0, 0.0, 1.0, 0.01, 0.01, 0.0);
+    gtk_object_set_data(GTK_OBJECT(vb), "offset", Offset_adj);
+    GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(mnu)));
+    SPStop *stop = SP_STOP(g_object_get_data(G_OBJECT(gtk_menu_get_active(m)), "stop"));
+    gtk_adjustment_set_value(Offset_adj, stop->offset);
 
     /* Slider */
     GtkWidget *slider = gtk_hscale_new(Offset_adj);
     gtk_scale_set_draw_value( GTK_SCALE(slider), FALSE );
-    gtk_widget_show (slider);
-    gtk_box_pack_start (GTK_BOX (hb),slider, TRUE, TRUE, AUX_BETWEEN_BUTTON_GROUPS);
-    gtk_object_set_data (GTK_OBJECT (vb), "offslide", slider);
+    gtk_widget_show(slider);
+    gtk_box_pack_start(GTK_BOX(hb),slider, TRUE, TRUE, AUX_BETWEEN_BUTTON_GROUPS);
+    gtk_object_set_data(GTK_OBJECT(vb), "offslide", slider);
 
     /* Spinbutton */
-    GtkWidget *sbtn = gtk_spin_button_new (GTK_ADJUSTMENT (Offset_adj), 0.01, 2);
-    sp_dialog_defocus_on_enter (sbtn);
-    gtk_widget_show (sbtn);
-    gtk_box_pack_start (GTK_BOX (hb),sbtn, FALSE, TRUE, AUX_BETWEEN_BUTTON_GROUPS);
-    gtk_object_set_data (GTK_OBJECT (vb), "offspn", sbtn);
+    GtkWidget *sbtn = gtk_spin_button_new(GTK_ADJUSTMENT(Offset_adj), 0.01, 2);
+    sp_dialog_defocus_on_enter(sbtn);
+    gtk_widget_show(sbtn);
+    gtk_box_pack_start(GTK_BOX(hb),sbtn, FALSE, TRUE, AUX_BETWEEN_BUTTON_GROUPS);
+    gtk_object_set_data(GTK_OBJECT(vb), "offspn", sbtn);
 
     if (stop->offset>0 && stop->offset<1) {
-        gtk_widget_set_sensitive (slider, TRUE);
-        gtk_widget_set_sensitive (GTK_WIDGET (sbtn), TRUE);
+        gtk_widget_set_sensitive(slider, TRUE);
+        gtk_widget_set_sensitive(GTK_WIDGET(sbtn), TRUE);
     } else {
-        gtk_widget_set_sensitive (slider, FALSE);
-        gtk_widget_set_sensitive (GTK_WIDGET (sbtn), FALSE);
+        gtk_widget_set_sensitive(slider, FALSE);
+        gtk_widget_set_sensitive(GTK_WIDGET(sbtn), FALSE);
     }
 
 
     /* Signals */
-    gtk_signal_connect (GTK_OBJECT (Offset_adj), "value_changed",
-                        GTK_SIGNAL_FUNC (offadjustmentChanged), vb);
+    gtk_signal_connect(GTK_OBJECT(Offset_adj), "value_changed",
+                        GTK_SIGNAL_FUNC(offadjustmentChanged), vb);
 
-    // gtk_signal_connect (GTK_OBJECT (slider), "changed",  GTK_SIGNAL_FUNC (offsliderChanged), vb);
-    gtk_widget_show (hb);
-    gtk_box_pack_start (GTK_BOX (vb), hb, FALSE, FALSE, PAD);
+    // gtk_signal_connect(GTK_OBJECT(slider), "changed",  GTK_SIGNAL_FUNC(offsliderChanged), vb);
+    gtk_widget_show(hb);
+    gtk_box_pack_start(GTK_BOX(vb), hb, FALSE, FALSE, PAD);
 
     // TRANSLATORS: "Stop" means: a "phase" of a gradient
-    f = gtk_frame_new (_("Stop Color"));
-    gtk_widget_show (f);
-    gtk_box_pack_start (GTK_BOX (vb), f, TRUE, TRUE, PAD);
-    csel = (GtkWidget*)sp_color_selector_new (SP_TYPE_COLOR_NOTEBOOK);
-    g_object_set_data (G_OBJECT (vb), "cselector", csel);
-    gtk_widget_show (csel);
-    gtk_container_add (GTK_CONTAINER (f), csel);
-    g_signal_connect (G_OBJECT (csel), "dragged", G_CALLBACK (sp_gradient_vector_color_dragged), vb);
-    g_signal_connect (G_OBJECT (csel), "changed", G_CALLBACK (sp_gradient_vector_color_changed), vb);
-
-    gtk_widget_show (vb);
-
-    sp_gradient_vector_widget_load_gradient (vb, gradient);
-
-    if (select_stop)
-        select_stop_in_list (GTK_WIDGET(mnu), gradient, select_stop);
+    f = gtk_frame_new(_("Stop Color"));
+    gtk_widget_show(f);
+    gtk_box_pack_start(GTK_BOX(vb), f, TRUE, TRUE, PAD);
+    csel = static_cast<GtkWidget*>(sp_color_selector_new(SP_TYPE_COLOR_NOTEBOOK));
+    g_object_set_data(G_OBJECT(vb), "cselector", csel);
+    gtk_widget_show(csel);
+    gtk_container_add(GTK_CONTAINER(f), csel);
+    g_signal_connect(G_OBJECT(csel), "dragged", G_CALLBACK(sp_gradient_vector_color_dragged), vb);
+    g_signal_connect(G_OBJECT(csel), "changed", G_CALLBACK(sp_gradient_vector_color_changed), vb);
+
+    gtk_widget_show(vb);
+
+    sp_gradient_vector_widget_load_gradient(vb, gradient);
+
+    if (select_stop) {
+        select_stop_in_list(GTK_WIDGET(mnu), gradient, select_stop);
+    }
 
     return vb;
 }
 
 
 
-GtkWidget *
-sp_gradient_vector_editor_new (SPGradient *gradient, SPStop *stop)
+GtkWidget * sp_gradient_vector_editor_new(SPGradient *gradient, SPStop *stop)
 {
     GtkWidget *wid;
 
     if (dlg == NULL) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
-        dlg = sp_window_new (_("Gradient editor"), TRUE);
+        dlg = sp_window_new(_("Gradient editor"), TRUE);
         if (x == -1000 || y == -1000) {
             x = prefs->getInt(prefs_path + "x", -1000);
             y = prefs->getInt(prefs_path + "y", -1000);
@@ -912,32 +909,39 @@ sp_gradient_vector_editor_new (SPGradient *gradient, SPStop *stop)
             h = prefs->getInt(prefs_path + "h", 0);
         }
 
-        if (x<0) x=0;
-        if (y<0) y=0;
+        if (x<0) {
+            x=0;
+        }
+        if (y<0) {
+            y=0;
+        }
 
-        if (x != 0 || y != 0)
-            gtk_window_move ((GtkWindow *) dlg, x, y);
-        else
+        if (x != 0 || y != 0) {
+            gtk_window_move(reinterpret_cast<GtkWindow *>(dlg), x, y);
+        } else {
             gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER);
-        if (w && h) gtk_window_resize ((GtkWindow *) dlg, w, h);
-        sp_transientize (dlg);
+        }
+        if (w && h) {
+            gtk_window_resize(reinterpret_cast<GtkWindow *>(dlg), w, h);
+        }
+        sp_transientize(dlg);
         wd.win = dlg;
         wd.stop = 0;
-        g_signal_connect (G_OBJECT (INKSCAPE), "activate_desktop", G_CALLBACK (sp_transientize_callback), &wd);
-        gtk_signal_connect (GTK_OBJECT (dlg), "event", GTK_SIGNAL_FUNC (sp_dialog_event_handler), dlg);
-        gtk_signal_connect (GTK_OBJECT (dlg), "destroy", G_CALLBACK (sp_gradient_vector_dialog_destroy), dlg);
-        gtk_signal_connect (GTK_OBJECT (dlg), "delete_event", G_CALLBACK (sp_gradient_vector_dialog_delete), dlg);
-        g_signal_connect (G_OBJECT (INKSCAPE), "shut_down", G_CALLBACK (sp_gradient_vector_dialog_delete), dlg);
-        g_signal_connect ( G_OBJECT (INKSCAPE), "dialogs_hide", G_CALLBACK (sp_dialog_hide), dlg );
-        g_signal_connect ( G_OBJECT (INKSCAPE), "dialogs_unhide", G_CALLBACK (sp_dialog_unhide), dlg );
-
-        gtk_container_set_border_width (GTK_CONTAINER (dlg), PAD);
-
-        wid = (GtkWidget*)sp_gradient_vector_widget_new (gradient, stop);
-        g_object_set_data (G_OBJECT (dlg), "gradient-vector-widget", wid);
+        g_signal_connect(G_OBJECT(INKSCAPE), "activate_desktop", G_CALLBACK(sp_transientize_callback), &wd);
+        gtk_signal_connect(GTK_OBJECT(dlg), "event", GTK_SIGNAL_FUNC(sp_dialog_event_handler), dlg);
+        gtk_signal_connect(GTK_OBJECT(dlg), "destroy", G_CALLBACK(sp_gradient_vector_dialog_destroy), dlg);
+        gtk_signal_connect(GTK_OBJECT(dlg), "delete_event", G_CALLBACK(sp_gradient_vector_dialog_delete), dlg);
+        g_signal_connect(G_OBJECT(INKSCAPE), "shut_down", G_CALLBACK(sp_gradient_vector_dialog_delete), dlg);
+        g_signal_connect( G_OBJECT(INKSCAPE), "dialogs_hide", G_CALLBACK(sp_dialog_hide), dlg );
+        g_signal_connect( G_OBJECT(INKSCAPE), "dialogs_unhide", G_CALLBACK(sp_dialog_unhide), dlg );
+
+        gtk_container_set_border_width(GTK_CONTAINER(dlg), PAD);
+
+        wid = static_cast<GtkWidget*>(sp_gradient_vector_widget_new(gradient, stop));
+        g_object_set_data(G_OBJECT(dlg), "gradient-vector-widget", wid);
         /* Connect signals */
-        gtk_widget_show (wid);
-        gtk_container_add (GTK_CONTAINER (dlg), wid);
+        gtk_widget_show(wid);
+        gtk_container_add(GTK_CONTAINER(dlg), wid);
     } else {
         // FIXME: temp fix for 0.38
         // Simply load_gradient into the editor does not work for multi-stop gradients,
@@ -946,29 +950,28 @@ sp_gradient_vector_editor_new (SPGradient *gradient, SPStop *stop)
         // and call sp_gradient_vector_editor_new again, so it creates the window anew.
 
         GdkEventAny event;
-        GtkWidget *widget = (GtkWidget *) dlg;
+        GtkWidget *widget = static_cast<GtkWidget *>(dlg);
         event.type = GDK_DELETE;
         event.window = widget->window;
         event.send_event = TRUE;
-        g_object_ref (G_OBJECT (event.window));
-        gtk_main_do_event ((GdkEvent*)&event);
-        g_object_unref (G_OBJECT (event.window));
+        g_object_ref(G_OBJECT(event.window));
+        gtk_main_do_event(reinterpret_cast<GdkEvent*>(&event));
+        g_object_unref(G_OBJECT(event.window));
 
-        g_assert (dlg == NULL);
-        sp_gradient_vector_editor_new (gradient, stop);
+        g_assert(dlg == NULL);
+        sp_gradient_vector_editor_new(gradient, stop);
     }
 
     return dlg;
 }
 
-static void
-sp_gradient_vector_widget_load_gradient (GtkWidget *widget, SPGradient *gradient)
+static void sp_gradient_vector_widget_load_gradient(GtkWidget *widget, SPGradient *gradient)
 {
     blocked = TRUE;
 
     SPGradient *old;
 
-    old = (SPGradient*)g_object_get_data (G_OBJECT (widget), "gradient");
+    old = (SPGradient*)g_object_get_data(G_OBJECT(widget), "gradient");
 
     if (old != gradient) {
         sigc::connection *release_connection;
@@ -982,7 +985,7 @@ sp_gradient_vector_widget_load_gradient (GtkWidget *widget, SPGradient *gradient
             g_assert( modified_connection != NULL );
             release_connection->disconnect();
             modified_connection->disconnect();
-            sp_signal_disconnect_by_data (old, widget);
+            sp_signal_disconnect_by_data(old, widget);
         }
 
         if (gradient) {
@@ -1009,62 +1012,64 @@ sp_gradient_vector_widget_load_gradient (GtkWidget *widget, SPGradient *gradient
         g_object_set_data(G_OBJECT(widget), "gradient_modified_connection", modified_connection);
     }
 
-    g_object_set_data (G_OBJECT (widget), "gradient", gradient);
+    g_object_set_data(G_OBJECT(widget), "gradient", gradient);
 
     if (gradient) {
-        gtk_widget_set_sensitive (widget, TRUE);
+        gtk_widget_set_sensitive(widget, TRUE);
 
-        sp_gradient_ensure_vector (gradient);
+        sp_gradient_ensure_vector(gradient);
 
-        GtkOptionMenu *mnu = (GtkOptionMenu *)g_object_get_data (G_OBJECT(widget), "stopmenu");
-        SPStop *stop = SP_STOP(g_object_get_data (G_OBJECT(gtk_menu_get_active (GTK_MENU(gtk_option_menu_get_menu (mnu)))), "stop"));
+        GtkOptionMenu *mnu = static_cast<GtkOptionMenu *>(g_object_get_data(G_OBJECT(widget), "stopmenu"));
+        SPStop *stop = SP_STOP(g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))), "stop"));
         guint32 const c = sp_stop_get_rgba32(stop);
 
         /// get the color selector
-        SPColorSelector *csel = SP_COLOR_SELECTOR(g_object_get_data (G_OBJECT (widget), "cselector"));
+        SPColorSelector *csel = SP_COLOR_SELECTOR(g_object_get_data(G_OBJECT(widget), "cselector"));
         // set alpha
-        csel->base->setAlpha(SP_RGBA32_A_F (c));
-        SPColor color( SP_RGBA32_R_F (c), SP_RGBA32_G_F (c), SP_RGBA32_B_F (c) );
+        csel->base->setAlpha(SP_RGBA32_A_F(c));
+        SPColor color( SP_RGBA32_R_F(c), SP_RGBA32_G_F(c), SP_RGBA32_B_F(c) );
         // set color
         csel->base->setColor( color );
 
         /* Fill preview */
         GtkWidget *w = static_cast<GtkWidget *>(g_object_get_data(G_OBJECT(widget), "preview"));
-        sp_gradient_image_set_gradient (SP_GRADIENT_IMAGE (w), gradient);
+        sp_gradient_image_set_gradient(SP_GRADIENT_IMAGE(w), gradient);
 
-        update_stop_list (GTK_WIDGET(mnu), gradient, NULL);
+        update_stop_list(GTK_WIDGET(mnu), gradient, NULL);
 
         // Once the user edits a gradient, it stops being auto-collectable
         if (SP_OBJECT_REPR(gradient)->attribute("inkscape:collect")) {
-            SPDocument *document = SP_OBJECT_DOCUMENT (gradient);
+            SPDocument *document = SP_OBJECT_DOCUMENT(gradient);
             bool saved = sp_document_get_undo_sensitive(document);
-            sp_document_set_undo_sensitive (document, false);
+            sp_document_set_undo_sensitive(document, false);
             SP_OBJECT_REPR(gradient)->setAttribute("inkscape:collect", NULL);
-            sp_document_set_undo_sensitive (document, saved);
+            sp_document_set_undo_sensitive(document, saved);
         }
     } else { // no gradient, disable everything
-        gtk_widget_set_sensitive (widget, FALSE);
+        gtk_widget_set_sensitive(widget, FALSE);
     }
 
     blocked = FALSE;
 }
 
-static void
-sp_gradient_vector_dialog_destroy (GtkObject */*object*/, gpointer /*data*/)
+static void sp_gradient_vector_dialog_destroy(GtkObject */*object*/, gpointer /*data*/)
 {
-    sp_signal_disconnect_by_data (INKSCAPE, dlg);
+    sp_signal_disconnect_by_data(INKSCAPE, dlg);
     wd.win = dlg = NULL;
     wd.stop = 0;
 }
 
-static gboolean
-sp_gradient_vector_dialog_delete (GtkWidget */*widget*/, GdkEvent */*event*/, GtkWidget */*dialog*/)
+static gboolean sp_gradient_vector_dialog_delete(GtkWidget */*widget*/, GdkEvent */*event*/, GtkWidget */*dialog*/)
 {
-    gtk_window_get_position ((GtkWindow *) dlg, &x, &y);
-    gtk_window_get_size ((GtkWindow *) dlg, &w, &h);
+    gtk_window_get_position(GTK_WINDOW(dlg), &x, &y);
+    gtk_window_get_size(GTK_WINDOW(dlg), &w, &h);
 
-    if (x<0) x=0;
-    if (y<0) y=0;
+    if (x<0) {
+        x=0;
+    }
+    if (y<0) {
+        y=0;
+    }
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     prefs->setInt(prefs_path + "x", x);
@@ -1077,12 +1082,11 @@ sp_gradient_vector_dialog_delete (GtkWidget */*widget*/, GdkEvent */*event*/, Gt
 
 /* Widget destroy handler */
 
-static void
-sp_gradient_vector_widget_destroy (GtkObject *object, gpointer /*data*/)
+static void sp_gradient_vector_widget_destroy(GtkObject *object, gpointer /*data*/)
 {
     GObject *gradient;
 
-    gradient = (GObject*)g_object_get_data (G_OBJECT (object), "gradient");
+    gradient = (GObject*)g_object_get_data(G_OBJECT(object), "gradient");
 
     sigc::connection *release_connection = (sigc::connection *)g_object_get_data(G_OBJECT(object), "gradient_release_connection");
     sigc::connection *modified_connection = (sigc::connection *)g_object_get_data(G_OBJECT(object), "gradient_modified_connection");
@@ -1092,27 +1096,25 @@ sp_gradient_vector_widget_destroy (GtkObject *object, gpointer /*data*/)
         g_assert( modified_connection != NULL );
         release_connection->disconnect();
         modified_connection->disconnect();
-        sp_signal_disconnect_by_data (gradient, object);
+        sp_signal_disconnect_by_data(gradient, object);
     }
 
     if (gradient && SP_OBJECT_REPR(gradient)) {
-        sp_repr_remove_listener_by_data (SP_OBJECT_REPR(gradient), object);
+        sp_repr_remove_listener_by_data(SP_OBJECT_REPR(gradient), object);
     }
 }
 
-static void
-sp_gradient_vector_gradient_release (SPObject */*object*/, GtkWidget *widget)
+static void sp_gradient_vector_gradient_release(SPObject */*object*/, GtkWidget *widget)
 {
-    sp_gradient_vector_widget_load_gradient (widget, NULL);
+    sp_gradient_vector_widget_load_gradient(widget, NULL);
 }
 
-static void
-sp_gradient_vector_gradient_modified (SPObject *object, guint /*flags*/, GtkWidget *widget)
+static void sp_gradient_vector_gradient_modified(SPObject *object, guint /*flags*/, GtkWidget *widget)
 {
     SPGradient *gradient=SP_GRADIENT(object);
     if (!blocked) {
         blocked = TRUE;
-        sp_gradient_vector_widget_load_gradient (widget, gradient);
+        sp_gradient_vector_widget_load_gradient(widget, gradient);
         blocked = FALSE;
     }
 }
@@ -1121,79 +1123,86 @@ static void sp_gradient_vector_color_dragged(SPColorSelector *csel, GtkObject *o
 {
     SPGradient *gradient, *ngr;
 
-    if (blocked) return;
+    if (blocked) {
+        return;
+    }
 
-    gradient = (SPGradient*)g_object_get_data (G_OBJECT (object), "gradient");
-    if (!gradient) return;
+    gradient = static_cast<SPGradient*>(g_object_get_data(G_OBJECT(object), "gradient"));
+    if (!gradient) {
+        return;
+    }
 
     blocked = TRUE;
 
-    ngr = sp_gradient_ensure_vector_normalized (gradient);
+    ngr = sp_gradient_ensure_vector_normalized(gradient);
     if (ngr != gradient) {
         /* Our master gradient has changed */
-        sp_gradient_vector_widget_load_gradient (GTK_WIDGET (object), ngr);
+        sp_gradient_vector_widget_load_gradient(GTK_WIDGET(object), ngr);
     }
 
-    sp_gradient_ensure_vector (ngr);
+    sp_gradient_ensure_vector(ngr);
 
-    GtkOptionMenu *mnu = (GtkOptionMenu *)g_object_get_data (G_OBJECT(object), "stopmenu");
-    SPStop *stop = SP_STOP(g_object_get_data (G_OBJECT(gtk_menu_get_active (GTK_MENU(gtk_option_menu_get_menu (mnu)))), "stop"));
+    GtkOptionMenu *mnu = static_cast<GtkOptionMenu *>(g_object_get_data(G_OBJECT(object), "stopmenu"));
+    SPStop *stop = SP_STOP(g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))), "stop"));
 
 
-    csel->base->getColorAlpha(stop->specified_color, &stop->opacity);
+    csel->base->getColorAlpha(stop->specified_color, stop->opacity);
     stop->currentColor = false;
 
     blocked = FALSE;
 }
 
-static void
-sp_gradient_vector_color_changed (SPColorSelector *csel, GtkObject *object)
+static void sp_gradient_vector_color_changed(SPColorSelector *csel, GtkObject *object)
 {
     SPColor color;
     float alpha;
     guint32 rgb;
 
-    if (blocked) return;
+    if (blocked) {
+        return;
+    }
 
-    SPGradient *gradient = (SPGradient*)g_object_get_data (G_OBJECT (object), "gradient");
-    if (!gradient) return;
+    SPGradient *gradient = static_cast<SPGradient*>(g_object_get_data(G_OBJECT(object), "gradient"));
+    if (!gradient) {
+        return;
+    }
 
     blocked = TRUE;
 
-    SPGradient *ngr = sp_gradient_ensure_vector_normalized (gradient);
+    SPGradient *ngr = sp_gradient_ensure_vector_normalized(gradient);
     if (ngr != gradient) {
         /* Our master gradient has changed */
-        sp_gradient_vector_widget_load_gradient (GTK_WIDGET (object), ngr);
+        sp_gradient_vector_widget_load_gradient(GTK_WIDGET(object), ngr);
     }
 
-    sp_gradient_ensure_vector (ngr);
+    sp_gradient_ensure_vector(ngr);
 
     /* Set start parameters */
     /* We rely on normalized vector, i.e. stops HAVE to exist */
-    g_return_if_fail (sp_first_stop(ngr) != NULL);
+    g_return_if_fail(ngr->getFirstStop() != NULL);
 
-    GtkOptionMenu *mnu = (GtkOptionMenu *)g_object_get_data (G_OBJECT(object), "stopmenu");
-    SPStop *stop = SP_STOP(g_object_get_data (G_OBJECT(gtk_menu_get_active (GTK_MENU(gtk_option_menu_get_menu (mnu)))), "stop"));
+    GtkOptionMenu *mnu = static_cast<GtkOptionMenu *>(g_object_get_data(G_OBJECT(object), "stopmenu"));
+    SPStop *stop = SP_STOP(g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))), "stop"));
 
-    csel = (SPColorSelector*)g_object_get_data (G_OBJECT (object), "cselector");
-    csel->base->getColorAlpha( color, &alpha );
+    csel = static_cast<SPColorSelector*>(g_object_get_data(G_OBJECT(object), "cselector"));
+    csel->base->getColorAlpha( color, alpha );
     rgb = color.toRGBA32( 0x00 );
 
-    sp_repr_set_css_double (SP_OBJECT_REPR (stop), "offset", stop->offset);
+    sp_repr_set_css_double(SP_OBJECT_REPR(stop), "offset", stop->offset);
     Inkscape::CSSOStringStream os;
     gchar c[64];
-    sp_svg_write_color (c, sizeof(c), rgb);
-    os << "stop-color:" << c << ";stop-opacity:" << (gdouble) alpha <<";";
-    SP_OBJECT_REPR (stop)->setAttribute("style", os.str().c_str());
-    // g_snprintf (c, 256, "stop-color:#%06x;stop-opacity:%g;", rgb >> 8, (gdouble) alpha);
-    //SP_OBJECT_REPR (stop)->setAttribute("style", c);
+    sp_svg_write_color(c, sizeof(c), rgb);
+    os << "stop-color:" << c << ";stop-opacity:" << static_cast<gdouble>(alpha) <<";";
+    SP_OBJECT_REPR(stop)->setAttribute("style", os.str().c_str());
+    // g_snprintf(c, 256, "stop-color:#%06x;stop-opacity:%g;", rgb >> 8, static_cast<gdouble>(alpha));
+    //SP_OBJECT_REPR(stop)->setAttribute("style", c);
 
-    sp_document_done (SP_OBJECT_DOCUMENT (ngr), SP_VERB_CONTEXT_GRADIENT,
+    sp_document_done(SP_OBJECT_DOCUMENT(ngr), SP_VERB_CONTEXT_GRADIENT,
                       _("Change gradient stop color"));
 
     blocked = FALSE;
 
-    SPColorPreview *cpv = (SPColorPreview *)g_object_get_data (G_OBJECT(gtk_menu_get_active (GTK_MENU(gtk_option_menu_get_menu (mnu)))), "preview");
+    SPColorPreview *cpv = static_cast<SPColorPreview *>(g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))), "preview"));
     sp_color_preview_set_rgba32(cpv, sp_stop_get_rgba32(stop));
 }
 
diff --git a/src/widgets/gradient-vector.h b/src/widgets/gradient-vector.h
index ea1f5159f..ceca9158c 100644
--- a/src/widgets/gradient-vector.h
+++ b/src/widgets/gradient-vector.h
@@ -6,7 +6,9 @@
  *
  * Author:
  *   Lauris Kaplinski <lauris@kaplinski.com>
+ *   Jon A. Cruz <jon@joncruz.org>
  *
+ * Copyright (C) 2010 Jon A. Cruz
  * Copyright (C) 2001-2002 Lauris Kaplinski
  * Copyright (C) 2001 Ximian, Inc.
  *
@@ -31,6 +33,8 @@ struct SPGradientVectorSelector {
 
     guint idlabel : 1;
 
+    bool swatched;
+
     SPDocument *doc;
     SPGradient *gr;
 
@@ -40,6 +44,9 @@ struct SPGradientVectorSelector {
     sigc::connection gradient_release_connection;
     sigc::connection defs_release_connection;
     sigc::connection defs_modified_connection;
+
+
+    void setSwatched();
 };
 
 struct SPGradientVectorSelectorClass {
diff --git a/src/widgets/icon.cpp b/src/widgets/icon.cpp
index 743502d27..5d91d3532 100644
--- a/src/widgets/icon.cpp
+++ b/src/widgets/icon.cpp
@@ -1115,6 +1115,26 @@ static guchar *load_svg_pixels(gchar const *name,
             /* Create ArenaItem and set transform */
             unsigned visionkey = sp_item_display_key_new(1);
             /* fixme: Memory manage root if needed (Lauris) */
+            // This needs to be fixed indeed; this leads to a memory leak of a few megabytes these days
+            // because shapes are being rendered which are not being freed
+            // Valgrind output:
+            /*==7014== 1,548,344 bytes in 599 blocks are possibly lost in loss record 20,361 of 20,362
+            ==7014==    at 0x4A05974: operator new(unsigned long) (vg_replace_malloc.c:220)
+            ==7014==    by 0x4F1015: __gnu_cxx::new_allocator<Shape::point_data>::allocate(unsigned long, void const*) (new_allocator.h:89)
+            ==7014==    by 0x4F02AC: std::_Vector_base<Shape::point_data, std::allocator<Shape::point_data> >::_M_allocate(unsigned long) (stl_vector.h:140)
+            ==7014==    by 0xCF62D7: std::vector<Shape::point_data, std::allocator<Shape::point_data> >::_M_fill_insert(__gnu_cxx::__normal_iterator<Shape::point_data*, std::vector<Shape::point_data, std::allocator<Shape::point_data> > >, unsigned long, Shape::point_data const&) (vector.tcc:414)
+            ==7014==    by 0xCF4D45: std::vector<Shape::point_data, std::allocator<Shape::point_data> >::insert(__gnu_cxx::__normal_iterator<Shape::point_data*, std::vector<Shape::point_data, std::allocator<Shape::point_data> > >, unsigned long, Shape::point_data const&) (stl_vector.h:851)
+            ==7014==    by 0xCF3DCD: std::vector<Shape::point_data, std::allocator<Shape::point_data> >::resize(unsigned long, Shape::point_data) (stl_vector.h:557)
+            ==7014==    by 0xCEA771: Shape::AddPoint(Geom::Point) (Shape.cpp:326)
+            ==7014==    by 0xD0F413: Shape::ConvertToShape(Shape*, fill_typ, bool) (ShapeSweep.cpp:257)
+            ==7014==    by 0x5ECD4F: nr_arena_shape_update_stroke(NRArenaShape*, NRGC*, NRRectL*) (nr-arena-shape.cpp:651)
+            ==7014==    by 0x5EE0DA: nr_arena_shape_render(_cairo*, NRArenaItem*, NRRectL*, NRPixBlock*, unsigned int) (nr-arena-shape.cpp:862)
+            ==7014==    by 0x5E72FB: nr_arena_item_invoke_render(_cairo*, NRArenaItem*, NRRectL const*, NRPixBlock*, unsigned int) (nr-arena-item.cpp:578)
+            ==7014==    by 0x5E9DDE: nr_arena_group_render(_cairo*, NRArenaItem*, NRRectL*, NRPixBlock*, unsigned int) (nr-arena-group.cpp:228)
+            ==7014==    by 0x5E72FB: nr_arena_item_invoke_render(_cairo*, NRArenaItem*, NRRectL const*, NRPixBlock*, unsigned int) (nr-arena-item.cpp:578)
+            ==7014==    by 0x5E9DDE: nr_arena_group_render(_cairo*, NRArenaItem*, NRRectL*, NRPixBlock*, unsigned int) (nr-arena-group.cpp:228)
+            ==7014==    by 0x5E72FB: nr_arena_item_invoke_render(_cairo*, NRArenaItem*, NRRectL const*, NRPixBlock*, unsigned int) (nr-arena-item.cpp:578)
+            */
             root = sp_item_invoke_show( SP_ITEM(SP_DOCUMENT_ROOT(doc)),
                                         arena, visionkey, SP_ITEM_SHOW_DISPLAY );
 
diff --git a/src/widgets/paint-selector.cpp b/src/widgets/paint-selector.cpp
index a101b9eeb..288764177 100644
--- a/src/widgets/paint-selector.cpp
+++ b/src/widgets/paint-selector.cpp
@@ -1,13 +1,16 @@
-#define __SP_PAINT_SELECTOR_C__
-
 /** \file
  * SPPaintSelector: Generic paint selector widget.
  */
 
 /*
- * Copyright (C) Lauris Kaplinski 2002
+ * Authors:
+ *   Lauris Kaplinski
  *   bulia byak <buliabyak@users.sf.net>
  *   John Cliff <simarilius@yahoo.com>
+ *   Jon A. Cruz <jon@joncruz.org>
+ *
+ * Copyright (C) Lauris Kaplinski 2002
+ * Copyright (C) 2010 Authors
 */
 
 #define noSP_PS_VERBOSE
@@ -49,6 +52,7 @@
 #include "io/sys.h"
 #include "helper/stock-items.h"
 #include "ui/icon-names.h"
+#include "widgets/swatch-selector.h"
 
 #include "paint-selector.h"
 
@@ -56,6 +60,9 @@
 #include "svg/svg-icc-color.h"
 #endif // SP_PS_VERBOSE
 
+
+using Inkscape::Widgets::SwatchSelector;
+
 enum {
     MODE_CHANGED,
     GRABBED,
@@ -70,16 +77,17 @@ static void sp_paint_selector_class_init(SPPaintSelectorClass *klass);
 static void sp_paint_selector_init(SPPaintSelector *slider);
 static void sp_paint_selector_destroy(GtkObject *object);
 
-static GtkWidget *sp_paint_selector_style_button_add(SPPaintSelector *psel, gchar const *px, SPPaintSelectorMode mode, GtkTooltips *tt, gchar const *tip);
+static GtkWidget *sp_paint_selector_style_button_add(SPPaintSelector *psel, gchar const *px, SPPaintSelector::Mode mode, GtkTooltips *tt, gchar const *tip);
 static void sp_paint_selector_style_button_toggled(GtkToggleButton *tb, SPPaintSelector *psel);
 static void sp_paint_selector_fillrule_toggled(GtkToggleButton *tb, SPPaintSelector *psel);
 
 static void sp_paint_selector_set_mode_empty(SPPaintSelector *psel);
 static void sp_paint_selector_set_mode_multiple(SPPaintSelector *psel);
 static void sp_paint_selector_set_mode_none(SPPaintSelector *psel);
-static void sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelectorMode mode);
-static void sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelectorMode mode);
-static void sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSelectorMode mode);
+static void sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelector::Mode mode);
+static void sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelector::Mode mode);
+static void sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSelector::Mode mode);
+static void sp_paint_selector_set_mode_swatch(SPPaintSelector *psel, SPPaintSelector::Mode mode);
 static void sp_paint_selector_set_mode_unset(SPPaintSelector *psel);
 
 
@@ -88,6 +96,48 @@ static void sp_paint_selector_set_style_buttons(SPPaintSelector *psel, GtkWidget
 static GtkVBoxClass *parent_class;
 static guint psel_signals[LAST_SIGNAL] = {0};
 
+#ifdef SP_PS_VERBOSE
+static gchar const* modeStrings[] = {
+    "MODE_EMPTY",
+    "MODE_MULTIPLE",
+    "MODE_NONE",
+    "MODE_COLOR_RGB",
+    "MODE_COLOR_CMYK",
+    "MODE_GRADIENT_LINEAR",
+    "MODE_GRADIENT_RADIAL",
+    "MODE_PATTERN",
+    "MODE_SWATCH",
+    "MODE_UNSET",
+    ".",
+    ".",
+    ".",
+};
+#endif
+
+
+static bool isPaintModeGradient( SPPaintSelector::Mode mode )
+{
+    bool isGrad = (mode == SPPaintSelector::MODE_GRADIENT_LINEAR) ||
+        (mode == SPPaintSelector::MODE_GRADIENT_RADIAL) ||
+        (mode == SPPaintSelector::MODE_SWATCH);
+
+    return isGrad;
+}
+
+static SPGradientSelector *getGradientFromData(SPPaintSelector const *psel)
+{
+    SPGradientSelector *grad = 0;
+    if (psel->mode == SPPaintSelector::MODE_SWATCH) {
+        SwatchSelector *swatchsel = static_cast<SwatchSelector*>(g_object_get_data(G_OBJECT(psel->selector), "swatch-selector"));
+        if (swatchsel) {
+            grad = swatchsel->getGradientSelector();
+        }
+    } else {
+        grad = reinterpret_cast<SPGradientSelector*>(gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector"));
+    }
+    return grad;
+}
+
 GType sp_paint_selector_get_type(void)
 {
     static GtkType type = 0;
@@ -168,7 +218,7 @@ sp_paint_selector_init(SPPaintSelector *psel)
 {
     GtkTooltips *tt = gtk_tooltips_new();
 
-    psel->mode = (SPPaintSelectorMode)-1; // huh?  do you mean 0xff?  --  I think this means "not in the enum"
+    psel->mode = static_cast<SPPaintSelector::Mode>(-1); // huh?  do you mean 0xff?  --  I think this means "not in the enum"
 
     /* Paint style button box */
     psel->style = gtk_hbox_new(FALSE, 0);
@@ -178,17 +228,19 @@ sp_paint_selector_init(SPPaintSelector *psel)
 
     /* Buttons */
     psel->none = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_NONE,
-                                                    SP_PAINT_SELECTOR_MODE_NONE, tt, _("No paint"));
+                                                    SPPaintSelector::MODE_NONE, tt, _("No paint"));
     psel->solid = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_SOLID,
-                                                     SP_PAINT_SELECTOR_MODE_COLOR_RGB, tt, _("Flat color"));
+                                                     SPPaintSelector::MODE_COLOR_RGB, tt, _("Flat color"));
     psel->gradient = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_GRADIENT_LINEAR,
-                                                        SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR, tt, _("Linear gradient"));
+                                                        SPPaintSelector::MODE_GRADIENT_LINEAR, tt, _("Linear gradient"));
     psel->radial = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_GRADIENT_RADIAL,
-                                                      SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL, tt, _("Radial gradient"));
+                                                      SPPaintSelector::MODE_GRADIENT_RADIAL, tt, _("Radial gradient"));
     psel->pattern = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_PATTERN,
-                                                       SP_PAINT_SELECTOR_MODE_PATTERN, tt, _("Pattern"));
+                                                       SPPaintSelector::MODE_PATTERN, tt, _("Pattern"));
+    psel->swatch = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_SWATCH,
+                                                       SPPaintSelector::MODE_SWATCH, tt, _("Swatch"));
     psel->unset = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_UNKNOWN,
-                                                     SP_PAINT_SELECTOR_MODE_UNSET, tt, _("Unset paint (make it undefined so it can be inherited)"));
+                                                     SPPaintSelector::MODE_UNSET, tt, _("Unset paint (make it undefined so it can be inherited)"));
 
     /* Fillrule */
     {
@@ -201,7 +253,7 @@ sp_paint_selector_init(SPPaintSelector *psel)
         gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(psel->evenodd), FALSE);
         // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/painting.html#FillRuleProperty
         gtk_tooltips_set_tip(tt, psel->evenodd, _("Any path self-intersections or subpaths create holes in the fill (fill-rule: evenodd)"), NULL);
-        gtk_object_set_data(GTK_OBJECT(psel->evenodd), "mode", GUINT_TO_POINTER(SP_PAINT_SELECTOR_FILLRULE_EVENODD));
+        gtk_object_set_data(GTK_OBJECT(psel->evenodd), "mode", GUINT_TO_POINTER(SPPaintSelector::FILLRULE_EVENODD));
         w = sp_icon_new(Inkscape::ICON_SIZE_DECORATION, INKSCAPE_ICON_FILL_RULE_EVEN_ODD);
         gtk_container_add(GTK_CONTAINER(psel->evenodd), w);
         gtk_box_pack_start(GTK_BOX(psel->fillrulebox), psel->evenodd, FALSE, FALSE, 0);
@@ -212,7 +264,7 @@ sp_paint_selector_init(SPPaintSelector *psel)
         gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(psel->nonzero), FALSE);
         // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/painting.html#FillRuleProperty
         gtk_tooltips_set_tip(tt, psel->nonzero, _("Fill is solid unless a subpath is counterdirectional (fill-rule: nonzero)"), NULL);
-        gtk_object_set_data(GTK_OBJECT(psel->nonzero), "mode", GUINT_TO_POINTER(SP_PAINT_SELECTOR_FILLRULE_NONZERO));
+        gtk_object_set_data(GTK_OBJECT(psel->nonzero), "mode", GUINT_TO_POINTER(SPPaintSelector::FILLRULE_NONZERO));
         w = sp_icon_new(Inkscape::ICON_SIZE_DECORATION, INKSCAPE_ICON_FILL_RULE_NONZERO);
         gtk_container_add(GTK_CONTAINER(psel->nonzero), w);
         gtk_box_pack_start(GTK_BOX(psel->fillrulebox), psel->nonzero, FALSE, FALSE, 0);
@@ -242,10 +294,9 @@ sp_paint_selector_destroy(GtkObject *object)
         (* ((GtkObjectClass *) parent_class)->destroy)(object);
 }
 
-static GtkWidget *
-sp_paint_selector_style_button_add(SPPaintSelector *psel,
-                                   gchar const *pixmap, SPPaintSelectorMode mode,
-                                   GtkTooltips *tt, gchar const *tip)
+static GtkWidget *sp_paint_selector_style_button_add(SPPaintSelector *psel,
+                                                     gchar const *pixmap, SPPaintSelector::Mode mode,
+                                                     GtkTooltips *tt, gchar const *tip)
 {
     GtkWidget *b, *w;
 
@@ -274,7 +325,7 @@ static void
 sp_paint_selector_style_button_toggled(GtkToggleButton *tb, SPPaintSelector *psel)
 {
     if (!psel->update && gtk_toggle_button_get_active(tb)) {
-        sp_paint_selector_set_mode(psel, (SPPaintSelectorMode)GPOINTER_TO_UINT(gtk_object_get_data(GTK_OBJECT(tb), "mode")));
+        psel->setMode(static_cast<SPPaintSelector::Mode>(GPOINTER_TO_UINT(gtk_object_get_data(GTK_OBJECT(tb), "mode"))));
     }
 }
 
@@ -282,7 +333,7 @@ static void
 sp_paint_selector_fillrule_toggled(GtkToggleButton *tb, SPPaintSelector *psel)
 {
     if (!psel->update && gtk_toggle_button_get_active(tb)) {
-        SPPaintSelectorFillRule fr = (SPPaintSelectorFillRule)GPOINTER_TO_UINT(gtk_object_get_data(GTK_OBJECT(tb), "mode"));
+        SPPaintSelector::FillRule fr = static_cast<SPPaintSelector::FillRule>(GPOINTER_TO_UINT(g_object_get_data(G_OBJECT(tb), "mode")));
         gtk_signal_emit(GTK_OBJECT(psel), psel_signals[FILLRULE_CHANGED], fr);
     }
 }
@@ -304,11 +355,9 @@ sp_paint_selector_show_fillrule(SPPaintSelector *psel, bool is_fill)
 GtkWidget *
 sp_paint_selector_new(bool is_fill)
 {
-    SPPaintSelector *psel;
+    SPPaintSelector *psel = static_cast<SPPaintSelector*>(gtk_type_new(SP_TYPE_PAINT_SELECTOR));
 
-    psel = (SPPaintSelector*)gtk_type_new(SP_TYPE_PAINT_SELECTOR);
-
-    sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_MULTIPLE);
+    psel->setMode(SPPaintSelector::MODE_MULTIPLE);
 
     // This silliness is here because I don't know how to pass a parameter to the
     // GtkObject "constructor" (sp_paint_selector_init). Remove it when paint_selector
@@ -318,63 +367,64 @@ sp_paint_selector_new(bool is_fill)
     return GTK_WIDGET(psel);
 }
 
-void
-sp_paint_selector_set_mode(SPPaintSelector *psel, SPPaintSelectorMode mode)
+void SPPaintSelector::setMode(Mode mode)
 {
-    if (psel->mode != mode) {
-        psel->update = TRUE;
+    if (this->mode != mode) {
+        update = TRUE;
 #ifdef SP_PS_VERBOSE
-        g_print("Mode change %d -> %d\n", psel->mode, mode);
+        g_print("Mode change %d -> %d   %s -> %s\n", this->mode, mode, modeStrings[this->mode], modeStrings[mode]);
 #endif
         switch (mode) {
-            case SP_PAINT_SELECTOR_MODE_EMPTY:
-                sp_paint_selector_set_mode_empty(psel);
+            case MODE_EMPTY:
+                sp_paint_selector_set_mode_empty(this);
                 break;
-            case SP_PAINT_SELECTOR_MODE_MULTIPLE:
-                sp_paint_selector_set_mode_multiple(psel);
+            case MODE_MULTIPLE:
+                sp_paint_selector_set_mode_multiple(this);
                 break;
-            case SP_PAINT_SELECTOR_MODE_NONE:
-                sp_paint_selector_set_mode_none(psel);
+            case MODE_NONE:
+                sp_paint_selector_set_mode_none(this);
                 break;
-            case SP_PAINT_SELECTOR_MODE_COLOR_RGB:
-            case SP_PAINT_SELECTOR_MODE_COLOR_CMYK:
-                sp_paint_selector_set_mode_color(psel, mode);
+            case MODE_COLOR_RGB:
+            case MODE_COLOR_CMYK:
+                sp_paint_selector_set_mode_color(this, mode);
                 break;
-            case SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR:
-            case SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL:
-                sp_paint_selector_set_mode_gradient(psel, mode);
+            case MODE_GRADIENT_LINEAR:
+            case MODE_GRADIENT_RADIAL:
+                sp_paint_selector_set_mode_gradient(this, mode);
                 break;
-            case SP_PAINT_SELECTOR_MODE_PATTERN:
-                sp_paint_selector_set_mode_pattern(psel, mode);
+            case MODE_PATTERN:
+                sp_paint_selector_set_mode_pattern(this, mode);
                 break;
-            case SP_PAINT_SELECTOR_MODE_UNSET:
-                sp_paint_selector_set_mode_unset(psel);
+            case MODE_SWATCH:
+                sp_paint_selector_set_mode_swatch(this, mode);
+                break;
+            case MODE_UNSET:
+                sp_paint_selector_set_mode_unset(this);
                 break;
             default:
                 g_warning("file %s: line %d: Unknown paint mode %d", __FILE__, __LINE__, mode);
                 break;
         }
-        psel->mode = mode;
-        gtk_signal_emit(GTK_OBJECT(psel), psel_signals[MODE_CHANGED], psel->mode);
-        psel->update = FALSE;
+        this->mode = mode;
+        gtk_signal_emit(GTK_OBJECT(this), psel_signals[MODE_CHANGED], this->mode);
+        update = FALSE;
     }
 }
 
-void
-sp_paint_selector_set_fillrule(SPPaintSelector *psel, SPPaintSelectorFillRule fillrule)
+void SPPaintSelector::setFillrule(FillRule fillrule)
 {
-    if (psel->fillrulebox) {
-        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->evenodd), (fillrule == SP_PAINT_SELECTOR_FILLRULE_EVENODD));
-        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->nonzero), (fillrule == SP_PAINT_SELECTOR_FILLRULE_NONZERO));
+    if (fillrulebox) {
+        // TODO this flips widgets but does not use a member to store state. Revisit
+        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(evenodd), (fillrule == FILLRULE_EVENODD));
+        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(nonzero), (fillrule == FILLRULE_NONZERO));
     }
 }
 
-void
-sp_paint_selector_set_color_alpha(SPPaintSelector *psel, SPColor const *color, float alpha)
+void SPPaintSelector::setColorAlpha(SPColor const &color, float alpha)
 {
     g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
-    SPColorSelector *csel;
-    guint32 rgba;
+    SPColorSelector *csel = 0;
+    guint32 rgba = 0;
 
 /*
     if ( sp_color_get_colorspace_type(color) == SP_COLORSPACE_TYPE_CMYK )
@@ -382,7 +432,7 @@ sp_paint_selector_set_color_alpha(SPPaintSelector *psel, SPColor const *color, f
 #ifdef SP_PS_VERBOSE
         g_print("PaintSelector set CMYKA\n");
 #endif
-        sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_COLOR_CMYK);
+        sp_paint_selector_set_mode(psel, MODE_COLOR_CMYK);
     }
     else
 */
@@ -390,104 +440,105 @@ sp_paint_selector_set_color_alpha(SPPaintSelector *psel, SPColor const *color, f
 #ifdef SP_PS_VERBOSE
         g_print("PaintSelector set RGBA\n");
 #endif
-        sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_COLOR_RGB);
+        setMode(MODE_COLOR_RGB);
     }
 
-    csel = (SPColorSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
-    rgba = color->toRGBA32( alpha );
-    csel->base->setColorAlpha( *color, alpha );
+    csel = reinterpret_cast<SPColorSelector*>(gtk_object_get_data(GTK_OBJECT(selector), "color-selector"));
+    rgba = color.toRGBA32( alpha );
+    csel->base->setColorAlpha( color, alpha );
 }
 
-void
-sp_paint_selector_set_gradient_linear(SPPaintSelector *psel, SPGradient *vector)
+void SPPaintSelector::setSwatch(SPGradient *vector )
+{
+#ifdef SP_PS_VERBOSE
+    g_print("PaintSelector set SWATCH\n");
+#endif
+    setMode(MODE_SWATCH);
+
+    SwatchSelector *swatchsel = static_cast<SwatchSelector*>(g_object_get_data(G_OBJECT(selector), "swatch-selector"));
+    if (swatchsel) {
+        swatchsel->setVector( (vector) ? SP_OBJECT_DOCUMENT(vector) : 0, vector );
+    }
+}
+
+void SPPaintSelector::setGradientLinear(SPGradient *vector)
 {
-    SPGradientSelector *gsel;
 #ifdef SP_PS_VERBOSE
     g_print("PaintSelector set GRADIENT LINEAR\n");
 #endif
-    sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR);
+    setMode(MODE_GRADIENT_LINEAR);
 
-    gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
+    SPGradientSelector *gsel = getGradientFromData(this);
 
-    sp_gradient_selector_set_mode(gsel, SP_GRADIENT_SELECTOR_MODE_LINEAR);
-    sp_gradient_selector_set_vector(gsel, (vector) ? SP_OBJECT_DOCUMENT(vector) : NULL, vector);
+    gsel->setMode(SPGradientSelector::MODE_LINEAR);
+    gsel->setVector((vector) ? SP_OBJECT_DOCUMENT(vector) : 0, vector);
 }
 
-void
-sp_paint_selector_set_gradient_radial(SPPaintSelector *psel, SPGradient *vector)
+void SPPaintSelector::setGradientRadial(SPGradient *vector)
 {
-    SPGradientSelector *gsel;
 #ifdef SP_PS_VERBOSE
     g_print("PaintSelector set GRADIENT RADIAL\n");
 #endif
-    sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL);
+    setMode(MODE_GRADIENT_RADIAL);
 
-    gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
+    SPGradientSelector *gsel = getGradientFromData(this);
 
-    sp_gradient_selector_set_mode(gsel, SP_GRADIENT_SELECTOR_MODE_RADIAL);
-    sp_gradient_selector_set_vector(gsel, (vector) ? SP_OBJECT_DOCUMENT(vector) : NULL, vector);
+    gsel->setMode(SPGradientSelector::MODE_RADIAL);
+
+    gsel->setVector((vector) ? SP_OBJECT_DOCUMENT(vector) : 0, vector);
 }
 
-void
-sp_paint_selector_set_gradient_properties(SPPaintSelector *psel, SPGradientUnits units, SPGradientSpread spread)
+void SPPaintSelector::setGradientProperties( SPGradientUnits units, SPGradientSpread spread )
 {
-    SPGradientSelector *gsel;
-    g_return_if_fail(SP_IS_PAINT_SELECTOR(psel));
-    g_return_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) ||
-                     (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL));
-    gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
-    sp_gradient_selector_set_units(gsel, units);
-    sp_gradient_selector_set_spread(gsel, spread);
+    g_return_if_fail(isPaintModeGradient(mode));
+
+    SPGradientSelector *gsel = getGradientFromData(this);
+    gsel->setUnits(units);
+    gsel->setSpread(spread);
 }
 
-void
-sp_paint_selector_get_gradient_properties(SPPaintSelector *psel, SPGradientUnits *units, SPGradientSpread *spread)
+void SPPaintSelector::getGradientProperties( SPGradientUnits &units, SPGradientSpread &spread) const
 {
-    SPGradientSelector *gsel;
-    g_return_if_fail(SP_IS_PAINT_SELECTOR(psel));
-    g_return_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) ||
-                     (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL));
-    gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
-    if (units) *units = sp_gradient_selector_get_units(gsel);
-    if (spread) *spread = sp_gradient_selector_get_spread(gsel);
+    g_return_if_fail(isPaintModeGradient(mode));
+
+    SPGradientSelector *gsel = getGradientFromData(this);
+    units = gsel->getUnits();
+    spread = gsel->getSpread();
 }
 
 /**
  * \post (alpha == NULL) || (*alpha in [0.0, 1.0]).
  */
-void
-sp_paint_selector_get_color_alpha(SPPaintSelector *psel, SPColor *color, gfloat *alpha)
+void SPPaintSelector::getColorAlpha(SPColor &color, gfloat &alpha) const
 {
     SPColorSelector *csel;
 
-    csel = (SPColorSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
+    csel = reinterpret_cast<SPColorSelector*>(g_object_get_data(G_OBJECT(selector), "color-selector"));
 
-    csel->base->getColorAlpha( *color, alpha );
+    csel->base->getColorAlpha( color, alpha );
 
-    g_assert( !alpha
-              || ( ( 0.0 <= *alpha )
-                   && ( *alpha <= 1.0 ) ) );
+    g_assert( ( 0.0 <= alpha )
+              && ( alpha <= 1.0 ) );
 }
 
-SPGradient *
-sp_paint_selector_get_gradient_vector(SPPaintSelector *psel)
+SPGradient *SPPaintSelector::getGradientVector()
 {
-    SPGradientSelector *gsel;
+    SPGradient* vect = 0;
 
-    g_return_val_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) ||
-                         (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL), NULL);
-
-    gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
+    if (isPaintModeGradient(mode)) {
+        SPGradientSelector *gsel = getGradientFromData(this);
+        vect = gsel->getVector();
+    }
 
-    return sp_gradient_selector_get_vector(gsel);
+    return vect;
 }
 
-void
-sp_gradient_selector_attrs_to_gradient(SPGradient *gr, SPPaintSelector *psel)
+
+void SPPaintSelector::pushAttrsToGradient( SPGradient *gr ) const
 {
-    SPGradientUnits units;
-    SPGradientSpread spread;
-    sp_paint_selector_get_gradient_properties(psel, &units, &spread);
+    SPGradientUnits units = SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX;
+    SPGradientSpread spread = SP_GRADIENT_SPREAD_PAD;
+    getGradientProperties( units, spread );
     sp_gradient_set_units(gr, units);
     sp_gradient_set_spread(gr, spread);
     SP_OBJECT(gr)->updateRepr();
@@ -566,45 +617,37 @@ sp_paint_selector_set_mode_none(SPPaintSelector *psel)
 
 /* Color paint */
 
-static void
-sp_paint_selector_color_grabbed(SPColorSelector *csel, SPPaintSelector *psel)
+static void sp_paint_selector_color_grabbed(SPColorSelector * /*csel*/, SPPaintSelector *psel)
 {
-    (void)csel;
     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[GRABBED]);
 }
 
-static void
-sp_paint_selector_color_dragged(SPColorSelector *csel, SPPaintSelector *psel)
+static void sp_paint_selector_color_dragged(SPColorSelector * /*csel*/, SPPaintSelector *psel)
 {
-    (void)csel;
     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[DRAGGED]);
 }
 
-static void
-sp_paint_selector_color_released(SPColorSelector *csel, SPPaintSelector *psel)
+static void sp_paint_selector_color_released(SPColorSelector * /*csel*/, SPPaintSelector *psel)
 {
-    (void)csel;
     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[RELEASED]);
 }
 
 static void
 sp_paint_selector_color_changed(SPColorSelector *csel, SPPaintSelector *psel)
 {
-    csel->base->getColorAlpha( psel->color, &psel->alpha );
+    csel->base->getColorAlpha( psel->color, psel->alpha );
 
     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
 }
 
-static void
-sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelectorMode mode)
+static void sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelector::Mode /*mode*/)
 {
-    (void)mode;
     GtkWidget *csel;
 
     sp_paint_selector_set_style_buttons(psel, psel->solid);
     gtk_widget_set_sensitive(psel->style, TRUE);
 
-    if ((psel->mode == SP_PAINT_SELECTOR_MODE_COLOR_RGB) || (psel->mode == SP_PAINT_SELECTOR_MODE_COLOR_CMYK)) {
+    if ((psel->mode == SPPaintSelector::MODE_COLOR_RGB) || (psel->mode == SPPaintSelector::MODE_COLOR_CMYK)) {
         /* Already have color selector */
         csel = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
     } else {
@@ -641,49 +684,40 @@ sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelectorMode mode
 
 /* Gradient */
 
-static void
-sp_paint_selector_gradient_grabbed(SPColorSelector *csel, SPPaintSelector *psel)
+static void sp_paint_selector_gradient_grabbed(SPColorSelector * /*csel*/, SPPaintSelector *psel)
 {
-    (void)csel;
     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[GRABBED]);
 }
 
-static void
-sp_paint_selector_gradient_dragged(SPColorSelector *csel, SPPaintSelector *psel)
+static void sp_paint_selector_gradient_dragged(SPColorSelector * /*csel*/, SPPaintSelector *psel)
 {
-    (void)csel;
     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[DRAGGED]);
 }
 
-static void
-sp_paint_selector_gradient_released(SPColorSelector *csel, SPPaintSelector *psel)
+static void sp_paint_selector_gradient_released(SPColorSelector * /*csel*/, SPPaintSelector *psel)
 {
-    (void)csel;
     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[RELEASED]);
 }
 
-static void
-sp_paint_selector_gradient_changed(SPColorSelector *csel, SPPaintSelector *psel)
+static void sp_paint_selector_gradient_changed(SPColorSelector * /*csel*/, SPPaintSelector *psel)
 {
-    (void)csel;
     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
 }
 
-static void
-sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelectorMode mode)
+static void sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelector::Mode mode)
 {
     GtkWidget *gsel;
 
     /* fixme: We do not need function-wide gsel at all */
 
-    if (mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) {
+    if (mode == SPPaintSelector::MODE_GRADIENT_LINEAR) {
         sp_paint_selector_set_style_buttons(psel, psel->gradient);
     } else {
         sp_paint_selector_set_style_buttons(psel, psel->radial);
     }
     gtk_widget_set_sensitive(psel->style, TRUE);
 
-    if ((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) || (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL)) {
+    if ((psel->mode == SPPaintSelector::MODE_GRADIENT_LINEAR) || (psel->mode == SPPaintSelector::MODE_GRADIENT_RADIAL)) {
         /* Already have gradient selector */
         gsel = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
     } else {
@@ -702,11 +736,12 @@ sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelectorMode m
     }
 
     /* Actually we have to set option menu history here */
-    if (mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) {
-        sp_gradient_selector_set_mode(SP_GRADIENT_SELECTOR(gsel), SP_GRADIENT_SELECTOR_MODE_LINEAR);
+    if (mode == SPPaintSelector::MODE_GRADIENT_LINEAR) {
+        SP_GRADIENT_SELECTOR(gsel)->setMode(SPGradientSelector::MODE_LINEAR);
+        //sp_gradient_selector_set_mode(SP_GRADIENT_SELECTOR(gsel), SP_GRADIENT_SELECTOR_MODE_LINEAR);
         gtk_frame_set_label(GTK_FRAME(psel->frame), _("Linear gradient"));
     } else {
-        sp_gradient_selector_set_mode(SP_GRADIENT_SELECTOR(gsel), SP_GRADIENT_SELECTOR_MODE_RADIAL);
+        SP_GRADIENT_SELECTOR(gsel)->setMode(SPGradientSelector::MODE_RADIAL);
         gtk_frame_set_label(GTK_FRAME(psel->frame), _("Radial gradient"));
     }
 #ifdef SP_PS_VERBOSE
@@ -722,21 +757,18 @@ sp_paint_selector_set_style_buttons(SPPaintSelector *psel, GtkWidget *active)
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->gradient), (active == psel->gradient));
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->radial), (active == psel->radial));
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->pattern), (active == psel->pattern));
+    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->swatch), (active == psel->swatch));
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->unset), (active == psel->unset));
 }
 
-static void
-sp_psel_pattern_destroy(GtkWidget *widget,  SPPaintSelector *psel)
+static void sp_psel_pattern_destroy(GtkWidget *widget, SPPaintSelector * /*psel*/)
 {
-    (void)psel;
     // drop our reference to the pattern menu widget
     g_object_unref( G_OBJECT(widget) );
 }
 
-static void
-sp_psel_pattern_change(GtkWidget *widget,  SPPaintSelector *psel)
+static void sp_psel_pattern_change(GtkWidget * /*widget*/, SPPaintSelector *psel)
 {
-    (void)widget;
     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
 }
 
@@ -812,17 +844,15 @@ sp_pattern_menu_build (GtkWidget *m, GSList *pattern_list, SPDocument */*source*
  * current_doc (if non-NULL), and add items to the pattern menu
  *
  */
-static void
-sp_pattern_list_from_doc (GtkWidget *m, SPDocument *current_doc, SPDocument *source, SPDocument *pattern_doc)
+static void sp_pattern_list_from_doc (GtkWidget *m, SPDocument * /*current_doc*/, SPDocument *source, SPDocument * /*pattern_doc*/)
 {
-    (void)current_doc;
-    (void)pattern_doc;
     GSList *pl = ink_pattern_list_get(source);
     GSList *clean_pl = NULL;
 
     for (; pl != NULL; pl = pl->next) {
-        if (!SP_IS_PATTERN(pl->data))
+        if (!SP_IS_PATTERN(pl->data)) {
             continue;
+        }
 
         // Add to the list of patterns we really do wish to show
         clean_pl = g_slist_prepend (clean_pl, pl->data);
@@ -901,11 +931,12 @@ ink_pattern_menu(GtkWidget *mnu)
 
 
 /*update pattern list*/
-void
-sp_update_pattern_list( SPPaintSelector *psel,  SPPattern *pattern)
+void SPPaintSelector::updatePatternList( SPPattern *pattern )
 {
-    if (psel->update) return;
-    GtkWidget *mnu = (GtkWidget *)g_object_get_data(G_OBJECT(psel), "patternmenu");
+    if (update) {
+        return;
+    }
+    GtkWidget *mnu = GTK_WIDGET(g_object_get_data(G_OBJECT(this), "patternmenu"));
     g_assert( mnu != NULL );
 
     /* Clear existing menu if any */
@@ -944,17 +975,17 @@ sp_update_pattern_list( SPPaintSelector *psel,  SPPattern *pattern)
     //gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
 }
 
-static void
-sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSelectorMode mode)
+static void sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSelector::Mode mode)
 {
-    if (mode == SP_PAINT_SELECTOR_MODE_PATTERN)
+    if (mode == SPPaintSelector::MODE_PATTERN) {
         sp_paint_selector_set_style_buttons(psel, psel->pattern);
+    }
 
     gtk_widget_set_sensitive(psel->style, TRUE);
 
     GtkWidget *tbl = NULL;
 
-    if (psel->mode == SP_PAINT_SELECTOR_MODE_PATTERN){
+    if (psel->mode == SPPaintSelector::MODE_PATTERN) {
         /* Already have pattern menu */
         tbl = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "pattern-selector");
     } else {
@@ -1001,13 +1032,12 @@ sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSelectorMode mo
 #endif
 }
 
-SPPattern *
-sp_paint_selector_get_pattern(SPPaintSelector *psel)
+SPPattern *SPPaintSelector::getPattern()
 {
-    SPPattern *pat;
-    g_return_val_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_PATTERN) , NULL);
+    SPPattern *pat = 0;
+    g_return_val_if_fail((mode == MODE_PATTERN) , NULL);
 
-    GtkWidget *patmnu = (GtkWidget *) g_object_get_data(G_OBJECT(psel), "patternmenu");
+    GtkWidget *patmnu = (GtkWidget *) g_object_get_data(G_OBJECT(this), "patternmenu");
     /* no pattern menu if we were just selected */
     if ( patmnu == NULL ) return NULL;
 
@@ -1019,34 +1049,73 @@ sp_paint_selector_get_pattern(SPPaintSelector *psel)
         return NULL;
     }
     gchar *patid = (gchar *) g_object_get_data(G_OBJECT(gtk_menu_get_active(m)),
-                                                "pattern");
+                                               "pattern");
     //gchar *pattern = "";
     if (strcmp(patid, "none")){
 
-       gchar *stockid = (gchar *) g_object_get_data(G_OBJECT(gtk_menu_get_active(m)),
-                                                "stockid");
-       gchar *paturn = patid;
-       if (!strcmp(stockid,"true")) paturn = g_strconcat("urn:inkscape:pattern:",patid,NULL);
-       SPObject *pat_obj = get_stock_item(paturn);
-       if (pat_obj) {
+        gchar *stockid = (gchar *) g_object_get_data(G_OBJECT(gtk_menu_get_active(m)),
+                                                     "stockid");
+        gchar *paturn = patid;
+        if (!strcmp(stockid,"true")) paturn = g_strconcat("urn:inkscape:pattern:",patid,NULL);
+        SPObject *pat_obj = get_stock_item(paturn);
+        if (pat_obj) {
             pat = SP_PATTERN(pat_obj);
         }
     } else {
-    pat = pattern_getroot(SP_PATTERN(g_object_get_data(G_OBJECT(gtk_menu_get_active(m)), "pattern")));
+        pat = pattern_getroot(SP_PATTERN(g_object_get_data(G_OBJECT(gtk_menu_get_active(m)), "pattern")));
     }
 
-    if SP_IS_PATTERN(pat) return pat;
-    return NULL;
+    if (pat && !SP_IS_PATTERN(pat)) {
+        pat = 0;
+    }
+
+    return pat;
 }
 
-void
-sp_paint_selector_set_flat_color(SPPaintSelector *psel, SPDesktop *desktop, gchar const *color_property, gchar const *opacity_property)
+static void sp_paint_selector_set_mode_swatch(SPPaintSelector *psel, SPPaintSelector::Mode mode)
+{
+    if (mode == SPPaintSelector::MODE_SWATCH) {
+        sp_paint_selector_set_style_buttons(psel, psel->swatch);
+    }
+
+    gtk_widget_set_sensitive(psel->style, TRUE);
+
+    SwatchSelector *swatchsel = 0;
+
+    if (psel->mode == SPPaintSelector::MODE_SWATCH){
+        /* Already have pattern menu */
+        swatchsel = static_cast<SwatchSelector*>(g_object_get_data(G_OBJECT(psel->selector), "swatch-selector"));
+    } else {
+        sp_paint_selector_clear_frame(psel);
+        /* Create new gradient selector */
+        SwatchSelector *swatchsel = new SwatchSelector();
+        swatchsel->show();
+
+        swatchsel->connectGrabbedHandler( G_CALLBACK(sp_paint_selector_gradient_grabbed), psel );
+        swatchsel->connectDraggedHandler( G_CALLBACK(sp_paint_selector_gradient_dragged), psel );
+        swatchsel->connectReleasedHandler( G_CALLBACK(sp_paint_selector_gradient_released), psel );
+        swatchsel->connectchangedHandler( G_CALLBACK(sp_paint_selector_gradient_changed), psel );
+
+        // Pack everything to frame
+        gtk_container_add(GTK_CONTAINER(psel->frame), GTK_WIDGET(swatchsel->gobj()));
+        psel->selector = GTK_WIDGET(swatchsel->gobj());
+        gtk_object_set_data(GTK_OBJECT(psel->selector), "swatch-selector", swatchsel);
+
+        gtk_frame_set_label(GTK_FRAME(psel->frame), _("Swatch fill"));
+    }
+#ifdef SP_PS_VERBOSE
+    g_print("Swatch req\n");
+#endif
+}
+
+// TODO this seems very bad to be taking in a desktop pointer to muck with. Logic probably belongs elsewhere
+void SPPaintSelector::setFlatColor( SPDesktop *desktop, gchar const *color_property, gchar const *opacity_property )
 {
     SPCSSAttr *css = sp_repr_css_attr_new();
 
     SPColor color;
-    gfloat alpha;
-    sp_paint_selector_get_color_alpha(psel, &color, &alpha);
+    gfloat alpha = 0;
+    getColorAlpha( color, alpha );
 
     std::string colorStr = color.toString();
 
@@ -1055,7 +1124,7 @@ sp_paint_selector_set_flat_color(SPPaintSelector *psel, SPDesktop *desktop, gcha
     g_message("sp_paint_selector_set_flat_color() to '%s' from 0x%08x::%s",
               colorStr.c_str(),
               rgba,
-              (color.icc?color.icc->colorProfile.c_str():"<null>") );
+              (color.icc ? color.icc->colorProfile.c_str():"<null>") );
 #endif // SP_PS_VERBOSE
 
     sp_repr_css_set_property(css, color_property, colorStr.c_str());
@@ -1068,34 +1137,42 @@ sp_paint_selector_set_flat_color(SPPaintSelector *psel, SPDesktop *desktop, gcha
     sp_repr_css_attr_unref(css);
 }
 
-SPPaintSelectorMode
-sp_style_determine_paint_selector_mode(SPStyle *style, bool isfill)
+SPPaintSelector::Mode SPPaintSelector::getModeForStyle(SPStyle const & style, bool isfill)
 {
-    SPPaintSelectorMode mode = SP_PAINT_SELECTOR_MODE_UNSET;
-    SPIPaint& target = isfill ? style->fill : style->stroke;
+    Mode mode = MODE_UNSET;
+    SPIPaint const & target = isfill ? style.fill : style.stroke;
 
     if ( !target.set ) {
-        mode = SP_PAINT_SELECTOR_MODE_UNSET;
+        mode = MODE_UNSET;
     } else if ( target.isPaintserver() ) {
-        SPPaintServer *server = isfill? SP_STYLE_FILL_SERVER(style) : SP_STYLE_STROKE_SERVER(style);
+        SPPaintServer const *server = isfill ? style.getFillPaintServer() : style.getStrokePaintServer();
+
+#ifdef SP_PS_VERBOSE
+        g_message("SPPaintSelector::getModeForStyle(%p, %d)", &style, isfill);
+        g_message("==== server:%p %s  grad:%s   swatch:%s", server, server->getId(), (SP_IS_GRADIENT(server)?"Y":"n"), (SP_IS_GRADIENT(server) && SP_GRADIENT(server)->getVector()->isSwatch()?"Y":"n"));
+#endif // SP_PS_VERBOSE
+
 
-        if (SP_IS_LINEARGRADIENT(server)) {
-            mode = SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR;
+        if (server && SP_IS_GRADIENT(server) && SP_GRADIENT(server)->getVector()->isSwatch()) {
+            mode = MODE_SWATCH;
+        } else if (SP_IS_LINEARGRADIENT(server)) {
+            mode = MODE_GRADIENT_LINEAR;
         } else if (SP_IS_RADIALGRADIENT(server)) {
-            mode = SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL;
+            mode = MODE_GRADIENT_RADIAL;
         } else if (SP_IS_PATTERN(server)) {
-            mode = SP_PAINT_SELECTOR_MODE_PATTERN;
+            mode = MODE_PATTERN;
         } else {
             g_warning( "file %s: line %d: Unknown paintserver", __FILE__, __LINE__ );
-            mode = SP_PAINT_SELECTOR_MODE_NONE;
+            mode = MODE_NONE;
         }
     } else if ( target.isColor() ) {
-        mode = SP_PAINT_SELECTOR_MODE_COLOR_RGB; // so far only rgb can be read from svg
+        // TODO this is no longer a valid assertion:
+        mode = MODE_COLOR_RGB; // so far only rgb can be read from svg
     } else if ( target.isNone() ) {
-        mode = SP_PAINT_SELECTOR_MODE_NONE;
+        mode = MODE_NONE;
     } else {
         g_warning( "file %s: line %d: Unknown paint type", __FILE__, __LINE__ );
-        mode = SP_PAINT_SELECTOR_MODE_NONE;
+        mode = MODE_NONE;
     }
 
     return mode;
diff --git a/src/widgets/paint-selector.h b/src/widgets/paint-selector.h
index de8bbf46a..a3c4cb973 100644
--- a/src/widgets/paint-selector.h
+++ b/src/widgets/paint-selector.h
@@ -1,16 +1,22 @@
-#ifndef __SP_PAINT_SELECTOR_H__
-#define __SP_PAINT_SELECTOR_H__
+#ifndef SEEN_SP_PAINT_SELECTOR_H
+#define SEEN_SP_PAINT_SELECTOR_H
 
 /** \file
  * Generic paint selector widget
  *
+ * Authors:
+ *   Lauris
+ *   Jon A. Cruz <jon@joncruz.org>
+ *
  * Copyright (C) Lauris 2002
+ * Copyright (C) 2010 Authors
  *
  */
 
 #include <glib.h>
 #include "sp-gradient-spread.h"
 #include "sp-gradient-units.h"
+
 class SPGradient;
 
 #define SP_TYPE_PAINT_SELECTOR (sp_paint_selector_get_type ())
@@ -25,86 +31,102 @@ class SPGradient;
 #include <color.h>
 #include <libnr/nr-forward.h>
 
-typedef enum {
-	SP_PAINT_SELECTOR_MODE_EMPTY,
-	SP_PAINT_SELECTOR_MODE_MULTIPLE,
-	SP_PAINT_SELECTOR_MODE_NONE,
-	SP_PAINT_SELECTOR_MODE_COLOR_RGB,
-	SP_PAINT_SELECTOR_MODE_COLOR_CMYK,
-	SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR,
-    SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL,
-    SP_PAINT_SELECTOR_MODE_PATTERN,
-    SP_PAINT_SELECTOR_MODE_UNSET
-} SPPaintSelectorMode;
-
-typedef enum {
-	SP_PAINT_SELECTOR_FILLRULE_NONZERO,
-	SP_PAINT_SELECTOR_FILLRULE_EVENODD
-} SPPaintSelectorFillRule;
 
 /// Generic paint selector widget
 struct SPPaintSelector {
-	GtkVBox vbox;
+    GtkVBox vbox;
 
-	guint update : 1;
+    enum Mode {
+        MODE_EMPTY,
+        MODE_MULTIPLE,
+        MODE_NONE,
+        MODE_COLOR_RGB,
+        MODE_COLOR_CMYK,
+        MODE_GRADIENT_LINEAR,
+        MODE_GRADIENT_RADIAL,
+        MODE_PATTERN,
+        MODE_SWATCH,
+        MODE_UNSET
+    } ;
 
-	SPPaintSelectorMode mode;
+    enum FillRule {
+        FILLRULE_NONZERO,
+        FILLRULE_EVENODD
+    } ;
 
-	GtkWidget *style;
-	GtkWidget *none, *solid, *gradient, *radial, *pattern, *unset;
+    guint update : 1;
 
-	GtkWidget *fillrulebox;
-	GtkWidget *evenodd, *nonzero;
+    Mode mode;
 
-	GtkWidget *frame, *selector;
+    GtkWidget *style;
+    GtkWidget *none;
+    GtkWidget *solid;
+    GtkWidget *gradient;
+    GtkWidget *radial;
+    GtkWidget *pattern;
+    GtkWidget *swatch;
+    GtkWidget *unset;
 
-	SPColor color;
-	float alpha;
-};
+    GtkWidget *fillrulebox;
+    GtkWidget *evenodd, *nonzero;
 
-/// The SPPaintSelector vtable
-struct SPPaintSelectorClass {
-	GtkVBoxClass parent_class;
+    GtkWidget *frame, *selector;
 
-	void (* mode_changed) (SPPaintSelector *psel, SPPaintSelectorMode mode);
+    SPColor color;
+    float alpha;
 
-	void (* grabbed) (SPPaintSelector *psel);
-	void (* dragged) (SPPaintSelector *psel);
-	void (* released) (SPPaintSelector *psel);
-	void (* changed) (SPPaintSelector *psel);
-	void (* fillrule_changed) (SPPaintSelector *psel, SPPaintSelectorFillRule fillrule);
-};
+    static Mode getModeForStyle(SPStyle const & style, bool isfill);
 
-GtkType sp_paint_selector_get_type (void);
+    void setMode( Mode mode );
+    void setFillrule( FillRule fillrule );
 
-GtkWidget *sp_paint_selector_new (bool is_fill);
+    void setColorAlpha( SPColor const &color, float alpha );
+    void getColorAlpha( SPColor &color, gfloat &alpha ) const;
 
-void sp_paint_selector_set_mode (SPPaintSelector *psel, SPPaintSelectorMode mode);
-void sp_paint_selector_set_fillrule (SPPaintSelector *psel, SPPaintSelectorFillRule fillrule);
+    void setGradientLinear( SPGradient *vector );
+    void setGradientRadial( SPGradient *vector );
+    void setSwatch( SPGradient *vector );
 
-void sp_paint_selector_set_color_alpha (SPPaintSelector *psel, const SPColor *color, float alpha);
+    void setGradientProperties( SPGradientUnits units, SPGradientSpread spread );
+    void getGradientProperties( SPGradientUnits &units, SPGradientSpread &spread ) const;
 
-void sp_paint_selector_set_gradient_linear (SPPaintSelector *psel, SPGradient *vector);
+    void pushAttrsToGradient( SPGradient *gr ) const;
+    SPGradient *getGradientVector();
+    SPPattern * getPattern();
+    void updatePatternList( SPPattern *pat );
 
-void sp_paint_selector_set_gradient_radial (SPPaintSelector *psel, SPGradient *vector);
-
-void sp_paint_selector_set_gradient_properties (SPPaintSelector *psel, SPGradientUnits units, SPGradientSpread spread);
-void sp_paint_selector_get_gradient_properties (SPPaintSelector *psel, SPGradientUnits *units, SPGradientSpread *spread);
+    // TODO move this elsewhere:
+    void setFlatColor( SPDesktop *desktop, const gchar *color_property, const gchar *opacity_property );
+};
 
-void sp_gradient_selector_attrs_to_gradient (SPGradient *gr, SPPaintSelector *psel);
+/// The SPPaintSelector vtable
+struct SPPaintSelectorClass {
+    GtkVBoxClass parent_class;
 
-void sp_paint_selector_get_color_alpha (SPPaintSelector *psel, SPColor *color, gfloat *alpha);
+    void (* mode_changed) (SPPaintSelector *psel, SPPaintSelector::Mode mode);
 
-SPGradient *sp_paint_selector_get_gradient_vector (SPPaintSelector *psel);
+    void (* grabbed) (SPPaintSelector *psel);
+    void (* dragged) (SPPaintSelector *psel);
+    void (* released) (SPPaintSelector *psel);
+    void (* changed) (SPPaintSelector *psel);
+    void (* fillrule_changed) (SPPaintSelector *psel, SPPaintSelector::FillRule fillrule);
+};
 
-void sp_paint_selector_system_color_set (SPPaintSelector *psel, const SPColor *color, float opacity);
+GtkType sp_paint_selector_get_type (void);
 
-SPPattern * sp_paint_selector_get_pattern (SPPaintSelector *psel);
+GtkWidget *sp_paint_selector_new (bool is_fill);
 
-void sp_update_pattern_list ( SPPaintSelector *psel, SPPattern *pat);
 
-void sp_paint_selector_set_flat_color (SPPaintSelector *psel, SPDesktop *desktop, const gchar *color_property, const gchar *opacity_property);
 
-SPPaintSelectorMode sp_style_determine_paint_selector_mode (SPStyle *style, bool isfill);
+#endif // SEEN_SP_PAINT_SELECTOR_H
 
-#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:encoding=utf-8:textwidth=99 :
diff --git a/src/widgets/select-toolbar.cpp b/src/widgets/select-toolbar.cpp
index f168cedeb..e2ad61e2d 100644
--- a/src/widgets/select-toolbar.cpp
+++ b/src/widgets/select-toolbar.cpp
@@ -390,7 +390,7 @@ static GtkAction* create_action_for_verb( Inkscape::Verb* verb, Inkscape::UI::Vi
 void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
 {
     Inkscape::UI::View::View *view = desktop;
-    Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
+    Inkscape::IconSize secondarySize = Inkscape::UI::ToolboxFactory::prefToSize("/toolbox/secondary", 1);
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
     GtkAction* act = 0;
@@ -457,7 +457,7 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb
 
     //TRANSLATORS: only translate "string" in "context|string".
     // For more details, see http://developer.gnome.org/doc/API/2.0/glib/glib-I18N.html#Q-:CAPS
-    eact = create_adjustment_action( "XAction", _("select_toolbar|X position"), _("select_toolbar|X"), "X",
+    eact = create_adjustment_action( "XAction", _("select toolbar|X position"), _("select toolbar|X"), "X",
                                      -1e6, GTK_WIDGET(desktop->canvas), tracker, spw,
                                      _("Horizontal coordinate of selection"), TRUE );
     gtk_action_group_add_action( selectionActions, GTK_ACTION(eact) );
@@ -465,7 +465,7 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb
 
     //TRANSLATORS: only translate "string" in "context|string".
     // For more details, see http://developer.gnome.org/doc/API/2.0/glib/glib-I18N.html#Q-:CAPS
-    eact = create_adjustment_action( "YAction", _("select_toolbar|Y position"), _("select_toolbar|Y"), "Y",
+    eact = create_adjustment_action( "YAction", _("select toolbar|Y position"), _("select toolbar|Y"), "Y",
                                      -1e6, GTK_WIDGET(desktop->canvas), tracker, spw,
                                      _("Vertical coordinate of selection"), FALSE );
     gtk_action_group_add_action( selectionActions, GTK_ACTION(eact) );
@@ -473,7 +473,7 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb
 
     //TRANSLATORS: only translate "string" in "context|string".
     // For more details, see http://developer.gnome.org/doc/API/2.0/glib/glib-I18N.html#Q-:CAPS
-    eact = create_adjustment_action( "WidthAction", _("select_toolbar|Width"), _("select_toolbar|W"), "width",
+    eact = create_adjustment_action( "WidthAction", _("select toolbar|Width"), _("select toolbar|W"), "width",
                                      1e-3, GTK_WIDGET(desktop->canvas), tracker, spw,
                                      _("Width of selection"), FALSE );
     gtk_action_group_add_action( selectionActions, GTK_ACTION(eact) );
@@ -494,7 +494,7 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb
 
     //TRANSLATORS: only translate "string" in "context|string".
     // For more details, see http://developer.gnome.org/doc/API/2.0/glib/glib-I18N.html#Q-:CAPS
-    eact = create_adjustment_action( "HeightAction", _("select_toolbar|Height"), _("select_toolbar|H"), "height",
+    eact = create_adjustment_action( "HeightAction", _("select toolbar|Height"), _("select toolbar|H"), "height",
                                      1e-3, GTK_WIDGET(desktop->canvas), tracker, spw,
                                      _("Height of selection"), FALSE );
     gtk_action_group_add_action( selectionActions, GTK_ACTION(eact) );
diff --git a/src/widgets/sp-color-notebook.cpp b/src/widgets/sp-color-notebook.cpp
index 3ba39dd30..a249786ff 100644
--- a/src/widgets/sp-color-notebook.cpp
+++ b/src/widgets/sp-color-notebook.cpp
@@ -4,7 +4,7 @@
  * A notebook with RGB, CMYK, CMS, HSL, and Wheel pages
  *
  * Author:
- *	 Lauris Kaplinski <lauris@kaplinski.com>
+ *   Lauris Kaplinski <lauris@kaplinski.com>
  *   bulia byak <buliabyak@users.sf.net>
  *
  * Copyright (C) 2001-2002 Lauris Kaplinski
@@ -38,13 +38,13 @@
 #include "../profile-manager.h"
 
 struct SPColorNotebookTracker {
-	const gchar* name;
-	const gchar* className;
-	GType type;
-	guint submode;
-	gboolean enabledFull;
-	gboolean enabledBrief;
-	SPColorNotebook *backPointer;
+    const gchar* name;
+    const gchar* className;
+    GType type;
+    guint submode;
+    gboolean enabledFull;
+    gboolean enabledBrief;
+    SPColorNotebook *backPointer;
 };
 
 static void sp_color_notebook_class_init (SPColorNotebookClass *klass);
@@ -83,20 +83,20 @@ GType sp_color_notebook_get_type(void)
 static void
 sp_color_notebook_class_init (SPColorNotebookClass *klass)
 {
-	GtkObjectClass *object_class;
-	GtkWidgetClass *widget_class;
-	SPColorSelectorClass *selector_class;
+    GtkObjectClass *object_class;
+    GtkWidgetClass *widget_class;
+    SPColorSelectorClass *selector_class;
 
-	object_class = (GtkObjectClass *) klass;
-	widget_class = (GtkWidgetClass *) klass;
-	selector_class = SP_COLOR_SELECTOR_CLASS (klass);
+    object_class = (GtkObjectClass *) klass;
+    widget_class = (GtkWidgetClass *) klass;
+    selector_class = SP_COLOR_SELECTOR_CLASS (klass);
 
-	parent_class = SP_COLOR_SELECTOR_CLASS (g_type_class_peek_parent (klass));
+    parent_class = SP_COLOR_SELECTOR_CLASS (g_type_class_peek_parent (klass));
 
-	object_class->destroy = sp_color_notebook_destroy;
+    object_class->destroy = sp_color_notebook_destroy;
 
-	widget_class->show_all = sp_color_notebook_show_all;
-	widget_class->hide_all = sp_color_notebook_hide_all;
+    widget_class->show_all = sp_color_notebook_show_all;
+    widget_class->hide_all = sp_color_notebook_hide_all;
 }
 
 static void
@@ -126,7 +126,7 @@ void ColorNotebook::switchPage(GtkNotebook*,
     if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (_book)) >= 0 )
     {
         csel = getCurrentSelector();
-        csel->base->getColorAlpha(_color, &_alpha);
+        csel->base->getColorAlpha(_color, _alpha);
     }
     widget = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), page_num);
     if ( widget && SP_IS_COLOR_SELECTOR (widget) )
@@ -165,21 +165,21 @@ gint ColorNotebook::menuHandler( GdkEvent* event )
 
 static void sp_color_notebook_menuitem_response (GtkMenuItem *menuitem, gpointer user_data)
 {
-	gboolean active = FALSE;
-
-	active = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem));
-	SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (user_data);
-	if ( entry )
-	{
-		if ( active )
-		{
-			((ColorNotebook*)(SP_COLOR_SELECTOR(entry->backPointer)->base))->addPage(entry->type, entry->submode);
-		}
-		else
-		{
-			((ColorNotebook*)(SP_COLOR_SELECTOR(entry->backPointer)->base))->removePage(entry->type, entry->submode);
-		}
-	}
+    gboolean active = FALSE;
+
+    active = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem));
+    SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (user_data);
+    if ( entry )
+    {
+        if ( active )
+        {
+            ((ColorNotebook*)(SP_COLOR_SELECTOR(entry->backPointer)->base))->addPage(entry->type, entry->submode);
+        }
+        else
+        {
+            ((ColorNotebook*)(SP_COLOR_SELECTOR(entry->backPointer)->base))->removePage(entry->type, entry->submode);
+        }
+    }
 }
 
 static void
@@ -195,249 +195,249 @@ sp_color_notebook_init (SPColorNotebook *colorbook)
 
 void ColorNotebook::init()
 {
-	GtkWidget* table = 0;
-	guint row = 0;
-	guint i = 0;
-	guint j = 0;
-	GType *selector_types = 0;
-	guint	selector_type_count = 0;
-
-	GtkTooltips *tt = gtk_tooltips_new ();
-
-	/* tempory hardcoding to get types loaded */
-	SP_TYPE_COLOR_SCALES;
-	SP_TYPE_COLOR_WHEEL_SELECTOR;
+    GtkWidget* table = 0;
+    guint row = 0;
+    guint i = 0;
+    guint j = 0;
+    GType *selector_types = 0;
+    guint selector_type_count = 0;
+
+    GtkTooltips *tt = gtk_tooltips_new ();
+
+    /* tempory hardcoding to get types loaded */
+    SP_TYPE_COLOR_SCALES;
+    SP_TYPE_COLOR_WHEEL_SELECTOR;
 #if ENABLE_LCMS
-	SP_TYPE_COLOR_ICC_SELECTOR;
+    SP_TYPE_COLOR_ICC_SELECTOR;
 #endif // ENABLE_LCMS
 
-	/* REJON: Comment out the next line to not use the normal GTK Color
+    /* 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);
-
-	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 = gtk_type_class (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);
-					}
-				}
-			}
-		}
-	}
-
-	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);
-		}
-	}
-
-	table = gtk_table_new (2, 3, FALSE);
-	gtk_widget_show (table);
-
-	gtk_box_pack_start (GTK_BOX (_csel), table, TRUE, TRUE, 0);
-
-	gtk_table_attach (GTK_TABLE (table), _book, 0, 2, row, row + 1,
+    _updating = FALSE;
+    _updatingrgba = FALSE;
+    _btn = 0;
+    _popup = 0;
+    _trackerList = g_ptr_array_new ();
+
+    _book = gtk_notebook_new ();
+    gtk_widget_show (_book);
+
+    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 = gtk_type_class (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);
+                    }
+                }
+            }
+        }
+    }
+
+    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);
+        }
+    }
+
+    table = gtk_table_new (2, 3, FALSE);
+    gtk_widget_show (table);
+
+    gtk_box_pack_start (GTK_BOX (_csel), table, TRUE, TRUE, 0);
+
+    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, YPAD);
 
-	// restore the last active page
-	Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-	gtk_notebook_set_current_page (GTK_NOTEBOOK (_book), prefs->getInt("/colorselector/page", 0));
-
-	{
-		gboolean found = FALSE;
+    // restore the last active page
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gtk_notebook_set_current_page (GTK_NOTEBOOK (_book), prefs->getInt("/colorselector/page", 0));
 
-		_popup = gtk_menu_new();
-		GtkMenu *menu = GTK_MENU (_popup);
+    {
+        gboolean found = FALSE;
 
-		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_append (menu, item);
+        _popup = gtk_menu_new();
+        GtkMenu *menu = GTK_MENU (_popup);
 
-				g_signal_connect (G_OBJECT (item), "activate",
-								  G_CALLBACK (sp_color_notebook_menuitem_response),
-								  reinterpret_cast< gpointer > (entry) );
-				found = TRUE;
-			}
-		}
+        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_append (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);
+        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);
+        _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);
+        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);
+        // 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);
 
-		gtk_signal_connect_object(GTK_OBJECT(_btn), "event", GTK_SIGNAL_FUNC (sp_color_notebook_menu_handler), GTK_OBJECT(_csel));
-		if ( !found )
-		{
-			gtk_widget_set_sensitive (_btn, FALSE);
-		}
-	}
+        gtk_signal_connect_object(GTK_OBJECT(_btn), "event", GTK_SIGNAL_FUNC (sp_color_notebook_menu_handler), GTK_OBJECT(_csel));
+        if ( !found )
+        {
+            gtk_widget_set_sensitive (_btn, FALSE);
+        }
+    }
 
-	row++;
+    row++;
 
-	GtkWidget *rgbabox = gtk_hbox_new (FALSE, 0);
+    GtkWidget *rgbabox = gtk_hbox_new (FALSE, 0);
 
 #if ENABLE_LCMS
-	/* 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);
-        GtkTooltips *tooltips_colormanaged = gtk_tooltips_new ();
-        gtk_tooltips_set_tip (tooltips_colormanaged, _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);
-        GtkTooltips *tooltips_outofgamut = gtk_tooltips_new ();
-        gtk_tooltips_set_tip (tooltips_outofgamut, _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);
-        GtkTooltips *tooltips_toomuchink = gtk_tooltips_new ();
-        gtk_tooltips_set_tip (tooltips_toomuchink, _box_toomuchink, _("Too much ink!"), "");
-        gtk_widget_set_sensitive (_box_toomuchink, false);
-	gtk_box_pack_start(GTK_BOX(rgbabox), _box_toomuchink, FALSE, FALSE, 2);
+    /* 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);
+    GtkTooltips *tooltips_colormanaged = gtk_tooltips_new ();
+    gtk_tooltips_set_tip (tooltips_colormanaged, _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);
+    GtkTooltips *tooltips_outofgamut = gtk_tooltips_new ();
+    gtk_tooltips_set_tip (tooltips_outofgamut, _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);
+    GtkTooltips *tooltips_toomuchink = gtk_tooltips_new ();
+    gtk_tooltips_set_tip (tooltips_toomuchink, _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 //ENABLE_LCMS
 
-	/* Create RGBA entry and color preview */
-	_rgbal = gtk_label_new_with_mnemonic (_("RGBA_:"));
-	gtk_misc_set_alignment (GTK_MISC (_rgbal), 1.0, 0.5);
-	gtk_box_pack_start(GTK_BOX(rgbabox), _rgbal, TRUE, TRUE, 2);
+    /* Create RGBA entry and color preview */
+    _rgbal = gtk_label_new_with_mnemonic (_("RGBA_:"));
+    gtk_misc_set_alignment (GTK_MISC (_rgbal), 1.0, 0.5);
+    gtk_box_pack_start(GTK_BOX(rgbabox), _rgbal, TRUE, TRUE, 2);
 
-	_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_tooltips_set_tip (tt, _rgbae, _("Hexadecimal RGBA value of the color"), NULL);
-	gtk_box_pack_start(GTK_BOX(rgbabox), _rgbae, FALSE, FALSE, 0);
-	gtk_label_set_mnemonic_widget (GTK_LABEL(_rgbal), _rgbae);
+    _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_tooltips_set_tip (tt, _rgbae, _("Hexadecimal RGBA value of the color"), NULL);
+    gtk_box_pack_start(GTK_BOX(rgbabox), _rgbae, FALSE, FALSE, 0);
+    gtk_label_set_mnemonic_widget (GTK_LABEL(_rgbal), _rgbae);
 
-	sp_set_font_size_smaller (rgbabox);
-	gtk_widget_show_all (rgbabox);
+    sp_set_font_size_smaller (rgbabox);
+    gtk_widget_show_all (rgbabox);
 
 #if ENABLE_LCMS
-        //the "too much ink" icon is initially hidden
-        gtk_widget_hide(GTK_WIDGET(_box_toomuchink));
+    //the "too much ink" icon is initially hidden
+    gtk_widget_hide(GTK_WIDGET(_box_toomuchink));
 #endif //ENABLE_LCMS
 
-        gtk_table_attach (GTK_TABLE (table), rgbabox, 0, 2, row, row + 1, GTK_FILL, GTK_SHRINK, XPAD, YPAD);
+    gtk_table_attach (GTK_TABLE (table), rgbabox, 0, 2, row, row + 1, GTK_FILL, GTK_SHRINK, XPAD, YPAD);
 
 #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);
+    gtk_table_attach (GTK_TABLE (table), _p, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
 #endif
 
-	_switchId = g_signal_connect(GTK_OBJECT (_book), "switch-page",
-								GTK_SIGNAL_FUNC (sp_color_notebook_switch_page), SP_COLOR_NOTEBOOK(_csel));
+    _switchId = g_signal_connect(GTK_OBJECT (_book), "switch-page",
+                                 GTK_SIGNAL_FUNC (sp_color_notebook_switch_page), SP_COLOR_NOTEBOOK(_csel));
 
-	_entryId = gtk_signal_connect (GTK_OBJECT (_rgbae), "changed", GTK_SIGNAL_FUNC (ColorNotebook::_rgbaEntryChangedHook), _csel);
+    _entryId = gtk_signal_connect (GTK_OBJECT (_rgbae), "changed", GTK_SIGNAL_FUNC (ColorNotebook::_rgbaEntryChangedHook), _csel);
 }
 
 static void
 sp_color_notebook_destroy (GtkObject *object)
 {
-	if (((GtkObjectClass *) (parent_class))->destroy)
-		(* ((GtkObjectClass *) (parent_class))->destroy) (object);
+    if (((GtkObjectClass *) (parent_class))->destroy)
+        (* ((GtkObjectClass *) (parent_class))->destroy) (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 ( _trackerList )
+    {
+        g_ptr_array_free (_trackerList, TRUE);
+        _trackerList = 0;
+    }
+
+    if ( _switchId )
+    {
+        if ( _book )
+        {
+            g_signal_handler_disconnect (_book, _switchId);
+            _switchId = 0;
+        }
+    }
 }
 
 static void
 sp_color_notebook_show_all (GtkWidget *widget)
 {
-	gtk_widget_show (widget);
+    gtk_widget_show (widget);
 }
 
 static void
 sp_color_notebook_hide_all (GtkWidget *widget)
 {
-	gtk_widget_hide (widget);
+    gtk_widget_hide (widget);
 }
 
 GtkWidget *
 sp_color_notebook_new (void)
 {
-	SPColorNotebook *colorbook;
+    SPColorNotebook *colorbook;
 
-	colorbook = (SPColorNotebook*)gtk_type_new (SP_TYPE_COLOR_NOTEBOOK);
+    colorbook = (SPColorNotebook*)gtk_type_new (SP_TYPE_COLOR_NOTEBOOK);
 
-	return GTK_WIDGET (colorbook);
+    return GTK_WIDGET (colorbook);
 }
 
 ColorNotebook::ColorNotebook( SPColorSelector* csel )
@@ -523,7 +523,7 @@ void ColorNotebook::_updateRgbaEntry( const SPColor& color, gfloat alpha )
 {
     g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
 
-#if ENABLE_LCMS    
+#if ENABLE_LCMS
     /* update color management icon*/
     gtk_widget_set_sensitive (_box_colormanaged, color.icc != NULL);
 
@@ -584,15 +584,15 @@ void ColorNotebook::_entryGrabbed (SPColorSelector *, SPColorNotebook *colorbook
 
 void ColorNotebook::_entryDragged (SPColorSelector *csel, SPColorNotebook *colorbook)
 {
-	gboolean oldState;
+    gboolean oldState;
     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 
-	oldState = nb->_dragging;
+    oldState = nb->_dragging;
 
-	nb->_dragging = TRUE;
-	nb->_entryModified( csel, colorbook );
+    nb->_dragging = TRUE;
+    nb->_entryModified( csel, colorbook );
 
-	nb->_dragging = oldState;
+    nb->_dragging = oldState;
 }
 
 void ColorNotebook::_entryReleased (SPColorSelector *, SPColorNotebook *colorbook)
@@ -603,116 +603,116 @@ void ColorNotebook::_entryReleased (SPColorSelector *, SPColorNotebook *colorboo
 
 void ColorNotebook::_entryChanged (SPColorSelector *csel, SPColorNotebook *colorbook)
 {
-	gboolean oldState;
+    gboolean oldState;
     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 
-	oldState = nb->_dragging;
+    oldState = nb->_dragging;
 
-	nb->_dragging = FALSE;
-	nb->_entryModified( csel, colorbook );
+    nb->_dragging = FALSE;
+    nb->_entryModified( csel, colorbook );
 
-	nb->_dragging = oldState;
+    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));
+    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 = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
     SPColor color;
     gfloat alpha = 1.0;
 
-    csel->base->getColorAlpha( color, &alpha );
+    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);
+    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;
         const gchar* str = _(SP_COLOR_SELECTOR_GET_CLASS (csel)->name[index]);
 //         g_message( "Hitting up for tab for '%s'", str );
-		tab_label = gtk_label_new(_(str));
-		gtk_notebook_append_page( GTK_NOTEBOOK (_book), page, tab_label );
-		gtk_signal_connect (GTK_OBJECT (page), "grabbed", GTK_SIGNAL_FUNC (_entryGrabbed), _csel);
-		gtk_signal_connect (GTK_OBJECT (page), "dragged", GTK_SIGNAL_FUNC (_entryDragged), _csel);
-		gtk_signal_connect (GTK_OBJECT (page), "released", GTK_SIGNAL_FUNC (_entryReleased), _csel);
-		gtk_signal_connect (GTK_OBJECT (page), "changed", GTK_SIGNAL_FUNC (_entryChanged), _csel);
-	}
-
-	return page;
+        tab_label = gtk_label_new(_(str));
+        gtk_notebook_append_page( GTK_NOTEBOOK (_book), page, tab_label );
+        gtk_signal_connect (GTK_OBJECT (page), "grabbed", GTK_SIGNAL_FUNC (_entryGrabbed), _csel);
+        gtk_signal_connect (GTK_OBJECT (page), "dragged", GTK_SIGNAL_FUNC (_entryDragged), _csel);
+        gtk_signal_connect (GTK_OBJECT (page), "released", GTK_SIGNAL_FUNC (_entryReleased), _csel);
+        gtk_signal_connect (GTK_OBJECT (page), "changed", GTK_SIGNAL_FUNC (_entryChanged), _csel);
+    }
+
+    return page;
 }
 
 GtkWidget* ColorNotebook::getPage(GType page_type, guint submode)
 {
-	gint count = 0;
-	gint i = 0;
-	GtkWidget* page = 0;
-
-//	  count = gtk_notebook_get_n_pages (_book);
-	count = 200;
-	for ( i = 0; i < count && !page; i++ )
-	{
-		page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), i);
-		if ( page )
-		{
-			SPColorSelector* csel;
-			guint pagemode;
-			csel = SP_COLOR_SELECTOR (page);
-			pagemode = csel->base->getSubmode();
-			if ( G_TYPE_FROM_INSTANCE (page) == page_type
-				 && pagemode == submode )
-			{
-				// found it.
-				break;
-			}
-			else
-			{
-				page = 0;
-			}
-		}
-		else
-		{
-			break;
-		}
-	}
-	return page;
+    gint count = 0;
+    gint i = 0;
+    GtkWidget* page = 0;
+
+//     count = gtk_notebook_get_n_pages (_book);
+    count = 200;
+    for ( i = 0; i < count && !page; i++ )
+    {
+        page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), i);
+        if ( page )
+        {
+            SPColorSelector* csel;
+            guint pagemode;
+            csel = SP_COLOR_SELECTOR (page);
+            pagemode = csel->base->getSubmode();
+            if ( G_TYPE_FROM_INSTANCE (page) == page_type
+                 && pagemode == submode )
+            {
+                // found it.
+                break;
+            }
+            else
+            {
+                page = 0;
+            }
+        }
+        else
+        {
+            break;
+        }
+    }
+    return page;
 }
 
 void ColorNotebook::removePage( GType page_type, guint submode )
 {
-	GtkWidget *page = 0;
-
-	page = getPage(page_type, submode);
-	if ( page )
-	{
-		gint where = gtk_notebook_page_num (GTK_NOTEBOOK (_book), page);
-		if ( where >= 0 )
-		{
-			if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (_book)) == where )
-			{
+    GtkWidget *page = 0;
+
+    page = getPage(page_type, submode);
+    if ( page )
+    {
+        gint where = gtk_notebook_page_num (GTK_NOTEBOOK (_book), page);
+        if ( where >= 0 )
+        {
+            if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (_book)) == where )
+            {
 //                 getColorAlpha(_color, &_alpha);
-			}
-			gtk_notebook_remove_page (GTK_NOTEBOOK (_book), where);
-		}
-	}
+            }
+            gtk_notebook_remove_page (GTK_NOTEBOOK (_book), where);
+        }
+    }
 }
 
 /*
diff --git a/src/widgets/sp-color-selector.cpp b/src/widgets/sp-color-selector.cpp
index 312128781..203bc3c2a 100644
--- a/src/widgets/sp-color-selector.cpp
+++ b/src/widgets/sp-color-selector.cpp
@@ -318,15 +318,12 @@ void ColorSelector::_colorChanged()
 {
 }
 
-void ColorSelector::getColorAlpha( SPColor& color, gfloat* alpha ) const
+void ColorSelector::getColorAlpha( SPColor &color, gfloat &alpha ) const
 {
     gint i = 0;
 
     color = _color;
-    if ( alpha )
-    {
-        *alpha = _alpha;
-    }
+    alpha = _alpha;
 
     // Try to catch uninitialized value usage
     if ( color.v.c[0] )
@@ -345,7 +342,7 @@ void ColorSelector::getColorAlpha( SPColor& color, gfloat* alpha ) const
     {
         i++;
     }
-    if ( alpha && *alpha )
+    if ( alpha )
     {
         i++;
     }
diff --git a/src/widgets/sp-color-selector.h b/src/widgets/sp-color-selector.h
index 40446fe0a..a2ad87dd5 100644
--- a/src/widgets/sp-color-selector.h
+++ b/src/widgets/sp-color-selector.h
@@ -26,7 +26,7 @@ public:
     gfloat getAlpha() const;
 
     void setColorAlpha( const SPColor& color, gfloat alpha, bool emit = false );
-    void getColorAlpha( SPColor& color, gfloat* alpha ) const;
+    void getColorAlpha( SPColor &color, gfloat &alpha ) const;
 
     virtual void setSubmode( guint submode );
     virtual guint getSubmode() const;
diff --git a/src/widgets/stroke-style.cpp b/src/widgets/stroke-style.cpp
index f502f87d3..ddd1c92d3 100644
--- a/src/widgets/stroke-style.cpp
+++ b/src/widgets/stroke-style.cpp
@@ -63,7 +63,7 @@ static void sp_stroke_style_paint_selection_modified (SPWidget *spw, Inkscape::S
 static void sp_stroke_style_paint_selection_changed (SPWidget *spw, Inkscape::Selection *selection, SPPaintSelector *psel);
 static void sp_stroke_style_paint_update(SPWidget *spw);
 
-static void sp_stroke_style_paint_mode_changed(SPPaintSelector *psel, SPPaintSelectorMode mode, SPWidget *spw);
+static void sp_stroke_style_paint_mode_changed(SPPaintSelector *psel, SPPaintSelector::Mode mode, SPWidget *spw);
 static void sp_stroke_style_paint_dragged(SPPaintSelector *psel, SPWidget *spw);
 static void sp_stroke_style_paint_changed(SPPaintSelector *psel, SPWidget *spw);
 
@@ -189,7 +189,7 @@ sp_stroke_style_paint_update (SPWidget *spw)
         case QUERY_STYLE_NOTHING:
         {
             /* No paint at all */
-            sp_paint_selector_set_mode (psel, SP_PAINT_SELECTOR_MODE_EMPTY);
+            psel->setMode(SPPaintSelector::MODE_EMPTY);
             break;
         }
 
@@ -197,43 +197,43 @@ sp_stroke_style_paint_update (SPWidget *spw)
         case QUERY_STYLE_MULTIPLE_AVERAGED: // TODO: treat this slightly differently, e.g. display "averaged" somewhere in paint selector
         case QUERY_STYLE_MULTIPLE_SAME:
         {
-            SPPaintSelectorMode pselmode = sp_style_determine_paint_selector_mode (query, false);
-            sp_paint_selector_set_mode (psel, pselmode);
+            SPPaintSelector::Mode pselmode = SPPaintSelector::getModeForStyle(*query, false);
+            psel->setMode(pselmode);
 
             if (query->stroke.set && query->stroke.isPaintserver()) {
 
                 SPPaintServer *server = SP_STYLE_STROKE_SERVER (query);
 
-                if (SP_IS_LINEARGRADIENT (server)) {
-                    SPGradient *vector = sp_gradient_get_vector (SP_GRADIENT (server), FALSE);
-                    sp_paint_selector_set_gradient_linear (psel, vector);
+                if (server && server->isSwatch()) {
+                    SPGradient *vector = SP_GRADIENT(server)->getVector();
+                    psel->setSwatch( vector );
+                } else if (SP_IS_LINEARGRADIENT (server)) {
+                    SPGradient *vector = SP_GRADIENT(server)->getVector();
+                    psel->setGradientLinear( vector );
 
                     SPLinearGradient *lg = SP_LINEARGRADIENT (server);
-                    sp_paint_selector_set_gradient_properties (psel,
-                                                       SP_GRADIENT_UNITS (lg),
-                                                       SP_GRADIENT_SPREAD (lg));
+                    psel->setGradientProperties( SP_GRADIENT_UNITS(lg),
+                                                 SP_GRADIENT_SPREAD(lg) );
                 } else if (SP_IS_RADIALGRADIENT (server)) {
-                    SPGradient *vector = sp_gradient_get_vector (SP_GRADIENT (server), FALSE);
-                    sp_paint_selector_set_gradient_radial (psel, vector);
+                    SPGradient *vector = SP_GRADIENT(server)->getVector();
+                    psel->setGradientRadial( vector );
 
                     SPRadialGradient *rg = SP_RADIALGRADIENT (server);
-                    sp_paint_selector_set_gradient_properties (psel,
-                                                       SP_GRADIENT_UNITS (rg),
-                                                       SP_GRADIENT_SPREAD (rg));
+                    psel->setGradientProperties( SP_GRADIENT_UNITS(rg),
+                                                 SP_GRADIENT_SPREAD(rg) );
                 } else if (SP_IS_PATTERN (server)) {
                     SPPattern *pat = pattern_getroot (SP_PATTERN (server));
-                    sp_update_pattern_list (psel, pat);
+                    psel->updatePatternList( pat );
                 }
             } else if (query->stroke.set && query->stroke.isColor()) {
-                sp_paint_selector_set_color_alpha (psel, &query->stroke.value.color, SP_SCALE24_TO_FLOAT (query->stroke_opacity.value));
-
+                psel->setColorAlpha(query->stroke.value.color, SP_SCALE24_TO_FLOAT(query->stroke_opacity.value));
             }
             break;
         }
 
         case QUERY_STYLE_MULTIPLE_DIFFERENT:
         {
-            sp_paint_selector_set_mode (psel, SP_PAINT_SELECTOR_MODE_MULTIPLE);
+            psel->setMode(SPPaintSelector::MODE_MULTIPLE);
             break;
         }
     }
@@ -248,7 +248,7 @@ sp_stroke_style_paint_update (SPWidget *spw)
  */
 static void
 sp_stroke_style_paint_mode_changed( SPPaintSelector *psel,
-                                    SPPaintSelectorMode /*mode*/,
+                                    SPPaintSelector::Mode /*mode*/,
                                     SPWidget *spw )
 {
     if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
@@ -278,10 +278,10 @@ sp_stroke_style_paint_dragged(SPPaintSelector *psel, SPWidget *spw)
     }
 
     switch (psel->mode) {
-        case SP_PAINT_SELECTOR_MODE_COLOR_RGB:
-        case SP_PAINT_SELECTOR_MODE_COLOR_CMYK:
+        case SPPaintSelector::MODE_COLOR_RGB:
+        case SPPaintSelector::MODE_COLOR_CMYK:
         {
-            sp_paint_selector_set_flat_color (psel, SP_ACTIVE_DESKTOP, "stroke", "stroke-opacity");
+            psel->setFlatColor( SP_ACTIVE_DESKTOP, "stroke", "stroke-opacity" );
             sp_document_maybe_done (sp_desktop_document(SP_ACTIVE_DESKTOP), undo_label, SP_VERB_DIALOG_FILL_STROKE,
                                     _("Set stroke color"));
             break;
@@ -313,17 +313,17 @@ sp_stroke_style_paint_changed(SPPaintSelector *psel, SPWidget *spw)
     GSList const *items = selection->itemList();
 
     switch (psel->mode) {
-        case SP_PAINT_SELECTOR_MODE_EMPTY:
+        case SPPaintSelector::MODE_EMPTY:
             // This should not happen.
             g_warning ( "file %s: line %d: Paint %d should not emit 'changed'",
                         __FILE__, __LINE__, psel->mode);
             break;
-        case SP_PAINT_SELECTOR_MODE_MULTIPLE:
+        case SPPaintSelector::MODE_MULTIPLE:
             // This happens when you switch multiple objects with different gradients to flat color;
             // nothing to do here.
             break;
 
-        case SP_PAINT_SELECTOR_MODE_NONE:
+        case SPPaintSelector::MODE_NONE:
         {
             SPCSSAttr *css = sp_repr_css_attr_new();
             sp_repr_css_set_property(css, "stroke", "none");
@@ -337,10 +337,10 @@ sp_stroke_style_paint_changed(SPPaintSelector *psel, SPWidget *spw)
             break;
         }
 
-        case SP_PAINT_SELECTOR_MODE_COLOR_RGB:
-        case SP_PAINT_SELECTOR_MODE_COLOR_CMYK:
+        case SPPaintSelector::MODE_COLOR_RGB:
+        case SPPaintSelector::MODE_COLOR_CMYK:
         {
-            sp_paint_selector_set_flat_color (psel, desktop, "stroke", "stroke-opacity");
+            psel->setFlatColor(desktop, "stroke", "stroke-opacity");
             sp_document_maybe_done (sp_desktop_document(desktop), undo_label, SP_VERB_DIALOG_FILL_STROKE,
                                     _("Set stroke color"));
 
@@ -353,13 +353,13 @@ sp_stroke_style_paint_changed(SPPaintSelector *psel, SPWidget *spw)
             break;
         }
 
-        case SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR:
-        case SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL:
+        case SPPaintSelector::MODE_GRADIENT_LINEAR:
+        case SPPaintSelector::MODE_GRADIENT_RADIAL:
             if (items) {
-                SPGradientType const gradient_type = ( psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR
+                SPGradientType const gradient_type = ( psel->mode == SPPaintSelector::MODE_GRADIENT_LINEAR
                                                        ? SP_GRADIENT_TYPE_LINEAR
                                                        : SP_GRADIENT_TYPE_RADIAL );
-                SPGradient *vector = sp_paint_selector_get_gradient_vector(psel);
+                SPGradient *vector = psel->getGradientVector();
                 if (!vector) {
                     /* No vector in paint selector should mean that we just changed mode */
 
@@ -389,7 +389,7 @@ sp_stroke_style_paint_changed(SPPaintSelector *psel, SPWidget *spw)
                     vector = sp_gradient_ensure_vector_normalized(vector);
                     for (GSList const *i = items; i != NULL; i = i->next) {
                         SPGradient *gr = sp_item_set_gradient(SP_ITEM(i->data), vector, gradient_type, false);
-                        sp_gradient_selector_attrs_to_gradient(gr, psel);
+                        psel->pushAttrsToGradient( gr );
                     }
                 }
 
@@ -398,11 +398,11 @@ sp_stroke_style_paint_changed(SPPaintSelector *psel, SPWidget *spw)
             }
             break;
 
-        case SP_PAINT_SELECTOR_MODE_PATTERN:
+        case SPPaintSelector::MODE_PATTERN:
 
             if (items) {
 
-                SPPattern *pattern = sp_paint_selector_get_pattern (psel);
+                SPPattern *pattern = psel->getPattern();
                 if (!pattern) {
 
                     /* No Pattern in paint selector should mean that we just
@@ -443,7 +443,11 @@ sp_stroke_style_paint_changed(SPPaintSelector *psel, SPWidget *spw)
 
             break;
 
-        case SP_PAINT_SELECTOR_MODE_UNSET:
+        case SPPaintSelector::MODE_SWATCH:
+            // TODO
+            break;
+
+        case SPPaintSelector::MODE_UNSET:
             if (items) {
                     SPCSSAttr *css = sp_repr_css_attr_new ();
                     sp_repr_css_unset_property (css, "stroke");
diff --git a/src/widgets/swatch-selector.cpp b/src/widgets/swatch-selector.cpp
new file mode 100644
index 000000000..a6f5133b7
--- /dev/null
+++ b/src/widgets/swatch-selector.cpp
@@ -0,0 +1,203 @@
+
+
+#include <glibmm/i18n.h>
+
+#include "swatch-selector.h"
+
+#include "document.h"
+#include "gradient-chemistry.h"
+#include "gradient-selector.h"
+#include "sp-color-notebook.h"
+#include "sp-stop.h"
+#include "svg/css-ostringstream.h"
+#include "svg/svg-color.h"
+#include "verbs.h"
+#include "xml/node.h"
+
+namespace Inkscape
+{
+namespace Widgets
+{
+
+SwatchSelector::SwatchSelector() :
+    Gtk::VBox(),
+    _gsel(0),
+    _csel(0)
+{
+    GtkWidget *gsel = sp_gradient_selector_new();
+    _gsel = SP_GRADIENT_SELECTOR(gsel);
+    g_object_set_data( G_OBJECT(gobj()), "base", this );
+    _gsel->setMode(SPGradientSelector::MODE_SWATCH);
+
+    gtk_widget_show(gsel);
+
+    pack_start(*Gtk::manage(Glib::wrap(gsel)));
+
+
+    GtkWidget *csel = sp_color_selector_new( SP_TYPE_COLOR_NOTEBOOK );
+    _csel = SP_COLOR_SELECTOR(csel);
+    Gtk::Widget *wrappedCSel = Glib::wrap(csel);
+    wrappedCSel->show();
+    //gtk_widget_show(csel);
+
+
+    GObject *obj = G_OBJECT(csel);
+
+    g_signal_connect(obj, "grabbed", G_CALLBACK(_grabbedCb), this);
+    g_signal_connect(obj, "dragged", G_CALLBACK(_draggedCb), this);
+    g_signal_connect(obj, "released", G_CALLBACK(_releasedCb), this);
+    g_signal_connect(obj, "changed", G_CALLBACK(_changedCb), this);
+
+    pack_start(*Gtk::manage(wrappedCSel));
+}
+
+SwatchSelector::~SwatchSelector()
+{
+    _csel = 0; // dtor should be handled by Gtk::manage()
+    _gsel = 0;
+}
+
+SPGradientSelector *SwatchSelector::getGradientSelector()
+{
+    return _gsel;
+}
+
+void SwatchSelector::_grabbedCb(SPColorSelector * /*csel*/, void * /*data*/)
+{
+}
+
+void SwatchSelector::_draggedCb(SPColorSelector * /*csel*/, void *data)
+{
+    if (data) {
+        //SwatchSelector *swsel = reinterpret_cast<SwatchSelector*>(data);
+
+        // TODO might have to block cycles
+
+        // Copied from gradient-vector.cpp, but does not appear to cause visible changes:
+        /*
+        if (swsel->_gsel) {
+            SPGradient *gradient = swsel->_gsel->getVector();
+            SPGradient *ngr = sp_gradient_ensure_vector_normalized(gradient);
+            if (ngr != gradient) {
+                // Our master gradient has changed
+                // TODO replace with proper - sp_gradient_vector_widget_load_gradient(GTK_WIDGET(swsel->_gsel), ngr);
+            }
+
+            sp_gradient_ensure_vector(ngr);
+
+
+            SPStop* stop = ngr->getFirstStop();
+            if (stop) {
+                swsel->_csel->base->getColorAlpha(stop->specified_color, &stop->opacity);
+                stop->currentColor = false;
+                // TODO push refresh
+            }
+        }
+        */
+    }
+}
+
+void SwatchSelector::_releasedCb(SPColorSelector * /*csel*/, void * /*data*/)
+{
+}
+
+void SwatchSelector::_changedCb(SPColorSelector */*csel*/, void *data)
+{
+    if (data) {
+        SwatchSelector *swsel = reinterpret_cast<SwatchSelector*>(data);
+
+        // TODO might have to block cycles
+
+        if (swsel->_gsel && swsel->_gsel->getVector()) {
+            SPGradient *gradient = swsel->_gsel->getVector();
+            SPGradient *ngr = sp_gradient_ensure_vector_normalized(gradient);
+            if (ngr != gradient) {
+                /* Our master gradient has changed */
+                // TODO replace with proper - sp_gradient_vector_widget_load_gradient(GTK_WIDGET(swsel->_gsel), ngr);
+            }
+
+            sp_gradient_ensure_vector(ngr);
+
+
+            SPStop* stop = ngr->getFirstStop();
+            if (stop) {
+                SPColor color;
+                float alpha = 0;
+                guint32 rgb = 0;
+
+                swsel->_csel->base->getColorAlpha( color, alpha );
+                rgb = color.toRGBA32( 0x00 );
+
+                // TODO replace with generic shared code that also handles icc-color
+                Inkscape::CSSOStringStream os;
+                gchar c[64];
+                sp_svg_write_color(c, sizeof(c), rgb);
+                os << "stop-color:" << c << ";stop-opacity:" << static_cast<gdouble>(alpha) <<";";
+                SP_OBJECT_REPR(stop)->setAttribute("style", os.str().c_str());
+
+                sp_document_done(SP_OBJECT_DOCUMENT(ngr), SP_VERB_CONTEXT_GRADIENT,
+                                 _("Change swatch color"));
+            }
+        }
+    }
+}
+
+void SwatchSelector::connectGrabbedHandler( GCallback handler, void *data )
+{
+    GObject* obj = G_OBJECT(_gsel);
+    g_signal_connect( obj, "grabbed", handler, data );
+}
+
+void SwatchSelector::connectDraggedHandler( GCallback handler, void *data )
+{
+    GObject* obj = G_OBJECT(_gsel);
+    g_signal_connect( obj, "dragged", handler, data );
+}
+
+void SwatchSelector::connectReleasedHandler( GCallback handler, void *data )
+{
+    GObject* obj = G_OBJECT(_gsel);
+    g_signal_connect( obj, "released", handler, data );
+}
+
+void SwatchSelector::connectchangedHandler( GCallback handler, void *data )
+{
+    GObject* obj = G_OBJECT(_gsel);
+    g_signal_connect( obj, "changed", handler, data );
+}
+
+void SwatchSelector::setVector(SPDocument */*doc*/, SPGradient *vector)
+{
+    //GtkVBox * box = gobj();
+
+    _gsel->setVector((vector) ? SP_OBJECT_DOCUMENT(vector) : 0, vector);
+
+    if (vector) {
+        SPStop* stop = vector->getFirstStop();
+
+        guint32 const colorVal = sp_stop_get_rgba32(stop);
+        _csel->base->setAlpha(SP_RGBA32_A_F(colorVal));
+        SPColor color( SP_RGBA32_R_F(colorVal), SP_RGBA32_G_F(colorVal), SP_RGBA32_B_F(colorVal) );
+        // set its color, from the stored array
+        _csel->base->setColor( color );
+    }
+
+/*
+*/
+}
+
+} // namespace Widgets
+} // namespace Inkscape
+
+
+
+/*
+  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:encoding=utf-8:textwidth=99 :
diff --git a/src/widgets/swatch-selector.h b/src/widgets/swatch-selector.h
new file mode 100644
index 000000000..83acf9fda
--- /dev/null
+++ b/src/widgets/swatch-selector.h
@@ -0,0 +1,59 @@
+#ifndef SEEN_SP_SWATCH_SELECTOR_H
+#define SEEN_SP_SWATCH_SELECTOR_H
+
+
+
+#include <gtkmm/box.h>
+
+class SPDocument;
+class SPGradient;
+class SPColorSelector;
+class SPGradientSelector;
+
+namespace Inkscape
+{
+namespace Widgets
+{
+
+class SwatchSelector : public Gtk::VBox
+{
+public:
+    SwatchSelector();
+    virtual ~SwatchSelector();
+
+    void connectGrabbedHandler( GCallback handler, void *data );
+    void connectDraggedHandler( GCallback handler, void *data );
+    void connectReleasedHandler( GCallback handler, void *data );
+    void connectchangedHandler( GCallback handler, void *data );
+
+    void setVector(SPDocument *doc, SPGradient *vector);
+
+    SPGradientSelector *getGradientSelector();
+
+private:
+    static void _grabbedCb(SPColorSelector *csel, void *data);
+    static void _draggedCb(SPColorSelector *csel, void *data);
+    static void _releasedCb(SPColorSelector *csel, void *data);
+    static void _changedCb(SPColorSelector *csel, void *data);
+
+    SPGradientSelector *_gsel;
+    SPColorSelector *_csel;
+};
+
+
+} // namespace Widgets
+} // namespace Inkscape
+
+#endif // SEEN_SP_SWATCH_SELECTOR_H
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :
+
diff --git a/src/widgets/toolbox.cpp b/src/widgets/toolbox.cpp
index 9fc077778..4b0d84d90 100644
--- a/src/widgets/toolbox.cpp
+++ b/src/widgets/toolbox.cpp
@@ -9,7 +9,7 @@
  *   Frank Felfe <innerspace@iname.com>
  *   John Cliff <simarilius@yahoo.com>
  *   David Turner <novalis@gnu.org>
- *   Josh Andler <scislac@users.sf.net>
+ *   Josh Andler <scislac@scislac.com>
  *   Jon A. Cruz <jon@joncruz.org>
  *   Maximilian Albert <maximilian.albert@gmail.com>
  *
@@ -50,7 +50,7 @@
 #include "../ege-select-one-action.h"
 #include "../flood-context.h"
 #include "gradient-toolbar.h"
-#include "../graphlayout/graphlayout.h"
+#include "../graphlayout.h"
 #include "../helper/unit-menu.h"
 #include "../helper/units.h"
 #include "../helper/unit-tracker.h"
@@ -65,7 +65,6 @@
 #include "../live_effects/lpe-line_segment.h"
 #include "../lpe-tool-context.h"
 #include "../mod360.h"
-#include "../node-context.h"
 #include "../pen-context.h"
 #include "../preferences.h"
 #include "../selection-chemistry.h"
@@ -89,6 +88,9 @@
 #include "../spray-context.h"
 #include "../ui/dialog/calligraphic-profile-rename.h"
 #include "../ui/icon-names.h"
+#include "../ui/tool/control-point-selection.h"
+#include "../ui/tool/node-tool.h"
+#include "../ui/tool/multi-path-manipulator.h"
 #include "../ui/widget/style-swatch.h"
 #include "../verbs.h"
 #include "../widgets/button.h"
@@ -98,14 +100,28 @@
 #include "../xml/attribute-record.h"
 #include "../xml/node-event-vector.h"
 #include "../xml/repr.h"
+#include "ui/uxmanager.h"
 
 #include "toolbox.h"
 
+#define ENABLE_TASK_SUPPORT 1
+
 using Inkscape::UnitTracker;
+using Inkscape::UI::UXManager;
 
 typedef void (*SetupFunction)(GtkWidget *toolbox, SPDesktop *desktop);
 typedef void (*UpdateFunction)(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox);
 
+enum BarId {
+    BAR_TOOL = 0,
+    BAR_AUX,
+    BAR_COMMANDS,
+    BAR_SNAP,
+};
+
+#define BAR_ID_KEY "BarIdValue"
+#define HANDLE_POS_MARK "x-inkscape-pos"
+
 static void       sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 static void       sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 static void       sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
@@ -128,7 +144,18 @@ static void       sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* ma
 namespace { GtkWidget *sp_text_toolbox_new (SPDesktop *desktop); }
 
 
-Inkscape::IconSize prefToSize( Glib::ustring const &path, int base ) {
+#if ENABLE_TASK_SUPPORT
+static void fireTaskChange( EgeSelectOneAction *act, SPDesktop *dt )
+{
+    gint selected = ege_select_one_action_get_active( act );
+    UXManager::getInstance()->setTask(dt, selected);
+}
+#endif // ENABLE_TASK_SUPPORT
+
+using Inkscape::UI::ToolboxFactory;
+
+
+Inkscape::IconSize ToolboxFactory::prefToSize( Glib::ustring const &path, int base ) {
     static Inkscape::IconSize sizeChoices[] = {
         Inkscape::ICON_SIZE_LARGE_TOOLBAR,
         Inkscape::ICON_SIZE_SMALL_TOOLBAR,
@@ -146,7 +173,7 @@ static struct {
     sp_verb_t doubleclick_verb;
 } const tools[] = {
     { "SPSelectContext",   "select_tool",    SP_VERB_CONTEXT_SELECT,  SP_VERB_CONTEXT_SELECT_PREFS},
-    { "SPNodeContext",     "node_tool",      SP_VERB_CONTEXT_NODE, SP_VERB_CONTEXT_NODE_PREFS },
+    { "InkNodeTool",     "node_tool",      SP_VERB_CONTEXT_NODE, SP_VERB_CONTEXT_NODE_PREFS },
     { "SPTweakContext",    "tweak_tool",     SP_VERB_CONTEXT_TWEAK, SP_VERB_CONTEXT_TWEAK_PREFS },
     { "SPSprayContext",    "spray_tool",     SP_VERB_CONTEXT_SPRAY, SP_VERB_CONTEXT_SPRAY_PREFS },
     { "SPZoomContext",     "zoom_tool",      SP_VERB_CONTEXT_ZOOM, SP_VERB_CONTEXT_ZOOM_PREFS },
@@ -180,7 +207,7 @@ static struct {
 } const aux_toolboxes[] = {
     { "SPSelectContext", "select_toolbox", 0, sp_select_toolbox_prep,            "SelectToolbar",
       SP_VERB_INVALID, 0, 0},
-    { "SPNodeContext",   "node_toolbox",   0, sp_node_toolbox_prep,              "NodeToolbar",
+    { "InkNodeTool",   "node_toolbox",   0, sp_node_toolbox_prep,              "NodeToolbar",
       SP_VERB_INVALID, 0, 0},
     { "SPTweakContext",   "tweak_toolbox",   0, sp_tweak_toolbox_prep,              "TweakToolbar",
       SP_VERB_CONTEXT_TWEAK_PREFS, "/tools/tweak", N_("Color/opacity used for color tweaking")},
@@ -255,6 +282,7 @@ static gchar const * ui_descr =
         "  </toolbar>"
 
         "  <toolbar name='NodeToolbar'>"
+        "    <separator />"
         "    <toolitem action='NodeInsertAction' />"
         "    <toolitem action='NodeDeleteAction' />"
         "    <separator />"
@@ -283,6 +311,7 @@ static gchar const * ui_descr =
         "    <toolitem action='ObjectEditMaskPathAction' />"
         "    <toolitem action='EditNextLPEParameterAction' />"
         "    <separator />"
+        "    <toolitem action='NodesShowTransformHandlesAction' />"
         "    <toolitem action='NodesShowHandlesAction' />"
         "    <toolitem action='NodesShowHelperpath' />"
         "  </toolbar>"
@@ -470,7 +499,7 @@ static gchar const * ui_descr =
         "  </toolbar>"
 
         "  <toolbar name='ConnectorToolbar'>"
-        "    <toolitem action='ConnectorEditModeAction' />"
+//        "    <toolitem action='ConnectorEditModeAction' />"
         "    <toolitem action='ConnectorAvoidAction' />"
         "    <toolitem action='ConnectorIgnoreAction' />"
         "    <toolitem action='ConnectorOrthogonalAction' />"
@@ -480,8 +509,8 @@ static gchar const * ui_descr =
         "    <toolitem action='ConnectorLengthAction' />"
         "    <toolitem action='ConnectorDirectedAction' />"
         "    <toolitem action='ConnectorOverlapAction' />"
-        "    <toolitem action='ConnectorNewConnPointAction' />"
-        "    <toolitem action='ConnectorRemoveConnPointAction' />"
+//        "    <toolitem action='ConnectorNewConnPointAction' />"
+//        "    <toolitem action='ConnectorRemoveConnPointAction' />"
         "  </toolbar>"
 
         "</ui>"
@@ -489,7 +518,7 @@ static gchar const * ui_descr =
 
 static Glib::RefPtr<Gtk::ActionGroup> create_or_fetch_actions( SPDesktop* desktop );
 
-static void toolbox_set_desktop (GtkWidget *toolbox, SPDesktop *desktop, SetupFunction setup_func, UpdateFunction update_func, sigc::connection*);
+void setup_snap_toolbox (GtkWidget *toolbox, SPDesktop *desktop);
 
 static void setup_tool_toolbox (GtkWidget *toolbox, SPDesktop *desktop);
 static void update_tool_toolbox (SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox);
@@ -572,7 +601,7 @@ Gtk::Widget* VerbAction::create_menu_item_vfunc()
 Gtk::Widget* VerbAction::create_tool_item_vfunc()
 {
 //     Gtk::Widget* widg = Gtk::Action::create_tool_item_vfunc();
-    Inkscape::IconSize toolboxSize = prefToSize("/toolbox/tools/small");
+    Inkscape::IconSize toolboxSize = ToolboxFactory::prefToSize("/toolbox/tools/small");
     GtkWidget* toolbox = 0;
     GtkWidget *button = sp_toolbox_button_new_from_verb_with_doubleclick( toolbox, toolboxSize,
                                                                           SP_BUTTON_TYPE_TOGGLE,
@@ -780,7 +809,7 @@ Glib::RefPtr<Gtk::ActionGroup> create_or_fetch_actions( SPDesktop* desktop )
         SP_VERB_ZOOM_SELECTION,
     };
 
-    Inkscape::IconSize toolboxSize = prefToSize("/toolbox/small");
+    Inkscape::IconSize toolboxSize = ToolboxFactory::prefToSize("/toolbox/small");
 
     static std::map<SPDesktop*, Glib::RefPtr<Gtk::ActionGroup> > groups;
     Glib::RefPtr<Gtk::ActionGroup> mainActions;
@@ -816,6 +845,43 @@ Glib::RefPtr<Gtk::ActionGroup> create_or_fetch_actions( SPDesktop* desktop )
         }
     }
 
+#if ENABLE_TASK_SUPPORT
+    if ( !mainActions->get_action("TaskSetAction") ) {
+        GtkListStore* model = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_STRING );
+
+        GtkTreeIter iter;
+        gtk_list_store_append( model, &iter );
+        gtk_list_store_set( model, &iter,
+                            0, _("Default"),
+                            1, _("Default interface setup"),
+                            -1 );
+
+        gtk_list_store_append( model, &iter );
+        gtk_list_store_set( model, &iter,
+                            0, _("Custom"),
+                            1, _("Set the custom task"),
+                            -1 );
+
+        gtk_list_store_append( model, &iter );
+        gtk_list_store_set( model, &iter,
+                            0, _("Wide"),
+                            1, _("Setup for widescreen work"),
+                            -1 );
+
+        EgeSelectOneAction* act = ege_select_one_action_new( "TaskSetAction", _("Task"), (""), NULL, GTK_TREE_MODEL(model) );
+        g_object_set( act, "short_label", _("Task:"), NULL );
+        mainActions->add(Glib::wrap(GTK_ACTION(act)));
+        //g_object_set_data( holder, "mode_action", act );
+
+        ege_select_one_action_set_appearance( act, "minimal" );
+        ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
+        //ege_select_one_action_set_icon_size( act, secondarySize );
+        ege_select_one_action_set_tooltip_column( act, 1  );
+
+        //ege_select_one_action_set_active( act, mode );
+        g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(fireTaskChange), desktop );
+    }
+#endif // ENABLE_TASK_SUPPORT
 
     return mainActions;
 }
@@ -833,25 +899,21 @@ void handlebox_attached(GtkHandleBox* /*handlebox*/, GtkWidget* widget, gpointer
     gtk_widget_set_size_request( widget, -1, -1 );
 }
 
-
-
-GtkWidget *
-sp_tool_toolbox_new()
+static GtkWidget* toolboxNewCommon( GtkWidget* tb, BarId id, GtkPositionType handlePos )
 {
-    GtkTooltips *tt = gtk_tooltips_new();
-    GtkWidget* tb = gtk_toolbar_new();
-    gtk_toolbar_set_orientation(GTK_TOOLBAR(tb), GTK_ORIENTATION_VERTICAL);
-    gtk_toolbar_set_show_arrow(GTK_TOOLBAR(tb), TRUE);
-
     g_object_set_data(G_OBJECT(tb), "desktop", NULL);
-    g_object_set_data(G_OBJECT(tb), "tooltips", tt);
 
     gtk_widget_set_sensitive(tb, FALSE);
 
-    GtkWidget *hb = gtk_handle_box_new();
-    gtk_handle_box_set_handle_position(GTK_HANDLE_BOX(hb), GTK_POS_TOP);
-    gtk_handle_box_set_shadow_type(GTK_HANDLE_BOX(hb), GTK_SHADOW_OUT);
-    gtk_handle_box_set_snap_edge(GTK_HANDLE_BOX(hb), GTK_POS_LEFT);
+    GtkWidget *hb = 0;
+    if ( UXManager::getInstance()->isFloatWindowProblem() ) {
+        hb = gtk_event_box_new(); // A simple, neutral container.
+    } else {
+        hb = gtk_handle_box_new();
+        gtk_handle_box_set_handle_position(GTK_HANDLE_BOX(hb), handlePos);
+        gtk_handle_box_set_shadow_type(GTK_HANDLE_BOX(hb), GTK_SHADOW_OUT);
+        gtk_handle_box_set_snap_edge(GTK_HANDLE_BOX(hb), GTK_POS_LEFT);
+    }
 
     gtk_container_add(GTK_CONTAINER(hb), tb);
     gtk_widget_show(GTK_WIDGET(tb));
@@ -859,96 +921,47 @@ sp_tool_toolbox_new()
     sigc::connection* conn = new sigc::connection;
     g_object_set_data(G_OBJECT(hb), "event_context_connection", conn);
 
-    g_signal_connect(G_OBJECT(hb), "child_detached", G_CALLBACK(handlebox_detached), static_cast<gpointer>(0));
-    g_signal_connect(G_OBJECT(hb), "child_attached", G_CALLBACK(handlebox_attached), static_cast<gpointer>(0));
+    if ( GTK_IS_HANDLE_BOX(hb) ) {
+        g_signal_connect(G_OBJECT(hb), "child_detached", G_CALLBACK(handlebox_detached), static_cast<gpointer>(0));
+        g_signal_connect(G_OBJECT(hb), "child_attached", G_CALLBACK(handlebox_attached), static_cast<gpointer>(0));
+    }
+
+    gpointer val = GINT_TO_POINTER(id);
+    g_object_set_data(G_OBJECT(hb), BAR_ID_KEY, val);
 
     return hb;
 }
 
-GtkWidget *
-sp_aux_toolbox_new()
+GtkWidget *ToolboxFactory::createToolToolbox()
 {
     GtkWidget *tb = gtk_vbox_new(FALSE, 0);
 
-    gtk_box_set_spacing(GTK_BOX(tb), AUX_SPACING);
-
-    g_object_set_data(G_OBJECT(tb), "desktop", NULL);
-
-    gtk_widget_set_sensitive(tb, FALSE);
-
-    GtkWidget *hb = gtk_handle_box_new();
-    gtk_handle_box_set_handle_position(GTK_HANDLE_BOX(hb), GTK_POS_LEFT);
-    gtk_handle_box_set_shadow_type(GTK_HANDLE_BOX(hb), GTK_SHADOW_OUT);
-    gtk_handle_box_set_snap_edge(GTK_HANDLE_BOX(hb), GTK_POS_LEFT);
-
-    gtk_container_add(GTK_CONTAINER(hb), tb);
-    gtk_widget_show(GTK_WIDGET(tb));
-
-    sigc::connection* conn = new sigc::connection;
-    g_object_set_data(G_OBJECT(hb), "event_context_connection", conn);
+    return toolboxNewCommon( tb, BAR_TOOL, GTK_POS_TOP );
+}
 
-    g_signal_connect(G_OBJECT(hb), "child_detached", G_CALLBACK(handlebox_detached), static_cast<gpointer>(0));
-    g_signal_connect(G_OBJECT(hb), "child_attached", G_CALLBACK(handlebox_attached), static_cast<gpointer>(0));
+GtkWidget *ToolboxFactory::createAuxToolbox()
+{
+    GtkWidget *tb = gtk_vbox_new(FALSE, 0);
 
-    return hb;
+    return toolboxNewCommon( tb, BAR_AUX, GTK_POS_LEFT );
 }
 
 //####################################
 //# Commands Bar
 //####################################
 
-GtkWidget *
-sp_commands_toolbox_new()
+GtkWidget *ToolboxFactory::createCommandsToolbox()
 {
-    GtkWidget *tb = gtk_toolbar_new();
-
-    g_object_set_data(G_OBJECT(tb), "desktop", NULL);
-    gtk_widget_set_sensitive(tb, FALSE);
-
-    GtkWidget *hb = gtk_handle_box_new();
-    gtk_handle_box_set_handle_position(GTK_HANDLE_BOX(hb), GTK_POS_LEFT);
-    gtk_handle_box_set_shadow_type(GTK_HANDLE_BOX(hb), GTK_SHADOW_OUT);
-    gtk_handle_box_set_snap_edge(GTK_HANDLE_BOX(hb), GTK_POS_LEFT);
-
-    gtk_container_add(GTK_CONTAINER(hb), tb);
-    gtk_widget_show(GTK_WIDGET(tb));
-
-    sigc::connection* conn = new sigc::connection;
-    g_object_set_data(G_OBJECT(hb), "event_context_connection", conn);
-
-    g_signal_connect(G_OBJECT(hb), "child_detached", G_CALLBACK(handlebox_detached), static_cast<gpointer>(0));
-    g_signal_connect(G_OBJECT(hb), "child_attached", G_CALLBACK(handlebox_attached), static_cast<gpointer>(0));
+    GtkWidget *tb = gtk_vbox_new(FALSE, 0);
 
-    return hb;
+    return toolboxNewCommon( tb, BAR_COMMANDS, GTK_POS_LEFT );
 }
 
-GtkWidget *
-sp_snap_toolbox_new()
+GtkWidget *ToolboxFactory::createSnapToolbox()
 {
     GtkWidget *tb = gtk_vbox_new(FALSE, 0);
-    gtk_box_set_spacing(GTK_BOX(tb), AUX_SPACING);
-    g_object_set_data(G_OBJECT(tb), "desktop", NULL);
-
-    //GtkWidget *tb = gtk_toolbar_new();
-    //g_object_set_data(G_OBJECT(tb), "desktop", NULL);
-
-    gtk_widget_set_sensitive(tb, FALSE);
 
-    GtkWidget *hb = gtk_handle_box_new();
-    gtk_handle_box_set_handle_position(GTK_HANDLE_BOX(hb), GTK_POS_LEFT);
-    gtk_handle_box_set_shadow_type(GTK_HANDLE_BOX(hb), GTK_SHADOW_OUT);
-    gtk_handle_box_set_snap_edge(GTK_HANDLE_BOX(hb), GTK_POS_LEFT);
-
-    gtk_container_add(GTK_CONTAINER(hb), tb);
-    gtk_widget_show(GTK_WIDGET(tb));
-
-    sigc::connection* conn = new sigc::connection;
-    g_object_set_data(G_OBJECT(hb), "event_context_connection", conn);
-
-    g_signal_connect(G_OBJECT(hb), "child_detached", G_CALLBACK(handlebox_detached), static_cast<gpointer>(0));
-    g_signal_connect(G_OBJECT(hb), "child_attached", G_CALLBACK(handlebox_attached), static_cast<gpointer>(0));
-
-    return hb;
+    return toolboxNewCommon( tb, BAR_SNAP, GTK_POS_LEFT );
 }
 
 static EgeAdjustmentAction * create_adjustment_action( gchar const *name,
@@ -1006,135 +1019,157 @@ static EgeAdjustmentAction * create_adjustment_action( gchar const *name,
 //# node editing callbacks
 //####################################
 
-/**
- * FIXME: Returns current shape_editor in context. // later eliminate this function at all!
- */
-static ShapeEditor *get_current_shape_editor()
+/** Temporary hack: Returns the node tool in the active desktop.
+ * Will go away during tool refactoring. */
+static InkNodeTool *get_node_tool()
 {
-    if (!SP_ACTIVE_DESKTOP) {
-        return NULL;
-    }
-
-    SPEventContext *event_context = (SP_ACTIVE_DESKTOP)->event_context;
-
-    if (!SP_IS_NODE_CONTEXT(event_context)) {
-        return NULL;
-    }
-
-    return event_context->shape_editor;
+    if (!SP_ACTIVE_DESKTOP) return NULL;
+    SPEventContext *ec = SP_ACTIVE_DESKTOP->event_context;
+    if (!INK_IS_NODE_TOOL(ec)) return NULL;
+    return static_cast<InkNodeTool*>(ec);
 }
 
-
 void
 sp_node_path_edit_add(void)
 {
-    ShapeEditor *shape_editor = get_current_shape_editor();
-    if (shape_editor) shape_editor->add_node();
+    InkNodeTool *nt = get_node_tool();
+    if (nt) {
+        nt->_multipath->insertNodes();
+    }
 }
 
 void
 sp_node_path_edit_delete(void)
 {
-    ShapeEditor *shape_editor = get_current_shape_editor();
-    if (shape_editor) shape_editor->delete_nodes_preserving_shape();
+    InkNodeTool *nt = get_node_tool();
+    if (nt) {
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        nt->_multipath->deleteNodes(prefs->getBool("/tools/nodes/delete_preserves_shape", true));
+    }
 }
 
 void
 sp_node_path_edit_delete_segment(void)
 {
-    ShapeEditor *shape_editor = get_current_shape_editor();
-    if (shape_editor) shape_editor->delete_segment();
+    InkNodeTool *nt = get_node_tool();
+    if (nt) {
+        nt->_multipath->deleteSegments();
+    }
 }
 
 void
 sp_node_path_edit_break(void)
 {
-    ShapeEditor *shape_editor = get_current_shape_editor();
-    if (shape_editor) shape_editor->break_at_nodes();
+    InkNodeTool *nt = get_node_tool();
+    if (nt) {
+        nt->_multipath->breakNodes();
+    }
 }
 
 void
 sp_node_path_edit_join(void)
 {
-    ShapeEditor *shape_editor = get_current_shape_editor();
-    if (shape_editor) shape_editor->join_nodes();
+    InkNodeTool *nt = get_node_tool();
+    if (nt) {
+        nt->_multipath->joinNodes();
+    }
 }
 
 void
 sp_node_path_edit_join_segment(void)
 {
-    ShapeEditor *shape_editor = get_current_shape_editor();
-    if (shape_editor) shape_editor->join_segments();
+    InkNodeTool *nt = get_node_tool();
+    if (nt) {
+        nt->_multipath->joinSegments();
+    }
 }
 
 void
 sp_node_path_edit_toline(void)
 {
-    ShapeEditor *shape_editor = get_current_shape_editor();
-    if (shape_editor) shape_editor->set_type_of_segments(NR_LINETO);
+    InkNodeTool *nt = get_node_tool();
+    if (nt) {
+        nt->_multipath->setSegmentType(Inkscape::UI::SEGMENT_STRAIGHT);
+    }
 }
 
 void
 sp_node_path_edit_tocurve(void)
 {
-    ShapeEditor *shape_editor = get_current_shape_editor();
-    if (shape_editor) shape_editor->set_type_of_segments(NR_CURVETO);
+    InkNodeTool *nt = get_node_tool();
+    if (nt) {
+        nt->_multipath->setSegmentType(Inkscape::UI::SEGMENT_CUBIC_BEZIER);
+    }
 }
 
 void
 sp_node_path_edit_cusp(void)
 {
-    ShapeEditor *shape_editor = get_current_shape_editor();
-    if (shape_editor) shape_editor->set_node_type(Inkscape::NodePath::NODE_CUSP);
+    InkNodeTool *nt = get_node_tool();
+    if (nt) {
+        nt->_multipath->setNodeType(Inkscape::UI::NODE_CUSP);
+    }
 }
 
 void
 sp_node_path_edit_smooth(void)
 {
-    ShapeEditor *shape_editor = get_current_shape_editor();
-    if (shape_editor) shape_editor->set_node_type(Inkscape::NodePath::NODE_SMOOTH);
+    InkNodeTool *nt = get_node_tool();
+    if (nt) {
+        nt->_multipath->setNodeType(Inkscape::UI::NODE_SMOOTH);
+    }
 }
 
 void
 sp_node_path_edit_symmetrical(void)
 {
-    ShapeEditor *shape_editor = get_current_shape_editor();
-    if (shape_editor) shape_editor->set_node_type(Inkscape::NodePath::NODE_SYMM);
+    InkNodeTool *nt = get_node_tool();
+    if (nt) {
+        nt->_multipath->setNodeType(Inkscape::UI::NODE_SYMMETRIC);
+    }
 }
 
 void
 sp_node_path_edit_auto(void)
 {
-    ShapeEditor *shape_editor = get_current_shape_editor();
-    if (shape_editor) shape_editor->set_node_type(Inkscape::NodePath::NODE_AUTO);
+    InkNodeTool *nt = get_node_tool();
+    if (nt) {
+        nt->_multipath->setNodeType(Inkscape::UI::NODE_AUTO);
+    }
+}
+
+static void toggle_show_transform_handles (GtkToggleAction *act, gpointer /*data*/) {
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    bool show = gtk_toggle_action_get_active( act );
+    prefs->setBool("/tools/nodes/show_transform_handles", show);
 }
 
 static void toggle_show_handles (GtkToggleAction *act, gpointer /*data*/) {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     bool show = gtk_toggle_action_get_active( act );
     prefs->setBool("/tools/nodes/show_handles",  show);
-    ShapeEditor *shape_editor = get_current_shape_editor();
-    if (shape_editor) shape_editor->show_handles(show);
 }
 
 static void toggle_show_helperpath (GtkToggleAction *act, gpointer /*data*/) {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     bool show = gtk_toggle_action_get_active( act );
-    prefs->setBool("/tools/nodes/show_helperpath",  show);
-    ShapeEditor *shape_editor = get_current_shape_editor();
-    if (shape_editor) shape_editor->show_helperpath(show);
+    prefs->setBool("/tools/nodes/show_outline",  show);
 }
 
 void sp_node_path_edit_nextLPEparam (GtkAction */*act*/, gpointer data) {
     sp_selection_next_patheffect_param( reinterpret_cast<SPDesktop*>(data) );
 }
 
-void sp_node_path_edit_clippath (GtkAction */*act*/, gpointer data) {
-    sp_selection_edit_clip_or_mask( reinterpret_cast<SPDesktop*>(data), true);
+void toggle_edit_clip (GtkToggleAction *act, gpointer /*data*/) {
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    bool edit = gtk_toggle_action_get_active( act );
+    prefs->setBool("/tools/nodes/edit_clipping_paths", edit);
 }
 
-void sp_node_path_edit_maskpath (GtkAction */*act*/, gpointer data) {
-    sp_selection_edit_clip_or_mask( reinterpret_cast<SPDesktop*>(data), false);
+void toggle_edit_mask (GtkToggleAction *act, gpointer /*data*/) {
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    bool edit = gtk_toggle_action_get_active( act );
+    prefs->setBool("/tools/nodes/edit_masks", edit);
 }
 
 /* is called when the node selection is modified */
@@ -1157,54 +1192,29 @@ sp_node_toolbox_coord_changed(gpointer /*shape_editor*/, GObject *tbl)
     UnitTracker* tracker = reinterpret_cast<UnitTracker*>( g_object_get_data( tbl, "tracker" ) );
     SPUnit const *unit = tracker->getActiveUnit();
 
-    ShapeEditor *shape_editor = get_current_shape_editor();
-    if (shape_editor && shape_editor->has_nodepath()) {
-        Inkscape::NodePath::Path *nodepath = shape_editor->get_nodepath();
-        int n_selected = 0;
-        if (nodepath) {
-            n_selected = nodepath->numSelected();
-        }
-
-        if (n_selected == 0) {
-            gtk_action_set_sensitive(xact, FALSE);
-            gtk_action_set_sensitive(yact, FALSE);
-        } else {
-            gtk_action_set_sensitive(xact, TRUE);
-            gtk_action_set_sensitive(yact, TRUE);
-            Geom::Coord oldx = sp_units_get_pixels(gtk_adjustment_get_value(xadj), *unit);
-            Geom::Coord oldy = sp_units_get_pixels(gtk_adjustment_get_value(xadj), *unit);
-
-            if (n_selected == 1) {
-                Geom::Point sel_node = nodepath->singleSelectedCoords();
-                if (oldx != sel_node[Geom::X] || oldy != sel_node[Geom::Y]) {
-                    gtk_adjustment_set_value(xadj, sp_pixels_get_units(sel_node[Geom::X], *unit));
-                    gtk_adjustment_set_value(yadj, sp_pixels_get_units(sel_node[Geom::Y], *unit));
-                }
-            } else {
-                boost::optional<Geom::Coord> x = sp_node_selected_common_coord(nodepath, Geom::X);
-                boost::optional<Geom::Coord> y = sp_node_selected_common_coord(nodepath, Geom::Y);
-                if ((x && ((*x) != oldx)) || (y && ((*y) != oldy))) {
-                    /* Note: Currently x and y will always have a value, even if the coordinates of the
-                       selected nodes don't coincide (in this case we use the coordinates of the center
-                       of the bounding box). So the entries are never set to zero. */
-                    // FIXME: Maybe we should clear the entry if several nodes are selected
-                    //        instead of providing a kind of average value
-                    gtk_adjustment_set_value(xadj, sp_pixels_get_units(x ? (*x) : 0.0, *unit));
-                    gtk_adjustment_set_value(yadj, sp_pixels_get_units(y ? (*y) : 0.0, *unit));
-                }
-            }
-        }
-    } else {
-        // no shape-editor or nodepath yet (when we just switched to the tool); coord entries must be inactive
+    InkNodeTool *nt = get_node_tool();
+    if (!nt || nt->_selected_nodes->empty()) {
+        // no path selected
         gtk_action_set_sensitive(xact, FALSE);
         gtk_action_set_sensitive(yact, FALSE);
+    } else {
+        gtk_action_set_sensitive(xact, TRUE);
+        gtk_action_set_sensitive(yact, TRUE);
+        Geom::Coord oldx = sp_units_get_pixels(gtk_adjustment_get_value(xadj), *unit);
+        Geom::Coord oldy = sp_units_get_pixels(gtk_adjustment_get_value(xadj), *unit);
+        Geom::Point mid = nt->_selected_nodes->pointwiseBounds()->midpoint();
+
+        if (oldx != mid[Geom::X])
+            gtk_adjustment_set_value(xadj, sp_pixels_get_units(mid[Geom::X], *unit));
+        if (oldy != mid[Geom::Y])
+            gtk_adjustment_set_value(yadj, sp_pixels_get_units(mid[Geom::Y], *unit));
     }
 
     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
 }
 
 static void
-sp_node_path_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_name)
+sp_node_path_value_changed(GtkAdjustment *adj, GObject *tbl, Geom::Dim2 d)
 {
     SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
@@ -1213,7 +1223,8 @@ sp_node_path_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_
     SPUnit const *unit = tracker->getActiveUnit();
 
     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
-        prefs->setDouble(Glib::ustring("/tools/nodes/") + value_name, sp_units_get_pixels(adj->value, *unit));
+        prefs->setDouble(Glib::ustring("/tools/nodes/") + (d == Geom::X ? "x" : "y"),
+            sp_units_get_pixels(adj->value, *unit));
     }
 
     // quit if run by the attr_changed listener
@@ -1224,15 +1235,13 @@ sp_node_path_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_
     // in turn, prevent listener from responding
     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE));
 
-    ShapeEditor *shape_editor = get_current_shape_editor();
-    if (shape_editor && shape_editor->has_nodepath()) {
+    InkNodeTool *nt = get_node_tool();
+    if (nt && !nt->_selected_nodes->empty()) {
         double val = sp_units_get_pixels(gtk_adjustment_get_value(adj), *unit);
-        if (!strcmp(value_name, "x")) {
-            sp_node_selected_move_absolute(shape_editor->get_nodepath(), val, Geom::X);
-        }
-        if (!strcmp(value_name, "y")) {
-            sp_node_selected_move_absolute(shape_editor->get_nodepath(), val, Geom::Y);
-        }
+        double oldval = nt->_selected_nodes->pointwiseBounds()->midpoint()[d];
+        Geom::Point delta(0,0);
+        delta[d] = val - oldval;
+        nt->_multipath->move(delta);
     }
 
     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
@@ -1241,13 +1250,13 @@ sp_node_path_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_
 static void
 sp_node_path_x_value_changed(GtkAdjustment *adj, GObject *tbl)
 {
-    sp_node_path_value_changed(adj, tbl, "x");
+    sp_node_path_value_changed(adj, tbl, Geom::X);
 }
 
 static void
 sp_node_path_y_value_changed(GtkAdjustment *adj, GObject *tbl)
 {
-    sp_node_path_value_changed(adj, tbl, "y");
+    sp_node_path_value_changed(adj, tbl, Geom::Y);
 }
 
 void
@@ -1266,26 +1275,6 @@ sp_node_toolbox_sel_changed (Inkscape::Selection *selection, GObject *tbl)
        gtk_action_set_sensitive(w, FALSE);
     }
     }
-
-    {
-    GtkAction* w = GTK_ACTION( g_object_get_data( tbl, "nodes_clippathedit" ) );
-    SPItem *item = selection->singleItem();
-    if (item && item->clip_ref && item->clip_ref->getObject()) {
-       gtk_action_set_sensitive(w, TRUE);
-    } else {
-       gtk_action_set_sensitive(w, FALSE);
-    }
-    }
-
-    {
-    GtkAction* w = GTK_ACTION( g_object_get_data( tbl, "nodes_maskedit" ) );
-    SPItem *item = selection->singleItem();
-    if (item && item->mask_ref && item->mask_ref->getObject()) {
-       gtk_action_set_sensitive(w, TRUE);
-    } else {
-       gtk_action_set_sensitive(w, FALSE);
-    }
-    }
 }
 
 void
@@ -1307,7 +1296,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
     tracker->setActiveUnit( sp_desktop_namedview(desktop)->doc_units );
     g_object_set_data( holder, "tracker", tracker );
 
-    Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
+    Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
 
     {
         InkAction* inky = ink_action_new( "NodeInsertAction",
@@ -1333,8 +1322,8 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
 
     {
         InkAction* inky = ink_action_new( "NodeJoinAction",
-                                          _("Join endnodes"),
-                                          _("Join selected endnodes"),
+                                          _("Join nodes"),
+                                          _("Join selected nodes"),
                                           INKSCAPE_ICON_NODE_JOIN,
                                           secondarySize );
         g_object_set( inky, "short_label", _("Join"), NULL );
@@ -1434,11 +1423,22 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
     }
 
     {
+        InkToggleAction* act = ink_toggle_action_new( "NodesShowTransformHandlesAction",
+                                                      _("Show Transform Handles"),
+                                                      _("Show node transformation handles"),
+                                                      "node-transform",
+                                                      secondarySize );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_show_transform_handles), desktop );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/nodes/show_transform_handles", false) );
+    }
+
+    {
         InkToggleAction* act = ink_toggle_action_new( "NodesShowHandlesAction",
                                                       _("Show Handles"),
                                                       _("Show the Bezier handles of selected nodes"),
                                                       INKSCAPE_ICON_SHOW_NODE_HANDLES,
-                                                      Inkscape::ICON_SIZE_DECORATION );
+                                                      secondarySize );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_show_handles), desktop );
         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/nodes/show_handles", true) );
@@ -1449,10 +1449,10 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
                                                       _("Show Outline"),
                                                       _("Show the outline of the path"),
                                                       INKSCAPE_ICON_SHOW_PATH_OUTLINE,
-                                                      Inkscape::ICON_SIZE_DECORATION );
+                                                      secondarySize );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_show_helperpath), desktop );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/nodes/show_helperpath", false) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/nodes/show_outline", false) );
     }
 
     {
@@ -1460,32 +1460,32 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
                                           _("Next path effect parameter"),
                                           _("Show next path effect parameter for editing"),
                                           INKSCAPE_ICON_PATH_EFFECT_PARAMETER_NEXT,
-                                          Inkscape::ICON_SIZE_DECORATION );
+                                          secondarySize );
         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_nextLPEparam), desktop );
         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
         g_object_set_data( holder, "nodes_lpeedit", inky);
     }
 
     {
-        InkAction* inky = ink_action_new( "ObjectEditClipPathAction",
-                                          _("Edit clipping path"),
-                                          _("Edit the clipping path of the object"),
+        InkToggleAction* inky = ink_toggle_action_new( "ObjectEditClipPathAction",
+                                          _("Edit clipping paths"),
+                                          _("Show editing controls for clipping paths of selected objects"),
                                           INKSCAPE_ICON_PATH_CLIP_EDIT,
-                                          Inkscape::ICON_SIZE_DECORATION );
-        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_clippath), desktop );
+                                          secondarySize );
         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
-        g_object_set_data( holder, "nodes_clippathedit", inky);
+        g_signal_connect_after( G_OBJECT(inky), "toggled", G_CALLBACK(toggle_edit_clip), desktop );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(inky), prefs->getBool("/tools/nodes/edit_clipping_paths") );
     }
 
     {
-        InkAction* inky = ink_action_new( "ObjectEditMaskPathAction",
-                                          _("Edit mask path"),
-                                          _("Edit the mask of the object"),
+        InkToggleAction* inky = ink_toggle_action_new( "ObjectEditMaskPathAction",
+                                          _("Edit masks"),
+                                          _("Show editing controls for masks of selected objects"),
                                           INKSCAPE_ICON_PATH_MASK_EDIT,
-                                          Inkscape::ICON_SIZE_DECORATION );
-        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_maskpath), desktop );
+                                          secondarySize );
         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
-        g_object_set_data( holder, "nodes_maskedit", inky);
+        g_signal_connect_after( G_OBJECT(inky), "toggled", G_CALLBACK(toggle_edit_mask), desktop );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(inky), prefs->getBool("/tools/nodes/edit_masks") );
     }
 
     /* X coord of selected node(s) */
@@ -1566,55 +1566,41 @@ static void sp_zoom_toolbox_prep(SPDesktop */*desktop*/, GtkActionGroup* /*mainA
     // no custom GtkAction setup needed
 } // end of sp_zoom_toolbox_prep()
 
-void
-sp_tool_toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop)
+void ToolboxFactory::setToolboxDesktop(GtkWidget *toolbox, SPDesktop *desktop)
 {
-    toolbox_set_desktop(toolbox,
-                        desktop,
-                        setup_tool_toolbox,
-                        update_tool_toolbox,
-                        static_cast<sigc::connection*>(g_object_get_data(G_OBJECT(toolbox),
-                                                                         "event_context_connection")));
-}
+    sigc::connection *conn = static_cast<sigc::connection*>(g_object_get_data(G_OBJECT(toolbox),
+                                                                              "event_context_connection"));
 
+    BarId id = static_cast<BarId>( GPOINTER_TO_INT(g_object_get_data(G_OBJECT(toolbox), BAR_ID_KEY)) );
 
-void
-sp_aux_toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop)
-{
-    toolbox_set_desktop(gtk_bin_get_child(GTK_BIN(toolbox)),
-                        desktop,
-                        setup_aux_toolbox,
-                        update_aux_toolbox,
-                        static_cast<sigc::connection*>(g_object_get_data(G_OBJECT(toolbox),
-                                                                         "event_context_connection")));
-}
+    SetupFunction setup_func = 0;
+    UpdateFunction update_func = 0;
 
-void
-sp_commands_toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop)
-{
-    toolbox_set_desktop(toolbox,
-                        desktop,
-                        setup_commands_toolbox,
-                        update_commands_toolbox,
-                        static_cast<sigc::connection*>(g_object_get_data(G_OBJECT(toolbox),
-                                                                         "event_context_connection")));
-}
+    switch (id) {
+        case BAR_TOOL:
+            setup_func = setup_tool_toolbox;
+            update_func = update_tool_toolbox;
+            break;
 
-void
-sp_snap_toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop)
-{
-    toolbox_set_desktop(toolbox,
-                        desktop,
-                        setup_snap_toolbox,
-                        update_snap_toolbox,
-                        static_cast<sigc::connection*>(g_object_get_data(G_OBJECT(toolbox),
-                                                                         "event_context_connection")));
-}
+        case BAR_AUX:
+            toolbox = gtk_bin_get_child(GTK_BIN(toolbox));
+            setup_func = setup_aux_toolbox;
+            update_func = update_aux_toolbox;
+            break;
 
+        case BAR_COMMANDS:
+            setup_func = setup_commands_toolbox;
+            update_func = update_commands_toolbox;
+            break;
+
+        case BAR_SNAP:
+            setup_func = setup_snap_toolbox;
+            update_func = updateSnapToolbox;
+            break;
+        default:
+            g_warning("Unexpected toolbox id encountered.");
+    }
 
-static void
-toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop, SetupFunction setup_func, UpdateFunction update_func, sigc::connection *conn)
-{
     gpointer ptr = g_object_get_data(G_OBJECT(toolbox), "desktop");
     SPDesktop *old_desktop = static_cast<SPDesktop*>(ptr);
 
@@ -1630,19 +1616,156 @@ toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop, SetupFunction setup_
 
     g_object_set_data(G_OBJECT(toolbox), "desktop", (gpointer)desktop);
 
-    if (desktop) {
+    if (desktop && setup_func && update_func) {
         gtk_widget_set_sensitive(toolbox, TRUE);
         setup_func(toolbox, desktop);
         update_func(desktop, desktop->event_context, toolbox);
-        *conn = desktop->connectEventContextChanged
-            (sigc::bind (sigc::ptr_fun(update_func), toolbox));
+        *conn = desktop->connectEventContextChanged(sigc::bind (sigc::ptr_fun(update_func), toolbox));
     } else {
         gtk_widget_set_sensitive(toolbox, FALSE);
     }
 
-} // end of toolbox_set_desktop()
+} // end of sp_toolbox_set_desktop()
 
 
+static void setupToolboxCommon( GtkWidget *toolbox,
+                                SPDesktop *desktop,
+                                gchar const *descr,
+                                gchar const* toolbarName,
+                                gchar const* sizePref )
+{
+    Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions( desktop );
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+    GtkUIManager* mgr = gtk_ui_manager_new();
+    GError* errVal = 0;
+
+    GtkOrientation orientation = GTK_ORIENTATION_HORIZONTAL;
+
+    gtk_ui_manager_insert_action_group( mgr, mainActions->gobj(), 0 );
+    gtk_ui_manager_add_ui_from_string( mgr, descr, -1, &errVal );
+
+    GtkWidget* toolBar = gtk_ui_manager_get_widget( mgr, toolbarName );
+    if ( prefs->getBool("/toolbox/icononly", true) ) {
+        gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS );
+    }
+
+    Inkscape::IconSize toolboxSize = ToolboxFactory::prefToSize(sizePref);
+    gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), static_cast<GtkIconSize>(toolboxSize) );
+
+    if (GTK_IS_HANDLE_BOX(toolbox)) {
+        // g_message("GRABBING ORIENTATION   [%s]", toolbarName);
+        GtkPositionType pos = gtk_handle_box_get_handle_position(GTK_HANDLE_BOX(toolbox));
+        orientation = ((pos == GTK_POS_LEFT) || (pos == GTK_POS_RIGHT)) ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL;
+    } else {
+        GtkPositionType pos = static_cast<GtkPositionType>(GPOINTER_TO_INT(g_object_get_data( G_OBJECT(toolbox), HANDLE_POS_MARK )));
+        orientation = ((pos == GTK_POS_LEFT) || (pos == GTK_POS_RIGHT)) ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL;
+    }
+    gtk_toolbar_set_orientation(GTK_TOOLBAR(toolBar), orientation);
+    gtk_toolbar_set_show_arrow(GTK_TOOLBAR(toolBar), TRUE);
+
+    g_object_set_data(G_OBJECT(toolBar), "desktop", NULL);
+
+    GtkWidget* child = gtk_bin_get_child(GTK_BIN(toolbox));
+    if ( child ) {
+        gtk_container_remove( GTK_CONTAINER(toolbox), child );
+    }
+
+    gtk_container_add( GTK_CONTAINER(toolbox), toolBar );
+}
+
+#define noDUMP_DETAILS 1
+
+void ToolboxFactory::setOrientation(GtkWidget* toolbox, GtkOrientation orientation)
+{
+#if DUMP_DETAILS
+    g_message("Set orientation for %p to be %d", toolbox, orientation);
+    GType type = GTK_WIDGET_TYPE(toolbox);
+    g_message("        [%s]", g_type_name(type));
+    g_message("             %p", g_object_get_data(G_OBJECT(toolbox), BAR_ID_KEY));
+#endif
+
+    GtkPositionType pos = (orientation == GTK_ORIENTATION_HORIZONTAL) ? GTK_POS_LEFT : GTK_POS_TOP;
+    GtkHandleBox* handleBox = 0;
+
+    if (GTK_IS_BIN(toolbox)) {
+#if DUMP_DETAILS
+        g_message("            is a BIN");
+#endif // DUMP_DETAILS
+        GtkWidget* child = gtk_bin_get_child(GTK_BIN(toolbox));
+        if (child) {
+#if DUMP_DETAILS
+            GType type2 = GTK_WIDGET_TYPE(child);
+            g_message("            child    [%s]", g_type_name(type2));
+#endif // DUMP_DETAILS
+
+            if (GTK_IS_BOX(child)) {
+#if DUMP_DETAILS
+                g_message("                is a BOX");
+#endif // DUMP_DETAILS
+
+                GList* children = gtk_container_get_children(GTK_CONTAINER(child));
+                if (children) {
+                    for (GList* curr = children; curr; curr = g_list_next(curr)) {
+                        GtkWidget* child2 = GTK_WIDGET(curr->data);
+#if DUMP_DETAILS
+                        GType type3 = GTK_WIDGET_TYPE(child2);
+                        g_message("                child2   [%s]", g_type_name(type3));
+#endif // DUMP_DETAILS
+
+                        if (GTK_IS_CONTAINER(child2)) {
+                            GList* children2 = gtk_container_get_children(GTK_CONTAINER(child2));
+                            if (children2) {
+                                for (GList* curr2 = children2; curr2; curr2 = g_list_next(curr2)) {
+                                    GtkWidget* child3 = GTK_WIDGET(curr2->data);
+#if DUMP_DETAILS
+                                    GType type4 = GTK_WIDGET_TYPE(child3);
+                                    g_message("                    child3   [%s]", g_type_name(type4));
+#endif // DUMP_DETAILS
+                                    if (GTK_IS_TOOLBAR(child3)) {
+                                        GtkToolbar* childBar = GTK_TOOLBAR(child3);
+                                        gtk_toolbar_set_orientation(childBar, orientation);
+                                    }
+                                }
+                                g_list_free(children2);
+                            }
+                        }
+
+
+                        if (GTK_IS_TOOLBAR(child2)) {
+                            GtkToolbar* childBar = GTK_TOOLBAR(child2);
+                            gtk_toolbar_set_orientation(childBar, orientation);
+                            if (GTK_IS_HANDLE_BOX(toolbox)) {
+                                handleBox = GTK_HANDLE_BOX(toolbox);
+                            }
+                        } else {
+                            g_message("need to add dynamic switch");
+                        }
+                    }
+                    g_list_free(children);
+                } else {
+                    // The call is being made before the toolbox proper has been setup.
+                    if (GTK_IS_HANDLE_BOX(toolbox)) {
+                        handleBox = GTK_HANDLE_BOX(toolbox);
+                    } else {
+                        g_object_set_data(G_OBJECT(toolbox), HANDLE_POS_MARK, GINT_TO_POINTER(pos));
+                    }
+                }
+            } else if (GTK_IS_TOOLBAR(child)) {
+                GtkToolbar* toolbar = GTK_TOOLBAR(child);
+                gtk_toolbar_set_orientation( toolbar, orientation );
+                if (GTK_IS_HANDLE_BOX(toolbox)) {
+                    handleBox = GTK_HANDLE_BOX(toolbox);
+                }
+            }
+        }
+    }
+
+    if (handleBox) {
+        gtk_handle_box_set_handle_position(handleBox, pos);
+    }
+}
+
 static void
 setup_tool_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
 {
@@ -1671,36 +1794,12 @@ setup_tool_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
         "    <toolitem action='ToolDropper' />"
         "  </toolbar>"
         "</ui>";
-    Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions( desktop );
-    GtkUIManager* mgr = gtk_ui_manager_new();
-    GError* errVal = 0;
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-
-    gtk_ui_manager_insert_action_group( mgr, mainActions->gobj(), 0 );
-    gtk_ui_manager_add_ui_from_string( mgr, descr, -1, &errVal );
 
-    GtkWidget* toolBar = gtk_ui_manager_get_widget( mgr, "/ui/ToolToolbar" );
-    if ( prefs->getBool("/toolbox/icononly", true) ) {
-        gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS );
-    }
-    Inkscape::IconSize toolboxSize = prefToSize("/toolbox/tools/small");
-    gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), (GtkIconSize)toolboxSize );
-
-    gtk_toolbar_set_orientation(GTK_TOOLBAR(toolBar), GTK_ORIENTATION_VERTICAL);
-    gtk_toolbar_set_show_arrow(GTK_TOOLBAR(toolBar), TRUE);
-
-    g_object_set_data(G_OBJECT(toolBar), "desktop", NULL);
-
-    GtkWidget* child = gtk_bin_get_child(GTK_BIN(toolbox));
-    if ( child ) {
-        gtk_container_remove( GTK_CONTAINER(toolbox), child );
-    }
-
-    gtk_container_add( GTK_CONTAINER(toolbox), toolBar );
-//     Inkscape::IconSize toolboxSize = prefToSize("/toolbox/tools/small");
+    setupToolboxCommon( toolbox, desktop, descr,
+                        "/ui/ToolToolbar",
+                        "/toolbox/tools/small");
 }
 
-
 static void
 update_tool_toolbox( SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget */*toolbox*/ )
 {
@@ -1746,9 +1845,9 @@ setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
         } else {
 
             GtkWidget *sub_toolbox = 0;
-            if (aux_toolboxes[i].create_func == NULL)
+            if (aux_toolboxes[i].create_func == NULL) {
                 sub_toolbox = sp_empty_toolbox_new(desktop);
-            else {
+            } else {
                 sub_toolbox = aux_toolboxes[i].create_func(desktop);
             }
 
@@ -1779,7 +1878,7 @@ setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
                 gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS );
             }
 
-            Inkscape::IconSize toolboxSize = prefToSize("/toolbox/small");
+            Inkscape::IconSize toolboxSize = ToolboxFactory::prefToSize("/toolbox/small");
             gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), static_cast<GtkIconSize>(toolboxSize) );
 
             gtk_table_attach( GTK_TABLE(holder), toolBar, 0, 1, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0 );
@@ -1863,37 +1962,16 @@ setup_commands_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
         "    <separator />"
         "    <toolitem action='DialogPreferences' />"
         "    <toolitem action='DialogDocumentProperties' />"
+#if ENABLE_TASK_SUPPORT
+        "    <separator />"
+        "    <toolitem action='TaskSetAction' />"
+#endif // ENABLE_TASK_SUPPORT
         "  </toolbar>"
         "</ui>";
-    Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions( desktop );
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
-    GtkUIManager* mgr = gtk_ui_manager_new();
-    GError* errVal = 0;
-
-    gtk_ui_manager_insert_action_group( mgr, mainActions->gobj(), 0 );
-    gtk_ui_manager_add_ui_from_string( mgr, descr, -1, &errVal );
-
-    GtkWidget* toolBar = gtk_ui_manager_get_widget( mgr, "/ui/CommandsToolbar" );
-    if ( prefs->getBool("/toolbox/icononly", true) ) {
-        gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS );
-    }
-
-    Inkscape::IconSize toolboxSize = prefToSize("/toolbox/small");
-    gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), (GtkIconSize)toolboxSize );
-
-    gtk_toolbar_set_orientation(GTK_TOOLBAR(toolBar), GTK_ORIENTATION_HORIZONTAL);
-    gtk_toolbar_set_show_arrow(GTK_TOOLBAR(toolBar), TRUE);
-
-
-    g_object_set_data(G_OBJECT(toolBar), "desktop", NULL);
-
-    GtkWidget* child = gtk_bin_get_child(GTK_BIN(toolbox));
-    if ( child ) {
-        gtk_container_remove( GTK_CONTAINER(toolbox), child );
-    }
-
-    gtk_container_add( GTK_CONTAINER(toolbox), toolBar );
+    setupToolboxCommon( toolbox, desktop, descr,
+                        "/ui/CommandsToolbar",
+                        "/toolbox/small" );
 }
 
 static void
@@ -2017,7 +2095,6 @@ void toggle_snap_callback (GtkToggleAction *act, gpointer data) { //data points
 
 void setup_snap_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
 {
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions(desktop);
 
     gchar const * descr =
@@ -2047,7 +2124,7 @@ void setup_snap_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
         "  </toolbar>"
         "</ui>";
 
-    Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
+    Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
 
     {
         InkToggleAction* act = ink_toggle_action_new("ToggleSnapGlobal",
@@ -2212,42 +2289,41 @@ void setup_snap_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
       g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
       }*/
 
-    GtkUIManager* mgr = gtk_ui_manager_new();
-    GError* errVal = 0;
-
-    gtk_ui_manager_insert_action_group( mgr, mainActions->gobj(), 0 );
-    gtk_ui_manager_add_ui_from_string( mgr, descr, -1, &errVal );
-
-    GtkWidget* toolBar = gtk_ui_manager_get_widget( mgr, "/ui/SnapToolbar" );
-    if ( prefs->getBool("/toolbox/icononly", true) ) {
-        gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS );
-    }
-
-    Inkscape::IconSize toolboxSize = prefToSize("/toolbox/secondary");
-    gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), static_cast<GtkIconSize>(toolboxSize) );
-
-    gtk_toolbar_set_orientation(GTK_TOOLBAR(toolBar), GTK_ORIENTATION_HORIZONTAL);
-    gtk_toolbar_set_show_arrow(GTK_TOOLBAR(toolBar), TRUE);
-
-    g_object_set_data(G_OBJECT(toolBar), "desktop", NULL);
+    setupToolboxCommon( toolbox, desktop, descr,
+                        "/ui/SnapToolbar",
+                        "/toolbox/secondary" );
+}
 
-    GtkWidget* child = gtk_bin_get_child(GTK_BIN(toolbox));
-    if ( child ) {
-        gtk_container_remove( GTK_CONTAINER(toolbox), child );
+Glib::ustring ToolboxFactory::getToolboxName(GtkWidget* toolbox)
+{
+    Glib::ustring name;
+    BarId id = static_cast<BarId>( GPOINTER_TO_INT(g_object_get_data(G_OBJECT(toolbox), BAR_ID_KEY)) );
+    switch(id) {
+        case BAR_TOOL:
+            name = "ToolToolbar";
+            break;
+        case BAR_AUX:
+            name = "AuxToolbar";
+            break;
+        case BAR_COMMANDS:
+            name = "CommandsToolbar";
+            break;
+        case BAR_SNAP:
+            name = "SnapToolbar";
+            break;
     }
 
-    gtk_container_add( GTK_CONTAINER(toolbox), toolBar );
-
+    return name;
 }
 
-void update_snap_toolbox(SPDesktop *desktop, SPEventContext */*eventcontext*/, GtkWidget *toolbox)
+void ToolboxFactory::updateSnapToolbox(SPDesktop *desktop, SPEventContext */*eventcontext*/, GtkWidget *toolbox)
 {
     g_assert(desktop != NULL);
     g_assert(toolbox != NULL);
 
     SPNamedView *nv = sp_desktop_namedview(desktop);
     if (nv == NULL) {
-        g_warning("Namedview cannot be retrieved (in update_snap_toolbox)!");
+        g_warning("Namedview cannot be retrieved (in updateSnapToolbox)!");
         return;
     }
 
@@ -2332,7 +2408,7 @@ void update_snap_toolbox(SPDesktop *desktop, SPEventContext */*eventcontext*/, G
     g_object_set_data(G_OBJECT(toolbox), "freeze", GINT_TO_POINTER(FALSE)); // unfreeze (see above)
 }
 
-void show_aux_toolbox(GtkWidget *toolbox_toplevel)
+void ToolboxFactory::showAuxToolbox(GtkWidget *toolbox_toplevel)
 {
     gtk_widget_show(toolbox_toplevel);
     GtkWidget *toolbox = gtk_bin_get_child(GTK_BIN(toolbox_toplevel));
@@ -2346,8 +2422,7 @@ void show_aux_toolbox(GtkWidget *toolbox_toplevel)
     gtk_widget_show_all(shown_toolbox);
 }
 
-static GtkWidget *
-sp_empty_toolbox_new(SPDesktop *desktop)
+static GtkWidget *sp_empty_toolbox_new(SPDesktop *desktop)
 {
     GtkWidget *tbl = gtk_toolbar_new();
     gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
@@ -2728,7 +2803,7 @@ sp_toolbox_add_label(GtkWidget *tbl, gchar const *title, bool wide)
 
 static void sp_star_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
 {
-    Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
+    Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
 
     {
         EgeOutputAction* act = ege_output_action_new( "StarStateAction", _("<b>New:</b>"), "", 0 );
@@ -3097,7 +3172,7 @@ sp_rect_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
 static void sp_rect_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
 {
     EgeAdjustmentAction* eact = 0;
-    Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
+    Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
 
     {
         EgeOutputAction* act = ege_output_action_new( "RectStateAction", _("<b>New:</b>"), "", 0 );
@@ -3461,7 +3536,7 @@ static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions,
         box3d_angle_x = eact;
     }
 
-    if (!persp3d_VP_is_finite(persp_impl, Proj::X)) {
+    if (!persp_impl || !persp3d_VP_is_finite(persp_impl, Proj::X)) {
         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
     } else {
         gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
@@ -3501,7 +3576,7 @@ static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions,
         box3d_angle_y = eact;
     }
 
-    if (!persp3d_VP_is_finite(persp_impl, Proj::Y)) {
+    if (!persp_impl || !persp3d_VP_is_finite(persp_impl, Proj::Y)) {
         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
     } else {
         gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
@@ -3540,7 +3615,7 @@ static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions,
         box3d_angle_z = eact;
     }
 
-    if (!persp3d_VP_is_finite(persp_impl, Proj::Z)) {
+    if (!persp_impl || !persp3d_VP_is_finite(persp_impl, Proj::Z)) {
         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
     } else {
         gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
@@ -3739,7 +3814,7 @@ sp_spiral_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl
 static void sp_spiral_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
 {
     EgeAdjustmentAction* eact = 0;
-    Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
+    Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
 
     {
         EgeOutputAction* act = ege_output_action_new( "SpiralStateAction", _("<b>New:</b>"), "", 0 );
@@ -3846,7 +3921,7 @@ static void sp_add_freehand_mode_toggle(GtkActionGroup* mainActions, GObject* ho
     {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
         guint freehandMode = prefs->getInt(( tool_is_pencil ? "/tools/freehand/pencil/freehand-mode" : "/tools/freehand/pen/freehand-mode" ), 0);
-        Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
+        Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
 
         {
             GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
@@ -4140,7 +4215,7 @@ static void tweak_toggle_doo (GtkToggleAction *act, gpointer /*data*/) {
 
 static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
 {
-    Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
+    Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
     {
@@ -4454,7 +4529,7 @@ static void sp_spray_scale_value_changed( GtkAdjustment *adj, GObject */*tbl*/ )
 
 static void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
 {
-    Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
+    Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
     {
@@ -4561,6 +4636,7 @@ static void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction
                                                               1, 100, 1.0, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
                                                               sp_spray_population_value_changed,  1, 0 );
+        ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
         g_object_set_data( holder, "spray_population", eact );
@@ -4583,12 +4659,14 @@ static void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction
         gdouble values[] = {10, 25, 35, 50, 60, 80, 100};
         EgeAdjustmentAction *eact = create_adjustment_action( "SprayRotationAction",
                                                               _("Rotation"), _("Rotation:"),
+                                                              // xgettext:no-c-format
                                                               _("Variation of the rotation of the sprayed objects. 0% for the same rotation than the original object."),
                                                               "/tools/spray/rotation_variation", 0,
                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "spray-rotation",
                                                               0, 100, 1.0, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
                                                               sp_spray_rotation_value_changed,  1, 0 );
+        ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
         g_object_set_data( holder, "spray_rotation", eact );
@@ -4599,12 +4677,14 @@ static void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction
         gdouble values[] = {10, 25, 35, 50, 60, 80, 100};
         EgeAdjustmentAction *eact = create_adjustment_action( "SprayScaleAction",
                                                               _("Scale"), _("Scale:"),
+                                                              // xgettext:no-c-format
                                                               _("Variation in the scale of the sprayed objects. 0% for the same scale than the original object."),
                                                               "/tools/spray/scale_variation", 0,
                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "spray-scale",
                                                               0, 100, 1.0, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
                                                               sp_spray_scale_value_changed,  1, 0 );
+        ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
         g_object_set_data( holder, "spray_scale", eact );
@@ -5396,7 +5476,7 @@ static void sp_arc_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions,
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
     EgeAdjustmentAction* eact = 0;
-    Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
+    Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
 
 
     {
@@ -6660,10 +6740,10 @@ sp_text_toolbox_family_keypress (GtkWidget */*w*/, GdkEventKey *event, GObject *
         case GDK_Return:
             // unfreeze and update, which will defocus
             g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
-            sp_text_toolbox_family_changed (NULL, tbl);
+            sp_text_toolbox_family_changed (NULL, tbl); 
             return TRUE; // I consumed the event
             break;
-        case GDK_Escape:
+        case GDK_Escape: 
             // defocus
             gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas));
             return TRUE; // I consumed the event
@@ -6939,10 +7019,10 @@ void sp_text_toolbox_family_popnotify(GtkComboBox *widget,
                          }
 
                          // update
-                         sp_text_toolbox_family_changed (NULL, tbl);
+                         sp_text_toolbox_family_changed (NULL, tbl); 
                          break;
                      }
-                 }
+                 } 
              }
          }
 
@@ -6954,11 +7034,10 @@ void sp_text_toolbox_family_popnotify(GtkComboBox *widget,
   }
 }
 
-GtkWidget*
-sp_text_toolbox_new (SPDesktop *desktop)
+GtkWidget *sp_text_toolbox_new (SPDesktop *desktop)
 {
     GtkToolbar   *tbl = GTK_TOOLBAR(gtk_toolbar_new());
-    GtkIconSize secondarySize = static_cast<GtkIconSize>(prefToSize("/toolbox/secondary", 1));
+    GtkIconSize secondarySize = static_cast<GtkIconSize>(ToolboxFactory::prefToSize("/toolbox/secondary", 1));
 
     gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
     gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop);
@@ -6981,7 +7060,7 @@ sp_text_toolbox_new (SPDesktop *desktop)
     g_signal_connect (G_OBJECT (font_sel->gobj()), "key-press-event", G_CALLBACK(sp_text_toolbox_family_list_keypress), tbl);
 
     cbe_add_completion(font_sel->gobj(), G_OBJECT(tbl));
-
+    
     gtk_toolbar_append_widget( tbl, (GtkWidget*) font_sel->gobj(), "", "");
     g_object_set_data (G_OBJECT (tbl), "family-entry-combo", font_sel);
 
@@ -6994,7 +7073,7 @@ sp_text_toolbox_new (SPDesktop *desktop)
     g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (sp_text_toolbox_family_changed), tbl);
 
     g_signal_connect (G_OBJECT (font_sel->gobj()), "changed", G_CALLBACK (sp_text_toolbox_family_changed), tbl);
-    g_signal_connect (G_OBJECT (font_sel->gobj()), "notify::popup-shown",
+    g_signal_connect (G_OBJECT (font_sel->gobj()), "notify::popup-shown", 
              G_CALLBACK (sp_text_toolbox_family_popnotify), tbl);
     g_signal_connect (G_OBJECT (entry), "key-press-event", G_CALLBACK(sp_text_toolbox_family_keypress), tbl);
     g_signal_connect (G_OBJECT (entry),  "focus-in-event", G_CALLBACK (sp_text_toolbox_entry_focus_in), tbl);
@@ -7317,7 +7396,7 @@ static void connector_spacing_changed(GtkAdjustment *adj, GObject* tbl)
 
     if ( !repr->attribute("inkscape:connector-spacing") &&
             ( adj->value == defaultConnSpacing )) {
-        // Don't need to update the repr if the attribute doesn't
+        // Don't need to update the repr if the attribute doesn't 
         // exist and it is being set to the default value -- as will
         // happen at startup.
         return;
@@ -7455,7 +7534,7 @@ static void sp_connector_toolbox_selection_changed(Inkscape::Selection *selectio
 static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
+    Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
 
     // Editing mode toggle button
     {
@@ -7567,8 +7646,7 @@ static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainA
         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act), ( tbuttonstate ? TRUE : FALSE ));
 
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_directed_graph_layout_toggled), holder );
-        sigc::connection *connection = new sigc::connection(sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_connector_toolbox_selection_changed), (GObject *)holder))
-        );
+        sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_connector_toolbox_selection_changed), (GObject *)holder));
     }
 
     // Avoid overlaps toggle button
diff --git a/src/widgets/toolbox.h b/src/widgets/toolbox.h
index 4bc417e8f..2e4b2958a 100644
--- a/src/widgets/toolbox.h
+++ b/src/widgets/toolbox.h
@@ -7,6 +7,7 @@
  * Authors:
  *   Lauris Kaplinski <lauris@kaplinski.com>
  *   Frank Felfe <innerspace@iname.com>
+ *   Jon A. Cruz <jon@joncruz.org>
  *
  * Copyright (C) 1999-2002 Authors
  * Copyright (C) 2001-2002 Ximian, Inc.
@@ -16,38 +17,45 @@
 
 #include <gtk/gtkstyle.h>
 #include <gtk/gtktooltips.h>
+#include <glibmm/ustring.h>
 
 #include "forward.h"
 #include "icon-size.h"
 
-GtkWidget *sp_tool_toolbox_new ();
-void sp_tool_toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop);
+namespace Inkscape {
+namespace UI {
 
-GtkWidget *sp_aux_toolbox_new ();
-void sp_aux_toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop);
+class ToolboxFactory
+{
+public:
+    static void setToolboxDesktop(GtkWidget *toolbox, SPDesktop *desktop);
+    static void setOrientation(GtkWidget* toolbox, GtkOrientation orientation);
+    static void showAuxToolbox(GtkWidget* toolbox);
 
-GtkWidget *sp_commands_toolbox_new ();
-void sp_commands_toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop);
+    static GtkWidget *createToolToolbox();
+    static GtkWidget *createAuxToolbox();
+    static GtkWidget *createCommandsToolbox();
+    static GtkWidget *createSnapToolbox();
 
-GtkWidget *sp_snap_toolbox_new ();
-void sp_snap_toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop);
-void update_snap_toolbox(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox);
-void setup_snap_toolbox (GtkWidget *toolbox, SPDesktop *desktop);
+    static Glib::ustring getToolboxName(GtkWidget* toolbox);
 
-void show_aux_toolbox(GtkWidget *toolbox);
+    static void updateSnapToolbox(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox);
 
-GtkWidget *sp_toolbox_button_normal_new_from_verb(GtkWidget *t,
-                                                  Inkscape::IconSize size,
-                                                  Inkscape::Verb * verb,
-                                                  Inkscape::UI::View::View *view,
-                                                  GtkTooltips *tt);
+    static Inkscape::IconSize prefToSize(Glib::ustring const &path, int base = 0 );
+
+private:
+    ToolboxFactory();
+};
+
+} // namespace UI
+} // namespace Inkscape
 
-void aux_toolbox_space(GtkWidget *tb, gint space);
 
 // utility
+
+// TODO remove this:
 void sp_toolbox_add_label(GtkWidget *tbl, gchar const *title, bool wide = true);
 
-Inkscape::IconSize prefToSize(Glib::ustring const &path, int base = 0 );
 
 #endif /* !SEEN_TOOLBOX_H */