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