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