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 <midi++/controllable.h>
  27
  28 #include <gtkmm2ext/gtk_ui.h>
  29 #include <gtkmm2ext/barcontroller.h>
  30
  31 #include "i18n.h"
  32
  33 using namespace std;
  34 using namespace Gtk;
  35 using namespace Gtkmm2ext;
  36
  37 BarController::BarController (Gtk::Adjustment& adj,
  38                               MIDI::Controllable *mc,
  39                               sigc::slot<void,char*,unsigned int> lc)
  40
  41         : adjustment (adj),
  42           prompter (Gtk::WIN_POS_MOUSE, 30000, false),
  43           midi_control (mc),
  44           label_callback (lc),
  45           spinner (adjustment),
  46           bind_button (2),
  47           bind_statemask (Gdk::CONTROL_MASK)
  48
  49 {
  50         _style = LeftToRight;
  51         grabbed = false;
  52         switching = false;
  53         switch_on_release = false;
  54         with_text = true;
  55         use_parent = false;
  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
  70         darea.signal_expose_event().connect (mem_fun (*this, &BarController::expose));
  71         darea.signal_motion_notify_event().connect (mem_fun (*this, &BarController::motion));
  72         darea.signal_button_press_event().connect (mem_fun (*this, &BarController::button_press));
  73         darea.signal_button_release_event().connect (mem_fun (*this, &BarController::button_release));
  74
  75         prompter.signal_unmap_event().connect (mem_fun (*this, &BarController::prompter_hiding));
  76
  77         prompting = false;
  78         unprompting = false;
  79
  80         if (mc) {
  81                 mc->learning_started.connect (mem_fun (*this, &BarController::midicontrol_prompt));
  82                 mc->learning_stopped.connect (mem_fun (*this, &BarController::midicontrol_unprompt));
  83         }
  84
  85         spinner.signal_activate().connect (mem_fun (*this, &BarController::entry_activated));
  86         spinner.signal_focus_out_event().connect (mem_fun (*this, &BarController::entry_focus_out));
  87         spinner.set_digits (3);
  88
  89         add (darea);
  90         show_all ();
  91 }
  92
  93 void
  94 BarController::set_bind_button_state (guint button, guint statemask)
  95 {
  96         bind_button = button;
  97         bind_statemask = statemask;
  98 }
  99
 100 void
 101 BarController::get_bind_button_state (guint &button, guint &statemask)
 102 {
 103         button = bind_button;
 104         statemask = bind_statemask;
 105 }
 106
 107
 108 gint
 109 BarController::button_press (GdkEventButton* ev)
 110 {
 111         switch (ev->button) {
 112         case 1:
 113                 if (ev->type == GDK_2BUTTON_PRESS) {
 114                         switch_on_release = true;
 115                 } else {
 116                         switch_on_release = false;
 117                         darea.add_modal_grab();
 118                         grabbed = true;
 119                         grab_x = ev->x;
 120                         grab_window = ev->window;
 121                         StartGesture ();
 122                 }
 123                 return TRUE;
 124                 break;
 125
 126         case 2:
 127         case 3:
 128                 break;
 129
 130         case 4:
 131         case 5:
 132                 break;
 133         }
 134
 135         return FALSE;
 136 }
 137
 138 gint
 139 BarController::button_release (GdkEventButton* ev)
 140 {
 141         switch (ev->button) {
 142         case 1:
 143                 if (switch_on_release) {
 144                         Glib::signal_idle().connect (mem_fun (*this, &BarController::switch_to_spinner));
 145                         return TRUE;
 146                 }
 147
 148                 if ((ev->state & (GDK_SHIFT_MASK|GDK_CONTROL_MASK)) == GDK_SHIFT_MASK) {
 149                         adjustment.set_value (initial_value);
 150                 } else {
 151                         double scale;
 152
 153                         if (ev->state & (GDK_CONTROL_MASK|GDK_SHIFT_MASK) == (GDK_CONTROL_MASK|GDK_SHIFT_MASK)) {
 154                                 scale = 0.01;
 155                         } else if (ev->state & GDK_CONTROL_MASK) {
 156                                 scale = 0.1;
 157                         } else {
 158                                 scale = 1.0;
 159                         }
 160
 161                         mouse_control (ev->x, ev->window, scale);
 162                 }
 163                 grabbed = false;
 164                 darea.remove_modal_grab();
 165                 StopGesture ();
 166                 break;
 167
 168         case 2:
 169                 if ((ev->state & bind_statemask) && bind_button == 2) {
 170                         midi_learn ();
 171                 } else {
 172                         double fract;
 173                         fract = ev->x / (darea.get_width() - 2.0);
 174                         adjustment.set_value (adjustment.get_lower() +
 175                                               fract * (adjustment.get_upper() - adjustment.get_lower()));
 176                 }
 177                 return TRUE;
 178
 179         case 3:
 180                 if ((ev->state & bind_statemask) && bind_button == 3) {
 181                         midi_learn ();
 182                         return TRUE;
 183                 }
 184                 return FALSE;
 185
 186         case 4:
 187                 adjustment.set_value (adjustment.get_value() +
 188                                       adjustment.get_step_increment());
 189                 break;
 190         case 5:
 191                 adjustment.set_value (adjustment.get_value() -
 192                                       adjustment.get_step_increment());
 193                 break;
 194         }
 195
 196         return TRUE;
 197 }
 198
 199 gint
 200 BarController::motion (GdkEventMotion* ev)
 201 {
 202         double scale;
 203
 204         if (!grabbed) {
 205                 return TRUE;
 206         }
 207
 208         if ((ev->state & (GDK_SHIFT_MASK|GDK_CONTROL_MASK)) == GDK_SHIFT_MASK) {
 209                 return TRUE;
 210         }
 211
 212         if (ev->state & (GDK_CONTROL_MASK|GDK_SHIFT_MASK) == (GDK_CONTROL_MASK|GDK_SHIFT_MASK)) {
 213                 scale = 0.01;
 214         } else if (ev->state & GDK_CONTROL_MASK) {
 215                 scale = 0.1;
 216         } else {
 217                 scale = 1.0;
 218         }
 219
 220         return mouse_control (ev->x, ev->window, scale);
 221 }
 222
 223 gint
 224 BarController::mouse_control (double x, GdkWindow* window, double scaling)
 225 {
 226         double fract;
 227         double delta;
 228
 229         if (window != grab_window) {
 230                 grab_x = x;
 231                 grab_window = window;
 232                 return TRUE;
 233         }
 234
 235         delta = x - grab_x;
 236         grab_x = x;
 237
 238         switch (_style) {
 239         case Line:
 240         case LeftToRight:
 241                 fract = scaling * (delta / (darea.get_width() - 2));
 242                 fract = min (1.0, fract);
 243                 fract = max (-1.0, fract);
 244                 adjustment.set_value (adjustment.get_value() + fract * (adjustment.get_upper() - adjustment.get_lower()));
 245                 break;
 246
 247         default:
 248                 fract = 0.0;
 249         }
 250
 251
 252         return TRUE;
 253 }
 254
 255 gint
 256 BarController::expose (GdkEventExpose* event)
 257 {
 258         Glib::RefPtr<Gdk::Window> win (darea.get_window());
 259         Widget* parent;
 260         gint x1, x2, y1, y2;
 261         gint w, h;
 262         double fract;
 263
 264         w = darea.get_width() - 2;
 265         h = darea.get_height() - 2;
 266
 267         fract = ((adjustment.get_value() - adjustment.get_lower()) /
 268                  (adjustment.get_upper() - adjustment.get_lower()));
 269
 270         switch (_style) {
 271         case Line:
 272                 x1 = (gint) floor (w * fract);
 273                 x2 = x1;
 274                 y1 = 0;
 275                 y2 = h - 1;
 276
 277                 if (use_parent) {
 278                         parent = get_parent();
 279
 280                         if (parent) {
 281                                 win->draw_rectangle (parent->get_style()->get_fg_gc (parent->get_state()),
 282                                                     true,
 283                                                     0, 0, darea.get_width(), darea.get_height());
 284                         }
 285                 } else {
 286                         win->draw_rectangle (get_style()->get_bg_gc (get_state()),
 287                                             true,
 288                                             0, 0, darea.get_width(), darea.get_height());
 289                 }
 290
 291                 if (fract == 0.0) {
 292                         win->draw_rectangle (get_style()->get_fg_gc (get_state()),
 293                                             true, x1, 1, 2, darea.get_height() - 2);
 294                 } else {
 295                         win->draw_rectangle (get_style()->get_fg_gc (get_state()),
 296                                             true, x1 - 1, 1, 3, darea.get_height() - 2);
 297                 }
 298                 break;
 299
 300         case CenterOut:
 301                 break;
 302
 303         case LeftToRight:
 304                 x1 = 0;
 305                 x2 = (gint) floor (w * fract);
 306                 y1 = 0;
 307                 y2 = h - 1;
 308
 309                 win->draw_rectangle (get_style()->get_bg_gc (get_state()),
 310                                     false,
 311                                     0, 0, darea.get_width(), darea.get_height());
 312
 313                 /* draw active box */
 314
 315                 win->draw_rectangle (get_style()->get_fg_gc (get_state()),
 316                                     true,
 317                                     1 + x1,
 318                                     1 + y1,
 319                                     x2,
 320                                     1 + y2);
 321
 322                 /* draw inactive box */
 323
 324                 win->draw_rectangle (get_style()->get_fg_gc (STATE_INSENSITIVE),
 325                                     true,
 326                                     1 + x2,
 327                                     1 + y1,
 328                                     w - x2,
 329                                     1 + y2);
 330
 331                 break;
 332
 333         case RightToLeft:
 334                 break;
 335         case TopToBottom:
 336                 break;
 337         case BottomToTop:
 338                 break;
 339         }
 340
 341         if (with_text) {
 342                 /* draw label */
 343
 344                 char buf[64];
 345                 buf[0] = '\0';
 346
 347                 label_callback (buf, 64);
 348
 349                 if (buf[0] != '\0') {
 350                         int width = 0, height;
 351                         darea.create_pango_layout(buf)->get_pixel_size(width, height);
 352                         darea.set_size_request(width + 2, -1);
 353                 }
 354         }
 355         return TRUE;
 356 }
 357
 358 void
 359 BarController::set_with_text (bool yn)
 360 {
 361         if (with_text != yn) {
 362                 with_text = yn;
 363                 queue_draw ();
 364         }
 365 }
 366
 367 void
 368 BarController::midicontrol_set_tip ()
 369 {
 370         if (midi_control) {
 371                 // Gtkmm2ext::UI::instance()->set_tip (&darea, midi_control->control_description());
 372         }
 373 }
 374
 375 void
 376 BarController::midi_learn()
 377 {
 378         if (midi_control) {
 379                 prompting = true;
 380                 midi_control->learn_about_external_control ();
 381         }
 382 }
 383
 384
 385 void
 386 BarController::midicontrol_prompt ()
 387 {
 388         if (prompting) {
 389                 string prompt = _("operate MIDI controller now");
 390                 prompter.set_text (prompt);
 391                 Gtkmm2ext::UI::instance()->touch_display (&prompter);
 392
 393                 unprompting = true;
 394                 prompting = false;
 395         }
 396 }
 397
 398 void
 399 BarController::midicontrol_unprompt ()
 400 {
 401         if (unprompting) {
 402                 Gtkmm2ext::UI::instance()->touch_display (&prompter);
 403
 404                 unprompting = false;
 405         }
 406 }
 407
 408 gint
 409 BarController::prompter_hiding (GdkEventAny *ev)
 410 {
 411         if (unprompting) {
 412                 if (midi_control) {
 413                         midi_control->stop_learning();
 414                 }
 415                 unprompting = false;
 416         }
 417
 418         return FALSE;
 419 }
 420
 421
 422 void
 423 BarController::set_style (Style s)
 424 {
 425         _style = s;
 426         darea.queue_draw ();
 427 }
 428
 429 gint
 430 BarController::switch_to_bar ()
 431 {
 432         if (switching) {
 433                 return FALSE;
 434         }
 435
 436         switching = true;
 437
 438         if (get_child() == &darea) {
 439                 return FALSE;
 440         }
 441
 442         remove ();
 443         add (darea);
 444         darea.show ();
 445
 446         switching = false;
 447         return FALSE;
 448 }
 449
 450 gint
 451 BarController::switch_to_spinner ()
 452 {
 453         if (switching) {
 454                 return FALSE;
 455         }
 456
 457         switching = true;
 458
 459         if (get_child() == &spinner) {
 460                 return FALSE;
 461         }
 462
 463         remove ();
 464         add (spinner);
 465         spinner.show ();
 466         spinner.grab_focus ();
 467
 468         switching = false;
 469         return FALSE;
 470 }
 471
 472 void
 473 BarController::entry_activated ()
 474 {
 475         string text = spinner.get_text ();
 476         float val;
 477
 478         if (sscanf (text.c_str(), "%f", &val) == 1) {
 479                 adjustment.set_value (val);
 480         }
 481
 482         switch_to_bar ();
 483 }
 484
 485 gint
 486 BarController::entry_focus_out (GdkEventFocus* ev)
 487 {
 488         entry_activated ();
 489         return TRUE;
 490 }
 491
 492 void
 493 BarController::set_use_parent (bool yn)
 494 {
 495         use_parent = yn;
 496         queue_draw ();
 497 }