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