Replace GimpSpinScale by InkSpinScale.

9 files changed, 393 insertions, 68 deletions

diff --git a/src/ui/CMakeLists.txt b/src/ui/CMakeLists.txt
index be13d9b1b..fecb14a91 100644
--- a/src/ui/CMakeLists.txt
+++ b/src/ui/CMakeLists.txt
@@ -140,6 +140,8 @@ set(ui_SRC
 	widget/highlight-picker.cpp
 	widget/imageicon.cpp
 	widget/imagetoggler.cpp
+	widget/ink-select-one-action.cpp
+	widget/ink-spinscale.cpp
 	widget/insertordericon.cpp
 	widget/labelled.cpp
 	widget/layer-selector.cpp
@@ -147,7 +149,6 @@ set(ui_SRC
 	widget/licensor.cpp
 	widget/notebook-page.cpp
 	widget/object-composite-settings.cpp
-	widget/ink-select-one-action.cpp
 	widget/page-sizer.cpp
 	widget/panel.cpp
 	widget/point.cpp
@@ -333,13 +334,14 @@ set(ui_SRC
 	widget/insertordericon.h
 	widget/imageicon.h
 	widget/imagetoggler.h
+	widget/ink-select-one-action.h
+	widget/ink-spinscale.h
 	widget/labelled.h
 	widget/layer-selector.h
 	widget/layertypeicon.h
 	widget/licensor.h
 	widget/notebook-page.h
 	widget/object-composite-settings.h
-	widget/ink-select-one-action.h
 	widget/page-sizer.h
 	widget/panel.h
 	widget/point.h
diff --git a/src/ui/dialog/filter-effects-dialog.cpp b/src/ui/dialog/filter-effects-dialog.cpp
index e60785f57..9764618ec 100644
--- a/src/ui/dialog/filter-effects-dialog.cpp
+++ b/src/ui/dialog/filter-effects-dialog.cpp
@@ -842,7 +842,10 @@ public:
     SpinScale* add_spinscale(double def, const SPAttributeEnum attr, const Glib::ustring& label,
                          const double lo, const double hi, const double step_inc, const double climb, const int digits, char* tip_text = NULL)
     {
-        SpinScale* spinslider = new SpinScale("", def, lo, hi, step_inc, climb, digits, attr, tip_text);
+        Glib::ustring tip_text2;
+        if (tip_text)
+            tip_text2 = tip_text;
+        SpinScale* spinslider = new SpinScale("", def, lo, hi, step_inc, climb, digits, attr, tip_text2);
         add_widget(spinslider, label);
         add_attr_widget(spinslider);
         return spinslider;
@@ -850,8 +853,10 @@ public:
 
     // DualSpinScale
     DualSpinScale* add_dualspinscale(const SPAttributeEnum attr, const Glib::ustring& label,
-                                       const double lo, const double hi, const double step_inc,
-                                       const double climb, const int digits, char* tip_text1 = NULL, char* tip_text2 = NULL)
+                                     const double lo, const double hi, const double step_inc,
+                                     const double climb, const int digits,
+                                     const Glib::ustring tip_text1 = "",
+                                     const Glib::ustring tip_text2 = "")
     {
         DualSpinScale* dss = new DualSpinScale("", "", lo, lo, hi, step_inc, climb, digits, attr, tip_text1, tip_text2);
         add_widget(dss, label);
diff --git a/src/ui/widget/filter-effect-chooser.cpp b/src/ui/widget/filter-effect-chooser.cpp
index 7a9d512ac..30506851c 100644
--- a/src/ui/widget/filter-effect-chooser.cpp
+++ b/src/ui/widget/filter-effect-chooser.cpp
@@ -22,7 +22,7 @@ SimpleFilterModifier::SimpleFilterModifier(int flags)
       _lb_blur(_("_Blur:")),
       _lb_blur_unit(_("%")),
       _blend(BlendModeConverter, SP_ATTR_INVALID, false),
-      _blur(_("Blur (%)"), 0, 0, 100, 1, 0.01, 1)
+      _blur(_("Blur (%)"), 0, 0, 100, 1, 1, 1)
 {
     set_name("SimpleFilterModifier");
 
diff --git a/src/ui/widget/ink-spinscale.cpp b/src/ui/widget/ink-spinscale.cpp
new file mode 100644
index 000000000..4fe69633f
--- /dev/null
+++ b/src/ui/widget/ink-spinscale.cpp
@@ -0,0 +1,245 @@
+
+#include "ink-spinscale.h"
+#include <gdkmm/general.h>
+#include <gdkmm/cursor.h>
+#include <gdkmm/event.h>
+
+#include <gtkmm/spinbutton.h>
+
+#include <gdk/gdk.h>
+
+#include <iostream>
+
+// Constructor for Gtk::Range is protected... must derive a new class.
+InkRange::InkRange(Glib::RefPtr<Gtk::Adjustment> adjustment, Gtk::SpinButton* spinbutton)
+  : Glib::ObjectBase("InkRange")
+  , Gtk::Range()
+  , _spinbutton(spinbutton)
+  , _dragging(false)
+  , _drag_start(0)
+  , _drag_offset(0)
+{
+  set_name("InkRange");
+  set_adjustment(adjustment);
+  // std::cout << "GType name: " << G_OBJECT_TYPE_NAME(gobj()) << std::endl;
+}
+
+void
+InkRange::set_label(Glib::ustring label) {
+  _label = label;
+}
+
+bool
+InkRange::on_draw(const::Cairo::RefPtr<::Cairo::Context>& cr) {
+
+  // std::cout << "\nInkRange::on_draw" << std::endl;
+
+  // Get our own style info...
+  // auto style = get_style_context();
+  // auto state = style->get_state();
+  // std::cout << "color:      " << style->get_color( state ).to_string() << std::endl;
+  // std::cout << "background: " << style->get_background_color( state ).to_string() << std::endl;
+  // std::cout << "border:     " << style->get_border_color( state ).to_string() << std::endl;
+  
+  // Get SpinButton style info...
+  auto style_spin = _spinbutton->get_style_context();
+  auto state_spin = style_spin->get_state();
+  Gdk::RGBA text_color = style_spin->get_color( state_spin );
+
+  // Create Pango layout.
+  auto layout_label = create_pango_layout(_label);
+  layout_label->set_ellipsize( Pango::ELLIPSIZE_END );
+  layout_label->set_width(PANGO_SCALE * get_width());
+
+  // Get y location of SpinButton text (to match vertical position of SpinButton text).
+  int x, y;
+  _spinbutton->get_layout_offsets(x, y);
+
+  // Render text in normal text color.
+  cr->save();
+  Gdk::Cairo::set_source_rgba(cr, text_color);
+  cr->set_source_rgba(0, 0, 0, 1);
+  cr->move_to(5, y );
+  layout_label->show_in_cairo_context(cr);
+  cr->restore();
+
+  // Fill widget proportional to value.
+  double fraction = get_fraction();
+
+  // Render bar (over normal text to reduce blurriness).
+  Gdk::RGBA fill_color("rgba(74,144,217,1.0)");
+  Gdk::Cairo::set_source_rgba(cr, fill_color);
+  cr->rectangle(0, 0, get_width() * fraction, get_height());
+  cr->fill_preserve(); // Save rectangle for clipping text.
+
+  // Render text, clipped, in white over bar (TODO: use same color as SpinButton progress bar).
+  cr->save();
+  cr->clip();
+  cr->set_source_rgba(1, 1, 1, 1);
+  cr->move_to(5, y);
+  layout_label->show_in_cairo_context(cr);
+  cr->restore();
+
+  return false;
+}
+
+bool
+InkRange::on_button_press_event(GdkEventButton* button_event) {
+
+  _dragging = true;
+
+  if (! (button_event->state & GDK_MOD1_MASK) ) {
+    set_adjustment_value(button_event->x);
+  }
+
+  // Dragging must be initialized after any adjustment due to button press.
+  _dragging = true;
+  _drag_start  = button_event->x;
+  _drag_offset = get_width() * get_fraction(); 
+
+  return true;
+}
+
+bool
+InkRange::on_button_release_event(GdkEventButton* button_event) {
+
+  _dragging = false;
+  return true;
+}
+
+bool
+InkRange::on_motion_notify_event(GdkEventMotion* motion_event) {
+
+  double x = motion_event->x;
+  double y = motion_event->y;
+
+  if (_dragging) {
+
+    if (! (motion_event->state & GDK_MOD1_MASK) ) {
+      // Absolute change
+      set_adjustment_value(x);
+    } else {
+      // Relative change
+      double xx = (_drag_offset + (x - _drag_start) * 0.1);
+      set_adjustment_value(xx);
+    }
+    return true;
+  }
+
+  if (! (motion_event->state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK))) {
+
+    auto display = get_display();
+    auto cursor = Gdk::Cursor::create(display, Gdk::SB_DOWN_ARROW);
+    // Get Gdk::window (not Gtk::window).. set cursor for entire window.
+    // Would need to unset with leave event.
+    // get_window()->set_cursor( cursor );
+
+    // Can't see how to do this the C++ way since GdkEventMotion
+    // is a structure with a C window member. There is a gdkmm
+    // wrapping function for Gdk::EventMotion but only in unstable.
+    gdk_window_set_cursor( motion_event->window, cursor->gobj() );
+  }
+
+  return false;
+}
+
+double
+InkRange::get_fraction() {
+
+  Glib::RefPtr<Gtk::Adjustment> adjustment = get_adjustment();
+  double upper = adjustment->get_upper();
+  double lower = adjustment->get_lower();
+  double value = adjustment->get_value();
+  double fraction = (value - lower)/(upper - lower);
+
+  return fraction;
+}
+
+void
+InkRange::set_adjustment_value(double x) {
+
+  Glib::RefPtr<Gtk::Adjustment> adjustment = get_adjustment();
+  double upper = adjustment->get_upper();
+  double lower = adjustment->get_lower();
+  double fraction = x / (double)get_width();
+  double value = fraction * (upper - lower) + lower;
+  adjustment->set_value( value );
+}
+
+/*******************************************************************/
+
+InkSpinScale::InkSpinScale(double value, double lower,
+                           double upper, double step_increment,
+                           double page_increment, double page_size)
+{
+  set_name("InkSpinScale");
+
+  g_assert (upper - lower > 0);
+
+  _adjustment = Gtk::Adjustment::create(value,
+                                        lower,
+                                        upper,
+                                        step_increment,
+                                        page_increment,
+                                        page_size);
+
+  _spinbutton  = Gtk::manage(new Gtk::SpinButton(_adjustment));
+  _spinbutton->set_numeric();
+  _spinbutton->signal_key_release_event().connect(sigc::mem_fun(*this,&InkSpinScale::on_key_release_event),false);
+  _range       = Gtk::manage(new InkRange(_adjustment, _spinbutton));
+  pack_end( *_spinbutton,  Gtk::PACK_SHRINK );
+  pack_end( *_range,       Gtk::PACK_EXPAND_WIDGET );
+}
+
+InkSpinScale::InkSpinScale(Glib::RefPtr<Gtk::Adjustment> adjustment)
+  : _adjustment(adjustment)
+{
+  set_name("InkSpinScale");
+
+  g_assert (_adjustment->get_upper() - _adjustment->get_lower() > 0);
+
+  _spinbutton  = Gtk::manage(new Gtk::SpinButton(_adjustment));
+  _spinbutton->set_numeric();
+  _range       = Gtk::manage(new InkRange(_adjustment, _spinbutton));
+  pack_end( *_spinbutton,  Gtk::PACK_SHRINK );
+  pack_end( *_range,       Gtk::PACK_EXPAND_WIDGET );
+}
+
+void
+InkSpinScale::set_label(Glib::ustring label) {
+  _range->set_label(label);
+}
+
+void
+InkSpinScale::set_digits(int digits) {
+  _spinbutton->set_digits(digits);
+}
+
+int
+InkSpinScale::get_digits() const {
+  return _spinbutton->get_digits();
+}
+
+void
+InkSpinScale::set_focus_widget(GtkWidget * focus_widget) {
+  _focus_widget = focus_widget;
+}
+
+// Return focus to canvas.
+bool
+InkSpinScale::on_key_release_event(GdkEventKey* key_event) {
+
+  switch (key_event->keyval) {
+  case GDK_KEY_Escape:
+  case GDK_KEY_Return:
+  case GDK_KEY_KP_Enter:
+    {
+      if (_focus_widget) {
+        gtk_widget_grab_focus( _focus_widget );
+      }
+    }
+    break;
+  }
+
+  return false;
+}
diff --git a/src/ui/widget/ink-spinscale.h b/src/ui/widget/ink-spinscale.h
new file mode 100644
index 000000000..9b67d3891
--- /dev/null
+++ b/src/ui/widget/ink-spinscale.h
@@ -0,0 +1,78 @@
+#ifndef INK_SPINSCALE_H
+#define INK_SPINSCALE_H
+
+#include <glibmm/ustring.h>
+
+#include <gtkmm/box.h>
+#include <gtkmm/range.h>
+
+namespace Gtk {
+  class SpinButton;
+}
+
+class InkRange : public Gtk::Range
+{
+ public:
+  InkRange(Glib::RefPtr<Gtk::Adjustment>, Gtk::SpinButton* spinbutton);
+  ~InkRange() {};
+
+  void set_label(Glib::ustring label);
+
+  bool on_draw(const::Cairo::RefPtr<::Cairo::Context>& cr) override;
+
+ protected:
+
+  bool on_button_press_event(GdkEventButton* button_event) override;
+  bool on_button_release_event(GdkEventButton* button_event) override;
+  bool on_motion_notify_event(GdkEventMotion* motion_event) override;
+
+ private:
+
+  double get_fraction();
+  void set_adjustment_value(double x);
+
+  Gtk::SpinButton * _spinbutton; // Needed to get placement/text color.
+  Glib::ustring _label;
+
+  bool   _dragging;
+  double _drag_start;
+  double _drag_offset;
+};
+
+class InkSpinScale : public Gtk::Box
+{
+ public:
+
+  // Create an InkSpinScale with a new adjustment.
+  InkSpinScale(double value,
+               double lower,
+               double upper,
+               double step_increment = 1,
+               double page_increment = 10,
+               double page_size = 0);
+
+  // Create an InkSpinScale with a preexisting adjustment.
+  InkSpinScale(Glib::RefPtr<Gtk::Adjustment>);
+
+  virtual ~InkSpinScale() {};
+
+  void set_label(Glib::ustring label);
+  void set_digits(int digits);
+  int  get_digits() const;
+  void set_focus_widget(GtkWidget *focus_widget);
+  Glib::RefPtr<Gtk::Adjustment> get_adjustment() { return _adjustment; };
+
+ protected:
+
+  InkRange*                      _range;
+  Gtk::SpinButton*               _spinbutton;
+  Glib::RefPtr<Gtk::Adjustment>  _adjustment;
+  GtkWidget*                     _focus_widget;
+
+  bool on_key_release_event(GdkEventKey* key_event) override;
+
+ private:
+
+};
+
+#endif // INK_SPINSCALE_H
diff --git a/src/ui/widget/object-composite-settings.cpp b/src/ui/widget/object-composite-settings.cpp
index fa3f6e905..ae01c049b 100644
--- a/src/ui/widget/object-composite-settings.cpp
+++ b/src/ui/widget/object-composite-settings.cpp
@@ -52,8 +52,6 @@ ObjectCompositeSettings::ObjectCompositeSettings(unsigned int verb_code, char co
     pack_start(_opacity_vbox, false, false, 2);
     _opacity_vbox.pack_start(_opacity_scale);
 
-    _opacity_scale.set_appearance("compact");
-
     _opacity_scale.signal_value_changed().connect(sigc::mem_fun(*this, &ObjectCompositeSettings::_opacityValueChanged));
 
     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
diff --git a/src/ui/widget/object-composite-settings.h b/src/ui/widget/object-composite-settings.h
index d7525093f..eff1ba800 100644
--- a/src/ui/widget/object-composite-settings.h
+++ b/src/ui/widget/object-composite-settings.h
@@ -46,7 +46,7 @@ private:
     Glib::ustring   _opacity_tag;
 
     Gtk::VBox       _opacity_vbox;
-    Inkscape::UI::Widget::SpinScale _opacity_scale;
+    SpinScale       _opacity_scale;
 
     StyleSubject *_subject;
 
diff --git a/src/ui/widget/spin-scale.cpp b/src/ui/widget/spin-scale.cpp
index c658b4756..94b178a43 100644
--- a/src/ui/widget/spin-scale.cpp
+++ b/src/ui/widget/spin-scale.cpp
@@ -2,6 +2,7 @@
  * Author:
  *
  * Copyright (C) 2012 Author
+ *               2017 Tavmjong Bah
  *
  * Released under GNU GPL.  Read the file 'COPYING' for more information.
  */
@@ -11,50 +12,49 @@
 #include <glibmm/i18n.h>
 #include <glibmm/stringutils.h>
 
-#include "widgets/gimp/gimpspinscale.h"
-
 namespace Inkscape {
 namespace UI {
 namespace Widget {
 
-SpinScale::SpinScale(const char* label, double value, double lower, double upper, double step_inc,
-                     double /*climb_rate*/, int digits, const SPAttributeEnum a, const char* tip_text)
+SpinScale::SpinScale(const Glib::ustring label, double value,
+                     double lower, double upper,
+                     double step_increment, double page_increment, int digits,
+                     const SPAttributeEnum a, const Glib::ustring tip_text)
     : AttrWidget(a, value)
+    , _inkspinscale(value, lower, upper, step_increment, page_increment, 0)
 {
     set_name("SpinScale");
-    _adjustment = Gtk::Adjustment::create(value, lower, upper, step_inc);
-    _spinscale = gimp_spin_scale_new (_adjustment->gobj(), label, digits);
 
-    signal_value_changed().connect(signal_attr_changed().make_slot());
+    _inkspinscale.set_label (label);
+    _inkspinscale.set_digits (digits);
+    _inkspinscale.set_tooltip_text (tip_text);
 
-    pack_start(*Gtk::manage(Glib::wrap(_spinscale)));
+    _adjustment = _inkspinscale.get_adjustment();
 
-    if (tip_text){
-        gtk_widget_set_tooltip_text( _spinscale, tip_text );
-    }
+    signal_value_changed().connect(signal_attr_changed().make_slot());
+
+    pack_start(_inkspinscale);
 
     show_all_children();
 }
 
-SpinScale::SpinScale(const char* label,
-                     Glib::RefPtr<Gtk::Adjustment> adj,
-                     int digits,
-                     const SPAttributeEnum a,
-                     const char* tip_text)
-    : AttrWidget(a, 0.0),
-      _adjustment(adj)
-
+SpinScale::SpinScale(const Glib::ustring label,
+                     Glib::RefPtr<Gtk::Adjustment> adjustment, int digits,
+                     const SPAttributeEnum a, const Glib::ustring tip_text)
+    : AttrWidget(a, 0.0)
+    , _inkspinscale(adjustment)
 {
+    set_name("SpinScale");
 
-    _spinscale = gimp_spin_scale_new (_adjustment->gobj(), label, digits);
+    _inkspinscale.set_label (label);
+    _inkspinscale.set_digits (digits);
+    _inkspinscale.set_tooltip_text (tip_text);
+
+    _adjustment = _inkspinscale.get_adjustment();
 
     signal_value_changed().connect(signal_attr_changed().make_slot());
 
-    pack_start(*Gtk::manage(Glib::wrap(_spinscale)));
-
-    if (tip_text){
-        gtk_widget_set_tooltip_text( _spinscale, tip_text );
-    }
+    pack_start(_inkspinscale);
 
     show_all_children();
 }
@@ -63,16 +63,16 @@ Glib::ustring SpinScale::get_as_attribute() const
 {
     const double val = _adjustment->get_value();
 
-    //if(_spin.get_digits() == 0)
-    //    return Glib::Ascii::dtostr((int)val);
-    //else
+    if( _inkspinscale.get_digits() == 0)
+        return Glib::Ascii::dtostr((int)val);
+    else
         return Glib::Ascii::dtostr(val);
 }
 
 void SpinScale::set_from_attribute(SPObject* o)
 {
     const gchar* val = attribute_value(o);
-    if(val)
+    if (val)
         _adjustment->set_value(Glib::Ascii::strtod(val));
     else
         _adjustment->set_value(get_default()->as_double());
@@ -95,13 +95,7 @@ void SpinScale::set_value(const double val)
 
 void SpinScale::set_focuswidget(GtkWidget *widget)
 {
-    gimp_spin_scale_set_focuswidget(_spinscale, widget);
-}
-
-
-void SpinScale::set_appearance(const gchar* appearance)
-{
-    gimp_spin_scale_set_appearance(_spinscale, appearance);
+    _inkspinscale.set_focus_widget(widget);
 }
 
 const decltype(SpinScale::_adjustment) SpinScale::get_adjustment() const
@@ -115,11 +109,14 @@ decltype(SpinScale::_adjustment) SpinScale::get_adjustment()
 }
 
 
-DualSpinScale::DualSpinScale(const char* label1, const char* label2, double value, double lower, double upper, double step_inc,
-                               double climb_rate, int digits, const SPAttributeEnum a, char* tip_text1, char* tip_text2)
+DualSpinScale::DualSpinScale(const Glib::ustring label1, const Glib::ustring label2,
+                             double value, double lower, double upper,
+                             double step_increment, double page_increment, int digits,
+                             const SPAttributeEnum a,
+                             const Glib::ustring tip_text1, const Glib::ustring tip_text2)
     : AttrWidget(a),
-      _s1(label1, value, lower, upper, step_inc, climb_rate, digits, SP_ATTR_INVALID, tip_text1),
-      _s2(label2, value, lower, upper, step_inc, climb_rate, digits, SP_ATTR_INVALID, tip_text2),
+      _s1(label1, value, lower, upper, step_increment, page_increment, digits, SP_ATTR_INVALID, tip_text1),
+      _s2(label2, value, lower, upper, step_increment, page_increment, digits, SP_ATTR_INVALID, tip_text2),
       //TRANSLATORS: "Link" means to _link_ two sliders together
       _link(C_("Sliders", "Link"))
 {
@@ -132,7 +129,7 @@ DualSpinScale::DualSpinScale(const char* label1, const char* label2, double valu
 
     _link.signal_toggled().connect(sigc::mem_fun(*this, &DualSpinScale::link_toggled));
 
-    Gtk::VBox* vb = Gtk::manage(new Gtk::VBox);
+    Gtk::Box* vb = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL));
     vb->add(_s1);
     vb->add(_s2);
     pack_start(*vb);
@@ -199,12 +196,6 @@ SpinScale& DualSpinScale::get_SpinScale2()
     return _s2;
 }
 
-/*void DualSpinScale::remove_scale()
-{
-    _s1.remove_scale();
-    _s2.remove_scale();
-}*/
-
 void DualSpinScale::link_toggled()
 {
     _s2.set_sensitive(!_link.get_active());
diff --git a/src/ui/widget/spin-scale.h b/src/ui/widget/spin-scale.h
index 33731f256..123f527bb 100644
--- a/src/ui/widget/spin-scale.h
+++ b/src/ui/widget/spin-scale.h
@@ -2,6 +2,7 @@
  * Author:
  *
  * Copyright (C) 2012 Author
+ *               2017 Tavmjong Bah
  *
  * Released under GNU GPL.  Read the file 'COPYING' for more information.
  */
@@ -16,27 +17,30 @@
 #include <gtkmm/adjustment.h>
 #include <gtkmm/box.h>
 #include <gtkmm/togglebutton.h>
-#include "spinbutton.h"
 #include "attr-widget.h"
+#include "ink-spinscale.h"
 
 namespace Inkscape {
 namespace UI {
 namespace Widget {
 
 /**
- * Wrap the gimpspinscale class
- * A combo widget with label, scale slider, spinbutton, and adjustment
+ * Wrap the InkSpinScale class and attach an attribute.
+ * A combo widget with label, scale slider, spinbutton, and adjustment;
  */
 class SpinScale : public Gtk::Box, public AttrWidget
 {
 
 public:
-    SpinScale(const char* label, double value, double lower, double upper, double step_inc, double climb_rate,
-	       int digits, const SPAttributeEnum a = SP_ATTR_INVALID, const char* tip_text = NULL);
+    SpinScale(const Glib::ustring label, double value,
+              double lower, double upper,
+              double step_increment, double page_increment, int digits,
+              const SPAttributeEnum a = SP_ATTR_INVALID, const Glib::ustring tip_text = "");
 
-    SpinScale(const char* label,
-              Glib::RefPtr<Gtk::Adjustment> adj,
-	      int digits, const SPAttributeEnum a = SP_ATTR_INVALID, const char* tip_text = NULL);
+    // Used by extensions
+    SpinScale(const Glib::ustring label,
+              Glib::RefPtr<Gtk::Adjustment> adjustment, int digits,
+              const SPAttributeEnum a = SP_ATTR_INVALID, const Glib::ustring tip_text = "");
 
     virtual Glib::ustring get_as_attribute() const;
     virtual void set_from_attribute(SPObject*);
@@ -46,11 +50,10 @@ public:
     double get_value() const;
     void set_value(const double);
     void set_focuswidget(GtkWidget *widget);
-    void set_appearance(const gchar* appearance);
     
 private:
     Glib::RefPtr<Gtk::Adjustment> _adjustment;
-    GtkWidget *_spinscale;
+    InkSpinScale _inkspinscale;
 
 public:
     const decltype(_adjustment) get_adjustment() const;
@@ -66,8 +69,11 @@ public:
 class DualSpinScale : public Gtk::Box, public AttrWidget
 {
 public:
-    DualSpinScale(const char* label1, const char* label2, double value, double lower, double upper, double step_inc,
-                   double climb_rate, int digits, const SPAttributeEnum, char* tip_text1, char* tip_text2);
+    DualSpinScale(const Glib::ustring label1, const Glib::ustring label2,
+                  double value, double lower, double upper,
+                  double step_increment, double page_increment, int digits,
+                  const SPAttributeEnum a,
+                  const Glib::ustring tip_text1, const Glib::ustring tip_text2);
 
     virtual Glib::ustring get_as_attribute() const;
     virtual void set_from_attribute(SPObject*);