gtk2_ardour/gain_meter.cc

   1 /*
   2   Copyright (C) 2002 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 <limits.h>
  21
  22 #include <ardour/io.h>
  23 #include <ardour/route.h>
  24 #include <ardour/route_group.h>
  25 #include <ardour/session.h>
  26 #include <ardour/session_route.h>
  27 #include <ardour/dB.h>
  28
  29 #include <gtkmm2ext/utils.h>
  30 #include <gtkmm2ext/fastmeter.h>
  31 #include <gtkmm2ext/stop_signal.h>
  32 #include <gtkmm2ext/barcontroller.h>
  33 #include <midi++/manager.h>
  34 #include <pbd/fastlog.h>
  35
  36 #include "ardour_ui.h"
  37 #include "gain_meter.h"
  38 #include "utils.h"
  39 #include "logmeter.h"
  40 #include "gui_thread.h"
  41 #include "keyboard.h"
  42 #include "public_editor.h"
  43
  44 #include <ardour/session.h>
  45 #include <ardour/route.h>
  46
  47 #include "i18n.h"
  48
  49 using namespace ARDOUR;
  50 using namespace PBD;
  51 using namespace Gtkmm2ext;
  52 using namespace Gtk;
  53 using namespace sigc;
  54 using namespace std;
  55
  56 sigc::signal<void> GainMeter::ResetAllPeakDisplays;
  57 sigc::signal<void,RouteGroup*> GainMeter::ResetGroupPeakDisplays;
  58 Glib::RefPtr<Gdk::Pixbuf> GainMeter::slider;
  59 Glib::RefPtr<Gdk::Pixbuf> GainMeter::rail;
  60 map<string,Glib::RefPtr<Gdk::Pixmap> > GainMeter::metric_pixmaps;
  61
  62 int
  63 GainMeter::setup_slider_pix ()
  64 {
  65         slider = ::get_icon ("fader_belt");
  66         return 0;
  67 }
  68
  69 GainMeter::GainMeter (boost::shared_ptr<IO> io, Session& s)
  70         : _io (io),
  71           _session (s),
  72           gain_slider (0),
  73           // 0.781787 is the value needed for gain to be set to 0.
  74           gain_adjustment (0.781787, 0.0, 1.0, 0.01, 0.1),
  75           gain_automation_style_button (""),
  76           gain_automation_state_button ("")
  77
  78 {
  79         if (slider == 0) {
  80                 setup_slider_pix ();
  81         }
  82
  83         ignore_toggle = false;
  84         meter_menu = 0;
  85         next_release_selects = false;
  86         style_changed = true;
  87
  88         gain_slider = manage (new VSliderController (slider,
  89                                                      &gain_adjustment,
  90                                                      _io->gain_control(),
  91                                                      false));
  92
  93         gain_slider->signal_button_press_event().connect (mem_fun(*this, &GainMeter::start_gain_touch));
  94         gain_slider->signal_button_release_event().connect (mem_fun(*this, &GainMeter::end_gain_touch));
  95         gain_slider->set_name ("GainFader");
  96
  97         gain_display.set_name ("MixerStripGainDisplay");
  98         gain_display.set_has_frame (false);
  99         set_size_request_to_display_given_text (gain_display, "-80.g", 2, 6); /* note the descender */
 100         gain_display.signal_activate().connect (mem_fun (*this, &GainMeter::gain_activated));
 101         gain_display.signal_focus_in_event().connect (mem_fun (*this, &GainMeter::gain_focused), false);
 102         gain_display.signal_focus_out_event().connect (mem_fun (*this, &GainMeter::gain_focused), false);
 103
 104         gain_display_box.set_homogeneous (true);
 105         gain_display_box.set_spacing (2);
 106         gain_display_box.pack_start (gain_display, true, true);
 107
 108         peak_display.set_name ("MixerStripPeakDisplay");
 109 //      peak_display.set_has_frame (false);
 110 //      peak_display.set_editable (false);
 111         set_size_request_to_display_given_text  (peak_display, "-80.g", 2, 6); /* note the descender */
 112         max_peak = minus_infinity();
 113         peak_display.set_label (_("-inf"));
 114         peak_display.unset_flags (Gtk::CAN_FOCUS);
 115
 116         meter_metric_area.set_name ("MeterMetricsStrip");
 117         set_size_request_to_display_given_text (meter_metric_area, "-50", 0, 0);
 118
 119         meter_packer.set_spacing (2);
 120
 121         gain_automation_style_button.set_name ("MixerAutomationModeButton");
 122         gain_automation_state_button.set_name ("MixerAutomationPlaybackButton");
 123
 124         ARDOUR_UI::instance()->tooltips().set_tip (gain_automation_state_button, _("Fader automation mode"));
 125         ARDOUR_UI::instance()->tooltips().set_tip (gain_automation_style_button, _("Fader automation type"));
 126
 127         gain_automation_style_button.unset_flags (Gtk::CAN_FOCUS);
 128         gain_automation_state_button.unset_flags (Gtk::CAN_FOCUS);
 129
 130         gain_automation_state_button.set_size_request(15, 15);
 131         gain_automation_style_button.set_size_request(15, 15);
 132
 133         HBox* fader_centering_box = manage (new HBox);
 134         fader_centering_box->pack_start (*gain_slider, true, false);
 135
 136         fader_vbox = manage (new Gtk::VBox());
 137         fader_vbox->set_spacing (0);
 138         fader_vbox->pack_start (*fader_centering_box, false, false, 0);
 139
 140         hbox.set_spacing (2);
 141         hbox.pack_start (*fader_vbox, true, true);
 142
 143         set_width(Narrow);
 144
 145         Route* r;
 146
 147         if ((r = dynamic_cast<Route*> (_io.get())) != 0) {
 148
 149                 /*
 150                    if we have a route (ie. we're not the click),
 151                    pack some route-dependent stuff.
 152                 */
 153
 154                 gain_display_box.pack_end (peak_display, true, true);
 155
 156                 hbox.pack_end (meter_packer, true, true);
 157
 158                 using namespace Menu_Helpers;
 159
 160                 gain_astate_menu.items().push_back (MenuElem (_("Manual"),
 161                                                       bind (mem_fun (*_io, &IO::set_gain_automation_state), (AutoState) Off)));
 162                 gain_astate_menu.items().push_back (MenuElem (_("Play"),
 163                                                       bind (mem_fun (*_io, &IO::set_gain_automation_state), (AutoState) Play)));
 164                 gain_astate_menu.items().push_back (MenuElem (_("Write"),
 165                                                       bind (mem_fun (*_io, &IO::set_gain_automation_state), (AutoState) Write)));
 166                 gain_astate_menu.items().push_back (MenuElem (_("Touch"),
 167                                                       bind (mem_fun (*_io, &IO::set_gain_automation_state), (AutoState) Touch)));
 168
 169                 gain_astyle_menu.items().push_back (MenuElem (_("Trim")));
 170                 gain_astyle_menu.items().push_back (MenuElem (_("Abs")));
 171
 172                 gain_astate_menu.set_name ("ArdourContextMenu");
 173                 gain_astyle_menu.set_name ("ArdourContextMenu");
 174
 175                 gain_automation_style_button.signal_button_press_event().connect (mem_fun(*this, &GainMeter::gain_automation_style_button_event), false);
 176                 gain_automation_state_button.signal_button_press_event().connect (mem_fun(*this, &GainMeter::gain_automation_state_button_event), false);
 177
 178                 r->gain_automation_curve().automation_state_changed.connect (mem_fun(*this, &GainMeter::gain_automation_state_changed));
 179                 r->gain_automation_curve().automation_style_changed.connect (mem_fun(*this, &GainMeter::gain_automation_style_changed));
 180                 fader_vbox->pack_start (gain_automation_state_button, false, false, 0);
 181
 182                 gain_automation_state_changed ();
 183         }
 184
 185         set_spacing (2);
 186
 187         pack_start (gain_display_box, Gtk::PACK_SHRINK);
 188         pack_start (hbox, Gtk::PACK_SHRINK);
 189
 190         _io->gain_changed.connect (mem_fun(*this, &GainMeter::gain_changed));
 191
 192         meter_metric_area.signal_expose_event().connect (mem_fun(*this, &GainMeter::meter_metrics_expose));
 193         gain_adjustment.signal_value_changed().connect (mem_fun(*this, &GainMeter::gain_adjusted));
 194         peak_display.signal_button_release_event().connect (mem_fun(*this, &GainMeter::peak_button_release), false);
 195         gain_display.signal_key_press_event().connect (mem_fun(*this, &GainMeter::gain_key_press), false);
 196
 197         Config->ParameterChanged.connect (mem_fun (*this, &GainMeter::parameter_changed));
 198
 199         gain_changed (0);
 200         show_gain ();
 201
 202         update_gain_sensitive ();
 203
 204         ResetAllPeakDisplays.connect (mem_fun(*this, &GainMeter::reset_peak_display));
 205         ResetGroupPeakDisplays.connect (mem_fun(*this, &GainMeter::reset_group_peak_display));
 206
 207         UI::instance()->theme_changed.connect (mem_fun(*this, &GainMeter::on_theme_changed));
 208 }
 209
 210 void
 211 GainMeter::set_width (Width w)
 212 {
 213         switch (w) {
 214         case Wide:
 215                 peak_display.show();
 216                 break;
 217         case Narrow:
 218                 peak_display.hide();
 219                 break;
 220         }
 221
 222         _width = w;
 223         setup_meters ();
 224 }
 225
 226 Glib::RefPtr<Gdk::Pixmap>
 227 GainMeter::render_metrics (Gtk::Widget& w)
 228 {
 229         Glib::RefPtr<Gdk::Window> win (w.get_window());
 230         Glib::RefPtr<Gdk::GC> fg_gc (w.get_style()->get_fg_gc (Gtk::STATE_NORMAL));
 231         Glib::RefPtr<Gdk::GC> bg_gc (w.get_style()->get_bg_gc (Gtk::STATE_NORMAL));
 232         gint width, height;
 233         int  db_points[] = { -50, -40, -20, -30, -10, -3, 0, 4 };
 234         char buf[32];
 235
 236         win->get_size (width, height);
 237
 238         Glib::RefPtr<Gdk::Pixmap> pixmap = Gdk::Pixmap::create (win, width, height);
 239
 240         metric_pixmaps[w.get_name()] = pixmap;
 241
 242         pixmap->draw_rectangle (bg_gc, true, 0, 0, width, height);
 243
 244         Glib::RefPtr<Pango::Layout> layout = w.create_pango_layout("");
 245
 246         for (uint32_t i = 0; i < sizeof (db_points)/sizeof (db_points[0]); ++i) {
 247
 248                 float fraction = log_meter (db_points[i]);
 249                 gint pos = height - (gint) floor (height * fraction);
 250
 251                 snprintf (buf, sizeof (buf), "%d", abs (db_points[i]));
 252
 253                 layout->set_text (buf);
 254
 255                 /* we want logical extents, not ink extents here */
 256
 257                 int width, height;
 258                 layout->get_pixel_size (width, height);
 259
 260                 pixmap->draw_line (fg_gc, 0, pos, 4, pos);
 261                 pixmap->draw_layout (fg_gc, 6, pos - (height/2), layout);
 262         }
 263
 264         return pixmap;
 265 }
 266
 267 gint
 268 GainMeter::meter_metrics_expose (GdkEventExpose *ev)
 269 {
 270         static Glib::RefPtr<Gtk::Style> meter_style;
 271
 272         if (style_changed) {
 273                 meter_style = meter_metric_area.get_style();
 274         }
 275         Glib::RefPtr<Gdk::Window> win (meter_metric_area.get_window());
 276         Glib::RefPtr<Gdk::GC> fg_gc (meter_style->get_fg_gc (Gtk::STATE_NORMAL));
 277         Glib::RefPtr<Gdk::GC> bg_gc (meter_style->get_fg_gc (Gtk::STATE_NORMAL));
 278         GdkRectangle base_rect;
 279         GdkRectangle draw_rect;
 280         gint width, height;
 281
 282         win->get_size (width, height);
 283
 284         base_rect.width = width;
 285         base_rect.height = height;
 286         base_rect.x = 0;
 287         base_rect.y = 0;
 288
 289         Glib::RefPtr<Gdk::Pixmap> pixmap;
 290         std::map<string,Glib::RefPtr<Gdk::Pixmap> >::iterator i = metric_pixmaps.find (meter_metric_area.get_name());
 291
 292         if (i == metric_pixmaps.end() || style_changed) {
 293                 pixmap = render_metrics (meter_metric_area);
 294         } else {
 295                 pixmap = i->second;
 296         }
 297
 298         gdk_rectangle_intersect (&ev->area, &base_rect, &draw_rect);
 299         win->draw_rectangle (bg_gc, true, draw_rect.x, draw_rect.y, draw_rect.width, draw_rect.height);
 300         win->draw_drawable (fg_gc, pixmap, draw_rect.x, draw_rect.y, draw_rect.x, draw_rect.y, draw_rect.width, draw_rect.height);
 301
 302         style_changed = false;
 303         return true;
 304 }
 305
 306 void
 307 GainMeter::on_theme_changed()
 308 {
 309         style_changed = true;
 310 }
 311
 312 GainMeter::~GainMeter ()
 313 {
 314         if (meter_menu) {
 315                 delete meter_menu;
 316         }
 317
 318         for (vector<MeterInfo>::iterator i = meters.begin(); i != meters.end(); i++) {
 319                 if ((*i).meter) {
 320                         delete (*i).meter;
 321                 }
 322         }
 323 }
 324
 325 void
 326 GainMeter::update_meters ()
 327 {
 328         vector<MeterInfo>::iterator i;
 329         uint32_t n;
 330         float peak, mpeak;
 331         char buf[32];
 332
 333         for (n = 0, i = meters.begin(); i != meters.end(); ++i, ++n) {
 334                 if ((*i).packed) {
 335                         peak = _io->peak_input_power (n);
 336
 337                         (*i).meter->set (log_meter (peak));
 338
 339                         mpeak = _io->max_peak_power(n);
 340
 341                         if (mpeak > max_peak) {
 342                                 max_peak = mpeak;
 343                                 /* set peak display */
 344                                 if (max_peak <= -200.0f) {
 345                                         peak_display.set_label (_("-inf"));
 346                                 } else {
 347                                         snprintf (buf, sizeof(buf), "%.1f", max_peak);
 348                                         peak_display.set_label (buf);
 349                                 }
 350
 351                                 if (max_peak >= 0.0f) {
 352                                         peak_display.set_name ("MixerStripPeakDisplayPeak");
 353                                 }
 354                         }
 355                 }
 356         }
 357 }
 358
 359 void
 360 GainMeter::parameter_changed(const char* parameter_name)
 361 {
 362 #define PARAM_IS(x) (!strcmp (parameter_name, (x)))
 363
 364         ENSURE_GUI_THREAD (bind (mem_fun(*this, &GainMeter::parameter_changed), parameter_name));
 365
 366         if (PARAM_IS ("meter-hold")) {
 367
 368                 vector<MeterInfo>::iterator i;
 369                 uint32_t n;
 370
 371                 for (n = 0, i = meters.begin(); i != meters.end(); ++i, ++n) {
 372
 373                         (*i).meter->set_hold_count ((uint32_t) floor(Config->get_meter_hold()));
 374                 }
 375         }
 376
 377 #undef PARAM_IS
 378 }
 379
 380 void
 381 GainMeter::hide_all_meters ()
 382 {
 383         bool remove_metric_area = false;
 384
 385         for (vector<MeterInfo>::iterator i = meters.begin(); i != meters.end(); ++i) {
 386                 if ((*i).packed) {
 387                         remove_metric_area = true;
 388                         meter_packer.remove (*((*i).meter));
 389                         (*i).packed = false;
 390                 }
 391         }
 392
 393         if (remove_metric_area) {
 394                 if (meter_metric_area.get_parent()) {
 395                         meter_packer.remove (meter_metric_area);
 396                 }
 397         }
 398 }
 399
 400 void
 401 GainMeter::setup_meters ()
 402 {
 403         uint32_t nmeters = _io->n_outputs();
 404         guint16 width;
 405
 406         hide_all_meters ();
 407
 408         Route* r;
 409
 410         if ((r = dynamic_cast<Route*> (_io.get())) != 0) {
 411
 412                 switch (r->meter_point()) {
 413                 case MeterPreFader:
 414                 case MeterInput:
 415                         nmeters = r->n_inputs();
 416                         break;
 417                 case MeterPostFader:
 418                         nmeters = r->n_outputs();
 419                         break;
 420                 }
 421
 422         } else {
 423
 424                 nmeters = _io->n_outputs();
 425
 426         }
 427
 428         if (nmeters == 0) {
 429                 return;
 430         }
 431
 432         if (nmeters <= 2) {
 433                 width = regular_meter_width;
 434         } else {
 435                 width = thin_meter_width;
 436         }
 437
 438         while (meters.size() < nmeters) {
 439                 meters.push_back (MeterInfo());
 440         }
 441
 442         /* pack them backwards */
 443
 444         if (_width == Wide) {
 445                 meter_packer.pack_end (meter_metric_area, false, false);
 446                 meter_metric_area.show_all ();
 447         }
 448
 449         for (int32_t n = nmeters-1; nmeters && n >= 0 ; --n) {
 450                 if (meters[n].width != width) {
 451                         delete meters[n].meter;
 452                         meters[n].meter = new FastMeter ((uint32_t) floor (Config->get_meter_hold()), width, FastMeter::Vertical);
 453                         meters[n].width = width;
 454
 455                         meters[n].meter->add_events (Gdk::BUTTON_RELEASE_MASK);
 456                         meters[n].meter->signal_button_release_event().connect (bind (mem_fun(*this, &GainMeter::meter_button_release), n));
 457                 }
 458
 459                 meter_packer.pack_end (*meters[n].meter, false, false);
 460                 meters[n].meter->show_all ();
 461                 meters[n].packed = true;
 462         }
 463 }
 464
 465 int
 466 GainMeter::get_gm_width ()
 467 {
 468         Gtk::Requisition sz;
 469         hbox.size_request (sz);
 470         return sz.width;
 471 }
 472
 473 bool
 474 GainMeter::gain_key_press (GdkEventKey* ev)
 475 {
 476         if (key_is_legal_for_numeric_entry (ev->keyval)) {
 477                 /* drop through to normal handling */
 478                 return false;
 479         }
 480         /* illegal key for gain entry */
 481         return true;
 482 }
 483
 484 bool
 485 GainMeter::peak_button_release (GdkEventButton* ev)
 486 {
 487         /* reset peak label */
 488
 489         if (ev->button == 1 && Keyboard::modifier_state_equals (ev->state, Keyboard::Control|Keyboard::Shift)) {
 490                 ResetAllPeakDisplays ();
 491         } else if (ev->button == 1 && Keyboard::modifier_state_equals (ev->state, Keyboard::Control)) {
 492                 Route* r;
 493                 if ((r = dynamic_cast<Route*> (_io.get())) != 0) {
 494                         ResetGroupPeakDisplays (r->mix_group());
 495                 }
 496         } else {
 497                 reset_peak_display ();
 498         }
 499
 500         return true;
 501 }
 502
 503 void
 504 GainMeter::reset_peak_display ()
 505 {
 506         Route * r;
 507         if ((r = dynamic_cast<Route*> (_io.get())) != 0) {
 508                 r->reset_max_peak_meters();
 509         }
 510
 511         max_peak = -INFINITY;
 512         peak_display.set_label (_("-Inf"));
 513         peak_display.set_name ("MixerStripPeakDisplay");
 514 }
 515
 516 void
 517 GainMeter::reset_group_peak_display (RouteGroup* group)
 518 {
 519         Route* r;
 520         if ((r = dynamic_cast<Route*> (_io.get())) != 0) {
 521                 if (group == r->mix_group()) {
 522                         reset_peak_display ();
 523                 }
 524         }
 525 }
 526
 527 gint
 528 GainMeter::meter_button_release (GdkEventButton* ev, uint32_t which)
 529 {
 530         switch (ev->button) {
 531         case 1:
 532                 meters[which].meter->clear();
 533                 max_peak = minus_infinity();
 534                 peak_display.set_label (_("-inf"));
 535                 peak_display.set_name ("MixerStripPeakDisplay");
 536                 break;
 537
 538         case 3:
 539                 // popup_meter_menu (ev);
 540                 break;
 541         };
 542
 543         return TRUE;
 544 }
 545
 546 void
 547 GainMeter::popup_meter_menu (GdkEventButton *ev)
 548 {
 549         using namespace Menu_Helpers;
 550
 551         if (meter_menu == 0) {
 552                 meter_menu = new Gtk::Menu;
 553                 MenuList& items = meter_menu->items();
 554
 555                 items.push_back (MenuElem ("-inf .. +0dBFS"));
 556                 items.push_back (MenuElem ("-10dB .. +0dBFS"));
 557                 items.push_back (MenuElem ("-4 .. +0dBFS"));
 558                 items.push_back (SeparatorElem());
 559                 items.push_back (MenuElem ("-inf .. -2dBFS"));
 560                 items.push_back (MenuElem ("-10dB .. -2dBFS"));
 561                 items.push_back (MenuElem ("-4 .. -2dBFS"));
 562         }
 563
 564         meter_menu->popup (1, ev->time);
 565 }
 566
 567 bool
 568 GainMeter::gain_focused (GdkEventFocus* ev)
 569 {
 570         if (ev->in) {
 571                 gain_display.select_region (0, -1);
 572         } else {
 573                 gain_display.select_region (0, 0);
 574         }
 575         return false;
 576 }
 577
 578 void
 579 GainMeter::gain_activated ()
 580 {
 581         float f;
 582
 583         if (sscanf (gain_display.get_text().c_str(), "%f", &f) == 1) {
 584
 585                 /* clamp to displayable values */
 586
 587                 f = min (f, 6.0f);
 588
 589                 _io->set_gain (dB_to_coefficient(f), this);
 590
 591                 if (gain_display.has_focus()) {
 592                         PublicEditor::instance().reset_focus();
 593                 }
 594         }
 595 }
 596
 597 void
 598 GainMeter::show_gain ()
 599 {
 600         char buf[32];
 601
 602         float v = gain_adjustment.get_value();
 603
 604         if (v == 0.0) {
 605                 strcpy (buf, _("-inf"));
 606         } else {
 607                 snprintf (buf, 32, "%.1f", coefficient_to_dB (slider_position_to_gain (v)));
 608         }
 609
 610         gain_display.set_text (buf);
 611 }
 612
 613 void
 614 GainMeter::gain_adjusted ()
 615 {
 616         if (!ignore_toggle) {
 617                 _io->set_gain (slider_position_to_gain (gain_adjustment.get_value()), this);
 618         }
 619         show_gain ();
 620 }
 621
 622 void
 623 GainMeter::effective_gain_display ()
 624 {
 625         gfloat value = gain_to_slider_position (_io->effective_gain());
 626
 627         if (gain_adjustment.get_value() != value) {
 628                 ignore_toggle = true;
 629                 gain_adjustment.set_value (value);
 630                 ignore_toggle = false;
 631         }
 632 }
 633
 634 void
 635 GainMeter::gain_changed (void *src)
 636 {
 637         Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &GainMeter::effective_gain_display));
 638 }
 639
 640 void
 641 GainMeter::set_meter_strip_name (const char * name)
 642 {
 643         // meter_metric_area.set_name (name);
 644 }
 645
 646 void
 647 GainMeter::set_fader_name (const char * name)
 648 {
 649         gain_slider->set_name (name);
 650 }
 651
 652 void
 653 GainMeter::update_gain_sensitive ()
 654 {
 655         static_cast<Gtkmm2ext::SliderController*>(gain_slider)->set_sensitive (!(_io->gain_automation_state() & Play));
 656 }
 657
 658
 659 static MeterPoint
 660 next_meter_point (MeterPoint mp)
 661 {
 662         switch (mp) {
 663         case MeterInput:
 664                 return MeterPreFader;
 665                 break;
 666
 667         case MeterPreFader:
 668                 return MeterPostFader;
 669                 break;
 670
 671         case MeterPostFader:
 672                 return MeterInput;
 673                 break;
 674         }
 675         /*NOTREACHED*/
 676         return MeterInput;
 677 }
 678
 679 gint
 680 GainMeter::meter_press(GdkEventButton* ev)
 681 {
 682         Route* _route;
 683
 684         wait_for_release = false;
 685
 686         if ((_route = dynamic_cast<Route*>(_io.get())) == 0) {
 687                 return FALSE;
 688         }
 689
 690         if (!ignore_toggle) {
 691
 692                 if (Keyboard::is_context_menu_event (ev)) {
 693
 694                         // no menu at this time.
 695
 696                 } else {
 697
 698                         if (ev->button == 2) {
 699
 700                                 // ctrl-button2 click is the midi binding click
 701                                 // button2-click is "momentary"
 702
 703                                 if (!Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::Control))) {
 704                                         wait_for_release = true;
 705                                         old_meter_point = _route->meter_point ();
 706                                 }
 707                         }
 708
 709                         if (ev->button == 1 || ev->button == 2) {
 710
 711                                 if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::Control|Keyboard::Shift))) {
 712
 713                                         /* ctrl-shift-click applies change to all routes */
 714
 715                                         _session.begin_reversible_command (_("meter point change"));
 716                                         Session::GlobalMeteringStateCommand *cmd = new Session::GlobalMeteringStateCommand (_session, this);
 717                                         _session.foreach_route (this, &GainMeter::set_meter_point, next_meter_point (_route->meter_point()));
 718                                         cmd->mark();
 719                                         _session.add_command (cmd);
 720                                         _session.commit_reversible_command ();
 721
 722
 723                                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::Control)) {
 724
 725                                         /* ctrl-click: solo mix group.
 726                                            ctrl-button2 is MIDI learn.
 727                                         */
 728
 729                                         if (ev->button == 1) {
 730                                                 _session.begin_reversible_command (_("meter point change"));
 731                                                 Session::GlobalMeteringStateCommand *cmd = new Session::GlobalMeteringStateCommand (_session, this);
 732                                                 set_mix_group_meter_point (*_route, next_meter_point (_route->meter_point()));
 733                                                 cmd->mark();
 734                                                 _session.add_command (cmd);
 735                                                 _session.commit_reversible_command ();
 736                                         }
 737
 738                                 } else {
 739
 740                                         /* click: change just this route */
 741
 742                                         // XXX no undo yet
 743
 744                                         _route->set_meter_point (next_meter_point (_route->meter_point()), this);
 745                                 }
 746                         }
 747                 }
 748         }
 749
 750         return true;
 751
 752 }
 753
 754 gint
 755 GainMeter::meter_release(GdkEventButton* ev)
 756 {
 757
 758         if(!ignore_toggle){
 759                 if (wait_for_release){
 760                         wait_for_release = false;
 761                         set_meter_point (*(dynamic_cast<Route*>(_io.get())), old_meter_point);
 762                 }
 763         }
 764         return true;
 765 }
 766
 767 void
 768 GainMeter::set_meter_point (Route& route, MeterPoint mp)
 769 {
 770         route.set_meter_point (mp, this);
 771 }
 772
 773 void
 774 GainMeter::set_mix_group_meter_point (Route& route, MeterPoint mp)
 775 {
 776         RouteGroup* mix_group;
 777
 778         if((mix_group = route.mix_group()) != 0){
 779                 mix_group->apply (&Route::set_meter_point, mp, this);
 780         } else {
 781                 route.set_meter_point (mp, this);
 782         }
 783 }
 784
 785 void
 786 GainMeter::meter_point_clicked ()
 787 {
 788         Route* r;
 789
 790         if ((r = dynamic_cast<Route*> (_io.get())) != 0) {
 791
 792         }
 793 }
 794
 795 gint
 796 GainMeter::start_gain_touch (GdkEventButton* ev)
 797 {
 798         _io->start_gain_touch ();
 799         return FALSE;
 800 }
 801
 802 gint
 803 GainMeter::end_gain_touch (GdkEventButton* ev)
 804 {
 805         _io->end_gain_touch ();
 806         return FALSE;
 807 }
 808
 809 gint
 810 GainMeter::gain_automation_state_button_event (GdkEventButton *ev)
 811 {
 812         if (ev->type == GDK_BUTTON_RELEASE) {
 813                 return TRUE;
 814         }
 815
 816         switch (ev->button) {
 817                 case 1:
 818                         gain_astate_menu.popup (1, ev->time);
 819                         break;
 820                 default:
 821                         break;
 822         }
 823
 824         return TRUE;
 825 }
 826
 827 gint
 828 GainMeter::gain_automation_style_button_event (GdkEventButton *ev)
 829 {
 830         if (ev->type == GDK_BUTTON_RELEASE) {
 831                 return TRUE;
 832         }
 833
 834         switch (ev->button) {
 835         case 1:
 836                 gain_astyle_menu.popup (1, ev->time);
 837                 break;
 838         default:
 839                 break;
 840         }
 841         return TRUE;
 842 }
 843
 844 string
 845 GainMeter::astate_string (AutoState state)
 846 {
 847         return _astate_string (state, false);
 848 }
 849
 850 string
 851 GainMeter::short_astate_string (AutoState state)
 852 {
 853         return _astate_string (state, true);
 854 }
 855
 856 string
 857 GainMeter::_astate_string (AutoState state, bool shrt)
 858 {
 859         string sstr;
 860
 861         switch (state) {
 862         case Off:
 863                 sstr = (shrt ? "M" : _("M"));
 864                 break;
 865         case Play:
 866                 sstr = (shrt ? "P" : _("P"));
 867                 break;
 868         case Touch:
 869                 sstr = (shrt ? "T" : _("T"));
 870                 break;
 871         case Write:
 872                 sstr = (shrt ? "W" : _("W"));
 873                 break;
 874         }
 875
 876         return sstr;
 877 }
 878
 879 string
 880 GainMeter::astyle_string (AutoStyle style)
 881 {
 882         return _astyle_string (style, false);
 883 }
 884
 885 string
 886 GainMeter::short_astyle_string (AutoStyle style)
 887 {
 888         return _astyle_string (style, true);
 889 }
 890
 891 string
 892 GainMeter::_astyle_string (AutoStyle style, bool shrt)
 893 {
 894         if (style & Trim) {
 895                 return _("Trim");
 896         } else {
 897                 /* XXX it might different in different languages */
 898
 899                 return (shrt ? _("Abs") : _("Abs"));
 900         }
 901 }
 902
 903 void
 904 GainMeter::gain_automation_style_changed ()
 905 {
 906   // Route* _route = dynamic_cast<Route*>(&_io);
 907         switch (_width) {
 908         case Wide:
 909                 gain_automation_style_button.set_label (astyle_string(_io->gain_automation_curve().automation_style()));
 910                 break;
 911         case Narrow:
 912                 gain_automation_style_button.set_label  (short_astyle_string(_io->gain_automation_curve().automation_style()));
 913                 break;
 914         }
 915 }
 916
 917 void
 918 GainMeter::gain_automation_state_changed ()
 919 {
 920         ENSURE_GUI_THREAD(mem_fun(*this, &GainMeter::gain_automation_state_changed));
 921         //Route* _route = dynamic_cast<Route*>(&_io);
 922
 923         bool x;
 924
 925         switch (_width) {
 926         case Wide:
 927                 gain_automation_state_button.set_label (astate_string(_io->gain_automation_curve().automation_state()));
 928                 break;
 929         case Narrow:
 930                 gain_automation_state_button.set_label (short_astate_string(_io->gain_automation_curve().automation_state()));
 931                 break;
 932         }
 933
 934         x = (_io->gain_automation_state() != Off);
 935
 936         if (gain_automation_state_button.get_active() != x) {
 937                 ignore_toggle = true;
 938                 gain_automation_state_button.set_active (x);
 939                 ignore_toggle = false;
 940         }
 941
 942         update_gain_sensitive ();
 943
 944         /* start watching automation so that things move */
 945
 946         gain_watching.disconnect();
 947
 948         if (x) {
 949                 gain_watching = ARDOUR_UI::RapidScreenUpdate.connect (mem_fun (*this, &GainMeter::effective_gain_display));
 950         }
 951 }