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