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