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         if (binding_proxy.button_press_handler (ev)) {
  99                 return true;
 100         }
 101
 102         switch (ev->button) {
 103         case 1:
 104                 if (ev->type == GDK_2BUTTON_PRESS) {
 105                         switch_on_release = true;
 106                         drop_grab ();
 107                 } else {
 108                         switch_on_release = false;
 109                         darea.add_modal_grab();
 110                         grabbed = true;
 111                         grab_x = ev->x;
 112                         grab_window = ev->window;
 113                         StartGesture ();
 114                 }
 115                 return true;
 116                 break;
 117
 118         case 2:
 119         case 3:
 120                 break;
 121
 122         case 4:
 123         case 5:
 124                 break;
 125         }
 126
 127         return false;
 128 }
 129
 130 bool
 131 BarController::button_release (GdkEventButton* ev)
 132 {
 133         double fract;
 134
 135         drop_grab ();
 136
 137         switch (ev->button) {
 138         case 1:
 139                 if (switch_on_release) {
 140                         Glib::signal_idle().connect (mem_fun (*this, &BarController::switch_to_spinner));
 141                         return true;
 142                 }
 143
 144                 if ((ev->state & (GDK_SHIFT_MASK|GDK_CONTROL_MASK)) == GDK_SHIFT_MASK) {
 145                         adjustment.set_value (initial_value);
 146                 } else {
 147                         double scale;
 148
 149                         if (ev->state & (GDK_CONTROL_MASK|GDK_SHIFT_MASK) == (GDK_CONTROL_MASK|GDK_SHIFT_MASK)) {
 150                                 scale = 0.01;
 151                         } else if (ev->state & GDK_CONTROL_MASK) {
 152                                 scale = 0.1;
 153                         } else {
 154                                 scale = 1.0;
 155                         }
 156
 157                         mouse_control (ev->x, ev->window, scale);
 158                 }
 159                 break;
 160
 161         case 2:
 162                 fract = ev->x / (darea.get_width() - 2.0);
 163                 adjustment.set_value (adjustment.get_lower() + fract * (adjustment.get_upper() - adjustment.get_lower()));
 164                 break;
 165
 166         case 3:
 167                 return false;
 168
 169         default:
 170                 break;
 171         }
 172
 173         return true;
 174 }
 175
 176 bool
 177 BarController::scroll (GdkEventScroll* ev)
 178 {
 179         double scale;
 180
 181         if (ev->state & (GDK_CONTROL_MASK|GDK_SHIFT_MASK) == (GDK_CONTROL_MASK|GDK_SHIFT_MASK)) {
 182                 scale = 0.01;
 183         } else if (ev->state & GDK_CONTROL_MASK) {
 184                 scale = 0.1;
 185         } else {
 186                 scale = 1.0;
 187         }
 188
 189         switch (ev->direction) {
 190         case GDK_SCROLL_UP:
 191         case GDK_SCROLL_RIGHT:
 192                 adjustment.set_value (adjustment.get_value() + (scale * adjustment.get_step_increment()));
 193                 break;
 194
 195         case GDK_SCROLL_DOWN:
 196         case GDK_SCROLL_LEFT:
 197                 adjustment.set_value (adjustment.get_value() - (scale * adjustment.get_step_increment()));
 198                 break;
 199         }
 200
 201         return true;
 202 }
 203
 204 bool
 205 BarController::motion (GdkEventMotion* ev)
 206 {
 207         double scale;
 208
 209         if (!grabbed) {
 210                 return true;
 211         }
 212
 213         if ((ev->state & (GDK_SHIFT_MASK|GDK_CONTROL_MASK)) == GDK_SHIFT_MASK) {
 214                 return TRUE;
 215         }
 216
 217         if (ev->state & (GDK_CONTROL_MASK|GDK_SHIFT_MASK) == (GDK_CONTROL_MASK|GDK_SHIFT_MASK)) {
 218                 scale = 0.01;
 219         } else if (ev->state & GDK_CONTROL_MASK) {
 220                 scale = 0.1;
 221         } else {
 222                 scale = 1.0;
 223         }
 224
 225         return mouse_control (ev->x, ev->window, scale);
 226 }
 227
 228 gint
 229 BarController::mouse_control (double x, GdkWindow* window, double scaling)
 230 {
 231         double fract;
 232         double delta;
 233
 234         if (window != grab_window) {
 235                 grab_x = x;
 236                 grab_window = window;
 237                 return TRUE;
 238         }
 239
 240         delta = x - grab_x;
 241         grab_x = x;
 242
 243         switch (_style) {
 244         case Line:
 245         case LeftToRight:
 246                 fract = scaling * (delta / (darea.get_width() - 2));
 247                 fract = min (1.0, fract);
 248                 fract = max (-1.0, fract);
 249                 adjustment.set_value (adjustment.get_value() + fract * (adjustment.get_upper() - adjustment.get_lower()));
 250                 break;
 251
 252         default:
 253                 fract = 0.0;
 254         }
 255
 256
 257         return TRUE;
 258 }
 259
 260 bool
 261 BarController::expose (GdkEventExpose* event)
 262 {
 263         Glib::RefPtr<Gdk::Window> win (darea.get_window());
 264         Widget* parent;
 265         gint x1, x2, y1, y2;
 266         gint w, h;
 267         double fract;
 268
 269         w = darea.get_width() - 2;
 270         h = darea.get_height() - 2;
 271
 272         fract = ((adjustment.get_value() - adjustment.get_lower()) /
 273                  (adjustment.get_upper() - adjustment.get_lower()));
 274
 275         switch (_style) {
 276         case Line:
 277                 x1 = (gint) floor (w * fract);
 278                 x2 = x1;
 279                 y1 = 0;
 280                 y2 = h - 1;
 281
 282                 if (use_parent) {
 283                         parent = get_parent();
 284
 285                         if (parent) {
 286                                 win->draw_rectangle (parent->get_style()->get_fg_gc (parent->get_state()),
 287                                                      true,
 288                                                      0, 0, darea.get_width(), darea.get_height());
 289                         }
 290
 291                 } else {
 292
 293                         win->draw_rectangle (get_style()->get_bg_gc (get_state()),
 294                                              true,
 295                                              0, 0, darea.get_width(), darea.get_height());
 296                 }
 297
 298                 win->draw_line (get_style()->get_base_gc (get_state()), x1, 0, x1, darea.get_height());
 299                 break;
 300
 301         case CenterOut:
 302                 break;
 303
 304         case LeftToRight:
 305                 x1 = 0;
 306                 x2 = (gint) floor (w * fract);
 307                 y1 = 0;
 308                 y2 = h - 1;
 309
 310                 win->draw_rectangle (get_style()->get_bg_gc (get_state()),
 311                                     false,
 312                                     0, 0, darea.get_width() - 1, darea.get_height() - 1);
 313
 314                 /* draw active box */
 315
 316                 win->draw_rectangle (get_style()->get_fg_gc (get_state()),
 317                                     true,
 318                                     1 + x1,
 319                                     1 + y1,
 320                                     x2,
 321                                     1 + y2);
 322
 323                 /* draw inactive box */
 324
 325                 win->draw_rectangle (get_style()->get_fg_gc (STATE_INSENSITIVE),
 326                                     true,
 327                                     1 + x2,
 328                                     1 + y1,
 329                                     w - x2,
 330                                     1 + y2);
 331
 332                 break;
 333
 334         case RightToLeft:
 335                 break;
 336         case TopToBottom:
 337                 break;
 338         case BottomToTop:
 339                 break;
 340         }
 341
 342         if (with_text) {
 343                 /* draw label */
 344
 345                 char buf[64];
 346                 buf[0] = '\0';
 347
 348                 label_callback (buf, 64);
 349
 350                 if (buf[0] != '\0') {
 351
 352                         layout->set_text (buf);
 353
 354                         int width, height;
 355                         layout->get_pixel_size (width, height);
 356
 357                         int xpos;
 358
 359                         xpos = max (3, 1 + (x2 - (width/2)));
 360                         xpos = min (darea.get_width() - width - 3, xpos);
 361
 362                         win->draw_layout (get_style()->get_text_gc (get_state()),
 363                                           xpos,
 364                                           (darea.get_height()/2) - (height/2),
 365                                           layout);
 366                 }
 367         }
 368
 369         return true;
 370 }
 371
 372 void
 373 BarController::set_with_text (bool yn)
 374 {
 375         if (with_text != yn) {
 376                 with_text = yn;
 377                 queue_draw ();
 378         }
 379 }
 380
 381 void
 382 BarController::set_style (Style s)
 383 {
 384         _style = s;
 385         darea.queue_draw ();
 386 }
 387
 388 gint
 389 BarController::switch_to_bar ()
 390 {
 391         if (switching) {
 392                 return FALSE;
 393         }
 394
 395         switching = true;
 396
 397         if (get_child() == &darea) {
 398                 return FALSE;
 399         }
 400
 401         remove ();
 402         add (darea);
 403         darea.show ();
 404
 405         switching = false;
 406         return FALSE;
 407 }
 408
 409 gint
 410 BarController::switch_to_spinner ()
 411 {
 412         if (switching) {
 413                 return FALSE;
 414         }
 415
 416         switching = true;
 417
 418         if (get_child() == &spinner) {
 419                 return FALSE;
 420         }
 421
 422         remove ();
 423         add (spinner);
 424         spinner.show ();
 425         spinner.select_region (0, spinner.get_text_length());
 426         spinner.grab_focus ();
 427
 428         switching = false;
 429         return FALSE;
 430 }
 431
 432 void
 433 BarController::entry_activated ()
 434 {
 435         string text = spinner.get_text ();
 436         float val;
 437
 438         if (sscanf (text.c_str(), "%f", &val) == 1) {
 439                 adjustment.set_value (val);
 440         }
 441
 442         switch_to_bar ();
 443 }
 444
 445 bool
 446 BarController::entry_focus_out (GdkEventFocus* ev)
 447 {
 448         entry_activated ();
 449         return true;
 450 }
 451
 452 void
 453 BarController::set_use_parent (bool yn)
 454 {
 455         use_parent = yn;
 456         queue_draw ();
 457 }
 458
 459 void
 460 BarController::set_sensitive (bool yn)
 461 {
 462         Frame::set_sensitive (yn);
 463         darea.set_sensitive (yn);
 464 }