gtk2_ardour/meter_strip.cc

   1 /*
   2     Copyright (C) 2013 Paul Davis
   3     Author: Robin Gareus
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18 */
  19
  20 #include <list>
  21
  22 #include <sigc++/bind.h>
  23
  24 #include "ardour/session.h"
  25 #include "ardour/route.h"
  26 #include "ardour/route_group.h"
  27 #include "ardour/meter.h"
  28
  29 #include "ardour/audio_track.h"
  30 #include "ardour/midi_track.h"
  31
  32 #include <gtkmm2ext/gtk_ui.h>
  33 #include <gtkmm2ext/keyboard.h>
  34 #include <gtkmm2ext/utils.h>
  35 #include <gtkmm2ext/rgb_macros.h>
  36
  37 #include "ardour_ui.h"
  38 #include "global_signals.h"
  39 #include "logmeter.h"
  40 #include "gui_thread.h"
  41 #include "ardour_window.h"
  42 #include "utils.h"
  43
  44 #include "meterbridge.h"
  45 #include "meter_strip.h"
  46 #include "meter_patterns.h"
  47
  48 #include "i18n.h"
  49
  50 using namespace ARDOUR;
  51 using namespace ARDOUR_UI_UTILS;
  52 using namespace PBD;
  53 using namespace Gtk;
  54 using namespace Gtkmm2ext;
  55 using namespace std;
  56 using namespace ArdourMeter;
  57
  58 PBD::Signal1<void,MeterStrip*> MeterStrip::CatchDeletion;
  59 PBD::Signal0<void> MeterStrip::MetricChanged;
  60 PBD::Signal0<void> MeterStrip::ConfigurationChanged;
  61
  62 MeterStrip::MeterStrip (int metricmode, MeterType mt)
  63         : AxisView(0)
  64         , RouteUI(0)
  65 {
  66         level_meter = 0;
  67         _strip_type = 0;
  68         _tick_bar = 0;
  69         _metricmode = -1;
  70         metric_type = MeterPeak;
  71         mtr_vbox.set_spacing(2);
  72         nfo_vbox.set_spacing(2);
  73         peakbx.set_size_request(-1, 14);
  74         namebx.set_size_request(18, 52);
  75         spacer.set_size_request(-1,0);
  76
  77         set_metric_mode(metricmode, mt);
  78
  79         meter_metric_area.set_size_request(25, 10);
  80         meter_metric_area.signal_expose_event().connect (
  81                         sigc::mem_fun(*this, &MeterStrip::meter_metrics_expose));
  82         RedrawMetrics.connect (sigc::mem_fun(*this, &MeterStrip::redraw_metrics));
  83
  84         meterbox.pack_start(meter_metric_area, true, false);
  85
  86         mtr_vbox.pack_start (peakbx, false, false);
  87         mtr_vbox.pack_start (meterbox, true, true);
  88         mtr_vbox.pack_start (spacer, false, false);
  89         mtr_container.add(mtr_vbox);
  90
  91         mtr_hsep.set_size_request(-1,1);
  92         mtr_hsep.set_name("BlackSeparator");
  93
  94         nfo_vbox.pack_start (mtr_hsep, false, false);
  95         nfo_vbox.pack_start (btnbox, false, false);
  96         nfo_vbox.pack_start (namebx, false, false);
  97
  98         pack_start (mtr_container, true, true);
  99         pack_start (nfo_vbox, false, false);
 100
 101         peakbx.show();
 102         btnbox.show();
 103         meter_metric_area.show();
 104         meterbox.show();
 105         spacer.show();
 106         mtr_vbox.show();
 107         mtr_container.show();
 108         mtr_hsep.show();
 109         nfo_vbox.show();
 110
 111         UI::instance()->theme_changed.connect (sigc::mem_fun(*this, &MeterStrip::on_theme_changed));
 112         ColorsChanged.connect (sigc::mem_fun (*this, &MeterStrip::on_theme_changed));
 113         DPIReset.connect (sigc::mem_fun (*this, &MeterStrip::on_theme_changed));
 114 }
 115
 116 MeterStrip::MeterStrip (Session* sess, boost::shared_ptr<ARDOUR::Route> rt)
 117         : AxisView(sess)
 118         , RouteUI(sess)
 119         , _route(rt)
 120         , peak_display()
 121 {
 122         mtr_vbox.set_spacing(2);
 123         nfo_vbox.set_spacing(2);
 124         RouteUI::set_route (rt);
 125         SessionHandlePtr::set_session (sess);
 126
 127         _has_midi = false;
 128         _tick_bar = 0;
 129         _metricmode = -1;
 130         metric_type = MeterPeak;
 131
 132         int meter_width = 6;
 133         if (_route->shared_peak_meter()->input_streams().n_total() == 1) {
 134                 meter_width = 12;
 135         }
 136
 137         // level meter + ticks
 138         level_meter = new LevelMeterHBox(sess);
 139         level_meter->set_meter (_route->shared_peak_meter().get());
 140         level_meter->clear_meters();
 141         level_meter->set_type (_route->meter_type());
 142         level_meter->setup_meters (220, meter_width, 6);
 143         level_meter->ButtonRelease.connect_same_thread (level_meter_connection, boost::bind (&MeterStrip::level_meter_button_release, this, _1));
 144         level_meter->MeterTypeChanged.connect_same_thread (level_meter_connection, boost::bind (&MeterStrip::meter_type_changed, this, _1));
 145
 146         meter_align.set(0.5, 0.5, 0.0, 1.0);
 147         meter_align.add(*level_meter);
 148
 149         meterbox.pack_start(meter_ticks1_area, true, false);
 150         meterbox.pack_start(meter_align, true, true);
 151         meterbox.pack_start(meter_ticks2_area, true, false);
 152
 153         // peak display
 154         peak_display.set_name ("meterbridge peakindicator");
 155         peak_display.set_elements((ArdourButton::Element) (ArdourButton::Edge|ArdourButton::Body));
 156         max_peak = minus_infinity();
 157         peak_display.unset_flags (Gtk::CAN_FOCUS);
 158         peak_display.set_size_request(12, 8);
 159         peak_display.set_corner_radius(2);
 160
 161         peak_align.set(0.5, 1.0, 1.0, 0.8);
 162         peak_align.add(peak_display);
 163         peakbx.pack_start(peak_align, true, true, 3);
 164         peakbx.set_size_request(-1, 14);
 165
 166         // add track-name label
 167         name_label.set_text(_route->name());
 168         name_label.set_corner_radius(2);
 169         name_label.set_name("meterbridge label");
 170         name_label.set_angle(-90.0);
 171         name_label.layout()->set_ellipsize (Pango::ELLIPSIZE_END);
 172         name_label.layout()->set_width(48 * PANGO_SCALE);
 173         name_label.set_size_request(18, 50);
 174         name_label.set_alignment(-1.0, .5);
 175         ARDOUR_UI::instance()->set_tip (name_label, _route->name());
 176         ARDOUR_UI::instance()->set_tip (*level_meter, _route->name());
 177
 178         namebx.set_size_request(18, 52);
 179         namebx.pack_start(name_label, true, false, 3);
 180
 181         mon_in_box.pack_start(*monitor_input_button, true, false);
 182         btnbox.pack_start(mon_in_box, false, false, 1);
 183         mon_disk_box.pack_start(*monitor_disk_button, true, false);
 184         btnbox.pack_start(mon_disk_box, false, false, 1);
 185
 186         recbox.pack_start(*rec_enable_button, true, false);
 187         btnbox.pack_start(recbox, false, false, 1);
 188         mutebox.pack_start(*mute_button, true, false);
 189         btnbox.pack_start(mutebox, false, false, 1);
 190         solobox.pack_start(*solo_button, true, false);
 191         btnbox.pack_start(solobox, false, false, 1);
 192
 193         rec_enable_button->set_corner_radius(2);
 194         rec_enable_button->set_size_request(16, 16);
 195
 196         mute_button->set_corner_radius(2);
 197         mute_button->set_size_request(16, 16);
 198
 199         solo_button->set_corner_radius(2);
 200         solo_button->set_size_request(16, 16);
 201
 202         monitor_input_button->set_corner_radius(2);
 203         monitor_input_button->set_size_request(16, 16);
 204
 205         monitor_disk_button->set_corner_radius(2);
 206         monitor_disk_button->set_size_request(16, 16);
 207
 208         mutebox.set_size_request(16, 16);
 209         solobox.set_size_request(16, 16);
 210         recbox.set_size_request(16, 16);
 211         mon_in_box.set_size_request(16, 16);
 212         mon_disk_box.set_size_request(16, 16);
 213         spacer.set_size_request(-1,0);
 214
 215         update_button_box();
 216         update_name_box();
 217         update_background (_route->meter_type());
 218
 219         mtr_vbox.pack_start (peakbx, false, false);
 220         mtr_vbox.pack_start (meterbox, true, true);
 221         mtr_vbox.pack_start (spacer, false, false);
 222         mtr_container.add(mtr_vbox);
 223
 224         mtr_hsep.set_size_request(-1,1);
 225         mtr_hsep.set_name("BlackSeparator");
 226
 227         nfo_vbox.pack_start (mtr_hsep, false, false);
 228         nfo_vbox.pack_start (btnbox, false, false);
 229         nfo_vbox.pack_start (namebx, false, false);
 230
 231         pack_start (mtr_container, true, true);
 232         pack_start (nfo_vbox, false, false);
 233
 234         name_label.show();
 235         peak_display.show();
 236         peakbx.show();
 237         meter_ticks1_area.show();
 238         meter_ticks2_area.show();
 239         meterbox.show();
 240         spacer.show();
 241         level_meter->show();
 242         meter_align.show();
 243         peak_align.show();
 244         btnbox.show();
 245         mtr_vbox.show();
 246         mtr_container.show();
 247         mtr_hsep.show();
 248         nfo_vbox.show();
 249
 250         if (boost::dynamic_pointer_cast<Track>(_route)) {
 251                 monitor_input_button->show();
 252                 monitor_disk_button->show();
 253         } else {
 254                 monitor_input_button->hide();
 255                 monitor_disk_button->hide();
 256         }
 257
 258         _route->shared_peak_meter()->ConfigurationChanged.connect (
 259                         route_connections, invalidator (*this), boost::bind (&MeterStrip::meter_configuration_changed, this, _1), gui_context()
 260                         );
 261
 262         ResetAllPeakDisplays.connect (sigc::mem_fun(*this, &MeterStrip::reset_peak_display));
 263         ResetRoutePeakDisplays.connect (sigc::mem_fun(*this, &MeterStrip::reset_route_peak_display));
 264         ResetGroupPeakDisplays.connect (sigc::mem_fun(*this, &MeterStrip::reset_group_peak_display));
 265         RedrawMetrics.connect (sigc::mem_fun(*this, &MeterStrip::redraw_metrics));
 266         SetMeterTypeMulti.connect (sigc::mem_fun(*this, &MeterStrip::set_meter_type_multi));
 267
 268         meter_configuration_changed (_route->shared_peak_meter()->input_streams ());
 269
 270         meter_ticks1_area.set_size_request(3,-1);
 271         meter_ticks2_area.set_size_request(3,-1);
 272         meter_ticks1_area.signal_expose_event().connect (sigc::mem_fun(*this, &MeterStrip::meter_ticks1_expose));
 273         meter_ticks2_area.signal_expose_event().connect (sigc::mem_fun(*this, &MeterStrip::meter_ticks2_expose));
 274
 275         _route->DropReferences.connect (route_connections, invalidator (*this), boost::bind (&MeterStrip::self_delete, this), gui_context());
 276         _route->PropertyChanged.connect (route_connections, invalidator (*this), boost::bind (&MeterStrip::strip_property_changed, this, _1), gui_context());
 277
 278         peak_display.signal_button_release_event().connect (sigc::mem_fun(*this, &MeterStrip::peak_button_release), false);
 279         name_label.signal_button_release_event().connect (sigc::mem_fun(*this, &MeterStrip::name_label_button_release), false);
 280
 281         UI::instance()->theme_changed.connect (sigc::mem_fun(*this, &MeterStrip::on_theme_changed));
 282         ColorsChanged.connect (sigc::mem_fun (*this, &MeterStrip::on_theme_changed));
 283         DPIReset.connect (sigc::mem_fun (*this, &MeterStrip::on_theme_changed));
 284         Config->ParameterChanged.connect (*this, invalidator (*this), ui_bind (&MeterStrip::parameter_changed, this, _1), gui_context());
 285         sess->config.ParameterChanged.connect (*this, invalidator (*this), ui_bind (&MeterStrip::parameter_changed, this, _1), gui_context());
 286
 287         if (_route->is_master()) {
 288                 _strip_type = 4;
 289         }
 290         else if (boost::dynamic_pointer_cast<AudioTrack>(_route) == 0
 291                         && boost::dynamic_pointer_cast<MidiTrack>(_route) == 0) {
 292                 /* non-master bus */
 293                 _strip_type = 3;
 294         }
 295         else if (boost::dynamic_pointer_cast<MidiTrack>(_route)) {
 296                 _strip_type = 2;
 297         }
 298         else {
 299                 _strip_type = 1;
 300         }
 301 }
 302
 303 MeterStrip::~MeterStrip ()
 304 {
 305         if (level_meter) {
 306                 delete level_meter;
 307                 CatchDeletion (this);
 308         }
 309 }
 310
 311 void
 312 MeterStrip::self_delete ()
 313 {
 314         delete this;
 315 }
 316
 317 void
 318 MeterStrip::set_session (Session* s)
 319 {
 320         SessionHandlePtr::set_session (s);
 321         if (!s) return;
 322         s->config.ParameterChanged.connect (*this, invalidator (*this), ui_bind (&MeterStrip::parameter_changed, this, _1), gui_context());
 323         update_button_box();
 324         update_name_box();
 325 }
 326
 327 void
 328 MeterStrip::update_rec_display ()
 329 {
 330         RouteUI::update_rec_display ();
 331 }
 332
 333 std::string
 334 MeterStrip::state_id() const
 335 {
 336         return string_compose ("mtrs %1", _route->id().to_s());
 337 }
 338
 339 void
 340 MeterStrip::set_button_names()
 341 {
 342         mute_button->set_text (_("M"));
 343         rec_enable_button->set_text ("");
 344         rec_enable_button->set_image (::get_icon (X_("record_normal_red")));
 345
 346         if (_route && _route->solo_safe()) {
 347                 solo_button->set_visual_state (Gtkmm2ext::VisualState (solo_button->visual_state() | Gtkmm2ext::Insensitive));
 348         } else {
 349                 solo_button->set_visual_state (Gtkmm2ext::VisualState (solo_button->visual_state() & ~Gtkmm2ext::Insensitive));
 350         }
 351         if (!Config->get_solo_control_is_listen_control()) {
 352                 solo_button->set_text (_("S"));
 353         } else {
 354                 switch (Config->get_listen_position()) {
 355                 case AfterFaderListen:
 356                         solo_button->set_text (_("A"));
 357                         break;
 358                 case PreFaderListen:
 359                         solo_button->set_text (_("P"));
 360                         break;
 361                 }
 362         }
 363
 364         monitor_input_button->set_text (_("I"));
 365         monitor_disk_button->set_text (_("D"));
 366 }
 367
 368 void
 369 MeterStrip::strip_property_changed (const PropertyChange& what_changed)
 370 {
 371         if (!what_changed.contains (ARDOUR::Properties::name)) {
 372                 return;
 373         }
 374         ENSURE_GUI_THREAD (*this, &MeterStrip::strip_name_changed, what_changed)
 375         name_label.set_text(_route->name());
 376         ARDOUR_UI::instance()->set_tip (name_label, _route->name());
 377         if (level_meter) {
 378                 ARDOUR_UI::instance()->set_tip (*level_meter, _route->name());
 379         }
 380 }
 381
 382 void
 383 MeterStrip::fast_update ()
 384 {
 385         float mpeak = level_meter->update_meters();
 386         if (mpeak > max_peak) {
 387                 max_peak = mpeak;
 388                 if (mpeak >= Config->get_meter_peak()) {
 389                         peak_display.set_name ("meterbridge peakindicator on");
 390                         peak_display.set_elements((ArdourButton::Element) (ArdourButton::Edge|ArdourButton::Body));
 391                 }
 392         }
 393 }
 394
 395 void
 396 MeterStrip::on_theme_changed()
 397 {
 398         if (level_meter && _route) {
 399                 int meter_width = 6;
 400                 if (_route->shared_peak_meter()->input_streams().n_total() == 1) {
 401                         meter_width = 12;
 402                 }
 403                 level_meter->setup_meters (220, meter_width, 6);
 404         }
 405 }
 406
 407 void
 408 MeterStrip::meter_configuration_changed (ChanCount c)
 409 {
 410         int type = 0;
 411         _types.clear ();
 412         bool old_has_midi = _has_midi;
 413
 414         for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) {
 415                 if (c.get (*i) > 0) {
 416                         _types.push_back (*i);
 417                         type |= 1 << (*i);
 418                 }
 419         }
 420
 421         if (boost::dynamic_pointer_cast<AudioTrack>(_route) == 0
 422                         && boost::dynamic_pointer_cast<MidiTrack>(_route) == 0
 423                         ) {
 424                 meter_ticks1_area.set_name ("MyAudioBusMetricsLeft");
 425                 meter_ticks2_area.set_name ("MyAudioBusMetricsRight");
 426                 _has_midi = false;
 427         }
 428         else if (type == (1 << DataType::AUDIO)) {
 429                 meter_ticks1_area.set_name ("MyAudioTrackMetricsLeft");
 430                 meter_ticks2_area.set_name ("MyAudioTrackMetricsRight");
 431                 _has_midi = false;
 432         }
 433         else if (type == (1 << DataType::MIDI)) {
 434                 meter_ticks1_area.set_name ("MidiTrackMetricsLeft");
 435                 meter_ticks2_area.set_name ("MidiTrackMetricsRight");
 436                 _has_midi = true;
 437         } else {
 438                 meter_ticks1_area.set_name ("AudioMidiTrackMetricsLeft");
 439                 meter_ticks2_area.set_name ("AudioMidiTrackMetricsRight");
 440                 _has_midi = true;
 441         }
 442         set_tick_bar(_tick_bar);
 443
 444         on_theme_changed();
 445         if (old_has_midi != _has_midi) MetricChanged();
 446         else ConfigurationChanged();
 447 }
 448
 449 void
 450 MeterStrip::set_tick_bar (int m)
 451 {
 452         std::string n;
 453         _tick_bar = m;
 454         if (_tick_bar & 1) {
 455                 n = meter_ticks1_area.get_name();
 456                 if (n.substr(0,3) != "Bar") {
 457                         meter_ticks1_area.set_name("Bar" + n);
 458                 }
 459         } else {
 460                 n = meter_ticks1_area.get_name();
 461                 if (n.substr(0,3) == "Bar") {
 462                         meter_ticks1_area.set_name(n.substr(3,-1));
 463                 }
 464         }
 465         if (_tick_bar & 2) {
 466                 n = meter_ticks2_area.get_name();
 467                 if (n.substr(0,3) != "Bar") {
 468                         meter_ticks2_area.set_name("Bar" + n);
 469                 }
 470         } else {
 471                 n = meter_ticks2_area.get_name();
 472                 if (n.substr(0,3) == "Bar") {
 473                         meter_ticks2_area.set_name(n.substr(3,-1));
 474                 }
 475         }
 476 }
 477
 478 void
 479 MeterStrip::on_size_request (Gtk::Requisition* r)
 480 {
 481         VBox::on_size_request(r);
 482 }
 483
 484 void
 485 MeterStrip::on_size_allocate (Gtk::Allocation& a)
 486 {
 487         const int wh = a.get_height();
 488         int nh;
 489         int mh = 0;
 490         if (_session) {
 491                 mh = _session->config.get_meterbridge_label_height();
 492         }
 493         switch (mh) {
 494                 default:
 495                 case 0:
 496                         nh = ceilf(wh * .12f);
 497                         if (nh < 52) nh = 52;
 498                         if (nh > 148) nh = 148;
 499                         break;
 500                 case 1:
 501                         nh = 52;
 502                         break;
 503                 case 2:
 504                         nh = 88;
 505                         break;
 506                 case 3:
 507                         nh = 106;
 508                         break;
 509                 case 4:
 510                         nh = 148;
 511                         break;
 512         }
 513         namebx.set_size_request(18, nh);
 514         if (_route) {
 515                 name_label.set_size_request(18, nh-2);
 516                 name_label.layout()->set_width((nh-4) * PANGO_SCALE);
 517         }
 518         VBox::on_size_allocate(a);
 519 }
 520
 521 gint
 522 MeterStrip::meter_metrics_expose (GdkEventExpose *ev)
 523 {
 524         if (_route) {
 525                 return meter_expose_metrics(ev, _route->meter_type(), _types, &meter_metric_area);
 526         } else {
 527                 return meter_expose_metrics(ev, metric_type, _types, &meter_metric_area);
 528         }
 529 }
 530
 531 void
 532 MeterStrip::set_metric_mode (int metricmode, ARDOUR::MeterType mt)
 533 {
 534         if (metric_type == mt && _metricmode == metricmode) {
 535                 return;
 536         }
 537         metric_type = mt;
 538         _metricmode = metricmode;
 539
 540         _types.clear ();
 541         switch(metricmode) {
 542                 case 0:
 543                         meter_metric_area.set_name ("MidiTrackMetricsLeft");
 544                         _types.push_back (DataType::MIDI);
 545                         break;
 546                 case 1:
 547                         meter_metric_area.set_name ("AudioTrackMetricsLeft");
 548                         _types.push_back (DataType::AUDIO);
 549                         break;
 550                 case 2:
 551                         meter_metric_area.set_name ("MidiTrackMetricsRight");
 552                         _types.push_back (DataType::MIDI);
 553                         break;
 554                 case 3:
 555                 default:
 556                         meter_metric_area.set_name ("AudioTrackMetricsRight");
 557                         _types.push_back (DataType::AUDIO);
 558                         break;
 559         }
 560         update_background (mt);
 561         meter_metric_area.queue_draw ();
 562 }
 563
 564 void
 565 MeterStrip::update_background(MeterType type)
 566 {
 567         switch(type) {
 568                 case MeterIEC1DIN:
 569                 case MeterIEC1NOR:
 570                 case MeterIEC2BBC:
 571                 case MeterIEC2EBU:
 572                 case MeterK12:
 573                 case MeterK14:
 574                 case MeterK20:
 575                         mtr_container.set_name ("meterstripPPM");
 576                         break;
 577                 case MeterVU:
 578                         mtr_container.set_name ("meterstripVU");
 579                         break;
 580                 default:
 581                         mtr_container.set_name ("meterstripDPM");
 582         }
 583 }
 584
 585 MeterType
 586 MeterStrip::meter_type()
 587 {
 588         assert((!_route && _strip_type == 0) || (_route && _strip_type != 0));
 589         if (!_route) return metric_type;
 590         return _route->meter_type();
 591 }
 592
 593 gint
 594 MeterStrip::meter_ticks1_expose (GdkEventExpose *ev)
 595 {
 596         assert(_route);
 597         return meter_expose_ticks(ev, _route->meter_type(), _types, &meter_ticks1_area);
 598 }
 599
 600 gint
 601 MeterStrip::meter_ticks2_expose (GdkEventExpose *ev)
 602 {
 603         assert(_route);
 604         return meter_expose_ticks(ev, _route->meter_type(), _types, &meter_ticks2_area);
 605 }
 606
 607 void
 608 MeterStrip::reset_route_peak_display (Route* route)
 609 {
 610         if (_route && _route.get() == route) {
 611                 reset_peak_display ();
 612         }
 613 }
 614
 615 void
 616 MeterStrip::reset_group_peak_display (RouteGroup* group)
 617 {
 618         if (_route && group == _route->route_group()) {
 619                 reset_peak_display ();
 620         }
 621 }
 622
 623 void
 624 MeterStrip::reset_peak_display ()
 625 {
 626         _route->shared_peak_meter()->reset_max();
 627         level_meter->clear_meters();
 628         max_peak = -INFINITY;
 629         peak_display.set_name ("meterbridge peakindicator");
 630         peak_display.set_elements((ArdourButton::Element) (ArdourButton::Edge|ArdourButton::Body));
 631 }
 632
 633 bool
 634 MeterStrip::peak_button_release (GdkEventButton* ev)
 635 {
 636         if (ev->button == 1 && Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier|Keyboard::TertiaryModifier)) {
 637                 ResetAllPeakDisplays ();
 638         } else if (ev->button == 1 && Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 639                 if (_route) {
 640                         ResetGroupPeakDisplays (_route->route_group());
 641                 }
 642         } else {
 643                 ResetRoutePeakDisplays (_route.get());
 644         }
 645         return true;
 646 }
 647
 648 void
 649 MeterStrip::redraw_metrics ()
 650 {
 651         meter_metric_area.queue_draw();
 652         meter_ticks1_area.queue_draw();
 653         meter_ticks2_area.queue_draw();
 654 }
 655
 656 void
 657 MeterStrip::update_button_box ()
 658 {
 659         if (!_session) return;
 660         int height = 0;
 661         if (_session->config.get_show_mute_on_meterbridge()) {
 662                 height += 18;
 663                 mutebox.show();
 664         } else {
 665                 mutebox.hide();
 666         }
 667         if (_session->config.get_show_solo_on_meterbridge()) {
 668                 height += 18;
 669                 solobox.show();
 670         } else {
 671                 solobox.hide();
 672         }
 673         if (_session->config.get_show_rec_on_meterbridge()) {
 674                 height += 18;
 675                 recbox.show();
 676         } else {
 677                 recbox.hide();
 678         }
 679         if (_session->config.get_show_monitor_on_meterbridge()) {
 680                 height += 18 + 18;
 681                 mon_in_box.show();
 682                 mon_disk_box.show();
 683         } else {
 684                 mon_in_box.hide();
 685                 mon_disk_box.hide();
 686         }
 687         btnbox.set_size_request(16, height);
 688         check_resize();
 689 }
 690
 691 void
 692 MeterStrip::update_name_box ()
 693 {
 694         if (!_session) return;
 695         if (_session->config.get_show_name_on_meterbridge()) {
 696                 namebx.show();
 697         } else {
 698                 namebx.hide();
 699         }
 700 }
 701
 702 void
 703 MeterStrip::parameter_changed (std::string const & p)
 704 {
 705         if (p == "meter-peak") {
 706                 max_peak = -INFINITY;
 707         }
 708         else if (p == "show-rec-on-meterbridge") {
 709                 update_button_box();
 710         }
 711         else if (p == "show-mute-on-meterbridge") {
 712                 update_button_box();
 713         }
 714         else if (p == "show-solo-on-meterbridge") {
 715                 update_button_box();
 716         }
 717         else if (p == "show-name-on-meterbridge") {
 718                 update_name_box();
 719         }
 720         else if (p == "show-monitor-on-meterbridge") {
 721                 update_button_box();
 722         }
 723         else if (p == "meterbridge-label-height") {
 724                 queue_resize();
 725         }
 726 }
 727
 728 bool
 729 MeterStrip::level_meter_button_release (GdkEventButton* ev)
 730 {
 731         if (ev->button == 3) {
 732                 popup_level_meter_menu (ev);
 733                 return true;
 734         }
 735
 736         return false;
 737 }
 738
 739 void
 740 MeterStrip::popup_level_meter_menu (GdkEventButton* ev)
 741 {
 742         using namespace Gtk::Menu_Helpers;
 743
 744         Gtk::Menu* m = manage (new Menu);
 745         MenuList& items = m->items ();
 746
 747         RadioMenuItem::Group group;
 748
 749         _suspend_menu_callbacks = true;
 750         add_level_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterPeak), MeterPeak);
 751         add_level_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterKrms),  MeterKrms);
 752         add_level_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterIEC1DIN), MeterIEC1DIN);
 753         add_level_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterIEC1NOR), MeterIEC1NOR);
 754         add_level_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterIEC2BBC), MeterIEC2BBC);
 755         add_level_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterIEC2EBU), MeterIEC2EBU);
 756         add_level_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterK20), MeterK20);
 757         add_level_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterK14), MeterK14);
 758         add_level_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterK12), MeterK12);
 759         add_level_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterVU),  MeterVU);
 760
 761         MeterType cmt = _route->meter_type();
 762         const std::string cmn = ArdourMeter::meter_type_string(cmt);
 763
 764         items.push_back (SeparatorElem());
 765         items.push_back (MenuElem (string_compose(_("Change all in Group to %1"), cmn),
 766                                 sigc::bind (SetMeterTypeMulti, -1, _route->route_group(), cmt)));
 767         items.push_back (MenuElem (string_compose(_("Change all to %1"), cmn),
 768                                 sigc::bind (SetMeterTypeMulti, 0, _route->route_group(), cmt)));
 769         items.push_back (MenuElem (string_compose(_("Change same track-type to %1"), cmn),
 770                                 sigc::bind (SetMeterTypeMulti, _strip_type, _route->route_group(), cmt)));
 771
 772         m->popup (ev->button, ev->time);
 773         _suspend_menu_callbacks = false;
 774 }
 775
 776 bool
 777 MeterStrip::name_label_button_release (GdkEventButton* ev)
 778 {
 779         if (!_session) return true;
 780         if (!_session->config.get_show_name_on_meterbridge()) return true;
 781
 782         if (ev->button == 3) {
 783                 popup_name_label_menu (ev);
 784                 return true;
 785         }
 786
 787         return false;
 788 }
 789
 790 void
 791 MeterStrip::popup_name_label_menu (GdkEventButton* ev)
 792 {
 793         using namespace Gtk::Menu_Helpers;
 794
 795         Gtk::Menu* m = manage (new Menu);
 796         MenuList& items = m->items ();
 797
 798         RadioMenuItem::Group group;
 799
 800         _suspend_menu_callbacks = true;
 801         add_label_height_item (items, group, _("Variable height"), 0);
 802         add_label_height_item (items, group, _("Short"), 1);
 803         add_label_height_item (items, group, _("Tall"), 2);
 804         add_label_height_item (items, group, _("Grande"), 3);
 805         add_label_height_item (items, group, _("Venti"), 4);
 806
 807         m->popup (ev->button, ev->time);
 808         _suspend_menu_callbacks = false;
 809 }
 810
 811 void
 812 MeterStrip::add_label_height_item (Menu_Helpers::MenuList& items, RadioMenuItem::Group& group, string const & name, uint32_t h)
 813 {
 814         using namespace Menu_Helpers;
 815
 816         items.push_back (RadioMenuElem (group, name, sigc::bind (sigc::mem_fun (*this, &MeterStrip::set_label_height), h)));
 817         RadioMenuItem* i = dynamic_cast<RadioMenuItem *> (&items.back ());
 818         i->set_active (_session && _session->config.get_meterbridge_label_height() == h);
 819 }
 820
 821 void
 822 MeterStrip::add_level_meter_type_item (Menu_Helpers::MenuList& items, RadioMenuItem::Group& group, string const & name, MeterType type)
 823 {
 824         using namespace Menu_Helpers;
 825
 826         items.push_back (RadioMenuElem (group, name, sigc::bind (sigc::mem_fun (*this, &MeterStrip::set_meter_type), type)));
 827         RadioMenuItem* i = dynamic_cast<RadioMenuItem *> (&items.back ());
 828         i->set_active (_route->meter_type() == type);
 829 }
 830
 831 void
 832 MeterStrip::set_meter_type (MeterType type)
 833 {
 834         if (_suspend_menu_callbacks) return;
 835         if (_route->meter_type() == type) return;
 836
 837         level_meter->set_type (type);
 838 }
 839
 840 void
 841 MeterStrip::set_label_height (uint32_t h)
 842 {
 843         if (_suspend_menu_callbacks) return;
 844         _session->config.set_meterbridge_label_height(h);
 845 }
 846
 847 void
 848 MeterStrip::meter_type_changed (MeterType type)
 849 {
 850         if (_route->meter_type() != type) {
 851                 _route->set_meter_type(type);
 852         }
 853         update_background (type);
 854         MetricChanged();
 855 }
 856
 857 void
 858 MeterStrip::set_meter_type_multi (int what, RouteGroup* group, MeterType type)
 859 {
 860         switch (what) {
 861                 case -1:
 862                         if (_route && group == _route->route_group()) {
 863                                 level_meter->set_type (type);
 864                         }
 865                         break;
 866                 case 0:
 867                         level_meter->set_type (type);
 868                 default:
 869                         if (what == _strip_type) {
 870                                 level_meter->set_type (type);
 871                         }
 872                         break;
 873         }
 874 }