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 "global_signals.h"
  55 #include "meter_patterns.h"
  56
  57 #include "i18n.h"
  58
  59 using namespace ARDOUR;
  60 using namespace PBD;
  61 using namespace Gtk;
  62 using namespace Glib;
  63 using namespace Gtkmm2ext;
  64 using namespace std;
  65
  66 using PBD::atoi;
  67
  68 Meterbridge* Meterbridge::_instance = 0;
  69
  70 Meterbridge*
  71 Meterbridge::instance ()
  72 {
  73         if (!_instance) {
  74                 _instance  = new Meterbridge;
  75         }
  76
  77         return _instance;
  78 }
  79
  80 /* copy from gtk2_ardour/mixer_ui.cc -- TODO consolidate
  81  * used by Meterbridge::set_session() below
  82  */
  83 struct SignalOrderRouteSorter {
  84         bool operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b) {
  85                 if (a->is_master() || a->is_monitor()) {
  86                         /* "a" is a special route (master, monitor, etc), and comes
  87                          * last in the mixer ordering
  88                          */
  89                         return false;
  90                 } else if (b->is_master() || b->is_monitor()) {
  91                         /* everything comes before b */
  92                         return true;
  93                 }
  94                 return a->order_key (MixerSort) < b->order_key (MixerSort);
  95         }
  96 };
  97
  98 Meterbridge::Meterbridge ()
  99         : Window (Gtk::WINDOW_TOPLEVEL)
 100         , VisibilityTracker (*((Gtk::Window*) this))
 101         , _visible (false)
 102         , _show_busses (false)
 103         , metrics_left (1)
 104         , metrics_right (2)
 105         , cur_max_width (-1)
 106 {
 107         set_name ("Meter Bridge");
 108
 109         m_width = default_width;
 110         m_height = default_height;
 111         m_root_x = 1;
 112         m_root_y = 1;
 113
 114         update_title ();
 115
 116         set_wmclass (X_("ardour_mixer"), PROGRAM_NAME);
 117
 118         Gdk::Geometry geom;
 119         geom.max_width = 1<<16;
 120         geom.max_height = max_height;
 121         geom.height_inc = 16;
 122         geom.width_inc = 1;
 123         set_geometry_hints(*((Gtk::Window*) this), geom, Gdk::HINT_MAX_SIZE | Gdk::HINT_RESIZE_INC);
 124
 125         set_keep_above (true);
 126         set_border_width (0);
 127
 128         metrics_vpacker_left.pack_start (metrics_left, true, true);
 129         metrics_vpacker_left.pack_start (metrics_spacer_left, false, false);
 130         metrics_spacer_left.set_size_request(-1, 0);
 131         metrics_spacer_left.set_spacing(0);
 132
 133         metrics_vpacker_right.pack_start (metrics_right, true, true);
 134         metrics_vpacker_right.pack_start (metrics_spacer_right, false, false);
 135         metrics_spacer_right.set_size_request(-1, 0);
 136         metrics_spacer_right.set_spacing(0);
 137
 138         signal_delete_event().connect (sigc::mem_fun (*this, &Meterbridge::hide_window));
 139         signal_configure_event().connect (sigc::mem_fun (*ARDOUR_UI::instance(), &ARDOUR_UI::configure_handler));
 140         Route::SyncOrderKeys.connect (*this, invalidator (*this), boost::bind (&Meterbridge::sync_order_keys, this, _1), gui_context());
 141         MeterStrip::CatchDeletion.connect (*this, invalidator (*this), boost::bind (&Meterbridge::remove_strip, this, _1), gui_context());
 142         MeterStrip::MetricChanged.connect_same_thread (*this, boost::bind(&Meterbridge::update_metrics, this));
 143
 144         /* work around ScrolledWindowViewport alignment mess Part one */
 145         Gtk::HBox * yspc = manage (new Gtk::HBox());
 146         yspc->set_size_request(-1, 1);
 147         Gtk::VBox * xspc = manage (new Gtk::VBox());
 148         xspc->pack_start(meterarea, true, true);
 149         xspc->pack_start(*yspc, false, false);
 150         yspc->show();
 151         xspc->show();
 152
 153         meterarea.set_spacing(0);
 154         scroller.set_shadow_type(Gtk::SHADOW_NONE);
 155         scroller.set_border_width(0);
 156         scroller.add (*xspc);
 157         scroller.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_NEVER);
 158
 159         global_hpacker.pack_start (metrics_vpacker_left, false, false);
 160         global_hpacker.pack_start (scroller, true, true);
 161         global_hpacker.pack_start (metrics_vpacker_right, false, false);
 162
 163         global_vpacker.pack_start (global_hpacker, true, true);
 164         add (global_vpacker);
 165
 166         metrics_left.show();
 167         metrics_right.show();
 168
 169         metrics_vpacker_left.show();
 170         metrics_spacer_left.show();
 171         metrics_vpacker_right.show();
 172         metrics_spacer_right.show();
 173
 174         meterarea.show();
 175         global_vpacker.show();
 176         global_hpacker.show();
 177         scroller.show();
 178
 179         /* the return of the ScrolledWindowViewport mess:
 180          * remove shadow from scrollWindow's viewport
 181          * see http://www.mail-archive.com/gtkmm-list@gnome.org/msg03509.html
 182          */
 183         Gtk::Viewport* viewport = (Gtk::Viewport*) scroller.get_child();
 184         viewport->set_shadow_type(Gtk::SHADOW_NONE);
 185         viewport->set_border_width(0);
 186
 187         UI::instance()->theme_changed.connect (sigc::mem_fun(*this, &Meterbridge::on_theme_changed));
 188         ColorsChanged.connect (sigc::mem_fun (*this, &Meterbridge::on_theme_changed));
 189         DPIReset.connect (sigc::mem_fun (*this, &Meterbridge::on_theme_changed));
 190 }
 191
 192 Meterbridge::~Meterbridge ()
 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 forward_key_press (ev);
 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         geom.max_width = meterarea.get_width() + metrics_left.get_width() + metrics_right.get_width();
 335         geom.max_height = max_height;
 336
 337         if (cur_max_width != geom.max_width) {
 338                 cur_max_width = geom.max_width;
 339                 geom.height_inc = 16;
 340                 geom.width_inc = 1;
 341                 set_geometry_hints(*((Gtk::Window*) this), geom, 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         if (scroller.get_hscrollbar_visible() && hsc) {
 351                 gint scrollbar_spacing;
 352                 gtk_widget_style_get (GTK_WIDGET (scroller.gobj()),
 353                                 "scrollbar-spacing", &scrollbar_spacing, NULL);
 354                 const int h = hsc->get_height() + scrollbar_spacing + 1;
 355                 metrics_spacer_left.set_size_request(-1, h);
 356                 metrics_spacer_right.set_size_request(-1, h);
 357         } else {
 358                 metrics_spacer_left.set_size_request(-1, 0);
 359                 metrics_spacer_right.set_size_request(-1, 0);
 360         }
 361         Gtk::Window::on_size_allocate(a);
 362 }
 363
 364 void
 365 Meterbridge::set_session (Session* s)
 366 {
 367         SessionHandlePtr::set_session (s);
 368
 369         if (!_session) {
 370                 return;
 371         }
 372
 373         metrics_left.set_session(s);
 374         metrics_right.set_session(s);
 375
 376         XMLNode* node = _session->instant_xml(X_("Meterbridge"));
 377         if (node) {
 378                 set_state (*node);
 379         }
 380
 381         update_title ();
 382         _show_busses = _session->config.get_show_busses_on_meterbridge();
 383         _show_master = _session->config.get_show_master_on_meterbridge();
 384         _show_midi = _session->config.get_show_midi_on_meterbridge();
 385
 386         SignalOrderRouteSorter sorter;
 387         boost::shared_ptr<RouteList> routes = _session->get_routes();
 388
 389         RouteList copy(*routes);
 390         copy.sort(sorter);
 391         add_strips(copy);
 392
 393         _session->RouteAdded.connect (_session_connections, invalidator (*this), boost::bind (&Meterbridge::add_strips, this, _1), gui_context());
 394         _session->DirtyChanged.connect (_session_connections, invalidator (*this), boost::bind (&Meterbridge::update_title, this), gui_context());
 395         _session->StateSaved.connect (_session_connections, invalidator (*this), boost::bind (&Meterbridge::update_title, this), gui_context());
 396         _session->config.ParameterChanged.connect (*this, invalidator (*this), ui_bind (&Meterbridge::parameter_changed, this, _1), gui_context());
 397         Config->ParameterChanged.connect (*this, invalidator (*this), ui_bind (&Meterbridge::parameter_changed, this, _1), gui_context());
 398
 399         if (_visible) {
 400                 show_window();
 401                 ActionManager::check_toggleaction ("<Actions>/Common/toggle-meterbridge");
 402         }
 403         start_updating ();
 404 }
 405
 406 void
 407 Meterbridge::session_going_away ()
 408 {
 409         ENSURE_GUI_THREAD (*this, &Meterbridge::session_going_away);
 410
 411         for (list<MeterBridgeStrip>::iterator i = strips.begin(); i != strips.end(); ++i) {
 412                 delete ((*i).s);
 413         }
 414
 415         strips.clear ();
 416         stop_updating ();
 417
 418         SessionHandlePtr::session_going_away ();
 419
 420         _session = 0;
 421         update_title ();
 422 }
 423
 424 int
 425 Meterbridge::set_state (const XMLNode& node)
 426 {
 427         const XMLProperty* prop;
 428         XMLNode* geometry;
 429
 430         m_width = default_width;
 431         m_height = default_height;
 432         m_root_x = 1;
 433         m_root_y = 1;
 434
 435         if ((geometry = find_named_node (node, "geometry")) != 0) {
 436
 437                 XMLProperty* prop;
 438
 439                 if ((prop = geometry->property("x_size")) == 0) {
 440                         prop = geometry->property ("x-size");
 441                 }
 442                 if (prop) {
 443                         m_width = atoi(prop->value());
 444                 }
 445                 if ((prop = geometry->property("y_size")) == 0) {
 446                         prop = geometry->property ("y-size");
 447                 }
 448                 if (prop) {
 449                         m_height = atoi(prop->value());
 450                 }
 451
 452                 if ((prop = geometry->property ("x_pos")) == 0) {
 453                         prop = geometry->property ("x-pos");
 454                 }
 455                 if (prop) {
 456                         m_root_x = atoi (prop->value());
 457
 458                 }
 459                 if ((prop = geometry->property ("y_pos")) == 0) {
 460                         prop = geometry->property ("y-pos");
 461                 }
 462                 if (prop) {
 463                         m_root_y = atoi (prop->value());
 464                 }
 465         }
 466
 467         set_window_pos_and_size ();
 468
 469         if ((prop = node.property ("show-meterbridge"))) {
 470                 if (string_is_affirmative (prop->value())) {
 471                        _visible = true;
 472                 }
 473         }
 474
 475         return 0;
 476 }
 477
 478 XMLNode&
 479 Meterbridge::get_state (void)
 480 {
 481         char buf[32];
 482         XMLNode* node = new XMLNode ("Meterbridge");
 483
 484         if (is_realized() && _visible) {
 485                 get_window_pos_and_size ();
 486         }
 487
 488         XMLNode* geometry = new XMLNode ("geometry");
 489         snprintf(buf, sizeof(buf), "%d", m_width);
 490         geometry->add_property(X_("x_size"), string(buf));
 491         snprintf(buf, sizeof(buf), "%d", m_height);
 492         geometry->add_property(X_("y_size"), string(buf));
 493         snprintf(buf, sizeof(buf), "%d", m_root_x);
 494         geometry->add_property(X_("x_pos"), string(buf));
 495         snprintf(buf, sizeof(buf), "%d", m_root_y);
 496         geometry->add_property(X_("y_pos"), string(buf));
 497         node->add_child_nocopy (*geometry);
 498
 499         node->add_property ("show-meterbridge", _visible ? "yes" : "no");
 500         return *node;
 501 }
 502
 503
 504 gint
 505 Meterbridge::start_updating ()
 506 {
 507         fast_screen_update_connection = ARDOUR_UI::instance()->SuperRapidScreenUpdate.connect (sigc::mem_fun(*this, &Meterbridge::fast_update_strips));
 508         return 0;
 509 }
 510
 511 gint
 512 Meterbridge::stop_updating ()
 513 {
 514         fast_screen_update_connection.disconnect();
 515         return 0;
 516 }
 517
 518 void
 519 Meterbridge::fast_update_strips ()
 520 {
 521         if (!is_mapped () || !_session) {
 522                 return;
 523         }
 524         for (list<MeterBridgeStrip>::iterator i = strips.begin(); i != strips.end(); ++i) {
 525                 if (!(*i).visible) continue;
 526                 (*i).s->fast_update ();
 527         }
 528 }
 529
 530 void
 531 Meterbridge::add_strips (RouteList& routes)
 532 {
 533         MeterStrip* strip;
 534         for (RouteList::iterator x = routes.begin(); x != routes.end(); ++x) {
 535                 boost::shared_ptr<Route> route = (*x);
 536                 if (route->is_auditioner()) {
 537                         continue;
 538                 }
 539                 if (route->is_monitor()) {
 540                         continue;
 541                 }
 542
 543                 strip = new MeterStrip (_session, route);
 544                 strips.push_back (MeterBridgeStrip(strip));
 545                 route->active_changed.connect (*this, invalidator (*this), boost::bind (&Meterbridge::resync_order, this), gui_context ());
 546
 547                 meterarea.pack_start (*strip, false, false);
 548                 strip->show();
 549         }
 550
 551         resync_order();
 552         update_metrics();
 553 }
 554
 555 void
 556 Meterbridge::remove_strip (MeterStrip* strip)
 557 {
 558         if (_session && _session->deletion_in_progress()) {
 559                 return;
 560         }
 561
 562         list<MeterBridgeStrip>::iterator i;
 563         for (list<MeterBridgeStrip>::iterator i = strips.begin(); i != strips.end(); ++i) {
 564                 if ( (*i).s == strip) {
 565                         strips.erase (i);
 566                         break;
 567                 }
 568         }
 569         update_metrics();
 570 }
 571
 572 void
 573 Meterbridge::update_metrics ()
 574 {
 575         bool have_midi = false;
 576         for (list<MeterBridgeStrip>::iterator i = strips.begin(); i != strips.end(); ++i) {
 577                 if ( (*i).s->has_midi() && (*i).visible) {
 578                         have_midi = true;
 579                         break;
 580                 }
 581         }
 582         if (have_midi) {
 583                 metrics_right.set_metric_mode(2);
 584         } else {
 585                 metrics_right.set_metric_mode(3);
 586         }
 587 }
 588
 589 void
 590 Meterbridge::sync_order_keys (RouteSortOrderKey src)
 591 {
 592         Glib::Threads::Mutex::Lock lm (_resync_mutex);
 593
 594         MeterOrderRouteSorter sorter;
 595         strips.sort(sorter);
 596
 597         int pos = 0;
 598         int vis = 0;
 599
 600         for (list<MeterBridgeStrip>::iterator i = strips.begin(); i != strips.end(); ++i) {
 601
 602                 if (! (*i).s->route()->active()) {
 603                         (*i).s->hide();
 604                         (*i).visible = false;
 605                 }
 606                 else if ((*i).s->route()->is_master()) {
 607                         if (_show_master) {
 608                                 (*i).s->show();
 609                                 (*i).visible = true;
 610                                 vis++;
 611                         } else {
 612                                 (*i).s->hide();
 613                                 (*i).visible = false;
 614                         }
 615                 }
 616                 else if (boost::dynamic_pointer_cast<AudioTrack>((*i).s->route()) == 0
 617                                 && boost::dynamic_pointer_cast<MidiTrack>((*i).s->route()) == 0
 618                                 ) {
 619                         /* non-master bus */
 620                         if (_show_busses) {
 621                                 (*i).s->show();
 622                                 (*i).visible = true;
 623                                 vis++;
 624                         } else {
 625                                 (*i).s->hide();
 626                                 (*i).visible = false;
 627                         }
 628                 }
 629                 else if (boost::dynamic_pointer_cast<MidiTrack>((*i).s->route())) {
 630                         if (_show_midi) {
 631                                 (*i).s->show();
 632                                 (*i).visible = true;
 633                                 vis++;
 634                         } else {
 635                                 (*i).s->hide();
 636                                 (*i).visible = false;
 637                         }
 638                 }
 639                 else {
 640                         (*i).s->show();
 641                         (*i).visible = true;
 642                                 vis++;
 643                 }
 644                 (*i).s->set_pos(vis);
 645                 meterarea.reorder_child(*((*i).s), pos++);
 646         }
 647 }
 648
 649 void
 650 Meterbridge::resync_order()
 651 {
 652         sync_order_keys(MixerSort);
 653 }
 654
 655 void
 656 Meterbridge::parameter_changed (std::string const & p)
 657 {
 658         if (p == "show-busses-on-meterbridge") {
 659                 _show_busses = _session->config.get_show_busses_on_meterbridge();
 660                 resync_order();
 661                 update_metrics();
 662         }
 663         else if (p == "show-master-on-meterbridge") {
 664                 _show_master = _session->config.get_show_master_on_meterbridge();
 665                 resync_order();
 666                 update_metrics();
 667         }
 668         else if (p == "show-midi-on-meterbridge") {
 669                 _show_midi = _session->config.get_show_midi_on_meterbridge();
 670                 resync_order();
 671                 update_metrics();
 672         }
 673         else if (p == "meter-line-up-level") {
 674                 meter_clear_pattern_cache();
 675                 update_metrics();
 676         }
 677         else if (p == "show-rec-on-meterbridge") {
 678                 scroller.queue_resize();
 679         }
 680         else if (p == "show-mute-on-meterbridge") {
 681                 scroller.queue_resize();
 682         }
 683         else if (p == "show-solo-on-meterbridge") {
 684                 scroller.queue_resize();
 685         }
 686         else if (p == "show-name-on-meterbridge") {
 687                 scroller.queue_resize();
 688         }
 689 }
 690
 691 void
 692 Meterbridge::on_theme_changed ()
 693 {
 694         meter_clear_pattern_cache();
 695 }