gtk2_ardour/meterbridge.cc

   1 /*
   2     Copyright (C) 2012 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
  21 #ifdef WAF_BUILD
  22 #include "gtk2ardour-config.h"
  23 #endif
  24
  25 #include <map>
  26 #include <sigc++/bind.h>
  27
  28 #include <gtkmm/accelmap.h>
  29
  30 #include <glibmm/threads.h>
  31
  32 #include <gtkmm2ext/gtk_ui.h>
  33 #include <gtkmm2ext/utils.h>
  34 #include <gtkmm2ext/window_title.h>
  35
  36 #include "ardour/debug.h"
  37 #include "ardour/midi_track.h"
  38 #include "ardour/route_group.h"
  39 #include "ardour/session.h"
  40
  41 #include "ardour/audio_track.h"
  42 #include "ardour/midi_track.h"
  43 #include "ardour/route_sorters.h"
  44
  45 #include "meterbridge.h"
  46
  47 #include "keyboard.h"
  48 #include "monitor_section.h"
  49 #include "public_editor.h"
  50 #include "ardour_ui.h"
  51 #include "utils.h"
  52 #include "route_sorter.h"
  53 #include "actions.h"
  54 #include "gui_thread.h"
  55 #include "global_signals.h"
  56 #include "meter_patterns.h"
  57 #include "timers.h"
  58
  59 #include "i18n.h"
  60
  61 using namespace ARDOUR;
  62 using namespace ARDOUR_UI_UTILS;
  63 using namespace PBD;
  64 using namespace Gtk;
  65 using namespace Glib;
  66 using namespace Gtkmm2ext;
  67 using namespace std;
  68 using namespace ArdourMeter;
  69
  70 using PBD::atoi;
  71
  72 Meterbridge* Meterbridge::_instance = 0;
  73
  74 Meterbridge*
  75 Meterbridge::instance ()
  76 {
  77         if (!_instance) {
  78                 _instance  = new Meterbridge;
  79         }
  80
  81         return _instance;
  82 }
  83
  84 Meterbridge::Meterbridge ()
  85         : Window (Gtk::WINDOW_TOPLEVEL)
  86         , VisibilityTracker (*((Gtk::Window*) this))
  87         , _visible (false)
  88         , _show_busses (false)
  89         , metrics_left (1, MeterPeak)
  90         , metrics_right (2, MeterPeak)
  91         , cur_max_width (-1)
  92 {
  93         set_name ("Meter Bridge");
  94
  95         m_width = default_width;
  96         m_height = default_height;
  97         m_root_x = 1;
  98         m_root_y = 1;
  99
 100         update_title ();
 101
 102         set_wmclass (X_("ardour_mixer"), PROGRAM_NAME);
 103
 104         Gdk::Geometry geom;
 105         geom.max_width = 1<<16;
 106         geom.max_height = max_height;
 107         geom.min_width = 40;
 108         geom.min_height = -1;
 109         geom.height_inc = 16;
 110         geom.width_inc = 1;
 111         assert(max_height % 16 == 0);
 112         set_geometry_hints(*((Gtk::Window*) this), geom, Gdk::HINT_MIN_SIZE | Gdk::HINT_MAX_SIZE | Gdk::HINT_RESIZE_INC);
 113
 114         set_border_width (0);
 115
 116         metrics_vpacker_left.pack_start (metrics_left, true, true);
 117         metrics_vpacker_left.pack_start (metrics_spacer_left, false, false);
 118         metrics_spacer_left.set_size_request(-1, 0);
 119         metrics_spacer_left.set_spacing(0);
 120
 121         metrics_vpacker_right.pack_start (metrics_right, true, true);
 122         metrics_vpacker_right.pack_start (metrics_spacer_right, false, false);
 123         metrics_spacer_right.set_size_request(-1, 0);
 124         metrics_spacer_right.set_spacing(0);
 125
 126         signal_delete_event().connect (sigc::mem_fun (*this, &Meterbridge::hide_window));
 127         signal_configure_event().connect (sigc::mem_fun (*ARDOUR_UI::instance(), &ARDOUR_UI::configure_handler));
 128         Route::SyncOrderKeys.connect (*this, invalidator (*this), boost::bind (&Meterbridge::sync_order_keys, this), gui_context());
 129         MeterStrip::CatchDeletion.connect (*this, invalidator (*this), boost::bind (&Meterbridge::remove_strip, this, _1), gui_context());
 130         MeterStrip::MetricChanged.connect (*this, invalidator (*this), boost::bind(&Meterbridge::resync_order, this), gui_context());
 131         MeterStrip::ConfigurationChanged.connect (*this, invalidator (*this), boost::bind(&Meterbridge::queue_resize, this), gui_context());
 132
 133         /* work around ScrolledWindowViewport alignment mess Part one */
 134         Gtk::HBox * yspc = manage (new Gtk::HBox());
 135         yspc->set_size_request(-1, 1);
 136         Gtk::VBox * xspc = manage (new Gtk::VBox());
 137         xspc->pack_start(meterarea, true, true);
 138         xspc->pack_start(*yspc, false, false);
 139         yspc->show();
 140         xspc->show();
 141
 142         meterarea.set_spacing(0);
 143         scroller.set_shadow_type(Gtk::SHADOW_NONE);
 144         scroller.set_border_width(0);
 145         scroller.add (*xspc);
 146         scroller.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_NEVER);
 147
 148         global_hpacker.pack_start (metrics_vpacker_left, false, false);
 149         global_hpacker.pack_start (scroller, true, true);
 150         global_hpacker.pack_start (metrics_vpacker_right, false, false);
 151
 152         global_vpacker.pack_start (global_hpacker, true, true);
 153         add (global_vpacker);
 154
 155         metrics_left.show();
 156         metrics_right.show();
 157
 158         metrics_vpacker_left.show();
 159         metrics_spacer_left.show();
 160         metrics_vpacker_right.show();
 161         metrics_spacer_right.show();
 162
 163         meterarea.show();
 164         global_vpacker.show();
 165         global_hpacker.show();
 166         scroller.show();
 167
 168         /* the return of the ScrolledWindowViewport mess:
 169          * remove shadow from scrollWindow's viewport
 170          * see http://www.mail-archive.com/gtkmm-list@gnome.org/msg03509.html
 171          */
 172         Gtk::Viewport* viewport = (Gtk::Viewport*) scroller.get_child();
 173         viewport->set_shadow_type(Gtk::SHADOW_NONE);
 174         viewport->set_border_width(0);
 175
 176         UI::instance()->theme_changed.connect (sigc::mem_fun(*this, &Meterbridge::on_theme_changed));
 177         ColorsChanged.connect (sigc::mem_fun (*this, &Meterbridge::on_theme_changed));
 178         DPIReset.connect (sigc::mem_fun (*this, &Meterbridge::on_theme_changed));
 179 }
 180
 181 Meterbridge::~Meterbridge ()
 182 {
 183         while (_metrics.size() > 0) {
 184                 delete (_metrics.back());
 185                 _metrics.pop_back();
 186         }
 187 }
 188
 189 void
 190 Meterbridge::show_window ()
 191 {
 192         present();
 193         if (!_visible) {
 194                 set_window_pos_and_size ();
 195         }
 196         _visible = true;
 197 }
 198
 199 /* code duplicated from gtk2_ardour/mixer_ui.cc  Mixer_UI::update_title() */
 200 void
 201 Meterbridge::update_title ()
 202 {
 203         if (_session) {
 204                 string n;
 205
 206                 if (_session->snap_name() != _session->name()) {
 207                         n = _session->snap_name ();
 208                 } else {
 209                         n = _session->name ();
 210                 }
 211
 212                 if (_session->dirty ()) {
 213                         n = "*" + n;
 214                 }
 215
 216                 WindowTitle title (n);
 217                 title += S_("Window|Meterbridge");
 218                 title += Glib::get_application_name ();
 219                 set_title (title.get_string());
 220
 221         } else {
 222
 223                 WindowTitle title (S_("Window|Meterbridge"));
 224                 title += Glib::get_application_name ();
 225                 set_title (title.get_string());
 226         }
 227 }
 228
 229 void
 230 Meterbridge::set_window_pos_and_size ()
 231 {
 232         resize (m_width, m_height);
 233         if (m_root_x >= 0 && m_root_y >= 0) {
 234                 move (m_root_x, m_root_y);
 235         }
 236 }
 237
 238 void
 239 Meterbridge::get_window_pos_and_size ()
 240 {
 241         get_position(m_root_x, m_root_y);
 242         get_size(m_width, m_height);
 243 }
 244
 245 bool
 246 Meterbridge::hide_window (GdkEventAny *ev)
 247 {
 248         if (!_visible) return 0;
 249         get_window_pos_and_size();
 250         _visible = false;
 251         return just_hide_it(ev, static_cast<Gtk::Window *>(this));
 252 }
 253
 254 bool
 255 Meterbridge::on_key_press_event (GdkEventKey* ev)
 256 {
 257         if (gtk_window_propagate_key_event (GTK_WINDOW(gobj()), ev)) {
 258                 return true;
 259         }
 260         return forward_key_press (ev);
 261 }
 262
 263 bool
 264 Meterbridge::on_key_release_event (GdkEventKey* ev)
 265 {
 266         if (gtk_window_propagate_key_event (GTK_WINDOW(gobj()), ev)) {
 267                 return true;
 268         }
 269         /* don't forward releases */
 270         return true;
 271 }
 272
 273 bool
 274 Meterbridge::on_scroll_event (GdkEventScroll* ev)
 275 {
 276         switch (ev->direction) {
 277         case GDK_SCROLL_LEFT:
 278                 scroll_left ();
 279                 return true;
 280         case GDK_SCROLL_UP:
 281                 if (ev->state & Keyboard::TertiaryModifier) {
 282                         scroll_left ();
 283                         return true;
 284                 }
 285                 return false;
 286
 287         case GDK_SCROLL_RIGHT:
 288                 scroll_right ();
 289                 return true;
 290
 291         case GDK_SCROLL_DOWN:
 292                 if (ev->state & Keyboard::TertiaryModifier) {
 293                         scroll_right ();
 294                         return true;
 295                 }
 296                 return false;
 297         }
 298
 299         return false;
 300 }
 301
 302 void
 303 Meterbridge::scroll_left ()
 304 {
 305         if (!scroller.get_hscrollbar()) return;
 306         Adjustment* adj = scroller.get_hscrollbar()->get_adjustment();
 307         /* stupid GTK: can't rely on clamping across versions */
 308         scroller.get_hscrollbar()->set_value (max (adj->get_lower(), adj->get_value() - adj->get_step_increment()));
 309 }
 310
 311 void
 312 Meterbridge::scroll_right ()
 313 {
 314         if (!scroller.get_hscrollbar()) return;
 315         Adjustment* adj = scroller.get_hscrollbar()->get_adjustment();
 316         /* stupid GTK: can't rely on clamping across versions */
 317         scroller.get_hscrollbar()->set_value (min (adj->get_upper(), adj->get_value() + adj->get_step_increment()));
 318 }
 319
 320 void
 321 Meterbridge::on_size_request (Gtk::Requisition* r)
 322 {
 323         meter_clear_pattern_cache(3);
 324         Gtk::Window::on_size_request(r);
 325
 326         Gdk::Geometry geom;
 327         Gtk::Requisition mr = meterarea.size_request();
 328
 329         geom.max_width = mr.width + metrics_left.get_width() + metrics_right.get_width();
 330         geom.max_width = std::max(50, geom.max_width);
 331         geom.max_height = max_height;
 332
 333         if (cur_max_width != geom.max_width) {
 334                 cur_max_width = geom.max_width;
 335                 /* height resizes are 'heavy' since the metric areas and meter-patterns
 336                  * are re-generated. limit to 16px steps. */
 337                 geom.height_inc = 16;
 338                 geom.width_inc = 1;
 339                 geom.min_width = 40;
 340                 geom.min_height = -1;
 341                 set_geometry_hints(*((Gtk::Window*) this), geom, Gdk::HINT_MIN_SIZE | Gdk::HINT_MAX_SIZE | Gdk::HINT_RESIZE_INC);
 342         }
 343 }
 344
 345 void
 346 Meterbridge::on_size_allocate (Gtk::Allocation& a)
 347 {
 348         const Gtk::Scrollbar * hsc = scroller.get_hscrollbar();
 349
 350         /* switch left/right edge patterns depending on horizontal scroll-position */
 351         if (scroller.get_hscrollbar_visible() && hsc) {
 352                 if (!scroll_connection.connected()) {
 353                         scroll_connection = scroller.get_hscrollbar()->get_adjustment()->signal_value_changed().connect(sigc::mem_fun (*this, &Meterbridge::on_scroll));
 354                         scroller.get_hscrollbar()->get_adjustment()->signal_changed().connect(sigc::mem_fun (*this, &Meterbridge::on_scroll));
 355                 }
 356                 gint scrollbar_spacing;
 357                 gtk_widget_style_get (GTK_WIDGET (scroller.gobj()),
 358                                 "scrollbar-spacing", &scrollbar_spacing, NULL);
 359                 const int h = hsc->get_height() + scrollbar_spacing + 1;
 360                 metrics_spacer_left.set_size_request(-1, h);
 361                 metrics_spacer_right.set_size_request(-1, h);
 362         } else {
 363                 metrics_spacer_left.set_size_request(-1, 0);
 364                 metrics_spacer_right.set_size_request(-1, 0);
 365         }
 366         Gtk::Window::on_size_allocate(a);
 367 }
 368
 369 void
 370 Meterbridge::on_scroll()
 371 {
 372         if (!scroller.get_hscrollbar()) return;
 373
 374         Adjustment* adj = scroller.get_hscrollbar()->get_adjustment();
 375         int leftend = adj->get_value();
 376         int rightend = scroller.get_width() + leftend;
 377
 378         int mm_left = _mm_left;
 379         int mm_right = _mm_right;
 380         ARDOUR::MeterType mt_left = _mt_left;
 381         ARDOUR::MeterType mt_right = _mt_right;
 382
 383         for (unsigned int i = 0; i < _metrics.size(); ++i) {
 384                 int sx, dx = 0, dy = 0;
 385                 int mm = _metrics[i]->get_metric_mode();
 386                 sx = (mm & 2) ? _metrics[i]->get_width() : 0;
 387
 388                 _metrics[i]->translate_coordinates(meterarea, sx, 0, dx, dy);
 389
 390                 if (dx < leftend && !(mm&2)) {
 391                         mm_left = mm;
 392                         mt_left = _metrics[i]->meter_type();
 393                 }
 394                 if (dx > rightend && (mm&2)) {
 395                         mm_right = mm;
 396                         mt_right = _metrics[i]->meter_type();
 397                         break;
 398                 }
 399         }
 400         metrics_left.set_metric_mode(mm_left, mt_left);
 401         metrics_right.set_metric_mode(mm_right, mt_right);
 402 }
 403
 404 void
 405 Meterbridge::set_session (Session* s)
 406 {
 407         SessionHandlePtr::set_session (s);
 408
 409         if (!_session) {
 410                 return;
 411         }
 412
 413         metrics_left.set_session(s);
 414         metrics_right.set_session(s);
 415
 416         XMLNode* node = _session->instant_xml(X_("Meterbridge"));
 417         if (node) {
 418                 set_state (*node);
 419         }
 420
 421         update_title ();
 422         _show_busses = _session->config.get_show_busses_on_meterbridge();
 423         _show_master = _session->config.get_show_master_on_meterbridge();
 424         _show_midi = _session->config.get_show_midi_on_meterbridge();
 425
 426         ARDOUR::SignalOrderRouteSorter sorter;
 427         boost::shared_ptr<RouteList> routes = _session->get_routes();
 428
 429         RouteList copy(*routes);
 430         copy.sort(sorter);
 431         add_strips(copy);
 432
 433         _session->RouteAdded.connect (_session_connections, invalidator (*this), boost::bind (&Meterbridge::add_strips, this, _1), gui_context());
 434         _session->DirtyChanged.connect (_session_connections, invalidator (*this), boost::bind (&Meterbridge::update_title, this), gui_context());
 435         _session->StateSaved.connect (_session_connections, invalidator (*this), boost::bind (&Meterbridge::update_title, this), gui_context());
 436         _session->config.ParameterChanged.connect (*this, invalidator (*this), ui_bind (&Meterbridge::parameter_changed, this, _1), gui_context());
 437         Config->ParameterChanged.connect (*this, invalidator (*this), ui_bind (&Meterbridge::parameter_changed, this, _1), gui_context());
 438
 439         if (_visible) {
 440                 show_window();
 441                 present ();
 442         }
 443         start_updating ();
 444 }
 445
 446 void
 447 Meterbridge::session_going_away ()
 448 {
 449         ENSURE_GUI_THREAD (*this, &Meterbridge::session_going_away);
 450
 451         for (list<MeterBridgeStrip>::iterator i = strips.begin(); i != strips.end(); ++i) {
 452                 delete ((*i).s);
 453         }
 454
 455         strips.clear ();
 456         stop_updating ();
 457
 458         SessionHandlePtr::session_going_away ();
 459
 460         _session = 0;
 461         update_title ();
 462 }
 463
 464 int
 465 Meterbridge::set_state (const XMLNode& node)
 466 {
 467         const XMLProperty* prop;
 468         XMLNode* geometry;
 469
 470         m_width = default_width;
 471         m_height = default_height;
 472         m_root_x = 1;
 473         m_root_y = 1;
 474
 475         if ((geometry = find_named_node (node, "geometry")) != 0) {
 476
 477                 XMLProperty* prop;
 478
 479                 if ((prop = geometry->property("x_size")) == 0) {
 480                         prop = geometry->property ("x-size");
 481                 }
 482                 if (prop) {
 483                         m_width = atoi(prop->value());
 484                 }
 485                 if ((prop = geometry->property("y_size")) == 0) {
 486                         prop = geometry->property ("y-size");
 487                 }
 488                 if (prop) {
 489                         m_height = atoi(prop->value());
 490                 }
 491
 492                 if ((prop = geometry->property ("x_pos")) == 0) {
 493                         prop = geometry->property ("x-pos");
 494                 }
 495                 if (prop) {
 496                         m_root_x = atoi (prop->value());
 497
 498                 }
 499                 if ((prop = geometry->property ("y_pos")) == 0) {
 500                         prop = geometry->property ("y-pos");
 501                 }
 502                 if (prop) {
 503                         m_root_y = atoi (prop->value());
 504                 }
 505         }
 506
 507         set_window_pos_and_size ();
 508
 509         if ((prop = node.property ("show-meterbridge"))) {
 510                 if (string_is_affirmative (prop->value())) {
 511                        _visible = true;
 512                 }
 513         }
 514
 515         return 0;
 516 }
 517
 518 XMLNode&
 519 Meterbridge::get_state (void)
 520 {
 521         char buf[32];
 522         XMLNode* node = new XMLNode ("Meterbridge");
 523
 524         if (is_realized() && _visible) {
 525                 get_window_pos_and_size ();
 526         }
 527
 528         XMLNode* geometry = new XMLNode ("geometry");
 529         snprintf(buf, sizeof(buf), "%d", m_width);
 530         geometry->add_property(X_("x_size"), string(buf));
 531         snprintf(buf, sizeof(buf), "%d", m_height);
 532         geometry->add_property(X_("y_size"), string(buf));
 533         snprintf(buf, sizeof(buf), "%d", m_root_x);
 534         geometry->add_property(X_("x_pos"), string(buf));
 535         snprintf(buf, sizeof(buf), "%d", m_root_y);
 536         geometry->add_property(X_("y_pos"), string(buf));
 537         node->add_child_nocopy (*geometry);
 538
 539         node->add_property ("show-meterbridge", _visible ? "yes" : "no");
 540         return *node;
 541 }
 542
 543
 544 gint
 545 Meterbridge::start_updating ()
 546 {
 547         fast_screen_update_connection = Timers::super_rapid_connect (sigc::mem_fun(*this, &Meterbridge::fast_update_strips));
 548         return 0;
 549 }
 550
 551 gint
 552 Meterbridge::stop_updating ()
 553 {
 554         fast_screen_update_connection.disconnect();
 555         return 0;
 556 }
 557
 558 void
 559 Meterbridge::fast_update_strips ()
 560 {
 561         if (!is_mapped () || !_session) {
 562                 return;
 563         }
 564         for (list<MeterBridgeStrip>::iterator i = strips.begin(); i != strips.end(); ++i) {
 565                 if (!(*i).visible) continue;
 566                 (*i).s->fast_update ();
 567         }
 568 }
 569
 570 void
 571 Meterbridge::add_strips (RouteList& routes)
 572 {
 573         MeterStrip* strip;
 574         for (RouteList::iterator x = routes.begin(); x != routes.end(); ++x) {
 575                 boost::shared_ptr<Route> route = (*x);
 576                 if (route->is_auditioner()) {
 577                         continue;
 578                 }
 579                 if (route->is_monitor()) {
 580                         continue;
 581                 }
 582
 583                 strip = new MeterStrip (_session, route);
 584                 strips.push_back (MeterBridgeStrip(strip));
 585                 route->active_changed.connect (*this, invalidator (*this), boost::bind (&Meterbridge::resync_order, this), gui_context ());
 586
 587                 meterarea.pack_start (*strip, false, false);
 588                 strip->show();
 589         }
 590
 591         resync_order();
 592 }
 593
 594 void
 595 Meterbridge::remove_strip (MeterStrip* strip)
 596 {
 597         if (_session && _session->deletion_in_progress()) {
 598                 return;
 599         }
 600
 601         list<MeterBridgeStrip>::iterator i;
 602         for (list<MeterBridgeStrip>::iterator i = strips.begin(); i != strips.end(); ++i) {
 603                 if ( (*i).s == strip) {
 604                         strips.erase (i);
 605                         break;
 606                 }
 607         }
 608
 609         resync_order();
 610 }
 611
 612 void
 613 Meterbridge::sync_order_keys ()
 614 {
 615         Glib::Threads::Mutex::Lock lm (_resync_mutex);
 616
 617         MeterOrderRouteSorter sorter;
 618         strips.sort(sorter);
 619
 620         int pos = 0;
 621         int vis = 0;
 622         MeterStrip * last = 0;
 623
 624         unsigned int metrics = 0;
 625         MeterType lmt = MeterPeak;
 626         bool have_midi = false;
 627         metrics_left.set_metric_mode(1, lmt);
 628
 629         for (list<MeterBridgeStrip>::iterator i = strips.begin(); i != strips.end(); ++i) {
 630
 631                 if (! (*i).s->route()->active()) {
 632                         (*i).s->hide();
 633                         (*i).visible = false;
 634                 }
 635                 else if ((*i).s->route()->is_master()) {
 636                         if (_show_master) {
 637                                 (*i).s->show();
 638                                 (*i).visible = true;
 639                                 vis++;
 640                         } else {
 641                                 (*i).s->hide();
 642                                 (*i).visible = false;
 643                         }
 644                 }
 645                 else if (boost::dynamic_pointer_cast<AudioTrack>((*i).s->route()) == 0
 646                                 && boost::dynamic_pointer_cast<MidiTrack>((*i).s->route()) == 0
 647                                 ) {
 648                         /* non-master bus */
 649                         if (_show_busses) {
 650                                 (*i).s->show();
 651                                 (*i).visible = true;
 652                                 vis++;
 653                         } else {
 654                                 (*i).s->hide();
 655                                 (*i).visible = false;
 656                         }
 657                 }
 658                 else if (boost::dynamic_pointer_cast<MidiTrack>((*i).s->route())) {
 659                         if (_show_midi) {
 660                                 (*i).s->show();
 661                                 (*i).visible = true;
 662                                 vis++;
 663                         } else {
 664                                 (*i).s->hide();
 665                                 (*i).visible = false;
 666                         }
 667                 }
 668                 else {
 669                         (*i).s->show();
 670                         (*i).visible = true;
 671                                 vis++;
 672                 }
 673
 674                 (*i).s->set_tick_bar(0);
 675
 676                 MeterType nmt = (*i).s->meter_type();
 677                 if (nmt == MeterKrms) nmt = MeterPeak; // identical metrics
 678                 if (vis == 1) {
 679                         (*i).s->set_tick_bar(1);
 680                 }
 681
 682                 if ((*i).visible && nmt != lmt && vis == 1) {
 683                         lmt = nmt;
 684                         metrics_left.set_metric_mode(1, lmt);
 685                 } else if ((*i).visible && nmt != lmt) {
 686
 687                         if (last) {
 688                                 last->set_tick_bar(last->get_tick_bar() | 2);
 689                         }
 690                         (*i).s->set_tick_bar((*i).s->get_tick_bar() | 1);
 691
 692                         if (_metrics.size() <= metrics) {
 693                                 _metrics.push_back(new MeterStrip(have_midi ? 2 : 3, lmt));
 694                                 meterarea.pack_start (*_metrics[metrics], false, false);
 695                                 _metrics[metrics]->set_session(_session);
 696                                 _metrics[metrics]->show();
 697                         } else {
 698                                 _metrics[metrics]->set_metric_mode(have_midi ? 2 : 3, lmt);
 699                         }
 700                         meterarea.reorder_child(*_metrics[metrics], pos++);
 701                         metrics++;
 702
 703                         lmt = nmt;
 704
 705                         if (_metrics.size() <= metrics) {
 706                                 _metrics.push_back(new MeterStrip(1, lmt));
 707                                 meterarea.pack_start (*_metrics[metrics], false, false);
 708                                 _metrics[metrics]->set_session(_session);
 709                                 _metrics[metrics]->show();
 710                         } else {
 711                                 _metrics[metrics]->set_metric_mode(1, lmt);
 712                         }
 713                         meterarea.reorder_child(*_metrics[metrics], pos++);
 714                         metrics++;
 715                         have_midi = false;
 716                 }
 717
 718                 if ((*i).visible && (*i).s->has_midi()) {
 719                         have_midi = true;
 720                 }
 721
 722                 meterarea.reorder_child(*((*i).s), pos++);
 723                 if ((*i).visible) {
 724                         last = (*i).s;
 725                 }
 726         }
 727
 728         if (last) {
 729                 last->set_tick_bar(last->get_tick_bar() | 2);
 730         }
 731
 732         metrics_right.set_metric_mode(have_midi ? 2 : 3, lmt);
 733
 734         while (_metrics.size() > metrics) {
 735                 meterarea.remove(*_metrics.back());
 736                 delete (_metrics.back());
 737                 _metrics.pop_back();
 738         }
 739
 740         _mm_left = metrics_left.get_metric_mode();
 741         _mt_left = metrics_left.meter_type();
 742         _mm_right = metrics_right.get_metric_mode();
 743         _mt_right = metrics_right.meter_type();
 744
 745         on_scroll();
 746         queue_resize();
 747 }
 748
 749 void
 750 Meterbridge::resync_order()
 751 {
 752         sync_order_keys();
 753 }
 754
 755 void
 756 Meterbridge::parameter_changed (std::string const & p)
 757 {
 758         if (p == "show-busses-on-meterbridge") {
 759                 _show_busses = _session->config.get_show_busses_on_meterbridge();
 760                 resync_order();
 761         }
 762         else if (p == "show-master-on-meterbridge") {
 763                 _show_master = _session->config.get_show_master_on_meterbridge();
 764                 resync_order();
 765         }
 766         else if (p == "show-midi-on-meterbridge") {
 767                 _show_midi = _session->config.get_show_midi_on_meterbridge();
 768                 resync_order();
 769         }
 770         else if (p == "meter-line-up-level") {
 771                 meter_clear_pattern_cache();
 772         }
 773         else if (p == "show-rec-on-meterbridge") {
 774                 scroller.queue_resize();
 775         }
 776         else if (p == "show-mute-on-meterbridge") {
 777                 scroller.queue_resize();
 778         }
 779         else if (p == "show-solo-on-meterbridge") {
 780                 scroller.queue_resize();
 781         }
 782         else if (p == "show-name-on-meterbridge") {
 783                 scroller.queue_resize();
 784         }
 785         else if (p == "meterbridge-label-height") {
 786                 scroller.queue_resize();
 787         }
 788         else if (p == "show-monitor-on-meterbridge") {
 789                 scroller.queue_resize();
 790         }
 791         else if (p == "track-name-number") {
 792                 scroller.queue_resize();
 793         }
 794 }
 795
 796 void
 797 Meterbridge::on_theme_changed ()
 798 {
 799         meter_clear_pattern_cache();
 800 }