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