Fix for 1032880 : Stroke style panel is mirrored between open windows

(bzr r11587)

1 files changed, 434 insertions, 547 deletions

diff --git a/src/widgets/stroke-style.cpp b/src/widgets/stroke-style.cpp
index d6168ca04..1a1865326 100644
--- a/src/widgets/stroke-style.cpp
+++ b/src/widgets/stroke-style.cpp
@@ -17,106 +17,309 @@
 
 #define noSP_SS_VERBOSE
 
-#include "widgets/dash-selector.h"
-#include <gtkmm/radiobutton.h>
-#include <gtkmm/table.h>
-#include <glibmm/i18n.h>
-
-#include "desktop-handles.h"
-#include "desktop-style.h"
-#include "dialogs/dialog-events.h"
-#include "display/canvas-bpath.h" // for SP_STROKE_LINEJOIN_*
-#include "display/drawing.h"
-#include "document-private.h"
-#include "document-undo.h"
-#include "gradient-chemistry.h"
-#include "helper/stock-items.h"
-#include "helper/unit-menu.h"
-#include "helper/units.h"
-#include "inkscape.h"
-#include "io/sys.h"
-#include "marker.h"
-#include "path-prefix.h"
-#include "selection.h"
-#include "sp-linear-gradient.h"
-#include "sp-namedview.h"
-#include "sp-pattern.h"
-#include "sp-radial-gradient.h"
-#include "sp-rect.h"
-#include "sp-text.h"
-#include "style.h"
-#include "svg/css-ostringstream.h"
-#include "ui/cache/svg_preview_cache.h"
-#include "ui/icon-names.h"
-#include "widgets/icon.h"
-#include "widgets/paint-selector.h"
-#include "widgets/sp-widget.h"
-#include "widgets/spw-utilities.h"
-#include "ui/widget/spinbutton.h"
-#include "xml/repr.h"
-
 #include "stroke-style.h"
-#include "stroke-marker-selector.h"
-#include "fill-style.h" // to get sp_fill_style_widget_set_desktop
-#include "fill-n-stroke-factory.h"
-
-#include "verbs.h"
 
 using Inkscape::DocumentUndo;
 
-
-static MarkerComboBox *start_marker_combobox = NULL;
-static MarkerComboBox *mid_marker_combobox = NULL;
-static MarkerComboBox *end_marker_combobox = NULL;
-
-sigc::connection start_marker_connection;
-sigc::connection mid_marker_connection;
-sigc::connection end_marker_connection;
-
-static SPObject *ink_extract_marker_name(gchar const *n, SPDocument *doc);
-static void      ink_markers_combo_update(Gtk::Container* spw, SPMarkerLoc const which);
-
+/**
+ * Creates a new widget for the line stroke paint.
+ */
 Gtk::Widget *sp_stroke_style_paint_widget_new(void)
 {
     return Inkscape::Widgets::createStyleWidget( STROKE );
 }
 
+/**
+ * Creates a new widget for the line stroke style.
+ */
+Gtk::Widget *sp_stroke_style_line_widget_new(void)
+{
+    return Inkscape::Widgets::createStrokeStyleWidget();
+}
+
 void sp_stroke_style_widget_set_desktop(Gtk::Widget *widget, SPDesktop *desktop)
 {
-    sp_fill_style_widget_set_desktop(widget, desktop);
+    Inkscape::StrokeStyle *ss = dynamic_cast<Inkscape::StrokeStyle*>(widget);
+    if (ss) {
+        ss->setDesktop(desktop);
+    }
+}
+
+namespace Inkscape {
+
+/**
+ * Create the fill or stroke style widget, and hook up all the signals.
+ */
+Gtk::Widget *Inkscape::Widgets::createStrokeStyleWidget( )
+{
+    StrokeStyle *strokeStyle = new StrokeStyle();
+
+    return strokeStyle;
 }
 
-/* Line */
+StrokeStyle::StrokeStyle() :
+    Gtk::VBox(),
+    miterLimitSpin(),
+    widthSpin(),
+    unitSelector(),
+    joinMiter(),
+    joinRound(),
+    joinBevel(),
+    capButt(),
+    capRound(),
+    capSquare(),
+    dashSelector(),
+    update(false),
+    desktop(0),
+    selectChangedConn(),
+    selectModifiedConn(),
+    startMarkerConn(),
+    midMarkerConn(),
+    endMarkerConn()
+{
+    Gtk::HBox *hb;
+    Gtk::HBox *f = new Gtk::HBox(false, 0);
+    f->show();
+    add(*f);
+
+    table = new Gtk::Table(3, 6, false);
+    table->show();
+    table->set_border_width(4);
+    table->set_row_spacings(4);
+    f->add(*table);
 
-static void sp_stroke_style_line_selection_modified(SPWidget *spw, Inkscape::Selection *selection, guint flags, gpointer data);
-static void sp_stroke_style_line_selection_changed(SPWidget *spw, Inkscape::Selection *selection, gpointer data);
+    gint i = 0;
+
+    //spw_label(t, C_("Stroke width", "_Width:"), 0, i);
 
-static void sp_stroke_style_line_update(Gtk::Container *spw, Inkscape::Selection *sel);
+    hb = spw_hbox(table, 3, 1, i);
 
-static void sp_stroke_style_set_join_buttons(Gtk::Container *spw, Gtk::ToggleButton *active);
+// TODO: when this is gtkmmified, use an Inkscape::UI::Widget::ScalarUnit instead of the separate
+// spinbutton and unit selector for stroke width. In sp_stroke_style_line_update, use
+// setHundredPercent to remember the averaged width corresponding to 100%. Then the
+// stroke_width_set_unit will be removed (because ScalarUnit takes care of conversions itself), and
+// with it, the two remaining calls of stroke_average_width, allowing us to get rid of that
+// function in desktop-style.
 
-static void sp_stroke_style_set_cap_buttons(Gtk::Container *spw, Gtk::ToggleButton *active);
+#if WITH_GTKMM_3_0
+    widthAdj = new Glib::RefPtr<Gtk::Adjustment>(Gtk::Adjustment::create(1.0, 0.0, 1000.0, 0.1, 10.0, 0.0));
+#else
+    widthAdj = new Gtk::Adjustment(1.0, 0.0, 1000.0, 0.1, 10.0, 0.0);
+#endif
 
-static void sp_stroke_style_width_changed(Gtk::Container *spw);
-static void sp_stroke_style_miterlimit_changed(Gtk::Container *spw);
-static void sp_stroke_style_any_toggled(Gtk::ToggleButton *tb, Gtk::Container *spw);
-static void sp_stroke_style_line_dash_changed(Gtk::Container *spw);
+    widthSpin = new Inkscape::UI::Widget::SpinButton(*widthAdj, 0.1, 3);
+    widthSpin->set_tooltip_text(_("Stroke width"));
+    widthSpin->show();
+    spw_label(table, C_("Stroke width", "_Width:"), 0, i, widthSpin);
 
-static void sp_stroke_style_update_marker_combo(Gtk::Container *spw, GSList const *objects);
+    sp_dialog_defocus_on_enter_cpp(widthSpin);
+
+    hb->pack_start(*widthSpin, false, false, 0);
+    unitSelector = sp_unit_selector_new(SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE);
+    Gtk::Widget *us = manage(Glib::wrap(unitSelector));
+    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+
+    if (desktop)
+        sp_unit_selector_set_unit (SP_UNIT_SELECTOR(unitSelector), sp_desktop_namedview(desktop)->doc_units);
+    sp_unit_selector_add_unit(SP_UNIT_SELECTOR(unitSelector), &sp_unit_get_by_id(SP_UNIT_PERCENT), 0);
+    g_signal_connect ( G_OBJECT (unitSelector), "set_unit", G_CALLBACK (StrokeStyle::setStrokeWidthUnit), this );
+    us->show();
+
+#if WITH_GTKMM_3_0
+    sp_unit_selector_add_adjustment( SP_UNIT_SELECTOR(unitSelector), GTK_ADJUSTMENT((*widthAdj)->gobj()) );
+#else
+    sp_unit_selector_add_adjustment( SP_UNIT_SELECTOR(unitSelector), GTK_ADJUSTMENT(widthAdj->gobj()) );
+#endif
+
+    hb->pack_start(*us, FALSE, FALSE, 0);
+
+#if WITH_GTKMM_3_0
+    (*widthAdj)->signal_value_changed().connect(sigc::mem_fun(*this, &StrokeStyle::widthChangedCB));
+#else
+    widthAdj->signal_value_changed().connect(sigc::mem_fun(*this, &StrokeStyle::widthChangedCB));
+#endif
+    i++;
+
+    /* Join type */
+    // TRANSLATORS: The line join style specifies the shape to be used at the
+    //  corners of paths. It can be "miter", "round" or "bevel".
+    spw_label(table, _("Join:"), 0, i, NULL);
+
+    hb = spw_hbox(table, 3, 1, i);
+
+    //tb = NULL;
+
+    joinMiter = makeRadioButton(NULL, INKSCAPE_ICON("stroke-join-miter"),
+                                hb, "join", "miter");
+    // TRANSLATORS: Miter join: joining lines with a sharp (pointed) corner.
+    //  For an example, draw a triangle with a large stroke width and modify the
+    //  "Join" option (in the Fill and Stroke dialog).
+    joinMiter->set_tooltip_text(_("Miter join"));
+
+    joinRound = makeRadioButton(joinMiter, INKSCAPE_ICON("stroke-join-round"),
+                                hb, "join", "round");
+    // TRANSLATORS: Round join: joining lines with a rounded corner.
+    //  For an example, draw a triangle with a large stroke width and modify the
+    //  "Join" option (in the Fill and Stroke dialog).
+    joinRound->set_tooltip_text(_("Round join"));
+
+    joinBevel = makeRadioButton(joinMiter, INKSCAPE_ICON("stroke-join-bevel"),
+                                hb, "join", "bevel");
+    // TRANSLATORS: Bevel join: joining lines with a blunted (flattened) corner.
+    //  For an example, draw a triangle with a large stroke width and modify the
+    //  "Join" option (in the Fill and Stroke dialog).
+    joinBevel->set_tooltip_text(_("Bevel join"));
+
+    i++;
+
+    /* Miterlimit  */
+    // TRANSLATORS: Miter limit: only for "miter join", this limits the length
+    //  of the sharp "spike" when the lines connect at too sharp an angle.
+    // When two line segments meet at a sharp angle, a miter join results in a
+    //  spike that extends well beyond the connection point. The purpose of the
+    //  miter limit is to cut off such spikes (i.e. convert them into bevels)
+    //  when they become too long.
+    //spw_label(t, _("Miter _limit:"), 0, i);
+
+    hb = spw_hbox(table, 3, 1, i);
+
+#if WITH_GTKMM_3_0
+    miterLimitAdj = new Glib::RefPtr<Gtk::Adjustment>(Gtk::Adjustment::create(4.0, 0.0, 100.0, 0.1, 10.0, 0.0));
+    miterLimitSpin = new Inkscape::UI::Widget::SpinButton(*miterLimitAdj, 0.1, 2);
+#else
+    miterLimitAdj = new Gtk::Adjustment(4.0, 0.0, 100.0, 0.1, 10.0, 0.0);
+    miterLimitSpin = new Inkscape::UI::Widget::SpinButton(*miterLimitAdj, 0.1, 2);
+#endif
+
+    miterLimitSpin->set_tooltip_text(_("Maximum length of the miter (in units of stroke width)"));
+    miterLimitSpin->show();
+    spw_label(table, _("Miter _limit:"), 0, i, miterLimitSpin);
+    sp_dialog_defocus_on_enter_cpp(miterLimitSpin);
+
+    hb->pack_start(*miterLimitSpin, false, false, 0);
+
+#if WITH_GTKMM_3_0
+    (*miterLimitAdj)->signal_value_changed().connect(sigc::mem_fun(*this, &StrokeStyle::miterLimitChangedCB));
+
+#else
+    miterLimitAdj->signal_value_changed().connect(sigc::mem_fun(*this, &StrokeStyle::miterLimitChangedCB));
+#endif
+    i++;
+
+    /* Cap type */
+    // TRANSLATORS: cap type specifies the shape for the ends of lines
+    //spw_label(t, _("_Cap:"), 0, i);
+    spw_label(table, _("Cap:"), 0, i, NULL);
+
+    hb = spw_hbox(table, 3, 1, i);
+
+    capButt = makeRadioButton(capButt, INKSCAPE_ICON("stroke-cap-butt"),
+                                hb, "cap", "butt");
+    // TRANSLATORS: Butt cap: the line shape does not extend beyond the end point
+    //  of the line; the ends of the line are square
+    capButt->set_tooltip_text(_("Butt cap"));
+
+    capRound = makeRadioButton(capButt, INKSCAPE_ICON("stroke-cap-round"),
+                                hb, "cap", "round");
+    // TRANSLATORS: Round cap: the line shape extends beyond the end point of the
+    //  line; the ends of the line are rounded
+    capRound->set_tooltip_text(_("Round cap"));
+
+    capSquare = makeRadioButton(capButt, INKSCAPE_ICON("stroke-cap-square"),
+                                hb, "cap", "square");
+    // TRANSLATORS: Square cap: the line shape extends beyond the end point of the
+    //  line; the ends of the line are square
+    capSquare->set_tooltip_text(_("Square cap"));
+
+    i++;
+
+    /* Dash */
+    spw_label(table, _("Dashes:"), 0, i, NULL); //no mnemonic for now
+                                            //decide what to do:
+                                            //   implement a set_mnemonic_source function in the
+                                            //   SPDashSelector class, so that we do not have to
+                                            //   expose any of the underlying widgets?
+    dashSelector = manage(new SPDashSelector);
+
+    dashSelector->show();
+    table->attach(*dashSelector, 1, 4, i, i+1, (Gtk::EXPAND | Gtk::FILL), static_cast<Gtk::AttachOptions>(0), 0, 0);
+    dashSelector->changed_signal.connect(sigc::mem_fun(*this, &StrokeStyle::lineDashChangedCB));
+
+    i++;
+
+    /* Drop down marker selectors*/
+    // TRANSLATORS: Path markers are an SVG feature that allows you to attach arbitrary shapes
+    // (arrowheads, bullets, faces, whatever) to the start, end, or middle nodes of a path.
+
+    startMarkerCombo = manage(new MarkerComboBox("marker-start"));
+    spw_label(table, _("_Start Markers:"), 0, i, startMarkerCombo);
+    startMarkerCombo->set_tooltip_text(_("Start Markers are drawn on the first node of a path or shape"));
+    startMarkerConn = startMarkerCombo->signal_changed().connect(
+            sigc::bind<MarkerComboBox *, StrokeStyle *, SPMarkerLoc>(
+                sigc::ptr_fun(&StrokeStyle::markerSelectCB), startMarkerCombo, this, SP_MARKER_LOC_START));
+    startMarkerCombo->show();
+    table->attach(*startMarkerCombo, 1, 4, i, i+1, (Gtk::EXPAND | Gtk::FILL), static_cast<Gtk::AttachOptions>(0), 0, 0);
+    i++;
+
+    midMarkerCombo =  manage(new MarkerComboBox("marker-mid"));
+    spw_label(table, _("_Mid Markers:"), 0, i, midMarkerCombo);
+    midMarkerCombo->set_tooltip_text(_("Mid Markers are drawn on every node of a path or shape except the first and last nodes"));
+    midMarkerConn = midMarkerCombo->signal_changed().connect(
+        sigc::bind<MarkerComboBox *, StrokeStyle *, SPMarkerLoc>(
+            sigc::ptr_fun(&StrokeStyle::markerSelectCB), midMarkerCombo, this, SP_MARKER_LOC_MID));
+    midMarkerCombo->show();
+    table->attach(*midMarkerCombo, 1, 4, i, i+1, (Gtk::EXPAND | Gtk::FILL), static_cast<Gtk::AttachOptions>(0), 0, 0);
+    i++;
+
+    endMarkerCombo = manage(new MarkerComboBox("marker-end"));
+    spw_label(table, _("_End Markers:"), 0, i, endMarkerCombo);
+    endMarkerCombo->set_tooltip_text(_("End Markers are drawn on the last node of a path or shape"));
+    endMarkerConn = endMarkerCombo->signal_changed().connect(
+        sigc::bind<MarkerComboBox *, StrokeStyle *, SPMarkerLoc>(
+            sigc::ptr_fun(&StrokeStyle::markerSelectCB), endMarkerCombo, this, SP_MARKER_LOC_END));
+    endMarkerCombo->show();
+    table->attach(*endMarkerCombo, 1, 4, i, i+1, (Gtk::EXPAND | Gtk::FILL), static_cast<Gtk::AttachOptions>(0), 0, 0);
+    i++;
+
+    setDesktop(desktop);
+    updateLine();
+
+}
+
+StrokeStyle::~StrokeStyle()
+{
+    selectModifiedConn.disconnect();
+    selectChangedConn.disconnect();
+}
+
+void StrokeStyle::setDesktop(SPDesktop *desktop)
+{
+    if (this->desktop != desktop) {
+
+        if (this->desktop) {
+            selectModifiedConn.disconnect();
+            selectChangedConn.disconnect();
+        }
+        this->desktop = desktop;
+        if (desktop && desktop->selection) {
+            selectChangedConn = desktop->selection->connectChanged(sigc::hide(sigc::mem_fun(*this, &StrokeStyle::selectionChangedCB)));
+            selectModifiedConn = desktop->selection->connectModified(sigc::hide<0>(sigc::mem_fun(*this, &StrokeStyle::selectionModifiedCB)));
+        }
+        updateLine();
+    }
+}
 
 
 /**
  * Helper function for creating radio buttons.  This should probably be re-thought out
  * when reimplementing this with Gtkmm.
  */
-static Gtk::RadioButton *
-sp_stroke_radio_button(Gtk::RadioButton *tb, char const *icon,
-                       Gtk::HBox *hb, Gtk::Container *spw,
-                       gchar const *key, gchar const *data)
+Gtk::RadioButton *
+StrokeStyle::makeRadioButton(Gtk::RadioButton *tb, char const *icon,
+                       Gtk::HBox *hb, gchar const *key, gchar const *data)
 {
     g_assert(icon != NULL);
     g_assert(hb  != NULL);
-    g_assert(spw != NULL);
 
     if (tb == NULL) {
         tb = new Gtk::RadioButton();
@@ -128,10 +331,13 @@ sp_stroke_radio_button(Gtk::RadioButton *tb, char const *icon,
     tb->show();
     tb->set_mode(false);
     hb->pack_start(*tb, false, false, 0);
-    spw->set_data(icon, tb);
+    // TODO
+    set_data(icon, tb);
     tb->set_data(key, (gpointer*)data);
-    tb->signal_toggled().connect(sigc::bind<Gtk::RadioButton *, Gtk::Container *>(
-                                     sigc::ptr_fun(&sp_stroke_style_any_toggled), tb, spw));
+
+    tb->signal_toggled().connect(sigc::bind<Gtk::RadioButton *, StrokeStyle *>(
+                                     sigc::ptr_fun(&StrokeStyle::buttonToggledCB), tb, this));
+
     Gtk::Widget *px = manage(Glib::wrap(sp_icon_new(Inkscape::ICON_SIZE_LARGE_TOOLBAR, icon)));
     g_assert(px != NULL);
     px->show();
@@ -146,15 +352,14 @@ sp_stroke_radio_button(Gtk::RadioButton *tb, char const *icon,
  * Gets the marker uri string and applies it to all selected
  * items in the current desktop.
  */
-static void
-sp_marker_select(MarkerComboBox *marker_combo, Gtk::Container *spw, SPMarkerLoc const which)
+void
+StrokeStyle::markerSelectCB(MarkerComboBox *marker_combo, StrokeStyle *spw, SPMarkerLoc const which)
 {
-    if (spw->get_data("update")) {
+    if (spw->update) {
         return;
     }
 
-    SPDesktop *desktop = inkscape_active_desktop();
-    SPDocument *document = sp_desktop_document(desktop);
+    SPDocument *document = sp_desktop_document(spw->desktop);
     if (!document) {
         return;
     }
@@ -162,7 +367,6 @@ sp_marker_select(MarkerComboBox *marker_combo, Gtk::Container *spw, SPMarkerLoc
     /* Get Marker */
     gchar const *marker = marker_combo->get_active_marker_uri();
 
-
     SPCSSAttr *css = sp_repr_css_attr_new();
     gchar const *combo_id = marker_combo->get_id();
     sp_repr_css_set_property(css, combo_id, marker);
@@ -170,9 +374,9 @@ sp_marker_select(MarkerComboBox *marker_combo, Gtk::Container *spw, SPMarkerLoc
     // Also update the marker combobox, so the document's markers
     // show up at the top of the combobox
 //    sp_stroke_style_line_update( SP_WIDGET(spw), desktop ? sp_desktop_selection(desktop) : NULL);
-    ink_markers_combo_update(spw, which);
+    spw->updateMarkerHist(which);
 
-    Inkscape::Selection *selection = sp_desktop_selection(desktop);
+    Inkscape::Selection *selection = sp_desktop_selection(spw->desktop);
     GSList const *items = selection->itemList();
     for (; items != NULL; items = items->next) {
         SPItem *item = reinterpret_cast<SPItem *>(items->data);
@@ -195,26 +399,26 @@ sp_marker_select(MarkerComboBox *marker_combo, Gtk::Container *spw, SPMarkerLoc
 
 };
 
-static void
-ink_markers_combo_update(Gtk::Container* /*spw*/, SPMarkerLoc const which) {
+void
+StrokeStyle::updateMarkerHist(SPMarkerLoc const which) {
 
     switch (which) {
         case SP_MARKER_LOC_START:
-            start_marker_connection.block();
-            start_marker_combobox->set_active_history();
-            start_marker_connection.unblock();
+            startMarkerConn.block();
+            startMarkerCombo->set_active_history();
+            startMarkerConn.unblock();
             break;
 
         case SP_MARKER_LOC_MID:
-            mid_marker_connection.block();
-            mid_marker_combobox->set_active_history();
-            mid_marker_connection.unblock();
+            midMarkerConn.block();
+            midMarkerCombo->set_active_history();
+            midMarkerConn.unblock();
             break;
 
         case SP_MARKER_LOC_END:
-            end_marker_connection.block();
-            end_marker_combobox->set_active_history();
-            end_marker_connection.unblock();
+            endMarkerConn.block();
+            endMarkerCombo->set_active_history();
+            endMarkerConn.unblock();
             break;
         default:
             g_assert_not_reached();
@@ -225,22 +429,20 @@ ink_markers_combo_update(Gtk::Container* /*spw*/, SPMarkerLoc const which) {
  * Sets the stroke width units for all selected items.
  * Also handles absolute and dimensionless units.
  */
-static gboolean stroke_width_set_unit(SPUnitSelector *,
+gboolean StrokeStyle::setStrokeWidthUnit(SPUnitSelector *,
                                       SPUnit const *old,
                                       SPUnit const *new_units,
-                                      Gtk::Container *spw)
+                                      StrokeStyle *spw)
 {
-    if (spw->get_data("update")) {
+    if (spw->update) {
         return FALSE;
     }
 
-    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
-
-    if (!desktop) {
+    if (!spw->desktop) {
         return FALSE;
     }
 
-    Inkscape::Selection *selection = sp_desktop_selection (desktop);
+    Inkscape::Selection *selection = sp_desktop_selection (spw->desktop);
 
     if (selection->isEmpty())
         return FALSE;
@@ -251,14 +453,12 @@ static gboolean stroke_width_set_unit(SPUnitSelector *,
        (new_units->base == SP_UNIT_DIMENSIONLESS)) {
 
         /* Absolute to percentage */
-        spw->set_data ("update", GUINT_TO_POINTER (TRUE));
+        spw->update = true;
 
 #if WITH_GTKMM_3_0
-        Glib::RefPtr<Gtk::Adjustment> *a = static_cast<Glib::RefPtr<Gtk::Adjustment> *>(spw->get_data("width"));
-        float w = sp_units_get_pixels( (*a)->get_value(), *old);
+        float w = sp_units_get_pixels( (*spw->widthAdj)->get_value(), *old);
 #else
-        Gtk::Adjustment *a = static_cast<Gtk::Adjustment *>(spw->get_data("width"));
-        float w = sp_units_get_pixels(a->get_value(), *old);
+        float w = sp_units_get_pixels(spw->widthAdj->get_value(), *old);
 #endif
 
         gdouble average = stroke_average_width (objects);
@@ -267,330 +467,62 @@ static gboolean stroke_width_set_unit(SPUnitSelector *,
             return FALSE;
 
 #if WITH_GTKMM_3_0
-        (*a)->set_value(100.0 * w / average);
+        (*spw->widthAdj)->set_value(100.0 * w / average);
 #else
-        a->set_value(100.0 * w / average);
+        spw->widthAdj->set_value(100.0 * w / average);
 #endif
 
-        spw->set_data ("update", GUINT_TO_POINTER (FALSE));
+        spw->update = false;
         return TRUE;
 
     } else if ((old->base == SP_UNIT_DIMENSIONLESS) &&
               (new_units->base == SP_UNIT_ABSOLUTE || new_units->base == SP_UNIT_DEVICE)) {
 
         /* Percentage to absolute */
-        spw->set_data ("update", GUINT_TO_POINTER (TRUE));
-
-#if WITH_GTKMM_3_0
-        Glib::RefPtr<Gtk::Adjustment> *a = static_cast<Glib::RefPtr<Gtk::Adjustment> *>(spw->get_data("width"));
-#else
-        Gtk::Adjustment *a = static_cast<Gtk::Adjustment *>(spw->get_data("width"));
-#endif
+        spw->update = true;
 
         gdouble average = stroke_average_width (objects);
 
 #if WITH_GTKMM_3_0
-        (*a)->set_value (sp_pixels_get_units (0.01 * (*a)->get_value() * average, *new_units));
+        (*spw->widthAdj)->set_value (sp_pixels_get_units (0.01 * (*spw->widthAdj)->get_value() * average, *new_units));
 #else
-        a->set_value (sp_pixels_get_units (0.01 * a->get_value() * average, *new_units));
+        spw->widthAdj->set_value (sp_pixels_get_units (0.01 * spw->widthAdj->get_value() * average, *new_units));
 #endif
 
-        spw->set_data ("update", GUINT_TO_POINTER (FALSE));
+        spw->update = false;
         return TRUE;
     }
 
     return FALSE;
 }
 
-
-/**
- * Creates a new widget for the line stroke style.
- */
-Gtk::Container *sp_stroke_style_line_widget_new(void)
-{
-    Inkscape::UI::Widget::SpinButton *sb;
-    Gtk::RadioButton *tb;
-    Gtk::HBox *hb;
-
-    GtkWidget *spw_old = sp_widget_new_global(INKSCAPE);
-    Gtk::Container *spw = dynamic_cast<Gtk::Container *>(manage(Glib::wrap(spw_old)));
-
-    Gtk::HBox *f = new Gtk::HBox(false, 0);
-    f->show();
-    spw->add(*f);
-
-    Gtk::Table *t = new Gtk::Table(3, 6, false);
-    t->show();
-    t->set_border_width(4);
-    t->set_row_spacings(4);
-    f->add(*t);
-    spw->set_data("stroke", t);
-
-    gint i = 0;
-
-    //spw_label(t, C_("Stroke width", "_Width:"), 0, i);
-
-    hb = spw_hbox(t, 3, 1, i);
-
-// TODO: when this is gtkmmified, use an Inkscape::UI::Widget::ScalarUnit instead of the separate
-// spinbutton and unit selector for stroke width. In sp_stroke_style_line_update, use
-// setHundredPercent to remember the averaged width corresponding to 100%. Then the
-// stroke_width_set_unit will be removed (because ScalarUnit takes care of conversions itself), and
-// with it, the two remaining calls of stroke_average_width, allowing us to get rid of that
-// function in desktop-style.
-
-#if WITH_GTKMM_3_0
-    Glib::RefPtr<Gtk::Adjustment> *a = new Glib::RefPtr<Gtk::Adjustment>(Gtk::Adjustment::create(1.0, 0.0, 1000.0, 0.1, 10.0, 0.0));
-#else
-    Gtk::Adjustment *a = new Gtk::Adjustment(1.0, 0.0, 1000.0, 0.1, 10.0, 0.0);
-#endif
-
-    spw->set_data("width", a);
-    sb = new Inkscape::UI::Widget::SpinButton(*a, 0.1, 3);
-    sb->set_tooltip_text(_("Stroke width"));
-    sb->show();
-    spw_label(t, C_("Stroke width", "_Width:"), 0, i, sb);
-
-    sp_dialog_defocus_on_enter_cpp(sb);
-
-    hb->pack_start(*sb, false, false, 0);
-    GtkWidget *us_old = sp_unit_selector_new(SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE);
-    Gtk::Widget *us = manage(Glib::wrap(us_old));
-    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
-    if (desktop)
-        sp_unit_selector_set_unit (SP_UNIT_SELECTOR(us_old), sp_desktop_namedview(desktop)->doc_units);
-    sp_unit_selector_add_unit(SP_UNIT_SELECTOR(us_old), &sp_unit_get_by_id(SP_UNIT_PERCENT), 0);
-    g_signal_connect ( G_OBJECT (us_old), "set_unit", G_CALLBACK (stroke_width_set_unit), spw );
-    us->show();
-
-#if WITH_GTKMM_3_0
-    sp_unit_selector_add_adjustment( SP_UNIT_SELECTOR(us_old), GTK_ADJUSTMENT((*a)->gobj()) );
-#else
-    sp_unit_selector_add_adjustment( SP_UNIT_SELECTOR(us_old), GTK_ADJUSTMENT(a->gobj()) );
-#endif
-
-    hb->pack_start(*us, FALSE, FALSE, 0);
-    spw->set_data("units", us_old);
-
-#if WITH_GTKMM_3_0
-    (*a)->signal_value_changed().connect(sigc::bind(sigc::ptr_fun(&sp_stroke_style_width_changed), spw));
-#else
-    a->signal_value_changed().connect(sigc::bind(sigc::ptr_fun(&sp_stroke_style_width_changed), spw));
-#endif
-    i++;
-
-    /* Join type */
-    // TRANSLATORS: The line join style specifies the shape to be used at the
-    //  corners of paths. It can be "miter", "round" or "bevel".
-    spw_label(t, _("Join:"), 0, i, NULL);
-
-    hb = spw_hbox(t, 3, 1, i);
-
-    tb = NULL;
-
-    tb = sp_stroke_radio_button(tb, INKSCAPE_ICON("stroke-join-miter"),
-                                hb, spw, "join", "miter");
-
-    // TRANSLATORS: Miter join: joining lines with a sharp (pointed) corner.
-    //  For an example, draw a triangle with a large stroke width and modify the
-    //  "Join" option (in the Fill and Stroke dialog).
-    tb->set_tooltip_text(_("Miter join"));
-    spw->set_data("miter join", tb);
-
-    tb = sp_stroke_radio_button(tb, INKSCAPE_ICON("stroke-join-round"),
-                                hb, spw, "join", "round");
-
-
-    // TRANSLATORS: Round join: joining lines with a rounded corner.
-    //  For an example, draw a triangle with a large stroke width and modify the
-    //  "Join" option (in the Fill and Stroke dialog).
-    tb->set_tooltip_text(_("Round join"));
-    spw->set_data("round join", tb);
-
-    tb = sp_stroke_radio_button(tb, INKSCAPE_ICON("stroke-join-bevel"),
-                                hb, spw, "join", "bevel");
-
-
-    // TRANSLATORS: Bevel join: joining lines with a blunted (flattened) corner.
-    //  For an example, draw a triangle with a large stroke width and modify the
-    //  "Join" option (in the Fill and Stroke dialog).
-    tb->set_tooltip_text(_("Bevel join"));
-    spw->set_data("bevel join", tb);
-
-    i++;
-
-    /* Miterlimit  */
-    // TRANSLATORS: Miter limit: only for "miter join", this limits the length
-    //  of the sharp "spike" when the lines connect at too sharp an angle.
-    // When two line segments meet at a sharp angle, a miter join results in a
-    //  spike that extends well beyond the connection point. The purpose of the
-    //  miter limit is to cut off such spikes (i.e. convert them into bevels)
-    //  when they become too long.
-    //spw_label(t, _("Miter _limit:"), 0, i);
-
-    hb = spw_hbox(t, 3, 1, i);
-
-#if WITH_GTKMM_3_0
-    a = new Glib::RefPtr<Gtk::Adjustment>(Gtk::Adjustment::create(4.0, 0.0, 100.0, 0.1, 10.0, 0.0));
-    spw->set_data("miterlimit", a);
-    sb = new Inkscape::UI::Widget::SpinButton(*a, 0.1, 2);
-#else
-    a = new Gtk::Adjustment(4.0, 0.0, 100.0, 0.1, 10.0, 0.0);
-    spw->set_data("miterlimit", a);
-    sb = new Inkscape::UI::Widget::SpinButton(*a, 0.1, 2);
-#endif
-
-    sb->set_tooltip_text(_("Maximum length of the miter (in units of stroke width)"));
-    sb->show();
-    spw_label(t, _("Miter _limit:"), 0, i, sb);
-    spw->set_data("miterlimit_sb", sb);
-    sp_dialog_defocus_on_enter_cpp(sb);
-
-    hb->pack_start(*sb, false, false, 0);
-
-#if WITH_GTKMM_3_0
-    (*a)->signal_value_changed().connect(sigc::bind(sigc::ptr_fun(&sp_stroke_style_miterlimit_changed), spw));
-#else
-    a->signal_value_changed().connect(sigc::bind(sigc::ptr_fun(&sp_stroke_style_miterlimit_changed), spw));
-#endif
-    i++;
-
-    /* Cap type */
-    // TRANSLATORS: cap type specifies the shape for the ends of lines
-    //spw_label(t, _("_Cap:"), 0, i);
-    spw_label(t, _("Cap:"), 0, i, NULL);
-
-    hb = spw_hbox(t, 3, 1, i);
-
-    tb = NULL;
-
-    tb = sp_stroke_radio_button(tb, INKSCAPE_ICON("stroke-cap-butt"),
-                                hb, spw, "cap", "butt");
-    spw->set_data("cap butt", tb);
-
-    // TRANSLATORS: Butt cap: the line shape does not extend beyond the end point
-    //  of the line; the ends of the line are square
-    tb->set_tooltip_text(_("Butt cap"));
-
-    tb = sp_stroke_radio_button(tb, INKSCAPE_ICON("stroke-cap-round"),
-                                hb, spw, "cap", "round");
-    spw->set_data("cap round", tb);
-
-    // TRANSLATORS: Round cap: the line shape extends beyond the end point of the
-    //  line; the ends of the line are rounded
-    tb->set_tooltip_text(_("Round cap"));
-
-    tb = sp_stroke_radio_button(tb, INKSCAPE_ICON("stroke-cap-square"),
-                                hb, spw, "cap", "square");
-    spw->set_data("cap square", tb);
-
-    // TRANSLATORS: Square cap: the line shape extends beyond the end point of the
-    //  line; the ends of the line are square
-    tb->set_tooltip_text(_("Square cap"));
-
-    i++;
-
-
-    /* Dash */
-    spw_label(t, _("Dashes:"), 0, i, NULL); //no mnemonic for now
-                                            //decide what to do:
-                                            //   implement a set_mnemonic_source function in the
-                                            //   SPDashSelector class, so that we do not have to
-                                            //   expose any of the underlying widgets?
-    SPDashSelector *ds = manage(new SPDashSelector);
-
-    ds->show();
-    t->attach(*ds, 1, 4, i, i+1, (Gtk::EXPAND | Gtk::FILL), static_cast<Gtk::AttachOptions>(0), 0, 0);
-    spw->set_data("dash", ds);
-    ds->changed_signal.connect(sigc::bind(sigc::ptr_fun(&sp_stroke_style_line_dash_changed), spw));
-    i++;
-
-    /* Drop down marker selectors*/
-    // TRANSLATORS: Path markers are an SVG feature that allows you to attach arbitrary shapes
-    // (arrowheads, bullets, faces, whatever) to the start, end, or middle nodes of a path.
-
-    start_marker_combobox = manage(new MarkerComboBox("marker-start"));
-    spw_label(t, _("_Start Markers:"), 0, i, start_marker_combobox);
-    start_marker_combobox->set_tooltip_text(_("Start Markers are drawn on the first node of a path or shape"));
-    start_marker_connection = start_marker_combobox->signal_changed().connect(
-            sigc::bind<MarkerComboBox *, Gtk::Container *, SPMarkerLoc>(
-                sigc::ptr_fun(&sp_marker_select), start_marker_combobox, spw, SP_MARKER_LOC_START));
-    start_marker_combobox->show();
-    t->attach(*start_marker_combobox, 1, 4, i, i+1, (Gtk::EXPAND | Gtk::FILL), static_cast<Gtk::AttachOptions>(0), 0, 0);
-    spw->set_data("start_marker_combobox", start_marker_combobox);
-    i++;
-
-    mid_marker_combobox =  manage(new MarkerComboBox("marker-mid"));
-    spw_label(t, _("_Mid Markers:"), 0, i, mid_marker_combobox);
-    mid_marker_combobox->set_tooltip_text(_("Mid Markers are drawn on every node of a path or shape except the first and last nodes"));
-    mid_marker_connection = mid_marker_combobox->signal_changed().connect(
-        sigc::bind<MarkerComboBox *, Gtk::Container *, SPMarkerLoc>(
-            sigc::ptr_fun(&sp_marker_select), mid_marker_combobox, spw, SP_MARKER_LOC_MID));
-    mid_marker_combobox->show();
-    t->attach(*mid_marker_combobox, 1, 4, i, i+1, (Gtk::EXPAND | Gtk::FILL), static_cast<Gtk::AttachOptions>(0), 0, 0);
-    spw->set_data("mid_marker_combobox", mid_marker_combobox);
-    i++;
-
-    end_marker_combobox = manage(new MarkerComboBox("marker-end"));
-    spw_label(t, _("_End Markers:"), 0, i, end_marker_combobox);
-    end_marker_combobox->set_tooltip_text(_("End Markers are drawn on the last node of a path or shape"));
-    end_marker_connection = end_marker_combobox->signal_changed().connect(
-        sigc::bind<MarkerComboBox *, Gtk::Container *, SPMarkerLoc>(
-            sigc::ptr_fun(&sp_marker_select), end_marker_combobox, spw, SP_MARKER_LOC_END));
-    end_marker_combobox->show();
-    t->attach(*end_marker_combobox, 1, 4, i, i+1, (Gtk::EXPAND | Gtk::FILL), static_cast<Gtk::AttachOptions>(0), 0, 0);
-    spw->set_data("end_marker_combobox", end_marker_combobox);
-    i++;
-
-    // FIXME: we cheat and still use gtk+ signals
-
-    g_signal_connect(G_OBJECT(spw_old), "modify_selection",
-                     G_CALLBACK(sp_stroke_style_line_selection_modified),
-                     spw);
-    g_signal_connect(G_OBJECT(spw_old), "change_selection",
-                     G_CALLBACK(sp_stroke_style_line_selection_changed),
-                     spw);
-
-    sp_stroke_style_line_update(spw, desktop ? sp_desktop_selection(desktop) : NULL);
-
-    return spw;
-}
-
 /**
  * Callback for when stroke style widget is modified.
  * Triggers update action.
  */
-static void
-sp_stroke_style_line_selection_modified(SPWidget *,
-                                        Inkscape::Selection *selection,
-                                        guint flags,
-                                        gpointer data)
+void
+StrokeStyle::selectionModifiedCB(guint flags)
 {
-    Gtk::Container *spw = static_cast<Gtk::Container *>(data);
     if (flags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_PARENT_MODIFIED_FLAG)) {
-        sp_stroke_style_line_update(spw, selection);
+        updateLine();
     }
-
 }
 
 /**
  * Callback for when stroke style widget is changed.
  * Triggers update action.
  */
-static void
-sp_stroke_style_line_selection_changed(SPWidget *,
-                                       Inkscape::Selection *selection,
-                                       gpointer data)
+void
+StrokeStyle::selectionChangedCB()
 {
-    Gtk::Container *spw = static_cast<Gtk::Container *>(data);
-    sp_stroke_style_line_update(spw, selection);
+    updateLine();
 }
 
 /**
  * Sets selector widgets' dash style from an SPStyle object.
  */
-static void
-sp_dash_selector_set_from_style(SPDashSelector *dsel, SPStyle *style)
+void
+StrokeStyle::setDashSelectorFromStyle(SPDashSelector *dsel, SPStyle *style)
 {
     if (style->stroke_dash.n_dash > 0) {
         double d[64];
@@ -612,76 +544,66 @@ sp_dash_selector_set_from_style(SPDashSelector *dsel, SPStyle *style)
 /**
  * Sets the join type for a line, and updates the stroke style widget's buttons
  */
-static void
-sp_jointype_set (Gtk::Container *spw, unsigned const jointype)
+void
+StrokeStyle::setJoinType (unsigned const jointype)
 {
     Gtk::RadioButton *tb = NULL;
     switch (jointype) {
         case SP_STROKE_LINEJOIN_MITER:
-            tb = static_cast<Gtk::RadioButton *>(spw->get_data(INKSCAPE_ICON("stroke-join-miter")));
+            tb = joinMiter;
             break;
         case SP_STROKE_LINEJOIN_ROUND:
-            tb = static_cast<Gtk::RadioButton *>(spw->get_data(INKSCAPE_ICON("stroke-join-round")));
+            tb = joinRound;
             break;
         case SP_STROKE_LINEJOIN_BEVEL:
-            tb = static_cast<Gtk::RadioButton *>(spw->get_data(INKSCAPE_ICON("stroke-join-bevel")));
+            tb = joinBevel;
             break;
         default:
             break;
     }
-    sp_stroke_style_set_join_buttons(spw, tb);
+    setJoinButtons(tb);
 }
 
 /**
  * Sets the cap type for a line, and updates the stroke style widget's buttons
  */
-static void
-sp_captype_set (Gtk::Container *spw, unsigned const captype)
+void
+StrokeStyle::setCapType (unsigned const captype)
 {
     Gtk::RadioButton *tb = NULL;
     switch (captype) {
         case SP_STROKE_LINECAP_BUTT:
-            tb = static_cast<Gtk::RadioButton *>(spw->get_data(INKSCAPE_ICON("stroke-cap-butt")));
+            tb = capButt;
             break;
         case SP_STROKE_LINECAP_ROUND:
-            tb = static_cast<Gtk::RadioButton *>(spw->get_data(INKSCAPE_ICON("stroke-cap-round")));
+            tb = capRound;
             break;
         case SP_STROKE_LINECAP_SQUARE:
-            tb = static_cast<Gtk::RadioButton *>(spw->get_data(INKSCAPE_ICON("stroke-cap-square")));
+            tb = capSquare;
             break;
         default:
             break;
     }
-    sp_stroke_style_set_cap_buttons(spw, tb);
+    setCapButtons(tb);
 }
 
 /**
  * Callback for when stroke style widget is updated, including markers, cap type,
  * join type, etc.
  */
-static void
-sp_stroke_style_line_update(Gtk::Container *spw, Inkscape::Selection *sel)
+void
+StrokeStyle::updateLine()
 {
-    if (spw->get_data("update")) {
+    if (update) {
         return;
     }
 
-    spw->set_data("update", GINT_TO_POINTER(TRUE));
+    update = true;
 
-    FillOrStroke kind = GPOINTER_TO_INT(spw->get_data("kind")) ? FILL : STROKE;
+    Inkscape::Selection *sel = desktop ? sp_desktop_selection(desktop) : NULL;
 
-    Gtk::Table *sset = static_cast<Gtk::Table *>(spw->get_data("stroke"));
-
-#if WITH_GTKMM_3_0
-    Glib::RefPtr<Gtk::Adjustment> *width = static_cast<Glib::RefPtr<Gtk::Adjustment> *>(spw->get_data("width"));
-    Glib::RefPtr<Gtk::Adjustment> *ml = static_cast<Glib::RefPtr<Gtk::Adjustment> *>(spw->get_data("miterlimit"));
-#else
-    Gtk::Adjustment *width = static_cast<Gtk::Adjustment *>(spw->get_data("width"));
-    Gtk::Adjustment *ml = static_cast<Gtk::Adjustment *>(spw->get_data("miterlimit"));
-#endif
-
-    SPUnitSelector *us = SP_UNIT_SELECTOR(spw->get_data("units"));
-    SPDashSelector *dsel = static_cast<SPDashSelector *>(spw->get_data("dash"));
+    // TODO
+    FillOrStroke kind = GPOINTER_TO_INT(get_data("kind")) ? FILL : STROKE;
 
     // create temporary style
     SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT);
@@ -694,39 +616,39 @@ sp_stroke_style_line_update(Gtk::Container *spw, Inkscape::Selection *sel)
 
     if (!sel || sel->isEmpty()) {
         // Nothing selected, grey-out all controls in the stroke-style dialog
-        sset->set_sensitive(false);
+        table->set_sensitive(false);
 
-        spw->set_data("update", GINT_TO_POINTER(FALSE));
+        update = false;
 
         return;
     } else {
-        sset->set_sensitive(true);
+        table->set_sensitive(true);
 
-        SPUnit const *unit = sp_unit_selector_get_unit(us);
+        SPUnit const *unit = sp_unit_selector_get_unit(SP_UNIT_SELECTOR(unitSelector));
 
         if (result_sw == QUERY_STYLE_MULTIPLE_AVERAGED) {
-            sp_unit_selector_set_unit(us, &sp_unit_get_by_id(SP_UNIT_PERCENT));
+            sp_unit_selector_set_unit(SP_UNIT_SELECTOR(unitSelector), &sp_unit_get_by_id(SP_UNIT_PERCENT));
         } else {
             // same width, or only one object; no sense to keep percent, switch to absolute
             if (unit->base != SP_UNIT_ABSOLUTE && unit->base != SP_UNIT_DEVICE) {
-                sp_unit_selector_set_unit(us, sp_desktop_namedview(SP_ACTIVE_DESKTOP)->doc_units);
+                sp_unit_selector_set_unit(SP_UNIT_SELECTOR(unitSelector), sp_desktop_namedview(SP_ACTIVE_DESKTOP)->doc_units);
             }
         }
 
-        unit = sp_unit_selector_get_unit(us);
+        unit = sp_unit_selector_get_unit(SP_UNIT_SELECTOR(unitSelector));
 
         if (unit->base == SP_UNIT_ABSOLUTE || unit->base == SP_UNIT_DEVICE) {
             double avgwidth = sp_pixels_get_units (query->stroke_width.computed, *unit);
 #if WITH_GTKMM_3_0
-            (*width)->set_value(avgwidth);
+            (*widthAdj)->set_value(avgwidth);
 #else
-            width->set_value(avgwidth);
+            widthAdj->set_value(avgwidth);
 #endif
         } else {
 #if WITH_GTKMM_3_0
-            (*width)->set_value(100);
+            (*widthAdj)->set_value(100);
 #else
-            width->set_value(100);
+            widthAdj->set_value(100);
 #endif
         }
 
@@ -734,45 +656,36 @@ sp_stroke_style_line_update(Gtk::Container *spw, Inkscape::Selection *sel)
         // The markers might still be shown though, so these will not be disabled
         bool enabled = (result_sw != QUERY_STYLE_NOTHING) && !targPaint.isNoneSet();
         /* No objects stroked, set insensitive */
-        Gtk::RadioButton *tb = NULL;
-        tb = static_cast<Gtk::RadioButton *>(spw->get_data("miter join"));
-        tb->set_sensitive(enabled);
-        tb = static_cast<Gtk::RadioButton *>(spw->get_data("round join"));
-        tb->set_sensitive(enabled);
-        tb = static_cast<Gtk::RadioButton *>(spw->get_data("bevel join"));
-        tb->set_sensitive(enabled);
-
-        Inkscape::UI::Widget::SpinButton* sb = NULL;
-        sb = static_cast<Inkscape::UI::Widget::SpinButton *>(spw->get_data("miterlimit_sb"));
-        sb->set_sensitive(enabled);
-
-        tb = static_cast<Gtk::RadioButton *>(spw->get_data("cap butt"));
-        tb->set_sensitive(enabled);
-        tb = static_cast<Gtk::RadioButton *>(spw->get_data("cap round"));
-        tb->set_sensitive(enabled);
-        tb = static_cast<Gtk::RadioButton *>(spw->get_data("cap square"));
-        tb->set_sensitive(enabled);
-
-        dsel->set_sensitive(enabled);
+        joinMiter->set_sensitive(enabled);
+        joinRound->set_sensitive(enabled);
+        joinBevel->set_sensitive(enabled);
+
+        miterLimitSpin->set_sensitive(enabled);
+
+        capButt->set_sensitive(enabled);
+        capRound->set_sensitive(enabled);
+        capSquare->set_sensitive(enabled);
+
+        dashSelector->set_sensitive(enabled);
     }
 
     if (result_ml != QUERY_STYLE_NOTHING)
 #if WITH_GTKMM_3_0
-        (*ml)->set_value(query->stroke_miterlimit.value); // TODO: reflect averagedness?
+        (*miterLimitAdj)->set_value(query->stroke_miterlimit.value); // TODO: reflect averagedness?
 #else
-        ml->set_value(query->stroke_miterlimit.value); // TODO: reflect averagedness?
+        miterLimitAdj->set_value(query->stroke_miterlimit.value); // TODO: reflect averagedness?
 #endif
 
     if (result_join != QUERY_STYLE_MULTIPLE_DIFFERENT) {
-        sp_jointype_set(spw, query->stroke_linejoin.value);
+        setJoinType(query->stroke_linejoin.value);
     } else {
-        sp_stroke_style_set_join_buttons(spw, NULL);
+        setJoinButtons(NULL);
     }
 
     if (result_cap != QUERY_STYLE_MULTIPLE_DIFFERENT) {
-        sp_captype_set (spw, query->stroke_linecap.value);
+        setCapType (query->stroke_linecap.value);
     } else {
-        sp_stroke_style_set_cap_buttons(spw, NULL);
+        setCapButtons(NULL);
     }
 
     sp_style_unref(query);
@@ -785,21 +698,21 @@ sp_stroke_style_line_update(Gtk::Container *spw, Inkscape::Selection *sel)
     SPStyle * const style = object->style;
 
     /* Markers */
-    sp_stroke_style_update_marker_combo(spw, objects); // FIXME: make this desktop query too
+    updateAllMarkers(objects); // FIXME: make this desktop query too
 
     /* Dash */
-    sp_dash_selector_set_from_style(dsel, style); // FIXME: make this desktop query too
+    setDashSelectorFromStyle(dashSelector, style); // FIXME: make this desktop query too
 
-    sset->set_sensitive(true);
+    table->set_sensitive(true);
 
-    spw->set_data("update", GINT_TO_POINTER(FALSE));
+    update = false;
 }
 
 /**
  * Sets a line's dash properties in a CSS style object.
  */
-static void
-sp_stroke_style_set_scaled_dash(SPCSSAttr *css,
+void
+StrokeStyle::setScaledDash(SPCSSAttr *css,
                                 int ndash, double *dash, double offset,
                                 double scale)
 {
@@ -825,27 +738,15 @@ sp_stroke_style_set_scaled_dash(SPCSSAttr *css,
 /**
  * Sets line properties like width, dashes, markers, etc. on all currently selected items.
  */
-static void
-sp_stroke_style_scale_line(Gtk::Container *spw)
+void
+StrokeStyle::scaleLine()
 {
-    if (spw->get_data("update")) {
+    if (update) {
         return;
     }
 
-    spw->set_data("update", GINT_TO_POINTER(TRUE));
-
-#if WITH_GTKMM_3_0
-    Glib::RefPtr<Gtk::Adjustment> *wadj = static_cast<Glib::RefPtr<Gtk::Adjustment> *>(spw->get_data("width"));
-    Glib::RefPtr<Gtk::Adjustment> *ml = static_cast<Glib::RefPtr<Gtk::Adjustment> *>(spw->get_data("miterlimit"));
-#else
-    Gtk::Adjustment *wadj = static_cast<Gtk::Adjustment *>(spw->get_data("width"));
-    Gtk::Adjustment *ml = static_cast<Gtk::Adjustment *>(spw->get_data("miterlimit"));
-#endif
+    update = true;
     
-    SPUnitSelector *us = SP_UNIT_SELECTOR(spw->get_data("units"));
-    SPDashSelector *dsel = static_cast<SPDashSelector *>(spw->get_data("dash"));
-
-    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
     SPDocument *document = sp_desktop_document (desktop);
     Inkscape::Selection *selection = sp_desktop_selection (desktop);
 
@@ -856,18 +757,18 @@ sp_stroke_style_scale_line(Gtk::Container *spw)
 
     if (items) {
 #if WITH_GTKMM_3_0
-        double width_typed = (*wadj)->get_value();
-        double const miterlimit = (*ml)->get_value();
+        double width_typed = (*widthAdj)->get_value();
+        double const miterlimit = (*miterLimitAdj)->get_value();
 #else
-        double width_typed = wadj->get_value();
-        double const miterlimit = ml->get_value();
+        double width_typed = widthAdj->get_value();
+        double const miterlimit = miterLimitAdj->get_value();
 #endif
 
-        SPUnit const *const unit = sp_unit_selector_get_unit(SP_UNIT_SELECTOR(us));
+        SPUnit const *const unit = sp_unit_selector_get_unit(SP_UNIT_SELECTOR(unitSelector));
 
         double *dash, offset;
         int ndash;
-        dsel->get_dash(&ndash, &dash, &offset);
+        dashSelector->get_dash(&ndash, &dash, &offset);
 
         for (GSList const *i = items; i != NULL; i = i->next) {
             /* Set stroke width */
@@ -892,7 +793,7 @@ sp_stroke_style_scale_line(Gtk::Container *spw)
             }
 
             /* Set dash */
-            sp_stroke_style_set_scaled_dash(css, ndash, dash, offset, width);
+            setScaledDash(css, ndash, dash, offset, width);
 
             sp_desktop_apply_css_recursive (SP_OBJECT(i->data), css, true);
         }
@@ -902,9 +803,9 @@ sp_stroke_style_scale_line(Gtk::Container *spw)
         if (unit->base != SP_UNIT_ABSOLUTE && unit->base != SP_UNIT_DEVICE) {
             // reset to 100 percent
 #if WITH_GTKMM_3_0
-            (*wadj)->set_value(100.0);
+            (*widthAdj)->set_value(100.0);
 #else
-            wadj->set_value(100.0);
+            widthAdj->set_value(100.0);
 #endif
         }
 
@@ -920,35 +821,35 @@ sp_stroke_style_scale_line(Gtk::Container *spw)
     DocumentUndo::done(document, SP_VERB_DIALOG_FILL_STROKE,
                        _("Set stroke style"));
 
-    spw->set_data("update", GINT_TO_POINTER(FALSE));
+    update = false;
 }
 
 /**
  * Callback for when the stroke style's width changes.
  * Causes all line styles to be applied to all selected items.
  */
-static void
-sp_stroke_style_width_changed(Gtk::Container *spw)
+void
+StrokeStyle::widthChangedCB()
 {
-    if (spw->get_data("update")) {
+    if (update) {
         return;
     }
 
-    sp_stroke_style_scale_line(spw);
+    scaleLine();
 }
 
 /**
  * Callback for when the stroke style's miterlimit changes.
  * Causes all line styles to be applied to all selected items.
  */
-static void
-sp_stroke_style_miterlimit_changed(Gtk::Container *spw)
+void
+StrokeStyle::miterLimitChangedCB()
 {
-    if (spw->get_data("update")) {
+    if (update) {
         return;
     }
 
-    sp_stroke_style_scale_line(spw);
+    scaleLine();
 }
 
 /**
@@ -956,14 +857,14 @@ sp_stroke_style_miterlimit_changed(Gtk::Container *spw)
  * Causes all line styles to be applied to all selected items.
  */
 
-static void
-sp_stroke_style_line_dash_changed(Gtk::Container *spw)
+void
+StrokeStyle::lineDashChangedCB()
 {
-    if (spw->get_data("update")) {
+    if (update) {
         return;
     }
 
-    sp_stroke_style_scale_line(spw);
+    scaleLine();
 }
 
 /**
@@ -973,48 +874,45 @@ sp_stroke_style_line_dash_changed(Gtk::Container *spw)
  * calls the respective routines to update css properties, etc.
  *
  */
-static void sp_stroke_style_any_toggled(Gtk::ToggleButton *tb, Gtk::Container *spw)
+void StrokeStyle::buttonToggledCB(Gtk::ToggleButton *tb, StrokeStyle *spw)
 {
-    if (spw->get_data("update")) {
+    if (spw->update) {
         return;
     }
 
-
     if (tb->get_active()) {
 
+        // TODO
         gchar const *join
             = static_cast<gchar const *>(tb->get_data("join"));
         gchar const *cap
             = static_cast<gchar const *>(tb->get_data("cap"));
 
         if (join) {
-            Gtk::SpinButton *ml = static_cast<Gtk::SpinButton *>(spw->get_data("miterlimit_sb"));
-            ml->set_sensitive(!strcmp(join, "miter"));
+            spw->miterLimitSpin->set_sensitive(!strcmp(join, "miter"));
         }
 
-        SPDesktop *desktop = SP_ACTIVE_DESKTOP;
-
         /* TODO: Create some standardized method */
         SPCSSAttr *css = sp_repr_css_attr_new();
 
         if (join) {
             sp_repr_css_set_property(css, "stroke-linejoin", join);
 
-            sp_desktop_set_style (desktop, css);
+            sp_desktop_set_style (spw->desktop, css);
 
-            sp_stroke_style_set_join_buttons(spw, tb);
+            spw->setJoinButtons(tb);
         } else if (cap) {
             sp_repr_css_set_property(css, "stroke-linecap", cap);
 
-            sp_desktop_set_style (desktop, css);
+            sp_desktop_set_style (spw->desktop, css);
 
-            sp_stroke_style_set_cap_buttons(spw, tb);
+            spw->setCapButtons(tb);
         }
 
         sp_repr_css_attr_unref(css);
         css = 0;
 
-        DocumentUndo::done(sp_desktop_document(desktop), SP_VERB_DIALOG_FILL_STROKE,
+        DocumentUndo::done(sp_desktop_document(spw->desktop), SP_VERB_DIALOG_FILL_STROKE,
                            _("Set stroke style"));
     }
 }
@@ -1022,38 +920,24 @@ static void sp_stroke_style_any_toggled(Gtk::ToggleButton *tb, Gtk::Container *s
 /**
  * Updates the join style toggle buttons
  */
-static void
-sp_stroke_style_set_join_buttons(Gtk::Container *spw, Gtk::ToggleButton *active)
+void
+StrokeStyle::setJoinButtons(Gtk::ToggleButton *active)
 {
-    Gtk::RadioButton *tb;
-
-    tb = static_cast<Gtk::RadioButton *>(spw->get_data(INKSCAPE_ICON("stroke-join-miter")));
-    tb->set_active(active == tb);
-
-    Gtk::SpinButton *ml = static_cast<Gtk::SpinButton *>(spw->get_data("miterlimit_sb"));
-    ml->set_sensitive(active == tb);
-
-    tb = static_cast<Gtk::RadioButton *>(spw->get_data(INKSCAPE_ICON("stroke-join-round")));
-    tb->set_active(active == tb);
-
-    tb = static_cast<Gtk::RadioButton *>(spw->get_data(INKSCAPE_ICON("stroke-join-bevel")));
-    tb->set_active(active == tb);
+    joinMiter->set_active(active == joinMiter);
+    miterLimitSpin->set_sensitive(active == joinMiter);
+    joinRound->set_active(active == joinRound);
+    joinBevel->set_active(active == joinBevel);
 }
 
 /**
  * Updates the cap style toggle buttons
  */
-static void
-sp_stroke_style_set_cap_buttons(Gtk::Container *spw, Gtk::ToggleButton *active)
+void
+StrokeStyle::setCapButtons(Gtk::ToggleButton *active)
 {
-    Gtk::RadioButton *tb;
-
-    tb = static_cast<Gtk::RadioButton *>(spw->get_data(INKSCAPE_ICON("stroke-cap-butt")));
-    tb->set_active(active == tb);
-    tb = static_cast<Gtk::RadioButton *>(spw->get_data(INKSCAPE_ICON("stroke-cap-round")));
-    tb->set_active(active == tb);
-    tb = static_cast<Gtk::RadioButton *>(spw->get_data(INKSCAPE_ICON("stroke-cap-square")));
-    tb->set_active(active == tb);
+    capButt->set_active(active == capButt);
+    capRound->set_active(active == capRound);
+    capSquare->set_active(active == capSquare);
 }
 
 
@@ -1061,13 +945,13 @@ sp_stroke_style_set_cap_buttons(Gtk::Container *spw, Gtk::ToggleButton *active)
  * Updates the marker combobox to highlight the appropriate marker and scroll to
  * that marker.
  */
-static void
-sp_stroke_style_update_marker_combo(Gtk::Container *spw, GSList const *objects)
+void
+StrokeStyle::updateAllMarkers(GSList const *objects)
 {
-    struct { char const *key; int loc; } const keyloc[] = {
-            { "start_marker_combobox", SP_MARKER_LOC_START },
-            { "mid_marker_combobox", SP_MARKER_LOC_MID },
-            { "end_marker_combobox", SP_MARKER_LOC_END }
+    struct { MarkerComboBox *key; int loc; } const keyloc[] = {
+            { startMarkerCombo, SP_MARKER_LOC_START },
+            { midMarkerCombo, SP_MARKER_LOC_MID },
+            { endMarkerCombo, SP_MARKER_LOC_END }
     };
 
     bool all_texts = true;
@@ -1078,7 +962,7 @@ sp_stroke_style_update_marker_combo(Gtk::Container *spw, GSList const *objects)
     }
 
     for (unsigned i = 0; i < G_N_ELEMENTS(keyloc); ++i) {
-        MarkerComboBox *combo = static_cast<MarkerComboBox *>(spw->get_data(keyloc[i].key));
+        MarkerComboBox *combo = static_cast<MarkerComboBox *>(keyloc[i].key);
         // Per SVG spec, text objects cannot have markers; disable combobox if only texts are selected
         combo->set_sensitive(!all_texts);
     }
@@ -1091,7 +975,7 @@ sp_stroke_style_update_marker_combo(Gtk::Container *spw, GSList const *objects)
         // For all three marker types,
 
         // find the corresponding combobox item
-        MarkerComboBox *combo = static_cast<MarkerComboBox *>(spw->get_data(keyloc[i].key));
+        MarkerComboBox *combo = static_cast<MarkerComboBox *>(keyloc[i].key);
 
         // Quit if we're in update state
         if (combo->update()) {
@@ -1102,7 +986,7 @@ sp_stroke_style_update_marker_combo(Gtk::Container *spw, GSList const *objects)
             // If the object has this type of markers,
 
             // Extract the name of the marker that the object uses
-            SPObject *marker = ink_extract_marker_name(object->style->marker[keyloc[i].loc].value, object->document);
+            SPObject *marker = getMarkerName(object->style->marker[keyloc[i].loc].value, object->document);
             // Scroll the combobox to that marker
             combo->set_current(marker);
 
@@ -1120,8 +1004,8 @@ sp_stroke_style_update_marker_combo(Gtk::Container *spw, GSList const *objects)
  * \return Buffer containing the actual name, allocated from GLib;
  * the caller should free the buffer when they no longer need it.
  */
-static SPObject*
-ink_extract_marker_name(gchar const *n, SPDocument *doc)
+SPObject*
+StrokeStyle::getMarkerName(gchar const *n, SPDocument *doc)
 {
     gchar const *p = n;
     while (*p != '\0' && *p != '#') {
@@ -1150,6 +1034,9 @@ ink_extract_marker_name(gchar const *n, SPDocument *doc)
     return marker;
 }
 
+} // namespace Inkscape
+
+
 /*
   Local Variables:
   mode:c++