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 /* modified version of above
  99  * used in Meterbridge::sync_order_keys()
 100  */
 101 struct MeterOrderRouteSorter {
 102         bool operator() (MeterStrip *ma, MeterStrip *mb) {
 103                 boost::shared_ptr<Route> a = ma->route();
 104                 boost::shared_ptr<Route> b = mb->route();
 105                 if (a->is_master() || a->is_monitor()) {
 106                         /* "a" is a special route (master, monitor, etc), and comes
 107                          * last in the mixer ordering
 108                          */
 109                         return false;
 110                 } else if (b->is_master() || b->is_monitor()) {
 111                         /* everything comes before b */
 112                         return true;
 113                 }
 114                 return a->order_key (MixerSort) < b->order_key (MixerSort);
 115         }
 116 };
 117
 118
 119 Meterbridge::Meterbridge ()
 120         : Window (Gtk::WINDOW_TOPLEVEL)
 121         , VisibilityTracker (*((Gtk::Window*) this))
 122         , _visible (false)
 123         , _show_busses (false)
 124         , metrics_left (1)
 125         , metrics_right (2)
 126         , cur_max_width (-1)
 127 {
 128         set_name ("Meter Bridge");
 129
 130         m_width = default_width;
 131         m_height = default_height;
 132         m_root_x = 1;
 133         m_root_y = 1;
 134
 135         update_title ();
 136
 137         set_wmclass (X_("ardour_mixer"), PROGRAM_NAME);
 138
 139         Gdk::Geometry geom;
 140         geom.max_width = 1<<16;
 141         geom.max_height = max_height;
 142         set_geometry_hints(*((Gtk::Window*) this), geom, Gdk::HINT_MAX_SIZE);
 143
 144         set_keep_above (true);
 145         set_border_width (0);
 146
 147         metrics_vpacker_left.pack_start (metrics_left, true, true);
 148         metrics_vpacker_left.pack_start (metrics_spacer_left, false, false);
 149         metrics_spacer_left.set_size_request(-1, 0);
 150         metrics_spacer_left.set_spacing(0);
 151
 152         metrics_vpacker_right.pack_start (metrics_right, true, true);
 153         metrics_vpacker_right.pack_start (metrics_spacer_right, false, false);
 154         metrics_spacer_right.set_size_request(-1, 0);
 155         metrics_spacer_right.set_spacing(0);
 156
 157         signal_delete_event().connect (sigc::mem_fun (*this, &Meterbridge::hide_window));
 158         signal_configure_event().connect (sigc::mem_fun (*ARDOUR_UI::instance(), &ARDOUR_UI::configure_handler));
 159         Route::SyncOrderKeys.connect (*this, invalidator (*this), boost::bind (&Meterbridge::sync_order_keys, this, _1), gui_context());
 160         MeterStrip::CatchDeletion.connect (*this, invalidator (*this), boost::bind (&Meterbridge::remove_strip, this, _1), gui_context());
 161         MeterStrip::MetricChanged.connect_same_thread (*this, boost::bind(&Meterbridge::update_metrics, this));
 162
 163         /* work around ScrolledWindowViewport alignment mess Part one */
 164         Gtk::HBox * yspc = manage (new Gtk::HBox());
 165         yspc->set_size_request(-1, 1);
 166         Gtk::VBox * xspc = manage (new Gtk::VBox());
 167         xspc->pack_start(meterarea, true, true);
 168         xspc->pack_start(*yspc, false, false);
 169         yspc->show();
 170         xspc->show();
 171
 172         meterarea.set_spacing(0);
 173         scroller.set_shadow_type(Gtk::SHADOW_NONE);
 174         scroller.set_border_width(0);
 175         scroller.add (*xspc);
 176         scroller.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_NEVER);
 177
 178         global_hpacker.pack_start (metrics_vpacker_left, false, false);
 179         global_hpacker.pack_start (scroller, true, true);
 180         global_hpacker.pack_start (metrics_vpacker_right, false, false);
 181
 182         global_vpacker.pack_start (global_hpacker, true, true);
 183         add (global_vpacker);
 184
 185         metrics_left.show();
 186         metrics_right.show();
 187
 188         metrics_vpacker_left.show();
 189         metrics_spacer_left.show();
 190         metrics_vpacker_right.show();
 191         metrics_spacer_right.show();
 192
 193         meterarea.show();
 194         global_vpacker.show();
 195         global_hpacker.show();
 196         scroller.show();
 197
 198         /* the return of the ScrolledWindowViewport mess:
 199          * remove shadow from scrollWindow's viewport
 200          * see http://www.mail-archive.com/gtkmm-list@gnome.org/msg03509.html
 201          */
 202         Gtk::Viewport* viewport = (Gtk::Viewport*) scroller.get_child();
 203         viewport->set_shadow_type(Gtk::SHADOW_NONE);
 204         viewport->set_border_width(0);
 205
 206         UI::instance()->theme_changed.connect (sigc::mem_fun(*this, &Meterbridge::on_theme_changed));
 207         ColorsChanged.connect (sigc::mem_fun (*this, &Meterbridge::on_theme_changed));
 208         DPIReset.connect (sigc::mem_fun (*this, &Meterbridge::on_theme_changed));
 209 }
 210
 211 Meterbridge::~Meterbridge ()
 212 {
 213 }
 214
 215 void
 216 Meterbridge::show_window ()
 217 {
 218         present();
 219         if (!_visible) {
 220                 set_window_pos_and_size ();
 221         }
 222         _visible = true;
 223 }
 224
 225 /* code duplicated from gtk2_ardour/mixer_ui.cc  Mixer_UI::update_title() */
 226 void
 227 Meterbridge::update_title ()
 228 {
 229         if (_session) {
 230                 string n;
 231
 232                 if (_session->snap_name() != _session->name()) {
 233                         n = _session->snap_name ();
 234                 } else {
 235                         n = _session->name ();
 236                 }
 237
 238                 if (_session->dirty ()) {
 239                         n = "*" + n;
 240                 }
 241
 242                 WindowTitle title (n);
 243                 title += S_("Window|Meterbridge");
 244                 title += Glib::get_application_name ();
 245                 set_title (title.get_string());
 246
 247         } else {
 248
 249                 WindowTitle title (S_("Window|Meterbridge"));
 250                 title += Glib::get_application_name ();
 251                 set_title (title.get_string());
 252         }
 253 }
 254
 255 void
 256 Meterbridge::set_window_pos_and_size ()
 257 {
 258         resize (m_width, m_height);
 259         if (m_root_x >= 0 && m_root_y >= 0) {
 260                 move (m_root_x, m_root_y);
 261         }
 262 }
 263
 264 void
 265 Meterbridge::get_window_pos_and_size ()
 266 {
 267         get_position(m_root_x, m_root_y);
 268         get_size(m_width, m_height);
 269 }
 270
 271 bool
 272 Meterbridge::hide_window (GdkEventAny *ev)
 273 {
 274         get_window_pos_and_size();
 275         _visible = false;
 276         return just_hide_it(ev, static_cast<Gtk::Window *>(this));
 277 }
 278
 279 bool
 280 Meterbridge::on_key_press_event (GdkEventKey* ev)
 281 {
 282         if (gtk_window_propagate_key_event (GTK_WINDOW(gobj()), ev)) {
 283                 return true;
 284         }
 285         return forward_key_press (ev);
 286 }
 287
 288 bool
 289 Meterbridge::on_key_release_event (GdkEventKey* ev)
 290 {
 291         if (gtk_window_propagate_key_event (GTK_WINDOW(gobj()), ev)) {
 292                 return true;
 293         }
 294         /* don't forward releases */
 295         return true;
 296 }
 297
 298 bool
 299 Meterbridge::on_scroll_event (GdkEventScroll* ev)
 300 {
 301         switch (ev->direction) {
 302         case GDK_SCROLL_LEFT:
 303                 scroll_left ();
 304                 return true;
 305         case GDK_SCROLL_UP:
 306                 if (ev->state & Keyboard::TertiaryModifier) {
 307                         scroll_left ();
 308                         return true;
 309                 }
 310                 return false;
 311
 312         case GDK_SCROLL_RIGHT:
 313                 scroll_right ();
 314                 return true;
 315
 316         case GDK_SCROLL_DOWN:
 317                 if (ev->state & Keyboard::TertiaryModifier) {
 318                         scroll_right ();
 319                         return true;
 320                 }
 321                 return false;
 322         }
 323
 324         return false;
 325 }
 326
 327 void
 328 Meterbridge::scroll_left ()
 329 {
 330         Adjustment* adj = scroller.get_hscrollbar()->get_adjustment();
 331         /* stupid GTK: can't rely on clamping across versions */
 332         scroller.get_hscrollbar()->set_value (max (adj->get_lower(), adj->get_value() - adj->get_step_increment()));
 333 }
 334
 335 void
 336 Meterbridge::scroll_right ()
 337 {
 338         Adjustment* adj = scroller.get_hscrollbar()->get_adjustment();
 339         /* stupid GTK: can't rely on clamping across versions */
 340         scroller.get_hscrollbar()->set_value (min (adj->get_upper(), adj->get_value() + adj->get_step_increment()));
 341 }
 342
 343 void
 344 Meterbridge::on_size_request (Gtk::Requisition* r)
 345 {
 346         Gtk::Window::on_size_request(r);
 347
 348         Gdk::Geometry geom;
 349         geom.max_width = meterarea.get_width() + metrics_left.get_width() + metrics_right.get_width();
 350         geom.max_height = max_height;
 351
 352         if (cur_max_width != geom.max_width) {
 353                 cur_max_width = geom.max_width;
 354                 set_geometry_hints(*((Gtk::Window*) this), geom, Gdk::HINT_MAX_SIZE);
 355         }
 356 }
 357
 358 void
 359 Meterbridge::on_size_allocate (Gtk::Allocation& a)
 360 {
 361         const Gtk::Scrollbar * hsc = scroller.get_hscrollbar();
 362
 363         if (scroller.get_hscrollbar_visible() && hsc) {
 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::set_session (Session* s)
 379 {
 380         SessionHandlePtr::set_session (s);
 381
 382         if (!_session) {
 383                 return;
 384         }
 385
 386         XMLNode* node = _session->instant_xml(X_("Meterbridge"));
 387         if (node) {
 388                 set_state (*node);
 389         }
 390
 391         update_title ();
 392         _show_busses = _session->config.get_show_busses_on_meterbridge();
 393         _show_master = _session->config.get_show_master_on_meterbridge();
 394         _show_midi = _session->config.get_show_midi_on_meterbridge();
 395
 396         SignalOrderRouteSorter sorter;
 397         boost::shared_ptr<RouteList> routes = _session->get_routes();
 398
 399         RouteList copy(*routes);
 400         copy.sort(sorter);
 401         add_strips(copy);
 402
 403         _session->RouteAdded.connect (_session_connections, invalidator (*this), boost::bind (&Meterbridge::add_strips, this, _1), gui_context());
 404         _session->DirtyChanged.connect (_session_connections, invalidator (*this), boost::bind (&Meterbridge::update_title, this), gui_context());
 405         _session->StateSaved.connect (_session_connections, invalidator (*this), boost::bind (&Meterbridge::update_title, this), gui_context());
 406         _session->config.ParameterChanged.connect (*this, invalidator (*this), ui_bind (&Meterbridge::parameter_changed, this, _1), gui_context());
 407         Config->ParameterChanged.connect (*this, invalidator (*this), ui_bind (&Meterbridge::parameter_changed, this, _1), gui_context());
 408
 409         if (_visible) {
 410                 show_window();
 411                 ActionManager::check_toggleaction ("<Actions>/Common/toggle-meterbridge");
 412         }
 413         start_updating ();
 414 }
 415
 416 void
 417 Meterbridge::session_going_away ()
 418 {
 419         ENSURE_GUI_THREAD (*this, &Meterbridge::session_going_away);
 420
 421         for (list<MeterStrip *>::iterator i = strips.begin(); i != strips.end(); ++i) {
 422                 delete (*i);
 423         }
 424
 425         strips.clear ();
 426         stop_updating ();
 427
 428         SessionHandlePtr::session_going_away ();
 429
 430         _session = 0;
 431         update_title ();
 432 }
 433
 434 int
 435 Meterbridge::set_state (const XMLNode& node)
 436 {
 437         const XMLProperty* prop;
 438         XMLNode* geometry;
 439
 440         m_width = default_width;
 441         m_height = default_height;
 442         m_root_x = 1;
 443         m_root_y = 1;
 444
 445         if ((geometry = find_named_node (node, "geometry")) != 0) {
 446
 447                 XMLProperty* prop;
 448
 449                 if ((prop = geometry->property("x_size")) == 0) {
 450                         prop = geometry->property ("x-size");
 451                 }
 452                 if (prop) {
 453                         m_width = atoi(prop->value());
 454                 }
 455                 if ((prop = geometry->property("y_size")) == 0) {
 456                         prop = geometry->property ("y-size");
 457                 }
 458                 if (prop) {
 459                         m_height = atoi(prop->value());
 460                 }
 461
 462                 if ((prop = geometry->property ("x_pos")) == 0) {
 463                         prop = geometry->property ("x-pos");
 464                 }
 465                 if (prop) {
 466                         m_root_x = atoi (prop->value());
 467
 468                 }
 469                 if ((prop = geometry->property ("y_pos")) == 0) {
 470                         prop = geometry->property ("y-pos");
 471                 }
 472                 if (prop) {
 473                         m_root_y = atoi (prop->value());
 474                 }
 475         }
 476
 477         set_window_pos_and_size ();
 478
 479         if ((prop = node.property ("show-meterbridge"))) {
 480                 if (string_is_affirmative (prop->value())) {
 481                        _visible = true;
 482                 }
 483         }
 484
 485         return 0;
 486 }
 487
 488 XMLNode&
 489 Meterbridge::get_state (void)
 490 {
 491         XMLNode* node = new XMLNode ("Meterbridge");
 492
 493         if (is_realized()) {
 494                 Glib::RefPtr<Gdk::Window> win = get_window();
 495
 496                 get_window_pos_and_size ();
 497
 498                 XMLNode* geometry = new XMLNode ("geometry");
 499                 char buf[32];
 500                 snprintf(buf, sizeof(buf), "%d", m_width);
 501                 geometry->add_property(X_("x_size"), string(buf));
 502                 snprintf(buf, sizeof(buf), "%d", m_height);
 503                 geometry->add_property(X_("y_size"), string(buf));
 504                 snprintf(buf, sizeof(buf), "%d", m_root_x);
 505                 geometry->add_property(X_("x_pos"), string(buf));
 506                 snprintf(buf, sizeof(buf), "%d", m_root_y);
 507                 geometry->add_property(X_("y_pos"), string(buf));
 508                 node->add_child_nocopy (*geometry);
 509         }
 510
 511         node->add_property ("show-meterbridge", _visible ? "yes" : "no");
 512         return *node;
 513 }
 514
 515
 516 gint
 517 Meterbridge::start_updating ()
 518 {
 519         fast_screen_update_connection = ARDOUR_UI::instance()->SuperRapidScreenUpdate.connect (sigc::mem_fun(*this, &Meterbridge::fast_update_strips));
 520         return 0;
 521 }
 522
 523 gint
 524 Meterbridge::stop_updating ()
 525 {
 526         fast_screen_update_connection.disconnect();
 527         return 0;
 528 }
 529
 530 void
 531 Meterbridge::fast_update_strips ()
 532 {
 533         if (!is_mapped () || !_session) {
 534                 return;
 535         }
 536         for (list<MeterStrip *>::iterator i = strips.begin(); i != strips.end(); ++i) {
 537                 // TODO skip inactive/hidden routes
 538                 (*i)->fast_update ();
 539         }
 540 }
 541
 542 void
 543 Meterbridge::add_strips (RouteList& routes)
 544 {
 545         MeterStrip* strip;
 546         for (RouteList::iterator x = routes.begin(); x != routes.end(); ++x) {
 547                 boost::shared_ptr<Route> route = (*x);
 548                 if (route->is_auditioner()) {
 549                         continue;
 550                 }
 551                 if (route->is_monitor()) {
 552                         continue;
 553                 }
 554
 555                 strip = new MeterStrip (_session, route);
 556                 strips.push_back (strip);
 557                 route->active_changed.connect (*this, invalidator (*this), boost::bind (&Meterbridge::resync_order, this), gui_context ());
 558
 559                 meterarea.pack_start (*strip, false, false);
 560                 strip->show();
 561         }
 562
 563         sync_order_keys(MixerSort);
 564         update_metrics();
 565 }
 566
 567 void
 568 Meterbridge::remove_strip (MeterStrip* strip)
 569 {
 570         if (_session && _session->deletion_in_progress()) {
 571                 return;
 572         }
 573
 574         list<MeterStrip *>::iterator i;
 575         if ((i = find (strips.begin(), strips.end(), strip)) != strips.end()) {
 576                 strips.erase (i);
 577         }
 578         update_metrics();
 579 }
 580
 581 void
 582 Meterbridge::update_metrics ()
 583 {
 584         bool have_midi = false;
 585         for (list<MeterStrip *>::iterator i = strips.begin(); i != strips.end(); ++i) {
 586                 if ( (*i)->has_midi ()) {
 587                         have_midi = true;
 588                         break;
 589                 }
 590         }
 591         if (have_midi) {
 592                 metrics_right.set_metric_mode(2);
 593         } else {
 594                 metrics_right.set_metric_mode(3);
 595         }
 596 }
 597
 598 void
 599 Meterbridge::sync_order_keys (RouteSortOrderKey src)
 600 {
 601         MeterOrderRouteSorter sorter;
 602         std::list<MeterStrip *> copy (strips);
 603         copy.sort(sorter);
 604
 605         int pos = 0;
 606
 607         for (list<MeterStrip *>::iterator i = copy.begin(); i != copy.end(); ++i) {
 608
 609                 if (! (*i)->route()->active()) {
 610                         (*i)->hide();
 611                 }
 612                 else if ((*i)->route()->is_master()) {
 613                         if (_show_master) {
 614                                 (*i)->show();
 615                         } else {
 616                                 (*i)->hide();
 617                         }
 618                 }
 619                 else if (boost::dynamic_pointer_cast<AudioTrack>((*i)->route()) == 0
 620                                 && boost::dynamic_pointer_cast<MidiTrack>((*i)->route()) == 0
 621                                 ) {
 622                         /* non-master bus */
 623                         if (_show_busses) {
 624                                 (*i)->show();
 625                         } else {
 626                                 (*i)->hide();
 627                         }
 628                 }
 629                 else if (boost::dynamic_pointer_cast<MidiTrack>((*i)->route())) {
 630                         if (_show_midi) {
 631                                 (*i)->show();
 632                         } else {
 633                                 (*i)->hide();
 634                         }
 635                 }
 636                 else {
 637                         (*i)->show();
 638                 }
 639                 meterarea.reorder_child(*(*i), pos++);
 640         }
 641 }
 642
 643 void
 644 Meterbridge::resync_order ()
 645 {
 646         sync_order_keys(MixerSort);
 647 }
 648
 649 void
 650 Meterbridge::parameter_changed (std::string const & p)
 651 {
 652         if (p == "show-busses-on-meterbridge") {
 653                 _show_busses = _session->config.get_show_busses_on_meterbridge();
 654                 sync_order_keys(MixerSort);
 655         }
 656         else if (p == "show-master-on-meterbridge") {
 657                 _show_master = _session->config.get_show_master_on_meterbridge();
 658                 sync_order_keys(MixerSort);
 659         }
 660         else if (p == "show-midi-on-meterbridge") {
 661                 _show_midi = _session->config.get_show_midi_on_meterbridge();
 662                 sync_order_keys(MixerSort);
 663         }
 664         else if (p == "meter-line-up-level") {
 665                 meter_clear_pattern_cache();
 666         }
 667 }
 668
 669 void
 670 Meterbridge::on_theme_changed ()
 671 {
 672         meter_clear_pattern_cache();
 673 }