gtk2_ardour/stereo_panner.cc

   1 /*
   2     Copyright (C) 2000-2007 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <iostream>
  21 #include <iomanip>
  22 #include <cstring>
  23 #include <cmath>
  24
  25 #include "pbd/controllable.h"
  26 #include "pbd/compose.h"
  27
  28 #include "gtkmm2ext/gui_thread.h"
  29 #include "gtkmm2ext/gtk_ui.h"
  30 #include "gtkmm2ext/keyboard.h"
  31
  32 #include "ardour/panner.h"
  33 #include "stereo_panner.h"
  34 #include "utils.h"
  35
  36 #include "i18n.h"
  37
  38 using namespace std;
  39 using namespace Gtk;
  40 using namespace Gtkmm2ext;
  41
  42 static const int pos_box_size = 10;
  43 static const int lr_box_size = 15;
  44 static const int step_down = 10;
  45 static const int top_step = 2;
  46
  47 StereoPanner::StereoPanner (boost::shared_ptr<PBD::Controllable> position, boost::shared_ptr<PBD::Controllable> width)
  48         : position_control (position)
  49         , width_control (width)
  50         , dragging (false)
  51         , dragging_position (false)
  52         , drag_start_x (0)
  53         , last_drag_x (0)
  54 {
  55         position_control->Changed.connect (connections, invalidator(*this), boost::bind (&StereoPanner::value_change, this), gui_context());
  56         width_control->Changed.connect (connections, invalidator(*this), boost::bind (&StereoPanner::value_change, this), gui_context());
  57         set_tooltip ();
  58
  59         set_flags (Gtk::CAN_FOCUS);
  60
  61         add_events (Gdk::ENTER_NOTIFY_MASK|Gdk::LEAVE_NOTIFY_MASK|
  62                     Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|
  63                     Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|
  64                     Gdk::SCROLL_MASK|
  65                     Gdk::POINTER_MOTION_MASK);
  66 }
  67
  68 StereoPanner::~StereoPanner ()
  69 {
  70 }
  71
  72 void
  73 StereoPanner::set_tooltip ()
  74 {
  75         double pos = position_control->get_value(); // 0..1
  76         double w = width_control->get_value (); // -1..+1
  77         int lpos = (int) lrint ((pos - (w/2.0)) * 100.0);
  78         int rpos = (int) lrint ((pos + (w/2.0)) * 100.0);
  79
  80         Gtkmm2ext::UI::instance()->set_tip (this, string_compose (_("L:%1 R:%2 Width: %3%%"),
  81                                                                   lpos, rpos,
  82                                                                   (int) floor (w * 100.0)).c_str());
  83 }
  84
  85 void
  86 StereoPanner::value_change ()
  87 {
  88         set_tooltip ();
  89         queue_draw ();
  90 }
  91
  92 bool
  93 StereoPanner::on_expose_event (GdkEventExpose* ev)
  94 {
  95         Glib::RefPtr<Gdk::Window> win (get_window());
  96         Glib::RefPtr<Gdk::GC> gc (get_style()->get_base_gc (get_state()));
  97
  98         cairo_t* cr = gdk_cairo_create (win->gobj());
  99
 100         int width, height;
 101         double pos = position_control->get_value (); /* 0..1 */
 102         double swidth = width_control->get_value (); /* -1..+1 */
 103         double fswidth = fabs (swidth);
 104
 105         width = get_width();
 106         height = get_height ();
 107
 108         /* background */
 109
 110         cairo_set_source_rgb (cr, 0.184, 0.172, 0.172);
 111         cairo_rectangle (cr, 0, 0, width, height);
 112         cairo_fill (cr);
 113
 114         /* compute the outer edges of the L/R boxes based on the current stereo width */
 115
 116         int usable_width = width - lr_box_size;
 117         int center = lr_box_size/2 + (int) floor (usable_width * pos);
 118         int left = center - (int) floor (fswidth * usable_width / 2.0); // center of leftmost box
 119         int right = center + (int) floor (fswidth * usable_width / 2.0); // center of rightmost box
 120
 121         // cerr << "pos " << pos << " width = " << width << " swidth = " << swidth << " center @ " << center << " L = " << left << " R = " << right << endl;
 122
 123         /* compute & draw the line through the box */
 124
 125         cairo_set_line_width (cr, 2);
 126         cairo_set_source_rgba (cr, 0.3137, 0.4431, 0.7843, 1.0);
 127         cairo_move_to (cr, left, top_step+(pos_box_size/2)+step_down);
 128         cairo_line_to (cr, left, top_step+(pos_box_size/2));
 129         cairo_line_to (cr, right, top_step+(pos_box_size/2));
 130         cairo_line_to (cr, right, top_step+(pos_box_size/2) + step_down);
 131         cairo_stroke (cr);
 132
 133         if (swidth < 0.0) {
 134                 /* flip where the L/R boxes are drawn */
 135                 swap (left, right);
 136         }
 137
 138         /* left box */
 139
 140         left -= lr_box_size/2;
 141         right -= lr_box_size/2;
 142
 143         cairo_rectangle (cr,
 144                          left,
 145                          (lr_box_size/2)+step_down,
 146                          lr_box_size, lr_box_size);
 147         cairo_set_source_rgba (cr, 0.3137, 0.4431, 0.7843, 1.0);
 148         cairo_stroke_preserve (cr);
 149         cairo_set_source_rgba (cr, 0.4509, 0.7686, 0.8627, 0.8);
 150         cairo_fill (cr);
 151
 152         /* add text */
 153
 154         cairo_move_to (cr,
 155                        left + 3,
 156                        (lr_box_size/2) + step_down + 13);
 157         cairo_set_source_rgba (cr, 0.129, 0.054, 0.588, 1.0);
 158         cairo_select_font_face (cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
 159         cairo_show_text (cr, "L");
 160
 161         /* right box */
 162
 163         cairo_rectangle (cr,
 164                          right,
 165                          (lr_box_size/2)+step_down,
 166                          lr_box_size, lr_box_size);
 167         cairo_set_source_rgba (cr, 0.3137, 0.4431, 0.7843, 1.0);
 168         cairo_stroke_preserve (cr);
 169         cairo_set_source_rgba (cr, 0.4509, 0.7686, 0.8627, 0.8);
 170         cairo_fill (cr);
 171
 172         /* add text */
 173
 174         cairo_move_to (cr,
 175                        right + 3,
 176                        (lr_box_size/2)+step_down + 13);
 177         cairo_set_source_rgba (cr, 0.129, 0.054, 0.588, 1.0);
 178         cairo_show_text (cr, "R");
 179
 180         /* draw the central box */
 181
 182         cairo_set_line_width (cr, 1);
 183         cairo_rectangle (cr, center - (pos_box_size/2), top_step, pos_box_size, pos_box_size);
 184         cairo_set_source_rgba (cr, 0.3137, 0.4431, 0.7843, 1.0);
 185         cairo_stroke_preserve (cr);
 186         cairo_set_source_rgba (cr, 0.4509, 0.7686, 0.8627, 0.8);
 187         cairo_fill (cr);
 188
 189         /* done */
 190
 191         cairo_destroy (cr);
 192         return true;
 193 }
 194
 195 bool
 196 StereoPanner::on_button_press_event (GdkEventButton* ev)
 197 {
 198         drag_start_x = ev->x;
 199         last_drag_x = ev->x;
 200
 201         if (ev->y < 20) {
 202                 /* top section of widget is for position drags */
 203                 dragging_position = true;
 204         } else {
 205                 dragging_position = false;
 206         }
 207
 208         if (ev->type == GDK_2BUTTON_PRESS) {
 209                 if (dragging_position) {
 210                         cerr << "Reset pos\n";
 211                         position_control->set_value (0.5); // reset position to center
 212                 } else {
 213                         cerr << "Reset width\n";
 214                         width_control->set_value (1.0); // reset position to full, LR
 215                 }
 216                 dragging = false;
 217         } else {
 218                 dragging = true;
 219         }
 220
 221         return true;
 222 }
 223
 224 bool
 225 StereoPanner::on_button_release_event (GdkEventButton* ev)
 226 {
 227         dragging = false;
 228         dragging_position = false;
 229         return true;
 230 }
 231
 232 bool
 233 StereoPanner::on_scroll_event (GdkEventScroll* ev)
 234 {
 235         double one_degree = 1.0/180.0;
 236         double pv = position_control->get_value(); // 0..1.0 ; 0 = left
 237         double wv = width_control->get_value(); // 0..1.0 ; 0 = left
 238         double step;
 239
 240         if (Keyboard::modifier_state_contains (ev->state, Keyboard::PrimaryModifier)) {
 241                 step = one_degree;
 242         } else {
 243                 step = one_degree * 5.0;
 244         }
 245
 246         switch (ev->direction) {
 247         case GDK_SCROLL_LEFT:
 248                 wv += step;
 249                 width_control->set_value (wv);
 250                 break;
 251         case GDK_SCROLL_UP:
 252                 pv -= step;
 253                 position_control->set_value (pv);
 254                 break;
 255         case GDK_SCROLL_RIGHT:
 256                 wv -= step;
 257                 width_control->set_value (wv);
 258                 break;
 259         case GDK_SCROLL_DOWN:
 260                 pv += step;
 261                 position_control->set_value (pv);
 262                 break;
 263         }
 264
 265         return true;
 266 }
 267
 268 bool
 269 StereoPanner::on_motion_notify_event (GdkEventMotion* ev)
 270 {
 271         if (!dragging) {
 272                 return false;
 273         }
 274
 275         int w = get_width();
 276         double delta = (abs (ev->x - last_drag_x)) / (w/2.0);
 277         int drag_dir = 0;
 278
 279         if (!dragging_position) {
 280                 double wv = width_control->get_value();
 281                 int inc;
 282                 double old_wv;
 283                 double opx; // compute the operational x-coordinate given the current pos+width
 284
 285                 if (wv > 0) {
 286                         /* positive value: increasing width means adding */
 287                         inc = 1;
 288                 } else {
 289                         /* positive value: increasing width means subtracting */
 290                         inc = -1;
 291                 }
 292
 293                 if (drag_start_x < w/2) {
 294                         /* started left of center */
 295
 296                         opx = position_control->get_value() - (wv/2.0);
 297
 298                         if (opx < 0.5) {
 299                                 /* still left */
 300                                 if (ev->x > last_drag_x) {
 301                                         /* motion to left */
 302                                         drag_dir = -inc;
 303                                 } else {
 304                                         drag_dir = inc;
 305                                 }
 306                         } else {
 307                                 /* now right */
 308                                 if (ev->x > last_drag_x) {
 309                                         /* motion to left */
 310                                         drag_dir = inc;
 311                                 } else {
 312                                         drag_dir = -inc;
 313                                 }
 314                         }
 315                 } else {
 316                         /* started right of center */
 317
 318                         opx = position_control->get_value() + (wv/2.0);
 319
 320                         if (opx > 0.5) {
 321                                 /* still right */
 322                                 if (ev->x < last_drag_x) {
 323                                         /* motion to right */
 324                                         drag_dir = -inc;
 325                                 } else {
 326                                         drag_dir = inc;
 327                                 }
 328                         } else {
 329                                 /* now left */
 330                                 if (ev->x < last_drag_x) {
 331                                         /* motion to right */
 332                                         drag_dir = inc;
 333                                 } else {
 334                                         drag_dir = -inc;
 335                                 }
 336                         }
 337
 338                 }
 339
 340                 old_wv = wv;
 341                 wv = wv + (drag_dir * delta);
 342
 343                 width_control->set_value (wv);
 344
 345         } else {
 346
 347                 double pv = position_control->get_value(); // 0..1.0 ; 0 = left
 348
 349                 if (ev->x > last_drag_x) { // increasing
 350                         pv = pv * (1.0 + delta);
 351                 } else {
 352                         pv = pv * (1.0 - delta);
 353                 }
 354
 355                 position_control->set_value (pv);
 356         }
 357
 358         last_drag_x = ev->x;
 359         return true;
 360 }
 361
 362 bool
 363 StereoPanner::on_key_press_event (GdkEventKey* ev)
 364 {
 365         double one_degree = 1.0/180.0;
 366         double pv = position_control->get_value(); // 0..1.0 ; 0 = left
 367         double wv = width_control->get_value(); // 0..1.0 ; 0 = left
 368         double step;
 369
 370         if (Keyboard::modifier_state_contains (ev->state, Keyboard::PrimaryModifier)) {
 371                 step = one_degree;
 372         } else {
 373                 step = one_degree * 5.0;
 374         }
 375
 376         switch (ev->keyval) {
 377         case GDK_Up:
 378                 wv += step;
 379                 width_control->set_value (wv);
 380                 break;
 381         case GDK_Left:
 382                 pv -= step;
 383                 position_control->set_value (pv);
 384                 break;
 385         case GDK_Right:
 386                 pv += step;
 387                 position_control->set_value (pv);
 388                 break;
 389         case GDK_Down:
 390                 wv -= step;
 391                 width_control->set_value (wv);
 392                 break;
 393         default:
 394                 return forward_key_press (ev);
 395         }
 396
 397         return true;
 398 }
 399
 400 bool
 401 StereoPanner::on_key_release_event (GdkEventKey* ev)
 402 {
 403         return true;
 404 }
 405
 406 bool
 407 StereoPanner::on_enter_notify_event (GdkEventCrossing* ev)
 408 {
 409         grab_focus ();
 410         Keyboard::magic_widget_grab_focus ();
 411         return false;
 412 }
 413
 414 bool
 415 StereoPanner::on_leave_notify_event (GdkEventCrossing*)
 416 {
 417         Keyboard::magic_widget_drop_focus ();
 418         return false;
 419 }