X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fardour_ui_dialogs.cc;h=02c72d723066f081fcdb8567ef0320176c2bc656;hb=82be348d429b97f3e223b3a5b1c6807d23fcdaa0;hp=c90480c1dd9fbae244f4d5be8ba440c1b4440c6d;hpb=1ae094813858a2b8cf5b08569edcb9b15d910729;p=ardour.git diff --git a/gtk2_ardour/ardour_ui_dialogs.cc b/gtk2_ardour/ardour_ui_dialogs.cc index c90480c1dd..02c72d7230 100644 --- a/gtk2_ardour/ardour_ui_dialogs.cc +++ b/gtk2_ardour/ardour_ui_dialogs.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2000 Paul Davis + Copyright (C) 2000 Paul Davis This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -18,23 +18,36 @@ */ /* This file contains any ARDOUR_UI methods that require knowledge of - the various dialog boxes, and exists so that no compilation dependency + the various dialog boxes, and exists so that no compilation dependency exists between the main ARDOUR_UI modules and their respective classes. This is to cut down on the compile times. It also helps with my sanity. */ -#include +#include "ardour/session.h" +#include "ardour/audioengine.h" +#include "ardour/automation_watch.h" #include "actions.h" +#include "add_route_dialog.h" #include "ardour_ui.h" -#include "connection_editor.h" +#include "bundle_manager.h" +#include "global_port_matrix.h" +#include "gui_object.h" +#include "gui_thread.h" +#include "keyeditor.h" #include "location_ui.h" +#include "main_clock.h" +#include "midi_tracer.h" #include "mixer_ui.h" -#include "option_editor.h" #include "public_editor.h" +#include "rc_option_editor.h" #include "route_params_ui.h" +#include "shuttle_control.h" +#include "session_option_editor.h" +#include "speaker_dialog.h" #include "sfdb_ui.h" -#include "color_manager.h" +#include "theme_manager.h" +#include "time_info_box.h" #include "i18n.h" @@ -45,125 +58,190 @@ using namespace Gtk; using namespace Gtkmm2ext; void -ARDOUR_UI::connect_to_session (Session *s) +ARDOUR_UI::set_session (Session *s) { - session = s; + SessionHandlePtr::set_session (s); - session->HaltOnXrun.connect (mem_fun(*this, &ARDOUR_UI::halt_on_xrun_message)); - - /* sensitize menu bar options that are now valid */ + for (ARDOUR::DataType::iterator i = ARDOUR::DataType::begin(); i != ARDOUR::DataType::end(); ++i) { + GlobalPortMatrixWindow* w; + if ((w = _global_port_matrix[*i]->get()) != 0) { + w->set_session (s); + } + } - ActionManager::set_sensitive (ActionManager::session_sensitive_actions, true); - - if (session->locations()->num_range_markers()) { - ActionManager::set_sensitive (ActionManager::range_sensitive_actions, true); - } else { - ActionManager::set_sensitive (ActionManager::range_sensitive_actions, false); + if (!_session) { + return; } - /* there are never any selections on startup */ + const XMLNode* node = _session->extra_xml (X_("UI")); - ActionManager::set_sensitive (ActionManager::region_selection_sensitive_actions, false); - ActionManager::set_sensitive (ActionManager::time_selection_sensitive_actions, false); - ActionManager::set_sensitive (ActionManager::track_selection_sensitive_actions, false); - ActionManager::set_sensitive (ActionManager::line_selection_sensitive_actions, false); - ActionManager::set_sensitive (ActionManager::point_selection_sensitive_actions, false); - ActionManager::set_sensitive (ActionManager::playlist_selection_sensitive_actions, false); + if (node) { + const XMLNodeList& children = node->children(); + for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) { + if ((*i)->name() == GUIObjectState::xml_node_name) { + gui_object_state->load (**i); + break; + } + } + } - session->locations()->added.connect (mem_fun (*this, &ARDOUR_UI::handle_locations_change)); - session->locations()->removed.connect (mem_fun (*this, &ARDOUR_UI::handle_locations_change)); + AutomationWatch::instance().set_session (s); - rec_button.set_sensitive (true); - shuttle_box.set_sensitive (true); - - if (connection_editor) { - connection_editor->set_session (s); + if (location_ui->get()) { + location_ui->get()->set_session(s); } - if (location_ui) { - location_ui->set_session(s); - } + if (speaker_config_window->get()) { + speaker_config_window->get()->set_speakers (s->get_speakers()); + } if (route_params) { route_params->set_session (s); } - if (option_editor) { - option_editor->set_session (s); + if (add_route_dialog) { + add_route_dialog->set_session (s); } - if (sfdb) { - sfdb->set_session (s); + if (session_option_editor) { + session_option_editor->set_session (s); } - setup_session_options (); + if (shuttle_box) { + shuttle_box->set_session (s); + } - Blink.connect (mem_fun(*this, &ARDOUR_UI::transport_rec_enable_blink)); - Blink.connect (mem_fun(*this, &ARDOUR_UI::solo_blink)); - Blink.connect (mem_fun(*this, &ARDOUR_UI::audition_blink)); + for (ARDOUR::DataType::iterator i = ARDOUR::DataType::begin(); i != ARDOUR::DataType::end(); ++i) { + if (_global_port_matrix[*i]->get()) { + _global_port_matrix[*i]->get()->set_session (_session); + } + } - /* these are all need to be handled in an RT-safe and MT way, so don't - do any GUI work, just queue it for handling by the GUI thread. - */ + primary_clock->set_session (s); + secondary_clock->set_session (s); + big_clock->set_session (s); + time_info_box->set_session (s); + + /* sensitize menu bar options that are now valid */ - session->TransportStateChange.connect (mem_fun(*this, &ARDOUR_UI::queue_transport_change)); + ActionManager::set_sensitive (ActionManager::session_sensitive_actions, true); + ActionManager::set_sensitive (ActionManager::write_sensitive_actions, _session->writable()); - /* alert the user to these things happening */ + if (_session->locations()->num_range_markers()) { + ActionManager::set_sensitive (ActionManager::range_sensitive_actions, true); + } else { + ActionManager::set_sensitive (ActionManager::range_sensitive_actions, false); + } - session->AuditionActive.connect (mem_fun(*this, &ARDOUR_UI::auditioning_changed)); - session->SoloActive.connect (mem_fun(*this, &ARDOUR_UI::soloing_changed)); + if (!_session->monitor_out()) { + Glib::RefPtr act = ActionManager::get_action (X_("options"), X_("SoloViaBus")); + if (act) { + act->set_sensitive (false); + } + } - solo_alert_button.set_active (session->soloing()); + /* allow wastebasket flush again */ - /* can't be auditioning here */ + Glib::RefPtr act = ActionManager::get_action (X_("Main"), X_("FlushWastebasket")); + if (act) { + act->set_sensitive (true); + } - primary_clock.set_session (s); - secondary_clock.set_session (s); - big_clock.set_session (s); - preroll_clock.set_session (s); - postroll_clock.set_session (s); + /* there are never any selections on startup */ + + ActionManager::set_sensitive (ActionManager::time_selection_sensitive_actions, false); + ActionManager::set_sensitive (ActionManager::track_selection_sensitive_actions, false); + ActionManager::set_sensitive (ActionManager::line_selection_sensitive_actions, false); + ActionManager::set_sensitive (ActionManager::point_selection_sensitive_actions, false); + ActionManager::set_sensitive (ActionManager::playlist_selection_sensitive_actions, false); + + rec_button.set_sensitive (true); + + solo_alert_button.set_active (_session->soloing()); + + setup_session_options (); + + Blink.connect (sigc::mem_fun(*this, &ARDOUR_UI::transport_rec_enable_blink)); + Blink.connect (sigc::mem_fun(*this, &ARDOUR_UI::solo_blink)); + Blink.connect (sigc::mem_fun(*this, &ARDOUR_UI::sync_blink)); + Blink.connect (sigc::mem_fun(*this, &ARDOUR_UI::audition_blink)); + Blink.connect (sigc::mem_fun(*this, &ARDOUR_UI::feedback_blink)); + + _session->RecordStateChanged.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::record_state_changed, this), gui_context()); + _session->StepEditStatusChange.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::step_edit_status_change, this, _1), gui_context()); + _session->TransportStateChange.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::map_transport_state, this), gui_context()); + _session->DirtyChanged.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::update_autosave, this), gui_context()); + + _session->Xrun.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::xrun_handler, this, _1), gui_context()); + _session->SoloActive.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::soloing_changed, this, _1), gui_context()); + _session->AuditionActive.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::auditioning_changed, this, _1), gui_context()); + _session->locations()->added.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::handle_locations_change, this, _1), gui_context()); + _session->locations()->removed.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::handle_locations_change, this, _1), gui_context()); + _session->config.ParameterChanged.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::session_parameter_changed, this, _1), gui_context ()); + +#ifdef HAVE_JACK_SESSION + engine->JackSessionEvent.connect (*_session, MISSING_INVALIDATOR, boost::bind (&Session::jack_session_event, _session, _1), gui_context()); +#endif /* Clocks are on by default after we are connected to a session, so show that here. */ - + connect_dependents_to_session (s); + /* listen to clock mode changes. don't do this earlier because otherwise as the clocks + restore their modes or are explicitly set, we will cause the "new" mode to be saved + back to the session XML ("Extra") state. + */ + + AudioClock::ModeChanged.connect (sigc::mem_fun (*this, &ARDOUR_UI::store_clock_modes)); + + Glib::signal_idle().connect (sigc::mem_fun (*this, &ARDOUR_UI::first_idle)); + start_clocking (); start_blinking (); - if (editor) { - editor->present(); - } + map_transport_state (); - transport_stopped (); + second_connection = Glib::signal_timeout().connect (sigc::mem_fun(*this, &ARDOUR_UI::every_second), 1000); + point_one_second_connection = Glib::signal_timeout().connect (sigc::mem_fun(*this, &ARDOUR_UI::every_point_one_seconds), 100); + point_zero_one_second_connection = Glib::signal_timeout().connect (sigc::mem_fun(*this, &ARDOUR_UI::every_point_zero_one_seconds), 40); - second_connection = Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::every_second), 1000); - point_one_second_connection = Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::every_point_one_seconds), 100); - point_zero_one_second_connection = Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::every_point_zero_one_seconds), 40); + update_format (); } int -ARDOUR_UI::unload_session () +ARDOUR_UI::unload_session (bool hide_stuff) { - if (session && session->dirty()) { - switch (ask_about_saving_session (_("close"))) { + if (_session && _session->dirty()) { + std::vector actions; + actions.push_back (_("Don't close")); + actions.push_back (_("Just close")); + actions.push_back (_("Save and close")); + switch (ask_about_saving_session (actions)) { case -1: + // cancel return 1; - + case 1: - session->save_state (""); + _session->save_state (""); break; } } - editor->hide (); + + if (hide_stuff) { + editor->hide (); + mixer->hide (); + theme_manager->hide (); + } + second_connection.disconnect (); point_one_second_connection.disconnect (); + point_oh_five_second_connection.disconnect (); point_zero_one_second_connection.disconnect(); ActionManager::set_sensitive (ActionManager::session_sensitive_actions, false); - + rec_button.set_sensitive (false); - shuttle_box.set_sensitive (false); stop_blinking (); stop_clocking (); @@ -172,112 +250,123 @@ ARDOUR_UI::unload_session () Blink.clear (); - primary_clock.set_session (0); - secondary_clock.set_session (0); - big_clock.set_session (0); - preroll_clock.set_session (0); - postroll_clock.set_session (0); + delete _session; + _session = 0; - if (option_editor) { - option_editor->set_session (0); - } - - if (mixer) { - mixer->hide_all (); - } - - delete session; - session = 0; + session_loaded = false; update_buffer_load (); return 0; } -int -ARDOUR_UI::create_connection_editor () +void +ARDOUR_UI::toggle_big_clock_window () { -#if 0 - if (connection_editor == 0) { - connection_editor = new ConnectionEditor (); - connection_editor->signal_unmap().connect (sigc::bind (ptr_fun(&ActionManager::uncheck_toggleaction), X_("/Common/ToggleConnections"))); - } + RefPtr act = ActionManager::get_action (X_("Common"), X_("ToggleBigClock")); + if (act) { + RefPtr tact = RefPtr::cast_dynamic(act); - if (session) { - connection_editor->set_session (session); + if (tact->get_active()) { + big_clock_window->get()->show_all (); + big_clock_window->get()->present (); + } else { + big_clock_window->get()->hide (); + } } -#endif - - return 0; } void -ARDOUR_UI::toggle_connection_editor () +ARDOUR_UI::toggle_speaker_config_window () { - if (create_connection_editor()) { - return; - } - -#if 0 - RefPtr act = ActionManager::get_action (X_("Common"), X_("ToggleConnections")); + RefPtr act = ActionManager::get_action (X_("Common"), X_("toggle-speaker-config")); if (act) { RefPtr tact = RefPtr::cast_dynamic(act); - + if (tact->get_active()) { - connection_editor->show_all (); - connection_editor->present (); + speaker_config_window->get()->show_all (); + speaker_config_window->get()->present (); } else { - connection_editor->hide (); - } + speaker_config_window->get()->hide (); + } } -#endif } void -ARDOUR_UI::toggle_big_clock_window () +ARDOUR_UI::new_midi_tracer_window () { - RefPtr act = ActionManager::get_action (X_("Common"), X_("ToggleBigClock")); + RefPtr act = ActionManager::get_action (X_("Common"), X_("NewMIDITracer")); + if (!act) { + return; + } + + std::list::iterator i = _midi_tracer_windows.begin (); + while (i != _midi_tracer_windows.end() && (*i)->get_visible() == true) { + ++i; + } + + if (i == _midi_tracer_windows.end()) { + /* all our MIDITracer windows are visible; make a new one */ + MidiTracer* t = new MidiTracer (); + manage_window (*t); + t->show_all (); + _midi_tracer_windows.push_back (t); + } else { + /* re-use the hidden one */ + (*i)->show_all (); + } +} + +void +ARDOUR_UI::toggle_rc_options_window () +{ + if (rc_option_editor == 0) { + rc_option_editor = new RCOptionEditor; + rc_option_editor->signal_unmap().connect(sigc::bind (sigc::ptr_fun(&ActionManager::uncheck_toggleaction), X_("/Common/ToggleRCOptionsEditor"))); + rc_option_editor->set_session (_session); + } + + RefPtr act = ActionManager::get_action (X_("Common"), X_("ToggleRCOptionsEditor")); if (act) { RefPtr tact = RefPtr::cast_dynamic(act); - + if (tact->get_active()) { - big_clock_window->show_all (); - big_clock_window->present (); + rc_option_editor->show_all (); + rc_option_editor->present (); } else { - big_clock_window->hide (); - } + rc_option_editor->hide (); + } } } void -ARDOUR_UI::toggle_options_window () +ARDOUR_UI::toggle_session_options_window () { - if (option_editor == 0) { - option_editor = new OptionEditor (*this, *editor, *mixer); - option_editor->signal_unmap().connect(sigc::bind (sigc::ptr_fun(&ActionManager::uncheck_toggleaction), X_("/Common/ToggleOptionsEditor"))); - option_editor->set_session (session); - } + if (session_option_editor == 0) { + session_option_editor = new SessionOptionEditor (_session); + session_option_editor->signal_unmap().connect(sigc::bind (sigc::ptr_fun(&ActionManager::uncheck_toggleaction), X_("/Common/ToggleSessionOptionsEditor"))); + } - RefPtr act = ActionManager::get_action (X_("Common"), X_("ToggleOptionsEditor")); + RefPtr act = ActionManager::get_action (X_("Common"), X_("ToggleSessionOptionsEditor")); if (act) { - RefPtr tact = RefPtr::cast_dynamic(act); - + RefPtr tact = RefPtr::cast_dynamic (act); + if (tact->get_active()) { - option_editor->show_all (); - option_editor->present (); + session_option_editor->show_all (); + session_option_editor->present (); } else { - option_editor->hide (); - } + session_option_editor->hide (); + } } } int ARDOUR_UI::create_location_ui () { - if (location_ui == 0) { - location_ui = new LocationUI (); - location_ui->set_session (session); - location_ui->signal_unmap().connect (sigc::bind (sigc::ptr_fun(&ActionManager::uncheck_toggleaction), X_("/Common/ToggleLocations"))); + if (location_ui->get() == 0) { + location_ui->set (new LocationUIWindow ()); + location_ui->get()->set_session (_session); + location_ui->get()->signal_unmap().connect (sigc::bind (sigc::ptr_fun(&ActionManager::uncheck_toggleaction), X_("/Common/ToggleLocations"))); } return 0; } @@ -292,101 +381,140 @@ ARDOUR_UI::toggle_location_window () RefPtr act = ActionManager::get_action (X_("Common"), X_("ToggleLocations")); if (act) { RefPtr tact = RefPtr::cast_dynamic(act); - + if (tact->get_active()) { - location_ui->show_all (); - location_ui->present (); + location_ui->get()->show_all (); + location_ui->get()->present (); } else { - location_ui->hide (); - } + location_ui->get()->hide (); + } } } void -ARDOUR_UI::toggle_color_manager () +ARDOUR_UI::toggle_key_editor () { - RefPtr act = ActionManager::get_action (X_("Common"), X_("ToggleColorManager")); + if (key_editor == 0) { + key_editor = new KeyEditor; + key_editor->signal_unmap().connect (sigc::bind (sigc::ptr_fun(&ActionManager::uncheck_toggleaction), X_("/Common/ToggleKeyEditor"))); + } + + RefPtr act = ActionManager::get_action (X_("Common"), X_("ToggleKeyEditor")); if (act) { RefPtr tact = RefPtr::cast_dynamic(act); - + if (tact->get_active()) { - color_manager->show_all (); - color_manager->present (); + key_editor->show_all (); + key_editor->present (); } else { - color_manager->hide (); - } + key_editor->hide (); + } } } -int -ARDOUR_UI::create_route_params () +void +ARDOUR_UI::toggle_theme_manager () { - if (route_params == 0) { - route_params = new RouteParams_UI (*engine); - route_params->set_session (session); - route_params->signal_unmap().connect (sigc::bind(sigc::ptr_fun(&ActionManager::uncheck_toggleaction), X_("/Common/ToggleInspector"))); + RefPtr act = ActionManager::get_action (X_("Common"), X_("ToggleThemeManager")); + if (act) { + RefPtr tact = RefPtr::cast_dynamic(act); + + if (tact->get_active()) { + theme_manager->show_all (); + theme_manager->present (); + } else { + theme_manager->hide (); + } } - return 0; } void -ARDOUR_UI::toggle_route_params_window () +ARDOUR_UI::create_bundle_manager () { - if (create_route_params ()) { - return; + if (bundle_manager == 0) { + bundle_manager = new BundleManager (_session); + bundle_manager->signal_unmap().connect (sigc::bind (sigc::ptr_fun (&ActionManager::uncheck_toggleaction), X_("/Common/ToggleBundleManager"))); } +} - RefPtr act = ActionManager::get_action (X_("Common"), X_("ToggleInspector")); +void +ARDOUR_UI::toggle_bundle_manager () +{ + create_bundle_manager (); + + RefPtr act = ActionManager::get_action (X_("Common"), X_("ToggleBundleManager")); if (act) { - RefPtr tact = RefPtr::cast_dynamic(act); - + RefPtr tact = RefPtr::cast_dynamic (act); + if (tact->get_active()) { - route_params->show_all (); - route_params->present (); + bundle_manager->show_all (); + bundle_manager->present (); } else { - route_params->hide (); - } + bundle_manager->hide (); + } } } int -ARDOUR_UI::create_sound_file_browser () +ARDOUR_UI::create_route_params () { - if (sfdb == 0) { - sfdb = new SoundFileBrowser (_("Sound File Browser"), session); - sfdb->signal_unmap().connect (sigc::bind(sigc::ptr_fun(&ActionManager::uncheck_toggleaction), X_("/Common/ToggleSoundFileBrowser"))); + if (route_params == 0) { + route_params = new RouteParams_UI (); + route_params->set_session (_session); + route_params->signal_unmap().connect (sigc::bind(sigc::ptr_fun(&ActionManager::uncheck_toggleaction), X_("/Common/ToggleInspector"))); } return 0; } - + void -ARDOUR_UI::toggle_sound_file_browser () +ARDOUR_UI::toggle_route_params_window () { - if (create_sound_file_browser()) { + if (create_route_params ()) { return; } - RefPtr act = ActionManager::get_action (X_("Common"), X_("ToggleSoundFileBrowser")); + RefPtr act = ActionManager::get_action (X_("Common"), X_("ToggleInspector")); if (act) { RefPtr tact = RefPtr::cast_dynamic(act); - + if (tact->get_active()) { - sfdb->show_all(); - sfdb->present(); + route_params->show_all (); + route_params->present (); } else { - sfdb->hide (); + route_params->hide (); } } } void -ARDOUR_UI::handle_locations_change (Location* ignored) +ARDOUR_UI::handle_locations_change (Location *) { - if (session) { - if (session->locations()->num_range_markers()) { + if (_session) { + if (_session->locations()->num_range_markers()) { ActionManager::set_sensitive (ActionManager::range_sensitive_actions, true); } else { ActionManager::set_sensitive (ActionManager::range_sensitive_actions, false); } } } + +bool +ARDOUR_UI::main_window_state_event_handler (GdkEventWindowState* ev, bool window_was_editor) +{ + if (window_was_editor) { + + if ((ev->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) && + (ev->new_window_state & GDK_WINDOW_STATE_FULLSCREEN)) { + float_big_clock (editor); + } + + } else { + + if ((ev->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) && + (ev->new_window_state & GDK_WINDOW_STATE_FULLSCREEN)) { + float_big_clock (mixer); + } + } + + return false; +}