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