libs/gtkmm2ext/barcontroller.cc

   1 /*
   2     Copyright (C) 2004 Paul Davis
   3     This program is free software; you can redistribute it and/or modify
   4     it under the terms of the GNU General Public License as published by
   5     the Free Software Foundation; either version 2 of the License, or
   6     (at your option) any later version.
   7
   8     This program is distributed in the hope that it will be useful,
   9     but WITHOUT ANY WARRANTY; without even the implied warranty of
  10     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11     GNU General Public License for more details.
  12
  13     You should have received a copy of the GNU General Public License
  14     along with this program; if not, write to the Free Software
  15     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  16
  17     $Id$
  18 */
  19
  20 #include <string>
  21 #include <climits>
  22 #include <cstdio>
  23 #include <cmath>
  24 #include <algorithm>
  25
  26 #include <pbd/controllable.h>
  27
  28 #include <gtkmm2ext/gtk_ui.h>
  29 #include <gtkmm2ext/utils.h>
  30 #include <gtkmm2ext/barcontroller.h>
  31
  32 #include "i18n.h"
  33
  34 using namespace std;
  35 using namespace Gtk;
  36 using namespace Gtkmm2ext;
  37
  38 BarController::BarController (Gtk::Adjustment& adj,
  39                               PBD::Controllable& mc,
  40                               sigc::slot<void,char*,unsigned int> lc)
  41
  42         : adjustment (adj),
  43           binding_proxy (mc),
  44           label_callback (lc),
  45           spinner (adjustment)
  46
  47 {
  48         _style = LeftToRight;
  49         grabbed = false;
  50         switching = false;
  51         switch_on_release = false;
  52         with_text = true;
  53         use_parent = false;
  54
  55         layout = darea.create_pango_layout("");
  56
  57         set_shadow_type (SHADOW_NONE);
  58
  59         initial_value = adjustment.get_value ();
  60
  61         adjustment.signal_value_changed().connect (mem_fun (*this, &Gtk::Widget::queue_draw));
  62         adjustment.signal_changed().connect (mem_fun (*this, &Gtk::Widget::queue_draw));
  63
  64         darea.add_events (Gdk::BUTTON_RELEASE_MASK|
  65                           Gdk::BUTTON_PRESS_MASK|
  66                           Gdk::POINTER_MOTION_MASK|
  67                           Gdk::ENTER_NOTIFY_MASK|
  68                           Gdk::LEAVE_NOTIFY_MASK|
  69                           Gdk::SCROLL_MASK);
  70
  71         darea.signal_expose_event().connect (mem_fun (*this, &BarController::expose));
  72         darea.signal_motion_notify_event().connect (mem_fun (*this, &BarController::motion));
  73         darea.signal_button_press_event().connect (mem_fun (*this, &BarController::button_press), false);
  74         darea.signal_button_release_event().connect (mem_fun (*this, &BarController::button_release), false);
  75         darea.signal_scroll_event().connect (mem_fun (*this, &BarController::scroll));
  76
  77         spinner.signal_activate().connect (mem_fun (*this, &BarController::entry_activated));
  78         spinner.signal_focus_out_event().connect (mem_fun (*this, &BarController::entry_focus_out));
  79         spinner.set_digits (3);
  80
  81         add (darea);
  82         show_all ();
  83 }
  84
  85 void
  86 BarController::drop_grab ()
  87 {
  88         if (grabbed) {
  89                 grabbed = false;
  90                 darea.remove_modal_grab();
  91                 StopGesture ();
  92         }
  93 }
  94
  95 bool
  96 BarController::button_press (GdkEventButton* ev)
  97 {
  98         double fract;
  99
 100         if (binding_proxy.button_press_handler (ev)) {
 101                 return true;
 102         }
 103
 104         switch (ev->button) {
 105         case 1:
 106                 if (ev->type == GDK_2BUTTON_PRESS) {
 107                         switch_on_release = true;
 108                         drop_grab ();
 109                 } else {
 110                         switch_on_release = false;
 111                         darea.add_modal_grab();
 112                         grabbed = true;
 113                         grab_x = ev->x;
 114                         grab_window = ev->window;
 115                         StartGesture ();
 116                 }
 117                 return true;
 118                 break;
 119
 120         case 2:
 121                 fract = ev->x / (darea.get_width() - 2.0);
 122                 adjustment.set_value (adjustment.get_lower() + fract * (adjustment.get_upper() - adjustment.get_lower()));
 123
 124         case 3:
 125                 break;
 126
 127         case 4:
 128         case 5:
 129                 break;
 130         }
 131
 132         return false;
 133 }
 134
 135 bool
 136 BarController::button_release (GdkEventButton* ev)
 137 {
 138         drop_grab ();
 139
 140         switch (ev->button) {
 141         case 1:
 142                 if (switch_on_release) {
 143                         Glib::signal_idle().connect (mem_fun (*this, &BarController::switch_to_spinner));
 144                         return true;
 145                 }
 146
 147                 if ((ev->state & (GDK_SHIFT_MASK|GDK_CONTROL_MASK)) == GDK_SHIFT_MASK) {
 148                         adjustment.set_value (initial_value);
 149                 } else {
 150                         double scale;
 151
 152                         if (ev->state & (GDK_CONTROL_MASK|GDK_SHIFT_MASK) == (GDK_CONTROL_MASK|GDK_SHIFT_MASK)) {
 153                                 scale = 0.01;
 154                         } else if (ev->state & GDK_CONTROL_MASK) {
 155                                 scale = 0.1;
 156                         } else {
 157                                 scale = 1.0;
 158                         }
 159
 160                         mouse_control (ev->x, ev->window, scale);
 161                 }
 162                 break;
 163
 164         case 2:
 165                 break;
 166
 167         case 3:
 168                 return false;
 169
 170         default:
 171                 break;
 172         }
 173
 174         return true;
 175 }
 176
 177 bool
 178 BarController::scroll (GdkEventScroll* ev)
 179 {
 180         double scale;
 181
 182         if (ev->state & (GDK_CONTROL_MASK|GDK_SHIFT_MASK) == (GDK_CONTROL_MASK|GDK_SHIFT_MASK)) {
 183                 scale = 0.01;
 184         } else if (ev->state & GDK_CONTROL_MASK) {
 185                 scale = 0.1;
 186         } else {
 187                 scale = 1.0;
 188         }
 189
 190         switch (ev->direction) {
 191         case GDK_SCROLL_UP:
 192         case GDK_SCROLL_RIGHT:
 193                 adjustment.set_value (adjustment.get_value() + (scale * adjustment.get_step_increment()));
 194                 break;
 195
 196         case GDK_SCROLL_DOWN:
 197         case GDK_SCROLL_LEFT:
 198                 adjustment.set_value (adjustment.get_value() - (scale * adjustment.get_step_increment()));
 199                 break;
 200         }
 201
 202         return true;
 203 }
 204
 205 bool
 206 BarController::motion (GdkEventMotion* ev)
 207 {
 208         double scale;
 209
 210         if (!grabbed) {
 211                 return true;
 212         }
 213
 214         if ((ev->state & (GDK_SHIFT_MASK|GDK_CONTROL_MASK)) == GDK_SHIFT_MASK) {
 215                 return TRUE;
 216         }
 217
 218         if (ev->state & (GDK_CONTROL_MASK|GDK_SHIFT_MASK) == (GDK_CONTROL_MASK|GDK_SHIFT_MASK)) {
 219                 scale = 0.01;
 220         } else if (ev->state & GDK_CONTROL_MASK) {
 221                 scale = 0.1;
 222         } else {
 223                 scale = 1.0;
 224         }
 225
 226         return mouse_control (ev->x, ev->window, scale);
 227 }
 228
 229 gint
 230 BarController::mouse_control (double x, GdkWindow* window, double scaling)
 231 {
 232         double fract = 0.0;
 233         double delta;
 234
 235         if (window != grab_window) {
 236                 grab_x = x;
 237                 grab_window = window;
 238                 return TRUE;
 239         }
 240
 241         delta = x - grab_x;
 242         grab_x = x;
 243
 244         switch (_style) {
 245         case Line:
 246         case LeftToRight:
 247                 fract = scaling * (delta / (darea.get_width() - 2));
 248                 fract = min (1.0, fract);
 249                 fract = max (-1.0, fract);
 250                 adjustment.set_value (adjustment.get_value() + fract * (adjustment.get_upper() - adjustment.get_lower()));
 251                 break;
 252
 253         default:
 254                 fract = 0.0;
 255         }
 256
 257
 258         return TRUE;
 259 }
 260
 261 bool
 262 BarController::expose (GdkEventExpose* event)
 263 {
 264         Glib::RefPtr<Gdk::Window> win (darea.get_window());
 265         Widget* parent;
 266         gint x1=0, x2=0, y1=0, y2=0;
 267         gint w, h;
 268         double fract;
 269
 270         w = darea.get_width() - 2;
 271         h = darea.get_height() - 2;
 272
 273         fract = ((adjustment.get_value() - adjustment.get_lower()) /
 274                  (adjustment.get_upper() - adjustment.get_lower()));
 275
 276         switch (_style) {
 277         case Line:
 278                 h = darea.get_height();
 279                 x1 = (gint) floor (w * fract);
 280                 x2 = x1;
 281                 y1 = 0;
 282                 y2 = h - 1;
 283
 284                 if (use_parent) {
 285                         parent = get_parent();
 286
 287                         if (parent) {
 288                                 win->draw_rectangle (parent->get_style()->get_fg_gc (parent->get_state()),
 289                                                      true,
 290                                                      0, 0, darea.get_width(), darea.get_height());
 291                         }
 292
 293                 } else {
 294
 295                         win->draw_rectangle (get_style()->get_bg_gc (get_state()),
 296                                              true,
 297                                              0, 0, darea.get_width() - ((darea.get_width()+1) % 2), darea.get_height());
 298                 }
 299
 300                 win->draw_line (get_style()->get_fg_gc (get_state()), x1, 0, x1, h);
 301                 break;
 302
 303         case CenterOut:
 304                 break;
 305
 306         case LeftToRight:
 307                 x1 = 0;
 308                 x2 = (gint) floor (w * fract);
 309                 y1 = 0;
 310                 y2 = h - 1;
 311
 312                 win->draw_rectangle (get_style()->get_bg_gc (get_state()),
 313                                     false,
 314                                     0, 0, darea.get_width() - 1, darea.get_height() - 1);
 315
 316                 /* draw active box */
 317
 318                 win->draw_rectangle (get_style()->get_fg_gc (get_state()),
 319                                     true,
 320                                     1 + x1,
 321                                     1 + y1,
 322                                     x2,
 323                                     1 + y2);
 324
 325                 /* draw inactive box */
 326
 327                 win->draw_rectangle (get_style()->get_fg_gc (STATE_INSENSITIVE),
 328                                     true,
 329                                     1 + x2,
 330                                     1 + y1,
 331                                     w - x2,
 332                                     1 + y2);
 333
 334                 break;
 335
 336         case RightToLeft:
 337                 break;
 338         case TopToBottom:
 339                 break;
 340         case BottomToTop:
 341                 break;
 342         }
 343
 344         if (with_text) {
 345                 /* draw label */
 346
 347                 char buf[64];
 348                 buf[0] = '\0';
 349
 350                 label_callback (buf, 64);
 351
 352                 if (buf[0] != '\0') {
 353
 354                         layout->set_text (buf);
 355
 356                         int width, height;
 357                         layout->get_pixel_size (width, height);
 358
 359                         int xpos;
 360
 361                         xpos = max (3, 1 + (x2 - (width/2)));
 362                         xpos = min (darea.get_width() - width - 3, xpos);
 363
 364                         win->draw_layout (get_style()->get_text_gc (get_state()),
 365                                           xpos,
 366                                           (darea.get_height()/2) - (height/2),
 367                                           layout);
 368                 }
 369         }
 370
 371         return true;
 372 }
 373
 374 void
 375 BarController::set_with_text (bool yn)
 376 {
 377         if (with_text != yn) {
 378                 with_text = yn;
 379                 queue_draw ();
 380         }
 381 }
 382
 383 void
 384 BarController::set_style (Style s)
 385 {
 386         _style = s;
 387         darea.queue_draw ();
 388 }
 389
 390 gint
 391 BarController::switch_to_bar ()
 392 {
 393         if (switching) {
 394                 return FALSE;
 395         }
 396
 397         switching = true;
 398
 399         if (get_child() == &darea) {
 400                 return FALSE;
 401         }
 402
 403         remove ();
 404         add (darea);
 405         darea.show ();
 406
 407         switching = false;
 408         return FALSE;
 409 }
 410
 411 gint
 412 BarController::switch_to_spinner ()
 413 {
 414         if (switching) {
 415                 return FALSE;
 416         }
 417
 418         switching = true;
 419
 420         if (get_child() == &spinner) {
 421                 return FALSE;
 422         }
 423
 424         remove ();
 425         add (spinner);
 426         spinner.show ();
 427         spinner.select_region (0, spinner.get_text_length());
 428         spinner.grab_focus ();
 429
 430         switching = false;
 431         return FALSE;
 432 }
 433
 434 void
 435 BarController::entry_activated ()
 436 {
 437         string text = spinner.get_text ();
 438         float val;
 439
 440         if (sscanf (text.c_str(), "%f", &val) == 1) {
 441                 adjustment.set_value (val);
 442         }
 443
 444         switch_to_bar ();
 445 }
 446
 447 bool
 448 BarController::entry_focus_out (GdkEventFocus* ev)
 449 {
 450         entry_activated ();
 451         return true;
 452 }
 453
 454 void
 455 BarController::set_use_parent (bool yn)
 456 {
 457         use_parent = yn;
 458         queue_draw ();
 459 }
 460
 461 void
 462 BarController::set_sensitive (bool yn)
 463 {
 464         Frame::set_sensitive (yn);
 465         darea.set_sensitive (yn);
 466 }