X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fardour_ui_dialogs.cc;h=fcd8d515991effdc3e2238b6a15d64c4f502aa9f;hb=204d840c43445745942eb834c120cbeaff77809e;hp=6f727e3004cd0d70491ce81e4be3e660cc2a4cd7;hpb=d38e2213d79b1c8952c776a3b60f7709457edc0c;p=ardour.git

diff --git a/gtk2_ardour/ardour_ui_dialogs.cc b/gtk2_ardour/ardour_ui_dialogs.cc
index 6f727e3004..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,184 +18,230 @@
 */
 
 /* 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 <ardour/session.h>
+#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 "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 "meter_bridge.h"
-#include "connection_editor.h"
 #include "public_editor.h"
-#include "option_editor.h"
-#include "location_ui.h"
+#include "rc_option_editor.h"
 #include "route_params_ui.h"
-#include "library_ui.h"
+#include "shuttle_control.h"
+#include "session_option_editor.h"
+#include "speaker_dialog.h"
+#include "sfdb_ui.h"
+#include "theme_manager.h"
+#include "time_info_box.h"
 
 #include "i18n.h"
 
 using namespace ARDOUR;
+using namespace PBD;
+using namespace Glib;
 using namespace Gtk;
 using namespace Gtkmm2ext;
 
 void
-ARDOUR_UI::connect_to_session (Session *s)
+ARDOUR_UI::set_session (Session *s)
 {
-	session = s;
-
-	session->HaltOnXrun.connect (mem_fun(*this, &ARDOUR_UI::halt_on_xrun_message));
+	SessionHandlePtr::set_session (s);
 
-	/* 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);
+		}
+	}
 
-//	save_as_item->set_sensitive (true);
-	save_template_item->set_sensitive (true);
-	snapshot_item->set_sensitive (true);
-	save_item->set_sensitive (true);
-	add_track_item->set_sensitive (true);
-	export_item->set_sensitive (true);
-	close_item->set_sensitive (true);
-	locations_dialog_check->set_sensitive (true);
-	route_params_check->set_sensitive (true);
-	connection_editor_check->set_sensitive (true);
-
-	cleanup_item->set_sensitive (true);
-
-	/* sensitize transport bar */
-
-	goto_start_button.set_sensitive (true);
-	goto_end_button.set_sensitive (true);
-	roll_button.set_sensitive (true);
-	stop_button.set_sensitive (true);
-	play_selection_button.set_sensitive (true);
-	rec_button.set_sensitive (true);
-	auto_loop_button.set_sensitive (true);
-	shuttle_box.set_sensitive (true);
-	
-	/* <CMT Additions> */
-	if (image_compositor_item) {
-		image_compositor_item->set_sensitive(true) ;
-	}
-	/* </CMT Additions> */
-	
-
-	if (session->n_diskstreams()) {
-		// meter_bridge_dialog_check->set_sensitive (true);
-	} else {
-		session->DiskStreamAdded.connect (mem_fun(*this, &ARDOUR_UI::diskstream_added));
+	if (!_session) {
+		return;
 	}
 
-	if (connection_editor) {
-		connection_editor->set_session (s);
+	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;
+			}
+		}
 	}
 
-	if (location_ui) {
-		location_ui->set_session(s);
+	AutomationWatch::instance().set_session (s);
+
+	if (location_ui->get()) {
+		location_ui->get()->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 (session_option_editor) {
+		session_option_editor->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));
+	if (shuttle_box) {
+		shuttle_box->set_session (s);
+	}
 
-	/* 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.
-	*/
+	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);
+		}
+	}
+
+	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 */
+
+	ActionManager::set_sensitive (ActionManager::session_sensitive_actions, true);
+	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->monitor_out()) {
+		Glib::RefPtr<Action> act = ActionManager::get_action (X_("options"), X_("SoloViaBus"));
+		if (act) {
+			act->set_sensitive (false);
+		}
+	}
+
+	/* allow wastebasket flush again */
+
+	Glib::RefPtr<Action> act = ActionManager::get_action (X_("Main"), X_("FlushWastebasket"));
+	if (act) {
+		act->set_sensitive (true);
+	}
+
+	/* 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);
 
-	session->TransportStateChange.connect (mem_fun(*this, &ARDOUR_UI::queue_transport_change));
-	session->ControlChanged.connect (mem_fun(*this, &ARDOUR_UI::queue_map_control_change));
+	rec_button.set_sensitive (true);
+
+	solo_alert_button.set_active (_session->soloing());
 
-	/* alert the user to these things happening */
+	setup_session_options ();
 
-	session->AuditionActive.connect (mem_fun(*this, &ARDOUR_UI::auditioning_changed));
-	session->SoloActive.connect (mem_fun(*this, &ARDOUR_UI::soloing_changed));
+	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));
 
-	solo_alert_button.set_active (session->soloing());
+	_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());
 
-	/* can't be auditioning here */
+	_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 ());
 
-	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);
+#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.
 	*/
-	
-	map_button_state ();
 
 	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->window().realize();
-	}
+	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 = Main::timeout.connect (mem_fun(*this, &ARDOUR_UI::every_second), 1000);
-	point_one_second_connection = Main::timeout.connect (mem_fun(*this, &ARDOUR_UI::every_point_one_seconds), 100);
-	point_zero_one_second_connection = Main::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 session"))) {
+	if (_session && _session->dirty()) {
+		std::vector<std::string> 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;
 		}
 	}
 
+	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();
 
-	/* desensitize menu bar options that are now invalid */
-
-//	save_as_item->set_sensitive (false);
-	save_template_item->set_sensitive (false);
-	snapshot_item->set_sensitive (false);
-	save_item->set_sensitive (false);
-	add_track_item->set_sensitive (false);
-	export_item->set_sensitive (false);
-	close_item->set_sensitive (false);
-	// meter_bridge_dialog_check->set_sensitive (false);
-	connection_editor_check->set_sensitive (false);
-	locations_dialog_check->set_sensitive (false);
-	// meter_bridge_dialog_check->set_active(false);
-	connection_editor_check->set_active(false);
-	locations_dialog_check->set_active(false);
-	route_params_check->set_sensitive (false);
-
-	/* desensitize transport bar */
-
-	goto_start_button.set_sensitive (false);
-	goto_end_button.set_sensitive (false);
-	roll_button.set_sensitive (false);
-	stop_button.set_sensitive (false);
-	play_selection_button.set_sensitive (false);
+	ActionManager::set_sensitive (ActionManager::session_sensitive_actions, false);
+
 	rec_button.set_sensitive (false);
-	auto_loop_button.set_sensitive (false);
-	shuttle_box.set_sensitive (false);
 
 	stop_blinking ();
 	stop_clocking ();
@@ -204,192 +250,218 @@ 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);
-
-	if (option_editor) {
-		option_editor->set_session (0);
-	}
-
-	if (mixer) {
-		mixer->hide_all ();
-	}
+	delete _session;
+	_session = 0;
 
-	delete session;
-	session = 0;
+	session_loaded = false;
 
 	update_buffer_load ();
-	// update_disk_rate ();
 
 	return 0;
 }
 
-int
-ARDOUR_UI::create_meter_bridge ()
+void
+ARDOUR_UI::toggle_big_clock_window ()
 {
-	if (meter_bridge == 0) {
-		meter_bridge = new MeterBridge ();
-		meter_bridge->Hiding.connect (mem_fun(*this, &ARDOUR_UI::meter_bridge_hiding));
+	RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("ToggleBigClock"));
+	if (act) {
+		RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
+
+		if (tact->get_active()) {
+			big_clock_window->get()->show_all ();
+			big_clock_window->get()->present ();
+		} else {
+			big_clock_window->get()->hide ();
+		}
 	}
-	return 0;
 }
 
 void
-ARDOUR_UI::meter_bridge_hiding()
-{
-	// meter_bridge_dialog_check->set_active(false);
-}
-
-int
-ARDOUR_UI::create_connection_editor ()
+ARDOUR_UI::toggle_speaker_config_window ()
 {
-	if (connection_editor == 0) {
-		connection_editor = new ConnectionEditor ();
-		connection_editor->Hiding.connect (mem_fun(*this, &ARDOUR_UI::connection_editor_hiding));
-	}
-
-	if (session) {
-		connection_editor->set_session (session);
+	RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("toggle-speaker-config"));
+	if (act) {
+		RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
+
+		if (tact->get_active()) {
+			speaker_config_window->get()->show_all ();
+			speaker_config_window->get()->present ();
+		} else {
+			speaker_config_window->get()->hide ();
+		}
 	}
-
-	return 0;
 }
 
 void
-ARDOUR_UI::toggle_connection_editor ()
+ARDOUR_UI::new_midi_tracer_window ()
 {
-	if (create_connection_editor()) {
+	RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("NewMIDITracer"));
+	if (!act) {
 		return;
 	}
 
-	if (connection_editor->within_hiding()) {
-		return;
+	std::list<MidiTracer*>::iterator i = _midi_tracer_windows.begin ();
+	while (i != _midi_tracer_windows.end() && (*i)->get_visible() == true) {
+		++i;
 	}
-						      
 
-	if (connection_editor_check->get_active()){
-		connection_editor->show_all();
+	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 {
-		connection_editor->hide_all();
+		/* re-use the hidden one */
+		(*i)->show_all ();
 	}
 }
 
 void
-ARDOUR_UI::connection_editor_hiding()
+ARDOUR_UI::toggle_rc_options_window ()
 {
-	connection_editor_check->set_active(false);
-}
+	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_("<Actions>/Common/ToggleRCOptionsEditor")));
+		rc_option_editor->set_session (_session);
+	}
 
-void
-ARDOUR_UI::big_clock_hiding()
-{
-	big_clock_check->set_active(false);
+	RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("ToggleRCOptionsEditor"));
+	if (act) {
+		RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
+
+		if (tact->get_active()) {
+			rc_option_editor->show_all ();
+			rc_option_editor->present ();
+		} else {
+			rc_option_editor->hide ();
+		}
+	}
 }
 
 void
-ARDOUR_UI::toggle_big_clock_window ()
+ARDOUR_UI::toggle_session_options_window ()
 {
-	if (big_clock_window->within_hiding()) {
-		return;
+	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_("<Actions>/Common/ToggleSessionOptionsEditor")));
 	}
 
-	if (big_clock_window->is_visible()) {
-		big_clock_window->hide_all ();
-	} else {
-		big_clock_window->show_all ();
+	RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("ToggleSessionOptionsEditor"));
+	if (act) {
+		RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic (act);
+
+		if (tact->get_active()) {
+			session_option_editor->show_all ();
+			session_option_editor->present ();
+		} else {
+			session_option_editor->hide ();
+		}
+	}
+}
+
+int
+ARDOUR_UI::create_location_ui ()
+{
+	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_("<Actions>/Common/ToggleLocations")));
 	}
+	return 0;
 }
 
 void
-ARDOUR_UI::toggle_options_window ()
+ARDOUR_UI::toggle_location_window ()
 {
-	if (option_editor == 0) {
-		option_editor = new OptionEditor (*this, *editor, *mixer);
-		option_editor->Hiding.connect(mem_fun(*this, &ARDOUR_UI::option_hiding));
-		option_editor->set_session (session);
-	} else if (option_editor->within_hiding()) {
+	if (create_location_ui()) {
 		return;
 	}
 
-	if (option_editor->is_visible()) {
-		option_editor->hide_all ();
-	} else {
-		option_editor->show_all ();
+	RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("ToggleLocations"));
+	if (act) {
+		RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
+
+		if (tact->get_active()) {
+			location_ui->get()->show_all ();
+			location_ui->get()->present ();
+		} else {
+			location_ui->get()->hide ();
+		}
 	}
 }
 
 void
-ARDOUR_UI::option_hiding ()
+ARDOUR_UI::toggle_key_editor ()
 {
-	options_window_check->set_active(false);
-}
+	if (key_editor == 0) {
+		key_editor = new KeyEditor;
+		key_editor->signal_unmap().connect (sigc::bind (sigc::ptr_fun(&ActionManager::uncheck_toggleaction), X_("<Actions>/Common/ToggleKeyEditor")));
+	}
 
-void
-ARDOUR_UI::toggle_auto_input ()
+	RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("ToggleKeyEditor"));
+	if (act) {
+		RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
 
-{
-	toggle_some_session_state (auto_input_button,
-				   &Session::get_auto_input,
-				   &Session::set_auto_input);
-	
-	meter_bridge->clear_all_meters ();
+		if (tact->get_active()) {
+			key_editor->show_all ();
+			key_editor->present ();
+		} else {
+			key_editor->hide ();
+		}
+	}
 }
 
 void
-ARDOUR_UI::toggle_metering ()
+ARDOUR_UI::toggle_theme_manager ()
 {
-#if 0
-	if (global_meter_button.get_active()) {
-		meter_bridge->toggle_metering ();
+	RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("ToggleThemeManager"));
+	if (act) {
+		RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
+
+		if (tact->get_active()) {
+			theme_manager->show_all ();
+			theme_manager->present ();
+		} else {
+			theme_manager->hide ();
+		}
 	}
-#endif
 }
 
-int
-ARDOUR_UI::create_location_ui ()
+void
+ARDOUR_UI::create_bundle_manager ()
 {
-	if (location_ui == 0) {
-		location_ui = new LocationUI ();
-		location_ui->set_session (session);
-		location_ui->Hiding.connect (mem_fun(*this, &ARDOUR_UI::location_ui_hiding));
-	} 
-	return 0;
+	if (bundle_manager == 0) {
+		bundle_manager = new BundleManager (_session);
+		bundle_manager->signal_unmap().connect (sigc::bind (sigc::ptr_fun (&ActionManager::uncheck_toggleaction), X_("<Actions>/Common/ToggleBundleManager")));
+	}
 }
 
 void
-ARDOUR_UI::toggle_location_window ()
+ARDOUR_UI::toggle_bundle_manager ()
 {
-	if (create_location_ui()) {
-		return;
-	}
+	create_bundle_manager ();
 
-	if (location_ui->within_hiding()) {
-		return;
-	}
+	RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("ToggleBundleManager"));
+	if (act) {
+		RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic (act);
 
-	if (location_ui->is_visible()) {
-		location_ui->hide_all();
-	} else {
-		location_ui->show_all();
+		if (tact->get_active()) {
+			bundle_manager->show_all ();
+			bundle_manager->present ();
+		} else {
+			bundle_manager->hide ();
+		}
 	}
 }
 
-void
-ARDOUR_UI::location_ui_hiding()
-{
-	locations_dialog_check->set_active(false);
-}
-
 int
 ARDOUR_UI::create_route_params ()
 {
 	if (route_params == 0) {
-		route_params = new RouteParams_UI (*engine);
-		route_params->set_session (session);
-		route_params->Hiding.connect (mem_fun(*this, &ARDOUR_UI::route_params_hiding));
+		route_params = new RouteParams_UI ();
+		route_params->set_session (_session);
+		route_params->signal_unmap().connect (sigc::bind(sigc::ptr_fun(&ActionManager::uncheck_toggleaction), X_("<Actions>/Common/ToggleInspector")));
 	}
 	return 0;
 }
@@ -401,54 +473,48 @@ ARDOUR_UI::toggle_route_params_window ()
 		return;
 	}
 
-	if (route_params->within_hiding()) {
-		return;
-	}
+	RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("ToggleInspector"));
+	if (act) {
+		RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
 
-	if (route_params->is_visible ()) {
-		route_params->hide_all ();
-	} else {
-		route_params->show_all ();
+		if (tact->get_active()) {
+			route_params->show_all ();
+			route_params->present ();
+		} else {
+			route_params->hide ();
+		}
 	}
 }
-	
-void
-ARDOUR_UI::route_params_hiding ()
-{
-	route_params_check->set_active (false);
-}
 
-SoundFileSelector&
-ARDOUR_UI::get_sfdb_window ()
+void
+ARDOUR_UI::handle_locations_change (Location *)
 {
-	if (sfdb_window == 0) {
-		sfdb_window = new SoundFileSelector ();
-		sfdb_window->Hiding.connect (mem_fun(*this, &ARDOUR_UI::sfdb_hiding));
-		sfdb_window->hide_all ();
+	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);
+		}
 	}
-	
-	return *sfdb_window;
 }
 
-void
-ARDOUR_UI::toggle_sfdb_window ()
+bool
+ARDOUR_UI::main_window_state_event_handler (GdkEventWindowState* ev, bool window_was_editor)
 {
-	get_sfdb_window ();
+	if (window_was_editor) {
 
-	if (sfdb_window->within_hiding()) {
-		return;
-	}
+		if ((ev->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) &&
+		    (ev->new_window_state & GDK_WINDOW_STATE_FULLSCREEN)) {
+			float_big_clock (editor);
+		}
 
-	if (sfdb_window->is_visible ()) {
-		sfdb_window->hide_all ();
 	} else {
-		sfdb_window->show_all ();
-		sfdb_window->hide_import_stuff();
+
+		if ((ev->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) &&
+		    (ev->new_window_state & GDK_WINDOW_STATE_FULLSCREEN)) {
+			float_big_clock (mixer);
+		}
 	}
-}
 
-void
-ARDOUR_UI::sfdb_hiding ()
-{
-	sfdb_check->set_active (false);
+	return false;
 }