X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fardour_ui_dialogs.cc;h=7d7ee7d60b0df2cf74b8e3f6016bba193134903e;hb=6129b3492d3e47f7c027278f795ebb5cbea53cca;hp=34104016d7142b8ab264ebefa9bd7e139dddfcd6;hpb=77f16522e0b396262bc272c1637753faa9da0ba7;p=ardour.git diff --git a/gtk2_ardour/ardour_ui_dialogs.cc b/gtk2_ardour/ardour_ui_dialogs.cc index 34104016d7..7d7ee7d60b 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,25 +18,46 @@ */ /* 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/audioengine.h" +#include "ardour/automation_watch.h" +#include "ardour/control_protocol_manager.h" +#include "ardour/profile.h" +#include "ardour/session.h" +#include "control_protocol/control_protocol.h" #include "actions.h" +#include "add_route_dialog.h" +#include "add_video_dialog.h" #include "ardour_ui.h" -#include "connection_editor.h" +#include "big_clock_window.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 "meter_patterns.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 "splash.h" #include "sfdb_ui.h" #include "theme_manager.h" -#include "bundle_manager.h" -#include "keyeditor.h" +#include "time_info_box.h" +#include "timers.h" + +#include #include "i18n.h" @@ -47,24 +68,57 @@ 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); + + if (!_session) { + WM::Manager::instance().set_session (s); + /* Session option editor cannot exist across change-of-session */ + session_option_editor.drop_window (); + /* Ditto for AddVideoDialog */ + add_video_dialog.drop_window (); + return; + } + + const XMLNode* node = _session->extra_xml (X_("UI")); + + 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->HaltOnXrun.connect (mem_fun(*this, &ARDOUR_UI::halt_on_xrun_message)); - session->RecordStateChanged.connect (mem_fun (*this, &ARDOUR_UI::record_state_changed)); + WM::Manager::instance().set_session (s); + + AutomationWatch::instance().set_session (s); + + if (shuttle_box) { + shuttle_box->set_session (s); + } + + primary_clock->set_session (s); + secondary_clock->set_session (s); + big_clock->set_session (s); + time_info_box->set_session (s); + video_timeline->set_session (s); /* sensitize menu bar options that are now valid */ ActionManager::set_sensitive (ActionManager::session_sensitive_actions, true); - - if (session->locations()->num_range_markers()) { + ActionManager::set_sensitive (ActionManager::write_sensitive_actions, _session->writable()); + + 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->control_out()) { + if (!_session->monitor_out()) { Glib::RefPtr act = ActionManager::get_action (X_("options"), X_("SoloViaBus")); if (act) { act->set_sensitive (false); @@ -80,356 +134,454 @@ ARDOUR_UI::connect_to_session (Session *s) /* there are never any selections on startup */ - 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); - session->locations()->added.connect (mem_fun (*this, &ARDOUR_UI::handle_locations_change)); - session->locations()->removed.connect (mem_fun (*this, &ARDOUR_UI::handle_locations_change)); - rec_button.set_sensitive (true); - shuttle_box.set_sensitive (true); - - if (connection_editor) { - connection_editor->set_session (s); - } - if (location_ui) { - location_ui->set_session(s); - } + solo_alert_button.set_active (_session->soloing()); - if (route_params) { - route_params->set_session (s); - } + setup_session_options (); - if (option_editor) { - option_editor->set_session (s); - } + blink_connection = Timers::blink_connect (sigc::mem_fun(*this, &ARDOUR_UI::blink_handler)); - setup_session_options (); + _session->SaveSessionRequested.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::save_session_at_its_request, this, _1), gui_context()); + _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()); - 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)); + _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 ()); - /* 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. + /* Clocks are on by default after we are connected to a session, so show that here. */ - session->TransportStateChange.connect (mem_fun(*this, &ARDOUR_UI::queue_transport_change)); + connect_dependents_to_session (s); - /* alert the user to these things happening */ + /* 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. + */ - session->AuditionActive.connect (mem_fun(*this, &ARDOUR_UI::auditioning_changed)); - session->SoloActive.connect (mem_fun(*this, &ARDOUR_UI::soloing_changed)); + AudioClock::ModeChanged.connect (sigc::mem_fun (*this, &ARDOUR_UI::store_clock_modes)); - solo_alert_button.set_active (session->soloing()); + Glib::signal_idle().connect (sigc::mem_fun (*this, &ARDOUR_UI::first_idle)); - /* update autochange callback on dirty state changing */ + start_clocking (); - session->DirtyChanged.connect (mem_fun(*this, &ARDOUR_UI::update_autosave)); + map_transport_state (); - /* can't be auditioning here */ + second_connection = Timers::second_connect (sigc::mem_fun(*this, &ARDOUR_UI::every_second)); + point_one_second_connection = Timers::rapid_connect (sigc::mem_fun(*this, &ARDOUR_UI::every_point_one_seconds)); + point_zero_something_second_connection = Timers::super_rapid_connect (sigc::mem_fun(*this, &ARDOUR_UI::every_point_zero_something_seconds)); + set_fps_timeout_connection(); - 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); + update_format (); - /* Clocks are on by default after we are connected to a session, so show that here. - */ - - connect_dependents_to_session (s); + if (meter_box.get_parent()) { + transport_tearoff_hbox.remove (meter_box); + transport_tearoff_hbox.remove (editor_meter_peak_display); + } - /* 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. - */ + if (editor_meter) { + meter_box.remove(*editor_meter); + delete editor_meter; + editor_meter = 0; + editor_meter_peak_display.hide(); + } - AudioClock::ModeChanged.connect (mem_fun (*this, &ARDOUR_UI::store_clock_modes)); + if (meter_box.get_parent()) { + transport_tearoff_hbox.remove (meter_box); + transport_tearoff_hbox.remove (editor_meter_peak_display); + } - Glib::signal_idle().connect (mem_fun (*this, &ARDOUR_UI::first_idle)); + if (_session && + _session->master_out() && + _session->master_out()->n_outputs().n(DataType::AUDIO) > 0) { + + if (!ARDOUR::Profile->get_trx()) { + editor_meter = new LevelMeterHBox(_session); + editor_meter->set_meter (_session->master_out()->shared_peak_meter().get()); + editor_meter->clear_meters(); + editor_meter->set_type (_session->master_out()->meter_type()); + editor_meter->setup_meters (30, 12, 6); + editor_meter->show(); + meter_box.pack_start(*editor_meter); + } - start_clocking (); - start_blinking (); + ArdourMeter::ResetAllPeakDisplays.connect (sigc::mem_fun(*this, &ARDOUR_UI::reset_peak_display)); + ArdourMeter::ResetRoutePeakDisplays.connect (sigc::mem_fun(*this, &ARDOUR_UI::reset_route_peak_display)); + ArdourMeter::ResetGroupPeakDisplays.connect (sigc::mem_fun(*this, &ARDOUR_UI::reset_group_peak_display)); - transport_stopped (); + editor_meter_peak_display.set_name ("meterbridge peakindicator"); + editor_meter_peak_display.unset_flags (Gtk::CAN_FOCUS); + editor_meter_peak_display.set_size_request (std::max(9.f, rintf(8.f * ui_scale)), -1); + editor_meter_peak_display.set_corner_radius (3.0); - 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); + editor_meter_max_peak = -INFINITY; + editor_meter_peak_display.signal_button_release_event().connect (sigc::mem_fun(*this, &ARDOUR_UI::editor_meter_peak_button_release), false); + + if (ARDOUR_UI::config()->get_show_editor_meter() && !ARDOUR::Profile->get_trx()) { + transport_tearoff_hbox.pack_start (meter_box, false, false); + transport_tearoff_hbox.pack_start (editor_meter_peak_display, false, false); + meter_box.show(); + editor_meter_peak_display.show(); + } + } } int ARDOUR_UI::unload_session (bool hide_stuff) { - if (session && session->dirty()) { - switch (ask_about_saving_session (_("close"))) { + if (_session) { + ARDOUR_UI::instance()->video_timeline->sync_session_state(); + } + + 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; } } + { + // tear down session specific CPI (owned by rc_config_editor which can remain) + ControlProtocolManager& m = ControlProtocolManager::instance (); + for (std::list::iterator i = m.control_protocol_info.begin(); i != m.control_protocol_info.end(); ++i) { + if (*i && (*i)->protocol && (*i)->protocol->has_editor ()) { + (*i)->protocol->tear_down_gui (); + } + } + } + if (hide_stuff) { editor->hide (); mixer->hide (); + meterbridge->hide (); + audio_port_matrix->hide(); + midi_port_matrix->hide(); + route_params->hide(); } second_connection.disconnect (); point_one_second_connection.disconnect (); - point_oh_five_second_connection.disconnect (); - point_zero_one_second_connection.disconnect(); + point_zero_something_second_connection.disconnect(); + fps_connection.disconnect(); + + if (editor_meter) { + meter_box.remove(*editor_meter); + delete editor_meter; + editor_meter = 0; + editor_meter_peak_display.hide(); + } ActionManager::set_sensitive (ActionManager::session_sensitive_actions, false); - + rec_button.set_sensitive (false); - shuttle_box.set_sensitive (false); - stop_blinking (); + WM::Manager::instance().set_session ((ARDOUR::Session*) 0); + + if (ARDOUR_UI::instance()->video_timeline) { + ARDOUR_UI::instance()->video_timeline->close_session(); + } + stop_clocking (); /* drop everything attached to the blink signal */ - 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); + blink_connection.disconnect (); - if (option_editor) { - option_editor->set_session (0); - } + delete _session; + _session = 0; - delete session; - session = 0; + session_loaded = false; update_buffer_load (); return 0; } -int -ARDOUR_UI::create_connection_editor () +static bool +_hide_splash (gpointer arg) { -#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"))); - } - - if (session) { - connection_editor->set_session (session); - } -#endif - - return 0; + ((ARDOUR_UI*)arg)->hide_splash(); + return false; } void -ARDOUR_UI::toggle_connection_editor () +ARDOUR_UI::goto_editor_window () { - if (create_connection_editor()) { - return; + if (splash && splash->is_visible()) { + // in 2 seconds, hide the splash screen + Glib::signal_timeout().connect (sigc::bind (sigc::ptr_fun (_hide_splash), this), 2000); } -#if 0 - RefPtr act = ActionManager::get_action (X_("Common"), X_("ToggleConnections")); - if (act) { - RefPtr tact = RefPtr::cast_dynamic(act); - - if (tact->get_active()) { - connection_editor->show_all (); - connection_editor->present (); - } else { - connection_editor->hide (); - } + editor->show_window (); + editor->present (); + /* mixer should now be on top */ + if (ARDOUR_UI::config()->get_transients_follow_front()) { + WM::Manager::instance().set_transient_for (editor); } -#endif + _mixer_on_top = false; } void -ARDOUR_UI::toggle_big_clock_window () +ARDOUR_UI::goto_mixer_window () { - RefPtr act = ActionManager::get_action (X_("Common"), X_("ToggleBigClock")); - if (act) { - RefPtr tact = RefPtr::cast_dynamic(act); + Glib::RefPtr win; + Glib::RefPtr screen; - if (tact->get_active()) { - big_clock_window->show_all (); - big_clock_window->present (); - } else { - big_clock_window->hide (); - } + if (editor) { + win = editor->get_window (); } + + if (win) { + screen = win->get_screen(); + } else { + screen = Gdk::Screen::get_default(); + } + + if (g_getenv ("ARDOUR_LOVES_STUPID_TINY_SCREENS") == 0 && screen && screen->get_height() < 700) { + Gtk::MessageDialog msg (_("This screen is not tall enough to display the mixer window")); + msg.run (); + return; + } + + mixer->show_window (); + mixer->present (); + /* mixer should now be on top */ + if (ARDOUR_UI::config()->get_transients_follow_front()) { + WM::Manager::instance().set_transient_for (mixer); + } + _mixer_on_top = true; } void -ARDOUR_UI::toggle_options_window () +ARDOUR_UI::toggle_mixer_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); - } + /* thse windows are created in ARDOUR_UI::setup_windows() + * it should be impossible to get here with any of them being NULL + */ + assert (editor && mixer && meterbridge); - RefPtr act = ActionManager::get_action (X_("Common"), X_("ToggleOptionsEditor")); - if (act) { - RefPtr tact = RefPtr::cast_dynamic(act); - - if (tact->get_active()) { - option_editor->show_all (); - option_editor->present (); - } else { - option_editor->hide (); - } + bool show = false; + bool obscuring = false; + + if (mixer->not_visible ()) { + show = true; + } + else if ( (!editor->not_visible () && ARDOUR_UI_UTILS::windows_overlap (editor, mixer)) + || (!meterbridge->not_visible () && ARDOUR_UI_UTILS::windows_overlap (meterbridge, mixer)) + ) { + obscuring = true; } -} -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 (obscuring && (editor->property_has_toplevel_focus() || meterbridge->property_has_toplevel_focus())) { + show = true; + } + + if (show) { + goto_mixer_window (); + } else { + mixer->hide (); } - return 0; } void -ARDOUR_UI::toggle_location_window () +ARDOUR_UI::toggle_meterbridge () { - if (create_location_ui()) { - return; + assert (editor && mixer && meterbridge); + + bool show = false; + bool obscuring = false; + + if (meterbridge->not_visible ()) { + show = true; + } + else if ( (!editor->not_visible() && ARDOUR_UI_UTILS::windows_overlap (editor, meterbridge)) + || (!mixer->not_visible () && ARDOUR_UI_UTILS::windows_overlap (meterbridge, mixer)) + ) { + obscuring = true; } - 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 (); - } else { - location_ui->hide (); - } + if (obscuring && (editor->property_has_toplevel_focus() || mixer->property_has_toplevel_focus())) { + show = true; + } + + if (show) { + meterbridge->show_window (); + meterbridge->present (); + meterbridge->raise (); + } else { + meterbridge->hide_window (NULL); } } void -ARDOUR_UI::toggle_key_editor () +ARDOUR_UI::toggle_editor_mixer () { - if (key_editor == 0) { - key_editor = new KeyEditor; - key_editor->signal_unmap().connect (sigc::bind (sigc::ptr_fun(&ActionManager::uncheck_toggleaction), X_("/Common/ToggleKeyEditor"))); + bool obscuring = false; + + if (editor && mixer) { + if (ARDOUR_UI_UTILS::windows_overlap (editor, mixer)) { + obscuring = true; + } } - RefPtr act = ActionManager::get_action (X_("Common"), X_("ToggleKeyEditor")); - if (act) { - RefPtr tact = RefPtr::cast_dynamic(act); - - if (tact->get_active()) { - key_editor->show_all (); - key_editor->present (); + if (mixer && !mixer->not_visible() && mixer->property_has_toplevel_focus()) { + if (obscuring) { + goto_editor_window(); + } + } else if (editor && !editor->not_visible() && editor->property_has_toplevel_focus()) { + if (obscuring) { + goto_mixer_window(); + } + } else if (mixer && mixer->not_visible()) { + if (obscuring) { + goto_mixer_window (); + } + } else if (editor && editor->not_visible()) { + if (obscuring) { + goto_editor_window (); + } + } else if (obscuring) { + //it's unclear what to do here, so just do the opposite of what we did last time (old behavior) + if (_mixer_on_top) { + goto_editor_window (); } else { - key_editor->hide (); - } + goto_mixer_window (); + } } } void -ARDOUR_UI::toggle_theme_manager () +ARDOUR_UI::new_midi_tracer_window () { - 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 (); - } + 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 (); + t->show_all (); + _midi_tracer_windows.push_back (t); + } else { + /* re-use the hidden one */ + (*i)->show_all (); } } -void +BundleManager* ARDOUR_UI::create_bundle_manager () { - 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"))); - } + return new BundleManager (_session); +} + +AddVideoDialog* +ARDOUR_UI::create_add_video_dialog () +{ + return new AddVideoDialog (_session); +} + +SessionOptionEditor* +ARDOUR_UI::create_session_option_editor () +{ + return new SessionOptionEditor (_session); +} + +BigClockWindow* +ARDOUR_UI::create_big_clock_window () +{ + return new BigClockWindow (*big_clock); } void -ARDOUR_UI::toggle_bundle_manager () +ARDOUR_UI::handle_locations_change (Location *) { - create_bundle_manager (); - - RefPtr act = ActionManager::get_action (X_("Common"), X_("ToggleBundleManager")); - if (act) { - RefPtr tact = RefPtr::cast_dynamic (act); - - if (tact->get_active()) { - bundle_manager->show_all (); - bundle_manager->present (); + if (_session) { + if (_session->locations()->num_range_markers()) { + ActionManager::set_sensitive (ActionManager::range_sensitive_actions, true); } else { - bundle_manager->hide (); - } + ActionManager::set_sensitive (ActionManager::range_sensitive_actions, false); + } } } -int -ARDOUR_UI::create_route_params () +bool +ARDOUR_UI::main_window_state_event_handler (GdkEventWindowState* ev, bool window_was_editor) { - 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"))); + if (window_was_editor) { + + if ((ev->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) && + (ev->new_window_state & GDK_WINDOW_STATE_FULLSCREEN)) { + if (big_clock_window) { + big_clock_window->set_transient_for (*editor); + } + } + + } else { + + if ((ev->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) && + (ev->new_window_state & GDK_WINDOW_STATE_FULLSCREEN)) { + if (big_clock_window) { + big_clock_window->set_transient_for (*mixer); + } + } } - return 0; + + return false; } -void -ARDOUR_UI::toggle_route_params_window () +bool +ARDOUR_UI::editor_meter_peak_button_release (GdkEventButton* ev) { - if (create_route_params ()) { - return; - } - - RefPtr act = ActionManager::get_action (X_("Common"), X_("ToggleInspector")); - if (act) { - RefPtr tact = RefPtr::cast_dynamic(act); - - if (tact->get_active()) { - route_params->show_all (); - route_params->present (); - } else { - route_params->hide (); - } + if (ev->button == 1 && Gtkmm2ext::Keyboard::modifier_state_equals (ev->state, Gtkmm2ext::Keyboard::PrimaryModifier|Gtkmm2ext::Keyboard::TertiaryModifier)) { + ArdourMeter::ResetAllPeakDisplays (); + } else if (ev->button == 1 && Gtkmm2ext::Keyboard::modifier_state_equals (ev->state, Gtkmm2ext::Keyboard::PrimaryModifier)) { + if (_session->master_out()) { + ArdourMeter::ResetGroupPeakDisplays (_session->master_out()->route_group()); + } + } else if (_session->master_out()) { + ArdourMeter::ResetRoutePeakDisplays (_session->master_out().get()); } + return false; } void -ARDOUR_UI::handle_locations_change (Location* ignored) +ARDOUR_UI::toggle_mixer_space() { - if (session) { - if (session->locations()->num_range_markers()) { - ActionManager::set_sensitive (ActionManager::range_sensitive_actions, true); + Glib::RefPtr act = ActionManager::get_action ("Common", "ToggleMaximalMixer"); + + if (act) { + Glib::RefPtr tact = Glib::RefPtr::cast_dynamic(act); + if (tact->get_active()) { + mixer->maximise_mixer_space (); } else { - ActionManager::set_sensitive (ActionManager::range_sensitive_actions, false); + mixer->restore_mixer_space (); } } }