gtk2_ardour/ardour_ui_dialogs.cc

   1 /*
   2     Copyright (C) 2000 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 /* This file contains any ARDOUR_UI methods that require knowledge of
  21    the various dialog boxes, and exists so that no compilation dependency
  22    exists between the main ARDOUR_UI modules and their respective classes.
  23    This is to cut down on the compile times.  It also helps with my sanity.
  24 */
  25
  26 #include "ardour/session.h"
  27 #include "ardour/audioengine.h"
  28 #include "ardour/automation_watch.h"
  29
  30 #ifdef interface
  31 #undef interface
  32 #endif
  33
  34 #include "actions.h"
  35 #include "add_route_dialog.h"
  36 #include "add_video_dialog.h"
  37 #include "ardour_ui.h"
  38 #include "big_clock_window.h"
  39 #include "bundle_manager.h"
  40 #include "global_port_matrix.h"
  41 #include "gui_object.h"
  42 #include "gui_thread.h"
  43 #include "keyeditor.h"
  44 #include "location_ui.h"
  45 #include "main_clock.h"
  46 #include "meter_patterns.h"
  47 #include "midi_tracer.h"
  48 #include "mixer_ui.h"
  49 #include "public_editor.h"
  50 #include "rc_option_editor.h"
  51 #include "route_params_ui.h"
  52 #include "shuttle_control.h"
  53 #include "session_option_editor.h"
  54 #include "speaker_dialog.h"
  55 #include "splash.h"
  56 #include "sfdb_ui.h"
  57 #include "theme_manager.h"
  58 #include "time_info_box.h"
  59
  60 #include <gtkmm2ext/keyboard.h>
  61
  62 #include "i18n.h"
  63
  64 using namespace ARDOUR;
  65 using namespace PBD;
  66 using namespace Glib;
  67 using namespace Gtk;
  68 using namespace Gtkmm2ext;
  69
  70 void
  71 ARDOUR_UI::set_session (Session *s)
  72 {
  73         SessionHandlePtr::set_session (s);
  74
  75         if (!_session) {
  76                 WM::Manager::instance().set_session (s);
  77                 /* Session option editor cannot exist across change-of-session */
  78                 session_option_editor.drop_window ();
  79                 /* Ditto for AddVideoDialog */
  80                 add_video_dialog.drop_window ();
  81                 return;
  82         }
  83
  84         const XMLNode* node = _session->extra_xml (X_("UI"));
  85
  86         if (node) {
  87                 const XMLNodeList& children = node->children();
  88                 for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
  89                         if ((*i)->name() == GUIObjectState::xml_node_name) {
  90                                 gui_object_state->load (**i);
  91                                 break;
  92                         }
  93                 }
  94         }
  95
  96         WM::Manager::instance().set_session (s);
  97
  98         AutomationWatch::instance().set_session (s);
  99
 100         if (shuttle_box) {
 101                 shuttle_box->set_session (s);
 102         }
 103
 104         primary_clock->set_session (s);
 105         secondary_clock->set_session (s);
 106         big_clock->set_session (s);
 107         time_info_box->set_session (s);
 108         video_timeline->set_session (s);
 109
 110         /* sensitize menu bar options that are now valid */
 111
 112         ActionManager::set_sensitive (ActionManager::session_sensitive_actions, true);
 113         ActionManager::set_sensitive (ActionManager::write_sensitive_actions, _session->writable());
 114
 115         if (_session->locations()->num_range_markers()) {
 116                 ActionManager::set_sensitive (ActionManager::range_sensitive_actions, true);
 117         } else {
 118                 ActionManager::set_sensitive (ActionManager::range_sensitive_actions, false);
 119         }
 120
 121         if (!_session->monitor_out()) {
 122                 Glib::RefPtr<Action> act = ActionManager::get_action (X_("options"), X_("SoloViaBus"));
 123                 if (act) {
 124                         act->set_sensitive (false);
 125                 }
 126         }
 127
 128         /* allow wastebasket flush again */
 129
 130         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Main"), X_("FlushWastebasket"));
 131         if (act) {
 132                 act->set_sensitive (true);
 133         }
 134
 135         /* there are never any selections on startup */
 136
 137         ActionManager::set_sensitive (ActionManager::time_selection_sensitive_actions, false);
 138         ActionManager::set_sensitive (ActionManager::track_selection_sensitive_actions, false);
 139         ActionManager::set_sensitive (ActionManager::line_selection_sensitive_actions, false);
 140         ActionManager::set_sensitive (ActionManager::point_selection_sensitive_actions, false);
 141         ActionManager::set_sensitive (ActionManager::playlist_selection_sensitive_actions, false);
 142
 143         rec_button.set_sensitive (true);
 144
 145         solo_alert_button.set_active (_session->soloing());
 146
 147         setup_session_options ();
 148
 149         Blink.connect (sigc::mem_fun(*this, &ARDOUR_UI::transport_rec_enable_blink));
 150         Blink.connect (sigc::mem_fun(*this, &ARDOUR_UI::solo_blink));
 151         Blink.connect (sigc::mem_fun(*this, &ARDOUR_UI::sync_blink));
 152         Blink.connect (sigc::mem_fun(*this, &ARDOUR_UI::audition_blink));
 153         Blink.connect (sigc::mem_fun(*this, &ARDOUR_UI::feedback_blink));
 154
 155         _session->RecordStateChanged.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::record_state_changed, this), gui_context());
 156         _session->StepEditStatusChange.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::step_edit_status_change, this, _1), gui_context());
 157         _session->TransportStateChange.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::map_transport_state, this), gui_context());
 158         _session->DirtyChanged.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::update_autosave, this), gui_context());
 159
 160         _session->Xrun.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::xrun_handler, this, _1), gui_context());
 161         _session->SoloActive.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::soloing_changed, this, _1), gui_context());
 162         _session->AuditionActive.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::auditioning_changed, this, _1), gui_context());
 163         _session->locations()->added.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::handle_locations_change, this, _1), gui_context());
 164         _session->locations()->removed.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::handle_locations_change, this, _1), gui_context());
 165         _session->config.ParameterChanged.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::session_parameter_changed, this, _1), gui_context ());
 166
 167         /* Clocks are on by default after we are connected to a session, so show that here.
 168         */
 169
 170         connect_dependents_to_session (s);
 171
 172         /* listen to clock mode changes. don't do this earlier because otherwise as the clocks
 173            restore their modes or are explicitly set, we will cause the "new" mode to be saved
 174            back to the session XML ("Extra") state.
 175          */
 176
 177         AudioClock::ModeChanged.connect (sigc::mem_fun (*this, &ARDOUR_UI::store_clock_modes));
 178
 179         Glib::signal_idle().connect (sigc::mem_fun (*this, &ARDOUR_UI::first_idle));
 180
 181         start_clocking ();
 182         start_blinking ();
 183
 184         map_transport_state ();
 185
 186         second_connection = Glib::signal_timeout().connect (sigc::mem_fun(*this, &ARDOUR_UI::every_second), 1000);
 187         point_one_second_connection = Glib::signal_timeout().connect (sigc::mem_fun(*this, &ARDOUR_UI::every_point_one_seconds), 100);
 188         point_zero_something_second_connection = Glib::signal_timeout().connect (sigc::mem_fun(*this, &ARDOUR_UI::every_point_zero_something_seconds), 40);
 189
 190         update_format ();
 191
 192         if (meter_box.get_parent()) {
 193                 transport_tearoff_hbox.remove (meter_box);
 194                 transport_tearoff_hbox.remove (editor_meter_peak_display);
 195         }
 196
 197         if (editor_meter) {
 198                 meter_box.remove(*editor_meter);
 199                 delete editor_meter;
 200                 editor_meter = 0;
 201                 editor_meter_peak_display.hide();
 202         }
 203
 204         if (meter_box.get_parent()) {
 205                 transport_tearoff_hbox.remove (meter_box);
 206                 transport_tearoff_hbox.remove (editor_meter_peak_display);
 207         }
 208
 209         if (_session &&
 210             _session->master_out() &&
 211             _session->master_out()->n_outputs().n(DataType::AUDIO) > 0) {
 212
 213                 editor_meter = new LevelMeterHBox(_session);
 214                 editor_meter->set_meter (_session->master_out()->shared_peak_meter().get());
 215                 editor_meter->clear_meters();
 216                 editor_meter->set_type (_session->master_out()->meter_type());
 217                 editor_meter->setup_meters (30, 12, 6);
 218                 editor_meter->show();
 219                 meter_box.pack_start(*editor_meter);
 220
 221                 ArdourMeter::ResetAllPeakDisplays.connect (sigc::mem_fun(*this, &ARDOUR_UI::reset_peak_display));
 222                 ArdourMeter::ResetRoutePeakDisplays.connect (sigc::mem_fun(*this, &ARDOUR_UI::reset_route_peak_display));
 223                 ArdourMeter::ResetGroupPeakDisplays.connect (sigc::mem_fun(*this, &ARDOUR_UI::reset_group_peak_display));
 224
 225                 editor_meter_peak_display.set_name ("meterbridge peakindicator");
 226                 editor_meter_peak_display.set_elements((ArdourButton::Element) (ArdourButton::Edge|ArdourButton::Body));
 227                 editor_meter_peak_display.unset_flags (Gtk::CAN_FOCUS);
 228                 editor_meter_peak_display.set_size_request(6, -1);
 229                 editor_meter_peak_display.set_corner_radius(2);
 230
 231                 editor_meter_max_peak = -INFINITY;
 232                 editor_meter_peak_display.signal_button_release_event().connect (sigc::mem_fun(*this, &ARDOUR_UI::editor_meter_peak_button_release), false);
 233
 234                 if (Config->get_show_editor_meter()) {
 235                         transport_tearoff_hbox.pack_start (meter_box, false, false);
 236                         transport_tearoff_hbox.pack_start (editor_meter_peak_display, false, false);
 237                         meter_box.show();
 238                         editor_meter_peak_display.show();
 239                 }
 240         }
 241 }
 242
 243 int
 244 ARDOUR_UI::unload_session (bool hide_stuff)
 245 {
 246         if (_session) {
 247                 ARDOUR_UI::instance()->video_timeline->sync_session_state();
 248         }
 249
 250         if (_session && _session->dirty()) {
 251                 std::vector<std::string> actions;
 252                 actions.push_back (_("Don't close"));
 253                 actions.push_back (_("Just close"));
 254                 actions.push_back (_("Save and close"));
 255                 switch (ask_about_saving_session (actions)) {
 256                 case -1:
 257                         // cancel
 258                         return 1;
 259
 260                 case 1:
 261                         _session->save_state ("");
 262                         break;
 263                 }
 264         }
 265
 266         if (hide_stuff) {
 267                 editor->hide ();
 268                 mixer->hide ();
 269                 meterbridge->hide ();
 270                 theme_manager->hide ();
 271                 audio_port_matrix->hide();
 272                 midi_port_matrix->hide();
 273                 route_params->hide();
 274         }
 275
 276         second_connection.disconnect ();
 277         point_one_second_connection.disconnect ();
 278         point_zero_something_second_connection.disconnect();
 279
 280         if (editor_meter) {
 281                 meter_box.remove(*editor_meter);
 282                 delete editor_meter;
 283                 editor_meter = 0;
 284                 editor_meter_peak_display.hide();
 285         }
 286
 287         ActionManager::set_sensitive (ActionManager::session_sensitive_actions, false);
 288
 289         rec_button.set_sensitive (false);
 290
 291         WM::Manager::instance().set_session ((ARDOUR::Session*) 0);
 292
 293         if (ARDOUR_UI::instance()->video_timeline) {
 294                 ARDOUR_UI::instance()->video_timeline->close_session();
 295         }
 296
 297         stop_blinking ();
 298         stop_clocking ();
 299
 300         /* drop everything attached to the blink signal */
 301
 302         Blink.clear ();
 303
 304         delete _session;
 305         _session = 0;
 306
 307         session_loaded = false;
 308
 309         update_buffer_load ();
 310
 311         return 0;
 312 }
 313
 314 static bool
 315 _hide_splash (gpointer arg)
 316 {
 317         ((ARDOUR_UI*)arg)->hide_splash();
 318         return false;
 319 }
 320
 321 void
 322 ARDOUR_UI::goto_editor_window ()
 323 {
 324         if (splash && splash->is_visible()) {
 325                 // in 2 seconds, hide the splash screen
 326                 Glib::signal_timeout().connect (sigc::bind (sigc::ptr_fun (_hide_splash), this), 2000);
 327         }
 328
 329         editor->show_window ();
 330         editor->present ();
 331         /* mixer should now be on top */
 332         WM::Manager::instance().set_transient_for (editor);
 333         _mixer_on_top = false;
 334 }
 335
 336 void
 337 ARDOUR_UI::goto_mixer_window ()
 338 {
 339         Glib::RefPtr<Gdk::Window> win;
 340         Glib::RefPtr<Gdk::Screen> screen;
 341
 342         if (editor) {
 343                 win = editor->get_window ();
 344         }
 345
 346         if (win) {
 347                 screen = win->get_screen();
 348         } else {
 349                 screen = Gdk::Screen::get_default();
 350         }
 351
 352         if (g_getenv ("ARDOUR_LOVES_STUPID_TINY_SCREENS") == 0 && screen && screen->get_height() < 700) {
 353                 Gtk::MessageDialog msg (_("This screen is not tall enough to display the mixer window"));
 354                 msg.run ();
 355                 return;
 356         }
 357
 358         mixer->show_window ();
 359         mixer->present ();
 360         /* mixer should now be on top */
 361         WM::Manager::instance().set_transient_for (mixer);
 362         _mixer_on_top = true;
 363 }
 364
 365 void
 366 ARDOUR_UI::toggle_mixer_window ()
 367 {
 368         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("toggle-mixer"));
 369         if (!act) {
 370                 return;
 371         }
 372
 373         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 374
 375         if (tact->get_active()) {
 376                 goto_mixer_window ();
 377         } else {
 378                 mixer->hide ();
 379         }
 380 }
 381
 382 void
 383 ARDOUR_UI::toggle_meterbridge ()
 384 {
 385         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("toggle-meterbridge"));
 386         if (!act) {
 387                 return;
 388         }
 389
 390         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 391
 392         if (tact->get_active()) {
 393                 meterbridge->show_window ();
 394         } else {
 395                 meterbridge->hide_window (NULL);
 396         }
 397 }
 398
 399 void
 400 ARDOUR_UI::toggle_editor_mixer ()
 401 {
 402         bool obscuring = false;
 403         /* currently, if windows are on different
 404            screens then we do nothing; but in the
 405            future we may want to bring the window
 406            to the front or something, so I'm leaving this
 407            variable for future use
 408         */
 409         bool same_screen = true;
 410
 411         if (editor && mixer) {
 412
 413                 /* remeber: Screen != Monitor (Screen is a separately rendered
 414                  * continuous geometry that make include 1 or more monitors.
 415                  */
 416
 417                 if (editor->get_screen() != mixer->get_screen() && (mixer->get_screen() != 0) && (editor->get_screen() != 0)) {
 418                         // different screens, so don't do anything
 419                         same_screen = false;
 420                 } else {
 421                         // they are on the same screen, see if they are obscuring each other
 422
 423                         gint ex, ey, ew, eh;
 424                         gint mx, my, mw, mh;
 425
 426                         editor->get_position (ex, ey);
 427                         editor->get_size (ew, eh);
 428
 429                         mixer->get_position (mx, my);
 430                         mixer->get_size (mw, mh);
 431
 432                         GdkRectangle e;
 433                         GdkRectangle m;
 434                         GdkRectangle r;
 435
 436                         e.x = ex;
 437                         e.y = ey;
 438                         e.width = ew;
 439                         e.height = eh;
 440
 441                         m.x = mx;
 442                         m.y = my;
 443                         m.width = mw;
 444                         m.height = mh;
 445
 446                         if (gdk_rectangle_intersect (&e, &m, &r)) {
 447                                 obscuring = true;
 448                         }
 449                 }
 450         }
 451
 452         if (mixer && !mixer->not_visible() && mixer->property_has_toplevel_focus()) {
 453                 if (obscuring && same_screen) {
 454                         goto_editor_window();
 455                 }
 456         } else if (editor && !editor->not_visible() && editor->property_has_toplevel_focus()) {
 457                 if (obscuring && same_screen) {
 458                         goto_mixer_window();
 459                 }
 460         } else if (mixer && mixer->not_visible()) {
 461                 if (obscuring && same_screen) {
 462                         goto_mixer_window ();
 463                 }
 464         } else if (editor && editor->not_visible()) {
 465                 if (obscuring && same_screen) {
 466                         goto_editor_window ();
 467                 }
 468         } else if (obscuring && same_screen) {
 469                 //it's unclear what to do here, so just do the opposite of what we did last time  (old behavior)
 470                 if (_mixer_on_top) {
 471                         goto_editor_window ();
 472                 } else {
 473                         goto_mixer_window ();
 474                 }
 475         }
 476 }
 477
 478 void
 479 ARDOUR_UI::new_midi_tracer_window ()
 480 {
 481         RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("NewMIDITracer"));
 482         if (!act) {
 483                 return;
 484         }
 485
 486         std::list<MidiTracer*>::iterator i = _midi_tracer_windows.begin ();
 487         while (i != _midi_tracer_windows.end() && (*i)->get_visible() == true) {
 488                 ++i;
 489         }
 490
 491         if (i == _midi_tracer_windows.end()) {
 492                 /* all our MIDITracer windows are visible; make a new one */
 493                 MidiTracer* t = new MidiTracer ();
 494                 t->show_all ();
 495                 _midi_tracer_windows.push_back (t);
 496         } else {
 497                 /* re-use the hidden one */
 498                 (*i)->show_all ();
 499         }
 500 }
 501
 502 BundleManager*
 503 ARDOUR_UI::create_bundle_manager ()
 504 {
 505         return new BundleManager (_session);
 506 }
 507
 508 AddVideoDialog*
 509 ARDOUR_UI::create_add_video_dialog ()
 510 {
 511         return new AddVideoDialog (_session);
 512 }
 513
 514 SessionOptionEditor*
 515 ARDOUR_UI::create_session_option_editor ()
 516 {
 517         return new SessionOptionEditor (_session);
 518 }
 519
 520 BigClockWindow*
 521 ARDOUR_UI::create_big_clock_window ()
 522 {
 523         return new BigClockWindow (*big_clock);
 524 }
 525
 526 void
 527 ARDOUR_UI::handle_locations_change (Location *)
 528 {
 529         if (_session) {
 530                 if (_session->locations()->num_range_markers()) {
 531                         ActionManager::set_sensitive (ActionManager::range_sensitive_actions, true);
 532                 } else {
 533                         ActionManager::set_sensitive (ActionManager::range_sensitive_actions, false);
 534                 }
 535         }
 536 }
 537
 538 bool
 539 ARDOUR_UI::main_window_state_event_handler (GdkEventWindowState* ev, bool window_was_editor)
 540 {
 541         if (window_was_editor) {
 542
 543                 if ((ev->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) &&
 544                     (ev->new_window_state & GDK_WINDOW_STATE_FULLSCREEN)) {
 545                         if (big_clock_window) {
 546                                 big_clock_window->set_transient_for (*editor);
 547                         }
 548                 }
 549
 550         } else {
 551
 552                 if ((ev->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) &&
 553                     (ev->new_window_state & GDK_WINDOW_STATE_FULLSCREEN)) {
 554                         if (big_clock_window) {
 555                                 big_clock_window->set_transient_for (*mixer);
 556                         }
 557                 }
 558         }
 559
 560         return false;
 561 }
 562
 563 bool
 564 ARDOUR_UI::editor_meter_peak_button_release (GdkEventButton* ev)
 565 {
 566         if (ev->button == 1 && Gtkmm2ext::Keyboard::modifier_state_equals (ev->state, Gtkmm2ext::Keyboard::PrimaryModifier|Gtkmm2ext::Keyboard::TertiaryModifier)) {
 567                 ArdourMeter::ResetAllPeakDisplays ();
 568         } else if (ev->button == 1 && Gtkmm2ext::Keyboard::modifier_state_equals (ev->state, Gtkmm2ext::Keyboard::PrimaryModifier)) {
 569                 if (_session->master_out()) {
 570                         ArdourMeter::ResetGroupPeakDisplays (_session->master_out()->route_group());
 571                 }
 572         } else if (_session->master_out()) {
 573                 ArdourMeter::ResetRoutePeakDisplays (_session->master_out().get());
 574         }
 575         return true;
 576 }