derive all toolbars from Inkscape::Toolbar

45 files changed, 7252 insertions, 6201 deletions

diff --git a/src/ui/toolbar/arc-toolbar.cpp b/src/ui/toolbar/arc-toolbar.cpp
index 4f31d0ea8..7c75b63bb 100644
--- a/src/ui/toolbar/arc-toolbar.cpp
+++ b/src/ui/toolbar/arc-toolbar.cpp
@@ -60,60 +60,237 @@ using Inkscape::UI::PrefPusher;
 using Inkscape::Util::Quantity;
 using Inkscape::Util::unit_table;
 
-//########################
-//##    Circle / Arc    ##
-//########################
 
-static void sp_arctb_sensitivize( GObject *tbl, double v1, double v2 )
+static Inkscape::XML::NodeEventVector arc_tb_repr_events = {
+    nullptr, /* child_added */
+    nullptr, /* child_removed */
+    Inkscape::UI::Toolbar::ArcToolbar::event_attr_changed,
+    nullptr, /* content_changed */
+    nullptr  /* order_changed */
+};
+
+namespace Inkscape {
+namespace UI {
+namespace Toolbar {
+ArcToolbar::ArcToolbar(SPDesktop *desktop) :
+        Toolbar(desktop),
+        _tracker(new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR)),
+        _freeze(false),
+        _repr(nullptr)
 {
-    Gtk::Action *ocb = static_cast<Gtk::Action*>( g_object_get_data( tbl, "type_action" ) );
-    GtkAction *make_whole = GTK_ACTION( g_object_get_data( tbl, "make_whole" ) );
+    _tracker->setActiveUnit(unit_table.getUnit("px"));
+}
 
-    if (v1 == 0 && v2 == 0) {
-        if (g_object_get_data( tbl, "single" )) { // only for a single selected ellipse (for now)
-            ocb->set_sensitive(false);
-            gtk_action_set_sensitive( make_whole, FALSE );
-        }
-    } else {
-        ocb->set_sensitive(true);
-        gtk_action_set_sensitive( make_whole, TRUE );
+ArcToolbar::~ArcToolbar()
+{
+    if(_repr) {
+        _repr->removeListenerByData(this);
+        GC::release(_repr);
+        _repr = nullptr;
+    }
+}
+
+GtkWidget *
+ArcToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
+{
+    auto toolbar = new ArcToolbar(desktop);
+
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+    GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
+    EgeAdjustmentAction* eact = nullptr;
+
+    {
+        toolbar->_mode_action = ege_output_action_new( "ArcStateAction", _("<b>New:</b>"), "", nullptr );
+        ege_output_action_set_use_markup( toolbar->_mode_action, TRUE );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_mode_action ) );
+    }
+
+    /* Radius X */
+    {
+        gchar const* labels[] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
+        gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
+        toolbar->_rx_action = create_adjustment_action( "ArcRadiusXAction",
+                                                        _("Horizontal radius"), _("Rx:"), _("Horizontal radius of the circle, ellipse, or arc"),
+                                                        "/tools/shapes/arc/rx", 0,
+                                                        GTK_WIDGET(desktop->canvas),
+                                                        nullptr, // dataKludge
+                                                        TRUE, "altx-arc",
+                                                        0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
+                                                        labels, values, G_N_ELEMENTS(labels),
+                                                        nullptr, // callback
+                                                        toolbar->_tracker);
+        toolbar->_rx_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_rx_action));
+        toolbar->_rx_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*toolbar, &ArcToolbar::value_changed),
+                                                                    toolbar->_rx_adj, "rx"));
+        gtk_action_set_sensitive( GTK_ACTION(toolbar->_rx_action), FALSE );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_rx_action) );
+    }
+
+    /* Radius Y */
+    {
+        gchar const* labels[] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
+        gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
+        toolbar->_ry_action = create_adjustment_action( "ArcRadiusYAction",
+                                                        _("Vertical radius"), _("Ry:"), _("Vertical radius of the circle, ellipse, or arc"),
+                                                        "/tools/shapes/arc/ry", 0,
+                                                        GTK_WIDGET(desktop->canvas),
+                                                        nullptr, // dataKludge
+                                                        FALSE, nullptr,
+                                                        0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
+                                                        labels, values, G_N_ELEMENTS(labels),
+                                                        nullptr, // callback
+                                                        toolbar->_tracker);
+        toolbar->_ry_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_ry_action));
+        toolbar->_ry_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*toolbar, &ArcToolbar::value_changed),
+                                                                    toolbar->_ry_adj, "ry"));
+        gtk_action_set_sensitive( GTK_ACTION(toolbar->_ry_action), FALSE );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_ry_action) );
+    }
+
+    // add the units menu
+    {
+        Gtk::Action* act = toolbar->_tracker->createAction( "ArcUnitsAction", _("Units"), ("") );
+        gtk_action_group_add_action( mainActions, act->gobj() );
+    }
+
+    /* Start */
+    {
+        eact = create_adjustment_action( "ArcStartAction",
+                                         _("Start"), _("Start:"),
+                                         _("The angle (in degrees) from the horizontal to the arc's start point"),
+                                         "/tools/shapes/arc/start", 0.0,
+                                         GTK_WIDGET(desktop->canvas),
+                                         nullptr,
+                                         TRUE, "altx-arc",
+                                         -360.0, 360.0, 1.0, 10.0,
+                                         nullptr, nullptr, 0,
+                                         nullptr // callback
+                                         );
+        toolbar->_start_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+    }
+
+    /* End */
+    {
+        eact = create_adjustment_action( "ArcEndAction",
+                                         _("End"), _("End:"),
+                                         _("The angle (in degrees) from the horizontal to the arc's end point"),
+                                         "/tools/shapes/arc/end", 0.0,
+                                         GTK_WIDGET(desktop->canvas),
+                                         nullptr, // dataKludge
+                                         FALSE, nullptr,
+                                         -360.0, 360.0, 1.0, 10.0,
+                                         nullptr, nullptr, 0,
+                                         nullptr // callback
+                                         );
+        toolbar->_end_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+    }
+    toolbar->_start_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*toolbar, &ArcToolbar::startend_value_changed),
+                                                                   toolbar->_start_adj, "start", toolbar->_end_adj));
+    toolbar->_end_adj->signal_value_changed().connect(  sigc::bind(sigc::mem_fun(*toolbar, &ArcToolbar::startend_value_changed),
+                                                                   toolbar->_end_adj,   "end",   toolbar->_start_adj));
+
+    /* Arc: Slice, Arc, Chord */
+    {
+        InkSelectOneActionColumns columns;
+
+        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
+
+        Gtk::TreeModel::Row row;
+
+        row = *(store->append());
+        row[columns.col_label    ] = _("Slice");
+        row[columns.col_tooltip  ] = _("Switch to slice (closed shape with two radii)"),
+        row[columns.col_icon     ] = INKSCAPE_ICON("draw-ellipse-segment");
+        row[columns.col_sensitive] = true;
+
+        row = *(store->append());
+        row[columns.col_label    ] = _("Arc (Open)");
+        row[columns.col_tooltip  ] = _("Switch to arc (unclosed shape)");
+        row[columns.col_icon     ] = INKSCAPE_ICON("draw-ellipse-arc");
+        row[columns.col_sensitive] = true;
+
+        row = *(store->append());
+        row[columns.col_label    ] = _("Chord");
+        row[columns.col_tooltip  ] = _("Switch to chord (closed shape)"),
+        row[columns.col_icon     ] = INKSCAPE_ICON("draw-ellipse-chord");
+        row[columns.col_sensitive] = true;
+
+        toolbar->_type_action =
+            InkSelectOneAction::create( "ArcTypeAction",   // Name
+                                        "",                // Label
+                                        "",                // Tooltip
+                                        "Not Used",        // Icon
+                                        store );           // Tree store
+
+        toolbar->_type_action->use_radio( true );
+        toolbar->_type_action->use_group_label( false );
+        gint type = prefs->getInt("/tools/shapes/arc/arc_type", 0);
+        toolbar->_type_action->set_active( type );
+
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_type_action->gobj() ));
+
+        toolbar->_type_action->signal_changed().connect(sigc::mem_fun(*toolbar, &ArcToolbar::type_changed));
     }
+
+    /* Make Whole */
+    {
+        toolbar->_make_whole = ink_action_new( "ArcResetAction",
+                                               _("Make whole"),
+                                               _("Make the shape a whole ellipse, not arc or segment"),
+                                               INKSCAPE_ICON("draw-ellipse-whole"),
+                                               secondarySize );
+        g_signal_connect_after( G_OBJECT(toolbar->_make_whole), "activate", G_CALLBACK(ArcToolbar::defaults), toolbar );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_make_whole) );
+        gtk_action_set_sensitive( GTK_ACTION(toolbar->_make_whole), TRUE );
+    }
+
+    toolbar->_single = true;
+    // sensitivize make whole and open checkbox
+    {
+        toolbar->sensitivize( toolbar->_start_adj->get_value(), toolbar->_end_adj->get_value() );
+    }
+
+    desktop->connectEventContextChanged(sigc::mem_fun(*toolbar, &ArcToolbar::check_ec));
+
+    return GTK_WIDGET(toolbar->gobj());
 }
 
-static void sp_arctb_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_name)
+void
+ArcToolbar::value_changed(Glib::RefPtr<Gtk::Adjustment>&  adj,
+                          gchar const                    *value_name)
 {
     // Per SVG spec "a [radius] value of zero disables rendering of the element".
     // However our implementation does not allow a setting of zero in the UI (not even in the XML editor)
     // and ugly things happen if it's forced here, so better leave the properties untouched.
-    if (!gtk_adjustment_get_value(adj)) {
+    if (!adj->get_value()) {
         return;
     }
 
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( tbl, "desktop" ));
-
-    UnitTracker* tracker = reinterpret_cast<UnitTracker*>(g_object_get_data( tbl, "tracker" ));
-    Unit const *unit = tracker->getActiveUnit();
+    Unit const *unit = _tracker->getActiveUnit();
     g_return_if_fail(unit != nullptr);
 
-    SPDocument* document = desktop->getDocument();
+    SPDocument* document = _desktop->getDocument();
     Geom::Scale scale = document->getDocumentScale();
 
     if (DocumentUndo::getUndoSensitive(document)) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
         prefs->setDouble(Glib::ustring("/tools/shapes/arc/") + value_name,
-            Quantity::convert(gtk_adjustment_get_value(adj), unit, "px"));
+            Quantity::convert(adj->get_value(), unit, "px"));
     }
 
     // quit if run by the attr_changed listener
-    if (g_object_get_data( tbl, "freeze" ) || tracker->isUpdating()) {
+    if (_freeze || _tracker->isUpdating()) {
         return;
     }
 
     // in turn, prevent listener from responding
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE));
+    _freeze = true;
 
     bool modmade = false;
-    Inkscape::Selection *selection = desktop->getSelection();
+    Inkscape::Selection *selection = _desktop->getSelection();
     auto itemlist= selection->items();
     for(auto i=itemlist.begin();i!=itemlist.end();++i){
         SPItem *item = *i;
@@ -122,9 +299,9 @@ static void sp_arctb_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const
             SPGenericEllipse *ge = SP_GENERICELLIPSE(item);
 
             if (!strcmp(value_name, "rx")) {
-                ge->setVisibleRx(Quantity::convert(gtk_adjustment_get_value(adj), unit, "px"));
+                ge->setVisibleRx(Quantity::convert(adj->get_value(), unit, "px"));
             } else {
-                ge->setVisibleRy(Quantity::convert(gtk_adjustment_get_value(adj), unit, "px"));
+                ge->setVisibleRy(Quantity::convert(adj->get_value(), unit, "px"));
             }
 
             ge->normalize();
@@ -136,45 +313,35 @@ static void sp_arctb_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const
     }
 
     if (modmade) {
-        DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_ARC,
+        DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_ARC,
                            _("Ellipse: Change radius"));
     }
 
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
-}
-
-static void sp_arctb_rx_value_changed(GtkAdjustment *adj, GObject *tbl)
-{
-    sp_arctb_value_changed(adj, tbl, "rx");
+    _freeze = false;
 }
 
-static void sp_arctb_ry_value_changed(GtkAdjustment *adj, GObject *tbl)
+void
+ArcToolbar::startend_value_changed(Glib::RefPtr<Gtk::Adjustment>&  adj,
+                                   gchar const                    *value_name,
+                                   Glib::RefPtr<Gtk::Adjustment>&  other_adj)
 {
-    sp_arctb_value_changed(adj, tbl, "ry");
-}
-
-static void
-sp_arctb_startend_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_name, gchar const *other_name)
-{
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( tbl, "desktop" ));
-
-    if (DocumentUndo::getUndoSensitive(desktop->getDocument())) {
+    if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setDouble(Glib::ustring("/tools/shapes/arc/") + value_name, gtk_adjustment_get_value(adj));
+        prefs->setDouble(Glib::ustring("/tools/shapes/arc/") + value_name, adj->get_value());
     }
 
     // quit if run by the attr_changed listener
-    if (g_object_get_data( tbl, "freeze" )) {
+    if (_freeze) {
         return;
     }
 
     // in turn, prevent listener from responding
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+    _freeze = true;
 
     gchar* namespaced_name = g_strconcat("sodipodi:", value_name, NULL);
 
     bool modmade = false;
-    auto itemlist= desktop->getSelection()->items();
+    auto itemlist= _desktop->getSelection()->items();
     for(auto i=itemlist.begin();i!=itemlist.end();++i){
         SPItem *item = *i;
         if (SP_IS_GENERICELLIPSE(item)) {
@@ -182,9 +349,9 @@ sp_arctb_startend_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *v
             SPGenericEllipse *ge = SP_GENERICELLIPSE(item);
 
             if (!strcmp(value_name, "start")) {
-                ge->start = (gtk_adjustment_get_value(adj) * M_PI)/ 180;
+                ge->start = (adj->get_value() * M_PI)/ 180;
             } else {
-                ge->end = (gtk_adjustment_get_value(adj) * M_PI)/ 180;
+                ge->end = (adj->get_value() * M_PI)/ 180;
             }
 
             ge->normalize();
@@ -197,45 +364,31 @@ sp_arctb_startend_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *v
 
     g_free(namespaced_name);
 
-    GtkAdjustment *other = GTK_ADJUSTMENT( g_object_get_data( tbl, other_name ) );
-
-    sp_arctb_sensitivize( tbl, gtk_adjustment_get_value(adj), gtk_adjustment_get_value(other) );
+    sensitivize( adj->get_value(), other_adj->get_value() );
 
     if (modmade) {
-        DocumentUndo::maybeDone(desktop->getDocument(), value_name, SP_VERB_CONTEXT_ARC,
+        DocumentUndo::maybeDone(_desktop->getDocument(), value_name, SP_VERB_CONTEXT_ARC,
                                 _("Arc: Change start/end"));
     }
 
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-
-static void sp_arctb_start_value_changed(GtkAdjustment *adj,  GObject *tbl)
+void
+ArcToolbar::type_changed( int type )
 {
-    sp_arctb_startend_value_changed(adj,  tbl, "start", "end");
-}
-
-static void sp_arctb_end_value_changed(GtkAdjustment *adj, GObject *tbl)
-{
-    sp_arctb_startend_value_changed(adj,  tbl, "end", "start");
-}
-
-
-static void sp_arctb_type_changed( GObject *tbl, int type )
-{
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( tbl, "desktop" ));
-    if (DocumentUndo::getUndoSensitive(desktop->getDocument())) {
+    if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
         prefs->setInt("/tools/shapes/arc/arc_type", type);
     }
 
     // quit if run by the attr_changed listener
-    if (g_object_get_data( tbl, "freeze" )) {
+    if (_freeze) {
         return;
     }
 
     // in turn, prevent listener from responding
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+    _freeze = true;
 
     Glib::ustring arc_type = "slice";
     bool open = false;
@@ -257,7 +410,7 @@ static void sp_arctb_type_changed( GObject *tbl, int type )
     }
                
     bool modmade = false;
-    auto itemlist= desktop->getSelection()->items();
+    auto itemlist= _desktop->getSelection()->items();
     for(auto i=itemlist.begin();i!=itemlist.end();++i){
         SPItem *item = *i;
         if (SP_IS_GENERICELLIPSE(item)) {
@@ -270,334 +423,174 @@ static void sp_arctb_type_changed( GObject *tbl, int type )
     }
 
     if (modmade) {
-        DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_ARC,
+        DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_ARC,
                            _("Arc: Changed arc type"));
     }
 
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-static void sp_arctb_defaults(GtkWidget *, GObject *obj)
+void
+ArcToolbar::defaults(GtkWidget *, GObject *obj)
 {
+    auto toolbar = reinterpret_cast<ArcToolbar *>(obj);
     GtkAdjustment *adj;
 
-    adj = GTK_ADJUSTMENT( g_object_get_data(obj, "start") );
-    gtk_adjustment_set_value(adj, 0.0);
+    toolbar->_start_adj->set_value(0.0);
+    toolbar->_end_adj->set_value(0.0);
 
 #if !GTK_CHECK_VERSION(3,18,0)
-    gtk_adjustment_value_changed(adj);
+    toolbar->_start_adj->value_changed();
+    toolbar->_end_adj->value_changed();
 #endif
 
-    adj = GTK_ADJUSTMENT( g_object_get_data(obj, "end") );
-    gtk_adjustment_set_value(adj, 0.0);
-
-#if !GTK_CHECK_VERSION(3,18,0)
-    gtk_adjustment_value_changed(adj);
-#endif
-
-    spinbutton_defocus(GTK_WIDGET(obj));
+    if(toolbar->_desktop->canvas) gtk_widget_grab_focus(GTK_WIDGET(toolbar->_desktop->canvas));
 }
 
-static void arc_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const * /*name*/,
-                                      gchar const * /*old_value*/, gchar const * /*new_value*/,
-                                      bool /*is_interactive*/, gpointer data)
+void
+ArcToolbar::sensitivize( double v1, double v2 )
 {
-    GObject *tbl = G_OBJECT(data);
-
-    // quit if run by the _changed callbacks
-    if (g_object_get_data( tbl, "freeze" )) {
-        return;
-    }
-
-    // in turn, prevent callbacks from responding
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
-
-    gpointer item = g_object_get_data( tbl, "item" );
-    if (item && SP_IS_GENERICELLIPSE(item)) {
-        SPGenericEllipse *ge = SP_GENERICELLIPSE(item);
-
-        UnitTracker* tracker = reinterpret_cast<UnitTracker*>( g_object_get_data( tbl, "tracker" ) );
-        Unit const *unit = tracker->getActiveUnit();
-        g_return_if_fail(unit != nullptr);
-
-        GtkAdjustment *adj;
-        adj = GTK_ADJUSTMENT( g_object_get_data(tbl, "rx") );
-        gdouble rx = ge->getVisibleRx();
-        gtk_adjustment_set_value(adj, Quantity::convert(rx, "px", unit));
-
-#if !GTK_CHECK_VERSION(3,18,0)
-        gtk_adjustment_value_changed(adj);
-#endif
-
-        adj = GTK_ADJUSTMENT( g_object_get_data(tbl, "ry") );
-        gdouble ry = ge->getVisibleRy();
-        gtk_adjustment_set_value(adj, Quantity::convert(ry, "px", unit));
-
-#if !GTK_CHECK_VERSION(3,18,0)
-        gtk_adjustment_value_changed(adj);
-#endif
-    }
-
-    gdouble start = 0.;
-    gdouble end = 0.;
-    sp_repr_get_double(repr, "sodipodi:start", &start);
-    sp_repr_get_double(repr, "sodipodi:end", &end);
-
-    GtkAdjustment *adj1,*adj2;
-    adj1 = GTK_ADJUSTMENT( g_object_get_data( tbl, "start" ) );
-    gtk_adjustment_set_value(adj1, mod360((start * 180)/M_PI));
-    adj2 = GTK_ADJUSTMENT( g_object_get_data( tbl, "end" ) );
-    gtk_adjustment_set_value(adj2, mod360((end * 180)/M_PI));
-
-    sp_arctb_sensitivize( tbl, gtk_adjustment_get_value(adj1), gtk_adjustment_get_value(adj2) );
-
-    char const *arctypestr = nullptr;
-    arctypestr = repr->attribute("sodipodi:arc-type");
-    if (!arctypestr) { // For old files.
-        char const *openstr = nullptr;
-        openstr = repr->attribute("sodipodi:open");
-        arctypestr = (openstr ? "arc" : "slice");
+    if (v1 == 0 && v2 == 0) {
+        if (_single) { // only for a single selected ellipse (for now)
+            _type_action->set_sensitive(false);
+            gtk_action_set_sensitive( GTK_ACTION(_make_whole), FALSE );
+        }
+    } else {
+        _type_action->set_sensitive(true);
+        gtk_action_set_sensitive( GTK_ACTION(_make_whole), TRUE );
     }
+}
 
-    InkSelectOneAction *typeAction =
-        static_cast<InkSelectOneAction*>( g_object_get_data( tbl, "type_action" ) );
-
-    if (!strcmp(arctypestr,"slice")) {
-        typeAction->set_active( 0 );
-    } else if (!strcmp(arctypestr,"arc")) {
-        typeAction->set_active( 1 );
+void
+ArcToolbar::check_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec)
+{
+    if (SP_IS_ARC_CONTEXT(ec)) {
+        _changed = _desktop->getSelection()->connectChanged(sigc::mem_fun(*this, &ArcToolbar::selection_changed));
+        selection_changed(desktop->getSelection());
     } else {
-        typeAction->set_active( 2 );
+        if (_changed) {
+            _changed.disconnect();
+            if(_repr) {
+                _repr->removeListenerByData(this);
+                Inkscape::GC::release(_repr);
+                _repr = nullptr;
+            }
+        }
     }
-
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
 }
 
-static Inkscape::XML::NodeEventVector arc_tb_repr_events = {
-    nullptr, /* child_added */
-    nullptr, /* child_removed */
-    arc_tb_event_attr_changed,
-    nullptr, /* content_changed */
-    nullptr  /* order_changed */
-};
-
-
-static void sp_arc_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
+void
+ArcToolbar::selection_changed(Inkscape::Selection *selection)
 {
     int n_selected = 0;
     Inkscape::XML::Node *repr = nullptr;
-    SPItem *item = nullptr;
 
-    if ( g_object_get_data( tbl, "repr" ) ) {
-        g_object_set_data( tbl, "item", nullptr );
+    if ( _repr ) {
+        _item = nullptr;
+        _repr->removeListenerByData(this);
+        GC::release(_repr);
+        _repr = nullptr;
     }
-    purge_repr_listener( tbl, tbl );
 
-    auto itemlist= selection->items();
-    for(auto i=itemlist.begin();i!=itemlist.end();++i){
-        if (SP_IS_GENERICELLIPSE(*i)) {
+    SPItem *item = nullptr;
+
+    for(auto i : selection->items()){
+        if (SP_IS_GENERICELLIPSE(i)) {
             n_selected++;
-            item = *i;
+            item = i;
             repr = item->getRepr();
         }
     }
 
-    EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) );
-
-    g_object_set_data( tbl, "single", GINT_TO_POINTER(FALSE) );
+    _single = false;
     if (n_selected == 0) {
-        g_object_set( G_OBJECT(act), "label", _("<b>New:</b>"), NULL );
+        gtk_action_set_label(GTK_ACTION(_mode_action), _("<b>New:</b>"));
     } else if (n_selected == 1) {
-        g_object_set_data( tbl, "single", GINT_TO_POINTER(TRUE) );
-        g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
-
-        GtkAction* rx = GTK_ACTION( g_object_get_data( tbl, "rx_action" ) );
-        gtk_action_set_sensitive(rx, TRUE);
-        GtkAction* ry = GTK_ACTION( g_object_get_data( tbl, "ry_action" ) );
-        gtk_action_set_sensitive(ry, TRUE);
+        _single = true;
+        gtk_action_set_label(GTK_ACTION(_mode_action), _("<b>Change:</b>"));
+        gtk_action_set_sensitive(GTK_ACTION(_rx_action), TRUE);
+        gtk_action_set_sensitive(GTK_ACTION(_ry_action), TRUE);
 
         if (repr) {
-            g_object_set_data( tbl, "repr", repr );
-            g_object_set_data( tbl, "item", item );
-            Inkscape::GC::anchor(repr);
-            sp_repr_add_listener(repr, &arc_tb_repr_events, tbl);
-            sp_repr_synthesize_events(repr, &arc_tb_repr_events, tbl);
+            _repr = repr;
+            _item = item;
+            Inkscape::GC::anchor(_repr);
+            _repr->addListener(&arc_tb_repr_events, this);
+            _repr->synthesizeEvents(&arc_tb_repr_events, this);
         }
     } else {
         // FIXME: implement averaging of all parameters for multiple selected
         //gtk_label_set_markup(GTK_LABEL(l), _("<b>Average:</b>"));
-        g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
-        sp_arctb_sensitivize( tbl, 1, 0 );
+        gtk_action_set_label(GTK_ACTION(_mode_action), _("<b>Change:</b>"));
+        sensitivize( 1, 0 );
     }
 }
 
-static void arc_toolbox_check_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* holder);
-
-void sp_arc_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
+void
+ArcToolbar::event_attr_changed(Inkscape::XML::Node *repr, gchar const * /*name*/,
+                               gchar const * /*old_value*/, gchar const * /*new_value*/,
+                               bool /*is_interactive*/, gpointer data)
 {
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    auto toolbar = reinterpret_cast<ArcToolbar *>(data);
 
-    EgeAdjustmentAction* eact = nullptr;
-    GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
-
-    UnitTracker* tracker = new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR);
-    tracker->setActiveUnit(unit_table.getUnit("px"));
-    g_object_set_data( holder, "tracker", tracker );
-
-    {
-        EgeOutputAction* act = ege_output_action_new( "ArcStateAction", _("<b>New:</b>"), "", nullptr );
-        ege_output_action_set_use_markup( act, TRUE );
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        g_object_set_data( holder, "mode_action", act );
+    // quit if run by the _changed callbacks
+    if (toolbar->_freeze) {
+        return;
     }
 
-    /* Radius X */
-    {
-        gchar const* labels[] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
-        gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
-        eact = create_adjustment_action( "ArcRadiusXAction",
-                                         _("Horizontal radius"), _("Rx:"), _("Horizontal radius of the circle, ellipse, or arc"),
-                                         "/tools/shapes/arc/rx", 0,
-                                         GTK_WIDGET(desktop->canvas), holder, TRUE, "altx-arc",
-                                         0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         sp_arctb_rx_value_changed, tracker);
-        g_object_set_data( holder, "rx_action", eact );
-        gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-    }
+    // in turn, prevent callbacks from responding
+    toolbar->_freeze = true;
 
-    /* Radius Y */
-    {
-        gchar const* labels[] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
-        gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
-        eact = create_adjustment_action( "ArcRadiusYAction",
-                                         _("Vertical radius"), _("Ry:"), _("Vertical radius of the circle, ellipse, or arc"),
-                                         "/tools/shapes/arc/ry", 0,
-                                         GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
-                                         0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         sp_arctb_ry_value_changed, tracker);
-        g_object_set_data( holder, "ry_action", eact );
-        gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-    }
+    if (toolbar->_item && SP_IS_GENERICELLIPSE(toolbar->_item)) {
+        SPGenericEllipse *ge = SP_GENERICELLIPSE(toolbar->_item);
 
-    // add the units menu
-    {
-        Gtk::Action* act = tracker->createAction( "ArcUnitsAction", _("Units"), ("") );
-        gtk_action_group_add_action( mainActions, act->gobj() );
-    }
+        Unit const *unit = toolbar->_tracker->getActiveUnit();
+        g_return_if_fail(unit != nullptr);
 
-    /* Start */
-    {
-        eact = create_adjustment_action( "ArcStartAction",
-                                         _("Start"), _("Start:"),
-                                         _("The angle (in degrees) from the horizontal to the arc's start point"),
-                                         "/tools/shapes/arc/start", 0.0,
-                                         GTK_WIDGET(desktop->canvas), holder, TRUE, "altx-arc",
-                                         -360.0, 360.0, 1.0, 10.0,
-                                         nullptr, nullptr, 0,
-                                         sp_arctb_start_value_changed);
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-    }
+        gdouble rx = ge->getVisibleRx();
+        gdouble ry = ge->getVisibleRy();
+        toolbar->_rx_adj->set_value(Quantity::convert(rx, "px", unit));
+        toolbar->_ry_adj->set_value(Quantity::convert(ry, "px", unit));
 
-    /* End */
-    {
-        eact = create_adjustment_action( "ArcEndAction",
-                                         _("End"), _("End:"),
-                                         _("The angle (in degrees) from the horizontal to the arc's end point"),
-                                         "/tools/shapes/arc/end", 0.0,
-                                         GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
-                                         -360.0, 360.0, 1.0, 10.0,
-                                         nullptr, nullptr, 0,
-                                         sp_arctb_end_value_changed);
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+#if !GTK_CHECK_VERSION(3,18,0)
+        toolbar->_rx_adj->value_changed();
+        toolbar->_ry_adj->value_changed();
+#endif
     }
 
-    /* Arc: Slice, Arc, Chord */
-    {
-        InkSelectOneActionColumns columns;
-
-        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
-
-        Gtk::TreeModel::Row row;
-
-        row = *(store->append());
-        row[columns.col_label    ] = _("Slice");
-        row[columns.col_tooltip  ] = _("Switch to slice (closed shape with two radii)"),
-        row[columns.col_icon     ] = INKSCAPE_ICON("draw-ellipse-segment");
-        row[columns.col_sensitive] = true;
-
-        row = *(store->append());
-        row[columns.col_label    ] = _("Arc (Open)");
-        row[columns.col_tooltip  ] = _("Switch to arc (unclosed shape)");
-        row[columns.col_icon     ] = INKSCAPE_ICON("draw-ellipse-arc");
-        row[columns.col_sensitive] = true;
-
-        row = *(store->append());
-        row[columns.col_label    ] = _("Chord");
-        row[columns.col_tooltip  ] = _("Switch to chord (closed shape)"),
-        row[columns.col_icon     ] = INKSCAPE_ICON("draw-ellipse-chord");
-        row[columns.col_sensitive] = true;
-
-        InkSelectOneAction* act =
-            InkSelectOneAction::create( "ArcTypeAction",   // Name
-                                        "",                // Label
-                                        "",                // Tooltip
-                                        "Not Used",        // Icon
-                                        store );           // Tree store
+    gdouble start = 0.;
+    gdouble end = 0.;
+    sp_repr_get_double(repr, "sodipodi:start", &start);
+    sp_repr_get_double(repr, "sodipodi:end", &end);
 
-        act->use_radio( true );
-        act->use_group_label( false );
-        gint type = prefs->getInt("/tools/shapes/arc/arc_type", 0);
-        act->set_active( type );
+    toolbar->_start_adj->set_value(mod360((start * 180)/M_PI));
+    toolbar->_end_adj->set_value(mod360((end * 180)/M_PI));
 
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data( holder, "type_action", act );
+    toolbar->sensitivize(toolbar->_start_adj->get_value(), toolbar->_end_adj->get_value());
 
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_arctb_type_changed), holder));
+    char const *arctypestr = nullptr;
+    arctypestr = repr->attribute("sodipodi:arc-type");
+    if (!arctypestr) { // For old files.
+        char const *openstr = nullptr;
+        openstr = repr->attribute("sodipodi:open");
+        arctypestr = (openstr ? "arc" : "slice");
     }
 
-    /* Make Whole */
-    {
-        InkAction* inky = ink_action_new( "ArcResetAction",
-                                          _("Make whole"),
-                                          _("Make the shape a whole ellipse, not arc or segment"),
-                                          INKSCAPE_ICON("draw-ellipse-whole"),
-                                          secondarySize );
-        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_arctb_defaults), holder );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
-        gtk_action_set_sensitive( GTK_ACTION(inky), TRUE );
-        g_object_set_data( holder, "make_whole", inky );
-    }
-
-    g_object_set_data( G_OBJECT(holder), "single", GINT_TO_POINTER(TRUE) );
-    // sensitivize make whole and open checkbox
-    {
-        GtkAdjustment *adj1 = GTK_ADJUSTMENT( g_object_get_data( holder, "start" ) );
-        GtkAdjustment *adj2 = GTK_ADJUSTMENT( g_object_get_data( holder, "end" ) );
-        sp_arctb_sensitivize( holder, gtk_adjustment_get_value(adj1), gtk_adjustment_get_value(adj2) );
+    if (!strcmp(arctypestr,"slice")) {
+        toolbar->_type_action->set_active( 0 );
+    } else if (!strcmp(arctypestr,"arc")) {
+        toolbar->_type_action->set_active( 1 );
+    } else {
+        toolbar->_type_action->set_active( 2 );
     }
 
-    desktop->connectEventContextChanged(sigc::bind(sigc::ptr_fun(arc_toolbox_check_ec), holder));
-    g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );
+    toolbar->_freeze = false;
 }
 
-static void arc_toolbox_check_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec, GObject* holder)
-{
-    static sigc::connection changed;
-
-    if (SP_IS_ARC_CONTEXT(ec)) {
-        changed = desktop->getSelection()->connectChanged(sigc::bind(sigc::ptr_fun(sp_arc_toolbox_selection_changed), holder));
-        sp_arc_toolbox_selection_changed(desktop->getSelection(), holder);
-    } else {
-        if (changed) {
-            changed.disconnect();
-            purge_repr_listener(nullptr, holder);
-        }
-    }
 }
+}
+}
+
 
 /*
   Local Variables:
diff --git a/src/ui/toolbar/arc-toolbar.h b/src/ui/toolbar/arc-toolbar.h
index 821db6dd7..b9b735dcb 100644
--- a/src/ui/toolbar/arc-toolbar.h
+++ b/src/ui/toolbar/arc-toolbar.h
@@ -28,11 +28,88 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "toolbar.h"
+
+#include <gtkmm/adjustment.h>
+
+class InkSelectOneAction;
 class SPDesktop;
+class SPItem;
 
+typedef struct _EgeAdjustmentAction EgeAdjustmentAction;
+typedef struct _EgeOutputAction EgeOutputAction;
 typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _GObject GObject;
+typedef struct _InkAction InkAction;
+
+namespace Inkscape {
+class Selection;
+
+namespace XML {
+class Node;
+}
+
+namespace UI {
+namespace Tools {
+class ToolBase;
+}
+
+namespace Widget {
+class UnitTracker;
+}
+
+namespace Toolbar {
+class ArcToolbar : public Toolbar {
+private:
+    UI::Widget::UnitTracker *_tracker;
+
+    EgeAdjustmentAction *_rx_action;
+    EgeAdjustmentAction *_ry_action;
+
+    EgeOutputAction *_mode_action;
+
+    InkSelectOneAction *_type_action;
+    InkAction *_make_whole;
+
+    Glib::RefPtr<Gtk::Adjustment> _rx_adj;
+    Glib::RefPtr<Gtk::Adjustment> _ry_adj;
+    Glib::RefPtr<Gtk::Adjustment> _start_adj;
+    Glib::RefPtr<Gtk::Adjustment> _end_adj;
+
+    bool _freeze;
+    bool _single;
+
+    XML::Node *_repr;
+    SPItem *_item;
+
+    void value_changed(Glib::RefPtr<Gtk::Adjustment>&  adj,
+                       gchar const                    *value_name);
+    void startend_value_changed(Glib::RefPtr<Gtk::Adjustment>&  adj,
+                                gchar const                    *value_name,
+                                Glib::RefPtr<Gtk::Adjustment>&  other_adj);
+    void type_changed( int type );
+    static void defaults(GtkWidget *, GObject *obj);
+    void sensitivize( double v1, double v2 );
+    void check_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec);
+    void selection_changed(Inkscape::Selection *selection);
+
+    sigc::connection _changed;
+
+protected:
+    ArcToolbar(SPDesktop *desktop);
+    ~ArcToolbar();
+
+public:
+    static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions);
+    static void event_attr_changed(Inkscape::XML::Node *repr,
+                                   gchar const         *name,
+                                   gchar const         *old_value,
+                                   gchar const         *new_value,
+                                   bool                 is_interactive,
+                                   gpointer             data);
+};
 
-void       sp_arc_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
+}
+}
+}
 
 #endif /* !SEEN_ARC_TOOLBAR_H */
diff --git a/src/ui/toolbar/box3d-toolbar.cpp b/src/ui/toolbar/box3d-toolbar.cpp
index fb59b13b9..50838a393 100644
--- a/src/ui/toolbar/box3d-toolbar.cpp
+++ b/src/ui/toolbar/box3d-toolbar.cpp
@@ -58,168 +58,176 @@ using Inkscape::UI::PrefPusher;
 //##       3D Box       ##
 //########################
 
-// normalize angle so that it lies in the interval [0,360]
-static double box3d_normalize_angle (double a) {
-    double angle = a + ((int) (a/360.0))*360;
-    if (angle < 0) {
-        angle += 360.0;
-    }
-    return angle;
-}
 
-static void box3d_set_button_and_adjustment(Persp3D *persp,
-                                            Proj::Axis axis,
-                                            GtkAdjustment *adj,
-                                            GtkAction *act,
-                                            GtkToggleAction *tact)
-{
-    // TODO: Take all selected perspectives into account but don't touch the state button if not all of them
-    //       have the same state (otherwise a call to box3d_vp_z_state_changed() is triggered and the states
-    //       are reset).
-    bool is_infinite = !persp3d_VP_is_finite(persp->perspective_impl, axis);
-
-    if (is_infinite) {
-        gtk_toggle_action_set_active(tact, TRUE);
-        gtk_action_set_sensitive(act, TRUE);
 
-        double angle = persp3d_get_infinite_angle(persp, axis);
-        if (angle != Geom::infinity()) { // FIXME: We should catch this error earlier (don't show the spinbutton at all)
-            gtk_adjustment_set_value(adj, box3d_normalize_angle(angle));
-        }
-    } else {
-        gtk_toggle_action_set_active(tact, FALSE);
-        gtk_action_set_sensitive(act, FALSE);
-    }
-}
+static Inkscape::XML::NodeEventVector box3d_persp_tb_repr_events =
+{
+    nullptr, /* child_added */
+    nullptr, /* child_removed */
+    Inkscape::UI::Toolbar::Box3DToolbar::event_attr_changed,
+    nullptr, /* content_changed */
+    nullptr  /* order_changed */
+};
 
-static void box3d_resync_toolbar(Inkscape::XML::Node *persp_repr, GObject *data)
+namespace Inkscape {
+namespace UI {
+namespace Toolbar {
+GtkWidget *
+Box3DToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
 {
-    if (!persp_repr) {
-        g_print ("No perspective given to box3d_resync_toolbar().\n");
-        return;
-    }
+    auto holder = new Box3DToolbar(desktop);
 
-    GtkWidget *tbl = GTK_WIDGET(data);
-    GtkAdjustment *adj = nullptr;
-    GtkAction *act = nullptr;
-    GtkToggleAction *tact = nullptr;
-    Persp3D *persp = persp3d_get_from_repr(persp_repr);
-    if (!persp) {
-        // Hmm, is it an error if this happens?
-        return;
-    }
-    {
-        adj = GTK_ADJUSTMENT(g_object_get_data(G_OBJECT(tbl), "box3d_angle_x"));
-        act = GTK_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_angle_x_action"));
-        tact = &INK_TOGGLE_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_vp_x_state_action"))->action;
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    SPDocument *document = desktop->getDocument();
+    Persp3DImpl *persp_impl = document->getCurrentPersp3DImpl();
 
-        box3d_set_button_and_adjustment(persp, Proj::X, adj, act, tact);
-    }
+    /* Angle X */
     {
-        adj = GTK_ADJUSTMENT(g_object_get_data(G_OBJECT(tbl), "box3d_angle_y"));
-        act = GTK_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_angle_y_action"));
-        tact = &INK_TOGGLE_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_vp_y_state_action"))->action;
-
-        box3d_set_button_and_adjustment(persp, Proj::Y, adj, act, tact);
+        gchar const* labels[] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
+        gdouble values[] = {-90, -60, -30, 0, 30, 60, 90};
+        holder->_angle_x_action = create_adjustment_action( "3DBoxAngleXAction",
+                                                            _("Angle in X direction"), _("Angle X:"),
+                                                            // Translators: PL is short for 'perspective line'
+                                                            _("Angle of PLs in X direction"),
+                                                            "/tools/shapes/3dbox/box3d_angle_x", 30,
+                                                            GTK_WIDGET(desktop->canvas),
+                                                            nullptr, // dataKludge
+                                                            TRUE, "altx-box3d",
+                                                            -360.0, 360.0, 1.0, 10.0,
+                                                            labels, values, G_N_ELEMENTS(labels),
+                                                            nullptr // callback
+                                                            );
+        holder->_angle_x_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_angle_x_action));
+        holder->_angle_x_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &Box3DToolbar::angle_value_changed),
+                                                                        holder->_angle_x_adj, Proj::X));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_angle_x_action) );
     }
-    {
-        adj = GTK_ADJUSTMENT(g_object_get_data(G_OBJECT(tbl), "box3d_angle_z"));
-        act = GTK_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_angle_z_action"));
-        tact = &INK_TOGGLE_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_vp_z_state_action"))->action;
 
-        box3d_set_button_and_adjustment(persp, Proj::Z, adj, act, tact);
+    if (!persp_impl || !persp3d_VP_is_finite(persp_impl, Proj::X)) {
+        gtk_action_set_sensitive( GTK_ACTION(holder->_angle_x_action), TRUE );
+    } else {
+        gtk_action_set_sensitive( GTK_ACTION(holder->_angle_x_action), FALSE );
     }
-}
 
-static void box3d_persp_tb_event_attr_changed(Inkscape::XML::Node *repr,
-                                              gchar const * /*name*/,
-                                              gchar const * /*old_value*/,
-                                              gchar const * /*new_value*/,
-                                              bool /*is_interactive*/,
-                                              gpointer data)
-{
-    GtkWidget *tbl = GTK_WIDGET(data);
 
-    // quit if run by the attr_changed or selection changed listener
-    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
-        return;
+    /* VP X state */
+    {
+        holder->_vp_x_state_action = ink_toggle_action_new( "3DBoxVPXStateAction",
+                                                            // Translators: VP is short for 'vanishing point'
+                                                            _("State of VP in X direction"),
+                                                            _("Toggle VP in X direction between 'finite' and 'infinite' (=parallel)"),
+                                                            INKSCAPE_ICON("perspective-parallel"),
+                                                            GTK_ICON_SIZE_MENU );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_vp_x_state_action ) );
+        g_signal_connect_after( G_OBJECT(holder->_vp_x_state_action), "toggled", G_CALLBACK(Box3DToolbar::vp_state_changed), (gpointer)Proj::X );
+        gtk_action_set_sensitive( GTK_ACTION(holder->_angle_x_action), !prefs->getBool("/tools/shapes/3dbox/vp_x_state", true) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_vp_x_state_action), prefs->getBool("/tools/shapes/3dbox/vp_x_state", true) );
     }
 
-    // set freeze so that it can be caught in box3d_angle_z_value_changed() (to avoid calling
-    // SPDocumentUndo::maybeDone() when the document is undo insensitive)
-    g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE));
-
-    // TODO: Only update the appropriate part of the toolbar
-//    if (!strcmp(name, "inkscape:vp_z")) {
-        box3d_resync_toolbar(repr, G_OBJECT(tbl));
-//    }
-
-    Persp3D *persp = persp3d_get_from_repr(repr);
-    persp3d_update_box_reprs(persp);
+    /* Angle Y */
+    {
+        gchar const* labels[] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
+        gdouble values[] = {-90, -60, -30, 0, 30, 60, 90};
+        holder->_angle_y_action = create_adjustment_action( "3DBoxAngleYAction",
+                                         _("Angle in Y direction"), _("Angle Y:"),
+                                         // Translators: PL is short for 'perspective line'
+                                         _("Angle of PLs in Y direction"),
+                                         "/tools/shapes/3dbox/box3d_angle_y", 30,
+                                         GTK_WIDGET(desktop->canvas),
+                                         nullptr, // dataKludge
+                                         FALSE, nullptr,
+                                         -360.0, 360.0, 1.0, 10.0,
+                                         labels, values, G_N_ELEMENTS(labels),
+                                         nullptr // callback
+                                         );
+        holder->_angle_y_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_angle_y_action));
+        holder->_angle_y_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &Box3DToolbar::angle_value_changed),
+                                                                        holder->_angle_y_adj, Proj::Y));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_angle_y_action) );
+    }
 
-    g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
-}
+    if (!persp_impl || !persp3d_VP_is_finite(persp_impl, Proj::Y)) {
+        gtk_action_set_sensitive( GTK_ACTION(holder->_angle_y_action), TRUE );
+    } else {
+        gtk_action_set_sensitive( GTK_ACTION(holder->_angle_y_action), FALSE );
+    }
 
-static Inkscape::XML::NodeEventVector box3d_persp_tb_repr_events =
-{
-    nullptr, /* child_added */
-    nullptr, /* child_removed */
-    box3d_persp_tb_event_attr_changed,
-    nullptr, /* content_changed */
-    nullptr  /* order_changed */
-};
+    /* VP Y state */
+    {
+        holder->_vp_y_state_action = ink_toggle_action_new( "3DBoxVPYStateAction",
+                                                            // Translators: VP is short for 'vanishing point'
+                                                            _("State of VP in Y direction"),
+                                                            _("Toggle VP in Y direction between 'finite' and 'infinite' (=parallel)"),
+                                                            INKSCAPE_ICON("perspective-parallel"),
+                                                            GTK_ICON_SIZE_MENU );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_vp_y_state_action ) );
+        g_signal_connect_after( G_OBJECT(holder->_vp_y_state_action), "toggled", G_CALLBACK(Box3DToolbar::vp_state_changed), (gpointer)Proj::Y);
+        gtk_action_set_sensitive( GTK_ACTION(holder->_angle_y_action), !prefs->getBool("/tools/shapes/3dbox/vp_y_state", true) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_vp_y_state_action), prefs->getBool("/tools/shapes/3dbox/vp_y_state", true) );
+    }
 
-/**
- *  \param selection Should not be NULL.
- */
-// FIXME: This should rather be put into persp3d-reference.cpp or something similar so that it reacts upon each
-//        Change of the perspective, and not of the current selection (but how to refer to the toolbar then?)
-static void box3d_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
-{
-    // Here the following should be done: If all selected boxes have finite VPs in a certain direction,
-    // disable the angle entry fields for this direction (otherwise entering a value in them should only
-    // update the perspectives with infinite VPs and leave the other ones untouched).
+    /* Angle Z */
+    {
+        gchar const* labels[] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
+        gdouble values[] = {-90, -60, -30, 0, 30, 60, 90};
+        holder->_angle_z_action = create_adjustment_action( "3DBoxAngleZAction",
+                                         _("Angle in Z direction"), _("Angle Z:"),
+                                         // Translators: PL is short for 'perspective line'
+                                         _("Angle of PLs in Z direction"),
+                                         "/tools/shapes/3dbox/box3d_angle_z", 30,
+                                         GTK_WIDGET(desktop->canvas),
+                                         nullptr, // dataKludge
+                                         FALSE, nullptr,
+                                         -360.0, 360.0, 1.0, 10.0,
+                                         labels, values, G_N_ELEMENTS(labels),
+                                         nullptr // callback
+                                         );
+        holder->_angle_z_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_angle_z_action));
+        holder->_angle_z_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &Box3DToolbar::angle_value_changed),
+                                                                        holder->_angle_z_adj, Proj::Z));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_angle_z_action) );
+    }
 
-    Inkscape::XML::Node *persp_repr = nullptr;
-    purge_repr_listener(tbl, tbl);
+    if (!persp_impl || !persp3d_VP_is_finite(persp_impl, Proj::Z)) {
+        gtk_action_set_sensitive( GTK_ACTION(holder->_angle_z_action), TRUE );
+    } else {
+        gtk_action_set_sensitive( GTK_ACTION(holder->_angle_z_action), FALSE );
+    }
 
-    SPItem *item = selection->singleItem();
-    SPBox3D *box = dynamic_cast<SPBox3D *>(item);
-    if (box) {
-        // FIXME: Also deal with multiple selected boxes
-        Persp3D *persp = box3d_get_perspective(box);
-        persp_repr = persp->getRepr();
-        if (persp_repr) {
-            g_object_set_data(tbl, "repr", persp_repr);
-            Inkscape::GC::anchor(persp_repr);
-            sp_repr_add_listener(persp_repr, &box3d_persp_tb_repr_events, tbl);
-            sp_repr_synthesize_events(persp_repr, &box3d_persp_tb_repr_events, tbl);
+    /* VP Z state */
+    {
+        holder->_vp_z_state_action = ink_toggle_action_new( "3DBoxVPZStateAction",
+                                                            // Translators: VP is short for 'vanishing point'
+                                                            _("State of VP in Z direction"),
+                                                            _("Toggle VP in Z direction between 'finite' and 'infinite' (=parallel)"),
+                                                            INKSCAPE_ICON("perspective-parallel"),
+                                                            GTK_ICON_SIZE_MENU );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_vp_z_state_action ) );
+        g_signal_connect_after( G_OBJECT(holder->_vp_z_state_action), "toggled", G_CALLBACK(Box3DToolbar::vp_state_changed), (gpointer)Proj::Z );
+        gtk_action_set_sensitive( GTK_ACTION(holder->_angle_z_action), !prefs->getBool("/tools/shapes/3dbox/vp_z_state", true) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_vp_z_state_action), prefs->getBool("/tools/shapes/3dbox/vp_z_state", true) );
+    }
 
-            SP_ACTIVE_DOCUMENT->setCurrentPersp3D(persp3d_get_from_repr(persp_repr));
-            Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-            prefs->setString("/tools/shapes/3dbox/persp", persp_repr->attribute("id"));
+    desktop->connectEventContextChanged(sigc::mem_fun(*holder, &Box3DToolbar::check_ec));
 
-            g_object_set_data(tbl, "freeze", GINT_TO_POINTER(TRUE));
-            box3d_resync_toolbar(persp_repr, tbl);
-            g_object_set_data(tbl, "freeze", GINT_TO_POINTER(FALSE));
-        }
-    }
+    return GTK_WIDGET(holder->gobj());
 }
 
-static void box3d_angle_value_changed(GtkAdjustment *adj, GObject *dataKludge, Proj::Axis axis)
+void
+Box3DToolbar::angle_value_changed(Glib::RefPtr<Gtk::Adjustment> &adj,
+                                  Proj::Axis                     axis)
 {
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( dataKludge, "desktop" ));
-    SPDocument *document = desktop->getDocument();
+    SPDocument *document = _desktop->getDocument();
 
     // quit if run by the attr_changed or selection changed listener
-    if (g_object_get_data( dataKludge, "freeze" )) {
+    if (_freeze) {
         return;
     }
 
     // in turn, prevent listener from responding
-    g_object_set_data(dataKludge, "freeze", GINT_TO_POINTER(TRUE));
+    _freeze = true;
 
-    std::list<Persp3D *> sel_persps = desktop->getSelection()->perspList();
+    std::list<Persp3D *> sel_persps = _desktop->getSelection()->perspList();
     if (sel_persps.empty()) {
         // this can happen when the document is created; we silently ignore it
         return;
@@ -227,33 +235,18 @@ static void box3d_angle_value_changed(GtkAdjustment *adj, GObject *dataKludge, P
     Persp3D *persp = sel_persps.front();
 
     persp->perspective_impl->tmat.set_infinite_direction (axis,
-            gtk_adjustment_get_value(adj));
+                                                          adj->get_value());
     persp->updateRepr();
 
     // TODO: use the correct axis here, too
     DocumentUndo::maybeDone(document, "perspangle", SP_VERB_CONTEXT_3DBOX, _("3D Box: Change perspective (angle of infinite axis)"));
 
-    g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-
-static void box3d_angle_x_value_changed(GtkAdjustment *adj, GObject *dataKludge)
-{
-    box3d_angle_value_changed(adj, dataKludge, Proj::X);
-}
-
-static void box3d_angle_y_value_changed(GtkAdjustment *adj, GObject *dataKludge)
-{
-    box3d_angle_value_changed(adj, dataKludge, Proj::Y);
-}
-
-static void box3d_angle_z_value_changed(GtkAdjustment *adj, GObject *dataKludge)
-{
-    box3d_angle_value_changed(adj, dataKludge, Proj::Z);
-}
-
-
-static void box3d_vp_state_changed( GtkToggleAction *act, GtkAction * /*box3d_angle*/, Proj::Axis axis )
+void
+Box3DToolbar::vp_state_changed(GtkToggleAction *act,
+                               Proj::Axis       axis )
 {
     // TODO: Take all selected perspectives into account
     std::list<Persp3D *> sel_persps = SP_ACTIVE_DESKTOP->getSelection()->perspList();
@@ -267,167 +260,171 @@ static void box3d_vp_state_changed( GtkToggleAction *act, GtkAction * /*box3d_an
     persp3d_set_VP_state (persp, axis, set_infinite ? Proj::VP_INFINITE : Proj::VP_FINITE);
 }
 
-static void box3d_vp_x_state_changed( GtkToggleAction *act, GtkAction *box3d_angle )
+void
+Box3DToolbar::check_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec)
 {
-    box3d_vp_state_changed(act, box3d_angle, Proj::X);
-}
-
-static void box3d_vp_y_state_changed( GtkToggleAction *act, GtkAction *box3d_angle )
-{
-    box3d_vp_state_changed(act, box3d_angle, Proj::Y);
+    if (SP_IS_BOX3D_CONTEXT(ec)) {
+        _changed = desktop->getSelection()->connectChanged(sigc::mem_fun(*this, &Box3DToolbar::selection_changed));
+        selection_changed(desktop->getSelection());
+    } else {
+        if (_changed)
+            _changed.disconnect();
+    }
 }
 
-static void box3d_vp_z_state_changed( GtkToggleAction *act, GtkAction *box3d_angle )
+Box3DToolbar::~Box3DToolbar()
 {
-    box3d_vp_state_changed(act, box3d_angle, Proj::Z);
+    if (_repr) { // remove old listener
+        _repr->removeListenerByData(this);
+        Inkscape::GC::release(_repr);
+        _repr = nullptr;
+    }
 }
 
-static void box3d_toolbox_check_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* holder);
-
-void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
+/**
+ *  \param selection Should not be NULL.
+ */
+// FIXME: This should rather be put into persp3d-reference.cpp or something similar so that it reacts upon each
+//        Change of the perspective, and not of the current selection (but how to refer to the toolbar then?)
+void
+Box3DToolbar::selection_changed(Inkscape::Selection *selection)
 {
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    EgeAdjustmentAction* eact = nullptr;
-    SPDocument *document = desktop->getDocument();
-    Persp3DImpl *persp_impl = document->getCurrentPersp3DImpl();
+    // Here the following should be done: If all selected boxes have finite VPs in a certain direction,
+    // disable the angle entry fields for this direction (otherwise entering a value in them should only
+    // update the perspectives with infinite VPs and leave the other ones untouched).
 
-    EgeAdjustmentAction* box3d_angle_x = nullptr;
-    EgeAdjustmentAction* box3d_angle_y = nullptr;
-    EgeAdjustmentAction* box3d_angle_z = nullptr;
+    Inkscape::XML::Node *persp_repr = nullptr;
 
-    /* Angle X */
-    {
-        gchar const* labels[] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
-        gdouble values[] = {-90, -60, -30, 0, 30, 60, 90};
-        eact = create_adjustment_action( "3DBoxAngleXAction",
-                                         _("Angle in X direction"), _("Angle X:"),
-                                         // Translators: PL is short for 'perspective line'
-                                         _("Angle of PLs in X direction"),
-                                         "/tools/shapes/3dbox/box3d_angle_x", 30,
-                                         GTK_WIDGET(desktop->canvas), holder, TRUE, "altx-box3d",
-                                         -360.0, 360.0, 1.0, 10.0,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         box3d_angle_x_value_changed );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        g_object_set_data( holder, "box3d_angle_x_action", eact );
-        box3d_angle_x = eact;
+    if (_repr) { // remove old listener
+        _repr->removeListenerByData(this);
+        Inkscape::GC::release(_repr);
+        _repr = nullptr;
     }
 
-    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 );
-    }
+    SPItem *item = selection->singleItem();
+    SPBox3D *box = dynamic_cast<SPBox3D *>(item);
+    if (box) {
+        // FIXME: Also deal with multiple selected boxes
+        Persp3D *persp = box3d_get_perspective(box);
+        persp_repr = persp->getRepr();
+        if (persp_repr) {
+            _repr = persp_repr;
+            Inkscape::GC::anchor(_repr);
+            _repr->addListener(&box3d_persp_tb_repr_events, this);
+            _repr->synthesizeEvents(&box3d_persp_tb_repr_events, this);
 
+            SP_ACTIVE_DOCUMENT->setCurrentPersp3D(persp3d_get_from_repr(_repr));
+            Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+            prefs->setString("/tools/shapes/3dbox/persp", _repr->attribute("id"));
 
-    /* VP X state */
-    {
-        InkToggleAction* act = ink_toggle_action_new( "3DBoxVPXStateAction",
-                                                      // Translators: VP is short for 'vanishing point'
-                                                      _("State of VP in X direction"),
-                                                      _("Toggle VP in X direction between 'finite' and 'infinite' (=parallel)"),
-                                                      INKSCAPE_ICON("perspective-parallel"),
-                                                      GTK_ICON_SIZE_MENU );
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        g_object_set_data( holder, "box3d_vp_x_state_action", act );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(box3d_vp_x_state_changed), box3d_angle_x );
-        gtk_action_set_sensitive( GTK_ACTION(box3d_angle_x), !prefs->getBool("/tools/shapes/3dbox/vp_x_state", true) );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/shapes/3dbox/vp_x_state", true) );
+            _freeze = true;
+            resync_toolbar(_repr);
+            _freeze = false;
+        }
     }
+}
 
-    /* Angle Y */
-    {
-        gchar const* labels[] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
-        gdouble values[] = {-90, -60, -30, 0, 30, 60, 90};
-        eact = create_adjustment_action( "3DBoxAngleYAction",
-                                         _("Angle in Y direction"), _("Angle Y:"),
-                                         // Translators: PL is short for 'perspective line'
-                                         _("Angle of PLs in Y direction"),
-                                         "/tools/shapes/3dbox/box3d_angle_y", 30,
-                                         GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
-                                         -360.0, 360.0, 1.0, 10.0,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         box3d_angle_y_value_changed );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        g_object_set_data( holder, "box3d_angle_y_action", eact );
-        box3d_angle_y = eact;
+void
+Box3DToolbar::resync_toolbar(Inkscape::XML::Node *persp_repr)
+{
+    if (!persp_repr) {
+        g_print ("No perspective given to box3d_resync_toolbar().\n");
+        return;
     }
 
-    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 );
+    Persp3D *persp = persp3d_get_from_repr(persp_repr);
+    if (!persp) {
+        // Hmm, is it an error if this happens?
+        return;
     }
+    set_button_and_adjustment(persp, Proj::X,
+                              _angle_x_adj,
+                              GTK_ACTION(_angle_x_action),
+                              GTK_TOGGLE_ACTION(_vp_x_state_action));
+    set_button_and_adjustment(persp, Proj::Y,
+                              _angle_y_adj,
+                              GTK_ACTION(_angle_y_action),
+                              GTK_TOGGLE_ACTION(_vp_y_state_action));
+    set_button_and_adjustment(persp, Proj::Z,
+                              _angle_z_adj,
+                              GTK_ACTION(_angle_z_action),
+                              GTK_TOGGLE_ACTION(_vp_z_state_action));
+}
 
-    /* VP Y state */
-    {
-        InkToggleAction* act = ink_toggle_action_new( "3DBoxVPYStateAction",
-                                                      // Translators: VP is short for 'vanishing point'
-                                                      _("State of VP in Y direction"),
-                                                      _("Toggle VP in Y direction between 'finite' and 'infinite' (=parallel)"),
-                                                      INKSCAPE_ICON("perspective-parallel"),
-                                                      GTK_ICON_SIZE_MENU );
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        g_object_set_data( holder, "box3d_vp_y_state_action", act );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(box3d_vp_y_state_changed), box3d_angle_y );
-        gtk_action_set_sensitive( GTK_ACTION(box3d_angle_y), !prefs->getBool("/tools/shapes/3dbox/vp_y_state", true) );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/shapes/3dbox/vp_y_state", true) );
-    }
+void
+Box3DToolbar::set_button_and_adjustment(Persp3D                        *persp,
+                                        Proj::Axis                      axis,
+                                        Glib::RefPtr<Gtk::Adjustment>&  adj,
+                                        GtkAction                      *act,
+                                        GtkToggleAction                *tact)
+{
+    // TODO: Take all selected perspectives into account but don't touch the state button if not all of them
+    //       have the same state (otherwise a call to box3d_vp_z_state_changed() is triggered and the states
+    //       are reset).
+    bool is_infinite = !persp3d_VP_is_finite(persp->perspective_impl, axis);
 
-    /* Angle Z */
-    {
-        gchar const* labels[] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
-        gdouble values[] = {-90, -60, -30, 0, 30, 60, 90};
-        eact = create_adjustment_action( "3DBoxAngleZAction",
-                                         _("Angle in Z direction"), _("Angle Z:"),
-                                         // Translators: PL is short for 'perspective line'
-                                         _("Angle of PLs in Z direction"),
-                                         "/tools/shapes/3dbox/box3d_angle_z", 30,
-                                         GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
-                                         -360.0, 360.0, 1.0, 10.0,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         box3d_angle_z_value_changed );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        g_object_set_data( holder, "box3d_angle_z_action", eact );
-        box3d_angle_z = eact;
-    }
+    if (is_infinite) {
+        gtk_toggle_action_set_active(tact, TRUE);
+        gtk_action_set_sensitive(act, TRUE);
 
-    if (!persp_impl || !persp3d_VP_is_finite(persp_impl, Proj::Z)) {
-        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+        double angle = persp3d_get_infinite_angle(persp, axis);
+        if (angle != Geom::infinity()) { // FIXME: We should catch this error earlier (don't show the spinbutton at all)
+            adj->set_value(normalize_angle(angle));
+        }
     } else {
-        gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
+        gtk_toggle_action_set_active(tact, FALSE);
+        gtk_action_set_sensitive(act, FALSE);
     }
+}
 
-    /* VP Z state */
-    {
-        InkToggleAction* act = ink_toggle_action_new( "3DBoxVPZStateAction",
-                                                      // Translators: VP is short for 'vanishing point'
-                                                      _("State of VP in Z direction"),
-                                                      _("Toggle VP in Z direction between 'finite' and 'infinite' (=parallel)"),
-                                                      INKSCAPE_ICON("perspective-parallel"),
-                                                      GTK_ICON_SIZE_MENU );
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        g_object_set_data( holder, "box3d_vp_z_state_action", act );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(box3d_vp_z_state_changed), box3d_angle_z );
-        gtk_action_set_sensitive( GTK_ACTION(box3d_angle_z), !prefs->getBool("/tools/shapes/3dbox/vp_z_state", true) );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/shapes/3dbox/vp_z_state", true) );
+void
+Box3DToolbar::event_attr_changed(Inkscape::XML::Node *repr,
+                                 gchar const         * /*name*/,
+                                 gchar const         * /*old_value*/,
+                                 gchar const         * /*new_value*/,
+                                 bool                  /*is_interactive*/,
+                                 gpointer              data)
+{
+    auto toolbar = reinterpret_cast<Box3DToolbar*>(data);
+
+    // quit if run by the attr_changed or selection changed listener
+    if (toolbar->_freeze) {
+        return;
     }
 
-    desktop->connectEventContextChanged(sigc::bind(sigc::ptr_fun(box3d_toolbox_check_ec), holder));
-    g_signal_connect(holder, "destroy", G_CALLBACK(purge_repr_listener), holder);
+    // set freeze so that it can be caught in box3d_angle_z_value_changed() (to avoid calling
+    // SPDocumentUndo::maybeDone() when the document is undo insensitive)
+    toolbar->_freeze = true;
+
+    // TODO: Only update the appropriate part of the toolbar
+//    if (!strcmp(name, "inkscape:vp_z")) {
+        toolbar->resync_toolbar(repr);
+//    }
+
+    Persp3D *persp = persp3d_get_from_repr(repr);
+    persp3d_update_box_reprs(persp);
+
+    toolbar->_freeze = false;
 }
 
-static void box3d_toolbox_check_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec, GObject* holder)
-{
-    static sigc::connection changed;
-    if (SP_IS_BOX3D_CONTEXT(ec)) {
-        changed = desktop->getSelection()->connectChanged(sigc::bind(sigc::ptr_fun(box3d_toolbox_selection_changed), holder));
-        box3d_toolbox_selection_changed(desktop->getSelection(), holder);
-    } else {
-        if (changed)
-            changed.disconnect();
+/**
+ * \brief normalize angle so that it lies in the interval [0,360]
+ *
+ * TODO: Isn't there something in 2Geom or cmath that does this?
+ */
+double
+Box3DToolbar::normalize_angle(double a) {
+    double angle = a + ((int) (a/360.0))*360;
+    if (angle < 0) {
+        angle += 360.0;
     }
+    return angle;
+}
+
+}
 }
+}
+
 
 /*
   Local Variables:
diff --git a/src/ui/toolbar/box3d-toolbar.h b/src/ui/toolbar/box3d-toolbar.h
index 962a43c25..6ff04cc81 100644
--- a/src/ui/toolbar/box3d-toolbar.h
+++ b/src/ui/toolbar/box3d-toolbar.h
@@ -28,12 +28,83 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "toolbar.h"
 
+#include <gtkmm/adjustment.h>
+
+#include "axis-manip.h"
+
+class Persp3D;
 class SPDesktop;
 
+typedef struct _EgeAdjustmentAction EgeAdjustmentAction;
 typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _GObject GObject;
+typedef struct _InkToggleAction InkToggleAction;
+
+namespace Inkscape {
+class Selection;
+
+namespace XML {
+class Node;
+}
+
+namespace UI {
+namespace Tools {
+class ToolBase;
+}
+
+namespace Toolbar {
+class Box3DToolbar : public Toolbar {
+private:
+    EgeAdjustmentAction *_angle_x_action;
+    EgeAdjustmentAction *_angle_y_action;
+    EgeAdjustmentAction *_angle_z_action;
+
+    Glib::RefPtr<Gtk::Adjustment> _angle_x_adj;
+    Glib::RefPtr<Gtk::Adjustment> _angle_y_adj;
+    Glib::RefPtr<Gtk::Adjustment> _angle_z_adj;
+
+    InkToggleAction *_vp_x_state_action;
+    InkToggleAction *_vp_y_state_action;
+    InkToggleAction *_vp_z_state_action;
+
+    XML::Node *_repr;
+    bool _freeze;
+
+    void angle_value_changed(Glib::RefPtr<Gtk::Adjustment> &adj,
+                             Proj::Axis                     axis);
+    static void vp_state_changed(GtkToggleAction *act,
+                                 Proj::Axis       axis);
+    void check_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec);
+    void selection_changed(Inkscape::Selection *selection);
+    void resync_toolbar(Inkscape::XML::Node *persp_repr);
+    void set_button_and_adjustment(Persp3D                        *persp,
+                                   Proj::Axis                      axis,
+                                   Glib::RefPtr<Gtk::Adjustment>&  adj,
+                                   GtkAction                      *act,
+                                   GtkToggleAction                *tact);
+    double normalize_angle(double a);
+
+    sigc::connection _changed;
+
+protected:
+    Box3DToolbar(SPDesktop *desktop)
+        : Toolbar(desktop),
+        _repr(nullptr)
+    {}
+    ~Box3DToolbar();
 
-void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
+public:
+    static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions);
+    static void event_attr_changed(Inkscape::XML::Node *repr,
+                                   gchar const         *name,
+                                   gchar const         *old_value,
+                                   gchar const         *new_value,
+                                   bool                 is_interactive,
+                                   gpointer             data);
 
+};
+}
+}
+}
 #endif /* !SEEN_BOX3D_TOOLBAR_H */
diff --git a/src/ui/toolbar/calligraphy-toolbar.cpp b/src/ui/toolbar/calligraphy-toolbar.cpp
index 2a9d7b0d9..a2908401e 100644
--- a/src/ui/toolbar/calligraphy-toolbar.cpp
+++ b/src/ui/toolbar/calligraphy-toolbar.cpp
@@ -58,129 +58,8 @@ std::vector<Glib::ustring> get_presets_list() {
     return presets;
 }
 
-void update_presets_list(GObject *tbl)
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    if (g_object_get_data(tbl, "presets_blocked")) {
-        return;
-    }
-
-    InkSelectOneAction *act = static_cast<InkSelectOneAction *>(g_object_get_data(tbl, "profile_selector"));
-
-    std::vector<Glib::ustring> presets = get_presets_list();
-
-    int index = 1;  // 0 is for no preset.
-    for (std::vector<Glib::ustring>::iterator i = presets.begin(); i != presets.end(); ++i, ++index) {
-        bool match = true;
-
-        std::vector<Inkscape::Preferences::Entry> preset = prefs->getAllEntries(*i);
-        for (auto & j : preset) {
-            Glib::ustring entry_name = j.getEntryName();
-            if (entry_name == "id" || entry_name == "name") {
-                continue;
-            }
-
-            void *widget = g_object_get_data(tbl, entry_name.data());
-            if (widget) {
-                if (GTK_IS_ADJUSTMENT(widget)) {
-                    double v = j.getDouble();
-                    GtkAdjustment* adj = static_cast<GtkAdjustment *>(widget);
-                    //std::cout << "compared adj " << attr_name << gtk_adjustment_get_value(adj) << " to " << v << "\n";
-                    if (fabs(gtk_adjustment_get_value(adj) - v) > 1e-6) {
-                        match = false;
-                        break;
-                    }
-                } else if (GTK_IS_TOGGLE_ACTION(widget)) {
-                    bool v = j.getBool();
-                    GtkToggleAction* toggle = static_cast<GtkToggleAction *>(widget);
-                    //std::cout << "compared toggle " << attr_name << gtk_toggle_action_get_active(toggle) << " to " << v << "\n";
-                    if ( static_cast<bool>(gtk_toggle_action_get_active(toggle)) != v ) {
-                        match = false;
-                        break;
-                    }
-                }
-            }
-        }
-
-        if (match) {
-            // newly added item is at the same index as the
-            // save command, so we need to change twice for it to take effect
-            act->set_active(0);
-            act->set_active(index);
-            return;
-        }
-    }
-
-    // no match found
-    act->set_active(0);
-}
-
-static void sp_ddc_mass_value_changed( GtkAdjustment *adj, GObject* tbl )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/calligraphic/mass", gtk_adjustment_get_value(adj) );
-    update_presets_list(tbl);
-}
-
-static void sp_ddc_wiggle_value_changed( GtkAdjustment *adj, GObject* tbl )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/calligraphic/wiggle", gtk_adjustment_get_value(adj) );
-    update_presets_list(tbl);
-}
-
-static void sp_ddc_angle_value_changed( GtkAdjustment *adj, GObject* tbl )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/calligraphic/angle", gtk_adjustment_get_value(adj) );
-    update_presets_list(tbl);
-}
-
-static void sp_ddc_width_value_changed( GtkAdjustment *adj, GObject *tbl )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/calligraphic/width", gtk_adjustment_get_value(adj) );
-    update_presets_list(tbl);
-}
-
-static void sp_ddc_velthin_value_changed( GtkAdjustment *adj, GObject* tbl )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble("/tools/calligraphic/thinning", gtk_adjustment_get_value(adj) );
-    update_presets_list(tbl);
-}
-
-static void sp_ddc_flatness_value_changed( GtkAdjustment *adj, GObject* tbl )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/calligraphic/flatness", gtk_adjustment_get_value(adj) );
-    update_presets_list(tbl);
-}
-
-static void sp_ddc_tremor_value_changed( GtkAdjustment *adj, GObject* tbl )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/calligraphic/tremor", gtk_adjustment_get_value(adj) );
-    update_presets_list(tbl);
-}
-
-static void sp_ddc_cap_rounding_value_changed( GtkAdjustment *adj, GObject* tbl )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/calligraphic/cap_rounding", gtk_adjustment_get_value(adj) );
-    update_presets_list(tbl);
-}
-
-static void sp_ddc_tilt_state_changed( GtkToggleAction *act, GObject*  tbl )
-{
-    // TODO merge into PrefPusher
-    GtkAction * calligraphy_angle = static_cast<GtkAction *> (g_object_get_data(tbl,"angle_action"));
-    if (calligraphy_angle ) {
-        gtk_action_set_sensitive( calligraphy_angle, !gtk_toggle_action_get_active( act ) );
-    }
-}
-
 
+#if 0
 static gchar const *const widget_names[] = {
     "width",
     "mass",
@@ -194,200 +73,29 @@ static gchar const *const widget_names[] = {
     "tracebackground",
     "usetilt"
 };
+#endif
 
 
-static void sp_dcc_build_presets_list(GObject *tbl)
-{
-    g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(TRUE));
-
-    InkSelectOneAction* act = static_cast<InkSelectOneAction *>(g_object_get_data(tbl, "profile_selector"));
-
-    Glib::RefPtr<Gtk::ListStore> store = act->get_store();
-    store->clear();
-
-    InkSelectOneActionColumns columns;
-
-    Gtk::TreeModel::Row row;
-
-    row = *(store->append());
-    row[columns.col_label    ] = _("No preset");
-    row[columns.col_sensitive] = true;
-
-    // iterate over all presets to populate the list
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    std::vector<Glib::ustring> presets = get_presets_list();
-    int ii=1;
-
-    for (auto & preset : presets) {
-        GtkTreeIter iter;
-        Glib::ustring preset_name = prefs->getString(preset + "/name");
-
-        if (!preset_name.empty()) {
-            row = *(store->append());
-            row[columns.col_label    ] = _(preset_name.data());
-            row[columns.col_sensitive] = true;
-        }
-    }
-
-    g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(FALSE));
-
-    update_presets_list (tbl);
-}
-
-static void sp_dcc_save_profile(GtkWidget * /*widget*/, GObject *tbl)
-{
-    using Inkscape::UI::Dialog::CalligraphicProfileRename;
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(tbl, "desktop" ));
-    if (! desktop) {
-        return;
-    }
-
-    if (g_object_get_data(tbl, "presets_blocked")) {
-        return;
-    }
-
-    InkSelectOneAction *act = static_cast<InkSelectOneAction *>(g_object_get_data(tbl, "profile_selector"));
-
-    Glib::ustring current_profile_name = act->get_active_text();
-
-    if (current_profile_name == _("No preset")) {
-        current_profile_name = "";
-    }
-
-    CalligraphicProfileRename::show(desktop, current_profile_name);
-    if ( !CalligraphicProfileRename::applied()) {
-        // dialog cancelled
-        update_presets_list (tbl);
-        return;
-    }
-    Glib::ustring new_profile_name = CalligraphicProfileRename::getProfileName();
-
-    if (new_profile_name.empty()) {
-        // empty name entered
-        update_presets_list (tbl);
-        return;
-    }
-
-    g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(TRUE));
-
-    // If there's a preset with the given name, find it and set save_path appropriately
-    std::vector<Glib::ustring> presets = get_presets_list();
-    int total_presets = presets.size();
-    int new_index = -1;
-    Glib::ustring save_path; // profile pref path without a trailing slash
-
-    int temp_index = 0;
-    for (std::vector<Glib::ustring>::iterator i = presets.begin(); i != presets.end(); ++i, ++temp_index) {
-        Glib::ustring name = prefs->getString(*i + "/name");
-        if (!name.empty() && (new_profile_name == name || current_profile_name == name)) {
-            new_index = temp_index;
-            save_path = *i;
-            break;
-        }
-    }
-
-
-    if ( CalligraphicProfileRename::deleted() && new_index != -1) {
-        prefs->remove(save_path);
-        g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(FALSE));
-        sp_dcc_build_presets_list (tbl);
-        return;
-    }
-
-    if (new_index == -1) {
-        // no preset with this name, create
-        new_index = total_presets + 1;
-        gchar *profile_id = g_strdup_printf("/dcc%d", new_index);
-        save_path = Glib::ustring("/tools/calligraphic/preset") + profile_id;
-        g_free(profile_id);
-    }
-
-    for (auto widget_name : widget_names) {
-        void *widget = g_object_get_data(tbl, widget_name);
-        if (widget) {
-            if (GTK_IS_ADJUSTMENT(widget)) {
-                GtkAdjustment* adj = static_cast<GtkAdjustment *>(widget);
-                prefs->setDouble(save_path + "/" + widget_name, gtk_adjustment_get_value(adj));
-                //std::cout << "wrote adj " << widget_name << ": " << v << "\n";
-            } else if (GTK_IS_TOGGLE_ACTION(widget)) {
-                GtkToggleAction* toggle = static_cast<GtkToggleAction *>(widget);
-                prefs->setBool(save_path + "/" + widget_name, gtk_toggle_action_get_active(toggle));
-                //std::cout << "wrote tog " << widget_name << ": " << v << "\n";
-            } else {
-                g_warning("Unknown widget type for preset: %s\n", widget_name);
-            }
-        } else {
-            g_warning("Bad key when writing preset: %s\n", widget_name);
-        }
-    }
-    prefs->setString(save_path + "/name", new_profile_name);
-
-    g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(FALSE));
-    sp_dcc_build_presets_list (tbl);
-}
 
+namespace Inkscape {
+namespace UI {
+namespace Toolbar {
 
-static void sp_ddc_change_profile(GObject* tbl, int mode)
+CalligraphyToolbar::~CalligraphyToolbar()
 {
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-
-    if (g_object_get_data(tbl, "presets_blocked")) {
-        return;
-    }
-
-    // mode is one-based so we subtract 1
-    std::vector<Glib::ustring> presets = get_presets_list();
-
-    Glib::ustring preset_path = "";
-    if (mode - 1 < presets.size()) {
-        preset_path = presets.at(mode - 1);
-    }
-
-    if (!preset_path.empty()) {
-        g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(TRUE)); //temporarily block the selector so no one will updadte it while we're reading it
-
-        std::vector<Inkscape::Preferences::Entry> preset = prefs->getAllEntries(preset_path);
-
-        // Shouldn't this be std::map?
-        for (auto & i : preset) {
-            Glib::ustring entry_name = i.getEntryName();
-            if (entry_name == "id" || entry_name == "name") {
-                continue;
-            }
-            void *widget = g_object_get_data(tbl, entry_name.data());
-            if (widget) {
-                if (GTK_IS_ADJUSTMENT(widget)) {
-                    GtkAdjustment* adj = static_cast<GtkAdjustment *>(widget);
-                    gtk_adjustment_set_value(adj, i.getDouble());
-                    //std::cout << "set adj " << attr_name << " to " << v << "\n";
-                } else if (GTK_IS_TOGGLE_ACTION(widget)) {
-                    GtkToggleAction* toggle = static_cast<GtkToggleAction *>(widget);
-                    gtk_toggle_action_set_active(toggle, i.getBool());
-                    //std::cout << "set toggle " << attr_name << " to " << v << "\n";
-                } else {
-                    g_warning("Unknown widget type for preset: %s\n", entry_name.data());
-                }
-            } else {
-                g_warning("Bad key found in a preset record: %s\n", entry_name.data());
-            }
-        }
-        g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(FALSE));
-    }
+    if(_tracebackground_pusher) delete _tracebackground_pusher;
+    if(_usepressure_pusher)     delete _usepressure_pusher;
+    if(_usetilt_pusher)         delete _usetilt_pusher;
 }
 
-static void sp_ddc_edit_profile(GtkAction * /*act*/, GObject* tbl)
+GtkWidget *
+CalligraphyToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
 {
-    sp_dcc_save_profile(nullptr, tbl);
-}
+    auto toolbar = new CalligraphyToolbar(desktop);
 
-void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
-{
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     {
-        g_object_set_data(holder, "presets_blocked", GINT_TO_POINTER(TRUE));
-
-        EgeAdjustmentAction* calligraphy_angle = nullptr;
+        toolbar->_presets_blocked = true;
 
         {
         /* Width */
@@ -397,10 +105,16 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
                                                               _("Pen Width"), _("Width:"),
                                                               _("The width of the calligraphic pen (relative to the visible canvas area)"),
                                                               "/tools/calligraphic/width", 15,
-                                                              GTK_WIDGET(desktop->canvas), holder, TRUE, "altx-calligraphy",
+                                                              GTK_WIDGET(desktop->canvas),
+                                                              nullptr, // dataKludge
+                                                              TRUE, "altx-calligraphy",
                                                               1, 100, 1.0, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
-                                                              sp_ddc_width_value_changed, nullptr /*unit tracker*/, 1, 0 );
+                                                              nullptr, // callback
+                                                              nullptr /*unit tracker*/, 1, 0 );
+        toolbar->_width_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        toolbar->_width_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &CalligraphyToolbar::width_value_changed));
+        toolbar->_widget_map["width"] = G_OBJECT(toolbar->_width_adj->gobj());
         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 );
@@ -414,10 +128,16 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
                                                               _("Stroke Thinning"), _("Thinning:"),
                                                               _("How much velocity thins the stroke (> 0 makes fast strokes thinner, < 0 makes them broader, 0 makes width independent of velocity)"),
                                                               "/tools/calligraphic/thinning", 10,
-                                                              GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
+                                                              GTK_WIDGET(desktop->canvas),
+                                                              nullptr, // dataKludge
+                                                              FALSE, nullptr,
                                                               -100, 100, 1, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
-                                                              sp_ddc_velthin_value_changed, nullptr /*unit tracker*/, 1, 0);
+                                                              nullptr, // callback
+                                                              nullptr /*unit tracker*/, 1, 0);
+        toolbar->_thinning_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        toolbar->_thinning_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &CalligraphyToolbar::velthin_value_changed));
+        toolbar->_widget_map["thinning"] = G_OBJECT(toolbar->_thinning_adj->gobj());
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
         }
@@ -426,18 +146,22 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
         /* Angle */
         gchar const* labels[] = {_("(left edge up)"), nullptr, nullptr, _("(horizontal)"), _("(default)"), nullptr, _("(right edge up)")};
         gdouble values[] = {-90, -60, -30, 0, 30, 60, 90};
-        EgeAdjustmentAction* eact = create_adjustment_action( "AngleAction",
-                                                              _("Pen Angle"), _("Angle:"),
-                                                              _("The angle of the pen's nib (in degrees; 0 = horizontal; has no effect if fixation = 0)"),
-                                                              "/tools/calligraphic/angle", 30,
-                                                              GTK_WIDGET(desktop->canvas), holder, TRUE, "calligraphy-angle",
-                                                              -90.0, 90.0, 1.0, 10.0,
-                                                              labels, values, G_N_ELEMENTS(labels),
-                                                              sp_ddc_angle_value_changed, nullptr /*unit tracker*/, 1, 0 );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        g_object_set_data( holder, "angle_action", eact );
-        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
-        calligraphy_angle = eact;
+        toolbar->_angle_action = create_adjustment_action( "AngleAction",
+                                                           _("Pen Angle"), _("Angle:"),
+                                                           _("The angle of the pen's nib (in degrees; 0 = horizontal; has no effect if fixation = 0)"),
+                                                           "/tools/calligraphic/angle", 30,
+                                                           GTK_WIDGET(desktop->canvas),
+                                                           nullptr, // dataKludge
+                                                           TRUE, "calligraphy-angle",
+                                                           -90.0, 90.0, 1.0, 10.0,
+                                                           labels, values, G_N_ELEMENTS(labels),
+                                                           nullptr, // callback
+                                                           nullptr /*unit tracker*/, 1, 0 );
+        toolbar->_angle_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_angle_action));
+        toolbar->_angle_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &CalligraphyToolbar::angle_value_changed));
+        toolbar->_widget_map["angle"] = G_OBJECT(toolbar->_angle_adj->gobj());
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_angle_action) );
+        gtk_action_set_sensitive( GTK_ACTION(toolbar->_angle_action), TRUE );
         }
 
         {
@@ -448,10 +172,16 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
                                                               _("Fixation"), _("Fixation:"),
                                                               _("Angle behavior (0 = nib always perpendicular to stroke direction, 100 = fixed angle)"),
                                                               "/tools/calligraphic/flatness", 90,
-                                                              GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
+                                                              GTK_WIDGET(desktop->canvas),
+                                                              nullptr, // dataKludge
+                                                              FALSE, nullptr,
                                                               0.0, 100, 1.0, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
-                                                              sp_ddc_flatness_value_changed, nullptr /*unit tracker*/, 1, 0);
+                                                              nullptr, // callback
+                                                              nullptr /*unit tracker*/, 1, 0);
+        toolbar->_fixation_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        toolbar->_fixation_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &CalligraphyToolbar::flatness_value_changed));
+        toolbar->_widget_map["flatness"] = G_OBJECT(toolbar->_fixation_adj->gobj());
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
         }
@@ -465,10 +195,16 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
                                                               _("Cap rounding"), _("Caps:"),
                                                               _("Increase to make caps at the ends of strokes protrude more (0 = no caps, 1 = round caps)"),
                                                               "/tools/calligraphic/cap_rounding", 0.0,
-                                                              GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
+                                                              GTK_WIDGET(desktop->canvas),
+                                                              nullptr, // dataKludge
+                                                              FALSE, nullptr,
                                                               0.0, 5.0, 0.01, 0.1,
                                                               labels, values, G_N_ELEMENTS(labels),
-                                                              sp_ddc_cap_rounding_value_changed, nullptr /*unit tracker*/, 0.01, 2 );
+                                                              nullptr, // callback
+                                                              nullptr /*unit tracker*/, 0.01, 2 );
+        toolbar->_cap_rounding_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        toolbar->_cap_rounding_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &CalligraphyToolbar::cap_rounding_value_changed));
+        toolbar->_widget_map["cap_rounding"] = G_OBJECT(toolbar->_cap_rounding_adj->gobj());
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
         }
@@ -481,11 +217,17 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
                                                               _("Stroke Tremor"), _("Tremor:"),
                                                               _("Increase to make strokes rugged and trembling"),
                                                               "/tools/calligraphic/tremor", 0.0,
-                                                              GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
+                                                              GTK_WIDGET(desktop->canvas),
+                                                              nullptr, // dataKludge
+                                                              FALSE, nullptr,
                                                               0.0, 100, 1, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
-                                                              sp_ddc_tremor_value_changed, nullptr /*unit tracker*/, 1, 0);
+                                                              nullptr, // callback
+                                                              nullptr /*unit tracker*/, 1, 0);
 
+        toolbar->_tremor_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        toolbar->_tremor_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &CalligraphyToolbar::tremor_value_changed));
+        toolbar->_widget_map["tremor"] = G_OBJECT(toolbar->_tremor_adj->gobj());
         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 );
@@ -499,10 +241,16 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
                                                               _("Pen Wiggle"), _("Wiggle:"),
                                                               _("Increase to make the pen waver and wiggle"),
                                                               "/tools/calligraphic/wiggle", 0.0,
-                                                              GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
+                                                              GTK_WIDGET(desktop->canvas),
+                                                              nullptr, // dataKludge
+                                                              FALSE, nullptr,
                                                               0.0, 100, 1, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
-                                                              sp_ddc_wiggle_value_changed, nullptr /*unit tracker*/, 1, 0);
+                                                              nullptr, // callback
+                                                              nullptr /*unit tracker*/, 1, 0);
+        toolbar->_wiggle_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        toolbar->_wiggle_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &CalligraphyToolbar::wiggle_value_changed));
+        toolbar->_widget_map["wiggle"] = G_OBJECT(toolbar->_wiggle_adj->gobj());
         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 );
@@ -516,10 +264,16 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
                                                               _("Pen Mass"), _("Mass:"),
                                                               _("Increase to make the pen drag behind, as if slowed by inertia"),
                                                               "/tools/calligraphic/mass", 2.0,
-                                                              GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
+                                                              GTK_WIDGET(desktop->canvas),
+                                                              nullptr, // dataKludge
+                                                              FALSE, nullptr,
                                                               0.0, 100, 1, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
-                                                              sp_ddc_mass_value_changed, nullptr /*unit tracker*/, 1, 0);
+                                                              nullptr, // callback
+                                                              nullptr /*unit tracker*/, 1, 0);
+        toolbar->_mass_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        toolbar->_mass_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &CalligraphyToolbar::mass_value_changed));
+        toolbar->_widget_map["mass"] = G_OBJECT(toolbar->_mass_adj->gobj());
         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 );
@@ -528,44 +282,41 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
 
         /* Trace Background button */
         {
-            InkToggleAction* act = ink_toggle_action_new( "TraceAction",
-                                                          _("Trace Background"),
-                                                          _("Trace the lightness of the background by the width of the pen (white - minimum width, black - maximum width)"),
-                                                          INKSCAPE_ICON("draw-trace-background"),
-                                                          GTK_ICON_SIZE_MENU );
-            gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-            PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/calligraphic/tracebackground", update_presets_list, holder);
-            g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
-            g_object_set_data( holder, "tracebackground", act );
+            toolbar->_tracebackground = ink_toggle_action_new( "TraceAction",
+                                                               _("Trace Background"),
+                                                               _("Trace the lightness of the background by the width of the pen (white - minimum width, black - maximum width)"),
+                                                               INKSCAPE_ICON("draw-trace-background"),
+                                                               GTK_ICON_SIZE_MENU );
+            toolbar->_widget_map["tracebackground"] = G_OBJECT(toolbar->_tracebackground);
+            gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_tracebackground ) );
+            toolbar->_tracebackground_pusher = new PrefPusher(GTK_TOGGLE_ACTION(toolbar->_tracebackground), "/tools/calligraphic/tracebackground", update_presets_list, gpointer(toolbar));
         }
 
         /* Use Pressure button */
         {
-            InkToggleAction* act = ink_toggle_action_new( "PressureAction",
-                                                          _("Pressure"),
-                                                          _("Use the pressure of the input device to alter the width of the pen"),
-                                                          INKSCAPE_ICON("draw-use-pressure"),
-                                                          GTK_ICON_SIZE_MENU );
-            gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-            PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/calligraphic/usepressure", update_presets_list, holder);
-            g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
-            g_object_set_data( holder, "usepressure", act );
+            toolbar->_usepressure = ink_toggle_action_new( "PressureAction",
+                                                           _("Pressure"),
+                                                           _("Use the pressure of the input device to alter the width of the pen"),
+                                                           INKSCAPE_ICON("draw-use-pressure"),
+                                                           GTK_ICON_SIZE_MENU );
+            toolbar->_widget_map["usepressure"] = G_OBJECT(toolbar->_usepressure);
+            gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_usepressure ) );
+            toolbar->_usepressure_pusher = new PrefPusher(GTK_TOGGLE_ACTION(toolbar->_usepressure), "/tools/calligraphic/usepressure", update_presets_list, gpointer(toolbar));
         }
 
         /* Use Tilt button */
         {
-            InkToggleAction* act = ink_toggle_action_new( "TiltAction",
-                                                          _("Tilt"),
-                                                          _("Use the tilt of the input device to alter the angle of the pen's nib"),
-                                                          INKSCAPE_ICON("draw-use-tilt"),
-                                                          GTK_ICON_SIZE_MENU );
-            gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-            PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/calligraphic/usetilt", update_presets_list, holder);
-            g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
-            g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_ddc_tilt_state_changed), holder );
-            gtk_action_set_sensitive( GTK_ACTION(calligraphy_angle), !prefs->getBool("/tools/calligraphic/usetilt", true) );
-            gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/calligraphic/usetilt", true) );
-            g_object_set_data( holder, "usetilt", act );
+            toolbar->_usetilt = ink_toggle_action_new( "TiltAction",
+                                                       _("Tilt"),
+                                                       _("Use the tilt of the input device to alter the angle of the pen's nib"),
+                                                       INKSCAPE_ICON("draw-use-tilt"),
+                                                       GTK_ICON_SIZE_MENU );
+            toolbar->_widget_map["usetilt"] = G_OBJECT(toolbar->_usetilt);
+            gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_usetilt ) );
+            toolbar->_usetilt_pusher = new PrefPusher(GTK_TOGGLE_ACTION(toolbar->_usetilt), "/tools/calligraphic/usetilt", update_presets_list, gpointer(toolbar));
+            g_signal_connect_after( G_OBJECT(toolbar->_usetilt), "toggled", G_CALLBACK(tilt_state_changed), toolbar );
+            gtk_action_set_sensitive( GTK_ACTION(toolbar->_angle_action), !prefs->getBool("/tools/calligraphic/usetilt", true) );
+            gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(toolbar->_usetilt), prefs->getBool("/tools/calligraphic/usetilt", true) );
         }
 
         /*calligraphic profile */
@@ -574,22 +325,20 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
 
             Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
 
-            InkSelectOneAction* act =
+            toolbar->_profile_selector =
                 InkSelectOneAction::create( "SetProfileAction",   // Name
                                             "",                   // Label
                                             _("Choose a preset"), // Tooltip
                                             "NotUsed",            // Icon
                                             store );              // Tree store
-            act->use_radio( false );
-            act->use_label( true );
+            toolbar->_profile_selector->use_radio( false );
+            toolbar->_profile_selector->use_label( true );
 
-            g_object_set_data (holder, "profile_selector", act);
+            toolbar->build_presets_list();
 
-            sp_dcc_build_presets_list (holder);
+            gtk_action_group_add_action(mainActions, GTK_ACTION( toolbar->_profile_selector->gobj() ));
 
-            gtk_action_group_add_action(mainActions, GTK_ACTION( act->gobj() ));
-
-            act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_ddc_change_profile), holder));
+            toolbar->_profile_selector->signal_changed().connect(sigc::mem_fun(*toolbar, &CalligraphyToolbar::change_profile));
         }
 
         /*calligraphic profile editor */
@@ -599,11 +348,335 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
                                               _("Add or edit calligraphic profile"),
                                               INKSCAPE_ICON("document-properties"),
                                               GTK_ICON_SIZE_MENU );
-            g_object_set( inky, "short_label", _("Edit"), NULL );
-            g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_ddc_edit_profile), (GObject*)holder );
+            gtk_action_set_short_label(GTK_ACTION(inky), _("Edit"));
+            g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(edit_profile), toolbar );
             gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
         }
     }
+
+    return GTK_WIDGET(toolbar->gobj());
+}
+
+void
+CalligraphyToolbar::width_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/calligraphic/width", _width_adj->get_value() );
+    update_presets_list(this);
+}
+
+void
+CalligraphyToolbar::velthin_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble("/tools/calligraphic/thinning", _thinning_adj->get_value() );
+    update_presets_list(this);
+}
+
+void
+CalligraphyToolbar::angle_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/calligraphic/angle", _angle_adj->get_value() );
+    update_presets_list(this);
+}
+
+void
+CalligraphyToolbar::flatness_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/calligraphic/flatness", _fixation_adj->get_value() );
+    update_presets_list(this);
+}
+
+void
+CalligraphyToolbar::cap_rounding_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/calligraphic/cap_rounding", _cap_rounding_adj->get_value() );
+    update_presets_list(this);
+}
+
+void
+CalligraphyToolbar::tremor_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/calligraphic/tremor", _tremor_adj->get_value() );
+    update_presets_list(this);
+}
+
+void
+CalligraphyToolbar::wiggle_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/calligraphic/wiggle", _wiggle_adj->get_value() );
+    update_presets_list(this);
+}
+
+void
+CalligraphyToolbar::mass_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/calligraphic/mass", _mass_adj->get_value() );
+    update_presets_list(this);
+}
+
+void
+CalligraphyToolbar::update_presets_list(gpointer data)
+{
+    auto toolbar = reinterpret_cast<CalligraphyToolbar *>(data);
+
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    if (toolbar->_presets_blocked) {
+        return;
+    }
+
+    std::vector<Glib::ustring> presets = get_presets_list();
+
+    int index = 1;  // 0 is for no preset.
+    for (std::vector<Glib::ustring>::iterator i = presets.begin(); i != presets.end(); ++i, ++index) {
+        bool match = true;
+
+        std::vector<Inkscape::Preferences::Entry> preset = prefs->getAllEntries(*i);
+        for (auto & j : preset) {
+            Glib::ustring entry_name = j.getEntryName();
+            if (entry_name == "id" || entry_name == "name") {
+                continue;
+            }
+
+            void *widget = toolbar->_widget_map[entry_name.data()];
+            if (widget) {
+                if (GTK_IS_ADJUSTMENT(widget)) {
+                    double v = j.getDouble();
+                    GtkAdjustment* adj = static_cast<GtkAdjustment *>(widget);
+                    //std::cout << "compared adj " << attr_name << gtk_adjustment_get_value(adj) << " to " << v << "\n";
+                    if (fabs(gtk_adjustment_get_value(adj) - v) > 1e-6) {
+                        match = false;
+                        break;
+                    }
+                } else if (GTK_IS_TOGGLE_ACTION(widget)) {
+                    bool v = j.getBool();
+                    GtkToggleAction* toggle = static_cast<GtkToggleAction *>(widget);
+                    //std::cout << "compared toggle " << attr_name << gtk_toggle_action_get_active(toggle) << " to " << v << "\n";
+                    if ( static_cast<bool>(gtk_toggle_action_get_active(toggle)) != v ) {
+                        match = false;
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (match) {
+            // newly added item is at the same index as the
+            // save command, so we need to change twice for it to take effect
+            toolbar->_profile_selector->set_active(0);
+            toolbar->_profile_selector->set_active(index);
+            return;
+        }
+    }
+
+    // no match found
+    toolbar->_profile_selector->set_active(0);
+}
+
+void
+CalligraphyToolbar::tilt_state_changed( GtkToggleAction *act, gpointer data )
+{
+    auto toolbar = reinterpret_cast<CalligraphyToolbar *>(data);
+
+    // TODO merge into PrefPusher
+    if (toolbar->_angle_action) {
+        gtk_action_set_sensitive( GTK_ACTION(toolbar->_angle_action), !gtk_toggle_action_get_active( act ) );
+    }
+}
+
+void
+CalligraphyToolbar::build_presets_list()
+{
+    _presets_blocked = true;
+
+    auto store = _profile_selector->get_store();
+    store->clear();
+
+    InkSelectOneActionColumns columns;
+
+    Gtk::TreeModel::Row row;
+
+    row = *(store->append());
+    row[columns.col_label    ] = _("No preset");
+    row[columns.col_sensitive] = true;
+
+    // iterate over all presets to populate the list
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    std::vector<Glib::ustring> presets = get_presets_list();
+    int ii=1;
+
+    for (auto & preset : presets) {
+        GtkTreeIter iter;
+        Glib::ustring preset_name = prefs->getString(preset + "/name");
+
+        if (!preset_name.empty()) {
+            row = *(store->append());
+            row[columns.col_label    ] = _(preset_name.data());
+            row[columns.col_sensitive] = true;
+        }
+    }
+
+    _presets_blocked = false;
+
+    update_presets_list(this);
+}
+
+void
+CalligraphyToolbar::change_profile(int mode)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+    if (_presets_blocked) {
+        return;
+    }
+
+    // mode is one-based so we subtract 1
+    std::vector<Glib::ustring> presets = get_presets_list();
+
+    Glib::ustring preset_path = "";
+    if (mode - 1 < presets.size()) {
+        preset_path = presets.at(mode - 1);
+    }
+
+    if (!preset_path.empty()) {
+        _presets_blocked = true; //temporarily block the selector so no one will updadte it while we're reading it
+
+        std::vector<Inkscape::Preferences::Entry> preset = prefs->getAllEntries(preset_path);
+
+        // Shouldn't this be std::map?
+        for (auto & i : preset) {
+            Glib::ustring entry_name = i.getEntryName();
+            if (entry_name == "id" || entry_name == "name") {
+                continue;
+            }
+            void *widget = _widget_map[entry_name.data()];
+            if (widget) {
+                if (GTK_IS_ADJUSTMENT(widget)) {
+                    GtkAdjustment* adj = static_cast<GtkAdjustment *>(widget);
+                    gtk_adjustment_set_value(adj, i.getDouble());
+                    //std::cout << "set adj " << attr_name << " to " << v << "\n";
+                } else if (GTK_IS_TOGGLE_ACTION(widget)) {
+                    GtkToggleAction* toggle = static_cast<GtkToggleAction *>(widget);
+                    gtk_toggle_action_set_active(toggle, i.getBool());
+                    //std::cout << "set toggle " << attr_name << " to " << v << "\n";
+                } else {
+                    g_warning("Unknown widget type for preset: %s\n", entry_name.data());
+                }
+            } else {
+                g_warning("Bad key found in a preset record: %s\n", entry_name.data());
+            }
+        }
+        _presets_blocked = false;
+    }
+}
+
+void
+CalligraphyToolbar::edit_profile(GtkAction * /*act*/, gpointer data)
+{
+    auto toolbar = reinterpret_cast<CalligraphyToolbar *>(data);
+    toolbar->save_profile(nullptr);
+}
+
+void
+CalligraphyToolbar::save_profile(GtkWidget * /*widget*/)
+{
+    using Inkscape::UI::Dialog::CalligraphicProfileRename;
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    if (! _desktop) {
+        return;
+    }
+
+    if (_presets_blocked) {
+        return;
+    }
+
+    Glib::ustring current_profile_name = _profile_selector->get_active_text();
+
+    if (current_profile_name == _("No preset")) {
+        current_profile_name = "";
+    }
+
+    CalligraphicProfileRename::show(_desktop, current_profile_name);
+    if ( !CalligraphicProfileRename::applied()) {
+        // dialog cancelled
+        update_presets_list(this);
+        return;
+    }
+    Glib::ustring new_profile_name = CalligraphicProfileRename::getProfileName();
+
+    if (new_profile_name.empty()) {
+        // empty name entered
+        update_presets_list (this);
+        return;
+    }
+
+    _presets_blocked = true;
+
+    // If there's a preset with the given name, find it and set save_path appropriately
+    auto presets = get_presets_list();
+    int total_presets = presets.size();
+    int new_index = -1;
+    Glib::ustring save_path; // profile pref path without a trailing slash
+
+    int temp_index = 0;
+    for (std::vector<Glib::ustring>::iterator i = presets.begin(); i != presets.end(); ++i, ++temp_index) {
+        Glib::ustring name = prefs->getString(*i + "/name");
+        if (!name.empty() && (new_profile_name == name || current_profile_name == name)) {
+            new_index = temp_index;
+            save_path = *i;
+            break;
+        }
+    }
+
+    if ( CalligraphicProfileRename::deleted() && new_index != -1) {
+        prefs->remove(save_path);
+        _presets_blocked = false;
+        build_presets_list();
+        return;
+    }
+
+    if (new_index == -1) {
+        // no preset with this name, create
+        new_index = total_presets + 1;
+        gchar *profile_id = g_strdup_printf("/dcc%d", new_index);
+        save_path = Glib::ustring("/tools/calligraphic/preset") + profile_id;
+        g_free(profile_id);
+    }
+
+    for (auto map_item : _widget_map) {
+        auto widget_name = map_item.first;
+        auto widget      = map_item.second;
+
+        if (widget) {
+            if (GTK_IS_ADJUSTMENT(widget)) {
+                GtkAdjustment* adj = GTK_ADJUSTMENT(widget);
+                prefs->setDouble(save_path + "/" + widget_name, gtk_adjustment_get_value(adj));
+                //std::cout << "wrote adj " << widget_name << ": " << v << "\n";
+            } else if (GTK_IS_TOGGLE_ACTION(widget)) {
+                GtkToggleAction* toggle = GTK_TOGGLE_ACTION(widget);
+                prefs->setBool(save_path + "/" + widget_name, gtk_toggle_action_get_active(toggle));
+                //std::cout << "wrote tog " << widget_name << ": " << v << "\n";
+            } else {
+                g_warning("Unknown widget type for preset: %s\n", widget_name.c_str());
+            }
+        } else {
+            g_warning("Bad key when writing preset: %s\n", widget_name.c_str());
+        }
+    }
+    prefs->setString(save_path + "/name", new_profile_name);
+
+    _presets_blocked = true;
+    build_presets_list();
+}
+
+}
+}
 }
 
 
diff --git a/src/ui/toolbar/calligraphy-toolbar.h b/src/ui/toolbar/calligraphy-toolbar.h
index ea9804d2e..2305a72a2 100644
--- a/src/ui/toolbar/calligraphy-toolbar.h
+++ b/src/ui/toolbar/calligraphy-toolbar.h
@@ -28,12 +28,76 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "toolbar.h"
+#include <gtkmm/adjustment.h>
+
+class InkSelectOneAction;
 class SPDesktop;
 
+typedef struct _EgeAdjustmentAction EgeAdjustmentAction;
 typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _GObject GObject;
+typedef struct _InkToggleAction InkToggleAction;
+
+namespace Inkscape {
+namespace UI {
+class PrefPusher;
+
+namespace Toolbar {
+
+class CalligraphyToolbar : public Toolbar {
+private:
+    bool _presets_blocked;
+
+    EgeAdjustmentAction *_angle_action;
+    InkSelectOneAction *_profile_selector;
+
+    std::map<Glib::ustring, GObject *> _widget_map;
+
+    Glib::RefPtr<Gtk::Adjustment> _width_adj;
+    Glib::RefPtr<Gtk::Adjustment> _mass_adj;
+    Glib::RefPtr<Gtk::Adjustment> _wiggle_adj;
+    Glib::RefPtr<Gtk::Adjustment> _angle_adj;
+    Glib::RefPtr<Gtk::Adjustment> _thinning_adj;
+    Glib::RefPtr<Gtk::Adjustment> _tremor_adj;
+    Glib::RefPtr<Gtk::Adjustment> _fixation_adj;
+    Glib::RefPtr<Gtk::Adjustment> _cap_rounding_adj;
+    InkToggleAction *_usepressure;
+    InkToggleAction *_tracebackground;
+    InkToggleAction *_usetilt;
+
+    PrefPusher *_tracebackground_pusher;
+    PrefPusher *_usepressure_pusher;
+    PrefPusher *_usetilt_pusher;
+
+    void width_value_changed();
+    void velthin_value_changed();
+    void angle_value_changed();
+    void flatness_value_changed();
+    void cap_rounding_value_changed();
+    void tremor_value_changed();
+    void wiggle_value_changed();
+    void mass_value_changed();
+    void build_presets_list();
+    void change_profile(int mode);
+    void save_profile(GtkWidget *widget);
+
+    static void edit_profile(GtkAction *act, gpointer data);
+    static void update_presets_list(gpointer data);
+    static void tilt_state_changed( GtkToggleAction *act, gpointer data );
+    
+protected:
+    CalligraphyToolbar(SPDesktop *desktop)
+        : Toolbar(desktop)
+    {}
+
+    ~CalligraphyToolbar();
+
+public:
+    static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions);
+};
 
-void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
-void update_presets_list(GObject *tbl);
+}
+}
+}
 
 #endif /* !SEEN_CALLIGRAPHY_TOOLBAR_H */
diff --git a/src/ui/toolbar/connector-toolbar.cpp b/src/ui/toolbar/connector-toolbar.cpp
index 77308c9ec..1cf80cec8 100644
--- a/src/ui/toolbar/connector-toolbar.cpp
+++ b/src/ui/toolbar/connector-toolbar.cpp
@@ -57,38 +57,200 @@ using Inkscape::DocumentUndo;
 using Inkscape::UI::ToolboxFactory;
 using Inkscape::UI::PrefPusher;
 
-//#########################
-//##      Connector      ##
-//#########################
+static Inkscape::XML::NodeEventVector connector_tb_repr_events = {
+    nullptr, /* child_added */
+    nullptr, /* child_removed */
+    Inkscape::UI::Toolbar::ConnectorToolbar::event_attr_changed,
+    nullptr, /* content_changed */
+    nullptr  /* order_changed */
+};
+
+namespace Inkscape {
+namespace UI {
+namespace Toolbar {
+GtkWidget *
+ConnectorToolbar::prep( SPDesktop *desktop, GtkActionGroup* mainActions)
+{
+    auto toolbar = new ConnectorToolbar(desktop);
+
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
+
+    {
+        InkAction* inky = ink_action_new( "ConnectorAvoidAction",
+                                          _("Avoid"),
+                                          _("Make connectors avoid selected objects"),
+                                          INKSCAPE_ICON("connector-avoid"),
+                                          secondarySize );
+        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(path_set_avoid), (gpointer)toolbar);
+        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
+    }
+
+    {
+        InkAction* inky = ink_action_new( "ConnectorIgnoreAction",
+                                          _("Ignore"),
+                                          _("Make connectors ignore selected objects"),
+                                          INKSCAPE_ICON("connector-ignore"),
+                                          secondarySize );
+        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(path_set_ignore), (gpointer)toolbar);
+        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
+    }
+
+    // Orthogonal connectors toggle button
+    {
+        toolbar->_orthogonal = ink_toggle_action_new( "ConnectorOrthogonalAction",
+                                                      _("Orthogonal"),
+                                                      _("Make connector orthogonal or polyline"),
+                                                      INKSCAPE_ICON("connector-orthogonal"),
+                                                      GTK_ICON_SIZE_MENU );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_orthogonal ) );
+
+        bool tbuttonstate = prefs->getBool("/tools/connector/orthogonal");
+        gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(toolbar->_orthogonal), ( tbuttonstate ? TRUE : FALSE ));
+        g_signal_connect_after( G_OBJECT(toolbar->_orthogonal), "toggled", G_CALLBACK(orthogonal_toggled), (gpointer)toolbar );
+    }
+
+    EgeAdjustmentAction* eact = nullptr;
+    // Curvature spinbox
+    eact = create_adjustment_action( "ConnectorCurvatureAction",
+                                    _("Connector Curvature"), _("Curvature:"),
+                                    _("The amount of connectors curvature"),
+                                    "/tools/connector/curvature", defaultConnCurvature,
+                                    GTK_WIDGET(desktop->canvas),
+                                    nullptr, // dataKludge
+                                    TRUE, "inkscape:connector-curvature",
+                                    0, 100, 1.0, 10.0,
+                                    nullptr, nullptr, 0,
+                                    nullptr, // callback
+                                    nullptr /*unit tracker*/, 1, 0 );
+    toolbar->_curvature_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+    toolbar->_curvature_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &ConnectorToolbar::curvature_changed));
+    gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+
+    // Spacing spinbox
+    eact = create_adjustment_action( "ConnectorSpacingAction",
+                                    _("Connector Spacing"), _("Spacing:"),
+                                    _("The amount of space left around objects by auto-routing connectors"),
+                                    "/tools/connector/spacing", defaultConnSpacing,
+                                    GTK_WIDGET(desktop->canvas),
+                                    nullptr, // dataKludge
+                                    TRUE, "inkscape:connector-spacing",
+                                    0, 100, 1.0, 10.0,
+                                    nullptr, nullptr, 0,
+                                    nullptr, // callback
+                                    nullptr /*unit tracker*/, 1, 0 );
+    toolbar->_spacing_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+    toolbar->_spacing_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &ConnectorToolbar::spacing_changed));
+    gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+
+    // Graph (connector network) layout
+    {
+        InkAction* inky = ink_action_new( "ConnectorGraphAction",
+                                          _("Graph"),
+                                          _("Nicely arrange selected connector network"),
+                                          INKSCAPE_ICON("distribute-graph"),
+                                          secondarySize );
+        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(graph_layout), (gpointer)toolbar);
+        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
+    }
+
+    // Default connector length spinbox
+    eact = create_adjustment_action( "ConnectorLengthAction",
+                                     _("Connector Length"), _("Length:"),
+                                     _("Ideal length for connectors when layout is applied"),
+                                     "/tools/connector/length", 100,
+                                     GTK_WIDGET(desktop->canvas),
+                                     nullptr, // dataKludge
+                                     TRUE, "inkscape:connector-length",
+                                     10, 1000, 10.0, 100.0,
+                                     nullptr, nullptr, 0,
+                                     nullptr, // callback
+                                     nullptr /*unit tracker*/, 1, 0 );
+    toolbar->_length_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+    toolbar->_length_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &ConnectorToolbar::length_changed));
+    gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+
+    // Directed edges toggle button
+    {
+        InkToggleAction* act = ink_toggle_action_new( "ConnectorDirectedAction",
+                                                      _("Downwards"),
+                                                      _("Make connectors with end-markers (arrows) point downwards"),
+                                                      INKSCAPE_ICON("distribute-graph-directed"),
+                                                      GTK_ICON_SIZE_MENU );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
+
+        bool tbuttonstate = prefs->getBool("/tools/connector/directedlayout");
+        gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act), ( tbuttonstate ? TRUE : FALSE ));
+
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(directed_graph_layout_toggled), (gpointer)toolbar);
+        desktop->getSelection()->connectChanged(sigc::mem_fun(*toolbar, &ConnectorToolbar::selection_changed));
+    }
+
+    // Avoid overlaps toggle button
+    {
+        InkToggleAction* act = ink_toggle_action_new( "ConnectorOverlapAction",
+                                                      _("Remove overlaps"),
+                                                      _("Do not allow overlapping shapes"),
+                                                      INKSCAPE_ICON("distribute-remove-overlaps"),
+                                                      GTK_ICON_SIZE_MENU );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
+
+        bool tbuttonstate = prefs->getBool("/tools/connector/avoidoverlaplayout");
+        gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act), (tbuttonstate ? TRUE : FALSE ));
+
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(nooverlaps_graph_layout_toggled), (gpointer)toolbar);
+    }
+
+    // Code to watch for changes to the connector-spacing attribute in
+    // the XML.
+    Inkscape::XML::Node *repr = desktop->namedview->getRepr();
+    g_assert(repr != nullptr);
+
+    if(toolbar->_repr) {
+        toolbar->_repr->removeListenerByData(toolbar);
+        Inkscape::GC::release(toolbar->_repr);
+        toolbar->_repr = nullptr;
+    }
+
+    if (repr) {
+        toolbar->_repr = repr;
+        Inkscape::GC::anchor(toolbar->_repr);
+        toolbar->_repr->addListener(&connector_tb_repr_events, toolbar);
+        toolbar->_repr->synthesizeEvents(&connector_tb_repr_events, toolbar);
+    }
+
+    return GTK_WIDGET(toolbar->gobj());
+} // end of ConnectorToolbar::prep()
 
-static void sp_connector_path_set_avoid()
+void
+ConnectorToolbar::path_set_avoid()
 {
     Inkscape::UI::Tools::cc_selection_set_avoid(true);
 }
 
-
-static void sp_connector_path_set_ignore()
+void
+ConnectorToolbar::path_set_ignore()
 {
     Inkscape::UI::Tools::cc_selection_set_avoid(false);
 }
 
-static void sp_connector_orthogonal_toggled( GtkToggleAction* act, GObject *tbl )
+void
+ConnectorToolbar::orthogonal_toggled( GtkToggleAction* act, gpointer data)
 {
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( tbl, "desktop" ));
-    SPDocument *doc = desktop->getDocument();
+    auto toolbar = reinterpret_cast<ConnectorToolbar *>(data);
+    SPDocument *doc = toolbar->_desktop->getDocument();
 
     if (!DocumentUndo::getUndoSensitive(doc)) {
         return;
     }
 
-
     // quit if run by the _changed callbacks
-    if (g_object_get_data( tbl, "freeze" )) {
+    if (toolbar->_freeze) {
         return;
     }
 
     // in turn, prevent callbacks from responding
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+    toolbar->_freeze = true;
 
     bool is_orthog = gtk_toggle_action_get_active( act );
     gchar orthog_str[] = "orthogonal";
@@ -96,7 +258,7 @@ static void sp_connector_orthogonal_toggled( GtkToggleAction* act, GObject *tbl
     gchar *value = is_orthog ? orthog_str : polyline_str ;
 
     bool modmade = false;
-    auto itemlist= desktop->getSelection()->items();
+    auto itemlist= toolbar->_desktop->getSelection()->items();
     for(auto i=itemlist.begin();i!=itemlist.end();++i){
         SPItem *item = *i;
 
@@ -117,13 +279,13 @@ static void sp_connector_orthogonal_toggled( GtkToggleAction* act, GObject *tbl
                        is_orthog ? _("Set connector type: orthogonal"): _("Set connector type: polyline"));
     }
 
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    toolbar->_freeze = false;
 }
 
-static void connector_curvature_changed(GtkAdjustment *adj, GObject* tbl)
+void
+ConnectorToolbar::curvature_changed()
 {
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( tbl, "desktop" ));
-    SPDocument *doc = desktop->getDocument();
+    SPDocument *doc = _desktop->getDocument();
 
     if (!DocumentUndo::getUndoSensitive(doc)) {
         return;
@@ -131,19 +293,19 @@ static void connector_curvature_changed(GtkAdjustment *adj, GObject* tbl)
 
 
     // quit if run by the _changed callbacks
-    if (g_object_get_data( tbl, "freeze" )) {
+    if (_freeze) {
         return;
     }
 
     // in turn, prevent callbacks from responding
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+    _freeze = true;
 
-    gdouble newValue = gtk_adjustment_get_value(adj);
+    auto newValue = _curvature_adj->get_value();
     gchar value[G_ASCII_DTOSTR_BUF_SIZE];
     g_ascii_dtostr(value, G_ASCII_DTOSTR_BUF_SIZE, newValue);
 
     bool modmade = false;
-    auto itemlist= desktop->getSelection()->items();
+    auto itemlist= _desktop->getSelection()->items();
     for(auto i=itemlist.begin();i!=itemlist.end();++i){
         SPItem *item = *i;
 
@@ -164,23 +326,22 @@ static void connector_curvature_changed(GtkAdjustment *adj, GObject* tbl)
                        _("Change connector curvature"));
     }
 
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-
-static void connector_spacing_changed(GtkAdjustment *adj, GObject* tbl)
+void
+ConnectorToolbar::spacing_changed()
 {
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( tbl, "desktop" ));
-    SPDocument *doc = desktop->getDocument();
+    SPDocument *doc = _desktop->getDocument();
 
     if (!DocumentUndo::getUndoSensitive(doc)) {
         return;
     }
 
-    Inkscape::XML::Node *repr = desktop->namedview->getRepr();
+    Inkscape::XML::Node *repr = _desktop->namedview->getRepr();
 
     if ( !repr->attribute("inkscape:connector-spacing") &&
-            ( gtk_adjustment_get_value(adj) == defaultConnSpacing )) {
+            ( _spacing_adj->get_value() == defaultConnSpacing )) {
         // 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.
@@ -188,19 +349,19 @@ static void connector_spacing_changed(GtkAdjustment *adj, GObject* tbl)
     }
 
     // quit if run by the attr_changed listener
-    if (g_object_get_data( tbl, "freeze" )) {
+    if (_freeze) {
         return;
     }
 
     // in turn, prevent listener from responding
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE));
+    _freeze = true;
 
-    sp_repr_set_css_double(repr, "inkscape:connector-spacing", gtk_adjustment_get_value(adj));
-    desktop->namedview->updateRepr();
+    sp_repr_set_css_double(repr, "inkscape:connector-spacing", _spacing_adj->get_value());
+    _desktop->namedview->updateRepr();
     bool modmade = false;
 
     std::vector<SPItem *> items;
-    items = get_avoided_items(items, desktop->currentRoot(), desktop);
+    items = get_avoided_items(items, _desktop->currentRoot(), _desktop);
     for (std::vector<SPItem *>::const_iterator iter = items.begin(); iter != items.end(); ++iter ) {
         SPItem *item = *iter;
         Geom::Affine m = Geom::identity();
@@ -212,10 +373,11 @@ static void connector_spacing_changed(GtkAdjustment *adj, GObject* tbl)
         DocumentUndo::done(doc, SP_VERB_CONTEXT_CONNECTOR,
                        _("Change connector spacing"));
     }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-static void sp_connector_graph_layout()
+void
+ConnectorToolbar::graph_layout()
 {
     if (!SP_ACTIVE_DESKTOP) {
         return;
@@ -235,205 +397,72 @@ static void sp_connector_graph_layout()
     DocumentUndo::done(SP_ACTIVE_DESKTOP->getDocument(), SP_VERB_DIALOG_ALIGN_DISTRIBUTE, _("Arrange connector network"));
 }
 
-static void sp_directed_graph_layout_toggled( GtkToggleAction* act, GObject * /*tbl*/ )
+void
+ConnectorToolbar::length_changed()
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setBool("/tools/connector/directedlayout",
-                gtk_toggle_action_get_active( act ));
+    prefs->setDouble("/tools/connector/length", _length_adj->get_value());
 }
 
-static void sp_nooverlaps_graph_layout_toggled( GtkToggleAction* act, GObject * /*tbl*/ )
+void
+ConnectorToolbar::directed_graph_layout_toggled(GtkToggleAction *act,
+                                                gpointer         data)
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setBool("/tools/connector/avoidoverlaplayout",
+    prefs->setBool("/tools/connector/directedlayout",
                 gtk_toggle_action_get_active( act ));
 }
 
-
-static void connector_length_changed(GtkAdjustment *adj, GObject* /*tbl*/)
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble("/tools/connector/length", gtk_adjustment_get_value(adj));
-}
-
-static void connector_tb_event_attr_changed(Inkscape::XML::Node *repr,
-                                            gchar const *name, gchar const * /*old_value*/, gchar const * /*new_value*/,
-                                            bool /*is_interactive*/, gpointer data)
-{
-    GtkWidget *tbl = GTK_WIDGET(data);
-
-    if ( !g_object_get_data(G_OBJECT(tbl), "freeze")
-         && (strcmp(name, "inkscape:connector-spacing") == 0) ) {
-        GtkAdjustment *adj = static_cast<GtkAdjustment*>(g_object_get_data(G_OBJECT(tbl), "spacing"));
-        gdouble spacing = defaultConnSpacing;
-        sp_repr_get_double(repr, "inkscape:connector-spacing", &spacing);
-
-        gtk_adjustment_set_value(adj, spacing);
-
-#if !GTK_CHECK_VERSION(3,18,0)
-        gtk_adjustment_value_changed(adj);
-#endif
-
-        spinbutton_defocus(tbl);
-    }
-}
-
-static Inkscape::XML::NodeEventVector connector_tb_repr_events = {
-    nullptr, /* child_added */
-    nullptr, /* child_removed */
-    connector_tb_event_attr_changed,
-    nullptr, /* content_changed */
-    nullptr  /* order_changed */
-};
-
-static void sp_connector_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
+void
+ConnectorToolbar::selection_changed(Inkscape::Selection *selection)
 {
-    GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "curvature" ) );
-    GtkToggleAction *act = GTK_TOGGLE_ACTION( g_object_get_data( tbl, "orthogonal" ) );
     SPItem *item = selection->singleItem();
     if (SP_IS_PATH(item))
     {
         gdouble curvature = SP_PATH(item)->connEndPair.getCurvature();
         bool is_orthog = SP_PATH(item)->connEndPair.isOrthogonal();
-        gtk_toggle_action_set_active(act, is_orthog);
-        gtk_adjustment_set_value(adj, curvature);
+        gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(_orthogonal), is_orthog);
+        _curvature_adj->set_value(curvature);
     }
 
 }
 
-void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder )
+void
+ConnectorToolbar::nooverlaps_graph_layout_toggled( GtkToggleAction* act, gpointer /* data */)
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
-
-    {
-        InkAction* inky = ink_action_new( "ConnectorAvoidAction",
-                                          _("Avoid"),
-                                          _("Make connectors avoid selected objects"),
-                                          INKSCAPE_ICON("connector-avoid"),
-                                          secondarySize );
-        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_path_set_avoid), holder );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
-    }
-
-    {
-        InkAction* inky = ink_action_new( "ConnectorIgnoreAction",
-                                          _("Ignore"),
-                                          _("Make connectors ignore selected objects"),
-                                          INKSCAPE_ICON("connector-ignore"),
-                                          secondarySize );
-        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_path_set_ignore), holder );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
-    }
-
-    // Orthogonal connectors toggle button
-    {
-        InkToggleAction* act = ink_toggle_action_new( "ConnectorOrthogonalAction",
-                                                      _("Orthogonal"),
-                                                      _("Make connector orthogonal or polyline"),
-                                                      INKSCAPE_ICON("connector-orthogonal"),
-                                                      GTK_ICON_SIZE_MENU );
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-
-        bool tbuttonstate = prefs->getBool("/tools/connector/orthogonal");
-        gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act), ( tbuttonstate ? TRUE : FALSE ));
-        g_object_set_data( holder, "orthogonal", act );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_connector_orthogonal_toggled), holder );
-    }
-
-    EgeAdjustmentAction* eact = nullptr;
-    // Curvature spinbox
-    eact = create_adjustment_action( "ConnectorCurvatureAction",
-                                    _("Connector Curvature"), _("Curvature:"),
-                                    _("The amount of connectors curvature"),
-                                    "/tools/connector/curvature", defaultConnCurvature,
-                                    GTK_WIDGET(desktop->canvas), holder, TRUE, "inkscape:connector-curvature",
-                                    0, 100, 1.0, 10.0,
-                                    nullptr, nullptr, 0,
-                                    connector_curvature_changed, nullptr /*unit tracker*/, 1, 0 );
-    gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-
-    // Spacing spinbox
-    eact = create_adjustment_action( "ConnectorSpacingAction",
-                                    _("Connector Spacing"), _("Spacing:"),
-                                    _("The amount of space left around objects by auto-routing connectors"),
-                                    "/tools/connector/spacing", defaultConnSpacing,
-                                    GTK_WIDGET(desktop->canvas), holder, TRUE, "inkscape:connector-spacing",
-                                    0, 100, 1.0, 10.0,
-                                    nullptr, nullptr, 0,
-                                    connector_spacing_changed, nullptr /*unit tracker*/, 1, 0 );
-    gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-
-    // Graph (connector network) layout
-    {
-        InkAction* inky = ink_action_new( "ConnectorGraphAction",
-                                          _("Graph"),
-                                          _("Nicely arrange selected connector network"),
-                                          INKSCAPE_ICON("distribute-graph"),
-                                          secondarySize );
-        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_graph_layout), holder );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
-    }
-
-    // Default connector length spinbox
-    eact = create_adjustment_action( "ConnectorLengthAction",
-                                     _("Connector Length"), _("Length:"),
-                                     _("Ideal length for connectors when layout is applied"),
-                                     "/tools/connector/length", 100,
-                                     GTK_WIDGET(desktop->canvas), holder, TRUE, "inkscape:connector-length",
-                                     10, 1000, 10.0, 100.0,
-                                     nullptr, nullptr, 0,
-                                     connector_length_changed, nullptr /*unit tracker*/, 1, 0 );
-    gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-
-
-    // Directed edges toggle button
-    {
-        InkToggleAction* act = ink_toggle_action_new( "ConnectorDirectedAction",
-                                                      _("Downwards"),
-                                                      _("Make connectors with end-markers (arrows) point downwards"),
-                                                      INKSCAPE_ICON("distribute-graph-directed"),
-                                                      GTK_ICON_SIZE_MENU );
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-
-        bool tbuttonstate = prefs->getBool("/tools/connector/directedlayout");
-        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 );
-        desktop->getSelection()->connectChanged(sigc::bind(sigc::ptr_fun(sp_connector_toolbox_selection_changed), holder));
-    }
-
-    // Avoid overlaps toggle button
-    {
-        InkToggleAction* act = ink_toggle_action_new( "ConnectorOverlapAction",
-                                                      _("Remove overlaps"),
-                                                      _("Do not allow overlapping shapes"),
-                                                      INKSCAPE_ICON("distribute-remove-overlaps"),
-                                                      GTK_ICON_SIZE_MENU );
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-
-        bool tbuttonstate = prefs->getBool("/tools/connector/avoidoverlaplayout");
-        gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act), (tbuttonstate ? TRUE : FALSE ));
+    prefs->setBool("/tools/connector/avoidoverlaplayout",
+                gtk_toggle_action_get_active( act ));
+}
 
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_nooverlaps_graph_layout_toggled), holder );
-    }
+void
+ConnectorToolbar::event_attr_changed(Inkscape::XML::Node *repr,
+                                     gchar const         *name,
+                                     gchar const         * /*old_value*/,
+                                     gchar const         * /*new_value*/,
+                                     bool                  /*is_interactive*/,
+                                     gpointer             data)
+{
+    auto toolbar = reinterpret_cast<ConnectorToolbar *>(data);
 
+    if ( !toolbar->_freeze
+         && (strcmp(name, "inkscape:connector-spacing") == 0) ) {
+        gdouble spacing = defaultConnSpacing;
+        sp_repr_get_double(repr, "inkscape:connector-spacing", &spacing);
 
-    // Code to watch for changes to the connector-spacing attribute in
-    // the XML.
-    Inkscape::XML::Node *repr = desktop->namedview->getRepr();
-    g_assert(repr != nullptr);
+        toolbar->_spacing_adj->set_value(spacing);
 
-    purge_repr_listener( holder, holder );
+#if !GTK_CHECK_VERSION(3,18,0)
+        toolbar->_spacing_adj->value_changed();
+#endif
 
-    if (repr) {
-        g_object_set_data( holder, "repr", repr );
-        Inkscape::GC::anchor(repr);
-        sp_repr_add_listener( repr, &connector_tb_repr_events, holder );
-        sp_repr_synthesize_events( repr, &connector_tb_repr_events, holder );
+        if(toolbar->_desktop->canvas) gtk_widget_grab_focus(GTK_WIDGET(toolbar->_desktop->canvas));
     }
-} // end of sp_connector_toolbox_prep()
+}
 
+}
+}
+}
 
 /*
   Local Variables:
diff --git a/src/ui/toolbar/connector-toolbar.h b/src/ui/toolbar/connector-toolbar.h
index bc75f6bfe..f350739d0 100644
--- a/src/ui/toolbar/connector-toolbar.h
+++ b/src/ui/toolbar/connector-toolbar.h
@@ -28,11 +28,71 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "toolbar.h"
+
+#include <gtkmm/adjustment.h>
+
 class SPDesktop;
 
 typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _GObject GObject;
+typedef struct _InkToggleAction InkToggleAction;
+
+namespace Inkscape {
+class Selection;
+
+namespace XML {
+class Node;
+}
+
+namespace UI {
+namespace Toolbar {
+class ConnectorToolbar : public Toolbar {
+private:
+    InkToggleAction *_orthogonal;
+
+    Glib::RefPtr<Gtk::Adjustment> _curvature_adj;
+    Glib::RefPtr<Gtk::Adjustment> _spacing_adj;
+    Glib::RefPtr<Gtk::Adjustment> _length_adj;
+
+    bool _freeze;
+
+    Inkscape::XML::Node *_repr;
+
+    static void path_set_avoid();
+    static void path_set_ignore();
+    static void orthogonal_toggled(GtkToggleAction *act,
+                                   gpointer         data);
+    static void graph_layout();
+    static void directed_graph_layout_toggled  (GtkToggleAction *act,
+                                                gpointer         data);
+    static void nooverlaps_graph_layout_toggled(GtkToggleAction *act,
+                                                gpointer         data);
+
+    void curvature_changed();
+    void spacing_changed();
+    void length_changed();
+    void selection_changed(Inkscape::Selection *selection);
+
+protected:
+    ConnectorToolbar(SPDesktop *desktop)
+        : Toolbar(desktop),
+          _freeze(false),
+          _repr(nullptr)
+    {}
+
+public:
+    static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions);
+
+    static void event_attr_changed(Inkscape::XML::Node *repr,
+                                   gchar const         *name,
+                                   gchar const         * /*old_value*/,
+                                   gchar const         * /*new_value*/,
+                                   bool                  /*is_interactive*/,
+                                   gpointer             data);
+};
 
-void       sp_connector_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
+}
+}
+}
 
 #endif /* !SEEN_CONNECTOR_TOOLBAR_H */
diff --git a/src/ui/toolbar/eraser-toolbar.cpp b/src/ui/toolbar/eraser-toolbar.cpp
index ee28c127b..8950b6a58 100644
--- a/src/ui/toolbar/eraser-toolbar.cpp
+++ b/src/ui/toolbar/eraser-toolbar.cpp
@@ -48,89 +48,19 @@ using Inkscape::UI::PrefPusher;
 //##       Eraser       ##
 //########################
 
-// A dummy function for PrefPusher.
-// The code was calling the update_presets_list function in the calligraphy tool
-// which was immediately returning. TODO: Investigate this further.
-void eraser_update_presets_list(GObject *tbl)
-{
-    return;
-}
-
-static void sp_erc_width_value_changed( GtkAdjustment *adj, GObject *tbl )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/eraser/width", gtk_adjustment_get_value(adj) );
-}
-
-static void sp_erc_mass_value_changed( GtkAdjustment *adj, GObject* tbl )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/eraser/mass", gtk_adjustment_get_value(adj) );
-}
-
-static void sp_erc_velthin_value_changed( GtkAdjustment *adj, GObject* tbl )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble("/tools/eraser/thinning", gtk_adjustment_get_value(adj) );
-}
-
-static void sp_erc_cap_rounding_value_changed( GtkAdjustment *adj, GObject* tbl )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/eraser/cap_rounding", gtk_adjustment_get_value(adj) );
-}
-
-static void sp_erc_tremor_value_changed( GtkAdjustment *adj, GObject* tbl )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/eraser/tremor", gtk_adjustment_get_value(adj) );
-}
-
-static void sp_set_tbl_eraser_mode_visibility(GObject *const tbl, const guint eraser_mode)
-{
-    gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "split") ), (eraser_mode == ERASER_MODE_CUT));
-
-    const gboolean visibility = (eraser_mode != ERASER_MODE_DELETE);
-    const std::array<const gchar *, 6> arr = {"cap_rounding", "mass", "thinning", "tremor", "usepressure", "width"};
-    for (const gchar * str : arr) {
-        gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, str) ), visibility );
-    }
-}
-
-static void sp_erasertb_mode_changed( GObject *tbl, int mode )
-{
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( tbl, "desktop" ));
-    if (DocumentUndo::getUndoSensitive(desktop->getDocument())) {
-        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setInt( "/tools/eraser/mode", mode );
-    }
-    sp_set_tbl_eraser_mode_visibility(tbl, mode);
-
-    // only take action if run by the attr_changed listener
-    if (!g_object_get_data( tbl, "freeze" )) {
-        // in turn, prevent listener from responding
-        g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
-
-        /*
-        if ( eraser_mode != ERASER_MODE_DELETE ) {
-        } else {
-        }
-        */
-        // TODO finish implementation
-
-        g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
-    }
-}
 
-static void sp_toggle_break_apart( GtkToggleAction* act, gpointer data )
+namespace Inkscape {
+namespace UI {
+namespace Toolbar {
+EraserToolbar::~EraserToolbar()
 {
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    gboolean active = gtk_toggle_action_get_active(act);
-    prefs->setBool("/tools/eraser/break_apart", active);
+    if(_pressure_pusher) delete _pressure_pusher;
 }
 
-void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
+GtkWidget *
+EraserToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
 {
+    auto toolbar = new EraserToolbar(desktop);
     GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     gint eraser_mode = ERASER_MODE_DELETE;
@@ -160,21 +90,20 @@ void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb
         row[columns.col_icon     ] = INKSCAPE_ICON("path-intersection");
         row[columns.col_sensitive] = true;
 
-        InkSelectOneAction* act =
+        toolbar->_eraser_mode_action =
             InkSelectOneAction::create( "EraserModeAction",  // Name
                                         _("Mode"),           // Label
                                         "",                  // Tooltip
                                         "Not Used",          // Icon
                                         store );             // Tree store
-        act->use_radio( true );
-        act->use_group_label( true );
+        toolbar->_eraser_mode_action->use_radio( true );
+        toolbar->_eraser_mode_action->use_group_label( true );
         eraser_mode = prefs->getInt("/tools/eraser/mode", ERASER_MODE_CLIP); // Used at end
-        act->set_active( eraser_mode );
+        toolbar->_eraser_mode_action->set_active( eraser_mode );
 
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data( holder, "EraserModeAction", act );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_eraser_mode_action->gobj() ));
 
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_erasertb_mode_changed), holder));
+        toolbar->_eraser_mode_action->signal_changed().connect(sigc::mem_fun(*toolbar, &EraserToolbar::mode_changed));
     }
 
 
@@ -182,32 +111,34 @@ void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb
     {
         gchar const* labels[] = {_("(no width)"),_("(hairline)"), nullptr, nullptr, nullptr, _("(default)"), nullptr, nullptr, nullptr, nullptr, _("(broad stroke)")};
         gdouble values[] = {0, 1, 3, 5, 10, 15, 20, 30, 50, 75, 100};
-        EgeAdjustmentAction *eact = create_adjustment_action( "EraserWidthAction",
-                                                              _("Pen Width"), _("Width:"),
-                                                              _("The width of the eraser pen (relative to the visible canvas area)"),
-                                                              "/tools/eraser/width", 15,
-                                                              GTK_WIDGET(desktop->canvas), holder, TRUE, "altx-eraser",
-                                                              0, 100, 1.0, 10.0,
-                                                              labels, values, G_N_ELEMENTS(labels),
-                                                              sp_erc_width_value_changed, nullptr /*unit tracker*/, 1, 0);
-        ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        g_object_set_data( holder, "width", eact );
-        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+        toolbar->_width = create_adjustment_action( "EraserWidthAction",
+                                                    _("Pen Width"), _("Width:"),
+                                                    _("The width of the eraser pen (relative to the visible canvas area)"),
+                                                    "/tools/eraser/width", 15,
+                                                    GTK_WIDGET(desktop->canvas),
+                                                    nullptr, // dataKludge
+                                                    TRUE, "altx-eraser",
+                                                    0, 100, 1.0, 10.0,
+                                                    labels, values, G_N_ELEMENTS(labels),
+                                                    nullptr, // callback
+                                                    nullptr /*unit tracker*/, 1, 0);
+        toolbar->_width_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_width));
+        toolbar->_width_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &EraserToolbar::width_value_changed));
+        ege_adjustment_action_set_appearance( toolbar->_width, TOOLBAR_SLIDER_HINT );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_width) );
+        gtk_action_set_sensitive( GTK_ACTION(toolbar->_width), TRUE );
     }
 
 
     /* Use Pressure button */
     {
-        InkToggleAction* act = ink_toggle_action_new( "EraserPressureAction",
-                                                      _("Eraser Pressure"),
-                                                      _("Use the pressure of the input device to alter the width of the pen"),
-                                                      INKSCAPE_ICON("draw-use-pressure"),
-                                                      GTK_ICON_SIZE_MENU );
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/eraser/usepressure", eraser_update_presets_list, holder);
-        g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
-        g_object_set_data( holder, "usepressure", act );
+        toolbar->_usepressure = ink_toggle_action_new( "EraserPressureAction",
+                                                       _("Eraser Pressure"),
+                                                       _("Use the pressure of the input device to alter the width of the pen"),
+                                                       INKSCAPE_ICON("draw-use-pressure"),
+                                                       GTK_ICON_SIZE_MENU );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_usepressure ) );
+        toolbar->_pressure_pusher = new PrefPusher(GTK_TOGGLE_ACTION(toolbar->_usepressure), "/tools/eraser/usepressure", update_presets_list, (gpointer)toolbar);
     }
 
 
@@ -215,17 +146,21 @@ void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb
     {
         gchar const* labels[] = {_("(speed blows up stroke)"), nullptr, nullptr, _("(slight widening)"), _("(constant width)"), _("(slight thinning, default)"), nullptr, nullptr, _("(speed deflates stroke)")};
         gdouble values[] = {-100, -40, -20, -10, 0, 10, 20, 40, 100};
-        EgeAdjustmentAction* eact = create_adjustment_action( "EraserThinningAction",
-                                                              _("Eraser Stroke Thinning"), _("Thinning:"),
-                                                              _("How much velocity thins the stroke (> 0 makes fast strokes thinner, < 0 makes them broader, 0 makes width independent of velocity)"),
-                                                              "/tools/eraser/thinning", 10,
-                                                              GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
-                                                              -100, 100, 1, 10.0,
-                                                              labels, values, G_N_ELEMENTS(labels),
-                                                              sp_erc_velthin_value_changed, nullptr /*unit tracker*/, 1, 0);
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        g_object_set_data( holder, "thinning", eact );
-        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+        toolbar->_thinning = create_adjustment_action( "EraserThinningAction",
+                                                       _("Eraser Stroke Thinning"), _("Thinning:"),
+                                                       _("How much velocity thins the stroke (> 0 makes fast strokes thinner, < 0 makes them broader, 0 makes width independent of velocity)"),
+                                                       "/tools/eraser/thinning", 10,
+                                                       GTK_WIDGET(desktop->canvas),
+                                                       nullptr, // dataKludge
+                                                       FALSE, nullptr,
+                                                       -100, 100, 1, 10.0,
+                                                       labels, values, G_N_ELEMENTS(labels),
+                                                       nullptr, // callback
+                                                       nullptr /*unit tracker*/, 1, 0);
+        toolbar->_thinning_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_thinning));
+        toolbar->_thinning_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &EraserToolbar::velthin_value_changed));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_thinning) );
+        gtk_action_set_sensitive( GTK_ACTION(toolbar->_thinning), TRUE );
     }
 
 
@@ -234,17 +169,21 @@ void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb
             gchar const* labels[] = {_("(blunt caps, default)"), _("(slightly bulging)"), nullptr, nullptr, _("(approximately round)"), _("(long protruding caps)")};
         gdouble values[] = {0, 0.3, 0.5, 1.0, 1.4, 5.0};
         // TRANSLATORS: "cap" means "end" (both start and finish) here
-        EgeAdjustmentAction* eact = create_adjustment_action( "EraserCapRoundingAction",
-                                                              _("Eraser Cap rounding"), _("Caps:"),
-                                                              _("Increase to make caps at the ends of strokes protrude more (0 = no caps, 1 = round caps)"),
-                                                              "/tools/eraser/cap_rounding", 0.0,
-                                                              GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
-                                                              0.0, 5.0, 0.01, 0.1,
-                                                              labels, values, G_N_ELEMENTS(labels),
-                                                              sp_erc_cap_rounding_value_changed, nullptr /*unit tracker*/, 0.01, 2 );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        g_object_set_data( holder, "cap_rounding", eact );
-        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+        toolbar->_cap_rounding = create_adjustment_action( "EraserCapRoundingAction",
+                                                           _("Eraser Cap rounding"), _("Caps:"),
+                                                           _("Increase to make caps at the ends of strokes protrude more (0 = no caps, 1 = round caps)"),
+                                                           "/tools/eraser/cap_rounding", 0.0,
+                                                           GTK_WIDGET(desktop->canvas),
+                                                           nullptr, // dataKludge
+                                                           FALSE, nullptr,
+                                                           0.0, 5.0, 0.01, 0.1,
+                                                           labels, values, G_N_ELEMENTS(labels),
+                                                           nullptr, // callback
+                                                           nullptr /*unit tracker*/, 0.01, 2 );
+        toolbar->_cap_rounding_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_cap_rounding));
+        toolbar->_cap_rounding_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &EraserToolbar::cap_rounding_value_changed));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_cap_rounding) );
+        gtk_action_set_sensitive( GTK_ACTION(toolbar->_cap_rounding), TRUE );
     }
 
 
@@ -252,55 +191,163 @@ void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb
     {
         gchar const* labels[] = {_("(smooth line)"), _("(slight tremor)"), _("(noticeable tremor)"), nullptr, nullptr, _("(maximum tremor)")};
         gdouble values[] = {0, 10, 20, 40, 60, 100};
-        EgeAdjustmentAction* eact = create_adjustment_action( "EraserTremorAction",
-                                                              _("EraserStroke Tremor"), _("Tremor:"),
-                                                              _("Increase to make strokes rugged and trembling"),
-                                                              "/tools/eraser/tremor", 0.0,
-                                                              GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
-                                                              0.0, 100, 1, 10.0,
-                                                              labels, values, G_N_ELEMENTS(labels),
-                                                              sp_erc_tremor_value_changed, nullptr /*unit tracker*/, 1, 0);
-
-        ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
-        g_object_set_data( holder, "tremor", eact );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+        toolbar->_tremor = create_adjustment_action( "EraserTremorAction",
+                                                     _("EraserStroke Tremor"), _("Tremor:"),
+                                                     _("Increase to make strokes rugged and trembling"),
+                                                     "/tools/eraser/tremor", 0.0,
+                                                     GTK_WIDGET(desktop->canvas),
+                                                     nullptr, // dataKludge
+                                                     FALSE, nullptr,
+                                                     0.0, 100, 1, 10.0,
+                                                     labels, values, G_N_ELEMENTS(labels),
+                                                     nullptr, // callback
+                                                     nullptr /*unit tracker*/, 1, 0);
+        toolbar->_tremor_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_tremor));
+        toolbar->_tremor_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &EraserToolbar::tremor_value_changed));
+
+        ege_adjustment_action_set_appearance( toolbar->_tremor, TOOLBAR_SLIDER_HINT );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_tremor) );
+        gtk_action_set_sensitive( GTK_ACTION(toolbar->_tremor), TRUE );
     }
 
-
     /* Mass */
     {
-            gchar const* labels[] = {_("(no inertia)"), _("(slight smoothing, default)"), _("(noticeable lagging)"), nullptr, nullptr, _("(maximum inertia)")};
+        gchar const* labels[] = {_("(no inertia)"), _("(slight smoothing, default)"), _("(noticeable lagging)"), nullptr, nullptr, _("(maximum inertia)")};
         gdouble values[] = {0.0, 2, 10, 20, 50, 100};
-        EgeAdjustmentAction* eact = create_adjustment_action( "EraserMassAction",
-                                                              _("Eraser Mass"), _("Mass:"),
-                                                              _("Increase to make the eraser drag behind, as if slowed by inertia"),
-                                                              "/tools/eraser/mass", 10.0,
-                                                              GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
-                                                              0.0, 100, 1, 10.0,
-                                                              labels, values, G_N_ELEMENTS(labels),
-                                                              sp_erc_mass_value_changed, nullptr /*unit tracker*/, 1, 0);
-        ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
-        g_object_set_data( holder, "mass", eact );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+        toolbar->_mass = create_adjustment_action( "EraserMassAction",
+                                                   _("Eraser Mass"), _("Mass:"),
+                                                   _("Increase to make the eraser drag behind, as if slowed by inertia"),
+                                                   "/tools/eraser/mass", 10.0,
+                                                   GTK_WIDGET(desktop->canvas),
+                                                   nullptr, // dataKludge
+                                                   FALSE, nullptr,
+                                                   0.0, 100, 1, 10.0,
+                                                   labels, values, G_N_ELEMENTS(labels),
+                                                   nullptr, // callback
+                                                   nullptr /*unit tracker*/, 1, 0);
+        toolbar->_mass_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_mass));
+        toolbar->_mass_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &EraserToolbar::mass_value_changed));
+        ege_adjustment_action_set_appearance( toolbar->_mass, TOOLBAR_SLIDER_HINT );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_mass) );
+        gtk_action_set_sensitive( GTK_ACTION(toolbar->_mass), TRUE );
     }
 
-
     /* Overlap */
     {
-        InkToggleAction* act = ink_toggle_action_new( "EraserBreakAppart",
-                                                      _("Break apart cut items"),
-                                                      _("Break apart cut items"),
-                                                      INKSCAPE_ICON("distribute-randomize"),
-                                                      secondarySize );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/eraser/break_apart", false) );
-        g_object_set_data( holder, "split", act );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_break_apart), holder) ;
-        gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
+        toolbar->_split = ink_toggle_action_new( "EraserBreakAppart",
+                                                 _("Break apart cut items"),
+                                                 _("Break apart cut items"),
+                                                 INKSCAPE_ICON("distribute-randomize"),
+                                                 secondarySize );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(toolbar->_split), prefs->getBool("/tools/eraser/break_apart", false) );
+        g_signal_connect_after( G_OBJECT(toolbar->_split), "toggled", G_CALLBACK(toggle_break_apart), (gpointer)toolbar);
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_split) );
     }
 
-    sp_set_tbl_eraser_mode_visibility(holder, eraser_mode);
+    toolbar->set_eraser_mode_visibility(eraser_mode);
+
+    return GTK_WIDGET(toolbar->gobj());
+}
+
+void
+EraserToolbar::mode_changed(int mode)
+{
+    if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) {
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        prefs->setInt( "/tools/eraser/mode", mode );
+    }
+
+    set_eraser_mode_visibility(mode);
+
+    // only take action if run by the attr_changed listener
+    if (!_freeze) {
+        // in turn, prevent listener from responding
+        _freeze = true;
+
+        /*
+        if ( eraser_mode != ERASER_MODE_DELETE ) {
+        } else {
+        }
+        */
+        // TODO finish implementation
+
+        _freeze =  false;
+    }
+}
+
+void
+EraserToolbar::set_eraser_mode_visibility(const guint eraser_mode)
+{
+    gtk_action_set_visible( GTK_ACTION(_split), (eraser_mode == ERASER_MODE_CUT));
+
+    const gboolean visibility = (eraser_mode != ERASER_MODE_DELETE);
+
+    const std::array<GtkAction *, 6> arr = {GTK_ACTION(_cap_rounding),
+                                            GTK_ACTION(_mass),
+                                            GTK_ACTION(_thinning),
+                                            GTK_ACTION(_tremor),
+                                            GTK_ACTION(_usepressure),
+                                            GTK_ACTION(_width)};
+    for (auto act : arr) {
+        gtk_action_set_visible( act, visibility );
+    }
+}
+
+void
+EraserToolbar::width_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/eraser/width", _width_adj->get_value() );
+}
+
+void
+EraserToolbar::mass_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/eraser/mass", _mass_adj->get_value() );
+}
+
+void
+EraserToolbar::velthin_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble("/tools/eraser/thinning", _thinning_adj->get_value() );
+}
+
+void
+EraserToolbar::cap_rounding_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/eraser/cap_rounding", _cap_rounding_adj->get_value() );
+}
+
+void
+EraserToolbar::tremor_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/eraser/tremor", _tremor_adj->get_value() );
+}
+
+// A dummy function for PrefPusher.
+// The code was calling the update_presets_list function in the calligraphy tool
+// which was immediately returning. TODO: Investigate this further.
+void
+EraserToolbar::update_presets_list(gpointer data)
+{
+    return;
+}
+
+void
+EraserToolbar::toggle_break_apart(GtkToggleAction *act,
+                                  gpointer         data)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gboolean active = gtk_toggle_action_get_active(act);
+    prefs->setBool("/tools/eraser/break_apart", active);
+}
+
+}
+}
 }
 
 /*
diff --git a/src/ui/toolbar/eraser-toolbar.h b/src/ui/toolbar/eraser-toolbar.h
index 2f837e5d7..0f8485aeb 100644
--- a/src/ui/toolbar/eraser-toolbar.h
+++ b/src/ui/toolbar/eraser-toolbar.h
@@ -28,11 +28,69 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "toolbar.h"
+
+#include <gtkmm/adjustment.h>
+
+class InkSelectOneAction;
 class SPDesktop;
 
+typedef struct _EgeAdjustmentAction EgeAdjustmentAction;
 typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _GObject GObject;
+typedef struct _InkToggleAction InkToggleAction;
+
+namespace Inkscape {
+namespace UI {
+class PrefPusher;
+
+namespace Toolbar {
+class EraserToolbar : public Toolbar {
+private:
+    InkSelectOneAction  *_eraser_mode_action;
+    EgeAdjustmentAction *_width;
+    EgeAdjustmentAction *_mass;
+    EgeAdjustmentAction *_thinning;
+    EgeAdjustmentAction *_cap_rounding;
+    EgeAdjustmentAction *_tremor;
+
+    InkToggleAction *_usepressure;
+    InkToggleAction *_split;
+
+    Glib::RefPtr<Gtk::Adjustment> _width_adj;
+    Glib::RefPtr<Gtk::Adjustment> _mass_adj;
+    Glib::RefPtr<Gtk::Adjustment> _thinning_adj;
+    Glib::RefPtr<Gtk::Adjustment> _cap_rounding_adj;
+    Glib::RefPtr<Gtk::Adjustment> _tremor_adj;
+
+    PrefPusher *_pressure_pusher;
+
+    bool _freeze;
+
+    void mode_changed(int mode);
+    void set_eraser_mode_visibility(const guint eraser_mode);
+    void width_value_changed();
+    void mass_value_changed();
+    void velthin_value_changed();
+    void cap_rounding_value_changed();
+    void tremor_value_changed();
+    static void update_presets_list(gpointer data);
+    static void toggle_break_apart(GtkToggleAction *act,
+                                   gpointer         data);
+
+protected:
+    EraserToolbar(SPDesktop *desktop)
+        : Toolbar(desktop),
+          _freeze(false)
+    {}
+
+    ~EraserToolbar();
+
+public:
+    static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions);
+};
 
-void       sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
+}
+}
+}
 
 #endif /* !SEEN_ERASOR_TOOLBAR_H */
diff --git a/src/ui/toolbar/gradient-toolbar.cpp b/src/ui/toolbar/gradient-toolbar.cpp
index cf14be7c3..4d1b16c6e 100644
--- a/src/ui/toolbar/gradient-toolbar.cpp
+++ b/src/ui/toolbar/gradient-toolbar.cpp
@@ -336,371 +336,300 @@ void gr_read_selection( Inkscape::Selection *selection,
     }
  }
 
-/* Get stop selected by menu */
-static SPStop *get_selected_stop( GObject *data)
-{
-    InkSelectOneAction *act =
-        static_cast<InkSelectOneAction *>(g_object_get_data(data, "gradient_stop_action"));
-
-    int active = act->get_active();
-
-    Glib::RefPtr<Gtk::ListStore> store = act->get_store();
-    Gtk::TreeModel::Row row = store->children()[active];
-    InkSelectOneActionColumns columns;
-    void* pointer = row[columns.col_data];
-    SPStop *stop = static_cast<SPStop *>(pointer);
+namespace Inkscape {
+namespace UI {
+namespace Toolbar {
 
-    return stop;
-}
-
-/* Add stop to gradient */
-static void gr_add_stop(GtkWidget * /*button*/, GObject *data)
+/**
+ * Gradient auxiliary toolbar construction and setup.
+ *
+ */
+GtkWidget *
+GradientToolbar::prep(SPDesktop * desktop, GtkActionGroup* mainActions)
 {
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(data, "desktop"));
-    if (!desktop) {
-        return;
-    }
-
-    Inkscape::Selection *selection = desktop->getSelection();
-    if (!selection) {
-        return;
-    }
-
-    ToolBase *ev = desktop->getEventContext();
-    Inkscape::UI::Tools::GradientTool *rc = SP_GRADIENT_CONTEXT(ev);
-
-    if (rc) {
-        sp_gradient_context_add_stops_between_selected_stops(rc);
-    }
-
-}
+    auto toolbar = new GradientToolbar(desktop);
+    GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
 
-/* Remove stop from vector */
-static void gr_remove_stop(GtkWidget * /*button*/, GObject *data)
-{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(data, "desktop"));
-    if (!desktop) {
-        return;
-    }
+    /* New gradient linear or radial */
+    {
+        InkSelectOneActionColumns columns;
 
-    Inkscape::Selection *selection = desktop->getSelection(); // take from desktop, not from args
-    if (!selection) {
-        return;
-    }
+        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
 
-    ToolBase *ev = desktop->getEventContext();
-    GrDrag *drag = nullptr;
-    if (ev) {
-        drag = ev->get_drag();
-    }
+        Gtk::TreeModel::Row row;
 
-    if (drag) {
-        drag->deleteSelected();
-    }
+        row = *(store->append());
+        row[columns.col_label    ] = _("linear");
+        row[columns.col_tooltip  ] = _("Create linear gradient");
+        row[columns.col_icon     ] = INKSCAPE_ICON("paint-gradient-linear");
+        row[columns.col_sensitive] = true;
 
-}
+        row = *(store->append());
+        row[columns.col_label    ] = _("radial");
+        row[columns.col_tooltip  ] = _("Create radial (elliptic or circular) gradient");
+        row[columns.col_icon     ] = INKSCAPE_ICON("paint-gradient-radial");
+        row[columns.col_sensitive] = true;
 
-/* Lock or unlock links */
-static void gr_linked_changed(GtkToggleAction *act, gpointer /*data*/)
-{
-    gboolean active = gtk_toggle_action_get_active( act );
-    if ( active ) {
-        g_object_set( G_OBJECT(act), "iconId", INKSCAPE_ICON("object-locked"), NULL );
-    } else {
-        g_object_set( G_OBJECT(act), "iconId", INKSCAPE_ICON("object-unlocked"), NULL );
-    }
+        toolbar->_new_type_mode =
+            InkSelectOneAction::create( "GradientNewTypeAction", // Name
+                                        _("New"),            // Label
+                                        "",                  // Tooltip
+                                        "Not Used",          // Icon
+                                        store );             // Tree store
 
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setBool("/options/forkgradientvectors/value", !active);
-}
+        toolbar->_new_type_mode->use_radio( true );
+        toolbar->_new_type_mode->use_group_label( true );
+        gint mode = prefs->getInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR);
+        toolbar->_new_type_mode->set_active( mode == SP_GRADIENT_TYPE_LINEAR ? 0 : 1 ); // linear == 1, radial == 2
 
-/* Reverse vector */
-static void gr_reverse(GtkWidget * /*button*/, gpointer data)
-{
-    SPDesktop *desktop = static_cast<SPDesktop *>(data);
-    sp_gradient_reverse_selected_gradients(desktop);
-}
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_new_type_mode->gobj() ));
 
-/*
- *  Change desktop dragger selection to this stop
- */
-/* Set the offset widget value (based on which stop is selected). */
-static void gr_stop_set_offset (GObject *data)
-{
-    if (!blocked) {
-        std::cerr << "gr_stop_set_offset: should be blocked!" << std::endl;
+        toolbar->_new_type_mode->signal_changed().connect(sigc::mem_fun(*toolbar, &GradientToolbar::new_type_changed));
     }
 
-    SPStop *stop = get_selected_stop(data);
-    if (!stop) {
-        // std::cerr << "gr_stop_set_offset: no stop!" << std::endl;
-        return;
-    }
+    /* New gradient on fill or stroke*/
+    {
+        InkSelectOneActionColumns columns;
 
-    EgeAdjustmentAction* act = (EgeAdjustmentAction *)g_object_get_data( data, "offset_action");
-    if (!act) {
-        return;
-    }
-    GtkAdjustment *adj = ege_adjustment_action_get_adjustment(act);
+        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
 
-    bool isEndStop = false;
+        Gtk::TreeModel::Row row;
 
-    SPStop *prev = nullptr;
-    prev = stop->getPrevStop();
-    if (prev != nullptr )  {
-        gtk_adjustment_set_lower(adj, prev->offset);
-    } else {
-        isEndStop = true;
-        gtk_adjustment_set_lower(adj, 0);
-    }
+        row = *(store->append());
+        row[columns.col_label    ] = _("fill");
+        row[columns.col_tooltip  ] = _("Create gradient in the fill");
+        row[columns.col_icon     ] = INKSCAPE_ICON("object-fill");
+        row[columns.col_sensitive] = true;
 
-    SPStop *next = nullptr;
-    next = stop->getNextStop();
-    if (next != nullptr ) {
-        gtk_adjustment_set_upper(adj, next->offset);
-    } else {
-        isEndStop = true;
-        gtk_adjustment_set_upper(adj, 1.0);
-    }
+        row = *(store->append());
+        row[columns.col_label    ] = _("stroke");
+        row[columns.col_tooltip  ] = _("Create gradient in the stroke");
+        row[columns.col_icon     ] = INKSCAPE_ICON("object-stroke");
+        row[columns.col_sensitive] = true;
 
-    gtk_adjustment_set_value(adj, stop->offset);
-    gtk_action_set_sensitive( GTK_ACTION(act), !isEndStop );
-    gtk_adjustment_changed(adj);
-}
+        toolbar->_new_fillstroke_action =
+            InkSelectOneAction::create( "GradientNewFillStrokeAction", // Name
+                                        "",                  // Label
+                                        "",                  // Tooltip
+                                        "Not Used",          // Icon
+                                        store );             // Tree store
 
-static void select_dragger_by_stop( GObject *data, SPGradient *gradient, ToolBase *ev)
-{
-    if (!blocked) {
-        std::cerr << "select_dragger_by_stop: should be blocked!" << std::endl;
-    }
+        toolbar->_new_fillstroke_action->use_radio( true );
+        toolbar->_new_fillstroke_action->use_group_label( false );
+        Inkscape::PaintTarget fsmode = (prefs->getInt("/tools/gradient/newfillorstroke", 1) != 0) ? Inkscape::FOR_FILL : Inkscape::FOR_STROKE;
+        toolbar->_new_fillstroke_action->set_active( fsmode == Inkscape::FOR_FILL ? 0 : 1 );
 
-    if (!ev || !gradient) {
-        return;
-    }
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_new_fillstroke_action->gobj() ));
 
-    GrDrag *drag = ev->get_drag();
-    if (!drag) {
-        return;
+        toolbar->_new_fillstroke_action->signal_changed().connect(sigc::mem_fun(*toolbar, &GradientToolbar::new_fillstroke_changed));
     }
 
-    SPStop *stop = get_selected_stop(data);
+    /* Gradient Select list*/
+    {
+        InkSelectOneActionColumns columns;
 
-    drag->selectByStop(stop, false, true);
+        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
 
-    gr_stop_set_offset(data);
-}
+        Gtk::TreeModel::Row row;
 
-/* Find position of new_stop in menu. */
-static int select_stop_in_list (SPGradient *gradient, SPStop *new_stop, GObject *data)
-{
-    int i = 0;
-    for (auto& ochild: gradient->children) {
-        if (SP_IS_STOP(&ochild)) {
-            if (&ochild == new_stop) {
-                return i;
-            }
-            i++;
-        }
-    }
-    return -1;
-}
+        row = *(store->append());
+        row[columns.col_label    ] = _("No gradient");
+        row[columns.col_tooltip  ] = "";
+        row[columns.col_icon     ] = "NotUsed";
+        row[columns.col_sensitive] = true;
 
-/* Construct stop list */
-static int update_stop_list( SPGradient *gradient, SPStop *new_stop, GObject *data, bool gr_multi)
-{
-    if (!blocked) {
-        std::cerr << "update_stop_list should be blocked!" << std::endl;
-    }
+        toolbar->_select_action =
+            InkSelectOneAction::create( "GradientSelectGradientAction", // Name
+                                        _("Select"),         // Label
+                                        "",                  // Tooltip
+                                        "Not Used",          // Icon
+                                        store );             // Tree store
 
-    int selected = -1;
+        toolbar->_select_action->use_radio( false );
+        toolbar->_select_action->use_icon( false );
+        toolbar->_select_action->use_pixbuf( true );
+        toolbar->_select_action->use_group_label( true );
+        toolbar->_select_action->set_active( 0 );
+        toolbar->_select_action->set_sensitive( false );
 
-    auto act = static_cast<InkSelectOneAction*>(g_object_get_data(data, "gradient_stop_action"));
-    Glib::RefPtr<Gtk::ListStore> store = act->get_store();
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_select_action->gobj() ));
 
-    if (!store) {
-        return selected;
+        toolbar->_select_action->signal_changed().connect(sigc::mem_fun(*toolbar, &GradientToolbar::gradient_changed));
     }
 
-    store->clear();
+    // Gradient Spread type (how a gradient is drawn outside it's nominal area)
+    {
+        InkSelectOneActionColumns columns;
 
-    InkSelectOneActionColumns columns;
-    Gtk::TreeModel::Row row;
+        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
 
-    if (!SP_IS_GRADIENT(gradient)) {
-        // No valid gradient
+        Gtk::TreeModel::Row row;
 
         row = *(store->append());
-        row[columns.col_label    ] = _("No gradient");
+        row[columns.col_label    ] = C_("Gradient repeat type", "None");
         row[columns.col_tooltip  ] = "";
         row[columns.col_icon     ] = "NotUsed";
-        row[columns.col_data     ] = nullptr;
         row[columns.col_sensitive] = true;
 
-    } else if (!gradient->hasStops()) {
-        // Has gradient but it has no stops
-
         row = *(store->append());
-        row[columns.col_label    ] = _("No stops in gradient");
+        row[columns.col_label    ] = _("Reflected");
         row[columns.col_tooltip  ] = "";
         row[columns.col_icon     ] = "NotUsed";
-        row[columns.col_data     ] = nullptr;
         row[columns.col_sensitive] = true;
 
-    } else {
-        // Gradient has stops
+        row = *(store->append());
+        row[columns.col_label    ] = _("Direct");
+        row[columns.col_tooltip  ] = "";
+        row[columns.col_icon     ] = "NotUsed";
+        row[columns.col_sensitive] = true;
 
-        // Get list of stops
-        for (auto& ochild: gradient->children) {
-            if (SP_IS_STOP(&ochild)) {
+        toolbar->_spread_action =
+            InkSelectOneAction::create( "GradientSelectSpreadAction", // Name
+                                        _("Repeat"),            // Label
+                                        // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/pservers.html#LinearGradientSpreadMethodAttribute
+                                        _("Whether to fill with flat color beyond the ends of the gradient vector "
+                                          "(spreadMethod=\"pad\"), or repeat the gradient in the same direction "
+                                          "(spreadMethod=\"repeat\"), or repeat the gradient in alternating opposite "
+                                          "directions (spreadMethod=\"reflect\")"),    // Tooltip
+                                        "Not Used",             // Icon
+                                        store );                // Tree store
 
-                SPStop *stop = SP_STOP(&ochild);
-                Glib::RefPtr<Gdk::Pixbuf> pixbuf = sp_gradstop_to_pixbuf_ref (stop, 32, 16);
+        toolbar->_spread_action->use_radio( false );
+        toolbar->_spread_action->use_icon( false );
+        toolbar->_spread_action->use_group_label( true );
+        toolbar->_spread_action->set_sensitive( false );
 
-                Inkscape::XML::Node *repr = reinterpret_cast<SPItem *>(&ochild)->getRepr();
-                Glib::ustring label = gr_ellipsize_text(repr->attribute("id"), 25);
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_spread_action->gobj() ));
 
-                row = *(store->append());
-                row[columns.col_label    ] = label;
-                row[columns.col_tooltip  ] = "";
-                row[columns.col_icon     ] = "NotUsed";
-                row[columns.col_pixbuf   ] = pixbuf;
-                row[columns.col_data     ] = stop;
-                row[columns.col_sensitive] = true;
-            }
-        }
+        toolbar->_spread_action->signal_changed().connect(sigc::mem_fun(*toolbar, &GradientToolbar::spread_changed));
     }
 
-    if (new_stop != nullptr) {
-        selected = select_stop_in_list (gradient, new_stop, data);
-    }
+    /* Gradidnt Stop list */
+    {
+        InkSelectOneActionColumns columns;
 
-    return selected;
-}
+        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
 
-/* Set stop in menu to match stops selected by draggers. */
-static void select_stop_by_draggers(SPGradient *gradient, ToolBase *ev, GObject *data)
-{
-    if (!blocked) {
-        std::cerr << "select_stop_by_draggers should be blocked!" << std::endl;
-    }
+        Gtk::TreeModel::Row row;
 
-    if (!ev || !gradient)
-        return;
+        row = *(store->append());
+        row[columns.col_label    ] = _("No stops");
+        row[columns.col_tooltip  ] = "";
+        row[columns.col_icon     ] = "NotUsed";
+        row[columns.col_sensitive] = true;
 
-    SPGradient *vector = gradient->getVector();
-    if (!vector)
-        return;
+        toolbar->_stop_action =
+            InkSelectOneAction::create( "GradientStopAction", // Name
+                                        _("Stops" ),         // Label
+                                        "",                  // Tooltip
+                                        "Not Used",          // Icon
+                                        store );             // Tree store
 
-    InkSelectOneAction *act =
-        static_cast<InkSelectOneAction *>(g_object_get_data(data, "gradient_stop_action"));
+        toolbar->_stop_action->use_radio( false );
+        toolbar->_stop_action->use_icon( false );
+        toolbar->_stop_action->use_pixbuf( true );
+        toolbar->_stop_action->use_group_label( true );
+        toolbar->_stop_action->set_active( 0 );
+        toolbar->_stop_action->set_sensitive( false );
 
-    GrDrag *drag = ev->get_drag();
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_stop_action->gobj() ));
 
-    if (!drag || drag->selected.empty()) {
-        act->set_active(0);
-        gr_stop_set_offset(data);
-        return;
+        toolbar->_stop_action->signal_changed().connect(sigc::mem_fun(*toolbar, &GradientToolbar::stop_changed));
     }
 
-    gint n = 0;
-    SPStop *stop = nullptr;
-    int selected = -1;
-
-    // For all selected draggers
-    for(auto dragger : drag->selected) {
-
-        // For all draggables of dragger
-         for(auto draggable : dragger->draggables) {
-
-            if (draggable->point_type != POINT_RG_FOCUS) {
-                n++;
-                if (n > 1) break;
-            }
-
-            stop = vector->getFirstStop();
-
-            switch (draggable->point_type) {
-                case POINT_LG_MID:
-                case POINT_RG_MID1:
-                case POINT_RG_MID2:
-                    stop = sp_get_stop_i(vector, draggable->point_i);
-                    break;
-                case POINT_LG_END:
-                case POINT_RG_R1:
-                case POINT_RG_R2:
-                    stop = sp_last_stop(vector);
-                    break;
-                default:
-                    break;
-            }
-        }
-        if (n > 1) break;
+    /* Offset */
+    {
+        toolbar->_offset_action = create_adjustment_action( "GradientEditOffsetAction",
+                                                            _("Offset"), C_("Gradient", "Offset:"), _("Offset of selected stop"),
+                                                            "/tools/gradient/stopoffset", 0,
+                                                            GTK_WIDGET(desktop->canvas),
+                                                            nullptr, // dataKludge
+                                                            FALSE, nullptr,
+                                                            0.0, 1.0, 0.01, 0.1,
+                                                            nullptr, nullptr, 0,
+                                                            nullptr, // callback
+                                                            nullptr /*unit tracker*/,
+                                                            0.01, 2, 1.0);
+
+        toolbar->_offset_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_offset_action));
+        toolbar->_offset_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &GradientToolbar::stop_offset_adjustment_changed));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_offset_action) );
+        gtk_action_set_sensitive( GTK_ACTION(toolbar->_offset_action), FALSE );
     }
 
-    if (n > 1) {
-        // Multiple stops selected
-
-        EgeAdjustmentAction* offset = (EgeAdjustmentAction *)g_object_get_data( G_OBJECT(data), "offset_action");
-        if (offset) {
-            gtk_action_set_sensitive( GTK_ACTION(offset), FALSE);
-        }
-
-        // Stop list always updated first... reinsert "Multiple stops" as first entry.
-        InkSelectOneActionColumns columns;
-        Glib::RefPtr<Gtk::ListStore> store = act->get_store();
-
-        Gtk::TreeModel::Row row = *(store->prepend());
-        row[columns.col_label    ] = _("Multiple stops");
-        row[columns.col_tooltip  ] = "";
-        row[columns.col_icon     ] = "NotUsed";
-        row[columns.col_sensitive] = true;
-        selected = 0;
-
-    } else {
-        selected = select_stop_in_list( gradient, stop, data);
+    /* Add stop */
+    {
+        toolbar->_stops_add_action = ink_action_new( "GradientEditAddAction",
+                                                     _("Insert new stop"),
+                                                     _("Insert new stop"),
+                                                     INKSCAPE_ICON("node-add"),
+                                                     secondarySize );
+        gtk_action_set_short_label(GTK_ACTION(toolbar->_stops_add_action), _("Delete"));
+        g_signal_connect_after( G_OBJECT(toolbar->_stops_add_action), "activate", G_CALLBACK(add_stop), (gpointer)toolbar);
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_stops_add_action) );
+        gtk_action_set_sensitive( GTK_ACTION(toolbar->_stops_add_action), FALSE );
     }
 
-    if (selected < 0) {
-        act->set_active (0);
-        act->set_sensitive (false);
-    } else {
-        act->set_active (selected);
-        act->set_sensitive (true);
-        gr_stop_set_offset(data);
+    /* Delete stop */
+    {
+        toolbar->_stops_delete_action = ink_action_new( "GradientEditDeleteAction",
+                                                        _("Delete stop"),
+                                                        _("Delete stop"),
+                                                        INKSCAPE_ICON("node-delete"),
+                                                        secondarySize );
+        gtk_action_set_short_label(GTK_ACTION(toolbar->_stops_delete_action), _("Delete"));
+        g_signal_connect_after( G_OBJECT(toolbar->_stops_delete_action), "activate", G_CALLBACK(remove_stop), (gpointer)toolbar );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_stops_delete_action) );
+        gtk_action_set_sensitive( GTK_ACTION(toolbar->_stops_delete_action), FALSE );
     }
-}
 
-/* Return gradient selected in menu. */
-static SPGradient *gr_get_selected_gradient(GObject *data)
-{
-    InkSelectOneAction *act =
-        static_cast<InkSelectOneAction *>(g_object_get_data(data, "gradient_select_action"));
+    /* Reverse */
+    {
+        toolbar->_stops_reverse_action = ink_action_new( "GradientEditReverseAction",
+                                                         _("Reverse"),
+                                                         _("Reverse the direction of the gradient"),
+                                                         INKSCAPE_ICON("object-flip-horizontal"),
+                                                         secondarySize );
+        // TODO: Is this label correct?
+        gtk_action_set_short_label(GTK_ACTION(toolbar->_stops_reverse_action), _("Delete"));
+        g_signal_connect_after( G_OBJECT(toolbar->_stops_reverse_action), "activate", G_CALLBACK(reverse), desktop );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_stops_reverse_action) );
+        gtk_action_set_sensitive( GTK_ACTION(toolbar->_stops_reverse_action), FALSE );
+    }
 
-    int active = act->get_active();
+    // Gradients Linked toggle
+    {
+        InkToggleAction* itact = ink_toggle_action_new( "GradientEditLinkAction",
+                                                        _("Link gradients"),
+                                                        _("Link gradients to change all related gradients"),
+                                                        INKSCAPE_ICON("object-unlocked"),
+                                                        GTK_ICON_SIZE_MENU );
+        // TODO: Shouldn't this be translatable?
+        gtk_action_set_short_label( GTK_ACTION(itact), "Lock");
+        g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(linked_changed), desktop) ;
+        gtk_action_group_add_action( mainActions, GTK_ACTION(itact) );
 
-    Glib::RefPtr<Gtk::ListStore> store = act->get_store();
-    Gtk::TreeModel::Row row = store->children()[active];
-    InkSelectOneActionColumns columns;
+        bool linkedmode = prefs->getBool("/options/forkgradientvectors/value", true);
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(itact), !linkedmode );
+    }
 
-    void* pointer = row[columns.col_data];
-    SPGradient *gr = static_cast<SPGradient *>(pointer);
+    desktop->connectEventContextChanged(sigc::mem_fun(*toolbar, &GradientToolbar::check_ec));
 
-    return gr;
+    return GTK_WIDGET(toolbar->gobj());
 }
 
-/*
- * Callback functions for user actions
- */
-
-static void gr_new_type_changed( GObject * /*data*/, int mode )
+void
+GradientToolbar::new_type_changed(int mode)
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     prefs->setInt("/tools/gradient/newgradient",
                   mode == 0 ? SP_GRADIENT_TYPE_LINEAR : SP_GRADIENT_TYPE_RADIAL);
 }
 
-static void gr_new_fillstroke_changed( GObject * /*data*/, int mode )
+void
+GradientToolbar::new_fillstroke_changed(int mode)
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     Inkscape::PaintTarget fsmode = (mode == 0) ? Inkscape::FOR_FILL : Inkscape::FOR_STROKE;
@@ -710,7 +639,8 @@ static void gr_new_fillstroke_changed( GObject * /*data*/, int mode )
 /*
  * User selected a gradient from the combobox
  */
-static void gr_gradient_changed( GObject *data, int active )
+void
+GradientToolbar::gradient_changed(int active)
 {
     if (blocked) {
         return;
@@ -722,28 +652,46 @@ static void gr_gradient_changed( GObject *data, int active )
 
     blocked = true;
 
-    SPGradient *gr = gr_get_selected_gradient (data);
+    SPGradient *gr = get_selected_gradient();
 
     if (gr) {
         gr = sp_gradient_ensure_vector_normalized(gr);
 
-        SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(data, "desktop"));
-        Inkscape::Selection *selection = desktop->getSelection();
-        ToolBase *ev = desktop->getEventContext();
+        Inkscape::Selection *selection = _desktop->getSelection();
+        ToolBase *ev = _desktop->getEventContext();
 
         gr_apply_gradient(selection, ev ? ev->get_drag() : nullptr, gr);
 
-        DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_GRADIENT,
+        DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_GRADIENT,
                    _("Assign gradient to object"));
     }
 
     blocked = false;
 }
 
-/*
- * User selected a spread method from the combobox
+/**
+ * \brief Return gradient selected in menu
  */
-static void gr_spread_changed( GObject *data, int active )
+SPGradient *
+GradientToolbar::get_selected_gradient()
+{
+    int active = _select_action->get_active();
+
+    Glib::RefPtr<Gtk::ListStore> store = _select_action->get_store();
+    Gtk::TreeModel::Row row = store->children()[active];
+    InkSelectOneActionColumns columns;
+
+    void* pointer = row[columns.col_data];
+    SPGradient *gr = static_cast<SPGradient *>(pointer);
+
+    return gr;
+}
+
+/**
+ * \brief User selected a spread method from the combobox
+ */
+void
+GradientToolbar::spread_changed(int active)
 {
     if (blocked) {
         return;
@@ -751,8 +699,7 @@ static void gr_spread_changed( GObject *data, int active )
 
     blocked = true;
 
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(data, "desktop"));
-    Inkscape::Selection *selection = desktop->getSelection();
+    Inkscape::Selection *selection = _desktop->getSelection();
     SPGradient *gradient = nullptr;
     gr_get_dt_selected_gradient(selection, gradient);
 
@@ -761,17 +708,18 @@ static void gr_spread_changed( GObject *data, int active )
         gradient->setSpread(spread);
         gradient->updateRepr();
 
-        DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_GRADIENT,
+        DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_GRADIENT,
                    _("Set gradient repeat"));
     }
 
     blocked = false;
 }
 
-/*
- * User selected a stop from the combobox
+/**
+ * \brief User selected a stop from the combobox
  */
-static void gr_stop_changed( GObject *data, int active )
+void
+GradientToolbar::stop_changed(int active)
 {
     if (blocked) {
         return;
@@ -779,39 +727,106 @@ static void gr_stop_changed( GObject *data, int active )
 
     blocked = true;
 
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(G_OBJECT(data), "desktop"));
-    ToolBase *ev = desktop->getEventContext();
-    SPGradient *gr = gr_get_selected_gradient(data);
+    ToolBase *ev = _desktop->getEventContext();
+    SPGradient *gr = get_selected_gradient();
 
-    select_dragger_by_stop(data, gr, ev);
+    select_dragger_by_stop(gr, ev);
 
     blocked = false;
 }
 
-/*
- * User selected a stop from the combobox
+void
+GradientToolbar::select_dragger_by_stop(SPGradient *gradient,
+                                        ToolBase   *ev)
+{
+    if (!blocked) {
+        std::cerr << "select_dragger_by_stop: should be blocked!" << std::endl;
+    }
+
+    if (!ev || !gradient) {
+        return;
+    }
+
+    GrDrag *drag = ev->get_drag();
+    if (!drag) {
+        return;
+    }
+
+    SPStop *stop = get_selected_stop();
+
+    drag->selectByStop(stop, false, true);
+
+    stop_set_offset();
+}
+
+/**
+ * \brief Get stop selected by menu
  */
-static void gr_stop_combo_changed(GtkComboBox * /*widget*/, GObject *data)
+SPStop *
+GradientToolbar::get_selected_stop()
 {
-    if (blocked) {
+    int active = _stop_action->get_active();
+
+    Glib::RefPtr<Gtk::ListStore> store = _stop_action->get_store();
+    Gtk::TreeModel::Row row = store->children()[active];
+    InkSelectOneActionColumns columns;
+    void* pointer = row[columns.col_data];
+    SPStop *stop = static_cast<SPStop *>(pointer);
+
+    return stop;
+}
+
+/**
+ *  Change desktop dragger selection to this stop
+ *
+ *  Set the offset widget value (based on which stop is selected)
+ */
+void
+GradientToolbar::stop_set_offset()
+{
+    if (!blocked) {
+        std::cerr << "gr_stop_set_offset: should be blocked!" << std::endl;
+    }
+
+    SPStop *stop = get_selected_stop();
+    if (!stop) {
+        // std::cerr << "gr_stop_set_offset: no stop!" << std::endl;
         return;
     }
 
-    blocked = true;
+    if (!_offset_action) {
+        return;
+    }
+    bool isEndStop = false;
 
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(G_OBJECT(data), "desktop"));
-    ToolBase *ev = desktop->getEventContext();
-    SPGradient *gr = gr_get_selected_gradient(data);
+    SPStop *prev = nullptr;
+    prev = stop->getPrevStop();
+    if (prev != nullptr )  {
+        _offset_adj->set_lower(prev->offset);
+    } else {
+        isEndStop = true;
+        _offset_adj->set_lower(0);
+    }
 
-    select_dragger_by_stop(data, gr, ev);
+    SPStop *next = nullptr;
+    next = stop->getNextStop();
+    if (next != nullptr ) {
+        _offset_adj->set_upper(next->offset);
+    } else {
+        isEndStop = true;
+        _offset_adj->set_upper(1.0);
+    }
 
-    blocked = false;
+    _offset_adj->set_value(stop->offset);
+    gtk_action_set_sensitive( GTK_ACTION(_offset_action), !isEndStop );
+    _offset_adj->changed();
 }
 
-/*
- * User changed the offset
+/**
+ * \brief User changed the offset
  */
-static void gr_stop_offset_adjustment_changed(GtkAdjustment *adj, GObject *data)
+void
+GradientToolbar::stop_offset_adjustment_changed()
 {
     if (blocked) {
         return;
@@ -819,9 +834,9 @@ static void gr_stop_offset_adjustment_changed(GtkAdjustment *adj, GObject *data)
 
     blocked = true;
 
-    SPStop *stop = get_selected_stop(data);
+    SPStop *stop = get_selected_stop();
     if (stop) {
-        stop->offset = gtk_adjustment_get_value(adj);
+        stop->offset = _offset_adj->get_value();
         sp_repr_set_css_double(stop->getRepr(), "offset", stop->offset);
 
         DocumentUndo::maybeDone(stop->document, "gradient:stop:offset", SP_VERB_CONTEXT_GRADIENT,
@@ -832,428 +847,394 @@ static void gr_stop_offset_adjustment_changed(GtkAdjustment *adj, GObject *data)
     blocked = false;
 }
 
-
-static void gradient_toolbox_check_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* data);
-
 /**
- * Gradient auxiliary toolbar construction and setup.
- *
+ * \brief Add stop to gradient
  */
-void sp_gradient_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObject* data)
+void
+GradientToolbar::add_stop(GtkWidget * /*button*/, gpointer data)
 {
-    GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
-
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-
-    /* New gradient linear or radial */
-    {
-        InkSelectOneActionColumns columns;
-
-        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
-
-        Gtk::TreeModel::Row row;
+    auto toolbar = reinterpret_cast<GradientToolbar *>(data);
+    if (!toolbar->_desktop) {
+        return;
+    }
 
-        row = *(store->append());
-        row[columns.col_label    ] = _("linear");
-        row[columns.col_tooltip  ] = _("Create linear gradient");
-        row[columns.col_icon     ] = INKSCAPE_ICON("paint-gradient-linear");
-        row[columns.col_sensitive] = true;
+    Inkscape::Selection *selection = toolbar->_desktop->getSelection();
+    if (!selection) {
+        return;
+    }
 
-        row = *(store->append());
-        row[columns.col_label    ] = _("radial");
-        row[columns.col_tooltip  ] = _("Create radial (elliptic or circular) gradient");
-        row[columns.col_icon     ] = INKSCAPE_ICON("paint-gradient-radial");
-        row[columns.col_sensitive] = true;
+    ToolBase *ev = toolbar->_desktop->getEventContext();
+    Inkscape::UI::Tools::GradientTool *rc = SP_GRADIENT_CONTEXT(ev);
 
-        InkSelectOneAction* act =
-            InkSelectOneAction::create( "GradientNewTypeAction", // Name
-                                        _("New"),            // Label
-                                        "",                  // Tooltip
-                                        "Not Used",          // Icon
-                                        store );             // Tree store
+    if (rc) {
+        sp_gradient_context_add_stops_between_selected_stops(rc);
+    }
+}
 
-        act->use_radio( true );
-        act->use_group_label( true );
-        gint mode = prefs->getInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR);
-        act->set_active( mode == SP_GRADIENT_TYPE_LINEAR ? 0 : 1 ); // linear == 1, radial == 2
+/**
+ * \brief Remove stop from vector
+ */
+void
+GradientToolbar::remove_stop(GtkWidget * /*button*/, gpointer data)
+{
+    auto toolbar = reinterpret_cast<GradientToolbar *>(data);
 
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data( data, "gradient_new_type_mode", act );
+    if (!toolbar->_desktop) {
+        return;
+    }
 
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&gr_new_type_changed), data));
+    Inkscape::Selection *selection = toolbar->_desktop->getSelection(); // take from desktop, not from args
+    if (!selection) {
+        return;
     }
 
-    /* New gradient on fill or stroke*/
-    {
-        InkSelectOneActionColumns columns;
+    ToolBase *ev = toolbar->_desktop->getEventContext();
+    GrDrag *drag = nullptr;
+    if (ev) {
+        drag = ev->get_drag();
+    }
 
-        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
+    if (drag) {
+        drag->deleteSelected();
+    }
+}
 
-        Gtk::TreeModel::Row row;
+/**
+ * \brief Reverse vector
+ */
+void
+GradientToolbar::reverse(GtkWidget * /*button*/, gpointer data)
+{
+    SPDesktop *desktop = static_cast<SPDesktop *>(data);
+    sp_gradient_reverse_selected_gradients(desktop);
+}
 
-        row = *(store->append());
-        row[columns.col_label    ] = _("fill");
-        row[columns.col_tooltip  ] = _("Create gradient in the fill");
-        row[columns.col_icon     ] = INKSCAPE_ICON("object-fill");
-        row[columns.col_sensitive] = true;
+/**
+ * \brief Lock or unlock links
+ */
+void
+GradientToolbar::linked_changed(GtkToggleAction *act, gpointer /*data*/)
+{
+    gboolean active = gtk_toggle_action_get_active( act );
+    if ( active ) {
+        g_object_set( G_OBJECT(act), "iconId", INKSCAPE_ICON("object-locked"), NULL );
+    } else {
+        g_object_set( G_OBJECT(act), "iconId", INKSCAPE_ICON("object-unlocked"), NULL );
+    }
 
-        row = *(store->append());
-        row[columns.col_label    ] = _("stroke");
-        row[columns.col_tooltip  ] = _("Create gradient in the stroke");
-        row[columns.col_icon     ] = INKSCAPE_ICON("object-stroke");
-        row[columns.col_sensitive] = true;
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setBool("/options/forkgradientvectors/value", !active);
+}
 
-        InkSelectOneAction* act =
-            InkSelectOneAction::create( "GradientNewFillStrokeAction", // Name
-                                        "",                  // Label
-                                        "",                  // Tooltip
-                                        "Not Used",          // Icon
-                                        store );             // Tree store
+// lp:1327267
+/**
+ * Checks the current tool and connects gradient aux toolbox signals if it happens to be the gradient tool.
+ * Called every time the current tool changes by signal emission.
+ */
+void
+GradientToolbar::check_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec)
+{
+    if (SP_IS_GRADIENT_CONTEXT(ec)) {
+        Inkscape::Selection *selection = desktop->getSelection();
+        SPDocument *document = desktop->getDocument();
 
-        act->use_radio( true );
-        act->use_group_label( false );
-        Inkscape::PaintTarget fsmode = (prefs->getInt("/tools/gradient/newfillorstroke", 1) != 0) ? Inkscape::FOR_FILL : Inkscape::FOR_STROKE;
-        act->set_active( fsmode == Inkscape::FOR_FILL ? 0 : 1 );
+        // connect to selection modified and changed signals
+        _connection_changed  = selection->connectChanged(sigc::mem_fun(*this, &GradientToolbar::selection_changed));
+        _connection_modified = selection->connectModified(sigc::mem_fun(*this, &GradientToolbar::selection_modified));
+        _connection_subselection_changed = desktop->connectToolSubselectionChanged(sigc::mem_fun(*this, &GradientToolbar::drag_selection_changed));
 
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data( data, "gradient_new_fillstroke_action", act );
+        // Is this necessary? Couldn't hurt.
+        selection_changed(selection);
 
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&gr_new_fillstroke_changed), data));
+        // connect to release and modified signals of the defs (i.e. when someone changes gradient)
+        _connection_defs_release  = document->getDefs()->connectRelease(sigc::mem_fun(*this, &GradientToolbar::defs_release));
+        _connection_defs_modified = document->getDefs()->connectModified(sigc::mem_fun(*this, &GradientToolbar::defs_modified));
+    } else {
+        if (_connection_changed)
+            _connection_changed.disconnect();
+        if (_connection_modified)
+            _connection_modified.disconnect();
+        if (_connection_subselection_changed)
+            _connection_subselection_changed.disconnect();
+        if (_connection_defs_release)
+            _connection_defs_release.disconnect();
+        if (_connection_defs_modified)
+            _connection_defs_modified.disconnect();
     }
+}
 
-    /* Gradient Select list*/
-    {
-        InkSelectOneActionColumns columns;
+/**
+ * Core function, setup all the widgets whenever something changes on the desktop
+ */
+void
+GradientToolbar::selection_changed(Inkscape::Selection * /*selection*/)
+{
+    if (blocked)
+        return;
 
-        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
+    blocked = true;
 
-        Gtk::TreeModel::Row row;
+    if (!_desktop) {
+        return;
+    }
 
-        row = *(store->append());
-        row[columns.col_label    ] = _("No gradient");
-        row[columns.col_tooltip  ] = "";
-        row[columns.col_icon     ] = "NotUsed";
-        row[columns.col_sensitive] = true;
+    Inkscape::Selection *selection = _desktop->getSelection(); // take from desktop, not from args
+    if (selection) {
 
-        InkSelectOneAction* act =
-            InkSelectOneAction::create( "GradientSelectGradientAction", // Name
-                                        _("Select"),         // Label
-                                        "",                  // Tooltip
-                                        "Not Used",          // Icon
-                                        store );             // Tree store
+        ToolBase *ev = _desktop->getEventContext();
+        GrDrag *drag = nullptr;
+        if (ev) {
+            drag = ev->get_drag();
+        }
 
-        act->use_radio( false );
-        act->use_icon( false );
-        act->use_pixbuf( true );
-        act->use_group_label( true );
-        act->set_active( 0 );
-        act->set_sensitive( false );
+        SPGradient *gr_selected = nullptr;
+        SPGradientSpread spr_selected = SP_GRADIENT_SPREAD_UNDEFINED;
+        bool gr_multi = false;
+        bool spr_multi = false;
 
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data( data, "gradient_select_action", act );
+        gr_read_selection(selection, drag, gr_selected, gr_multi, spr_selected, spr_multi);
 
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&gr_gradient_changed), data));
-    }
+        // Gradient selection menu
+        auto store = _select_action->get_store();
+        int gradient = gr_vector_list (store, _desktop, selection->isEmpty(), gr_selected, gr_multi);
 
-    // Gradient Spread type (how a gradient is drawn outside it's nominal area)
-    {
-        InkSelectOneActionColumns columns;
+        if (gradient < 0) {
+            // No selection or no gradients
+            _select_action->set_active( 0 );
+            _select_action->set_sensitive (false);
+        } else {
+            // Single gradient or multiple gradients
+            _select_action->set_active( gradient );
+            _select_action->set_sensitive (true);
+        }
 
-        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
+        // Spread menu
+        _spread_action->set_sensitive( gr_selected && !gr_multi );
+        _spread_action->set_active( gr_selected ? (int)spr_selected : 0 );
 
-        Gtk::TreeModel::Row row;
+        gtk_action_set_sensitive(GTK_ACTION(_stops_add_action),     (gr_selected && !gr_multi && drag && !drag->selected.empty()));
+        gtk_action_set_sensitive(GTK_ACTION(_stops_delete_action),  (gr_selected && !gr_multi && drag && !drag->selected.empty()));
+        gtk_action_set_sensitive(GTK_ACTION(_stops_reverse_action), (gr_selected!= nullptr));
 
-        row = *(store->append());
-        row[columns.col_label    ] = C_("Gradient repeat type", "None");
-        row[columns.col_tooltip  ] = "";
-        row[columns.col_icon     ] = "NotUsed";
-        row[columns.col_sensitive] = true;
+        _stop_action->set_sensitive( gr_selected && !gr_multi);
 
-        row = *(store->append());
-        row[columns.col_label    ] = _("Reflected");
-        row[columns.col_tooltip  ] = "";
-        row[columns.col_icon     ] = "NotUsed";
-        row[columns.col_sensitive] = true;
+        int stop = update_stop_list (gr_selected, nullptr, gr_multi);
+        select_stop_by_draggers(gr_selected, ev);
+    }
 
-        row = *(store->append());
-        row[columns.col_label    ] = _("Direct");
-        row[columns.col_tooltip  ] = "";
-        row[columns.col_icon     ] = "NotUsed";
-        row[columns.col_sensitive] = true;
+    blocked = false;
+}
 
-        InkSelectOneAction* act =
-            InkSelectOneAction::create( "GradientSelectSpreadAction", // Name
-                                        _("Repeat"),            // Label
-                                        // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/pservers.html#LinearGradientSpreadMethodAttribute
-                                        _("Whether to fill with flat color beyond the ends of the gradient vector "
-                                          "(spreadMethod=\"pad\"), or repeat the gradient in the same direction "
-                                          "(spreadMethod=\"repeat\"), or repeat the gradient in alternating opposite "
-                                          "directions (spreadMethod=\"reflect\")"),    // Tooltip
-                                        "Not Used",             // Icon
-                                        store );                // Tree store
+/**
+ * \brief Construct stop list
+ */
+int
+GradientToolbar::update_stop_list( SPGradient *gradient, SPStop *new_stop, bool gr_multi)
+{
+    if (!blocked) {
+        std::cerr << "update_stop_list should be blocked!" << std::endl;
+    }
 
-        act->use_radio( false );
-        act->use_icon( false );
-        act->use_group_label( true );
-        act->set_sensitive( false );
+    int selected = -1;
 
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data( data, "gradient_spread_action", act );
+    auto store = _stop_action->get_store();
 
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&gr_spread_changed), data));
+    if (!store) {
+        return selected;
     }
 
-    /* Gradidnt Stop list */
-    {
-        InkSelectOneActionColumns columns;
+    store->clear();
 
-        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
+    InkSelectOneActionColumns columns;
+    Gtk::TreeModel::Row row;
 
-        Gtk::TreeModel::Row row;
+    if (!SP_IS_GRADIENT(gradient)) {
+        // No valid gradient
 
         row = *(store->append());
-        row[columns.col_label    ] = _("No stops");
+        row[columns.col_label    ] = _("No gradient");
         row[columns.col_tooltip  ] = "";
         row[columns.col_icon     ] = "NotUsed";
+        row[columns.col_data     ] = nullptr;
         row[columns.col_sensitive] = true;
 
-        InkSelectOneAction* act =
-            InkSelectOneAction::create( "GradientStopAction", // Name
-                                        _("Stops" ),         // Label
-                                        "",                  // Tooltip
-                                        "Not Used",          // Icon
-                                        store );             // Tree store
-
-        act->use_radio( false );
-        act->use_icon( false );
-        act->use_pixbuf( true );
-        act->use_group_label( true );
-        act->set_active( 0 );
-        act->set_sensitive( false );
+    } else if (!gradient->hasStops()) {
+        // Has gradient but it has no stops
 
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data( data, "gradient_stop_action", act );
+        row = *(store->append());
+        row[columns.col_label    ] = _("No stops in gradient");
+        row[columns.col_tooltip  ] = "";
+        row[columns.col_icon     ] = "NotUsed";
+        row[columns.col_data     ] = nullptr;
+        row[columns.col_sensitive] = true;
 
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&gr_stop_changed), data));
-    }
+    } else {
+        // Gradient has stops
 
-    /* Offset */
-    {
-        EgeAdjustmentAction* eact = nullptr;
-        eact = create_adjustment_action( "GradientEditOffsetAction",
-                                         _("Offset"), C_("Gradient", "Offset:"), _("Offset of selected stop"),
-                                         "/tools/gradient/stopoffset", 0,
-                                         GTK_WIDGET(desktop->canvas), data, FALSE, nullptr,
-                                         0.0, 1.0, 0.01, 0.1,
-                                         nullptr, nullptr, 0,
-                                         gr_stop_offset_adjustment_changed,
-                                         nullptr /*unit tracker*/,
-                                         0.01, 2, 1.0);
-
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        g_object_set_data( data, "offset_action", eact );
-        gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
+        // Get list of stops
+        for (auto& ochild: gradient->children) {
+            if (SP_IS_STOP(&ochild)) {
 
-    }
+                SPStop *stop = SP_STOP(&ochild);
+                Glib::RefPtr<Gdk::Pixbuf> pixbuf = sp_gradstop_to_pixbuf_ref (stop, 32, 16);
 
-    /* Add stop */
-    {
-        InkAction* inky = ink_action_new( "GradientEditAddAction",
-                                          _("Insert new stop"),
-                                          _("Insert new stop"),
-                                          INKSCAPE_ICON("node-add"),
-                                          secondarySize );
-        g_object_set( inky, "short_label", _("Delete"), NULL );
-        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(gr_add_stop), data );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
-        gtk_action_set_sensitive( GTK_ACTION(inky), FALSE );
-        g_object_set_data( data, "gradient_stops_add_action", inky );
-    }
+                Inkscape::XML::Node *repr = reinterpret_cast<SPItem *>(&ochild)->getRepr();
+                Glib::ustring label = gr_ellipsize_text(repr->attribute("id"), 25);
 
-    /* Delete stop */
-    {
-        InkAction* inky = ink_action_new( "GradientEditDeleteAction",
-                                          _("Delete stop"),
-                                          _("Delete stop"),
-                                          INKSCAPE_ICON("node-delete"),
-                                          secondarySize );
-        g_object_set( inky, "short_label", _("Delete"), NULL );
-        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(gr_remove_stop), data );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
-        gtk_action_set_sensitive( GTK_ACTION(inky), FALSE );
-        g_object_set_data( data, "gradient_stops_delete_action", inky );
+                row = *(store->append());
+                row[columns.col_label    ] = label;
+                row[columns.col_tooltip  ] = "";
+                row[columns.col_icon     ] = "NotUsed";
+                row[columns.col_pixbuf   ] = pixbuf;
+                row[columns.col_data     ] = stop;
+                row[columns.col_sensitive] = true;
+            }
+        }
     }
 
-    /* Reverse */
-    {
-        InkAction* inky = ink_action_new( "GradientEditReverseAction",
-                                          _("Reverse"),
-                                          _("Reverse the direction of the gradient"),
-                                          INKSCAPE_ICON("object-flip-horizontal"),
-                                          secondarySize );
-        g_object_set( inky, "short_label", _("Delete"), NULL );
-        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(gr_reverse), desktop );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
-        gtk_action_set_sensitive( GTK_ACTION(inky), FALSE );
-        g_object_set_data( data, "gradient_stops_reverse_action", inky );
-
+    if (new_stop != nullptr) {
+        selected = select_stop_in_list (gradient, new_stop);
     }
 
-    // Gradients Linked toggle
-    {
-        InkToggleAction* itact = ink_toggle_action_new( "GradientEditLinkAction",
-                                                        _("Link gradients"),
-                                                        _("Link gradients to change all related gradients"),
-                                                        INKSCAPE_ICON("object-unlocked"),
-                                                        GTK_ICON_SIZE_MENU );
-        g_object_set( itact, "short_label", "Lock", NULL );
-        g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(gr_linked_changed), desktop) ;
-        gtk_action_group_add_action( mainActions, GTK_ACTION(itact) );
+    return selected;
+}
 
-        bool linkedmode = prefs->getBool("/options/forkgradientvectors/value", true);
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(itact), !linkedmode );
+/**
+ * \brief Find position of new_stop in menu.
+ */
+int
+GradientToolbar::select_stop_in_list(SPGradient *gradient, SPStop *new_stop)
+{
+    int i = 0;
+    for (auto& ochild: gradient->children) {
+        if (SP_IS_STOP(&ochild)) {
+            if (&ochild == new_stop) {
+                return i;
+            }
+            i++;
+        }
     }
-
-    g_object_set_data(data, "desktop", desktop);
-
-    desktop->connectEventContextChanged(sigc::bind(sigc::ptr_fun(&gradient_toolbox_check_ec), data));
+    return -1;
 }
 
-
-// =================== Selection Changed Callbacks ======================= //
-
-/*
- * Core function, setup all the widgets whenever something changes on the desktop
+/**
+ * \brief Set stop in menu to match stops selected by draggers
  */
-static void gr_tb_selection_changed(Inkscape::Selection * /*selection*/, GObject* data)
+void
+GradientToolbar::select_stop_by_draggers(SPGradient *gradient, ToolBase *ev)
 {
-    if (blocked)
+    if (!blocked) {
+        std::cerr << "select_stop_by_draggers should be blocked!" << std::endl;
+    }
+
+    if (!ev || !gradient)
         return;
 
-    blocked = true;
+    SPGradient *vector = gradient->getVector();
+    if (!vector)
+        return;
 
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(data, "desktop"));
-    if (!desktop) {
+    GrDrag *drag = ev->get_drag();
+
+    if (!drag || drag->selected.empty()) {
+        _stop_action->set_active(0);
+        stop_set_offset();
         return;
     }
 
-    Inkscape::Selection *selection = desktop->getSelection(); // take from desktop, not from args
-    if (selection) {
+    gint n = 0;
+    SPStop *stop = nullptr;
+    int selected = -1;
 
-        ToolBase *ev = desktop->getEventContext();
-        GrDrag *drag = nullptr;
-        if (ev) {
-            drag = ev->get_drag();
-        }
+    // For all selected draggers
+    for(auto dragger : drag->selected) {
 
-        SPGradient *gr_selected = nullptr;
-        SPGradientSpread spr_selected = SP_GRADIENT_SPREAD_UNDEFINED;
-        bool gr_multi = false;
-        bool spr_multi = false;
+        // For all draggables of dragger
+         for(auto draggable : dragger->draggables) {
 
-        gr_read_selection(selection, drag, gr_selected, gr_multi, spr_selected, spr_multi);
+            if (draggable->point_type != POINT_RG_FOCUS) {
+                n++;
+                if (n > 1) break;
+            }
 
-        // Gradient selection menu
-        auto sel = static_cast<InkSelectOneAction*>(g_object_get_data(data, "gradient_select_action"));
-        Glib::RefPtr<Gtk::ListStore> store = sel->get_store();
-        int gradient = gr_vector_list (store, desktop, selection->isEmpty(), gr_selected, gr_multi);
+            stop = vector->getFirstStop();
 
-        if (gradient < 0) {
-            // No selection or no gradients
-            sel->set_active( 0 );
-            sel->set_sensitive (false);
-        } else {
-            // Single gradient or multiple gradients
-            sel->set_active( gradient );
-            sel->set_sensitive (true);
+            switch (draggable->point_type) {
+                case POINT_LG_MID:
+                case POINT_RG_MID1:
+                case POINT_RG_MID2:
+                    stop = sp_get_stop_i(vector, draggable->point_i);
+                    break;
+                case POINT_LG_END:
+                case POINT_RG_R1:
+                case POINT_RG_R2:
+                    stop = sp_last_stop(vector);
+                    break;
+                default:
+                    break;
+            }
         }
+        if (n > 1) break;
+    }
 
-        // Spread menu
-        auto spread = static_cast<InkSelectOneAction*>(g_object_get_data(data, "gradient_spread_action"));
-        spread->set_sensitive( gr_selected && !gr_multi );
-        spread->set_active( gr_selected ? (int)spr_selected : 0 );
-
-        InkAction *add = (InkAction *) g_object_get_data(data, "gradient_stops_add_action");
-        gtk_action_set_sensitive(GTK_ACTION(add), (gr_selected && !gr_multi && drag && !drag->selected.empty()));
-
-        InkAction *del = (InkAction *) g_object_get_data(data, "gradient_stops_delete_action");
-        gtk_action_set_sensitive(GTK_ACTION(del), (gr_selected && !gr_multi && drag && !drag->selected.empty()));
+    if (n > 1) {
+        // Multiple stops selected
+        if (_offset_action) {
+            gtk_action_set_sensitive( GTK_ACTION(_offset_action), FALSE);
+        }
 
-        InkAction *reverse = (InkAction *) g_object_get_data(data, "gradient_stops_reverse_action");
-        gtk_action_set_sensitive(GTK_ACTION(reverse), (gr_selected!= nullptr));
+        // Stop list always updated first... reinsert "Multiple stops" as first entry.
+        InkSelectOneActionColumns columns;
+        Glib::RefPtr<Gtk::ListStore> store = _stop_action->get_store();
 
-        InkSelectOneAction *stops_action = (InkSelectOneAction *) g_object_get_data(data, "gradient_stop_action");
-        stops_action->set_sensitive( gr_selected && !gr_multi);
+        Gtk::TreeModel::Row row = *(store->prepend());
+        row[columns.col_label    ] = _("Multiple stops");
+        row[columns.col_tooltip  ] = "";
+        row[columns.col_icon     ] = "NotUsed";
+        row[columns.col_sensitive] = true;
+        selected = 0;
 
-        int stop = update_stop_list (gr_selected, nullptr, data, gr_multi);
-        select_stop_by_draggers(gr_selected, ev, data);
+    } else {
+        selected = select_stop_in_list(gradient, stop);
     }
 
-    blocked = false;
+    if (selected < 0) {
+        _stop_action->set_active (0);
+        _stop_action->set_sensitive (false);
+    } else {
+        _stop_action->set_active (selected);
+        _stop_action->set_sensitive (true);
+        stop_set_offset();
+    }
 }
 
-static void gr_tb_selection_modified(Inkscape::Selection *selection, guint /*flags*/, GObject* data)
+void
+GradientToolbar::selection_modified(Inkscape::Selection *selection, guint /*flags*/)
 {
-    gr_tb_selection_changed(selection, data);
+    selection_changed(selection);
 }
 
-static void gr_drag_selection_changed(gpointer /*dragger*/, GObject* data)
+void
+GradientToolbar::drag_selection_changed(gpointer /*dragger*/)
 {
-    gr_tb_selection_changed(nullptr, data);
+   selection_changed(nullptr);
 }
 
-static void gr_defs_release(SPObject * /*defs*/, GObject* data)
+void
+GradientToolbar::defs_release(SPObject * /*defs*/)
 {
-    gr_tb_selection_changed(nullptr, data);
+    selection_changed(nullptr);
 }
 
-static void gr_defs_modified(SPObject * /*defs*/, guint /*flags*/, GObject* data)
+void
+GradientToolbar::defs_modified(SPObject * /*defs*/, guint /*flags*/)
 {
-    gr_tb_selection_changed(nullptr, data);
+    selection_changed(nullptr);
 }
 
-// lp:1327267
-/**
- * Checks the current tool and connects gradient aux toolbox signals if it happens to be the gradient tool.
- * Called every time the current tool changes by signal emission.
- */
-static void gradient_toolbox_check_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec, GObject* data)
-{
-    static sigc::connection connChanged;
-    static sigc::connection connModified;
-    static sigc::connection connSubselectionChanged;
-    static sigc::connection connDefsRelease;
-    static sigc::connection connDefsModified;
-
-    if (SP_IS_GRADIENT_CONTEXT(ec)) {
-        Inkscape::Selection *selection = desktop->getSelection();
-        SPDocument *document = desktop->getDocument();
-
-        // connect to selection modified and changed signals
-        connChanged  = selection->connectChanged(sigc::bind(sigc::ptr_fun(&gr_tb_selection_changed), data));
-        connModified = selection->connectModified(sigc::bind(sigc::ptr_fun(&gr_tb_selection_modified), data));
-        connSubselectionChanged = desktop->connectToolSubselectionChanged(sigc::bind(sigc::ptr_fun(&gr_drag_selection_changed), data));
-
-        // Is this necessary? Couldn't hurt.
-        gr_tb_selection_changed(selection, data);
-
-        // connect to release and modified signals of the defs (i.e. when someone changes gradient)
-        connDefsRelease  = document->getDefs()->connectRelease( sigc::bind<1>(sigc::ptr_fun(&gr_defs_release),  data));
-        connDefsModified = document->getDefs()->connectModified(sigc::bind<2>(sigc::ptr_fun(&gr_defs_modified), data));
-    } else {
-        if (connChanged)
-            connChanged.disconnect();
-        if (connModified)
-            connModified.disconnect();
-        if (connSubselectionChanged)
-            connSubselectionChanged.disconnect();
-        if (connDefsRelease)
-            connDefsRelease.disconnect();
-        if (connDefsModified)
-            connDefsModified.disconnect();
-    }
 }
-
+}
+}
 /*
   Local Variables:
   mode:c++
diff --git a/src/ui/toolbar/gradient-toolbar.h b/src/ui/toolbar/gradient-toolbar.h
index 242086758..4e9f33bb7 100644
--- a/src/ui/toolbar/gradient-toolbar.h
+++ b/src/ui/toolbar/gradient-toolbar.h
@@ -13,11 +13,85 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "toolbar.h"
+
+#include <gtkmm/adjustment.h>
+
+class InkSelectOneAction;
 class SPDesktop;
+class SPGradient;
 
+typedef struct _EgeAdjustmentAction EgeAdjustmentAction;
 typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _GObject GObject;
+typedef struct _InkAction InkAction;
+
+namespace Inkscape {
+class Selection;
+
+namespace UI {
+namespace Tools {
+class ToolBase;
+}
+
+namespace Toolbar {
+class GradientToolbar : public Toolbar {
+private:
+    InkSelectOneAction *_new_type_mode;
+    InkSelectOneAction *_new_fillstroke_action;
+    InkSelectOneAction *_select_action;
+    InkSelectOneAction *_spread_action;
+    InkSelectOneAction *_stop_action;
+
+    InkAction *_stops_add_action;
+    InkAction *_stops_delete_action;
+    InkAction *_stops_reverse_action;
+
+    EgeAdjustmentAction *_offset_action;
+
+    Glib::RefPtr<Gtk::Adjustment> _offset_adj;
+
+    void new_type_changed(int mode);
+    void new_fillstroke_changed(int mode);
+    void gradient_changed(int active);
+    SPGradient * get_selected_gradient();
+    void spread_changed(int active);
+    void stop_changed(int active);
+    void select_dragger_by_stop(SPGradient          *gradient,
+                                UI::Tools::ToolBase *ev);
+    SPStop * get_selected_stop();
+    void stop_set_offset();
+    void stop_offset_adjustment_changed();
+    static void add_stop(GtkWidget *button, gpointer data);
+    static void remove_stop(GtkWidget *button, gpointer data);
+    static void reverse(GtkWidget *button, gpointer data);
+    static void linked_changed(GtkToggleAction *act, gpointer data);
+    void check_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec);
+    void selection_changed(Inkscape::Selection *selection);
+    int update_stop_list( SPGradient *gradient, SPStop *new_stop, bool gr_multi);
+    int select_stop_in_list(SPGradient *gradient, SPStop *new_stop);
+    void select_stop_by_draggers(SPGradient *gradient, UI::Tools::ToolBase *ev);
+    void selection_modified(Inkscape::Selection *selection, guint flags);
+    void drag_selection_changed(gpointer dragger);
+    void defs_release(SPObject * defs);
+    void defs_modified(SPObject *defs, guint flags);
+
+    sigc::connection _connection_changed;
+    sigc::connection _connection_modified;
+    sigc::connection _connection_subselection_changed;
+    sigc::connection _connection_defs_release;
+    sigc::connection _connection_defs_modified;
+
+protected:
+    GradientToolbar(SPDesktop *desktop)
+        : Toolbar(desktop)
+    {}
+
+public:
+    static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions);
+};
 
-void sp_gradient_toolbox_prep(SPDesktop * /*desktop*/, GtkActionGroup* mainActions, GObject* holder);
+}
+}
+}
 
 #endif /* !SEEN_GRADIENT_TOOLBAR_H */
diff --git a/src/ui/toolbar/lpe-toolbar.cpp b/src/ui/toolbar/lpe-toolbar.cpp
index 8ed30d9ac..361144881 100644
--- a/src/ui/toolbar/lpe-toolbar.cpp
+++ b/src/ui/toolbar/lpe-toolbar.cpp
@@ -45,219 +45,30 @@ using Inkscape::DocumentUndo;
 using Inkscape::UI::Tools::ToolBase;
 using Inkscape::UI::Tools::LpeTool;
 
-
-//########################
-//##      LPETool       ##
-//########################
-
-// the subtools from which the toolbar is built automatically are listed in lpe-tool-context.h
-
-// this is called when the mode is changed via the toolbar (i.e., one of the subtool buttons is pressed)
-static void sp_lpetool_mode_changed(GObject *tbl, int mode)
-{
-    using namespace Inkscape::LivePathEffect;
-
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(tbl, "desktop"));
-    ToolBase *ec = desktop->event_context;
-    if (!SP_IS_LPETOOL_CONTEXT(ec)) {
-        return;
-    }
-
-    // only take action if run by the attr_changed listener
-    if (!g_object_get_data(tbl, "freeze")) {
-        // in turn, prevent listener from responding
-        g_object_set_data(tbl, "freeze", GINT_TO_POINTER(TRUE));
-
-        EffectType type = lpesubtools[mode].type;
-
-        LpeTool *lc = SP_LPETOOL_CONTEXT(desktop->event_context);
-        bool success = lpetool_try_construction(lc, type);
-        if (success) {
-            // since the construction was already performed, we set the state back to inactive
-            InkSelectOneAction* act =
-                static_cast<InkSelectOneAction*>( g_object_get_data( tbl, "lpetool_mode_action" ) );
-            act->set_active(0);
-            mode = 0;
-        } else {
-            // switch to the chosen subtool
-            SP_LPETOOL_CONTEXT(desktop->event_context)->mode = type;
-        }
-
-        if (DocumentUndo::getUndoSensitive(desktop->getDocument())) {
-            Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-            prefs->setInt( "/tools/lpetool/mode", mode );
-        }
-
-        g_object_set_data(tbl, "freeze", GINT_TO_POINTER(FALSE));
-    }
-}
-
-static void sp_lpetool_toolbox_sel_modified(Inkscape::Selection *selection, guint /*flags*/, GObject * /*tbl*/)
-{
-    ToolBase *ec = selection->desktop()->event_context;
-    if (SP_IS_LPETOOL_CONTEXT(ec)) {
-        lpetool_update_measuring_items(SP_LPETOOL_CONTEXT(ec));
-    }
-}
-
-static void sp_lpetool_toolbox_sel_changed(Inkscape::Selection *selection, GObject *tbl)
-{
-    using namespace Inkscape::LivePathEffect;
-    ToolBase *ec = selection->desktop()->event_context;
-    if (!SP_IS_LPETOOL_CONTEXT(ec)) {
-        return;
-    }
-    LpeTool *lc = SP_LPETOOL_CONTEXT(ec);
-
-    lpetool_delete_measuring_items(lc);
-    lpetool_create_measuring_items(lc, selection);
-
-    // activate line segment combo box if a single item with LPELineSegment is selected
-    InkSelectOneAction* act =
-        static_cast<InkSelectOneAction*>( g_object_get_data( tbl, "lpetool_line_segment_action" ) );
-
-    SPItem *item = selection->singleItem();
-    if (item && SP_IS_LPE_ITEM(item) && lpetool_item_has_construction(lc, item)) {
-
-        SPLPEItem *lpeitem = SP_LPE_ITEM(item);
-        Effect* lpe = lpeitem->getCurrentLPE();
-        if (lpe && lpe->effectType() == LINE_SEGMENT) {
-            LPELineSegment *lpels = static_cast<LPELineSegment*>(lpe);
-            g_object_set_data(tbl, "currentlpe", lpe);
-            g_object_set_data(tbl, "currentlpeitem", lpeitem);
-            act->set_sensitive(true);
-            act->set_active( lpels->end_type.get_value() );
-        } else {
-            g_object_set_data(tbl, "currentlpe", nullptr);
-            g_object_set_data(tbl, "currentlpeitem", nullptr);
-            act->set_sensitive(false);
-        }
-
-    } else {
-        g_object_set_data(tbl, "currentlpe", nullptr);
-        g_object_set_data(tbl, "currentlpeitem", nullptr);
-        act->set_sensitive(false);
-    }
-}
-
-static void lpetool_toggle_show_bbox(GtkToggleAction *act, gpointer data) {
-    SPDesktop *desktop = static_cast<SPDesktop *>(data);
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-
-    bool show = gtk_toggle_action_get_active( act );
-    prefs->setBool("/tools/lpetool/show_bbox",  show);
-
-    if (tools_isactive(desktop, TOOLS_LPETOOL)) {
-        LpeTool *lc = SP_LPETOOL_CONTEXT(desktop->event_context);
-        lpetool_context_reset_limiting_bbox(lc);
-    }
-}
-
-static void lpetool_toggle_show_measuring_info(GtkToggleAction *act, GObject *tbl)
-{
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(tbl, "desktop"));
-    if (!tools_isactive(desktop, TOOLS_LPETOOL)) {
-        return;
-    }
-
-    bool show = gtk_toggle_action_get_active( act );
-
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setBool("/tools/lpetool/show_measuring_info",  show);
-
-    LpeTool *lc = SP_LPETOOL_CONTEXT(desktop->event_context);
-    lpetool_show_measuring_info(lc, show);
-
-    InkSelectOneAction* unitact =
-        static_cast<InkSelectOneAction*>(g_object_get_data(tbl, "lpetool_units_action"));
-    unitact->set_sensitive( show );
-}
-
-static void lpetool_unit_changed(GObject* tbl, int /* NotUsed */)
-{
-    UnitTracker* tracker = reinterpret_cast<UnitTracker*>(g_object_get_data(tbl, "tracker"));
-    Unit const *unit = tracker->getActiveUnit();
-    g_return_if_fail(unit != nullptr);
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setString("/tools/lpetool/unit", unit->abbr);
-
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( tbl, "desktop" ));
-    if (SP_IS_LPETOOL_CONTEXT(desktop->event_context)) {
-        LpeTool *lc = SP_LPETOOL_CONTEXT(desktop->event_context);
-        lpetool_delete_measuring_items(lc);
-        lpetool_create_measuring_items(lc);
-    }
-}
-
-static void lpetool_toggle_set_bbox(GtkToggleAction *act, gpointer data)
-{
-    SPDesktop *desktop = static_cast<SPDesktop *>(data);
-    Inkscape::Selection *selection = desktop->selection;
-
-    Geom::OptRect bbox = selection->visualBounds();
-
-    if (bbox) {
-        Geom::Point A(bbox->min());
-        Geom::Point B(bbox->max());
-
-        A *= desktop->doc2dt();
-        B *= desktop->doc2dt();
-
-        // TODO: should we provide a way to store points in prefs?
-        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setDouble("/tools/lpetool/bbox_upperleftx", A[Geom::X]);
-        prefs->setDouble("/tools/lpetool/bbox_upperlefty", A[Geom::Y]);
-        prefs->setDouble("/tools/lpetool/bbox_lowerrightx", B[Geom::X]);
-        prefs->setDouble("/tools/lpetool/bbox_lowerrighty", B[Geom::Y]);
-
-        lpetool_context_reset_limiting_bbox(SP_LPETOOL_CONTEXT(desktop->event_context));
-    }
-
-    gtk_toggle_action_set_active(act, false);
-}
-
-static void sp_lpetool_change_line_segment_type(GObject* tbl, int mode)
+namespace Inkscape {
+namespace UI {
+namespace Toolbar {
+LPEToolbar::LPEToolbar(SPDesktop *desktop)
+    : Toolbar(desktop),
+      _tracker(new UnitTracker(Util::UNIT_TYPE_LINEAR)),
+      _freeze(false),
+      _currentlpe(nullptr),
+      _currentlpeitem(nullptr)
 {
-    using namespace Inkscape::LivePathEffect;
-
-    // quit if run by the attr_changed listener
-    if (g_object_get_data(tbl, "freeze")) {
-        return;
-    }
-
-    // in turn, prevent listener from responding
-    g_object_set_data(tbl, "freeze", GINT_TO_POINTER(TRUE));
-
-    LPELineSegment *lpe = static_cast<LPELineSegment *>(g_object_get_data(tbl, "currentlpe"));
-    SPLPEItem *lpeitem = static_cast<SPLPEItem *>(g_object_get_data(tbl, "currentlpeitem"));
-    if (lpeitem) {
-        SPLPEItem *lpeitem = static_cast<SPLPEItem *>(g_object_get_data(tbl, "currentlpeitem"));
-        lpe->end_type.param_set_value(static_cast<Inkscape::LivePathEffect::EndType>(mode));
-        sp_lpe_item_update_patheffect(lpeitem, true, true);
-    }
-
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    _tracker->setActiveUnit(_desktop->getNamedView()->display_units);
 }
 
-static void lpetool_open_lpe_dialog(GtkToggleAction *act, gpointer data)
+LPEToolbar::~LPEToolbar()
 {
-    SPDesktop *desktop = static_cast<SPDesktop *>(data);
-
-    if (tools_isactive(desktop, TOOLS_LPETOOL)) {
-        sp_action_perform(Inkscape::Verb::get(SP_VERB_DIALOG_LIVE_PATH_EFFECT)->get_action(Inkscape::ActionContext(desktop)), nullptr);
-    }
-    gtk_toggle_action_set_active(act, false);
+    delete _tracker;
 }
 
-static void lpetool_toolbox_watch_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* holder);
-
-void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
+GtkWidget *
+LPEToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
 {
-    UnitTracker* tracker = new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR);
-    tracker->setActiveUnit(desktop->getNamedView()->display_units);
-    g_object_set_data(holder, "tracker", tracker);
-    Unit const *unit = tracker->getActiveUnit();
-    g_return_if_fail(unit != nullptr);
+    auto toolbar = new LPEToolbar(desktop);
+    Unit const *unit = toolbar->_tracker->getActiveUnit();
+    g_return_val_if_fail(unit != nullptr, nullptr);
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     prefs->setString("/tools/lpetool/unit", unit->abbr);
@@ -289,23 +100,22 @@ void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GO
             row[columns.col_sensitive] = true;
         }
 
-        InkSelectOneAction* act =
+        toolbar->_mode_action =
             InkSelectOneAction::create( "LPEToolModeAction",    // Name
                                         (""),                // Label
                                         (""),                // Tooltip
                                         "Not Used",          // Icon
                                         store );             // Tree store
 
-        act->use_radio( true );
-        act->use_icon( true );
-        act->use_label( false );
+        toolbar->_mode_action->use_radio( true );
+        toolbar->_mode_action->use_icon( true );
+        toolbar->_mode_action->use_label( false );
         int mode = prefs->getInt("/tools/lpetool/mode", 0);
-        act->set_active( mode );
+        toolbar->_mode_action->set_active( mode );
 
-        gtk_action_group_add_action( mainActions, act->gobj() );
-        g_object_set_data( holder, "lpetool_mode_action", act );
+        gtk_action_group_add_action( mainActions, toolbar->_mode_action->gobj() );
 
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_lpetool_mode_changed), holder));
+        toolbar->_mode_action->signal_changed().connect(sigc::mem_fun(*toolbar, &LPEToolbar::mode_changed));
     }
 
     /* Show limiting bounding box */
@@ -316,7 +126,7 @@ void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GO
                                                       "show-bounding-box",
                                                       GTK_ICON_SIZE_MENU );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(lpetool_toggle_show_bbox), desktop );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_show_bbox), desktop );
         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool( "/tools/lpetool/show_bbox", true ) );
     }
 
@@ -328,11 +138,10 @@ void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GO
                                                       "draw-geometry-set-bounding-box",
                                                       GTK_ICON_SIZE_MENU );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(lpetool_toggle_set_bbox), desktop );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_set_bbox), desktop );
         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), FALSE );
     }
 
-
     /* Combo box to choose line segment type */
     {
         InkSelectOneActionColumns columns;
@@ -365,22 +174,21 @@ void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GO
         row[columns.col_icon     ] = "NotUsed";
         row[columns.col_sensitive] = true;
 
-        InkSelectOneAction* act =
+        toolbar->_line_segment_action =
             InkSelectOneAction::create( "LPELineSegmentAction", // Name
                                         (""),                   // Label
                                         _("Choose a line segment type"), // Tooltip
                                         "Not Used",             // Icon
                                         store );                // Tree store
 
-        act->use_radio( false );
-        act->use_icon( false );
-        act->use_label( true );
-        act->set_sensitive( false );
+        toolbar->_line_segment_action->use_radio( false );
+        toolbar->_line_segment_action->use_icon( false );
+        toolbar->_line_segment_action->use_label( true );
+        toolbar->_line_segment_action->set_sensitive( false );
 
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data (holder, "lpetool_line_segment_action", act );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_line_segment_action->gobj() ));
 
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(sp_lpetool_change_line_segment_type), holder));
+        toolbar->_line_segment_action->signal_changed().connect(sigc::mem_fun(*toolbar, &LPEToolbar::change_line_segment_type));
     }
 
     /* Display measuring info for selected items */
@@ -391,17 +199,16 @@ void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GO
                                                       "draw-geometry-show-measuring-info",
                                                       GTK_ICON_SIZE_MENU );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(lpetool_toggle_show_measuring_info), holder );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_show_measuring_info), toolbar );
         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool( "/tools/lpetool/show_measuring_info", true ) );
     }
 
     // Add the units menu
     {
-        InkSelectOneAction* act = tracker->createAction( "LPEToolUnitsAction", _("Units"), ("") );
-        gtk_action_group_add_action( mainActions, act->gobj() );
-        act->signal_changed_after().connect(sigc::bind<0>(sigc::ptr_fun(&lpetool_unit_changed), holder));
-        g_object_set_data(holder, "lpetool_units_action", act);
-        act->set_sensitive( prefs->getBool("/tools/lpetool/show_measuring_info", true));
+        toolbar->_units_action = toolbar->_tracker->createAction( "LPEToolUnitsAction", _("Units"), ("") );
+        gtk_action_group_add_action( mainActions, toolbar->_units_action->gobj() );
+        toolbar->_units_action->signal_changed_after().connect(sigc::mem_fun(*toolbar, &LPEToolbar::unit_changed));
+        toolbar->_units_action->set_sensitive( prefs->getBool("/tools/lpetool/show_measuring_info", true));
     }
 
     /* Open LPE dialog (to adapt parameters numerically) */
@@ -412,23 +219,171 @@ void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GO
                                                       "dialog-geometry",
                                                       GTK_ICON_SIZE_MENU );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(lpetool_open_lpe_dialog), desktop );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(open_lpe_dialog), desktop );
         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), FALSE );
     }
 
-    desktop->connectEventContextChanged(sigc::bind(sigc::ptr_fun(lpetool_toolbox_watch_ec), holder));
+    desktop->connectEventContextChanged(sigc::mem_fun(*toolbar, &LPEToolbar::watch_ec));
+
+    return GTK_WIDGET(toolbar->gobj());
 }
 
-static void lpetool_toolbox_watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec, GObject* holder)
+// this is called when the mode is changed via the toolbar (i.e., one of the subtool buttons is pressed)
+void
+LPEToolbar::mode_changed(int mode)
 {
-    static sigc::connection c_selection_modified;
-    static sigc::connection c_selection_changed;
+    using namespace Inkscape::LivePathEffect;
+
+    ToolBase *ec = _desktop->event_context;
+    if (!SP_IS_LPETOOL_CONTEXT(ec)) {
+        return;
+    }
+
+    // only take action if run by the attr_changed listener
+    if (!_freeze) {
+        // in turn, prevent listener from responding
+        _freeze = true;
+
+        EffectType type = lpesubtools[mode].type;
+
+        LpeTool *lc = SP_LPETOOL_CONTEXT(_desktop->event_context);
+        bool success = lpetool_try_construction(lc, type);
+        if (success) {
+            // since the construction was already performed, we set the state back to inactive
+            _mode_action->set_active(0);
+            mode = 0;
+        } else {
+            // switch to the chosen subtool
+            SP_LPETOOL_CONTEXT(_desktop->event_context)->mode = type;
+        }
+
+        if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) {
+            Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+            prefs->setInt( "/tools/lpetool/mode", mode );
+        }
+
+        _freeze = false;
+    }
+}
+
+void
+LPEToolbar::toggle_show_bbox(GtkToggleAction *act, gpointer data) {
+    SPDesktop *desktop = static_cast<SPDesktop *>(data);
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+    bool show = gtk_toggle_action_get_active( act );
+    prefs->setBool("/tools/lpetool/show_bbox",  show);
+
+    if (tools_isactive(desktop, TOOLS_LPETOOL)) {
+        LpeTool *lc = SP_LPETOOL_CONTEXT(desktop->event_context);
+        lpetool_context_reset_limiting_bbox(lc);
+    }
+}
+
+void
+LPEToolbar::toggle_set_bbox(GtkToggleAction *act, gpointer data)
+{
+    SPDesktop *desktop = static_cast<SPDesktop *>(data);
+    Inkscape::Selection *selection = desktop->selection;
+
+    Geom::OptRect bbox = selection->visualBounds();
+
+    if (bbox) {
+        Geom::Point A(bbox->min());
+        Geom::Point B(bbox->max());
+
+        A *= desktop->doc2dt();
+        B *= desktop->doc2dt();
+
+        // TODO: should we provide a way to store points in prefs?
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        prefs->setDouble("/tools/lpetool/bbox_upperleftx", A[Geom::X]);
+        prefs->setDouble("/tools/lpetool/bbox_upperlefty", A[Geom::Y]);
+        prefs->setDouble("/tools/lpetool/bbox_lowerrightx", B[Geom::X]);
+        prefs->setDouble("/tools/lpetool/bbox_lowerrighty", B[Geom::Y]);
+
+        lpetool_context_reset_limiting_bbox(SP_LPETOOL_CONTEXT(desktop->event_context));
+    }
+
+    gtk_toggle_action_set_active(act, false);
+}
+
+void
+LPEToolbar::change_line_segment_type(int mode)
+{
+    using namespace Inkscape::LivePathEffect;
+
+    // quit if run by the attr_changed listener
+    if (_freeze) {
+        return;
+    }
+
+    // in turn, prevent listener from responding
+    _freeze = true;
+    auto line_seg = dynamic_cast<LPELineSegment *>(_currentlpe);
+
+    if (_currentlpeitem && line_seg) {
+        line_seg->end_type.param_set_value(static_cast<Inkscape::LivePathEffect::EndType>(mode));
+        sp_lpe_item_update_patheffect(_currentlpeitem, true, true);
+    }
 
+    _freeze = false;
+}
+
+void
+LPEToolbar::toggle_show_measuring_info(GtkToggleAction *act, gpointer data)
+{
+    auto toolbar = reinterpret_cast<LPEToolbar *>(data);
+
+    if (!tools_isactive(toolbar->_desktop, TOOLS_LPETOOL)) {
+        return;
+    }
+
+    bool show = gtk_toggle_action_get_active( act );
+
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setBool("/tools/lpetool/show_measuring_info",  show);
+
+    LpeTool *lc = SP_LPETOOL_CONTEXT(toolbar->_desktop->event_context);
+    lpetool_show_measuring_info(lc, show);
+
+    toolbar->_units_action->set_sensitive( show );
+}
+
+void
+LPEToolbar::unit_changed(int /* NotUsed */)
+{
+    Unit const *unit = _tracker->getActiveUnit();
+    g_return_if_fail(unit != nullptr);
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setString("/tools/lpetool/unit", unit->abbr);
+
+    if (SP_IS_LPETOOL_CONTEXT(_desktop->event_context)) {
+        LpeTool *lc = SP_LPETOOL_CONTEXT(_desktop->event_context);
+        lpetool_delete_measuring_items(lc);
+        lpetool_create_measuring_items(lc);
+    }
+}
+
+void
+LPEToolbar::open_lpe_dialog(GtkToggleAction *act, gpointer data)
+{
+    SPDesktop *desktop = static_cast<SPDesktop *>(data);
+
+    if (tools_isactive(desktop, TOOLS_LPETOOL)) {
+        sp_action_perform(Inkscape::Verb::get(SP_VERB_DIALOG_LIVE_PATH_EFFECT)->get_action(Inkscape::ActionContext(desktop)), nullptr);
+    }
+    gtk_toggle_action_set_active(act, false);
+}
+
+void
+LPEToolbar::watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec)
+{
     if (SP_IS_LPETOOL_CONTEXT(ec)) {
         // Watch selection
-        c_selection_modified = desktop->getSelection()->connectModified(sigc::bind(sigc::ptr_fun(sp_lpetool_toolbox_sel_modified), holder));
-        c_selection_changed = desktop->getSelection()->connectChanged(sigc::bind(sigc::ptr_fun(sp_lpetool_toolbox_sel_changed), holder));
-        sp_lpetool_toolbox_sel_changed(desktop->getSelection(), holder);
+        c_selection_modified = desktop->getSelection()->connectModified(sigc::mem_fun(*this, &LPEToolbar::sel_modified));
+        c_selection_changed = desktop->getSelection()->connectChanged(sigc::mem_fun(*this, &LPEToolbar::sel_changed));
+        sel_changed(desktop->getSelection());
     } else {
         if (c_selection_modified)
             c_selection_modified.disconnect();
@@ -437,6 +392,57 @@ static void lpetool_toolbox_watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::To
     }
 }
 
+void
+LPEToolbar::sel_modified(Inkscape::Selection *selection, guint /*flags*/)
+{
+    ToolBase *ec = selection->desktop()->event_context;
+    if (SP_IS_LPETOOL_CONTEXT(ec)) {
+        lpetool_update_measuring_items(SP_LPETOOL_CONTEXT(ec));
+    }
+}
+
+void
+LPEToolbar::sel_changed(Inkscape::Selection *selection)
+{
+    using namespace Inkscape::LivePathEffect;
+    ToolBase *ec = selection->desktop()->event_context;
+    if (!SP_IS_LPETOOL_CONTEXT(ec)) {
+        return;
+    }
+    LpeTool *lc = SP_LPETOOL_CONTEXT(ec);
+
+    lpetool_delete_measuring_items(lc);
+    lpetool_create_measuring_items(lc, selection);
+
+    // activate line segment combo box if a single item with LPELineSegment is selected
+    SPItem *item = selection->singleItem();
+    if (item && SP_IS_LPE_ITEM(item) && lpetool_item_has_construction(lc, item)) {
+
+        SPLPEItem *lpeitem = SP_LPE_ITEM(item);
+        Effect* lpe = lpeitem->getCurrentLPE();
+        if (lpe && lpe->effectType() == LINE_SEGMENT) {
+            LPELineSegment *lpels = static_cast<LPELineSegment*>(lpe);
+            _currentlpe = lpe;
+            _currentlpeitem = lpeitem;
+            _line_segment_action->set_sensitive(true);
+            _line_segment_action->set_active( lpels->end_type.get_value() );
+        } else {
+            _currentlpe = nullptr;
+            _currentlpeitem = nullptr;
+            _line_segment_action->set_sensitive(false);
+        }
+
+    } else {
+        _currentlpe = nullptr;
+        _currentlpeitem = nullptr;
+        _line_segment_action->set_sensitive(false);
+    }
+}
+
+}
+}
+}
+
 /*
   Local Variables:
   mode:c++
diff --git a/src/ui/toolbar/lpe-toolbar.h b/src/ui/toolbar/lpe-toolbar.h
index 4ceada774..5e5187a07 100644
--- a/src/ui/toolbar/lpe-toolbar.h
+++ b/src/ui/toolbar/lpe-toolbar.h
@@ -28,11 +28,70 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "toolbar.h"
+
+class InkSelectOneAction;
 class SPDesktop;
+class SPLPEItem;
 
 typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _GObject GObject;
 
-void       sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
+namespace Inkscape {
+namespace LivePathEffect {
+class Effect;
+}
+
+namespace UI {
+namespace Tools {
+class ToolBase;
+}
+
+namespace Widget {
+class UnitTracker;
+}
+
+namespace Toolbar {
+class LPEToolbar : public Toolbar {
+private:
+    UI::Widget::UnitTracker *_tracker;
+    InkSelectOneAction *_mode_action;
+    InkSelectOneAction *_line_segment_action;
+    InkSelectOneAction *_units_action;
+
+    bool _freeze;
+
+    LivePathEffect::Effect *_currentlpe;
+    SPLPEItem *_currentlpeitem;
+
+    sigc::connection c_selection_modified;
+    sigc::connection c_selection_changed;
+
+    void mode_changed(int mode);
+    void unit_changed(int not_used);
+    void sel_modified(Inkscape::Selection *selection, guint flags);
+    void sel_changed(Inkscape::Selection *selection);
+    void change_line_segment_type(int mode);
+    void watch_ec(SPDesktop* desktop, UI::Tools::ToolBase* ec);
+
+    static void toggle_show_bbox(GtkToggleAction *act,
+                                 gpointer         data);
+    static void toggle_set_bbox(GtkToggleAction *act,
+                                gpointer         data);
+    static void toggle_show_measuring_info(GtkToggleAction *act,
+                                           gpointer         data);
+    static void open_lpe_dialog(GtkToggleAction *act,
+                                gpointer         data);
+
+protected:
+    LPEToolbar(SPDesktop *desktop);
+    ~LPEToolbar();
+
+public:
+    static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions);
+};
+
+}
+}
+}
 
 #endif /* !SEEN_LPE_TOOLBAR_H */
diff --git a/src/ui/toolbar/measure-toolbar.cpp b/src/ui/toolbar/measure-toolbar.cpp
index fa0d8827e..f16b1fdb6 100644
--- a/src/ui/toolbar/measure-toolbar.cpp
+++ b/src/ui/toolbar/measure-toolbar.cpp
@@ -25,10 +25,10 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
-#include <glibmm/i18n.h>
-
 #include "measure-toolbar.h"
 
+#include <glibmm/i18n.h>
+
 #include "desktop.h"
 #include "document-undo.h"
 #include "widgets/ink-action.h"
@@ -70,81 +70,8 @@ static MeasureTool *get_measure_tool()
     return tool;
 }
 
-static void
-sp_measure_fontsize_value_changed(GtkAdjustment *adj, GObject *tbl)
-{
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( tbl, "desktop" ));
-
-    if (DocumentUndo::getUndoSensitive(desktop->getDocument())) {
-        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setDouble(Glib::ustring("/tools/measure/fontsize"),
-            gtk_adjustment_get_value(adj));
-        MeasureTool *mt = get_measure_tool();
-        if (mt) {
-            mt->showCanvasItems();
-        }
-    }
-}
-
-static void
-sp_measure_offset_value_changed(GtkAdjustment *adj, GObject *tbl)
-{
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( tbl, "desktop" ));
-
-    if (DocumentUndo::getUndoSensitive(desktop->getDocument())) {
-        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setDouble(Glib::ustring("/tools/measure/offset"),
-            gtk_adjustment_get_value(adj));
-        MeasureTool *mt = get_measure_tool();
-        if (mt) {
-            mt->showCanvasItems();
-        }
-    }
-}
-
-static void sp_measure_scale_value_changed(GtkAdjustment *adj, GObject *tbl)
-{
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( tbl, "desktop" ));
-
-    if (DocumentUndo::getUndoSensitive(desktop->getDocument())) {
-        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setDouble(Glib::ustring("/tools/measure/scale"),
-            gtk_adjustment_get_value(adj));
-        MeasureTool *mt = get_measure_tool();
-        if (mt) {
-            mt->showCanvasItems();
-        }
-    }
-}
-
-static void
-sp_measure_precision_value_changed(GtkAdjustment *adj, GObject *tbl)
-{
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( tbl, "desktop" ));
 
-    if (DocumentUndo::getUndoSensitive(desktop->getDocument())) {
-        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setInt(Glib::ustring("/tools/measure/precision"),
-            gtk_adjustment_get_value(adj));
-        MeasureTool *mt = get_measure_tool();
-        if (mt) {
-            mt->showCanvasItems();
-        }
-    }
-}
 
-static void 
-sp_measure_unit_changed(GObject* tbl, int /* notUsed */)
-{
-    UnitTracker* tracker = reinterpret_cast<UnitTracker*>(g_object_get_data(tbl, "tracker"));
-    Glib::ustring const unit = tracker->getActiveUnit()->abbr;
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setString("/tools/measure/unit", unit);
-    MeasureTool *mt = get_measure_tool();
-    if (mt) {
-        mt->showCanvasItems();
-    }
-}
 
 static void 
 sp_toggle_ignore_1st_and_last( GtkToggleAction* act, gpointer data )
@@ -275,13 +202,21 @@ sp_to_item(){
     }
 }
 
-void sp_measure_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObject* holder)
+namespace Inkscape {
+namespace UI {
+namespace Toolbar {
+MeasureToolbar::MeasureToolbar(SPDesktop *desktop)
+    : Toolbar(desktop),
+    _tracker(new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR))
+{}
+
+GtkWidget *
+MeasureToolbar::prep(SPDesktop * desktop, GtkActionGroup* mainActions)
 {
-    UnitTracker* tracker = new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR);
+    auto holder = new MeasureToolbar(desktop);
+
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    tracker->setActiveUnitByAbbr(prefs->getString("/tools/measure/unit").c_str());
-    
-    g_object_set_data( holder, "tracker", tracker );
+    holder->_tracker->setActiveUnitByAbbr(prefs->getString("/tools/measure/unit").c_str());
 
     EgeAdjustmentAction *eact = nullptr;
     GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
@@ -292,10 +227,15 @@ void sp_measure_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, G
                                          _("Font Size"), _("Font Size:"),
                                          _("The font size to be used in the measurement labels"),
                                          "/tools/measure/fontsize", 10.0,
-                                         GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
+                                         GTK_WIDGET(desktop->canvas),
+                                         nullptr, // dataKludge
+                                         FALSE, nullptr,
                                          1.0, 36.0, 1.0, 4.0,
                                          nullptr, nullptr, 0,
-                                         sp_measure_fontsize_value_changed, nullptr, 0 , 2);
+                                         nullptr, // callback
+                                         nullptr, 0 , 2);
+        holder->_font_size_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        holder->_font_size_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &MeasureToolbar::fontsize_value_changed));
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact));
     }
 
@@ -309,8 +249,8 @@ void sp_measure_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, G
 
     /* units menu */
     {
-        InkSelectOneAction* act = tracker->createAction( "MeasureUnitsAction", _("Units:"), _("The units to be used for the measurements") );
-        act->signal_changed_after().connect(sigc::bind<0>(sigc::ptr_fun(&sp_measure_unit_changed), holder));
+        InkSelectOneAction* act = holder->_tracker->createAction( "MeasureUnitsAction", _("Units:"), _("The units to be used for the measurements") );
+        act->signal_changed_after().connect(sigc::mem_fun(*holder, &MeasureToolbar::unit_changed));
         gtk_action_group_add_action( mainActions, act->gobj() );
     }
 
@@ -320,10 +260,15 @@ void sp_measure_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, G
                                          _("Precision"), _("Precision:"),
                                          _("Decimal precision of measure"),
                                          "/tools/measure/precision", 2,
-                                         GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
+                                         GTK_WIDGET(desktop->canvas),
+                                         nullptr, // dataKludge
+                                         FALSE, nullptr,
                                          0, 10, 1, 0,
                                          nullptr, nullptr, 0,
-                                         sp_measure_precision_value_changed, nullptr, 0 ,0);
+                                         nullptr, // callback
+                                         nullptr, 0 ,0);
+        holder->_precision_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        holder->_precision_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &MeasureToolbar::precision_value_changed));
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact));
     }
 
@@ -333,10 +278,15 @@ void sp_measure_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, G
                                          _("Scale %"), _("Scale %:"),
                                          _("Scale the results"),
                                          "/tools/measure/scale", 100.0,
-                                         GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
+                                         GTK_WIDGET(desktop->canvas),
+                                         nullptr, // dataKludge
+                                         FALSE, nullptr,
                                          0.0, 90000.0, 1.0, 4.0,
                                          nullptr, nullptr, 0,
-                                         sp_measure_scale_value_changed, nullptr, 0 , 3);
+                                         nullptr, // callback
+                                         nullptr, 0 , 3);
+        holder->_scale_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        holder->_scale_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &MeasureToolbar::scale_value_changed));
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
     }
 
@@ -346,10 +296,15 @@ void sp_measure_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, G
                                          _("Offset"), _("Offset:"),
                                          _("Mark dimension offset"),
                                          "/tools/measure/offset", 5.0,
-                                         GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
+                                         GTK_WIDGET(desktop->canvas),
+                                         nullptr, // dataKludge
+                                         FALSE, nullptr,
                                          0.0, 90000.0, 1.0, 4.0,
                                          nullptr, nullptr, 0,
-                                         sp_measure_offset_value_changed, nullptr, 0 , 2);
+                                         nullptr, // callback
+                                         nullptr, 0 , 2);
+        holder->_offset_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        holder->_offset_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &MeasureToolbar::offset_value_changed));
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
     }
 
@@ -459,7 +414,81 @@ void sp_measure_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, G
         g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(sp_to_item), 0 );
         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
     }
-} // end of sp_measure_toolbox_prep()
+
+    return GTK_WIDGET(holder->gobj());
+} // MeasureToolbar::prep()
+
+void
+MeasureToolbar::fontsize_value_changed()
+{
+    if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) {
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        prefs->setDouble(Glib::ustring("/tools/measure/fontsize"),
+            _font_size_adj->get_value());
+        MeasureTool *mt = get_measure_tool();
+        if (mt) {
+            mt->showCanvasItems();
+        }
+    }
+}
+
+void 
+MeasureToolbar::unit_changed(int /* notUsed */)
+{
+    Glib::ustring const unit = _tracker->getActiveUnit()->abbr;
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setString("/tools/measure/unit", unit);
+    MeasureTool *mt = get_measure_tool();
+    if (mt) {
+        mt->showCanvasItems();
+    }
+}
+
+void
+MeasureToolbar::precision_value_changed()
+{
+    if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) {
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        prefs->setInt(Glib::ustring("/tools/measure/precision"),
+            _precision_adj->get_value());
+        MeasureTool *mt = get_measure_tool();
+        if (mt) {
+            mt->showCanvasItems();
+        }
+    }
+}
+
+void
+MeasureToolbar::scale_value_changed()
+{
+    if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) {
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        prefs->setDouble(Glib::ustring("/tools/measure/scale"),
+            _scale_adj->get_value());
+        MeasureTool *mt = get_measure_tool();
+        if (mt) {
+            mt->showCanvasItems();
+        }
+    }
+}
+
+void
+MeasureToolbar::offset_value_changed()
+{
+    if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) {
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        prefs->setDouble(Glib::ustring("/tools/measure/offset"),
+            _offset_adj->get_value());
+        MeasureTool *mt = get_measure_tool();
+        if (mt) {
+            mt->showCanvasItems();
+        }
+    }
+}
+
+}
+}
+}
 
 
 /*
diff --git a/src/ui/toolbar/measure-toolbar.h b/src/ui/toolbar/measure-toolbar.h
index 9a03bb8c3..fd11ab425 100644
--- a/src/ui/toolbar/measure-toolbar.h
+++ b/src/ui/toolbar/measure-toolbar.h
@@ -4,7 +4,7 @@
 
 /**
  * @file
- * Measue aux toolbar
+ * Measure aux toolbar
  */
 /* Authors:
  *   MenTaLguY <mental@rydia.net>
@@ -28,11 +28,44 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "toolbar.h"
+
+#include <gtkmm/adjustment.h>
+
 class SPDesktop;
 
 typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _GObject GObject;
 
-void       sp_measure_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+class UnitTracker;
+}
+
+namespace Toolbar {
+class MeasureToolbar : public Toolbar {
+private:
+    UI::Widget::UnitTracker *_tracker;
+    Glib::RefPtr<Gtk::Adjustment> _font_size_adj;
+    Glib::RefPtr<Gtk::Adjustment> _precision_adj;
+    Glib::RefPtr<Gtk::Adjustment> _scale_adj;
+    Glib::RefPtr<Gtk::Adjustment> _offset_adj;
+
+    void fontsize_value_changed();
+    void unit_changed(int notUsed);
+    void precision_value_changed();
+    void scale_value_changed();
+    void offset_value_changed();
+
+protected:
+    MeasureToolbar(SPDesktop *desktop);
+
+public:
+    static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions);
+};
+
+}
+}
+}
 
 #endif /* !SEEN_MEASURE_TOOLBAR_H */
diff --git a/src/ui/toolbar/mesh-toolbar.cpp b/src/ui/toolbar/mesh-toolbar.cpp
index b3f37f3e5..2345a16ba 100644
--- a/src/ui/toolbar/mesh-toolbar.cpp
+++ b/src/ui/toolbar/mesh-toolbar.cpp
@@ -133,143 +133,11 @@ void ms_read_selection( Inkscape::Selection *selection,
     }
 }
 
-/*
- * Core function, setup all the widgets whenever something changes on the desktop
- */
-static void ms_tb_selection_changed(Inkscape::Selection * /*selection*/, gpointer data)
-{
-
-    // std::cout << "ms_tb_selection_changed" << std::endl;
-
-    if (blocked)
-        return;
-
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(G_OBJECT(data), "desktop"));
-    if (!desktop) {
-        return;
-    }
-
-    Inkscape::Selection *selection = desktop->getSelection(); // take from desktop, not from args
-    if (selection) {
-        // ToolBase *ev = sp_desktop_event_context(desktop);
-        // GrDrag *drag = NULL;
-        // if (ev) {
-        //     drag = ev->get_drag();
-        //     // Hide/show handles?
-        // }
-
-        SPMeshGradient *ms_selected = nullptr;
-        SPMeshType ms_type = SP_MESH_TYPE_COONS;
-        bool ms_selected_multi = false;
-        bool ms_type_multi = false; 
-        ms_read_selection( selection, ms_selected, ms_selected_multi, ms_type, ms_type_multi );
-        // std::cout << "   type: " << ms_type << std::endl;
-        
-        InkSelectOneAction* type = static_cast<InkSelectOneAction*> (g_object_get_data(G_OBJECT(data), "mesh_select_type_action"));
-        if (type) {
-            type->set_sensitive(!ms_type_multi);
-            blocked = TRUE;
-            type->set_active(ms_type);
-            blocked = FALSE;
-        }
-    }
-}
-
-
-static void ms_tb_selection_modified(Inkscape::Selection *selection, guint /*flags*/, gpointer data)
-{
-    ms_tb_selection_changed(selection, data);
-}
-
-static void ms_drag_selection_changed(gpointer /*dragger*/, gpointer data)
-{
-    ms_tb_selection_changed(nullptr, data);
-
-}
-
-static void ms_defs_release(SPObject * /*defs*/, GObject *widget)
-{
-    ms_tb_selection_changed(nullptr, widget);
-}
-
-static void ms_defs_modified(SPObject * /*defs*/, guint /*flags*/, GObject *widget)
-{
-    ms_tb_selection_changed(nullptr, widget);
-}
 
 /*
  * Callback functions for user actions
  */
 
-static void ms_new_geometry_changed( GObject * /*tbl*/, int mode )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setInt("/tools/mesh/mesh_geometry", mode);
-}
-
-static void ms_new_fillstroke_changed( GObject * /*tbl*/, int mode )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setInt("/tools/mesh/newfillorstroke", mode);
-}
-
-static void ms_row_changed(GtkAdjustment *adj, GObject * /*tbl*/ )
-{
-    if (blocked) {
-        return;
-    }
-
-    blocked = TRUE;
-
-    int rows = gtk_adjustment_get_value(adj);
-
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-
-    prefs->setInt("/tools/mesh/mesh_rows", rows);
-
-    blocked = FALSE;
-}
-
-static void ms_col_changed(GtkAdjustment *adj, GObject * /*tbl*/ )
-{
-    if (blocked) {
-        return;
-    }
-
-    blocked = TRUE;
-
-    int cols = gtk_adjustment_get_value(adj);
-
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-
-    prefs->setInt("/tools/mesh/mesh_cols", cols);
-
-    blocked = FALSE;
-}
-
-/**
- * Sets mesh type: Coons, Bicubic
- */
-static void ms_type_changed( GObject *tbl, int mode )
-{
-    if (blocked) {
-        return;
-    }
-
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(tbl, "desktop"));
-    Inkscape::Selection *selection = desktop->getSelection();
-    std::vector<SPMeshGradient *> meshes = ms_get_dt_selected_gradients(selection);
-
-    SPMeshType type = (SPMeshType) mode;
-    for (auto & meshe : meshes) {
-        meshe->type = type;
-        meshe->type_set = true;
-        meshe->updateRepr();
-    }
-    if (!meshes.empty() ) {
-        DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_MESH,_("Set mesh type"));
-    }
-}
 
 /** Temporary hack: Returns the mesh tool in the active desktop.
  * Will go away during tool refactoring. */
@@ -317,50 +185,30 @@ static void ms_fit_mesh()
     }
 }
 
-static void ms_toggle_handles()
-{
-    MeshTool *mt = get_mesh_tool();
-    if (mt) {
-        GrDrag *drag = mt->_grdrag;
-        drag->refreshDraggers();
-    }
-}
 
-static void ms_toggle_fill_stroke(InkToggleAction * /*act*/, gpointer data)
-{
-    MeshTool *mt = get_mesh_tool();
-    if (mt) {
-        GrDrag *drag = mt->_grdrag;
-        drag->updateDraggers();
-        drag->updateLines();
-        drag->updateLevels();
-        ms_tb_selection_changed(nullptr, data); // Need to update Type widget
-    }
-}
+static void mesh_toolbox_watch_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* holder);
 
-static void ms_warning_popup()
-{
-    char *msg = _("Mesh gradients are part of SVG 2:\n"
-                  "* Syntax may change.\n"
-                  "* Web browser implementation is not guaranteed.\n"
-                  "\n"
-                  "For web: convert to bitmap (Edit->Make bitmap copy).\n"
-                  "For print: export to PDF.");
-    Gtk::MessageDialog dialog(msg, false, Gtk::MESSAGE_WARNING,
-                              Gtk::BUTTONS_OK, true);
-    dialog.run();
+namespace Inkscape {
+namespace UI {
+namespace Toolbar {
 
+MeshToolbar::~MeshToolbar()
+{
+    if(_edit_fill_pusher) delete _edit_fill_pusher;
+    if(_edit_stroke_pusher) delete _edit_stroke_pusher;
+    if(_show_handles_pusher) delete _show_handles_pusher;
 }
 
-static void mesh_toolbox_watch_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* holder);
-
 /**
  * Mesh auxiliary toolbar construction and setup.
  * Don't forget to add to XML in widgets/toolbox.cpp!
  *
  */
-void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObject* holder)
+GtkWidget *
+MeshToolbar::prep(SPDesktop * desktop, GtkActionGroup* mainActions)
 {
+    auto toolbar = new MeshToolbar(desktop);
+
     GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
 
     EgeAdjustmentAction* eact = nullptr;
@@ -387,22 +235,21 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj
         row[columns.col_icon     ] = INKSCAPE_ICON("paint-gradient-conical");
         row[columns.col_sensitive] = true;
 
-        InkSelectOneAction* act =
+        toolbar->_new_type_mode =
             InkSelectOneAction::create( "MeshNewTypeAction", // Name
                                         _("New:"),           // Label
                                         "",                  // Tooltip
                                         "Not Used",          // Icon
                                         store );             // Tree store
 
-        act->use_radio( true );
-        act->use_group_label( true );
+        toolbar->_new_type_mode->use_radio( true );
+        toolbar->_new_type_mode->use_group_label( true );
         gint mode = prefs->getInt("/tools/mesh/mesh_geometry", SP_MESH_GEOMETRY_NORMAL);
-        act->set_active( mode );
+        toolbar->_new_type_mode->set_active( mode );
 
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data( holder, "mesh_new_type_mode", act );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_new_type_mode->gobj() ));
 
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&ms_new_geometry_changed), holder));
+        toolbar->_new_type_mode->signal_changed().connect(sigc::mem_fun(*toolbar, &MeshToolbar::new_geometry_changed));
     }
 
     /* New gradient on fill or stroke*/
@@ -425,22 +272,21 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj
         row[columns.col_icon     ] = INKSCAPE_ICON("object-stroke");
         row[columns.col_sensitive] = true;
 
-        InkSelectOneAction* act =
+        toolbar->_new_fillstroke_mode =
             InkSelectOneAction::create( "MeshNewFillStrokeAction", // Name
                                         "",                  // Label
                                         "",                  // Tooltip
                                         "Not Used",          // Icon
                                         store );             // Tree store
 
-        act->use_radio( true );
-        act->use_group_label( false );
+        toolbar->_new_fillstroke_mode->use_radio( true );
+        toolbar->_new_fillstroke_mode->use_group_label( false );
         gint mode = prefs->getInt("/tools/mesh/newfillorstroke");
-        act->set_active( mode );
+        toolbar->_new_fillstroke_mode->set_active( mode );
 
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data( holder, "mesh_new_type_mode", act );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_new_fillstroke_mode->gobj() ));
 
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&ms_new_fillstroke_changed), holder));
+        toolbar->_new_fillstroke_mode->signal_changed().connect(sigc::mem_fun(*toolbar, &MeshToolbar::new_fillstroke_changed));
     }
 
     /* Number of mesh rows */
@@ -450,11 +296,16 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj
         eact = create_adjustment_action( "MeshRowAction",
                                          _("Rows"), _("Rows:"), _("Number of rows in new mesh"),
                                          "/tools/mesh/mesh_rows", 1,
-                                         GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
+                                         GTK_WIDGET(desktop->canvas),
+                                         nullptr, // dataKludge
+                                         FALSE, nullptr,
                                          1, 20, 1, 1,
                                          labels, values, 0,
-                                         ms_row_changed, nullptr /*unit tracker*/,
+                                         nullptr, // callback
+                                         nullptr /*unit tracker*/,
                                          1.0, 0 );
+        toolbar->_row_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        toolbar->_row_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &MeshToolbar::row_changed));
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
     }
@@ -466,11 +317,16 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj
         eact = create_adjustment_action( "MeshColumnAction",
                                          _("Columns"), _("Columns:"), _("Number of columns in new mesh"),
                                          "/tools/mesh/mesh_cols", 1,
-                                         GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
+                                         GTK_WIDGET(desktop->canvas),
+                                         nullptr, // dataKludge
+                                         FALSE, nullptr,
                                          1, 20, 1, 1,
                                          labels, values, 0,
-                                         ms_col_changed, nullptr /*unit tracker*/,
+                                         nullptr, // callback
+                                         nullptr /*unit tracker*/,
                                          1.0, 0 );
+        toolbar->_col_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        toolbar->_col_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &MeshToolbar::col_changed));
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
     }
@@ -483,9 +339,8 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj
                                                       INKSCAPE_ICON("object-fill"),
                                                       secondarySize );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/mesh/edit_fill");
-        g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
-        g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(ms_toggle_fill_stroke), holder);
+        toolbar->_edit_fill_pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/mesh/edit_fill");
+        g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(toggle_fill_stroke), (gpointer)toolbar);
     }
 
     /* Edit stroke mesh */
@@ -496,9 +351,8 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj
                                                       INKSCAPE_ICON("object-stroke"),
                                                       secondarySize );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/mesh/edit_stroke");
-        g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
-        g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(ms_toggle_fill_stroke), holder);
+        toolbar->_edit_stroke_pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/mesh/edit_stroke");
+        g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(toggle_fill_stroke), (gpointer)toolbar);
     }
 
     /* Show/hide side and tensor handles */
@@ -509,14 +363,11 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj
                                                       INKSCAPE_ICON("show-node-handles"),
                                                       secondarySize );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/mesh/show_handles");
-        g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
-        g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(ms_toggle_handles), 0);
+        toolbar->_show_handles_pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/mesh/show_handles");
+        g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(toggle_handles), nullptr);
     }
 
-    g_object_set_data(holder, "desktop", desktop);
-
-    desktop->connectEventContextChanged(sigc::bind(sigc::ptr_fun(mesh_toolbox_watch_ec), holder));
+    desktop->connectEventContextChanged(sigc::mem_fun(*toolbar, &MeshToolbar::watch_ec));
 
     /* Warning */
     {
@@ -526,7 +377,7 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj
                                          INKSCAPE_ICON("dialog-warning"),
                                          secondarySize );
         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
-        g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(ms_warning_popup), holder );
+        g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(warning_popup), (gpointer)toolbar );
         gtk_action_set_sensitive( GTK_ACTION(act), TRUE );
     }
 
@@ -551,24 +402,23 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj
         row[columns.col_sensitive] = true;
 
         // TRANSLATORS: Type of Smoothing. See https://en.wikipedia.org/wiki/Coons_patch
-        InkSelectOneAction* act =
+        toolbar->_select_type_action =
             InkSelectOneAction::create( "MeshSmoothAction",  // Name
                                         _("Smoothing"),      // Label
                                         _("Coons: no smothing. Bicubic: smothing across patch boundaries."),               // Tooltip
                                         "Not Used",          // Icon
                                         store );             // Tree store
 
-        act->use_radio( false );
-        act->use_label( true );
-        act->use_icon( false );
-        act->use_group_label( true );
-        act->set_sensitive( false );
-        act->set_active( 0 );
+        toolbar->_select_type_action->use_radio( false );
+        toolbar->_select_type_action->use_label( true );
+        toolbar->_select_type_action->use_icon( false );
+        toolbar->_select_type_action->use_group_label( true );
+        toolbar->_select_type_action->set_sensitive( false );
+        toolbar->_select_type_action->set_active( 0 );
 
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data( holder, "mesh_select_type_action", act );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_select_type_action->gobj() ));
 
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&ms_type_changed), holder));
+        toolbar->_select_type_action->signal_changed().connect(sigc::mem_fun(*toolbar, &MeshToolbar::type_changed));
     }
 
     {
@@ -616,28 +466,98 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj
         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
     }
 
+    return GTK_WIDGET(toolbar->gobj());
 }
 
-static void mesh_toolbox_watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec, GObject* holder)
+void
+MeshToolbar::new_geometry_changed(int mode)
 {
-    static sigc::connection c_selection_changed;
-    static sigc::connection c_selection_modified;
-    static sigc::connection c_subselection_changed;
-    static sigc::connection c_defs_release;
-    static sigc::connection c_defs_modified;
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setInt("/tools/mesh/mesh_geometry", mode);
+}
+
+void
+MeshToolbar::new_fillstroke_changed(int mode)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setInt("/tools/mesh/newfillorstroke", mode);
+}
+
+void
+MeshToolbar::row_changed()
+{
+    if (blocked) {
+        return;
+    }
+
+    blocked = TRUE;
 
+    int rows = _row_adj->get_value();
+
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+    prefs->setInt("/tools/mesh/mesh_rows", rows);
+
+    blocked = FALSE;
+}
+
+void
+MeshToolbar::col_changed()
+{
+    if (blocked) {
+        return;
+    }
+
+    blocked = TRUE;
+
+    int cols = _col_adj->get_value();
+
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+    prefs->setInt("/tools/mesh/mesh_cols", cols);
+
+    blocked = FALSE;
+}
+
+void
+MeshToolbar::toggle_fill_stroke(InkToggleAction * /*act*/, gpointer data)
+{
+    auto toolbar = reinterpret_cast<MeshToolbar *>(data);
+    MeshTool *mt = get_mesh_tool();
+    if (mt) {
+        GrDrag *drag = mt->_grdrag;
+        drag->updateDraggers();
+        drag->updateLines();
+        drag->updateLevels();
+        toolbar->selection_changed(nullptr); // Need to update Type widget
+    }
+}
+
+void
+MeshToolbar::toggle_handles()
+{
+    MeshTool *mt = get_mesh_tool();
+    if (mt) {
+        GrDrag *drag = mt->_grdrag;
+        drag->refreshDraggers();
+    }
+}
+
+void
+MeshToolbar::watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec)
+{
     if (SP_IS_MESH_CONTEXT(ec)) {
         // connect to selection modified and changed signals
         Inkscape::Selection *selection = desktop->getSelection();
         SPDocument *document = desktop->getDocument();
 
-        c_selection_changed = selection->connectChanged(sigc::bind(sigc::ptr_fun(&ms_tb_selection_changed), holder));
-        c_selection_modified = selection->connectModified(sigc::bind(sigc::ptr_fun(&ms_tb_selection_modified), holder));
-        c_subselection_changed = desktop->connectToolSubselectionChanged(sigc::bind(sigc::ptr_fun(&ms_drag_selection_changed), holder));
+        c_selection_changed = selection->connectChanged(sigc::mem_fun(*this, &MeshToolbar::selection_changed));
+        c_selection_modified = selection->connectModified(sigc::mem_fun(*this, &MeshToolbar::selection_modified));
+        c_subselection_changed = desktop->connectToolSubselectionChanged(sigc::mem_fun(*this, &MeshToolbar::drag_selection_changed));
 
-        c_defs_release = document->getDefs()->connectRelease(sigc::bind<1>(sigc::ptr_fun(&ms_defs_release), holder));
-        c_defs_modified = document->getDefs()->connectModified(sigc::bind<2>(sigc::ptr_fun(&ms_defs_modified), holder));
-        ms_tb_selection_changed(selection, holder);
+        c_defs_release = document->getDefs()->connectRelease(sigc::mem_fun(*this, &MeshToolbar::defs_release));
+        c_defs_modified = document->getDefs()->connectModified(sigc::mem_fun(*this, &MeshToolbar::defs_modified));
+        selection_changed(selection);
     } else {
         if (c_selection_changed)
             c_selection_changed.disconnect();
@@ -652,6 +572,113 @@ static void mesh_toolbox_watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolB
     }
 }
 
+void
+MeshToolbar::selection_modified(Inkscape::Selection *selection, guint /*flags*/)
+{
+    selection_changed(selection);
+}
+
+void
+MeshToolbar::drag_selection_changed(gpointer /*dragger*/)
+{
+    selection_changed(nullptr);
+}
+
+void
+MeshToolbar::defs_release(SPObject * /*defs*/)
+{
+    selection_changed(nullptr);
+}
+
+void
+MeshToolbar::defs_modified(SPObject * /*defs*/, guint /*flags*/)
+{
+    selection_changed(nullptr);
+}
+
+/*
+ * Core function, setup all the widgets whenever something changes on the desktop
+ */
+void
+MeshToolbar::selection_changed(Inkscape::Selection * /* selection */)
+{
+    // std::cout << "ms_tb_selection_changed" << std::endl;
+
+    if (blocked)
+        return;
+
+    if (!_desktop) {
+        return;
+    }
+
+    Inkscape::Selection *selection = _desktop->getSelection(); // take from desktop, not from args
+    if (selection) {
+        // ToolBase *ev = sp_desktop_event_context(desktop);
+        // GrDrag *drag = NULL;
+        // if (ev) {
+        //     drag = ev->get_drag();
+        //     // Hide/show handles?
+        // }
+
+        SPMeshGradient *ms_selected = nullptr;
+        SPMeshType ms_type = SP_MESH_TYPE_COONS;
+        bool ms_selected_multi = false;
+        bool ms_type_multi = false; 
+        ms_read_selection( selection, ms_selected, ms_selected_multi, ms_type, ms_type_multi );
+        // std::cout << "   type: " << ms_type << std::endl;
+        
+        if (_select_type_action) {
+            _select_type_action->set_sensitive(!ms_type_multi);
+            blocked = TRUE;
+            _select_type_action->set_active(ms_type);
+            blocked = FALSE;
+        }
+    }
+}
+
+void
+MeshToolbar::warning_popup()
+{
+    char *msg = _("Mesh gradients are part of SVG 2:\n"
+                  "* Syntax may change.\n"
+                  "* Web browser implementation is not guaranteed.\n"
+                  "\n"
+                  "For web: convert to bitmap (Edit->Make bitmap copy).\n"
+                  "For print: export to PDF.");
+    Gtk::MessageDialog dialog(msg, false, Gtk::MESSAGE_WARNING,
+                              Gtk::BUTTONS_OK, true);
+    dialog.run();
+
+}
+
+/**
+ * Sets mesh type: Coons, Bicubic
+ */
+void
+MeshToolbar::type_changed(int mode)
+{
+    if (blocked) {
+        return;
+    }
+
+    Inkscape::Selection *selection = _desktop->getSelection();
+    std::vector<SPMeshGradient *> meshes = ms_get_dt_selected_gradients(selection);
+
+    SPMeshType type = (SPMeshType) mode;
+    for (auto & meshe : meshes) {
+        meshe->type = type;
+        meshe->type_set = true;
+        meshe->updateRepr();
+    }
+    if (!meshes.empty() ) {
+        DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_MESH,_("Set mesh type"));
+    }
+}
+
+}
+}
+}
+
 /*
   Local Variables:
   mode:c++
diff --git a/src/ui/toolbar/mesh-toolbar.h b/src/ui/toolbar/mesh-toolbar.h
index 34ccc844e..8d431dccb 100644
--- a/src/ui/toolbar/mesh-toolbar.h
+++ b/src/ui/toolbar/mesh-toolbar.h
@@ -15,11 +15,76 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "toolbar.h"
+
+#include <gtkmm/adjustment.h>
+
+class InkSelectOneAction;
 class SPDesktop;
+class SPObject;
 
 typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _GObject GObject;
+typedef struct _InkToggleAction InkToggleAction;
+
+namespace Inkscape {
+class Selection;
+
+namespace UI {
+class PrefPusher;
+
+namespace Tools {
+class ToolBase;
+}
+
+namespace Toolbar {
+class MeshToolbar : public Toolbar {
+private:
+    InkSelectOneAction *_new_type_mode;
+    InkSelectOneAction *_new_fillstroke_mode;
+    InkSelectOneAction *_select_type_action;
+
+    Glib::RefPtr<Gtk::Adjustment> _row_adj;
+    Glib::RefPtr<Gtk::Adjustment> _col_adj;
+
+    UI::PrefPusher *_edit_fill_pusher;
+    UI::PrefPusher *_edit_stroke_pusher;
+    UI::PrefPusher *_show_handles_pusher;
+
+    sigc::connection c_selection_changed;
+    sigc::connection c_selection_modified;
+    sigc::connection c_subselection_changed;
+    sigc::connection c_defs_release;
+    sigc::connection c_defs_modified;
+
+    void new_geometry_changed(int mode);
+    void new_fillstroke_changed(int mode);
+    void row_changed();
+    void col_changed();
+    static void toggle_fill_stroke(InkToggleAction *act, gpointer data);
+    void selection_changed(Inkscape::Selection *selection);
+    static void toggle_handles();
+    void watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec);
+    void selection_modified(Inkscape::Selection *selection, guint flags);
+    void drag_selection_changed(gpointer dragger);
+    void defs_release(SPObject *defs);
+    void defs_modified(SPObject *defs, guint flags);
+    static void warning_popup();
+    void type_changed(int mode);
+
+protected:
+    MeshToolbar(SPDesktop *desktop)
+        : Toolbar(desktop),
+          _edit_fill_pusher(nullptr)
+    {}
+
+    ~MeshToolbar();
+
+public:
+    static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions);
+};
 
-void sp_mesh_toolbox_prep(    SPDesktop * /*desktop*/, GtkActionGroup* mainActions, GObject* holder);
+}
+}
+}
 
 #endif /* !SEEN_MESH_TOOLBAR_H */
diff --git a/src/ui/toolbar/node-toolbar.cpp b/src/ui/toolbar/node-toolbar.cpp
index 86d2f4d52..32fbaaefd 100644
--- a/src/ui/toolbar/node-toolbar.cpp
+++ b/src/ui/toolbar/node-toolbar.cpp
@@ -25,8 +25,11 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "node-toolbar.h"
+
 #include <glibmm/i18n.h>
 
+#include <gtkmm/adjustment.h>
 
 #include "desktop.h"
 #include "document-undo.h"
@@ -34,7 +37,6 @@
 #include "widgets/ink-tool-menu-action.h"
 #include "widgets/toolbox.h"
 #include "inkscape.h"
-#include "node-toolbar.h"
 #include "selection-chemistry.h"
 #include "verbs.h"
 
@@ -207,132 +209,36 @@ static void sp_node_path_edit_nextLPEparam(GtkAction * /*act*/, gpointer data) {
     sp_selection_next_patheffect_param( reinterpret_cast<SPDesktop*>(data) );
 }
 
-/* is called when the node selection is modified */
-static void sp_node_toolbox_coord_changed(gpointer /*shape_editor*/, GObject *tbl)
-{
-    GtkAction* xact = GTK_ACTION( g_object_get_data( tbl, "nodes_x_action" ) );
-    GtkAction* yact = GTK_ACTION( g_object_get_data( tbl, "nodes_y_action" ) );
-    GtkAdjustment *xadj = ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION(xact));
-    GtkAdjustment *yadj = ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION(yact));
-
-    // quit if run by the attr_changed listener
-    if (g_object_get_data( tbl, "freeze" )) {
-        return;
-    }
 
-    // in turn, prevent listener from responding
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE));
-
-    UnitTracker* tracker = reinterpret_cast<UnitTracker*>( g_object_get_data( tbl, "tracker" ) );
-    if (!tracker) {
-        return;
-    }
-    Unit const *unit = tracker->getActiveUnit();
-    g_return_if_fail(unit != nullptr);
-
-    NodeTool *nt = get_node_tool();
-    if (!nt || !(nt->_selected_nodes) ||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 = Quantity::convert(gtk_adjustment_get_value(xadj), unit, "px");
-        Geom::Coord oldy = Quantity::convert(gtk_adjustment_get_value(yadj), unit, "px");
-        Geom::Point mid = nt->_selected_nodes->pointwiseBounds()->midpoint();
-
-        if (oldx != mid[Geom::X]) {
-            gtk_adjustment_set_value(xadj, Quantity::convert(mid[Geom::X], "px", unit));
-        }
-        if (oldy != mid[Geom::Y]) {
-            gtk_adjustment_set_value(yadj, Quantity::convert(mid[Geom::Y], "px", unit));
-        }
-    }
-
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
-}
-
-static void sp_node_path_value_changed(GtkAdjustment *adj, GObject *tbl, Geom::Dim2 d)
-{
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( tbl, "desktop" ));
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-
-    UnitTracker* tracker = reinterpret_cast<UnitTracker*>(g_object_get_data( tbl, "tracker" ));
-    if (!tracker) {
-        return;
-    }
-    Unit const *unit = tracker->getActiveUnit();
-
-    if (DocumentUndo::getUndoSensitive(desktop->getDocument())) {
-        prefs->setDouble(Glib::ustring("/tools/nodes/") + (d == Geom::X ? "x" : "y"),
-            Quantity::convert(gtk_adjustment_get_value(adj), unit, "px"));
-    }
 
-    // quit if run by the attr_changed listener
-    if (g_object_get_data( tbl, "freeze" ) || tracker->isUpdating()) {
-        return;
-    }
-
-    // in turn, prevent listener from responding
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE));
-
-    NodeTool *nt = get_node_tool();
-    if (nt && !nt->_selected_nodes->empty()) {
-        double val = Quantity::convert(gtk_adjustment_get_value(adj), unit, "px");
-        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) );
-}
-
-static void sp_node_path_x_value_changed(GtkAdjustment *adj, GObject *tbl)
-{
-    sp_node_path_value_changed(adj, tbl, Geom::X);
-}
+//################################
+//##    Node Editing Toolbox    ##
+//################################
 
-static void sp_node_path_y_value_changed(GtkAdjustment *adj, GObject *tbl)
-{
-    sp_node_path_value_changed(adj, tbl, Geom::Y);
-}
+namespace Inkscape {
+namespace UI {
+namespace Toolbar {
 
-static void sp_node_toolbox_sel_changed(Inkscape::Selection *selection, GObject *tbl)
-{
-    {
-    GtkAction* w = GTK_ACTION( g_object_get_data( tbl, "nodes_lpeedit" ) );
-    SPItem *item = selection->singleItem();
-    if (item && SP_IS_LPE_ITEM(item)) {
-       if (SP_LPE_ITEM(item)->hasPathEffect()) {
-           gtk_action_set_sensitive(w, TRUE);
-       } else {
-           gtk_action_set_sensitive(w, FALSE);
-       }
-    } else {
-       gtk_action_set_sensitive(w, FALSE);
-    }
-    }
-}
+NodeToolbar::NodeToolbar(SPDesktop *desktop)
+    : Toolbar(desktop),
+    _tracker(new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR))
+{}
 
-static void sp_node_toolbox_sel_modified(Inkscape::Selection *selection, guint /*flags*/, GObject *tbl)
+NodeToolbar::~NodeToolbar()
 {
-    sp_node_toolbox_sel_changed (selection, tbl);
+    delete _pusher_show_transform_handles;
+    delete _pusher_show_handles;
+    delete _pusher_show_outline;
+    delete _pusher_edit_clipping_paths;
+    delete _pusher_edit_masks;
 }
 
-static void node_toolbox_watch_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* holder);
-
-//################################
-//##    Node Editing Toolbox    ##
-//################################
-
-void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
+GtkWidget *
+NodeToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
 {
-    UnitTracker* tracker = new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR);
+    auto holder = new NodeToolbar(desktop);
     Unit doc_units = *desktop->getNamedView()->display_units;
-    tracker->setActiveUnit(&doc_units);
-    g_object_set_data( holder, "tracker", tracker );
+    holder->_tracker->setActiveUnit(&doc_units);
 
     GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
 
@@ -342,7 +248,7 @@ void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObje
                                                             _("Insert new nodes into selected segments"),
                                                             INKSCAPE_ICON("node-add"),
                                                             secondarySize );
-        g_object_set( INK_ACTION(inky), "short_label", _("Insert"), NULL );
+        gtk_action_set_short_label(GTK_ACTION(inky), _("Insert"));
         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_add), 0 );
         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
         GtkToolItem *menu_tool_button = gtk_menu_tool_button_new (nullptr, nullptr);
@@ -357,7 +263,7 @@ void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObje
                                           _("Insert new nodes at min X into selected segments"),
                                           INKSCAPE_ICON("node_insert_min_x"),
                                           secondarySize );
-        g_object_set( inky, "short_label", _("Insert min X"), NULL );
+        gtk_action_set_short_label( GTK_ACTION(inky), _("Insert min X"));
         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_add_min_x), 0 );
         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
     }
@@ -512,8 +418,7 @@ void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObje
                                                       "node-transform",
                                                       secondarySize );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/nodes/show_transform_handles");
-        g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
+        holder->_pusher_show_transform_handles = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/nodes/show_transform_handles");
     }
 
     {
@@ -523,8 +428,7 @@ void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObje
                                                       INKSCAPE_ICON("show-node-handles"),
                                                       secondarySize );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/nodes/show_handles");
-        g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
+        holder->_pusher_show_handles = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/nodes/show_handles");
     }
 
     {
@@ -534,20 +438,18 @@ void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObje
                                                       INKSCAPE_ICON("show-path-outline"),
                                                       secondarySize );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/nodes/show_outline");
-        g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
+        holder->_pusher_show_outline = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/nodes/show_outline");
     }
 
     {
         Inkscape::Verb* verb = Inkscape::Verb::get(SP_VERB_EDIT_NEXT_PATHEFFECT_PARAMETER);
-        InkAction* inky = ink_action_new( verb->get_id(),
-                                          verb->get_name(),
-                                          verb->get_tip(),
-                                          INKSCAPE_ICON("path-effect-parameter-next"),
-                                          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);
+        holder->_nodes_lpeedit = ink_action_new( verb->get_id(),
+                                                 verb->get_name(),
+                                                 verb->get_tip(),
+                                                 INKSCAPE_ICON("path-effect-parameter-next"),
+                                                 secondarySize );
+        g_signal_connect_after( G_OBJECT(holder->_nodes_lpeedit), "activate", G_CALLBACK(sp_node_path_edit_nextLPEparam), desktop );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_nodes_lpeedit) );
     }
 
     {
@@ -557,8 +459,7 @@ void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObje
                                           INKSCAPE_ICON("path-clip-edit"),
                                           secondarySize );
         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
-        PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(inky), "/tools/nodes/edit_clipping_paths");
-        g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
+        holder->_pusher_edit_clipping_paths = new PrefPusher(GTK_TOGGLE_ACTION(inky), "/tools/nodes/edit_clipping_paths");
     }
 
     {
@@ -568,68 +469,124 @@ void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObje
                                           INKSCAPE_ICON("path-mask-edit"),
                                           secondarySize );
         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
-        PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(inky), "/tools/nodes/edit_masks");
-        g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
+        holder->_pusher_edit_masks = new PrefPusher(GTK_TOGGLE_ACTION(inky), "/tools/nodes/edit_masks");
     }
 
     /* X coord of selected node(s) */
     {
-        EgeAdjustmentAction* eact = nullptr;
         gchar const* labels[] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
         gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
-        eact = create_adjustment_action( "NodeXAction",
-                                         _("X coordinate:"), _("X:"), _("X coordinate of selected node(s)"),
-                                         "/tools/nodes/Xcoord", 0,
-                                         GTK_WIDGET(desktop->canvas), holder, TRUE, "altx-nodes",
-                                         -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         sp_node_path_x_value_changed, tracker );
-        g_object_set_data( holder, "nodes_x_action", eact );
-        gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+        holder->_nodes_x_action = create_adjustment_action( "NodeXAction",
+                                                            _("X coordinate:"), _("X:"), _("X coordinate of selected node(s)"),
+                                                            "/tools/nodes/Xcoord", 0,
+                                                            GTK_WIDGET(desktop->canvas),
+                                                            nullptr, // dataKludge
+                                                            TRUE, "altx-nodes",
+                                                            -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
+                                                            labels, values, G_N_ELEMENTS(labels),
+                                                            nullptr, // callback
+                                                            holder->_tracker );
+        holder->_nodes_x_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_nodes_x_action));
+        holder->_nodes_x_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &NodeToolbar::value_changed), Geom::X));
+        gtk_action_set_sensitive( GTK_ACTION(holder->_nodes_x_action), FALSE );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_nodes_x_action) );
     }
 
     /* Y coord of selected node(s) */
     {
-        EgeAdjustmentAction* eact = nullptr;
         gchar const* labels[] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
         gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
-        eact = create_adjustment_action( "NodeYAction",
-                                         _("Y coordinate:"), _("Y:"), _("Y coordinate of selected node(s)"),
-                                         "/tools/nodes/Ycoord", 0,
-                                         GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
-                                         -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         sp_node_path_y_value_changed, tracker );
-        g_object_set_data( holder, "nodes_y_action", eact );
-        gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+        holder->_nodes_y_action = create_adjustment_action( "NodeYAction",
+                                                            _("Y coordinate:"), _("Y:"), _("Y coordinate of selected node(s)"),
+                                                            "/tools/nodes/Ycoord", 0,
+                                                            GTK_WIDGET(desktop->canvas),
+                                                            nullptr, // dataKludge
+                                                            FALSE, nullptr,
+                                                            -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
+                                                            labels, values, G_N_ELEMENTS(labels),
+                                                            nullptr, // callback
+                                                            holder->_tracker );
+        holder->_nodes_y_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_nodes_y_action));
+        holder->_nodes_y_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &NodeToolbar::value_changed), Geom::Y));
+        gtk_action_set_sensitive( GTK_ACTION(holder->_nodes_y_action), FALSE );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_nodes_y_action) );
     }
 
     // add the units menu
     {
-        InkSelectOneAction* act = tracker->createAction( "NodeUnitsAction", _("Units"), ("") );
+        InkSelectOneAction* act = holder->_tracker->createAction( "NodeUnitsAction", _("Units"), ("") );
         gtk_action_group_add_action( mainActions, act->gobj() );
     }
 
-    sp_node_toolbox_sel_changed(desktop->getSelection(), holder);
-    desktop->connectEventContextChanged(sigc::bind(sigc::ptr_fun(node_toolbox_watch_ec), holder));
+    holder->sel_changed(desktop->getSelection());
+    desktop->connectEventContextChanged(sigc::mem_fun(*holder, &NodeToolbar::watch_ec));
 
-} // end of sp_node_toolbox_prep()
+    return GTK_WIDGET(holder->gobj());
+} // NodeToolbar::prep()
 
-static void node_toolbox_watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec, GObject* holder)
+void
+NodeToolbar::value_changed(Geom::Dim2 d)
 {
-    static sigc::connection c_selection_changed;
-    static sigc::connection c_selection_modified;
-    static sigc::connection c_subselection_changed;
+    auto adj = (d == Geom::X) ? _nodes_x_adj : _nodes_y_adj;
+
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+    if (!_tracker) {
+        return;
+    }
 
+    Unit const *unit = _tracker->getActiveUnit();
+
+    if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) {
+        prefs->setDouble(Glib::ustring("/tools/nodes/") + (d == Geom::X ? "x" : "y"),
+            Quantity::convert(adj->get_value(), unit, "px"));
+    }
+
+    // quit if run by the attr_changed listener
+    if (_freeze || _tracker->isUpdating()) {
+        return;
+    }
+
+    // in turn, prevent listener from responding
+    _freeze = true;
+
+    NodeTool *nt = get_node_tool();
+    if (nt && !nt->_selected_nodes->empty()) {
+        double val = Quantity::convert(adj->get_value(), unit, "px");
+        double oldval = nt->_selected_nodes->pointwiseBounds()->midpoint()[d];
+        Geom::Point delta(0,0);
+        delta[d] = val - oldval;
+        nt->_multipath->move(delta);
+    }
+
+    _freeze = false;
+}
+
+void
+NodeToolbar::sel_changed(Inkscape::Selection *selection)
+{
+    SPItem *item = selection->singleItem();
+    if (item && SP_IS_LPE_ITEM(item)) {
+       if (SP_LPE_ITEM(item)->hasPathEffect()) {
+           gtk_action_set_sensitive(GTK_ACTION(_nodes_lpeedit), TRUE);
+       } else {
+           gtk_action_set_sensitive(GTK_ACTION(_nodes_lpeedit), FALSE);
+       }
+    } else {
+       gtk_action_set_sensitive(GTK_ACTION(_nodes_lpeedit), FALSE);
+    }
+}
+
+void
+NodeToolbar::watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec)
+{
     if (INK_IS_NODE_TOOL(ec)) {
         // watch selection
-        c_selection_changed = desktop->getSelection()->connectChanged(sigc::bind(sigc::ptr_fun(sp_node_toolbox_sel_changed), holder));
-        c_selection_modified = desktop->getSelection()->connectModified(sigc::bind(sigc::ptr_fun(sp_node_toolbox_sel_modified), holder));
-        c_subselection_changed = desktop->connectToolSubselectionChanged(sigc::bind(sigc::ptr_fun(sp_node_toolbox_coord_changed), holder));
+        c_selection_changed = desktop->getSelection()->connectChanged(sigc::mem_fun(*this, &NodeToolbar::sel_changed));
+        c_selection_modified = desktop->getSelection()->connectModified(sigc::mem_fun(*this, &NodeToolbar::sel_modified));
+        c_subselection_changed = desktop->connectToolSubselectionChanged(sigc::mem_fun(*this, &NodeToolbar::coord_changed));
 
-        sp_node_toolbox_sel_changed(desktop->getSelection(), holder);
+        sel_changed(desktop->getSelection());
     } else {
         if (c_selection_changed)
             c_selection_changed.disconnect();
@@ -640,6 +597,56 @@ static void node_toolbox_watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolB
     }
 }
 
+void
+NodeToolbar::sel_modified(Inkscape::Selection *selection, guint /*flags*/)
+{
+    sel_changed(selection);
+}
+
+/* is called when the node selection is modified */
+void
+NodeToolbar::coord_changed(gpointer /*shape_editor*/)
+{
+    // quit if run by the attr_changed listener
+    if (_freeze) {
+        return;
+    }
+
+    // in turn, prevent listener from responding
+    _freeze = true;
+
+    if (!_tracker) {
+        return;
+    }
+    Unit const *unit = _tracker->getActiveUnit();
+    g_return_if_fail(unit != nullptr);
+
+    NodeTool *nt = get_node_tool();
+    if (!nt || !(nt->_selected_nodes) ||nt->_selected_nodes->empty()) {
+        // no path selected
+        gtk_action_set_sensitive(GTK_ACTION(_nodes_x_action), FALSE);
+        gtk_action_set_sensitive(GTK_ACTION(_nodes_y_action), FALSE);
+    } else {
+        gtk_action_set_sensitive(GTK_ACTION(_nodes_x_action), TRUE);
+        gtk_action_set_sensitive(GTK_ACTION(_nodes_y_action), TRUE);
+        Geom::Coord oldx = Quantity::convert(_nodes_x_adj->get_value(), unit, "px");
+        Geom::Coord oldy = Quantity::convert(_nodes_y_adj->get_value(), unit, "px");
+        Geom::Point mid = nt->_selected_nodes->pointwiseBounds()->midpoint();
+
+        if (oldx != mid[Geom::X]) {
+            _nodes_x_adj->set_value(Quantity::convert(mid[Geom::X], "px", unit));
+        }
+        if (oldy != mid[Geom::Y]) {
+            _nodes_y_adj->set_value(Quantity::convert(mid[Geom::Y], "px", unit));
+        }
+    }
+
+    _freeze = false;
+}
+
+}
+}
+}
 
 /*
   Local Variables:
diff --git a/src/ui/toolbar/node-toolbar.h b/src/ui/toolbar/node-toolbar.h
index 9cbd6ba6c..c612b52d8 100644
--- a/src/ui/toolbar/node-toolbar.h
+++ b/src/ui/toolbar/node-toolbar.h
@@ -28,11 +28,68 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "toolbar.h"
+#include "2geom/coord.h"
+
 class SPDesktop;
 
+typedef struct _EgeAdjustmentAction EgeAdjustmentAction;
 typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _GObject GObject;
+typedef struct _InkAction InkAction;
+
+namespace Inkscape {
+class Selection;
+
+namespace UI {
+class PrefPusher;
+
+namespace Tools {
+class ToolBase;
+}
+
+namespace Widget {
+class UnitTracker;
+}
+
+namespace Toolbar {
+class NodeToolbar : public Toolbar {
+private:
+    UI::Widget::UnitTracker *_tracker;
+
+    PrefPusher *_pusher_show_transform_handles;
+    PrefPusher *_pusher_show_handles;
+    PrefPusher *_pusher_show_outline;
+    PrefPusher *_pusher_edit_clipping_paths;
+    PrefPusher *_pusher_edit_masks;
+
+    InkAction *_nodes_lpeedit;
+
+    EgeAdjustmentAction *_nodes_x_action;
+    EgeAdjustmentAction *_nodes_y_action;
+
+    Glib::RefPtr<Gtk::Adjustment> _nodes_x_adj;
+    Glib::RefPtr<Gtk::Adjustment> _nodes_y_adj;
+
+    bool _freeze;
+
+    sigc::connection c_selection_changed;
+    sigc::connection c_selection_modified;
+    sigc::connection c_subselection_changed;
+
+    void value_changed(Geom::Dim2 d);
+    void sel_changed(Inkscape::Selection *selection);
+    void sel_modified(Inkscape::Selection *selection, guint /*flags*/);
+    void coord_changed(gpointer shape_editor);
+    void watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec);
 
-void       sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
+protected:
+    NodeToolbar(SPDesktop *desktop);
+    ~NodeToolbar();
 
+public:
+    static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions);
+};
+}
+}
+}
 #endif /* !SEEN_SELECT_TOOLBAR_H */
diff --git a/src/ui/toolbar/paintbucket-toolbar.cpp b/src/ui/toolbar/paintbucket-toolbar.cpp
index 81a240262..fd463289d 100644
--- a/src/ui/toolbar/paintbucket-toolbar.cpp
+++ b/src/ui/toolbar/paintbucket-toolbar.cpp
@@ -49,70 +49,18 @@ using Inkscape::UI::PrefPusher;
 using Inkscape::Util::unit_table;
 
 
-//#########################
-//##     Paintbucket     ##
-//#########################
-
-static void paintbucket_channels_changed(GObject* /*tbl*/, int channels)
-{
-    Inkscape::UI::Tools::FloodTool::set_channels(channels);
-}
-
-static void paintbucket_threshold_changed(GtkAdjustment *adj, GObject * /*tbl*/)
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setInt("/tools/paintbucket/threshold", (gint)gtk_adjustment_get_value(adj));
-}
-
-static void paintbucket_autogap_changed(GObject * /*tbl*/, int autogap)
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setInt("/tools/paintbucket/autogap", autogap);
-}
-
-static void paintbucket_offset_changed(GtkAdjustment *adj, GObject *tbl)
-{
-    UnitTracker* tracker = static_cast<UnitTracker*>(g_object_get_data( tbl, "tracker" ));
-    Unit const *unit = tracker->getActiveUnit();
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-
-    // Don't adjust the offset value because we're saving the
-    // unit and it'll be correctly handled on load.
-    prefs->setDouble("/tools/paintbucket/offset", (gdouble)gtk_adjustment_get_value(adj));
-
-    g_return_if_fail(unit != nullptr);
-    prefs->setString("/tools/paintbucket/offsetunits", unit->abbr);
-}
-
-static void paintbucket_defaults(GtkWidget *, GObject *tbl)
-{
-    // FIXME: make defaults settable via Inkscape Options
-    struct KeyValue {
-        char const *key;
-        double value;
-    } const key_values[] = {
-        {"threshold", 15},
-        {"offset", 0.0}
-    };
-
-    for (auto kv : key_values) {
-        GtkAdjustment* adj = static_cast<GtkAdjustment *>(g_object_get_data(tbl, kv.key));
-        if ( adj ) {
-            gtk_adjustment_set_value(adj, kv.value);
-        }
-    }
-
-    InkSelectOneAction* channels_action =
-        static_cast<InkSelectOneAction*>( g_object_get_data( tbl, "channels_action" ) );
-    channels_action->set_active( Inkscape::UI::Tools::FLOOD_CHANNELS_RGB );
-
-    InkSelectOneAction* autogap_action =
-        static_cast<InkSelectOneAction*>( g_object_get_data( tbl, "autogap_action" ) );
-    autogap_action->set_active( 0 );
-}
-
-void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
+namespace Inkscape {
+namespace UI {
+namespace Toolbar {
+PaintbucketToolbar::PaintbucketToolbar(SPDesktop *desktop)
+    : Toolbar(desktop),
+      _tracker(new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR))
+{}
+
+GtkWidget *
+PaintbucketToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
 {
+    auto toolbar = new PaintbucketToolbar(desktop);
     EgeAdjustmentAction* eact = nullptr;
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
@@ -132,24 +80,23 @@ void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
             row[columns.col_sensitive] = true;
         }
 
-        InkSelectOneAction* act =
+        toolbar->_channels_action =
             InkSelectOneAction::create( "ChannelsAction",    // Name
                                         _("Fill by"),        // Label
                                         (""),                // Tooltip
                                         "Not Used",          // Icon
                                         store );             // Tree store
 
-        act->use_radio( false );
-        act->use_icon( false );
-        act->use_label( true );
-        act->use_group_label( true );
+        toolbar->_channels_action->use_radio( false );
+        toolbar->_channels_action->use_icon( false );
+        toolbar->_channels_action->use_label( true );
+        toolbar->_channels_action->use_group_label( true );
         int channels = prefs->getInt("/tools/paintbucket/channels", 0);
-        act->set_active( channels );
+        toolbar->_channels_action->set_active( channels );
 
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data( holder, "channels_action", act );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_channels_action->gobj() ));
 
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&paintbucket_channels_changed), holder));
+        toolbar->_channels_action->signal_changed().connect(sigc::mem_fun(*toolbar, &PaintbucketToolbar::channels_changed));
     }
 
     // Spacing spinbox
@@ -158,26 +105,29 @@ void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
             "ThresholdAction",
             _("Fill Threshold"), _("Threshold:"),
             _("The maximum allowed difference between the clicked pixel and the neighboring pixels to be counted in the fill"),
-            "/tools/paintbucket/threshold", 5, GTK_WIDGET(desktop->canvas), holder, TRUE,
+            "/tools/paintbucket/threshold", 5, GTK_WIDGET(desktop->canvas),
+            nullptr, // dataKludge
+            TRUE,
             "inkscape:paintbucket-threshold", 0, 100.0, 1.0, 10.0,
             nullptr, nullptr, 0,
-            paintbucket_threshold_changed, nullptr /*unit tracker*/, 1, 0 );
+            nullptr, // callback
+            nullptr /*unit tracker*/, 1, 0 );
 
+        toolbar->_threshold_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        toolbar->_threshold_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &PaintbucketToolbar::threshold_changed));
         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
     }
 
     // Create the units menu.
-    UnitTracker* tracker = new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR);
     Glib::ustring stored_unit = prefs->getString("/tools/paintbucket/offsetunits");
     if (!stored_unit.empty()) {
         Unit const *u = unit_table.getUnit(stored_unit);
-        tracker->setActiveUnit(u);
+        toolbar->_tracker->setActiveUnit(u);
     }
-    g_object_set_data( holder, "tracker", tracker );
 
     {
-        InkSelectOneAction* act = tracker->createAction( "PaintbucketUnitsAction", _("Units"), ("") );
+        InkSelectOneAction* act = toolbar->_tracker->createAction( "PaintbucketUnitsAction", _("Units"), ("") );
         gtk_action_group_add_action( mainActions, act->gobj() );
     }
 
@@ -187,10 +137,16 @@ void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
             "OffsetAction",
             _("Grow/shrink by"), _("Grow/shrink by:"),
             _("The amount to grow (positive) or shrink (negative) the created fill path"),
-            "/tools/paintbucket/offset", 0, GTK_WIDGET(desktop->canvas), holder, TRUE,
+            "/tools/paintbucket/offset", 0, GTK_WIDGET(desktop->canvas),
+            nullptr, // dataKludge
+            TRUE,
             "inkscape:paintbucket-offset", -1e4, 1e4, 0.1, 0.5,
             nullptr, nullptr, 0,
-            paintbucket_offset_changed, tracker, 1, 2);
+            nullptr, // callback
+            toolbar->_tracker,
+            1, 2);
+        toolbar->_offset_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        toolbar->_offset_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &PaintbucketToolbar::offset_changed));
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
     }
 
@@ -210,24 +166,23 @@ void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
             row[columns.col_sensitive] = true;
         }
 
-        InkSelectOneAction* act =
+        toolbar->_autogap_action =
             InkSelectOneAction::create( "AutoGapAction",     // Name
                                         _("Close gaps"),     // Label
                                         (""),                // Tooltip
                                         "Not Used",          // Icon
                                         store );             // Tree store
 
-        act->use_radio( false );
-        act->use_icon( false );
-        act->use_label( true );
-        act->use_group_label( true );
+        toolbar->_autogap_action->use_radio( false );
+        toolbar->_autogap_action->use_icon( false );
+        toolbar->_autogap_action->use_label( true );
+        toolbar->_autogap_action->use_group_label( true );
         int autogap = prefs->getInt("/tools/paintbucket/autogap");
-        act->set_active( autogap );
+        toolbar->_autogap_action->set_active( autogap );
 
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data( holder, "autogap_action", act );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_autogap_action->gobj() ));
 
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&paintbucket_autogap_changed), holder));
+        toolbar->_autogap_action->signal_changed().connect(sigc::mem_fun(*toolbar, &PaintbucketToolbar::autogap_changed));
     }
 
     /* Reset */
@@ -237,11 +192,63 @@ void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
                                           _("Reset paint bucket parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
                                           INKSCAPE_ICON("edit-clear"),
                                           GTK_ICON_SIZE_SMALL_TOOLBAR);
-        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(paintbucket_defaults), holder );
+        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(defaults), (gpointer)toolbar );
         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
         gtk_action_set_sensitive( GTK_ACTION(inky), TRUE );
     }
 
+    return GTK_WIDGET(toolbar->gobj());
+}
+
+void
+PaintbucketToolbar::channels_changed(int channels)
+{
+    Inkscape::UI::Tools::FloodTool::set_channels(channels);
+}
+
+void
+PaintbucketToolbar::threshold_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setInt("/tools/paintbucket/threshold", (gint)_threshold_adj->get_value());
+}
+
+void
+PaintbucketToolbar::offset_changed()
+{
+    Unit const *unit = _tracker->getActiveUnit();
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+    // Don't adjust the offset value because we're saving the
+    // unit and it'll be correctly handled on load.
+    prefs->setDouble("/tools/paintbucket/offset", (gdouble)_offset_adj->get_value());
+
+    g_return_if_fail(unit != nullptr);
+    prefs->setString("/tools/paintbucket/offsetunits", unit->abbr);
+}
+
+void
+PaintbucketToolbar::autogap_changed(int autogap)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setInt("/tools/paintbucket/autogap", autogap);
+}
+
+void
+PaintbucketToolbar::defaults(GtkWidget * /* widget */, gpointer data)
+{
+    auto toolbar = reinterpret_cast<PaintbucketToolbar *>(data);
+
+    // FIXME: make defaults settable via Inkscape Options
+    toolbar->_threshold_adj->set_value(15);
+    toolbar->_offset_adj->set_value(0.0);
+
+    toolbar->_channels_action->set_active( Inkscape::UI::Tools::FLOOD_CHANNELS_RGB );
+    toolbar->_autogap_action->set_active( 0 );
+}
+
+}
+}
 }
 
 /*
diff --git a/src/ui/toolbar/paintbucket-toolbar.h b/src/ui/toolbar/paintbucket-toolbar.h
index 8b530a50d..e8a92fbcf 100644
--- a/src/ui/toolbar/paintbucket-toolbar.h
+++ b/src/ui/toolbar/paintbucket-toolbar.h
@@ -28,11 +28,47 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "toolbar.h"
+
+#include <gtkmm/adjustment.h>
+
+class InkSelectOneAction;
 class SPDesktop;
 
 typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _GObject GObject;
 
-void       sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+class UnitTracker;
+}
+
+namespace Toolbar {
+class PaintbucketToolbar : public Toolbar {
+private:
+    InkSelectOneAction *_channels_action;
+    InkSelectOneAction *_autogap_action;
+
+    Glib::RefPtr<Gtk::Adjustment> _threshold_adj;
+    Glib::RefPtr<Gtk::Adjustment> _offset_adj;
+
+    UI::Widget::UnitTracker *_tracker;
+
+    void channels_changed(int channels);
+    void threshold_changed();
+    void offset_changed();
+    void autogap_changed(int autogap);
+    static void defaults(GtkWidget *widget, gpointer data);
+
+protected:
+    PaintbucketToolbar(SPDesktop *desktop);
+
+public:
+    static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions);
+};
+
+}
+}
+}
 
 #endif /* !SEEN_PAINTBUCKET_TOOLBAR_H */
diff --git a/src/ui/toolbar/pencil-toolbar.cpp b/src/ui/toolbar/pencil-toolbar.cpp
index 52cc32637..74c40c44f 100644
--- a/src/ui/toolbar/pencil-toolbar.cpp
+++ b/src/ui/toolbar/pencil-toolbar.cpp
@@ -62,58 +62,228 @@ using Inkscape::UI::UXManager;
 using Inkscape::UI::ToolboxFactory;
 using Inkscape::UI::PrefPusher;
 
-//########################
-//##     Pen/Pencil     ##
-//########################
-static void sp_flatten_spiro_bspline(GtkWidget * /*widget*/, GObject *obj);
-/* This is used in generic functions below to share large portions of code between pen and pencil tool */
-static Glib::ustring const freehand_tool_name(GObject *dataKludge)
+
+/*
+class PencilToleranceObserver : public Inkscape::Preferences::Observer {
+public:
+    PencilToleranceObserver(Glib::ustring const &path, GObject *x) : Observer(path), _obj(x)
+    {
+        g_object_set_data(_obj, "prefobserver", this);
+    }
+    virtual ~PencilToleranceObserver() {
+        if (g_object_get_data(_obj, "prefobserver") == this) {
+            g_object_set_data(_obj, "prefobserver", NULL);
+        }
+    }
+    virtual void notify(Inkscape::Preferences::Entry const &val) {
+        GObject* tbl = _obj;
+        if (g_object_get_data( tbl, "freeze" )) {
+            return;
+        }
+        g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+
+        GtkAdjustment * adj = GTK_ADJUSTMENT(g_object_get_data(tbl, "tolerance"));
+
+        double v = val.getDouble(adj->value);
+        gtk_adjustment_set_value(adj, v);
+        g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    }
+private:
+    GObject *_obj;
+};
+*/
+
+namespace Inkscape {
+namespace UI {
+namespace Toolbar {
+
+GtkWidget *
+PencilToolbar::prep_pencil(SPDesktop *desktop, GtkActionGroup* mainActions)
 {
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(dataKludge, "desktop"));
-    return ( tools_isactive(desktop, TOOLS_FREEHAND_PEN)
-             ? "/tools/freehand/pen"
-             : "/tools/freehand/pencil" );
+    auto toolbar = new PencilToolbar(desktop);
+    toolbar->add_freehand_mode_toggle(mainActions, true);
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+    /* min pressure */
+    {
+        toolbar->_minpressure = create_adjustment_action( "MinPressureAction",
+                                                          _("Min pressure"), _("Min:"), _("Min percent of pressure"),
+                                                          "/tools/freehand/pencil/minpressure", 0,
+                                                          GTK_WIDGET(desktop->canvas),
+                                                          nullptr, // dataKludge
+                                                          FALSE, nullptr,
+                                                          0, 100, 1, 0,
+                                                          nullptr, nullptr, 0,
+                                                          nullptr, // callback
+                                                          nullptr, 0 ,0);
+        
+        toolbar->_minpressure_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_minpressure));
+        toolbar->_minpressure_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &PencilToolbar::minpressure_value_changed));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_minpressure) );
+        if (prefs->getInt("/tools/freehand/pencil/freehand-mode", 0) == 3) {
+            gtk_action_set_visible( GTK_ACTION(toolbar->_minpressure), true );
+        } else {
+            gtk_action_set_visible( GTK_ACTION(toolbar->_minpressure), false );
+        }
+    }
+    /* max pressure */
+    {
+        toolbar->_maxpressure = create_adjustment_action( "MaxPressureAction",
+                                                          _("Max pressure"), _("Max:"), _("Max percent of pressure"),
+                                                          "/tools/freehand/pencil/maxpressure", 100,
+                                                          GTK_WIDGET(desktop->canvas),
+                                                          nullptr, // dataKludge
+                                                          FALSE, nullptr,
+                                                          0, 100, 1, 0,
+                                                          nullptr, nullptr, 0,
+                                                          nullptr, // callback
+                                                          nullptr, 0 ,0);
+        toolbar->_maxpressure_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_maxpressure));
+        toolbar->_maxpressure_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &PencilToolbar::maxpressure_value_changed));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_maxpressure) );
+        if (prefs->getInt("/tools/freehand/pencil/freehand-mode", 0) == 3) {
+            gtk_action_set_visible( GTK_ACTION(toolbar->_maxpressure), true );
+        } else {
+            gtk_action_set_visible( GTK_ACTION(toolbar->_maxpressure), false );
+        }
+    }
+    /* Use pressure */
+    {
+        InkToggleAction* itact = ink_toggle_action_new( "PencilPressureAction",
+                                                        _("Use pressure input"),
+                                                        _("Use pressure input"),
+                                                        INKSCAPE_ICON("draw-use-pressure"),
+                                                        GTK_ICON_SIZE_SMALL_TOOLBAR );
+        bool pressure = prefs->getBool(toolbar->freehand_tool_name() + "/pressure", false);
+        gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(itact), pressure );
+        g_signal_connect_after(  G_OBJECT(itact), "toggled", G_CALLBACK(PencilToolbar::use_pencil_pressure), toolbar);
+        gtk_action_group_add_action( mainActions, GTK_ACTION(itact) );
+        if (pressure) {
+            gtk_action_set_visible( GTK_ACTION( toolbar->_minpressure ), true );
+            gtk_action_set_visible( GTK_ACTION( toolbar->_maxpressure ), true );
+        } else {
+            gtk_action_set_visible( GTK_ACTION( toolbar->_minpressure ), false );
+            gtk_action_set_visible( GTK_ACTION( toolbar->_maxpressure ), false );
+        }
+    }
+    /* Tolerance */
+    {
+        gchar const* labels[] = {_("(many nodes, rough)"), _("(default)"), nullptr, nullptr, nullptr, nullptr, _("(few nodes, smooth)")};
+        gdouble values[] = {1, 10, 20, 30, 50, 75, 100};
+        EgeAdjustmentAction *eact = create_adjustment_action( "PencilToleranceAction",
+                                                              _("Smoothing:"), _("Smoothing: "),
+                                                              _("How much smoothing (simplifying) is applied to the line"),
+                                                              "/tools/freehand/pencil/tolerance",
+                                                              3.0,
+                                                              GTK_WIDGET(desktop->canvas),
+                                                              nullptr, // dataKludge
+                                                              TRUE, "altx-pencil",
+                                                              1, 100.0, 0.5, 1.0,
+                                                              labels, values, G_N_ELEMENTS(labels),
+                                                              nullptr, // callback
+                                                              nullptr /*unit tracker*/,
+                                                              1, 2);
+
+        toolbar->_tolerance_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        toolbar->_tolerance_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &PencilToolbar::tolerance_value_changed));
+        ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+    }
+
+    /* advanced shape options */
+    toolbar->freehand_add_advanced_shape_options(mainActions, true);
+
+    /* Reset */
+    {
+        InkAction* inky = ink_action_new( "PencilResetAction",
+                                          _("Defaults"),
+                                          _("Reset pencil parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
+                                          INKSCAPE_ICON("edit-clear"),
+                                          GTK_ICON_SIZE_SMALL_TOOLBAR );
+        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(PencilToolbar::defaults), toolbar );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
+    }
+    /* LPE simplify based tolerance */
+    {
+        toolbar->_simplify = ink_toggle_action_new( "PencilLpeSimplify",
+                                                    _("LPE based interactive simplify"),
+                                                    _("LPE based interactive simplify"),
+                                                    INKSCAPE_ICON("interactive_simplify"),
+                                                    GTK_ICON_SIZE_SMALL_TOOLBAR );
+        gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(toolbar->_simplify), prefs->getInt("/tools/freehand/pencil/simplify", 0) );
+        g_signal_connect_after(  G_OBJECT(toolbar->_simplify), "toggled", G_CALLBACK(PencilToolbar::freehand_simplify_lpe), toolbar) ;
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_simplify) );
+        guint freehandMode = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0);
+        if (freehandMode == 2) {
+            gtk_action_set_visible( GTK_ACTION( toolbar->_simplify ), false );
+        } else {
+            gtk_action_set_visible( GTK_ACTION( toolbar->_simplify ), true );
+        }
+    }
+    /* LPE simplify flatten */
+    {
+        toolbar->_flatten_simplify = ink_action_new( "PencilLpeSimplifyFlatten",
+                                                     _("LPE simplify flatten"),
+                                                     _("LPE simplify flatten"),
+                                                     INKSCAPE_ICON("flatten"),
+                                                     GTK_ICON_SIZE_SMALL_TOOLBAR );
+        g_signal_connect_after( G_OBJECT(toolbar->_flatten_simplify), "activate", G_CALLBACK(PencilToolbar::simplify_flatten), toolbar );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_flatten_simplify) );
+        guint freehandMode = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0);
+        if (freehandMode == 2 || !prefs->getInt("/tools/freehand/pencil/simplify", 0)) {
+            gtk_action_set_visible( GTK_ACTION(toolbar->_flatten_simplify), false );
+        } else {
+            gtk_action_set_visible( GTK_ACTION(toolbar->_flatten_simplify), true );
+        }
+    }
+
+    return GTK_WIDGET(toolbar->gobj());
+}
+
+PencilToolbar::~PencilToolbar()
+{
+    if(_repr) {
+        _repr->removeListenerByData(this);
+        GC::release(_repr);
+        _repr = nullptr;
+    }
 }
 
-static void freehand_mode_changed(GObject* tbl, int mode)
+void
+PencilToolbar::freehand_mode_changed(int mode)
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setInt(freehand_tool_name(tbl) + "/freehand-mode", mode);
+    prefs->setInt(freehand_tool_name() + "/freehand-mode", mode);
 
     if (mode == 1 || mode == 2) {
-        gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "flatten_spiro_bspline") ), true );
+        gtk_action_set_visible( GTK_ACTION( _flatten_spiro_bspline ), true );
     } else {
-        gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "flatten_spiro_bspline") ), false );
+        gtk_action_set_visible( GTK_ACTION( _flatten_spiro_bspline ), false );
     }
-    if (mode == 2) {
-        gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "flatten_simplify") ), false );
-        gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "simplify") ), false );
-    } else {
-        gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "flatten_simplify") ), true );
-        gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "simplify") ), true );
+
+    bool visible = (mode != 2);
+
+    if (_flatten_simplify) {
+        gtk_action_set_visible(GTK_ACTION(_flatten_simplify), visible);
     }
-}
 
-static void use_pencil_pressure(InkToggleAction* itact, GObject *dataKludge) {
-    bool pressure = gtk_toggle_action_get_active( GTK_TOGGLE_ACTION(itact) );
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setBool(freehand_tool_name(dataKludge) + "/pressure", pressure);
-    if (pressure) {
-        gtk_action_set_visible( GTK_ACTION( g_object_get_data(dataKludge, "minpressure") ), true );
-        gtk_action_set_visible( GTK_ACTION( g_object_get_data(dataKludge, "maxpressure") ), true );
-        InkSelectOneAction* act =
-            static_cast<InkSelectOneAction*>( g_object_get_data( dataKludge, "shape_action" ) );
-        act->set_visible (false);
-    } else {
-        gtk_action_set_visible( GTK_ACTION( g_object_get_data(dataKludge, "minpressure") ), false );
-        gtk_action_set_visible( GTK_ACTION( g_object_get_data(dataKludge, "maxpressure") ), false );
-        InkSelectOneAction* act =
-            static_cast<InkSelectOneAction*>( g_object_get_data( dataKludge, "shape_action" ) );
-        act->set_visible (true);
+    if (_simplify) {
+        gtk_action_set_visible(GTK_ACTION(_simplify), visible);
     }
 }
 
-static void sp_add_freehand_mode_toggle(GtkActionGroup* mainActions, GObject* holder, bool tool_is_pencil)
+/* This is used in generic functions below to share large portions of code between pen and pencil tool */
+Glib::ustring const
+PencilToolbar::freehand_tool_name()
+{
+    return ( tools_isactive(_desktop, TOOLS_FREEHAND_PEN)
+             ? "/tools/freehand/pen"
+             : "/tools/freehand/pencil" );
+}
+
+void
+PencilToolbar::add_freehand_mode_toggle(GtkActionGroup* mainActions,
+                                        bool tool_is_pencil)
 {
     /* Freehand mode toggle buttons */
 
@@ -176,43 +346,69 @@ static void sp_add_freehand_mode_toggle(GtkActionGroup* mainActions, GObject* ho
     gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
     // g_object_set_data( dataKludge, "flat_action", act );
 
-    act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&freehand_mode_changed), holder));
+    act->signal_changed().connect(sigc::mem_fun(*this, &PencilToolbar::freehand_mode_changed));
 
     /* LPE bspline spiro flatten */
-    InkAction* inky = ink_action_new( tool_is_pencil ? "FlattenSpiroBsplinePencil" :
-                                      "FlattenSpiroBsplinePen",
-                                      _("LPE spiro or bspline flatten"),
-                                      _("LPE spiro or bspline flatten"),
-                                      INKSCAPE_ICON("flatten"),
-                                      GTK_ICON_SIZE_SMALL_TOOLBAR );
-    g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_flatten_spiro_bspline), holder );
-    gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
-    g_object_set_data( holder, "flatten_spiro_bspline", inky );
+    _flatten_spiro_bspline = ink_action_new( tool_is_pencil ? "FlattenSpiroBsplinePencil" :
+                                             "FlattenSpiroBsplinePen",
+                                             _("LPE spiro or bspline flatten"),
+                                             _("LPE spiro or bspline flatten"),
+                                             INKSCAPE_ICON("flatten"),
+                                             GTK_ICON_SIZE_SMALL_TOOLBAR );
+    g_signal_connect_after( G_OBJECT(_flatten_spiro_bspline), "activate", G_CALLBACK(PencilToolbar::flatten_spiro_bspline), this);
+    gtk_action_group_add_action( mainActions, GTK_ACTION(_flatten_spiro_bspline) );
+
     if (freehandMode == 1 || freehandMode == 2) {
-        gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "flatten_spiro_bspline") ), true );
+        gtk_action_set_visible( GTK_ACTION( _flatten_spiro_bspline ), true );
     } else {
-        gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "flatten_spiro_bspline") ), false );
+        gtk_action_set_visible( GTK_ACTION( _flatten_spiro_bspline ), false );
     }
 }
 
-static void freehand_change_shape(GObject *dataKludge, int shape) {
+void
+PencilToolbar::minpressure_value_changed()
+{
+    // quit if run by the attr_changed listener
+    if (_freeze) {
+        return;
+    }
+
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setInt(freehand_tool_name(dataKludge) + "/shape", shape);
+    prefs->setDouble( "/tools/freehand/pencil/minpressure", _minpressure_adj->get_value());
 }
 
-static void freehand_simplify_lpe(InkToggleAction* itact, GObject *dataKludge) {
-    bool simplify = gtk_toggle_action_get_active( GTK_TOGGLE_ACTION(itact) );
+void
+PencilToolbar::maxpressure_value_changed()
+{
+    // quit if run by the attr_changed listener
+    if (_freeze) {
+        return;
+    }
+
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setBool(freehand_tool_name(dataKludge) + "/simplify", simplify);
-    gtk_action_set_visible( GTK_ACTION( g_object_get_data(dataKludge, "flatten_simplify") ), simplify );
-    if (simplify) {
-        gtk_action_set_visible( GTK_ACTION( g_object_get_data(dataKludge, "flatten_simplify") ), true );
+    prefs->setDouble( "/tools/freehand/pencil/maxpressure", _maxpressure_adj->get_value());
+}
+
+void
+PencilToolbar::use_pencil_pressure(InkToggleAction* itact, gpointer data) {
+    auto toolbar = reinterpret_cast<PencilToolbar *>(data);
+
+    bool pressure = gtk_toggle_action_get_active( GTK_TOGGLE_ACTION(itact) );
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setBool(toolbar->freehand_tool_name() + "/pressure", pressure);
+    if (pressure) {
+        gtk_action_set_visible( GTK_ACTION( toolbar->_minpressure ), true );
+        gtk_action_set_visible( GTK_ACTION( toolbar->_maxpressure ), true );
+        toolbar->_shape_action->set_visible (false);
     } else {
-        gtk_action_set_visible( GTK_ACTION( g_object_get_data(dataKludge, "flatten_simplify") ), false );
+        gtk_action_set_visible( GTK_ACTION( toolbar->_minpressure ), false );
+        gtk_action_set_visible( GTK_ACTION( toolbar->_maxpressure ), false );
+        toolbar->_shape_action->set_visible (true);
     }
 }
 
-static void freehand_add_advanced_shape_options(GtkActionGroup* mainActions, GObject* holder, bool tool_is_pencil)
+void
+PencilToolbar::freehand_add_advanced_shape_options(GtkActionGroup* mainActions, bool tool_is_pencil)
 {
     /*advanced shape options */
 
@@ -243,7 +439,7 @@ static void freehand_add_advanced_shape_options(GtkActionGroup* mainActions, GOb
         row[columns.col_sensitive] = true;
     }
 
-    InkSelectOneAction* act =
+    _shape_action =
         InkSelectOneAction::create( tool_is_pencil ?
                                     "SetPencilShapeAction" :
                                     "SetPenShapeAction", // Name
@@ -252,55 +448,68 @@ static void freehand_add_advanced_shape_options(GtkActionGroup* mainActions, GOb
                                     "Not Used",          // Icon
                                     store );             // Tree store
 
-    act->use_radio( false );
-    act->use_icon( false );
-    act->use_label( true );
-    act->use_group_label( true );
+    _shape_action->use_radio( false );
+    _shape_action->use_icon( false );
+    _shape_action->use_label( true );
+    _shape_action->use_group_label( true );
     int shape = prefs->getInt( (tool_is_pencil ?
                                 "/tools/freehand/pencil/shape" :
                                 "/tools/freehand/pen/shape" ), 0);
-    act->set_active( shape );
+    _shape_action->set_active( shape );
 
-    gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-    g_object_set_data( holder, "shape_action", act );
+    gtk_action_group_add_action( mainActions, GTK_ACTION( _shape_action->gobj() ));
 
     bool hide = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0) == 3 ||
         (tool_is_pencil && prefs->getBool("/tools/freehand/pencil/pressure", false));
-    act->set_visible( !hide );
+    _shape_action->set_visible( !hide );
 
-    act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&freehand_change_shape), holder));
+    _shape_action->signal_changed().connect(sigc::mem_fun(*this, &PencilToolbar::freehand_change_shape));
 }
 
-void sp_pen_toolbox_prep(SPDesktop * /*desktop*/, GtkActionGroup* mainActions, GObject* holder)
-{
-    sp_add_freehand_mode_toggle(mainActions, holder, false);
-    freehand_add_advanced_shape_options(mainActions, holder, false);
+void
+PencilToolbar::freehand_change_shape(int shape) {
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setInt(freehand_tool_name() + "/shape", shape);
 }
 
-
-static void sp_pencil_tb_defaults(GtkWidget * /*widget*/, GObject *obj)
+void
+PencilToolbar::defaults(GtkWidget * /*widget*/, GObject *obj)
 {
-    GtkWidget *tbl = GTK_WIDGET(obj);
-
-    GtkAdjustment *adj;
+    auto toolbar = reinterpret_cast<PencilToolbar *>(obj);
 
     // fixme: make settable
     gdouble tolerance = 4;
 
-    adj = GTK_ADJUSTMENT(g_object_get_data(obj, "tolerance"));
-    gtk_adjustment_set_value(adj, tolerance);
+    toolbar->_tolerance_adj->set_value(tolerance);
 
 #if !GTK_CHECK_VERSION(3,18,0)
-    gtk_adjustment_value_changed(adj);
+    toolbar->_tolerance_adj->value_changed();
 #endif
 
-    spinbutton_defocus(tbl);
+    if(toolbar->_desktop->canvas) gtk_widget_grab_focus(GTK_WIDGET(toolbar->_desktop->canvas));
 }
 
-static void sp_flatten_spiro_bspline(GtkWidget * /*widget*/, GObject *obj)
+void
+PencilToolbar::freehand_simplify_lpe(InkToggleAction* itact, GObject *data)
 {
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(obj, "desktop"));
-    auto selected = desktop->getSelection()->items();
+    auto toolbar = reinterpret_cast<PencilToolbar *>(data);
+
+    bool simplify = gtk_toggle_action_get_active( GTK_TOGGLE_ACTION(itact) );
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setBool(toolbar->freehand_tool_name() + "/simplify", simplify);
+    gtk_action_set_visible( GTK_ACTION( toolbar->_flatten_simplify ), simplify );
+    if (simplify) {
+        gtk_action_set_visible( GTK_ACTION( toolbar->_flatten_simplify ), true );
+    } else {
+        gtk_action_set_visible( GTK_ACTION( toolbar->_flatten_simplify ), false );
+    }
+}
+
+void
+PencilToolbar::simplify_flatten(GtkWidget * /*widget*/, GObject *data)
+{
+    auto toolbar = reinterpret_cast<PencilToolbar *>(data);
+    auto selected = toolbar->_desktop->getSelection()->items();
     SPLPEItem* lpeitem = nullptr;
     for (auto it(selected.begin()); it != selected.end(); ++it){
         lpeitem = dynamic_cast<SPLPEItem*>(*it);
@@ -311,9 +520,7 @@ static void sp_flatten_spiro_bspline(GtkWidget * /*widget*/, GObject *obj)
                 LivePathEffectObject *lpeobj = (*i)->lpeobject;
                 if (lpeobj) {
                     Inkscape::LivePathEffect::Effect *lpe = lpeobj->get_lpe();
-                    if (dynamic_cast<Inkscape::LivePathEffect::LPEBSpline *>(lpe) || 
-                        dynamic_cast<Inkscape::LivePathEffect::LPESpiro *>(lpe)) 
-                    {
+                    if (dynamic_cast<Inkscape::LivePathEffect::LPESimplify *>(lpe)) {
                         SPShape * shape = dynamic_cast<SPShape *>(lpeitem);
                         if(shape){
                             SPCurve * c = shape->getCurveForEdit();
@@ -334,16 +541,17 @@ static void sp_flatten_spiro_bspline(GtkWidget * /*widget*/, GObject *obj)
         }
     }
     if (lpeitem) {
-        desktop->getSelection()->remove(lpeitem->getRepr());
-        desktop->getSelection()->add(lpeitem->getRepr());
+        toolbar->_desktop->getSelection()->remove(lpeitem->getRepr());
+        toolbar->_desktop->getSelection()->add(lpeitem->getRepr());
         sp_lpe_item_update_patheffect(lpeitem, false, false);
     }
 }
 
-static void sp_simplify_flatten(GtkWidget * /*widget*/, GObject *obj)
+void
+PencilToolbar::flatten_spiro_bspline(GtkWidget * /*widget*/, gpointer data)
 {
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(obj, "desktop"));
-    auto selected = desktop->getSelection()->items();
+    auto toolbar = reinterpret_cast<PencilToolbar *>(data);
+    auto selected = toolbar->_desktop->getSelection()->items();
     SPLPEItem* lpeitem = nullptr;
     for (auto it(selected.begin()); it != selected.end(); ++it){
         lpeitem = dynamic_cast<SPLPEItem*>(*it);
@@ -354,7 +562,9 @@ static void sp_simplify_flatten(GtkWidget * /*widget*/, GObject *obj)
                 LivePathEffectObject *lpeobj = (*i)->lpeobject;
                 if (lpeobj) {
                     Inkscape::LivePathEffect::Effect *lpe = lpeobj->get_lpe();
-                    if (dynamic_cast<Inkscape::LivePathEffect::LPESimplify *>(lpe)) {
+                    if (dynamic_cast<Inkscape::LivePathEffect::LPEBSpline *>(lpe) || 
+                        dynamic_cast<Inkscape::LivePathEffect::LPESpiro *>(lpe)) 
+                    {
                         SPShape * shape = dynamic_cast<SPShape *>(lpeitem);
                         if(shape){
                             SPCurve * c = shape->getCurveForEdit();
@@ -375,46 +585,36 @@ static void sp_simplify_flatten(GtkWidget * /*widget*/, GObject *obj)
         }
     }
     if (lpeitem) {
-        desktop->getSelection()->remove(lpeitem->getRepr());
-        desktop->getSelection()->add(lpeitem->getRepr());
+        toolbar->_desktop->getSelection()->remove(lpeitem->getRepr());
+        toolbar->_desktop->getSelection()->add(lpeitem->getRepr());
         sp_lpe_item_update_patheffect(lpeitem, false, false);
     }
 }
 
-static void sp_minpressure_value_changed(GtkAdjustment *adj, GObject *tbl)
+GtkWidget *
+PencilToolbar::prep_pen(SPDesktop *desktop, GtkActionGroup* mainActions)
 {
-    // quit if run by the attr_changed listener
-    if (g_object_get_data( tbl, "freeze" )) {
-        return;
-    }
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/freehand/pencil/minpressure", gtk_adjustment_get_value(adj));
+    auto toolbar = new PencilToolbar(desktop);
+    toolbar->add_freehand_mode_toggle(mainActions, false);
+    toolbar->freehand_add_advanced_shape_options(mainActions, false);
+    return GTK_WIDGET(toolbar->gobj());
 }
 
-static void sp_maxpressure_value_changed(GtkAdjustment *adj, GObject *tbl)
+void
+PencilToolbar::tolerance_value_changed()
 {
     // quit if run by the attr_changed listener
-    if (g_object_get_data( tbl, "freeze" )) {
+    if (_freeze) {
         return;
     }
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/freehand/pencil/maxpressure", gtk_adjustment_get_value(adj));
-}
 
-static void sp_pencil_tb_tolerance_value_changed(GtkAdjustment *adj, GObject *tbl)
-{
-    // quit if run by the attr_changed listener
-    if (g_object_get_data( tbl, "freeze" )) {
-        return;
-    }
     // in turn, prevent listener from responding
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+    _freeze = true;
     prefs->setDouble("/tools/freehand/pencil/tolerance",
-            gtk_adjustment_get_value(adj));
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(tbl, "desktop"));
-    auto selected = desktop->getSelection()->items();
+                     _tolerance_adj->get_value());
+    _freeze = false;
+    auto selected = _desktop->getSelection()->items();
     for (auto it(selected.begin()); it != selected.end(); ++it){
         SPLPEItem* lpeitem = dynamic_cast<SPLPEItem*>(*it);
         if (lpeitem && lpeitem->hasPathEffect()){
@@ -460,170 +660,9 @@ static void sp_pencil_tb_tolerance_value_changed(GtkAdjustment *adj, GObject *tb
     }
 }
 
-/*
-class PencilToleranceObserver : public Inkscape::Preferences::Observer {
-public:
-    PencilToleranceObserver(Glib::ustring const &path, GObject *x) : Observer(path), _obj(x)
-    {
-        g_object_set_data(_obj, "prefobserver", this);
-    }
-    virtual ~PencilToleranceObserver() {
-        if (g_object_get_data(_obj, "prefobserver") == this) {
-            g_object_set_data(_obj, "prefobserver", NULL);
-        }
-    }
-    virtual void notify(Inkscape::Preferences::Entry const &val) {
-        GObject* tbl = _obj;
-        if (g_object_get_data( tbl, "freeze" )) {
-            return;
-        }
-        g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
-
-        GtkAdjustment * adj = GTK_ADJUSTMENT(g_object_get_data(tbl, "tolerance"));
-
-        double v = val.getDouble(adj->value);
-        gtk_adjustment_set_value(adj, v);
-        g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
-    }
-private:
-    GObject *_obj;
-};
-*/
-
-void sp_pencil_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
-{
-    sp_add_freehand_mode_toggle(mainActions, holder, true);
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    EgeAdjustmentAction* eact = nullptr;
-
-    
-    /* min pressure */
-    {
-        eact = create_adjustment_action( "MinPressureAction",
-                                         _("Min pressure"), _("Min:"), _("Min percent of pressure"),
-                                         "/tools/freehand/pencil/minpressure", 0,
-                                         GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
-                                         0, 100, 1, 0,
-                                         nullptr, nullptr, 0,
-                                         sp_minpressure_value_changed, nullptr, 0 ,0);
-                                         
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        g_object_set_data( holder, "minpressure", eact );
-        if (prefs->getInt("/tools/freehand/pencil/freehand-mode", 0) == 3) {
-            gtk_action_set_visible( GTK_ACTION(eact), true );
-        } else {
-            gtk_action_set_visible( GTK_ACTION(eact), false );
-        }
-    }
-    /* max pressure */
-    {
-        eact = create_adjustment_action( "MaxPressureAction",
-                                         _("Max pressure"), _("Max:"), _("Max percent of pressure"),
-                                         "/tools/freehand/pencil/maxpressure", 100,
-                                         GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
-                                         0, 100, 1, 0,
-                                         nullptr, nullptr, 0,
-                                         sp_maxpressure_value_changed, nullptr, 0 ,0);
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        g_object_set_data( holder, "maxpressure", eact );
-        if (prefs->getInt("/tools/freehand/pencil/freehand-mode", 0) == 3) {
-            gtk_action_set_visible( GTK_ACTION(eact), true );
-        } else {
-            gtk_action_set_visible( GTK_ACTION(eact), false );
-        }
-    }
-    /* Use pressure */
-    {
-        InkToggleAction* itact = ink_toggle_action_new( "PencilPressureAction",
-                                                        _("Use pressure input"),
-                                                        _("Use pressure input"),
-                                                        INKSCAPE_ICON("draw-use-pressure"),
-                                                        GTK_ICON_SIZE_SMALL_TOOLBAR );
-        bool pressure = prefs->getBool(freehand_tool_name(holder) + "/pressure", false);
-        gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(itact), pressure );
-        g_signal_connect_after(  G_OBJECT(itact), "toggled", G_CALLBACK(use_pencil_pressure), holder) ;
-        gtk_action_group_add_action( mainActions, GTK_ACTION(itact) );
-        if (pressure) {
-            gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "minpressure") ), true );
-            gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "maxpressure") ), true );
-        } else {
-            gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "minpressure") ), false );
-            gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "maxpressure") ), false );
-        }
-    }
-    /* Tolerance */
-    {
-        gchar const* labels[] = {_("(many nodes, rough)"), _("(default)"), nullptr, nullptr, nullptr, nullptr, _("(few nodes, smooth)")};
-        gdouble values[] = {1, 10, 20, 30, 50, 75, 100};
-        eact = create_adjustment_action( "PencilToleranceAction",
-                                         _("Smoothing:"), _("Smoothing: "),
-                 _("How much smoothing (simplifying) is applied to the line"),
-                                         "/tools/freehand/pencil/tolerance",
-                                         3.0,
-                                         GTK_WIDGET(desktop->canvas),
-                                         holder, TRUE, "altx-pencil",
-                                         1, 100.0, 0.5, 1.0,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         sp_pencil_tb_tolerance_value_changed,
-                                         nullptr /*unit tracker*/,
-                                         1, 2);
-        ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-    }
-
-    /* advanced shape options */
-    freehand_add_advanced_shape_options(mainActions, holder, true);
-
-    /* Reset */
-    {
-        InkAction* inky = ink_action_new( "PencilResetAction",
-                                          _("Defaults"),
-                                          _("Reset pencil parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
-                                          INKSCAPE_ICON("edit-clear"),
-                                          GTK_ICON_SIZE_SMALL_TOOLBAR );
-        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_pencil_tb_defaults), holder );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
-    }
-    /* LPE simplify based tolerance */
-    {
-        InkToggleAction* itact = ink_toggle_action_new( "PencilLpeSimplify",
-                                                        _("LPE based interactive simplify"),
-                                                        _("LPE based interactive simplify"),
-                                                        INKSCAPE_ICON("interactive_simplify"),
-                                                        GTK_ICON_SIZE_SMALL_TOOLBAR );
-        gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(itact), prefs->getInt("/tools/freehand/pencil/simplify", 0) );
-        g_object_set_data( holder, "simplify", itact );
-        g_signal_connect_after(  G_OBJECT(itact), "toggled", G_CALLBACK(freehand_simplify_lpe), holder) ;
-        gtk_action_group_add_action( mainActions, GTK_ACTION(itact) );
-        guint freehandMode = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0);
-        if (freehandMode == 2) {
-            gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "simplify") ), false );
-        } else {
-            gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "simplify") ), true );
-        }
-    }
-    /* LPE simplify flatten */
-    {
-        InkAction* inky = ink_action_new( "PencilLpeSimplifyFlatten",
-                                          _("LPE simplify flatten"),
-                                          _("LPE simplify flatten"),
-                                          INKSCAPE_ICON("flatten"),
-                                          GTK_ICON_SIZE_SMALL_TOOLBAR );
-        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_simplify_flatten), holder );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
-        g_object_set_data( holder, "flatten_simplify", inky );
-        guint freehandMode = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0);
-        if (freehandMode == 2 || !prefs->getInt("/tools/freehand/pencil/simplify", 0)) {
-            gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "flatten_simplify") ), false );
-        } else {
-            gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "flatten_simplify") ), true );
-        }
-    }
-
-    g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );
-
 }
-
+}
+}
 /*
   Local Variables:
   mode:c++
diff --git a/src/ui/toolbar/pencil-toolbar.h b/src/ui/toolbar/pencil-toolbar.h
index 33a56aed2..1016ae8d9 100644
--- a/src/ui/toolbar/pencil-toolbar.h
+++ b/src/ui/toolbar/pencil-toolbar.h
@@ -28,12 +28,77 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "toolbar.h"
+
+#include <gtkmm/adjustment.h>
+
+class InkSelectOneAction;
 class SPDesktop;
 
+typedef struct _EgeAdjustmentAction EgeAdjustmentAction;
 typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _GObject GObject;
+typedef struct _InkAction InkAction;
+typedef struct _InkToggleAction InkToggleAction;
+
+namespace Inkscape {
+namespace XML {
+class Node;
+}
+
+namespace UI {
+namespace Toolbar {
+class PencilToolbar : public Toolbar {
+private:
+    EgeAdjustmentAction *_minpressure;
+    EgeAdjustmentAction *_maxpressure;
+
+    XML::Node *_repr;
+    InkAction *_flatten_spiro_bspline;
+    InkAction *_flatten_simplify;
+
+    InkSelectOneAction *_shape_action;
+
+    InkToggleAction *_simplify;
+
+    bool _freeze;
+
+    Glib::RefPtr<Gtk::Adjustment> _minpressure_adj;
+    Glib::RefPtr<Gtk::Adjustment> _maxpressure_adj;
+    Glib::RefPtr<Gtk::Adjustment> _tolerance_adj;
+
+    void add_freehand_mode_toggle(GtkActionGroup* mainActions,
+                                  bool tool_is_pencil);
+    void freehand_mode_changed(int mode);
+    Glib::ustring const freehand_tool_name();
+    void minpressure_value_changed();
+    void maxpressure_value_changed();
+    static void use_pencil_pressure(InkToggleAction *itact,
+                                    gpointer         data);
+    void tolerance_value_changed();
+    void freehand_add_advanced_shape_options(GtkActionGroup* mainActions, bool tool_is_pencil);
+    void freehand_change_shape(int shape);
+    static void defaults(GtkWidget *widget, GObject *obj);
+    static void freehand_simplify_lpe(InkToggleAction* itact, GObject *data);
+    static void simplify_flatten(GtkWidget *widget, GObject *data);
+    static void flatten_spiro_bspline(GtkWidget *widget, gpointer data);
+
+protected:
+    PencilToolbar(SPDesktop *desktop)
+        : Toolbar(desktop),
+          _repr(nullptr),
+          _freeze(false),
+          _flatten_simplify(nullptr),
+          _simplify(nullptr)
+    {}
+
+    ~PencilToolbar();
 
-void    sp_pencil_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
-void    sp_pen_toolbox_prep(SPDesktop * /*desktop*/, GtkActionGroup* mainActions, GObject* holder);
+public:
+    static GtkWidget * prep_pencil(SPDesktop *desktop, GtkActionGroup* mainActions);
+    static GtkWidget * prep_pen(SPDesktop *desktop, GtkActionGroup* mainActions);
+};
+}
+}
+}
 
 #endif /* !SEEN_PENCIL_TOOLBAR_H */
diff --git a/src/ui/toolbar/rect-toolbar.cpp b/src/ui/toolbar/rect-toolbar.cpp
index cc615a35d..d4fa9d74f 100644
--- a/src/ui/toolbar/rect-toolbar.cpp
+++ b/src/ui/toolbar/rect-toolbar.cpp
@@ -61,55 +61,198 @@ using Inkscape::Util::Unit;
 using Inkscape::Util::Quantity;
 using Inkscape::Util::unit_table;
 
+static Inkscape::XML::NodeEventVector rect_tb_repr_events = {
+    nullptr, /* child_added */
+    nullptr, /* child_removed */
+    Inkscape::UI::Toolbar::RectToolbar::event_attr_changed,
+    nullptr, /* content_changed */
+    nullptr  /* order_changed */
+};
 
-//########################
-//##       Rect         ##
-//########################
+namespace Inkscape {
+namespace UI {
+namespace Toolbar {
 
-static void sp_rtb_sensitivize( GObject *tbl )
+RectToolbar::RectToolbar(SPDesktop *desktop)
+    : Toolbar(desktop),
+      _tracker(new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR)),
+      _freeze(false),
+      _single(true)
 {
-    GtkAdjustment *adj1 = GTK_ADJUSTMENT( g_object_get_data(tbl, "rx") );
-    GtkAdjustment *adj2 = GTK_ADJUSTMENT( g_object_get_data(tbl, "ry") );
-    GtkAction* not_rounded = GTK_ACTION( g_object_get_data(tbl, "not_rounded") );
+    // rx/ry units menu: create
+    //tracker->addUnit( SP_UNIT_PERCENT, 0 );
+    // fixme: add % meaning per cent of the width/height
+    _tracker->setActiveUnit(unit_table.getUnit("px"));
+}
 
-    if (gtk_adjustment_get_value(adj1) == 0 && gtk_adjustment_get_value(adj2) == 0 && g_object_get_data(tbl, "single")) { // only for a single selected rect (for now)
-        gtk_action_set_sensitive( not_rounded, FALSE );
-    } else {
-        gtk_action_set_sensitive( not_rounded, TRUE );
+RectToolbar::~RectToolbar()
+{
+    if (_repr) { // remove old listener
+        _repr->removeListenerByData(this);
+        Inkscape::GC::release(_repr);
+        _repr = nullptr;
     }
 }
 
-
-static void sp_rtb_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_name,
-                                 void (SPRect::*setter)(gdouble))
+GtkWidget *
+RectToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
 {
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( tbl, "desktop" ));
+    auto holder = new RectToolbar(desktop);
+
+    EgeAdjustmentAction* eact = nullptr;
+    GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
+
+    {
+        holder->_mode_action = ege_output_action_new( "RectStateAction", _("<b>New:</b>"), "", nullptr );
+        ege_output_action_set_use_markup( holder->_mode_action, TRUE );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_mode_action ) );
+    }
+
+    /* W */
+    {
+        gchar const* labels[] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
+        gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
+        holder->_width_action = create_adjustment_action( "RectWidthAction",
+                                                          _("Width"), _("W:"), _("Width of rectangle"),
+                                                          "/tools/shapes/rect/width", 0,
+                                                          GTK_WIDGET(desktop->canvas),
+                                                          nullptr, // dataKludge
+                                                          TRUE, "altx-rect",
+                                                          0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
+                                                          labels, values, G_N_ELEMENTS(labels),
+                                                          nullptr, // callback
+                                                          holder->_tracker);
+
+        holder->_width_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_width_action));
+        holder->_width_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &RectToolbar::value_changed),
+                                                                      holder->_width_adj,
+                                                                      "width",
+                                                                      &SPRect::setVisibleWidth));
+        gtk_action_set_sensitive( GTK_ACTION(holder->_width_action), FALSE );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_width_action) );
+    }
+
+    /* H */
+    {
+        gchar const* labels[] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
+        gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
+        holder->_height_action = create_adjustment_action( "RectHeightAction",
+                                                           _("Height"), _("H:"), _("Height of rectangle"),
+                                                           "/tools/shapes/rect/height", 0,
+                                                           GTK_WIDGET(desktop->canvas),
+                                                           nullptr, // dataKludge
+                                                           FALSE, nullptr,
+                                                           0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
+                                                           labels, values, G_N_ELEMENTS(labels),
+                                                           nullptr, // callback
+                                                           holder->_tracker);
+        holder->_height_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_height_action));
+        holder->_height_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &RectToolbar::value_changed),
+                                                                       holder->_height_adj,
+                                                                       "height",
+                                                                       &SPRect::setVisibleHeight));
+        gtk_action_set_sensitive( GTK_ACTION(holder->_height_action), FALSE );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_height_action) );
+    }
+
+    /* rx */
+    {
+        gchar const* labels[] = {_("not rounded"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
+        gdouble values[] = {0.5, 1, 2, 3, 5, 10, 20, 50, 100};
+        eact = create_adjustment_action( "RadiusXAction",
+                                         _("Horizontal radius"), _("Rx:"), _("Horizontal radius of rounded corners"),
+                                         "/tools/shapes/rect/rx", 0,
+                                         GTK_WIDGET(desktop->canvas),
+                                         nullptr, // dataKludge
+                                         FALSE, nullptr,
+                                         0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
+                                         labels, values, G_N_ELEMENTS(labels),
+                                         nullptr, // callback
+                                         holder->_tracker);
+        holder->_rx_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        holder->_rx_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &RectToolbar::value_changed),
+                                                                   holder->_rx_adj,
+                                                                   "rx",
+                                                                   &SPRect::setVisibleRx));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+    }
+
+    /* ry */
+    {
+        gchar const* labels[] = {_("not rounded"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
+        gdouble values[] = {0.5, 1, 2, 3, 5, 10, 20, 50, 100};
+        eact = create_adjustment_action( "RadiusYAction",
+                                         _("Vertical radius"), _("Ry:"), _("Vertical radius of rounded corners"),
+                                         "/tools/shapes/rect/ry", 0,
+                                         GTK_WIDGET(desktop->canvas),
+                                         nullptr, // dataKludge
+                                         FALSE, nullptr,
+                                         0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
+                                         labels, values, G_N_ELEMENTS(labels),
+                                         nullptr, // callback
+                                         holder->_tracker);
+        holder->_ry_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        holder->_ry_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &RectToolbar::value_changed),
+                                                                   holder->_ry_adj,
+                                                                   "ry",
+                                                                   &SPRect::setVisibleRy));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+    }
+
+    // add the units menu
+    {
+        InkSelectOneAction* act = holder->_tracker->createAction( "RectUnitsAction", _("Units"), ("") );
+        gtk_action_group_add_action( mainActions, act->gobj() );
+    }
 
-    UnitTracker* tracker = reinterpret_cast<UnitTracker*>(g_object_get_data( tbl, "tracker" ));
-    Unit const *unit = tracker->getActiveUnit();
+    /* Reset */
+    {
+        holder->_not_rounded = ink_action_new( "RectResetAction",
+                                               _("Not rounded"),
+                                               _("Make corners sharp"),
+                                               INKSCAPE_ICON("rectangle-make-corners-sharp"),
+                                               secondarySize );
+        g_signal_connect_after( G_OBJECT(holder->_not_rounded), "activate", G_CALLBACK(&RectToolbar::defaults), holder );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_not_rounded) );
+        gtk_action_set_sensitive( GTK_ACTION(holder->_not_rounded), TRUE );
+    }
+
+    holder->sensitivize();
+
+    desktop->connectEventContextChanged(sigc::mem_fun(*holder, &RectToolbar::watch_ec));
+
+    return GTK_WIDGET(holder->gobj());
+}
+
+void
+RectToolbar::value_changed(Glib::RefPtr<Gtk::Adjustment>&  adj,
+                           gchar const                    *value_name,
+                           void (SPRect::*setter)(gdouble))
+{
+    Unit const *unit = _tracker->getActiveUnit();
     g_return_if_fail(unit != nullptr);
 
-    if (DocumentUndo::getUndoSensitive(desktop->getDocument())) {
+    if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
         prefs->setDouble(Glib::ustring("/tools/shapes/rect/") + value_name,
-            Quantity::convert(gtk_adjustment_get_value(adj), unit, "px"));
+            Quantity::convert(adj->get_value(), unit, "px"));
     }
 
     // quit if run by the attr_changed listener
-    if (g_object_get_data( tbl, "freeze" ) || tracker->isUpdating()) {
+    if (_freeze || _tracker->isUpdating()) {
         return;
     }
 
     // in turn, prevent listener from responding
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE));
+    _freeze = true;
 
     bool modmade = false;
-    Inkscape::Selection *selection = desktop->getSelection();
+    Inkscape::Selection *selection = _desktop->getSelection();
     auto itemlist= selection->items();
     for(auto i=itemlist.begin();i!=itemlist.end();++i){
         if (SP_IS_RECT(*i)) {
-            if (gtk_adjustment_get_value(adj) != 0) {
-                (SP_RECT(*i)->*setter)(Quantity::convert(gtk_adjustment_get_value(adj), unit, "px"));
+            if (adj->get_value() != 0) {
+                (SP_RECT(*i)->*setter)(Quantity::convert(adj->get_value(), unit, "px"));
             } else {
                 (*i)->getRepr()->setAttribute(value_name, nullptr);
             }
@@ -117,136 +260,86 @@ static void sp_rtb_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *
         }
     }
 
-    sp_rtb_sensitivize( tbl );
+    sensitivize();
 
     if (modmade) {
-        DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_RECT,
+        DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_RECT,
                            _("Change rectangle"));
     }
 
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-static void sp_rtb_rx_value_changed(GtkAdjustment *adj, GObject *tbl)
+void
+RectToolbar::sensitivize()
 {
-    sp_rtb_value_changed(adj, tbl, "rx", &SPRect::setVisibleRx);
-}
-
-static void sp_rtb_ry_value_changed(GtkAdjustment *adj, GObject *tbl)
-{
-    sp_rtb_value_changed(adj, tbl, "ry", &SPRect::setVisibleRy);
-}
-
-static void sp_rtb_width_value_changed(GtkAdjustment *adj, GObject *tbl)
-{
-    sp_rtb_value_changed(adj, tbl, "width", &SPRect::setVisibleWidth);
+    if (_rx_adj->get_value() == 0 && _ry_adj->get_value() == 0 && _single) { // only for a single selected rect (for now)
+        gtk_action_set_sensitive( GTK_ACTION(_not_rounded), FALSE );
+    } else {
+        gtk_action_set_sensitive( GTK_ACTION(_not_rounded), TRUE );
+    }
 }
 
-static void sp_rtb_height_value_changed(GtkAdjustment *adj, GObject *tbl)
+void
+RectToolbar::defaults( GtkWidget * /*widget*/, GObject *obj)
 {
-    sp_rtb_value_changed(adj, tbl, "height", &SPRect::setVisibleHeight);
-}
-
+    auto toolbar = reinterpret_cast<RectToolbar*>(obj);
 
-
-static void sp_rtb_defaults( GtkWidget * /*widget*/, GObject *obj)
-{
-    GtkAdjustment *adj = nullptr;
-
-    adj = GTK_ADJUSTMENT( g_object_get_data(obj, "rx") );
-    gtk_adjustment_set_value(adj, 0.0);
+    toolbar->_rx_adj->set_value(0.0);
+    toolbar->_ry_adj->set_value(0.0);
 
 #if !GTK_CHECK_VERSION(3,18,0)
     // this is necessary if the previous value was 0, but we still need to run the callback to change all selected objects
-    gtk_adjustment_value_changed(adj);
+    toolbar->_rx_adj->value_changed();
+    toolbar->_ry_adj->value_changed();
 #endif
 
-    adj = GTK_ADJUSTMENT( g_object_get_data(obj, "ry") );
-    gtk_adjustment_set_value(adj, 0.0);
-
-#if !GTK_CHECK_VERSION(3,18,0)
-    gtk_adjustment_value_changed(adj);
-#endif
-
-    sp_rtb_sensitivize( obj );
+    toolbar->sensitivize();
 }
 
-static void rect_tb_event_attr_changed(Inkscape::XML::Node * /*repr*/, gchar const * /*name*/,
-                                       gchar const * /*old_value*/, gchar const * /*new_value*/,
-                                       bool /*is_interactive*/, gpointer data)
+void
+RectToolbar::watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec)
 {
-    GObject *tbl = G_OBJECT(data);
-
-    // quit if run by the _changed callbacks
-    if (g_object_get_data( tbl, "freeze" )) {
-        return;
-    }
-
-    // in turn, prevent callbacks from responding
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
-
-    UnitTracker* tracker = reinterpret_cast<UnitTracker*>( g_object_get_data( tbl, "tracker" ) );
-    Unit const *unit = tracker->getActiveUnit();
-    g_return_if_fail(unit != nullptr);
-
-    gpointer item = g_object_get_data( tbl, "item" );
-    if (item && SP_IS_RECT(item)) {
-        {
-            GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "rx" ) );
-
-            gdouble rx = SP_RECT(item)->getVisibleRx();
-            gtk_adjustment_set_value(adj, Quantity::convert(rx, "px", unit));
-        }
-
-        {
-            GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "ry" ) );
-
-            gdouble ry = SP_RECT(item)->getVisibleRy();
-            gtk_adjustment_set_value(adj, Quantity::convert(ry, "px", unit));
-        }
+    static sigc::connection changed;
 
-        {
-            GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "width" ) );
+    // use of dynamic_cast<> seems wrong here -- we just need to check the current tool
 
-            gdouble width = SP_RECT(item)->getVisibleWidth();
-            gtk_adjustment_set_value(adj, Quantity::convert(width, "px", unit));
-        }
+    if (dynamic_cast<Inkscape::UI::Tools::RectTool *>(ec)) {
+        Inkscape::Selection *sel = desktop->getSelection();
 
-        {
-            GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "height" ) );
+        changed = sel->connectChanged(sigc::mem_fun(*this, &RectToolbar::selection_changed));
 
-            gdouble height = SP_RECT(item)->getVisibleHeight();
-            gtk_adjustment_set_value(adj, Quantity::convert(height, "px", unit));
+        // Synthesize an emission to trigger the update
+        selection_changed(sel);
+    } else {
+        if (changed) {
+            changed.disconnect();
+        
+            if (_repr) { // remove old listener
+                _repr->removeListenerByData(this);
+                Inkscape::GC::release(_repr);
+                _repr = nullptr;
+            }
         }
     }
-
-    sp_rtb_sensitivize( tbl );
-
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
 }
 
-
-static Inkscape::XML::NodeEventVector rect_tb_repr_events = {
-    nullptr, /* child_added */
-    nullptr, /* child_removed */
-    rect_tb_event_attr_changed,
-    nullptr, /* content_changed */
-    nullptr  /* order_changed */
-};
-
 /**
  *  \param selection should not be NULL.
  */
-static void sp_rect_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
+void
+RectToolbar::selection_changed(Inkscape::Selection *selection)
 {
     int n_selected = 0;
     Inkscape::XML::Node *repr = nullptr;
     SPItem *item = nullptr;
 
-    if ( g_object_get_data( tbl, "repr" ) ) {
-        g_object_set_data( tbl, "item", nullptr );
+    if (_repr) { // remove old listener
+        _item = nullptr;
+        _repr->removeListenerByData(this);
+        Inkscape::GC::release(_repr);
+        _repr = nullptr;
     }
-    purge_repr_listener( tbl, tbl );
 
     auto itemlist= selection->items();
     for(auto i=itemlist.begin();i!=itemlist.end();++i){
@@ -257,169 +350,80 @@ static void sp_rect_toolbox_selection_changed(Inkscape::Selection *selection, GO
         }
     }
 
-    EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) );
-
-    g_object_set_data( tbl, "single", GINT_TO_POINTER(FALSE) );
+    _single = false;
 
     if (n_selected == 0) {
-        g_object_set( G_OBJECT(act), "label", _("<b>New:</b>"), NULL );
-
-        GtkAction* w = GTK_ACTION( g_object_get_data( tbl, "width_action" ) );
-        gtk_action_set_sensitive(w, FALSE);
-        GtkAction* h = GTK_ACTION( g_object_get_data( tbl, "height_action" ) );
-        gtk_action_set_sensitive(h, FALSE);
-
+        gtk_action_set_label(GTK_ACTION(_mode_action), _("<b>New:</b>"));
+        gtk_action_set_sensitive(GTK_ACTION(_width_action), FALSE);
+        gtk_action_set_sensitive(GTK_ACTION(_height_action), FALSE);
     } else if (n_selected == 1) {
-        g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
-        g_object_set_data( tbl, "single", GINT_TO_POINTER(TRUE) );
-
-        GtkAction* w = GTK_ACTION( g_object_get_data( tbl, "width_action" ) );
-        gtk_action_set_sensitive(w, TRUE);
-        GtkAction* h = GTK_ACTION( g_object_get_data( tbl, "height_action" ) );
-        gtk_action_set_sensitive(h, TRUE);
+        gtk_action_set_label(GTK_ACTION(_mode_action), _("<b>Change:</b>"));
+        _single = true;
+        gtk_action_set_sensitive(GTK_ACTION(_width_action), TRUE);
+        gtk_action_set_sensitive(GTK_ACTION(_height_action), TRUE);
 
         if (repr) {
-            g_object_set_data( tbl, "repr", repr );
-            g_object_set_data( tbl, "item", item );
-            Inkscape::GC::anchor(repr);
-            sp_repr_add_listener(repr, &rect_tb_repr_events, tbl);
-            sp_repr_synthesize_events(repr, &rect_tb_repr_events, tbl);
+            _repr = repr;
+            _item = item;
+            Inkscape::GC::anchor(_repr);
+            _repr->addListener(&rect_tb_repr_events, this);
+            _repr->synthesizeEvents(&rect_tb_repr_events, this);
         }
     } else {
         // FIXME: implement averaging of all parameters for multiple selected
         //gtk_label_set_markup(GTK_LABEL(l), _("<b>Average:</b>"));
-        g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
-        sp_rtb_sensitivize( tbl );
+        gtk_action_set_label(GTK_ACTION(_mode_action), _("<b>Change:</b>"));
+        sensitivize();
     }
 }
 
-static void rect_toolbox_watch_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* holder);
-
-void sp_rect_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
+void RectToolbar::event_attr_changed(Inkscape::XML::Node * /*repr*/, gchar const * /*name*/,
+                                     gchar const * /*old_value*/, gchar const * /*new_value*/,
+                                     bool /*is_interactive*/, gpointer data)
 {
-    EgeAdjustmentAction* eact = nullptr;
-    GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
+    auto toolbar = reinterpret_cast<RectToolbar*>(data);
 
-    {
-        EgeOutputAction* act = ege_output_action_new( "RectStateAction", _("<b>New:</b>"), "", nullptr );
-        ege_output_action_set_use_markup( act, TRUE );
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        g_object_set_data( holder, "mode_action", act );
+    // quit if run by the _changed callbacks
+    if (toolbar->_freeze) {
+        return;
     }
 
-    // rx/ry units menu: create
-    UnitTracker* tracker = new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR);
-    //tracker->addUnit( SP_UNIT_PERCENT, 0 );
-    // fixme: add % meaning per cent of the width/height
-    tracker->setActiveUnit(unit_table.getUnit("px"));
-    g_object_set_data( holder, "tracker", tracker );
-
-    /* W */
-    {
-        gchar const* labels[] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
-        gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
-        eact = create_adjustment_action( "RectWidthAction",
-                                         _("Width"), _("W:"), _("Width of rectangle"),
-                                         "/tools/shapes/rect/width", 0,
-                                         GTK_WIDGET(desktop->canvas), holder, TRUE, "altx-rect",
-                                         0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         sp_rtb_width_value_changed, tracker);
-        g_object_set_data( holder, "width_action", eact );
-        gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-    }
+    // in turn, prevent callbacks from responding
+    toolbar->_freeze = true;
 
-    /* H */
-    {
-        gchar const* labels[] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
-        gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
-        eact = create_adjustment_action( "RectHeightAction",
-                                         _("Height"), _("H:"), _("Height of rectangle"),
-                                         "/tools/shapes/rect/height", 0,
-                                         GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
-                                         0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         sp_rtb_height_value_changed, tracker);
-        g_object_set_data( holder, "height_action", eact );
-        gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-    }
+    Unit const *unit = toolbar->_tracker->getActiveUnit();
+    g_return_if_fail(unit != nullptr);
 
-    /* rx */
-    {
-        gchar const* labels[] = {_("not rounded"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
-        gdouble values[] = {0.5, 1, 2, 3, 5, 10, 20, 50, 100};
-        eact = create_adjustment_action( "RadiusXAction",
-                                         _("Horizontal radius"), _("Rx:"), _("Horizontal radius of rounded corners"),
-                                         "/tools/shapes/rect/rx", 0,
-                                         GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
-                                         0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         sp_rtb_rx_value_changed, tracker);
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-    }
+    if (toolbar->_item && SP_IS_RECT(toolbar->_item)) {
+        {
+            gdouble rx = SP_RECT(toolbar->_item)->getVisibleRx();
+            toolbar->_rx_adj->set_value(Quantity::convert(rx, "px", unit));
+        }
 
-    /* ry */
-    {
-        gchar const* labels[] = {_("not rounded"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
-        gdouble values[] = {0.5, 1, 2, 3, 5, 10, 20, 50, 100};
-        eact = create_adjustment_action( "RadiusYAction",
-                                         _("Vertical radius"), _("Ry:"), _("Vertical radius of rounded corners"),
-                                         "/tools/shapes/rect/ry", 0,
-                                         GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
-                                         0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         sp_rtb_ry_value_changed, tracker);
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-    }
+        {
+            gdouble ry = SP_RECT(toolbar->_item)->getVisibleRy();
+            toolbar->_ry_adj->set_value(Quantity::convert(ry, "px", unit));
+        }
 
-    // add the units menu
-    {
-        InkSelectOneAction* act = tracker->createAction( "RectUnitsAction", _("Units"), ("") );
-        gtk_action_group_add_action( mainActions, act->gobj() );
-    }
+        {
+            gdouble width = SP_RECT(toolbar->_item)->getVisibleWidth();
+            toolbar->_width_adj->set_value(Quantity::convert(width, "px", unit));
+        }
 
-    /* Reset */
-    {
-        InkAction* inky = ink_action_new( "RectResetAction",
-                                          _("Not rounded"),
-                                          _("Make corners sharp"),
-                                          INKSCAPE_ICON("rectangle-make-corners-sharp"),
-                                          secondarySize );
-        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_rtb_defaults), holder );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
-        gtk_action_set_sensitive( GTK_ACTION(inky), TRUE );
-        g_object_set_data( holder, "not_rounded", inky );
+        {
+            gdouble height = SP_RECT(toolbar->_item)->getVisibleHeight();
+            toolbar->_height_adj->set_value(Quantity::convert(height, "px", unit));
+        }
     }
 
-    g_object_set_data( holder, "single", GINT_TO_POINTER(TRUE) );
-    sp_rtb_sensitivize( holder );
-
-    desktop->connectEventContextChanged(sigc::bind(sigc::ptr_fun(rect_toolbox_watch_ec), holder));
-    g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );
+    toolbar->sensitivize();
+    toolbar->_freeze = false;
 }
 
-static void rect_toolbox_watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec, GObject* holder)
-{
-    static sigc::connection changed;
-
-    // use of dynamic_cast<> seems wrong here -- we just need to check the current tool
-
-    if (dynamic_cast<Inkscape::UI::Tools::RectTool *>(ec)) {
-        Inkscape::Selection *sel = desktop->getSelection();
-
-        changed = sel->connectChanged(sigc::bind(sigc::ptr_fun(sp_rect_toolbox_selection_changed), holder));
-
-        // Synthesize an emission to trigger the update
-        sp_rect_toolbox_selection_changed(sel, holder);
-    } else {
-        if (changed) {
-            changed.disconnect();
-            purge_repr_listener(nullptr, holder);
-        }
-    }
 }
+}
+}
+
 
 /*
   Local Variables:
diff --git a/src/ui/toolbar/rect-toolbar.h b/src/ui/toolbar/rect-toolbar.h
index 9976d8a43..297ac5281 100644
--- a/src/ui/toolbar/rect-toolbar.h
+++ b/src/ui/toolbar/rect-toolbar.h
@@ -28,11 +28,85 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "toolbar.h"
+
+#include <gtkmm/adjustment.h>
+
 class SPDesktop;
+class SPItem;
+class SPRect;
 
+typedef struct _EgeAdjustmentAction EgeAdjustmentAction;
+typedef struct _EgeOutputAction EgeOutputAction;
 typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _GObject GObject;
+typedef struct _InkAction InkAction;
+
+namespace Inkscape {
+class Selection;
+
+namespace XML {
+class Node;
+}
+
+namespace UI {
+namespace Tools {
+class ToolBase;
+}
+
+namespace Widget {
+class UnitTracker;
+}
+
+namespace Toolbar {
+class RectToolbar : public Toolbar {
+private:
+    EgeOutputAction *_mode_action;
+
+    UI::Widget::UnitTracker *_tracker;
+
+    XML::Node *_repr;
+    SPItem *_item;
+
+    EgeAdjustmentAction *_width_action;
+    EgeAdjustmentAction *_height_action;
+    InkAction *_not_rounded;
+
+    Glib::RefPtr<Gtk::Adjustment> _width_adj;
+    Glib::RefPtr<Gtk::Adjustment> _height_adj;
+    Glib::RefPtr<Gtk::Adjustment> _rx_adj;
+    Glib::RefPtr<Gtk::Adjustment> _ry_adj;
+
+    bool _freeze;
+    bool _single;
+
+    void value_changed(Glib::RefPtr<Gtk::Adjustment>&  adj,
+                       gchar const                    *value_name,
+                       void (SPRect::*setter)(gdouble));
+
+    void sensitivize();
+    static void defaults(GtkWidget *widget,
+                         GObject   *obj);
+    void watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec);
+    void selection_changed(Inkscape::Selection *selection);
+
+protected:
+    RectToolbar(SPDesktop *desktop);
+    ~RectToolbar();
+
+public:
+    static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions);
+
+    static void event_attr_changed(Inkscape::XML::Node *repr,
+                                   gchar const         *name,
+                                   gchar const         *old_value,
+                                   gchar const         *new_value,
+                                   bool                 is_interactive,
+                                   gpointer             data);
+
+};
 
-void       sp_rect_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
+}
+}
+}
 
 #endif /* !SEEN_RECT_TOOLBAR_H */
diff --git a/src/ui/toolbar/select-toolbar.cpp b/src/ui/toolbar/select-toolbar.cpp
index 0e1ad9c1b..604b185b7 100644
--- a/src/ui/toolbar/select-toolbar.cpp
+++ b/src/ui/toolbar/select-toolbar.cpp
@@ -44,7 +44,6 @@
 #include "ui/widget/unit-tracker.h"
 
 #include "widgets/ege-adjustment-action.h"
-#include "widgets/sp-widget.h"
 #include "widgets/widget-sizes.h"
 
 using Inkscape::UI::Widget::UnitTracker;
@@ -53,219 +52,7 @@ using Inkscape::Util::Quantity;
 using Inkscape::DocumentUndo;
 using Inkscape::Util::unit_table;
 
-static void
-sp_selection_layout_widget_update(SPWidget *spw, Inkscape::Selection *sel)
-{
-    if (g_object_get_data(G_OBJECT(spw), "update")) {
-        return;
-    }
-
-    g_object_set_data(G_OBJECT(spw), "update", GINT_TO_POINTER(TRUE));
-
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    using Geom::X;
-    using Geom::Y;
-    if ( sel && !sel->isEmpty() ) {
-        int prefs_bbox = prefs->getInt("/tools/bounding_box", 0);
-        SPItem::BBoxType bbox_type = (prefs_bbox ==0)?
-            SPItem::VISUAL_BBOX : SPItem::GEOMETRIC_BBOX;
-        Geom::OptRect const bbox(sel->bounds(bbox_type));
-        if ( bbox ) {
-            UnitTracker *tracker = reinterpret_cast<UnitTracker*>(g_object_get_data(G_OBJECT(spw), "tracker"));
-            Unit const *unit = tracker->getActiveUnit();
-            g_return_if_fail(unit != nullptr);
 
-            struct { char const *key; double val; } const keyval[] = {
-                { "X", bbox->min()[X] },
-                { "Y", bbox->min()[Y] },
-                { "width", bbox->dimensions()[X] },
-                { "height", bbox->dimensions()[Y] }
-            };
-
-            if (unit->type == Inkscape::Util::UNIT_TYPE_DIMENSIONLESS) {
-                double const val = unit->factor * 100;
-                for (auto i : keyval) {
-                    GtkAdjustment *a = GTK_ADJUSTMENT(g_object_get_data(G_OBJECT(spw), i.key));
-                    gtk_adjustment_set_value(a, val);
-                    tracker->setFullVal( a, i.val );
-                }
-            } else {
-                for (auto i : keyval) {
-                    GtkAdjustment *a = GTK_ADJUSTMENT(g_object_get_data(G_OBJECT(spw), i.key));
-                    gtk_adjustment_set_value(a, Quantity::convert(i.val, "px", unit));
-                }
-            }
-        }
-    }
-
-    g_object_set_data(G_OBJECT(spw), "update", GINT_TO_POINTER(FALSE));
-}
-
-
-static void
-sp_selection_layout_widget_modify_selection(SPWidget *spw, Inkscape::Selection *selection, guint flags, gpointer data)
-{
-    SPDesktop *desktop = static_cast<SPDesktop *>(data);
-    if ((desktop->getSelection() == selection) // only respond to changes in our desktop
-        && (flags & (SP_OBJECT_MODIFIED_FLAG        |
-                     SP_OBJECT_PARENT_MODIFIED_FLAG |
-                     SP_OBJECT_CHILD_MODIFIED_FLAG   )))
-    {
-        sp_selection_layout_widget_update(spw, selection);
-    }
-}
-
-static void
-sp_selection_layout_widget_change_selection(SPWidget *spw, Inkscape::Selection *selection, gpointer data)
-{
-    SPDesktop *desktop = static_cast<SPDesktop *>(data);
-    if (desktop->getSelection() == selection) { // only respond to changes in our desktop
-        gboolean setActive = (selection && !selection->isEmpty());
-        std::vector<GtkAction*> *contextActions = reinterpret_cast<std::vector<GtkAction*> *>(g_object_get_data(G_OBJECT(spw), "contextActions"));
-        if ( contextActions ) {
-            for (auto & contextAction : *contextActions) {
-                if ( setActive != gtk_action_is_sensitive(contextAction) ) {
-                    gtk_action_set_sensitive( contextAction, setActive );
-                }
-            }
-        }
-
-        sp_selection_layout_widget_update(spw, selection);
-    }
-}
-
-static void
-sp_object_layout_any_value_changed(GtkAdjustment *adj, GObject *tbl)
-{
-    if (g_object_get_data(tbl, "update")) {
-        return;
-    }
-
-    UnitTracker *tracker = reinterpret_cast<UnitTracker*>(g_object_get_data(tbl, "tracker"));
-    if ( !tracker || tracker->isUpdating() ) {
-        /*
-         * When only units are being changed, don't treat changes
-         * to adjuster values as object changes.
-         */
-        return;
-    }
-    g_object_set_data(tbl, "update", GINT_TO_POINTER(TRUE));
-
-    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
-    Inkscape::Selection *selection = desktop->getSelection();
-    SPDocument *document = desktop->getDocument();
-
-    document->ensureUpToDate ();
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-
-    Geom::OptRect bbox_vis = selection->visualBounds();
-    Geom::OptRect bbox_geom = selection->geometricBounds();
-
-    int prefs_bbox = prefs->getInt("/tools/bounding_box");
-    SPItem::BBoxType bbox_type = (prefs_bbox == 0)?
-        SPItem::VISUAL_BBOX : SPItem::GEOMETRIC_BBOX;
-    Geom::OptRect bbox_user = selection->bounds(bbox_type);
-
-    if ( !bbox_user ) {
-        g_object_set_data(tbl, "update", GINT_TO_POINTER(FALSE));
-        return;
-    }
-
-    gdouble x0 = 0;
-    gdouble y0 = 0;
-    gdouble x1 = 0;
-    gdouble y1 = 0;
-    gdouble xrel = 0;
-    gdouble yrel = 0;
-    Unit const *unit = tracker->getActiveUnit();
-    g_return_if_fail(unit != nullptr);
-
-    GtkAdjustment* a_x = GTK_ADJUSTMENT( g_object_get_data( tbl, "X" ) );
-    GtkAdjustment* a_y = GTK_ADJUSTMENT( g_object_get_data( tbl, "Y" ) );
-    GtkAdjustment* a_w = GTK_ADJUSTMENT( g_object_get_data( tbl, "width" ) );
-    GtkAdjustment* a_h = GTK_ADJUSTMENT( g_object_get_data( tbl, "height" ) );
-
-    if (unit->type == Inkscape::Util::UNIT_TYPE_LINEAR) {
-        x0 = Quantity::convert(gtk_adjustment_get_value(a_x), unit, "px");
-        y0 = Quantity::convert(gtk_adjustment_get_value(a_y), unit, "px");
-        x1 = x0 + Quantity::convert(gtk_adjustment_get_value(a_w), unit, "px");
-        xrel = Quantity::convert(gtk_adjustment_get_value(a_w), unit, "px") / bbox_user->dimensions()[Geom::X];
-        y1 = y0 + Quantity::convert(gtk_adjustment_get_value(a_h), unit, "px");;
-        yrel = Quantity::convert(gtk_adjustment_get_value(a_h), unit, "px") / bbox_user->dimensions()[Geom::Y];
-    } else {
-        double const x0_propn = gtk_adjustment_get_value (a_x) / 100 / unit->factor;
-        x0 = bbox_user->min()[Geom::X] * x0_propn;
-        double const y0_propn = gtk_adjustment_get_value (a_y) / 100 / unit->factor;
-        y0 = y0_propn * bbox_user->min()[Geom::Y];
-        xrel = gtk_adjustment_get_value (a_w) / (100 / unit->factor);
-        x1 = x0 + xrel * bbox_user->dimensions()[Geom::X];
-        yrel = gtk_adjustment_get_value (a_h) / (100 / unit->factor);
-        y1 = y0 + yrel * bbox_user->dimensions()[Geom::Y];
-    }
-
-    // Keep proportions if lock is on
-    GtkToggleAction *lock = GTK_TOGGLE_ACTION( g_object_get_data(tbl, "lock") );
-    if ( gtk_toggle_action_get_active(lock) ) {
-        if (adj == a_h) {
-            x1 = x0 + yrel * bbox_user->dimensions()[Geom::X];
-        } else if (adj == a_w) {
-            y1 = y0 + xrel * bbox_user->dimensions()[Geom::Y];
-        }
-    }
-
-    // scales and moves, in px
-    double mh = fabs(x0 - bbox_user->min()[Geom::X]);
-    double sh = fabs(x1 - bbox_user->max()[Geom::X]);
-    double mv = fabs(y0 - bbox_user->min()[Geom::Y]);
-    double sv = fabs(y1 - bbox_user->max()[Geom::Y]);
-
-    // unless the unit is %, convert the scales and moves to the unit
-    if (unit->type == Inkscape::Util::UNIT_TYPE_LINEAR) {
-        mh = Quantity::convert(mh, "px", unit);
-        sh = Quantity::convert(sh, "px", unit);
-        mv = Quantity::convert(mv, "px", unit);
-        sv = Quantity::convert(sv, "px", unit);
-    }
-
-    // do the action only if one of the scales/moves is greater than half the last significant
-    // digit in the spinbox (currently spinboxes have 3 fractional digits, so that makes 0.0005). If
-    // the value was changed by the user, the difference will be at least that much; otherwise it's
-    // just rounding difference between the spinbox value and actual value, so no action is
-    // performed
-    char const * const actionkey = ( mh > 5e-4 ? "selector:toolbar:move:horizontal" :
-                                     sh > 5e-4 ? "selector:toolbar:scale:horizontal" :
-                                     mv > 5e-4 ? "selector:toolbar:move:vertical" :
-                                     sv > 5e-4 ? "selector:toolbar:scale:vertical" : nullptr );
-
-    if (actionkey != nullptr) {
-
-        // FIXME: fix for GTK breakage, see comment in SelectedStyle::on_opacity_changed
-        desktop->getCanvas()->forceFullRedrawAfterInterruptions(0);
-
-        bool transform_stroke = prefs->getBool("/options/transform/stroke", true);
-        bool preserve = prefs->getBool("/options/preservetransform/value", false);
-
-        Geom::Affine scaler;
-        if (bbox_type == SPItem::VISUAL_BBOX) {
-            scaler = get_scale_transform_for_variable_stroke (*bbox_vis, *bbox_geom, transform_stroke, preserve, x0, y0, x1, y1);
-        } else {
-            // 1) We could have use the newer get_scale_transform_for_variable_stroke() here, but to avoid regressions
-            // we'll just use the old get_scale_transform_for_uniform_stroke() for now.
-            // 2) get_scale_transform_for_uniform_stroke() is intended for visual bounding boxes, not geometrical ones!
-            // we'll trick it into using a geometric bounding box though, by setting the stroke width to zero
-            scaler = get_scale_transform_for_uniform_stroke (*bbox_geom, 0, 0, false, false, x0, y0, x1, y1);
-        }
-
-        selection->applyAffine(scaler);
-        DocumentUndo::maybeDone(document, actionkey, SP_VERB_CONTEXT_SELECT,
-                                _("Transform by toolbar"));
-
-        // resume interruptibility
-        desktop->getCanvas()->endForcedFullRedraws();
-    }
-
-    g_object_set_data(tbl, "update", GINT_TO_POINTER(FALSE));
-}
 
 // toggle button callbacks and updaters
 
@@ -330,15 +117,6 @@ static void toggle_lock( GtkToggleAction *act, gpointer /*data*/ ) {
     }
 }
 
-static void destroy_tracker( GObject* obj, gpointer /*user_data*/ )
-{
-    UnitTracker *tracker = reinterpret_cast<UnitTracker*>(g_object_get_data(obj, "tracker"));
-    if ( tracker ) {
-        delete tracker;
-        g_object_set_data( obj, "tracker", nullptr );
-    }
-}
-
 static void trigger_sp_action( GtkAction* /*act*/, gpointer user_data )
 {
     SPAction* targetAction = SP_ACTION(user_data);
@@ -360,70 +138,78 @@ static GtkAction* create_action_for_verb( Inkscape::Verb* verb, Inkscape::UI::Vi
     return act;
 }
 
-void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
+namespace Inkscape {
+namespace UI {
+namespace Toolbar {
+
+SelectToolbar::SelectToolbar(SPDesktop *desktop) :
+    Toolbar(desktop),
+    _context_actions(new std::vector<GtkAction*>()),
+    _tracker(new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR)),
+    _update(false)
+{}
+
+SelectToolbar::~SelectToolbar()
+{
+    delete _tracker;
+}
+
+GtkWidget *
+SelectToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
 {
+    auto holder = new SelectToolbar(desktop);
+
     Inkscape::UI::View::View *view = desktop;
     GtkIconSize secondarySize = Inkscape::UI::ToolboxFactory::prefToSize("/toolbox/secondary", 1);
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
     GtkAction* act = nullptr;
 
-    GtkActionGroup* selectionActions = mainActions; // temporary
-    std::vector<GtkAction*>* contextActions = new std::vector<GtkAction*>();
+    holder->_selection_actions = mainActions; // temporary
 
     act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_EDIT_SELECT_ALL), view, secondarySize );
-    gtk_action_group_add_action( selectionActions, act );
+    gtk_action_group_add_action( holder->_selection_actions, act );
     act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_EDIT_SELECT_ALL_IN_ALL_LAYERS), view, secondarySize );
-    gtk_action_group_add_action( selectionActions, act );
+    gtk_action_group_add_action( holder->_selection_actions, act );
     act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_EDIT_DESELECT), view, secondarySize );
-    gtk_action_group_add_action( selectionActions, act );
-    contextActions->push_back( act );
+    gtk_action_group_add_action( holder->_selection_actions, act );
+    holder->_context_actions->push_back( act );
 
     act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_OBJECT_ROTATE_90_CCW), view, secondarySize );
-    gtk_action_group_add_action( selectionActions, act );
-    contextActions->push_back( act );
+    gtk_action_group_add_action( holder->_selection_actions, act );
+    holder->_context_actions->push_back( act );
     act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_OBJECT_ROTATE_90_CW), view, secondarySize );
-    gtk_action_group_add_action( selectionActions, act );
-    contextActions->push_back( act );
+    gtk_action_group_add_action( holder->_selection_actions, act );
+    holder->_context_actions->push_back( act );
     act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_OBJECT_FLIP_HORIZONTAL), view, secondarySize );
-    gtk_action_group_add_action( selectionActions, act );
-    contextActions->push_back( act );
+    gtk_action_group_add_action( holder->_selection_actions, act );
+    holder->_context_actions->push_back( act );
     act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_OBJECT_FLIP_VERTICAL), view, secondarySize );
-    gtk_action_group_add_action( selectionActions, act );
-    contextActions->push_back( act );
+    gtk_action_group_add_action( holder->_selection_actions, act );
+    holder->_context_actions->push_back( act );
 
     act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_SELECTION_TO_BACK), view, secondarySize );
-    gtk_action_group_add_action( selectionActions, act );
-    contextActions->push_back( act );
+    gtk_action_group_add_action( holder->_selection_actions, act );
+    holder->_context_actions->push_back( act );
     act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_SELECTION_LOWER), view, secondarySize );
-    gtk_action_group_add_action( selectionActions, act );
-    contextActions->push_back( act );
+    gtk_action_group_add_action( holder->_selection_actions, act );
+    holder->_context_actions->push_back( act );
     act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_SELECTION_RAISE), view, secondarySize );
-    gtk_action_group_add_action( selectionActions, act );
-    contextActions->push_back( act );
+    gtk_action_group_add_action( holder->_selection_actions, act );
+    holder->_context_actions->push_back( act );
     act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_SELECTION_TO_FRONT), view, secondarySize );
-    gtk_action_group_add_action( selectionActions, act );
-    contextActions->push_back( act );
+    gtk_action_group_add_action( holder->_selection_actions, act );
+    holder->_context_actions->push_back( act );
 
     // Create the parent widget for x y w h tracker.
-    GtkWidget *spw = sp_widget_new_global();
-
-    // Remember the desktop's canvas widget, to be used for defocusing.
-    g_object_set_data(G_OBJECT(spw), "dtw", desktop->getCanvas());
-
     // The vb frame holds all other widgets and is used to set sensitivity depending on selection state.
     auto vb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
     gtk_box_set_homogeneous(GTK_BOX(vb), FALSE);
     gtk_widget_show(vb);
-    gtk_container_add(GTK_CONTAINER(spw), vb);
 
     // Create the units menu.
-    UnitTracker* tracker = new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR);
-    tracker->addUnit(unit_table.getUnit("%"));
-    tracker->setActiveUnit( desktop->getNamedView()->display_units );
-
-    g_object_set_data( G_OBJECT(spw), "tracker", tracker );
-    g_signal_connect( G_OBJECT(spw), "destroy", G_CALLBACK(destroy_tracker), spw );
+    holder->_tracker->addUnit(unit_table.getUnit("%"));
+    holder->_tracker->setActiveUnit( desktop->getNamedView()->display_units );
 
     EgeAdjustmentAction* eact = nullptr;
 
@@ -437,16 +223,18 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb
             "/tools/select/X",                    /* path */ 
             0.0,                                  /* def(default) */ 
             GTK_WIDGET(desktop->canvas),          /* focusTarget */ 
-            G_OBJECT(spw),                        /* dataKludge */ 
+            nullptr,                              /* dataKludge */
             TRUE, "altx",                         /* altx, altx_mark */ 
             -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP, /* lower, upper, step, page */ 
-            nullptr, nullptr, 0,                              /* descrLabels, descrValues, descrCount */ 
-            sp_object_layout_any_value_changed,   /* callback */ 
-            tracker,                              /* unit_tracker */ 
+            nullptr, nullptr, 0,                  /* descrLabels, descrValues, descrCount */
+            nullptr,                              /* callback */
+            holder->_tracker,                     /* unit_tracker */
             SPIN_STEP, 3, 1);                     /* climb, digits, factor */
 
-    gtk_action_group_add_action( selectionActions, GTK_ACTION(eact) );
-    contextActions->push_back( GTK_ACTION(eact) );
+    holder->_adj_x = Glib::wrap(GTK_ADJUSTMENT(ege_adjustment_action_get_adjustment(eact)));
+    holder->_adj_x->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &SelectToolbar::any_value_changed), holder->_adj_x));
+    gtk_action_group_add_action( holder->_selection_actions, GTK_ACTION(eact) );
+    holder->_context_actions->push_back( GTK_ACTION(eact) );
 
     eact = create_adjustment_action(
             "YAction",                            /* name */
@@ -456,16 +244,18 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb
             "/tools/select/Y",                    /* path */
             0.0,                                  /* def(default) */
             GTK_WIDGET(desktop->canvas),          /* focusTarget */
-            G_OBJECT(spw),                        /* dataKludge */
+            nullptr,                              /* dataKludge */
             TRUE, "altx",                         /* altx, altx_mark */
             -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP, /* lower, upper, step, page */
             nullptr, nullptr, 0,                              /* descrLabels, descrValues, descrCount */
-            sp_object_layout_any_value_changed,   /* callback */
-            tracker,                              /* unit_tracker */
+            nullptr,                              /* callback */
+            holder->_tracker,                     /* unit_tracker */
             SPIN_STEP, 3, 1);                     /* climb, digits, factor */              
 
-    gtk_action_group_add_action( selectionActions, GTK_ACTION(eact) );
-    contextActions->push_back( GTK_ACTION(eact) );
+    holder->_adj_y = Glib::wrap(GTK_ADJUSTMENT(ege_adjustment_action_get_adjustment(eact)));
+    holder->_adj_y->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &SelectToolbar::any_value_changed), holder->_adj_y));
+    gtk_action_group_add_action( holder->_selection_actions, GTK_ACTION(eact) );
+    holder->_context_actions->push_back( GTK_ACTION(eact) );
 
     eact = create_adjustment_action(
             "WidthAction",                        /* name */
@@ -475,28 +265,29 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb
             "/tools/select/width",                /* path */                      
             0.0,                                  /* def(default) */
             GTK_WIDGET(desktop->canvas),          /* focusTarget */
-            G_OBJECT(spw),                        /* dataKludge */
+            nullptr,                              /* dataKludge */
             TRUE, "altx",                         /* altx, altx_mark */
             0.0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,  /* lower, upper, step, page */
             nullptr, nullptr, 0,                              /* descrLabels, descrValues, descrCount */
-            sp_object_layout_any_value_changed,   /* callback */
-            tracker,                              /* unit_tracker */
+            nullptr,                              /* callback */
+            holder->_tracker,                     /* unit_tracker */
             SPIN_STEP, 3, 1);                     /* climb, digits, factor */
 
-    gtk_action_group_add_action( selectionActions, GTK_ACTION(eact) );
-    contextActions->push_back( GTK_ACTION(eact) );
+    holder->_adj_w = Glib::wrap(GTK_ADJUSTMENT(ege_adjustment_action_get_adjustment(eact)));
+    holder->_adj_w->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &SelectToolbar::any_value_changed), holder->_adj_w));
+    gtk_action_group_add_action( holder->_selection_actions, GTK_ACTION(eact) );
+    holder->_context_actions->push_back( GTK_ACTION(eact) );
 
     // lock toggle
     {
-    InkToggleAction* itact = ink_toggle_action_new( "LockAction",
-                                                    _("Lock width and height"),
-                                                    _("When locked, change both width and height by the same proportion"),
-                                                    INKSCAPE_ICON("object-unlocked"),
-                                                    GTK_ICON_SIZE_MENU );
-    g_object_set( itact, "short_label", "Lock", NULL );
-    g_object_set_data( G_OBJECT(spw), "lock", itact );
-    g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(toggle_lock), desktop) ;
-    gtk_action_group_add_action( mainActions, GTK_ACTION(itact) );
+    holder->_lock = GTK_TOGGLE_ACTION(ink_toggle_action_new( "LockAction",
+                                                            _("Lock width and height"),
+                                                            _("When locked, change both width and height by the same proportion"),
+                                                            INKSCAPE_ICON("object-unlocked"),
+                                                            GTK_ICON_SIZE_MENU ));
+    gtk_action_set_short_label( GTK_ACTION(holder->_lock), "Lock" );
+    g_signal_connect_after( G_OBJECT(holder->_lock), "toggled", G_CALLBACK(toggle_lock), desktop) ;
+    gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_lock) );
     }
 
     eact = create_adjustment_action(
@@ -507,50 +298,44 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb
             "/tools/select/height",               /* path */                      
             0.0,                                  /* def(default) */
             GTK_WIDGET(desktop->canvas),          /* focusTarget */
-            G_OBJECT(spw),                        /* dataKludge */
+            nullptr,                              /* dataKludge */
             TRUE, "altx",                         /* altx, altx_mark */
             0.0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,  /* lower, upper, step, page */
             nullptr, nullptr, 0,                              /* descrLabels, descrValues, descrCount */
-            sp_object_layout_any_value_changed,   /* callback */
-            tracker,                              /* unit_tracker */
+            nullptr,                              /* callback */
+            holder->_tracker,                     /* unit_tracker */
             SPIN_STEP, 3, 1);                     /* climb, digits, factor */
 
 
-    gtk_action_group_add_action( selectionActions, GTK_ACTION(eact) );
-    contextActions->push_back( GTK_ACTION(eact) );
+    holder->_adj_h = Glib::wrap(GTK_ADJUSTMENT(ege_adjustment_action_get_adjustment(eact)));
+    holder->_adj_h->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &SelectToolbar::any_value_changed), holder->_adj_h));
+    gtk_action_group_add_action( holder->_selection_actions, GTK_ACTION(eact) );
+    holder->_context_actions->push_back( GTK_ACTION(eact) );
 
     // Add the units menu.
     {
-        InkSelectOneAction* act = tracker->createAction( "UnitsAction", _("Units"), ("") );
-        gtk_action_group_add_action( selectionActions, act->gobj() );
+        InkSelectOneAction* act = holder->_tracker->createAction( "UnitsAction", _("Units"), ("") );
+        gtk_action_group_add_action( holder->_selection_actions, act->gobj() );
     }
 
-    g_object_set_data( G_OBJECT(spw), "selectionActions", selectionActions );
-    g_object_set_data( G_OBJECT(spw), "contextActions", contextActions );
-
     // Force update when selection changes.
-    g_signal_connect(G_OBJECT(spw), "modify_selection", G_CALLBACK(sp_selection_layout_widget_modify_selection), desktop);
-    g_signal_connect(G_OBJECT(spw), "change_selection", G_CALLBACK(sp_selection_layout_widget_change_selection), desktop);
+    INKSCAPE.signal_selection_modified.connect(sigc::mem_fun(*holder, &SelectToolbar::on_inkscape_selection_modified));
+    INKSCAPE.signal_selection_changed.connect(sigc::mem_fun(*holder, &SelectToolbar::on_inkscape_selection_changed));
 
     // Update now.
-    sp_selection_layout_widget_update(SP_WIDGET(spw), SP_ACTIVE_DESKTOP ? SP_ACTIVE_DESKTOP->getSelection() : nullptr);
+    holder->layout_widget_update(SP_ACTIVE_DESKTOP ? SP_ACTIVE_DESKTOP->getSelection() : nullptr);
 
-    for (auto & contextAction : *contextActions) {
+    for (auto & contextAction : *holder->_context_actions) {
         if ( gtk_action_is_sensitive(contextAction) ) {
             gtk_action_set_sensitive( contextAction, FALSE );
         }
     }
 
-    // Insert spw into the toolbar.
-    if ( GTK_IS_BOX(holder) ) {
-        gtk_box_pack_start(GTK_BOX(holder), spw, FALSE, FALSE, 0);
-    } else if ( GTK_IS_TOOLBAR(holder) ) {
-	GtkToolItem *spw_toolitem = gtk_tool_item_new();
-	gtk_container_add(GTK_CONTAINER(spw_toolitem), spw);
-	gtk_toolbar_insert(GTK_TOOLBAR(holder), spw_toolitem, -1);
-    } else {
-        g_warning("Unexpected holder type");
-    }
+    // Insert vb into the toolbar.
+    GtkToolItem *vb_toolitem = gtk_tool_item_new();
+    gtk_container_add(GTK_CONTAINER(vb_toolitem), vb);
+    holder->insert(*Glib::wrap(vb_toolitem), -1);
+
     // "Transform with object" buttons
     {
 
@@ -596,8 +381,218 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb
     g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(toggle_pattern), desktop) ;
     gtk_action_group_add_action( mainActions, GTK_ACTION(itact) );
     }
+
+    return GTK_WIDGET(holder->gobj());
 }
 
+void
+SelectToolbar::any_value_changed(Glib::RefPtr<Gtk::Adjustment>& adj)
+{
+    if (_update) {
+        return;
+    }
+
+    if ( !_tracker || _tracker->isUpdating() ) {
+        /*
+         * When only units are being changed, don't treat changes
+         * to adjuster values as object changes.
+         */
+        return;
+    }
+    _update = true;
+
+    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+    Inkscape::Selection *selection = desktop->getSelection();
+    SPDocument *document = desktop->getDocument();
+
+    document->ensureUpToDate ();
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+    Geom::OptRect bbox_vis = selection->visualBounds();
+    Geom::OptRect bbox_geom = selection->geometricBounds();
+
+    int prefs_bbox = prefs->getInt("/tools/bounding_box");
+    SPItem::BBoxType bbox_type = (prefs_bbox == 0)?
+        SPItem::VISUAL_BBOX : SPItem::GEOMETRIC_BBOX;
+    Geom::OptRect bbox_user = selection->bounds(bbox_type);
+
+    if ( !bbox_user ) {
+        _update = false;
+        return;
+    }
+
+    gdouble x0 = 0;
+    gdouble y0 = 0;
+    gdouble x1 = 0;
+    gdouble y1 = 0;
+    gdouble xrel = 0;
+    gdouble yrel = 0;
+    Unit const *unit = _tracker->getActiveUnit();
+    g_return_if_fail(unit != nullptr);
+
+    if (unit->type == Inkscape::Util::UNIT_TYPE_LINEAR) {
+        x0 = Quantity::convert(_adj_x->get_value(), unit, "px");
+        y0 = Quantity::convert(_adj_y->get_value(), unit, "px");
+        x1 = x0 + Quantity::convert(_adj_w->get_value(), unit, "px");
+        xrel = Quantity::convert(_adj_w->get_value(), unit, "px") / bbox_user->dimensions()[Geom::X];
+        y1 = y0 + Quantity::convert(_adj_h->get_value(), unit, "px");;
+        yrel = Quantity::convert(_adj_h->get_value(), unit, "px") / bbox_user->dimensions()[Geom::Y];
+    } else {
+        double const x0_propn = _adj_x->get_value() / 100 / unit->factor;
+        x0 = bbox_user->min()[Geom::X] * x0_propn;
+        double const y0_propn = _adj_y->get_value() / 100 / unit->factor;
+        y0 = y0_propn * bbox_user->min()[Geom::Y];
+        xrel = _adj_w->get_value() / (100 / unit->factor);
+        x1 = x0 + xrel * bbox_user->dimensions()[Geom::X];
+        yrel = _adj_h->get_value() / (100 / unit->factor);
+        y1 = y0 + yrel * bbox_user->dimensions()[Geom::Y];
+    }
+
+    // Keep proportions if lock is on
+    if ( gtk_toggle_action_get_active(_lock) ) {
+        if (adj == _adj_h) {
+            x1 = x0 + yrel * bbox_user->dimensions()[Geom::X];
+        } else if (adj == _adj_w) {
+            y1 = y0 + xrel * bbox_user->dimensions()[Geom::Y];
+        }
+    }
+
+    // scales and moves, in px
+    double mh = fabs(x0 - bbox_user->min()[Geom::X]);
+    double sh = fabs(x1 - bbox_user->max()[Geom::X]);
+    double mv = fabs(y0 - bbox_user->min()[Geom::Y]);
+    double sv = fabs(y1 - bbox_user->max()[Geom::Y]);
+
+    // unless the unit is %, convert the scales and moves to the unit
+    if (unit->type == Inkscape::Util::UNIT_TYPE_LINEAR) {
+        mh = Quantity::convert(mh, "px", unit);
+        sh = Quantity::convert(sh, "px", unit);
+        mv = Quantity::convert(mv, "px", unit);
+        sv = Quantity::convert(sv, "px", unit);
+    }
+
+    // do the action only if one of the scales/moves is greater than half the last significant
+    // digit in the spinbox (currently spinboxes have 3 fractional digits, so that makes 0.0005). If
+    // the value was changed by the user, the difference will be at least that much; otherwise it's
+    // just rounding difference between the spinbox value and actual value, so no action is
+    // performed
+    char const * const actionkey = ( mh > 5e-4 ? "selector:toolbar:move:horizontal" :
+                                     sh > 5e-4 ? "selector:toolbar:scale:horizontal" :
+                                     mv > 5e-4 ? "selector:toolbar:move:vertical" :
+                                     sv > 5e-4 ? "selector:toolbar:scale:vertical" : nullptr );
+
+    if (actionkey != nullptr) {
+
+        // FIXME: fix for GTK breakage, see comment in SelectedStyle::on_opacity_changed
+        desktop->getCanvas()->forceFullRedrawAfterInterruptions(0);
+
+        bool transform_stroke = prefs->getBool("/options/transform/stroke", true);
+        bool preserve = prefs->getBool("/options/preservetransform/value", false);
+
+        Geom::Affine scaler;
+        if (bbox_type == SPItem::VISUAL_BBOX) {
+            scaler = get_scale_transform_for_variable_stroke (*bbox_vis, *bbox_geom, transform_stroke, preserve, x0, y0, x1, y1);
+        } else {
+            // 1) We could have use the newer get_scale_transform_for_variable_stroke() here, but to avoid regressions
+            // we'll just use the old get_scale_transform_for_uniform_stroke() for now.
+            // 2) get_scale_transform_for_uniform_stroke() is intended for visual bounding boxes, not geometrical ones!
+            // we'll trick it into using a geometric bounding box though, by setting the stroke width to zero
+            scaler = get_scale_transform_for_uniform_stroke (*bbox_geom, 0, 0, false, false, x0, y0, x1, y1);
+        }
+
+        selection->applyAffine(scaler);
+        DocumentUndo::maybeDone(document, actionkey, SP_VERB_CONTEXT_SELECT,
+                                _("Transform by toolbar"));
+
+        // resume interruptibility
+        desktop->getCanvas()->endForcedFullRedraws();
+    }
+
+    _update = false;
+}
+
+void
+SelectToolbar::layout_widget_update(Inkscape::Selection *sel)
+{
+    if (_update) {
+        return;
+    }
+
+    _update = true;
+
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    using Geom::X;
+    using Geom::Y;
+    if ( sel && !sel->isEmpty() ) {
+        int prefs_bbox = prefs->getInt("/tools/bounding_box", 0);
+        SPItem::BBoxType bbox_type = (prefs_bbox ==0)?
+            SPItem::VISUAL_BBOX : SPItem::GEOMETRIC_BBOX;
+        Geom::OptRect const bbox(sel->bounds(bbox_type));
+        if ( bbox ) {
+            Unit const *unit = _tracker->getActiveUnit();
+            g_return_if_fail(unit != nullptr);
+
+            struct { char const *key; double val; } const keyval[] = {
+                { "X", bbox->min()[X] },
+                { "Y", bbox->min()[Y] },
+                { "width", bbox->dimensions()[X] },
+                { "height", bbox->dimensions()[Y] }
+            };
+
+            if (unit->type == Inkscape::Util::UNIT_TYPE_DIMENSIONLESS) {
+                double const val = unit->factor * 100;
+                _adj_x->set_value(val);
+                _adj_y->set_value(val);
+                _adj_w->set_value(val);
+                _adj_h->set_value(val);
+                _tracker->setFullVal( _adj_x->gobj(), keyval[0].val );
+                _tracker->setFullVal( _adj_y->gobj(), keyval[1].val );
+                _tracker->setFullVal( _adj_w->gobj(), keyval[2].val );
+                _tracker->setFullVal( _adj_h->gobj(), keyval[3].val );
+            } else {
+                _adj_x->set_value(Quantity::convert(keyval[0].val, "px", unit));
+                _adj_y->set_value(Quantity::convert(keyval[1].val, "px", unit));
+                _adj_w->set_value(Quantity::convert(keyval[2].val, "px", unit));
+                _adj_h->set_value(Quantity::convert(keyval[3].val, "px", unit));
+            }
+        }
+    }
+
+    _update = false;
+}
+
+void
+SelectToolbar::on_inkscape_selection_modified(Inkscape::Selection *selection, guint flags)
+{
+    if ((_desktop->getSelection() == selection) // only respond to changes in our desktop
+        && (flags & (SP_OBJECT_MODIFIED_FLAG        |
+                     SP_OBJECT_PARENT_MODIFIED_FLAG |
+                     SP_OBJECT_CHILD_MODIFIED_FLAG   )))
+    {
+        layout_widget_update(selection);
+    }
+}
+
+void
+SelectToolbar::on_inkscape_selection_changed(Inkscape::Selection *selection)
+{
+    if (_desktop->getSelection() == selection) { // only respond to changes in our desktop
+        gboolean setActive = (selection && !selection->isEmpty());
+        if ( _context_actions ) {
+            for (auto & contextAction : *_context_actions) {
+                if ( setActive != gtk_action_is_sensitive(contextAction) ) {
+                    gtk_action_set_sensitive( contextAction, setActive );
+                }
+            }
+        }
+
+        layout_widget_update(selection);
+    }
+}
+
+}
+}
+}
 
 /*
   Local Variables:
diff --git a/src/ui/toolbar/select-toolbar.h b/src/ui/toolbar/select-toolbar.h
index d4862600e..1ad4a628d 100644
--- a/src/ui/toolbar/select-toolbar.h
+++ b/src/ui/toolbar/select-toolbar.h
@@ -15,14 +15,54 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "toolbar.h"
+
 class SPDesktop;
 
 typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _GObject GObject;
 
-void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
+namespace Inkscape {
+class Selection;
+
+namespace UI {
+
+namespace Widget {
+class UnitTracker;
+}
+
+namespace Toolbar {
+
+class SelectToolbar : public Toolbar {
+private:
+    UI::Widget::UnitTracker *_tracker;
+
+    Glib::RefPtr<Gtk::Adjustment>  _adj_x;
+    Glib::RefPtr<Gtk::Adjustment>  _adj_y;
+    Glib::RefPtr<Gtk::Adjustment>  _adj_w;
+    Glib::RefPtr<Gtk::Adjustment>  _adj_h;
+    GtkToggleAction               *_lock;
+
+    GtkActionGroup *_selection_actions;
+    std::vector<GtkAction *> *_context_actions;
+
+    bool _update;
+
+    void any_value_changed(Glib::RefPtr<Gtk::Adjustment>& adj);
+    void layout_widget_update(Inkscape::Selection *sel);
+    void on_inkscape_selection_modified(Inkscape::Selection *selection, guint flags);
+    void on_inkscape_selection_changed(Inkscape::Selection *selection);
+
+protected:
+    SelectToolbar(SPDesktop *desktop);
+    ~SelectToolbar();
 
+public:
+    static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions);
+};
 
+}
+}
+}
 #endif /* !SEEN_SELECT_TOOLBAR_H */
 
 /*
diff --git a/src/ui/toolbar/spiral-toolbar.cpp b/src/ui/toolbar/spiral-toolbar.cpp
index 289dbfee6..acdf82b3b 100644
--- a/src/ui/toolbar/spiral-toolbar.cpp
+++ b/src/ui/toolbar/spiral-toolbar.cpp
@@ -53,38 +53,151 @@ using Inkscape::DocumentUndo;
 using Inkscape::UI::ToolboxFactory;
 using Inkscape::UI::PrefPusher;
 
-//########################
-//##       Spiral       ##
-//########################
+static Inkscape::XML::NodeEventVector spiral_tb_repr_events = {
+    nullptr, /* child_added */
+    nullptr, /* child_removed */
+    Inkscape::UI::Toolbar::SpiralToolbar::event_attr_changed,
+    nullptr, /* content_changed */
+    nullptr  /* order_changed */
+};
+
+namespace Inkscape {
+namespace UI {
+namespace Toolbar {
+SpiralToolbar::~SpiralToolbar()
+{
+    if(_repr) {
+        _repr->removeListenerByData(this);
+        GC::release(_repr);
+        _repr = nullptr;
+    }
+
+    if(_connection) {
+        _connection->disconnect();
+        delete _connection;
+    }
+}
 
-static void sp_spl_tb_value_changed(GtkAdjustment *adj, GObject *tbl, Glib::ustring const &value_name)
+GtkWidget *
+SpiralToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
 {
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( tbl, "desktop" ));
+    auto toolbar = new SpiralToolbar(desktop);
+
+    EgeAdjustmentAction* eact = nullptr;
+    GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
+
+    {
+        toolbar->_mode_action = ege_output_action_new( "SpiralStateAction", _("<b>New:</b>"), "", nullptr );
+        ege_output_action_set_use_markup( toolbar->_mode_action, TRUE );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_mode_action ) );
+    }
+
+    /* Revolution */
+    {
+        gchar const* labels[] = {_("just a curve"), nullptr, _("one full revolution"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
+        gdouble values[] = {0.01, 0.5, 1, 2, 3, 5, 10, 20, 50, 100};
+        eact = create_adjustment_action( "SpiralRevolutionAction",
+                                         _("Number of turns"), _("Turns:"), _("Number of revolutions"),
+                                         "/tools/shapes/spiral/revolution", 3.0,
+                                         GTK_WIDGET(desktop->canvas),
+                                         nullptr, // dataKludge
+                                         TRUE, "altx-spiral",
+                                         0.01, 1024.0, 0.1, 1.0,
+                                         labels, values, G_N_ELEMENTS(labels),
+                                         nullptr, // callback
+                                         nullptr /*unit tracker*/, 1, 2);
+        toolbar->_revolution_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        toolbar->_revolution_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*toolbar, &SpiralToolbar::value_changed),
+                                                                            toolbar->_revolution_adj, "revolution"));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+    }
+
+    /* Expansion */
+    {
+        gchar const* labels[] = {_("circle"), _("edge is much denser"), _("edge is denser"), _("even"), _("center is denser"), _("center is much denser"), nullptr};
+        gdouble values[] = {0, 0.1, 0.5, 1, 1.5, 5, 20};
+        eact = create_adjustment_action( "SpiralExpansionAction",
+                                         _("Divergence"), _("Divergence:"), _("How much denser/sparser are outer revolutions; 1 = uniform"),
+                                         "/tools/shapes/spiral/expansion", 1.0,
+                                         GTK_WIDGET(desktop->canvas),
+                                         nullptr, // dataKludge
+                                         FALSE, nullptr,
+                                         0.0, 1000.0, 0.01, 1.0,
+                                         labels, values, G_N_ELEMENTS(labels),
+                                         nullptr // dataKludge
+                                         );
+        toolbar->_expansion_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        toolbar->_expansion_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*toolbar, &SpiralToolbar::value_changed),
+                                                                           toolbar->_expansion_adj, "expansion"));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+    }
 
-    if (DocumentUndo::getUndoSensitive(desktop->getDocument())) {
+    /* T0 */
+    {
+        gchar const* labels[] = {_("starts from center"), _("starts mid-way"), _("starts near edge")};
+        gdouble values[] = {0, 0.5, 0.9};
+        eact = create_adjustment_action( "SpiralT0Action",
+                                         _("Inner radius"), _("Inner radius:"), _("Radius of the innermost revolution (relative to the spiral size)"),
+                                         "/tools/shapes/spiral/t0", 0.0,
+                                         GTK_WIDGET(desktop->canvas),
+                                         nullptr, // dataKludge
+                                         FALSE, nullptr,
+                                         0.0, 0.999, 0.01, 1.0,
+                                         labels, values, G_N_ELEMENTS(labels),
+                                         nullptr // callback
+                                         );
+        toolbar->_t0_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        toolbar->_t0_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*toolbar, &SpiralToolbar::value_changed),
+                                                                    toolbar->_t0_adj, "t0"));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+    }
+
+    /* Reset */
+    {
+        InkAction* inky = ink_action_new( "SpiralResetAction",
+                                          _("Defaults"),
+                                          _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
+                                          INKSCAPE_ICON("edit-clear"),
+                                          secondarySize );
+        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(&SpiralToolbar::defaults), toolbar );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
+    }
+
+
+    toolbar->_connection = new sigc::connection(
+        desktop->getSelection()->connectChanged(sigc::mem_fun(*toolbar, &SpiralToolbar::selection_changed)));
+
+    return GTK_WIDGET(toolbar->gobj());
+}
+
+void
+SpiralToolbar::value_changed(Glib::RefPtr<Gtk::Adjustment> &adj,
+                             Glib::ustring const           &value_name)
+{
+    if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
         prefs->setDouble("/tools/shapes/spiral/" + value_name,
-            gtk_adjustment_get_value(adj));
+            adj->get_value());
     }
 
     // quit if run by the attr_changed listener
-    if (g_object_get_data( tbl, "freeze" )) {
+    if (_freeze) {
         return;
     }
 
     // in turn, prevent listener from responding
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+    _freeze = true;
 
     gchar* namespaced_name = g_strconcat("sodipodi:", value_name.data(), NULL);
 
     bool modmade = false;
-    auto itemlist= desktop->getSelection()->items();
+    auto itemlist= _desktop->getSelection()->items();
     for(auto i=itemlist.begin();i!=itemlist.end(); ++i){
         SPItem *item = *i;
         if (SP_IS_SPIRAL(item)) {
             Inkscape::XML::Node *repr = item->getRepr();
             sp_repr_set_svg_double( repr, namespaced_name,
-                gtk_adjustment_get_value(adj) );
+                adj->get_value() );
             item->updateRepr();
             modmade = true;
         }
@@ -93,112 +206,47 @@ static void sp_spl_tb_value_changed(GtkAdjustment *adj, GObject *tbl, Glib::ustr
     g_free(namespaced_name);
 
     if (modmade) {
-        DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_SPIRAL,
+        DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_SPIRAL,
                            _("Change spiral"));
     }
 
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-static void sp_spl_tb_revolution_value_changed(GtkAdjustment *adj, GObject *tbl)
+void
+SpiralToolbar::defaults(GtkWidget * /*widget*/, GObject *obj)
 {
-    sp_spl_tb_value_changed(adj, tbl, "revolution");
-}
-
-static void sp_spl_tb_expansion_value_changed(GtkAdjustment *adj, GObject *tbl)
-{
-    sp_spl_tb_value_changed(adj, tbl, "expansion");
-}
-
-static void sp_spl_tb_t0_value_changed(GtkAdjustment *adj, GObject *tbl)
-{
-    sp_spl_tb_value_changed(adj, tbl, "t0");
-}
-
-static void sp_spl_tb_defaults(GtkWidget * /*widget*/, GObject *obj)
-{
-    GtkWidget *tbl = GTK_WIDGET(obj);
-
-    GtkAdjustment *adj;
+    auto toolbar = reinterpret_cast<SpiralToolbar *>(obj);
 
     // fixme: make settable
     gdouble rev = 3;
     gdouble exp = 1.0;
     gdouble t0 = 0.0;
 
-    adj = GTK_ADJUSTMENT(g_object_get_data(obj, "revolution"));
-    gtk_adjustment_set_value(adj, rev);
-
-#if !GTK_CHECK_VERSION(3,18,0)
-    gtk_adjustment_value_changed(adj);
-#endif
-
-    adj = GTK_ADJUSTMENT(g_object_get_data(obj, "expansion"));
-    gtk_adjustment_set_value(adj, exp);
-    gtk_adjustment_value_changed(adj);
-
-    adj = GTK_ADJUSTMENT(g_object_get_data(obj, "t0"));
-    gtk_adjustment_set_value(adj, t0);
+    toolbar->_revolution_adj->set_value(rev);
+    toolbar->_expansion_adj->set_value(exp);
+    toolbar->_t0_adj->set_value(t0);
 
 #if !GTK_CHECK_VERSION(3,18,0)
-    gtk_adjustment_value_changed(adj);
+    toolbar->_revolution_adj->value_changed();
+    toolbar->_expansion_adj->value_changed();
+    toolbar->_t0_adj->value_changed();
 #endif
 
-    spinbutton_defocus(tbl);
+    if(toolbar->_desktop->canvas) gtk_widget_grab_focus(GTK_WIDGET(toolbar->_desktop->canvas));
 }
 
-
-static void spiral_tb_event_attr_changed(Inkscape::XML::Node *repr,
-                                         gchar const * /*name*/,
-                                         gchar const * /*old_value*/,
-                                         gchar const * /*new_value*/,
-                                         bool /*is_interactive*/,
-                                         gpointer data)
-{
-    GtkWidget *tbl = GTK_WIDGET(data);
-
-    // quit if run by the _changed callbacks
-    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
-        return;
-    }
-
-    // in turn, prevent callbacks from responding
-    g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE));
-
-    GtkAdjustment *adj;
-    adj = GTK_ADJUSTMENT(g_object_get_data(G_OBJECT(tbl), "revolution"));
-    double revolution = 3.0;
-    sp_repr_get_double(repr, "sodipodi:revolution", &revolution);
-    gtk_adjustment_set_value(adj, revolution);
-
-    adj = GTK_ADJUSTMENT(g_object_get_data(G_OBJECT(tbl), "expansion"));
-    double expansion = 1.0;
-    sp_repr_get_double(repr, "sodipodi:expansion", &expansion);
-    gtk_adjustment_set_value(adj, expansion);
-
-    adj = GTK_ADJUSTMENT(g_object_get_data(G_OBJECT(tbl), "t0"));
-    double t0 = 0.0;
-    sp_repr_get_double(repr, "sodipodi:t0", &t0);
-    gtk_adjustment_set_value(adj, t0);
-
-    g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
-}
-
-
-static Inkscape::XML::NodeEventVector spiral_tb_repr_events = {
-    nullptr, /* child_added */
-    nullptr, /* child_removed */
-    spiral_tb_event_attr_changed,
-    nullptr, /* content_changed */
-    nullptr  /* order_changed */
-};
-
-static void sp_spiral_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
+void
+SpiralToolbar::selection_changed(Inkscape::Selection *selection)
 {
     int n_selected = 0;
     Inkscape::XML::Node *repr = nullptr;
 
-    purge_repr_listener( tbl, tbl );
+    if ( _repr ) {
+        _repr->removeListenerByData(this);
+        GC::release(_repr);
+        _repr = nullptr;
+    }
 
     auto itemlist= selection->items();
     for(auto i=itemlist.begin();i!=itemlist.end(); ++i){
@@ -209,100 +257,60 @@ static void sp_spiral_toolbox_selection_changed(Inkscape::Selection *selection,
         }
     }
 
-    EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) );
-
     if (n_selected == 0) {
-        g_object_set( G_OBJECT(act), "label", _("<b>New:</b>"), NULL );
+        gtk_action_set_label(GTK_ACTION(_mode_action), _("<b>New:</b>"));
     } else if (n_selected == 1) {
-        g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
+        gtk_action_set_label(GTK_ACTION(_mode_action), _("<b>Change:</b>"));
 
         if (repr) {
-            g_object_set_data( tbl, "repr", repr );
-            Inkscape::GC::anchor(repr);
-            sp_repr_add_listener(repr, &spiral_tb_repr_events, tbl);
-            sp_repr_synthesize_events(repr, &spiral_tb_repr_events, tbl);
+            _repr = repr;
+            Inkscape::GC::anchor(_repr);
+            _repr->addListener(&spiral_tb_repr_events, this);
+            _repr->synthesizeEvents(&spiral_tb_repr_events, this);
         }
     } else {
         // FIXME: implement averaging of all parameters for multiple selected
         //gtk_label_set_markup(GTK_LABEL(l), _("<b>Average:</b>"));
-        g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
+        gtk_action_set_label(GTK_ACTION(_mode_action), _("<b>Change:</b>"));
     }
 }
 
-
-void sp_spiral_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
+void
+SpiralToolbar::event_attr_changed(Inkscape::XML::Node *repr,
+                                  gchar const * /*name*/,
+                                  gchar const * /*old_value*/,
+                                  gchar const * /*new_value*/,
+                                  bool /*is_interactive*/,
+                                  gpointer data)
 {
-    EgeAdjustmentAction* eact = nullptr;
-    GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
-
-    {
-        EgeOutputAction* act = ege_output_action_new( "SpiralStateAction", _("<b>New:</b>"), "", nullptr );
-        ege_output_action_set_use_markup( act, TRUE );
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        g_object_set_data( holder, "mode_action", act );
-    }
+    auto toolbar = reinterpret_cast<SpiralToolbar *>(data);
 
-    /* Revolution */
-    {
-        gchar const* labels[] = {_("just a curve"), nullptr, _("one full revolution"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
-        gdouble values[] = {0.01, 0.5, 1, 2, 3, 5, 10, 20, 50, 100};
-        eact = create_adjustment_action( "SpiralRevolutionAction",
-                                         _("Number of turns"), _("Turns:"), _("Number of revolutions"),
-                                         "/tools/shapes/spiral/revolution", 3.0,
-                                         GTK_WIDGET(desktop->canvas), holder, TRUE, "altx-spiral",
-                                         0.01, 1024.0, 0.1, 1.0,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         sp_spl_tb_revolution_value_changed, nullptr /*unit tracker*/, 1, 2);
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+    // quit if run by the _changed callbacks
+    if (toolbar->_freeze) {
+        return;
     }
 
-    /* Expansion */
-    {
-        gchar const* labels[] = {_("circle"), _("edge is much denser"), _("edge is denser"), _("even"), _("center is denser"), _("center is much denser"), nullptr};
-        gdouble values[] = {0, 0.1, 0.5, 1, 1.5, 5, 20};
-        eact = create_adjustment_action( "SpiralExpansionAction",
-                                         _("Divergence"), _("Divergence:"), _("How much denser/sparser are outer revolutions; 1 = uniform"),
-                                         "/tools/shapes/spiral/expansion", 1.0,
-                                         GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
-                                         0.0, 1000.0, 0.01, 1.0,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         sp_spl_tb_expansion_value_changed);
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-    }
+    // in turn, prevent callbacks from responding
+    toolbar->_freeze = true;
 
-    /* T0 */
-    {
-        gchar const* labels[] = {_("starts from center"), _("starts mid-way"), _("starts near edge")};
-        gdouble values[] = {0, 0.5, 0.9};
-        eact = create_adjustment_action( "SpiralT0Action",
-                                         _("Inner radius"), _("Inner radius:"), _("Radius of the innermost revolution (relative to the spiral size)"),
-                                         "/tools/shapes/spiral/t0", 0.0,
-                                         GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
-                                         0.0, 0.999, 0.01, 1.0,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         sp_spl_tb_t0_value_changed);
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-    }
+    double revolution = 3.0;
+    sp_repr_get_double(repr, "sodipodi:revolution", &revolution);
+    toolbar->_revolution_adj->set_value(revolution);
 
-    /* Reset */
-    {
-        InkAction* inky = ink_action_new( "SpiralResetAction",
-                                          _("Defaults"),
-                                          _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
-                                          INKSCAPE_ICON("edit-clear"),
-                                          secondarySize );
-        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_spl_tb_defaults), holder );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
-    }
+    double expansion = 1.0;
+    sp_repr_get_double(repr, "sodipodi:expansion", &expansion);
+    toolbar->_expansion_adj->set_value(expansion);
 
+    double t0 = 0.0;
+    sp_repr_get_double(repr, "sodipodi:t0", &t0);
+    toolbar->_t0_adj->set_value(t0);
 
-    sigc::connection *connection = new sigc::connection(
-        desktop->getSelection()->connectChanged(sigc::bind(sigc::ptr_fun(sp_spiral_toolbox_selection_changed), holder))
-        );
-    g_signal_connect( holder, "destroy", G_CALLBACK(delete_connection), connection );
-    g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );
+    toolbar->_freeze = false;
 }
 
+}
+}
+}
 
 /*
   Local Variables:
diff --git a/src/ui/toolbar/spiral-toolbar.h b/src/ui/toolbar/spiral-toolbar.h
index d57b4fa09..cec8ddae4 100644
--- a/src/ui/toolbar/spiral-toolbar.h
+++ b/src/ui/toolbar/spiral-toolbar.h
@@ -28,11 +28,65 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "toolbar.h"
+
+#include <gtkmm/adjustment.h>
+
 class SPDesktop;
 
+typedef struct _EgeOutputAction EgeOutputAction;
 typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _GObject GObject;
 
-void       sp_spiral_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
+namespace Inkscape {
+class Selection;
+
+namespace XML {
+class Node;
+}
+
+namespace UI {
+namespace Toolbar {
+class SpiralToolbar : public Toolbar {
+private:
+    EgeOutputAction *_mode_action;
+
+    Glib::RefPtr<Gtk::Adjustment> _revolution_adj;
+    Glib::RefPtr<Gtk::Adjustment> _expansion_adj;
+    Glib::RefPtr<Gtk::Adjustment> _t0_adj;
+
+    bool _freeze;
+
+    XML::Node *_repr;
+
+    void value_changed(Glib::RefPtr<Gtk::Adjustment> &adj,
+                       Glib::ustring const           &value_name);
+    static void defaults(GtkWidget *widget,
+                         GObject   *obj);
+    void selection_changed(Inkscape::Selection *selection);
+
+    sigc::connection *_connection;
+
+protected:
+    SpiralToolbar(SPDesktop *desktop) :
+        Toolbar(desktop),
+        _freeze(false),
+        _repr(nullptr)
+    {}
+
+    ~SpiralToolbar();
+
+public:
+    static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions);
+
+    static void event_attr_changed(Inkscape::XML::Node *repr,
+                                   gchar const         *name,
+                                   gchar const         *old_value,
+                                   gchar const         *new_value,
+                                   bool                 is_interactive,
+                                   gpointer             data);
+};
+}
+}
+}
 
 #endif /* !SEEN_SPIRAL_TOOLBAR_H */
diff --git a/src/ui/toolbar/spray-toolbar.cpp b/src/ui/toolbar/spray-toolbar.cpp
index a8bfabac9..c0c945ffe 100644
--- a/src/ui/toolbar/spray-toolbar.cpp
+++ b/src/ui/toolbar/spray-toolbar.cpp
@@ -26,9 +26,9 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
-#include <gtkmm.h>
-
 #include "spray-toolbar.h"
+
+
 #include "desktop.h"
 #include "inkscape.h"
 #include "widgets/ege-adjustment-action.h"
@@ -54,75 +54,6 @@ using Inkscape::UI::PrefPusher;
 //##       Spray        ##
 //########################
 
-static void sp_stb_update_widgets( GObject *tbl )
-{
-    GtkAction* offset = GTK_ACTION( g_object_get_data(tbl, "offset") );
-    GtkAction* spray_scale = GTK_ACTION( g_object_get_data(tbl, "spray_scale") );
-    GtkAdjustment *adj_offset = ege_adjustment_action_get_adjustment( EGE_ADJUSTMENT_ACTION(offset) );
-    GtkAdjustment *adj_scale = ege_adjustment_action_get_adjustment( EGE_ADJUSTMENT_ACTION(spray_scale) );
-    GtkAction *no_overlap_action = GTK_ACTION( g_object_get_data(tbl, "no_overlap") );
-    GtkToggleAction *no_overlap = GTK_TOGGLE_ACTION( g_object_get_data(tbl, "no_overlap") );
-    GtkAction *picker_action = GTK_ACTION( g_object_get_data(tbl, "picker") );
-    GtkToggleAction *picker = GTK_TOGGLE_ACTION( g_object_get_data(tbl, "picker") );
-    GtkToggleAction *usepressurescale = GTK_TOGGLE_ACTION( g_object_get_data(tbl, "usepressurescale") );
-    GtkAction *pick_fill = GTK_ACTION( g_object_get_data(tbl, "pick_fill") );
-    GtkAction *pick_stroke = GTK_ACTION( g_object_get_data(tbl, "pick_stroke") );
-    GtkAction *pick_inverse_value = GTK_ACTION( g_object_get_data(tbl, "pick_inverse_value") );
-    GtkAction *pick_center = GTK_ACTION( g_object_get_data(tbl, "pick_center") );
-    gtk_adjustment_set_value( adj_offset, 100.0 );
-    if (gtk_toggle_action_get_active(no_overlap) && gtk_action_get_visible(no_overlap_action)) {
-        gtk_action_set_visible( offset, true );
-    } else {
-        gtk_action_set_visible( offset, false );
-    }
-    if (gtk_toggle_action_get_active(usepressurescale)) {
-        gtk_adjustment_set_value( adj_scale, 0.0 );
-        gtk_action_set_sensitive( spray_scale, false );
-    } else {
-        gtk_action_set_sensitive( spray_scale, true );
-    }
-    if(gtk_toggle_action_get_active(picker) && gtk_action_get_visible(picker_action)){
-        gtk_action_set_visible( pick_fill, true );
-        gtk_action_set_visible( pick_stroke, true );
-        gtk_action_set_visible( pick_inverse_value, true );
-        gtk_action_set_visible( pick_center, true );
-    } else {
-        gtk_action_set_visible( pick_fill, false );
-        gtk_action_set_visible( pick_stroke, false );
-        gtk_action_set_visible( pick_inverse_value, false );
-        gtk_action_set_visible( pick_center, false );
-    }
-}
-
-static void sp_spray_init( GObject *tbl){
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    int mode = prefs->getInt("/tools/spray/mode", 0);
-
-    bool show = true;
-    if(mode == 3 || mode == 2){
-        show = false;
-    }
-    gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "no_overlap") ), show );
-    gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "over_no_transparent") ), show );
-    gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "over_transparent") ), show );
-    gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "pick_no_overlap") ), show );
-    gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "pick_stroke") ), show );
-    gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "pick_fill") ), show );
-    gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "pick_inverse_value") ), show );
-    gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "pick_center") ), show );
-    gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "picker") ), show );
-    gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "offset") ), show );
-    gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "pick_fill") ), show );
-    gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "pick_stroke") ), show );
-    gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "pick_inverse_value") ), show );
-    gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "pick_center") ), show );
-    if(mode == 2){
-        show = true;
-    }
-    gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "spray_rotation") ), show );
-    sp_stb_update_widgets( tbl );
-}
-
 Inkscape::UI::Dialog::CloneTiler *get_clone_tiler_panel(SPDesktop *desktop)
 {
     if (Inkscape::UI::Dialog::PanelDialogBase *panel_dialog =
@@ -137,152 +68,21 @@ Inkscape::UI::Dialog::CloneTiler *get_clone_tiler_panel(SPDesktop *desktop)
     return nullptr;
 }
 
-static void sp_spray_width_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/spray/width",
-            gtk_adjustment_get_value(adj));
-}
-
-static void sp_spray_mean_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/spray/mean",
-            gtk_adjustment_get_value(adj));
-}
-
-static void sp_spray_standard_deviation_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/spray/standard_deviation",
-            gtk_adjustment_get_value(adj));
-}
-
-static void sp_spray_mode_changed( GObject *tbl, int mode )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setInt("/tools/spray/mode", mode);
-    sp_spray_init(tbl);
-}
-
-static void sp_spray_population_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/spray/population",
-            gtk_adjustment_get_value(adj));
-}
 
-static void sp_spray_rotation_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
+namespace Inkscape {
+namespace UI {
+namespace Toolbar {
+SprayToolbar::~SprayToolbar()
 {
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/spray/rotation_variation",
-            gtk_adjustment_get_value(adj));
+    delete _usepressurewidth_pusher;
+    delete _usepressurepopulation_pusher;
 }
 
-static void sp_spray_scale_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
+GtkWidget *
+SprayToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
 {
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/spray/scale_variation",
-            gtk_adjustment_get_value(adj));
-}
+    auto holder = new SprayToolbar(desktop);
 
-static void sp_spray_offset_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/spray/offset",
-            gtk_adjustment_get_value(adj));
-}
-
-static void sp_toggle_no_overlap( GtkToggleAction* act, gpointer data)
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    gboolean active = gtk_toggle_action_get_active(act);
-    prefs->setBool("/tools/spray/no_overlap", active);
-    GObject *tbl = G_OBJECT(data);
-    sp_stb_update_widgets(tbl);
-}
-
-static void sp_toggle_pressure_scale( GtkToggleAction* act, gpointer data)
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    gboolean active = gtk_toggle_action_get_active(act);
-    prefs->setBool("/tools/spray/usepressurescale", active);
-    if(active){
-        prefs->setDouble("/tools/spray/scale_variation", 0);
-    }
-    GObject *tbl = G_OBJECT(data);
-    sp_stb_update_widgets( tbl );
-}
-
-static void sp_toggle_over_no_transparent( GtkToggleAction* act, gpointer data)
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    gboolean active = gtk_toggle_action_get_active(act);
-    prefs->setBool("/tools/spray/over_no_transparent", active);
-}
-
-static void sp_toggle_over_transparent( GtkToggleAction* act, gpointer data)
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    gboolean active = gtk_toggle_action_get_active(act);
-    prefs->setBool("/tools/spray/over_transparent", active);
-}
-
-
-static void sp_toggle_picker( GtkToggleAction* act, gpointer data )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    gboolean active = gtk_toggle_action_get_active(act);
-    prefs->setBool("/tools/spray/picker", active);
-    if(active){
-        prefs->setBool("/dialogs/clonetiler/dotrace", false);
-        SPDesktop *dt = SP_ACTIVE_DESKTOP;
-        if (Inkscape::UI::Dialog::CloneTiler *ct = get_clone_tiler_panel(dt)){
-            dt->_dlg_mgr->showDialog("CloneTiler");
-            ct->show_page_trace();
-        }
-    }
-    GObject *tbl = G_OBJECT(data);
-    sp_stb_update_widgets(tbl);
-}
-
-static void sp_toggle_pick_center( GtkToggleAction* act, gpointer data )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    gboolean active = gtk_toggle_action_get_active(act);
-    prefs->setBool("/tools/spray/pick_center", active);
-}
-
-static void sp_toggle_pick_fill( GtkToggleAction* act, gpointer data )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    gboolean active = gtk_toggle_action_get_active(act);
-    prefs->setBool("/tools/spray/pick_fill", active);
-}
-
-static void sp_toggle_pick_stroke( GtkToggleAction* act, gpointer data )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    gboolean active = gtk_toggle_action_get_active(act);
-    prefs->setBool("/tools/spray/pick_stroke", active);
-}
-
-static void sp_toggle_pick_no_overlap( GtkToggleAction* act, gpointer data )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    gboolean active = gtk_toggle_action_get_active(act);
-    prefs->setBool("/tools/spray/pick_no_overlap", active);
-}
-
-static void sp_toggle_pick_inverse_value( GtkToggleAction* act, gpointer data )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    gboolean active = gtk_toggle_action_get_active(act);
-    prefs->setBool("/tools/spray/pick_inverse_value", active);
-}
-
-void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
-{
     GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     {
@@ -292,10 +92,15 @@ void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj
         EgeAdjustmentAction *eact = create_adjustment_action( "SprayWidthAction",
                                                               _("Width"), _("Width:"), _("The width of the spray area (relative to the visible canvas area)"),
                                                               "/tools/spray/width", 15,
-                                                              GTK_WIDGET(desktop->canvas), holder, true, "altx-spray",
+                                                              GTK_WIDGET(desktop->canvas),
+                                                              nullptr, // dataKludge
+                                                              true, "altx-spray",
                                                               1, 100, 1.0, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
-                                                              sp_spray_width_value_changed, nullptr /*unit tracker*/, 1, 0 );
+                                                              nullptr, // callback
+                                                              nullptr /*unit tracker*/, 1, 0 );
+        holder->_width_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        holder->_width_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &SprayToolbar::width_value_changed));
         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 );
@@ -309,9 +114,7 @@ void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj
                                                       INKSCAPE_ICON("draw-use-pressure"),
                                                       GTK_ICON_SIZE_MENU );
         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
-        PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/spray/usepressurewidth");
-        g_signal_connect(holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
-
+        holder->_usepressurewidth_pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/spray/usepressurewidth");
     }
     
     {
@@ -321,10 +124,15 @@ void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj
         EgeAdjustmentAction *eact = create_adjustment_action( "SprayMeanAction",
                                                               _("Focus"), _("Focus:"), _("0 to spray a spot; increase to enlarge the ring radius"),
                                                               "/tools/spray/mean", 0,
-                                                              GTK_WIDGET(desktop->canvas), holder, true, "spray-mean",
+                                                              GTK_WIDGET(desktop->canvas),
+                                                              nullptr, // dataKludge
+                                                              true, "spray-mean",
                                                               0, 100, 1.0, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
-                                                              sp_spray_mean_value_changed, nullptr /*unit tracker*/, 1, 0 );
+                                                              nullptr, // callback
+                                                              nullptr /*unit tracker*/, 1, 0 );
+        holder->_mean_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        holder->_mean_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &SprayToolbar::mean_value_changed));
         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 );
@@ -337,10 +145,15 @@ void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj
         EgeAdjustmentAction *eact = create_adjustment_action( "SprayStandard_deviationAction",
                                                               C_("Spray tool", "Scatter"), C_("Spray tool", "Scatter:"), _("Increase to scatter sprayed objects"),
                                                               "/tools/spray/standard_deviation", 70,
-                                                              GTK_WIDGET(desktop->canvas), holder, true, "spray-standard_deviation",
+                                                              GTK_WIDGET(desktop->canvas),
+                                                              nullptr, // dataKludge
+                                                              true, "spray-standard_deviation",
                                                               1, 100, 1.0, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
-                                                              sp_spray_standard_deviation_value_changed, nullptr /*unit tracker*/, 1, 0 );
+                                                              nullptr, // callback
+                                                              nullptr /*unit tracker*/, 1, 0 );
+        holder->_sd_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        holder->_sd_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &SprayToolbar::standard_deviation_value_changed));
         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 );
@@ -380,39 +193,40 @@ void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj
         row[columns.col_icon     ] = INKSCAPE_ICON("draw-eraser");
         row[columns.col_sensitive] = true;
 
-        InkSelectOneAction* act =
+        holder->_spray_tool_mode =
             InkSelectOneAction::create( "SprayModeAction",   // Name
                                         _("Mode"),           // Label
                                         "",                  // Tooltip
                                         "Not Used",          // Icon
                                         store );             // Tree store
 
-        act->use_radio( true );
-        act->use_group_label( true );
+        holder->_spray_tool_mode->use_radio( true );
+        holder->_spray_tool_mode->use_group_label( true );
         gint mode = prefs->getInt("/tools/spray/mode", 1);
-        act->set_active( mode );
-
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data( holder, "spray_tool_mode", act );
-
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_spray_mode_changed), holder));
+        holder->_spray_tool_mode->set_active( mode );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_spray_tool_mode->gobj() ));
+        holder->_spray_tool_mode->signal_changed().connect(sigc::mem_fun(*holder, &SprayToolbar::mode_changed));
     }
 
     {   /* Population */
         gchar const* labels[] = {_("(low population)"), nullptr, nullptr, nullptr, _("(default)"), nullptr, _("(high population)")};
         gdouble values[] = {5, 20, 35, 50, 70, 85, 100};
-        EgeAdjustmentAction *eact = create_adjustment_action( "SprayPopulationAction",
+        holder->_spray_population = create_adjustment_action( "SprayPopulationAction",
                                                               _("Amount"), _("Amount:"),
                                                               _("Adjusts the number of items sprayed per click"),
                                                               "/tools/spray/population", 70,
-                                                              GTK_WIDGET(desktop->canvas), holder, true, "spray-population",
+                                                              GTK_WIDGET(desktop->canvas),
+                                                              nullptr, // dataKludge
+                                                              true, "spray-population",
                                                               1, 100, 1.0, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
-                                                              sp_spray_population_value_changed, nullptr /*unit tracker*/, 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 );
+                                                              nullptr, // callback
+                                                              nullptr /*unit tracker*/, 1, 0 );
+        holder->_population_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_spray_population));
+        holder->_population_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &SprayToolbar::population_value_changed));
+        ege_adjustment_action_set_appearance( holder->_spray_population, TOOLBAR_SLIDER_HINT );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_spray_population) );
+        gtk_action_set_sensitive( GTK_ACTION(holder->_spray_population), true );
     }
 
     /* Use Pressure Population button */
@@ -423,196 +237,433 @@ void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj
                                                       INKSCAPE_ICON("draw-use-pressure"),
                                                       GTK_ICON_SIZE_MENU );
         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
-        PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/spray/usepressurepopulation");
-        g_signal_connect(holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
-
+        holder->_usepressurepopulation_pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/spray/usepressurepopulation");
     }
 
     {   /* Rotation */
         gchar const* labels[] = {_("(default)"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, _("(high rotation variation)")};
         gdouble values[] = {0, 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), holder, true, "spray-rotation",
-                                                              0, 100, 1.0, 10.0,
-                                                              labels, values, G_N_ELEMENTS(labels),
-                                                              sp_spray_rotation_value_changed, nullptr /*unit tracker*/, 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 );
+        holder->_spray_rotation = 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),
+                                                            nullptr, // dataKludge
+                                                            true, "spray-rotation",
+                                                            0, 100, 1.0, 10.0,
+                                                            labels, values, G_N_ELEMENTS(labels),
+                                                            nullptr, // callback
+                                                            nullptr /*unit tracker*/, 1, 0 );
+        holder->_rotation_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_spray_rotation));
+        holder->_rotation_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &SprayToolbar::rotation_value_changed));
+        ege_adjustment_action_set_appearance(holder->_spray_rotation, TOOLBAR_SLIDER_HINT );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_spray_rotation) );
+        gtk_action_set_sensitive( GTK_ACTION(holder->_spray_rotation), true );
     }
 
     {   /* Scale */
         gchar const* labels[] = {_("(default)"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, _("(high scale variation)")};
         gdouble values[] = {0, 10, 25, 35, 50, 60, 80, 100};
-        EgeAdjustmentAction *eact = create_adjustment_action( "SprayScaleAction",
+        holder->_spray_scale = create_adjustment_action( "SprayScaleAction",
                                                               C_("Spray tool", "Scale"), C_("Spray tool", "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), holder, true, "spray-scale",
+                                                              GTK_WIDGET(desktop->canvas),
+                                                              nullptr, // dataKludge
+                                                              true, "spray-scale",
                                                               0, 100, 1.0, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
-                                                              sp_spray_scale_value_changed, nullptr /*unit tracker*/, 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 );
+                                                              nullptr, // callback
+                                                              nullptr /*unit tracker*/, 1, 0 );
+        holder->_scale_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_spray_scale));
+        holder->_scale_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &SprayToolbar::scale_value_changed));
+        ege_adjustment_action_set_appearance( holder->_spray_scale, TOOLBAR_SLIDER_HINT );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_spray_scale) );
+        gtk_action_set_sensitive( GTK_ACTION(holder->_spray_scale), true );
     }
 
     /* Use Pressure Scale button */
     {
-        InkToggleAction* act = ink_toggle_action_new( "SprayPressureScaleAction",
-                                                      _("Pressure"),
-                                                      _("Use the pressure of the input device to alter the scale of new items"),
-                                                      INKSCAPE_ICON("draw-use-pressure"),
-                                                      GTK_ICON_SIZE_MENU);
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/usepressurescale", false) );
-        g_object_set_data( holder, "usepressurescale", act );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_pressure_scale), holder) ;
-        gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
+        holder->_usepressurescale = ink_toggle_action_new( "SprayPressureScaleAction",
+                                                           _("Pressure"),
+                                                           _("Use the pressure of the input device to alter the scale of new items"),
+                                                           INKSCAPE_ICON("draw-use-pressure"),
+                                                           GTK_ICON_SIZE_MENU);
+        gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(holder->_usepressurescale), prefs->getBool("/tools/spray/usepressurescale", false));
+        g_signal_connect(G_OBJECT(holder->_usepressurescale), "toggled", G_CALLBACK(&SprayToolbar::toggle_pressure_scale), holder);
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_usepressurescale) );
     }
 
     /* Picker */
     {
-        InkToggleAction* act = ink_toggle_action_new( "SprayPickColorAction",
+        holder->_picker = ink_toggle_action_new( "SprayPickColorAction",
                                                       _("Pick color from the drawing. You can use clonetiler trace dialog for advanced effects. In clone mode original fill or stroke colors must be unset."),
                                                       _("Pick color from the drawing. You can use clonetiler trace dialog for advanced effects. In clone mode original fill or stroke colors must be unset."),
                                                       INKSCAPE_ICON("color-picker"),
                                                       secondarySize );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/picker", false) );
-        g_object_set_data( holder, "picker", act );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_picker), holder) ;
-        gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_picker), prefs->getBool("/tools/spray/picker", false) );
+        g_signal_connect(G_OBJECT(holder->_picker), "toggled", G_CALLBACK(&SprayToolbar::toggle_picker), holder);
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_picker) );
     }
     
     /* Pick from center */
     {
-        InkToggleAction* act = ink_toggle_action_new( "SprayPickCenterAction",
+        holder->_pick_center = ink_toggle_action_new( "SprayPickCenterAction",
                                                       _("Pick from center instead average area."),
                                                       _("Pick from center instead average area."),
                                                       INKSCAPE_ICON("snap-bounding-box-center"),
                                                       secondarySize );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/pick_center", true) );
-        g_object_set_data( holder, "pick_center", act );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_pick_center), holder) ;
-        gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_pick_center), prefs->getBool("/tools/spray/pick_center", true) );
+        g_signal_connect(G_OBJECT(holder->_pick_center), "toggled", G_CALLBACK(&SprayToolbar::toggle_pick_center), holder);
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_pick_center) );
     }
 
     /* Inverse Value Size */
     {
-        InkToggleAction* act = ink_toggle_action_new( "SprayPickInverseValueAction",
+        holder->_pick_inverse_value = ink_toggle_action_new( "SprayPickInverseValueAction",
                                                       _("Inverted pick value, retaining color in advanced trace mode"),
                                                       _("Inverted pick value, retaining color in advanced trace mode"),
                                                       INKSCAPE_ICON("object-tweak-shrink"),
                                                       secondarySize );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/pick_inverse_value", false) );
-        g_object_set_data( holder, "pick_inverse_value", act );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_pick_inverse_value), holder) ;
-        gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_pick_inverse_value), prefs->getBool("/tools/spray/pick_inverse_value", false) );
+        g_signal_connect(G_OBJECT(holder->_pick_inverse_value), "toggled", G_CALLBACK(&SprayToolbar::toggle_pick_inverse_value), holder);
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_pick_inverse_value) );
     }
 
     /* Pick Fill */
     {
-        InkToggleAction* act = ink_toggle_action_new( "SprayPickFillAction",
+        holder->_pick_fill = ink_toggle_action_new( "SprayPickFillAction",
                                                       _("Apply picked color to fill"),
                                                       _("Apply picked color to fill"),
                                                       INKSCAPE_ICON("paint-solid"),
                                                       secondarySize );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/pick_fill", false) );
-        g_object_set_data( holder, "pick_fill", act );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_pick_fill), holder) ;
-        gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_pick_fill), prefs->getBool("/tools/spray/pick_fill", false) );
+        g_signal_connect(G_OBJECT(holder->_pick_fill), "toggled", G_CALLBACK(&SprayToolbar::toggle_pick_fill), holder);
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_pick_fill) );
     }
 
     /* Pick Stroke */
     {
-        InkToggleAction* act = ink_toggle_action_new( "SprayPickStrokeAction",
+        holder->_pick_stroke = ink_toggle_action_new( "SprayPickStrokeAction",
                                                       _("Apply picked color to stroke"),
                                                       _("Apply picked color to stroke"),
                                                       INKSCAPE_ICON("no-marker"),
                                                       secondarySize );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/pick_stroke", false) );
-        g_object_set_data( holder, "pick_stroke", act );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_pick_stroke), holder) ;
-        gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_pick_stroke), prefs->getBool("/tools/spray/pick_stroke", false) );
+        g_signal_connect(G_OBJECT(holder->_pick_stroke), "toggled", G_CALLBACK(&SprayToolbar::toggle_pick_stroke), holder);
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_pick_stroke) );
     }
 
     /* Pick No Overlap */
     {
-        InkToggleAction* act = ink_toggle_action_new( "SprayPickNoOverlapAction",
+        holder->_pick_no_overlap = ink_toggle_action_new( "SprayPickNoOverlapAction",
                                                       _("No overlap between colors"),
                                                       _("No overlap between colors"),
                                                       INKSCAPE_ICON("symbol-bigger"),
                                                       secondarySize );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/pick_no_overlap", false) );
-        g_object_set_data( holder, "pick_no_overlap", act );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_pick_no_overlap), holder) ;
-        gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_pick_no_overlap), prefs->getBool("/tools/spray/pick_no_overlap", false) );
+        g_signal_connect(G_OBJECT(holder->_pick_no_overlap), "toggled", G_CALLBACK(&SprayToolbar::toggle_pick_no_overlap), holder);
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_pick_no_overlap) );
     }
 
     /* Over Transparent */
     {
-        InkToggleAction* act = ink_toggle_action_new( "SprayOverTransparentAction",
+        holder->_over_transparent = ink_toggle_action_new( "SprayOverTransparentAction",
                                                       _("Apply over transparent areas"),
                                                       _("Apply over transparent areas"),
                                                       INKSCAPE_ICON("object-hidden"),
                                                       secondarySize );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/over_transparent", true) );
-        g_object_set_data( holder, "over_transparent", act );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_over_transparent), holder) ;
-        gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_over_transparent), prefs->getBool("/tools/spray/over_transparent", true) );
+        g_signal_connect(G_OBJECT(holder->_over_transparent), "toggled", G_CALLBACK(&SprayToolbar::toggle_over_transparent), holder);
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_over_transparent) );
     }
 
     /* Over No Transparent */
     {
-        InkToggleAction* act = ink_toggle_action_new( "SprayOverNoTransparentAction",
+        holder->_over_no_transparent = ink_toggle_action_new( "SprayOverNoTransparentAction",
                                                       _("Apply over no transparent areas"),
                                                       _("Apply over no transparent areas"),
                                                       INKSCAPE_ICON("object-visible"),
                                                       secondarySize );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/over_no_transparent", true) );
-        g_object_set_data( holder, "over_no_transparent", act );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_over_no_transparent), holder) ;
-        gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_over_no_transparent), prefs->getBool("/tools/spray/over_no_transparent", true) );
+        g_signal_connect(G_OBJECT(holder->_over_no_transparent), "toggled", G_CALLBACK(&SprayToolbar::toggle_over_no_transparent), holder);
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_over_no_transparent) );
     }
 
     /* Overlap */
     {
-        InkToggleAction* act = ink_toggle_action_new( "SprayNoOverlapAction",
+        holder->_no_overlap = ink_toggle_action_new( "SprayNoOverlapAction",
                                                       _("Prevent overlapping objects"),
                                                       _("Prevent overlapping objects"),
                                                       INKSCAPE_ICON("distribute-randomize"),
                                                       secondarySize );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/no_overlap", false) );
-        g_object_set_data( holder, "no_overlap", act );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_no_overlap), holder) ;
-        gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_no_overlap), prefs->getBool("/tools/spray/no_overlap", false) );
+        g_signal_connect(G_OBJECT(holder->_no_overlap), "toggled", G_CALLBACK(&SprayToolbar::toggle_no_overlap), holder);
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_no_overlap) );
     }
     
     /* Offset */
     {
         gchar const* labels[] = {_("(minimum offset)"), nullptr, nullptr, nullptr, _("(default)"), nullptr, nullptr, _("(maximum offset)")};
         gdouble values[] = {0, 25, 50, 75, 100, 150, 200, 1000};
-        EgeAdjustmentAction *eact = create_adjustment_action( "SprayToolOffsetAction",
+        holder->_offset = create_adjustment_action( "SprayToolOffsetAction",
                                          _("Offset %"), _("Offset %:"),
                                          _("Increase to segregate objects more (value in percent)"),
                                          "/tools/spray/offset", 100,
-                                         GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr,
+                                         GTK_WIDGET(desktop->canvas),
+                                         nullptr, // dataKludge
+                                         FALSE, nullptr,
                                          0, 1000, 1, 4,
                                          labels, values, G_N_ELEMENTS(labels),
-                                         sp_spray_offset_value_changed, nullptr, 0 , 0);
-        g_object_set_data( holder, "offset", eact );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+                                         nullptr, // callback
+                                         nullptr, 0 , 0);
+        holder->_offset_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_offset));
+        holder->_offset_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &SprayToolbar::offset_value_changed));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_offset) );
+    }
+    holder->init();
+
+    return GTK_WIDGET(holder->gobj());
+}
+
+void
+SprayToolbar::width_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/spray/width",
+            _width_adj->get_value());
+}
+
+void
+SprayToolbar::mean_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/spray/mean",
+            _mean_adj->get_value());
+}
+
+void
+SprayToolbar::standard_deviation_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/spray/standard_deviation",
+            _sd_adj->get_value());
+}
+
+void
+SprayToolbar::mode_changed(int mode)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setInt("/tools/spray/mode", mode);
+    init();
+}
+
+void
+SprayToolbar::init(){
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    int mode = prefs->getInt("/tools/spray/mode", 0);
+
+    bool show = true;
+    if(mode == 3 || mode == 2){
+        show = false;
+    }
+    gtk_action_set_visible( GTK_ACTION(_no_overlap), show );
+    gtk_action_set_visible( GTK_ACTION(_over_no_transparent), show );
+    gtk_action_set_visible( GTK_ACTION(_over_transparent), show );
+    gtk_action_set_visible( GTK_ACTION(_pick_no_overlap), show );
+    gtk_action_set_visible( GTK_ACTION(_pick_stroke), show );
+    gtk_action_set_visible( GTK_ACTION(_pick_fill), show );
+    gtk_action_set_visible( GTK_ACTION(_pick_inverse_value), show );
+    gtk_action_set_visible( GTK_ACTION(_pick_center), show );
+    gtk_action_set_visible( GTK_ACTION(_picker), show );
+    gtk_action_set_visible( GTK_ACTION(_offset), show );
+    gtk_action_set_visible( GTK_ACTION(_pick_fill), show );
+    gtk_action_set_visible( GTK_ACTION(_pick_stroke), show );
+    gtk_action_set_visible( GTK_ACTION(_pick_inverse_value), show );
+    gtk_action_set_visible( GTK_ACTION(_pick_center), show );
+    if(mode == 2){
+        show = true;
+    }
+    gtk_action_set_visible( GTK_ACTION(_spray_rotation), show );
+    update_widgets();
+}
+
+void
+SprayToolbar::population_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/spray/population",
+            _population_adj->get_value());
+}
+
+void
+SprayToolbar::rotation_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/spray/rotation_variation",
+            _rotation_adj->get_value());
+}
+
+void
+SprayToolbar::update_widgets()
+{
+    _offset_adj->set_value(100.0);
+
+    if (gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(_no_overlap)) &&
+        gtk_action_get_visible(GTK_ACTION(_no_overlap)))
+    {
+        gtk_action_set_visible( GTK_ACTION(_offset), true );
+    } else {
+        gtk_action_set_visible( GTK_ACTION(_offset), false );
+    }
+    if (gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(_usepressurescale))) {
+        _scale_adj->set_value(0.0);
+        gtk_action_set_sensitive( GTK_ACTION(_spray_scale), false );
+    } else {
+        gtk_action_set_sensitive( GTK_ACTION(_spray_scale), true );
+    }
+    if(gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(_picker)) &&
+       gtk_action_get_visible(GTK_ACTION(_picker))){
+        gtk_action_set_visible( GTK_ACTION(_pick_fill), true );
+        gtk_action_set_visible( GTK_ACTION(_pick_stroke), true );
+        gtk_action_set_visible( GTK_ACTION(_pick_inverse_value), true );
+        gtk_action_set_visible( GTK_ACTION(_pick_center), true );
+    } else {
+        gtk_action_set_visible( GTK_ACTION(_pick_fill), false );
+        gtk_action_set_visible( GTK_ACTION(_pick_stroke), false );
+        gtk_action_set_visible( GTK_ACTION(_pick_inverse_value), false );
+        gtk_action_set_visible( GTK_ACTION(_pick_center), false );
+    }
+}
+
+void
+SprayToolbar::toggle_no_overlap(GtkToggleAction *toggleaction,
+                                gpointer         user_data)
+{
+    auto toolbar = reinterpret_cast<SprayToolbar *>(user_data);
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gboolean active = gtk_toggle_action_get_active(toggleaction);
+    prefs->setBool("/tools/spray/no_overlap", active);
+    toolbar->update_widgets();
+}
+
+void
+SprayToolbar::scale_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/spray/scale_variation",
+            _scale_adj->get_value());
+}
+
+void
+SprayToolbar::offset_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/spray/offset",
+            _offset_adj->get_value());
+}
+
+void
+SprayToolbar::toggle_pressure_scale(GtkToggleAction *toggleaction,
+                                    gpointer         user_data)
+{
+    auto toolbar = reinterpret_cast<SprayToolbar *>(user_data);
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gboolean active = gtk_toggle_action_get_active(toggleaction);
+    prefs->setBool("/tools/spray/usepressurescale", active);
+    if(active){
+        prefs->setDouble("/tools/spray/scale_variation", 0);
     }
-    sp_spray_init(holder);
+    toolbar->update_widgets();
 }
 
+void
+SprayToolbar::toggle_over_no_transparent(GtkToggleAction *toggleaction,
+                                         gpointer         /* user_data */)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gboolean active = gtk_toggle_action_get_active(toggleaction);
+    prefs->setBool("/tools/spray/over_no_transparent", active);
+}
 
+void
+SprayToolbar::toggle_over_transparent(GtkToggleAction *toggleaction,
+                                      gpointer         /* user_data */)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gboolean active = gtk_toggle_action_get_active(toggleaction);
+    prefs->setBool("/tools/spray/over_transparent", active);
+}
+
+void
+SprayToolbar::toggle_picker(GtkToggleAction *toggleaction,
+                            gpointer         user_data)
+{
+    auto toolbar = reinterpret_cast<SprayToolbar *>(user_data);
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gboolean active = gtk_toggle_action_get_active(toggleaction);
+    prefs->setBool("/tools/spray/picker", active);
+    if(active){
+        prefs->setBool("/dialogs/clonetiler/dotrace", false);
+        SPDesktop *dt = SP_ACTIVE_DESKTOP;
+        if (Inkscape::UI::Dialog::CloneTiler *ct = get_clone_tiler_panel(dt)){
+            dt->_dlg_mgr->showDialog("CloneTiler");
+            ct->show_page_trace();
+        }
+    }
+    toolbar->update_widgets();
+}
+
+void
+SprayToolbar::toggle_pick_center(GtkToggleAction *toggleaction,
+                                 gpointer         /* user_data */)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gboolean active = gtk_toggle_action_get_active(toggleaction);
+    prefs->setBool("/tools/spray/pick_center", active);
+}
+
+void
+SprayToolbar::toggle_pick_fill(GtkToggleAction *toggleaction,
+                               gpointer         /* user_data */)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gboolean active = gtk_toggle_action_get_active(toggleaction);
+    prefs->setBool("/tools/spray/pick_fill", active);
+}
+
+void
+SprayToolbar::toggle_pick_stroke(GtkToggleAction *toggleaction,
+                                 gpointer         /* user_data */)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gboolean active = gtk_toggle_action_get_active(toggleaction);
+    prefs->setBool("/tools/spray/pick_stroke", active);
+}
+
+void
+SprayToolbar::toggle_pick_no_overlap(GtkToggleAction *toggleaction,
+                                     gpointer        /* user_data */)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gboolean active = gtk_toggle_action_get_active(toggleaction);
+    prefs->setBool("/tools/spray/pick_no_overlap", active);
+}
+
+void
+SprayToolbar::toggle_pick_inverse_value(GtkToggleAction *toggleaction,
+                                        gpointer         /* user_data */)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gboolean active = gtk_toggle_action_get_active(toggleaction);
+    prefs->setBool("/tools/spray/pick_inverse_value", active);
+}
+
+}
+}
+}
 
 /*
   Local Variables:
diff --git a/src/ui/toolbar/spray-toolbar.h b/src/ui/toolbar/spray-toolbar.h
index 9133575d1..af3ef8082 100644
--- a/src/ui/toolbar/spray-toolbar.h
+++ b/src/ui/toolbar/spray-toolbar.h
@@ -28,11 +28,94 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "toolbar.h"
+
+#include <gtkmm/adjustment.h>
+
+class InkSelectOneAction;
 class SPDesktop;
 
+typedef struct _EgeAdjustmentAction EgeAdjustmentAction;
 typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _GObject GObject;
+typedef struct _InkToggleAction InkToggleAction;
+
+namespace Inkscape {
+namespace UI {
+class PrefPusher;
+
+namespace Toolbar {
+class SprayToolbar : public Toolbar {
+private:
+    Glib::RefPtr<Gtk::Adjustment> _width_adj;
+    Glib::RefPtr<Gtk::Adjustment> _mean_adj;
+    Glib::RefPtr<Gtk::Adjustment> _sd_adj;
+    Glib::RefPtr<Gtk::Adjustment> _population_adj;
+    Glib::RefPtr<Gtk::Adjustment> _rotation_adj;
+    Glib::RefPtr<Gtk::Adjustment> _offset_adj;
+    Glib::RefPtr<Gtk::Adjustment> _scale_adj;
+
+    PrefPusher *_usepressurewidth_pusher;
+    PrefPusher *_usepressurepopulation_pusher;
+
+    InkSelectOneAction *_spray_tool_mode;
+    EgeAdjustmentAction *_spray_population;
+    EgeAdjustmentAction *_spray_rotation;
+    EgeAdjustmentAction *_spray_scale;
+    InkToggleAction * _usepressurescale;
+    InkToggleAction *_picker;
+    InkToggleAction *_pick_center;
+    InkToggleAction *_pick_inverse_value;
+    InkToggleAction *_pick_fill;
+    InkToggleAction *_pick_stroke;
+    InkToggleAction *_pick_no_overlap;
+    InkToggleAction *_over_transparent;
+    InkToggleAction *_over_no_transparent;
+    InkToggleAction *_no_overlap;
+    EgeAdjustmentAction *_offset;
+
+    void width_value_changed();
+    void mean_value_changed();
+    void standard_deviation_value_changed();
+    void mode_changed(int mode);
+    void init();
+    void population_value_changed();
+    void rotation_value_changed();
+    void update_widgets();
+    void scale_value_changed();
+    void offset_value_changed();
+    static void toggle_no_overlap         (GtkToggleAction *toggleaction,
+                                           gpointer         user_data);
+    static void toggle_pressure_scale     (GtkToggleAction *toggleaction,
+                                           gpointer         user_data);
+    static void toggle_over_no_transparent(GtkToggleAction *toggleaction,
+                                           gpointer         user_data);
+    static void toggle_over_transparent   (GtkToggleAction *toggleaction,
+                                           gpointer         user_data);
+    static void toggle_picker             (GtkToggleAction *toggleaction,
+                                           gpointer         user_data);
+    static void toggle_pick_center        (GtkToggleAction *toggleaction,
+                                           gpointer         user_data);
+    static void toggle_pick_fill          (GtkToggleAction *toggleaction,
+                                           gpointer         user_data);
+    static void toggle_pick_stroke        (GtkToggleAction *toggleaction,
+                                           gpointer         user_data);
+    static void toggle_pick_no_overlap    (GtkToggleAction *toggleaction,
+                                           gpointer         user_data);
+    static void toggle_pick_inverse_value (GtkToggleAction *toggleaction,
+                                           gpointer         user_data);
+
+protected:
+    SprayToolbar(SPDesktop *desktop) :
+        Toolbar(desktop)
+    {}
+
+    ~SprayToolbar();
 
-void       sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
+public:
+    static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions);
+};
+}
+}
+}
 
 #endif /* !SEEN_SELECT_TOOLBAR_H */
diff --git a/src/ui/toolbar/star-toolbar.cpp b/src/ui/toolbar/star-toolbar.cpp
index 2fa354f42..5aa88f1e0 100644
--- a/src/ui/toolbar/star-toolbar.cpp
+++ b/src/ui/toolbar/star-toolbar.cpp
@@ -58,324 +58,466 @@ using Inkscape::UI::PrefPusher;
 //##       Star         ##
 //########################
 
-static void sp_star_magnitude_value_changed( GtkAdjustment *adj, GObject *dataKludge )
+static Inkscape::XML::NodeEventVector star_tb_repr_events =
 {
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( dataKludge, "desktop" ));
+    nullptr, /* child_added */
+    nullptr, /* child_removed */
+    Inkscape::UI::Toolbar::StarToolbar::event_attr_changed,
+    nullptr, /* content_changed */
+    nullptr  /* order_changed */
+};
 
-    if (DocumentUndo::getUndoSensitive(desktop->getDocument())) {
-        // do not remember prefs if this call is initiated by an undo change, because undoing object
-        // creation sets bogus values to its attributes before it is deleted
+namespace Inkscape {
+namespace UI {
+namespace Toolbar {
+StarToolbar::~StarToolbar()
+{
+    if (_repr) { // remove old listener
+        _repr->removeListenerByData(this);
+        Inkscape::GC::release(_repr);
+        _repr = nullptr;
+    }
+}
+
+GtkWidget *
+StarToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
+{
+    auto holder = new StarToolbar(desktop);
+
+    GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
+
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    bool isFlatSided = prefs->getBool("/tools/shapes/star/isflatsided", true);
+
+    EgeAdjustmentAction* eact = nullptr;
+
+    {
+        holder->_mode_action = ege_output_action_new( "StarStateAction", _("<b>New:</b>"), "", nullptr );
+        ege_output_action_set_use_markup( holder->_mode_action, TRUE );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_mode_action ) );
+    }
+
+    /* Flatsided checkbox */
+    {
+        InkSelectOneActionColumns columns;
+
+        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
+
+        Gtk::TreeModel::Row row;
+
+        row = *(store->append());
+        row[columns.col_label    ] = _("Polygon");
+        row[columns.col_tooltip  ] = _("Regular polygon (with one handle) instead of a star");
+        row[columns.col_icon     ] = INKSCAPE_ICON("draw-polygon");
+        row[columns.col_sensitive] = true;
+
+        row = *(store->append());
+        row[columns.col_label    ] = _("Star");
+        row[columns.col_tooltip  ] = _("Star instead of a regular polygon (with one handle)");
+        row[columns.col_icon     ] = INKSCAPE_ICON("draw-star");
+        row[columns.col_sensitive] = true;
+
+        holder->_flat_action =
+            InkSelectOneAction::create( "FlatAction",        // Name
+                                        (""),                // Label
+                                        (""),                // Tooltip
+                                        "Not Used",          // Icon
+                                        store );             // Tree store
+        holder->_flat_action->use_radio( true );
+        holder->_flat_action->use_label( false );
+        holder->_flat_action->set_active( isFlatSided ? 0 : 1 );
+
+        gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_flat_action->gobj() ));
+
+        holder->_flat_action->signal_changed().connect(sigc::mem_fun(*holder, &StarToolbar::side_mode_changed));
+    }
+
+    /* Magnitude */
+    {
+        gchar const* labels[] = {_("triangle/tri-star"), _("square/quad-star"), _("pentagon/five-pointed star"), _("hexagon/six-pointed star"), nullptr, nullptr, nullptr, nullptr, nullptr};
+        gdouble values[] = {3, 4, 5, 6, 7, 8, 10, 12, 20};
+        eact = create_adjustment_action( "MagnitudeAction",
+                                         _("Corners"), _("Corners:"), _("Number of corners of a polygon or star"),
+                                         "/tools/shapes/star/magnitude", 3,
+                                         GTK_WIDGET(desktop->canvas),
+                                         nullptr, // dataKludge
+                                         FALSE, nullptr,
+                                         3, 1024, 1, 5,
+                                         labels, values, G_N_ELEMENTS(labels),
+                                         nullptr, // callback
+                                         nullptr /*unit tracker*/,
+                                         1.0, 0 );
+
+        holder->_magnitude_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        holder->_magnitude_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &StarToolbar::magnitude_value_changed));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+    }
+
+    /* Spoke ratio */
+    {
+        gchar const* labels[] = {_("thin-ray star"), nullptr, _("pentagram"), _("hexagram"), _("heptagram"), _("octagram"), _("regular polygon")};
+        gdouble values[] = {0.01, 0.2, 0.382, 0.577, 0.692, 0.765, 1};
+        holder->_prop_action = create_adjustment_action( "SpokeAction",
+                                         _("Spoke ratio"), _("Spoke ratio:"),
+                                         // TRANSLATORS: Tip radius of a star is the distance from the center to the farthest handle.
+                                         // Base radius is the same for the closest handle.
+                                         _("Base radius to tip radius ratio"),
+                                         "/tools/shapes/star/proportion", 0.5,
+                                         GTK_WIDGET(desktop->canvas),
+                                         nullptr, // dataKludge
+                                         FALSE, nullptr,
+                                         0.01, 1.0, 0.01, 0.1,
+                                         labels, values, G_N_ELEMENTS(labels),
+                                         nullptr // callback
+                                         );
+        holder->_spoke_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_prop_action));
+        holder->_spoke_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &StarToolbar::proportion_value_changed));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_prop_action) );
+
+        if ( !isFlatSided ) {
+            gtk_action_set_visible( GTK_ACTION(holder->_prop_action), TRUE );
+        } else {
+            gtk_action_set_visible( GTK_ACTION(holder->_prop_action), FALSE );
+        }
+    }
+
+    /* Roundedness */
+    {
+        gchar const* labels[] = {_("stretched"), _("twisted"), _("slightly pinched"), _("NOT rounded"), _("slightly rounded"),
+                                 _("visibly rounded"), _("well rounded"), _("amply rounded"), nullptr, _("stretched"), _("blown up")};
+        gdouble values[] = {-1, -0.2, -0.03, 0, 0.05, 0.1, 0.2, 0.3, 0.5, 1, 10};
+        eact = create_adjustment_action( "RoundednessAction",
+                                         _("Rounded"), _("Rounded:"), _("How much rounded are the corners (0 for sharp)"),
+                                         "/tools/shapes/star/rounded", 0.0,
+                                         GTK_WIDGET(desktop->canvas),
+                                         nullptr, // dataKludge
+                                         FALSE, nullptr,
+                                         -10.0, 10.0, 0.01, 0.1,
+                                         labels, values, G_N_ELEMENTS(labels),
+                                         nullptr // callback
+                                         );
+        holder->_roundedness_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        holder->_roundedness_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &StarToolbar::rounded_value_changed));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+    }
+
+    /* Randomization */
+    {
+        gchar const* labels[] = {_("NOT randomized"), _("slightly irregular"), _("visibly randomized"), _("strongly randomized"), _("blown up")};
+        gdouble values[] = {0, 0.01, 0.1, 0.5, 10};
+        eact = create_adjustment_action( "RandomizationAction",
+                                         _("Randomized"), _("Randomized:"), _("Scatter randomly the corners and angles"),
+                                         "/tools/shapes/star/randomized", 0.0,
+                                         GTK_WIDGET(desktop->canvas),
+                                         nullptr, // dataKludge
+                                         FALSE, nullptr,
+                                         -10.0, 10.0, 0.001, 0.01,
+                                         labels, values, G_N_ELEMENTS(labels),
+                                         nullptr, // callback
+                                         nullptr /*unit tracker*/, 0.1, 3 );
+        holder->_randomization_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        holder->_randomization_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &StarToolbar::randomized_value_changed));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+    }
+
+    /* Reset */
+    {
+        InkAction* inky = ink_action_new( "StarResetAction",
+                                          _("Defaults"),
+                                          _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
+                                          INKSCAPE_ICON("edit-clear"),
+                                          GTK_ICON_SIZE_SMALL_TOOLBAR);
+        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(StarToolbar::defaults), holder);
+        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
+        gtk_action_set_sensitive( GTK_ACTION(inky), TRUE );
+    }
+
+    desktop->connectEventContextChanged(sigc::mem_fun(*holder, &StarToolbar::watch_ec));
+
+    return GTK_WIDGET(holder->gobj());
+}
+
+void
+StarToolbar::side_mode_changed(int mode)
+{
+    bool flat = (mode == 0);
+
+    if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setInt("/tools/shapes/star/magnitude",
-            (gint)gtk_adjustment_get_value(adj));
+        prefs->setBool( "/tools/shapes/star/isflatsided", flat );
     }
 
     // quit if run by the attr_changed listener
-    if (g_object_get_data( dataKludge, "freeze" )) {
+    if (_freeze) {
         return;
     }
 
     // in turn, prevent listener from responding
-    g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(TRUE) );
+    _freeze = true;
 
+    Inkscape::Selection *selection = _desktop->getSelection();
     bool modmade = false;
 
-    Inkscape::Selection *selection = desktop->getSelection();
+    if ( _prop_action ) {
+        gtk_action_set_visible( GTK_ACTION(_prop_action), !flat );
+    }
+
     auto itemlist= selection->items();
     for(auto i=itemlist.begin();i!=itemlist.end();++i){
         SPItem *item = *i;
         if (SP_IS_STAR(item)) {
             Inkscape::XML::Node *repr = item->getRepr();
-            sp_repr_set_int(repr,"sodipodi:sides",
-                (gint)gtk_adjustment_get_value(adj));
-            double arg1 = 0.5;
-            sp_repr_get_double(repr, "sodipodi:arg1", &arg1);
-            sp_repr_set_svg_double(repr, "sodipodi:arg2",
-                                   (arg1 + M_PI / (gint)gtk_adjustment_get_value(adj)));
+            repr->setAttribute("inkscape:flatsided", flat ? "true" : "false" );
             item->updateRepr();
             modmade = true;
         }
     }
+
     if (modmade) {
-        DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_STAR,
-                           _("Star: Change number of corners"));
+        DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_STAR,
+                           flat ? _("Make polygon") : _("Make star"));
     }
 
-    g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-static void sp_star_proportion_value_changed( GtkAdjustment *adj, GObject *dataKludge )
+void
+StarToolbar::magnitude_value_changed()
 {
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( dataKludge, "desktop" ));
-
-    if (DocumentUndo::getUndoSensitive(desktop->getDocument())) {
-        if (!IS_NAN(gtk_adjustment_get_value(adj))) {
-            Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-            prefs->setDouble("/tools/shapes/star/proportion",
-                gtk_adjustment_get_value(adj));
-        }
+    if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) {
+        // do not remember prefs if this call is initiated by an undo change, because undoing object
+        // creation sets bogus values to its attributes before it is deleted
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        prefs->setInt("/tools/shapes/star/magnitude",
+            (gint)_magnitude_adj->get_value());
     }
 
     // quit if run by the attr_changed listener
-    if (g_object_get_data( dataKludge, "freeze" )) {
+    if (_freeze) {
         return;
     }
 
     // in turn, prevent listener from responding
-    g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(TRUE) );
+    _freeze = true;
 
     bool modmade = false;
-    Inkscape::Selection *selection = desktop->getSelection();
+
+    Inkscape::Selection *selection = _desktop->getSelection();
     auto itemlist= selection->items();
     for(auto i=itemlist.begin();i!=itemlist.end();++i){
         SPItem *item = *i;
         if (SP_IS_STAR(item)) {
             Inkscape::XML::Node *repr = item->getRepr();
-
-            gdouble r1 = 1.0;
-            gdouble r2 = 1.0;
-            sp_repr_get_double(repr, "sodipodi:r1", &r1);
-            sp_repr_get_double(repr, "sodipodi:r2", &r2);
-            if (r2 < r1) {
-                sp_repr_set_svg_double(repr, "sodipodi:r2",
-                r1*gtk_adjustment_get_value(adj));
-            } else {
-                sp_repr_set_svg_double(repr, "sodipodi:r1",
-                r2*gtk_adjustment_get_value(adj));
-            }
-
+            sp_repr_set_int(repr,"sodipodi:sides",
+                (gint)_magnitude_adj->get_value());
+            double arg1 = 0.5;
+            sp_repr_get_double(repr, "sodipodi:arg1", &arg1);
+            sp_repr_set_svg_double(repr, "sodipodi:arg2",
+                                   (arg1 + M_PI / (gint)_magnitude_adj->get_value()));
             item->updateRepr();
             modmade = true;
         }
     }
-
     if (modmade) {
-        DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_STAR,
-                           _("Star: Change spoke ratio"));
+        DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_STAR,
+                           _("Star: Change number of corners"));
     }
 
-    g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-static void sp_star_side_mode_changed( GObject *dataKludge, int mode )
+void
+StarToolbar::proportion_value_changed()
 {
-    bool flat = (mode == 0);
-
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( dataKludge, "desktop" ));
-
-    if (DocumentUndo::getUndoSensitive(desktop->getDocument())) {
-        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setBool( "/tools/shapes/star/isflatsided", flat );
+    if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) {
+        if (!IS_NAN(_spoke_adj->get_value())) {
+            Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+            prefs->setDouble("/tools/shapes/star/proportion",
+                _spoke_adj->get_value());
+        }
     }
 
     // quit if run by the attr_changed listener
-    if (g_object_get_data( dataKludge, "freeze" )) {
+    if (_freeze) {
         return;
     }
 
     // in turn, prevent listener from responding
-    g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(TRUE) );
+    _freeze = true;
 
-    Inkscape::Selection *selection = desktop->getSelection();
-    GtkAction* prop_action = GTK_ACTION( g_object_get_data( dataKludge, "prop_action" ) );
     bool modmade = false;
-
-    if ( prop_action ) {
-        gtk_action_set_visible( prop_action, !flat );
-    }
-
+    Inkscape::Selection *selection = _desktop->getSelection();
     auto itemlist= selection->items();
     for(auto i=itemlist.begin();i!=itemlist.end();++i){
         SPItem *item = *i;
         if (SP_IS_STAR(item)) {
             Inkscape::XML::Node *repr = item->getRepr();
-            repr->setAttribute("inkscape:flatsided", flat ? "true" : "false" );
+
+            gdouble r1 = 1.0;
+            gdouble r2 = 1.0;
+            sp_repr_get_double(repr, "sodipodi:r1", &r1);
+            sp_repr_get_double(repr, "sodipodi:r2", &r2);
+            if (r2 < r1) {
+                sp_repr_set_svg_double(repr, "sodipodi:r2",
+                r1*_spoke_adj->get_value());
+            } else {
+                sp_repr_set_svg_double(repr, "sodipodi:r1",
+                r2*_spoke_adj->get_value());
+            }
+
             item->updateRepr();
             modmade = true;
         }
     }
 
     if (modmade) {
-        DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_STAR,
-                           flat ? _("Make polygon") : _("Make star"));
+        DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_STAR,
+                           _("Star: Change spoke ratio"));
     }
 
-    g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-static void sp_star_rounded_value_changed( GtkAdjustment *adj, GObject *dataKludge )
+void
+StarToolbar::rounded_value_changed()
 {
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( dataKludge, "desktop" ));
-
-    if (DocumentUndo::getUndoSensitive(desktop->getDocument())) {
+    if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setDouble("/tools/shapes/star/rounded", (gdouble) gtk_adjustment_get_value(adj));
+        prefs->setDouble("/tools/shapes/star/rounded", (gdouble) _roundedness_adj->get_value());
     }
 
     // quit if run by the attr_changed listener
-    if (g_object_get_data( dataKludge, "freeze" )) {
+    if (_freeze) {
         return;
     }
 
     // in turn, prevent listener from responding
-    g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(TRUE) );
+    _freeze = true;
 
     bool modmade = false;
 
-    Inkscape::Selection *selection = desktop->getSelection();
+    Inkscape::Selection *selection = _desktop->getSelection();
     auto itemlist= selection->items();
     for(auto i=itemlist.begin();i!=itemlist.end();++i){
         SPItem *item = *i;
         if (SP_IS_STAR(item)) {
             Inkscape::XML::Node *repr = item->getRepr();
             sp_repr_set_svg_double(repr, "inkscape:rounded",
-                (gdouble) gtk_adjustment_get_value(adj));
+                (gdouble) _roundedness_adj->get_value());
             item->updateRepr();
             modmade = true;
         }
     }
     if (modmade) {
-        DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_STAR,
+        DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_STAR,
                            _("Star: Change rounding"));
     }
 
-    g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-static void sp_star_randomized_value_changed( GtkAdjustment *adj, GObject *dataKludge )
+void
+StarToolbar::randomized_value_changed()
 {
-    SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( dataKludge, "desktop" ));
-
-    if (DocumentUndo::getUndoSensitive(desktop->getDocument())) {
+    if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
         prefs->setDouble("/tools/shapes/star/randomized",
-            (gdouble) gtk_adjustment_get_value(adj));
+            (gdouble) _randomization_adj->get_value());
     }
 
     // quit if run by the attr_changed listener
-    if (g_object_get_data( dataKludge, "freeze" )) {
+    if (_freeze) {
         return;
     }
 
     // in turn, prevent listener from responding
-    g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(TRUE) );
+    _freeze = true;
 
     bool modmade = false;
 
-    Inkscape::Selection *selection = desktop->getSelection();
+    Inkscape::Selection *selection = _desktop->getSelection();
     auto itemlist= selection->items();
     for(auto i=itemlist.begin();i!=itemlist.end();++i){
         SPItem *item = *i;
         if (SP_IS_STAR(item)) {
             Inkscape::XML::Node *repr = item->getRepr();
             sp_repr_set_svg_double(repr, "inkscape:randomized",
-                (gdouble) gtk_adjustment_get_value(adj));
+                (gdouble) _randomization_adj->get_value());
             item->updateRepr();
             modmade = true;
         }
     }
     if (modmade) {
-        DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_STAR,
+        DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_STAR,
                            _("Star: Change randomization"));
     }
 
-    g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-
-static void star_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const *name,
-                                       gchar const * /*old_value*/, gchar const * /*new_value*/,
-                                       bool /*is_interactive*/, gpointer dataPointer)
+void
+StarToolbar::defaults(GtkWidget * /*widget*/, gpointer user_data)
 {
-    GObject *dataKludge = G_OBJECT( dataPointer );
-
-    // quit if run by the _changed callbacks
-    if (g_object_get_data(dataKludge, "freeze")) {
-        return;
-    }
+    auto toolbar = reinterpret_cast<StarToolbar *>(user_data);
 
-    // in turn, prevent callbacks from responding
-    g_object_set_data(dataKludge, "freeze", GINT_TO_POINTER(TRUE));
+    // FIXME: in this and all other _default functions, set some flag telling the value_changed
+    // callbacks to lump all the changes for all selected objects in one undo step
 
     GtkAdjustment *adj = nullptr;
 
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    bool isFlatSided = prefs->getBool("/tools/shapes/star/isflatsided", true);
-
-    if (!strcmp(name, "inkscape:randomized")) {
-
-        adj = GTK_ADJUSTMENT( g_object_get_data(dataKludge, "randomized") );
-        double randomized = 0.0;
-        sp_repr_get_double(repr, "inkscape:randomized", &randomized);
-        gtk_adjustment_set_value(adj, randomized);
-
-    } else if (!strcmp(name, "inkscape:rounded")) {
-
-        adj = GTK_ADJUSTMENT( g_object_get_data(dataKludge, "rounded") );
-        double rounded = 0.0;
-        sp_repr_get_double(repr, "inkscape:rounded", &rounded);
-        gtk_adjustment_set_value(adj, rounded);
-
-    } else if (!strcmp(name, "inkscape:flatsided")) {
-
-        GtkAction* prop_action = GTK_ACTION( g_object_get_data(dataKludge, "prop_action") );
-        char const *flatsides = repr->attribute("inkscape:flatsided");
-
-        InkSelectOneAction* flat_action =
-            static_cast<InkSelectOneAction *>(g_object_get_data( dataKludge, "flat_action" ) );
-        if ( flatsides && !strcmp(flatsides,"false") ) {
-            flat_action->set_active(1);
-            gtk_action_set_visible( prop_action, TRUE );
-        } else {
-            flat_action->set_active(0);
-            gtk_action_set_visible( prop_action, FALSE );
-        }
+    // fixme: make settable in prefs!
+    gint mag = 5;
+    gdouble prop = 0.5;
+    gboolean flat = FALSE;
+    gdouble randomized = 0;
+    gdouble rounded = 0;
 
-    } else if ((!strcmp(name, "sodipodi:r1") || !strcmp(name, "sodipodi:r2")) && (!isFlatSided) ) {
+    toolbar->_flat_action->set_active ( flat ? 0 : 1 );
 
-        adj = GTK_ADJUSTMENT(g_object_get_data(dataKludge, "proportion"));
-        gdouble r1 = 1.0;
-        gdouble r2 = 1.0;
-        sp_repr_get_double(repr, "sodipodi:r1", &r1);
-        sp_repr_get_double(repr, "sodipodi:r2", &r2);
-        if (r2 < r1) {
-            gtk_adjustment_set_value(adj, r2/r1);
-        } else {
-            gtk_adjustment_set_value(adj, r1/r2);
-        }
+    gtk_action_set_visible( GTK_ACTION(toolbar->_prop_action), !flat );
 
-    } else if (!strcmp(name, "sodipodi:sides")) {
+    toolbar->_magnitude_adj->set_value(mag);
+    toolbar->_spoke_adj->set_value(prop);
+    toolbar->_roundedness_adj->set_value(rounded);
+    toolbar->_randomization_adj->set_value(randomized);
 
-        adj = GTK_ADJUSTMENT(g_object_get_data(dataKludge, "magnitude"));
-        int sides = 0;
-        sp_repr_get_int(repr, "sodipodi:sides", &sides);
-        gtk_adjustment_set_value(adj, sides);
-    }
-
-    g_object_set_data(dataKludge, "freeze", GINT_TO_POINTER(FALSE));
+#if !GTK_CHECK_VERSION(3,18,0)
+    toolbar->_magnitude_adj->value_changed();
+    toolbar->_spoke_adj->value_changed();
+    toolbar->_roundedness_adj->value_changed();
+    toolbar->_randomization_adj->value_changed();
+#endif
 }
 
-
-static Inkscape::XML::NodeEventVector star_tb_repr_events =
+void
+StarToolbar::watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec)
 {
-    nullptr, /* child_added */
-    nullptr, /* child_removed */
-    star_tb_event_attr_changed,
-    nullptr, /* content_changed */
-    nullptr  /* order_changed */
-};
-
+    if (dynamic_cast<Inkscape::UI::Tools::StarTool const*>(ec) != nullptr) {
+        _changed = desktop->getSelection()->connectChanged(sigc::mem_fun(*this, &StarToolbar::selection_changed));
+        selection_changed(desktop->getSelection());
+    } else {
+        if (_changed)
+            _changed.disconnect();
+    }
+}
 
 /**
  *  \param selection Should not be NULL.
  */
-static void
-sp_star_toolbox_selection_changed(Inkscape::Selection *selection, GObject *dataKludge)
+void
+StarToolbar::selection_changed(Inkscape::Selection *selection)
 {
     int n_selected = 0;
     Inkscape::XML::Node *repr = nullptr;
 
-    purge_repr_listener( dataKludge, dataKludge );
+    if (_repr) { // remove old listener
+        _repr->removeListenerByData(this);
+        Inkscape::GC::release(_repr);
+        _repr = nullptr;
+    }
 
     auto itemlist= selection->items();
     for(auto i=itemlist.begin();i!=itemlist.end();++i){
@@ -386,18 +528,16 @@ sp_star_toolbox_selection_changed(Inkscape::Selection *selection, GObject *dataK
         }
     }
 
-    EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( dataKludge, "mode_action" ) );
-
     if (n_selected == 0) {
-        g_object_set( G_OBJECT(act), "label", _("<b>New:</b>"), NULL );
+        gtk_action_set_label(GTK_ACTION(_mode_action), _("<b>New:</b>"));
     } else if (n_selected == 1) {
-        g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
+        gtk_action_set_label(GTK_ACTION(_mode_action), _("<b>Change:</b>"));
 
         if (repr) {
-            g_object_set_data( dataKludge, "repr", repr );
-            Inkscape::GC::anchor(repr);
-            sp_repr_add_listener(repr, &star_tb_repr_events, dataKludge);
-            sp_repr_synthesize_events(repr, &star_tb_repr_events, dataKludge);
+            _repr = repr;
+            Inkscape::GC::anchor(_repr);
+            _repr->addListener(&star_tb_repr_events, this);
+            _repr->synthesizeEvents(&star_tb_repr_events, this);
         }
     } else {
         // FIXME: implement averaging of all parameters for multiple selected stars
@@ -406,209 +546,62 @@ sp_star_toolbox_selection_changed(Inkscape::Selection *selection, GObject *dataK
     }
 }
 
-
-static void sp_star_defaults( GtkWidget * /*widget*/, GObject *dataKludge )
+void
+StarToolbar::event_attr_changed(Inkscape::XML::Node *repr, gchar const *name,
+                                gchar const * /*old_value*/, gchar const * /*new_value*/,
+                                bool /*is_interactive*/, gpointer dataPointer)
 {
-    // FIXME: in this and all other _default functions, set some flag telling the value_changed
-    // callbacks to lump all the changes for all selected objects in one undo step
-
-    GtkAdjustment *adj = nullptr;
-
-    // fixme: make settable in prefs!
-    gint mag = 5;
-    gdouble prop = 0.5;
-    gboolean flat = FALSE;
-    gdouble randomized = 0;
-    gdouble rounded = 0;
-
-    InkSelectOneAction* flat_action =
-        static_cast<InkSelectOneAction *>(g_object_get_data( dataKludge, "flat_action" ) );
-    flat_action->set_active ( flat ? 0 : 1 );
+    auto toolbar = reinterpret_cast<StarToolbar *>(dataPointer);
 
-    GtkAction* sb2 = GTK_ACTION( g_object_get_data( dataKludge, "prop_action" ) );
-    gtk_action_set_visible( sb2, !flat );
-
-    adj = GTK_ADJUSTMENT( g_object_get_data( dataKludge, "magnitude" ) );
-    gtk_adjustment_set_value(adj, mag);
-
-#if !GTK_CHECK_VERSION(3,18,0)
-    gtk_adjustment_value_changed(adj);
-#endif
-
-    adj = GTK_ADJUSTMENT( g_object_get_data( dataKludge, "proportion" ) );
-    gtk_adjustment_set_value(adj, prop);
-
-#if !GTK_CHECK_VERSION(3,18,0)
-    gtk_adjustment_value_changed(adj);
-#endif
-
-    adj = GTK_ADJUSTMENT( g_object_get_data( dataKludge, "rounded" ) );
-    gtk_adjustment_set_value(adj, rounded);
-
-#if !GTK_CHECK_VERSION(3,18,0)
-    gtk_adjustment_value_changed(adj);
-#endif
-
-    adj = GTK_ADJUSTMENT( g_object_get_data( dataKludge, "randomized" ) );
-    gtk_adjustment_set_value(adj, randomized);
-
-#if !GTK_CHECK_VERSION(3,18,0)
-    gtk_adjustment_value_changed(adj);
-#endif
-}
-
-static void star_toolbox_watch_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* dataKludge);
+    // quit if run by the _changed callbacks
+    if (toolbar->_freeze) {
+        return;
+    }
 
-void sp_star_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* dataKludge)
-{
-    GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
+    // in turn, prevent callbacks from responding
+    toolbar->_freeze = true;
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     bool isFlatSided = prefs->getBool("/tools/shapes/star/isflatsided", true);
 
-    EgeAdjustmentAction* eact = nullptr;
-
-    {
-        EgeOutputAction* act = ege_output_action_new( "StarStateAction", _("<b>New:</b>"), "", nullptr );
-        ege_output_action_set_use_markup( act, TRUE );
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        g_object_set_data( dataKludge, "mode_action", act );
-    }
-
-    /* Flatsided checkbox */
-    {
-        InkSelectOneActionColumns columns;
-
-        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
-
-        Gtk::TreeModel::Row row;
-
-        row = *(store->append());
-        row[columns.col_label    ] = _("Polygon");
-        row[columns.col_tooltip  ] = _("Regular polygon (with one handle) instead of a star");
-        row[columns.col_icon     ] = INKSCAPE_ICON("draw-polygon");
-        row[columns.col_sensitive] = true;
-
-        row = *(store->append());
-        row[columns.col_label    ] = _("Star");
-        row[columns.col_tooltip  ] = _("Star instead of a regular polygon (with one handle)");
-        row[columns.col_icon     ] = INKSCAPE_ICON("draw-star");
-        row[columns.col_sensitive] = true;
-
-        InkSelectOneAction* act =
-            InkSelectOneAction::create( "FlatAction",        // Name
-                                        (""),                // Label
-                                        (""),                // Tooltip
-                                        "Not Used",          // Icon
-                                        store );             // Tree store
-        act->use_radio( true );
-        act->use_label( false );
-        act->set_active( isFlatSided ? 0 : 1 );
-
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data( dataKludge, "flat_action", act );
-
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_star_side_mode_changed), dataKludge));
-    }
-
-    /* Magnitude */
-    {
-        gchar const* labels[] = {_("triangle/tri-star"), _("square/quad-star"), _("pentagon/five-pointed star"), _("hexagon/six-pointed star"), nullptr, nullptr, nullptr, nullptr, nullptr};
-        gdouble values[] = {3, 4, 5, 6, 7, 8, 10, 12, 20};
-        eact = create_adjustment_action( "MagnitudeAction",
-                                         _("Corners"), _("Corners:"), _("Number of corners of a polygon or star"),
-                                         "/tools/shapes/star/magnitude", 3,
-                                         GTK_WIDGET(desktop->canvas), dataKludge, FALSE, nullptr,
-                                         3, 1024, 1, 5,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         sp_star_magnitude_value_changed, nullptr /*unit tracker*/,
-                                         1.0, 0 );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
-    }
-
-    /* Spoke ratio */
-    {
-        gchar const* labels[] = {_("thin-ray star"), nullptr, _("pentagram"), _("hexagram"), _("heptagram"), _("octagram"), _("regular polygon")};
-        gdouble values[] = {0.01, 0.2, 0.382, 0.577, 0.692, 0.765, 1};
-        eact = create_adjustment_action( "SpokeAction",
-                                         _("Spoke ratio"), _("Spoke ratio:"),
-                                         // TRANSLATORS: Tip radius of a star is the distance from the center to the farthest handle.
-                                         // Base radius is the same for the closest handle.
-                                         _("Base radius to tip radius ratio"),
-                                         "/tools/shapes/star/proportion", 0.5,
-                                         GTK_WIDGET(desktop->canvas), dataKludge, FALSE, nullptr,
-                                         0.01, 1.0, 0.01, 0.1,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         sp_star_proportion_value_changed );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        g_object_set_data( dataKludge, "prop_action", eact );
-
-        if ( !isFlatSided ) {
-            gtk_action_set_visible( GTK_ACTION(eact), TRUE );
+    if (!strcmp(name, "inkscape:randomized")) {
+        double randomized = 0.0;
+        sp_repr_get_double(repr, "inkscape:randomized", &randomized);
+        toolbar->_randomization_adj->set_value(randomized);
+    } else if (!strcmp(name, "inkscape:rounded")) {
+        double rounded = 0.0;
+        sp_repr_get_double(repr, "inkscape:rounded", &rounded);
+        toolbar->_roundedness_adj->set_value(rounded);
+    } else if (!strcmp(name, "inkscape:flatsided")) {
+        char const *flatsides = repr->attribute("inkscape:flatsided");
+        if ( flatsides && !strcmp(flatsides,"false") ) {
+            toolbar->_flat_action->set_active(1);
+            gtk_action_set_visible( GTK_ACTION(toolbar->_prop_action), TRUE );
         } else {
-            gtk_action_set_visible( GTK_ACTION(eact), FALSE );
+            toolbar->_flat_action->set_active(0);
+            gtk_action_set_visible( GTK_ACTION(toolbar->_prop_action), FALSE );
         }
+    } else if ((!strcmp(name, "sodipodi:r1") || !strcmp(name, "sodipodi:r2")) && (!isFlatSided) ) {
+        gdouble r1 = 1.0;
+        gdouble r2 = 1.0;
+        sp_repr_get_double(repr, "sodipodi:r1", &r1);
+        sp_repr_get_double(repr, "sodipodi:r2", &r2);
+        if (r2 < r1) {
+            toolbar->_spoke_adj->set_value(r2/r1);
+        } else {
+            toolbar->_spoke_adj->set_value(r1/r2);
+        }
+    } else if (!strcmp(name, "sodipodi:sides")) {
+        int sides = 0;
+        sp_repr_get_int(repr, "sodipodi:sides", &sides);
+        toolbar->_magnitude_adj->set_value(sides);
     }
 
-    /* Roundedness */
-    {
-        gchar const* labels[] = {_("stretched"), _("twisted"), _("slightly pinched"), _("NOT rounded"), _("slightly rounded"),
-                                 _("visibly rounded"), _("well rounded"), _("amply rounded"), nullptr, _("stretched"), _("blown up")};
-        gdouble values[] = {-1, -0.2, -0.03, 0, 0.05, 0.1, 0.2, 0.3, 0.5, 1, 10};
-        eact = create_adjustment_action( "RoundednessAction",
-                                         _("Rounded"), _("Rounded:"), _("How much rounded are the corners (0 for sharp)"),
-                                         "/tools/shapes/star/rounded", 0.0,
-                                         GTK_WIDGET(desktop->canvas), dataKludge, FALSE, nullptr,
-                                         -10.0, 10.0, 0.01, 0.1,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         sp_star_rounded_value_changed );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
-    }
-
-    /* Randomization */
-    {
-        gchar const* labels[] = {_("NOT randomized"), _("slightly irregular"), _("visibly randomized"), _("strongly randomized"), _("blown up")};
-        gdouble values[] = {0, 0.01, 0.1, 0.5, 10};
-        eact = create_adjustment_action( "RandomizationAction",
-                                         _("Randomized"), _("Randomized:"), _("Scatter randomly the corners and angles"),
-                                         "/tools/shapes/star/randomized", 0.0,
-                                         GTK_WIDGET(desktop->canvas), dataKludge, FALSE, nullptr,
-                                         -10.0, 10.0, 0.001, 0.01,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         sp_star_randomized_value_changed, nullptr /*unit tracker*/, 0.1, 3 );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
-    }
-
-    /* Reset */
-    {
-        InkAction* inky = ink_action_new( "StarResetAction",
-                                          _("Defaults"),
-                                          _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
-                                          INKSCAPE_ICON("edit-clear"),
-                                          GTK_ICON_SIZE_SMALL_TOOLBAR);
-        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_star_defaults), dataKludge );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
-        gtk_action_set_sensitive( GTK_ACTION(inky), TRUE );
-    }
-
-    desktop->connectEventContextChanged(sigc::bind(sigc::ptr_fun(star_toolbox_watch_ec), dataKludge));
-    g_signal_connect(dataKludge, "destroy", G_CALLBACK(purge_repr_listener), dataKludge);
+    toolbar->_freeze = false;
 }
 
-static void star_toolbox_watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec, GObject* dataKludge)
-{
-    static sigc::connection changed;
-
-    if (dynamic_cast<Inkscape::UI::Tools::StarTool const*>(ec) != nullptr) {
-        changed = desktop->getSelection()->connectChanged(sigc::bind(sigc::ptr_fun(sp_star_toolbox_selection_changed), dataKludge));
-        sp_star_toolbox_selection_changed(desktop->getSelection(), dataKludge);
-    } else {
-        if (changed)
-            changed.disconnect();
-    }
+}
+}
 }
 
 /*
diff --git a/src/ui/toolbar/star-toolbar.h b/src/ui/toolbar/star-toolbar.h
index 7ac306d86..3959bf5f7 100644
--- a/src/ui/toolbar/star-toolbar.h
+++ b/src/ui/toolbar/star-toolbar.h
@@ -28,11 +28,79 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "toolbar.h"
+
+#include <gtkmm/adjustment.h>
+
+class InkSelectOneAction;
 class SPDesktop;
 
+typedef struct _EgeAdjustmentAction EgeAdjustmentAction;
+typedef struct _EgeOutputAction EgeOutputAction;
 typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _GObject GObject;
 
-void       sp_star_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
+namespace Inkscape {
+class Selection;
+
+namespace XML {
+class Node;
+}
+
+namespace UI {
+namespace Tools {
+class ToolBase;
+}
+
+namespace Toolbar {
+class StarToolbar : public Toolbar {
+private:
+    EgeOutputAction *_mode_action;
+    InkSelectOneAction *_flat_action;
+    EgeAdjustmentAction *_prop_action;
+
+    XML::Node *_repr;
+
+    Glib::RefPtr<Gtk::Adjustment> _magnitude_adj;
+    Glib::RefPtr<Gtk::Adjustment> _spoke_adj;
+    Glib::RefPtr<Gtk::Adjustment> _roundedness_adj;
+    Glib::RefPtr<Gtk::Adjustment> _randomization_adj;
+
+    bool _freeze;
+    sigc::connection _changed;
+    
+    void side_mode_changed(int mode);
+    void magnitude_value_changed();
+    void proportion_value_changed();
+    void rounded_value_changed();
+    void randomized_value_changed();
+
+    static void defaults(GtkWidget *widget,
+                         gpointer   user_data);
+
+    void watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec);
+    void selection_changed(Inkscape::Selection *selection);
+
+protected:
+    StarToolbar(SPDesktop *desktop) :
+        Toolbar(desktop),
+        _repr(nullptr)
+    {}
+
+    ~StarToolbar();
+
+public:
+    static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions);
+
+    static void event_attr_changed(Inkscape::XML::Node *repr,
+                                   gchar const         *name,
+                                   gchar const         *old_value,
+                                   gchar const         *new_value,
+                                   bool                 is_interactive,
+                                   gpointer             dataPointer);
+};
+
+}
+}
+}
 
 #endif /* !SEEN_SELECT_TOOLBAR_H */
diff --git a/src/ui/toolbar/text-toolbar.cpp b/src/ui/toolbar/text-toolbar.cpp
index fc3e8cd7d..72bd5cdb0 100644
--- a/src/ui/toolbar/text-toolbar.cpp
+++ b/src/ui/toolbar/text-toolbar.cpp
@@ -123,11 +123,741 @@ static void       sp_print_fontstyle( SPStyle *query ) {
 }
 #endif
 
-static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/, GObject *tbl, bool subselection = false);
+static bool is_relative( Unit const *unit ) {
+    return (unit->abbr == "" || unit->abbr == "em" || unit->abbr == "ex" || unit->abbr == "%");
+}
+
+// Set property for object, but unset all descendents
+// Should probably be moved to desktop_style.cpp
+static void recursively_set_properties( SPObject* object, SPCSSAttr *css ) {
+    object->changeCSS (css, "style");
+
+    SPCSSAttr *css_unset = sp_repr_css_attr_unset_all( css );
+    std::vector<SPObject *> children = object->childList(false);
+    for (auto i: children) {
+        recursively_set_properties (i, css_unset);
+    }
+    sp_repr_css_attr_unref (css_unset);
+}
+
+// Apply line height changes (line-height value changed or line-height unit changed)
+static void set_lineheight (SPCSSAttr *css) {
+
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    bool outer = prefs->getInt("/tools/text/outer_style", false);
+    gint mode  = prefs->getInt("/tools/text/line_spacing_mode", 0);
+    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+
+    // Calling sp_desktop_set_style will result in a call to TextTool::_styleSet() which
+    // will set the style on selected text inside the <text> element. If we want to set
+    // the style on the outer <text> objects we need to bypass this call.
+    if ( mode == 3 && !outer ) {
+        // This will call sp_te_apply_style via signal
+        sp_desktop_set_style (desktop, css, true, true);
+    } else {
+        Inkscape::Selection *selection = desktop->getSelection();
+        auto itemlist= selection->items();
+        for (auto i: itemlist) {
+
+            if (dynamic_cast<SPText *>(i) || dynamic_cast<SPFlowtext *>(i)) {
+                SPItem *item = i;
+
+                // Scale by inverse of accumulated parent transform
+                SPCSSAttr *css_set = sp_repr_css_attr_new();
+                sp_repr_css_merge(css_set, css);
+                Geom::Affine const local(item->i2doc_affine());
+                double const ex(local.descrim());
+                if ( (ex != 0.0) && (ex != 1.0) ) {
+                    sp_css_attr_scale(css_set, 1/ex);
+                }
+
+                if ( mode == 1 || mode == 2 || mode == 3) {  // Minimum, Even, or Adjustable w/ outer.
+                    // We change only outer style
+                    item->changeCSS(css_set,"style");
+                } else {
+                    // We change only inner style (Adaptive).
+                    for (auto child: item->childList(false)) {
+                        child->changeCSS(css_set,"style");
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+/*
+ * Set the default list of font sizes, scaled to the users preferred unit
+ */
+static void sp_text_set_sizes(GtkListStore* model_size, int unit)
+{
+    gtk_list_store_clear(model_size);
+
+    // List of font sizes for drop-down menu
+    int sizes[] = {
+        4, 6, 8, 9, 10, 11, 12, 13, 14, 16, 18, 20, 22, 24, 28,
+        32, 36, 40, 48, 56, 64, 72, 144
+    };
+
+    // Array must be same length as SPCSSUnit in style.h
+    float ratios[] = {1, 1, 1, 10, 4, 40, 100, 16, 8, 0.16};
+
+    for(int i : sizes) {
+        GtkTreeIter iter;
+        Glib::ustring size = Glib::ustring::format(i / (float)ratios[unit]);
+        gtk_list_store_append( model_size, &iter );
+        gtk_list_store_set( model_size, &iter, 0, size.c_str(), -1 );
+    }
+}
+
+
+// TODO: possibly share with font-selector by moving most code to font-lister (passing family name)
+static void sp_text_toolbox_select_cb( GtkEntry* entry, GtkEntryIconPosition /*position*/, GdkEvent /*event*/, gpointer /*data*/ ) {
 
-// Font family
-static void sp_text_fontfamily_value_changed( Ink_ComboBoxEntry_Action *act, GObject *tbl )
+  Glib::ustring family = gtk_entry_get_text ( entry );
+  //std::cout << "text_toolbox_missing_font_cb: selecting: " << family << std::endl;
+
+  // Get all items with matching font-family set (not inherited!).
+  std::vector<SPItem*> selectList;
+
+  SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+  SPDocument *document = desktop->getDocument();
+  std::vector<SPItem*> x,y;
+  std::vector<SPItem*> allList = get_all_items(x, document->getRoot(), desktop, false, false, true, y);
+  for(std::vector<SPItem*>::const_reverse_iterator i=allList.rbegin();i!=allList.rend(); ++i){
+      SPItem *item = *i;
+    SPStyle *style = item->style;
+
+    if (style) {
+
+      Glib::ustring family_style;
+      if (style->font_family.set) {
+	family_style = style->font_family.value;
+	//std::cout << " family style from font_family: " << family_style << std::endl;
+      }
+      else if (style->font_specification.set) {
+	family_style = style->font_specification.value;
+	//std::cout << " family style from font_spec: " << family_style << std::endl;
+      }
+
+      if (family_style.compare( family ) == 0 ) {
+        //std::cout << "   found: " << item->getId() << std::endl;
+	selectList.push_back(item);
+      }
+    }
+  }
+
+  // Update selection
+  Inkscape::Selection *selection = desktop->getSelection();
+  selection->clear();
+  //std::cout << "   list length: " << g_slist_length ( selectList ) << std::endl;
+  selection->setList(selectList);
+}
+
+static void text_toolbox_watch_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* holder);
+
+namespace Inkscape {
+namespace UI {
+namespace Toolbar {
+
+TextToolbar::TextToolbar(SPDesktop *desktop)
+    : Toolbar(desktop),
+     _freeze(false),
+     _tracker(new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR))
+{
+    /* Line height unit tracker */
+    _tracker->prependUnit(unit_table.getUnit("")); // No unit
+    _tracker->addUnit(unit_table.getUnit("%"));
+    _tracker->addUnit(unit_table.getUnit("em"));
+    _tracker->addUnit(unit_table.getUnit("ex"));
+    _tracker->setActiveUnit(unit_table.getUnit("%"));
+}
+
+// Define all the "widgets" in the toolbar.
+GtkWidget *
+TextToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
 {
+    auto toolbar = new TextToolbar(desktop);
+
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
+
+    /* Font family */
+    {
+        // Font list
+        Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance();
+        fontlister->update_font_list( SP_ACTIVE_DESKTOP->getDocument());
+        Glib::RefPtr<Gtk::ListStore> store = fontlister->get_font_list();
+        GtkListStore* model = store->gobj();
+
+        toolbar->_font_family_action =
+            ink_comboboxentry_action_new( "TextFontFamilyAction",
+                                          _("Font Family"),
+                                          _("Select Font Family (Alt-X to access)"),
+                                          nullptr,
+                                          GTK_TREE_MODEL(model),
+                                          -1,                // Entry width
+                                          50,                // Extra list width
+                                          (gpointer)font_lister_cell_data_func2, // Cell layout
+                                          (gpointer)font_lister_separator_func2,
+                                          GTK_WIDGET(desktop->canvas)); // Focus widget
+        ink_comboboxentry_action_popup_enable( toolbar->_font_family_action ); // Enable entry completion
+
+        gchar *const info = _("Select all text with this font-family");
+        ink_comboboxentry_action_set_info( toolbar->_font_family_action, info ); // Show selection icon
+        ink_comboboxentry_action_set_info_cb( toolbar->_font_family_action, (gpointer)sp_text_toolbox_select_cb );
+
+        gchar *const warning = _("Font not found on system");
+        ink_comboboxentry_action_set_warning( toolbar->_font_family_action, warning ); // Show icon w/ tooltip if font missing
+        ink_comboboxentry_action_set_warning_cb( toolbar->_font_family_action, (gpointer)sp_text_toolbox_select_cb );
+
+        //ink_comboboxentry_action_set_warning_callback( act, sp_text_fontfamily_select_all );
+        ink_comboboxentry_action_set_altx_name( toolbar->_font_family_action, "altx-text" ); // Set Alt-X keyboard shortcut
+        g_signal_connect( G_OBJECT(toolbar->_font_family_action), "changed", G_CALLBACK(fontfamily_value_changed), (gpointer)toolbar );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_font_family_action) );
+
+        // Change style of drop-down from menu to list
+        auto css_provider = gtk_css_provider_new();
+        gtk_css_provider_load_from_data(css_provider,
+                                        "#TextFontFamilyAction_combobox {\n"
+                                        "  -GtkComboBox-appears-as-list: true;\n"
+                                        "}\n",
+                                        -1, nullptr);
+
+        auto screen = gdk_screen_get_default();
+        gtk_style_context_add_provider_for_screen(screen,
+                                                  GTK_STYLE_PROVIDER(css_provider),
+                                                  GTK_STYLE_PROVIDER_PRIORITY_USER);
+    }
+
+    /* Font size */
+    {
+        // List of font sizes for drop-down menu
+        GtkListStore* model_size = gtk_list_store_new( 1, G_TYPE_STRING );
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        int unit = prefs->getInt("/options/font/unitType", SP_CSS_UNIT_PT);
+
+        sp_text_set_sizes(model_size, unit);
+
+        Glib::ustring tooltip = Glib::ustring::format(_("Font size"), " (", sp_style_get_css_unit_string(unit), ")");
+
+        toolbar->_font_size_action = ink_comboboxentry_action_new( "TextFontSizeAction",
+                                                                   _("Font Size"),
+                                                                   _(tooltip.c_str()),
+                                                                   nullptr,
+                                                                   GTK_TREE_MODEL(model_size),
+                                                                   8,      // Width in characters
+                                                                   0,      // Extra list width
+                                                                   nullptr,   // Cell layout
+                                                                   nullptr,   // Separator
+                                                                   GTK_WIDGET(desktop->canvas)); // Focus widget
+
+        g_signal_connect( G_OBJECT(toolbar->_font_size_action), "changed", G_CALLBACK(fontsize_value_changed), (gpointer)toolbar );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_font_size_action) );
+    }
+
+    /* Font styles */
+    {
+        Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance();
+        Glib::RefPtr<Gtk::ListStore> store = fontlister->get_style_list();
+        GtkListStore* model_style = store->gobj();
+
+        toolbar->_font_style_action = ink_comboboxentry_action_new( "TextFontStyleAction",
+                                                                    _("Font Style"),
+                                                                    _("Font style"),
+                                                                    nullptr,
+                                                                    GTK_TREE_MODEL(model_style),
+                                                                    12,     // Width in characters
+                                                                    0,      // Extra list width
+                                                                    nullptr,   // Cell layout
+                                                                    nullptr,   // Separator
+                                                                    GTK_WIDGET(desktop->canvas)); // Focus widget
+
+        g_signal_connect( G_OBJECT(toolbar->_font_style_action), "changed", G_CALLBACK(fontstyle_value_changed), (gpointer)toolbar );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_font_style_action) );
+    }
+
+    /* Style - Superscript */
+    {
+        toolbar->_superscript_action = ink_toggle_action_new( "TextSuperscriptAction",             // Name
+                                                              _("Toggle Superscript"),             // Label
+                                                              _("Toggle superscript"),             // Tooltip
+                                                              "text_superscript",                  // Icon (inkId)
+                                                              secondarySize );                     // Icon size
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_superscript_action ) );
+        g_signal_connect_after( G_OBJECT(toolbar->_superscript_action), "toggled", G_CALLBACK(script_changed), toolbar );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(toolbar->_superscript_action), prefs->getBool("/tools/text/super", false) );
+    }
+
+    /* Style - Subscript */
+    {
+        toolbar->_subscript_action = ink_toggle_action_new( "TextSubscriptAction",             // Name
+                                                            _("Toggle Subscript"),             // Label
+                                                            _("Toggle subscript"),             // Tooltip
+                                                            "text_subscript",                  // Icon (inkId)
+                                                            secondarySize );                   // Icon size
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_subscript_action ) );
+        g_signal_connect_after( G_OBJECT(toolbar->_subscript_action), "toggled", G_CALLBACK(script_changed), (gpointer)toolbar );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(toolbar->_subscript_action), prefs->getBool("/tools/text/sub", false) );
+    }
+
+    /* Alignment */
+    {
+        InkSelectOneActionColumns columns;
+
+        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
+
+        Gtk::TreeModel::Row row;
+
+        row = *(store->append());
+        row[columns.col_label    ] = _("Align left");
+        row[columns.col_tooltip  ] = _("Align left");
+        row[columns.col_icon     ] = INKSCAPE_ICON("format-justify-left");
+        row[columns.col_sensitive] = true;
+
+        row = *(store->append());
+        row[columns.col_label    ] = _("Align center");
+        row[columns.col_tooltip  ] = _("Align center");
+        row[columns.col_icon     ] = INKSCAPE_ICON("format-justify-center");
+        row[columns.col_sensitive] = true;
+
+        row = *(store->append());
+        row[columns.col_label    ] = _("Align right");
+        row[columns.col_tooltip  ] = _("Align right");
+        row[columns.col_icon     ] = INKSCAPE_ICON("format-justify-right");
+        row[columns.col_sensitive] = true;
+
+        row = *(store->append());
+        row[columns.col_label    ] = _("Justify");
+        row[columns.col_tooltip  ] = _("Justify (only flowed text)");
+        row[columns.col_icon     ] = INKSCAPE_ICON("format-justify-fill");
+        row[columns.col_sensitive] = false;
+
+        toolbar->_align_action =
+            InkSelectOneAction::create( "TextAlignAction",   // Name
+                                        _("Alignment"),      // Label
+                                        _("Text alignment"), // Tooltip
+                                        "Not Used",          // Icon
+                                        store );             // Tree store
+        toolbar->_align_action->use_radio( false );
+        toolbar->_align_action->use_label( false );
+        gint mode = prefs->getInt("/tools/text/align_mode", 0);
+        toolbar->_align_action->set_active( mode );
+
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_align_action->gobj() ));
+
+        toolbar->_align_action->signal_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::align_mode_changed));
+    }
+
+    /* Writing mode (Horizontal, Vertical-LR, Vertical-RL) */
+    {
+        InkSelectOneActionColumns columns;
+
+        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
+
+        Gtk::TreeModel::Row row;
+
+        row = *(store->append());
+        row[columns.col_label    ] = _("Horizontal");
+        row[columns.col_tooltip  ] = _("Horizontal text");
+        row[columns.col_icon     ] = INKSCAPE_ICON("format-text-direction-horizontal");
+        row[columns.col_sensitive] = true;
+
+        row = *(store->append());
+        row[columns.col_label    ] = _("Vertical — RL");
+        row[columns.col_tooltip  ] = _("Vertical text — lines: right to left");
+        row[columns.col_icon     ] = INKSCAPE_ICON("format-text-direction-vertical");
+        row[columns.col_sensitive] = true;
+
+        row = *(store->append());
+        row[columns.col_label    ] = _("Vertical — LR");
+        row[columns.col_tooltip  ] = _("Vertical text — lines: left to right");
+        row[columns.col_icon     ] = INKSCAPE_ICON("format-text-direction-vertical-lr");
+        row[columns.col_sensitive] = true;
+
+        toolbar->_writing_mode_action =
+            InkSelectOneAction::create( "TextWritingModeAction", // Name
+                                        _("Writing mode"),       // Label
+                                        _("Block progression"),  // Tooltip
+                                        "Not Used",              // Icon
+                                        store );                 // Tree store
+        toolbar->_writing_mode_action->use_radio( false );
+        toolbar->_writing_mode_action->use_label( false );
+        gint mode = prefs->getInt("/tools/text/writing_mode", 0);
+        toolbar->_writing_mode_action->set_active( mode );
+
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_writing_mode_action->gobj() ));
+
+        toolbar->_writing_mode_action->signal_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::writing_mode_changed));
+    }
+
+    /* Text (glyph) orientation (Auto (mixed), Upright, Sideways) */
+    {
+        InkSelectOneActionColumns columns;
+
+        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
+
+        Gtk::TreeModel::Row row;
+
+        row = *(store->append());
+        row[columns.col_label    ] = _("Auto");
+        row[columns.col_tooltip  ] = _("Auto glyph orientation");
+        row[columns.col_icon     ] = INKSCAPE_ICON("text-orientation-auto");
+        row[columns.col_sensitive] = true;
+
+        row = *(store->append());
+        row[columns.col_label    ] = _("Upright");
+        row[columns.col_tooltip  ] = _("Upright glyph orientation");
+        row[columns.col_icon     ] = INKSCAPE_ICON("text-orientation-upright");
+        row[columns.col_sensitive] = true;
+
+        row = *(store->append());
+        row[columns.col_label    ] = _("Sideways");
+        row[columns.col_tooltip  ] = _("Sideways glyph orientation");
+        row[columns.col_icon     ] = INKSCAPE_ICON("text-orientation-sideways");
+        row[columns.col_sensitive] = true;
+
+        toolbar->_orientation_action =
+            InkSelectOneAction::create( "TextOrientationAction",  // Name
+                                        _("Text orientation"),    // Label
+                                        _("Text (glyph) orientation in vertical text."),  // Tooltip
+                                        "Not Used",               // Icon
+                                        store );                  // List store
+        toolbar->_orientation_action->use_radio( false );
+        toolbar->_orientation_action->use_label( false );
+        gint mode = prefs->getInt("/tools/text/text_orientation", 0);
+        toolbar->_orientation_action->set_active( mode );
+
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_orientation_action->gobj() ));
+
+        toolbar->_orientation_action->signal_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::orientation_changed));
+    }
+
+    // Text direction (predominant direction of horizontal text).
+    {
+        InkSelectOneActionColumns columns;
+
+        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
+
+        Gtk::TreeModel::Row row;
+
+        row = *(store->append());
+        row[columns.col_label    ] = _("LTR");
+        row[columns.col_tooltip  ] = _("Left to right text");
+        row[columns.col_icon     ] = INKSCAPE_ICON("format-text-direction-horizontal");
+        row[columns.col_sensitive] = true;
+
+        row = *(store->append());
+        row[columns.col_label    ] = _("RTL");
+        row[columns.col_tooltip  ] = _("Right to left text");
+        row[columns.col_icon     ] = INKSCAPE_ICON("format-text-direction-r2l");
+        row[columns.col_sensitive] = true;
+
+        toolbar->_direction_action =
+            InkSelectOneAction::create( "TextDirectionAction",  // Name
+                                        _("Text direction"),    // Label
+                                        _("Text direction for normally horizontal text."),  // Tooltip
+                                        "Not Used",               // Icon
+                                        store );                  // List store
+        toolbar->_direction_action->use_radio( false );
+        toolbar->_direction_action->use_label( false );
+        gint mode = prefs->getInt("/tools/text/text_direction", 0);
+        toolbar->_direction_action->set_active( mode );
+
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_direction_action->gobj() ));
+
+        toolbar->_direction_action->signal_changed_after().connect(sigc::mem_fun(*toolbar, &TextToolbar::direction_changed));
+    }
+
+    /* Line height */
+    {
+        // Drop down menu
+        gchar const* labels[] = {_("Smaller spacing"), nullptr, nullptr, nullptr, nullptr, C_("Text tool", "Normal"), nullptr, nullptr, nullptr, nullptr, nullptr, _("Larger spacing")};
+        gdouble values[] = { 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1,2, 1.3, 1.4, 1.5, 2.0};
+
+        toolbar->_line_height_action = create_adjustment_action(
+            "TextLineHeightAction",               /* name */
+            _("Line Height"),                     /* label */
+            _("Line:"),                           /* short label */
+            _("Spacing between baselines"),       /* tooltip */
+            "/tools/text/lineheight",             /* preferences path */
+            0.0,                                  /* default */
+            GTK_WIDGET(desktop->canvas),          /* focusTarget */
+            nullptr,                              /* dataKludge */
+            FALSE,                                /* set alt-x keyboard shortcut? */
+            nullptr,                              /* altx_mark */
+            0.0, 1000.0, 0.1, 1.0,                /* lower, upper, step (arrow up/down), page up/down */
+            labels, values, G_N_ELEMENTS(labels), /* drop down menu */
+            nullptr,                              /* callback */
+            nullptr, // tracker,                  /* unit tracker */
+            0.1,                                  /* step (used?) */
+            2,                                    /* digits to show */
+            1.0                                   /* factor (multiplies default) */
+            );
+
+        toolbar->_line_height_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_line_height_action));
+        toolbar->_line_height_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::lineheight_value_changed));
+
+        //tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_line_height_action) );
+        gtk_action_set_sensitive( GTK_ACTION(toolbar->_line_height_action), TRUE );
+
+        // TODO: Create accessor method for this, instead of GObject property
+        g_object_set( G_OBJECT(toolbar->_line_height_action), "iconId", "text_line_spacing", NULL );
+    }
+
+    /* Line height units */
+    {
+        toolbar->_line_height_units_action = toolbar->_tracker->createAction( "TextLineHeightUnitsAction", _("Units"), ("") );
+        gtk_action_group_add_action( mainActions, toolbar->_line_height_units_action->gobj() );
+        toolbar->_line_height_units_action->signal_changed_after().connect(sigc::mem_fun(*toolbar, &TextToolbar::lineheight_unit_changed));
+    }
+
+    /* Line spacing mode */
+    {
+        InkSelectOneActionColumns columns;
+
+        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
+
+        Gtk::TreeModel::Row row;
+
+        row = *(store->append());
+        row[columns.col_label    ] = _("Adaptive");
+        row[columns.col_tooltip  ] = _("Line spacing adapts to font size.");
+        row[columns.col_icon     ] = INKSCAPE_ICON("text_line_spacing");
+        row[columns.col_sensitive] = true;
+
+        row = *(store->append());
+        row[columns.col_label    ] = _("Minimum");
+        row[columns.col_tooltip  ] = _("Line spacing adapts to fonts size with set minimum spacing.");
+        row[columns.col_icon     ] = INKSCAPE_ICON("text_line_spacing");
+        row[columns.col_sensitive] = true;
+        row = *(store->append());
+        row[columns.col_label    ] = _("Even");
+        row[columns.col_tooltip  ] = _("Lines evenly spaced.");
+        row[columns.col_icon     ] = INKSCAPE_ICON("text_line_spacing");
+        row[columns.col_sensitive] = true;
+
+        row = *(store->append());
+        row[columns.col_label    ] = _("Adjustable ☠");
+        row[columns.col_tooltip  ] = _("Line spacing fully adjustable");
+        row[columns.col_icon     ] = INKSCAPE_ICON("text_line_spacing");
+        row[columns.col_sensitive] = true;
+
+        toolbar->_line_spacing_action =
+            InkSelectOneAction::create( "TextLineSpacingAction", // Name
+                                        _("Line Spacing Mode"),   // Label
+                                        _("How should multiple baselines be spaced?\n Adaptive: Line spacing adapts to font size.\n Minimum: Like Adaptive, but with a set minimum.\n Even: Evenly spaced.\n Adjustable: No restrictions."), // Tooltip
+                                        "Not Used",          // Icon
+                                        store );             // Tree store
+        toolbar->_line_spacing_action->use_radio( false );
+        toolbar->_line_spacing_action->use_label( true );
+        gint mode = prefs->getInt("/tools/text/line_spacing_mode", 0);
+        toolbar->_line_spacing_action->set_active( mode );
+
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_line_spacing_action->gobj() ));
+
+        toolbar->_line_spacing_action->signal_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::line_spacing_mode_changed));
+    }
+
+    /* Word spacing */
+    {
+        // Drop down menu
+        gchar const* labels[] = {_("Negative spacing"), nullptr, nullptr, nullptr, C_("Text tool", "Normal"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, _("Positive spacing")};
+        gdouble values[] = {-2.0, -1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0};
+
+        toolbar->_word_spacing_action = create_adjustment_action(
+            "TextWordSpacingAction",              /* name */
+            _("Word spacing"),                    /* label */
+            _("Word:"),                           /* short label */
+            _("Spacing between words (px)"),      /* tooltip */
+            "/tools/text/wordspacing",            /* preferences path */
+            0.0,                                  /* default */
+            GTK_WIDGET(desktop->canvas),          /* focusTarget */
+            nullptr,                              /* dataKludge */
+            FALSE,                                /* set alt-x keyboard shortcut? */
+            nullptr,                                 /* altx_mark */
+            -100.0, 100.0, 0.01, 0.10,            /* lower, upper, step (arrow up/down), page up/down */
+            labels, values, G_N_ELEMENTS(labels), /* drop down menu */
+            nullptr,                              /* callback */
+            nullptr,                                 /* unit tracker */
+            0.1,                                  /* step (used?) */
+            2,                                    /* digits to show */
+            1.0                                   /* factor (multiplies default) */
+            );
+
+        toolbar->_word_spacing_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_word_spacing_action));
+        toolbar->_word_spacing_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::wordspacing_value_changed));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_word_spacing_action) );
+        gtk_action_set_sensitive( GTK_ACTION(toolbar->_word_spacing_action), TRUE );
+        g_object_set( G_OBJECT(toolbar->_word_spacing_action), "iconId", "text_word_spacing", NULL );
+    }
+
+    /* Letter spacing */
+    {
+        // Drop down menu
+        gchar const* labels[] = {_("Negative spacing"), nullptr, nullptr, nullptr, C_("Text tool", "Normal"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, _("Positive spacing")};
+        gdouble values[] = {-2.0, -1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0};
+
+        toolbar->_letter_spacing_action = create_adjustment_action(
+            "TextLetterSpacingAction",            /* name */
+            _("Letter spacing"),                  /* label */
+            _("Letter:"),                         /* short label */
+            _("Spacing between letters (px)"),    /* tooltip */
+            "/tools/text/letterspacing",          /* preferences path */
+            0.0,                                  /* default */
+            GTK_WIDGET(desktop->canvas),          /* focusTarget */
+            nullptr,                              /* dataKludge */
+            FALSE,                                /* set alt-x keyboard shortcut? */
+            nullptr,                                 /* altx_mark */
+            -100.0, 100.0, 0.01, 0.10,            /* lower, upper, step (arrow up/down), page up/down */
+            labels, values, G_N_ELEMENTS(labels), /* drop down menu */
+            nullptr,                              /* callback */
+            nullptr,                                 /* unit tracker */
+            0.1,                                  /* step (used?) */
+            2,                                    /* digits to show */
+            1.0                                   /* factor (multiplies default) */
+            );
+        toolbar->_letter_spacing_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_letter_spacing_action));
+        toolbar->_letter_spacing_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::letterspacing_value_changed));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_letter_spacing_action) );
+        gtk_action_set_sensitive( GTK_ACTION(toolbar->_letter_spacing_action), TRUE );
+        g_object_set( G_OBJECT(toolbar->_letter_spacing_action), "iconId", "text_letter_spacing", NULL );
+    }
+
+    /* Character kerning (horizontal shift) */
+    {
+        // Drop down menu
+        gchar const* labels[] = {   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr };
+        gdouble values[]      = { -2.0, -1.5, -1.0, -0.5,   0,  0.5,  1.0,  1.5,  2.0, 2.5 };
+
+        toolbar->_dx_action = create_adjustment_action(
+            "TextDxAction",                       /* name */
+            _("Kerning"),                         /* label */
+            _("Kern:"),                           /* short label */
+            _("Horizontal kerning (px)"),         /* tooltip */
+            "/tools/text/dx",                     /* preferences path */
+            0.0,                                  /* default */
+            GTK_WIDGET(desktop->canvas),          /* focusTarget */
+            nullptr,                              /* dataKludge */
+            FALSE,                                /* set alt-x keyboard shortcut? */
+            nullptr,                              /* altx_mark */
+            -100.0, 100.0, 0.01, 0.1,             /* lower, upper, step (arrow up/down), page up/down */
+            labels, values, G_N_ELEMENTS(labels), /* drop down menu */
+            nullptr,                              /* callback */
+            nullptr,                              /* unit tracker */
+            0.1,                                  /* step (used?) */
+            2,                                    /* digits to show */
+            1.0                                   /* factor (multiplies default) */
+            );
+        toolbar->_dx_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_dx_action));
+        toolbar->_dx_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::dx_value_changed));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_dx_action) );
+        gtk_action_set_sensitive( GTK_ACTION(toolbar->_dx_action), TRUE );
+        g_object_set( G_OBJECT(toolbar->_dx_action), "iconId", "text_horz_kern", NULL );
+    }
+
+    /* Character vertical shift */
+    {
+        // Drop down menu
+        gchar const* labels[] = {   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr };
+        gdouble values[]      = { -2.0, -1.5, -1.0, -0.5,   0,  0.5,  1.0,  1.5,  2.0, 2.5 };
+
+        toolbar->_dy_action = create_adjustment_action(
+            "TextDyAction",                       /* name */
+            _("Vertical Shift"),                  /* label */
+            _("Vert:"),                           /* short label */
+            _("Vertical shift (px)"),             /* tooltip */
+            "/tools/text/dy",                     /* preferences path */
+            0.0,                                  /* default */
+            GTK_WIDGET(desktop->canvas),          /* focusTarget */
+            nullptr,                              /* dataKludge */
+            FALSE,                                /* set alt-x keyboard shortcut? */
+            nullptr,                                 /* altx_mark */
+            -100.0, 100.0, 0.01, 0.1,             /* lower, upper, step (arrow up/down), page up/down */
+            labels, values, G_N_ELEMENTS(labels), /* drop down menu */
+            nullptr,                              /* callback */
+            nullptr,                                 /* unit tracker */
+            0.1,                                  /* step (used?) */
+            2,                                    /* digits to show */
+            1.0                                   /* factor (multiplies default) */
+            );
+        toolbar->_dy_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_dy_action));
+        toolbar->_dy_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::dy_value_changed));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_dy_action) );
+        gtk_action_set_sensitive( GTK_ACTION(toolbar->_dy_action), TRUE );
+        g_object_set( G_OBJECT(toolbar->_dy_action), "iconId", "text_vert_kern", NULL );
+    }
+
+    /* Character rotation */
+    {
+        // Drop down menu
+        gchar const* labels[] = {   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr };
+        gdouble values[]      = { -90, -45, -30, -15,   0,  15,  30,  45,  90, 180 };
+
+        toolbar->_rotation_action = create_adjustment_action(
+            "TextRotationAction",                 /* name */
+            _("Letter rotation"),                 /* label */
+            _("Rot:"),                            /* short label */
+            _("Character rotation (degrees)"),    /* tooltip */
+            "/tools/text/rotation",               /* preferences path */
+            0.0,                                  /* default */
+            GTK_WIDGET(desktop->canvas),          /* focusTarget */
+            nullptr,                              /* dataKludge */
+            FALSE,                                /* set alt-x keyboard shortcut? */
+            nullptr,                                 /* altx_mark */
+            -180.0, 180.0, 0.1, 1.0,              /* lower, upper, step (arrow up/down), page up/down */
+            labels, values, G_N_ELEMENTS(labels), /* drop down menu */
+            nullptr,                              /* callback */
+            nullptr,                                 /* unit tracker */
+            0.1,                                  /* step (used?) */
+            2,                                    /* digits to show */
+            1.0                                   /* factor (multiplies default) */
+            );
+        toolbar->_rotation_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_rotation_action));
+        toolbar->_rotation_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::rotation_value_changed));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_rotation_action) );
+        gtk_action_set_sensitive( GTK_ACTION(toolbar->_rotation_action), TRUE );
+        g_object_set( G_OBJECT(toolbar->_rotation_action), "iconId", "text_rotation", NULL );
+    }
+
+    /* Text line height unset */
+    {
+        toolbar->_line_height_unset_action = ink_toggle_action_new( "TextLineHeightUnsetAction",       // Name
+                                                                    _("Unset line height"),            // Label
+                                                                    _("If enabled, line height is set on part of selection. Click to unset."),
+                                                                    INKSCAPE_ICON("paint-unknown"),
+                                                                    secondarySize );                   // Icon size
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_line_height_unset_action ) );
+        g_signal_connect_after( G_OBJECT(toolbar->_line_height_unset_action), "toggled", G_CALLBACK(lineheight_unset_changed), (gpointer)toolbar );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(toolbar->_line_height_unset_action), prefs->getBool("/tools/text/line_height_unset", false) );
+    }
+
+    /* Text outer style */
+    {
+        toolbar->_outer_style_action = ink_toggle_action_new( "TextOuterStyleAction",            // Name
+                                                              _("Show outer style"),             // Label
+                                                              _("Show style of outermost text element. The 'font-size' and 'line-height' values of the outermost text element determine the minimum line spacing in the block."),
+                                                              INKSCAPE_ICON("text_outer_style"),
+                                                              secondarySize );                   // Icon size
+        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_outer_style_action ) );
+        g_signal_connect_after( G_OBJECT(toolbar->_outer_style_action), "toggled", G_CALLBACK(outer_style_changed), (gpointer)toolbar );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(toolbar->_outer_style_action), prefs->getBool("/tools/text/outer_style", false) );
+    }
+
+    // Is this necessary to call? Shouldn't hurt.
+    toolbar->selection_changed(desktop->getSelection());
+
+    desktop->connectEventContextChanged(sigc::mem_fun(*toolbar, &TextToolbar::watch_ec));
+
+    return GTK_WIDGET(toolbar->gobj());
+}
+
+void
+TextToolbar::fontfamily_value_changed( Ink_ComboBoxEntry_Action *act, gpointer data )
+{
+    auto toolbar = reinterpret_cast<TextToolbar *>(data);
+
 #ifdef DEBUG_TEXT
     std::cout << std::endl;
     std::cout << "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM" << std::endl;
@@ -135,14 +865,14 @@ static void sp_text_fontfamily_value_changed( Ink_ComboBoxEntry_Action *act, GOb
 #endif
 
      // quit if run by the _changed callbacks
-    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
+    if (toolbar->_freeze) {
 #ifdef DEBUG_TEXT
         std::cout << "sp_text_fontfamily_value_changed: frozen... return" << std::endl;
         std::cout << "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM\n" << std::endl;
 #endif
         return;
     }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+    toolbar->_freeze = true;
 
     Glib::ustring new_family = ink_comboboxentry_action_get_active_text( act );
     css_font_family_unquote( new_family ); // Remove quotes around font family names.
@@ -187,7 +917,7 @@ static void sp_text_fontfamily_value_changed( Ink_ComboBoxEntry_Action *act, GOb
     }
 
     // unfreeze
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    toolbar->_freeze = false;
 
 #ifdef DEBUG_TEXT
     std::cout << "sp_text_toolbox_fontfamily_changes: exit"  << std::endl;
@@ -196,14 +926,16 @@ static void sp_text_fontfamily_value_changed( Ink_ComboBoxEntry_Action *act, GOb
 #endif
 }
 
-// Font size
-static void sp_text_fontsize_value_changed( Ink_ComboBoxEntry_Action *act, GObject *tbl )
+void
+TextToolbar::fontsize_value_changed( Ink_ComboBoxEntry_Action *act, gpointer data)
 {
-     // quit if run by the _changed callbacks
-    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
+    auto toolbar = reinterpret_cast<TextToolbar *>(data);
+
+    // quit if run by the _changed callbacks
+    if (toolbar->_freeze) {
         return;
     }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+    toolbar->_freeze = true;
 
     gchar *text = ink_comboboxentry_action_get_active_text( act );
     gchar *endptr;
@@ -211,7 +943,7 @@ static void sp_text_fontsize_value_changed( Ink_ComboBoxEntry_Action *act, GObje
     if (endptr == text) {  // Conversion failed, non-numeric input.
         g_warning( "Conversion of size text to double failed, input: %s\n", text );
         g_free( text );
-        g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+        toolbar->_freeze = false;
         return;
     }
     g_free( text );
@@ -280,19 +1012,19 @@ static void sp_text_fontsize_value_changed( Ink_ComboBoxEntry_Action *act, GObje
 
     sp_repr_css_attr_unref (css);
 
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    toolbar->_freeze = false;
 }
 
-/*
- *  Font style
- */
-static void sp_text_fontstyle_value_changed( Ink_ComboBoxEntry_Action *act, GObject *tbl )
+void
+TextToolbar::fontstyle_value_changed( Ink_ComboBoxEntry_Action *act, gpointer data)
 {
+    auto toolbar = reinterpret_cast<TextToolbar *>(data);
+
     // quit if run by the _changed callbacks
-    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
+    if (toolbar->_freeze) {
         return;
     }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+    toolbar->_freeze = true;
 
     Glib::ustring new_style = ink_comboboxentry_action_get_active_text( act );
 
@@ -327,51 +1059,19 @@ static void sp_text_fontstyle_value_changed( Ink_ComboBoxEntry_Action *act, GObj
 
     }
 
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
-}
-
-// Changes selection to only text outer elements.
-static void sp_text_outer_style_changed( InkToggleAction*act, GObject *tbl )
-{
-    bool outer = gtk_toggle_action_get_active( GTK_TOGGLE_ACTION(act) );
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setInt("/tools/text/outer_style", outer);
-
-    // Update widgets to reflect new state of Text Outer Style button.
-    sp_text_toolbox_selection_changed( nullptr, tbl );
-}
-
-// Unset line height on selection's inner text objects (tspan, etc.).
-static void sp_text_lineheight_unset_changed( InkToggleAction*act, GObject *tbl )
-{
-    // quit if run by the _changed callbacks
-    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
-        return;
-    }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
-
-    SPCSSAttr *css = sp_repr_css_attr_new();
-    sp_repr_css_unset_property(css, "line-height");
-
-    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
-    sp_desktop_set_style (desktop, css);
-
-    sp_repr_css_attr_unref(css);
-
-    DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_TEXT,
-                       _("Text: Unset line height."));
-
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    toolbar->_freeze = false;
 }
 
 // Handles both Superscripts and Subscripts
-static void sp_text_script_changed( InkToggleAction* act, GObject *tbl )
+void
+TextToolbar::script_changed( InkToggleAction* act, gpointer data)
 {
+    auto toolbar = reinterpret_cast<TextToolbar *>(data);
     // quit if run by the _changed callbacks
-    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
+    if (toolbar->_freeze) {
         return;
     }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+    toolbar->_freeze = true;
 
     // Called by Superscript or Subscript button?
     const gchar* name = gtk_action_get_name( GTK_ACTION( act ) );
@@ -438,16 +1138,17 @@ static void sp_text_script_changed( InkToggleAction* act, GObject *tbl )
         DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:script", SP_VERB_NONE,
                              _("Text: Change superscript or subscript"));
     }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    toolbar->_freeze = false;
 }
 
-static void sp_text_align_mode_changed( GObject *tbl, int mode )
+void
+TextToolbar::align_mode_changed(int mode)
 {
     // quit if run by the _changed callbacks
-    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
+    if (_freeze) {
         return;
     }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+    _freeze = true;
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     prefs->setInt("/tools/text/align_mode", mode);
@@ -583,87 +1284,182 @@ static void sp_text_align_mode_changed( GObject *tbl, int mode )
 
     gtk_widget_grab_focus (GTK_WIDGET(SP_ACTIVE_DESKTOP->canvas));
 
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-static bool is_relative( Unit const *unit ) {
-    return (unit->abbr == "" || unit->abbr == "em" || unit->abbr == "ex" || unit->abbr == "%");
-}
+void
+TextToolbar::writing_mode_changed(int mode)
+{
+    // quit if run by the _changed callbacks
+    if (_freeze) {
+        return;
+    }
+    _freeze = true;
 
-// Set property for object, but unset all descendents
-// Should probably be moved to desktop_style.cpp
-static void recursively_set_properties( SPObject* object, SPCSSAttr *css ) {
-    object->changeCSS (css, "style");
+    SPCSSAttr   *css        = sp_repr_css_attr_new ();
+    switch (mode)
+    {
+        case 0:
+            {
+                sp_repr_css_set_property (css, "writing-mode", "lr-tb");
+                break;
+            }
 
-    SPCSSAttr *css_unset = sp_repr_css_attr_unset_all( css );
-    std::vector<SPObject *> children = object->childList(false);
-    for (auto i: children) {
-        recursively_set_properties (i, css_unset);
+        case 1:
+            {
+                sp_repr_css_set_property (css, "writing-mode", "tb-rl");
+                break;
+            }
+
+        case 2:
+            {
+                sp_repr_css_set_property (css, "writing-mode", "vertical-lr");
+                break;
+            }
     }
-    sp_repr_css_attr_unref (css_unset);
-}
 
-// Apply line height changes (line-height value changed or line-height unit changed)
-static void set_lineheight (SPCSSAttr *css) {
+    SPStyle query(SP_ACTIVE_DOCUMENT);
+    int result_numbers =
+        sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_WRITINGMODES);
 
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    bool outer = prefs->getInt("/tools/text/outer_style", false);
-    gint mode  = prefs->getInt("/tools/text/line_spacing_mode", 0);
-    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+    // If querying returned nothing, update default style.
+    if (result_numbers == QUERY_STYLE_NOTHING)
+    {
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        prefs->mergeStyle("/tools/text/style", css);
+    }
 
-    // Calling sp_desktop_set_style will result in a call to TextTool::_styleSet() which
-    // will set the style on selected text inside the <text> element. If we want to set
-    // the style on the outer <text> objects we need to bypass this call.
-    if ( mode == 3 && !outer ) {
-        // This will call sp_te_apply_style via signal
-        sp_desktop_set_style (desktop, css, true, true);
-    } else {
-        Inkscape::Selection *selection = desktop->getSelection();
-        auto itemlist= selection->items();
-        for (auto i: itemlist) {
+    sp_desktop_set_style (SP_ACTIVE_DESKTOP, css, true, true);
+    if(result_numbers != QUERY_STYLE_NOTHING)
+    {
+        DocumentUndo::done(SP_ACTIVE_DESKTOP->getDocument(), SP_VERB_CONTEXT_TEXT,
+                       _("Text: Change writing mode"));
+    }
+    sp_repr_css_attr_unref (css);
 
-            if (dynamic_cast<SPText *>(i) || dynamic_cast<SPFlowtext *>(i)) {
-                SPItem *item = i;
+    gtk_widget_grab_focus (GTK_WIDGET(SP_ACTIVE_DESKTOP->canvas));
 
-                // Scale by inverse of accumulated parent transform
-                SPCSSAttr *css_set = sp_repr_css_attr_new();
-                sp_repr_css_merge(css_set, css);
-                Geom::Affine const local(item->i2doc_affine());
-                double const ex(local.descrim());
-                if ( (ex != 0.0) && (ex != 1.0) ) {
-                    sp_css_attr_scale(css_set, 1/ex);
-                }
+    _freeze = false;
+}
 
-                if ( mode == 1 || mode == 2 || mode == 3) {  // Minimum, Even, or Adjustable w/ outer.
-                    // We change only outer style
-                    item->changeCSS(css_set,"style");
-                } else {
-                    // We change only inner style (Adaptive).
-                    for (auto child: item->childList(false)) {
-                        child->changeCSS(css_set,"style");
-                    }
-                }
-            }
+void
+TextToolbar::orientation_changed(int mode)
+{
+    // quit if run by the _changed callbacks
+    if (_freeze) {
+        return;
+    }
+    _freeze = true;
+
+    SPCSSAttr   *css        = sp_repr_css_attr_new ();
+    switch (mode)
+    {
+        case 0:
+        {
+            sp_repr_css_set_property (css, "text-orientation", "auto");
+            break;
+        }
+
+        case 1:
+        {
+            sp_repr_css_set_property (css, "text-orientation", "upright");
+            break;
         }
+
+        case 2:
+        {
+            sp_repr_css_set_property (css, "text-orientation", "sideways");
+            break;
+        }
+    }
+
+    SPStyle query(SP_ACTIVE_DOCUMENT);
+    int result_numbers =
+        sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_WRITINGMODES);
+
+    // If querying returned nothing, update default style.
+    if (result_numbers == QUERY_STYLE_NOTHING)
+    {
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        prefs->mergeStyle("/tools/text/style", css);
+    }
+
+    sp_desktop_set_style (SP_ACTIVE_DESKTOP, css, true, true);
+    if(result_numbers != QUERY_STYLE_NOTHING)
+    {
+        DocumentUndo::done(SP_ACTIVE_DESKTOP->getDocument(), SP_VERB_CONTEXT_TEXT,
+                       _("Text: Change orientation"));
     }
+    sp_repr_css_attr_unref (css);
+
+    gtk_widget_grab_focus (GTK_WIDGET(SP_ACTIVE_DESKTOP->canvas));
+
+    _freeze = false;
 }
 
-static void sp_text_lineheight_value_changed( GtkAdjustment *adj, GObject *tbl )
+void
+TextToolbar::direction_changed(int mode)
 {
     // quit if run by the _changed callbacks
-    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
+    if (_freeze) {
         return;
     }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+    _freeze = true;
+
+    SPCSSAttr   *css        = sp_repr_css_attr_new ();
+    switch (mode)
+    {
+        case 0:
+        {
+            sp_repr_css_set_property (css, "direction", "ltr");
+            break;
+        }
+
+        case 1:
+        {
+            sp_repr_css_set_property (css, "direction", "rtl");
+            break;
+        }
+    }
+
+    SPStyle query(SP_ACTIVE_DOCUMENT);
+    int result_numbers =
+        sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_WRITINGMODES);
+
+    // If querying returned nothing, update default style.
+    if (result_numbers == QUERY_STYLE_NOTHING)
+    {
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        prefs->mergeStyle("/tools/text/style", css);
+    }
+
+    sp_desktop_set_style (SP_ACTIVE_DESKTOP, css, true, true);
+    if(result_numbers != QUERY_STYLE_NOTHING)
+    {
+        DocumentUndo::done(SP_ACTIVE_DESKTOP->getDocument(), SP_VERB_CONTEXT_TEXT,
+                       _("Text: Change direction"));
+    }
+    sp_repr_css_attr_unref (css);
+
+    gtk_widget_grab_focus (GTK_WIDGET(SP_ACTIVE_DESKTOP->canvas));
 
+    _freeze = false;
+}
+
+void
+TextToolbar::lineheight_value_changed()
+{
+    // quit if run by the _changed callbacks
+    if (_freeze) {
+        return;
+    }
+    _freeze = true;
 
     // Get user selected unit and save as preference
-    UnitTracker *tracker = reinterpret_cast<UnitTracker*>(g_object_get_data(tbl, "tracker"));
-    Unit const *unit = tracker->getActiveUnit();
+    Unit const *unit = _tracker->getActiveUnit();
     g_return_if_fail(unit != nullptr);
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
-
     // This nonsense is to get SP_CSS_UNIT_xx value corresponding to unit so
     // we can save it (allows us to adjust line height value when unit changes).
     SPILength temp_length;
@@ -671,16 +1467,16 @@ static void sp_text_lineheight_value_changed( GtkAdjustment *adj, GObject *tbl )
     temp_stream << 1 << unit->abbr;
     temp_length.read(temp_stream.str().c_str());
     prefs->setInt("/tools/text/lineheight/display_unit", temp_length.unit);
-    g_object_set_data( tbl, "lineheight_unit", GINT_TO_POINTER(temp_length.unit));
+    _lineheight_unit = temp_length.unit;
 
     // Set css line height.
     SPCSSAttr *css = sp_repr_css_attr_new ();
     Inkscape::CSSOStringStream osfs;
     if ( is_relative(unit) ) {
-        osfs << gtk_adjustment_get_value(adj) << unit->abbr;
+        osfs << _line_height_adj->get_value() << unit->abbr;
     } else {
         // Inside SVG file, always use "px" for absolute units.
-        osfs << Quantity::convert(gtk_adjustment_get_value(adj), unit, "px") << "px";
+        osfs << Quantity::convert(_line_height_adj->get_value(), unit, "px") << "px";
     }
     sp_repr_css_set_property (css, "line-height", osfs.str().c_str());
 
@@ -725,24 +1521,23 @@ static void sp_text_lineheight_value_changed( GtkAdjustment *adj, GObject *tbl )
 
     sp_repr_css_attr_unref (css);
 
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-
-static void sp_text_lineheight_unit_changed( GObject *tbl, int /* Not Used */ )
+void
+TextToolbar::lineheight_unit_changed(int /* Not Used */)
 {
     // quit if run by the _changed callbacks
-    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
+    if (_freeze) {
         return;
     }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+    _freeze = true;
 
     // Get old saved unit
-    int old_unit = GPOINTER_TO_INT( g_object_get_data(tbl, "lineheight_unit"));
+    int old_unit = _lineheight_unit;
 
     // Get user selected unit and save as preference
-    UnitTracker *tracker = reinterpret_cast<UnitTracker*>(g_object_get_data(tbl, "tracker"));
-    Unit const *unit = tracker->getActiveUnit();
+    Unit const *unit = _tracker->getActiveUnit();
     g_return_if_fail(unit != nullptr);
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
@@ -752,13 +1547,10 @@ static void sp_text_lineheight_unit_changed( GObject *tbl, int /* Not Used */ )
     temp_stream << 1 << unit->abbr;
     temp_length.read(temp_stream.str().c_str());
     prefs->setInt("/tools/text/lineheight/display_unit", temp_length.unit);
-    g_object_set_data( tbl, "lineheight_unit", GINT_TO_POINTER(temp_length.unit));
+    _lineheight_unit = temp_length.unit;
 
     // Read current line height value
-    EgeAdjustmentAction *line_height_act =
-        reinterpret_cast<EgeAdjustmentAction *>(g_object_get_data(tbl, "TextLineHeightAction"));
-    GtkAdjustment *line_height_adj = ege_adjustment_action_get_adjustment( line_height_act );
-    double line_height = gtk_adjustment_get_value(line_height_adj);
+    double line_height = _line_height_adj->get_value();
 
     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
     Inkscape::Selection *selection = desktop->getSelection();
@@ -849,15 +1641,15 @@ static void sp_text_lineheight_unit_changed( GObject *tbl, int /* Not Used */ )
     sp_repr_css_set_property (css, "line-height", osfs.str().c_str());
 
     // Update GUI with line_height value.
-    gtk_adjustment_set_value(line_height_adj, line_height);
+    _line_height_adj->set_value(line_height);
 
     // Update "climb rate"  The custom action has a step property but no way to set it.
     if (unit->abbr == "%") {
-        gtk_adjustment_set_step_increment (line_height_adj,  1.0);
-        gtk_adjustment_set_page_increment (line_height_adj, 10.0);
+        _line_height_adj->set_step_increment(1.0);
+        _line_height_adj->set_page_increment(10.0);
     } else {
-        gtk_adjustment_set_step_increment (line_height_adj,  0.1);
-        gtk_adjustment_set_page_increment (line_height_adj,  1.0);
+        _line_height_adj->set_step_increment(0.1);
+        _line_height_adj->set_page_increment(1.0);
     }
 
     // Internal function to set line-height which is spacing mode dependent.
@@ -889,18 +1681,17 @@ static void sp_text_lineheight_unit_changed( GObject *tbl, int /* Not Used */ )
 
     sp_repr_css_attr_unref (css);
 
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-//
-static void sp_text_line_spacing_mode_changed( GObject *tbl, int mode )
+void
+TextToolbar::line_spacing_mode_changed(int mode)
 {
-
     // quit if run by the _changed callbacks
-    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
+    if (_freeze) {
         return;
     }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+    _freeze = true;
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     prefs->setInt("/tools/text/line_spacing_mode", mode);
@@ -1016,17 +1807,15 @@ static void sp_text_line_spacing_mode_changed( GObject *tbl, int mode )
     }
 
     // Set "Outer Style" toggle to match mode.
-    InkToggleAction* outerStyle = INK_TOGGLE_ACTION(g_object_get_data (tbl, "TextOuterStyleAction"));
-
     switch (mode) {
         case 0: // Adaptive
-            gtk_toggle_action_set_active( &(outerStyle->action), false );
+            gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(_outer_style_action), false );
             prefs->setInt("/tools/text/outer_style", false);
             break;
 
         case 1: // Minimum
         case 2: // Even
-            gtk_toggle_action_set_active( &(outerStyle->action), true );
+            gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(_outer_style_action), true );
             prefs->setInt("/tools/text/outer_style", true);
             break;
 
@@ -1035,22 +1824,17 @@ static void sp_text_line_spacing_mode_changed( GObject *tbl, int mode )
     }
 
     // Outer style toggle set per mode so that line height widget should be enabled.
-    GtkAction* lineHeightAction = GTK_ACTION( g_object_get_data( tbl, "TextLineHeightAction" ) );
-    gtk_action_set_sensitive (lineHeightAction, true);
+    gtk_action_set_sensitive(GTK_ACTION(_line_height_action), true);
 
     // Update "climb rate"
-    EgeAdjustmentAction *line_height_act =
-        reinterpret_cast<EgeAdjustmentAction *>(g_object_get_data(tbl, "TextLineHeightAction"));
-    GtkAdjustment *line_height_adj = ege_adjustment_action_get_adjustment( line_height_act );
-    UnitTracker *tracker = reinterpret_cast<UnitTracker*>(g_object_get_data(tbl, "tracker"));
-    Unit const *unit = tracker->getActiveUnit();
+    Unit const *unit = _tracker->getActiveUnit();
 
     if (unit->abbr == "%") {
-        gtk_adjustment_set_step_increment (line_height_adj,  1.0);
-        gtk_adjustment_set_page_increment (line_height_adj, 10.0);
+        _line_height_adj->set_step_increment(1.0);
+        _line_height_adj->set_page_increment(10.0);
     } else {
-        gtk_adjustment_set_step_increment (line_height_adj,  0.1);
-        gtk_adjustment_set_page_increment (line_height_adj,  1.0);
+        _line_height_adj->set_step_increment(0.1);
+        _line_height_adj->set_page_increment(1.0);
     }
 
     DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_TEXT,
@@ -1058,22 +1842,23 @@ static void sp_text_line_spacing_mode_changed( GObject *tbl, int mode )
 
     gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas));
 
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-static void sp_text_wordspacing_value_changed( GtkAdjustment *adj, GObject *tbl )
+void
+TextToolbar::wordspacing_value_changed()
 {
     // quit if run by the _changed callbacks
-    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
+    if (_freeze) {
         return;
     }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+    _freeze = true;
 
     // At the moment this handles only numerical values (i.e. no em unit).
     // Set css word-spacing
     SPCSSAttr *css = sp_repr_css_attr_new ();
     Inkscape::CSSOStringStream osfs;
-    osfs << gtk_adjustment_get_value(adj) << "px"; // For now always use px
+    osfs << _word_spacing_adj->get_value() << "px"; // For now always use px
     sp_repr_css_set_property (css, "word-spacing", osfs.str().c_str());
 
     // Apply word-spacing to selected objects.
@@ -1096,22 +1881,23 @@ static void sp_text_wordspacing_value_changed( GtkAdjustment *adj, GObject *tbl
 
     sp_repr_css_attr_unref (css);
 
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-static void sp_text_letterspacing_value_changed( GtkAdjustment *adj, GObject *tbl )
+void
+TextToolbar::letterspacing_value_changed()
 {
     // quit if run by the _changed callbacks
-    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
+    if (_freeze) {
         return;
     }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+    _freeze = true;
 
     // At the moment this handles only numerical values (i.e. no em unit).
     // Set css letter-spacing
     SPCSSAttr *css = sp_repr_css_attr_new ();
     Inkscape::CSSOStringStream osfs;
-    osfs << gtk_adjustment_get_value(adj) << "px";  // For now always use px
+    osfs << _letter_spacing_adj->get_value() << "px";  // For now always use px
     sp_repr_css_set_property (css, "letter-spacing", osfs.str().c_str());
 
     // Apply letter-spacing to selected objects.
@@ -1136,19 +1922,19 @@ static void sp_text_letterspacing_value_changed( GtkAdjustment *adj, GObject *tb
 
     sp_repr_css_attr_unref (css);
 
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-
-static void sp_text_dx_value_changed( GtkAdjustment *adj, GObject *tbl )
+void
+TextToolbar::dx_value_changed()
 {
     // quit if run by the _changed callbacks
-    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
+    if (_freeze) {
         return;
     }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+    _freeze = true;
 
-    gdouble new_dx = gtk_adjustment_get_value(adj);
+    gdouble new_dx = _dx_adj->get_value();
     bool modmade = false;
 
     if( SP_IS_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context) ) {
@@ -1171,18 +1957,19 @@ static void sp_text_dx_value_changed( GtkAdjustment *adj, GObject *tbl )
         DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:dx", SP_VERB_NONE,
                              _("Text: Change dx (kern)"));
     }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-static void sp_text_dy_value_changed( GtkAdjustment *adj, GObject *tbl )
+void
+TextToolbar::dy_value_changed()
 {
     // quit if run by the _changed callbacks
-    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
+    if (_freeze) {
         return;
     }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+    _freeze = true;
 
-    gdouble new_dy = gtk_adjustment_get_value(adj);
+    gdouble new_dy = _dy_adj->get_value();
     bool modmade = false;
 
     if( SP_IS_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context) ) {
@@ -1206,18 +1993,19 @@ static void sp_text_dy_value_changed( GtkAdjustment *adj, GObject *tbl )
                             _("Text: Change dy"));
     }
 
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-static void sp_text_rotation_value_changed( GtkAdjustment *adj, GObject *tbl )
+void
+TextToolbar::rotation_value_changed()
 {
     // quit if run by the _changed callbacks
-    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
+    if (_freeze) {
         return;
     }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+    _freeze = true;
 
-    gdouble new_degrees = gtk_adjustment_get_value(adj);
+    gdouble new_degrees = _rotation_adj->get_value();
 
     bool modmade = false;
     if( SP_IS_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context) ) {
@@ -1241,199 +2029,57 @@ static void sp_text_rotation_value_changed( GtkAdjustment *adj, GObject *tbl )
                             _("Text: Change rotate"));
     }
 
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
-}
-
-static void sp_writing_mode_changed( GObject* tbl, int mode )
-{
-    // quit if run by the _changed callbacks
-    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
-        return;
-    }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
-
-    SPCSSAttr   *css        = sp_repr_css_attr_new ();
-    switch (mode)
-    {
-        case 0:
-        {
-            sp_repr_css_set_property (css, "writing-mode", "lr-tb");
-            break;
-        }
-
-        case 1:
-        {
-            sp_repr_css_set_property (css, "writing-mode", "tb-rl");
-            break;
-        }
-
-        case 2:
-        {
-            sp_repr_css_set_property (css, "writing-mode", "vertical-lr");
-            break;
-        }
-}
-
-    SPStyle query(SP_ACTIVE_DOCUMENT);
-    int result_numbers =
-        sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_WRITINGMODES);
-
-    // If querying returned nothing, update default style.
-    if (result_numbers == QUERY_STYLE_NOTHING)
-    {
-        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->mergeStyle("/tools/text/style", css);
-    }
-
-    sp_desktop_set_style (SP_ACTIVE_DESKTOP, css, true, true);
-    if(result_numbers != QUERY_STYLE_NOTHING)
-    {
-        DocumentUndo::done(SP_ACTIVE_DESKTOP->getDocument(), SP_VERB_CONTEXT_TEXT,
-                       _("Text: Change writing mode"));
-    }
-    sp_repr_css_attr_unref (css);
-
-    gtk_widget_grab_focus (GTK_WIDGET(SP_ACTIVE_DESKTOP->canvas));
-
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    _freeze = false;
 }
 
-static void sp_text_orientation_changed( GObject* tbl, int mode )
+// Unset line height on selection's inner text objects (tspan, etc.).
+void
+TextToolbar::lineheight_unset_changed(InkToggleAction*act, gpointer data)
 {
-    // quit if run by the _changed callbacks
-    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
-        return;
-    }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
-
-    SPCSSAttr   *css        = sp_repr_css_attr_new ();
-    switch (mode)
-    {
-        case 0:
-        {
-            sp_repr_css_set_property (css, "text-orientation", "auto");
-            break;
-        }
-
-        case 1:
-        {
-            sp_repr_css_set_property (css, "text-orientation", "upright");
-            break;
-        }
-
-        case 2:
-        {
-            sp_repr_css_set_property (css, "text-orientation", "sideways");
-            break;
-        }
-    }
-
-    SPStyle query(SP_ACTIVE_DOCUMENT);
-    int result_numbers =
-        sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_WRITINGMODES);
-
-    // If querying returned nothing, update default style.
-    if (result_numbers == QUERY_STYLE_NOTHING)
-    {
-        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->mergeStyle("/tools/text/style", css);
-    }
+    auto toolbar = reinterpret_cast<TextToolbar *>(data);
 
-    sp_desktop_set_style (SP_ACTIVE_DESKTOP, css, true, true);
-    if(result_numbers != QUERY_STYLE_NOTHING)
-    {
-        DocumentUndo::done(SP_ACTIVE_DESKTOP->getDocument(), SP_VERB_CONTEXT_TEXT,
-                       _("Text: Change orientation"));
-    }
-    sp_repr_css_attr_unref (css);
-
-    gtk_widget_grab_focus (GTK_WIDGET(SP_ACTIVE_DESKTOP->canvas));
-
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
-}
-
-static void sp_text_direction_changed( GObject *tbl, int mode )
-{
     // quit if run by the _changed callbacks
-    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
+    if (toolbar->_freeze) {
         return;
     }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
+    toolbar->_freeze = true;
 
-    SPCSSAttr   *css        = sp_repr_css_attr_new ();
-    switch (mode)
-    {
-        case 0:
-        {
-            sp_repr_css_set_property (css, "direction", "ltr");
-            break;
-        }
-
-        case 1:
-        {
-            sp_repr_css_set_property (css, "direction", "rtl");
-            break;
-        }
-    }
-
-    SPStyle query(SP_ACTIVE_DOCUMENT);
-    int result_numbers =
-        sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_WRITINGMODES);
+    SPCSSAttr *css = sp_repr_css_attr_new();
+    sp_repr_css_unset_property(css, "line-height");
 
-    // If querying returned nothing, update default style.
-    if (result_numbers == QUERY_STYLE_NOTHING)
-    {
-        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->mergeStyle("/tools/text/style", css);
-    }
+    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+    sp_desktop_set_style (desktop, css);
 
-    sp_desktop_set_style (SP_ACTIVE_DESKTOP, css, true, true);
-    if(result_numbers != QUERY_STYLE_NOTHING)
-    {
-        DocumentUndo::done(SP_ACTIVE_DESKTOP->getDocument(), SP_VERB_CONTEXT_TEXT,
-                       _("Text: Change direction"));
-    }
-    sp_repr_css_attr_unref (css);
+    sp_repr_css_attr_unref(css);
 
-    gtk_widget_grab_focus (GTK_WIDGET(SP_ACTIVE_DESKTOP->canvas));
+    DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_TEXT,
+                       _("Text: Unset line height."));
 
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    toolbar->_freeze = false;
 }
 
-/*
- * Set the default list of font sizes, scaled to the users preferred unit
- */
-static void sp_text_set_sizes(GtkListStore* model_size, int unit)
+// Changes selection to only text outer elements.
+void
+TextToolbar::outer_style_changed( InkToggleAction *act, gpointer data )
 {
-    gtk_list_store_clear(model_size);
-
-    // List of font sizes for drop-down menu
-    int sizes[] = {
-        4, 6, 8, 9, 10, 11, 12, 13, 14, 16, 18, 20, 22, 24, 28,
-        32, 36, 40, 48, 56, 64, 72, 144
-    };
-
-    // Array must be same length as SPCSSUnit in style.h
-    float ratios[] = {1, 1, 1, 10, 4, 40, 100, 16, 8, 0.16};
+    auto toolbar = reinterpret_cast<TextToolbar *>(data);
+    bool outer = gtk_toggle_action_get_active( GTK_TOGGLE_ACTION(act) );
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setInt("/tools/text/outer_style", outer);
 
-    for(int i : sizes) {
-        GtkTreeIter iter;
-        Glib::ustring size = Glib::ustring::format(i / (float)ratios[unit]);
-        gtk_list_store_append( model_size, &iter );
-        gtk_list_store_set( model_size, &iter, 0, size.c_str(), -1 );
-    }
+    // Update widgets to reflect new state of Text Outer Style button.
+    toolbar->selection_changed(nullptr);
 }
 
-
 /*
  * This function sets up the text-tool tool-controls, setting the entry boxes
  * etc. to the values from the current selection or the default if no selection.
  * It is called whenever a text selection is changed, including stepping cursor
  * through text, or setting focus to text.
  */
-static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/, GObject *tbl, bool subselection) // don't bother to update font list if subsel changed
+void
+TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subselection) // don't bother to update font list if subsel changed
 {
-
 #ifdef DEBUG_TEXT
     static int count = 0;
     ++count;
@@ -1452,7 +2098,7 @@ static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/
 #endif
 
     // quit if run by the _changed callbacks
-    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
+    if (_freeze) {
 #ifdef DEBUG_TEXT
         std::cout << "    Frozen, returning" << std::endl;
         std::cout << "sp_text_toolbox_selection_changed: exit " << count << std::endl;
@@ -1461,21 +2107,16 @@ static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/
 #endif
         return;
     }
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
-
-    Ink_ComboBoxEntry_Action* fontFamilyAction =
-        INK_COMBOBOXENTRY_ACTION( g_object_get_data( tbl, "TextFontFamilyAction" ) );
-    Ink_ComboBoxEntry_Action* fontStyleAction =
-        INK_COMBOBOXENTRY_ACTION( g_object_get_data( tbl, "TextFontStyleAction"  ) );
+    _freeze = true;
 
     Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance();
     fontlister->update_font_list (SP_ACTIVE_DESKTOP->getDocument());
     fontlister->selection_update();
 
     // Update font list, but only if widget already created.
-    if( fontFamilyAction->combobox != nullptr ) {
-        ink_comboboxentry_action_set_active_text( fontFamilyAction, fontlister->get_font_family().c_str(), fontlister->get_font_family_row() );
-        ink_comboboxentry_action_set_active_text( fontStyleAction,  fontlister->get_font_style().c_str()  );
+    if( _font_family_action->combobox != nullptr ) {
+        ink_comboboxentry_action_set_active_text( _font_family_action, fontlister->get_font_family().c_str(), fontlister->get_font_family_row() );
+        ink_comboboxentry_action_set_active_text( _font_style_action,  fontlister->get_font_style().c_str()  );
     }
 
     // Only flowed text can be justified, only normal text can be kerned...
@@ -1536,9 +2177,9 @@ static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/
         std::cout << "    read style from prefs:" << std::endl;
         sp_print_font( &query );
 #endif
-        if (g_object_get_data(tbl, "text_style_from_prefs")) {
+        if (_text_style_from_prefs) {
             // Do not reset the toolbar style from prefs if we already did it last time
-            g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+            _freeze = false;
 #ifdef DEBUG_TEXT
             std::cout << "    text_style_from_prefs: toolbar already set" << std:: endl;
             std::cout << "sp_text_toolbox_selection_changed: exit " << count << std::endl;
@@ -1550,11 +2191,11 @@ static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/
 
         // To ensure the value of the combobox is properly set on start-up, only mark
         // the prefs set if the combobox has already been constructed.
-        if( fontFamilyAction->combobox != nullptr ) {
-            g_object_set_data(tbl, "text_style_from_prefs", GINT_TO_POINTER(TRUE));
+        if( _font_family_action->combobox != nullptr ) {
+            _text_style_from_prefs = true;
         }
     } else {
-        g_object_set_data(tbl, "text_style_from_prefs", GINT_TO_POINTER(FALSE));
+        _text_style_from_prefs = false;
     }
 
     // If we have valid query data for text (font-family, font-specification) set toolbar accordingly.
@@ -1570,18 +2211,15 @@ static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/
         Inkscape::CSSOStringStream os;
         os << size;
 
-        Ink_ComboBoxEntry_Action* fontSizeAction =
-            INK_COMBOBOXENTRY_ACTION( g_object_get_data( tbl, "TextFontSizeAction" ) );
-
         // Freeze to ignore callbacks.
         //g_object_freeze_notify( G_OBJECT( fontSizeAction->combobox ) );
-        sp_text_set_sizes(GTK_LIST_STORE(ink_comboboxentry_action_get_model(fontSizeAction)), unit);
+        sp_text_set_sizes(GTK_LIST_STORE(ink_comboboxentry_action_get_model(_font_size_action)), unit);
         //g_object_thaw_notify( G_OBJECT( fontSizeAction->combobox ) );
 
-        ink_comboboxentry_action_set_active_text( fontSizeAction, os.str().c_str() );
+        ink_comboboxentry_action_set_active_text( _font_size_action, os.str().c_str() );
 
         Glib::ustring tooltip = Glib::ustring::format(_("Font size"), " (", sp_style_get_css_unit_string(unit), ")");
-        ink_comboboxentry_action_set_tooltip ( fontSizeAction, tooltip.c_str());
+        ink_comboboxentry_action_set_tooltip ( _font_size_action, tooltip.c_str());
 
         // Superscript
         gboolean superscriptSet =
@@ -1590,9 +2228,7 @@ static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/
              query.baseline_shift.type == SP_BASELINE_SHIFT_LITERAL &&
              query.baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUPER );
 
-        InkToggleAction* textSuperscriptAction = INK_TOGGLE_ACTION( g_object_get_data( tbl, "TextSuperscriptAction" ) );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(textSuperscriptAction), superscriptSet );
-
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(_superscript_action), superscriptSet );
 
         // Subscript
         gboolean subscriptSet =
@@ -1601,20 +2237,16 @@ static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/
              query.baseline_shift.type == SP_BASELINE_SHIFT_LITERAL &&
              query.baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUB );
 
-        InkToggleAction* textSubscriptAction = INK_TOGGLE_ACTION( g_object_get_data( tbl, "TextSubscriptAction" ) );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(textSubscriptAction), subscriptSet );
-
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(_subscript_action), subscriptSet );
 
         // Alignment
-        InkSelectOneAction* textAlignAction =
-            static_cast<InkSelectOneAction*>( g_object_get_data( tbl, "TextAlignAction" ) );
 
         // Note: SVG 1.1 doesn't include text-align, SVG 1.2 Tiny doesn't include text-align="justify"
         // text-align="justify" was a draft SVG 1.2 item (along with flowed text).
         // Only flowed text can be left and right justified at the same time.
         // Disable button if we don't have flowed text.
 
-        Glib::RefPtr<Gtk::ListStore> store = textAlignAction->get_store();
+        Glib::RefPtr<Gtk::ListStore> store = _align_action->get_store();
         Gtk::TreeModel::Row row = *(store->get_iter("3"));  // Justify entry
         InkSelectOneActionColumns columns;
         row[columns.col_sensitive] = isFlow;
@@ -1629,7 +2261,7 @@ static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/
             if (query.text_anchor.computed == SP_CSS_TEXT_ANCHOR_MIDDLE) activeButton = 1;
             if (query.text_anchor.computed == SP_CSS_TEXT_ANCHOR_END)    activeButton = 2;
         }
-        textAlignAction->set_active( activeButton );
+        _align_action->set_active( activeButton );
 
         // Line height (spacing) and line height unit
         double height;
@@ -1673,37 +2305,30 @@ static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/
                     Quantity::convert(height, "px", sp_style_get_css_unit_string(line_height_unit));
         }
 
-        GtkAction* lineHeightAction = GTK_ACTION( g_object_get_data( tbl, "TextLineHeightAction" ) );
-        GtkAdjustment *lineHeightAdjustment =
-            ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( lineHeightAction ));
-        gtk_adjustment_set_value( lineHeightAdjustment, height );
+        _line_height_adj->set_value(height);
 
         // Update "climb rate"
         if (line_height_unit == SP_CSS_UNIT_PERCENT) {
-            gtk_adjustment_set_step_increment (lineHeightAdjustment,  1.0);
-            gtk_adjustment_set_page_increment (lineHeightAdjustment, 10.0);
+            _line_height_adj->set_step_increment(1.0);
+            _line_height_adj->set_page_increment(10.0);
         } else {
-            gtk_adjustment_set_step_increment (lineHeightAdjustment,  0.1);
-            gtk_adjustment_set_page_increment (lineHeightAdjustment,  1.0);
+            _line_height_adj->set_step_increment(0.1);
+            _line_height_adj->set_page_increment(1.0);
         }
 
-        UnitTracker* tracker = reinterpret_cast<UnitTracker*>( g_object_get_data( tbl, "tracker" ) );
         if( line_height_unit == SP_CSS_UNIT_NONE ) {
             // Function 'sp_style_get_css_unit_string' returns 'px' for unit none.
             // We need to avoid this.
-            tracker->setActiveUnitByAbbr("");
+            _tracker->setActiveUnitByAbbr("");
         } else {
-            tracker->setActiveUnitByAbbr(sp_style_get_css_unit_string(line_height_unit));
+            _tracker->setActiveUnitByAbbr(sp_style_get_css_unit_string(line_height_unit));
         }
         // Save unit so we can do conversions between new/old units.
-        g_object_set_data( tbl, "lineheight_unit", GINT_TO_POINTER(line_height_unit));
+        _lineheight_unit = line_height_unit;
 
         // Enable and turn on only if selection includes an object with line height set.
-        InkToggleAction* lineHeightUnset =
-            INK_TOGGLE_ACTION( g_object_get_data( tbl, "TextLineHeightUnsetAction"));
-        gtk_action_set_sensitive(GTK_ACTION(lineHeightUnset), query.line_height.set );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(lineHeightUnset), query.line_height.set );
-
+        gtk_action_set_sensitive(GTK_ACTION(_line_height_unset_action), query.line_height.set );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(_line_height_unset_action), query.line_height.set );
 
         // Line spacing mode: requires calculating mode for each <text> element and the <tspan>s within.
         Inkscape::Selection *selection = desktop->getSelection();
@@ -1757,27 +2382,23 @@ static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/
         //           << ", "<< mode[1]
         //           << ", "<< mode[2]
         //           << ", "<< mode[3] << std::endl;
-        InkSelectOneAction* textLineSpacingAction =
-            static_cast<InkSelectOneAction*>( g_object_get_data( tbl, "TextLineSpacingAction" ) );
-        textLineSpacingAction->set_active( activeButtonLS );
+        _line_spacing_action->set_active( activeButtonLS );
 
         // Enable/disable line height widget based on mode and Outer Style toggle.
         if ( (activeButtonLS == 0 && outer)  ||   // Adaptive
              (activeButtonLS == 1 && !outer) ||   // Minimum
              (activeButtonLS == 2 && !outer)      // Even
             ) {
-            gtk_action_set_sensitive (lineHeightAction, false);
+            gtk_action_set_sensitive (GTK_ACTION(_line_height_action), false);
         } else {
-            gtk_action_set_sensitive (lineHeightAction, true);
+            gtk_action_set_sensitive (GTK_ACTION(_line_height_action), true);
         }
 
         // In Minimum and Adaptive modes, don't allow unit change (must remain unitless).
-        InkSelectOneAction* textLineHeightUnitsAction =
-            static_cast<InkSelectOneAction*>(g_object_get_data( tbl, "TextLineHeightUnitsAction") );
         if (activeButtonLS == 0 || (activeButtonLS == 1 && outer)) {
-            textLineHeightUnitsAction->set_sensitive(false);
+            _line_height_units_action->set_sensitive(false);
         } else {
-            textLineHeightUnitsAction->set_sensitive(true);
+            _line_height_units_action->set_sensitive(true);
         }
 
         // Word spacing
@@ -1785,21 +2406,14 @@ static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/
         if (query.word_spacing.normal) wordSpacing = 0.0;
         else wordSpacing = query.word_spacing.computed; // Assume no units (change in desktop-style.cpp)
 
-        GtkAction* wordSpacingAction = GTK_ACTION( g_object_get_data( tbl, "TextWordSpacingAction" ) );
-        GtkAdjustment *wordSpacingAdjustment =
-            ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( wordSpacingAction ));
-        gtk_adjustment_set_value( wordSpacingAdjustment, wordSpacing );
-
+        _word_spacing_adj->set_value(wordSpacing);
 
         // Letter spacing
         double letterSpacing;
         if (query.letter_spacing.normal) letterSpacing = 0.0;
         else letterSpacing = query.letter_spacing.computed; // Assume no units (change in desktop-style.cpp)
 
-        GtkAction* letterSpacingAction = GTK_ACTION( g_object_get_data( tbl, "TextLetterSpacingAction" ) );
-        GtkAdjustment *letterSpacingAdjustment =
-            ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( letterSpacingAction ));
-        gtk_adjustment_set_value( letterSpacingAdjustment, letterSpacing );
+        _letter_spacing_adj->set_value(letterSpacing);
 
 
         // Writing mode
@@ -1808,9 +2422,7 @@ static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/
         if (query.writing_mode.computed == SP_CSS_WRITING_MODE_TB_RL) activeButton2 = 1;
         if (query.writing_mode.computed == SP_CSS_WRITING_MODE_TB_LR) activeButton2 = 2;
 
-        InkSelectOneAction* writingModeAction =
-            static_cast<InkSelectOneAction*>( g_object_get_data( tbl, "TextWritingModeAction" ) );
-        writingModeAction->set_active( activeButton2 );
+        _writing_mode_action->set_active( activeButton2 );
 
         // Orientation
         int activeButton3 = 0;
@@ -1818,20 +2430,16 @@ static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/
         if (query.text_orientation.computed == SP_CSS_TEXT_ORIENTATION_UPRIGHT ) activeButton3 = 1;
         if (query.text_orientation.computed == SP_CSS_TEXT_ORIENTATION_SIDEWAYS) activeButton3 = 2;
 
-        InkSelectOneAction* textOrientationAction =
-            static_cast<InkSelectOneAction*>( g_object_get_data( tbl, "TextOrientationAction" ) );
-        textOrientationAction->set_active( activeButton3 );
+        _orientation_action->set_active( activeButton3 );
 
         // Disable text orientation for horizontal text...
-        textOrientationAction->set_sensitive( activeButton2 != 0 );
+        _orientation_action->set_sensitive( activeButton2 != 0 );
 
         // Direction
         int activeButton4 = 0;
         if (query.direction.computed == SP_CSS_DIRECTION_LTR ) activeButton4 = 0;
         if (query.direction.computed == SP_CSS_DIRECTION_RTL ) activeButton4 = 1;
-        InkSelectOneAction* textDirectionAction =
-            static_cast<InkSelectOneAction*>( g_object_get_data( tbl, "TextDirectionAction" ) );
-        textDirectionAction->set_active( activeButton4 );
+        _direction_action->set_active( activeButton4 );
     }
 
 #ifdef DEBUG_TEXT
@@ -1866,26 +2474,17 @@ static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/
 
                 // Dx
                 double dx = attributes->getDx( char_index );
-                GtkAction* dxAction = GTK_ACTION( g_object_get_data( tbl, "TextDxAction" ));
-                GtkAdjustment *dxAdjustment =
-                    ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( dxAction ));
-                gtk_adjustment_set_value( dxAdjustment, dx );
+                _dx_adj->set_value(dx);
 
                 // Dy
                 double dy = attributes->getDy( char_index );
-                GtkAction* dyAction = GTK_ACTION( g_object_get_data( tbl, "TextDyAction" ));
-                GtkAdjustment *dyAdjustment =
-                    ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( dyAction ));
-                gtk_adjustment_set_value( dyAdjustment, dy );
+                _dy_adj->set_value(dy);
 
                 // Rotation
                 double rotation = attributes->getRotate( char_index );
                 /* SVG value is between 0 and 360 but we're using -180 to 180 in widget */
                 if( rotation > 180.0 ) rotation -= 360.0;
-                GtkAction* rotationAction = GTK_ACTION( g_object_get_data( tbl, "TextRotationAction" ));
-                GtkAdjustment *rotationAdjustment =
-                    ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( rotationAction ));
-                gtk_adjustment_set_value( rotationAdjustment, rotation );
+                _rotation_adj->set_value(rotation);
 
 #ifdef DEBUG_TEXT
                 std::cout << "    GUI: Dx: " << dx << std::endl;
@@ -1898,14 +2497,9 @@ static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/
 
     {
         // Set these here as we don't always have kerning/rotating attributes
-        GtkAction* dxAction = GTK_ACTION( g_object_get_data( tbl, "TextDxAction" ));
-        gtk_action_set_sensitive( GTK_ACTION(dxAction), !isFlow );
-
-        GtkAction* dyAction = GTK_ACTION( g_object_get_data( tbl, "TextDyAction" ));
-        gtk_action_set_sensitive( GTK_ACTION(dyAction), !isFlow );
-
-        GtkAction* rotationAction = GTK_ACTION( g_object_get_data( tbl, "TextRotationAction" ));
-        gtk_action_set_sensitive( GTK_ACTION(rotationAction), !isFlow );
+        gtk_action_set_sensitive( GTK_ACTION(_dx_action), !isFlow );
+        gtk_action_set_sensitive( GTK_ACTION(_dy_action), !isFlow );
+        gtk_action_set_sensitive( GTK_ACTION(_rotation_action), !isFlow );
     }
 
 #ifdef DEBUG_TEXT
@@ -1914,671 +2508,18 @@ static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/
     std::cout << std::endl;
 #endif
 
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
-}
-
-static void sp_text_toolbox_selection_modified(Inkscape::Selection *selection, guint /*flags*/, GObject *tbl)
-{
-    sp_text_toolbox_selection_changed (selection, tbl);
-}
-
-static void
-sp_text_toolbox_subselection_changed (gpointer /*tc*/, GObject *tbl)
-{
-    sp_text_toolbox_selection_changed (nullptr, tbl, true);
+    _freeze = false;
 }
 
-// TODO: possibly share with font-selector by moving most code to font-lister (passing family name)
-static void sp_text_toolbox_select_cb( GtkEntry* entry, GtkEntryIconPosition /*position*/, GdkEvent /*event*/, gpointer /*data*/ ) {
-
-  Glib::ustring family = gtk_entry_get_text ( entry );
-  //std::cout << "text_toolbox_missing_font_cb: selecting: " << family << std::endl;
-
-  // Get all items with matching font-family set (not inherited!).
-  std::vector<SPItem*> selectList;
-
-  SPDesktop *desktop = SP_ACTIVE_DESKTOP;
-  SPDocument *document = desktop->getDocument();
-  std::vector<SPItem*> x,y;
-  std::vector<SPItem*> allList = get_all_items(x, document->getRoot(), desktop, false, false, true, y);
-  for(std::vector<SPItem*>::const_reverse_iterator i=allList.rbegin();i!=allList.rend(); ++i){
-      SPItem *item = *i;
-    SPStyle *style = item->style;
-
-    if (style) {
-
-      Glib::ustring family_style;
-      if (style->font_family.set) {
-	family_style = style->font_family.value;
-	//std::cout << " family style from font_family: " << family_style << std::endl;
-      }
-      else if (style->font_specification.set) {
-	family_style = style->font_specification.value;
-	//std::cout << " family style from font_spec: " << family_style << std::endl;
-      }
-
-      if (family_style.compare( family ) == 0 ) {
-        //std::cout << "   found: " << item->getId() << std::endl;
-	selectList.push_back(item);
-      }
-    }
-  }
-
-  // Update selection
-  Inkscape::Selection *selection = desktop->getSelection();
-  selection->clear();
-  //std::cout << "   list length: " << g_slist_length ( selectList ) << std::endl;
-  selection->setList(selectList);
-}
-
-static void text_toolbox_watch_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* holder);
-
-// Define all the "widgets" in the toolbar.
-void sp_text_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
-
-    /* Font family */
-    {
-        // Font list
-        Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance();
-        fontlister->update_font_list( SP_ACTIVE_DESKTOP->getDocument());
-        Glib::RefPtr<Gtk::ListStore> store = fontlister->get_font_list();
-        GtkListStore* model = store->gobj();
-
-        Ink_ComboBoxEntry_Action* act =
-            ink_comboboxentry_action_new( "TextFontFamilyAction",
-                                          _("Font Family"),
-                                          _("Select Font Family (Alt-X to access)"),
-                                          nullptr,
-                                          GTK_TREE_MODEL(model),
-                                          -1,                // Entry width
-                                          50,                // Extra list width
-                                          (gpointer)font_lister_cell_data_func2, // Cell layout
-                                          (gpointer)font_lister_separator_func2,
-                                          GTK_WIDGET(desktop->canvas)); // Focus widget
-        ink_comboboxentry_action_popup_enable( act ); // Enable entry completion
-
-        gchar *const info = _("Select all text with this font-family");
-        ink_comboboxentry_action_set_info( act, info ); // Show selection icon
-        ink_comboboxentry_action_set_info_cb( act, (gpointer)sp_text_toolbox_select_cb );
-
-        gchar *const warning = _("Font not found on system");
-        ink_comboboxentry_action_set_warning( act, warning ); // Show icon w/ tooltip if font missing
-        ink_comboboxentry_action_set_warning_cb( act, (gpointer)sp_text_toolbox_select_cb );
-
-        //ink_comboboxentry_action_set_warning_callback( act, sp_text_fontfamily_select_all );
-        ink_comboboxentry_action_set_altx_name( act, "altx-text" ); // Set Alt-X keyboard shortcut
-        g_signal_connect( G_OBJECT(act), "changed", G_CALLBACK(sp_text_fontfamily_value_changed), holder );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
-        g_object_set_data( holder, "TextFontFamilyAction", act );
-
-        // Change style of drop-down from menu to list
-        auto css_provider = gtk_css_provider_new();
-        gtk_css_provider_load_from_data(css_provider,
-                                        "#TextFontFamilyAction_combobox {\n"
-                                        "  -GtkComboBox-appears-as-list: true;\n"
-                                        "}\n",
-                                        -1, nullptr);
-
-        auto screen = gdk_screen_get_default();
-        gtk_style_context_add_provider_for_screen(screen,
-                                                  GTK_STYLE_PROVIDER(css_provider),
-                                                  GTK_STYLE_PROVIDER_PRIORITY_USER);
-    }
-
-    /* Font size */
-    {
-        // List of font sizes for drop-down menu
-        GtkListStore* model_size = gtk_list_store_new( 1, G_TYPE_STRING );
-        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        int unit = prefs->getInt("/options/font/unitType", SP_CSS_UNIT_PT);
-
-        sp_text_set_sizes(model_size, unit);
-
-        Glib::ustring tooltip = Glib::ustring::format(_("Font size"), " (", sp_style_get_css_unit_string(unit), ")");
-
-        Ink_ComboBoxEntry_Action* act = ink_comboboxentry_action_new( "TextFontSizeAction",
-                                                                      _("Font Size"),
-                                                                      _(tooltip.c_str()),
-                                                                      nullptr,
-                                                                      GTK_TREE_MODEL(model_size),
-                                                                      8,      // Width in characters
-                                                                      0,      // Extra list width
-                                                                      nullptr,   // Cell layout
-                                                                      nullptr,   // Separator
-                                                                      GTK_WIDGET(desktop->canvas)); // Focus widget
-
-        g_signal_connect( G_OBJECT(act), "changed", G_CALLBACK(sp_text_fontsize_value_changed), holder );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
-        g_object_set_data( holder, "TextFontSizeAction", act );
-    }
-
-    /* Font styles */
-    {
-        Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance();
-        Glib::RefPtr<Gtk::ListStore> store = fontlister->get_style_list();
-        GtkListStore* model_style = store->gobj();
-
-        Ink_ComboBoxEntry_Action* act = ink_comboboxentry_action_new( "TextFontStyleAction",
-                                                                      _("Font Style"),
-                                                                      _("Font style"),
-                                                                      nullptr,
-                                                                      GTK_TREE_MODEL(model_style),
-                                                                      12,     // Width in characters
-                                                                      0,      // Extra list width
-                                                                      nullptr,   // Cell layout
-                                                                      nullptr,   // Separator
-                                                                      GTK_WIDGET(desktop->canvas)); // Focus widget
-
-        g_signal_connect( G_OBJECT(act), "changed", G_CALLBACK(sp_text_fontstyle_value_changed), holder );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
-        g_object_set_data( holder, "TextFontStyleAction", act );
-    }
-
-    /* Style - Superscript */
-    {
-        InkToggleAction* act = ink_toggle_action_new( "TextSuperscriptAction",             // Name
-                                                      _("Toggle Superscript"),             // Label
-                                                      _("Toggle superscript"),             // Tooltip
-                                                      "text_superscript",                  // Icon (inkId)
-                                                      secondarySize );                     // Icon size
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_text_script_changed), holder );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/text/super", false) );
-        g_object_set_data( holder, "TextSuperscriptAction", act );
-    }
-
-    /* Style - Subscript */
-    {
-        InkToggleAction* act = ink_toggle_action_new( "TextSubscriptAction",             // Name
-                                                      _("Toggle Subscript"),             // Label
-                                                      _("Toggle subscript"),             // Tooltip
-                                                      "text_subscript",                  // Icon (inkId)
-                                                      secondarySize );                   // Icon size
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_text_script_changed), holder );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/text/sub", false) );
-        g_object_set_data( holder, "TextSubscriptAction", act );
-    }
-
-    /* Alignment */
-    {
-        InkSelectOneActionColumns columns;
-
-        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
-
-        Gtk::TreeModel::Row row;
-
-        row = *(store->append());
-        row[columns.col_label    ] = _("Align left");
-        row[columns.col_tooltip  ] = _("Align left");
-        row[columns.col_icon     ] = INKSCAPE_ICON("format-justify-left");
-        row[columns.col_sensitive] = true;
-
-        row = *(store->append());
-        row[columns.col_label    ] = _("Align center");
-        row[columns.col_tooltip  ] = _("Align center");
-        row[columns.col_icon     ] = INKSCAPE_ICON("format-justify-center");
-        row[columns.col_sensitive] = true;
-
-        row = *(store->append());
-        row[columns.col_label    ] = _("Align right");
-        row[columns.col_tooltip  ] = _("Align right");
-        row[columns.col_icon     ] = INKSCAPE_ICON("format-justify-right");
-        row[columns.col_sensitive] = true;
-
-        row = *(store->append());
-        row[columns.col_label    ] = _("Justify");
-        row[columns.col_tooltip  ] = _("Justify (only flowed text)");
-        row[columns.col_icon     ] = INKSCAPE_ICON("format-justify-fill");
-        row[columns.col_sensitive] = false;
-
-        InkSelectOneAction* act =
-            InkSelectOneAction::create( "TextAlignAction",   // Name
-                                        _("Alignment"),      // Label
-                                        _("Text alignment"), // Tooltip
-                                        "Not Used",          // Icon
-                                        store );             // Tree store
-        act->use_radio( false );
-        act->use_label( false );
-        gint mode = prefs->getInt("/tools/text/align_mode", 0);
-        act->set_active( mode );
-
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data( holder, "TextAlignAction", act );
-
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_text_align_mode_changed), holder));
-    }
-
-    /* Writing mode (Horizontal, Vertical-LR, Vertical-RL) */
-    {
-        InkSelectOneActionColumns columns;
-
-        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
-
-        Gtk::TreeModel::Row row;
-
-        row = *(store->append());
-        row[columns.col_label    ] = _("Horizontal");
-        row[columns.col_tooltip  ] = _("Horizontal text");
-        row[columns.col_icon     ] = INKSCAPE_ICON("format-text-direction-horizontal");
-        row[columns.col_sensitive] = true;
-
-        row = *(store->append());
-        row[columns.col_label    ] = _("Vertical — RL");
-        row[columns.col_tooltip  ] = _("Vertical text — lines: right to left");
-        row[columns.col_icon     ] = INKSCAPE_ICON("format-text-direction-vertical");
-        row[columns.col_sensitive] = true;
-
-        row = *(store->append());
-        row[columns.col_label    ] = _("Vertical — LR");
-        row[columns.col_tooltip  ] = _("Vertical text — lines: left to right");
-        row[columns.col_icon     ] = INKSCAPE_ICON("format-text-direction-vertical-lr");
-        row[columns.col_sensitive] = true;
-
-        InkSelectOneAction* act =
-            InkSelectOneAction::create( "TextWritingModeAction", // Name
-                                        _("Writing mode"),       // Label
-                                        _("Block progression"),  // Tooltip
-                                        "Not Used",              // Icon
-                                        store );                 // Tree store
-        act->use_radio( false );
-        act->use_label( false );
-        gint mode = prefs->getInt("/tools/text/writing_mode", 0);
-        act->set_active( mode );
-
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data( holder, "TextWritingModeAction", act );
-
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_writing_mode_changed), holder));
-    }
-
-    /* Text (glyph) orientation (Auto (mixed), Upright, Sideways) */
-    {
-        InkSelectOneActionColumns columns;
-
-        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
-
-        Gtk::TreeModel::Row row;
-
-        row = *(store->append());
-        row[columns.col_label    ] = _("Auto");
-        row[columns.col_tooltip  ] = _("Auto glyph orientation");
-        row[columns.col_icon     ] = INKSCAPE_ICON("text-orientation-auto");
-        row[columns.col_sensitive] = true;
-
-        row = *(store->append());
-        row[columns.col_label    ] = _("Upright");
-        row[columns.col_tooltip  ] = _("Upright glyph orientation");
-        row[columns.col_icon     ] = INKSCAPE_ICON("text-orientation-upright");
-        row[columns.col_sensitive] = true;
-
-        row = *(store->append());
-        row[columns.col_label    ] = _("Sideways");
-        row[columns.col_tooltip  ] = _("Sideways glyph orientation");
-        row[columns.col_icon     ] = INKSCAPE_ICON("text-orientation-sideways");
-        row[columns.col_sensitive] = true;
-
-        InkSelectOneAction* act =
-            InkSelectOneAction::create( "TextOrientationAction",  // Name
-                                        _("Text orientation"),    // Label
-                                        _("Text (glyph) orientation in vertical text."),  // Tooltip
-                                        "Not Used",               // Icon
-                                        store );                  // List store
-        act->use_radio( false );
-        act->use_label( false );
-        gint mode = prefs->getInt("/tools/text/text_orientation", 0);
-        act->set_active( mode );
-
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data( holder, "TextOrientationAction", act );
-
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_text_orientation_changed), holder));
-    }
-
-
-    // Text direction (predominant direction of horizontal text).
-    {
-        InkSelectOneActionColumns columns;
-
-        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
-
-        Gtk::TreeModel::Row row;
-
-        row = *(store->append());
-        row[columns.col_label    ] = _("LTR");
-        row[columns.col_tooltip  ] = _("Left to right text");
-        row[columns.col_icon     ] = INKSCAPE_ICON("format-text-direction-horizontal");
-        row[columns.col_sensitive] = true;
-
-        row = *(store->append());
-        row[columns.col_label    ] = _("RTL");
-        row[columns.col_tooltip  ] = _("Right to left text");
-        row[columns.col_icon     ] = INKSCAPE_ICON("format-text-direction-r2l");
-        row[columns.col_sensitive] = true;
-
-        InkSelectOneAction* act =
-            InkSelectOneAction::create( "TextDirectionAction",  // Name
-                                        _("Text direction"),    // Label
-                                        _("Text direction for normally horizontal text."),  // Tooltip
-                                        "Not Used",               // Icon
-                                        store );                  // List store
-        act->use_radio( false );
-        act->use_label( false );
-        gint mode = prefs->getInt("/tools/text/text_direction", 0);
-        act->set_active( mode );
-
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data( holder, "TextDirectionAction", act );
-
-        act->signal_changed_after().connect(sigc::bind<0>(sigc::ptr_fun(&sp_text_direction_changed), holder));
-    }
-
-    /* Line height unit tracker */
-    UnitTracker* tracker = new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR);
-    tracker->prependUnit(unit_table.getUnit("")); // No unit
-    tracker->addUnit(unit_table.getUnit("%"));
-    tracker->addUnit(unit_table.getUnit("em"));
-    tracker->addUnit(unit_table.getUnit("ex"));
-    tracker->setActiveUnit(unit_table.getUnit("%"));
-    g_object_set_data( holder, "tracker", tracker );
-
-    /* Line height */
-    {
-        // Drop down menu
-        gchar const* labels[] = {_("Smaller spacing"), nullptr, nullptr, nullptr, nullptr, C_("Text tool", "Normal"), nullptr, nullptr, nullptr, nullptr, nullptr, _("Larger spacing")};
-        gdouble values[] = { 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1,2, 1.3, 1.4, 1.5, 2.0};
-
-        EgeAdjustmentAction *eact = create_adjustment_action(
-            "TextLineHeightAction",               /* name */
-            _("Line Height"),                     /* label */
-            _("Line:"),                           /* short label */
-            _("Spacing between baselines"),       /* tooltip */
-            "/tools/text/lineheight",             /* preferences path */
-            0.0,                                  /* default */
-            GTK_WIDGET(desktop->canvas),          /* focusTarget */
-            holder,                               /* dataKludge */
-            FALSE,                                /* set alt-x keyboard shortcut? */
-            nullptr,                                 /* altx_mark */
-            0.0, 1000.0, 0.1, 1.0,                /* lower, upper, step (arrow up/down), page up/down */
-            labels, values, G_N_ELEMENTS(labels), /* drop down menu */
-            sp_text_lineheight_value_changed,     /* callback */
-            nullptr, // tracker,                     /* unit tracker */
-            0.1,                                  /* step (used?) */
-            2,                                    /* digits to show */
-            1.0                                   /* factor (multiplies default) */
-            );
-        //tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
-        g_object_set_data( holder, "TextLineHeightAction", eact );
-        g_object_set( G_OBJECT(eact), "iconId", "text_line_spacing", NULL );
-    }
-
-    /* Line height units */
-    {
-        InkSelectOneAction* act = tracker->createAction( "TextLineHeightUnitsAction", _("Units"), ("") );
-        gtk_action_group_add_action( mainActions, act->gobj() );
-        act->signal_changed_after().connect(sigc::bind<0>(sigc::ptr_fun(&sp_text_lineheight_unit_changed), holder));
-        g_object_set_data( holder, "TextLineHeightUnitsAction", act );
-    }
-
-    /* Line spacing mode */
-    {
-        InkSelectOneActionColumns columns;
-
-        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
-
-        Gtk::TreeModel::Row row;
-
-        row = *(store->append());
-        row[columns.col_label    ] = _("Adaptive");
-        row[columns.col_tooltip  ] = _("Line spacing adapts to font size.");
-        row[columns.col_icon     ] = INKSCAPE_ICON("text_line_spacing");
-        row[columns.col_sensitive] = true;
-
-        row = *(store->append());
-        row[columns.col_label    ] = _("Minimum");
-        row[columns.col_tooltip  ] = _("Line spacing adapts to fonts size with set minimum spacing.");
-        row[columns.col_icon     ] = INKSCAPE_ICON("text_line_spacing");
-        row[columns.col_sensitive] = true;
-        row = *(store->append());
-        row[columns.col_label    ] = _("Even");
-        row[columns.col_tooltip  ] = _("Lines evenly spaced.");
-        row[columns.col_icon     ] = INKSCAPE_ICON("text_line_spacing");
-        row[columns.col_sensitive] = true;
-
-        row = *(store->append());
-        row[columns.col_label    ] = _("Adjustable ☠");
-        row[columns.col_tooltip  ] = _("Line spacing fully adjustable");
-        row[columns.col_icon     ] = INKSCAPE_ICON("text_line_spacing");
-        row[columns.col_sensitive] = true;
-
-        InkSelectOneAction* act =
-            InkSelectOneAction::create( "TextLineSpacingAction", // Name
-                                        _("Line Spacing Mode"),   // Label
-                                        _("How should multiple baselines be spaced?\n Adaptive: Line spacing adapts to font size.\n Minimum: Like Adaptive, but with a set minimum.\n Even: Evenly spaced.\n Adjustable: No restrictions."), // Tooltip
-                                        "Not Used",          // Icon
-                                        store );             // Tree store
-        act->use_radio( false );
-        act->use_label( true );
-        gint mode = prefs->getInt("/tools/text/line_spacing_mode", 0);
-        act->set_active( mode );
-
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data( holder, "TextLineSpacingAction", act );
-
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_text_line_spacing_mode_changed), holder));
-    }
-
-    /* Word spacing */
-    {
-        // Drop down menu
-        gchar const* labels[] = {_("Negative spacing"), nullptr, nullptr, nullptr, C_("Text tool", "Normal"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, _("Positive spacing")};
-        gdouble values[] = {-2.0, -1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0};
-
-        EgeAdjustmentAction *eact = create_adjustment_action(
-            "TextWordSpacingAction",              /* name */
-            _("Word spacing"),                    /* label */
-            _("Word:"),                           /* short label */
-            _("Spacing between words (px)"),      /* tooltip */
-            "/tools/text/wordspacing",            /* preferences path */
-            0.0,                                  /* default */
-            GTK_WIDGET(desktop->canvas),          /* focusTarget */
-            holder,                               /* dataKludge */
-            FALSE,                                /* set alt-x keyboard shortcut? */
-            nullptr,                                 /* altx_mark */
-            -100.0, 100.0, 0.01, 0.10,            /* lower, upper, step (arrow up/down), page up/down */
-            labels, values, G_N_ELEMENTS(labels), /* drop down menu */
-            sp_text_wordspacing_value_changed,    /* callback */
-            nullptr,                                 /* unit tracker */
-            0.1,                                  /* step (used?) */
-            2,                                    /* digits to show */
-            1.0                                   /* factor (multiplies default) */
-            );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
-        g_object_set_data( holder, "TextWordSpacingAction", eact );
-        g_object_set( G_OBJECT(eact), "iconId", "text_word_spacing", NULL );
-    }
-
-    /* Letter spacing */
-    {
-        // Drop down menu
-        gchar const* labels[] = {_("Negative spacing"), nullptr, nullptr, nullptr, C_("Text tool", "Normal"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, _("Positive spacing")};
-        gdouble values[] = {-2.0, -1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0};
-
-        EgeAdjustmentAction *eact = create_adjustment_action(
-            "TextLetterSpacingAction",            /* name */
-            _("Letter spacing"),                  /* label */
-            _("Letter:"),                         /* short label */
-            _("Spacing between letters (px)"),    /* tooltip */
-            "/tools/text/letterspacing",          /* preferences path */
-            0.0,                                  /* default */
-            GTK_WIDGET(desktop->canvas),          /* focusTarget */
-            holder,                               /* dataKludge */
-            FALSE,                                /* set alt-x keyboard shortcut? */
-            nullptr,                                 /* altx_mark */
-            -100.0, 100.0, 0.01, 0.10,            /* lower, upper, step (arrow up/down), page up/down */
-            labels, values, G_N_ELEMENTS(labels), /* drop down menu */
-            sp_text_letterspacing_value_changed,  /* callback */
-            nullptr,                                 /* unit tracker */
-            0.1,                                  /* step (used?) */
-            2,                                    /* digits to show */
-            1.0                                   /* factor (multiplies default) */
-            );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
-        g_object_set_data( holder, "TextLetterSpacingAction", eact );
-        g_object_set( G_OBJECT(eact), "iconId", "text_letter_spacing", NULL );
-    }
-
-    /* Character kerning (horizontal shift) */
-    {
-        // Drop down menu
-        gchar const* labels[] = {   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr };
-        gdouble values[]      = { -2.0, -1.5, -1.0, -0.5,   0,  0.5,  1.0,  1.5,  2.0, 2.5 };
-
-        EgeAdjustmentAction *eact = create_adjustment_action(
-            "TextDxAction",                       /* name */
-            _("Kerning"),                         /* label */
-            _("Kern:"),                           /* short label */
-            _("Horizontal kerning (px)"),         /* tooltip */
-            "/tools/text/dx",                     /* preferences path */
-            0.0,                                  /* default */
-            GTK_WIDGET(desktop->canvas),          /* focusTarget */
-            holder,                               /* dataKludge */
-            FALSE,                                /* set alt-x keyboard shortcut? */
-            nullptr,                                 /* altx_mark */
-            -100.0, 100.0, 0.01, 0.1,             /* lower, upper, step (arrow up/down), page up/down */
-            labels, values, G_N_ELEMENTS(labels), /* drop down menu */
-            sp_text_dx_value_changed,             /* callback */
-            nullptr,                                 /* unit tracker */
-            0.1,                                  /* step (used?) */
-            2,                                    /* digits to show */
-            1.0                                   /* factor (multiplies default) */
-            );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
-        g_object_set_data( holder, "TextDxAction", eact );
-        g_object_set( G_OBJECT(eact), "iconId", "text_horz_kern", NULL );
-    }
-
-    /* Character vertical shift */
-    {
-        // Drop down menu
-        gchar const* labels[] = {   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr };
-        gdouble values[]      = { -2.0, -1.5, -1.0, -0.5,   0,  0.5,  1.0,  1.5,  2.0, 2.5 };
-
-        EgeAdjustmentAction *eact = create_adjustment_action(
-            "TextDyAction",                       /* name */
-            _("Vertical Shift"),                  /* label */
-            _("Vert:"),                           /* short label */
-            _("Vertical shift (px)"),             /* tooltip */
-            "/tools/text/dy",                     /* preferences path */
-            0.0,                                  /* default */
-            GTK_WIDGET(desktop->canvas),          /* focusTarget */
-            holder,                               /* dataKludge */
-            FALSE,                                /* set alt-x keyboard shortcut? */
-            nullptr,                                 /* altx_mark */
-            -100.0, 100.0, 0.01, 0.1,             /* lower, upper, step (arrow up/down), page up/down */
-            labels, values, G_N_ELEMENTS(labels), /* drop down menu */
-            sp_text_dy_value_changed,             /* callback */
-            nullptr,                                 /* unit tracker */
-            0.1,                                  /* step (used?) */
-            2,                                    /* digits to show */
-            1.0                                   /* factor (multiplies default) */
-            );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
-        g_object_set_data( holder, "TextDyAction", eact );
-        g_object_set( G_OBJECT(eact), "iconId", "text_vert_kern", NULL );
-    }
-
-    /* Character rotation */
-    {
-        // Drop down menu
-        gchar const* labels[] = {   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr,   nullptr };
-        gdouble values[]      = { -90, -45, -30, -15,   0,  15,  30,  45,  90, 180 };
-
-        EgeAdjustmentAction *eact = create_adjustment_action(
-            "TextRotationAction",                 /* name */
-            _("Letter rotation"),                 /* label */
-            _("Rot:"),                            /* short label */
-            _("Character rotation (degrees)"),    /* tooltip */
-            "/tools/text/rotation",               /* preferences path */
-            0.0,                                  /* default */
-            GTK_WIDGET(desktop->canvas),          /* focusTarget */
-            holder,                               /* dataKludge */
-            FALSE,                                /* set alt-x keyboard shortcut? */
-            nullptr,                                 /* altx_mark */
-            -180.0, 180.0, 0.1, 1.0,              /* lower, upper, step (arrow up/down), page up/down */
-            labels, values, G_N_ELEMENTS(labels), /* drop down menu */
-            sp_text_rotation_value_changed,       /* callback */
-            nullptr,                                 /* unit tracker */
-            0.1,                                  /* step (used?) */
-            2,                                    /* digits to show */
-            1.0                                   /* factor (multiplies default) */
-            );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
-        g_object_set_data( holder, "TextRotationAction", eact );
-        g_object_set( G_OBJECT(eact), "iconId", "text_rotation", NULL );
-    }
-
-    /* Text line height unset */
-    {
-        InkToggleAction* act = ink_toggle_action_new( "TextLineHeightUnsetAction",       // Name
-                                                      _("Unset line height"),            // Label
-                                                      _("If enabled, line height is set on part of selection. Click to unset."),
-                                                      INKSCAPE_ICON("paint-unknown"),
-                                                      secondarySize );                   // Icon size
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_text_lineheight_unset_changed), holder );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/text/line_height_unset", false) );
-        g_object_set_data( holder, "TextLineHeightUnsetAction", act );
-    }
-
-    /* Text outer style */
-    {
-        InkToggleAction* act = ink_toggle_action_new( "TextOuterStyleAction",            // Name
-                                                      _("Show outer style"),             // Label
-                                                      _("Show style of outermost text element. The 'font-size' and 'line-height' values of the outermost text element determine the minimum line spacing in the block."),
-                                                      INKSCAPE_ICON("text_outer_style"),
-                                                      secondarySize );                   // Icon size
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_text_outer_style_changed), holder );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/text/outer_style", false) );
-        g_object_set_data( holder, "TextOuterStyleAction", act );
-    }
-
-    // Is this necessary to call? Shouldn't hurt.
-    sp_text_toolbox_selection_changed(desktop->getSelection(), holder);
-
-    desktop->connectEventContextChanged(sigc::bind(sigc::ptr_fun(text_toolbox_watch_ec), holder));
-
-    g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );
-
-}
-
-static void text_toolbox_watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec, GObject* holder) {
-    using sigc::connection;
-    using sigc::bind;
-    using sigc::ptr_fun;
-
-    static connection c_selection_changed;
-    static connection c_selection_modified;
-    static connection c_subselection_changed;
-
+void
+TextToolbar::watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec) {
     if (SP_IS_TEXT_CONTEXT(ec)) {
         // Watch selection
 
         // Ensure FontLister is updated here first.................. VVVVV
-        c_selection_changed = desktop->getSelection()->connectChangedFirst(bind(ptr_fun(sp_text_toolbox_selection_changed), holder, false));
-        c_selection_modified = desktop->getSelection()->connectModifiedFirst(bind(ptr_fun(sp_text_toolbox_selection_modified), holder));
-        c_subselection_changed = desktop->connectToolSubselectionChanged(bind(ptr_fun(sp_text_toolbox_subselection_changed), holder));
+        c_selection_changed = desktop->getSelection()->connectChangedFirst(sigc::bind(sigc::mem_fun(*this, &TextToolbar::selection_changed), false));
+        c_selection_modified = desktop->getSelection()->connectModifiedFirst(sigc::mem_fun(*this, &TextToolbar::selection_modified));
+        c_subselection_changed = desktop->connectToolSubselectionChanged(sigc::mem_fun(*this, &TextToolbar::subselection_changed));
     } else {
         if (c_selection_changed)
             c_selection_changed.disconnect();
@@ -2588,6 +2529,23 @@ static void text_toolbox_watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolB
             c_subselection_changed.disconnect();
     }
 }
+
+void
+TextToolbar::selection_modified(Inkscape::Selection *selection, guint /*flags*/)
+{
+    selection_changed(selection);
+}
+
+void
+TextToolbar::subselection_changed(gpointer /*tc*/)
+{
+    selection_changed(nullptr, true);
+}
+
+}
+}
+}
+
 /*
   Local Variables:
   mode:c++
diff --git a/src/ui/toolbar/text-toolbar.h b/src/ui/toolbar/text-toolbar.h
index 9c988217d..acc6f3268 100644
--- a/src/ui/toolbar/text-toolbar.h
+++ b/src/ui/toolbar/text-toolbar.h
@@ -28,11 +28,112 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "toolbar.h"
+
+#include <gtkmm/adjustment.h>
+
+class InkSelectOneAction;
 class SPDesktop;
 
+typedef struct _EgeAdjustmentAction EgeAdjustmentAction;
 typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _GObject GObject;
+typedef struct _Ink_ComboBoxEntry_Action Ink_ComboBoxEntry_Action;
+typedef struct _InkToggleAction InkToggleAction;
+
+namespace Inkscape {
+class Selection;
+
+namespace UI {
+namespace Tools {
+class ToolBase;
+}
+
+namespace Widget {
+class UnitTracker;
+}
+
+namespace Toolbar {
+class TextToolbar : public Toolbar {
+private:
+    bool _freeze;
+    bool _text_style_from_prefs;
+
+    UI::Widget::UnitTracker *_tracker;
+
+    Ink_ComboBoxEntry_Action *_font_family_action;
+    Ink_ComboBoxEntry_Action *_font_size_action;
+    Ink_ComboBoxEntry_Action *_font_style_action;
+    InkToggleAction *_superscript_action;
+    InkToggleAction *_subscript_action;
+    InkToggleAction *_outer_style_action;
+    InkToggleAction *_line_height_unset_action;
+    InkSelectOneAction *_align_action;
+    InkSelectOneAction *_writing_mode_action;
+    InkSelectOneAction *_orientation_action;
+    InkSelectOneAction *_direction_action;
+    InkSelectOneAction *_line_height_units_action;
+    InkSelectOneAction *_line_spacing_action;
+
+    EgeAdjustmentAction *_line_height_action;
+    EgeAdjustmentAction *_word_spacing_action;
+    EgeAdjustmentAction *_letter_spacing_action;
+    EgeAdjustmentAction *_dx_action;
+    EgeAdjustmentAction *_dy_action;
+    EgeAdjustmentAction *_rotation_action;
+
+    Glib::RefPtr<Gtk::Adjustment> _line_height_adj;
+    Glib::RefPtr<Gtk::Adjustment> _word_spacing_adj;
+    Glib::RefPtr<Gtk::Adjustment> _letter_spacing_adj;
+    Glib::RefPtr<Gtk::Adjustment> _dx_adj;
+    Glib::RefPtr<Gtk::Adjustment> _dy_adj;
+    Glib::RefPtr<Gtk::Adjustment> _rotation_adj;
+
+    int _lineheight_unit;
+
+    sigc::connection c_selection_changed;
+    sigc::connection c_selection_modified;
+    sigc::connection c_subselection_changed;
+
+    static void fontfamily_value_changed(Ink_ComboBoxEntry_Action *act,
+                                         gpointer                  data);
+    static void fontsize_value_changed  (Ink_ComboBoxEntry_Action *act,
+                                         gpointer                  data);
+    static void fontstyle_value_changed (Ink_ComboBoxEntry_Action *act,
+                                         gpointer                  data);
+    static void script_changed          (InkToggleAction          *act,
+                                         gpointer                  data);
+    static void lineheight_unset_changed(InkToggleAction          *act,
+                                         gpointer                  data);
+    static void outer_style_changed     (InkToggleAction          *act,
+                                         gpointer                  data);
+
+    void align_mode_changed(int mode);
+    void writing_mode_changed(int mode);
+    void orientation_changed(int mode);
+    void direction_changed(int mode);
+    void lineheight_value_changed();
+    void lineheight_unit_changed(int not_used);
+    void line_spacing_mode_changed(int mode);
+    void wordspacing_value_changed();
+    void letterspacing_value_changed();
+    void dx_value_changed();
+    void dy_value_changed();
+    void rotation_value_changed();
+    void selection_changed(Inkscape::Selection *selection,
+                           bool subselection = false);
+    void selection_modified(Inkscape::Selection *selection, guint flags);
+    void subselection_changed(gpointer tc);
+    void watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec);
+
+protected:
+    TextToolbar(SPDesktop *desktop);
+
+public:
+    static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions);
+};
 
-void       sp_text_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
+}
+}
+}
 
 #endif /* !SEEN_TEXT_TOOLBAR_H */
diff --git a/src/ui/toolbar/tweak-toolbar.cpp b/src/ui/toolbar/tweak-toolbar.cpp
index 47a90910a..e85e1d7a5 100644
--- a/src/ui/toolbar/tweak-toolbar.cpp
+++ b/src/ui/toolbar/tweak-toolbar.cpp
@@ -52,52 +52,12 @@ using Inkscape::UI::PrefPusher;
 //##       Tweak        ##
 //########################
 
-static void sp_tweak_width_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/tweak/width",
-            gtk_adjustment_get_value(adj) * 0.01 );
-}
-
-static void sp_tweak_force_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/tweak/force",
-            gtk_adjustment_get_value(adj) * 0.01 );
-}
-
 static void sp_tweak_pressure_state_changed( GtkToggleAction *act, gpointer /*data*/ )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     prefs->setBool("/tools/tweak/usepressure", gtk_toggle_action_get_active(act));
 }
 
-static void sp_tweak_mode_changed( GObject *tbl, int mode )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setInt("/tools/tweak/mode", mode);
-
-    static gchar const* names[] = {"tweak_doh", "tweak_dos", "tweak_dol", "tweak_doo", "tweak_channels_label"};
-    bool flag = ((mode == Inkscape::UI::Tools::TWEAK_MODE_COLORPAINT) ||
-                 (mode == Inkscape::UI::Tools::TWEAK_MODE_COLORJITTER));
-    for (auto & name : names) {
-        GtkAction *act = GTK_ACTION(g_object_get_data( tbl, name ));
-        if (act) {
-            gtk_action_set_visible(act, flag);
-        }
-    }
-    GtkAction *fid = GTK_ACTION(g_object_get_data( tbl, "tweak_fidelity"));
-    if (fid) {
-        gtk_action_set_visible(fid, !flag);
-    }
-}
-
-static void sp_tweak_fidelity_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/tweak/fidelity",
-            gtk_adjustment_get_value(adj) * 0.01 );
-}
 
 static void tweak_toggle_doh(GtkToggleAction *act, gpointer /*data*/) {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
@@ -116,8 +76,14 @@ static void tweak_toggle_doo(GtkToggleAction *act, gpointer /*data*/) {
     prefs->setBool("/tools/tweak/doo", gtk_toggle_action_get_active(act));
 }
 
-void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
+namespace Inkscape {
+namespace UI {
+namespace Toolbar {
+GtkWidget *
+TweakToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
 {
+    auto holder = new TweakToolbar(desktop);
+
     GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
@@ -128,10 +94,16 @@ void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj
         EgeAdjustmentAction *eact = create_adjustment_action( "TweakWidthAction",
                                                               _("Width"), _("Width:"), _("The width of the tweak area (relative to the visible canvas area)"),
                                                               "/tools/tweak/width", 15,
-                                                              GTK_WIDGET(desktop->canvas), holder, TRUE, "altx-tweak",
+                                                              GTK_WIDGET(desktop->canvas),
+                                                              nullptr, // dataKludge
+                                                              TRUE, "altx-tweak",
                                                               1, 100, 1.0, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
-                                                              sp_tweak_width_value_changed, nullptr /*unit tracker*/, 0.01, 0, 100 );
+                                                              nullptr, // callback
+                                                              nullptr /*unit tracker*/, 0.01, 0, 100 );
+
+        holder->_adj_tweak_width = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        holder->_adj_tweak_width->signal_value_changed().connect(sigc::mem_fun(*holder, &TweakToolbar::tweak_width_value_changed));
         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 );
@@ -145,10 +117,15 @@ void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj
         EgeAdjustmentAction *eact = create_adjustment_action( "TweakForceAction",
                                                               _("Force"), _("Force:"), _("The force of the tweak action"),
                                                               "/tools/tweak/force", 20,
-                                                              GTK_WIDGET(desktop->canvas), holder, TRUE, "tweak-force",
+                                                              GTK_WIDGET(desktop->canvas),
+                                                              nullptr, // dataKludge
+                                                              TRUE, "tweak-force",
                                                               1, 100, 1.0, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
-                                                              sp_tweak_force_value_changed, nullptr /*unit tracker*/, 0.01, 0, 100 );
+                                                              nullptr, // callback
+                                                              nullptr /*unit tracker*/, 0.01, 0, 100 );
+        holder->_adj_tweak_force = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
+        holder->_adj_tweak_force->signal_value_changed().connect(sigc::mem_fun(*holder, &TweakToolbar::tweak_force_value_changed));
         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 );
@@ -240,120 +217,119 @@ void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj
         row[columns.col_icon     ] = INKSCAPE_ICON("object-tweak-blur");
         row[columns.col_sensitive] = true;
 
-        InkSelectOneAction* act =
+        holder->_tweak_tool_mode =
             InkSelectOneAction::create( "TweakModeAction",   // Name
                                         _("Mode"),           // Label
                                         (""),                // Tooltip
                                         "Not Used",          // Icon
                                         store );             // Tree store
 
-        act->use_radio( true );
-        act->use_icon( true );
-        act->use_label( false );
-        act->use_group_label( true );
+        holder->_tweak_tool_mode->use_radio( true );
+        holder->_tweak_tool_mode->use_icon( true );
+        holder->_tweak_tool_mode->use_label( false );
+        holder->_tweak_tool_mode->use_group_label( true );
         int mode = prefs->getInt("/tools/tweak/mode", 0);
-        act->set_active( mode );
+        holder->_tweak_tool_mode->set_active( mode );
 
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() ));
-        g_object_set_data( holder, "tweak_tool_mode", act );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_tweak_tool_mode->gobj() ));
 
-        act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_tweak_mode_changed), holder));
+        holder->_tweak_tool_mode->signal_changed().connect(sigc::mem_fun(*holder, &TweakToolbar::tweak_mode_changed));
     }
 
     guint mode = prefs->getInt("/tools/tweak/mode", 0);
 
     {
-        EgeOutputAction* act = ege_output_action_new( "TweakChannelsLabel", _("Channels:"), "", nullptr );
-        ege_output_action_set_use_markup( act, TRUE );
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
+        holder->_tweak_channels_label = ege_output_action_new( "TweakChannelsLabel", _("Channels:"), "", nullptr );
+        ege_output_action_set_use_markup( holder->_tweak_channels_label, TRUE );
+        gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_tweak_channels_label ) );
         if (mode != Inkscape::UI::Tools::TWEAK_MODE_COLORPAINT && mode != Inkscape::UI::Tools::TWEAK_MODE_COLORJITTER) {
-            gtk_action_set_visible (GTK_ACTION(act), FALSE);
+            gtk_action_set_visible (GTK_ACTION(holder->_tweak_channels_label), FALSE);
         }
-        g_object_set_data( holder, "tweak_channels_label", act);
     }
 
     {
-        InkToggleAction* act = ink_toggle_action_new( "TweakDoH",
+        holder->_tweak_doh = ink_toggle_action_new( "TweakDoH",
                                                       _("Hue"),
                                                       _("In color mode, act on objects' hue"),
                                                       nullptr,
                                                       GTK_ICON_SIZE_MENU );
         //TRANSLATORS:  "H" here stands for hue
-        g_object_set( act, "short_label", C_("Hue", "H"), NULL );
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_doh), desktop );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/doh", true) );
+        gtk_action_set_short_label(GTK_ACTION(holder->_tweak_doh), C_("Hue", "H"));
+        gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_tweak_doh ) );
+        g_signal_connect_after( G_OBJECT(holder->_tweak_doh), "toggled", G_CALLBACK(tweak_toggle_doh), desktop );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_tweak_doh), prefs->getBool("/tools/tweak/doh", true) );
         if (mode != Inkscape::UI::Tools::TWEAK_MODE_COLORPAINT && mode != Inkscape::UI::Tools::TWEAK_MODE_COLORJITTER) {
-            gtk_action_set_visible (GTK_ACTION(act), FALSE);
+            gtk_action_set_visible (GTK_ACTION(holder->_tweak_doh), FALSE);
         }
-        g_object_set_data( holder, "tweak_doh", act);
     }
     {
-        InkToggleAction* act = ink_toggle_action_new( "TweakDoS",
-                                                      _("Saturation"),
-                                                      _("In color mode, act on objects' saturation"),
-                                                      nullptr,
-                                                      GTK_ICON_SIZE_MENU );
+        holder->_tweak_dos = ink_toggle_action_new( "TweakDoS",
+                                                     _("Saturation"),
+                                                     _("In color mode, act on objects' saturation"),
+                                                     nullptr,
+                                                     GTK_ICON_SIZE_MENU );
         //TRANSLATORS: "S" here stands for Saturation
-        g_object_set( act, "short_label", C_("Saturation", "S"), NULL );
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_dos), desktop );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/dos", true) );
+        gtk_action_set_short_label( GTK_ACTION(holder->_tweak_dos), C_("Saturation", "S"));
+        gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_tweak_dos ) );
+        g_signal_connect_after( G_OBJECT(holder->_tweak_dos), "toggled", G_CALLBACK(tweak_toggle_dos), desktop );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_tweak_dos), prefs->getBool("/tools/tweak/dos", true) );
         if (mode != Inkscape::UI::Tools::TWEAK_MODE_COLORPAINT && mode != Inkscape::UI::Tools::TWEAK_MODE_COLORJITTER) {
-            gtk_action_set_visible (GTK_ACTION(act), FALSE);
+            gtk_action_set_visible (GTK_ACTION(holder->_tweak_dos), FALSE);
         }
-        g_object_set_data( holder, "tweak_dos", act );
     }
     {
-        InkToggleAction* act = ink_toggle_action_new( "TweakDoL",
-                                                      _("Lightness"),
-                                                      _("In color mode, act on objects' lightness"),
-                                                      nullptr,
-                                                      GTK_ICON_SIZE_MENU );
+        holder->_tweak_dol = ink_toggle_action_new( "TweakDoL",
+                                                     _("Lightness"),
+                                                     _("In color mode, act on objects' lightness"),
+                                                     nullptr,
+                                                     GTK_ICON_SIZE_MENU );
         //TRANSLATORS: "L" here stands for Lightness
-        g_object_set( act, "short_label", C_("Lightness", "L"), NULL );
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_dol), desktop );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/dol", true) );
+        gtk_action_set_short_label( GTK_ACTION(holder->_tweak_dol), C_("Lightness", "L"));
+        gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_tweak_dol ) );
+        g_signal_connect_after( G_OBJECT(holder->_tweak_dol), "toggled", G_CALLBACK(tweak_toggle_dol), desktop );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_tweak_dol), prefs->getBool("/tools/tweak/dol", true) );
         if (mode != Inkscape::UI::Tools::TWEAK_MODE_COLORPAINT && mode != Inkscape::UI::Tools::TWEAK_MODE_COLORJITTER) {
-            gtk_action_set_visible (GTK_ACTION(act), FALSE);
+            gtk_action_set_visible (GTK_ACTION(holder->_tweak_dol), FALSE);
         }
-        g_object_set_data( holder, "tweak_dol", act );
     }
     {
-        InkToggleAction* act = ink_toggle_action_new( "TweakDoO",
-                                                      _("Opacity"),
-                                                      _("In color mode, act on objects' opacity"),
-                                                      nullptr,
-                                                      GTK_ICON_SIZE_MENU );
+        holder->_tweak_doo = ink_toggle_action_new( "TweakDoO",
+                                                     _("Opacity"),
+                                                     _("In color mode, act on objects' opacity"),
+                                                     nullptr,
+                                                     GTK_ICON_SIZE_MENU );
         //TRANSLATORS: "O" here stands for Opacity
-        g_object_set( act, "short_label", C_("Opacity", "O"), NULL );
-        gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_doo), desktop );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/doo", true) );
+        gtk_action_set_short_label( GTK_ACTION(holder->_tweak_doo), C_("Opacity", "O"));
+        gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_tweak_doo ) );
+        g_signal_connect_after( G_OBJECT(holder->_tweak_doo), "toggled", G_CALLBACK(tweak_toggle_doo), desktop );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_tweak_doo), prefs->getBool("/tools/tweak/doo", true) );
         if (mode != Inkscape::UI::Tools::TWEAK_MODE_COLORPAINT && mode != Inkscape::UI::Tools::TWEAK_MODE_COLORJITTER) {
-            gtk_action_set_visible (GTK_ACTION(act), FALSE);
+            gtk_action_set_visible (GTK_ACTION(holder->_tweak_doo), FALSE);
         }
-        g_object_set_data( holder, "tweak_doo", act );
     }
 
     {   /* Fidelity */
         gchar const* labels[] = {_("(rough, simplified)"), nullptr, nullptr, _("(default)"), nullptr, nullptr, _("(fine, but many nodes)")};
         gdouble values[] = {10, 25, 35, 50, 60, 80, 100};
-        EgeAdjustmentAction *eact = create_adjustment_action( "TweakFidelityAction",
-                                                              _("Fidelity"), _("Fidelity:"),
-                                                              _("Low fidelity simplifies paths; high fidelity preserves path features but may generate a lot of new nodes"),
-                                                              "/tools/tweak/fidelity", 50,
-                                                              GTK_WIDGET(desktop->canvas), holder, TRUE, "tweak-fidelity",
-                                                              1, 100, 1.0, 10.0,
-                                                              labels, values, G_N_ELEMENTS(labels),
-                                                              sp_tweak_fidelity_value_changed, nullptr /*unit tracker*/, 0.01, 0, 100 );
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        gtk_action_set_visible( GTK_ACTION(eact), TRUE );
+        holder->_tweak_fidelity = create_adjustment_action( "TweakFidelityAction",
+                                                            _("Fidelity"), _("Fidelity:"),
+                                                            _("Low fidelity simplifies paths; high fidelity preserves path features but may generate a lot of new nodes"),
+                                                            "/tools/tweak/fidelity", 50,
+                                                            GTK_WIDGET(desktop->canvas),
+                                                            nullptr, // dataKludge
+                                                            TRUE, "tweak-fidelity",
+                                                            1, 100, 1.0, 10.0,
+                                                            labels, values, G_N_ELEMENTS(labels),
+                                                            nullptr, // callback
+                                                            nullptr /*unit tracker*/, 0.01, 0, 100 );
+
+        holder->_adj_tweak_fidelity = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_tweak_fidelity));
+        holder->_adj_tweak_fidelity->signal_value_changed().connect(sigc::mem_fun(*holder, &TweakToolbar::tweak_fidelity_value_changed));
+        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_tweak_fidelity) );
+        gtk_action_set_visible( GTK_ACTION(holder->_tweak_fidelity), TRUE );
         if (mode == Inkscape::UI::Tools::TWEAK_MODE_COLORPAINT || mode == Inkscape::UI::Tools::TWEAK_MODE_COLORJITTER) {
-            gtk_action_set_visible (GTK_ACTION(eact), FALSE);
+            gtk_action_set_visible (GTK_ACTION(holder->_tweak_fidelity), FALSE);
         }
-        g_object_set_data( holder, "tweak_fidelity", eact );
     }
 
 
@@ -369,8 +345,56 @@ void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj
         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/usepressure", true) );
     }
 
+    return GTK_WIDGET(holder->gobj());
+}
+
+void
+TweakToolbar::tweak_width_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/tweak/width",
+            _adj_tweak_width->get_value() * 0.01 );
+}
+
+void
+TweakToolbar::tweak_force_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/tweak/force",
+            _adj_tweak_force->get_value() * 0.01 );
 }
 
+void
+TweakToolbar::tweak_mode_changed(int mode)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setInt("/tools/tweak/mode", mode);
+
+    bool flag = ((mode == Inkscape::UI::Tools::TWEAK_MODE_COLORPAINT) ||
+                 (mode == Inkscape::UI::Tools::TWEAK_MODE_COLORJITTER));
+
+    gtk_action_set_visible(GTK_ACTION(_tweak_doh), flag);
+    gtk_action_set_visible(GTK_ACTION(_tweak_dos), flag);
+    gtk_action_set_visible(GTK_ACTION(_tweak_dol), flag);
+    gtk_action_set_visible(GTK_ACTION(_tweak_doo), flag);
+    gtk_action_set_visible(GTK_ACTION(_tweak_channels_label), flag);
+
+    if (_tweak_fidelity) {
+        gtk_action_set_visible(GTK_ACTION(_tweak_fidelity), !flag);
+    }
+}
+
+void
+TweakToolbar::tweak_fidelity_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setDouble( "/tools/tweak/fidelity",
+            _adj_tweak_fidelity->get_value() * 0.01 );
+}
+
+}
+}
+}
 
 /*
   Local Variables:
diff --git a/src/ui/toolbar/tweak-toolbar.h b/src/ui/toolbar/tweak-toolbar.h
index d6015d918..6489bd234 100644
--- a/src/ui/toolbar/tweak-toolbar.h
+++ b/src/ui/toolbar/tweak-toolbar.h
@@ -28,11 +28,50 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "toolbar.h"
+
+class InkSelectOneAction;
 class SPDesktop;
 
+typedef struct _EgeAdjustmentAction EgeAdjustmentAction;
+typedef struct _EgeOutputAction EgeOutputAction;
 typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _GObject GObject;
+typedef struct _InkToggleAction InkToggleAction;
+
+namespace Inkscape {
+namespace UI {
+namespace Toolbar {
+class TweakToolbar : public Toolbar {
+private:
+    Glib::RefPtr<Gtk::Adjustment> _adj_tweak_width;
+    Glib::RefPtr<Gtk::Adjustment> _adj_tweak_force;
+    Glib::RefPtr<Gtk::Adjustment> _adj_tweak_fidelity;
+
+    InkSelectOneAction *_tweak_tool_mode;
+
+    EgeOutputAction *_tweak_channels_label;
+    InkToggleAction *_tweak_doh;
+    InkToggleAction *_tweak_dos;
+    InkToggleAction *_tweak_dol;
+    InkToggleAction *_tweak_doo;
+
+    EgeAdjustmentAction *_tweak_fidelity;
+
+    void tweak_width_value_changed();
+    void tweak_force_value_changed();
+    void tweak_mode_changed(int mode);
+    void tweak_fidelity_value_changed();
+
+protected:
+    TweakToolbar(SPDesktop *_desktop)
+        : Toolbar(_desktop)
+    {}
 
-void       sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
+public:
+    static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions);
+};
+}
+}
+}
 
 #endif /* !SEEN_SELECT_TOOLBAR_H */
diff --git a/src/widgets/CMakeLists.txt b/src/widgets/CMakeLists.txt
index 5a3b101e5..c41fcdb03 100644
--- a/src/widgets/CMakeLists.txt
+++ b/src/widgets/CMakeLists.txt
@@ -18,7 +18,6 @@ set(widgets_SRC
 	paint-selector.cpp
 	sp-attribute-widget.cpp
 	sp-color-selector.cpp
-	sp-widget.cpp
 	sp-xmlview-tree.cpp
 	spinbutton-events.cpp
 	spw-utilities.cpp
@@ -46,7 +45,6 @@ set(widgets_SRC
 	paint-selector.h
 	sp-attribute-widget.h
 	sp-color-selector.h
-	sp-widget.h
 	sp-xmlview-tree.h
 	spinbutton-events.h
 	spw-utilities.h
diff --git a/src/widgets/sp-widget.cpp b/src/widgets/sp-widget.cpp
deleted file mode 100644
index 1e82d69ac..000000000
--- a/src/widgets/sp-widget.cpp
+++ /dev/null
@@ -1,322 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- * Abstract base class for dynamic control widgets
- *
- * Authors:
- *   Lauris Kaplinski <lauris@kaplinski.com>
- *   bulia byak <buliabyak@users.sf.net>
- *   Jon A. Cruz <jon@joncruz.org>
- *
- * Copyright (C) 1999-2002 Lauris Kaplinski
- * Copyright (C) 2000-2001 Ximian, Inc.
- * Copyright (C) 2012 Authors
- *
- * Released under GNU GPL v2+, read the file 'COPYING' for more information.
- */
-
-#include "document.h"
-#include "inkscape.h"
-#include "sp-widget.h"
-#include "helper/sp-marshal.h"
-
-using Inkscape::SPWidgetImpl;
-
-enum {
-    CONSTRUCT,
-    MODIFY_SELECTION,
-    CHANGE_SELECTION,
-    SET_SELECTION,
-    LAST_SIGNAL
-};
-
-namespace Inkscape {
-
-class SPWidgetImpl
-{
-public:
-    SPWidgetImpl(SPWidget &target);
-    ~SPWidgetImpl();
-
-    static void dispose(GObject *object);
-    static void show(GtkWidget *widget);
-    static void hide(GtkWidget *widget);
-
-    static void getPreferredWidth(GtkWidget *widget,
-                                  gint *minimal_width,
-                                  gint *natural_width);
-
-    static void getPreferredHeight(GtkWidget *widget,
-                                   gint *minimal_height,
-                                   gint *natural_height);
-    static gboolean draw(GtkWidget *widget, cairo_t *cr);
-
-    static void sizeAllocate(GtkWidget *widget, GtkAllocation *allocation);
-    static void modifySelectionCB(Selection *selection, guint flags, SPWidget *spw);
-    static void changeSelectionCB(Selection *selection, SPWidget *spw);
-    static void setSelectionCB(Selection *selection, SPWidget *spw);
-
-    static GtkWidget *constructGlobal(SPWidget *spw);
-
-    void modifySelection(Selection *selection, guint flags);
-    void changeSelection(Selection *selection);
-    void setSelection(Selection *selection);
-
-private:
-    SPWidget &_target;
-};
-} // namespace Inkscape
-
-G_DEFINE_TYPE(SPWidget, sp_widget, GTK_TYPE_BIN);
-
-static guint signals[LAST_SIGNAL] = {0};
-
-static void
-sp_widget_class_init(SPWidgetClass *klass)
-{
-    GObjectClass *object_class = reinterpret_cast<GObjectClass *>(klass);
-    GtkWidgetClass *widget_class = reinterpret_cast<GtkWidgetClass *>(klass);
-
-    object_class->dispose = SPWidgetImpl::dispose;
-
-    signals[CONSTRUCT] =        g_signal_new ("construct",
-                                              G_TYPE_FROM_CLASS(object_class),
-                                              G_SIGNAL_RUN_FIRST,
-                                              G_STRUCT_OFFSET(SPWidgetClass, construct),
-                                              nullptr, nullptr,
-                                              g_cclosure_marshal_VOID__VOID,
-                                              G_TYPE_NONE, 0);
-
-    signals[CHANGE_SELECTION] = g_signal_new ("change_selection",
-                                              G_TYPE_FROM_CLASS(object_class),
-                                              G_SIGNAL_RUN_FIRST,
-                                              G_STRUCT_OFFSET(SPWidgetClass, change_selection),
-                                              nullptr, nullptr,
-                                              g_cclosure_marshal_VOID__POINTER,
-                                              G_TYPE_NONE, 1,
-                                              G_TYPE_POINTER);
-
-    signals[MODIFY_SELECTION] = g_signal_new ("modify_selection",
-                                              G_TYPE_FROM_CLASS(object_class),
-                                              G_SIGNAL_RUN_FIRST,
-                                              G_STRUCT_OFFSET(SPWidgetClass, modify_selection),
-                                              nullptr, nullptr,
-                                              sp_marshal_VOID__POINTER_UINT,
-                                              G_TYPE_NONE, 2,
-                                              G_TYPE_POINTER, G_TYPE_UINT);
-
-    signals[SET_SELECTION] =    g_signal_new ("set_selection",
-                                              G_TYPE_FROM_CLASS(object_class),
-                                              G_SIGNAL_RUN_FIRST,
-                                              G_STRUCT_OFFSET(SPWidgetClass, set_selection),
-                                              nullptr, nullptr,
-                                              g_cclosure_marshal_VOID__POINTER,
-                                              G_TYPE_NONE, 1,
-                                              G_TYPE_POINTER);
-
-    widget_class->show = SPWidgetImpl::show;
-    widget_class->hide = SPWidgetImpl::hide;
-    widget_class->get_preferred_width = SPWidgetImpl::getPreferredWidth;
-    widget_class->get_preferred_height = SPWidgetImpl::getPreferredHeight;
-    widget_class->draw = SPWidgetImpl::draw;
-    widget_class->size_allocate = SPWidgetImpl::sizeAllocate;
-}
-
-static void sp_widget_init(SPWidget *spw)
-{
-    spw->_impl = new SPWidgetImpl(*spw); // ctor invoked after all other init
-}
-
-namespace Inkscape {
-
-SPWidgetImpl::SPWidgetImpl(SPWidget &target) :
-    _target(target)
-{
-}
-
-SPWidgetImpl::~SPWidgetImpl()
-= default;
-
-void SPWidgetImpl::dispose(GObject *object)
-{
-    SPWidget *spw = reinterpret_cast<SPWidget *>(object);
-
-    // Disconnect signals
-    if (Application::exists()) {
-        spw->selModified.disconnect();
-        spw->selChanged.disconnect();
-        spw->selSet.disconnect();
-    }            
-
-    delete spw->_impl;
-    spw->_impl = nullptr;
-
-    if (G_OBJECT_CLASS(sp_widget_parent_class)->dispose) {
-        G_OBJECT_CLASS(sp_widget_parent_class)->dispose(object);
-    }
-}
-
-void SPWidgetImpl::show(GtkWidget *widget)
-{
-    SPWidget *spw = SP_WIDGET(widget);
-
-    if (Application::exists()) {
-        // Connect signals
-        spw->selModified = INKSCAPE.signal_selection_modified.connect(
-                sigc::bind(
-                sigc::ptr_fun(SPWidgetImpl::modifySelectionCB), spw)
-        );
-        spw->selChanged = INKSCAPE.signal_selection_changed.connect(
-                sigc::bind(
-                sigc::ptr_fun(SPWidgetImpl::changeSelectionCB), spw)
-        );
-        spw->selSet = INKSCAPE.signal_selection_set.connect(
-                sigc::bind(
-                sigc::ptr_fun(SPWidgetImpl::setSelectionCB), spw)
-        );
-    }
-
-    if (GTK_WIDGET_CLASS(sp_widget_parent_class)->show) {
-        GTK_WIDGET_CLASS(sp_widget_parent_class)->show(widget);
-    }
-}
-
-void SPWidgetImpl::hide(GtkWidget *widget)
-{
-    SPWidget *spw = SP_WIDGET (widget);
-
-    if (Application::exists()) {
-        // Disconnect signals
-        spw->selModified.disconnect();
-        spw->selChanged.disconnect();
-        spw->selSet.disconnect();
-    }
-
-    if (GTK_WIDGET_CLASS(sp_widget_parent_class)->hide) {
-        GTK_WIDGET_CLASS(sp_widget_parent_class)->hide(widget);
-    }
-}
-
-gboolean SPWidgetImpl::draw(GtkWidget *widget, cairo_t *cr)
-{
-    GtkBin    *bin = GTK_BIN(widget);
-    GtkWidget *child = gtk_bin_get_child(bin);
-
-    if (child) {
-        gtk_container_propagate_draw(GTK_CONTAINER(widget), child, cr);
-    }
-
-    return FALSE;
-}
-
-void SPWidgetImpl::getPreferredWidth(GtkWidget *widget, gint *minimal_width, gint *natural_width)
-{
-    GtkBin    *bin   = GTK_BIN(widget);
-    GtkWidget *child = gtk_bin_get_child(bin);
-
-    if(child) {
-        gtk_widget_get_preferred_width(child, minimal_width, natural_width);
-    }
-}
-
-void SPWidgetImpl::getPreferredHeight(GtkWidget *widget, gint *minimal_height, gint *natural_height)
-{
-    GtkBin    *bin   = GTK_BIN(widget);
-    GtkWidget *child = gtk_bin_get_child(bin);
-
-    if(child) {
-        gtk_widget_get_preferred_height(child, minimal_height, natural_height);
-    }
-}
-
-void SPWidgetImpl::sizeAllocate(GtkWidget *widget, GtkAllocation *allocation)
-{
-    gtk_widget_set_allocation(widget, allocation);
-
-    GtkBin        *bin   = GTK_BIN(widget);
-    GtkWidget     *child = gtk_bin_get_child(bin);
-
-    if (child) {
-        gtk_widget_size_allocate(child, allocation);
-    }
-}
-
-GtkWidget *SPWidgetImpl::constructGlobal(SPWidget *spw)
-{
-    if (gtk_widget_get_visible(GTK_WIDGET(spw))) {
-        spw->selModified = INKSCAPE.signal_selection_modified.connect(
-                sigc::bind(
-                sigc::ptr_fun(SPWidgetImpl::modifySelectionCB), spw)
-        );
-        spw->selChanged = INKSCAPE.signal_selection_changed.connect(
-                sigc::bind(
-                sigc::ptr_fun(SPWidgetImpl::changeSelectionCB), spw)
-        );
-        spw->selSet = INKSCAPE.signal_selection_set.connect(
-                sigc::bind(
-                sigc::ptr_fun(SPWidgetImpl::setSelectionCB), spw)
-        );
-    }
-
-    g_signal_emit(spw, signals[CONSTRUCT], 0);
-
-    return GTK_WIDGET(spw);
-}
-
-void SPWidgetImpl::modifySelectionCB(Selection *selection, guint flags, SPWidget *spw)
-{
-    spw->_impl->modifySelection(selection, flags);
-}
-
-void SPWidgetImpl::changeSelectionCB(Selection *selection, SPWidget *spw)
-{
-    spw->_impl->changeSelection(selection);
-}
-
-void SPWidgetImpl::setSelectionCB(Selection *selection, SPWidget *spw)
-{
-    spw->_impl->setSelection(selection);
-}
-
-void SPWidgetImpl::modifySelection(Selection *selection, guint flags)
-{
-    g_signal_emit(&_target, signals[MODIFY_SELECTION], 0, selection, flags);
-}
-
-void SPWidgetImpl::changeSelection(Selection *selection)
-{
-    g_signal_emit(&_target, signals[CHANGE_SELECTION], 0, selection);
-}
-
-void SPWidgetImpl::setSelection(Selection *selection)
-{
-    // Emit "set_selection" signal
-    g_signal_emit(&_target, signals[SET_SELECTION], 0, selection);
-    // Inkscape will force "change_selection" anyways
-}
-
-} // namespace Inkscape
-
-// Methods
-
-GtkWidget *sp_widget_new_global()
-{
-    SPWidget *spw = reinterpret_cast<SPWidget*>(g_object_new(SP_TYPE_WIDGET, nullptr));
-
-    if (!SPWidgetImpl::constructGlobal(spw)) {
-        g_object_unref(spw);
-        spw = nullptr;
-    }
-
-    return reinterpret_cast<GtkWidget *>(spw);
-}
-
-/*
-  Local Variables:
-  mode:c++
-  c-file-style:"stroustrup"
-  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
-  indent-tabs-mode:nil
-  fill-column:99
-  End:
-*/
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
diff --git a/src/widgets/sp-widget.h b/src/widgets/sp-widget.h
deleted file mode 100644
index 3c08a3a50..000000000
--- a/src/widgets/sp-widget.h
+++ /dev/null
@@ -1,74 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-#ifndef SEEN_SP_WIDGET_H
-#define SEEN_SP_WIDGET_H
-
-/*
- * Abstract base class for dynamic control widgets
- *
- * Authors:
- *   Lauris Kaplinski <lauris@kaplinski.com>
- *   Jon A. Cruz <jon@joncruz.org>
- *
- * Copyright (C) 1999-2002 Lauris Kaplinski
- * Copyright (C) 2000-2001 Ximian, Inc.
- * Copyright (C) 2012 Authors
- *
- * Released under GNU GPL v2+, read the file 'COPYING' for more information.
- */
-
-#include <gtk/gtk.h>
-#include "inkscape.h"
-
-#define SP_TYPE_WIDGET (sp_widget_get_type())
-#define SP_WIDGET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SP_TYPE_WIDGET, SPWidget))
-#define SP_WIDGET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SP_TYPE_WIDGET, SPWidgetClass))
-#define SP_IS_WIDGET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SP_TYPE_WIDGET))
-#define SP_IS_WIDGET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SP_TYPE_WIDGET))
-
-namespace Inkscape {
-
-class Selection;
-class SPWidgetImpl;
-}
-
-struct SPWidget {
-    friend class Inkscape::SPWidgetImpl;
-
-    static GType getType();
-
-    GtkBin bin;
-
-    Inkscape::SPWidgetImpl *_impl;
-private:
-    sigc::connection selModified;
-    sigc::connection selChanged;
-    sigc::connection selSet;
-};
-
-struct SPWidgetClass {
-    GtkBinClass bin_class;
-
-    void (* construct) (SPWidget *spw);
-
-    // Selection change handlers
-    void (* modify_selection) (SPWidget *spw, Inkscape::Selection *selection, guint flags);
-    void (* change_selection) (SPWidget *spw, Inkscape::Selection *selection);
-    void (* set_selection) (SPWidget *spw, Inkscape::Selection *selection);
-};
-
-GType sp_widget_get_type();
-
-/** Generic constructor for global widget. */
-GtkWidget *sp_widget_new_global();
-
-#endif // SEEN_SP_WIDGET_H
-/*
-  Local Variables:
-  mode:c++
-  c-file-style:"stroustrup"
-  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
-  indent-tabs-mode:nil
-  fill-column:99
-  End:
-*/
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
diff --git a/src/widgets/spinbutton-events.cpp b/src/widgets/spinbutton-events.cpp
index 1ed55f13f..9800cf5fb 100644
--- a/src/widgets/spinbutton-events.cpp
+++ b/src/widgets/spinbutton-events.cpp
@@ -17,7 +17,6 @@
 
 #include "ui/tools/tool-base.h"
 
-#include "sp-widget.h"
 #include "spinbutton-events.h"
 
 gboolean spinbutton_focus_in(GtkWidget *w, GdkEventKey * /*event*/, gpointer /*data*/)
diff --git a/src/widgets/stroke-style.h b/src/widgets/stroke-style.h
index aca20718b..7d06a5173 100644
--- a/src/widgets/stroke-style.h
+++ b/src/widgets/stroke-style.h
@@ -51,7 +51,6 @@
 #include "ui/widget/spinbutton.h"
 
 #include "widgets/paint-selector.h"
-#include "widgets/sp-widget.h"
 #include "widgets/spw-utilities.h"
 #include "widgets/stroke-marker-selector.h"
 
diff --git a/src/widgets/toolbox.cpp b/src/widgets/toolbox.cpp
index ffc829789..2dd1c57ef 100644
--- a/src/widgets/toolbox.cpp
+++ b/src/widgets/toolbox.cpp
@@ -186,57 +186,57 @@ static struct {
     gchar const *type_name;
     gchar const *data_name;
     GtkWidget *(*create_func)(SPDesktop *desktop);
-    void (*prep_func)(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
+    GtkWidget *(*prep_func)(SPDesktop *desktop, GtkActionGroup* mainActions);
     gchar const *ui_name;
     gint swatch_verb_id;
     gchar const *swatch_tool;
     gchar const *swatch_tip;
 } const aux_toolboxes[] = {
-    { "/tools/select", "select_toolbox", nullptr, sp_select_toolbox_prep,            "SelectToolbar",
+    { "/tools/select", "select_toolbox", nullptr, Inkscape::UI::Toolbar::SelectToolbar::prep,            "SelectToolbar",
       SP_VERB_INVALID, nullptr, nullptr},
-    { "/tools/nodes",   "node_toolbox",   nullptr, sp_node_toolbox_prep,              "NodeToolbar",
+    { "/tools/nodes",   "node_toolbox",   nullptr, Inkscape::UI::Toolbar::NodeToolbar::prep,              "NodeToolbar",
       SP_VERB_INVALID, nullptr, nullptr},
-    { "/tools/tweak",   "tweak_toolbox",   nullptr, sp_tweak_toolbox_prep,              "TweakToolbar",
+    { "/tools/tweak",   "tweak_toolbox",   nullptr, Inkscape::UI::Toolbar::TweakToolbar::prep,              "TweakToolbar",
       SP_VERB_CONTEXT_TWEAK_PREFS, "/tools/tweak", N_("Color/opacity used for color tweaking")},
-    { "/tools/spray",   "spray_toolbox",   nullptr, sp_spray_toolbox_prep,              "SprayToolbar",
+    { "/tools/spray",   "spray_toolbox",   nullptr, Inkscape::UI::Toolbar::SprayToolbar::prep,              "SprayToolbar",
       SP_VERB_INVALID, nullptr, nullptr},
     { "/tools/zoom",   "zoom_toolbox",   Inkscape::UI::Toolbar::ZoomToolbar::create, nullptr, "ZoomToolbar",
       SP_VERB_INVALID, nullptr, nullptr},
-    { "/tools/measure",   "measure_toolbox",   nullptr, sp_measure_toolbox_prep,              "MeasureToolbar",
+    { "/tools/measure",   "measure_toolbox",   nullptr, Inkscape::UI::Toolbar::MeasureToolbar::prep,              "MeasureToolbar",
       SP_VERB_INVALID, nullptr, nullptr},
-    { "/tools/shapes/star",   "star_toolbox",   nullptr, sp_star_toolbox_prep,              "StarToolbar",
+    { "/tools/shapes/star",   "star_toolbox",   nullptr, Inkscape::UI::Toolbar::StarToolbar::prep,              "StarToolbar",
       SP_VERB_CONTEXT_STAR_PREFS,   "/tools/shapes/star",     N_("Style of new stars")},
-    { "/tools/shapes/rect",   "rect_toolbox",   nullptr, sp_rect_toolbox_prep,              "RectToolbar",
+    { "/tools/shapes/rect",   "rect_toolbox",   nullptr, Inkscape::UI::Toolbar::RectToolbar::prep,              "RectToolbar",
       SP_VERB_CONTEXT_RECT_PREFS,   "/tools/shapes/rect",     N_("Style of new rectangles")},
-    { "/tools/shapes/3dbox",  "3dbox_toolbox",  nullptr, box3d_toolbox_prep,             "3DBoxToolbar",
+    { "/tools/shapes/3dbox",  "3dbox_toolbox",  nullptr, Inkscape::UI::Toolbar::Box3DToolbar::prep,             "3DBoxToolbar",
       SP_VERB_CONTEXT_3DBOX_PREFS,  "/tools/shapes/3dbox",    N_("Style of new 3D boxes")},
-    { "/tools/shapes/arc",    "arc_toolbox",    nullptr, sp_arc_toolbox_prep,               "ArcToolbar",
+    { "/tools/shapes/arc",    "arc_toolbox",    nullptr, Inkscape::UI::Toolbar::ArcToolbar::prep,               "ArcToolbar",
       SP_VERB_CONTEXT_ARC_PREFS,    "/tools/shapes/arc",      N_("Style of new ellipses")},
-    { "/tools/shapes/spiral", "spiral_toolbox", nullptr, sp_spiral_toolbox_prep,            "SpiralToolbar",
+    { "/tools/shapes/spiral", "spiral_toolbox", nullptr, Inkscape::UI::Toolbar::SpiralToolbar::prep,            "SpiralToolbar",
       SP_VERB_CONTEXT_SPIRAL_PREFS, "/tools/shapes/spiral",   N_("Style of new spirals")},
-    { "/tools/freehand/pencil", "pencil_toolbox", nullptr, sp_pencil_toolbox_prep,            "PencilToolbar",
+    { "/tools/freehand/pencil", "pencil_toolbox", nullptr, Inkscape::UI::Toolbar::PencilToolbar::prep_pencil,   "PencilToolbar",
       SP_VERB_CONTEXT_PENCIL_PREFS, "/tools/freehand/pencil", N_("Style of new paths created by Pencil")},
-    { "/tools/freehand/pen", "pen_toolbox", nullptr, sp_pen_toolbox_prep,                     "PenToolbar",
+    { "/tools/freehand/pen", "pen_toolbox", nullptr,       Inkscape::UI::Toolbar::PencilToolbar::prep_pen,      "PenToolbar",
       SP_VERB_CONTEXT_PEN_PREFS,    "/tools/freehand/pen",    N_("Style of new paths created by Pen")},
-    { "/tools/calligraphic", "calligraphy_toolbox", nullptr, sp_calligraphy_toolbox_prep,"CalligraphyToolbar",
+    { "/tools/calligraphic", "calligraphy_toolbox", nullptr, Inkscape::UI::Toolbar::CalligraphyToolbar::prep,"CalligraphyToolbar",
       SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS, "/tools/calligraphic", N_("Style of new calligraphic strokes")},
-    { "/tools/eraser", "eraser_toolbox", nullptr, sp_eraser_toolbox_prep,"EraserToolbar",
+    { "/tools/eraser", "eraser_toolbox", nullptr, Inkscape::UI::Toolbar::EraserToolbar::prep,"EraserToolbar",
       SP_VERB_CONTEXT_ERASER_PREFS, "/tools/eraser", _("TBD")},
-    { "/tools/lpetool", "lpetool_toolbox", nullptr, sp_lpetool_toolbox_prep, "LPEToolToolbar",
+    { "/tools/lpetool", "lpetool_toolbox", nullptr, Inkscape::UI::Toolbar::LPEToolbar::prep, "LPEToolToolbar",
       SP_VERB_CONTEXT_LPETOOL_PREFS, "/tools/lpetool", _("TBD")},
     // If you change TextToolbar here, change it also in desktop-widget.cpp
-    { "/tools/text",   "text_toolbox",   nullptr, sp_text_toolbox_prep, "TextToolbar",
+    { "/tools/text",   "text_toolbox",   nullptr, Inkscape::UI::Toolbar::TextToolbar::prep, "TextToolbar",
       SP_VERB_INVALID, nullptr, nullptr},
     { "/tools/dropper", "dropper_toolbox", Inkscape::UI::Toolbar::DropperToolbar::create, nullptr,         "DropperToolbar",
       SP_VERB_INVALID, nullptr, nullptr},
-    { "/tools/connector", "connector_toolbox", nullptr, sp_connector_toolbox_prep,   "ConnectorToolbar",
+    { "/tools/connector", "connector_toolbox", nullptr, Inkscape::UI::Toolbar::ConnectorToolbar::prep,   "ConnectorToolbar",
       SP_VERB_INVALID, nullptr, nullptr},
-    { "/tools/gradient", "gradient_toolbox", nullptr, sp_gradient_toolbox_prep, "GradientToolbar",
+    { "/tools/gradient", "gradient_toolbox", nullptr, Inkscape::UI::Toolbar::GradientToolbar::prep, "GradientToolbar",
       SP_VERB_INVALID, nullptr, nullptr},
-    { "/tools/mesh", "mesh_toolbox", nullptr, sp_mesh_toolbox_prep, "MeshToolbar",
+    { "/tools/mesh", "mesh_toolbox", nullptr, Inkscape::UI::Toolbar::MeshToolbar::prep, "MeshToolbar",
       SP_VERB_INVALID, nullptr, nullptr},
 #if HAVE_POTRACE
-    { "/tools/paintbucket",  "paintbucket_toolbox",  nullptr, sp_paintbucket_toolbox_prep, "PaintbucketToolbar",
+    { "/tools/paintbucket",  "paintbucket_toolbox",  nullptr, Inkscape::UI::Toolbar::PaintbucketToolbar::prep, "PaintbucketToolbar",
       SP_VERB_CONTEXT_PAINTBUCKET_PREFS, "/tools/paintbucket", N_("Style of Paint Bucket fill objects")},
 #else
     { "/tools/paintbucket",  "paintbucket_toolbox",  0, NULL, "PaintbucketToolbar", SP_VERB_NONE, "/tools/paintbucket", N_("Disabled")},
@@ -401,7 +401,7 @@ void purge_repr_listener( GObject* /*obj*/, GObject* tbl )
     }
 }
 
-PrefPusher::PrefPusher( GtkToggleAction *act, Glib::ustring const &path, void (*callback)(GObject*), GObject *cbData ) :
+PrefPusher::PrefPusher( GtkToggleAction *act, Glib::ustring const &path, void (*callback)(gpointer), gpointer cbData ) :
     Observer(path),
     act(act),
     callback(callback),
@@ -714,7 +714,7 @@ EgeAdjustmentAction * create_adjustment_action( gchar const *name,
                                                        gchar const *label, gchar const *shortLabel, gchar const *tooltip,
                                                        Glib::ustring const &path, gdouble def,
                                                        GtkWidget *focusTarget,
-                                                       GObject *dataKludge,
+                                                       GObject * /* dataKludge */,
                                                        gboolean altx, gchar const *altx_mark,
                                                        gdouble lower, gdouble upper, gdouble step, gdouble page,
                                                        gchar const** descrLabels, gdouble const* descrValues, guint descrCount,
@@ -732,7 +732,7 @@ EgeAdjustmentAction * create_adjustment_action( gchar const *name,
     GtkAdjustment* adj = GTK_ADJUSTMENT( gtk_adjustment_new( prefs->getDouble(path, def) * factor,
                                                              lower, upper, step, page, 0 ) );
 
-    g_signal_connect( G_OBJECT(adj), "value-changed", G_CALLBACK(callback), dataKludge );
+//    g_signal_connect( G_OBJECT(adj), "value-changed", G_CALLBACK(callback), dataKludge );
 
     EgeAdjustmentAction* act = ege_adjustment_action_new( adj, name, label, tooltip, nullptr, climb, digits, unit_tracker );
     if ( shortLabel ) {
@@ -751,11 +751,14 @@ EgeAdjustmentAction * create_adjustment_action( gchar const *name,
         g_object_set( G_OBJECT(act), "self-id", altx_mark, NULL );
     }
 
+    /*
+     * TODO: Is this ever used?
     if ( dataKludge ) {
         // Rather lame, but it's the only place where we need to get the entry name
         // but we don't have an Entry
         g_object_set_data( dataKludge, prefs->getEntry(path).getEntryName().data(), adj );
     }
+    */
 
     if (unit_tracker) {
         unit_tracker->addAdjustment(adj);
@@ -1027,12 +1030,11 @@ void setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
             // that only contains a set of GtkActions.  In other
             // words, this doesn't actually show anything... it
             // just defines behaviour.
-            GtkWidget* kludge = gtk_toolbar_new();
+            GtkWidget* kludge = aux_toolboxes[i].prep_func(desktop, mainActions->gobj());
             gtk_widget_set_name( kludge, "Kludge" );
-            g_object_set_data( G_OBJECT(kludge), "dtw", desktop->canvas);
-            g_object_set_data( G_OBJECT(kludge), "desktop", desktop);
+            // g_object_set_data( G_OBJECT(kludge), "dtw", desktop->canvas);
+            // g_object_set_data( G_OBJECT(kludge), "desktop", desktop);
             dataHolders[aux_toolboxes[i].type_name] = kludge;
-            aux_toolboxes[i].prep_func( desktop, mainActions->gobj(), G_OBJECT(kludge) );
         } else {
 
             // For the "create" method, directly create a "real" toolbar,
diff --git a/src/widgets/toolbox.h b/src/widgets/toolbox.h
index 4a61a7892..2236a7ab1 100644
--- a/src/widgets/toolbox.h
+++ b/src/widgets/toolbox.h
@@ -84,7 +84,10 @@ public:
      * @param callback function to invoke when changes are pushed.
      * @param cbData data to be passed on to the callback function.
      */
-    PrefPusher( GtkToggleAction *act, Glib::ustring const &path, void (*callback)(GObject*) = nullptr, GObject *cbData = nullptr );
+    PrefPusher( GtkToggleAction       *act,
+                Glib::ustring const &  path,
+                void (*callback)(gpointer) = nullptr,
+                gpointer cbData = nullptr );
 
     /**
      * Destructor that unregisters the preference callback.
@@ -112,8 +115,8 @@ private:
     void handleToggled();
 
     GtkToggleAction *act;
-    void (*callback)(GObject*);
-    GObject *cbData;
+    void (*callback)(gpointer);
+    gpointer cbData;
     bool freeze;
 };