Merge branch 'master' into powerpencilII

17 files changed, 542 insertions, 171 deletions

diff --git a/src/ui/widget/color-notebook.cpp b/src/ui/widget/color-notebook.cpp
index bd4b21bdb..cda41bdb7 100644
--- a/src/ui/widget/color-notebook.cpp
+++ b/src/ui/widget/color-notebook.cpp
@@ -55,6 +55,8 @@ ColorNotebook::ColorNotebook(SelectedColor &color)
     : Gtk::Grid()
     , _selected_color(color)
 {
+    set_name("ColorNotebook");
+
     Page *page;
 
     page = new Page(new ColorScalesFactory(SP_COLOR_SCALES_MODE_RGB), true);
@@ -321,9 +323,11 @@ void ColorNotebook::_addPage(Page &page)
 
         Glib::ustring mode_name = page.selector_factory->modeName();
         Gtk::Widget *tab_label = Gtk::manage(new Gtk::Label(mode_name));
+        tab_label->set_name("ColorModeLabel");
         gint page_num = gtk_notebook_append_page(GTK_NOTEBOOK(_book), selector_widget->gobj(), tab_label->gobj());
 
         _buttons[page_num] = gtk_radio_button_new_with_label(NULL, mode_name.c_str());
+        gtk_widget_set_name(_buttons[page_num], "ColorModeButton");
         gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(_buttons[page_num]), FALSE);
         if (page_num > 0) {
             auto g = Glib::wrap(GTK_RADIO_BUTTON(_buttons[0]))->get_group();
diff --git a/src/ui/widget/color-wheel-selector.cpp b/src/ui/widget/color-wheel-selector.cpp
index 6bbb8e21d..ffdf173ba 100644
--- a/src/ui/widget/color-wheel-selector.cpp
+++ b/src/ui/widget/color-wheel-selector.cpp
@@ -31,6 +31,8 @@ ColorWheelSelector::ColorWheelSelector(SelectedColor &color)
     , _wheel(0)
     , _slider(0)
 {
+    set_name("ColorWheelSelector");
+
     _initUI();
     _color_changed_connection = color.signal_changed.connect(sigc::mem_fun(this, &ColorWheelSelector::_colorChanged));
     _color_dragged_connection = color.signal_dragged.connect(sigc::mem_fun(this, &ColorWheelSelector::_colorChanged));
diff --git a/src/ui/widget/dock-item.cpp b/src/ui/widget/dock-item.cpp
index 4a06163e1..29f22977a 100644
--- a/src/ui/widget/dock-item.cpp
+++ b/src/ui/widget/dock-item.cpp
@@ -29,8 +29,7 @@ DockItem::DockItem(Dock& dock, const Glib::ustring& name, const Glib::ustring& l
     _x(0),
     _y(0),
     _grab_focus_on_realize(false),
-    _gdl_dock_item(0),
-    _dock_item_action_area(0)
+    _gdl_dock_item(0)
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     GdlDockItemBehavior gdl_dock_behavior =
diff --git a/src/ui/widget/dock-item.h b/src/ui/widget/dock-item.h
index b5f6c13af..31cdcf080 100644
--- a/src/ui/widget/dock-item.h
+++ b/src/ui/widget/dock-item.h
@@ -108,11 +108,10 @@ private:
     Glib::RefPtr<Gdk::Pixbuf> _icon_pixbuf;
 
     /** Interface widgets, will be packed like 
-     * gdl_dock_item -> _frame -> _dock_item_box -> (_dock_item_action_area) 
+     * gdl_dock_item -> _frame -> _dock_item_box
      */
     Gtk::Frame _frame;
     Gtk::VBox _dock_item_box;
-    Gtk::HButtonBox *_dock_item_action_area;
 
     /** Internal signal handlers */
     void _onHide();
diff --git a/src/ui/widget/dock.cpp b/src/ui/widget/dock.cpp
index 20ec707d8..9c1f0f783 100644
--- a/src/ui/widget/dock.cpp
+++ b/src/ui/widget/dock.cpp
@@ -56,7 +56,8 @@ Dock::Dock(Gtk::Orientation orientation)
 #endif
       _scrolled_window (Gtk::manage(new Gtk::ScrolledWindow))
 {
-    _scrolled_window->set_name("Dock");
+    gtk_widget_set_name(_gdl_dock, "GdlDock");
+
 #if WITH_GDL_3_6
     gtk_orientable_set_orientation(GTK_ORIENTABLE(_gdl_dock_bar),
                                    static_cast<GtkOrientation>(orientation));
@@ -65,25 +66,22 @@ Dock::Dock(Gtk::Orientation orientation)
                                  static_cast<GtkOrientation>(orientation));
 #endif
 
-    switch(orientation) {
-        case Gtk::ORIENTATION_VERTICAL:
-            _dock_box = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL));
-            break;
-        case Gtk::ORIENTATION_HORIZONTAL:
-            _dock_box = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL));
-    }
-    
-    _paned = Gtk::manage(new Gtk::Paned(orientation));
+    _filler.set_name("DockBoxFiller");
 
-    _scrolled_window->add(*_dock_box);
-    _scrolled_window->set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
-
-    _paned->pack1(*Glib::wrap(GTK_WIDGET(_gdl_dock)), false, false);
-    _paned->pack2(_filler, true, false);
+    _paned = Gtk::manage(new Gtk::Paned(orientation));
+    _paned->set_name("DockBoxPane");
+    _paned->pack1(*Glib::wrap(GTK_WIDGET(_gdl_dock)), false,  false);
+    _paned->pack2(_filler,                            true,   false);
+    //                                                resize, shrink
 
+    _dock_box = Gtk::manage(new Gtk::Box(orientation));
+    _dock_box->set_name("DockBox");
     _dock_box->pack_start(*_paned, Gtk::PACK_EXPAND_WIDGET);
     _dock_box->pack_end(*Gtk::manage(Glib::wrap(GTK_WIDGET(_gdl_dock_bar))), Gtk::PACK_SHRINK);
 
+    _scrolled_window->set_name("DockScrolledWindow");
+    _scrolled_window->add(*_dock_box);
+    _scrolled_window->set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
     _scrolled_window->set_size_request(0);
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
@@ -215,7 +213,6 @@ void Dock::toggleDockable(int width, int height)
         parent_paned->set_position(prev_horizontal_position);
         _paned->set_position(prev_vertical_position);
     }
-
 }
 
 void Dock::scrollToItem(DockItem& item)
diff --git a/src/ui/widget/dock.h b/src/ui/widget/dock.h
index 6258a06e3..efdb6fa39 100644
--- a/src/ui/widget/dock.h
+++ b/src/ui/widget/dock.h
@@ -70,7 +70,7 @@ protected:
     Gtk::Paned          *_paned;
     GtkWidget           *_gdl_dock;
     GdlDockBar          *_gdl_dock_bar;
-    Gtk::VBox            _filler;
+    Gtk::Box             _filler;
     Gtk::ScrolledWindow *_scrolled_window;
 
     /** Internal signal handlers */
diff --git a/src/ui/widget/filter-effect-chooser.cpp b/src/ui/widget/filter-effect-chooser.cpp
index 7a9d512ac..c19aa037a 100644
--- a/src/ui/widget/filter-effect-chooser.cpp
+++ b/src/ui/widget/filter-effect-chooser.cpp
@@ -3,8 +3,9 @@
  *
  * Author:
  *   Nicholas Bishop <nicholasbishop@gmail.com>
+ *   Tavmjong Bah
  *
- * Copyright (C) 2007 Authors
+ * Copyright (C) 2007, 2017 Authors
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
@@ -18,11 +19,11 @@ namespace UI {
 namespace Widget {
 
 SimpleFilterModifier::SimpleFilterModifier(int flags)
-    : _lb_blend(_("Blend mode:")),
-      _lb_blur(_("_Blur:")),
-      _lb_blur_unit(_("%")),
-      _blend(BlendModeConverter, SP_ATTR_INVALID, false),
-      _blur(_("Blur (%)"), 0, 0, 100, 1, 0.01, 1)
+    : _flags( flags )
+    , _lb_blend(_("Blend mode:"))
+    , _blend(BlendModeConverter, SP_ATTR_INVALID, false)
+    , _blur(   _("Blur (%)"   ), 0, 0, 100, 1, 1, 1)
+    , _opacity(_("Opacity (%)"), 0, 0, 100, 1, 1, 1)
 {
     set_name("SimpleFilterModifier");
 
@@ -30,25 +31,40 @@ SimpleFilterModifier::SimpleFilterModifier(int flags)
 
     if (flags & BLEND) {
         add(_hb_blend);
+        _lb_blend.set_use_underline();
+        _lb_blend.set_mnemonic_widget(_blend);
         _hb_blend.pack_start(_lb_blend, false, false, 0);
         _hb_blend.pack_start(_blend);
     }
+
     if (flags & BLUR) {
         add(_blur);
     }
 
+    if (flags & OPACITY) {
+        add(_opacity);
+    }
+
     show_all_children();
 
-    _hb_blend.set_spacing(12);
-    _lb_blend.set_use_underline();
-    _lb_blend.set_mnemonic_widget(_blend);
-    _blend.signal_changed().connect(signal_blend_blur_changed());
-    _blur.signal_value_changed().connect(signal_blend_blur_changed());
+    _blend.signal_changed().connect(signal_blend_changed());
+    _blur.signal_value_changed().connect(signal_blur_changed());
+    _opacity.signal_value_changed().connect(signal_opacity_changed());
+}
+
+sigc::signal<void>& SimpleFilterModifier::signal_blend_changed()
+{
+    return _signal_blend_changed;
+}
+
+sigc::signal<void>& SimpleFilterModifier::signal_blur_changed()
+{
+    return _signal_blur_changed;
 }
 
-sigc::signal<void>& SimpleFilterModifier::signal_blend_blur_changed()
+sigc::signal<void>& SimpleFilterModifier::signal_opacity_changed()
 {
-    return _signal_blend_blur_changed;
+    return _signal_opacity_changed;
 }
 
 const Glib::ustring SimpleFilterModifier::get_blend_mode()
@@ -75,9 +91,14 @@ void SimpleFilterModifier::set_blur_value(const double val)
     _blur.set_value(val);
 }
 
-void SimpleFilterModifier::set_blur_sensitive(const bool s)
+double SimpleFilterModifier::get_opacity_value() const
+{
+    return _opacity.get_value();
+}
+
+void SimpleFilterModifier::set_opacity_value(const double val)
 {
-    _blur.set_sensitive(s);
+    _opacity.set_value(val);
 }
 
 }
diff --git a/src/ui/widget/filter-effect-chooser.h b/src/ui/widget/filter-effect-chooser.h
index 0bcf97433..148f44d04 100644
--- a/src/ui/widget/filter-effect-chooser.h
+++ b/src/ui/widget/filter-effect-chooser.h
@@ -6,8 +6,9 @@
  *
  * Author:
  *   Nicholas Bishop <nicholasbishop@gmail.com>
+ *   Tavmjong Bah
  *
- * Copyright (C) 2007 Authors
+ * Copyright (C) 2007, 2017 Authors
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
@@ -23,40 +24,47 @@ namespace Inkscape {
 namespace UI {
 namespace Widget {
 
-/* Allows basic control over feBlend and feGaussianBlur effects,
-   with an option to use the full filter effect controls. */
+/* Allows basic control over feBlend and feGaussianBlur effects as well as opacity.
+ *  Common for Object, Layers, and Fill and Stroke dialogs.
+*/
 class SimpleFilterModifier : public Gtk::VBox
 {
 public:
     enum Flags {
-      NONE=0,
-      BLUR=1,
-      BLEND=2
+      NONE   = 0,
+      BLUR   = 1,
+      OPACITY= 2,
+      BLEND  = 4
     };
 
     SimpleFilterModifier(int flags);
 
-    sigc::signal<void>& signal_blend_blur_changed();
+    sigc::signal<void>& signal_blend_changed();
+    sigc::signal<void>& signal_blur_changed();
+    sigc::signal<void>& signal_opacity_changed();
 
     const Glib::ustring get_blend_mode();
     // Uses blend mode enum values, or -1 for a complex filter
     void set_blend_mode(const int);
 
     double get_blur_value() const;
-    void set_blur_value(const double);
-    void set_blur_sensitive(const bool);
-    Gtk::Label *get_blur_label() { return &_lb_blur; };
+    void   set_blur_value(const double);
+
+    double get_opacity_value() const;
+    void   set_opacity_value(const double);
 
 private:
     int _flags;
-    Gtk::HBox _hb_blend;
-    Gtk::HBox _hb_blur;
-    Gtk::Label _lb_blend, _lb_blur, _lb_blur_unit;
 
+    Gtk::HBox _hb_blend;
+    Gtk::Label _lb_blend;
     ComboBoxEnum<Inkscape::Filters::FilterBlendMode> _blend;
     SpinScale _blur;
+    SpinScale _opacity;
 
-    sigc::signal<void> _signal_blend_blur_changed;
+    sigc::signal<void> _signal_blend_changed;
+    sigc::signal<void> _signal_blur_changed;
+    sigc::signal<void> _signal_opacity_changed;
 };
 
 }
diff --git a/src/ui/widget/ink-select-one-action.cpp b/src/ui/widget/ink-select-one-action.cpp
index 40bafecc2..dedfb8894 100644
--- a/src/ui/widget/ink-select-one-action.cpp
+++ b/src/ui/widget/ink-select-one-action.cpp
@@ -31,22 +31,22 @@
 #include <gtkmm/image.h>
 
 InkSelectOneAction* InkSelectOneAction::create(const Glib::ustring &name,
-                                               const Glib::ustring &label,
+                                               const Glib::ustring &group_label,
                                                const Glib::ustring &tooltip,
                                                const Glib::ustring &stock_id,
                                                Glib::RefPtr<Gtk::ListStore> store ) {
 
-    return new InkSelectOneAction(name, label, tooltip, stock_id, store);
+    return new InkSelectOneAction(name, group_label, tooltip, stock_id, store);
 }
 
 InkSelectOneAction::InkSelectOneAction (const Glib::ustring &name,
-                                        const Glib::ustring &label,
+                                        const Glib::ustring &group_label,
                                         const Glib::ustring &tooltip,
                                         const Glib::ustring &stock_id,
                                         Glib::RefPtr<Gtk::ListStore> store ) :
-    Gtk::Action(name, stock_id, label, tooltip),
+    Gtk::Action(name, stock_id, group_label, tooltip),
     _name( name ),
-    _label( label ),
+    _group_label( group_label ),
     _tooltip( tooltip ),
     _stock_id( stock_id ),
     _store (store),
@@ -136,6 +136,11 @@ Gtk::Widget* InkSelectOneAction::create_tool_item_vfunc() {
         Gtk::Box* box = Gtk::manage(new Gtk::Box());
         tool_item->add (*box);  
 
+        if (_use_group_label) {
+            Gtk::Label *group_label = Gtk::manage (new Gtk::Label( _group_label + ": " ));
+            box->add( *group_label );
+        }
+
         Gtk::RadioAction::Group group;
         int index = 0;
         auto children = _store->children();
@@ -167,6 +172,10 @@ Gtk::Widget* InkSelectOneAction::create_tool_item_vfunc() {
             box->add (*item);
         }
 
+        if (_radioaction) {
+            _radioaction->set_current_value (_active);
+        }
+
         _radioaction->signal_changed().connect( sigc::mem_fun(*this, &InkSelectOneAction::on_changed_radioaction));
 
     } else {
diff --git a/src/ui/widget/ink-select-one-action.h b/src/ui/widget/ink-select-one-action.h
index 194ca8027..0b1b08de4 100644
--- a/src/ui/widget/ink-select-one-action.h
+++ b/src/ui/widget/ink-select-one-action.h
@@ -61,6 +61,7 @@ public:
     void use_radio( bool use_radio ) { _use_radio = use_radio; }
     void use_label( bool use_label ) { _use_label = use_label; }
     void use_icon(  bool use_icon  ) { _use_icon  = use_icon;  }
+    void use_group_label( bool use_group_label ) { _use_group_label = use_group_label; }
   
     gint get_active() { return _active; }
     void set_active( gint active );
@@ -81,7 +82,7 @@ protected:
 private:
 
     Glib::ustring _name;
-    Glib::ustring _label;
+    Glib::ustring _group_label;
     Glib::ustring _tooltip;
     Glib::ustring _stock_id;
     Glib::RefPtr<Gtk::ListStore> _store;
@@ -92,6 +93,7 @@ private:
     bool _use_radio;  // Applies to tool item only
     bool _use_label;
     bool _use_icon;   // Applies to menu item only
+    bool _use_group_label; // Applies to tool item only
     Gtk::BuiltinIconSize _icon_size;
 
     /* Combobox in tool */
@@ -109,7 +111,7 @@ private:
     void on_toggled_radiomenu(int n);
 
     InkSelectOneAction (const Glib::ustring &name,
-                        const Glib::ustring &label,
+                        const Glib::ustring &group_label,
                         const Glib::ustring &tooltip,
                         const Glib::ustring &stock_id,
                         Glib::RefPtr<Gtk::ListStore> store );
diff --git a/src/ui/widget/ink-spinscale.cpp b/src/ui/widget/ink-spinscale.cpp
new file mode 100644
index 000000000..ab7ceffc4
--- /dev/null
+++ b/src/ui/widget/ink-spinscale.cpp
@@ -0,0 +1,260 @@
+/*
+ * Authors:
+ *   Tavmjong Bah <tavmjong@free.fr>
+ *
+ * Copyright  (C) 2017 Tavmjong Bah
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+/** \file
+   A widget that allows entering a numerical value either by
+   clicking/dragging on a custom Gtk::Scale or by using a
+   Gtk::SpinButton. The custom Gtk::Scale differs from the stock
+   Gtk::Scale in that it includes a label to save space and has a
+   "slow dragging" mode triggered by the Alt key.
+*/
+
+#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>
+
+InkScale::InkScale(Glib::RefPtr<Gtk::Adjustment> adjustment, Gtk::SpinButton* spinbutton)
+  : Glib::ObjectBase("InkScale")
+  , Gtk::Scale(adjustment)
+  , _spinbutton(spinbutton)
+  , _dragging(false)
+  , _drag_start(0)
+  , _drag_offset(0)
+{
+  set_name("InkScale");
+  // std::cout << "GType name: " << G_OBJECT_TYPE_NAME(gobj()) << std::endl;
+}
+
+void
+InkScale::set_label(Glib::ustring label) {
+  _label = label;
+}
+
+bool
+InkScale::on_draw(const::Cairo::RefPtr<::Cairo::Context>& cr) {
+
+  Gtk::Range::on_draw(cr);
+
+  // 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);
+
+  // Fill widget proportional to value.
+  double fraction = get_fraction();
+
+  // Get trough rectangle and clipping point for text.
+  Gdk::Rectangle slider_area = get_range_rect();
+  double clip_text_x = slider_area.get_x() + slider_area.get_width() * fraction;
+
+  // Render text in normal text color.
+  cr->save();
+  cr->rectangle(clip_text_x, 0, get_width(), get_height());
+  cr->clip();
+  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();
+
+  // Render text, clipped, in white over bar (TODO: use same color as SpinButton progress bar).
+  cr->save();
+  cr->rectangle(0, 0, clip_text_x, get_height());
+  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 true;
+}
+
+bool
+InkScale::on_button_press_event(GdkEventButton* button_event) {
+
+  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
+InkScale::on_button_release_event(GdkEventButton* button_event) {
+
+  _dragging = false;
+  return true;
+}
+
+bool
+InkScale::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
+InkScale::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
+InkScale::set_adjustment_value(double x) {
+
+  Glib::RefPtr<Gtk::Adjustment> adjustment = get_adjustment();
+  double upper = adjustment->get_upper();
+  double lower = adjustment->get_lower();
+
+  Gdk::Rectangle slider_area = get_range_rect();
+  double fraction = (x - slider_area.get_x()) / (double)slider_area.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);
+
+  _scale       = Gtk::manage(new InkScale(_adjustment, _spinbutton));
+  _scale->set_draw_value(false);
+
+  pack_end( *_spinbutton,  Gtk::PACK_SHRINK );
+  pack_end( *_scale,       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();
+
+  _scale       = Gtk::manage(new InkScale(_adjustment, _spinbutton));
+  _scale->set_draw_value(false);
+
+  pack_end( *_spinbutton,  Gtk::PACK_SHRINK );
+  pack_end( *_scale,       Gtk::PACK_EXPAND_WIDGET );
+}
+
+void
+InkSpinScale::set_label(Glib::ustring label) {
+  _scale->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..ff8ad352e
--- /dev/null
+++ b/src/ui/widget/ink-spinscale.h
@@ -0,0 +1,95 @@
+#ifndef INK_SPINSCALE_H
+#define INK_SPINSCALE_H
+
+/*
+ * Authors:
+ *   Tavmjong Bah <tavmjong@free.fr>
+ *
+ * Copyright  (C) 2017 Tavmjong Bah
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+/**
+   A widget that allows entering a numerical value either by
+   clicking/dragging on a custom Gtk::Scale or by using a
+   Gtk::SpinButton. The custom Gtk::Scale differs from the stock
+   Gtk::Scale in that it includes a label to save space and has a
+   "slow-dragging" mode triggered by the Alt key.
+*/
+
+#include <glibmm/ustring.h>
+
+#include <gtkmm/box.h>
+#include <gtkmm/scale.h>
+
+namespace Gtk {
+  class SpinButton;
+}
+
+class InkScale : public Gtk::Scale
+{
+ public:
+  InkScale(Glib::RefPtr<Gtk::Adjustment>, Gtk::SpinButton* spinbutton);
+  ~InkScale() {};
+
+  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:
+
+  InkScale*                      _scale;
+  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..161f5ba4f 100644
--- a/src/ui/widget/object-composite-settings.cpp
+++ b/src/ui/widget/object-composite-settings.cpp
@@ -33,44 +33,24 @@ namespace Widget {
 
 ObjectCompositeSettings::ObjectCompositeSettings(unsigned int verb_code, char const *history_prefix, int flags)
 : _verb_code(verb_code),
+  _blend_tag(Glib::ustring(history_prefix) + ":blend"),
   _blur_tag(Glib::ustring(history_prefix) + ":blur"),
   _opacity_tag(Glib::ustring(history_prefix) + ":opacity"),
-  _opacity_vbox(false, 0),
-  _opacity_scale(_("Opacity (%)"), 100.0, 0.0, 100.0, 1.0, 1.0, 1),
-  _fe_cb(flags),
-  _fe_vbox(false, 0),
+  _filter_modifier(flags),
   _blocked(false)
 {
-    set_name( "CompositeSettings");
+    set_name( "ObjectCompositeSettings");
 
     // Filter Effects
-    pack_start(_fe_vbox, false, false, 2);
-    _fe_vbox.pack_start(_fe_cb, false, false, 0);
-    _fe_cb.signal_blend_blur_changed().connect(sigc::mem_fun(*this, &ObjectCompositeSettings::_blendBlurValueChanged));
+    pack_start(_filter_modifier, false, false, 2);
 
-    // Opacity
-    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));
+    _filter_modifier.signal_blend_changed().connect(sigc::mem_fun(*this, &ObjectCompositeSettings::_blendBlurValueChanged));
+    _filter_modifier.signal_blur_changed().connect(sigc::mem_fun(*this, &ObjectCompositeSettings::_blendBlurValueChanged));
+    _filter_modifier.signal_opacity_changed().connect(sigc::mem_fun(*this, &ObjectCompositeSettings::_opacityValueChanged));
 
     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
-    _opacity_scale.set_focuswidget(GTK_WIDGET(desktop->canvas));
-
-    /* SizeGroup keeps the blur and opacity labels aligned in Fill & Stroke dlg */
-/*
-    GtkSizeGroup *labels = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
-    gtk_size_group_add_widget(labels, GTK_WIDGET(_opacity_label.gobj()));
-    gtk_size_group_add_widget(labels, GTK_WIDGET(_fe_cb.get_blur_label()->gobj()));
-*/
 
     show_all_children();
-
-    // These signals don't properly detect change in desktop, rely on owner dialog to call setSubject() from setTargetDesktop()
-    //_desktop_activated = g_signal_connect ( G_OBJECT (INKSCAPE), "activate_desktop", G_CALLBACK (&ObjectCompositeSettings::_on_desktop_activate), this );
-    //_desktop_activated = g_signal_connect ( G_OBJECT (INKSCAPE), "deactivate_desktop", G_CALLBACK (&ObjectCompositeSettings::_on_desktop_deactivate), this );
 }
 
 ObjectCompositeSettings::~ObjectCompositeSettings() {
@@ -86,6 +66,12 @@ void ObjectCompositeSettings::setSubject(StyleSubject *subject) {
     }
 }
 
+// We get away with sharing one callback for blend and blur as this is used by
+//  * the Layers dialog where only one layer can be selected at a time,
+//  * the Fill and Stroke dialog where only blur is used.
+// If both blend and blur are used in a dialog where more than one object can
+// be selected then this should be split into separate functions for blend and
+// blur (like in the Objects dialog).
 void
 ObjectCompositeSettings::_blendBlurValueChanged()
 {
@@ -110,12 +96,12 @@ ObjectCompositeSettings::_blendBlurValueChanged()
     double radius;
     if (bbox) {
         double perimeter = bbox->dimensions()[Geom::X] + bbox->dimensions()[Geom::Y];   // fixme: this is only half the perimeter, is that correct?
-        radius = _fe_cb.get_blur_value() * perimeter / 400;
+        radius = _filter_modifier.get_blur_value() * perimeter / 400;
     } else {
         radius = 0;
     }
 
-    const Glib::ustring blendmode = _fe_cb.get_blend_mode();
+    const Glib::ustring blendmode = _filter_modifier.get_blend_mode();
 
     //apply created filter to every selected item
     std::vector<SPObject*> sel = _subject->list();
@@ -150,7 +136,7 @@ ObjectCompositeSettings::_blendBlurValueChanged()
     }
 
     DocumentUndo::maybeDone(document, _blur_tag.c_str(), _verb_code,
-                            _("Change blur"));
+                            _("Change blur/blend filter"));
 
     // resume interruptibility
     //sp_canvas_end_forced_full_redraws(desktop->getCanvas());
@@ -174,15 +160,10 @@ ObjectCompositeSettings::_opacityValueChanged()
         return;
     _blocked = true;
 
-    // FIXME: fix for GTK breakage, see comment in SelectedStyle::on_opacity_changed; here it results in crash 1580903
-    // UPDATE: crash fixed in GTK+ 2.10.7 (bug 374378), remove this as soon as it's reasonably common
-    // (though this only fixes the crash, not the multiple change events)
-    //sp_canvas_force_full_redraw_after_interruptions(desktop->getCanvas(), 0);
-
     SPCSSAttr *css = sp_repr_css_attr_new ();
 
     Inkscape::CSSOStringStream os;
-    os << CLAMP (_opacity_scale.get_adjustment()->get_value() / 100, 0.0, 1.0);
+    os << CLAMP (_filter_modifier.get_opacity_value() / 100, 0.0, 1.0);
     sp_repr_css_set_property (css, "opacity", os.str().c_str());
 
     _subject->setCSS(css);
@@ -218,14 +199,11 @@ ObjectCompositeSettings::_subjectChanged() {
 
     switch (result) {
         case QUERY_STYLE_NOTHING:
-            _opacity_vbox.set_sensitive(false);
-            // gtk_widget_set_sensitive (opa, FALSE);
             break;
         case QUERY_STYLE_SINGLE:
         case QUERY_STYLE_MULTIPLE_AVERAGED: // TODO: treat this slightly differently
         case QUERY_STYLE_MULTIPLE_SAME:
-            _opacity_vbox.set_sensitive(true);
-            _opacity_scale.get_adjustment()->set_value(100 * SP_SCALE24_TO_FLOAT(query.opacity.value));
+            _filter_modifier.set_opacity_value(100 * SP_SCALE24_TO_FLOAT(query.opacity.value));
             break;
     }
 
@@ -233,16 +211,13 @@ ObjectCompositeSettings::_subjectChanged() {
     const int blend_result = _subject->queryStyle(&query, QUERY_STYLE_PROPERTY_BLEND);
     switch(blend_result) {
         case QUERY_STYLE_NOTHING:
-            _fe_cb.set_sensitive(false);
             break;
         case QUERY_STYLE_SINGLE:
         case QUERY_STYLE_MULTIPLE_SAME:
-            _fe_cb.set_blend_mode(query.filter_blend_mode.value);
-            _fe_cb.set_sensitive(true);
+            _filter_modifier.set_blend_mode(query.filter_blend_mode.value);
             break;
         case QUERY_STYLE_MULTIPLE_DIFFERENT:
             // TODO: set text
-            _fe_cb.set_sensitive(false);
             break;
     }
 
@@ -250,7 +225,7 @@ ObjectCompositeSettings::_subjectChanged() {
         int blur_result = _subject->queryStyle(&query, QUERY_STYLE_PROPERTY_BLUR);
         switch (blur_result) {
             case QUERY_STYLE_NOTHING: //no blurring
-                _fe_cb.set_blur_sensitive(false);
+                _filter_modifier.set_blur_value(0);
                 break;
             case QUERY_STYLE_SINGLE:
             case QUERY_STYLE_MULTIPLE_AVERAGED:
@@ -258,16 +233,23 @@ ObjectCompositeSettings::_subjectChanged() {
                 Geom::OptRect bbox = _subject->getBounds(SPItem::GEOMETRIC_BBOX);
                 if (bbox) {
                     double perimeter = bbox->dimensions()[Geom::X] + bbox->dimensions()[Geom::Y];   // fixme: this is only half the perimeter, is that correct?
-                    _fe_cb.set_blur_sensitive(true);
                     //update blur widget value
                     float radius = query.filter_gaussianBlur_deviation.value;
                     float percent = radius * 400 / perimeter; // so that for a square, 100% == half side
-                    _fe_cb.set_blur_value(percent);
+                    _filter_modifier.set_blur_value(percent);
                 }
                 break;
         }
     }
 
+    // If we have nothing selected, disable dialog.
+    if (result       == QUERY_STYLE_NOTHING &&
+        blend_result == QUERY_STYLE_NOTHING ) {
+        _filter_modifier.set_sensitive( false );
+    } else {
+        _filter_modifier.set_sensitive( true );
+    }
+
     _blocked = false;
 }
 
diff --git a/src/ui/widget/object-composite-settings.h b/src/ui/widget/object-composite-settings.h
index d7525093f..9e810bc00 100644
--- a/src/ui/widget/object-composite-settings.h
+++ b/src/ui/widget/object-composite-settings.h
@@ -18,7 +18,6 @@
 #include <glibmm/ustring.h>
 
 #include "ui/widget/filter-effect-chooser.h"
-#include "ui/widget/spinbutton.h"
 
 class SPDesktop;
 struct InkscapeApplication;
@@ -42,16 +41,13 @@ public:
 
 private:
     unsigned int    _verb_code;
+    Glib::ustring   _blend_tag;
     Glib::ustring   _blur_tag;
     Glib::ustring   _opacity_tag;
 
-    Gtk::VBox       _opacity_vbox;
-    Inkscape::UI::Widget::SpinScale _opacity_scale;
-
     StyleSubject *_subject;
 
-    SimpleFilterModifier _fe_cb;
-    Gtk::VBox       _fe_vbox;
+    SimpleFilterModifier _filter_modifier;
 
     bool _blocked;
     gulong _desktop_activated;
diff --git a/src/ui/widget/preferences-widget.cpp b/src/ui/widget/preferences-widget.cpp
index 8b8e663a5..345864a44 100644
--- a/src/ui/widget/preferences-widget.cpp
+++ b/src/ui/widget/preferences-widget.cpp
@@ -96,7 +96,7 @@ void DialogPage::add_line(bool                 indent,
         label_widget->set_mnemonic_widget(widget);
         
         if (indent) {
-#if WITH_GTKMM_3_12
+#if GTKMM_CHECK_VERSION(3,12,0)
             label_widget->set_margin_start(12);
 #else
             label_widget->set_margin_left(12);
@@ -112,7 +112,7 @@ void DialogPage::add_line(bool                 indent,
     if (label == "")
     {
         if (indent) {
-#if WITH_GTKMM_3_12
+#if GTKMM_CHECK_VERSION(3,12,0)
             hb->set_margin_start(12);
 #else
             hb->set_margin_left(12);
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*);