strip keyboard.cc of noxious focus handling stuff, and cleanup

git-svn-id: svn://localhost/trunk/ardour2@106 d708f5d6-7413-0410-9779-e7cbd77b26cf

40 files changed, 398 insertions, 942 deletions

diff --git a/gtk2_ardour/actions.cc b/gtk2_ardour/actions.cc
index 86ca2284f3..81c226843d 100644
--- a/gtk2_ardour/actions.cc
+++ b/gtk2_ardour/actions.cc
@@ -29,7 +29,6 @@ using namespace std;
 using namespace Gtk;
 using namespace Glib;
 using namespace sigc;
-using namespace ActionManager;
 
 vector<RefPtr<Gtk::Action> > ActionManager::session_sensitive_actions;
 vector<RefPtr<Gtk::Action> > ActionManager::region_list_selection_sensitive_actions;
@@ -40,16 +39,9 @@ vector<RefPtr<Gtk::Action> > ActionManager::range_sensitive_actions;
 vector<RefPtr<Gtk::Action> > ActionManager::jack_sensitive_actions;
 string ActionManager::unbound_string = "--";
 
-static vector<RefPtr<UIManager> > ui_managers;
-
-void
-register_ui_manager (RefPtr<UIManager> uim)
-{
-	ui_managers.push_back (uim);
-}
 
 RefPtr<Action>
-register_action (RefPtr<ActionGroup> group, string name, string label, slot<void> sl, guint key, Gdk::ModifierType mods)
+ActionManager::register_action (RefPtr<ActionGroup> group, string name, string label, slot<void> sl, guint key, Gdk::ModifierType mods)
 {
 	RefPtr<Action> act = register_action (group, name, label, sl);
 	AccelMap::add_entry (act->get_accel_path(), key, mods);
@@ -58,7 +50,7 @@ register_action (RefPtr<ActionGroup> group, string name, string label, slot<void
 }
 
 RefPtr<Action>
-register_action (RefPtr<ActionGroup> group, string name, string label, slot<void> sl)
+ActionManager::register_action (RefPtr<ActionGroup> group, string name, string label, slot<void> sl)
 {
 	RefPtr<Action> act = register_action (group, name, label);
 	group->add (act, sl);
@@ -67,7 +59,7 @@ register_action (RefPtr<ActionGroup> group, string name, string label, slot<void
 }
 
 RefPtr<Action>
-register_action (RefPtr<ActionGroup> group, string name, string label)
+ActionManager::register_action (RefPtr<ActionGroup> group, string name, string label)
 {
 	RefPtr<Action> act;
 
@@ -79,7 +71,7 @@ register_action (RefPtr<ActionGroup> group, string name, string label)
 
 
 RefPtr<Action>
-register_radio_action (RefPtr<ActionGroup> group, RadioAction::Group rgroup, string name, string label, slot<void> sl, guint key, Gdk::ModifierType mods)
+ActionManager::register_radio_action (RefPtr<ActionGroup> group, RadioAction::Group rgroup, string name, string label, slot<void> sl, guint key, Gdk::ModifierType mods)
 {
 	RefPtr<Action> act = register_radio_action (group, rgroup, name, label, sl);
 	AccelMap::add_entry (act->get_accel_path(), key, mods);
@@ -88,7 +80,7 @@ register_radio_action (RefPtr<ActionGroup> group, RadioAction::Group rgroup, str
 }
 
 RefPtr<Action>
-register_radio_action (RefPtr<ActionGroup> group, RadioAction::Group rgroup, string name, string label, slot<void> sl)
+ActionManager::register_radio_action (RefPtr<ActionGroup> group, RadioAction::Group rgroup, string name, string label, slot<void> sl)
 {
 	RefPtr<Action> act;
 
@@ -100,7 +92,7 @@ register_radio_action (RefPtr<ActionGroup> group, RadioAction::Group rgroup, str
 
 
 RefPtr<Action>
-register_toggle_action (RefPtr<ActionGroup> group, string name, string label, slot<void> sl, guint key, Gdk::ModifierType mods)
+ActionManager::register_toggle_action (RefPtr<ActionGroup> group, string name, string label, slot<void> sl, guint key, Gdk::ModifierType mods)
 {
 	RefPtr<Action> act = register_toggle_action (group,name, label, sl);
 	AccelMap::add_entry (act->get_accel_path(), key, mods);
@@ -109,7 +101,7 @@ register_toggle_action (RefPtr<ActionGroup> group, string name, string label, sl
 }
 
 RefPtr<Action>
-register_toggle_action (RefPtr<ActionGroup> group, string name, string label, slot<void> sl)
+ActionManager::register_toggle_action (RefPtr<ActionGroup> group, string name, string label, slot<void> sl)
 {
 	RefPtr<Action> act;
 
@@ -119,7 +111,8 @@ register_toggle_action (RefPtr<ActionGroup> group, string name, string label, sl
 	return act;
 }
 
-bool lookup_entry (const ustring accel_path, Gtk::AccelKey& key)
+bool 
+ActionManager::lookup_entry (const ustring accel_path, Gtk::AccelKey& key)
 {
 	GtkAccelKey gkey;
 	bool known = gtk_accel_map_lookup_entry (accel_path.c_str(), &gkey);
@@ -134,47 +127,39 @@ bool lookup_entry (const ustring accel_path, Gtk::AccelKey& key)
 }
 
 void
-merge_actions (RefPtr<ActionGroup> dst, const RefPtr<ActionGroup> src)
+ActionManager::get_all_actions (vector<string>& names, vector<string>& paths, vector<string>& keys, vector<AccelKey>& bindings)
 {
-	ListHandle<RefPtr<Action> > group_actions = src->get_actions();
-
-	for (ListHandle<RefPtr<Action> >::iterator a = group_actions.begin(); a != group_actions.end(); ++a) {
-		RefPtr<Action> act = Action::create ((*a)->get_name(), (*a)->property_label());
-		dst->add (act);
+	ListHandle<RefPtr<ActionGroup> > uim_groups = ui_manager.get_action_groups ();
+	
+	for (ListHandle<RefPtr<ActionGroup> >::iterator g = uim_groups.begin(); g != uim_groups.end(); ++g) {
+		
+		ListHandle<RefPtr<Action> > group_actions = (*g)->get_actions();
+		
+		for (ListHandle<RefPtr<Action> >::iterator a = group_actions.begin(); a != group_actions.end(); ++a) {
+			
+			ustring accel_path;
+			
+			accel_path = (*a)->get_accel_path();
+			
+			names.push_back ((*a)->get_name());
+			paths.push_back (accel_path);
+			
+			AccelKey key;
+			bool known = lookup_entry (accel_path, key);
+			
+			if (known) {
+				keys.push_back (ui_manager.get_accel_group()->name (key.get_key(), Gdk::ModifierType (key.get_mod())));
+			} else {
+				keys.push_back (unbound_string);
+			}
+			
+			bindings.push_back (AccelKey (key.get_key(), Gdk::ModifierType (key.get_mod())));
+		}
 	}
 }
 
 void
-get_all_actions (vector<string>& names, vector<string>& paths, vector<string>& keys, vector<AccelKey>& bindings)
+ActionManager::add_action_group (RefPtr<ActionGroup> grp)
 {
-	for (vector<RefPtr<UIManager> >::iterator u = ui_managers.begin(); u != ui_managers.end(); ++u) {
-
-		ListHandle<RefPtr<ActionGroup> > uim_groups = (*u)->get_action_groups ();
-
-		for (ListHandle<RefPtr<ActionGroup> >::iterator g = uim_groups.begin(); g != uim_groups.end(); ++g) {
-
-			ListHandle<RefPtr<Action> > group_actions = (*g)->get_actions();
-
-			for (ListHandle<RefPtr<Action> >::iterator a = group_actions.begin(); a != group_actions.end(); ++a) {
-				
-				ustring accel_path;
-				
-				accel_path = (*a)->get_accel_path();
-				
-				names.push_back ((*a)->get_name());
-				paths.push_back (accel_path);
-
-				AccelKey key;
-				bool known = lookup_entry (accel_path, key);
-
-				if (known) {
-					keys.push_back ((*u)->get_accel_group()->name (key.get_key(), Gdk::ModifierType (key.get_mod())));
-				} else {
-					keys.push_back (unbound_string);
-				}
-
-				bindings.push_back (AccelKey (key.get_key(), Gdk::ModifierType (key.get_mod())));
-			}
-		}
-	}
+	ui_manager.insert_action_group (grp);
 }
diff --git a/gtk2_ardour/actions.h b/gtk2_ardour/actions.h
index e0d7fa020f..3c831d0aff 100644
--- a/gtk2_ardour/actions.h
+++ b/gtk2_ardour/actions.h
@@ -6,47 +6,58 @@
 #include <gtkmm/radioaction.h>
 #include <gtkmm/toggleaction.h>
 #include <gtkmm/actiongroup.h>
+#include <gtkmm/accelkey.h>
 
 namespace Gtk {
 	class UIManager;
 }
 
-namespace ActionManager
+class ActionManager
 {
-	extern std::vector<Glib::RefPtr<Gtk::Action> > session_sensitive_actions;
-	extern std::vector<Glib::RefPtr<Gtk::Action> > region_list_selection_sensitive_actions;
-	extern std::vector<Glib::RefPtr<Gtk::Action> > region_selection_sensitive_actions;
-	extern std::vector<Glib::RefPtr<Gtk::Action> > track_selection_sensitive_actions;
-	extern std::vector<Glib::RefPtr<Gtk::Action> > plugin_selection_sensitive_actions;
-	extern std::vector<Glib::RefPtr<Gtk::Action> > range_sensitive_actions;
-	extern std::vector<Glib::RefPtr<Gtk::Action> > jack_sensitive_actions;
+  public:
+	ActionManager() {}
+	virtual ~ActionManager () {}
 
-	extern std::string unbound_string;  /* the key string returned if an action is not bound */
+	static std::vector<Glib::RefPtr<Gtk::Action> > session_sensitive_actions;
+	static std::vector<Glib::RefPtr<Gtk::Action> > region_list_selection_sensitive_actions;
+	static std::vector<Glib::RefPtr<Gtk::Action> > region_selection_sensitive_actions;
+	static std::vector<Glib::RefPtr<Gtk::Action> > track_selection_sensitive_actions;
+	static std::vector<Glib::RefPtr<Gtk::Action> > plugin_selection_sensitive_actions;
+	static std::vector<Glib::RefPtr<Gtk::Action> > range_sensitive_actions;
+	static std::vector<Glib::RefPtr<Gtk::Action> > jack_sensitive_actions;
 
-	void register_ui_manager (Glib::RefPtr<Gtk::UIManager>);
+	static std::string unbound_string;  /* the key string returned if an action is not bound */
+	static Gtk::UIManager ui_manager;
 
-	Glib::RefPtr<Gtk::Action> register_action (Glib::RefPtr<Gtk::ActionGroup> group, 
+	static void add_action_group (Glib::RefPtr<Gtk::ActionGroup>);
+
+	static Glib::RefPtr<Gtk::Action> register_action (Glib::RefPtr<Gtk::ActionGroup> group, 
 						   std::string name, std::string label);
-	Glib::RefPtr<Gtk::Action> register_action (Glib::RefPtr<Gtk::ActionGroup> group, 
+	static Glib::RefPtr<Gtk::Action> register_action (Glib::RefPtr<Gtk::ActionGroup> group, 
 						   std::string name, std::string label, sigc::slot<void> sl, 
 						   guint key, Gdk::ModifierType mods);
-	Glib::RefPtr<Gtk::Action> register_action (Glib::RefPtr<Gtk::ActionGroup> group, 
+	static Glib::RefPtr<Gtk::Action> register_action (Glib::RefPtr<Gtk::ActionGroup> group, 
 						   std::string name, std::string label, sigc::slot<void> sl);
 	
-	Glib::RefPtr<Gtk::Action> register_radio_action (Glib::RefPtr<Gtk::ActionGroup> group, Gtk::RadioAction::Group, 
+	static Glib::RefPtr<Gtk::Action> register_radio_action (Glib::RefPtr<Gtk::ActionGroup> group, Gtk::RadioAction::Group, 
 							 std::string name, std::string label, sigc::slot<void> sl, 
 							 guint key, Gdk::ModifierType mods);
-	Glib::RefPtr<Gtk::Action> register_radio_action (Glib::RefPtr<Gtk::ActionGroup> group, Gtk::RadioAction::Group, 
+	static Glib::RefPtr<Gtk::Action> register_radio_action (Glib::RefPtr<Gtk::ActionGroup> group, Gtk::RadioAction::Group, 
 							 std::string name, std::string label, sigc::slot<void> sl);
 	
-	Glib::RefPtr<Gtk::Action> register_toggle_action (Glib::RefPtr<Gtk::ActionGroup> group, 
+	static Glib::RefPtr<Gtk::Action> register_toggle_action (Glib::RefPtr<Gtk::ActionGroup> group, 
 							  std::string name, std::string label, sigc::slot<void> sl, 
 							  guint key, Gdk::ModifierType mods);
-	Glib::RefPtr<Gtk::Action> register_toggle_action (Glib::RefPtr<Gtk::ActionGroup> group, 
+	static Glib::RefPtr<Gtk::Action> register_toggle_action (Glib::RefPtr<Gtk::ActionGroup> group, 
 							  std::string name, std::string label, sigc::slot<void> sl);
 
-	void merge_actions (Glib::RefPtr<Gtk::ActionGroup> dst, const Glib::RefPtr<Gtk::ActionGroup> src);
+	static bool lookup_entry (const Glib::ustring accel_path, Gtk::AccelKey& key);
 
+	static void get_all_actions (std::vector<std::string>& names, 
+				     std::vector<std::string>& paths, 
+				     std::vector<std::string>& keys, 
+				     std::vector<Gtk::AccelKey>& bindings);
+	
 };
 
 #endif /* __ardour_gtk_actions_h__ */
diff --git a/gtk2_ardour/ardour_dialog.cc b/gtk2_ardour/ardour_dialog.cc
index 3af944d85c..030be0486e 100644
--- a/gtk2_ardour/ardour_dialog.cc
+++ b/gtk2_ardour/ardour_dialog.cc
@@ -27,8 +27,7 @@
 
 
 ArdourDialog::ArdourDialog (string name)
-	: Dialog (name), 
-	  KeyboardTarget (*this, name)
+	: Dialog (name)
 {
 	session = 0;
 	kbd_input = false;
@@ -46,25 +45,26 @@ bool
 ArdourDialog::on_enter_notify_event (GdkEventCrossing *ev)
 {
 	if (ev->detail != GDK_NOTIFY_INFERIOR) {
-		Keyboard::the_keyboard().set_current_dialog (this);
+		// GTK2FIX
+		//Keyboard::the_keyboard().set_current_dialog (this);
 	}
-	return FALSE;
+	return false;
 }
 
 bool
 ArdourDialog::on_leave_notify_event (GdkEventCrossing *ev)
 {
 	if (ev->detail != GDK_NOTIFY_INFERIOR) {
-		Keyboard::the_keyboard().set_current_dialog (0);
+		// GTK2FIX
+		//Keyboard::the_keyboard().set_current_dialog (0);
 	}
-	return FALSE;
+	return false;
 }
 
 void
 ArdourDialog::on_unmap ()
 {
 	_within_hiding = true;
-	Hiding (); /* EMIT_SIGNAL */
 	_within_hiding = false;
 	Dialog::on_unmap ();
 }
@@ -79,12 +79,7 @@ void
 ArdourDialog::stop (int rr)
 {
 	if (hide_on_stop) {
-		Hiding (); /* EMIT_SIGNAL */
 		hide_all ();
-
-		if (kbd_input) {
-			ARDOUR_UI::instance()->allow_focus (false);
-		}
 	}
 
 	if (running) {
@@ -102,10 +97,6 @@ ArdourDialog::run ()
 {
 	show_all ();
 
-	if (kbd_input) {
-		ARDOUR_UI::instance()->allow_focus (true);
-	}
-
 	running = true;
 	switch (Dialog::run ()) {
 	case GTK_RESPONSE_ACCEPT:
@@ -121,10 +112,6 @@ ArdourDialog::run ()
 	}
 
 	hide_all ();
-
-	if (kbd_input) {
-		ARDOUR_UI::instance()->allow_focus (false);
-	}
 }
 
 void
diff --git a/gtk2_ardour/ardour_dialog.h b/gtk2_ardour/ardour_dialog.h
index d2665c0ed8..9af434993a 100644
--- a/gtk2_ardour/ardour_dialog.h
+++ b/gtk2_ardour/ardour_dialog.h
@@ -24,8 +24,6 @@
 #include <gtkmm/window.h>
 #include <gtkmm/dialog.h>
 
-#include "keyboard_target.h"
-
 namespace ARDOUR {
 	class Session;
 };
@@ -35,7 +33,7 @@ namespace ARDOUR {
  * same mechanism to declare its closing, and to have a common
  * method of connecting and disconnecting from a Session.
  */
-class ArdourDialog : public Gtk::Dialog, public KeyboardTarget
+class ArdourDialog : public Gtk::Dialog
 {
   public:
 	ArdourDialog (string name);
diff --git a/gtk2_ardour/ardour_ui.cc b/gtk2_ardour/ardour_ui.cc
index f66b6ff0d1..9165d08a24 100644
--- a/gtk2_ardour/ardour_ui.cc
+++ b/gtk2_ardour/ardour_ui.cc
@@ -2551,14 +2551,6 @@ ARDOUR_UI::restore_state (string name)
 }
 
 void
-ARDOUR_UI::allow_focus (bool yn)
-{
-	if (keyboard) {
-		keyboard->allow_focus (yn);
-	}
-}
-
-void
 ARDOUR_UI::primary_clock_value_changed ()
 {
 	if (session) {
@@ -2633,20 +2625,6 @@ ARDOUR_UI::transport_rec_enable_blink (bool onoff)
 }
 
 gint
-ARDOUR_UI::generic_focus_in_event (GdkEventFocus *ev)
-{
-	ARDOUR_UI::instance()->allow_focus (true);
-	return FALSE;
-}
-
-gint
-ARDOUR_UI::generic_focus_out_event (GdkEventFocus *ev)
-{
-	ARDOUR_UI::instance()->allow_focus (false);
-	return FALSE;
-}
-
-gint
 ARDOUR_UI::hide_and_quit (GdkEventAny *ev, ArdourDialog *window)
 {
 	window->hide();
diff --git a/gtk2_ardour/ardour_ui.h b/gtk2_ardour/ardour_ui.h
index 49b1272d24..088d819b7e 100644
--- a/gtk2_ardour/ardour_ui.h
+++ b/gtk2_ardour/ardour_ui.h
@@ -145,11 +145,6 @@ class ARDOUR_UI : public Gtkmm2ext::UI
 	PublicEditor&	  the_editor(){return *editor;}
 	Mixer_UI* the_mixer() { return mixer; }
 	
-	void allow_focus (bool yn);
-
-	static gint generic_focus_in_event (GdkEventFocus *);
-	static gint generic_focus_out_event (GdkEventFocus *);
-
 	void toggle_location_window ();
 	void toggle_big_clock_window ();
 	void toggle_connection_editor ();
diff --git a/gtk2_ardour/ardour_ui2.cc b/gtk2_ardour/ardour_ui2.cc
index f375594cc6..64f85c0192 100644
--- a/gtk2_ardour/ardour_ui2.cc
+++ b/gtk2_ardour/ardour_ui2.cc
@@ -434,7 +434,7 @@ ARDOUR_UI::setup_clock ()
 
 	big_clock_window->signal_delete_event().connect (bind (sigc::ptr_fun (just_hide_it), static_cast<Gtk::Window*>(big_clock_window)));
 
-	big_clock_window->Hiding.connect (mem_fun(*this, &ARDOUR_UI::big_clock_hiding));
+	big_clock_window->signal_unmap().connect (mem_fun(*this, &ARDOUR_UI::big_clock_hiding));
 }
 
 void
diff --git a/gtk2_ardour/ardour_ui_dependents.cc b/gtk2_ardour/ardour_ui_dependents.cc
index 68c1edd3e8..f2b41bd47a 100644
--- a/gtk2_ardour/ardour_ui_dependents.cc
+++ b/gtk2_ardour/ardour_ui_dependents.cc
@@ -59,24 +59,8 @@ ARDOUR_UI::we_have_dependents ()
 void
 ARDOUR_UI::setup_keybindings ()
 {
-	/* install default bindings */
-
-	KeyboardTarget *defaults = new KeyboardTarget (editor->window(), X_("default"));
-
-	XMLNode* keynode = ARDOUR::Config->get_keys();
-
-	if (keynode != 0) {
-		defaults->set_binding_state (*keynode);
-		editor->set_binding_state (*keynode);
-		mixer->set_binding_state (*keynode);
-		meter_bridge->set_binding_state (*keynode);
-	} else {
-		error << _("keyboard_target: error setting binding state: invalid node") << endmsg;
-	}
-	
-	/* use the default keyboard target for now */
-
-	keyboard->set_default_target (defaults);
+	// GTK2FIX
+	editor->register_actions ();
 }
 
 void
diff --git a/gtk2_ardour/ardour_ui_dialogs.cc b/gtk2_ardour/ardour_ui_dialogs.cc
index 0af47c0c19..5324cfe464 100644
--- a/gtk2_ardour/ardour_ui_dialogs.cc
+++ b/gtk2_ardour/ardour_ui_dialogs.cc
@@ -141,7 +141,7 @@ ARDOUR_UI::connect_to_session (Session *s)
 	start_blinking ();
 
 	if (editor) {
-		editor->window().present();
+		editor->present();
 	}
 
 	transport_stopped ();
@@ -232,7 +232,7 @@ ARDOUR_UI::create_meter_bridge ()
 {
 	if (meter_bridge == 0) {
 		meter_bridge = new MeterBridge ();
-		meter_bridge->Hiding.connect (mem_fun(*this, &ARDOUR_UI::meter_bridge_hiding));
+		meter_bridge->signal_unmap().connect (mem_fun(*this, &ARDOUR_UI::meter_bridge_hiding));
 	}
 	return 0;
 }
@@ -248,7 +248,7 @@ ARDOUR_UI::create_connection_editor ()
 {
 	if (connection_editor == 0) {
 		connection_editor = new ConnectionEditor ();
-		connection_editor->Hiding.connect (mem_fun(*this, &ARDOUR_UI::connection_editor_hiding));
+		connection_editor->signal_unmap().connect (mem_fun(*this, &ARDOUR_UI::connection_editor_hiding));
 	}
 
 	if (session) {
@@ -308,7 +308,7 @@ ARDOUR_UI::toggle_options_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->signal_unmap().connect(mem_fun(*this, &ARDOUR_UI::option_hiding));
 		option_editor->set_session (session);
 	} else if (option_editor->within_hiding()) {
 		return;
@@ -354,7 +354,7 @@ ARDOUR_UI::create_location_ui ()
 	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));
+		location_ui->signal_unmap().connect (mem_fun(*this, &ARDOUR_UI::location_ui_hiding));
 	} 
 	return 0;
 }
@@ -389,7 +389,7 @@ 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->signal_unmap().connect (mem_fun(*this, &ARDOUR_UI::route_params_hiding));
 	}
 	return 0;
 }
diff --git a/gtk2_ardour/ardour_ui_ed.cc b/gtk2_ardour/ardour_ui_ed.cc
index d653df9942..1af3ba4a58 100644
--- a/gtk2_ardour/ardour_ui_ed.cc
+++ b/gtk2_ardour/ardour_ui_ed.cc
@@ -39,7 +39,6 @@
 using namespace ARDOUR;
 using namespace Gtk;
 using namespace Gtkmm2ext;
-using namespace ActionManager;
 
 int
 ARDOUR_UI::create_editor ()
@@ -64,14 +63,14 @@ ARDOUR_UI::install_actions ()
 	Glib::RefPtr<ActionGroup> main_actions = ActionGroup::create (X_("Main"));
 	Glib::RefPtr<Action> act;
 
-	register_action (main_actions, X_("New"), _("New"),  bind (mem_fun(*this, &ARDOUR_UI::new_session), false, string ()));
-	register_action (main_actions, X_("Open"), _("Open"),  mem_fun(*this, &ARDOUR_UI::open_session));
-	register_action (main_actions, X_("Recent"), _("Recent"),  mem_fun(*this, &ARDOUR_UI::open_recent_session));
-	act = register_action (main_actions, X_("Close"), _("Close"),  mem_fun(*this, &ARDOUR_UI::close_session));
-	session_sensitive_actions.push_back (act);
+	ActionManager::ActionManager::register_action (main_actions, X_("New"), _("New"),  bind (mem_fun(*this, &ARDOUR_UI::new_session), false, string ()));
+	ActionManager::ActionManager::register_action (main_actions, X_("Open"), _("Open"),  mem_fun(*this, &ARDOUR_UI::open_session));
+	ActionManager::ActionManager::register_action (main_actions, X_("Recent"), _("Recent"),  mem_fun(*this, &ARDOUR_UI::open_recent_session));
+	act = ActionManager::register_action (main_actions, X_("Close"), _("Close"),  mem_fun(*this, &ARDOUR_UI::close_session));
+	ActionManager::session_sensitive_actions.push_back (act);
 
-	act = register_action (main_actions, X_("AddTrackBus"), _("Add Track/Bus"),  mem_fun(*this, &ARDOUR_UI::add_route));
-	session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (main_actions, X_("AddTrackBus"), _("Add Track/Bus"),  mem_fun(*this, &ARDOUR_UI::add_route));
+	ActionManager::session_sensitive_actions.push_back (act);
 
 	
 	/* <CMT Additions> */
@@ -81,200 +80,198 @@ ARDOUR_UI::install_actions ()
 
 	if (results) {
 		if (!results->empty()) {
-			act = register_action (main_actions, X_("aniConnect"), _("Connect"),  (mem_fun (*editor, &PublicEditor::connect_to_image_compositor)));
-			session_sensitive_actions.push_back (act);
+			act = ActionManager::register_action (main_actions, X_("aniConnect"), _("Connect"),  (mem_fun (*editor, &PublicEditor::connect_to_image_compositor)));
+			ActionManager::session_sensitive_actions.push_back (act);
 		}
 		delete results;
 	}
 
 	/* </CMT Additions> */
 
-	act = register_action (main_actions, X_("Snapshot"), _("Snapshot"),  mem_fun(*this, &ARDOUR_UI::snapshot_session));
-	session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (main_actions, X_("Snapshot"), _("Snapshot"),  mem_fun(*this, &ARDOUR_UI::snapshot_session));
+	ActionManager::session_sensitive_actions.push_back (act);
 
-	act = register_action (main_actions, X_("Save Template..."), _("Save Template..."),  mem_fun(*this, &ARDOUR_UI::save_template));
-	session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (main_actions, X_("Save Template..."), _("Save Template..."),  mem_fun(*this, &ARDOUR_UI::save_template));
+	ActionManager::session_sensitive_actions.push_back (act);
 
-	act = register_action (main_actions, X_("ExportSession"), _("Export session to audiofile..."),  mem_fun (*editor, &PublicEditor::export_session));
-	session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (main_actions, X_("ExportSession"), _("Export session to audiofile..."),  mem_fun (*editor, &PublicEditor::export_session));
+	ActionManager::session_sensitive_actions.push_back (act);
 
-	act = register_action (main_actions, X_("ExportRange"), _("Export range to audiofile..."),  mem_fun (*editor, &PublicEditor::export_selection));
-	session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (main_actions, X_("ExportRange"), _("Export range to audiofile..."),  mem_fun (*editor, &PublicEditor::export_selection));
+	ActionManager::session_sensitive_actions.push_back (act);
 
-	act = register_action (main_actions, X_("Export"), _("Export"));
-	session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (main_actions, X_("Export"), _("Export"));
+	ActionManager::session_sensitive_actions.push_back (act);
 
-	act = register_action (main_actions, X_("CleanupUnused"), _("Cleanup unused sources"),  mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::cleanup));
-	session_sensitive_actions.push_back (act);
-	act = register_action (main_actions, X_("FlushWastebasket"), _("Flush wastebasket"),  mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::flush_trash));
-	session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (main_actions, X_("CleanupUnused"), _("Cleanup unused sources"),  mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::cleanup));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (main_actions, X_("FlushWastebasket"), _("Flush wastebasket"),  mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::flush_trash));
+	ActionManager::session_sensitive_actions.push_back (act);
 	
 	/* JACK actions for controlling ... JACK */
 
 	Glib::RefPtr<ActionGroup> jack_actions = ActionGroup::create (X_("JACK"));
 
-	act = register_action (jack_actions, X_("JACKDisconnect"), _("Disconnect"), mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::disconnect_from_jack));
-	jack_sensitive_actions.push_back (act);
-	act = register_action (jack_actions, X_("JACKReconnect"), _("Reconnect"), mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::reconnect_to_jack));
-	jack_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (jack_actions, X_("JACKDisconnect"), _("Disconnect"), mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::disconnect_from_jack));
+	ActionManager::jack_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (jack_actions, X_("JACKReconnect"), _("Reconnect"), mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::reconnect_to_jack));
+	ActionManager::jack_sensitive_actions.push_back (act);
 	
 	RadioAction::Group jack_latency_group;
 	
-	act = register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency32"), X_("32"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 32));
-	jack_sensitive_actions.push_back (act);
-	act = 	register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency64"), X_("64"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 64));
-	jack_sensitive_actions.push_back (act);
-	act = 	register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency128"), X_("128"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 128));
-	jack_sensitive_actions.push_back (act);
-	act = 	register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency256"), X_("256"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 256));
-	jack_sensitive_actions.push_back (act);
-	act = 	register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency512"), X_("512"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 512));
-	jack_sensitive_actions.push_back (act);
-	act = 	register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency1024"), X_("1024"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 1024));
-	jack_sensitive_actions.push_back (act);
-	act = 	register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency2048"), X_("2048"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 2048));
-	jack_sensitive_actions.push_back (act);
-	act = 	register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency4096"), X_("4096"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 4096));
-	jack_sensitive_actions.push_back (act);
-	act = 	register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency8192"), X_("8192"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 8192));
-	jack_sensitive_actions.push_back (act);
+	act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency32"), X_("32"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 32));
+	ActionManager::jack_sensitive_actions.push_back (act);
+	act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency64"), X_("64"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 64));
+	ActionManager::jack_sensitive_actions.push_back (act);
+	act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency128"), X_("128"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 128));
+	ActionManager::jack_sensitive_actions.push_back (act);
+	act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency256"), X_("256"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 256));
+	ActionManager::jack_sensitive_actions.push_back (act);
+	act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency512"), X_("512"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 512));
+	ActionManager::jack_sensitive_actions.push_back (act);
+	act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency1024"), X_("1024"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 1024));
+	ActionManager::jack_sensitive_actions.push_back (act);
+	act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency2048"), X_("2048"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 2048));
+	ActionManager::jack_sensitive_actions.push_back (act);
+	act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency4096"), X_("4096"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 4096));
+	ActionManager::jack_sensitive_actions.push_back (act);
+	act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency8192"), X_("8192"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 8192));
+	ActionManager::jack_sensitive_actions.push_back (act);
 	
 	/* these actions are intended to be shared across all windows */
 	
 	common_actions = ActionGroup::create (X_("Common"));
 
-	register_action (common_actions, X_("Start-Prefix"), _("start prefix"), mem_fun(*this, &ARDOUR_UI::start_keyboard_prefix));
-	register_action (common_actions, X_("Quit"), _("quit"), (mem_fun(*this, &ARDOUR_UI::finish)));
+	ActionManager::register_action (common_actions, X_("Start-Prefix"), _("start prefix"), mem_fun(*this, &ARDOUR_UI::start_keyboard_prefix));
+	ActionManager::register_action (common_actions, X_("Quit"), _("quit"), (mem_fun(*this, &ARDOUR_UI::finish)));
 
         /* windows visibility actions */
 
-	register_action (common_actions, X_("GotoEditor"), _("Editor"),  mem_fun(*this, &ARDOUR_UI::goto_editor_window));
-	register_action (common_actions, X_("GotoMixer"), _("Mixer"),  mem_fun(*this, &ARDOUR_UI::goto_mixer_window));
-	register_toggle_action (common_actions, X_("ToggleSoundFileBrowser"), _("Sound File Browser"), mem_fun(*this, &ARDOUR_UI::toggle_sound_file_browser));
-	register_toggle_action (common_actions, X_("ToggleOptionsEditor"), _("Options Editor"), mem_fun(*this, &ARDOUR_UI::toggle_options_window));
-	register_toggle_action (common_actions, X_("ToggleAudioLibrary"), _("Audio Library"), mem_fun(*this, &ARDOUR_UI::toggle_sound_file_browser));
-	act = register_toggle_action (common_actions, X_("ToggleInspector"), _("Track/Bus Inspector"), mem_fun(*this, &ARDOUR_UI::toggle_route_params_window));
-	session_sensitive_actions.push_back (act);
-	act = register_toggle_action (common_actions, X_("ToggleConnections"), _("Connections"), mem_fun(*this, &ARDOUR_UI::toggle_connection_editor));
-	session_sensitive_actions.push_back (act);
-	act = register_toggle_action (common_actions, X_("ToggleLocations"), _("Locations"), mem_fun(*this, &ARDOUR_UI::toggle_location_window));
-	session_sensitive_actions.push_back (act);
-	act = register_toggle_action (common_actions, X_("ToggleBigClock"), _("Big Clock"), mem_fun(*this, &ARDOUR_UI::toggle_big_clock_window));
-	session_sensitive_actions.push_back (act);
-	register_action (common_actions, X_("About"), _("About"),  mem_fun(*this, &ARDOUR_UI::show_splash));
+	ActionManager::register_action (common_actions, X_("GotoEditor"), _("Editor"),  mem_fun(*this, &ARDOUR_UI::goto_editor_window));
+	ActionManager::register_action (common_actions, X_("GotoMixer"), _("Mixer"),  mem_fun(*this, &ARDOUR_UI::goto_mixer_window));
+	ActionManager::register_toggle_action (common_actions, X_("ToggleSoundFileBrowser"), _("Sound File Browser"), mem_fun(*this, &ARDOUR_UI::toggle_sound_file_browser));
+	ActionManager::ActionManager::register_toggle_action (common_actions, X_("ToggleOptionsEditor"), _("Options Editor"), mem_fun(*this, &ARDOUR_UI::toggle_options_window));
+	ActionManager::register_toggle_action (common_actions, X_("ToggleAudioLibrary"), _("Audio Library"), mem_fun(*this, &ARDOUR_UI::toggle_sound_file_browser));
+	act = ActionManager::register_toggle_action (common_actions, X_("ToggleInspector"), _("Track/Bus Inspector"), mem_fun(*this, &ARDOUR_UI::toggle_route_params_window));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_toggle_action (common_actions, X_("ToggleConnections"), _("Connections"), mem_fun(*this, &ARDOUR_UI::toggle_connection_editor));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_toggle_action (common_actions, X_("ToggleLocations"), _("Locations"), mem_fun(*this, &ARDOUR_UI::toggle_location_window));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_toggle_action (common_actions, X_("ToggleBigClock"), _("Big Clock"), mem_fun(*this, &ARDOUR_UI::toggle_big_clock_window));
+	ActionManager::session_sensitive_actions.push_back (act);
+	ActionManager::register_action (common_actions, X_("About"), _("About"),  mem_fun(*this, &ARDOUR_UI::show_splash));
 	
-	act = register_action (common_actions, X_("ToggleAutoLoop"), _("toggle auto loop"), mem_fun(*this, &ARDOUR_UI::toggle_session_auto_loop));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("TogglePunchIn"), _("toggle punch in"), mem_fun(*this, &ARDOUR_UI::toggle_session_punch_in));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("NewSession"), _("new session"), bind (mem_fun(*this, &ARDOUR_UI::new_session), false, string()));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("AddAudioTrack"), _("add audio track"), bind (mem_fun(*this, &ARDOUR_UI::session_add_audio_track), 1, 1));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("AddAudioBus"), _("add audio bus"), bind (mem_fun(*this, &ARDOUR_UI::session_add_audio_bus), 1, 1));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("Save"), _("Save"),  bind (mem_fun(*this, &ARDOUR_UI::save_state), string("")));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("RemoveLastCapture"), _("remove last capture"), mem_fun(*this, &ARDOUR_UI::remove_last_capture));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("TransportStop"), _("transport stop"), mem_fun(*this, &ARDOUR_UI::transport_stop));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("TransportStopAndForgetCapture"), _("transport stop and forget capture"), mem_fun(*this, &ARDOUR_UI::transport_stop_and_forget_capture));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("TransportRoll"), _("transport roll"), mem_fun(*this, &ARDOUR_UI::transport_roll));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("TransportLoop"), _("transport loop"), mem_fun(*this, &ARDOUR_UI::transport_loop));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("TransportRecord"), _("transport record"), mem_fun(*this, &ARDOUR_UI::transport_record));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("TransportRewind"), _("transport rewind"), bind (mem_fun(*this, &ARDOUR_UI::transport_rewind), 0));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("TransportRewindSlow"), _("transport rewind slow"), bind (mem_fun(*this, &ARDOUR_UI::transport_rewind), -1));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("TransportRewindFast"), _("transport rewind fast"), bind (mem_fun(*this, &ARDOUR_UI::transport_rewind), 1));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("TransportForward"), _("transport forward"), bind (mem_fun(*this, &ARDOUR_UI::transport_forward), 0));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("TransportForwardSlow"), _("transport forward slow"), bind (mem_fun(*this, &ARDOUR_UI::transport_forward), -1));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("TransportForwardFast"), _("transport forward fast"), bind (mem_fun(*this, &ARDOUR_UI::transport_forward), 1));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("TransportGotoStart"), _("transport goto start"), mem_fun(*this, &ARDOUR_UI::transport_goto_start));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("TransportGotoEnd"), _("transport goto end"), mem_fun(*this, &ARDOUR_UI::transport_goto_end));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("SendAllMidiFeedback"), _("send all midi feedback"), mem_fun(*this, &ARDOUR_UI::send_all_midi_feedback));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack1"), _("toggle record enable track1"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  0U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack2"), _("toggle record enable track2"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  1U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack3"), _("toggle record enable track3"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  2U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack4"), _("toggle record enable track4"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  3U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack5"), _("toggle record enable track5"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  4U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack6"), _("toggle record enable track6"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  5U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack7"), _("toggle record enable track7"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  6U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack8"), _("toggle record enable track8"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  7U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack9"), _("toggle record enable track9"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  8U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack10"), _("toggle record enable track10"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 9U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack11"), _("toggle record enable track11"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 10U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack12"), _("toggle record enable track12"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 11U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack13"), _("toggle record enable track13"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 12U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack14"), _("toggle record enable track14"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 13U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack15"), _("toggle record enable track15"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 14U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack16"), _("toggle record enable track16"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 15U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack17"), _("toggle record enable track17"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 16U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack18"), _("toggle record enable track18"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 17U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack19"), _("toggle record enable track19"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 18U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack20"), _("toggle record enable track20"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 19U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack21"), _("toggle record enable track21"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 20U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack22"), _("toggle record enable track22"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 21U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack23"), _("toggle record enable track23"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 22U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack24"), _("toggle record enable track24"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 23U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack25"), _("toggle record enable track25"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 24U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack26"), _("toggle record enable track26"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 25U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack27"), _("toggle record enable track27"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 26U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack28"), _("toggle record enable track28"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 27U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack29"), _("toggle record enable track29"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 28U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack30"), _("toggle record enable track30"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 29U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack31"), _("toggle record enable track31"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 30U));
-	session_sensitive_actions.push_back (act);
-	act = register_action (common_actions, X_("ToggleRecordEnableTrack32"), _("toggle record enable track32"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 31U));
-	session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleAutoLoop"), _("toggle auto loop"), mem_fun(*this, &ARDOUR_UI::toggle_session_auto_loop));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("TogglePunchIn"), _("toggle punch in"), mem_fun(*this, &ARDOUR_UI::toggle_session_punch_in));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("NewSession"), _("new session"), bind (mem_fun(*this, &ARDOUR_UI::new_session), false, string()));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("AddAudioTrack"), _("add audio track"), bind (mem_fun(*this, &ARDOUR_UI::session_add_audio_track), 1, 1));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("AddAudioBus"), _("add audio bus"), bind (mem_fun(*this, &ARDOUR_UI::session_add_audio_bus), 1, 1));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("Save"), _("Save"),  bind (mem_fun(*this, &ARDOUR_UI::save_state), string("")));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("RemoveLastCapture"), _("remove last capture"), mem_fun(*this, &ARDOUR_UI::remove_last_capture));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("TransportStop"), _("transport stop"), mem_fun(*this, &ARDOUR_UI::transport_stop));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("TransportStopAndForgetCapture"), _("transport stop and forget capture"), mem_fun(*this, &ARDOUR_UI::transport_stop_and_forget_capture));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("TransportRoll"), _("transport roll"), mem_fun(*this, &ARDOUR_UI::transport_roll));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("TransportLoop"), _("transport loop"), mem_fun(*this, &ARDOUR_UI::transport_loop));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("TransportRecord"), _("transport record"), mem_fun(*this, &ARDOUR_UI::transport_record));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("TransportRewind"), _("transport rewind"), bind (mem_fun(*this, &ARDOUR_UI::transport_rewind), 0));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("TransportRewindSlow"), _("transport rewind slow"), bind (mem_fun(*this, &ARDOUR_UI::transport_rewind), -1));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("TransportRewindFast"), _("transport rewind fast"), bind (mem_fun(*this, &ARDOUR_UI::transport_rewind), 1));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("TransportForward"), _("transport forward"), bind (mem_fun(*this, &ARDOUR_UI::transport_forward), 0));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("TransportForwardSlow"), _("transport forward slow"), bind (mem_fun(*this, &ARDOUR_UI::transport_forward), -1));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("TransportForwardFast"), _("transport forward fast"), bind (mem_fun(*this, &ARDOUR_UI::transport_forward), 1));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("TransportGotoStart"), _("transport goto start"), mem_fun(*this, &ARDOUR_UI::transport_goto_start));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("TransportGotoEnd"), _("transport goto end"), mem_fun(*this, &ARDOUR_UI::transport_goto_end));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("SendAllMidiFeedback"), _("send all midi feedback"), mem_fun(*this, &ARDOUR_UI::send_all_midi_feedback));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack1"), _("toggle record enable track1"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  0U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack2"), _("toggle record enable track2"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  1U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack3"), _("toggle record enable track3"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  2U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack4"), _("toggle record enable track4"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  3U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack5"), _("toggle record enable track5"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  4U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack6"), _("toggle record enable track6"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  5U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack7"), _("toggle record enable track7"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  6U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack8"), _("toggle record enable track8"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  7U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack9"), _("toggle record enable track9"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  8U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack10"), _("toggle record enable track10"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 9U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack11"), _("toggle record enable track11"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 10U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack12"), _("toggle record enable track12"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 11U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack13"), _("toggle record enable track13"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 12U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack14"), _("toggle record enable track14"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 13U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack15"), _("toggle record enable track15"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 14U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack16"), _("toggle record enable track16"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 15U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack17"), _("toggle record enable track17"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 16U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack18"), _("toggle record enable track18"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 17U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack19"), _("toggle record enable track19"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 18U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack20"), _("toggle record enable track20"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 19U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack21"), _("toggle record enable track21"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 20U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack22"), _("toggle record enable track22"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 21U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack23"), _("toggle record enable track23"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 22U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack24"), _("toggle record enable track24"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 23U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack25"), _("toggle record enable track25"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 24U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack26"), _("toggle record enable track26"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 25U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack27"), _("toggle record enable track27"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 26U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack28"), _("toggle record enable track28"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 27U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack29"), _("toggle record enable track29"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 28U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack30"), _("toggle record enable track30"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 29U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack31"), _("toggle record enable track31"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 30U));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack32"), _("toggle record enable track32"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 31U));
+	ActionManager::session_sensitive_actions.push_back (act);
 	
-	ui_manager->insert_action_group (jack_actions);
-	ui_manager->insert_action_group (main_actions);
-	ui_manager->insert_action_group (common_actions);
-
-	register_ui_manager (ui_manager);
+	ActionManager::add_action_group (jack_actions);
+	ActionManager::add_action_group (main_actions);
+	ActionManager::add_action_group (common_actions);
 }
 
 void
diff --git a/gtk2_ardour/audio_clock.cc b/gtk2_ardour/audio_clock.cc
index 217ec690ac..83d8f6644c 100644
--- a/gtk2_ardour/audio_clock.cc
+++ b/gtk2_ardour/audio_clock.cc
@@ -696,8 +696,6 @@ AudioClock::field_key_release_event (GdkEventKey *ev, Field field)
 gint
 AudioClock::field_focus_in_event (GdkEventFocus *ev, Field field)
 {
-	ARDOUR_UI::instance()->allow_focus (true);
-
 	key_entry_state = 0;
 
 	switch (field) {
@@ -755,8 +753,6 @@ AudioClock::field_focus_in_event (GdkEventFocus *ev, Field field)
 gint
 AudioClock::field_focus_out_event (GdkEventFocus *ev, Field field)
 {
-	ARDOUR_UI::instance()->allow_focus (false);
-
 	switch (field) {
 
 	case SMPTE_Hours:
@@ -1657,9 +1653,8 @@ AudioClock::set_mode (Mode m)
 	   started editing the clock and then we switch clock mode.
 	*/
 
-	if (ARDOUR_UI::instance()) {
-		ARDOUR_UI::instance()->allow_focus (false);
-	}
+	// GTK2FIX might need an equivalent here for drop focus
+
 
 	if (_mode == m) {
 		return;
diff --git a/gtk2_ardour/audio_time_axis.cc b/gtk2_ardour/audio_time_axis.cc
index 4e77ae1f74..1c25863e23 100644
--- a/gtk2_ardour/audio_time_axis.cc
+++ b/gtk2_ardour/audio_time_axis.cc
@@ -169,7 +169,6 @@ AudioTimeAxisView::AudioTimeAxisView (PublicEditor& ed, Session& sess, Route& rt
 	hide_button.signal_clicked().connect (mem_fun(*this, &AudioTimeAxisView::hide_click));
 
 	name_entry.signal_activate().connect (mem_fun(*this, &AudioTimeAxisView::name_entry_activated));
-	name_entry.signal_focus_out_event().connect (mem_fun(*this, &AudioTimeAxisView::name_entry_focus_out_handler));
 	name_entry.signal_button_press_event().connect (mem_fun(*this, &AudioTimeAxisView::name_entry_button_press_handler));
 	name_entry.signal_button_release_event().connect (mem_fun(*this, &AudioTimeAxisView::name_entry_button_release_handler));
 	name_entry.signal_key_release_event().connect (mem_fun(*this, &AudioTimeAxisView::name_entry_key_release_handler));
@@ -1109,13 +1108,6 @@ AudioTimeAxisView::name_entry_button_release_handler (GdkEventButton *ev)
 }
 
 gint
-AudioTimeAxisView::name_entry_focus_out_handler (GdkEventFocus* ev)
-{
-	name_entry_changed ();
-	return TRUE;
-}
-
-gint
 AudioTimeAxisView::name_entry_key_release_handler (GdkEventKey* ev)
 {
 	switch (ev->keyval) {
@@ -1144,8 +1136,6 @@ AudioTimeAxisView::name_entry_changed ()
 {
 	string x;
 
-	ARDOUR_UI::generic_focus_out_event (0);
-
 	x = name_entry.get_text ();
 	
 	if (x == _route.name()) {
diff --git a/gtk2_ardour/audio_time_axis.h b/gtk2_ardour/audio_time_axis.h
index ca8aabf305..c9a0e69ce5 100644
--- a/gtk2_ardour/audio_time_axis.h
+++ b/gtk2_ardour/audio_time_axis.h
@@ -173,7 +173,6 @@ class AudioTimeAxisView : public RouteUI, public TimeAxisView
 	void route_name_changed (void *);
 	void name_entry_activated ();
 	void name_entry_changed ();
-	gint name_entry_focus_out_handler (GdkEventFocus*);
 	gint name_entry_key_release_handler (GdkEventKey*);
 	gint name_entry_button_release_handler (GdkEventButton*);
 	gint name_entry_button_press_handler (GdkEventButton*);
diff --git a/gtk2_ardour/default_keys.cc b/gtk2_ardour/default_keys.cc
index a15e12cfae..5209a4e277 100644
--- a/gtk2_ardour/default_keys.cc
+++ b/gtk2_ardour/default_keys.cc
@@ -32,80 +32,4 @@ using namespace sigc;
 void
 ARDOUR_UI::install_keybindings ()
 {
-	register_action (shared_actions, "start-prefix", _("start-prefix"), mem_fun(*this, &ARDOUR_UI::start_keyboard_prefix));
-
-	register_action (shared_actions, "toggle-editor-window", _("toggle-editor-window"), mem_fun(*this, &ARDOUR_UI::goto_editor_window));
-	register_action (shared_actions, "toggle-mixer-window", _("toggle-mixer-window"), mem_fun(*this, &ARDOUR_UI::goto_mixer_window));
-	register_action (shared_actions, "toggle-locations-window", _("toggle-locations-window"), mem_fun(*this, &ARDOUR_UI::toggle_location_window));
-	register_action (shared_actions, "toggle-big-clock-window", _("toggle-big-clock-window"), mem_fun(*this, &ARDOUR_UI::toggle_big_clock_window));
-	register_action (shared_actions, "toggle-options-window", _("toggle-options-window"), mem_fun(*this, &ARDOUR_UI::toggle_options_window));
-	register_action (shared_actions, "toggle-auto-loop", _("toggle-auto-loop"), mem_fun(*this, &ARDOUR_UI::toggle_session_auto_loop));
-	register_action (shared_actions, "toggle-punch-in", _("toggle-punch-in"), mem_fun(*this, &ARDOUR_UI::toggle_session_punch_in));
-
-	register_action (shared_actions, "new-session", _("new-session"), bind (mem_fun(*this, &ARDOUR_UI::new_session), false, string()));
-	register_action (shared_actions, "add-audio-track", _("add-audio-track"), bind (mem_fun(*this, &ARDOUR_UI::session_add_audio_track), 1, 1));
-	register_action (shared_actions, "add-audio-bus", _("add-audio-bus"), bind (mem_fun(*this, &ARDOUR_UI::session_add_audio_bus), 1, 1));
-
-	register_action (shared_actions, "save-state", _("save-state"), bind (mem_fun(*this, &ARDOUR_UI::save_state), string ("")));
-	register_action (shared_actions, "quit", _("quit"), (mem_fun(*this, &ARDOUR_UI::finish)));
-	register_action (shared_actions, "remove-last-capture", _("remove-last-capture"), mem_fun(*this, &ARDOUR_UI::remove_last_capture));
-
-	register_action (shared_actions, "transport-stop", _("transport-stop"), mem_fun(*this, &ARDOUR_UI::transport_stop));
-	register_action (shared_actions, "transport-stop-and-forget-capture", _("transport-stop-and-forget-capture"), mem_fun(*this, &ARDOUR_UI::transport_stop_and_forget_capture));
-	register_action (shared_actions, "transport-roll", _("transport-roll"), mem_fun(*this, &ARDOUR_UI::transport_roll));
-	register_action (shared_actions, "transport-loop", _("transport-loop"), mem_fun(*this, &ARDOUR_UI::transport_loop));
-	register_action (shared_actions, "transport-record", _("transport-record"), mem_fun(*this, &ARDOUR_UI::transport_record));
-	register_action (shared_actions, "transport-rewind", _("transport-rewind"), bind (mem_fun(*this, &ARDOUR_UI::transport_rewind), 0));
-	register_action (shared_actions, "transport-rewind-slow", _("transport-rewind-slow"), bind (mem_fun(*this, &ARDOUR_UI::transport_rewind), -1));
-	register_action (shared_actions, "transport-rewind-fast", _("transport-rewind-fast"), bind (mem_fun(*this, &ARDOUR_UI::transport_rewind), 1));
-	register_action (shared_actions, "transport-forward", _("transport-forward"), bind (mem_fun(*this, &ARDOUR_UI::transport_forward), 0));
-	register_action (shared_actions, "transport-forward-slow", _("transport-forward-slow"), bind (mem_fun(*this, &ARDOUR_UI::transport_forward), -1));
-	register_action (shared_actions, "transport-forward-fast", _("transport-forward-fast"), bind (mem_fun(*this, &ARDOUR_UI::transport_forward), 1));
-
-	register_action (shared_actions, "transport-goto-start", _("transport-goto-start"), mem_fun(*this, &ARDOUR_UI::transport_goto_start));
-	register_action (shared_actions, "transport-goto-end", _("transport-goto-end"), mem_fun(*this, &ARDOUR_UI::transport_goto_end));
-
-	register_action (shared_actions, "send-all-midi-feedback", _("send-all-midi-feedback"), mem_fun(*this, &ARDOUR_UI::send_all_midi_feedback));
-	
-	register_action (shared_actions, "toggle-record-enable-track1", _("toggle-record-enable-track1"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  0U));
-	register_action (shared_actions, "toggle-record-enable-track2", _("toggle-record-enable-track2"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  1U));
-	register_action (shared_actions, "toggle-record-enable-track3", _("toggle-record-enable-track3"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  2U));
-	register_action (shared_actions, "toggle-record-enable-track4", _("toggle-record-enable-track4"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  3U));
-	register_action (shared_actions, "toggle-record-enable-track5", _("toggle-record-enable-track5"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  4U));
-	register_action (shared_actions, "toggle-record-enable-track6", _("toggle-record-enable-track6"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  5U));
-	register_action (shared_actions, "toggle-record-enable-track7", _("toggle-record-enable-track7"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  6U));
-	register_action (shared_actions, "toggle-record-enable-track8", _("toggle-record-enable-track8"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  7U));
-	register_action (shared_actions, "toggle-record-enable-track9", _("toggle-record-enable-track9"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  8U));
-	register_action (shared_actions, "toggle-record-enable-track10", _("toggle-record-enable-track10"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 9U));
-	register_action (shared_actions, "toggle-record-enable-track11", _("toggle-record-enable-track11"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 10U));
-	register_action (shared_actions, "toggle-record-enable-track12", _("toggle-record-enable-track12"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 11U));
-	register_action (shared_actions, "toggle-record-enable-track13", _("toggle-record-enable-track13"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 12U));
-	register_action (shared_actions, "toggle-record-enable-track14", _("toggle-record-enable-track14"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 13U));
-	register_action (shared_actions, "toggle-record-enable-track15", _("toggle-record-enable-track15"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 14U));
-	register_action (shared_actions, "toggle-record-enable-track16", _("toggle-record-enable-track16"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 15U));
-	register_action (shared_actions, "toggle-record-enable-track17", _("toggle-record-enable-track17"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 16U));
-	register_action (shared_actions, "toggle-record-enable-track18", _("toggle-record-enable-track18"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 17U));
-	register_action (shared_actions, "toggle-record-enable-track19", _("toggle-record-enable-track19"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 18U));
-	register_action (shared_actions, "toggle-record-enable-track20", _("toggle-record-enable-track20"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 19U));
-	register_action (shared_actions, "toggle-record-enable-track21", _("toggle-record-enable-track21"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 20U));
-	register_action (shared_actions, "toggle-record-enable-track22", _("toggle-record-enable-track22"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 21U));
-	register_action (shared_actions, "toggle-record-enable-track23", _("toggle-record-enable-track23"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 22U));
-	register_action (shared_actions, "toggle-record-enable-track24", _("toggle-record-enable-track24"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 23U));
-	register_action (shared_actions, "toggle-record-enable-track25", _("toggle-record-enable-track25"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 24U));
-	register_action (shared_actions, "toggle-record-enable-track26", _("toggle-record-enable-track26"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 25U));
-	register_action (shared_actions, "toggle-record-enable-track27", _("toggle-record-enable-track27"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 26U));
-	register_action (shared_actions, "toggle-record-enable-track28", _("toggle-record-enable-track28"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 27U));
-	register_action (shared_actions, "toggle-record-enable-track29", _("toggle-record-enable-track29"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 28U));
-	register_action (shared_actions, "toggle-record-enable-track30", _("toggle-record-enable-track30"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 29U));
-	register_action (shared_actions, "toggle-record-enable-track31", _("toggle-record-enable-track31"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 30U));
-	register_action (shared_actions, "toggle-record-enable-track32", _("toggle-record-enable-track32"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 31U));
-	
-#if 0
-	ADD ME TO ARDOUR RC SOMEDAY
-	add_binding ("Shift-F1",, bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 0+12U));
-	add_binding ("Control-F1",, bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 0+24U));
-	add_binding ("Alt-F1",, bind (mem_fun(*this, &ARDOUR_UI::toggle_monitor_enable), 0U));
-	add_binding ("Alt-Shift-F1",, bind (mem_fun(*this, &ARDOUR_UI::toggle_monitor_enable), 0+12U));
-	add_binding ("Alt-Control-F1",, bind (mem_fun(*this, &ARDOUR_UI::toggle_monitor_enable), 0+24U));
-#endif
 }
diff --git a/gtk2_ardour/editor.cc b/gtk2_ardour/editor.cc
index cfbb6ddd4d..b1307e3989 100644
--- a/gtk2_ardour/editor.cc
+++ b/gtk2_ardour/editor.cc
@@ -706,8 +706,6 @@ Editor::Editor (AudioEngine& eng)
 
 	fade_context_menu.set_name ("ArdourContextMenu");
 
-	install_keybindings ();
-
 	set_title (_("ardour: editor"));
 	set_wmclass (_("ardour_editor"), "Ardour");
 
@@ -3813,9 +3811,6 @@ Editor::duplicate_dialog (bool dup_region)
 	entry.signal_activate().connect (bind (mem_fun (win, &ArdourDialog::stop), 0));
 	cancel_button.signal_clicked().connect (bind (mem_fun (win, &ArdourDialog::stop), 1));
 
-	entry.signal_focus_in_event().connect (sigc::ptr_fun (ARDOUR_UI::generic_focus_in_event));
-	entry.signal_focus_out_event().connect (sigc::ptr_fun (ARDOUR_UI::generic_focus_out_event));
-	
 	entry.set_text ("1");
 	set_size_request_to_display_given_text (entry, X_("12345678"), 20, 15);
 	entry.select_region (0, entry.get_text_length());
@@ -4069,7 +4064,6 @@ Editor::point_selection_changed ()
 void
 Editor::run_sub_event_loop ()
 {
-	Keyboard::the_keyboard().allow_focus (true);
 	sub_event_loop_status = 0;
 	Main::run ();
 }
@@ -4078,7 +4072,6 @@ void
 Editor::finish_sub_event_loop (int status)
 {
 	Main::quit ();
-	Keyboard::the_keyboard().allow_focus (false);
 	sub_event_loop_status = status;
 }
 
diff --git a/gtk2_ardour/editor_actions.cc b/gtk2_ardour/editor_actions.cc
index 13b4769111..d9b337853e 100644
--- a/gtk2_ardour/editor_actions.cc
+++ b/gtk2_ardour/editor_actions.cc
@@ -12,7 +12,6 @@ using namespace std;
 using namespace sigc;
 using namespace ARDOUR;
 using namespace Editing;
-using namespace ActionManager;
 
 void
 Editor::register_actions ()
@@ -20,153 +19,149 @@ Editor::register_actions ()
 
 	Glib::RefPtr<ActionGroup> editor_actions = ActionGroup::create (X_("Editor"));
 
-	/* start with actions shared between all top level (major) windows */
-
-	merge_actions (editor_actions, ARDOUR_UI::instance()::get_common_actions());
-
 	/* add named actions for the editor */
 
-	register_action (editor_actions, "toggle-xfades-active", _("toggle xfades active"), mem_fun(*this, &Editor::toggle_xfades_active));
+	ActionManager::register_action (editor_actions, "toggle-xfades-active", _("toggle xfades active"), mem_fun(*this, &Editor::toggle_xfades_active));
 
-	register_action (editor_actions, "playhead-to-next-region-start", _("playhead to next region start"), bind (mem_fun(*this, &Editor::cursor_to_next_region_point), playhead_cursor, RegionPoint (Start)));
-	register_action (editor_actions, "playhead-to-next-region-end", _("playhead to next region end"), bind (mem_fun(*this, &Editor::cursor_to_next_region_point), playhead_cursor, RegionPoint (End)));
-	register_action (editor_actions, "playhead-to-next-region-sync", _("playhead to next region sync"), bind (mem_fun(*this, &Editor::cursor_to_next_region_point), playhead_cursor, RegionPoint (SyncPoint)));
+	ActionManager::register_action (editor_actions, "playhead-to-next-region-start", _("playhead to next region start"), bind (mem_fun(*this, &Editor::cursor_to_next_region_point), playhead_cursor, RegionPoint (Start)));
+	ActionManager::register_action (editor_actions, "playhead-to-next-region-end", _("playhead to next region end"), bind (mem_fun(*this, &Editor::cursor_to_next_region_point), playhead_cursor, RegionPoint (End)));
+	ActionManager::register_action (editor_actions, "playhead-to-next-region-sync", _("playhead to next region sync"), bind (mem_fun(*this, &Editor::cursor_to_next_region_point), playhead_cursor, RegionPoint (SyncPoint)));
 
-	register_action (editor_actions, "playhead-to-previous-region-start", _("playhead to previous region start"), bind (mem_fun(*this, &Editor::cursor_to_previous_region_point), playhead_cursor, RegionPoint (Start)));
-	register_action (editor_actions, "playhead-to-previous-region-end", _("playhead to previous region end"), bind (mem_fun(*this, &Editor::cursor_to_previous_region_point), playhead_cursor, RegionPoint (End)));
-	register_action (editor_actions, "playhead-to-previous-region-sync", _("playhead to previous region sync"), bind (mem_fun(*this, &Editor::cursor_to_previous_region_point), playhead_cursor, RegionPoint (SyncPoint)));
+	ActionManager::register_action (editor_actions, "playhead-to-previous-region-start", _("playhead to previous region start"), bind (mem_fun(*this, &Editor::cursor_to_previous_region_point), playhead_cursor, RegionPoint (Start)));
+	ActionManager::register_action (editor_actions, "playhead-to-previous-region-end", _("playhead to previous region end"), bind (mem_fun(*this, &Editor::cursor_to_previous_region_point), playhead_cursor, RegionPoint (End)));
+	ActionManager::register_action (editor_actions, "playhead-to-previous-region-sync", _("playhead to previous region sync"), bind (mem_fun(*this, &Editor::cursor_to_previous_region_point), playhead_cursor, RegionPoint (SyncPoint)));
 
-	register_action (editor_actions, "edit-cursor-to-next-region-start", _("edit cursor to next region start"), bind (mem_fun(*this, &Editor::cursor_to_next_region_point), edit_cursor, RegionPoint (Start)));
-	register_action (editor_actions, "edit-cursor-to-next-region-end", _("edit cursor to next region end"), bind (mem_fun(*this, &Editor::cursor_to_next_region_point), edit_cursor, RegionPoint (End)));
-	register_action (editor_actions, "edit-cursor-to-next-region-sync", _("edit cursor to next region sync"), bind (mem_fun(*this, &Editor::cursor_to_next_region_point), edit_cursor, RegionPoint (SyncPoint)));
+	ActionManager::register_action (editor_actions, "edit-cursor-to-next-region-start", _("edit cursor to next region start"), bind (mem_fun(*this, &Editor::cursor_to_next_region_point), edit_cursor, RegionPoint (Start)));
+	ActionManager::register_action (editor_actions, "edit-cursor-to-next-region-end", _("edit cursor to next region end"), bind (mem_fun(*this, &Editor::cursor_to_next_region_point), edit_cursor, RegionPoint (End)));
+	ActionManager::register_action (editor_actions, "edit-cursor-to-next-region-sync", _("edit cursor to next region sync"), bind (mem_fun(*this, &Editor::cursor_to_next_region_point), edit_cursor, RegionPoint (SyncPoint)));
 
-	register_action (editor_actions, "edit-cursor-to-previous-region-start", _("edit cursor to previous region start"), bind (mem_fun(*this, &Editor::cursor_to_previous_region_point), edit_cursor, RegionPoint (Start)));
-	register_action (editor_actions, "edit-cursor-to-previous-region-end", _("edit cursor to previous region end"), bind (mem_fun(*this, &Editor::cursor_to_previous_region_point), edit_cursor, RegionPoint (End)));
-	register_action (editor_actions, "edit-cursor-to-previous-region-sync", _("edit cursor to previous region sync"), bind (mem_fun(*this, &Editor::cursor_to_previous_region_point), edit_cursor, RegionPoint (SyncPoint)));
+	ActionManager::register_action (editor_actions, "edit-cursor-to-previous-region-start", _("edit cursor to previous region start"), bind (mem_fun(*this, &Editor::cursor_to_previous_region_point), edit_cursor, RegionPoint (Start)));
+	ActionManager::register_action (editor_actions, "edit-cursor-to-previous-region-end", _("edit cursor to previous region end"), bind (mem_fun(*this, &Editor::cursor_to_previous_region_point), edit_cursor, RegionPoint (End)));
+	ActionManager::register_action (editor_actions, "edit-cursor-to-previous-region-sync", _("edit cursor to previous region sync"), bind (mem_fun(*this, &Editor::cursor_to_previous_region_point), edit_cursor, RegionPoint (SyncPoint)));
 
-	register_action (editor_actions, "playhead-to-range-start", _("playhead to range start"), bind (mem_fun(*this, &Editor::cursor_to_selection_start), playhead_cursor));
-	register_action (editor_actions, "playhead-to-range-end", _("playhead to range end"), bind (mem_fun(*this, &Editor::cursor_to_selection_end), playhead_cursor));
+	ActionManager::register_action (editor_actions, "playhead-to-range-start", _("playhead to range start"), bind (mem_fun(*this, &Editor::cursor_to_selection_start), playhead_cursor));
+	ActionManager::register_action (editor_actions, "playhead-to-range-end", _("playhead to range end"), bind (mem_fun(*this, &Editor::cursor_to_selection_end), playhead_cursor));
 
-	register_action (editor_actions, "edit-cursor-to-range-start", _("edit cursor to range start"), bind (mem_fun(*this, &Editor::cursor_to_selection_start), edit_cursor));
-	register_action (editor_actions, "edit-cursor-to-range-end", _("edit cursor to range end"), bind (mem_fun(*this, &Editor::cursor_to_selection_end), edit_cursor));
+	ActionManager::register_action (editor_actions, "edit-cursor-to-range-start", _("edit cursor to range start"), bind (mem_fun(*this, &Editor::cursor_to_selection_start), edit_cursor));
+	ActionManager::register_action (editor_actions, "edit-cursor-to-range-end", _("edit cursor to range end"), bind (mem_fun(*this, &Editor::cursor_to_selection_end), edit_cursor));
 
-	register_action (editor_actions, "jump-forward-to-mark", _("jump forward to mark"), mem_fun(*this, &Editor::jump_forward_to_mark));
-	register_action (editor_actions, "jump-backward-to-mark", _("jump backward to mark"), mem_fun(*this, &Editor::jump_backward_to_mark));
-	register_action (editor_actions, "add-location-from-playhead", _("add location from playhead"), mem_fun(*this, &Editor::add_location_from_playhead_cursor));
+	ActionManager::register_action (editor_actions, "jump-forward-to-mark", _("jump forward to mark"), mem_fun(*this, &Editor::jump_forward_to_mark));
+	ActionManager::register_action (editor_actions, "jump-backward-to-mark", _("jump backward to mark"), mem_fun(*this, &Editor::jump_backward_to_mark));
+	ActionManager::register_action (editor_actions, "add-location-from-playhead", _("add location from playhead"), mem_fun(*this, &Editor::add_location_from_playhead_cursor));
 
-	register_action (editor_actions, "nudge-forward", _("nudge forward"), bind (mem_fun(*this, &Editor::nudge_forward), false));
-	register_action (editor_actions, "nudge-next-forward", _("nudge next forward"), bind (mem_fun(*this, &Editor::nudge_forward), true));
-	register_action (editor_actions, "nudge-backward", _("nudge backward"), bind (mem_fun(*this, &Editor::nudge_backward), false));
-	register_action (editor_actions, "nudge-next-backward", _("nudge next backward"), bind (mem_fun(*this, &Editor::nudge_backward), true));
+	ActionManager::register_action (editor_actions, "nudge-forward", _("nudge forward"), bind (mem_fun(*this, &Editor::nudge_forward), false));
+	ActionManager::register_action (editor_actions, "nudge-next-forward", _("nudge next forward"), bind (mem_fun(*this, &Editor::nudge_forward), true));
+	ActionManager::register_action (editor_actions, "nudge-backward", _("nudge backward"), bind (mem_fun(*this, &Editor::nudge_backward), false));
+	ActionManager::register_action (editor_actions, "nudge-next-backward", _("nudge next backward"), bind (mem_fun(*this, &Editor::nudge_backward), true));
 
-	register_action (editor_actions, "toggle-playback", _("toggle playback"), bind (mem_fun(*this, &Editor::toggle_playback), false));
-	register_action (editor_actions, "toggle-playback-forget-capture", _("toggle playback forget capture"), bind (mem_fun(*this, &Editor::toggle_playback), true));
+	ActionManager::register_action (editor_actions, "toggle-playback", _("toggle playback"), bind (mem_fun(*this, &Editor::toggle_playback), false));
+	ActionManager::register_action (editor_actions, "toggle-playback-forget-capture", _("toggle playback forget capture"), bind (mem_fun(*this, &Editor::toggle_playback), true));
 
-	register_action (editor_actions, "toggle-loop-playback", _("toggle loop playback"), mem_fun(*this, &Editor::toggle_loop_playback));
+	ActionManager::register_action (editor_actions, "toggle-loop-playback", _("toggle loop playback"), mem_fun(*this, &Editor::toggle_loop_playback));
 	
-	register_action (editor_actions, "temporal-zoom-out", _("temporal zoom out"), bind (mem_fun(*this, &Editor::temporal_zoom_step), true));
-	register_action (editor_actions, "temporal-zoom-in", _("temporal zoom in"), bind (mem_fun(*this, &Editor::temporal_zoom_step), false));
-	register_action (editor_actions, "zoom-to-session", _("zoom to session"), mem_fun(*this, &Editor::temporal_zoom_session));
-
-	register_action (editor_actions, "scroll-tracks-up", _("scroll tracks up"), mem_fun(*this, &Editor::scroll_tracks_up));
-	register_action (editor_actions, "scroll-tracks-down", _("scroll tracks down"), mem_fun(*this, &Editor::scroll_tracks_down));
-	register_action (editor_actions, "step-tracks-up", _("step tracks up"), mem_fun(*this, &Editor::scroll_tracks_up_line));
-	register_action (editor_actions, "step-tracks-down", _("step tracks down"), mem_fun(*this, &Editor::scroll_tracks_down_line));
-
-	register_action (editor_actions, "scroll-backward", _("scroll backward"), bind (mem_fun(*this, &Editor::scroll_backward), 0.8f));
-	register_action (editor_actions, "scroll-forward", _("scroll forward"), bind (mem_fun(*this, &Editor::scroll_forward), 0.8f));
-	register_action (editor_actions, "goto", _("goto"), mem_fun(*this, &Editor::goto_frame));
-	register_action (editor_actions, "center-playhead", _("center playhead"), mem_fun(*this, &Editor::center_playhead));
-	register_action (editor_actions, "center-edit_cursor", _("center edit_cursor"), mem_fun(*this, &Editor::center_edit_cursor));
-	register_action (editor_actions, "playhead-forward", _("playhead forward"), mem_fun(*this, &Editor::playhead_forward));
-	register_action (editor_actions, "playhead-backward", _("playhead backward"), mem_fun(*this, &Editor::playhead_backward));
-	register_action (editor_actions, "playhead-to-edit", _("playhead to edit"), bind (mem_fun(*this, &Editor::cursor_align), true));
-	register_action (editor_actions, "edit-to-playhead", _("edit to playhead"), bind (mem_fun(*this, &Editor::cursor_align), false));
-
-	register_action (editor_actions, "align-regions-start", _("align regions start"), bind (mem_fun(*this, &Editor::align), ARDOUR::Start));
-	register_action (editor_actions, "align-regions-start-relative", _("align regions start relative"), bind (mem_fun(*this, &Editor::align_relative), ARDOUR::Start));
-	register_action (editor_actions, "align-regions-end", _("align regions end"), bind (mem_fun(*this, &Editor::align), ARDOUR::End));
-	register_action (editor_actions, "align-regions-end-relative", _("align regions end relative"), bind (mem_fun(*this, &Editor::align_relative), ARDOUR::End));
-	register_action (editor_actions, "align-regions-sync", _("align regions sync"), bind (mem_fun(*this, &Editor::align), ARDOUR::SyncPoint));
-	register_action (editor_actions, "align-regions-sync-relative", _("align regions sync relative"), bind (mem_fun(*this, &Editor::align_relative), ARDOUR::SyncPoint));
+	ActionManager::register_action (editor_actions, "temporal-zoom-out", _("temporal zoom out"), bind (mem_fun(*this, &Editor::temporal_zoom_step), true));
+	ActionManager::register_action (editor_actions, "temporal-zoom-in", _("temporal zoom in"), bind (mem_fun(*this, &Editor::temporal_zoom_step), false));
+	ActionManager::register_action (editor_actions, "zoom-to-session", _("zoom to session"), mem_fun(*this, &Editor::temporal_zoom_session));
+
+	ActionManager::register_action (editor_actions, "scroll-tracks-up", _("scroll tracks up"), mem_fun(*this, &Editor::scroll_tracks_up));
+	ActionManager::register_action (editor_actions, "scroll-tracks-down", _("scroll tracks down"), mem_fun(*this, &Editor::scroll_tracks_down));
+	ActionManager::register_action (editor_actions, "step-tracks-up", _("step tracks up"), mem_fun(*this, &Editor::scroll_tracks_up_line));
+	ActionManager::register_action (editor_actions, "step-tracks-down", _("step tracks down"), mem_fun(*this, &Editor::scroll_tracks_down_line));
+
+	ActionManager::register_action (editor_actions, "scroll-backward", _("scroll backward"), bind (mem_fun(*this, &Editor::scroll_backward), 0.8f));
+	ActionManager::register_action (editor_actions, "scroll-forward", _("scroll forward"), bind (mem_fun(*this, &Editor::scroll_forward), 0.8f));
+	ActionManager::register_action (editor_actions, "goto", _("goto"), mem_fun(*this, &Editor::goto_frame));
+	ActionManager::register_action (editor_actions, "center-playhead", _("center playhead"), mem_fun(*this, &Editor::center_playhead));
+	ActionManager::register_action (editor_actions, "center-edit_cursor", _("center edit_cursor"), mem_fun(*this, &Editor::center_edit_cursor));
+	ActionManager::register_action (editor_actions, "playhead-forward", _("playhead forward"), mem_fun(*this, &Editor::playhead_forward));
+	ActionManager::register_action (editor_actions, "playhead-backward", _("playhead backward"), mem_fun(*this, &Editor::playhead_backward));
+	ActionManager::register_action (editor_actions, "playhead-to-edit", _("playhead to edit"), bind (mem_fun(*this, &Editor::cursor_align), true));
+	ActionManager::register_action (editor_actions, "edit-to-playhead", _("edit to playhead"), bind (mem_fun(*this, &Editor::cursor_align), false));
+
+	ActionManager::register_action (editor_actions, "align-regions-start", _("align regions start"), bind (mem_fun(*this, &Editor::align), ARDOUR::Start));
+	ActionManager::register_action (editor_actions, "align-regions-start-relative", _("align regions start relative"), bind (mem_fun(*this, &Editor::align_relative), ARDOUR::Start));
+	ActionManager::register_action (editor_actions, "align-regions-end", _("align regions end"), bind (mem_fun(*this, &Editor::align), ARDOUR::End));
+	ActionManager::register_action (editor_actions, "align-regions-end-relative", _("align regions end relative"), bind (mem_fun(*this, &Editor::align_relative), ARDOUR::End));
+	ActionManager::register_action (editor_actions, "align-regions-sync", _("align regions sync"), bind (mem_fun(*this, &Editor::align), ARDOUR::SyncPoint));
+	ActionManager::register_action (editor_actions, "align-regions-sync-relative", _("align regions sync relative"), bind (mem_fun(*this, &Editor::align_relative), ARDOUR::SyncPoint));
 	
-	register_action (editor_actions, "set-playhead", _("set playhead"), mem_fun(*this, &Editor::kbd_set_playhead_cursor));
-	register_action (editor_actions, "set-edit-cursor", _("set edit cursor"), mem_fun(*this, &Editor::kbd_set_edit_cursor));
+	ActionManager::register_action (editor_actions, "set-playhead", _("set playhead"), mem_fun(*this, &Editor::kbd_set_playhead_cursor));
+	ActionManager::register_action (editor_actions, "set-edit-cursor", _("set edit cursor"), mem_fun(*this, &Editor::kbd_set_edit_cursor));
 
-	register_action (editor_actions, "set-undo", _("set undo"), bind (mem_fun(*this, &Editor::undo), 1U));
-	register_action (editor_actions, "set-redo", _("set redo"), bind (mem_fun(*this, &Editor::redo), 1U));
+	ActionManager::register_action (editor_actions, "set-undo", _("set undo"), bind (mem_fun(*this, &Editor::undo), 1U));
+	ActionManager::register_action (editor_actions, "set-redo", _("set redo"), bind (mem_fun(*this, &Editor::redo), 1U));
 
-	register_action (editor_actions, "export-session", _("export session"), mem_fun(*this, &Editor::export_session));
-	register_action (editor_actions, "export-range", _("export range"), mem_fun(*this, &Editor::export_selection));
+	ActionManager::register_action (editor_actions, "export-session", _("export session"), mem_fun(*this, &Editor::export_session));
+	ActionManager::register_action (editor_actions, "export-range", _("export range"), mem_fun(*this, &Editor::export_selection));
 
-	register_action (editor_actions, "editor-cut", _("editor cut"), mem_fun(*this, &Editor::cut));
-	register_action (editor_actions, "editor-copy", _("editor copy"), mem_fun(*this, &Editor::copy));
-	register_action (editor_actions, "editor-paste", _("editor paste"), mem_fun(*this, &Editor::keyboard_paste));
-	register_action (editor_actions, "duplicate-region", _("duplicate region"), mem_fun(*this, &Editor::keyboard_duplicate_region));
-	register_action (editor_actions, "duplicate-range", _("duplicate range"), mem_fun(*this, &Editor::keyboard_duplicate_selection));
-	register_action (editor_actions, "insert-region", _("insert region"), mem_fun(*this, &Editor::keyboard_insert_region_list_selection));
-	register_action (editor_actions, "reverse-region", _("reverse region"), mem_fun(*this, &Editor::reverse_region));
-	register_action (editor_actions, "normalize-region", _("normalize region"), mem_fun(*this, &Editor::normalize_region));
-	register_action (editor_actions, "editor-crop", _("editor crop"), mem_fun(*this, &Editor::crop_region_to_selection));
-	register_action (editor_actions, "insert-chunk", _("insert chunk"), bind (mem_fun(*this, &Editor::paste_named_selection), 1.0f));
+	ActionManager::register_action (editor_actions, "editor-cut", _("editor cut"), mem_fun(*this, &Editor::cut));
+	ActionManager::register_action (editor_actions, "editor-copy", _("editor copy"), mem_fun(*this, &Editor::copy));
+	ActionManager::register_action (editor_actions, "editor-paste", _("editor paste"), mem_fun(*this, &Editor::keyboard_paste));
+	ActionManager::register_action (editor_actions, "duplicate-region", _("duplicate region"), mem_fun(*this, &Editor::keyboard_duplicate_region));
+	ActionManager::register_action (editor_actions, "duplicate-range", _("duplicate range"), mem_fun(*this, &Editor::keyboard_duplicate_selection));
+	ActionManager::register_action (editor_actions, "insert-region", _("insert region"), mem_fun(*this, &Editor::keyboard_insert_region_list_selection));
+	ActionManager::register_action (editor_actions, "reverse-region", _("reverse region"), mem_fun(*this, &Editor::reverse_region));
+	ActionManager::register_action (editor_actions, "normalize-region", _("normalize region"), mem_fun(*this, &Editor::normalize_region));
+	ActionManager::register_action (editor_actions, "editor-crop", _("editor crop"), mem_fun(*this, &Editor::crop_region_to_selection));
+	ActionManager::register_action (editor_actions, "insert-chunk", _("insert chunk"), bind (mem_fun(*this, &Editor::paste_named_selection), 1.0f));
 
-	register_action (editor_actions, "split-at-edit-cursor", _("split at edit cursor"), mem_fun(*this, &Editor::split_region));
-	register_action (editor_actions, "split-at-mouse", _("split at mouse"), mem_fun(*this, &Editor::kbd_split));
+	ActionManager::register_action (editor_actions, "split-at-edit-cursor", _("split at edit cursor"), mem_fun(*this, &Editor::split_region));
+	ActionManager::register_action (editor_actions, "split-at-mouse", _("split at mouse"), mem_fun(*this, &Editor::kbd_split));
 
-	register_action (editor_actions, "brush-at-mouse", _("brush at mouse"), mem_fun(*this, &Editor::kbd_brush));
-	register_action (editor_actions, "audition-at-mouse", _("audition at mouse"), mem_fun(*this, &Editor::kbd_audition));
+	ActionManager::register_action (editor_actions, "brush-at-mouse", _("brush at mouse"), mem_fun(*this, &Editor::kbd_brush));
+	ActionManager::register_action (editor_actions, "audition-at-mouse", _("audition at mouse"), mem_fun(*this, &Editor::kbd_audition));
 
-	register_action (editor_actions, "start-range", _("start range"), mem_fun(*this, &Editor::keyboard_selection_begin));
-	register_action (editor_actions, "finish-range", _("finish range"), bind (mem_fun(*this, &Editor::keyboard_selection_finish), false));
-	register_action (editor_actions, "finish-add-range", _("finish add range"), bind (mem_fun(*this, &Editor::keyboard_selection_finish), true));
+	ActionManager::register_action (editor_actions, "start-range", _("start range"), mem_fun(*this, &Editor::keyboard_selection_begin));
+	ActionManager::register_action (editor_actions, "finish-range", _("finish range"), bind (mem_fun(*this, &Editor::keyboard_selection_finish), false));
+	ActionManager::register_action (editor_actions, "finish-add-range", _("finish add range"), bind (mem_fun(*this, &Editor::keyboard_selection_finish), true));
 
-	register_action (editor_actions, "extend-range-to-end-of-region", _("extend range to end of region"), bind (mem_fun(*this, &Editor::extend_selection_to_end_of_region), false));
-	register_action (editor_actions, "extend-range-to-start-of-region", _("extend range to start of region"), bind (mem_fun(*this, &Editor::extend_selection_to_start_of_region), false));
+	ActionManager::register_action (editor_actions, "extend-range-to-end-of-region", _("extend range to end of region"), bind (mem_fun(*this, &Editor::extend_selection_to_end_of_region), false));
+	ActionManager::register_action (editor_actions, "extend-range-to-start-of-region", _("extend range to start of region"), bind (mem_fun(*this, &Editor::extend_selection_to_start_of_region), false));
 
-	register_action (editor_actions, "toggle-follow-playhead", _("toggle follow playhead"), (mem_fun(*this, &Editor::toggle_follow_playhead)));
-	register_action (editor_actions, "remove-last-capture", _("remove last capture"), (mem_fun(*this, &Editor::remove_last_capture)));
+	ActionManager::register_action (editor_actions, "toggle-follow-playhead", _("toggle follow playhead"), (mem_fun(*this, &Editor::toggle_follow_playhead)));
+	ActionManager::register_action (editor_actions, "remove-last-capture", _("remove last capture"), (mem_fun(*this, &Editor::remove_last_capture)));
 
 	Glib::RefPtr<ActionGroup> zoom_actions = ActionGroup::create (X_("Zoom"));
 	RadioAction::Group zoom_group;
 
-	register_radio_action (zoom_actions, zoom_group, "zoom-focus-left", _("zoom focus left"), bind (mem_fun(*this, &Editor::set_zoom_focus), Editing::ZoomFocusLeft));
-	register_radio_action (zoom_actions, zoom_group, "zoom-focus-right", _("zoom focus right"), bind (mem_fun(*this, &Editor::set_zoom_focus), Editing::ZoomFocusRight));
-	register_radio_action (zoom_actions, zoom_group, "zoom-focus-center", _("zoom focus center"), bind (mem_fun(*this, &Editor::set_zoom_focus), Editing::ZoomFocusCenter));
-	register_radio_action (zoom_actions, zoom_group, "zoom-focus-playhead", _("zoom focus playhead"), bind (mem_fun(*this, &Editor::set_zoom_focus), Editing::ZoomFocusPlayhead));
-	register_radio_action (zoom_actions, zoom_group, "zoom-focus-edit", _("zoom focus edit"), bind (mem_fun(*this, &Editor::set_zoom_focus), Editing::ZoomFocusEdit));
+	ActionManager::register_radio_action (zoom_actions, zoom_group, "zoom-focus-left", _("zoom focus left"), bind (mem_fun(*this, &Editor::set_zoom_focus), Editing::ZoomFocusLeft));
+	ActionManager::register_radio_action (zoom_actions, zoom_group, "zoom-focus-right", _("zoom focus right"), bind (mem_fun(*this, &Editor::set_zoom_focus), Editing::ZoomFocusRight));
+	ActionManager::register_radio_action (zoom_actions, zoom_group, "zoom-focus-center", _("zoom focus center"), bind (mem_fun(*this, &Editor::set_zoom_focus), Editing::ZoomFocusCenter));
+	ActionManager::register_radio_action (zoom_actions, zoom_group, "zoom-focus-playhead", _("zoom focus playhead"), bind (mem_fun(*this, &Editor::set_zoom_focus), Editing::ZoomFocusPlayhead));
+	ActionManager::register_radio_action (zoom_actions, zoom_group, "zoom-focus-edit", _("zoom focus edit"), bind (mem_fun(*this, &Editor::set_zoom_focus), Editing::ZoomFocusEdit));
 
 	Glib::RefPtr<ActionGroup> mouse_mode_actions = ActionGroup::create (X_("MouseMode"));
 	RadioAction::Group mouse_mode_group;
 
-	register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-object", _("set mouse mode object"), bind (mem_fun(*this, &Editor::set_mouse_mode), Editing::MouseObject, false));
-	register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-range", _("set mouse mode range"), bind (mem_fun(*this, &Editor::set_mouse_mode), Editing::MouseRange, false));
-	register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-gain", _("set mouse mode gain"), bind (mem_fun(*this, &Editor::set_mouse_mode), Editing::MouseGain, false));
-	register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-zoom", _("set mouse mode zoom"), bind (mem_fun(*this, &Editor::set_mouse_mode), Editing::MouseZoom, false));
-	register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-timefx", _("set mouse mode timefx"), bind (mem_fun(*this, &Editor::set_mouse_mode), Editing::MouseTimeFX, false));
+	ActionManager::register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-object", _("set mouse mode object"), bind (mem_fun(*this, &Editor::set_mouse_mode), Editing::MouseObject, false));
+	ActionManager::register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-range", _("set mouse mode range"), bind (mem_fun(*this, &Editor::set_mouse_mode), Editing::MouseRange, false));
+	ActionManager::register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-gain", _("set mouse mode gain"), bind (mem_fun(*this, &Editor::set_mouse_mode), Editing::MouseGain, false));
+	ActionManager::register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-zoom", _("set mouse mode zoom"), bind (mem_fun(*this, &Editor::set_mouse_mode), Editing::MouseZoom, false));
+	ActionManager::register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-timefx", _("set mouse mode timefx"), bind (mem_fun(*this, &Editor::set_mouse_mode), Editing::MouseTimeFX, false));
 
 	Glib::RefPtr<ActionGroup> snap_actions = ActionGroup::create (X_("Snap"));
 	RadioAction::Group snap_choice_group;
 
-	register_radio_action (snap_actions, snap_choice_group, X_("snap-to-frame"), _("snap to frame"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToFrame)));
-	register_radio_action (snap_actions, snap_choice_group, X_("snap-to-cd-frame"), _("snap to cd frame"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToCDFrame)));
-	register_radio_action (snap_actions, snap_choice_group, X_("snap-to-smpte-frame"), _("snap to smpte frame"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToSMPTEFrame)));
-	register_radio_action (snap_actions, snap_choice_group, X_("snap-to-smpte-seconds"), _("snap to smpte seconds"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToSMPTESeconds)));
-	register_radio_action (snap_actions, snap_choice_group, X_("snap-to-smpte-minutes"), _("snap to smpte minutes"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToSMPTEMinutes)));
-	register_radio_action (snap_actions, snap_choice_group, X_("snap-to-seconds"), _("snap to seconds"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToSeconds)));
-	register_radio_action (snap_actions, snap_choice_group, X_("snap-to-minutes"), _("snap to minutes"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToMinutes)));
-	register_radio_action (snap_actions, snap_choice_group, X_("snap-to-thirtyseconds"), _("snap to thirtyseconds"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToAThirtysecondBeat)));
-	register_radio_action (snap_actions, snap_choice_group, X_("snap-to-asixteenthbeat"), _("snap to asixteenthbeat"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToASixteenthBeat)));
-	register_radio_action (snap_actions, snap_choice_group, X_("snap-to-eighths"), _("snap to eighths"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToAEighthBeat)));
-	register_radio_action (snap_actions, snap_choice_group, X_("snap-to-quarters"), _("snap to quarters"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToAQuarterBeat)));
-	register_radio_action (snap_actions, snap_choice_group, X_("snap-to-thirds"), _("snap to thirds"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToAThirdBeat)));
-	register_radio_action (snap_actions, snap_choice_group, X_("snap-to-beat"), _("snap to beat"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToBeat)));
-	register_radio_action (snap_actions, snap_choice_group, X_("snap-to-bar"), _("snap to bar"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToBar)));
-	register_radio_action (snap_actions, snap_choice_group, X_("snap-to-mark"), _("snap to mark"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToMark)));
-	register_radio_action (snap_actions, snap_choice_group, X_("snap-to-edit-cursor"), _("snap to edit cursor"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToEditCursor)));
-	register_radio_action (snap_actions, snap_choice_group, X_("snap-to-region-start"), _("snap to region start"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToRegionStart)));
-	register_radio_action (snap_actions, snap_choice_group, X_("snap-to-region-end"), _("snap to region end"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToRegionEnd)));
-	register_radio_action (snap_actions, snap_choice_group, X_("snap-to-region-sync"), _("snap to region sync"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToRegionSync)));
-	register_radio_action (snap_actions, snap_choice_group, X_("snap-to-region-boundary"), _("snap to region boundary"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToRegionBoundary)));
+	ActionManager::register_radio_action (snap_actions, snap_choice_group, X_("snap-to-frame"), _("snap to frame"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToFrame)));
+	ActionManager::register_radio_action (snap_actions, snap_choice_group, X_("snap-to-cd-frame"), _("snap to cd frame"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToCDFrame)));
+	ActionManager::register_radio_action (snap_actions, snap_choice_group, X_("snap-to-smpte-frame"), _("snap to smpte frame"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToSMPTEFrame)));
+	ActionManager::register_radio_action (snap_actions, snap_choice_group, X_("snap-to-smpte-seconds"), _("snap to smpte seconds"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToSMPTESeconds)));
+	ActionManager::register_radio_action (snap_actions, snap_choice_group, X_("snap-to-smpte-minutes"), _("snap to smpte minutes"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToSMPTEMinutes)));
+	ActionManager::register_radio_action (snap_actions, snap_choice_group, X_("snap-to-seconds"), _("snap to seconds"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToSeconds)));
+	ActionManager::register_radio_action (snap_actions, snap_choice_group, X_("snap-to-minutes"), _("snap to minutes"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToMinutes)));
+	ActionManager::register_radio_action (snap_actions, snap_choice_group, X_("snap-to-thirtyseconds"), _("snap to thirtyseconds"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToAThirtysecondBeat)));
+	ActionManager::register_radio_action (snap_actions, snap_choice_group, X_("snap-to-asixteenthbeat"), _("snap to asixteenthbeat"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToASixteenthBeat)));
+	ActionManager::register_radio_action (snap_actions, snap_choice_group, X_("snap-to-eighths"), _("snap to eighths"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToAEighthBeat)));
+	ActionManager::register_radio_action (snap_actions, snap_choice_group, X_("snap-to-quarters"), _("snap to quarters"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToAQuarterBeat)));
+	ActionManager::register_radio_action (snap_actions, snap_choice_group, X_("snap-to-thirds"), _("snap to thirds"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToAThirdBeat)));
+	ActionManager::register_radio_action (snap_actions, snap_choice_group, X_("snap-to-beat"), _("snap to beat"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToBeat)));
+	ActionManager::register_radio_action (snap_actions, snap_choice_group, X_("snap-to-bar"), _("snap to bar"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToBar)));
+	ActionManager::register_radio_action (snap_actions, snap_choice_group, X_("snap-to-mark"), _("snap to mark"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToMark)));
+	ActionManager::register_radio_action (snap_actions, snap_choice_group, X_("snap-to-edit-cursor"), _("snap to edit cursor"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToEditCursor)));
+	ActionManager::register_radio_action (snap_actions, snap_choice_group, X_("snap-to-region-start"), _("snap to region start"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToRegionStart)));
+	ActionManager::register_radio_action (snap_actions, snap_choice_group, X_("snap-to-region-end"), _("snap to region end"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToRegionEnd)));
+	ActionManager::register_radio_action (snap_actions, snap_choice_group, X_("snap-to-region-sync"), _("snap to region sync"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToRegionSync)));
+	ActionManager::register_radio_action (snap_actions, snap_choice_group, X_("snap-to-region-boundary"), _("snap to region boundary"), (bind (mem_fun(*this, &Editor::set_snap_to), Editing::SnapToRegionBoundary)));
 
 	/* REGION LIST */
 
@@ -174,48 +169,44 @@ Editor::register_actions ()
 	RadioAction::Group sort_type_group;
 	RadioAction::Group sort_order_group;
 
-	register_action (rl_actions, X_("rlAudition"), _("Audition"), mem_fun(*this, &Editor::audition_region_from_region_list));
-	register_action (rl_actions, X_("rlHide"), _("Hide"), mem_fun(*this, &Editor::hide_region_from_region_list));
-	register_action (rl_actions, X_("rlRemove"), _("Remove"), mem_fun (*this, &Editor::remove_region_from_region_list));
-	register_action (rl_actions, X_("rlShowAll"), _("Show all"), mem_fun(*this, &Editor::toggle_full_region_list));
+	ActionManager::register_action (rl_actions, X_("rlAudition"), _("Audition"), mem_fun(*this, &Editor::audition_region_from_region_list));
+	ActionManager::register_action (rl_actions, X_("rlHide"), _("Hide"), mem_fun(*this, &Editor::hide_region_from_region_list));
+	ActionManager::register_action (rl_actions, X_("rlRemove"), _("Remove"), mem_fun (*this, &Editor::remove_region_from_region_list));
+	ActionManager::register_action (rl_actions, X_("rlShowAll"), _("Show all"), mem_fun(*this, &Editor::toggle_full_region_list));
 
-	register_radio_action (rl_actions, sort_order_group, X_("SortAscending"),  _("Ascending"),
+	ActionManager::register_radio_action (rl_actions, sort_order_group, X_("SortAscending"),  _("Ascending"),
 			       bind (mem_fun(*this, &Editor::reset_region_list_sort_direction), true));
-	register_radio_action (rl_actions, sort_order_group, X_("SortDescending"),   _("Descending"),
+	ActionManager::register_radio_action (rl_actions, sort_order_group, X_("SortDescending"),   _("Descending"),
 			       bind (mem_fun(*this, &Editor::reset_region_list_sort_direction), false));
 	
-	register_radio_action (rl_actions, sort_type_group, X_("SortByRegionName"),  _("By Region Name"),
+	ActionManager::register_radio_action (rl_actions, sort_type_group, X_("SortByRegionName"),  _("By Region Name"),
 			       bind (mem_fun(*this, &Editor::reset_region_list_sort_type), ByName));
-	register_radio_action (rl_actions, sort_type_group, X_("SortByRegionLength"),  _("By Region Length"),
+	ActionManager::register_radio_action (rl_actions, sort_type_group, X_("SortByRegionLength"),  _("By Region Length"),
 			       bind (mem_fun(*this, &Editor::reset_region_list_sort_type), ByLength));
-	register_radio_action (rl_actions, sort_type_group, X_("SortByRegionPosition"),  _("By Region Position"),
+	ActionManager::register_radio_action (rl_actions, sort_type_group, X_("SortByRegionPosition"),  _("By Region Position"),
 			       bind (mem_fun(*this, &Editor::reset_region_list_sort_type), ByPosition));
-	register_radio_action (rl_actions, sort_type_group, X_("SortByRegionTimestamp"),  _("By Region Timestamp"),
+	ActionManager::register_radio_action (rl_actions, sort_type_group, X_("SortByRegionTimestamp"),  _("By Region Timestamp"),
 			       bind (mem_fun(*this, &Editor::reset_region_list_sort_type), ByTimestamp));
-	register_radio_action (rl_actions, sort_type_group, X_("SortByRegionStartinFile"),  _("By Region Start in File"),
+	ActionManager::register_radio_action (rl_actions, sort_type_group, X_("SortByRegionStartinFile"),  _("By Region Start in File"),
 			       bind (mem_fun(*this, &Editor::reset_region_list_sort_type), ByStartInFile));
-	register_radio_action (rl_actions, sort_type_group, X_("SortByRegionEndinFile"),  _("By Region End in File"),
+	ActionManager::register_radio_action (rl_actions, sort_type_group, X_("SortByRegionEndinFile"),  _("By Region End in File"),
 			       bind (mem_fun(*this, &Editor::reset_region_list_sort_type), ByEndInFile));
-	register_radio_action (rl_actions, sort_type_group, X_("SortBySourceFileName"),  _("By Source File Name"),
+	ActionManager::register_radio_action (rl_actions, sort_type_group, X_("SortBySourceFileName"),  _("By Source File Name"),
 			       bind (mem_fun(*this, &Editor::reset_region_list_sort_type), BySourceFileName));
-	register_radio_action (rl_actions, sort_type_group, X_("SortBySourceFileLength"),  _("By Source File Length"),
+	ActionManager::register_radio_action (rl_actions, sort_type_group, X_("SortBySourceFileLength"),  _("By Source File Length"),
 			       bind (mem_fun(*this, &Editor::reset_region_list_sort_type), BySourceFileLength));
-	register_radio_action (rl_actions, sort_type_group, X_("SortBySourceFileCreationDate"),  _("By Source File Creation Date"),
+	ActionManager::register_radio_action (rl_actions, sort_type_group, X_("SortBySourceFileCreationDate"),  _("By Source File Creation Date"),
 			       bind (mem_fun(*this, &Editor::reset_region_list_sort_type), BySourceFileCreationDate));
-	register_radio_action (rl_actions, sort_type_group, X_("SortBySourceFilesystem"),  _("By Source Filesystem"),
+	ActionManager::register_radio_action (rl_actions, sort_type_group, X_("SortBySourceFilesystem"),  _("By Source Filesystem"),
 			       bind (mem_fun(*this, &Editor::reset_region_list_sort_type), BySourceFileFS));
 	
-	register_action (rl_actions, X_("rlEmbedAudio"), _("Embed audio (link)"), mem_fun(*this, &Editor::embed_audio));
-	register_action (rl_actions, X_("rlImportAudio"), _("Embed audio (link)"), bind (mem_fun(*this, &Editor::import_audio), false));
-
-	/* now add them all */
+	ActionManager::register_action (rl_actions, X_("rlEmbedAudio"), _("Embed audio (link)"), mem_fun(*this, &Editor::embed_audio));
+	ActionManager::register_action (rl_actions, X_("rlImportAudio"), _("Embed audio (link)"), bind (mem_fun(*this, &Editor::import_audio), false));
 
-	ui_manager->insert_action_group (rl_actions);
-	ui_manager->insert_action_group (mouse_mode_actions);
-	ui_manager->insert_action_group (snap_actions);
-	ui_manager->insert_action_group (editor_actions);
 
-	/* and tell the world about us */
+	ActionManager::add_action_group (rl_actions);
+	ActionManager::add_action_group (mouse_mode_actions);
+	ActionManager::add_action_group (snap_actions);
+	ActionManager::add_action_group (editor_actions);
 
-	register_ui_manager (ui_manager);
 }
diff --git a/gtk2_ardour/editor_ops.cc b/gtk2_ardour/editor_ops.cc
index 2e486aa23a..2f8d3a8cfd 100644
--- a/gtk2_ardour/editor_ops.cc
+++ b/gtk2_ardour/editor_ops.cc
@@ -1766,9 +1766,7 @@ Editor::rename_region ()
 	/* recurse */
 
 	dialog.show_all ();
-	ARDOUR_UI::instance()->allow_focus (true);
 	Main::run ();
-	ARDOUR_UI::instance()->allow_focus (false);
 
 	if (region_renamed) {
 		(*selection->audio_regions.begin())->region.set_name (entry.get_text());
diff --git a/gtk2_ardour/export_dialog.cc b/gtk2_ardour/export_dialog.cc
index 1153f318f4..9c594e456d 100644
--- a/gtk2_ardour/export_dialog.cc
+++ b/gtk2_ardour/export_dialog.cc
@@ -130,9 +130,6 @@ ExportDialog::ExportDialog(PublicEditor& e, AudioRegion* r)
 	file_selector = 0;
 	spec.running = false;
 
-	file_entry.signal_focus_in_event().connect (sigc::ptr_fun (ARDOUR_UI::generic_focus_in_event));
-	file_entry.signal_focus_out_event().connect (sigc::ptr_fun (ARDOUR_UI::generic_focus_out_event));
-
 	file_entry.set_name ("ExportFileNameEntry");
 
 	master_list = ListStore::create (exp_cols);
@@ -1268,19 +1265,11 @@ ExportDialog::initiate_browse ()
 
 		file_selector->get_cancel_button()->signal_clicked().connect (bind (mem_fun(*this, &ExportDialog::finish_browse), -1));
 		file_selector->get_ok_button()->signal_clicked().connect (bind (mem_fun(*this, &ExportDialog::finish_browse), 1));
-		file_selector->signal_map_event().connect (bind (mem_fun(*this, &ExportDialog::change_focus_policy), true));
 		file_selector->signal_unmap_event().connect (bind (mem_fun(*this, &ExportDialog::change_focus_policy), false));
 	}
 	file_selector->show_all ();
 }
 
-gint
-ExportDialog::change_focus_policy (GdkEventAny *ev, bool yn)
-{
-	Keyboard::the_keyboard().allow_focus (yn);
-	return FALSE;
-}
-
 void
 ExportDialog::finish_browse (int status)
 {
diff --git a/gtk2_ardour/export_dialog.h b/gtk2_ardour/export_dialog.h
index 454b52389c..16343e55bc 100644
--- a/gtk2_ardour/export_dialog.h
+++ b/gtk2_ardour/export_dialog.h
@@ -135,7 +135,6 @@ class ExportDialog : public ArdourDialog
 	void export_cue_file (ARDOUR::Locations::LocationList& locations, const string& path);
 	void export_toc_file (ARDOUR::Locations::LocationList& locations, const string& path);
 	void do_export ();
-	gint change_focus_policy (GdkEventAny *, bool);
 	gint window_closed (GdkEventAny *ignored);
 
 	void track_selector_button_click ();
diff --git a/gtk2_ardour/gain_meter.cc b/gtk2_ardour/gain_meter.cc
index 4899e58733..ccb65a5ae9 100644
--- a/gtk2_ardour/gain_meter.cc
+++ b/gtk2_ardour/gain_meter.cc
@@ -552,18 +552,6 @@ GainMeter::gain_changed (void *src)
 	Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &GainMeter::effective_gain_display));
 }
 
-gint
-GainMeter::entry_focus_event (GdkEventFocus* ev)
-{
-	if (ev->in) {
-		ARDOUR_UI::instance()->allow_focus (true);
-	} else {
-		ARDOUR_UI::instance()->allow_focus (false);
-	}
-	return TRUE;
-}
-
-
 void
 GainMeter::set_meter_strip_name (string name)
 {
diff --git a/gtk2_ardour/gain_meter.h b/gtk2_ardour/gain_meter.h
index 49c7d611bf..a1dafafde9 100644
--- a/gtk2_ardour/gain_meter.h
+++ b/gtk2_ardour/gain_meter.h
@@ -131,8 +131,6 @@ class GainMeter : public Gtk::VBox
 	gint start_gain_touch (GdkEventButton*);
 	gint end_gain_touch (GdkEventButton*);
 
-	gint entry_focus_event (GdkEventFocus* ev);
-
 	void set_mix_group_meter_point (ARDOUR::Route&, ARDOUR::MeterPoint);
 	void set_meter_point (ARDOUR::Route&, ARDOUR::MeterPoint);
 	gint meter_release (GdkEventButton*);
diff --git a/gtk2_ardour/keyboard.cc b/gtk2_ardour/keyboard.cc
index eeb73ea5aa..3e187f15d3 100644
--- a/gtk2_ardour/keyboard.cc
+++ b/gtk2_ardour/keyboard.cc
@@ -31,8 +31,6 @@
 #include <pbd/error.h>
 
 #include "keyboard.h"
-#include "keyboard_target.h"
-#include "ardour_dialog.h"
 #include "gui_thread.h"
 
 #include "i18n.h"
@@ -65,23 +63,12 @@ Keyboard::Keyboard ()
 		_the_keyboard = this;
 	}
 
-	target = 0;
-	default_target = 0;
-	_queue_events = false;
-	_flush_queue = false;
-	playback_ignore_count = 0;
-	focus_allowed = false;
 	collecting_prefix = false;
-	current_dialog = 0;
 
 	get_modifier_masks ();
 
 	snooper_id = gtk_key_snooper_install (_snooper, (gpointer) this);
 
-	/* some global key actions */
-
-	KeyboardTarget::add_action ("close-dialog", mem_fun(*this, &Keyboard::close_current_dialog));
-
 	XMLNode* node = ARDOUR_UI::instance()->keyboard_settings();
 	set_state (*node);
 }
@@ -149,26 +136,15 @@ Keyboard::_snooper (GtkWidget *widget, GdkEventKey *event, gpointer data)
 gint
 Keyboard::snooper (GtkWidget *widget, GdkEventKey *event)
 {
-	bool handled = false;
 	uint32_t keyval;
 
 #if KBD_DEBUG
 	if (debug_keyboard) {
 		cerr << "snoop widget " << widget << " key " << event->keyval << " type: " << event->type 
-		     << " focus allowed? " << focus_allowed << " current dialog = " << current_dialog
 		     << endl;
 	}
 #endif
 
-	/* Only allow key events to propagate to the
-	   usual GTK model when specifically allowed. 
-	   Returning FALSE here does that.
-	*/
-
-	if (focus_allowed) {
-		return FALSE;
-	}
-	
 	if (event->keyval == GDK_Shift_R) {
 		keyval = GDK_Shift_L;
 
@@ -178,7 +154,6 @@ Keyboard::snooper (GtkWidget *widget, GdkEventKey *event)
 	} else {
 		keyval = event->keyval;
 	}
-	
 		
 	if (event->type == GDK_KEY_PRESS) {
 		bool was_prefix = false;
@@ -241,57 +216,6 @@ Keyboard::snooper (GtkWidget *widget, GdkEventKey *event)
 			sort (state.begin(), state.end());
 		}
 
-#if KBD_DEBUG
-		if (debug_keyboard) {
-			cerr << "STATE: ";
-			for (State::iterator i = state.begin(); i != state.end(); ++i) {
-				cerr << (*i) << ' ';
-			}
-			cerr << endl;
-		}
-#endif
-
-		if (!was_prefix) {
-
-			bool old_collecting_prefix = collecting_prefix;
-
-			if (target) {
-#if KBD_DEBUG
-				if (debug_keyboard) {
-					cerr << "PRESS: delivering to target " << target << endl;
-				}
-#endif
-				target->key_press_event (event, state, handled);
-			}
-			
-			if (!handled && default_target) {
-#if KBD_DEBUG
-				if (debug_keyboard) {
-					cerr << "PRESS: not handled, delivering to default target " << default_target << endl;
-				}
-#endif
-				default_target->key_press_event (event, state, handled);
-			}
-
-#if KBD_DEBUG
-			if (debug_keyboard) {
-				cerr << "PRESS: handled ? " << handled << endl;
-			}
-#endif
-
-			if (handled) {
-				
-				/* don't reset collecting prefix is start_prefix()
-				   was called by the handler.
-				*/
-				
-				if (collecting_prefix == old_collecting_prefix) {
-					collecting_prefix = false;
-					current_prefix = "";
-				}
-			}
-		}
-
 	} else if (event->type == GDK_KEY_RELEASE) {
 
 		State::iterator i;
@@ -301,26 +225,9 @@ Keyboard::snooper (GtkWidget *widget, GdkEventKey *event)
 			sort (state.begin(), state.end());
 		} 
 
-		if (target) {
-#if KBD_DEBUG
-			if (debug_keyboard) {
-				cerr << "RELEASE: delivering to target " << target << endl;
-			}
-#endif
-			target->key_release_event (event, state);
-		} 
-
-		if (default_target) {
-#if KBD_DEBUG
-			if (debug_keyboard) {
-				cerr << "RELEASE: delivering to default target " << default_target << endl;
-			}
-#endif
-			default_target->key_release_event (event, state);
-		}
 	}
 
-	return TRUE;
+	return false;
 }
 
 bool
@@ -329,35 +236,6 @@ Keyboard::key_is_down (uint32_t keyval)
 	return find (state.begin(), state.end(), keyval) != state.end();
 }
 
-void
-Keyboard::set_target (KeyboardTarget *kt)
-{
-	/* XXX possible thread issues here */
-	target = kt;
-}
-
-void
-Keyboard::maybe_unset_target (KeyboardTarget* kt)
-{
-	if (target == kt) {
-		target = 0;
-	}
-}
-
-void
-Keyboard::set_default_target (KeyboardTarget *kt)
-{
-	/* XXX possible thread issues here */
-
-	default_target = kt;
-}
-
-void
-Keyboard::allow_focus (bool yn)
-{
-	focus_allowed = yn;
-}
-
 Keyboard::State
 Keyboard::translate_key_name (const string& name)
 
@@ -778,36 +656,24 @@ Keyboard::get_modifier_masks ()
 	XFreeModifiermap (modifiers);
 }
 
-gint
-Keyboard::enter_window (GdkEventCrossing *ev, KeyboardTarget *kt)
+bool
+Keyboard::enter_window (GdkEventCrossing *ev)
 {
 	switch (ev->detail) {
 	case GDK_NOTIFY_INFERIOR:
-		if (debug_keyboard) {
-			cerr << "INFERIOR crossing to " << kt->name() << endl;
-		}
 		break;
 
 	case GDK_NOTIFY_VIRTUAL:
-		if (debug_keyboard) {
-			cerr << "VIRTUAL crossing to " << kt->name() << endl;
-		}
 		/* fallthru */
 
 	default:
-		if (debug_keyboard) {
-			cerr << "REAL crossing to " << kt->name() << endl;
-			cerr << "set current target to " << kt->name() << endl;
-		}
-
-		set_target (kt);
 		check_modifier_state ();
 	}
 
 	return FALSE;
 }
 
-gint
+bool
 Keyboard::leave_window (GdkEventCrossing *ev)
 {
 	switch (ev->detail) {
@@ -828,8 +694,6 @@ Keyboard::leave_window (GdkEventCrossing *ev)
 			cerr << "REAL CROSSING ... out\n";
 			cerr << "clearing current target\n";
 		}
-
-		set_target (0);
 		state.clear ();
 		clear_modifier_state ();
 	}
@@ -838,70 +702,6 @@ Keyboard::leave_window (GdkEventCrossing *ev)
 }
 
 void
-Keyboard::register_target (KeyboardTarget *kt)
-{
-	/* do not register the default - its not meant to be 
-	   an actual window, just a fallback if the current
-	   target for keyboard events doesn't handle an event.
-	*/
-
-	if (kt->name() == X_("default")) {
-		return;
-	}
-
-	kt->window().signal_enter_notify_event().connect (bind (mem_fun(*this, &Keyboard::enter_window), kt));
-	kt->window().signal_leave_notify_event().connect (mem_fun(*this, &Keyboard::leave_window));
-
-	kt->GoingAway.connect (bind (mem_fun(*this, &Keyboard::maybe_unset_target), kt));
-	kt->Hiding.connect (bind (mem_fun(*this, &Keyboard::maybe_unset_target), kt));
-}
-
-void
-Keyboard::set_current_dialog (ArdourDialog* dialog)
-{
-	ENSURE_GUI_THREAD(bind (mem_fun(*this, &Keyboard::set_current_dialog), dialog));
-	
-	current_dialog = dialog;
-
-	if (current_dialog) {
-
-		if (find (known_dialogs.begin(), known_dialogs.end(), dialog) == known_dialogs.end()) {
-			
-			current_dialog->GoingAway.connect 
-				(bind (mem_fun(*this, &Keyboard::set_current_dialog), 
-				       reinterpret_cast<ArdourDialog *>(0)));
-			current_dialog->Hiding.connect 
-				(bind (mem_fun(*this, &Keyboard::set_current_dialog), 
-				       reinterpret_cast<ArdourDialog *>(0)));
-			
-			current_dialog->signal_unmap_event().connect (mem_fun(*this, &Keyboard::current_dialog_vanished));
-			
-			known_dialogs.push_back (dialog);
-		}
-	}
-}
-
-gint
-Keyboard::current_dialog_vanished (GdkEventAny *ev)
-{
-	current_dialog = 0;
-	state.clear ();
-	focus_allowed = false;
-	clear_modifier_state ();
-	current_prefix = "";
-
-	return FALSE;
-}
-
-void
-Keyboard::close_current_dialog ()
-{
-	if (current_dialog) {
-		current_dialog->hide ();
-	}
-}
-
-void
 Keyboard::set_edit_button (guint but)
 {
 	edit_but = but;
@@ -991,16 +791,3 @@ Keyboard::modifier_state_equals (guint state, ModifierMask mask)
 	return (state & RelevantModifierKeyMask) == (guint) mask;
 }
 
-gint
-Keyboard::focus_in_handler (GdkEventFocus* ev)
-{
-	allow_focus (true);
-	return FALSE;
-}
-
-gint
-Keyboard::focus_out_handler (GdkEventFocus* ev)
-{
-	allow_focus (false);
-	return FALSE;
-}
diff --git a/gtk2_ardour/keyboard.h b/gtk2_ardour/keyboard.h
index 1b81f710f8..8e1c0f1b93 100644
--- a/gtk2_ardour/keyboard.h
+++ b/gtk2_ardour/keyboard.h
@@ -33,9 +33,6 @@
 using std::vector;
 using std::string;
 
-class KeyboardTarget;
-class ArdourDialog;
-
 class Keyboard : public sigc::trackable, Stateful
 {
   public:
@@ -47,24 +44,12 @@ class Keyboard : public sigc::trackable, Stateful
 
 	typedef vector<uint32_t> State;
 	
-	void set_target (KeyboardTarget *);
-	void set_default_target (KeyboardTarget *);
-	void allow_focus (bool);
-
-	gint focus_in_handler (GdkEventFocus*);
-	gint focus_out_handler (GdkEventFocus*);
-
 	int  get_prefix(float&, bool& was_floating);
 	void start_prefix ();
 
 	static State  translate_key_name (const string&);
 	static string get_real_keyname (const string& name);
 
-	void register_target (KeyboardTarget *);
-
-	void set_current_dialog (ArdourDialog*);
-	void close_current_dialog ();
-
 	typedef uint32_t ModifierMask;
 
 	static uint32_t Control;
@@ -80,6 +65,9 @@ class Keyboard : public sigc::trackable, Stateful
 		return (ev->state & RelevantModifierKeyMask) == 0;
 	}
 
+	bool leave_window (GdkEventCrossing *ev);
+	bool enter_window (GdkEventCrossing *ev);
+
 	static bool modifier_state_contains (guint state, ModifierMask);
 	static bool modifier_state_equals   (guint state, ModifierMask);
 
@@ -111,21 +99,15 @@ class Keyboard : public sigc::trackable, Stateful
 
 	bool   _queue_events;
 	bool   _flush_queue;
-	guint32 playback_ignore_count;
 
 	guint           snooper_id;
 	State           state;
-	KeyboardTarget* target;
-	KeyboardTarget* default_target;
-	bool            focus_allowed;
 	bool            collecting_prefix;
 	string          current_prefix;
 	int*            modifier_masks;
 	int             modifier_mask;
 	int             min_keycode;
 	int             max_keycode;
-	ArdourDialog*   current_dialog;
-	std::vector<ArdourDialog*> known_dialogs;
 
 	static guint     edit_but;
 	static guint     edit_mod;
@@ -136,16 +118,10 @@ class Keyboard : public sigc::trackable, Stateful
 	static gint _snooper (GtkWidget*, GdkEventKey*, gpointer);
 	gint snooper (GtkWidget*, GdkEventKey*);
 	
-	void maybe_unset_target (KeyboardTarget *);
 	void queue_event (GdkEventKey*);
-	void playback_queue ();
-	void clear_queue ();
 	void get_modifier_masks ();
 	void check_modifier_state ();
 	void clear_modifier_state ();
-	gint enter_window (GdkEventCrossing*, KeyboardTarget*);
-	gint leave_window (GdkEventCrossing*);
-	gint current_dialog_vanished (GdkEventAny*);
 
 	void check_meta_numlock (char keycode, guint mod, string modname);
 };
diff --git a/gtk2_ardour/location_ui.cc b/gtk2_ardour/location_ui.cc
index a6957a9017..564cc4dca2 100644
--- a/gtk2_ardour/location_ui.cc
+++ b/gtk2_ardour/location_ui.cc
@@ -108,17 +108,8 @@ LocationEditRow::LocationEditRow(Session * sess, Location * loc, int32_t num)
 	cd_track_details_hbox.pack_start (composer_entry, true, true);
 
 	isrc_entry.signal_changed().connect (mem_fun(*this, &LocationEditRow::isrc_entry_changed)); 
-	isrc_entry.signal_focus_in_event().connect (mem_fun(*this, &LocationEditRow::entry_focus_event));
-	isrc_entry.signal_focus_out_event().connect (mem_fun(*this, &LocationEditRow::entry_focus_event));
-
 	performer_entry.signal_changed().connect (mem_fun(*this, &LocationEditRow::performer_entry_changed));
-	performer_entry.signal_focus_in_event().connect (mem_fun(*this, &LocationEditRow::entry_focus_event));
-	performer_entry.signal_focus_out_event().connect (mem_fun(*this, &LocationEditRow::entry_focus_event));
-
 	composer_entry.signal_changed().connect (mem_fun(*this, &LocationEditRow::composer_entry_changed));
-	composer_entry.signal_focus_in_event().connect (mem_fun(*this, &LocationEditRow::entry_focus_event));
-	composer_entry.signal_focus_out_event().connect (mem_fun(*this, &LocationEditRow::entry_focus_event));
-
 	scms_check_button.signal_toggled().connect(mem_fun(*this, &LocationEditRow::scms_toggled));
 	preemph_check_button.signal_toggled().connect(mem_fun(*this, &LocationEditRow::preemph_toggled));
 
@@ -240,8 +231,6 @@ LocationEditRow::set_location (Location *loc)
 		name_entry.set_size_request (100, -1);
 		name_entry.set_editable (true);
 		name_entry.signal_changed().connect (mem_fun(*this, &LocationEditRow::name_entry_changed));  
-		name_entry.signal_focus_in_event().connect (mem_fun(*this, &LocationEditRow::entry_focus_event));
-		name_entry.signal_focus_out_event().connect (mem_fun(*this, &LocationEditRow::entry_focus_event));
 
 		if (!name_entry.get_parent()) {
 			item_table.attach (name_entry, 1, 2, 0, 1, FILL | EXPAND, FILL, 4, 0);
@@ -302,18 +291,6 @@ LocationEditRow::set_location (Location *loc)
 	
 }
 
-gint
-LocationEditRow::entry_focus_event (GdkEventFocus* ev)
-{
-	if (ev->in) {
-		ARDOUR_UI::instance()->allow_focus (true);
-	} else {
-		ARDOUR_UI::instance()->allow_focus (false);
-	}
-	return TRUE;
-}
-
-
 void
 LocationEditRow::name_entry_changed ()
 {
diff --git a/gtk2_ardour/location_ui.h b/gtk2_ardour/location_ui.h
index 8f16e2b43a..4c6b2da8e2 100644
--- a/gtk2_ardour/location_ui.h
+++ b/gtk2_ardour/location_ui.h
@@ -124,8 +124,6 @@ class LocationEditRow  : public Gtk::HBox
 	void scms_toggled ();
 	void preemph_toggled ();
 
-	gint entry_focus_event (GdkEventFocus* ev);
-	
 	void end_changed (ARDOUR::Location *);
 	void start_changed (ARDOUR::Location *);
 	void name_changed (ARDOUR::Location *);
diff --git a/gtk2_ardour/mixer_strip.cc b/gtk2_ardour/mixer_strip.cc
index 3b5a2be8a9..f37076aaa3 100644
--- a/gtk2_ardour/mixer_strip.cc
+++ b/gtk2_ardour/mixer_strip.cc
@@ -1131,8 +1131,6 @@ MixerStrip::setup_comment_editor ()
 
 	comment_area.set_name ("MixerTrackCommentArea");
 	comment_area.set_editable (true);
-	comment_area.signal_focus_in_event().connect (ptr_fun (ARDOUR_UI::generic_focus_in_event));
-	comment_area.signal_focus_out_event().connect (ptr_fun (ARDOUR_UI::generic_focus_out_event));
 	  comment_area.changed.connect (mem_fun(*this, &MixerStrip::comment_edited));
 	// GTK2FIX
 	// comment_area.signal_button_release_event().connect_after (ptr_fun (do_not_propagate));
diff --git a/gtk2_ardour/mixer_ui.cc b/gtk2_ardour/mixer_ui.cc
index 83aa261895..31e91fe343 100644
--- a/gtk2_ardour/mixer_ui.cc
+++ b/gtk2_ardour/mixer_ui.cc
@@ -278,8 +278,6 @@ Mixer_UI::strip_button_release_event (GdkEventButton *ev, MixerStrip *strip)
 		   at the same time.
 		*/
 		
-		ARDOUR_UI::instance()->allow_focus (false);
-		
 		if (_selection.selected (&strip->route())) {
 			_selection.remove (&strip->route());
 		} else {
diff --git a/gtk2_ardour/option_editor.cc b/gtk2_ardour/option_editor.cc
index 1e98dda2d4..803e17d79b 100644
--- a/gtk2_ardour/option_editor.cc
+++ b/gtk2_ardour/option_editor.cc
@@ -412,9 +412,6 @@ OptionEditor::setup_path_options()
 
 	session_raid_entry.signal_activate().connect (mem_fun(*this, &OptionEditor::raid_path_changed));
 
-	session_raid_entry.signal_focus_in_event().connect (mem_fun (Keyboard::the_keyboard(), &Keyboard::focus_in_handler));
-	session_raid_entry.signal_focus_out_event().connect (bind (mem_fun(*this, &OptionEditor::focus_out_event_handler), &OptionEditor::raid_path_changed));
-
 	label = manage(new Label(_("session RAID path")));
 	label->set_name ("OptionsLabel");
 	path_table.attach (*label, 0, 1, 0, 1, FILL|EXPAND, FILL);
@@ -1402,7 +1399,6 @@ void
 OptionEditor::just_close_win()
 {
 	hide_all();
-	ARDOUR_UI::instance()->allow_focus(false);
 }
 
 void
@@ -1523,9 +1519,7 @@ OptionEditor::setup_click_editor ()
 	click_path_entry.signal_activate().connect (mem_fun(*this, &OptionEditor::click_sound_changed));
 	click_emphasis_path_entry.signal_activate().connect (mem_fun(*this, &OptionEditor::click_emphasis_sound_changed));
 
-	click_path_entry.signal_focus_in_event().connect (mem_fun (Keyboard::the_keyboard(), &Keyboard::focus_in_handler));
 	click_path_entry.signal_focus_out_event().connect (bind (mem_fun(*this, &OptionEditor::focus_out_event_handler), &OptionEditor::click_sound_changed));
-	click_emphasis_path_entry.signal_focus_in_event().connect (mem_fun (Keyboard::the_keyboard(), &Keyboard::focus_in_handler));
 	click_emphasis_path_entry.signal_focus_out_event().connect (bind (mem_fun(*this, &OptionEditor::focus_out_event_handler), &OptionEditor::click_emphasis_sound_changed));
 
 	click_browse_button.set_name ("EditorGTKButton");
@@ -1606,11 +1600,11 @@ OptionEditor::connect_audition_editor ()
 	auditioner_gpm->show_all ();
 }
 
-gint
+bool
 OptionEditor::focus_out_event_handler (GdkEventFocus* ev, void (OptionEditor::*pmf)()) 
 {
 	(this->*pmf)();
-	return Keyboard::the_keyboard().focus_out_handler (ev);
+	return false;
 }
 
 void
diff --git a/gtk2_ardour/option_editor.h b/gtk2_ardour/option_editor.h
index 2808b18ddd..6eabe6a4c9 100644
--- a/gtk2_ardour/option_editor.h
+++ b/gtk2_ardour/option_editor.h
@@ -70,7 +70,7 @@ class OptionEditor : public ArdourDialog
 	void map_some_session_state (Gtk::CheckButton& button, bool (ARDOUR::Session::*get)() const);
 	gint wm_close (GdkEventAny *);
 	void just_close_win();
-	gint focus_out_event_handler (GdkEventFocus*, void (OptionEditor::*pmf)());
+	bool focus_out_event_handler (GdkEventFocus*, void (OptionEditor::*pmf)());
 
 	/* paths */
 
diff --git a/gtk2_ardour/panner_ui.cc b/gtk2_ardour/panner_ui.cc
index 06ae10ef1f..6d629118ac 100644
--- a/gtk2_ardour/panner_ui.cc
+++ b/gtk2_ardour/panner_ui.cc
@@ -261,17 +261,6 @@ PannerUI::~PannerUI ()
 }
 
 
-gint
-PannerUI::entry_focus_event (GdkEventFocus* ev)
-{
-	if (ev->in) {
-		ARDOUR_UI::instance()->allow_focus (true);
-	} else {
-		ARDOUR_UI::instance()->allow_focus (false);
-	}
-	return TRUE;
-}
-
 void
 PannerUI::panner_changed ()
 {
@@ -337,8 +326,6 @@ PannerUI::setup_pan ()
 			bc->set_name ("PanSlider");
 			bc->set_shadow_type (Gtk::SHADOW_NONE);
 			bc->set_style (BarController::Line);
-			bc->get_spin_button().signal_focus_in_event().connect (mem_fun(*this, &PannerUI::entry_focus_event));
-			bc->get_spin_button().signal_focus_out_event().connect (mem_fun(*this, &PannerUI::entry_focus_event));
 
 			bc->StartGesture.connect (bind (mem_fun (_io, &IO::start_pan_touch), (uint32_t) asz));
 			bc->StopGesture.connect (bind (mem_fun (_io, &IO::end_pan_touch), (uint32_t) asz));
diff --git a/gtk2_ardour/panner_ui.h b/gtk2_ardour/panner_ui.h
index e13be3684f..b028510de3 100644
--- a/gtk2_ardour/panner_ui.h
+++ b/gtk2_ardour/panner_ui.h
@@ -108,8 +108,6 @@ class PannerUI : public Gtk::HBox
 	gint start_pan_touch (GdkEventButton*);
 	gint end_pan_touch (GdkEventButton*);
 
-	gint entry_focus_event (GdkEventFocus* ev);
-
 	gint pan_button_event (GdkEventButton*, uint32_t which);
 	Gtk::Menu* pan_menu;
 	Gtk::CheckMenuItem* bypass_menu_item;
diff --git a/gtk2_ardour/plugin_ui.cc b/gtk2_ardour/plugin_ui.cc
index d155db57c6..c426b57702 100644
--- a/gtk2_ardour/plugin_ui.cc
+++ b/gtk2_ardour/plugin_ui.cc
@@ -553,9 +553,6 @@ PluginUI::build_control_ui (AudioEngine &engine, guint32 port_index, MIDI::Contr
 			control_ui->control->set_style (BarController::LeftToRight);
 			control_ui->control->set_use_parent (true);
 
-			control_ui->control->get_spin_button().signal_focus_in_event().connect (mem_fun(*this, &PluginUI::entry_focus_event));
-			control_ui->control->get_spin_button().signal_focus_out_event().connect (mem_fun(*this, &PluginUI::entry_focus_event));
-
 			control_ui->control->StartGesture.connect (bind (mem_fun(*this, &PluginUI::start_touch), control_ui));
 			control_ui->control->StopGesture.connect (bind (mem_fun(*this, &PluginUI::stop_touch), control_ui));
 			
@@ -770,17 +767,6 @@ PluginUIWindow::plugin_going_away (ARDOUR::Redirect* ignored)
 	delete_when_idle (this);
 }
 
-gint
-PluginUI::entry_focus_event (GdkEventFocus* ev)
-{
-	if (ev->in) {
-		ARDOUR_UI::instance()->allow_focus (true);
-	} else {
-		ARDOUR_UI::instance()->allow_focus (false);
-	}
-	return TRUE;
-}
-
 void
 PluginUI::redirect_active_changed (Redirect* r, void* src)
 {
diff --git a/gtk2_ardour/plugin_ui.h b/gtk2_ardour/plugin_ui.h
index ef7ba1eb2a..dd16082489 100644
--- a/gtk2_ardour/plugin_ui.h
+++ b/gtk2_ardour/plugin_ui.h
@@ -187,7 +187,6 @@ class PluginUI : public PlugUIBase, public Gtk::VBox
 	void update_control_display (ControlUI* cui);
 	void control_port_toggled (ControlUI* cui);
 	void control_combo_changed (GdkEventAny* ignored, ControlUI* cui);
-	gint entry_focus_event (GdkEventFocus* ev);
 
 	void redirect_active_changed (ARDOUR::Redirect*, void*);
 
diff --git a/gtk2_ardour/prompter.cc b/gtk2_ardour/prompter.cc
index 0839a5c8a7..08f089f404 100644
--- a/gtk2_ardour/prompter.cc
+++ b/gtk2_ardour/prompter.cc
@@ -26,7 +26,5 @@ using namespace sigc;
 ArdourPrompter::ArdourPrompter (bool modal)
 	: Gtkmm2ext::Prompter (modal)
 {
-	the_entry().signal_focus_in_event().connect (ptr_fun (ARDOUR_UI::generic_focus_in_event));
-	the_entry().signal_focus_out_event().connect (ptr_fun (ARDOUR_UI::generic_focus_out_event));
 }
 
diff --git a/gtk2_ardour/public_editor.h b/gtk2_ardour/public_editor.h
index 6ffbe098fa..9e73596b9f 100644
--- a/gtk2_ardour/public_editor.h
+++ b/gtk2_ardour/public_editor.h
@@ -94,6 +94,7 @@ class PublicEditor : public Gtk::Window, public Stateful {
 	virtual bool show_measures () const = 0;
 	virtual void export_session() = 0;
 	virtual void export_selection() = 0;
+	virtual void register_actions() = 0;
 	virtual void add_toplevel_controls (Gtk::Container&) = 0;
 	virtual void      set_zoom_focus (Editing::ZoomFocus) = 0;
 	virtual Editing::ZoomFocus get_zoom_focus () const = 0;
diff --git a/gtk2_ardour/region_editor.cc b/gtk2_ardour/region_editor.cc
index 616001ca76..dd3035cef6 100644
--- a/gtk2_ardour/region_editor.cc
+++ b/gtk2_ardour/region_editor.cc
@@ -70,9 +70,6 @@ AudioRegionEditor::AudioRegionEditor (Session&s, AudioRegion& r, AudioRegionView
 	name_entry.set_name ("AudioRegionEditorEntry");
 	name_label.set_name ("AudioRegionEditorLabel");
 
-	name_entry.signal_focus_in_event().connect (mem_fun(*this, &AudioRegionEditor::focus_change));
-	name_entry.signal_focus_out_event().connect (mem_fun(*this, &AudioRegionEditor::focus_change));
-	
 	name_hbox.set_spacing (5);
 	name_hbox.pack_start (name_label, false, false);
 	name_hbox.pack_start (name_entry, false, false);
@@ -204,8 +201,6 @@ AudioRegionEditor::AudioRegionEditor (Session&s, AudioRegion& r, AudioRegionView
 
 	fade_in_length_spinner.set_digits (3);
 
-	fade_in_length_spinner.signal_focus_in_event().connect (mem_fun(*this, &AudioRegionEditor::focus_change));
-	fade_in_length_spinner.signal_focus_out_event().connect (mem_fun(*this, &AudioRegionEditor::focus_change));
 	fade_in_length_spinner.signal_activate().connect (mem_fun(*this, &AudioRegionEditor::activation));
 
 	Gtkmm2ext::set_size_request_to_display_given_text (fade_in_length_spinner, "500g", 20, -1);
@@ -240,8 +235,6 @@ AudioRegionEditor::AudioRegionEditor (Session&s, AudioRegion& r, AudioRegionView
 	
 	fade_out_length_spinner.set_digits (3);
 
-	fade_out_length_spinner.signal_focus_in_event().connect (mem_fun(*this, &AudioRegionEditor::focus_change));
-	fade_out_length_spinner.signal_focus_out_event().connect (mem_fun(*this, &AudioRegionEditor::focus_change));
 	fade_out_length_spinner.signal_activate().connect (mem_fun(*this, &AudioRegionEditor::activation));
 
 	Gtkmm2ext::set_size_request_to_display_given_text (fade_out_length_spinner, "500g", 20, -1);
@@ -622,17 +615,6 @@ AudioRegionEditor::bounds_changed (Change what_changed)
 	}
 }
 
-gint
-AudioRegionEditor::focus_change (GdkEventFocus *ev)
-{
-	if (ev->in) {
-		ARDOUR_UI::instance()->allow_focus (true);
-	} else {
-		ARDOUR_UI::instance()->allow_focus (false);
-	}
-	return TRUE;
-}
-
 void
 AudioRegionEditor::activation ()
 {
diff --git a/gtk2_ardour/region_editor.h b/gtk2_ardour/region_editor.h
index fcf84beb3b..4c77e6186f 100644
--- a/gtk2_ardour/region_editor.h
+++ b/gtk2_ardour/region_editor.h
@@ -137,7 +137,6 @@ class AudioRegionEditor : public ArdourDialog
 	void fade_in_changed ();
 	void fade_out_changed ();
 
-	gint focus_change (GdkEventFocus *);
 	void activation ();
 
 	void name_entry_changed ();
diff --git a/gtk2_ardour/time_axis_view.cc b/gtk2_ardour/time_axis_view.cc
index 508ddb9260..47156bf672 100644
--- a/gtk2_ardour/time_axis_view.cc
+++ b/gtk2_ardour/time_axis_view.cc
@@ -88,9 +88,6 @@ TimeAxisView::TimeAxisView (ARDOUR::Session& sess, PublicEditor& ed, TimeAxisVie
 	name_entry.signal_button_release_event().connect (mem_fun (*this, &TimeAxisView::name_entry_button_release));
 	name_entry.signal_button_press_event().connect (mem_fun (*this, &TimeAxisView::name_entry_button_press));
 	
-	name_entry.signal_focus_in_event().connect (sigc::ptr_fun (ARDOUR_UI::generic_focus_in_event));
-	name_entry.signal_focus_out_event().connect (sigc::ptr_fun (ARDOUR_UI::generic_focus_out_event));
-
 	Gtkmm2ext::set_size_request_to_display_given_text (name_entry, N_("gTortnam"), 10, 10); // just represents a short name
 
 	name_label.set_name ("TrackLabel");
diff --git a/gtk2_ardour/utils.cc b/gtk2_ardour/utils.cc
index 0e1b3c80f5..bccdeb22bc 100644
--- a/gtk2_ardour/utils.cc
+++ b/gtk2_ardour/utils.cc
@@ -185,17 +185,10 @@ internationalize (const char **array)
 gint
 just_hide_it (GdkEventAny *ev, Gtk::Window *win)
 {
-	ARDOUR_UI::instance()->allow_focus (false);
 	win->hide_all ();
 	return TRUE;
 }
 
-void
-allow_keyboard_focus (bool yn)
-{
-	ARDOUR_UI::instance()->allow_focus (yn);
-}
-
 /* xpm2rgb copied from nixieclock, which bore the legend:
 
     nixieclock - a nixie desktop timepiece
diff --git a/gtk2_ardour/visual_time_axis.cc b/gtk2_ardour/visual_time_axis.cc
index 1f2de282d3..cb3d4d8c59 100644
--- a/gtk2_ardour/visual_time_axis.cc
+++ b/gtk2_ardour/visual_time_axis.cc
@@ -95,7 +95,6 @@ VisualTimeAxis::VisualTimeAxis(std::string name, PublicEditor& ed, ARDOUR::Sessi
 	_marked_for_display = true;
 	
 	name_entry.signal_activate().connect(mem_fun(*this, &VisualTimeAxis::name_entry_changed)) ;
-	name_entry.signal_focus_out_event().connect(mem_fun(*this, &VisualTimeAxis::name_entry_focus_out_handler)) ;
 	name_entry.signal_button_press_event().connect(mem_fun(*this, &VisualTimeAxis::name_entry_button_press_handler)) ;
 	name_entry.signal_button_release_event().connect(mem_fun(*this, &VisualTimeAxis::name_entry_button_release_handler)) ;
 	name_entry.signal_key_release_event().connect(mem_fun(*this, &VisualTimeAxis::name_entry_key_release_handler)) ;
@@ -359,7 +358,6 @@ VisualTimeAxis::start_time_axis_rename()
 	name_prompter = new ArdourPrompter() ;
 
 	name_prompter->set_prompt (_("new name: ")) ;
-	ARDOUR_UI::instance()->allow_focus(true) ;
 	name_prompter->show_all() ;
 
 	switch (name_prompter->run ()) {
@@ -401,8 +399,6 @@ VisualTimeAxis::label_view()
 void
 VisualTimeAxis::name_entry_changed()
 {
-	ARDOUR_UI::generic_focus_out_event (0);
-
 	string x = name_entry.get_text ();
 	
 	if (x == time_axis_name) {
@@ -440,13 +436,6 @@ VisualTimeAxis::name_entry_button_release_handler(GdkEventButton *ev)
 }
 
 gint
-VisualTimeAxis::name_entry_focus_out_handler(GdkEventFocus* ev)
-{
-	name_entry_changed();
-	return TRUE;
-}
-
-gint
 VisualTimeAxis::name_entry_key_release_handler(GdkEventKey* ev)
 {
 	switch (ev->keyval) {