Replace GimpSpinScale by InkSpinScale.

1 files changed, 245 insertions, 0 deletions

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;
+}