Towards packing CairoWidgets on ArdourCanvas.

[ardour.git] / libs / gtkmm2ext / auto_spin.cc

diff --git a/libs/gtkmm2ext/auto_spin.cc b/libs/gtkmm2ext/auto_spin.cc
index ba2a3cf76e71e3c7309b2fc090a1b945b38f8f33..2c70cb4293e16ec7fcc4fde659f666fb97fed3ee 100644 (file)
--- a/libs/gtkmm2ext/auto_spin.cc
+++ b/libs/gtkmm2ext/auto_spin.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 1999 Paul Barton-Davis 
+    Copyright (C) 1999 Paul Barton-Davis
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -18,8 +18,9 @@
     $Id$
 */
 
-#include <gtkmm2ext/auto_spin.h>
 #include <cmath>
+#include "gtkmm2ext/auto_spin.h"
+#include "gtkmm2ext/keyboard.h"
 
 using namespace Gtkmm2ext;
 using namespace std;
@@ -33,12 +34,12 @@ const unsigned int AutoSpin::initial_timer_interval = 500;   /* msecs */
 const unsigned int AutoSpin::timer_interval = 20;            /* msecs */
 const unsigned int AutoSpin::climb_timer_calls = 5;    /* between climbing */
 
-AutoSpin::AutoSpin (Gtk::Adjustment &adjr, gfloat cr, bool round_to_steps_yn) 
+AutoSpin::AutoSpin (Gtk::Adjustment &adjr, gfloat cr, bool round_to_steps_yn)
        : adjustment (adjr),
          climb_rate (cr)
 
 {
-       initial = adjustment.get_value();
+       initial = adjustment.get_value ();
        left_is_decrement = true;
        wrap = false;
        have_timer = false;
@@ -51,13 +52,13 @@ void
 AutoSpin::stop_timer ()
 {
        if (have_timer) {
-               gtk_timeout_remove (timeout_tag);
-               have_timer = false;     
+               g_source_remove (timeout_tag);
+               have_timer = false;
        }
 }
 
 gint
-AutoSpin::stop_spinning (GdkEventButton *ev)
+AutoSpin::stop_spinning (GdkEventButton */*ev*/)
 {
        need_timer = false;
        stop_timer ();
@@ -73,13 +74,17 @@ AutoSpin::button_press (GdkEventButton *ev)
 
        stop_spinning (0);
 
-       if (ev->state & GDK_SHIFT_MASK) {
+       if (ev->type == GDK_2BUTTON_PRESS || ev->type == GDK_3BUTTON_PRESS ) {
+               return true;
+       }
+
+       if (ev->state & Keyboard::TertiaryModifier) {
                /* use page shift */
 
                shifted = true;
        }
 
-       if (ev->state & GDK_CONTROL_MASK) {
+       if (ev->state & Keyboard::PrimaryModifier) {
                /* go to upper/lower bound on button1/button2 */
 
                control = true;
@@ -88,72 +93,96 @@ AutoSpin::button_press (GdkEventButton *ev)
        /* XXX should figure out which button is left/right */
 
        switch (ev->button) {
-       case 1:
-               if (control) {
-                       set_value (left_is_decrement ? lower : upper);
-                       return TRUE;
-               } else {
-                       if (left_is_decrement) {
-                               with_decrement = true;
+               case 1:
+                       if (control) {
+                               set_value (left_is_decrement ? lower : upper);
+                               return TRUE;
                        } else {
-                               with_decrement = false;
+                               if (left_is_decrement) {
+                                       with_decrement = true;
+                               } else {
+                                       with_decrement = false;
+                               }
                        }
-               }
-               break;
-
-       case 2:
-               if (!control) {
-                       set_value (initial);
-               }
-               return TRUE;
-               break;
+                       break;
 
-       case 3:
-               if (control) {
-                       set_value (left_is_decrement ? upper : lower);
+               case 2:
+                       if (!control) {
+                               set_value (initial);
+                       }
                        return TRUE;
-               }
-               break;
+                       break;
 
-       case 4:
-               if (!control) {
-                       adjust_value (shifted ? page_increment : step_increment);
-               } else {
-                       set_value (upper);
-               }
-               return TRUE;
-               break;
+               case 3:
+                       if (control) {
+                               set_value (left_is_decrement ? upper : lower);
+                               return TRUE;
+                       }
+                       break;
 
-       case 5:
-               if (!control) {
-                       adjust_value (shifted ? -page_increment : -step_increment);
-               } else {
-                       set_value (lower);
-               }
-               return TRUE;
-               break;
-       } 
+               case 4:
+                       if (!control) {
+                               adjust_value (shifted ? page_increment : step_increment);
+                       } else {
+                               set_value (upper);
+                       }
+                       return TRUE;
+                       break;
+
+               case 5:
+                       if (!control) {
+                               adjust_value (shifted ? -page_increment : -step_increment);
+                       } else {
+                               set_value (lower);
+                       }
+                       return TRUE;
+                       break;
+       }
 
        start_spinning (with_decrement, shifted);
        return TRUE;
 }
 
+gint
+AutoSpin::scroll_event (GdkEventScroll *ev)
+{
+       stop_spinning (0);
+
+       gfloat increment = step_increment;
+
+       if (ev->state & Keyboard::TertiaryModifier) {
+               increment = page_increment;
+       }
+
+       switch (ev->direction) {
+               case GDK_SCROLL_DOWN:
+               case GDK_SCROLL_LEFT:
+                       adjust_value (-increment);
+                       break;
+               case GDK_SCROLL_RIGHT:
+               case GDK_SCROLL_UP:
+                       adjust_value (increment);
+                       break;
+       }
+       return TRUE;
+}
+
 void
 AutoSpin::start_spinning (bool decrement, bool page)
 {
        timer_increment = page ? page_increment : step_increment;
 
-       if (decrement) { 
+       if (decrement) {
                timer_increment = -timer_increment;
        }
 
        adjust_value (timer_increment);
-       
+
        have_timer = true;
        timer_calls = 0;
-       timeout_tag = gtk_timeout_add (initial_timer_interval,
-                                      AutoSpin::_timer,
-                                      this);
+       timeout_tag = g_timeout_add (initial_timer_interval,
+                       AutoSpin::_timer,
+                       this);
 }
 
 gint
@@ -177,7 +206,7 @@ AutoSpin::adjust_value (gfloat increment)
        gfloat val;
        bool done = false;
 
-       val = adjustment.get_value();
+       val = adjustment.get_value ();
 
        val += increment;
 
@@ -197,7 +226,7 @@ AutoSpin::adjust_value (gfloat increment)
                }
        }
 
-       set_value(val);
+       set_value (val);
        return done;
 }
 
@@ -214,22 +243,22 @@ AutoSpin::timer ()
                /* we're in the initial call, which happened
                   after initial_timer_interval msecs. Now
                   request a much more frequent update.
-               */
-               
-               timeout_tag = gtk_timeout_add (timer_interval,
-                                              _timer,
-                                              this);
+                  */
+
+               timeout_tag = g_timeout_add (timer_interval,
+                               _timer,
+                               this);
                have_timer = true;
                need_timer = false;
 
                /* cancel this initial timeout */
-               
+
                retval = FALSE;
 
-       } else { 
+       } else {
                /* this is the regular "fast" call after each
-                  timer_interval msecs. 
-               */
+                  timer_interval msecs.
+                  */
 
                if (timer_calls < climb_timer_calls) {
                        timer_calls++;
@@ -250,19 +279,19 @@ AutoSpin::timer ()
        }
 
        return retval;
-}      
+}
 
 void
 AutoSpin::set_bounds (gfloat init, gfloat up, gfloat down, bool with_reset)
 {
-       adjustment.set_upper(up);
-       adjustment.set_lower(down);
+       adjustment.set_upper (up);
+       adjustment.set_lower (down);
 
        initial = init;
-       
+
        adjustment.changed ();
-       
+
        if (with_reset) {
                adjustment.set_value (init);
        }
-} 
+}