Merge branch 'text-toolbar-migration'

39 files changed, 1471 insertions, 3693 deletions

diff --git a/share/ui/toolbar-select.ui b/share/ui/toolbar-select.ui
deleted file mode 100644
index abb3e6080..000000000
--- a/share/ui/toolbar-select.ui
+++ /dev/null
@@ -1,28 +0,0 @@
-<ui>
-  <toolbar name='TextToolbar'>
-    <toolitem action='TextFontFamilyAction' />
-    <toolitem action='TextFontStyleAction' />
-    <separator />
-    <toolitem action='TextOuterStyleAction' />
-    <toolitem action='TextFontSizeAction' />
-    <toolitem action='TextLineHeightAction' />
-    <toolitem action='TextLineHeightUnitsAction' />
-    <toolitem action='TextLineHeightUnsetAction' />
-    <toolitem action='TextLineSpacingAction' />
-    <separator />
-    <toolitem action='TextAlignAction' />
-    <separator />
-    <toolitem action='TextSuperscriptAction' />
-    <toolitem action='TextSubscriptAction' />
-    <separator />
-    <toolitem action='TextLetterSpacingAction' />
-    <toolitem action='TextWordSpacingAction' />
-    <toolitem action='TextDxAction' />
-    <toolitem action='TextDyAction' />
-    <toolitem action='TextRotationAction' />
-    <separator />
-    <toolitem action='TextWritingModeAction' />
-    <toolitem action='TextOrientationAction' />
-    <toolitem action='TextDirectionAction' />
-  </toolbar>
-</ui>
diff --git a/src/desktop.cpp b/src/desktop.cpp
index 4c28cd918..ab8d70601 100644
--- a/src/desktop.cpp
+++ b/src/desktop.cpp
@@ -1524,10 +1524,10 @@ SPDesktop::setToolboxAdjustmentValue (gchar const* id, double val)
     _widget->setToolboxAdjustmentValue (id, val);
 }
 
-void
-SPDesktop::setToolboxSelectOneValue (gchar const* id, gint val)
+Gtk::Toolbar*
+SPDesktop::get_toolbar_by_name(const Glib::ustring& name)
 {
-    _widget->setToolboxSelectOneValue (id, val);
+    return _widget->get_toolbar_by_name(name);
 }
 
 bool
diff --git a/src/desktop.h b/src/desktop.h
index 66fad5a65..9b37754c7 100644
--- a/src/desktop.h
+++ b/src/desktop.h
@@ -65,7 +65,8 @@ class InkscapeWindow;
 
 namespace Gtk
 {
-  class Window;
+    class Toolbar;
+    class Window;
 }
 
 typedef int sp_verb_t;
@@ -388,8 +389,8 @@ public:
     void layoutWidget();
     void destroyWidget();
     void setToolboxFocusTo (gchar const* label);
+    Gtk::Toolbar* get_toolbar_by_name(const Glib::ustring& name); 
     void setToolboxAdjustmentValue (gchar const* id, double val);
-    void setToolboxSelectOneValue (gchar const* id, gint val);
     bool isToolboxButtonActive (gchar const *id);
     void updateNow();
     void updateCanvasNow();
diff --git a/src/ui/CMakeLists.txt b/src/ui/CMakeLists.txt
index bf773ba6f..d4f906836 100644
--- a/src/ui/CMakeLists.txt
+++ b/src/ui/CMakeLists.txt
@@ -162,6 +162,7 @@ set(ui_SRC
 	widget/color-scales.cpp
 	widget/color-slider.cpp
 	widget/color-wheel-selector.cpp
+	widget/combo-box-entry-tool-item.cpp
         widget/combo-tool-item.cpp
     widget/dash-selector.cpp
 	widget/dock-item.cpp
@@ -179,7 +180,6 @@ set(ui_SRC
 	widget/imagetoggler.cpp
     widget/ink-color-wheel.cpp
 	widget/ink-flow-box.cpp
-	widget/ink-select-one-action.cpp
 	widget/ink-spinscale.cpp
 	widget/insertordericon.cpp
         widget/label-tool-item.cpp
@@ -396,6 +396,7 @@ set(ui_SRC
 	widget/color-slider.h
 	widget/color-wheel-selector.h
 	widget/combo-enums.h
+	widget/combo-box-entry-tool-item.h
         widget/combo-tool-item.h
     widget/dash-selector.h
 	widget/dock-item.h
@@ -414,7 +415,6 @@ set(ui_SRC
 	widget/imagetoggler.h
     widget/ink-color-wheel.h
     widget/ink-flow-box.h
-	widget/ink-select-one-action.h
 	widget/ink-spinscale.h
         widget/label-tool-item.h
 	widget/labelled.h
diff --git a/src/ui/toolbar/arc-toolbar.h b/src/ui/toolbar/arc-toolbar.h
index 08acc136b..b0b04500b 100644
--- a/src/ui/toolbar/arc-toolbar.h
+++ b/src/ui/toolbar/arc-toolbar.h
@@ -32,7 +32,6 @@
 
 #include <gtkmm/adjustment.h>
 
-class InkSelectOneAction;
 class SPDesktop;
 class SPItem;
 
diff --git a/src/ui/toolbar/box3d-toolbar.h b/src/ui/toolbar/box3d-toolbar.h
index c5970bf3b..dc74664ee 100644
--- a/src/ui/toolbar/box3d-toolbar.h
+++ b/src/ui/toolbar/box3d-toolbar.h
@@ -37,10 +37,6 @@
 class Persp3D;
 class SPDesktop;
 
-typedef struct _EgeAdjustmentAction EgeAdjustmentAction;
-typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _InkToggleAction InkToggleAction;
-
 namespace Inkscape {
 class Selection;
 
diff --git a/src/ui/toolbar/lpe-toolbar.cpp b/src/ui/toolbar/lpe-toolbar.cpp
index 067687f02..ef5a2ce1c 100644
--- a/src/ui/toolbar/lpe-toolbar.cpp
+++ b/src/ui/toolbar/lpe-toolbar.cpp
@@ -173,6 +173,12 @@ LPEToolbar::LPEToolbar(SPDesktop *desktop)
     show_all();
 }
 
+void
+LPEToolbar::set_mode(int mode)
+{
+    _mode_buttons[mode]->set_active();
+}
+
 GtkWidget *
 LPEToolbar::create(SPDesktop *desktop)
 {
diff --git a/src/ui/toolbar/lpe-toolbar.h b/src/ui/toolbar/lpe-toolbar.h
index 1609f3915..23647a73c 100644
--- a/src/ui/toolbar/lpe-toolbar.h
+++ b/src/ui/toolbar/lpe-toolbar.h
@@ -92,6 +92,7 @@ protected:
 
 public:
     static GtkWidget * create(SPDesktop *desktop);
+    void set_mode(int mode);
 };
 
 }
diff --git a/src/ui/toolbar/rect-toolbar.h b/src/ui/toolbar/rect-toolbar.h
index 3aee3b563..58d4b2c1c 100644
--- a/src/ui/toolbar/rect-toolbar.h
+++ b/src/ui/toolbar/rect-toolbar.h
@@ -36,10 +36,6 @@ class SPDesktop;
 class SPItem;
 class SPRect;
 
-typedef struct _EgeAdjustmentAction EgeAdjustmentAction;
-typedef struct _EgeOutputAction EgeOutputAction;
-typedef struct _InkAction InkAction;
-
 namespace Gtk {
 class Toolbutton;
 }
diff --git a/src/ui/toolbar/select-toolbar.cpp b/src/ui/toolbar/select-toolbar.cpp
index e405b914f..87682b127 100644
--- a/src/ui/toolbar/select-toolbar.cpp
+++ b/src/ui/toolbar/select-toolbar.cpp
@@ -37,7 +37,6 @@
 
 #include "ui/icon-names.h"
 #include "ui/widget/combo-tool-item.h"
-#include "ui/widget/ink-select-one-action.h"
 #include "ui/widget/spin-button-tool-item.h"
 #include "ui/widget/unit-tracker.h"
 
diff --git a/src/ui/toolbar/spray-toolbar.cpp b/src/ui/toolbar/spray-toolbar.cpp
index 620351a99..9e7c4e820 100644
--- a/src/ui/toolbar/spray-toolbar.cpp
+++ b/src/ui/toolbar/spray-toolbar.cpp
@@ -528,6 +528,12 @@ SprayToolbar::on_pref_toggled(Gtk::ToggleToolButton *btn,
     prefs->setBool(path, active);
 }
 
+void
+SprayToolbar::set_mode(int mode)
+{
+    _mode_buttons[mode]->set_active();
+}
+
 }
 }
 }
diff --git a/src/ui/toolbar/spray-toolbar.h b/src/ui/toolbar/spray-toolbar.h
index 8c8d9172b..4587cf033 100644
--- a/src/ui/toolbar/spray-toolbar.h
+++ b/src/ui/toolbar/spray-toolbar.h
@@ -97,6 +97,8 @@ protected:
 
 public:
     static GtkWidget * create(SPDesktop *desktop);
+
+    void set_mode(int mode);
 };
 }
 }
diff --git a/src/ui/toolbar/text-toolbar.cpp b/src/ui/toolbar/text-toolbar.cpp
index 3b55f8b08..8e747cb39 100644
--- a/src/ui/toolbar/text-toolbar.cpp
+++ b/src/ui/toolbar/text-toolbar.cpp
@@ -35,8 +35,6 @@
 #include "desktop.h"
 #include "document-undo.h"
 #include "document.h"
-#include "widgets/ink-toggle-action.h"
-#include "widgets/toolbox.h"
 #include "inkscape.h"
 #include "selection-chemistry.h"
 #include "text-editing.h"
@@ -55,15 +53,14 @@
 
 #include "ui/icon-names.h"
 #include "ui/tools/text-tool.h"
-#include "ui/widget/ink-select-one-action.h"
+#include "ui/widget/combo-box-entry-tool-item.h"
+#include "ui/widget/combo-tool-item.h"
+#include "ui/widget/spin-button-tool-item.h"
 #include "ui/widget/unit-tracker.h"
 
-#include "widgets/ege-adjustment-action.h"
-#include "widgets/ink-comboboxentry-action.h"
 #include "widgets/style-utils.h"
 
 using Inkscape::DocumentUndo;
-using Inkscape::UI::ToolboxFactory;
 using Inkscape::Util::Unit;
 using Inkscape::Util::Quantity;
 using Inkscape::Util::unit_table;
@@ -270,16 +267,8 @@ TextToolbar::TextToolbar(SPDesktop *desktop)
     _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 */
     {
@@ -289,31 +278,30 @@ TextToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
         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
+        _font_family_item =
+            Gtk::manage(new UI::Widget::ComboBoxEntryToolItem( "TextFontFamilyAction",
+                                                               _("Font Family"),
+                                                               _("Select Font Family (Alt-X to access)"),
+                                                               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
+        _font_family_item->popup_enable(); // 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 );
+        _font_family_item->set_info( info ); // Show selection icon
+        _font_family_item->set_info_cb( (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 );
+        _font_family_item->set_warning( warning ); // Show icon w/ tooltip if font missing
+        _font_family_item->set_warning_cb( (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) );
+        _font_family_item->set_altx_name( "altx-text" ); // Set Alt-X keyboard shortcut
+        _font_family_item->signal_changed().connect( sigc::mem_fun(*this, &TextToolbar::fontfamily_value_changed) );
+        add(*_font_family_item);
 
         // Change style of drop-down from menu to list
         auto css_provider = gtk_css_provider_new();
@@ -329,6 +317,39 @@ TextToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
                                                   GTK_STYLE_PROVIDER_PRIORITY_USER);
     }
 
+    /* Font styles */
+    {
+        Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance();
+        Glib::RefPtr<Gtk::ListStore> store = fontlister->get_style_list();
+        GtkListStore* model_style = store->gobj();
+
+        _font_style_item = Gtk::manage(new UI::Widget::ComboBoxEntryToolItem( "TextFontStyleAction",
+                                                                              _("Font Style"),
+                                                                              _("Font style"),
+                                                                              GTK_TREE_MODEL(model_style),
+                                                                              12,     // Width in characters
+                                                                              0,      // Extra list width
+                                                                              nullptr,   // Cell layout
+                                                                              nullptr,   // Separator
+                                                                              GTK_WIDGET(desktop->canvas))); // Focus widget
+
+        _font_style_item->signal_changed().connect(sigc::mem_fun(*this, &TextToolbar::fontstyle_value_changed));
+        add(*_font_style_item);
+    }
+
+    add_separator();
+
+    /* Text outer style */
+    {
+        _outer_style_item = Gtk::manage(new Gtk::ToggleToolButton());
+        _outer_style_item->set_label(_("Show outer style"));
+        _outer_style_item->set_tooltip_text(_("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."));
+        _outer_style_item->set_icon_name(INKSCAPE_ICON("text_outer_style"));
+        add(*_outer_style_item);
+        _outer_style_item->signal_toggled().connect(sigc::mem_fun(*this, &TextToolbar::outer_style_changed));
+        _outer_style_item->set_active(prefs->getBool("/tools/text/outer_style", false));
+    }
+
     /* Font size */
     {
         // List of font sizes for drop-down menu
@@ -338,71 +359,111 @@ TextToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
 
         sp_text_set_sizes(model_size, unit);
 
-        Glib::ustring tooltip = Glib::ustring::format(_("Font size"), " (", sp_style_get_css_unit_string(unit), ")");
+        auto unit_str = sp_style_get_css_unit_string(unit);
+        Glib::ustring tooltip = Glib::ustring::format(_("Font size"), " (", unit_str, ")");
 
-        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
+        _font_size_item = Gtk::manage(new UI::Widget::ComboBoxEntryToolItem( "TextFontSizeAction",
+                                                                             _("Font Size"),
+                                                                             tooltip,
+                                                                             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_size_item->signal_changed().connect(sigc::mem_fun(*this, &TextToolbar::fontsize_value_changed));
+        add(*_font_size_item);
     }
 
-    /* Font styles */
+    /* Line height */
     {
-        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
+        // Drop down menu
+        std::vector<Glib::ustring> labels = {_("Smaller spacing"),  "",  "",  "",  "", C_("Text tool", "Normal"),  "", "",   "",  "",  "", _("Larger spacing")};
+        std::vector<double>        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};
+
+        auto line_height_val = prefs->getDouble("/tools/text/lineheight", 0.0);
+        _line_height_adj = Gtk::Adjustment::create(line_height_val, 0.0, 1000.0, 0.1, 1.0);
+        _line_height_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("text-line-height", _("Line:"), _line_height_adj, 0.1, 2));
+        _line_height_item->set_tooltip_text(_("Spacing between baselines"));
+        _line_height_item->set_custom_numeric_menu_data(values, labels);
+        _line_height_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas)));
+        _line_height_adj->signal_value_changed().connect(sigc::mem_fun(*this, &TextToolbar::lineheight_value_changed));
+        //_tracker->addAdjustment(_line_height_adj->gobj()); // (Alex V) Why is this commented out?
+        add(*_line_height_item);
+        _line_height_item->set_sensitive(true);
+        _line_height_item->set_icon(INKSCAPE_ICON("text_line_spacing"));
+    }
 
-        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) );
+    /* Line height units */
+    {
+        _line_height_units_item = _tracker->create_tool_item( _("Units"), ("") );
+        add(*_line_height_units_item);
+        _line_height_units_item->signal_changed_after().connect(sigc::mem_fun(*this, &TextToolbar::lineheight_unit_changed));
     }
 
-    /* Style - Superscript */
+    /* Text line height unset */
     {
-        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) );
+        _line_height_unset_item = Gtk::manage(new Gtk::ToggleToolButton());
+        _line_height_unset_item->set_label(_("Unset line height"));
+        _line_height_unset_item->set_tooltip_text(_("If enabled, line height is set on part of selection. Click to unset."));
+        _line_height_unset_item->set_icon_name(INKSCAPE_ICON("paint-unknown"));
+        add(*_line_height_unset_item);
+        _line_height_unset_item->signal_toggled().connect(sigc::mem_fun(*this, &TextToolbar::lineheight_unset_changed));
+        _line_height_unset_item->set_active(prefs->getBool("/tools/text/line_height_unset", false));
     }
 
-    /* Style - Subscript */
+    /* Line spacing mode */
     {
-        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) );
+        UI::Widget::ComboToolItemColumns 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;
+
+        _line_spacing_item =
+            UI::Widget::ComboToolItem::create(_("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
+        _line_spacing_item->use_icon(true);
+        _line_spacing_item->use_label(true);
+        gint mode = prefs->getInt("/tools/text/line_spacing_mode", 0);
+        _line_spacing_item->set_active( mode );
+
+        add(*_line_spacing_item);
+
+        _line_spacing_item->signal_changed().connect(sigc::mem_fun(*this, &TextToolbar::line_spacing_mode_changed));
     }
 
+    add_separator();
+
     /* Alignment */
     {
-        InkSelectOneActionColumns columns;
+        UI::Widget::ComboToolItemColumns columns;
 
         Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
 
@@ -432,25 +493,135 @@ TextToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
         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 );
+        _align_item =
+            UI::Widget::ComboToolItem::create(_("Alignment"),      // Label
+                                              _("Text alignment"), // Tooltip
+                                              "Not Used",          // Icon
+                                              store );             // Tree store
+        _align_item->use_icon( true );
+        _align_item->use_label( false );
         gint mode = prefs->getInt("/tools/text/align_mode", 0);
-        toolbar->_align_action->set_active( mode );
+        _align_item->set_active( mode );
 
-        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_align_action->gobj() ));
+        add(*_align_item);
 
-        toolbar->_align_action->signal_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::align_mode_changed));
+        _align_item->signal_changed().connect(sigc::mem_fun(*this, &TextToolbar::align_mode_changed));
     }
 
+    add_separator();
+
+    /* Style - Superscript */
+    {
+        _superscript_item = Gtk::manage(new Gtk::ToggleToolButton());
+        _superscript_item->set_label(_("Toggle superscript"));
+        _superscript_item->set_tooltip_text(_("Toggle superscript"));
+        _superscript_item->set_icon_name(INKSCAPE_ICON("text_superscript"));
+        _superscript_item->set_name("text-superscript");
+        add(*_superscript_item);
+        _superscript_item->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &TextToolbar::script_changed), _superscript_item));
+        _superscript_item->set_active(prefs->getBool("/tools/text/super", false));
+    }
+
+    /* Style - Subscript */
+    {
+        _subscript_item = Gtk::manage(new Gtk::ToggleToolButton());
+        _subscript_item->set_label(_("Toggle subscript"));
+        _subscript_item->set_tooltip_text(_("Toggle subscript"));
+        _subscript_item->set_icon_name(INKSCAPE_ICON("text_subscript"));
+        _subscript_item->set_name("text-subscript");
+        add(*_subscript_item);
+        _subscript_item->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &TextToolbar::script_changed), _subscript_item));
+        _subscript_item->set_active(prefs->getBool("/tools/text/sub", false));
+    }
+
+    add_separator();
+
+    /* Letter spacing */
+    {
+        // Drop down menu
+        std::vector<Glib::ustring> labels = {_("Negative spacing"),   "",   "",   "", C_("Text tool", "Normal"),  "",  "",  "",  "",  "",  "",  "", _("Positive spacing")};
+        std::vector<double>        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};
+        auto letter_spacing_val = prefs->getDouble("/tools/text/letterspacing", 0.0);
+        _letter_spacing_adj = Gtk::Adjustment::create(letter_spacing_val, -100.0, 100.0, 0.01, 0.10);
+        _letter_spacing_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("text-letter-spacing", _("Letter:"), _letter_spacing_adj, 0.1, 2));
+        _letter_spacing_item->set_tooltip_text(_("Spacing between letters (px)"));
+        _letter_spacing_item->set_custom_numeric_menu_data(values, labels);
+        _letter_spacing_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas)));
+        _letter_spacing_adj->signal_value_changed().connect(sigc::mem_fun(*this, &TextToolbar::letterspacing_value_changed));
+        add(*_letter_spacing_item);
+        _letter_spacing_item->set_sensitive(true);
+        _letter_spacing_item->set_icon(INKSCAPE_ICON("text_letter_spacing"));
+    }
+
+    /* Word spacing */
+    {
+        // Drop down menu
+        std::vector<Glib::ustring> labels = {_("Negative spacing"),   "",   "",   "", C_("Text tool", "Normal"),  "",  "",  "",  "",  "",  "",  "", _("Positive spacing")};
+        std::vector<double>        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};
+        auto word_spacing_val = prefs->getDouble("/tools/text/wordspacing", 0.0);
+        _word_spacing_adj = Gtk::Adjustment::create(word_spacing_val, -100.0, 100.0, 0.01, 0.10);
+        _word_spacing_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("text-word-spacing", _("Word:"), _word_spacing_adj, 0.1, 2));
+        _word_spacing_item->set_tooltip_text(_("Spacing between words (px)"));
+        _word_spacing_item->set_custom_numeric_menu_data(values, labels);
+        _word_spacing_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas)));
+        _word_spacing_adj->signal_value_changed().connect(sigc::mem_fun(*this, &TextToolbar::wordspacing_value_changed));
+        add(*_word_spacing_item);
+        _word_spacing_item->set_sensitive(true);
+        _word_spacing_item->set_icon(INKSCAPE_ICON("text_word_spacing"));
+    }
+
+    /* Character kerning (horizontal shift) */
+    {
+        // Drop down menu
+        std::vector<double> values = { -2.0, -1.5, -1.0, -0.5,   0,  0.5,  1.0,  1.5,  2.0, 2.5 };
+        auto dx_val = prefs->getDouble("/tools/text/dx", 0.0);
+        _dx_adj = Gtk::Adjustment::create(dx_val, -100.0, 100.0, 0.01, 0.1);
+        _dx_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("text-dx", _("Kern:"), _dx_adj, 0.1, 2));
+        _dx_item->set_custom_numeric_menu_data(values);
+        _dx_item->set_tooltip_text(_("Horizontal kerning (px)"));
+        _dx_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas)));
+        _dx_adj->signal_value_changed().connect(sigc::mem_fun(*this, &TextToolbar::dx_value_changed));
+        add(*_dx_item);
+        _dx_item->set_sensitive(true);
+        _dx_item->set_icon(INKSCAPE_ICON("text_horz_kern"));
+    }
+
+    /* Character vertical shift */
+    {
+        // Drop down menu
+        std::vector<double> values = { -2.0, -1.5, -1.0, -0.5,   0,  0.5,  1.0,  1.5,  2.0, 2.5 };
+        auto dy_val = prefs->getDouble("/tools/text/dy", 0.0);
+        _dy_adj = Gtk::Adjustment::create(dy_val, -100.0, 100.0, 0.01, 0.1);
+        _dy_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("text-dy", _("Vert:"), _dy_adj, 0.1, 2));
+        _dy_item->set_tooltip_text(_("Vertical kerning (px)"));
+        _dy_item->set_custom_numeric_menu_data(values);
+        _dy_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas)));
+        _dy_adj->signal_value_changed().connect(sigc::mem_fun(*this, &TextToolbar::dy_value_changed));
+        _dy_item->set_sensitive(true);
+        _dy_item->set_icon(INKSCAPE_ICON("text_vert_kern"));
+        add(*_dy_item);
+    }
+
+    /* Character rotation */
+    {
+        std::vector<double> values = { -90, -45, -30, -15,   0,  15,  30,  45,  90, 180 };
+        auto rotation_val = prefs->getDouble("/tools/text/rotation", 0.0);
+        _rotation_adj = Gtk::Adjustment::create(rotation_val, -180.0, 180.0, 0.1, 1.0);
+        _rotation_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("text-rotation", _("Rot:"), _rotation_adj, 0.1, 2));
+        _rotation_item->set_tooltip_text(_("Character rotation (degrees)"));
+        _rotation_item->set_custom_numeric_menu_data(values);
+        _rotation_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas)));
+        _rotation_adj->signal_value_changed().connect(sigc::mem_fun(*this, &TextToolbar::rotation_value_changed));
+        _rotation_item->set_sensitive();
+        _rotation_item->set_icon(INKSCAPE_ICON("text_rotation"));
+        add(*_rotation_item);
+    }
+
+    add_separator();
+
     /* Writing mode (Horizontal, Vertical-LR, Vertical-RL) */
     {
-        InkSelectOneActionColumns columns;
+        UI::Widget::ComboToolItemColumns columns;
 
         Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
 
@@ -474,25 +645,25 @@ TextToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
         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 );
+        _writing_mode_item =
+            UI::Widget::ComboToolItem::create( _("Writing mode"),       // Label
+                                               _("Block progression"),  // Tooltip
+                                               "Not Used",              // Icon
+                                               store );                 // Tree store
+        _writing_mode_item->use_icon(true);
+        _writing_mode_item->use_label( false );
         gint mode = prefs->getInt("/tools/text/writing_mode", 0);
-        toolbar->_writing_mode_action->set_active( mode );
+        _writing_mode_item->set_active( mode );
 
-        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_writing_mode_action->gobj() ));
+        add(*_writing_mode_item);
 
-        toolbar->_writing_mode_action->signal_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::writing_mode_changed));
+        _writing_mode_item->signal_changed().connect(sigc::mem_fun(*this, &TextToolbar::writing_mode_changed));
     }
 
+
     /* Text (glyph) orientation (Auto (mixed), Upright, Sideways) */
     {
-        InkSelectOneActionColumns columns;
+        UI::Widget::ComboToolItemColumns columns;
 
         Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
 
@@ -516,25 +687,24 @@ TextToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
         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 );
+        _orientation_item =
+            UI::Widget::ComboToolItem::create(_("Text orientation"),    // Label
+                                              _("Text (glyph) orientation in vertical text."),  // Tooltip
+                                              "Not Used",               // Icon
+                                              store );                  // List store
+        _orientation_item->use_icon(true);
+        _orientation_item->use_label( false );
         gint mode = prefs->getInt("/tools/text/text_orientation", 0);
-        toolbar->_orientation_action->set_active( mode );
+        _orientation_item->set_active( mode );
 
-        gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_orientation_action->gobj() ));
+        add(*_orientation_item);
 
-        toolbar->_orientation_action->signal_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::orientation_changed));
+        _orientation_item->signal_changed().connect(sigc::mem_fun(*this, &TextToolbar::orientation_changed));
     }
 
     // Text direction (predominant direction of horizontal text).
     {
-        InkSelectOneActionColumns columns;
+        UI::Widget::ComboToolItemColumns columns;
 
         Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
 
@@ -552,299 +722,31 @@ TextToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
         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 );
+        _direction_item =
+            UI::Widget::ComboToolItem::create( _("Text direction"),    // Label
+                                               _("Text direction for normally horizontal text."),  // Tooltip
+                                               "Not Used",               // Icon
+                                               store );                  // List store
+        _direction_item->use_icon(true);
+        _direction_item->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() ));
+        _direction_item->set_active( mode );
 
-        toolbar->_direction_action->signal_changed_after().connect(sigc::mem_fun(*toolbar, &TextToolbar::direction_changed));
+        add(*_direction_item);
+        _direction_item->signal_changed_after().connect(sigc::mem_fun(*this, &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 */
-            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, // tracker,                  /* unit tracker */
-            0.1,                                  /* step (used?) */
-            2,                                    /* digits to show */
-            1.0                                   /* factor (multiplies default) */
-            );
-        ege_adjustment_action_set_focuswidget(toolbar->_line_height_action, GTK_WIDGET(desktop->canvas));
-
-        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 */
-            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,                                 /* unit tracker */
-            0.1,                                  /* step (used?) */
-            2,                                    /* digits to show */
-            1.0                                   /* factor (multiplies default) */
-            );
-        ege_adjustment_action_set_focuswidget(toolbar->_word_spacing_action, GTK_WIDGET(desktop->canvas));
-
-        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 */
-            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,                                 /* unit tracker */
-            0.1,                                  /* step (used?) */
-            2,                                    /* digits to show */
-            1.0                                   /* factor (multiplies default) */
-            );
-        ege_adjustment_action_set_focuswidget(toolbar->_letter_spacing_action, GTK_WIDGET(desktop->canvas));
-        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 */
-            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,                              /* unit tracker */
-            0.1,                                  /* step (used?) */
-            2,                                    /* digits to show */
-            1.0                                   /* factor (multiplies default) */
-            );
-        ege_adjustment_action_set_focuswidget(toolbar->_dx_action, GTK_WIDGET(desktop->canvas));
-        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 */
-            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,                                 /* unit tracker */
-            0.1,                                  /* step (used?) */
-            2,                                    /* digits to show */
-            1.0                                   /* factor (multiplies default) */
-            );
-        ege_adjustment_action_set_focuswidget(toolbar->_dy_action, GTK_WIDGET(desktop->canvas));
-        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 */
-            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,                                 /* unit tracker */
-            0.1,                                  /* step (used?) */
-            2,                                    /* digits to show */
-            1.0                                   /* factor (multiplies default) */
-            );
-        ege_adjustment_action_set_focuswidget(toolbar->_rotation_action, GTK_WIDGET(desktop->canvas));
-        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) );
-    }
+    show_all();
 
     // Is this necessary to call? Shouldn't hurt.
-    toolbar->selection_changed(desktop->getSelection());
+    selection_changed(desktop->getSelection());
 
-    desktop->connectEventContextChanged(sigc::mem_fun(*toolbar, &TextToolbar::watch_ec));
-
-    return GTK_WIDGET(toolbar->gobj());
+    desktop->connectEventContextChanged(sigc::mem_fun(*this, &TextToolbar::watch_ec));
 }
 
 void
-TextToolbar::fontfamily_value_changed( Ink_ComboBoxEntry_Action *act, gpointer data )
+TextToolbar::fontfamily_value_changed()
 {
-    auto toolbar = reinterpret_cast<TextToolbar *>(data);
-
 #ifdef DEBUG_TEXT
     std::cout << std::endl;
     std::cout << "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM" << std::endl;
@@ -852,16 +754,16 @@ TextToolbar::fontfamily_value_changed( Ink_ComboBoxEntry_Action *act, gpointer d
 #endif
 
      // quit if run by the _changed callbacks
-    if (toolbar->_freeze) {
+    if (_freeze) {
 #ifdef DEBUG_TEXT
         std::cout << "sp_text_fontfamily_value_changed: frozen... return" << std::endl;
         std::cout << "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM\n" << std::endl;
 #endif
         return;
     }
-    toolbar->_freeze = true;
+    _freeze = true;
 
-    Glib::ustring new_family = ink_comboboxentry_action_get_active_text( act );
+    Glib::ustring new_family = _font_family_item->get_active_text();
     css_font_family_unquote( new_family ); // Remove quotes around font family names.
 
     // TODO: Think about how to handle handle multiple selections. While
@@ -877,13 +779,16 @@ TextToolbar::fontfamily_value_changed( Ink_ComboBoxEntry_Action *act, gpointer d
     if( new_family.compare( fontlister->get_font_family() ) != 0 ) {
         // Changed font-family
 
-        if( act->active == -1 ) {
+        if( _font_family_item->get_active() == -1 ) {
             // New font-family, not in document, not on system (could be fallback list)
             fontlister->insert_font_family( new_family );
-            act->active = 0; // New family is always at top of list.
+
+            // This just sets a variable in the ComboBoxEntryAction object...
+            // shouldn't we also set the actual active row in the combobox?
+            _font_family_item->set_active(0); // New family is always at top of list.
         }
 
-        fontlister->set_font_family( act->active );
+        fontlister->set_font_family( _font_family_item->get_active() );
         // active text set in sp_text_toolbox_selection_changed()
 
         SPCSSAttr *css = sp_repr_css_attr_new ();
@@ -904,7 +809,7 @@ TextToolbar::fontfamily_value_changed( Ink_ComboBoxEntry_Action *act, gpointer d
     }
 
     // unfreeze
-    toolbar->_freeze = false;
+    _freeze = false;
 
 #ifdef DEBUG_TEXT
     std::cout << "sp_text_toolbox_fontfamily_changes: exit"  << std::endl;
@@ -913,24 +818,29 @@ TextToolbar::fontfamily_value_changed( Ink_ComboBoxEntry_Action *act, gpointer d
 #endif
 }
 
-void
-TextToolbar::fontsize_value_changed( Ink_ComboBoxEntry_Action *act, gpointer data)
+GtkWidget *
+TextToolbar::create(SPDesktop *desktop)
 {
-    auto toolbar = reinterpret_cast<TextToolbar *>(data);
+    auto tb = Gtk::manage(new TextToolbar(desktop));
+    return GTK_WIDGET(tb->gobj());
+}
 
+void
+TextToolbar::fontsize_value_changed()
+{
     // quit if run by the _changed callbacks
-    if (toolbar->_freeze) {
+    if (_freeze) {
         return;
     }
-    toolbar->_freeze = true;
+    _freeze = true;
 
-    gchar *text = ink_comboboxentry_action_get_active_text( act );
+    gchar *text = _font_size_item->get_active_text();
     gchar *endptr;
     gdouble size = g_strtod( text, &endptr );
     if (endptr == text) {  // Conversion failed, non-numeric input.
         g_warning( "Conversion of size text to double failed, input: %s\n", text );
         g_free( text );
-        toolbar->_freeze = false;
+        _freeze = false;
         return;
     }
     g_free( text );
@@ -999,21 +909,19 @@ TextToolbar::fontsize_value_changed( Ink_ComboBoxEntry_Action *act, gpointer dat
 
     sp_repr_css_attr_unref (css);
 
-    toolbar->_freeze = false;
+    _freeze = false;
 }
 
 void
-TextToolbar::fontstyle_value_changed( Ink_ComboBoxEntry_Action *act, gpointer data)
+TextToolbar::fontstyle_value_changed()
 {
-    auto toolbar = reinterpret_cast<TextToolbar *>(data);
-
     // quit if run by the _changed callbacks
-    if (toolbar->_freeze) {
+    if (_freeze) {
         return;
     }
-    toolbar->_freeze = true;
+    _freeze = true;
 
-    Glib::ustring new_style = ink_comboboxentry_action_get_active_text( act );
+    Glib::ustring new_style = _font_style_item->get_active_text();
 
     Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance();
 
@@ -1046,26 +954,26 @@ TextToolbar::fontstyle_value_changed( Ink_ComboBoxEntry_Action *act, gpointer da
 
     }
 
-    toolbar->_freeze = false;
+    _freeze = false;
 }
 
 // Handles both Superscripts and Subscripts
 void
-TextToolbar::script_changed( InkToggleAction* act, gpointer data)
+TextToolbar::script_changed(Gtk::ToggleToolButton *btn)
 {
-    auto toolbar = reinterpret_cast<TextToolbar *>(data);
     // quit if run by the _changed callbacks
-    if (toolbar->_freeze) {
+    if (_freeze) {
         return;
     }
-    toolbar->_freeze = true;
+
+    _freeze = true;
 
     // Called by Superscript or Subscript button?
-    const gchar* name = gtk_action_get_name( GTK_ACTION( act ) );
-    gint prop = (strcmp(name, "TextSuperscriptAction") == 0) ? 0 : 1;
+    auto name = btn->get_name();
+    gint prop = (strcmp(name.c_str(), "TextSuperscriptAction") == 0) ? 0 : 1;
 
 #ifdef DEBUG_TEXT
-    std::cout << "sp_text_script_changed: " << prop << std::endl;
+    std::cout << "TextToolbar::script_changed: " << prop << std::endl;
 #endif
 
     // Query baseline
@@ -1125,7 +1033,7 @@ TextToolbar::script_changed( InkToggleAction* act, gpointer data)
         DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:script", SP_VERB_NONE,
                              _("Text: Change superscript or subscript"));
     }
-    toolbar->_freeze = false;
+    _freeze = false;
 }
 
 void
@@ -1796,13 +1704,13 @@ TextToolbar::line_spacing_mode_changed(int mode)
     // Set "Outer Style" toggle to match mode.
     switch (mode) {
         case 0: // Adaptive
-            gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(_outer_style_action), false );
+            _outer_style_item->set_active(false);
             prefs->setInt("/tools/text/outer_style", false);
             break;
 
         case 1: // Minimum
         case 2: // Even
-            gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(_outer_style_action), true );
+            _outer_style_item->set_active(true);
             prefs->setInt("/tools/text/outer_style", true);
             break;
 
@@ -1811,7 +1719,7 @@ TextToolbar::line_spacing_mode_changed(int mode)
     }
 
     // Outer style toggle set per mode so that line height widget should be enabled.
-    gtk_action_set_sensitive(GTK_ACTION(_line_height_action), true);
+    _line_height_item->set_sensitive(true);
 
     // Update "climb rate"
     Unit const *unit = _tracker->getActiveUnit();
@@ -2021,15 +1929,12 @@ TextToolbar::rotation_value_changed()
 
 // Unset line height on selection's inner text objects (tspan, etc.).
 void
-TextToolbar::lineheight_unset_changed(InkToggleAction*act, gpointer data)
+TextToolbar::lineheight_unset_changed()
 {
-    auto toolbar = reinterpret_cast<TextToolbar *>(data);
-
     // quit if run by the _changed callbacks
-    if (toolbar->_freeze) {
+    if (_freeze) {
         return;
     }
-    toolbar->_freeze = true;
 
     SPCSSAttr *css = sp_repr_css_attr_new();
     sp_repr_css_unset_property(css, "line-height");
@@ -2042,20 +1947,19 @@ TextToolbar::lineheight_unset_changed(InkToggleAction*act, gpointer data)
     DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_TEXT,
                        _("Text: Unset line height."));
 
-    toolbar->_freeze = false;
+    _freeze = false;
 }
 
 // Changes selection to only text outer elements.
 void
-TextToolbar::outer_style_changed( InkToggleAction *act, gpointer data )
+TextToolbar::outer_style_changed()
 {
-    auto toolbar = reinterpret_cast<TextToolbar *>(data);
-    bool outer = gtk_toggle_action_get_active( GTK_TOGGLE_ACTION(act) );
+    bool outer = _outer_style_item->get_active();
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     prefs->setInt("/tools/text/outer_style", outer);
 
     // Update widgets to reflect new state of Text Outer Style button.
-    toolbar->selection_changed(nullptr);
+    selection_changed(nullptr);
 }
 
 /*
@@ -2100,9 +2004,9 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele
     fontlister->selection_update();
 
     // Update font list, but only if widget already created.
-    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()  );
+    if( _font_family_item->get_combobox() != nullptr ) {
+        _font_family_item->set_active_text( fontlister->get_font_family().c_str(), fontlister->get_font_family_row() );
+        _font_style_item->set_active_text( fontlister->get_font_style().c_str() );
     }
 
     // Only flowed text can be justified, only normal text can be kerned...
@@ -2177,7 +2081,7 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele
 
         // 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( _font_family_action->combobox != nullptr ) {
+        if( _font_family_item->get_combobox() != nullptr ) {
             _text_style_from_prefs = true;
         }
     } else {
@@ -2199,13 +2103,13 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele
 
         // Freeze to ignore callbacks.
         //g_object_freeze_notify( G_OBJECT( fontSizeAction->combobox ) );
-        sp_text_set_sizes(GTK_LIST_STORE(ink_comboboxentry_action_get_model(_font_size_action)), unit);
+        sp_text_set_sizes(GTK_LIST_STORE(_font_size_item->get_model()), unit);
         //g_object_thaw_notify( G_OBJECT( fontSizeAction->combobox ) );
 
-        ink_comboboxentry_action_set_active_text( _font_size_action, os.str().c_str() );
+        _font_size_item->set_active_text( os.str().c_str() );
 
         Glib::ustring tooltip = Glib::ustring::format(_("Font size"), " (", sp_style_get_css_unit_string(unit), ")");
-        ink_comboboxentry_action_set_tooltip ( _font_size_action, tooltip.c_str());
+        _font_size_item->set_tooltip (tooltip.c_str());
 
         // Superscript
         gboolean superscriptSet =
@@ -2214,7 +2118,7 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele
              query.baseline_shift.type == SP_BASELINE_SHIFT_LITERAL &&
              query.baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUPER );
 
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(_superscript_action), superscriptSet );
+        _superscript_item->set_active(superscriptSet);
 
         // Subscript
         gboolean subscriptSet =
@@ -2223,7 +2127,7 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele
              query.baseline_shift.type == SP_BASELINE_SHIFT_LITERAL &&
              query.baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUB );
 
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(_subscript_action), subscriptSet );
+        _subscript_item->set_active(subscriptSet);
 
         // Alignment
 
@@ -2232,9 +2136,9 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele
         // 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 = _align_action->get_store();
+        Glib::RefPtr<Gtk::ListStore> store = _align_item->get_store();
         Gtk::TreeModel::Row row = *(store->get_iter("3"));  // Justify entry
-        InkSelectOneActionColumns columns;
+        UI::Widget::ComboToolItemColumns columns;
         row[columns.col_sensitive] = isFlow;
 
         int activeButton = 0;
@@ -2247,7 +2151,7 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele
             if (query.text_anchor.computed == SP_CSS_TEXT_ANCHOR_MIDDLE) activeButton = 1;
             if (query.text_anchor.computed == SP_CSS_TEXT_ANCHOR_END)    activeButton = 2;
         }
-        _align_action->set_active( activeButton );
+        _align_item->set_active( activeButton );
 
         // Line height (spacing) and line height unit
         double height;
@@ -2313,8 +2217,8 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele
         _lineheight_unit = line_height_unit;
 
         // Enable and turn on only if selection includes an object with 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_height_unset_item->set_sensitive(query.line_height.set);
+        _line_height_unset_item->set_active(query.line_height.set);
 
         // Line spacing mode: requires calculating mode for each <text> element and the <tspan>s within.
         Inkscape::Selection *selection = desktop->getSelection();
@@ -2368,23 +2272,23 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele
         //           << ", "<< mode[1]
         //           << ", "<< mode[2]
         //           << ", "<< mode[3] << std::endl;
-        _line_spacing_action->set_active( activeButtonLS );
+        _line_spacing_item->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 (GTK_ACTION(_line_height_action), false);
+            _line_height_item->set_sensitive(false);
         } else {
-            gtk_action_set_sensitive (GTK_ACTION(_line_height_action), true);
+            _line_height_item->set_sensitive(true);
         }
 
         // In Minimum and Adaptive modes, don't allow unit change (must remain unitless).
         if (activeButtonLS == 0 || (activeButtonLS == 1 && outer)) {
-            _line_height_units_action->set_sensitive(false);
+            _line_height_units_item->set_sensitive(false);
         } else {
-            _line_height_units_action->set_sensitive(true);
+            _line_height_units_item->set_sensitive(true);
         }
 
         // Word spacing
@@ -2408,7 +2312,7 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele
         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;
 
-        _writing_mode_action->set_active( activeButton2 );
+        _writing_mode_item->set_active( activeButton2 );
 
         // Orientation
         int activeButton3 = 0;
@@ -2416,16 +2320,16 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele
         if (query.text_orientation.computed == SP_CSS_TEXT_ORIENTATION_UPRIGHT ) activeButton3 = 1;
         if (query.text_orientation.computed == SP_CSS_TEXT_ORIENTATION_SIDEWAYS) activeButton3 = 2;
 
-        _orientation_action->set_active( activeButton3 );
+        _orientation_item->set_active( activeButton3 );
 
         // Disable text orientation for horizontal text...
-        _orientation_action->set_sensitive( activeButton2 != 0 );
+        _orientation_item->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;
-        _direction_action->set_active( activeButton4 );
+        _direction_item->set_active( activeButton4 );
     }
 
 #ifdef DEBUG_TEXT
@@ -2483,9 +2387,9 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele
 
     {
         // Set these here as we don't always have kerning/rotating attributes
-        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 );
+        _dx_item->set_sensitive(!isFlow);
+        _dy_item->set_sensitive(!isFlow);
+        _rotation_item->set_sensitive(!isFlow);
     }
 
 #ifdef DEBUG_TEXT
diff --git a/src/ui/toolbar/text-toolbar.h b/src/ui/toolbar/text-toolbar.h
index acc6f3268..00632b663 100644
--- a/src/ui/toolbar/text-toolbar.h
+++ b/src/ui/toolbar/text-toolbar.h
@@ -32,13 +32,12 @@
 
 #include <gtkmm/adjustment.h>
 
-class InkSelectOneAction;
 class SPDesktop;
 
-typedef struct _EgeAdjustmentAction EgeAdjustmentAction;
-typedef struct _GtkActionGroup GtkActionGroup;
-typedef struct _Ink_ComboBoxEntry_Action Ink_ComboBoxEntry_Action;
-typedef struct _InkToggleAction InkToggleAction;
+namespace Gtk {
+class ComboBoxText;
+class ToggleToolButton;
+}
 
 namespace Inkscape {
 class Selection;
@@ -49,6 +48,9 @@ class ToolBase;
 }
 
 namespace Widget {
+class ComboBoxEntryToolItem;
+class ComboToolItem;
+class SpinButtonToolItem;
 class UnitTracker;
 }
 
@@ -60,26 +62,26 @@ private:
 
     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;
+    UI::Widget::ComboBoxEntryToolItem *_font_family_item;
+    UI::Widget::ComboBoxEntryToolItem *_font_size_item;
+    UI::Widget::ComboBoxEntryToolItem *_font_style_item;
+    Gtk::ToggleToolButton *_superscript_item;
+    Gtk::ToggleToolButton *_subscript_item;
+    Gtk::ToggleToolButton *_outer_style_item;
+    Gtk::ToggleToolButton *_line_height_unset_item;
+    UI::Widget::ComboToolItem *_align_item;
+    UI::Widget::ComboToolItem *_writing_mode_item;
+    UI::Widget::ComboToolItem *_orientation_item;
+    UI::Widget::ComboToolItem *_direction_item;
+    UI::Widget::ComboToolItem *_line_height_units_item;
+    UI::Widget::ComboToolItem *_line_spacing_item;
+
+    UI::Widget::SpinButtonToolItem *_line_height_item;
+    UI::Widget::SpinButtonToolItem *_word_spacing_item;
+    UI::Widget::SpinButtonToolItem *_letter_spacing_item;
+    UI::Widget::SpinButtonToolItem *_dx_item;
+    UI::Widget::SpinButtonToolItem *_dy_item;
+    UI::Widget::SpinButtonToolItem *_rotation_item;
 
     Glib::RefPtr<Gtk::Adjustment> _line_height_adj;
     Glib::RefPtr<Gtk::Adjustment> _word_spacing_adj;
@@ -94,19 +96,12 @@ private:
     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 fontfamily_value_changed();
+    void fontsize_value_changed();
+    void fontstyle_value_changed();
+    void script_changed(Gtk::ToggleToolButton *btn);
+    void lineheight_unset_changed();
+    void outer_style_changed();
     void align_mode_changed(int mode);
     void writing_mode_changed(int mode);
     void orientation_changed(int mode);
@@ -124,12 +119,13 @@ private:
     void selection_modified(Inkscape::Selection *selection, guint flags);
     void subselection_changed(gpointer tc);
     void watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec);
+    void set_sizes(int unit);
 
 protected:
     TextToolbar(SPDesktop *desktop);
 
 public:
-    static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions);
+    static GtkWidget * create(SPDesktop *desktop);
 };
 
 }
diff --git a/src/ui/toolbar/tweak-toolbar.cpp b/src/ui/toolbar/tweak-toolbar.cpp
index 16c9b6009..dc5352ccf 100644
--- a/src/ui/toolbar/tweak-toolbar.cpp
+++ b/src/ui/toolbar/tweak-toolbar.cpp
@@ -243,6 +243,12 @@ TweakToolbar::TweakToolbar(SPDesktop *desktop)
     }
 }
 
+void
+TweakToolbar::set_mode(int mode)
+{
+    _mode_buttons[mode]->set_active();
+}
+
 GtkWidget *
 TweakToolbar::create(SPDesktop *desktop)
 {
diff --git a/src/ui/toolbar/tweak-toolbar.h b/src/ui/toolbar/tweak-toolbar.h
index 8995c64e2..cd1c7d048 100644
--- a/src/ui/toolbar/tweak-toolbar.h
+++ b/src/ui/toolbar/tweak-toolbar.h
@@ -79,6 +79,8 @@ protected:
 
 public:
     static GtkWidget * create(SPDesktop *desktop);
+
+    void set_mode(int mode);
 };
 }
 }
diff --git a/src/ui/tools/lpe-tool.cpp b/src/ui/tools/lpe-tool.cpp
index 55ec014ab..d1e7e186c 100644
--- a/src/ui/tools/lpe-tool.cpp
+++ b/src/ui/tools/lpe-tool.cpp
@@ -36,6 +36,7 @@
 
 #include "util/units.h"
 
+#include "ui/toolbar/lpe-toolbar.h"
 #include "ui/tools/lpe-tool.h"
 #include "ui/shape-editor.h"
 
@@ -309,7 +310,13 @@ lpetool_context_switch_mode(LpeTool *lc, Inkscape::LivePathEffect::EffectType co
     int index = lpetool_mode_to_index(type);
     if (index != -1) {
         lc->mode = type;
-        lc->desktop->setToolboxSelectOneValue ("lpetool_mode_action", index);
+        auto tb = dynamic_cast<UI::Toolbar::LPEToolbar*>(lc->desktop->get_toolbar_by_name("LPEToolToolbar"));
+
+        if(tb) {
+            tb->set_mode(index);
+        } else {
+            std::cerr << "Could not access LPE toolbar" << std::endl;
+        }
     } else {
         g_warning ("Invalid mode selected: %d", type);
         return;
diff --git a/src/ui/tools/spray-tool.cpp b/src/ui/tools/spray-tool.cpp
index 28990bd2d..5fed9e806 100644
--- a/src/ui/tools/spray-tool.cpp
+++ b/src/ui/tools/spray-tool.cpp
@@ -62,6 +62,7 @@
 #include "svg/svg.h"
 #include "svg/svg-color.h"
 
+#include "ui/toolbar/spray-toolbar.h"
 #include "ui/tools/spray-tool.h"
 #include "ui/dialog/dialog-manager.h"
 
@@ -1210,7 +1211,14 @@ static void sp_spray_update_area(SprayTool *tc)
 static void sp_spray_switch_mode(SprayTool *tc, gint mode, bool with_shift)
 {
     // Select the button mode
-    SP_EVENT_CONTEXT(tc)->desktop->setToolboxSelectOneValue("spray_tool_mode", mode); 
+    auto tb = dynamic_cast<UI::Toolbar::SprayToolbar*>(SP_EVENT_CONTEXT(tc)->desktop->get_toolbar_by_name("SprayToolbar"));
+
+    if(tb) {
+        tb->set_mode(mode);
+    } else {
+        std::cerr << "Could not access Spray toolbar" << std::endl;
+    }
+
     // Need to set explicitly, because the prefs may not have changed by the previous
     tc->mode = mode;
     tc->update_cursor(with_shift);
diff --git a/src/ui/tools/tweak-tool.cpp b/src/ui/tools/tweak-tool.cpp
index b8cf5549c..42e3520a0 100644
--- a/src/ui/tools/tweak-tool.cpp
+++ b/src/ui/tools/tweak-tool.cpp
@@ -74,6 +74,8 @@
 
 #include "svg/svg.h"
 
+#include "ui/toolbar/tweak-toolbar.h"
+
 #include "ui/tools/tweak-tool.h"
 
 using Inkscape::DocumentUndo;
@@ -1121,7 +1123,14 @@ sp_tweak_update_area (TweakTool *tc)
 static void
 sp_tweak_switch_mode (TweakTool *tc, gint mode, bool with_shift)
 {
-    SP_EVENT_CONTEXT(tc)->desktop->setToolboxSelectOneValue ("tweak_tool_mode", mode);
+    auto tb = dynamic_cast<UI::Toolbar::TweakToolbar*>(SP_EVENT_CONTEXT(tc)->desktop->get_toolbar_by_name("TweakToolbar"));
+
+    if(tb) {
+        tb->set_mode(mode);
+    } else {
+        std::cerr << "Could not access Tweak toolbar" << std::endl;
+    }
+
     // need to set explicitly, because the prefs may not have changed by the previous
     tc->mode = mode;
     tc->update_cursor(with_shift);
@@ -1133,7 +1142,15 @@ sp_tweak_switch_mode_temporarily (TweakTool *tc, gint mode, bool with_shift)
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
    // Juggling about so that prefs have the old value but tc->mode and the button show new mode:
    gint now_mode = prefs->getInt("/tools/tweak/mode", 0);
-   SP_EVENT_CONTEXT(tc)->desktop->setToolboxSelectOneValue ("tweak_tool_mode", mode);
+
+   auto tb = dynamic_cast<UI::Toolbar::TweakToolbar*>(SP_EVENT_CONTEXT(tc)->desktop->get_toolbar_by_name("TweakToolbar"));
+
+   if(tb) {
+       tb->set_mode(mode);
+   } else {
+       std::cerr << "Could not access Tweak toolbar" << std::endl;
+   }
+
    // button has changed prefs, restore
    prefs->setInt("/tools/tweak/mode", now_mode);
    // changing prefs changed tc->mode, restore back :)
diff --git a/src/ui/view/edit-widget-interface.h b/src/ui/view/edit-widget-interface.h
index 1bbbbc8bd..eb3e33bb5 100644
--- a/src/ui/view/edit-widget-interface.h
+++ b/src/ui/view/edit-widget-interface.h
@@ -17,7 +17,8 @@
 #include <2geom/point.h>
 
 namespace Gtk {
-class Window;
+    class Toolbar;
+    class Window;
 }
 
 namespace Glib {
@@ -132,15 +133,14 @@ struct EditWidgetInterface
     /// Temporarily block signals and update rotation display
     virtual void updateRotation() = 0;
 
+    virtual Gtk::Toolbar* get_toolbar_by_name(const Glib::ustring&) = 0;
+
     /// In auxiliary toolbox, set focus to widget having specific id
     virtual void setToolboxFocusTo (const gchar *) = 0;
 
     /// In auxiliary toolbox, set value of adjustment with specific id
     virtual void setToolboxAdjustmentValue (const gchar *, double) = 0;
 
-    /// In auxiliary toolbox, select one of the "select one" options (usually radio toggles)
-    virtual void setToolboxSelectOneValue (const gchar *, gint) = 0;
-
     /// In auxiliary toolbox, return true if specific togglebutton is active
     virtual bool isToolboxButtonActive (gchar const*) = 0;
 
diff --git a/src/ui/widget/combo-box-entry-tool-item.cpp b/src/ui/widget/combo-box-entry-tool-item.cpp
new file mode 100644
index 000000000..2c3a37693
--- /dev/null
+++ b/src/ui/widget/combo-box-entry-tool-item.cpp
@@ -0,0 +1,684 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * A subclass of GtkAction that wraps a GtkComboBoxEntry.
+ * Features:
+ *   Setting GtkEntryBox width in characters.
+ *   Passing a function for formatting cells.
+ *   Displaying a warning if entry text isn't in list.
+ *   Check comma separated values in text against list. (Useful for font-family fallbacks.)
+ *   Setting names for GtkComboBoxEntry and GtkEntry (actionName_combobox, actionName_entry)
+ *     to allow setting resources.
+ *
+ * Author(s):
+ *   Tavmjong Bah
+ *   Jon A. Cruz <jon@joncruz.org>
+ *
+ * Copyright (C) 2010 Authors
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+/*
+ * We must provide for both a toolbar item and a menu item.
+ * As we don't know which widgets are used (or even constructed),
+ * we must keep track of things like active entry ourselves.
+ */
+
+#include "combo-box-entry-tool-item.h"
+
+#include <iostream>
+#include <cstring>
+#include <glibmm/ustring.h>
+
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+#include <gdkmm/display.h>
+
+#include "ui/icon-names.h"
+
+static GQuark gDataName = 0;
+
+  //gDataName = g_quark_from_string("ink_comboboxentry-action");
+
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+
+ComboBoxEntryToolItem::ComboBoxEntryToolItem(Glib::ustring name,
+                                     Glib::ustring label,
+                                     Glib::ustring tooltip,
+                                     GtkTreeModel  *model,
+                                     gint           entry_width,
+                                     gint           extra_width,
+                                     void          *cell_data_func,
+                                     void          *separator_func,
+                                     GtkWidget     *focusWidget)
+    : _label(std::move(label)),
+      _tooltip(std::move(tooltip)),
+      _model(model),
+      _entry_width(entry_width),
+      _extra_width(extra_width),
+      _cell_data_func(cell_data_func),
+      _separator_func(separator_func),
+      _focusWidget(focusWidget),
+      _active(-1),
+      _text(strdup("")),
+      _entry_completion(nullptr),
+      _indicator(nullptr),
+      _popup(false),
+      _info(nullptr),
+      _info_cb(nullptr),
+      _info_cb_id(0),
+      _info_cb_blocked(false),
+      _warning(nullptr),
+      _warning_cb(nullptr),
+      _warning_cb_id(0),
+      _warning_cb_blocked(false),
+      _altx_name(nullptr)
+{
+    set_name(name);
+
+    gchar *action_name = g_strdup( get_name().c_str() );
+    gchar *combobox_name = g_strjoin( nullptr, action_name, "_combobox", NULL );
+    gchar *entry_name =    g_strjoin( nullptr, action_name, "_entry", NULL );
+    g_free( action_name );
+
+    GtkWidget* comboBoxEntry = gtk_combo_box_new_with_model_and_entry (_model);
+    gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (comboBoxEntry), 0);
+
+    // Name it so we can muck with it using an RC file
+    gtk_widget_set_name( comboBoxEntry, combobox_name );
+    g_free( combobox_name );
+
+    {
+        gtk_widget_set_halign(comboBoxEntry, GTK_ALIGN_START);
+        gtk_widget_set_hexpand(comboBoxEntry, FALSE);
+        gtk_widget_set_vexpand(comboBoxEntry, FALSE);
+        add(*Glib::wrap(comboBoxEntry));
+    }
+
+    _combobox = GTK_COMBO_BOX (comboBoxEntry);
+
+    //gtk_combo_box_set_active( GTK_COMBO_BOX( comboBoxEntry ), ink_comboboxentry_action->active );
+    gtk_combo_box_set_active( GTK_COMBO_BOX( comboBoxEntry ), 0 );
+
+    g_signal_connect( G_OBJECT(comboBoxEntry), "changed", G_CALLBACK(combo_box_changed_cb), this );
+
+    // Optionally add separator function...
+    if( _separator_func != nullptr ) {
+        gtk_combo_box_set_row_separator_func( _combobox,
+                GtkTreeViewRowSeparatorFunc (_separator_func),
+                nullptr, nullptr );
+    }
+
+    // FIXME: once gtk3 migration is done this can be removed
+    // https://bugzilla.gnome.org/show_bug.cgi?id=734915
+    gtk_widget_show_all (comboBoxEntry);
+
+    // Optionally add formatting...
+    if( _cell_data_func != nullptr ) {
+        GtkCellRenderer *cell = gtk_cell_renderer_text_new();
+        gtk_cell_layout_clear( GTK_CELL_LAYOUT( comboBoxEntry ) );
+        gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( comboBoxEntry ), cell, true );
+        gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT( comboBoxEntry ), cell,
+                GtkCellLayoutDataFunc (_cell_data_func),
+                nullptr, nullptr );
+    }
+
+    // Optionally widen the combobox width... which widens the drop-down list in list mode.
+    if( _extra_width > 0 ) {
+        GtkRequisition req;
+        gtk_widget_get_preferred_size(GTK_WIDGET(_combobox), &req, nullptr);
+        gtk_widget_set_size_request( GTK_WIDGET( _combobox ),
+                req.width + _extra_width, -1 );
+    }
+
+    // Get reference to GtkEntry and fiddle a bit with it.
+    GtkWidget *child = gtk_bin_get_child( GTK_BIN(comboBoxEntry) );
+
+    // Name it so we can muck with it using an RC file
+    gtk_widget_set_name( child, entry_name );
+    g_free( entry_name );
+
+    if( child && GTK_IS_ENTRY( child ) ) {
+
+        _entry = GTK_ENTRY(child);
+
+        // Change width
+        if( _entry_width > 0 ) {
+            gtk_entry_set_width_chars (GTK_ENTRY (child), _entry_width );
+        }
+
+        // Add pop-up entry completion if required
+        if( _popup ) {
+            popup_enable();
+        }
+
+        // Add altx_name if required
+        if( _altx_name ) {
+            g_object_set_data( G_OBJECT( child ), _altx_name, _entry );
+        }
+
+        // Add signal for GtkEntry to check if finished typing.
+        g_signal_connect( G_OBJECT(child), "activate", G_CALLBACK(entry_activate_cb), this );
+        g_signal_connect( G_OBJECT(child), "key-press-event", G_CALLBACK(keypress_cb), this );
+    }
+
+    set_tooltip(tooltip.c_str());
+
+    show_all();
+}
+
+// Setters/Getters ---------------------------------------------------
+
+gchar*
+ComboBoxEntryToolItem::get_active_text()
+{
+  gchar* text = g_strdup( _text );
+  return text;
+}
+
+/*
+ * For the font-family list we need to handle two cases:
+ *   Text is in list store:
+ *     In this case we use row number as the font-family list can have duplicate
+ *     entries, one in the document font part and one in the system font part. In
+ *     order that scrolling through the list works properly we must distinguish
+ *     between the two.
+ *   Text is not in the list store (i.e. default font-family is not on system):
+ *     In this case we have a row number of -1, and the text must be set by hand.
+ */
+gboolean
+ComboBoxEntryToolItem::set_active_text(const gchar* text, int row)
+{
+  if( strcmp( _text, text ) != 0 ) { 
+    g_free( _text );
+    _text = g_strdup( text );
+  }
+
+  // Get active row or -1 if none
+  if( row < 0 ) {
+    row = get_active_row_from_text(this, _text);
+  }
+  _active = row;
+
+  // Set active row, check that combobox has been created.
+  if( _combobox ) {
+    gtk_combo_box_set_active( GTK_COMBO_BOX( _combobox ), _active );
+  }
+
+  // Fiddle with entry
+  if( _entry ) {
+
+    // Explicitly set text in GtkEntry box (won't be set if text not in list).
+    gtk_entry_set_text( _entry, text );
+
+    // Show or hide warning  -- this might be better moved to text-toolbox.cpp
+    if( _info_cb_id != 0 &&
+	!_info_cb_blocked ) {
+      g_signal_handler_block (G_OBJECT(_entry),
+			      _info_cb_id );
+      _info_cb_blocked = true;
+    }
+    if( _warning_cb_id != 0 &&
+	!_warning_cb_blocked ) {
+      g_signal_handler_block (G_OBJECT(_entry),
+			      _warning_cb_id );
+      _warning_cb_blocked = true;
+    }
+
+    bool set = false;
+    if( _warning != nullptr ) {
+      Glib::ustring missing = check_comma_separated_text();
+      if( !missing.empty() ) {
+	  gtk_entry_set_icon_from_icon_name( _entry,
+					     GTK_ENTRY_ICON_SECONDARY,
+					     INKSCAPE_ICON("dialog-warning") );
+	// Can't add tooltip until icon set
+	Glib::ustring warning = _warning;
+	warning += ": ";
+	warning += missing;
+	gtk_entry_set_icon_tooltip_text( _entry,
+					 GTK_ENTRY_ICON_SECONDARY,
+					 warning.c_str() );
+
+	if( _warning_cb ) {
+
+	  // Add callback if we haven't already
+	  if( _warning_cb_id == 0 ) {
+	    _warning_cb_id =
+	      g_signal_connect( G_OBJECT(_entry),
+				"icon-press",
+				G_CALLBACK(_warning_cb),
+				this);
+	  }
+	  // Unblock signal
+	  if( _warning_cb_blocked ) {
+	    g_signal_handler_unblock (G_OBJECT(_entry),
+				      _warning_cb_id );
+	    _warning_cb_blocked = false;
+	  }
+	}
+	set = true;
+      }
+    }
+ 
+    if( !set && _info != nullptr ) {
+      gtk_entry_set_icon_from_icon_name( GTK_ENTRY(_entry),
+					 GTK_ENTRY_ICON_SECONDARY,
+					 INKSCAPE_ICON("edit-select-all") );
+      gtk_entry_set_icon_tooltip_text( _entry,
+				       GTK_ENTRY_ICON_SECONDARY,
+				       _info );
+
+      if( _info_cb ) {
+	// Add callback if we haven't already
+	if( _info_cb_id == 0 ) {
+	  _info_cb_id =
+	    g_signal_connect( G_OBJECT(_entry),
+			      "icon-press",
+			      G_CALLBACK(_info_cb),
+			      this);
+	}
+	// Unblock signal
+	if( _info_cb_blocked ) {
+	  g_signal_handler_unblock (G_OBJECT(_entry),
+				    _info_cb_id );
+	  _info_cb_blocked = false;
+	}
+      }
+      set = true;
+    }
+
+    if( !set ) {
+      gtk_entry_set_icon_from_icon_name( GTK_ENTRY(_entry),
+					 GTK_ENTRY_ICON_SECONDARY,
+					 nullptr );
+    }
+  }
+
+  // Return if active text in list
+  gboolean found = ( _active != -1 );
+  return found;
+}
+
+void
+ComboBoxEntryToolItem::set_entry_width(gint entry_width)
+{
+    _entry_width = entry_width;
+
+    // Clamp to limits
+    if(entry_width < -1)  entry_width = -1;
+    if(entry_width > 100) entry_width = 100;
+
+    // Widget may not have been created....
+    if( _entry ) {
+        gtk_entry_set_width_chars( GTK_ENTRY(_entry), entry_width );
+    }
+}
+
+void
+ComboBoxEntryToolItem::set_extra_width( gint extra_width )
+{
+    _extra_width = extra_width;
+
+    // Clamp to limits
+    if(extra_width < -1)  extra_width = -1;
+    if(extra_width > 500) extra_width = 500;
+
+    // Widget may not have been created....
+    if( _combobox ) {
+        GtkRequisition req;
+        gtk_widget_get_preferred_size(GTK_WIDGET(_combobox), &req, nullptr);
+        gtk_widget_set_size_request( GTK_WIDGET( _combobox ), req.width + _extra_width, -1 );
+    }
+}
+
+void
+ComboBoxEntryToolItem::popup_enable()
+{
+    _popup = true;
+
+    // Widget may not have been created....
+    if( _entry ) {
+
+        // Check we don't already have a GtkEntryCompletion
+        if( _entry_completion ) return;
+
+        _entry_completion = gtk_entry_completion_new();
+
+        gtk_entry_set_completion( _entry, _entry_completion );
+        gtk_entry_completion_set_model( _entry_completion, _model );
+        gtk_entry_completion_set_text_column( _entry_completion, 0 );
+        gtk_entry_completion_set_popup_completion( _entry_completion, true );
+        gtk_entry_completion_set_inline_completion( _entry_completion, false );
+        gtk_entry_completion_set_inline_selection( _entry_completion, true );
+
+        g_signal_connect (G_OBJECT (_entry_completion),  "match-selected", G_CALLBACK (match_selected_cb), this);
+    }
+}
+
+void
+ComboBoxEntryToolItem::popup_disable()
+{
+  _popup = false;
+
+  if( _entry_completion ) {
+    gtk_widget_destroy(GTK_WIDGET(_entry_completion));
+    _entry_completion = nullptr;
+  }
+}
+
+void
+ComboBoxEntryToolItem::set_tooltip(const gchar* tooltip)
+{
+    set_tooltip_text(tooltip);
+    gtk_widget_set_tooltip_text ( GTK_WIDGET(_combobox), tooltip);
+
+    // Widget may not have been created....
+    if( _entry ) {
+        gtk_widget_set_tooltip_text ( GTK_WIDGET(_entry), tooltip);
+    }
+}
+
+void
+ComboBoxEntryToolItem::set_info(const gchar* info)
+{
+    g_free( _info );
+    _info = g_strdup( info );
+
+    // Widget may not have been created....
+    if( _entry ) {
+        gtk_entry_set_icon_tooltip_text( GTK_ENTRY(_entry),
+                                         GTK_ENTRY_ICON_SECONDARY,
+                                         _info );
+    }
+}
+
+void
+ComboBoxEntryToolItem::set_info_cb(gpointer info_cb)
+{
+    _info_cb = info_cb;
+}
+
+void
+ComboBoxEntryToolItem::set_warning(const gchar* warning)
+{
+  g_free( _warning );
+  _warning = g_strdup( warning );
+
+  // Widget may not have been created....
+  if( _entry ) {
+    gtk_entry_set_icon_tooltip_text( GTK_ENTRY(_entry),
+                                     GTK_ENTRY_ICON_SECONDARY,
+                                     _warning );
+  }
+}
+
+void
+ComboBoxEntryToolItem::set_warning_cb(gpointer warning_cb)
+{
+    _warning_cb = warning_cb;
+}
+
+void
+ComboBoxEntryToolItem::set_altx_name(const gchar* altx_name)
+{
+    g_free(_altx_name);
+    _altx_name = g_strdup( altx_name );
+
+    // Widget may not have been created....
+    if(_entry) {
+        g_object_set_data( G_OBJECT(_entry), _altx_name, _entry );
+    }
+}
+
+// Internal ---------------------------------------------------
+
+// Return row of active text or -1 if not found. If exclude is true,
+// use 3d colunm if available to exclude row from checking (useful to
+// skip rows added for font-families included in doc and not on
+// system)
+gint
+ComboBoxEntryToolItem::get_active_row_from_text(ComboBoxEntryToolItem *action,
+                                              const gchar         *target_text,
+			                      gboolean             exclude,
+                                              gboolean             ignore_case )
+{
+  // Check if text in list
+  gint row = 0;
+  gboolean found = false;
+  GtkTreeIter iter;
+  gboolean valid = gtk_tree_model_get_iter_first( action->_model, &iter );
+  while ( valid ) {
+
+    // See if we should exclude a row
+    gboolean check = true;  // If true, font-family is on system.
+    if( exclude && gtk_tree_model_get_n_columns( action->_model ) > 2 ) {
+      gtk_tree_model_get( action->_model, &iter, 2, &check, -1 );
+    }
+
+    if( check ) {
+      // Get text from list entry
+      gchar* text = nullptr;
+      gtk_tree_model_get( action->_model, &iter, 0, &text, -1 ); // Column 0
+
+      if( !ignore_case ) {
+	// Case sensitive compare
+	if( strcmp( target_text, text ) == 0 ){
+	  found = true;
+	  break;
+	}
+      } else {
+	// Case insensitive compare
+	gchar* target_text_casefolded = g_utf8_casefold( target_text, -1 );
+	gchar* text_casefolded        = g_utf8_casefold( text, -1 );
+	gboolean equal = (strcmp( target_text_casefolded, text_casefolded ) == 0 );
+	g_free( text_casefolded );
+	g_free( target_text_casefolded );
+	if( equal ) {
+	  found = true;
+	  break;
+	}
+      }
+    }
+
+    ++row;
+    valid = gtk_tree_model_iter_next( action->_model, &iter );
+  }
+
+  if( !found ) row = -1;
+
+  return row;
+}
+
+// Checks if all comma separated text fragments are in the list and
+// returns a ustring with a list of missing fragments.
+// This is useful for checking if all fonts in a font-family fallback
+// list are available on the system.
+//
+// This routine could also create a Pango Markup string to show which
+// fragments are invalid in the entry box itself. See:
+// http://developer.gnome.org/pango/stable/PangoMarkupFormat.html
+// However... it appears that while one can retrieve the PangoLayout
+// for a GtkEntry box, it is only a copy and changing it has no effect.
+//   PangoLayout * pl = gtk_entry_get_layout( entry );
+//   pango_layout_set_markup( pl, "NEW STRING", -1 ); // DOESN'T WORK
+Glib::ustring
+ComboBoxEntryToolItem::check_comma_separated_text()
+{
+  Glib::ustring missing;
+
+  // Parse fallback_list using a comma as deliminator
+  gchar** tokens = g_strsplit( _text, ",", 0 );
+
+  gint i = 0;
+  while( tokens[i] != nullptr ) {
+
+    // Remove any surrounding white space.
+    g_strstrip( tokens[i] );
+
+    if( get_active_row_from_text( this, tokens[i], true, true ) == -1 ) {
+      missing += tokens[i];
+      missing += ", ";
+    }
+    ++i;
+  }
+  g_strfreev( tokens );
+
+  // Remove extra comma and space from end.
+  if( missing.size() >= 2 ) {
+    missing.resize( missing.size()-2 );
+  }
+  return missing;
+}
+
+// Callbacks ---------------------------------------------------
+
+void
+ComboBoxEntryToolItem::combo_box_changed_cb( GtkComboBox* widget, gpointer data )
+{
+  // Two things can happen to get here:
+  //   An item is selected in the drop-down menu.
+  //   Text is typed.
+  // We only react here if an item is selected.
+
+  // Get action
+  auto action = reinterpret_cast<ComboBoxEntryToolItem *>( data );
+
+  // Check if item selected:
+  gint newActive = gtk_combo_box_get_active(widget);
+  if( newActive >= 0 && newActive != action->_active ) {
+
+    action->_active = newActive;
+
+    GtkTreeIter iter;
+    if( gtk_combo_box_get_active_iter( GTK_COMBO_BOX( action->_combobox ), &iter ) ) {
+
+      gchar* text = nullptr;
+      gtk_tree_model_get( action->_model, &iter, 0, &text, -1 );
+      gtk_entry_set_text( action->_entry, text );
+
+      g_free( action->_text );
+      action->_text = text;
+    }
+
+    // Now let the world know
+    action->_signal_changed.emit();
+  }
+}
+
+void
+ComboBoxEntryToolItem::entry_activate_cb( GtkEntry *widget,
+                                        gpointer  data )
+{
+  // Get text from entry box.. check if it matches a menu entry.
+
+  // Get action
+  auto action = reinterpret_cast<ComboBoxEntryToolItem*>( data );
+
+  // Get text
+  g_free( action->_text );
+  action->_text = g_strdup( gtk_entry_get_text( widget ) );
+
+  // Get row
+  action->_active =
+    get_active_row_from_text( action, action->_text );
+
+  // Set active row
+  gtk_combo_box_set_active( GTK_COMBO_BOX( action->_combobox), action->_active );
+
+  // Now let the world know
+  action->_signal_changed.emit();
+}
+
+gboolean
+ComboBoxEntryToolItem::match_selected_cb( GtkEntryCompletion* /*widget*/, GtkTreeModel* model, GtkTreeIter* iter, gpointer data )
+{
+  // Get action
+  auto action = reinterpret_cast<ComboBoxEntryToolItem*>(data);
+  GtkEntry *entry = action->_entry;
+
+  if( entry) {
+    gchar *family = nullptr;
+    gtk_tree_model_get(model, iter, 0, &family, -1);
+
+    // Set text in GtkEntry
+    gtk_entry_set_text (GTK_ENTRY (entry), family );
+
+    // Set text in GtkAction
+    g_free( action->_text );
+    action->_text = family;
+
+    // Get row
+    action->_active =
+      get_active_row_from_text( action, action->_text );
+
+    // Set active row
+    gtk_combo_box_set_active( GTK_COMBO_BOX( action->_combobox), action->_active );
+
+    // Now let the world know
+    action->_signal_changed.emit();
+
+    return true;
+  }
+  return false;
+}
+
+void
+ComboBoxEntryToolItem::defocus()
+{
+    if ( _focusWidget ) {
+        gtk_widget_grab_focus( _focusWidget );
+    }
+}
+
+gboolean
+ComboBoxEntryToolItem::keypress_cb( GtkWidget * /*widget*/, GdkEventKey *event, gpointer data )
+{
+    gboolean wasConsumed = FALSE; /* default to report event not consumed */
+    guint key = 0;
+    auto action = reinterpret_cast<ComboBoxEntryToolItem*>(data);
+    gdk_keymap_translate_keyboard_state( Gdk::Display::get_default()->get_keymap(),
+                                         event->hardware_keycode, (GdkModifierType)event->state,
+                                         0, &key, nullptr, nullptr, nullptr );
+
+    switch ( key ) {
+
+        // TODO Add bindings for Tab/LeftTab
+        case GDK_KEY_Escape:
+        {
+            //gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), action->private_data->lastVal );
+            action->defocus();
+            wasConsumed = TRUE;
+        }
+        break;
+
+        case GDK_KEY_Return:
+        case GDK_KEY_KP_Enter:
+        {
+            action->defocus();
+            //wasConsumed = TRUE;
+        }
+        break;
+
+
+    }
+
+    return wasConsumed;
+}
+
+}
+}
+}
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/ui/widget/combo-box-entry-tool-item.h b/src/ui/widget/combo-box-entry-tool-item.h
new file mode 100644
index 000000000..70c8e94e7
--- /dev/null
+++ b/src/ui/widget/combo-box-entry-tool-item.h
@@ -0,0 +1,155 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * A subclass of GtkAction that wraps a GtkComboBoxEntry.
+ * Features:
+ *   Setting GtkEntryBox width in characters.
+ *   Passing a function for formatting cells.
+ *   Displaying a warning if text isn't in list.
+ *   Setting names for GtkComboBoxEntry and GtkEntry (actionName_combobox, actionName_entry)
+ *     to allow setting resources.
+ *
+ * Author(s):
+ *   Tavmjong Bah
+ *   Jon A. Cruz <jon@joncruz.org>
+ *
+ * Copyright (C) 2010 Authors
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifndef SEEN_INK_COMBOBOXENTRY_ACTION
+#define SEEN_INK_COMBOBOXENTRY_ACTION
+
+#include <gtkmm/toolitem.h>
+
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+
+/**
+ * Creates a Gtk::ToolItem subclass that wraps a Gtk::ComboBox object.
+ */
+class ComboBoxEntryToolItem : public Gtk::ToolItem {
+private:
+    Glib::ustring       _tooltip;
+    Glib::ustring       _label;
+    GtkTreeModel       *_model; ///< Tree Model
+    GtkComboBox        *_combobox;
+    GtkEntry           *_entry;
+    gint                _entry_width;// Width of GtkEntry in characters.
+    gint                _extra_width;// Extra Width of GtkComboBox.. to widen drop-down list in list mode.
+    gpointer            _cell_data_func; // drop-down menu format
+    gpointer            _separator_func;
+    gboolean            _popup;      // Do we pop-up an entry-completion dialog?
+    GtkEntryCompletion *_entry_completion;
+    GtkWidget          *_focusWidget; ///< The widget to return focus to
+
+    GtkWidget          *_indicator;
+    gint                _active;     // Index of active menu item (-1 if not in list).
+    gchar              *_text;       // Text of active menu item or entry box.
+    gchar              *_info;       // Text for tooltip info about entry.
+    gpointer            _info_cb;    // Callback for clicking info icon.
+    gint                _info_cb_id;
+    gboolean            _info_cb_blocked;
+    gchar              *_warning;    // Text for tooltip warning that entry isn't in list.
+    gpointer            _warning_cb; // Callback for clicking warning icon.
+    gint                _warning_cb_id;
+    gboolean            _warning_cb_blocked;
+    gchar              *_altx_name;  // Target for Alt-X keyboard shortcut.
+
+    // Signals
+    sigc::signal<void> _signal_changed;
+
+    void (*changed)   (ComboBoxEntryToolItem* action);
+    void (*activated) (ComboBoxEntryToolItem* action);
+
+    static gint get_active_row_from_text(ComboBoxEntryToolItem *action,
+                                         const gchar         *target_text,
+	                                 gboolean             exclude     = false,
+                                         gboolean             ignore_case = false);
+    void defocus();
+
+    static void combo_box_changed_cb( GtkComboBox* widget, gpointer data );
+    static void entry_activate_cb( GtkEntry *widget,
+                                   gpointer  data );
+    static gboolean match_selected_cb( GtkEntryCompletion *widget,
+                                       GtkTreeModel       *model,
+                                       GtkTreeIter        *iter,
+                                       gpointer            data);
+    static gboolean keypress_cb( GtkWidget   *widget,
+                                 GdkEventKey *event,
+                                 gpointer     data );
+
+    Glib::ustring check_comma_separated_text();
+ 
+public:
+    ComboBoxEntryToolItem(const Glib::ustring name,
+                          const Glib::ustring label,
+                          const Glib::ustring tooltip,
+                          GtkTreeModel *model,
+                          gint          entry_width    = -1,
+                          gint          extra_width    = -1,
+                          gpointer      cell_data_func = nullptr,
+                          gpointer      separator_func = nullptr,
+                          GtkWidget*    focusWidget    = nullptr);
+
+    gchar*   get_active_text();
+    gboolean set_active_text(const gchar* text, int row=-1);
+
+    void     set_entry_width(gint entry_width);
+    void     set_extra_width(gint extra_width);
+
+    void     popup_enable();
+    void     popup_disable();
+
+    void     set_info(      const gchar* info );
+    void     set_info_cb(   gpointer info_cb );
+    void     set_warning(   const gchar* warning_cb );
+    void     set_warning_cb(gpointer warning );
+    void     set_tooltip(   const gchar* tooltip );
+
+    void     set_altx_name( const gchar* altx_name );
+
+    // Accessor methods
+    decltype(_model)          get_model()          const {return _model;}
+    decltype(_combobox)       get_combobox()       const {return _combobox;}
+    decltype(_entry)          get_entry()          const {return _entry;}
+    decltype(_entry_width)    get_entry_width()    const {return _entry_width;}
+    decltype(_extra_width)    get_extra_width()    const {return _extra_width;}
+    decltype(_cell_data_func) get_cell_data_func() const {return _cell_data_func;}
+    decltype(_separator_func) get_separator_func() const {return _separator_func;}
+    decltype(_popup)          get_popup()          const {return _popup;}
+    decltype(_focusWidget)    get_focus_widget()   const {return _focusWidget;}
+
+    decltype(_active)         get_active()         const {return _active;}
+
+    decltype(_signal_changed) signal_changed() {return _signal_changed;}
+
+    // Mutator methods
+    void set_model         (decltype(_model)          model)          {_model          = model;}
+    void set_combobox      (decltype(_combobox)       combobox)       {_combobox       = combobox;}
+    void set_entry         (decltype(_entry)          entry)          {_entry          = entry;}
+    void set_cell_data_func(decltype(_cell_data_func) cell_data_func) {_cell_data_func = cell_data_func;}
+    void set_separator_func(decltype(_separator_func) separator_func) {_separator_func = separator_func;}
+    void set_popup         (decltype(_popup)          popup)          {_popup          = popup;}
+    void set_focus_widget  (decltype(_focusWidget)    focus_widget)   {_focusWidget    = focus_widget;}
+
+    // This doesn't seem right... surely we should set the active row in the Combobox too?
+    void set_active        (decltype(_active)         active)         {_active         = active;}
+};
+
+}
+}
+}
+#endif /* SEEN_INK_COMBOBOXENTRY_ACTION */
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/ui/widget/combo-tool-item.cpp b/src/ui/widget/combo-tool-item.cpp
index a6c44f7eb..b8638ba72 100644
--- a/src/ui/widget/combo-tool-item.cpp
+++ b/src/ui/widget/combo-tool-item.cpp
@@ -34,15 +34,17 @@ ComboToolItem*
 ComboToolItem::create(const Glib::ustring &group_label,
                       const Glib::ustring &tooltip,
                       const Glib::ustring &stock_id,
-                      Glib::RefPtr<Gtk::ListStore> store )
+                      Glib::RefPtr<Gtk::ListStore> store,
+                      bool                 has_entry)
 {
-    return new ComboToolItem(group_label, tooltip, stock_id, store);
+    return new ComboToolItem(group_label, tooltip, stock_id, store, has_entry);
 }
 
 ComboToolItem::ComboToolItem(Glib::ustring group_label,
                              Glib::ustring tooltip,
                              Glib::ustring stock_id,
-                             Glib::RefPtr<Gtk::ListStore> store ) :
+                             Glib::RefPtr<Gtk::ListStore> store,
+                             bool          has_entry) :
     _group_label(std::move( group_label )),
     _tooltip(std::move( tooltip )),
     _stock_id(std::move( stock_id )),
@@ -63,9 +65,45 @@ ComboToolItem::ComboToolItem(Glib::ustring group_label,
     }
 
     // Create combobox
-    _combobox = Gtk::manage (new Gtk::ComboBox());
+    _combobox = Gtk::manage (new Gtk::ComboBox(has_entry));
     _combobox->set_model(_store);
 
+    populate_combobox();
+
+    _combobox->signal_changed().connect(
+            sigc::mem_fun(*this, &ComboToolItem::on_changed_combobox));
+
+    box->add (*_combobox);
+
+    show_all();
+}
+
+void
+ComboToolItem::use_label(bool use_label)
+{
+    _use_label = use_label;
+    populate_combobox();
+}
+
+void
+ComboToolItem::use_icon(bool use_icon)
+{
+    _use_icon = use_icon;
+    populate_combobox();
+}
+
+void
+ComboToolItem::use_pixbuf(bool use_pixbuf)
+{
+    _use_pixbuf = use_pixbuf;
+    populate_combobox();
+}
+
+void
+ComboToolItem::populate_combobox()
+{
+    _combobox->clear();
+
     ComboToolItemColumns columns;
     if (_use_icon) {
         Gtk::CellRendererPixbuf *renderer = new Gtk::CellRendererPixbuf;
@@ -89,13 +127,6 @@ ComboToolItem::ComboToolItem(Glib::ustring group_label,
     }
 
     _combobox->set_active (_active);
-
-    _combobox->signal_changed().connect(
-            sigc::mem_fun(*this, &ComboToolItem::on_changed_combobox));
-
-    box->add (*_combobox);
-
-    show_all();
 }
 
 void
diff --git a/src/ui/widget/combo-tool-item.h b/src/ui/widget/combo-tool-item.h
index 1e4590163..d2ca874f0 100644
--- a/src/ui/widget/combo-tool-item.h
+++ b/src/ui/widget/combo-tool-item.h
@@ -54,12 +54,13 @@ public:
     static ComboToolItem* create(const Glib::ustring &label,
                                  const Glib::ustring &tooltip,
                                  const Glib::ustring &stock_id,
-                                 Glib::RefPtr<Gtk::ListStore> store );
+                                 Glib::RefPtr<Gtk::ListStore> store,
+                                 bool                 has_entry = false);
 
-    /* Style of action */
-    void use_label(  bool use_label  ) { _use_label  = use_label;  }
-    void use_icon(   bool use_icon   ) { _use_icon   = use_icon;   }
-    void use_pixbuf( bool use_pixbuf ) { _use_pixbuf = use_pixbuf; }
+    /* Style of combobox */
+    void use_label(  bool use_label  );
+    void use_icon(   bool use_icon   );
+    void use_pixbuf( bool use_pixbuf );
     void use_group_label( bool use_group_label ) { _use_group_label = use_group_label; }
   
     gint get_active() { return _active; }
@@ -74,6 +75,7 @@ public:
 
 protected:
     bool on_create_menu_proxy() override;
+    void populate_combobox();
 
     /* Signals */
     sigc::signal<void, int> _changed;
@@ -108,7 +110,8 @@ private:
     ComboToolItem(Glib::ustring group_label,
                   Glib::ustring tooltip,
                   Glib::ustring stock_id,
-                  Glib::RefPtr<Gtk::ListStore> store );
+                  Glib::RefPtr<Gtk::ListStore> store,
+                  bool          has_entry = false);
 };
 }
 }
diff --git a/src/ui/widget/ink-select-one-action.cpp b/src/ui/widget/ink-select-one-action.cpp
deleted file mode 100644
index 95f38b511..000000000
--- a/src/ui/widget/ink-select-one-action.cpp
+++ /dev/null
@@ -1,269 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- * Authors:
- *   Tavmjong Bah <tavmjong@free.fr>
- *
- * Copyright  (C) 2017 Tavmjong Bah
- *
- * Released under GNU GPL v2+, read the file 'COPYING' for more information.
- */
-
-
-/** \file
-    An action (menu/toolbar item) that allows selecting one choice out of many.
-
-    The choices may be displayed as:
-
-    1. A group of items in a toolbar with labels and/or icons.
-    2. As a drop-down menu with a labels and/or icons.
-*/
-
-#include "ink-select-one-action.h"
-
-#include <iostream>
-#include <utility>
-#include <gtkmm/toolitem.h>
-#include <gtkmm/menuitem.h>
-#include <gtkmm/radioaction.h>
-#include <gtkmm/radiomenuitem.h>
-#include <gtkmm/combobox.h>
-#include <gtkmm/menu.h>
-#include <gtkmm/box.h>
-#include <gtkmm/label.h>
-#include <gtkmm/image.h>
-
-InkSelectOneAction* InkSelectOneAction::create(const Glib::ustring &name,
-                                               const Glib::ustring &group_label,
-                                               const Glib::ustring &tooltip,
-                                               const Glib::ustring &stock_id,
-                                               Glib::RefPtr<Gtk::ListStore> store ) {
-
-    return new InkSelectOneAction(name, group_label, tooltip, stock_id, store);
-}
-
-InkSelectOneAction::InkSelectOneAction (const Glib::ustring &name,
-                                        const Glib::ustring &group_label,
-                                        const Glib::ustring &tooltip,
-                                        const Glib::ustring &stock_id,
-                                        Glib::RefPtr<Gtk::ListStore> store ) :
-    Gtk::Action(name, stock_id, group_label, tooltip),
-    _name( name ),
-    _group_label( group_label ),
-    _tooltip( tooltip ),
-    _stock_id( stock_id ),
-    _store (std::move(store)),
-    _use_radio (true),
-    _use_label (true),
-    _use_icon  (true),
-    _use_pixbuf (false),
-    _icon_size ( Gtk::ICON_SIZE_LARGE_TOOLBAR ),
-    _combobox (nullptr),
-    _radioaction (nullptr),
-    _menuitem (nullptr)
-{
-}
-
-void InkSelectOneAction::set_active (gint active) {
-
-    if (active < 0) {
-        std::cerr << "InkSelectOneAction::set_active: active < 0: " << active << std::endl;
-        return;
-    }
-
-    if (_active != active) {
-
-        _active = active;
-
-        if (_combobox) {
-            _combobox->set_active (active);
-        }
-
-        if (_radioaction) {
-            _radioaction->set_current_value (active);
-        }
-
-        if (active < _radiomenuitems.size()) {
-            _radiomenuitems[ active ]->set_active();
-        }
-    }
-}
-
-Glib::ustring InkSelectOneAction::get_active_text () {
-    Gtk::TreeModel::Row row = _store->children()[_active];
-    InkSelectOneActionColumns columns;
-    Glib::ustring label = row[columns.col_label];
-    return label;
-}
-
-Gtk::Widget* InkSelectOneAction::create_menu_item_vfunc() {
-
-    if (_menuitem == nullptr) {
-
-        _menuitem = Gtk::manage (new Gtk::MenuItem);
-        Gtk::Menu *menu = Gtk::manage (new Gtk::Menu);
-
-        Gtk::RadioButton::Group group;
-        int index = 0;
-        auto children = _store->children();
-        for (auto row : children) {
-            InkSelectOneActionColumns columns;
-            Glib::ustring label     = row[columns.col_label     ];
-            Glib::ustring icon      = row[columns.col_icon      ];
-            Glib::ustring tooltip   = row[columns.col_tooltip   ];
-            bool          sensitive = row[columns.col_sensitive ];
-
-            Gtk::RadioMenuItem* button = Gtk::manage(new Gtk::RadioMenuItem(group));
-            button->set_label (label);
-            button->set_tooltip_text( tooltip );
-            button->set_sensitive( sensitive );
-
-            button->signal_toggled().connect( sigc::bind<0>(
-              sigc::mem_fun(*this, &InkSelectOneAction::on_toggled_radiomenu), index++)
-                );
-
-            menu->add (*button);
-
-            _radiomenuitems.push_back( button );
-        }
-
-        if ( _active < _radiomenuitems.size()) {
-            _radiomenuitems[ _active ]->set_active();
-        }
-   
-        _menuitem->set_submenu (*menu);
-        _menuitem->show_all();
-    }
-
-    return _menuitem;
-}
-
-
-Gtk::Widget* InkSelectOneAction::create_tool_item_vfunc() {
-    // Either a group of radio actions or a combobox with labels and/or icons.
-
-    Gtk::ToolItem *tool_item = new Gtk::ToolItem;
-
-    Gtk::Box* box = Gtk::manage(new Gtk::Box());
-    tool_item->add (*box);
-
-    if (_use_group_label) {
-        Gtk::Label *group_label = Gtk::manage (new Gtk::Label( _group_label + ": " ));
-        box->add( *group_label );
-    }
-
-    if (_use_radio) {
-        // Create radio actions (note: these are not radio buttons).
-
-        Gtk::RadioAction::Group group;
-        int index = 0;
-        auto children = _store->children();
-        for (auto row : children) {
-            InkSelectOneActionColumns columns;
-            Glib::ustring label     = row[columns.col_label    ];
-            Glib::ustring icon      = row[columns.col_icon     ];
-            Glib::ustring tooltip   = row[columns.col_tooltip  ];
-            bool          sensitive = row[columns.col_sensitive];
-            Glib::RefPtr<Gtk::RadioAction> action;
-            if (_use_icon) {
-                action =
-                    Gtk::RadioAction::create_with_icon_name (group, "Anonymous", icon, label, tooltip);
-            } else {
-                action =
-                    Gtk::RadioAction::create (group, "Anonymous", label, tooltip);
-            }
-            action->set_property( "value", index++ ); // To identify uniquely each radioaction.
-            action->set_sensitive( sensitive );
-
-            // Save first action for use in setting/getting active value.
-            if (!_radioaction) {
-                _radioaction = action;
-            }
-
-            Gtk::ToolItem* item = action->create_tool_item(); 
-            box->add (*item);
-        }
-
-        if (_radioaction) {
-            _radioaction->set_current_value (_active);
-        }
-
-        _radioaction->signal_changed().connect( sigc::mem_fun(*this, &InkSelectOneAction::on_changed_radioaction));
-
-    } else {
-        // Create combobox
-
-        _combobox = Gtk::manage (new Gtk::ComboBox());
-        _combobox->set_model(_store);
-
-        InkSelectOneActionColumns columns;
-        if (_use_icon) {
-            Gtk::CellRendererPixbuf *renderer = new Gtk::CellRendererPixbuf;
-            renderer->set_property ("stock_size", Gtk::ICON_SIZE_LARGE_TOOLBAR);
-            _combobox->pack_start (*renderer, false);
-            _combobox->add_attribute (*renderer, "icon_name", columns.col_icon   );
-        } else if (_use_pixbuf) {
-            Gtk::CellRendererPixbuf *renderer = new Gtk::CellRendererPixbuf;
-            //renderer->set_property ("stock_size", Gtk::ICON_SIZE_LARGE_TOOLBAR);
-            _combobox->pack_start (*renderer, false);
-            _combobox->add_attribute (*renderer, "pixbuf", columns.col_pixbuf   );
-        }
-  
-        if (_use_label) {
-            _combobox->pack_start(columns.col_label);
-        }
-
-        std::vector<Gtk::CellRenderer*> cells = _combobox->get_cells();
-        for (auto & cell : cells) {
-            _combobox->add_attribute (*cell, "sensitive", columns.col_sensitive);
-        }
-
-        _combobox->set_active (_active);
-
-        _combobox->signal_changed().connect(
-            sigc::mem_fun(*this, &InkSelectOneAction::on_changed_combobox));
-
-        box->add (*_combobox);
-    }
-
-    tool_item->show_all();
-
-    return tool_item;
-}
-
-void InkSelectOneAction::on_changed_combobox() {
-
-    int row = _combobox->get_active_row_number();
-    if (row < 0) row = 0;  // Happens when Gtk::ListStore reconstructed
-    set_active( row );
-    _changed.emit (_active);
-    _changed_after.emit (_active);
-}
-
-void InkSelectOneAction::on_changed_radioaction(const Glib::RefPtr<Gtk::RadioAction>& current) {
-
-    set_active( current->get_current_value() );
-    _changed.emit (_active);
-    _changed_after.emit (_active);
-}
-
-void InkSelectOneAction::on_toggled_radiomenu(int n) {
-
-    // toggled emitted twice, first for button toggled off, second for button toggled on.
-    // We want to react only to the button turned on.
-    if ( n < _radiomenuitems.size() &&_radiomenuitems[ n ]->get_active()) {
-        set_active ( n );
-        _changed.emit (_active);
-        _changed_after.emit (_active);
-    }
-}
-
-/*
-  Local Variables:
-  mode:c++
-  c-file-style:"stroustrup"
-  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
-  indent-tabs-mode:nil
-  fill-column:99
-  End:
-*/
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/ui/widget/ink-select-one-action.h b/src/ui/widget/ink-select-one-action.h
deleted file mode 100644
index efe249da8..000000000
--- a/src/ui/widget/ink-select-one-action.h
+++ /dev/null
@@ -1,143 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-#ifndef SEEN_INK_SELECT_ONE_ACTION
-#define SEEN_INK_SELECT_ONE_ACTION
-
-/*
- * Authors:
- *   Tavmjong Bah <tavmjong@free.fr>
- *
- * Copyright  (C) 2017 Tavmjong Bah
- *
- * Released under GNU GPL v2+, read the file 'COPYING' for more information.
- */
-
-/**
-   An action (menu/toolbar item) that allows selecting one choice out of many.
-
-   The choices may be displayed as:
-
-   1. A group of items in a toolbar with labels and/or icons.
-   2. As a drop-down menu with a labels and/or icons.
-*/
-
-#include <gtkmm/action.h>
-#include <gtkmm/liststore.h>
-#include <sigc++/sigc++.h>
-#include <vector>
-
-namespace Gtk {
-class ComboBox;
-class RadioAction;
-class MenuItem;
-class RadioMenuItem;
-}
-
-class InkSelectOneActionColumns : public Gtk::TreeModel::ColumnRecord {
-
-public:
-    InkSelectOneActionColumns() {
-        add (col_label);
-        add (col_icon);
-        add (col_pixbuf);
-        add (col_data);  // Used to store a pointer
-        add (col_tooltip);
-        add (col_sensitive);
-    }
-    Gtk::TreeModelColumn<Glib::ustring> col_label;
-    Gtk::TreeModelColumn<Glib::ustring> col_icon;
-    Gtk::TreeModelColumn<Glib::RefPtr<Gdk::Pixbuf> >   col_pixbuf;
-    Gtk::TreeModelColumn<void *>        col_data;
-    Gtk::TreeModelColumn<Glib::ustring> col_tooltip;
-    Gtk::TreeModelColumn<bool>          col_sensitive;
-};
-
-
-class InkSelectOneAction : public Gtk::Action {
-
-public:
-
-    static InkSelectOneAction* create(const Glib::ustring &name,
-                                      const Glib::ustring &label,
-                                      const Glib::ustring &tooltip,
-                                      const Glib::ustring &stock_id,
-                                      Glib::RefPtr<Gtk::ListStore> store );
-
-    /* Style of action */
-    void use_radio(  bool use_radio  ) { _use_radio  = use_radio;  }
-    void use_label(  bool use_label  ) { _use_label  = use_label;  }
-    void use_icon(   bool use_icon   ) { _use_icon   = use_icon;   }
-    void use_pixbuf( bool use_pixbuf ) { _use_pixbuf = use_pixbuf; }
-    void use_group_label( bool use_group_label ) { _use_group_label = use_group_label; }
-  
-    gint get_active() { return _active; }
-    Glib::ustring get_active_text();
-    void set_active( gint active );
-    void set_icon_size( Gtk::BuiltinIconSize size ) { _icon_size = size; }
-
-    Glib::RefPtr<Gtk::ListStore> get_store() { return _store; }
-
-    sigc::signal<void, int> signal_changed() { return _changed; }
-    sigc::signal<void, int> signal_changed_after() { return _changed_after; }
-
-protected:
-
-    Gtk::Widget* create_menu_item_vfunc() override;
-    Gtk::Widget* create_tool_item_vfunc() override;
-
-    /* Signals */
-    sigc::signal<void, int> _changed;
-    sigc::signal<void, int> _changed_after;  // Needed for unit tracker which eats _changed.
-
-private:
-
-    Glib::ustring _name;
-    Glib::ustring _group_label;
-    Glib::ustring _tooltip;
-    Glib::ustring _stock_id;
-    Glib::RefPtr<Gtk::ListStore> _store;
-
-    gint _active;  /* Active menu item/button */
-
-    /* Style */
-    bool _use_radio;  // Applies to tool item only
-    bool _use_label;
-    bool _use_icon;   // Applies to menu item only
-    bool _use_pixbuf;
-    bool _use_group_label; // Applies to tool item only
-    Gtk::BuiltinIconSize _icon_size;
-
-    /* Combobox in tool */
-    Gtk::ComboBox* _combobox;
-  
-    /* Need to track one action to get active action. */
-    Glib::RefPtr<Gtk::RadioAction> _radioaction;
-
-    Gtk::MenuItem* _menuitem;
-    std::vector<Gtk::RadioMenuItem*> _radiomenuitems;
-
-    /* Internal Callbacks */
-    void on_changed_combobox();
-    void on_changed_radioaction(const Glib::RefPtr<Gtk::RadioAction>& current);
-    void on_toggled_radiomenu(int n);
-
-    InkSelectOneAction (const Glib::ustring &name,
-                        const Glib::ustring &group_label,
-                        const Glib::ustring &tooltip,
-                        const Glib::ustring &stock_id,
-                        Glib::RefPtr<Gtk::ListStore> store );
-
-};
-
-
-#endif /* SEEN_INK_SELECT_ONE_ACTION */
-
-/*
-  Local Variables:
-  mode:c++
-  c-file-style:"stroustrup"
-  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
-  indent-tabs-mode:nil
-  fill-column:99
-  End:
-*/
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/ui/widget/spin-button-tool-item.cpp b/src/ui/widget/spin-button-tool-item.cpp
index f8c285344..e190d8dd2 100644
--- a/src/ui/widget/spin-button-tool-item.cpp
+++ b/src/ui/widget/spin-button-tool-item.cpp
@@ -3,6 +3,7 @@
 #include "spin-button-tool-item.h"
 
 #include <gtkmm/box.h>
+#include <gtkmm/image.h>
 #include <gtkmm/radiomenuitem.h>
 #include <gtkmm/toolbar.h>
 
@@ -390,14 +391,28 @@ SpinButtonToolItem::SpinButtonToolItem(const Glib::ustring            name,
     _btn->add_events(Gdk::KEY_PRESS_MASK);
 
     // Create a label
-    auto label = Gtk::manage(new Gtk::Label(label_text));
+    _label = Gtk::manage(new Gtk::Label(label_text));
 
     // Arrange the widgets in a horizontal box
-    auto hbox = Gtk::manage(new Gtk::Box());
-    hbox->set_spacing(3);
-    hbox->pack_start(*label);
-    hbox->pack_start(*_btn);
-    add(*hbox);
+    _hbox = Gtk::manage(new Gtk::Box());
+    _hbox->set_spacing(3);
+    _hbox->pack_start(*_label);
+    _hbox->pack_start(*_btn);
+    add(*_hbox);
+    show_all();
+}
+
+void
+SpinButtonToolItem::set_icon(const Glib::ustring& icon_name)
+{
+    _hbox->remove(*_label);
+    _icon = Gtk::manage(new Gtk::Image(icon_name, Gtk::ICON_SIZE_SMALL_TOOLBAR));
+
+    if(_icon) {
+        _hbox->pack_start(*_icon);
+        _hbox->reorder_child(*_icon, 0);
+    }
+
     show_all();
 }
 
diff --git a/src/ui/widget/spin-button-tool-item.h b/src/ui/widget/spin-button-tool-item.h
index 1b33e8580..4386d4799 100644
--- a/src/ui/widget/spin-button-tool-item.h
+++ b/src/ui/widget/spin-button-tool-item.h
@@ -5,6 +5,7 @@
 #include <gtkmm/toolitem.h>
 
 namespace Gtk {
+class Box;
 class RadioButtonGroup;
 class RadioMenuItem;
 }
@@ -29,6 +30,10 @@ private:
     double         _last_val;       ///< The last value of the adjustment
     bool           _transfer_focus; ///< Whether or not to transfer focus
 
+    Gtk::Box    *_hbox;       ///< Horizontal box, to store widgets
+    Gtk::Widget *_label;      ///< A text label to describe the setting
+    Gtk::Widget *_icon;       ///< An icon to describe the setting
+
     /** A widget that grabs focus when this one loses it */
     Gtk::Widget * _focus_widget;
 
@@ -72,6 +77,7 @@ public:
     void set_custom_numeric_menu_data(std::vector<double>&              values,
                                       const std::vector<Glib::ustring>& labels = std::vector<Glib::ustring>());
     Glib::RefPtr<Gtk::Adjustment> get_adjustment();
+    void set_icon(const Glib::ustring& icon_name);
 };
 } // namespace Widget
 } // namespace UI
diff --git a/src/ui/widget/unit-tracker.cpp b/src/ui/widget/unit-tracker.cpp
index 4abfaa9c8..0bdd3210a 100644
--- a/src/ui/widget/unit-tracker.cpp
+++ b/src/ui/widget/unit-tracker.cpp
@@ -19,7 +19,6 @@
 
 #include "unit-tracker.h"
 
-#include "ink-select-one-action.h"
 #include "combo-tool-item.h"
 
 #define COLUMN_STRING 0
@@ -41,7 +40,7 @@ UnitTracker::UnitTracker(UnitType unit_type) :
 {
     UnitTable::UnitMap m = unit_table.units(unit_type);
     
-    InkSelectOneActionColumns columns;
+    ComboToolItemColumns columns;
     _store = Gtk::ListStore::create(columns);
     Gtk::TreeModel::Row row;
 
@@ -67,7 +66,6 @@ UnitTracker::UnitTracker(UnitType unit_type) :
 
 UnitTracker::~UnitTracker()
 {
-    _actionList.clear();
     _combo_list.clear();
 
     // Unhook weak references to GtkAdjustments
@@ -91,7 +89,7 @@ void UnitTracker::setActiveUnit(Inkscape::Util::Unit const *unit)
 {
     if (unit) {
 
-        InkSelectOneActionColumns columns;
+        ComboToolItemColumns columns;
         int index = 0;
         for (auto& row: _store->children() ) {
             Glib::ustring storedUnit = row[columns.col_label];
@@ -122,7 +120,7 @@ void UnitTracker::addAdjustment(GtkAdjustment *adj)
 
 void UnitTracker::addUnit(Inkscape::Util::Unit const *u)
 {
-    InkSelectOneActionColumns columns;
+    ComboToolItemColumns columns;
 
     Gtk::TreeModel::Row row;
     row = *(_store->append());
@@ -134,7 +132,7 @@ void UnitTracker::addUnit(Inkscape::Util::Unit const *u)
 
 void UnitTracker::prependUnit(Inkscape::Util::Unit const *u)
 {
-    InkSelectOneActionColumns columns;
+    ComboToolItemColumns columns;
 
     Gtk::TreeModel::Row row;
     row = *(_store->prepend());
@@ -153,28 +151,6 @@ void UnitTracker::setFullVal(GtkAdjustment *adj, gdouble val)
     _priorValues[adj] = val;
 }
 
-/**
- * \deprecated Use create_tool_item instead
- */
-InkSelectOneAction *UnitTracker::createAction(Glib::ustring const &name,
-                                     Glib::ustring const &label,
-                                     Glib::ustring const &tooltip)
-{
-    InkSelectOneAction* act =
-        InkSelectOneAction::create( name, label, tooltip, "NotUsed", _store);
-
-    act->use_radio( false );
-    act->use_label( true );
-    act->use_icon( false );
-    act->use_group_label( false );
-    act->set_active( _active );
-
-    act->signal_changed().connect(sigc::mem_fun(*this, &UnitTracker::_unitChangedCB));
-    _actionList.push_back(act);
-
-    return act;
-}
-
 ComboToolItem *
 UnitTracker::create_tool_item(Glib::ustring const &label,
                               Glib::ustring const &tooltip)
@@ -192,14 +168,6 @@ void UnitTracker::_unitChangedCB(int active)
     _setActive(active);
 }
 
-void UnitTracker::_actionFinalizedCB(gpointer data, GObject *where_the_object_was)
-{
-    if (data && where_the_object_was) {
-        UnitTracker *self = reinterpret_cast<UnitTracker *>(data);
-        self->_actionFinalized(where_the_object_was);
-    }
-}
-
 void UnitTracker::_adjustmentFinalizedCB(gpointer data, GObject *where_the_object_was)
 {
     if (data && where_the_object_was) {
@@ -208,17 +176,6 @@ void UnitTracker::_adjustmentFinalizedCB(gpointer data, GObject *where_the_objec
     }
 }
 
-void UnitTracker::_actionFinalized(GObject *where_the_object_was)
-{
-    InkSelectOneAction* act = (InkSelectOneAction*)(where_the_object_was);
-    auto it = std::find(_actionList.begin(),_actionList.end(), act);
-    if (it != _actionList.end()) {
-        _actionList.erase(it);
-    } else {
-        g_warning("Received a finalization callback for unknown object %p", where_the_object_was);
-    }
-}
-
 void UnitTracker::_adjustmentFinalized(GObject *where_the_object_was)
 {
     GtkAdjustment* adj = (GtkAdjustment*)(where_the_object_was);
@@ -238,7 +195,7 @@ void UnitTracker::_setActive(gint active)
         if (_store) {
 
             // Find old and new units
-            InkSelectOneActionColumns columns;
+            ComboToolItemColumns columns;
             int index = 0;
             Glib::ustring oldAbbr( "NotFound" );
             Glib::ustring newAbbr( "NotFound" );
@@ -274,10 +231,6 @@ void UnitTracker::_setActive(gint active)
         }
         _active = active;
 
-        for (auto act: _actionList) {
-            act->set_active (active);
-        }
-
         for (auto combo : _combo_list) {
             if(combo) combo->set_active(active);
         }
diff --git a/src/ui/widget/unit-tracker.h b/src/ui/widget/unit-tracker.h
index c876d8224..1f16292ff 100644
--- a/src/ui/widget/unit-tracker.h
+++ b/src/ui/widget/unit-tracker.h
@@ -20,17 +20,13 @@
 #include <vector>
 
 #include <gtkmm/liststore.h>
-#include <gtkmm/action.h>
 
 #include "util/units.h"
 
-class InkSelectOneAction;
-
 using Inkscape::Util::Unit;
 using Inkscape::Util::UnitType;
 
 typedef struct _GObject       GObject;
-typedef struct _GtkAction     GtkAction;
 typedef struct _GtkAdjustment GtkAdjustment;
 typedef struct _GtkListStore  GtkListStore;
 
@@ -55,10 +51,6 @@ public:
     void prependUnit(Inkscape::Util::Unit const *u);
     void setFullVal(GtkAdjustment *adj, gdouble val);
 
-    InkSelectOneAction *createAction(Glib::ustring const &name,
-                                     Glib::ustring const &label,
-                                     Glib::ustring const &tooltip);
-
     ComboToolItem *create_tool_item(Glib::ustring const &label,
                                     Glib::ustring const &tooltip);
 
@@ -68,14 +60,12 @@ protected:
 private:
     // Callbacks
     void _unitChangedCB(int active);
-    static void _actionFinalizedCB(gpointer data, GObject *where_the_object_was);
     static void _adjustmentFinalizedCB(gpointer data, GObject *where_the_object_was);
 
     void _setActive(gint index);
     void _fixupAdjustments(Inkscape::Util::Unit const *oldUnit, Inkscape::Util::Unit const *newUnit);
 
     // Cleanup
-    void _actionFinalized(GObject *where_the_object_was);
     void _adjustmentFinalized(GObject *where_the_object_was);
 
     gint _active;
@@ -84,7 +74,6 @@ private:
     bool _activeUnitInitialized;
 
     Glib::RefPtr<Gtk::ListStore> _store;
-    std::vector<InkSelectOneAction*> _actionList;
     std::vector<ComboToolItem *> _combo_list;
     std::vector<GtkAdjustment*> _adjList;
     std::map <GtkAdjustment *, gdouble> _priorValues;
diff --git a/src/widgets/CMakeLists.txt b/src/widgets/CMakeLists.txt
index c6dad3f1a..4c0617167 100644
--- a/src/widgets/CMakeLists.txt
+++ b/src/widgets/CMakeLists.txt
@@ -3,14 +3,12 @@ add_subdirectory(gimp)
 
 set(widgets_SRC
 	desktop-widget.cpp
-	ege-adjustment-action.cpp
 	ege-paint-def.cpp
 	fill-style.cpp
 	gradient-image.cpp
 	gradient-selector.cpp
 	gradient-vector.cpp
 	ink-action.cpp
-	ink-comboboxentry-action.cpp
 	ink-toggle-action.cpp
 	paint-selector.cpp
 	sp-attribute-widget.cpp
@@ -26,7 +24,6 @@ set(widgets_SRC
 	# -------
 	# Headers
 	desktop-widget.h
-	ege-adjustment-action.h
 	ege-paint-def.h
 	fill-n-stroke-factory.h
 	fill-style.h
@@ -34,7 +31,6 @@ set(widgets_SRC
 	gradient-selector.h
 	gradient-vector.h
 	ink-action.h
-	ink-comboboxentry-action.h
 	ink-toggle-action.h
 	paint-selector.h
 	sp-attribute-widget.h
diff --git a/src/widgets/desktop-widget.cpp b/src/widgets/desktop-widget.cpp
index e94448e2c..8bf236972 100644
--- a/src/widgets/desktop-widget.cpp
+++ b/src/widgets/desktop-widget.cpp
@@ -60,7 +60,6 @@
 #include "ui/uxmanager.h"
 #include "ui/widget/button.h"
 #include "ui/widget/dock.h"
-#include "ui/widget/ink-select-one-action.h"
 #include "ui/widget/layer-selector.h"
 #include "ui/widget/selected-style.h"
 #include "ui/widget/spin-button-tool-item.h"
@@ -1527,6 +1526,22 @@ void SPDesktopWidget::layoutWidgets()
     }
 }
 
+Gtk::Toolbar *
+SPDesktopWidget::get_toolbar_by_name(const Glib::ustring& name)
+{
+    // The name is actually attached to the GtkGrid that contains
+    // the toolbar, so we need to get the grid first
+    auto widget = sp_search_by_name_recursive(Glib::wrap(aux_toolbox), name);
+    auto grid = dynamic_cast<Gtk::Grid*>(widget);
+
+    if (!grid) return nullptr;
+
+    auto child = grid->get_child_at(0,0);
+    auto tb = dynamic_cast<Gtk::Toolbar*>(child);
+
+    return tb;
+}
+
 void
 SPDesktopWidget::setToolboxFocusTo (const gchar* label)
 {
@@ -1565,15 +1580,6 @@ SPDesktopWidget::setToolboxAdjustmentValue (gchar const *id, double value)
     else g_warning ("Could not find GtkAdjustment for %s\n", id);
 }
 
-void
-SPDesktopWidget::setToolboxSelectOneValue (gchar const *id, int value)
-{
-    gpointer hb = sp_search_by_data_recursive(aux_toolbox, (gpointer) id);
-    if (static_cast<InkSelectOneAction*>(hb)) {
-        static_cast<InkSelectOneAction*>(hb)->set_active( value );
-    }
-}
-
 
 bool
 SPDesktopWidget::isToolboxButtonActive (const gchar* id)
diff --git a/src/widgets/desktop-widget.h b/src/widgets/desktop-widget.h
index d21ba7bb8..59c031120 100644
--- a/src/widgets/desktop-widget.h
+++ b/src/widgets/desktop-widget.h
@@ -218,11 +218,10 @@ public:
         void updateZoom() override { _dtw->update_zoom(); }
         void letZoomGrabFocus() override { _dtw->letZoomGrabFocus(); }
         void updateRotation() override { _dtw->update_rotation(); }
+        Gtk::Toolbar* get_toolbar_by_name(const Glib::ustring& name) override {return _dtw->get_toolbar_by_name(name);}
         void setToolboxFocusTo(const gchar *id) override { _dtw->setToolboxFocusTo(id); }
         void setToolboxAdjustmentValue(const gchar *id, double val) override
         { _dtw->setToolboxAdjustmentValue (id, val); }
-        void setToolboxSelectOneValue (gchar const *id, int val) override
-        { _dtw->setToolboxSelectOneValue (id, val); }
         bool isToolboxButtonActive (gchar const* id) override
         { return _dtw->isToolboxButtonActive (id); }
         void setCoordinateStatus (Geom::Point p) override
@@ -255,9 +254,9 @@ public:
     void presentWindow();
     bool showInfoDialog( Glib::ustring const &message );
     bool warnDialog (Glib::ustring const &text);
+    Gtk::Toolbar* get_toolbar_by_name(const Glib::ustring& name);
     void setToolboxFocusTo (gchar const *);
     void setToolboxAdjustmentValue (gchar const * id, double value);
-    void setToolboxSelectOneValue (gchar const * id, gint value);
     bool isToolboxButtonActive (gchar const *id);
     void setToolboxPosition(Glib::ustring const& id, GtkPositionType pos);
     void setCoordinateStatus(Geom::Point p);
diff --git a/src/widgets/ege-adjustment-action.cpp b/src/widgets/ege-adjustment-action.cpp
deleted file mode 100644
index 49280bcd3..000000000
--- a/src/widgets/ege-adjustment-action.cpp
+++ /dev/null
@@ -1,1130 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later OR MPL-1.1 OR LGPL-2.1-or-later
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is EGE Adjustment Action.
- *
- * The Initial Developer of the Original Code is
- * Jon A. Cruz.
- * Portions created by the Initial Developer are Copyright (C) 2006
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-/* Note: this file should be kept compilable as both .cpp and .c */
-
-#include <cmath>
-#include <cstring>
-#include <vector>
-#include <algorithm>
-
-#include <gtkmm/container.h>
-#include <gtkmm/radiomenuitem.h>
-#include <gtkmm/adjustment.h>
-#include <gdk/gdkkeysyms.h>
-#include <gdkmm/display.h>
-
-#include "ui/icon-loader.h"
-#include "ui/icon-names.h"
-#include "ui/widget/ink-spinscale.h"
-#include "widgets/ege-adjustment-action.h"
-
-static void ege_adjustment_action_finalize( GObject* object );
-static void ege_adjustment_action_get_property( GObject* obj, guint propId, GValue* value, GParamSpec * pspec );
-static void ege_adjustment_action_set_property( GObject* obj, guint propId, const GValue *value, GParamSpec* pspec );
-
-static GtkWidget* create_menu_item( GtkAction* action );
-static GtkWidget* create_tool_item( GtkAction* action );
-static void connect_proxy( GtkAction *action, GtkWidget *proxy );
-static void disconnect_proxy( GtkAction *action, GtkWidget *proxy );
-
-static gboolean focus_in_cb( GtkWidget *widget, GdkEventKey *event, gpointer data );
-static gboolean focus_out_cb( GtkWidget *widget, GdkEventKey *event, gpointer data );
-static gboolean keypress_cb( GtkWidget *widget, GdkEventKey *event, gpointer data );
-
-static void ege_adjustment_action_defocus( EgeAdjustmentAction* action );
-
-static void egeAct_free_description( gpointer data, gpointer user_data );
-static void egeAct_free_all_descriptions( EgeAdjustmentAction* action );
-
-static EgeCreateAdjWidgetCB gFactoryCb = nullptr;
-static GQuark gDataName = 0;
-
-enum {
-    APPEARANCE_UNKNOWN = -1,
-    APPEARANCE_NONE = 0,
-    APPEARANCE_FULL,    /* label, then all choices represented by separate buttons */
-    APPEARANCE_COMPACT, /* label, then choices in a drop-down menu */
-    APPEARANCE_MINIMAL, /* no label, just choices in a drop-down menu */
-};
-
-/* TODO need to have appropriate icons setup for these: */
-static const gchar *floogles[] = {
-    INKSCAPE_ICON("list-remove"),
-    INKSCAPE_ICON("list-add"),
-    INKSCAPE_ICON("go-down"),
-    INKSCAPE_ICON("help-about"),
-    INKSCAPE_ICON("go-up"),
-    nullptr};
-
-typedef struct _EgeAdjustmentDescr EgeAdjustmentDescr;
-
-struct _EgeAdjustmentDescr
-{
-    gchar* descr;
-    gdouble value;
-};
-
-typedef struct {
-    GtkAdjustment* adj;
-    GtkWidget* focusWidget;
-    gdouble climbRate;
-    guint digits;
-    gdouble epsilon;
-    gchar* format;
-    gchar* selfId;
-    EgeWidgetFixup toolPost;
-    gdouble lastVal;
-    gdouble step;
-    gdouble page;
-    gint appearanceMode;
-    gboolean transferFocus;
-    std::vector<EgeAdjustmentDescr*> descriptions;
-    gchar* appearance;
-    gchar* iconId;
-    GtkIconSize iconSize;
-    Inkscape::UI::Widget::UnitTracker *unitTracker;
-} EgeAdjustmentActionPrivate;
-
-#define EGE_ADJUSTMENT_ACTION_GET_PRIVATE(o) \
-    reinterpret_cast<EgeAdjustmentActionPrivate *>( ege_adjustment_action_get_instance_private (o))
-
-enum {
-    PROP_ADJUSTMENT = 1,
-    PROP_FOCUS_WIDGET,
-    PROP_CLIMB_RATE,
-    PROP_DIGITS,
-    PROP_SELFID,
-    PROP_TOOL_POST,
-    PROP_APPEARANCE,
-    PROP_ICON_ID,
-    PROP_ICON_SIZE,
-    PROP_UNIT_TRACKER
-};
-
-enum {
-    BUMP_TOP = 0,
-    BUMP_PAGE_UP,
-    BUMP_UP,
-    BUMP_NONE,
-    BUMP_DOWN,
-    BUMP_PAGE_DOWN,
-    BUMP_BOTTOM,
-    BUMP_CUSTOM = 100
-};
-
-G_DEFINE_TYPE_WITH_PRIVATE(EgeAdjustmentAction, ege_adjustment_action, GTK_TYPE_ACTION);
-
-static void ege_adjustment_action_class_init( EgeAdjustmentActionClass* klass )
-{
-    if ( klass ) {
-        GObjectClass * objClass = G_OBJECT_CLASS( klass );
-
-        gDataName = g_quark_from_string("ege-adj-action");
-
-  
-        objClass->finalize = ege_adjustment_action_finalize;
-
-        objClass->get_property = ege_adjustment_action_get_property;
-        objClass->set_property = ege_adjustment_action_set_property;
-
-        klass->parent_class.create_menu_item = create_menu_item;
-        klass->parent_class.create_tool_item = create_tool_item;
-        klass->parent_class.connect_proxy = connect_proxy;
-        klass->parent_class.disconnect_proxy = disconnect_proxy;
-
-        g_object_class_install_property( objClass,
-                                         PROP_ADJUSTMENT,
-                                         g_param_spec_object( "adjustment",
-                                                              "Adjustment",
-                                                              "The adjustment to change",
-                                                              GTK_TYPE_ADJUSTMENT,
-                                                              (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
-
-        g_object_class_install_property( objClass,
-                                         PROP_FOCUS_WIDGET,
-                                         g_param_spec_pointer( "focus-widget",
-                                                               "Focus Widget",
-                                                               "The widget to return focus to",
-                                                               (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
-
-        g_object_class_install_property( objClass,
-                                         PROP_CLIMB_RATE,
-                                         g_param_spec_double( "climb-rate",
-                                                              "Climb Rate",
-                                                              "The acelleraton rate",
-                                                              0.0, G_MAXDOUBLE, 0.0,
-                                                              (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
-
-        g_object_class_install_property( objClass,
-                                         PROP_DIGITS,
-                                         g_param_spec_uint( "digits",
-                                                            "Digits",
-                                                            "The number of digits to show",
-                                                            0, 20, 0,
-                                                            (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
-
-        g_object_class_install_property( objClass,
-                                         PROP_SELFID,
-                                         g_param_spec_string( "self-id",
-                                                              "Self ID",
-                                                              "Marker for self pointer",
-                                                              nullptr,
-                                                              (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
-
-        g_object_class_install_property( objClass,
-                                         PROP_TOOL_POST,
-                                         g_param_spec_pointer( "tool-post",
-                                                               "Tool Widget post process",
-                                                               "Function for final adjustments",
-                                                               (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
-
-        g_object_class_install_property( objClass,
-                                         PROP_APPEARANCE,
-                                         g_param_spec_string( "appearance",
-                                                              "Appearance hint",
-                                                              "A hint for how to display",
-                                                              "",
-                                                              (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
-
-        g_object_class_install_property( objClass,
-                                         PROP_ICON_ID,
-                                         g_param_spec_string( "iconId",
-                                                              "Icon ID",
-                                                              "The id for the icon",
-                                                              "",
-                                                              (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
-
-        g_object_class_install_property( objClass,
-                                         PROP_ICON_SIZE,
-                                         g_param_spec_int( "iconSize",
-                                                           "Icon Size",
-                                                           "The size the icon",
-                                                           (int)GTK_ICON_SIZE_MENU,
-                                                           (int)GTK_ICON_SIZE_DIALOG,
-                                                           (int)GTK_ICON_SIZE_SMALL_TOOLBAR,
-                                                           (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
-
-        g_object_class_install_property( objClass,
-                                         PROP_UNIT_TRACKER,
-                                         g_param_spec_pointer( "unit_tracker",
-                                                               "Unit Tracker",
-                                                               "The widget that keeps track of the unit",
-                                                               (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
-    }
-}
-
-void ege_adjustment_action_set_compact_tool_factory( EgeCreateAdjWidgetCB factoryCb )
-{
-    gFactoryCb = factoryCb;
-}
-
-static void ege_adjustment_action_init( EgeAdjustmentAction* action )
-{
-    auto priv = EGE_ADJUSTMENT_ACTION_GET_PRIVATE( action );
-    priv->adj = nullptr;
-    priv->focusWidget = nullptr;
-    priv->climbRate = 0.0;
-    priv->digits = 2;
-    priv->epsilon = 0.009;
-    priv->format = g_strdup_printf("%%0.%df%%s%%s", priv->digits);
-    priv->selfId = nullptr;
-    priv->toolPost = nullptr;
-    priv->lastVal = 0.0;
-    priv->step = 0.0;
-    priv->page = 0.0;
-    priv->appearanceMode = APPEARANCE_NONE;
-    priv->transferFocus = FALSE;
-    //priv->descriptions = 0;
-    priv->appearance = nullptr;
-    priv->iconId = nullptr;
-    priv->iconSize = GTK_ICON_SIZE_SMALL_TOOLBAR;
-    priv->unitTracker = nullptr;
-}
-
-static void ege_adjustment_action_finalize( GObject* object )
-{
-    EgeAdjustmentAction* action = nullptr;
-    g_return_if_fail( object != nullptr );
-    g_return_if_fail( IS_EGE_ADJUSTMENT_ACTION(object) );
-
-    action = EGE_ADJUSTMENT_ACTION( object );
-    auto priv = EGE_ADJUSTMENT_ACTION_GET_PRIVATE (action);
-
-    // g_free(NULL) does nothing
-    g_free( priv->format );
-    g_free( priv->selfId );
-    g_free( priv->appearance );
-    g_free( priv->iconId );
-
-    egeAct_free_all_descriptions( action );
-
-    if ( G_OBJECT_CLASS(ege_adjustment_action_parent_class)->finalize ) {
-        (*G_OBJECT_CLASS(ege_adjustment_action_parent_class)->finalize)(object);
-    }
-}
-
-EgeAdjustmentAction* ege_adjustment_action_new( GtkAdjustment* adjustment,
-                                                const gchar *name,
-                                                const gchar *label,
-                                                const gchar *tooltip,
-                                                const gchar *stock_id,
-                                                gdouble climb_rate,
-                                                guint digits,
-                                                Inkscape::UI::Widget::UnitTracker *unit_tracker )
-{
-    GObject* obj = (GObject*)g_object_new( EGE_ADJUSTMENT_ACTION_TYPE,
-                                           "name", name,
-                                           "label", label,
-                                           "tooltip", tooltip,
-                                           "stock_id", stock_id,
-                                           "adjustment", adjustment,
-                                           "climb-rate", climb_rate,
-                                           "digits", digits,
-                                           "unit_tracker", unit_tracker,
-                                           NULL );
-
-    EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( obj );
-
-    return action;
-}
-
-static void ege_adjustment_action_get_property( GObject* obj, guint propId, GValue* value, GParamSpec * pspec )
-{
-    EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( obj );
-    auto priv = EGE_ADJUSTMENT_ACTION_GET_PRIVATE (action);
-    switch ( propId ) {
-        case PROP_ADJUSTMENT:
-            g_value_set_object( value, priv->adj );
-            break;
-
-        case PROP_FOCUS_WIDGET:
-            g_value_set_pointer( value, priv->focusWidget );
-            break;
-
-        case PROP_CLIMB_RATE:
-            g_value_set_double( value, priv->climbRate );
-            break;
-
-        case PROP_DIGITS:
-            g_value_set_uint( value, priv->digits );
-            break;
-
-        case PROP_SELFID:
-            g_value_set_string( value, priv->selfId );
-            break;
-
-        case PROP_TOOL_POST:
-            g_value_set_pointer( value, (void*)priv->toolPost );
-            break;
-
-        case PROP_APPEARANCE:
-            g_value_set_string( value, priv->appearance );
-            break;
-
-        case PROP_ICON_ID:
-            g_value_set_string( value, priv->iconId );
-            break;
-
-        case PROP_ICON_SIZE:
-            g_value_set_int( value, priv->iconSize );
-            break;
-
-        case PROP_UNIT_TRACKER:
-            g_value_set_pointer( value, priv->unitTracker );
-            break;
-
-        default:
-            G_OBJECT_WARN_INVALID_PROPERTY_ID( obj, propId, pspec );
-    }
-}
-
-void ege_adjustment_action_set_property( GObject* obj, guint propId, const GValue *value, GParamSpec* pspec )
-{
-    EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( obj );
-    auto priv = EGE_ADJUSTMENT_ACTION_GET_PRIVATE (action);
-    switch ( propId ) {
-        case PROP_ADJUSTMENT:
-        {
-            priv->adj = GTK_ADJUSTMENT( g_value_get_object( value ) );
-            g_object_get( G_OBJECT(priv->adj),
-                          "step-increment", &priv->step,
-                          "page-increment", &priv->page,
-                          NULL );
-        }
-        break;
-
-        case PROP_FOCUS_WIDGET:
-        {
-            /* TODO unhook prior */
-            priv->focusWidget = (GtkWidget*)g_value_get_pointer( value );
-        }
-        break;
-
-        case PROP_CLIMB_RATE:
-        {
-            /* TODO pass on */
-            priv->climbRate = g_value_get_double( value );
-        }
-        break;
-
-        case PROP_DIGITS:
-        {
-            /* TODO pass on */
-            priv->digits = g_value_get_uint( value );
-            switch ( priv->digits ) {
-                case 0: priv->epsilon = 0.9; break;
-                case 1: priv->epsilon = 0.09; break;
-                case 2: priv->epsilon = 0.009; break;
-                case 3: priv->epsilon = 0.0009; break;
-                case 4: priv->epsilon = 0.00009; break;
-            }
-            if ( priv->format ) {
-                g_free( priv->format );
-            }
-            priv->format = g_strdup_printf("%%0.%df%%s%%s", priv->digits);
-        }
-        break;
-
-        case PROP_SELFID:
-        {
-            /* TODO pass on */
-            gchar* prior = priv->selfId;
-            priv->selfId = g_value_dup_string( value );
-            g_free( prior );
-        }
-        break;
-
-        case PROP_TOOL_POST:
-        {
-            priv->toolPost = (EgeWidgetFixup)g_value_get_pointer( value );
-        }
-        break;
-
-        case PROP_APPEARANCE:
-        {
-            gchar* tmp = priv->appearance;
-            gchar* newVal = g_value_dup_string( value );
-            priv->appearance = newVal;
-            g_free( tmp );
-
-            if ( !priv->appearance || (strcmp("", newVal) == 0) ) {
-                priv->appearanceMode = APPEARANCE_NONE;
-            } else if ( strcmp("full", newVal) == 0 ) {
-                priv->appearanceMode = APPEARANCE_FULL;
-            } else if ( strcmp("compact", newVal) == 0 ) {
-                priv->appearanceMode = APPEARANCE_COMPACT;
-            } else if ( strcmp("minimal", newVal) == 0 ) {
-                priv->appearanceMode = APPEARANCE_MINIMAL;
-            } else {
-                priv->appearanceMode = APPEARANCE_UNKNOWN;
-            }
-        }
-        break;
-
-        case PROP_ICON_ID:
-        {
-            gchar* tmp = priv->iconId;
-            priv->iconId = g_value_dup_string( value );
-            g_free( tmp );
-        }
-        break;
-
-        case PROP_ICON_SIZE:
-        {
-            priv->iconSize = (GtkIconSize)g_value_get_int( value );
-        }
-        break;
-
-        case PROP_UNIT_TRACKER:
-        {
-            priv->unitTracker = (Inkscape::UI::Widget::UnitTracker*)g_value_get_pointer( value );
-        }
-        break;
-
-        default:
-            G_OBJECT_WARN_INVALID_PROPERTY_ID( obj, propId, pspec );
-    }
-}
-
-GtkAdjustment* ege_adjustment_action_get_adjustment( EgeAdjustmentAction* action )
-{
-    g_return_val_if_fail( IS_EGE_ADJUSTMENT_ACTION(action), NULL );
-
-    auto priv = EGE_ADJUSTMENT_ACTION_GET_PRIVATE (action);
-
-    return priv->adj;
-}
-
-void ege_adjustment_action_set_focuswidget( EgeAdjustmentAction* action, GtkWidget* widget )
-{
-    g_return_if_fail( IS_EGE_ADJUSTMENT_ACTION(action) );
-    auto priv = EGE_ADJUSTMENT_ACTION_GET_PRIVATE (action);
-
-    /* TODO unhook prior */
-
-    priv->focusWidget = widget;
-}
-
-GtkWidget* ege_adjustment_action_get_focuswidget( EgeAdjustmentAction* action )
-{
-    g_return_val_if_fail( IS_EGE_ADJUSTMENT_ACTION(action), NULL );
-    auto priv = EGE_ADJUSTMENT_ACTION_GET_PRIVATE (action);
-
-    return priv->focusWidget;
-}
-
-static void egeAct_free_description( gpointer data, gpointer user_data ) {
-    (void)user_data;
-    if ( data ) {
-        EgeAdjustmentDescr* descr = (EgeAdjustmentDescr*)data;
-        if ( descr->descr ) {
-            g_free( descr->descr );
-            descr->descr = nullptr;
-        }
-        g_free( descr );
-    }
-}
-
-static void egeAct_free_all_descriptions( EgeAdjustmentAction* action )
-{
-    auto priv = EGE_ADJUSTMENT_ACTION_GET_PRIVATE (action);
-    for(auto i:priv->descriptions) {
-        egeAct_free_description(i,nullptr);
-    }
-    for(auto i:priv->descriptions) {
-        g_free(i);
-    }
-    priv->descriptions.clear();
-}
-
-static gint egeAct_compare_descriptions( gconstpointer a, gconstpointer b )
-{
-    gint val = 0;
-
-    EgeAdjustmentDescr const * aa = (EgeAdjustmentDescr const *)a;
-    EgeAdjustmentDescr const * bb = (EgeAdjustmentDescr const *)b;
-
-    if ( aa && bb ) {
-        if ( aa->value < bb->value ) {
-            val = -1;
-        } else if ( aa->value > bb->value ) {
-            val = 1;
-        }
-    }
-
-    return val;
-}
-
-void ege_adjustment_action_set_descriptions( EgeAdjustmentAction* action, gchar const** descriptions, gdouble const* values, guint count )
-{
-    g_return_if_fail( IS_EGE_ADJUSTMENT_ACTION(action) );
-    auto priv = EGE_ADJUSTMENT_ACTION_GET_PRIVATE (action);
-
-    egeAct_free_all_descriptions( action );
-
-    if ( count && descriptions && values ) {
-        guint i = 0;
-        for ( i = 0; i < count; i++ ) {
-            EgeAdjustmentDescr* descr = g_new0( EgeAdjustmentDescr, 1 );
-            descr->descr = descriptions[i] ? g_strdup( descriptions[i] ) : nullptr;
-            descr->value = values[i];
-            priv->descriptions.push_back(descr);
-            std::sort(priv->descriptions.begin(),priv->descriptions.end());
-        }
-    }
-}
-
-void ege_adjustment_action_set_appearance( EgeAdjustmentAction* action, gchar const* val )
-{
-    g_object_set( G_OBJECT(action), "appearance", val, NULL );
-}
-
-static void process_menu_action( GtkWidget* obj, gpointer data )
-{
-    GtkCheckMenuItem* item = GTK_CHECK_MENU_ITEM(obj);
-    if ( gtk_check_menu_item_get_active (item)) {
-        EgeAdjustmentAction* act = (EgeAdjustmentAction*)g_object_get_qdata( G_OBJECT(obj), gDataName );
-        auto priv = EGE_ADJUSTMENT_ACTION_GET_PRIVATE (act);
-        gint what = GPOINTER_TO_INT(data);
-
-
-        gdouble base = gtk_adjustment_get_value( priv->adj );
-        gdouble lower = 0.0;
-        gdouble upper = 0.0;
-        gdouble step = 0.0;
-        gdouble page = 0.0;
-        g_object_get( G_OBJECT(priv->adj),
-                      "lower", &lower,
-                      "upper", &upper,
-                      "step-increment", &step,
-                      "page-increment", &page,
-                      NULL );
-
-        switch ( what ) {
-            case BUMP_TOP:
-                gtk_adjustment_set_value( priv->adj, upper );
-                break;
-
-            case BUMP_PAGE_UP:
-                gtk_adjustment_set_value( priv->adj, base + page );
-                break;
-
-            case BUMP_UP:
-                gtk_adjustment_set_value( priv->adj, base + step );
-                break;
-
-            case BUMP_DOWN:
-                gtk_adjustment_set_value( priv->adj, base - step );
-                break;
-
-            case BUMP_PAGE_DOWN:
-                gtk_adjustment_set_value( priv->adj, base - page );
-                break;
-
-            case BUMP_BOTTOM:
-                gtk_adjustment_set_value( priv->adj, lower );
-                break;
-
-            default:
-                if ( what >= BUMP_CUSTOM ) {
-                    guint index = what - BUMP_CUSTOM;
-                    if ( index < priv->descriptions.size() ) {
-                        EgeAdjustmentDescr* descr = priv->descriptions[index];
-                        if ( descr ) {
-                            gtk_adjustment_set_value( priv->adj, descr->value );
-                        }
-                    }
-                }
-        }
-    }
-}
-
-static void create_single_menu_item( GCallback toggleCb, int val, GtkWidget* menu, EgeAdjustmentAction* act, GtkWidget** dst, Gtk::RadioMenuItem::Group *group, gdouble num, gboolean active )
-{
-    auto priv = EGE_ADJUSTMENT_ACTION_GET_PRIVATE (act);
-    char* str = nullptr;
-    EgeAdjustmentDescr* marker = nullptr;
-    std::vector<EgeAdjustmentDescr*> cur = priv->descriptions;
-
-    for (auto descr:cur) {
-        gdouble delta = num - descr->value;
-        if ( delta < 0.0 ) {
-            delta = -delta;
-        }
-        if ( delta < priv->epsilon ) {
-            marker = descr;
-            break;
-        }
-    }
-
-    str = g_strdup_printf( priv->format, num,
-                           ((marker && marker->descr) ? ": " : ""),
-                           ((marker && marker->descr) ? marker->descr : ""));
-
-    auto rmi = new Gtk::RadioMenuItem(*group,Glib::ustring(str));
-    *dst = GTK_WIDGET(rmi->gobj());
-    if ( active ) {
-        gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(*dst), TRUE );
-    }
-    gtk_menu_shell_append( GTK_MENU_SHELL(menu), *dst );
-    g_object_set_qdata( G_OBJECT(*dst), gDataName, act );
-
-    g_signal_connect( G_OBJECT(*dst), "toggled", toggleCb, GINT_TO_POINTER(val) );
-
-    g_free(str);
-}
-
-static int flush_explicit_items( std::vector<EgeAdjustmentDescr*> descriptions,
-                                    int pos,
-                                    GCallback toggleCb,
-                                    int val,
-                                    GtkWidget* menu,
-                                    EgeAdjustmentAction* act,
-                                    GtkWidget** dst,
-                                    Gtk::RadioMenuItem::Group *group,
-                                    gdouble num )
-{
-    if(pos >= descriptions.size() || pos < 0) return pos;
-    EgeAdjustmentDescr* descr = descriptions[pos];
-    auto priv = EGE_ADJUSTMENT_ACTION_GET_PRIVATE (act);
-
-    gdouble valUpper = num + priv->epsilon;
-    gdouble valLower = num - priv->epsilon;
-
-    while ( pos>=0 && pos<descriptions.size() && descr && (descr->value >= valLower) ) {
-        if ( descr->value > valUpper ) {
-            create_single_menu_item( toggleCb, val + ( std::find(priv->descriptions.begin(),priv->descriptions.end(),descr) - priv->descriptions.begin() ) , menu, act, dst, group, descr->value, FALSE );
-        }
-        pos--;
-        descr = (pos<0) ? descriptions[pos] : nullptr;
-    }
-
-    return pos;
-}
-
-static GtkWidget* create_popup_number_menu( EgeAdjustmentAction* act )
-{
-    auto priv = EGE_ADJUSTMENT_ACTION_GET_PRIVATE (act);
-    GtkWidget* menu = gtk_menu_new();
-
-    Gtk::RadioMenuItem::Group group;
-    GtkWidget* single = nullptr;
-    std::vector<EgeAdjustmentDescr*> list = priv->descriptions;
-    int addOns = list.size() - 1;
-
-    gdouble base = gtk_adjustment_get_value( priv->adj );
-    gdouble lower = 0.0;
-    gdouble upper = 0.0;
-    gdouble step = 0.0;
-    gdouble page = 0.0;
-    g_object_get( G_OBJECT(priv->adj),
-                  "lower", &lower,
-                  "upper", &upper,
-                  "step-increment", &step,
-                  "page-increment", &page,
-                  NULL );
-
-
-    if ( base < upper ) {
-        addOns = flush_explicit_items( list, addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, upper );
-        create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_TOP, menu, act, &single, &group, upper, FALSE );
-        if ( (base + page) < upper ) {
-            addOns = flush_explicit_items( list, addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base + page );
-            create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_PAGE_UP, menu, act, &single, &group, base + page, FALSE );
-        }
-        if ( (base + step) < upper ) {
-            addOns = flush_explicit_items( list, addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base + step );
-            create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_UP, menu, act, &single, &group, base + step, FALSE );
-        }
-    }
-
-    addOns = flush_explicit_items( list, addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base );
-    create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_NONE, menu, act, &single, &group, base, TRUE );
-
-    if ( base > lower ) {
-        if ( (base - step) > lower ) {
-            addOns = flush_explicit_items( list, addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base - step );
-            create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_DOWN, menu, act, &single, &group, base - step, FALSE );
-        }
-        if ( (base - page) > lower ) {
-            addOns = flush_explicit_items( list, addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base - page );
-            create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_PAGE_DOWN, menu, act, &single, &group, base - page, FALSE );
-        }
-        addOns = flush_explicit_items( list, addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, lower );
-        create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_BOTTOM, menu, act, &single, &group, lower, FALSE );
-    }
-
-    if ( !priv->descriptions.empty() ) {
-        gdouble value = ((EgeAdjustmentDescr*)priv->descriptions[0])->value;
-        flush_explicit_items( list, addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, value );
-    }
-
-    return menu;
-}
-
-static GtkWidget* create_menu_item( GtkAction* action )
-{
-    GtkWidget* item = nullptr;
-
-    if ( IS_EGE_ADJUSTMENT_ACTION(action) ) {
-        EgeAdjustmentAction* act = EGE_ADJUSTMENT_ACTION( action );
-        GValue value;
-        GtkWidget*  subby = nullptr;
-
-        memset( &value, 0, sizeof(value) );
-        g_value_init( &value, G_TYPE_STRING );
-        g_object_get_property( G_OBJECT(action), "label", &value );
-
-        item = gtk_menu_item_new_with_label( g_value_get_string( &value ) );
-
-        subby = create_popup_number_menu( act );
-        gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), subby );
-        gtk_widget_show_all( subby );
-        g_value_unset( &value );
-    } else {
-        item = GTK_ACTION_CLASS(ege_adjustment_action_parent_class)->create_menu_item( action );
-    }
-
-    return item;
-}
-
-static void value_changed_cb( GtkSpinButton* spin, EgeAdjustmentAction* act )
-{
-    if ( gtk_widget_has_focus( GTK_WIDGET(spin) ) ) {
-        gint start = 0, end = 0;
-        if (GTK_IS_EDITABLE(spin) && gtk_editable_get_selection_bounds (GTK_EDITABLE(spin), &start, &end)
-                && start != end) {
-            // #167846, #363000 If the spin button has a selection, its probably
-            // because we got here from a Tab key from another spin, if so don't defocus
-            return;
-        }
-        ege_adjustment_action_defocus( act );
-    }
-}
-
-static gboolean event_cb( EgeAdjustmentAction* act, GdkEvent* evt )
-{
-    gboolean handled = FALSE;
-    if ( evt->type == GDK_BUTTON_PRESS ) {
-        if ( evt->button.button == 3 ) {
-            if ( IS_EGE_ADJUSTMENT_ACTION(act) ) {
-                GtkWidget* menu = create_popup_number_menu(act);
-                gtk_widget_show_all( menu );
-                gtk_menu_popup_at_pointer( GTK_MENU(menu), evt );
-            }
-            handled = TRUE;
-        }
-    }
-
-    return handled;
-}
-
-static GtkWidget* create_tool_item( GtkAction* action )
-{
-    GtkWidget* item = nullptr;
-
-    if ( IS_EGE_ADJUSTMENT_ACTION(action) ) {
-        EgeAdjustmentAction* act = EGE_ADJUSTMENT_ACTION( action );
-        auto priv = EGE_ADJUSTMENT_ACTION_GET_PRIVATE (act);
-        GtkWidget* spinbutton = nullptr;
-	auto hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
-	gtk_box_set_homogeneous(GTK_BOX(hb), FALSE);
-        GValue value;
-        memset( &value, 0, sizeof(value) );
-        g_value_init( &value, G_TYPE_STRING );
-        g_object_get_property( G_OBJECT(action), "short_label", &value );
-
-        if ( priv->appearanceMode == APPEARANCE_FULL ) {
-            /* Slider */
-            InkSpinScale* inkspinscale =
-              new InkSpinScale(Glib::wrap(priv->adj));
-            inkspinscale->set_label( g_value_get_string( &value ));
-            inkspinscale->set_digits(0);
-            spinbutton = (GtkWidget*)inkspinscale->gobj();
-            gtk_widget_set_size_request(spinbutton, 100, -1);
-
-        } else if ( priv->appearanceMode == APPEARANCE_MINIMAL ) {
-            spinbutton = gtk_scale_button_new( GTK_ICON_SIZE_MENU, 0, 100, 2, nullptr );
-            gtk_scale_button_set_adjustment( GTK_SCALE_BUTTON(spinbutton), priv->adj );
-            gtk_scale_button_set_icons( GTK_SCALE_BUTTON(spinbutton), floogles );
-        } else {
-            if ( gFactoryCb ) {
-                spinbutton = gFactoryCb( priv->adj, priv->climbRate, priv->digits, priv->unitTracker );
-            } else {
-                spinbutton = gtk_spin_button_new( priv->adj, priv->climbRate, priv->digits );
-            }
-        }
-
-        item = GTK_WIDGET( gtk_tool_item_new() );
-
-        {
-            GValue tooltip;
-            memset( &tooltip, 0, sizeof(tooltip) );
-            g_value_init( &tooltip, G_TYPE_STRING );
-            g_object_get_property( G_OBJECT(action), "tooltip", &tooltip );
-            const gchar* tipstr = g_value_get_string( &tooltip );
-            if ( tipstr && *tipstr ) {
-                gtk_widget_set_tooltip_text( spinbutton, tipstr );
-            }
-            g_value_unset( &tooltip );
-        }
-
-        if ( priv->appearanceMode != APPEARANCE_FULL ) {
-            GtkWidget* filler1 = gtk_label_new(" ");
-            gtk_box_pack_start( GTK_BOX(hb), filler1, FALSE, FALSE, 0 );
-
-            /* Use an icon if available or use short-label */
-            if ( priv->iconId && strcmp( priv->iconId, "" ) != 0 ) {
-                GtkWidget *icon = sp_get_icon_image(priv->iconId, priv->iconSize);
-                gtk_box_pack_start( GTK_BOX(hb), icon, FALSE, FALSE, 0 );
-            } else {
-                GtkWidget* lbl = gtk_label_new( g_value_get_string( &value ) ? g_value_get_string( &value ) : "wwww" );
-                gtk_widget_set_halign(lbl, GTK_ALIGN_END);
-                gtk_box_pack_start( GTK_BOX(hb), lbl, FALSE, FALSE, 0 );
-            }
-        }
-
-        if ( priv->appearanceMode == APPEARANCE_FULL ) {
-            gtk_box_pack_start( GTK_BOX(hb), spinbutton, TRUE, TRUE, 0 );
-        }  else {
-            gtk_box_pack_start( GTK_BOX(hb), spinbutton, FALSE, FALSE, 0 );
-        }
-
-        gtk_container_add( GTK_CONTAINER(item), hb );
-
-        if ( priv->selfId ) {
-            g_object_set_data( G_OBJECT(spinbutton), priv->selfId, spinbutton );
-        }
-
-        g_signal_connect( G_OBJECT(spinbutton), "focus-in-event", G_CALLBACK(focus_in_cb), action );
-        g_signal_connect( G_OBJECT(spinbutton), "focus-out-event", G_CALLBACK(focus_out_cb), action );
-        g_signal_connect( G_OBJECT(spinbutton), "key-press-event", G_CALLBACK(keypress_cb), action );
-
-        g_signal_connect( G_OBJECT(spinbutton), "value-changed", G_CALLBACK(value_changed_cb), action );
-
-        g_signal_connect_swapped( G_OBJECT(spinbutton), "event", G_CALLBACK(event_cb), action );
-        if ( priv->appearanceMode == APPEARANCE_FULL ) {
-            /* */
-        } else if ( priv->appearanceMode == APPEARANCE_MINIMAL ) {
-            /* */
-        } else {
-            gtk_entry_set_width_chars( GTK_ENTRY(spinbutton), priv->digits + 3 );
-        }
-
-        gtk_widget_show_all( item );
-
-        /* Shrink or whatnot after shown */
-        if ( priv->toolPost ) {
-            priv->toolPost( item );
-        }
-
-        g_value_unset( &value );
-    } else {
-        item = GTK_ACTION_CLASS(ege_adjustment_action_parent_class)->create_tool_item( action );
-    }
-
-    return item;
-}
-
-static void connect_proxy( GtkAction *action, GtkWidget *proxy )
-{
-    GTK_ACTION_CLASS(ege_adjustment_action_parent_class)->connect_proxy( action, proxy );
-}
-
-static void disconnect_proxy( GtkAction *action, GtkWidget *proxy )
-{
-    GTK_ACTION_CLASS(ege_adjustment_action_parent_class)->disconnect_proxy( action, proxy );
-}
-
-void ege_adjustment_action_defocus( EgeAdjustmentAction* action )
-{
-    auto priv = EGE_ADJUSTMENT_ACTION_GET_PRIVATE (action);
-    if ( priv->transferFocus ) {
-        if ( priv->focusWidget ) {
-            gtk_widget_grab_focus( priv->focusWidget );
-        }
-    }
-}
-
-gboolean focus_in_cb( GtkWidget *widget, GdkEventKey *event, gpointer data )
-{
-    (void)event;
-    if ( IS_EGE_ADJUSTMENT_ACTION(data) ) {
-        EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( data );
-        auto priv = EGE_ADJUSTMENT_ACTION_GET_PRIVATE (action);
-        if ( GTK_IS_SPIN_BUTTON(widget) ) {
-            priv->lastVal = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
-        } else if ( GTK_IS_SCALE_BUTTON(widget) ) {
-            priv->lastVal = gtk_scale_button_get_value( GTK_SCALE_BUTTON(widget) );
-        } else if (GTK_IS_RANGE(widget) ) {
-            priv->lastVal = gtk_range_get_value( GTK_RANGE(widget) );
-        }
-        priv->transferFocus = TRUE;
-    }
-
-    return FALSE; /* report event not consumed */
-}
-
-static gboolean focus_out_cb( GtkWidget *widget, GdkEventKey *event, gpointer data )
-{
-    (void)widget;
-    (void)event;
-    if ( IS_EGE_ADJUSTMENT_ACTION(data) ) {
-        EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( data );
-        auto priv = EGE_ADJUSTMENT_ACTION_GET_PRIVATE (action);
-        priv->transferFocus = FALSE;
-    }
-
-    return FALSE; /* report event not consumed */
-}
-
-
-static gboolean process_tab( GtkWidget* widget, int direction )
-{
-    gboolean handled = FALSE;
-    GtkWidget* parent = gtk_widget_get_parent(widget);
-    GtkWidget* gp = parent ? gtk_widget_get_parent(parent) : nullptr;
-    GtkWidget* ggp = gp ? gtk_widget_get_parent(gp) : nullptr;
-
-    if ( ggp && GTK_IS_TOOLBAR(ggp) ) {
-        std::vector<Gtk::Widget*> kids = Glib::wrap(GTK_CONTAINER(ggp))->get_children();
-        if ( !kids.empty() ) {
-            GtkWidget* curr = widget;
-            while ( curr && (gtk_widget_get_parent(curr) != ggp) ) {
-                curr = gtk_widget_get_parent( curr );
-            }
-            if ( curr ) {
-                std::vector<Gtk::Widget*>::iterator mid=kids.end();
-                for(auto i = kids.begin(); i!= kids.end(); ++i){
-                    if(curr == (*i)->gobj())
-                        mid = i;
-                }
-                while ( mid != kids.end() && !(mid==kids.begin() && direction<0 )  ) {
-                    mid = ( direction < 0 ) ? std::prev(mid) : ++mid;
-                    if ( mid!=kids.end() && GTK_IS_TOOL_ITEM((*mid)->gobj()) ) {
-                        /* potential target */
-                        GtkWidget* child = gtk_bin_get_child( GTK_BIN((*mid)->gobj()) );
-                        if ( child && GTK_IS_BOX(child) ) { /* could be ours */
-                            std::vector<Gtk::Widget*> subChildren = Glib::wrap(GTK_CONTAINER(child))->get_children();
-                            if ( ! subChildren.empty() ) {
-                                Gtk::Widget *last = subChildren[subChildren.size()-1];
-                                if ( GTK_IS_SPIN_BUTTON(last->gobj()) && gtk_widget_is_sensitive( GTK_WIDGET(last->gobj()) ) ) {
-                                    gtk_widget_grab_focus( GTK_WIDGET(last->gobj()) );
-                                    handled = TRUE;
-                                    mid = kids.end(); /* to stop loop */
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    return handled;
-}
-
-gboolean keypress_cb( GtkWidget *widget, GdkEventKey *event, gpointer data )
-{
-    gboolean wasConsumed = FALSE; /* default to report event not consumed */
-    EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION(data);
-    auto priv = EGE_ADJUSTMENT_ACTION_GET_PRIVATE (action);
-    guint key = 0;
-    gdk_keymap_translate_keyboard_state( Gdk::Display::get_default()->get_keymap(),
-                                         event->hardware_keycode, (GdkModifierType)event->state,
-                                         0, &key, nullptr, nullptr, nullptr );
-
-    switch ( key ) {
-        case GDK_KEY_Escape:
-        {
-            priv->transferFocus = TRUE;
-            gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), priv->lastVal );
-            ege_adjustment_action_defocus( action );
-            wasConsumed = TRUE;
-        }
-        break;
-
-        case GDK_KEY_Return:
-        case GDK_KEY_KP_Enter:
-        {
-            priv->transferFocus = TRUE;
-            ege_adjustment_action_defocus( action );
-            wasConsumed = TRUE;
-        }
-        break;
-
-        case GDK_KEY_Tab:
-        {
-            priv->transferFocus = FALSE;
-            wasConsumed = process_tab( widget, 1 );
-        }
-        break;
-
-        case GDK_KEY_ISO_Left_Tab:
-        {
-            priv->transferFocus = FALSE;
-            wasConsumed = process_tab( widget, -1 );
-        }
-        break;
-
-        case GDK_KEY_Up:
-        case GDK_KEY_KP_Up:
-        {
-            priv->transferFocus = FALSE;
-            gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
-            gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val + priv->step );
-            wasConsumed = TRUE;
-        }
-        break;
-
-        case GDK_KEY_Down:
-        case GDK_KEY_KP_Down:
-        {
-            priv->transferFocus = FALSE;
-            gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
-            gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val - priv->step );
-            wasConsumed = TRUE;
-        }
-        break;
-
-        case GDK_KEY_Page_Up:
-        case GDK_KEY_KP_Page_Up:
-        {
-            priv->transferFocus = FALSE;
-            gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
-            gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val + priv->page );
-            wasConsumed = TRUE;
-        }
-        break;
-
-        case GDK_KEY_Page_Down:
-        case GDK_KEY_KP_Page_Down:
-        {
-            priv->transferFocus = FALSE;
-            gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
-            gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val - priv->page );
-            wasConsumed = TRUE;
-        }
-        break;
-
-        case GDK_KEY_z:
-        case GDK_KEY_Z:
-        {
-            priv->transferFocus = FALSE;
-            gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), priv->lastVal );
-            wasConsumed = TRUE;
-        }
-        break;
-
-    }
-
-    return wasConsumed;
-}
-/*
-  Local Variables:
-  mode:c++
-  c-file-style:"stroustrup"
-  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
-  indent-tabs-mode:nil
-  fill-column:99
-  End:
-*/
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/ege-adjustment-action.h b/src/widgets/ege-adjustment-action.h
deleted file mode 100644
index 14229490c..000000000
--- a/src/widgets/ege-adjustment-action.h
+++ /dev/null
@@ -1,189 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later OR MPL-1.1 OR LGPL-2.1-or-later
-#ifndef SEEN_EGE_ADJUSTMENT_ACTION
-#define SEEN_EGE_ADJUSTMENT_ACTION
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is EGE Adjustment Action.
- *
- * The Initial Developer of the Original Code is
- * Jon A. Cruz.
- * Portions created by the Initial Developer are Copyright (C) 2006
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-/** \file
- *  GtkAction subclass that represents a GtkAdjustment value.
- */
-
-/* Note: this file should be kept compilable as both .cpp and .c */
-
-#include <gtk/gtk.h>
-
-G_BEGIN_DECLS
-
-
-#define EGE_ADJUSTMENT_ACTION_TYPE                ( ege_adjustment_action_get_type() )
-#define EGE_ADJUSTMENT_ACTION( obj )              ( G_TYPE_CHECK_INSTANCE_CAST( (obj), EGE_ADJUSTMENT_ACTION_TYPE, EgeAdjustmentAction) )
-#define EGE_ADJUSTMENT_ACTION_CLASS( klass )      ( G_TYPE_CHECK_CLASS_CAST( (klass), EGE_ADJUSTMENT_ACTION_TYPE, EgeAdjustmentActionClass) )
-#define IS_EGE_ADJUSTMENT_ACTION( obj )           ( G_TYPE_CHECK_INSTANCE_TYPE( (obj), EGE_ADJUSTMENT_ACTION_TYPE) )
-#define IS_EGE_ADJUSTMENT_ACTION_CLASS( klass )   ( G_TYPE_CHECK_CLASS_TYPE( (klass), EGE_ADJUSTMENT_ACTION_TYPE) )
-#define EGE_ADJUSTMENT_ACTION_GET_CLASS( obj )    ( G_TYPE_INSTANCE_GET_CLASS( (obj), EGE_ADJUSTMENT_ACTION_TYPE, EgeAdjustmentActionClass) )
-
-typedef struct _EgeAdjustmentAction      EgeAdjustmentAction;
-typedef struct _EgeAdjustmentActionClass EgeAdjustmentActionClass;
-
-namespace Inkscape {
-    namespace UI {
-        namespace Widget {
-            class UnitTracker;
-        }
-    }
-}
-
-/**
- * Instance structure of EgeAdjustmentAction.
- */
-struct _EgeAdjustmentAction
-{
-    /** Parent instance structure. */
-    GtkAction action;
-};
-
-/**
- * Class structure of EgeAdjustmentAction.
- */
-struct _EgeAdjustmentActionClass
-{
-    /** Parent class structure. */
-    GtkActionClass parent_class;
-};
-
-/** Standard Gtk type function */
-GType ege_adjustment_action_get_type( void );
-
-
-/*
- * Note: This normally could be implemented via a GType property for the class to construct,
- * but gtkmm classes implemented in C++ only will often not function properly.
- *
- */
-
-/** Callback type for widgets creation factory */
-typedef GtkWidget* (*EgeCreateAdjWidgetCB)( GtkAdjustment *adjustment, gdouble climb_rate, guint digits, Inkscape::UI::Widget::UnitTracker *unit_tracker );
-
-/**
- * Sets a factory callback to be used to create the specific widget.
- *
- * @param factoryCb the callback to use to create custom widgets, NULL to use the default.
- */
-void ege_adjustment_action_set_compact_tool_factory( EgeCreateAdjWidgetCB factoryCb );
-
-
-/**
- * Creates a new EgeAdjustmentAction instance.
- * This is a GtkAction subclass that manages a value stored in a
- * GtkAdjustment.
- *
- * @param adjustment The GtkAdjustment to manage.
- * @param name Functional name for the action.
- * @param label Display label for the action.
- * @param tooltip Tooltip for the action.
- * @param stock_id Icon id to use.
- * @param climb_rate Used for created widgets.
- * @param digits Used for created widgets.
- * @param unit_tracker Used to store unit.
- */
-EgeAdjustmentAction* ege_adjustment_action_new( GtkAdjustment* adjustment,
-                                                const gchar *name,
-                                                const gchar *label,
-                                                const gchar *tooltip,
-                                                const gchar *stock_id,
-                                                gdouble climb_rate,
-                                                guint digits,
-                                                Inkscape::UI::Widget::UnitTracker *unit_tracker
-                                                );
-/**
- * Returns a pointer to the GtkAdjustment represented by the given
- * EgeAdjustmentAction.
- *
- * @param action The action to fetch the GtkAdjustment for.
- */
-GtkAdjustment* ege_adjustment_action_get_adjustment( EgeAdjustmentAction* action );
-
-/**
- * Sets the GtkWidget to return focus to.
- * This is used to be able to transfer focus back out of a toolbar.
- *
- * @param action The action to set the widget for.
- * @param widget The widget to return focus to after editing.
- * @see ege_adjustment_action_get_focuswidget
- */
-void ege_adjustment_action_set_focuswidget( EgeAdjustmentAction* action, GtkWidget* widget );
-
-/**
- * Returns a pointer to the GtkWidget to return focus to after changing
- * the value.
- *
- * @param action The action to fetch the focus widget for.
- * @returns A pointer to the widget to return focus to, NULL if none set.
- * @see ege_adjustment_action_set_focuswidget
- */
-GtkWidget* ege_adjustment_action_get_focuswidget( EgeAdjustmentAction* action );
-
-/**
- * Set a list of values with labels to explicitly include in menus.
- *
- * @param action The action to set explicit entries for.
- * @param descriptions Array of descriptions to include.
- *          Descriptions will be matched one-for-one with numbers in the 'values' array.
- * @param values Array of values to include.
- *          Values will be matched one-for-one with numbers in the 'descriptions' array.
- * @param count Number of items in the 'descriptions' and 'values' arrays.
- */
-void ege_adjustment_action_set_descriptions( EgeAdjustmentAction* action, gchar const** descriptions, gdouble const* values, guint count );
-
-/**
- * Sets a hint to be used in determining the display form.
- * This is the XForms style 'appearance' hint: "full", "compact", "minimal".
- *
- * @param action The action to set the tooltip column for.
- * @param val The value of the appearance hint.
- */
-void ege_adjustment_action_set_appearance( EgeAdjustmentAction* action, gchar const* val );
-
-/** Callback type for post-creation 'fixup' pass on generated widgets */
-typedef void (*EgeWidgetFixup)(GtkWidget *widget);
-
-
-G_END_DECLS
-
-#endif /* SEEN_EGE_ADJUSTMENT_ACTION */
diff --git a/src/widgets/ink-comboboxentry-action.cpp b/src/widgets/ink-comboboxentry-action.cpp
deleted file mode 100644
index a49d5c2c3..000000000
--- a/src/widgets/ink-comboboxentry-action.cpp
+++ /dev/null
@@ -1,964 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- * A subclass of GtkAction that wraps a GtkComboBoxEntry.
- * Features:
- *   Setting GtkEntryBox width in characters.
- *   Passing a function for formatting cells.
- *   Displaying a warning if entry text isn't in list.
- *   Check comma separated values in text against list. (Useful for font-family fallbacks.)
- *   Setting names for GtkComboBoxEntry and GtkEntry (actionName_combobox, actionName_entry)
- *     to allow setting resources.
- *
- * Author(s):
- *   Tavmjong Bah
- *   Jon A. Cruz <jon@joncruz.org>
- *
- * Copyright (C) 2010 Authors
- *
- * Released under GNU GPL v2+, read the file 'COPYING' for more information.
- */
-
-/*
- * We must provide for both a toolbar item and a menu item.
- * As we don't know which widgets are used (or even constructed),
- * we must keep track of things like active entry ourselves.
- */
-
-#include <iostream>
-#include <cstring>
-#include <glibmm/ustring.h>
-
-#include <gtk/gtk.h>
-#include <gdk/gdkkeysyms.h>
-#include <gdkmm/display.h>
-
-#include "widgets/ink-comboboxentry-action.h"
-#include "ui/icon-names.h"
-
-// Must handle both tool and menu items!
-static GtkWidget* create_tool_item( GtkAction* action );
-static GtkWidget* create_menu_item( GtkAction* action );
-
-// Internal
-static gint get_active_row_from_text( Ink_ComboBoxEntry_Action* action, const gchar* target_text, gboolean exclude = false, gboolean ignore_case = false );
-static Glib::ustring check_comma_separated_text( Ink_ComboBoxEntry_Action* action );
-
-// Callbacks
-static void combo_box_changed_cb( GtkComboBox* widget, gpointer data );
-static void entry_activate_cb( GtkEntry* widget, gpointer data );
-static gboolean match_selected_cb( GtkEntryCompletion* widget, GtkTreeModel* model, GtkTreeIter* iter, gpointer data );
-static gboolean keypress_cb( GtkWidget *widget, GdkEventKey *event, gpointer data );
-
-enum {
-  PROP_MODEL = 1,
-  PROP_COMBOBOX,
-  PROP_ENTRY,
-  PROP_ENTRY_WIDTH,
-  PROP_EXTRA_WIDTH,
-  PROP_CELL_DATA_FUNC,
-  PROP_SEPARATOR_FUNC,
-  PROP_POPUP,
-  PROP_FOCUS_WIDGET
-};
-
-enum {
-  CHANGED = 0,
-  ACTIVATED,
-  N_SIGNALS
-};
-static guint signals[N_SIGNALS] = {0};
-
-static GQuark gDataName = 0;
-
-static void ink_comboboxentry_action_init (Ink_ComboBoxEntry_Action *action);
-static void ink_comboboxentry_action_class_init (Ink_ComboBoxEntry_ActionClass *klass);
-
-G_DEFINE_TYPE(Ink_ComboBoxEntry_Action, ink_comboboxentry_action, GTK_TYPE_ACTION);
-
-static void ink_comboboxentry_action_finalize (GObject *object)
-{
-  // Free any allocated resources.
-
-  G_OBJECT_CLASS (ink_comboboxentry_action_parent_class)->finalize (object);
-}
-
-
-static void ink_comboboxentry_action_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
-{
-  Ink_ComboBoxEntry_Action *action = INK_COMBOBOXENTRY_ACTION (object);
-
-  switch(property_id) {
-
-  case PROP_MODEL:
-    action->model = GTK_TREE_MODEL( g_value_get_object( value ));
-    break;
-
-  case PROP_COMBOBOX:
-    action->combobox = GTK_COMBO_BOX (g_value_get_object (value));
-    break;
-
-  case PROP_ENTRY:
-    action->entry = GTK_ENTRY( g_value_get_object( value ));
-    break;
-
-  case PROP_ENTRY_WIDTH:
-    action->entry_width = g_value_get_int( value );
-    break;
-
-  case PROP_EXTRA_WIDTH:
-    action->extra_width = g_value_get_int( value );
-    break;
-
-  case PROP_CELL_DATA_FUNC:
-    action->cell_data_func = g_value_get_pointer( value );
-    break;
-
-  case PROP_SEPARATOR_FUNC:
-    action->separator_func = g_value_get_pointer( value );
-    break;
-
-  case PROP_POPUP:
-    action->popup  = g_value_get_boolean( value );
-    break;
-
-  case PROP_FOCUS_WIDGET:
-   action->focusWidget = (GtkWidget*)g_value_get_pointer( value );
-   break;
-
-
-  default:
-    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
-  }
-}
-
-
-static void ink_comboboxentry_action_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec)
-{
-  Ink_ComboBoxEntry_Action *action = INK_COMBOBOXENTRY_ACTION (object);
-
-  switch(property_id) {
-
-  case PROP_MODEL:
-    g_value_set_object (value, action->model);
-    break;
-
-  case PROP_COMBOBOX:
-    g_value_set_object (value, action->combobox);
-    break;
-
-  case PROP_ENTRY:
-    g_value_set_object (value, action->entry);
-    break;
-
-  case PROP_ENTRY_WIDTH:
-    g_value_set_int (value, action->entry_width);
-    break;
-
-  case PROP_EXTRA_WIDTH:
-    g_value_set_int (value, action->extra_width);
-    break;
-
-  case PROP_CELL_DATA_FUNC:
-    g_value_set_pointer (value, action->cell_data_func);
-    break;
-
-  case PROP_SEPARATOR_FUNC:
-    g_value_set_pointer (value, action->separator_func);
-    break;
-
-  case PROP_POPUP:
-    g_value_set_boolean (value, action->popup);
-    break;
-
-  case PROP_FOCUS_WIDGET:
-    g_value_set_pointer (value, action->focusWidget);
-    break;
-
-
-  default:
-    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
-  }
-}
-
-static void
-ink_comboboxentry_action_connect_proxy (GtkAction *action,
-                                        GtkWidget *proxy)
-{
-  /* Override any proxy properties. */
-  //  if (GTK_IS_MENU_ITEM (proxy)) {
-  //  }
-
-  GTK_ACTION_CLASS (ink_comboboxentry_action_parent_class)->connect_proxy (action, proxy);
-}
-
-static void
-ink_comboboxentry_action_class_init (Ink_ComboBoxEntry_ActionClass *klass)
-{
-
-  GObjectClass     *gobject_class = G_OBJECT_CLASS (klass);
-  GtkActionClass *gtkaction_class = GTK_ACTION_CLASS (klass);
-
-  gtkaction_class->connect_proxy  = ink_comboboxentry_action_connect_proxy;
-
-  gobject_class->finalize      = ink_comboboxentry_action_finalize;
-  gobject_class->set_property  = ink_comboboxentry_action_set_property;
-  gobject_class->get_property  = ink_comboboxentry_action_get_property;
-
-  gDataName = g_quark_from_string("ink_comboboxentry-action");
-
-  klass->parent_class.create_tool_item = create_tool_item;
-  klass->parent_class.create_menu_item = create_menu_item;
-
-  g_object_class_install_property (
-                                   gobject_class,
-                                   PROP_MODEL,
-                                   g_param_spec_object ("model",
-                                                        "Tree Model",
-                                                        "Tree Model",
-                                                        GTK_TYPE_TREE_MODEL,
-                                                        (GParamFlags)G_PARAM_READWRITE));
-  g_object_class_install_property (
-                                   gobject_class,
-                                   PROP_COMBOBOX,
-                                   g_param_spec_object ("combobox",
-                                                        "GtkComboBoxEntry",
-                                                        "GtkComboBoxEntry",
-                                                        GTK_TYPE_WIDGET,
-                                                        (GParamFlags)G_PARAM_READABLE));
-  g_object_class_install_property (
-                                   gobject_class,
-                                   PROP_ENTRY,
-                                   g_param_spec_object ("entry",
-                                                        "GtkEntry",
-                                                        "GtkEntry",
-                                                        GTK_TYPE_WIDGET,
-                                                        (GParamFlags)G_PARAM_READABLE));
-  g_object_class_install_property (
-                                   gobject_class,
-                                   PROP_ENTRY_WIDTH,
-                                   g_param_spec_int ("entry_width",
-                                                     "EntryBox width",
-                                                     "EntryBox width (characters)",
-                                                     -1.0, 100, -1.0,
-                                                     (GParamFlags)G_PARAM_READWRITE));
-
-  g_object_class_install_property (
-                                   gobject_class,
-                                   PROP_EXTRA_WIDTH,
-                                   g_param_spec_int ("extra_width",
-                                                     "Extra width",
-                                                     "Extra width (px)",
-                                                     -1.0, 500, -1.0,
-                                                     (GParamFlags)G_PARAM_READWRITE));
-
-  g_object_class_install_property (
-                                   gobject_class,
-                                   PROP_CELL_DATA_FUNC,
-                                   g_param_spec_pointer ("cell_data_func",
-                                                         "Cell Data Func",
-                                                         "Cell Deta Function",
-                                                         (GParamFlags)G_PARAM_READWRITE));
-
-  g_object_class_install_property (
-                                   gobject_class,
-                                   PROP_SEPARATOR_FUNC,
-                                   g_param_spec_pointer ("separator_func",
-                                                         "Separator Func",
-                                                         "Separator Function",
-                                                         (GParamFlags)G_PARAM_READWRITE));
-
-  g_object_class_install_property (
-                                   gobject_class,
-                                   PROP_POPUP,
-                                   g_param_spec_boolean ("popup",
-                                                         "Entry Popup",
-                                                         "Entry Popup",
-                                                         false,
-                                                         (GParamFlags)G_PARAM_READWRITE));
-
-  g_object_class_install_property( gobject_class,
-                                   PROP_FOCUS_WIDGET,
-                                   g_param_spec_pointer( "focus-widget",
-                                                         "Focus Widget",
-                                                         "The widget to return focus to",
-                                                         (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
-
-  // We need to know when GtkComboBoxEvent or Menu ready for reading
-  signals[CHANGED] = g_signal_new( "changed",
-                                   G_TYPE_FROM_CLASS(klass),
-                                   G_SIGNAL_RUN_FIRST,
-                                   G_STRUCT_OFFSET(Ink_ComboBoxEntry_ActionClass, changed),
-                                   nullptr, nullptr,
-                                   g_cclosure_marshal_VOID__VOID,
-                                   G_TYPE_NONE, 0);
-
-  // Probably not needed... originally to keep track of key-presses.
-  signals[ACTIVATED] = g_signal_new( "activated",
-                                   G_TYPE_FROM_CLASS(klass),
-                                   G_SIGNAL_RUN_FIRST,
-                                   G_STRUCT_OFFSET(Ink_ComboBoxEntry_ActionClass, activated),
-                                   nullptr, nullptr,
-                                   g_cclosure_marshal_VOID__VOID,
-                                   G_TYPE_NONE, 0);
-
-}
-
-static void ink_comboboxentry_action_init (Ink_ComboBoxEntry_Action *action)
-{
-  action->active = -1;
-  action->text = strdup("");
-  action->entry_completion = nullptr;
-  action->indicator = nullptr;
-  action->popup = false;
-  action->info = nullptr;
-  action->info_cb = nullptr;
-  action->info_cb_id = 0;
-  action->info_cb_blocked = false;
-  action->warning = nullptr;
-  action->warning_cb = nullptr;
-  action->warning_cb_id = 0;
-  action->warning_cb_blocked = false;
-  action->altx_name = nullptr;
-  action->focusWidget = nullptr;
-}
-
-Ink_ComboBoxEntry_Action *ink_comboboxentry_action_new (const gchar   *name,
-                                                        const gchar   *label,
-                                                        const gchar   *tooltip,
-                                                        const gchar   *stock_id,
-                                                        GtkTreeModel  *model,
-                                                        gint           entry_width,
-                                                        gint           extra_width,
-                                                        void          *cell_data_func,
-                                                        void          *separator_func,
-                                                        GtkWidget      *focusWidget)
-{
-  g_return_val_if_fail (name != nullptr, NULL);
-
-  return (Ink_ComboBoxEntry_Action*)g_object_new (INK_COMBOBOXENTRY_TYPE_ACTION,
-                                                  "name",           name,
-                                                  "label",          label,
-                                                  "tooltip",        tooltip,
-                                                  "stock-id",       stock_id,
-                                                  "model",          model,
-                                                  "entry_width",    entry_width,
-                                                  "extra_width",    extra_width,
-                                                  "cell_data_func", cell_data_func,
-                                                  "separator_func", separator_func,
-                                                  "focus-widget",   focusWidget,
-                                                  NULL);
-}
-
-// Create a widget for a toolbar.
-GtkWidget* create_tool_item( GtkAction* action )
-{
-  GtkWidget* item = nullptr;
-
-  if ( INK_COMBOBOXENTRY_IS_ACTION( action ) && INK_COMBOBOXENTRY_ACTION(action)->model ) {
-
-    Ink_ComboBoxEntry_Action* ink_comboboxentry_action = INK_COMBOBOXENTRY_ACTION( action );
-
-    gchar *action_name = g_strdup( gtk_action_get_name( action ) );
-    gchar *combobox_name = g_strjoin( nullptr, action_name, "_combobox", NULL );
-    gchar *entry_name =    g_strjoin( nullptr, action_name, "_entry", NULL );
-    g_free( action_name );
-
-    item = GTK_WIDGET( gtk_tool_item_new() );
-
-    GtkWidget* comboBoxEntry = gtk_combo_box_new_with_model_and_entry (ink_comboboxentry_action->model);
-    gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (comboBoxEntry), 0);
-
-    // Name it so we can muck with it using an RC file
-    gtk_widget_set_name( comboBoxEntry, combobox_name );
-    g_free( combobox_name );
-
-    {
-        gtk_widget_set_halign(comboBoxEntry, GTK_ALIGN_START);
-        gtk_widget_set_hexpand(comboBoxEntry, FALSE);
-        gtk_widget_set_vexpand(comboBoxEntry, FALSE);
-        gtk_container_add(GTK_CONTAINER(item), comboBoxEntry);
-    }
-
-    ink_comboboxentry_action->combobox = GTK_COMBO_BOX (comboBoxEntry);
-
-    //gtk_combo_box_set_active( GTK_COMBO_BOX( comboBoxEntry ), ink_comboboxentry_action->active );
-    gtk_combo_box_set_active( GTK_COMBO_BOX( comboBoxEntry ), 0 );
-
-    g_signal_connect( G_OBJECT(comboBoxEntry), "changed", G_CALLBACK(combo_box_changed_cb), action );
-
-    // Optionally add separator function...
-    if( ink_comboboxentry_action->separator_func != nullptr ) {
-       gtk_combo_box_set_row_separator_func( ink_comboboxentry_action->combobox,
-					    GtkTreeViewRowSeparatorFunc (ink_comboboxentry_action->separator_func),
-      					    nullptr, nullptr );
-    }
-
-    // FIXME: once gtk3 migration is done this can be removed
-    // https://bugzilla.gnome.org/show_bug.cgi?id=734915
-    gtk_widget_show_all (comboBoxEntry);
-
-    // Optionally add formatting...
-    if( ink_comboboxentry_action->cell_data_func != nullptr ) {
-      GtkCellRenderer *cell = gtk_cell_renderer_text_new();
-      gtk_cell_layout_clear( GTK_CELL_LAYOUT( comboBoxEntry ) );
-      gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( comboBoxEntry ), cell, true );
-      gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT( comboBoxEntry ), cell,
-                                          GtkCellLayoutDataFunc (ink_comboboxentry_action->cell_data_func),
-                                          nullptr, nullptr );
-    }
-
-    // Optionally widen the combobox width... which widens the drop-down list in list mode.
-    if( ink_comboboxentry_action->extra_width > 0 ) {
-      GtkRequisition req;
-      gtk_widget_get_preferred_size(GTK_WIDGET(ink_comboboxentry_action->combobox), &req, nullptr);
-      gtk_widget_set_size_request( GTK_WIDGET( ink_comboboxentry_action->combobox ),
-				   req.width + ink_comboboxentry_action->extra_width, -1 );
-    }
-
-    // Get reference to GtkEntry and fiddle a bit with it.
-    GtkWidget *child = gtk_bin_get_child( GTK_BIN(comboBoxEntry) );
-
-    // Name it so we can muck with it using an RC file
-    gtk_widget_set_name( child, entry_name );
-    g_free( entry_name );
-
-    if( child && GTK_IS_ENTRY( child ) ) {
-
-      ink_comboboxentry_action->entry = GTK_ENTRY(child);
-
-      // Change width
-      if( ink_comboboxentry_action->entry_width > 0 ) {
-          gtk_entry_set_width_chars (GTK_ENTRY (child), ink_comboboxentry_action->entry_width );
-      }
-
-      // Add pop-up entry completion if required
-      if( ink_comboboxentry_action->popup ) {
-          ink_comboboxentry_action_popup_enable( ink_comboboxentry_action );
-      }
-
-      // Add altx_name if required
-      if( ink_comboboxentry_action->altx_name ) {
-          g_object_set_data( G_OBJECT( child ), ink_comboboxentry_action->altx_name, ink_comboboxentry_action->entry );
-      }
-
-      // Add signal for GtkEntry to check if finished typing.
-      g_signal_connect( G_OBJECT(child), "activate", G_CALLBACK(entry_activate_cb), action );
-      g_signal_connect( G_OBJECT(child), "key-press-event", G_CALLBACK(keypress_cb), action );
-    }
-
-    gtk_activatable_set_related_action( GTK_ACTIVATABLE (item), GTK_ACTION( action ) );
-    gtk_widget_show_all( item );
-
-  } else {
-
-    item = GTK_ACTION_CLASS(ink_comboboxentry_action_parent_class)->create_tool_item( action );
-
-  }
-
-  return item;
-}
-
-// Create a drop-down menu.
-GtkWidget* create_menu_item( GtkAction* action )
-{
-  GtkWidget* item = nullptr;
-
-    item = GTK_ACTION_CLASS(ink_comboboxentry_action_parent_class)->create_menu_item( action );
-    g_warning( "ink_comboboxentry_action: create_menu_item not implemented" );
-    // One can easily modify ege-select-one-action routine to implement this.
-  return item;
-}
-
-// Setters/Getters ---------------------------------------------------
-
-GtkTreeModel *ink_comboboxentry_action_get_model( Ink_ComboBoxEntry_Action* action ) {
-
-  return action->model;
-}
-
-GtkComboBox *ink_comboboxentry_action_get_comboboxentry( Ink_ComboBoxEntry_Action* action ) {
-
-  return action->combobox;
-}
-
-gchar* ink_comboboxentry_action_get_active_text( Ink_ComboBoxEntry_Action* action ) {
-
-  gchar* text = g_strdup( action->text );
-  return text;
-}
-
-/*
- * For the font-family list we need to handle two cases:
- *   Text is in list store:
- *     In this case we use row number as the font-family list can have duplicate
- *     entries, one in the document font part and one in the system font part. In
- *     order that scrolling through the list works properly we must distinguish
- *     between the two.
- *   Text is not in the list store (i.e. default font-family is not on system):
- *     In this case we have a row number of -1, and the text must be set by hand.
- */
-gboolean ink_comboboxentry_action_set_active_text( Ink_ComboBoxEntry_Action* action, const gchar* text, int row ) {
-
-  if( strcmp( action->text, text ) != 0 ) { 
-    g_free( action->text );
-    action->text = g_strdup( text );
-  }
-
-  // Get active row or -1 if none
-  if( row < 0 ) {
-    row = get_active_row_from_text( action, action->text );
-  }
-  action->active = row;
-
-  // Set active row, check that combobox has been created.
-  if( action->combobox ) {
-    gtk_combo_box_set_active( GTK_COMBO_BOX( action->combobox ), action->active );
-  }
-
-  // Fiddle with entry
-  if( action->entry ) {
-
-    // Explicitly set text in GtkEntry box (won't be set if text not in list).
-    gtk_entry_set_text( action->entry, text );
-
-    // Show or hide warning  -- this might be better moved to text-toolbox.cpp
-    if( action->info_cb_id != 0 &&
-	!action->info_cb_blocked ) {
-      g_signal_handler_block (G_OBJECT(action->entry),
-			      action->info_cb_id );
-      action->info_cb_blocked = true;
-    }
-    if( action->warning_cb_id != 0 &&
-	!action->warning_cb_blocked ) {
-      g_signal_handler_block (G_OBJECT(action->entry),
-			      action->warning_cb_id );
-      action->warning_cb_blocked = true;
-    }
-
-    bool set = false;
-    if( action->warning != nullptr ) {
-      Glib::ustring missing = check_comma_separated_text( action );
-      if( !missing.empty() ) {
-	  gtk_entry_set_icon_from_icon_name( action->entry,
-					     GTK_ENTRY_ICON_SECONDARY,
-					     INKSCAPE_ICON("dialog-warning") );
-	// Can't add tooltip until icon set
-	Glib::ustring warning = action->warning;
-	warning += ": ";
-	warning += missing;
-	gtk_entry_set_icon_tooltip_text( action->entry,
-					 GTK_ENTRY_ICON_SECONDARY,
-					 warning.c_str() );
-
-	if( action->warning_cb ) {
-
-	  // Add callback if we haven't already
-	  if( action->warning_cb_id == 0 ) {
-	    action->warning_cb_id =
-	      g_signal_connect( G_OBJECT(action->entry),
-				"icon-press",
-				G_CALLBACK(action->warning_cb),
-				action);
-	  }
-	  // Unblock signal
-	  if( action->warning_cb_blocked ) {
-	    g_signal_handler_unblock (G_OBJECT(action->entry),
-				      action->warning_cb_id );
-	    action->warning_cb_blocked = false;
-	  }
-	}
-	set = true;
-      }
-    }
- 
-    if( !set && action->info != nullptr ) {
-      gtk_entry_set_icon_from_icon_name( GTK_ENTRY(action->entry),
-					 GTK_ENTRY_ICON_SECONDARY,
-					 INKSCAPE_ICON("edit-select-all") );
-      gtk_entry_set_icon_tooltip_text( action->entry,
-				       GTK_ENTRY_ICON_SECONDARY,
-				       action->info );
-
-      if( action->info_cb ) {
-	// Add callback if we haven't already
-	if( action->info_cb_id == 0 ) {
-	  action->info_cb_id =
-	    g_signal_connect( G_OBJECT(action->entry),
-			      "icon-press",
-			      G_CALLBACK(action->info_cb),
-			      action);
-	}
-	// Unblock signal
-	if( action->info_cb_blocked ) {
-	  g_signal_handler_unblock (G_OBJECT(action->entry),
-				    action->info_cb_id );
-	  action->info_cb_blocked = false;
-	}
-      }
-      set = true;
-    }
-
-    if( !set ) {
-      gtk_entry_set_icon_from_icon_name( GTK_ENTRY(action->entry),
-					 GTK_ENTRY_ICON_SECONDARY,
-					 nullptr );
-    }
-  }
-
-  // Return if active text in list
-  gboolean found = ( action->active != -1 );
-  return found;
-}
-
-void ink_comboboxentry_action_set_entry_width( Ink_ComboBoxEntry_Action* action, gint entry_width ) {
-
-  action->entry_width = entry_width;
-
-  // Widget may not have been created....
-  if( action->entry ) {
-    gtk_entry_set_width_chars( GTK_ENTRY(action->entry), entry_width );
-  }
-}
-
-void ink_comboboxentry_action_set_extra_width( Ink_ComboBoxEntry_Action* action, gint extra_width ) {
-
-  action->extra_width = extra_width;
-
-  // Widget may not have been created....
-  if( action->combobox ) {
-    GtkRequisition req;
-    gtk_widget_get_preferred_size(GTK_WIDGET(action->combobox), &req, nullptr);
-    gtk_widget_set_size_request( GTK_WIDGET( action->combobox ), req.width + action->extra_width, -1 );
-  }
-}
-
-void ink_comboboxentry_action_popup_enable( Ink_ComboBoxEntry_Action* action ) {
-
-  action->popup = true;
-
-  // Widget may not have been created....
-  if( action->entry ) {
-
-    // Check we don't already have a GtkEntryCompletion
-    if( action->entry_completion ) return;
-
-    action->entry_completion = gtk_entry_completion_new();
-
-    gtk_entry_set_completion( action->entry, action->entry_completion );
-    gtk_entry_completion_set_model( action->entry_completion, action->model );
-    gtk_entry_completion_set_text_column( action->entry_completion, 0 );
-    gtk_entry_completion_set_popup_completion( action->entry_completion, true );
-    gtk_entry_completion_set_inline_completion( action->entry_completion, false );
-    gtk_entry_completion_set_inline_selection( action->entry_completion, true );
-
-    g_signal_connect (G_OBJECT (action->entry_completion),  "match-selected", G_CALLBACK (match_selected_cb), action );
-
-
-  }
-}
-
-void ink_comboboxentry_action_popup_disable( Ink_ComboBoxEntry_Action* action ) {
-
-  action->popup = false;
-
-  if( action->entry_completion ) {
-    gtk_widget_destroy(GTK_WIDGET(action->entry_completion));
-    action->entry_completion = nullptr;
-  }
-}
-void     ink_comboboxentry_action_set_tooltip( Ink_ComboBoxEntry_Action* action, const gchar* tooltip ) {
-
-  // Widget may not have been created....
-  if( action->entry ) {
-      gtk_widget_set_tooltip_text ( GTK_WIDGET(action->entry), tooltip);
-  }
-  if( action->combobox ) {
-      gtk_widget_set_tooltip_text ( GTK_WIDGET(action->combobox), tooltip);
-  }
-
-}
-
-void     ink_comboboxentry_action_set_info( Ink_ComboBoxEntry_Action* action, const gchar* info ) {
-
-  g_free( action->info );
-  action->info = g_strdup( info );
-
-  // Widget may not have been created....
-  if( action->entry ) {
-    gtk_entry_set_icon_tooltip_text( GTK_ENTRY(action->entry),
-                                     GTK_ENTRY_ICON_SECONDARY,
-                                     action->info );
-  }
-}
-
-void     ink_comboboxentry_action_set_info_cb( Ink_ComboBoxEntry_Action* action, gpointer info_cb ) {
-
-  action->info_cb = info_cb;
-}
-
-void     ink_comboboxentry_action_set_warning( Ink_ComboBoxEntry_Action* action, const gchar* warning ) {
-
-  g_free( action->warning );
-  action->warning = g_strdup( warning );
-
-  // Widget may not have been created....
-  if( action->entry ) {
-    gtk_entry_set_icon_tooltip_text( GTK_ENTRY(action->entry),
-                                     GTK_ENTRY_ICON_SECONDARY,
-                                     action->warning );
-  }
-}
-
-void     ink_comboboxentry_action_set_warning_cb( Ink_ComboBoxEntry_Action* action, gpointer warning_cb ) {
-
-  action->warning_cb = warning_cb;
-}
-
-void     ink_comboboxentry_action_set_altx_name( Ink_ComboBoxEntry_Action* action, const gchar* altx_name ) {
-
-  g_free( action->altx_name );
-  action->altx_name = g_strdup( altx_name );
-
-  // Widget may not have been created....
-  if( action->entry ) {
-    g_object_set_data( G_OBJECT(action->entry), action->altx_name, action->entry );
-  }
-}
-
-// Internal ---------------------------------------------------
-
-// Return row of active text or -1 if not found. If exclude is true,
-// use 3d colunm if available to exclude row from checking (useful to
-// skip rows added for font-families included in doc and not on
-// system)
-gint get_active_row_from_text( Ink_ComboBoxEntry_Action* action, const gchar* target_text,
-			       gboolean exclude, gboolean ignore_case ) {
-
-  // Check if text in list
-  gint row = 0;
-  gboolean found = false;
-  GtkTreeIter iter;
-  gboolean valid = gtk_tree_model_get_iter_first( action->model, &iter );
-  while ( valid ) {
-
-    // See if we should exclude a row
-    gboolean check = true;  // If true, font-family is on system.
-    if( exclude && gtk_tree_model_get_n_columns( action->model ) > 2 ) {
-      gtk_tree_model_get( action->model, &iter, 2, &check, -1 );
-    }
-
-    if( check ) {
-      // Get text from list entry
-      gchar* text = nullptr;
-      gtk_tree_model_get( action->model, &iter, 0, &text, -1 ); // Column 0
-
-      if( !ignore_case ) {
-	// Case sensitive compare
-	if( strcmp( target_text, text ) == 0 ){
-	  found = true;
-	  break;
-	}
-      } else {
-	// Case insensitive compare
-	gchar* target_text_casefolded = g_utf8_casefold( target_text, -1 );
-	gchar* text_casefolded        = g_utf8_casefold( text, -1 );
-	gboolean equal = (strcmp( target_text_casefolded, text_casefolded ) == 0 );
-	g_free( text_casefolded );
-	g_free( target_text_casefolded );
-	if( equal ) {
-	  found = true;
-	  break;
-	}
-      }
-    }
-
-    ++row;
-    valid = gtk_tree_model_iter_next( action->model, &iter );
-  }
-
-  if( !found ) row = -1;
-
-  return row;
-
-}
-
-// Checks if all comma separated text fragments are in the list and
-// returns a ustring with a list of missing fragments.
-// This is useful for checking if all fonts in a font-family fallback
-// list are available on the system.
-//
-// This routine could also create a Pango Markup string to show which
-// fragments are invalid in the entry box itself. See:
-// http://developer.gnome.org/pango/stable/PangoMarkupFormat.html
-// However... it appears that while one can retrieve the PangoLayout
-// for a GtkEntry box, it is only a copy and changing it has no effect.
-//   PangoLayout * pl = gtk_entry_get_layout( entry );
-//   pango_layout_set_markup( pl, "NEW STRING", -1 ); // DOESN'T WORK
-static Glib::ustring check_comma_separated_text( Ink_ComboBoxEntry_Action* action ) {
-
-  Glib::ustring missing;
-
-  // Parse fallback_list using a comma as deliminator
-  gchar** tokens = g_strsplit( action->text, ",", 0 );
-
-  gint i = 0;
-  while( tokens[i] != nullptr ) {
-
-    // Remove any surrounding white space.
-    g_strstrip( tokens[i] );
-
-    if( get_active_row_from_text( action, tokens[i], true, true ) == -1 ) {
-      missing += tokens[i];
-      missing += ", ";
-    }
-    ++i;
-  }
-  g_strfreev( tokens );
-
-  // Remove extra comma and space from end.
-  if( missing.size() >= 2 ) {
-    missing.resize( missing.size()-2 );
-  }
-  return missing;
-}
-
-// Callbacks ---------------------------------------------------
-
-static void combo_box_changed_cb( GtkComboBox* widget, gpointer data ) {
-
-  // Two things can happen to get here:
-  //   An item is selected in the drop-down menu.
-  //   Text is typed.
-  // We only react here if an item is selected.
-
-  // Get action
-  Ink_ComboBoxEntry_Action *action = INK_COMBOBOXENTRY_ACTION( data );
-
-  // Check if item selected:
-  gint newActive = gtk_combo_box_get_active(widget);
-  if( newActive >= 0 && newActive != action->active ) {
-
-    action->active = newActive;
-
-    GtkTreeIter iter;
-    if( gtk_combo_box_get_active_iter( GTK_COMBO_BOX( action->combobox ), &iter ) ) {
-
-      gchar* text = nullptr;
-      gtk_tree_model_get( action->model, &iter, 0, &text, -1 );
-      gtk_entry_set_text( action->entry, text );
-
-      g_free( action->text );
-      action->text = text;
-    }
-
-    // Now let the world know
-    g_signal_emit( G_OBJECT(action), signals[CHANGED], 0 );
-  }
-}
-
-static void entry_activate_cb( GtkEntry* widget, gpointer data ) {
-
-  // Get text from entry box.. check if it matches a menu entry.
-
-  // Get action
-  Ink_ComboBoxEntry_Action *action = INK_COMBOBOXENTRY_ACTION( data );
-
-  // Get text
-  g_free( action->text );
-  action->text = g_strdup( gtk_entry_get_text( widget ) );
-
-  // Get row
-  action->active =
-    get_active_row_from_text( action, action->text );
-
-  // Set active row
-  gtk_combo_box_set_active( GTK_COMBO_BOX( action->combobox), action->active );
-
-  // Now let the world know
-  g_signal_emit( G_OBJECT(action), signals[CHANGED], 0 );
-
-}
-
-static gboolean match_selected_cb( GtkEntryCompletion* /*widget*/, GtkTreeModel* model, GtkTreeIter* iter, gpointer data )
-{
-  // Get action
-  Ink_ComboBoxEntry_Action *action = INK_COMBOBOXENTRY_ACTION( data );
-  GtkEntry *entry = action->entry;
-
-  if( entry) {
-    gchar *family = nullptr;
-    gtk_tree_model_get(model, iter, 0, &family, -1);
-
-    // Set text in GtkEntry
-    gtk_entry_set_text (GTK_ENTRY (entry), family );
-
-    // Set text in GtkAction
-    g_free( action->text );
-    action->text = family;
-
-    // Get row
-    action->active =
-      get_active_row_from_text( action, action->text );
-
-    // Set active row
-    gtk_combo_box_set_active( GTK_COMBO_BOX( action->combobox), action->active );
-
-    // Now let the world know
-    g_signal_emit( G_OBJECT(action), signals[CHANGED], 0 );
-
-    return true;
-  }
-  return false;
-}
-
-static void ink_comboboxentry_action_defocus( Ink_ComboBoxEntry_Action* action )
-{
-    if ( action->focusWidget ) {
-        gtk_widget_grab_focus( action->focusWidget );
-    }
-}
-
-gboolean keypress_cb( GtkWidget * /*widget*/, GdkEventKey *event, gpointer data )
-{
-    gboolean wasConsumed = FALSE; /* default to report event not consumed */
-    guint key = 0;
-    Ink_ComboBoxEntry_Action* action = INK_COMBOBOXENTRY_ACTION( data );
-    gdk_keymap_translate_keyboard_state( Gdk::Display::get_default()->get_keymap(),
-                                         event->hardware_keycode, (GdkModifierType)event->state,
-                                         0, &key, nullptr, nullptr, nullptr );
-
-    switch ( key ) {
-
-        // TODO Add bindings for Tab/LeftTab
-        case GDK_KEY_Escape:
-        {
-            //gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), action->private_data->lastVal );
-            ink_comboboxentry_action_defocus( action );
-            wasConsumed = TRUE;
-        }
-        break;
-
-        case GDK_KEY_Return:
-        case GDK_KEY_KP_Enter:
-        {
-            ink_comboboxentry_action_defocus( action );
-            //wasConsumed = TRUE;
-        }
-        break;
-
-
-    }
-
-    return wasConsumed;
-}
-
-/*
-  Local Variables:
-  mode:c++
-  c-file-style:"stroustrup"
-  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
-  indent-tabs-mode:nil
-  fill-column:99
-  End:
-*/
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/ink-comboboxentry-action.h b/src/widgets/ink-comboboxentry-action.h
deleted file mode 100644
index fa7dd5cdf..000000000
--- a/src/widgets/ink-comboboxentry-action.h
+++ /dev/null
@@ -1,107 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- * A subclass of GtkAction that wraps a GtkComboBoxEntry.
- * Features:
- *   Setting GtkEntryBox width in characters.
- *   Passing a function for formatting cells.
- *   Displaying a warning if text isn't in list.
- *   Setting names for GtkComboBoxEntry and GtkEntry (actionName_combobox, actionName_entry)
- *     to allow setting resources.
- *
- * Author(s):
- *   Tavmjong Bah
- *   Jon A. Cruz <jon@joncruz.org>
- *
- * Copyright (C) 2010 Authors
- *
- * Released under GNU GPL v2+, read the file 'COPYING' for more information.
- */
-
-#ifndef SEEN_INK_COMBOBOXENTRY_ACTION
-#define SEEN_INK_COMBOBOXENTRY_ACTION
-
-#include <gtk/gtk.h>
-
-#define INK_COMBOBOXENTRY_TYPE_ACTION           (ink_comboboxentry_action_get_type())
-#define INK_COMBOBOXENTRY_ACTION(obj)           (G_TYPE_CHECK_INSTANCE_CAST ((obj), INK_COMBOBOXENTRY_TYPE_ACTION, Ink_ComboBoxEntry_Action))
-#define INK_COMBOBOXENTRY_ACTION_CLASS(klass)   (G_TYPE_CHECK_CLASS_CAST ((klass),  INK_COMBOBOXENTRY_TYPE_ACTION, Ink_ComboBoxEntry_ActionClass))
-#define INK_COMBOBOXENTRY_IS_ACTION(obj)        (G_TYPE_CHECK_INSTANCE_TYPE ((obj), INK_COMBOBOXENTRY_TYPE_ACTION))
-#define INK_COMBOBOXENTRY_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),  INK_COMBOBOXENTRY_TYPE_ACTION, Ink_ComboBoxEntry_ActionClass))
-
-typedef struct _Ink_ComboBoxEntry_ActionClass Ink_ComboBoxEntry_ActionClass;
-typedef struct _Ink_ComboBoxEntry_Action      Ink_ComboBoxEntry_Action;
-
-struct _Ink_ComboBoxEntry_ActionClass {
-  GtkActionClass parent_class;
-
-  void (*changed)   (Ink_ComboBoxEntry_Action* action);
-  void (*activated) (Ink_ComboBoxEntry_Action* action);
-};
-
-struct _Ink_ComboBoxEntry_Action {
-  GtkAction parent_instance;
-
-  GtkTreeModel       *model;
-  GtkComboBox        *combobox;
-  GtkEntry           *entry;
-  GtkEntryCompletion *entry_completion;
-  GtkWidget          *indicator;
-
-  gpointer            cell_data_func; // drop-down menu format
-  gpointer            separator_func;
-
-  gint                active;     // Index of active menu item (-1 if not in list).
-  gchar              *text;       // Text of active menu item or entry box.
-  gint                entry_width;// Width of GtkEntry in characters.
-  gint                extra_width;// Extra Width of GtkComboBox.. to widen drop-down list in list mode.
-  gboolean            popup;      // Do we pop-up an entry-completion dialog?
-  gchar              *info;       // Text for tooltip info about entry.
-  gpointer            info_cb;    // Callback for clicking info icon.
-  gint                info_cb_id;
-  gboolean            info_cb_blocked;
-  gchar              *warning;    // Text for tooltip warning that entry isn't in list.
-  gpointer            warning_cb; // Callback for clicking warning icon.
-  gint                warning_cb_id;
-  gboolean            warning_cb_blocked;
-  gchar              *altx_name;  // Target for Alt-X keyboard shortcut.
-  GtkWidget          *focusWidget;
-};
-
-
-GType ink_comboboxentry_action_get_type ();
-
-/**
- * Creates a GtkAction subclass that wraps a GtkComboBoxEntry object.
- */
-Ink_ComboBoxEntry_Action *ink_comboboxentry_action_new ( const gchar  *name,
-							 const gchar  *label,
-							 const gchar  *tooltip,
-							 const gchar  *stock_id,
-							 GtkTreeModel *model,
-							 gint          entry_width = -1,
-							 gint          extra_width = -1,
-							 gpointer cell_data_func = nullptr,
-							 gpointer separator_func = nullptr,
-							 GtkWidget* focusWidget = nullptr);
-
-GtkTreeModel     *ink_comboboxentry_action_get_model( Ink_ComboBoxEntry_Action* action );
-GtkComboBox      *ink_comboboxentry_action_get_comboboxentry( Ink_ComboBoxEntry_Action* action );
-
-gchar*   ink_comboboxentry_action_get_active_text( Ink_ComboBoxEntry_Action* action );
-gboolean ink_comboboxentry_action_set_active_text( Ink_ComboBoxEntry_Action* action, const gchar* text, int row=-1 );
-
-void     ink_comboboxentry_action_set_entry_width( Ink_ComboBoxEntry_Action* action, gint entry_width );
-void     ink_comboboxentry_action_set_extra_width( Ink_ComboBoxEntry_Action* action, gint extra_width );
-
-void     ink_comboboxentry_action_popup_enable(  Ink_ComboBoxEntry_Action* action );
-void     ink_comboboxentry_action_popup_disable( Ink_ComboBoxEntry_Action* action );
-
-void     ink_comboboxentry_action_set_info(      Ink_ComboBoxEntry_Action* action, const gchar* info );
-void     ink_comboboxentry_action_set_info_cb(   Ink_ComboBoxEntry_Action* action, gpointer info_cb );
-void     ink_comboboxentry_action_set_warning(   Ink_ComboBoxEntry_Action* action, const gchar* warning_cb );
-void     ink_comboboxentry_action_set_warning_cb(Ink_ComboBoxEntry_Action* action, gpointer warning );
-void     ink_comboboxentry_action_set_tooltip(   Ink_ComboBoxEntry_Action* action, const gchar* tooltip );
-
-void     ink_comboboxentry_action_set_altx_name( Ink_ComboBoxEntry_Action* action, const gchar* altx_name );
-
-#endif /* SEEN_INK_COMBOBOXENTRY_ACTION */
diff --git a/src/widgets/toolbox.cpp b/src/widgets/toolbox.cpp
index b3f25c764..10a24a0d1 100644
--- a/src/widgets/toolbox.cpp
+++ b/src/widgets/toolbox.cpp
@@ -60,7 +60,6 @@
 #include "ui/widget/style-swatch.h"
 #include "ui/widget/unit-tracker.h"
 
-#include "widgets/ege-adjustment-action.h"
 #include "widgets/spinbutton-events.h"
 #include "widgets/spw-utilities.h"
 #include "widgets/widget-sizes.h"
@@ -182,63 +181,64 @@ static struct {
     gchar const *type_name;
     gchar const *data_name;
     GtkWidget *(*create_func)(SPDesktop *desktop);
-    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", Inkscape::UI::Toolbar::SelectToolbar::create, nullptr,           "SelectToolbar",
-      SP_VERB_INVALID, nullptr, nullptr},
-    { "/tools/nodes",   "node_toolbox",  Inkscape::UI::Toolbar::NodeToolbar::create, nullptr,             "NodeToolbar",
-      SP_VERB_INVALID, nullptr, nullptr},
-    { "/tools/tweak",   "tweak_toolbox",   Inkscape::UI::Toolbar::TweakToolbar::create, nullptr,          "TweakToolbar",
-      SP_VERB_CONTEXT_TWEAK_PREFS, "/tools/tweak", N_("Color/opacity used for color tweaking")},
-    { "/tools/spray",   "spray_toolbox",  Inkscape::UI::Toolbar::SprayToolbar::create, nullptr,  "SprayToolbar",
-      SP_VERB_INVALID, nullptr, nullptr},
-    { "/tools/zoom",   "zoom_toolbox",   Inkscape::UI::Toolbar::ZoomToolbar::create, nullptr, "ZoomToolbar",
-      SP_VERB_INVALID, nullptr, nullptr},
+    { "/tools/select",          "select_toolbox",      Inkscape::UI::Toolbar::SelectToolbar::create,        "SelectToolbar",
+      SP_VERB_INVALID,                    nullptr,                  nullptr},
+    { "/tools/nodes",           "node_toolbox",        Inkscape::UI::Toolbar::NodeToolbar::create,          "NodeToolbar",
+      SP_VERB_INVALID,                    nullptr,                  nullptr},
+    { "/tools/tweak",           "tweak_toolbox",       Inkscape::UI::Toolbar::TweakToolbar::create,         "TweakToolbar",
+      SP_VERB_CONTEXT_TWEAK_PREFS,        "/tools/tweak",           N_("Color/opacity used for color tweaking")},
+    { "/tools/spray",           "spray_toolbox",       Inkscape::UI::Toolbar::SprayToolbar::create,         "SprayToolbar",
+      SP_VERB_INVALID,                    nullptr,                  nullptr},
+    { "/tools/zoom",            "zoom_toolbox",        Inkscape::UI::Toolbar::ZoomToolbar::create,          "ZoomToolbar",
+      SP_VERB_INVALID,                    nullptr,                  nullptr},
     // If you change MeasureToolbar here, change it also in desktop-widget.cpp
-    { "/tools/measure",   "measure_toolbox", Inkscape::UI::Toolbar::MeasureToolbar::create, nullptr,         "MeasureToolbar",
-      SP_VERB_INVALID, nullptr, nullptr},
-    { "/tools/shapes/star",   "star_toolbox",   Inkscape::UI::Toolbar::StarToolbar::create,   nullptr,  "StarToolbar",
-      SP_VERB_CONTEXT_STAR_PREFS,   "/tools/shapes/star",     N_("Style of new stars")},
-    { "/tools/shapes/rect",   "rect_toolbox",   Inkscape::UI::Toolbar::RectToolbar::create, nullptr,             "RectToolbar",
-      SP_VERB_CONTEXT_RECT_PREFS,   "/tools/shapes/rect",     N_("Style of new rectangles")},
-    { "/tools/shapes/3dbox",  "3dbox_toolbox",  Inkscape::UI::Toolbar::Box3DToolbar::create, nullptr,            "3DBoxToolbar",
-      SP_VERB_CONTEXT_3DBOX_PREFS,  "/tools/shapes/3dbox",    N_("Style of new 3D boxes")},
-    { "/tools/shapes/arc",    "arc_toolbox",    Inkscape::UI::Toolbar::ArcToolbar::create, nullptr,               "ArcToolbar",
-      SP_VERB_CONTEXT_ARC_PREFS,    "/tools/shapes/arc",      N_("Style of new ellipses")},
-    { "/tools/shapes/spiral", "spiral_toolbox", Inkscape::UI::Toolbar::SpiralToolbar::create, nullptr,           "SpiralToolbar",
-      SP_VERB_CONTEXT_SPIRAL_PREFS, "/tools/shapes/spiral",   N_("Style of new spirals")},
-    { "/tools/freehand/pencil", "pencil_toolbox", Inkscape::UI::Toolbar::PencilToolbar::create_pencil, nullptr,  "PencilToolbar",
-      SP_VERB_CONTEXT_PENCIL_PREFS, "/tools/freehand/pencil", N_("Style of new paths created by Pencil")},
-    { "/tools/freehand/pen", "pen_toolbox", Inkscape::UI::Toolbar::PencilToolbar::create_pen, nullptr,     "PenToolbar",
-      SP_VERB_CONTEXT_PEN_PREFS,    "/tools/freehand/pen",    N_("Style of new paths created by Pen")},
-    { "/tools/calligraphic", "calligraphy_toolbox", Inkscape::UI::Toolbar::CalligraphyToolbar::create, nullptr, "CalligraphyToolbar",
-      SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS, "/tools/calligraphic", N_("Style of new calligraphic strokes")},
-    { "/tools/eraser", "eraser_toolbox", Inkscape::UI::Toolbar::EraserToolbar::create, nullptr, "EraserToolbar",
-      SP_VERB_CONTEXT_ERASER_PREFS, "/tools/eraser", _("TBD")},
-    { "/tools/lpetool", "lpetool_toolbox", Inkscape::UI::Toolbar::LPEToolbar::create, nullptr, "LPEToolToolbar",
-      SP_VERB_CONTEXT_LPETOOL_PREFS, "/tools/lpetool", _("TBD")},
+    { "/tools/measure",         "measure_toolbox",     Inkscape::UI::Toolbar::MeasureToolbar::create,       "MeasureToolbar",
+      SP_VERB_INVALID,                    nullptr,                  nullptr},
+    { "/tools/shapes/star",     "star_toolbox",        Inkscape::UI::Toolbar::StarToolbar::create,          "StarToolbar",
+      SP_VERB_CONTEXT_STAR_PREFS,         "/tools/shapes/star",     N_("Style of new stars")},
+    { "/tools/shapes/rect",     "rect_toolbox",        Inkscape::UI::Toolbar::RectToolbar::create,          "RectToolbar",
+      SP_VERB_CONTEXT_RECT_PREFS,         "/tools/shapes/rect",     N_("Style of new rectangles")},
+    { "/tools/shapes/3dbox",    "3dbox_toolbox",       Inkscape::UI::Toolbar::Box3DToolbar::create,         "3DBoxToolbar",
+      SP_VERB_CONTEXT_3DBOX_PREFS,        "/tools/shapes/3dbox",    N_("Style of new 3D boxes")},
+    { "/tools/shapes/arc",      "arc_toolbox",         Inkscape::UI::Toolbar::ArcToolbar::create,           "ArcToolbar",
+      SP_VERB_CONTEXT_ARC_PREFS,          "/tools/shapes/arc",      N_("Style of new ellipses")},
+    { "/tools/shapes/spiral",   "spiral_toolbox",      Inkscape::UI::Toolbar::SpiralToolbar::create,        "SpiralToolbar",
+      SP_VERB_CONTEXT_SPIRAL_PREFS,       "/tools/shapes/spiral",   N_("Style of new spirals")},
+    { "/tools/freehand/pencil", "pencil_toolbox",      Inkscape::UI::Toolbar::PencilToolbar::create_pencil, "PencilToolbar",
+      SP_VERB_CONTEXT_PENCIL_PREFS,       "/tools/freehand/pencil", N_("Style of new paths created by Pencil")},
+    { "/tools/freehand/pen",    "pen_toolbox",         Inkscape::UI::Toolbar::PencilToolbar::create_pen,    "PenToolbar",
+      SP_VERB_CONTEXT_PEN_PREFS,          "/tools/freehand/pen",    N_("Style of new paths created by Pen")},
+    { "/tools/calligraphic",    "calligraphy_toolbox", Inkscape::UI::Toolbar::CalligraphyToolbar::create,   "CalligraphyToolbar",
+      SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS, "/tools/calligraphic",    N_("Style of new calligraphic strokes")},
+    { "/tools/eraser",          "eraser_toolbox",      Inkscape::UI::Toolbar::EraserToolbar::create,        "EraserToolbar",
+      SP_VERB_CONTEXT_ERASER_PREFS,       "/tools/eraser",           _("TBD")},
+    { "/tools/lpetool",         "lpetool_toolbox",     Inkscape::UI::Toolbar::LPEToolbar::create,           "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, 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", Inkscape::UI::Toolbar::ConnectorToolbar::create, nullptr,  "ConnectorToolbar",
-      SP_VERB_INVALID, nullptr, nullptr},
-    { "/tools/gradient", "gradient_toolbox", Inkscape::UI::Toolbar::GradientToolbar::create, nullptr, "GradientToolbar",
-      SP_VERB_INVALID, nullptr, nullptr},
-    { "/tools/mesh", "mesh_toolbox", Inkscape::UI::Toolbar::MeshToolbar::create, nullptr, "MeshToolbar",
-      SP_VERB_INVALID, nullptr, nullptr},
+    { "/tools/text",            "text_toolbox",        Inkscape::UI::Toolbar::TextToolbar::create,          "TextToolbar",
+      SP_VERB_INVALID,                    nullptr,                   nullptr},
+    { "/tools/dropper",         "dropper_toolbox",     Inkscape::UI::Toolbar::DropperToolbar::create,       "DropperToolbar",
+      SP_VERB_INVALID,                    nullptr,                   nullptr},
+    { "/tools/connector",       "connector_toolbox",   Inkscape::UI::Toolbar::ConnectorToolbar::create,     "ConnectorToolbar",
+      SP_VERB_INVALID,                    nullptr,                   nullptr},
+    { "/tools/gradient",        "gradient_toolbox",    Inkscape::UI::Toolbar::GradientToolbar::create,      "GradientToolbar",
+      SP_VERB_INVALID,                    nullptr,                   nullptr},
+    { "/tools/mesh",            "mesh_toolbox",        Inkscape::UI::Toolbar::MeshToolbar::create,          "MeshToolbar",
+      SP_VERB_INVALID,                    nullptr,                   nullptr},
 #if HAVE_POTRACE
-    { "/tools/paintbucket",  "paintbucket_toolbox", Inkscape::UI::Toolbar::PaintbucketToolbar::create, nullptr, "PaintbucketToolbar",
-      SP_VERB_CONTEXT_PAINTBUCKET_PREFS, "/tools/paintbucket", N_("Style of Paint Bucket fill objects")},
+    { "/tools/paintbucket",     "paintbucket_toolbox", Inkscape::UI::Toolbar::PaintbucketToolbar::create,   "PaintbucketToolbar",
+      SP_VERB_CONTEXT_PAINTBUCKET_PREFS, "/tools/paintbucket",       N_("Style of Paint Bucket fill objects")},
 #else
-    { "/tools/paintbucket",  "paintbucket_toolbox",  nullptr, nullptr, "PaintbucketToolbar", SP_VERB_NONE, "/tools/paintbucket", N_("Disabled")},
+    { "/tools/paintbucket",     "paintbucket_toolbox", nullptr,                                             "PaintbucketToolbar",
+        SP_VERB_NONE,                    "/tools/paintbucket",       N_("Disabled")},
 #endif
-    { nullptr, nullptr, nullptr, nullptr, nullptr, SP_VERB_INVALID, nullptr, nullptr }
+    { nullptr,                  nullptr,               nullptr,                                             nullptr,
+        SP_VERB_INVALID,                 nullptr,                    nullptr }
 };
 
 
@@ -464,55 +464,6 @@ static GtkWidget* createCustomSlider( GtkAdjustment *adjustment, gdouble climbRa
     return widget;
 }
 
-EgeAdjustmentAction * create_adjustment_action( gchar const *name,
-                                                       gchar const *label, gchar const *shortLabel, gchar const *tooltip,
-                                                       Glib::ustring const &path, gdouble def,
-                                                       gboolean altx, gchar const *altx_mark,
-                                                       gdouble lower, gdouble upper, gdouble step, gdouble page,
-                                                       gchar const** descrLabels, gdouble const* descrValues, guint descrCount,
-                                                       Inkscape::UI::Widget::UnitTracker *unit_tracker,
-                                                       gdouble climb/* = 0.1*/, guint digits/* = 3*/, double factor/* = 1.0*/ )
-{
-    static bool init = false;
-    if ( !init ) {
-        init = true;
-        ege_adjustment_action_set_compact_tool_factory( createCustomSlider );
-    }
-
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    GtkAdjustment* adj = GTK_ADJUSTMENT( gtk_adjustment_new( prefs->getDouble(path, def) * factor,
-                                                             lower, upper, step, page, 0 ) );
-
-    EgeAdjustmentAction* act = ege_adjustment_action_new( adj, name, label, tooltip, nullptr, climb, digits, unit_tracker );
-    if ( shortLabel ) {
-        g_object_set( act, "short_label", shortLabel, NULL );
-    }
-
-    if ( (descrCount > 0) && descrLabels && descrValues ) {
-        ege_adjustment_action_set_descriptions( act, descrLabels, descrValues, descrCount );
-    }
-
-    // The EgeAdjustmentAction class uses this to create a data member
-    // with the specified name, that simply points to the object itself.
-    // It appears to only be used by the DesktopWidget to find the named
-    // object
-    //
-    // TODO: Get rid of this and look up widgets by name instead.
-    if ( altx && altx_mark ) {
-        g_object_set( G_OBJECT(act), "self-id", altx_mark, NULL );
-    }
-
-    if (unit_tracker) {
-        unit_tracker->addAdjustment(adj);
-    }
-
-    // Using a cast just to make sure we pass in the right kind of function pointer
-    g_object_set( G_OBJECT(act), "tool-post", static_cast<EgeWidgetFixup>(sp_set_font_size_smaller), NULL );
-
-    return act;
-}
-
-
 void ToolboxFactory::setToolboxDesktop(GtkWidget *toolbox, SPDesktop *desktop)
 {
     sigc::connection *conn = static_cast<sigc::connection*>(g_object_get_data(G_OBJECT(toolbox),
@@ -723,60 +674,20 @@ void update_tool_toolbox( SPDesktop *desktop, ToolBase *eventcontext, GtkWidget
  *
  * \details This is the one that appears below the main menu, and contains
  *          tool-specific toolbars.  Each toolbar is created here, using
- *          either:
- *          * Its "create" method - this directly prepares a GtkToolbar
- *            widget, containing all the tools, or
- *          * Its "prep" method - this defines a set of GtkActions, which
- *            are later used to populate a toolbar.
+ *          its "create" method.
+ *
  *          The actual method used for each toolbar is specified in the
  *          "aux_toolboxes" array, defined above.
- *
- * \todo Needs to be rewritten so that GtkActions and GtkUIManager
- *       are not used.  This means that the "prep" approach is deprecated
- *       and we should adapt all toolbars to have a "create" method instead.
  */
 void setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     GtkSizeGroup* grouper = gtk_size_group_new( GTK_SIZE_GROUP_BOTH );
-    Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions( desktop );
-
-    // The UI Manager creates widgets based on the definitions in the
-    // "toolbar-select.ui" file.  This is only used with the "prep"
-    // method of toolbar-creation
-    GtkUIManager* mgr = gtk_ui_manager_new();
-    GError *err = nullptr;
-    gtk_ui_manager_insert_action_group( mgr, mainActions->gobj(), 0 );
-    Glib::ustring filename = get_filename(UIS, "toolbar-select.ui");
-    guint ret = gtk_ui_manager_add_ui_from_file(mgr, filename.c_str(), &err);
-    if(err) {
-      g_warning("Failed to load aux toolbar %s: %s", filename.c_str(), err->message);
-      g_error_free(err);
-      return;
-    }
-
-    // For the "prep" method, we create a "fake" set of toolbars
-    // that just contain a set of GtkActions.  These are stored
-    // in the "dataHolders" map.
-    std::map<std::string, GtkWidget*> dataHolders;
 
     // Loop through all the toolboxes and create them using either
-    // their "prep" or "create" methods.
+    // their "create" methods.
     for (int i = 0 ; aux_toolboxes[i].type_name ; i++ ) {
-        if ( aux_toolboxes[i].prep_func ) {
-
-            // For the "prep" method, create a "fake" toolbar
-            // that only contains a set of GtkActions.  In other
-            // words, this doesn't actually show anything... it
-            // just defines behaviour.
-            GtkWidget* kludge = aux_toolboxes[i].prep_func(desktop, mainActions->gobj());
-            gtk_widget_set_name( kludge, "Kludge" );
-            dataHolders[aux_toolboxes[i].type_name] = kludge;
-        } else if (aux_toolboxes[i].create_func) {
-
-            // For the "create" method, directly create a "real" toolbar,
-            // which contains visible, fully functional widgets.  Note that
-            // this should also contain any swatches that are needed.
+        if (aux_toolboxes[i].create_func) {
             GtkWidget *sub_toolbox = aux_toolboxes[i].create_func(desktop);
             gtk_widget_set_name( sub_toolbox, "SubToolBox" );
 
@@ -824,78 +735,6 @@ void setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
         }
     }
 
-    // Second pass to create toolbars *after* all GtkActions are created
-    // This is only used for toolbars that are being created using the "prep"
-    // method
-    for (int i = 0 ; aux_toolboxes[i].type_name ; i++ ) {
-        if ( aux_toolboxes[i].prep_func ) {
-
-            // Get the previously created "fake" toolbar that just contains
-            // invisible GtkAction definitions
-            auto kludge = dataHolders[aux_toolboxes[i].type_name];
-
-            // The thing that we put into the toolbox is actually a GtkGrid.
-            // It contains three elements... from left-to-right:
-            // * A "real" toolbar containing all the visible, fully functional
-            //   widgets
-            // * (optionally) A swatch widget for use with that toolbar
-            // * The "fake" toolbar containing the action definitions, which we
-            //   created previously
-            auto holder = gtk_grid_new();
-            gtk_widget_set_name( holder, aux_toolboxes[i].ui_name );
-
-            // First pack the "fake" toolbar with the action definitions
-            gtk_grid_attach( GTK_GRID(holder), kludge, 2, 0, 1, 1);
-
-            // Now, use the UI Manager to create a "real" toolbar.  This works
-            // because the actions needed by the UI file have all been defined
-            // in the "fake" toolbar
-            gchar* tmp = g_strdup_printf( "/ui/%s", aux_toolboxes[i].ui_name );
-            GtkWidget* toolBar = gtk_ui_manager_get_widget( mgr, tmp );
-            g_free( tmp );
-            tmp = nullptr;
-
-            // This part is just for styling
-            if ( prefs->getBool( "/toolbox/icononly", true) ) {
-                gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS );
-            }
-
-            GtkIconSize toolboxSize = ToolboxFactory::prefToSize("/toolbox/small");
-            gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), static_cast<GtkIconSize>(toolboxSize) );
-            gtk_widget_set_hexpand(toolBar, TRUE);
-            gtk_grid_attach( GTK_GRID(holder), toolBar, 0, 0, 1, 1);
-
-            // Add a swatch widget if one was specified
-            if ( aux_toolboxes[i].swatch_verb_id != SP_VERB_INVALID ) {
-                Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch( nullptr, _(aux_toolboxes[i].swatch_tip) );
-                swatch->setDesktop( desktop );
-                swatch->setClickVerb( aux_toolboxes[i].swatch_verb_id );
-                swatch->setWatchedTool( aux_toolboxes[i].swatch_tool, true );
-                swatch->set_margin_start(AUX_BETWEEN_BUTTON_GROUPS);
-                swatch->set_margin_end(AUX_BETWEEN_BUTTON_GROUPS);
-                swatch->set_margin_top(AUX_SPACING);
-                swatch->set_margin_bottom(AUX_SPACING);
-
-                auto swatch_ = GTK_WIDGET( swatch->gobj() );
-                gtk_grid_attach( GTK_GRID(holder), swatch_, 1, 0, 1, 1);
-            }
-            if(i==0){
-                gtk_widget_show_all( holder );
-            } else {
-                gtk_widget_show_now( holder );
-            }
-            sp_set_font_size_smaller( holder );
-
-            gtk_size_group_add_widget( grouper, holder );
-
-            // Finally add the grid to the toolbox.
-            // As described above, a pointer is also stored so that toolbars can be
-            // switched later.
-            gtk_container_add( GTK_CONTAINER(toolbox), holder );
-            g_object_set_data( G_OBJECT(toolbox), aux_toolboxes[i].data_name, holder );
-        }
-    }
-
     g_object_unref( G_OBJECT(grouper) );
 }
 
diff --git a/src/widgets/toolbox.h b/src/widgets/toolbox.h
index f396f4d9a..3a1bb4cc3 100644
--- a/src/widgets/toolbox.h
+++ b/src/widgets/toolbox.h
@@ -20,8 +20,6 @@
 
 #define TOOLBAR_SLIDER_HINT "compact"
 
-typedef struct _EgeAdjustmentAction      EgeAdjustmentAction;
-
 class SPDesktop;
 
 namespace Inkscape {
@@ -72,18 +70,6 @@ public:
 } // namespace UI
 } // namespace Inkscape
 
-
-// utility
-
- EgeAdjustmentAction * create_adjustment_action( gchar const *name,
-                                                       gchar const *label, gchar const *shortLabel, gchar const *tooltip,
-                                                       Glib::ustring const &path, gdouble def,
-                                                       gboolean altx, gchar const *altx_mark,
-                                                       gdouble lower, gdouble upper, gdouble step, gdouble page,
-                                                       gchar const** descrLabels, gdouble const* descrValues, guint descrCount,
-                                                       Inkscape::UI::Widget::UnitTracker *unit_tracker = nullptr,
-                                                       gdouble climb = 0.1, guint digits = 3, double factor = 1.0 );
-
 #endif /* !SEEN_TOOLBOX_H */
 
 /*