StarToolbar: GtkAction migration

5 files changed, 146 insertions, 202 deletions

diff --git a/share/ui/select-toolbar.ui b/share/ui/select-toolbar.ui
index c55daac23..5a81a3ecf 100644
--- a/share/ui/select-toolbar.ui
+++ b/share/ui/select-toolbar.ui
@@ -106,31 +106,6 @@
     <toolitem action='MeasureOffsetAction' />
   </toolbar>
 
-  <toolbar name='StarToolbar'>
-    <toolitem action='StarStateAction' />
-    <toolitem action='FlatAction' />
-    <separator />
-    <toolitem action='MagnitudeAction' />
-    <toolitem action='SpokeAction' />
-    <toolitem action='RoundednessAction' />
-    <toolitem action='RandomizationAction' />
-    <separator />
-    <toolitem action='StarResetAction' />
-  </toolbar>
-
-<!--
-  <toolbar name='RectToolbar'>
-    <toolitem action='RectStateAction' />
-    <toolitem action='RectWidthAction' />
-    <toolitem action='RectHeightAction' />
-    <toolitem action='RadiusXAction' />
-    <toolitem action='RadiusYAction' />
-    <toolitem action='RectUnitsAction' />
-    <separator />
-    <toolitem action='RectResetAction' />
-  </toolbar>
--->
-
   <toolbar name='3DBoxToolbar'>
     <toolitem action='3DBoxAngleXAction' />
     <toolitem action='3DBoxVPXStateAction' />
diff --git a/src/ui/toolbar/rect-toolbar.cpp b/src/ui/toolbar/rect-toolbar.cpp
index 019cc138d..321f81f97 100644
--- a/src/ui/toolbar/rect-toolbar.cpp
+++ b/src/ui/toolbar/rect-toolbar.cpp
@@ -48,7 +48,6 @@
 #include "ui/widget/spin-button-tool-item.h"
 #include "ui/widget/unit-tracker.h"
 
-#include "widgets/ege-adjustment-action.h"
 #include "widgets/ink-action.h"
 #include "widgets/widget-sizes.h"
 
diff --git a/src/ui/toolbar/star-toolbar.cpp b/src/ui/toolbar/star-toolbar.cpp
index b656f8cdb..5135f06ee 100644
--- a/src/ui/toolbar/star-toolbar.cpp
+++ b/src/ui/toolbar/star-toolbar.cpp
@@ -25,14 +25,15 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
+#include "star-toolbar.h"
+
 #include <glibmm/i18n.h>
 
-#include "star-toolbar.h"
+#include <gtkmm/radiotoolbutton.h>
+#include <gtkmm/separatortoolitem.h>
 
 #include "desktop.h"
 #include "document-undo.h"
-#include "widgets/ink-action.h"
-#include "widgets/toolbox.h"
 #include "selection.h"
 #include "verbs.h"
 
@@ -41,21 +42,13 @@
 #include "ui/icon-names.h"
 #include "ui/tools/star-tool.h"
 #include "ui/uxmanager.h"
-#include "ui/widget/ink-select-one-action.h"
-
-#include "widgets/ege-adjustment-action.h"
-#include "widgets/ege-output-action.h"
+#include "ui/widget/label-tool-item.h"
+#include "ui/widget/spin-button-tool-item.h"
 
 #include "xml/node-event-vector.h"
 
 using Inkscape::UI::UXManager;
 using Inkscape::DocumentUndo;
-using Inkscape::UI::ToolboxFactory;
-
-
-//########################
-//##       Star         ##
-//########################
 
 static Inkscape::XML::NodeEventVector star_tb_repr_events =
 {
@@ -69,166 +62,144 @@ static Inkscape::XML::NodeEventVector star_tb_repr_events =
 namespace Inkscape {
 namespace UI {
 namespace Toolbar {
-StarToolbar::~StarToolbar()
+StarToolbar::StarToolbar(SPDesktop *desktop) :
+    Toolbar(desktop),
+    _mode_item(Gtk::manage(new UI::Widget::LabelToolItem(_("<b>New:</b>")))),
+    _repr(nullptr)
 {
-    if (_repr) { // remove old listener
-        _repr->removeListenerByData(this);
-        Inkscape::GC::release(_repr);
-        _repr = nullptr;
-    }
-}
-
-GtkWidget *
-StarToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions)
-{
-    auto holder = new StarToolbar(desktop);
-
-    GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
+    _mode_item->set_use_markup(true);
+    add(*_mode_item);
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     bool isFlatSided = prefs->getBool("/tools/shapes/star/isflatsided", true);
 
-    EgeAdjustmentAction* eact = nullptr;
-
-    {
-        holder->_mode_action = ege_output_action_new( "StarStateAction", _("<b>New:</b>"), "", nullptr );
-        ege_output_action_set_use_markup( holder->_mode_action, TRUE );
-        gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_mode_action ) );
-    }
-
     /* Flatsided checkbox */
     {
-        InkSelectOneActionColumns columns;
+        Gtk::RadioToolButton::Group flat_item_group;
 
-        Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns);
+        auto flat_polygon_button = Gtk::manage(new Gtk::RadioToolButton(flat_item_group, _("Polygon")));
+        flat_polygon_button->set_tooltip_text(_("Regular polygon (with one handle) instead of a star"));
+        flat_polygon_button->set_icon_name(INKSCAPE_ICON("draw-polygon"));
+        _flat_item_buttons.push_back(flat_polygon_button);
 
-        Gtk::TreeModel::Row row;
+        auto flat_star_button = Gtk::manage(new Gtk::RadioToolButton(flat_item_group, _("Star")));
+        flat_star_button->set_tooltip_text(_("Star instead of a regular polygon (with one handle)"));
+        flat_star_button->set_icon_name(INKSCAPE_ICON("draw-star"));
+        _flat_item_buttons.push_back(flat_star_button);
 
-        row = *(store->append());
-        row[columns.col_label    ] = _("Polygon");
-        row[columns.col_tooltip  ] = _("Regular polygon (with one handle) instead of a star");
-        row[columns.col_icon     ] = INKSCAPE_ICON("draw-polygon");
-        row[columns.col_sensitive] = true;
+        _flat_item_buttons[ isFlatSided ? 0 : 1 ]->set_active();
 
-        row = *(store->append());
-        row[columns.col_label    ] = _("Star");
-        row[columns.col_tooltip  ] = _("Star instead of a regular polygon (with one handle)");
-        row[columns.col_icon     ] = INKSCAPE_ICON("draw-star");
-        row[columns.col_sensitive] = true;
+        int btn_index = 0;
 
-        holder->_flat_action =
-            InkSelectOneAction::create( "FlatAction",        // Name
-                                        (""),                // Label
-                                        (""),                // Tooltip
-                                        "Not Used",          // Icon
-                                        store );             // Tree store
-        holder->_flat_action->use_radio( true );
-        holder->_flat_action->use_label( false );
-        holder->_flat_action->set_active( isFlatSided ? 0 : 1 );
-
-        gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_flat_action->gobj() ));
-
-        holder->_flat_action->signal_changed().connect(sigc::mem_fun(*holder, &StarToolbar::side_mode_changed));
+        for (auto btn : _flat_item_buttons)
+        {
+            add(*btn);
+            btn->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &StarToolbar::side_mode_changed), btn_index++));
+        }
     }
 
+    add(*Gtk::manage(new Gtk::SeparatorToolItem()));
+
     /* Magnitude */
     {
-        gchar const* labels[] = {_("triangle/tri-star"), _("square/quad-star"), _("pentagon/five-pointed star"), _("hexagon/six-pointed star"), nullptr, nullptr, nullptr, nullptr, nullptr};
-        gdouble values[] = {3, 4, 5, 6, 7, 8, 10, 12, 20};
-        eact = create_adjustment_action( "MagnitudeAction",
-                                         _("Corners"), _("Corners:"), _("Number of corners of a polygon or star"),
-                                         "/tools/shapes/star/magnitude", 3,
-                                         FALSE, nullptr,
-                                         3, 1024, 1, 5,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         nullptr /*unit tracker*/,
-                                         1.0, 0 );
-        ege_adjustment_action_set_focuswidget(eact, GTK_WIDGET(desktop->canvas));
-
-        holder->_magnitude_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
-        holder->_magnitude_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &StarToolbar::magnitude_value_changed));
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+        std::vector<Glib::ustring> labels = {_("triangle/tri-star"), _("square/quad-star"), _("pentagon/five-pointed star"), _("hexagon/six-pointed star"), "", "", "", "", ""};
+        std::vector<double>        values = {                     3,                     4,                               5,                             6, 7,   8, 10, 12, 20};
+        auto magnitude_val = prefs->getDouble("/tools/shapes/star/magnitude", 3);
+        _magnitude_adj = Gtk::Adjustment::create(magnitude_val, 3, 1024, 1, 5);
+        _magnitude_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("star-magnitude", _("Corners:"), _magnitude_adj, 1.0, 0));
+        _magnitude_item->set_tooltip_text(_("Number of corners of a polygon or star"));
+        _magnitude_item->set_custom_numeric_menu_data(values, labels);
+        _magnitude_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas)));
+        _magnitude_adj->signal_value_changed().connect(sigc::mem_fun(*this, &StarToolbar::magnitude_value_changed));
+        _magnitude_item->set_sensitive(true);
+        add(*_magnitude_item);
     }
 
     /* Spoke ratio */
     {
-        gchar const* labels[] = {_("thin-ray star"), nullptr, _("pentagram"), _("hexagram"), _("heptagram"), _("octagram"), _("regular polygon")};
-        gdouble values[] = {0.01, 0.2, 0.382, 0.577, 0.692, 0.765, 1};
-        holder->_prop_action = create_adjustment_action( "SpokeAction",
-                                         _("Spoke ratio"), _("Spoke ratio:"),
-                                         // TRANSLATORS: Tip radius of a star is the distance from the center to the farthest handle.
-                                         // Base radius is the same for the closest handle.
-                                         _("Base radius to tip radius ratio"),
-                                         "/tools/shapes/star/proportion", 0.5,
-                                         FALSE, nullptr,
-                                         0.01, 1.0, 0.01, 0.1,
-                                         labels, values, G_N_ELEMENTS(labels)
-                                         );
-        ege_adjustment_action_set_focuswidget(holder->_prop_action, GTK_WIDGET(desktop->canvas));
-        holder->_spoke_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_prop_action));
-        holder->_spoke_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &StarToolbar::proportion_value_changed));
-        gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_prop_action) );
+        std::vector<Glib::ustring> labels = {_("thin-ray star"),  "", _("pentagram"), _("hexagram"), _("heptagram"), _("octagram"), _("regular polygon")};
+        std::vector<double>        values = {              0.01, 0.2,          0.382,         0.577,          0.692,         0.765,                    1};
+        auto prop_val = prefs->getDouble("/tools/shapes/star/proportion", 0.5);
+        _spoke_adj = Gtk::Adjustment::create(prop_val, 0.01, 1.0, 0.01, 0.1);
+        _spoke_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("star-spoke", _("Spoke ratio:"), _spoke_adj));
+        // TRANSLATORS: Tip radius of a star is the distance from the center to the farthest handle.
+        // Base radius is the same for the closest handle.
+        _spoke_item->set_tooltip_text(_("Base radius to tip radius ratio"));
+        _spoke_item->set_custom_numeric_menu_data(values, labels);
+        _spoke_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas)));
+        _spoke_adj->signal_value_changed().connect(sigc::mem_fun(*this, &StarToolbar::proportion_value_changed));
 
         if ( !isFlatSided ) {
-            gtk_action_set_visible( GTK_ACTION(holder->_prop_action), TRUE );
+            _spoke_item->set_visible(true);
         } else {
-            gtk_action_set_visible( GTK_ACTION(holder->_prop_action), FALSE );
+            _spoke_item->set_visible(false);
         }
+
+        add(*_spoke_item);
     }
 
     /* Roundedness */
     {
-        gchar const* labels[] = {_("stretched"), _("twisted"), _("slightly pinched"), _("NOT rounded"), _("slightly rounded"),
-                                 _("visibly rounded"), _("well rounded"), _("amply rounded"), nullptr, _("stretched"), _("blown up")};
-        gdouble values[] = {-1, -0.2, -0.03, 0, 0.05, 0.1, 0.2, 0.3, 0.5, 1, 10};
-        eact = create_adjustment_action( "RoundednessAction",
-                                         _("Rounded"), _("Rounded:"), _("How much rounded are the corners (0 for sharp)"),
-                                         "/tools/shapes/star/rounded", 0.0,
-                                         FALSE, nullptr,
-                                         -10.0, 10.0, 0.01, 0.1,
-                                         labels, values, G_N_ELEMENTS(labels)
-                                         );
-        ege_adjustment_action_set_focuswidget(eact, GTK_WIDGET(desktop->canvas));
-        holder->_roundedness_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
-        holder->_roundedness_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &StarToolbar::rounded_value_changed));
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+        std::vector<Glib::ustring> labels = {_("stretched"), _("twisted"), _("slightly pinched"), _("NOT rounded"), _("slightly rounded"),
+                                 _("visibly rounded"), _("well rounded"), _("amply rounded"), "", _("stretched"), _("blown up")};
+        std::vector<double> values = {-1, -0.2, -0.03, 0, 0.05, 0.1, 0.2, 0.3, 0.5, 1, 10};
+        auto roundedness_val = prefs->getDouble("/tools/shapes/star/rounded", 0.0);
+        _roundedness_adj = Gtk::Adjustment::create(roundedness_val, -10.0, 10.0, 0.01, 0.1);
+        _roundedness_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("star-roundedness", _("Rounded:"), _roundedness_adj));
+        _roundedness_item->set_tooltip_text(_("How rounded are the corners (0 for sharp)"));
+        _roundedness_item->set_custom_numeric_menu_data(values, labels);
+        _roundedness_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas)));
+        _roundedness_adj->signal_value_changed().connect(sigc::mem_fun(*this, &StarToolbar::rounded_value_changed));
+        _roundedness_item->set_sensitive(true);
+        add(*_roundedness_item);
     }
 
     /* Randomization */
     {
-        gchar const* labels[] = {_("NOT randomized"), _("slightly irregular"), _("visibly randomized"), _("strongly randomized"), _("blown up")};
-        gdouble values[] = {0, 0.01, 0.1, 0.5, 10};
-        eact = create_adjustment_action( "RandomizationAction",
-                                         _("Randomized"), _("Randomized:"), _("Scatter randomly the corners and angles"),
-                                         "/tools/shapes/star/randomized", 0.0,
-                                         FALSE, nullptr,
-                                         -10.0, 10.0, 0.001, 0.01,
-                                         labels, values, G_N_ELEMENTS(labels),
-                                         nullptr /*unit tracker*/, 0.1, 3 );
-        ege_adjustment_action_set_focuswidget(eact, GTK_WIDGET(desktop->canvas));
-        holder->_randomization_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact));
-        holder->_randomization_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &StarToolbar::randomized_value_changed));
-        gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-        gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
-    }
-
+        std::vector<Glib::ustring> labels = {_("NOT randomized"), _("slightly irregular"), _("visibly randomized"), _("strongly randomized"), _("blown up")};
+        std::vector<double>        values = {                  0,                    0.01,                     0.1,                      0.5,            10};
+        auto randomized_val = prefs->getDouble("/tools/shapes/star/randomized", 0.0);
+        _randomization_adj = Gtk::Adjustment::create(randomized_val, -10.0, 10.0, 0.001, 0.01);
+        _randomization_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("star-randomized", _("Randomized:"), _randomization_adj, 0.1, 3));
+        _randomization_item->set_tooltip_text(_("Scatter randomly the corners and angles"));
+        _randomization_item->set_custom_numeric_menu_data(values, labels);
+        _randomization_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas)));
+        _randomization_adj->signal_value_changed().connect(sigc::mem_fun(*this, &StarToolbar::randomized_value_changed));
+        _randomization_item->set_sensitive(true);
+        add(*_randomization_item);
+    }
+
+    add(*Gtk::manage(new Gtk::SeparatorToolItem()));
+    
     /* Reset */
     {
-        InkAction* inky = ink_action_new( "StarResetAction",
-                                          _("Defaults"),
-                                          _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
-                                          INKSCAPE_ICON("edit-clear"),
-                                          GTK_ICON_SIZE_SMALL_TOOLBAR);
-        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(StarToolbar::defaults), holder);
-        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
-        gtk_action_set_sensitive( GTK_ACTION(inky), TRUE );
+        _reset_item = Gtk::manage(new Gtk::ToolButton(_("Defaults")));
+        _reset_item->set_icon_name(INKSCAPE_ICON("edit-clear"));
+        _reset_item->set_tooltip_text(_("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"));
+        _reset_item->signal_clicked().connect(sigc::mem_fun(*this, &StarToolbar::defaults));
+        _reset_item->set_sensitive(true);
+        add(*_reset_item);
     }
 
-    desktop->connectEventContextChanged(sigc::mem_fun(*holder, &StarToolbar::watch_ec));
+    desktop->connectEventContextChanged(sigc::mem_fun(*this, &StarToolbar::watch_ec));
 
-    return GTK_WIDGET(holder->gobj());
+    show_all();
+}
+
+StarToolbar::~StarToolbar()
+{
+    if (_repr) { // remove old listener
+        _repr->removeListenerByData(this);
+        Inkscape::GC::release(_repr);
+        _repr = nullptr;
+    }
+}
+
+GtkWidget *
+StarToolbar::create(SPDesktop *desktop)
+{
+    auto toolbar = new StarToolbar(desktop);
+    return GTK_WIDGET(toolbar->gobj());
 }
 
 void
@@ -252,8 +223,8 @@ StarToolbar::side_mode_changed(int mode)
     Inkscape::Selection *selection = _desktop->getSelection();
     bool modmade = false;
 
-    if ( _prop_action ) {
-        gtk_action_set_visible( GTK_ACTION(_prop_action), !flat );
+    if (_spoke_item) {
+        _spoke_item->set_visible(!flat);
     }
 
     auto itemlist= selection->items();
@@ -450,15 +421,12 @@ StarToolbar::randomized_value_changed()
 }
 
 void
-StarToolbar::defaults(GtkWidget * /*widget*/, gpointer user_data)
+StarToolbar::defaults()
 {
-    auto toolbar = reinterpret_cast<StarToolbar *>(user_data);
 
     // FIXME: in this and all other _default functions, set some flag telling the value_changed
     // callbacks to lump all the changes for all selected objects in one undo step
 
-    GtkAdjustment *adj = nullptr;
-
     // fixme: make settable in prefs!
     gint mag = 5;
     gdouble prop = 0.5;
@@ -466,20 +434,20 @@ StarToolbar::defaults(GtkWidget * /*widget*/, gpointer user_data)
     gdouble randomized = 0;
     gdouble rounded = 0;
 
-    toolbar->_flat_action->set_active ( flat ? 0 : 1 );
+    _flat_item_buttons[ flat ? 0 : 1 ]->set_active();
 
-    gtk_action_set_visible( GTK_ACTION(toolbar->_prop_action), !flat );
+    _spoke_item->set_visible(!flat);
 
-    toolbar->_magnitude_adj->set_value(mag);
-    toolbar->_spoke_adj->set_value(prop);
-    toolbar->_roundedness_adj->set_value(rounded);
-    toolbar->_randomization_adj->set_value(randomized);
+    _magnitude_adj->set_value(mag);
+    _spoke_adj->set_value(prop);
+    _roundedness_adj->set_value(rounded);
+    _randomization_adj->set_value(randomized);
 
 #if !GTK_CHECK_VERSION(3,18,0)
-    toolbar->_magnitude_adj->value_changed();
-    toolbar->_spoke_adj->value_changed();
-    toolbar->_roundedness_adj->value_changed();
-    toolbar->_randomization_adj->value_changed();
+    _magnitude_adj->value_changed();
+    _spoke_adj->value_changed();
+    _roundedness_adj->value_changed();
+    _randomization_adj->value_changed();
 #endif
 }
 
@@ -520,9 +488,9 @@ StarToolbar::selection_changed(Inkscape::Selection *selection)
     }
 
     if (n_selected == 0) {
-        gtk_action_set_label(GTK_ACTION(_mode_action), _("<b>New:</b>"));
+        _mode_item->set_markup(_("<b>New:</b>"));
     } else if (n_selected == 1) {
-        gtk_action_set_label(GTK_ACTION(_mode_action), _("<b>Change:</b>"));
+        _mode_item->set_markup(_("<b>Change:</b>"));
 
         if (repr) {
             _repr = repr;
@@ -566,11 +534,11 @@ StarToolbar::event_attr_changed(Inkscape::XML::Node *repr, gchar const *name,
     } else if (!strcmp(name, "inkscape:flatsided")) {
         char const *flatsides = repr->attribute("inkscape:flatsided");
         if ( flatsides && !strcmp(flatsides,"false") ) {
-            toolbar->_flat_action->set_active(1);
-            gtk_action_set_visible( GTK_ACTION(toolbar->_prop_action), TRUE );
+            toolbar->_flat_item_buttons[1]->set_active();
+            toolbar->_spoke_item->set_visible(true);
         } else {
-            toolbar->_flat_action->set_active(0);
-            gtk_action_set_visible( GTK_ACTION(toolbar->_prop_action), FALSE );
+            toolbar->_flat_item_buttons[0]->set_active();
+            toolbar->_spoke_item->set_visible(false);
         }
     } else if ((!strcmp(name, "sodipodi:r1") || !strcmp(name, "sodipodi:r2")) && (!isFlatSided) ) {
         gdouble r1 = 1.0;
diff --git a/src/ui/toolbar/star-toolbar.h b/src/ui/toolbar/star-toolbar.h
index 0f7f5fbe3..c44caab22 100644
--- a/src/ui/toolbar/star-toolbar.h
+++ b/src/ui/toolbar/star-toolbar.h
@@ -32,12 +32,12 @@
 
 #include <gtkmm/adjustment.h>
 
-class InkSelectOneAction;
 class SPDesktop;
 
-typedef struct _EgeAdjustmentAction EgeAdjustmentAction;
-typedef struct _EgeOutputAction EgeOutputAction;
-typedef struct _GtkActionGroup GtkActionGroup;
+namespace Gtk {
+class RadioToolButton;
+class ToolButton;
+}
 
 namespace Inkscape {
 class Selection;
@@ -51,12 +51,21 @@ namespace Tools {
 class ToolBase;
 }
 
+namespace Widget {
+class LabelToolItem;
+class SpinButtonToolItem;
+}
+
 namespace Toolbar {
 class StarToolbar : public Toolbar {
 private:
-    EgeOutputAction *_mode_action;
-    InkSelectOneAction *_flat_action;
-    EgeAdjustmentAction *_prop_action;
+    UI::Widget::LabelToolItem *_mode_item;
+    std::vector<Gtk::RadioToolButton *> _flat_item_buttons;
+    UI::Widget::SpinButtonToolItem *_magnitude_item;
+    UI::Widget::SpinButtonToolItem *_spoke_item;
+    UI::Widget::SpinButtonToolItem *_roundedness_item;
+    UI::Widget::SpinButtonToolItem *_randomization_item;
+    Gtk::ToolButton *_reset_item;
 
     XML::Node *_repr;
 
@@ -73,23 +82,16 @@ private:
     void proportion_value_changed();
     void rounded_value_changed();
     void randomized_value_changed();
-
-    static void defaults(GtkWidget *widget,
-                         gpointer   user_data);
-
+    void defaults();
     void watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec);
     void selection_changed(Inkscape::Selection *selection);
 
 protected:
-    StarToolbar(SPDesktop *desktop) :
-        Toolbar(desktop),
-        _repr(nullptr)
-    {}
-
+    StarToolbar(SPDesktop *desktop);
     ~StarToolbar() override;
 
 public:
-    static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions);
+    static GtkWidget * create(SPDesktop *desktop);
 
     static void event_attr_changed(Inkscape::XML::Node *repr,
                                    gchar const         *name,
diff --git a/src/widgets/toolbox.cpp b/src/widgets/toolbox.cpp
index 24da611f2..6a194e8a1 100644
--- a/src/widgets/toolbox.cpp
+++ b/src/widgets/toolbox.cpp
@@ -201,7 +201,7 @@ static struct {
       SP_VERB_INVALID, nullptr, nullptr},
     { "/tools/measure",   "measure_toolbox",   nullptr, Inkscape::UI::Toolbar::MeasureToolbar::prep,              "MeasureToolbar",
       SP_VERB_INVALID, nullptr, nullptr},
-    { "/tools/shapes/star",   "star_toolbox",   nullptr, Inkscape::UI::Toolbar::StarToolbar::prep,              "StarToolbar",
+    { "/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")},