move Session::Event into SessionEvent class; add SessionEventManager (Session IS-A SessionEventManager); make session ops to toggle all track rec-enable be atomic with respect to process()

git-svn-id: svn://localhost/ardour2/branches/3.0@6273 d708f5d6-7413-0410-9779-e7cbd77b26cf

19 files changed, 528 insertions, 460 deletions

diff --git a/libs/ardour/ardour/click.h b/libs/ardour/ardour/click.h
index 50efe7ce46..5ee1d50194 100644
--- a/libs/ardour/ardour/click.h
+++ b/libs/ardour/ardour/click.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2004 Paul Davis
+    Copyright (C) 2009 Paul Davis
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -20,17 +20,43 @@
 #ifndef __ardour_click_h__
 #define __ardour_click_h__
 
+#include <list>
+
+#include "pbd/pool.h"
+#include "ardour/types.h"
 #include "ardour/io.h"
 
 namespace ARDOUR {
 
+struct Click {
+    nframes_t start;
+    nframes_t duration;
+    nframes_t offset;
+    const Sample *data;
+
+    Click (nframes_t s, nframes_t d, const Sample *b) : start (s), duration (d), offset (0), data (b) {}
+    
+    void *operator new (size_t) {
+	    return pool.alloc ();
+    };
+    
+    void operator delete(void *ptr, size_t /*size*/) {
+	    pool.release (ptr);
+    }
+    
+private:
+    static Pool pool;
+};
+
+typedef std::list<Click*> Clicks;
+
 class ClickIO : public IO
 {
-public:
+  public:
 	ClickIO (Session& s, const std::string& name) : IO (s, name, IO::Output) {}
 	~ClickIO() {}
-
-protected:
+	
+  protected:
 	uint32_t pans_required () const { return 1; }
 };
 
diff --git a/libs/ardour/ardour/diskstream.h b/libs/ardour/ardour/diskstream.h
index 175b147852..87fffb92f7 100644
--- a/libs/ardour/ardour/diskstream.h
+++ b/libs/ardour/ardour/diskstream.h
@@ -85,6 +85,7 @@ class Diskstream : public SessionObject, public boost::noncopyable
 
 	bool         record_enabled() const { return g_atomic_int_get (&_record_enabled); }
 	virtual void set_record_enabled (bool yn) = 0;
+	virtual void get_input_sources () = 0;
 
 	bool destructive() const { return _flags & Destructive; }
 	virtual int set_destructive (bool /*yn*/) { return -1; }
@@ -233,7 +234,6 @@ class Diskstream : public SessionObject, public boost::noncopyable
 
 	virtual int use_pending_capture_data (XMLNode& node) = 0;
 
-	virtual void get_input_sources () = 0;
 	virtual void check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record);
 	virtual void prepare_record_status (nframes_t /*capture_start_frame*/) {}
 	virtual void set_align_style_from_io() {}
@@ -310,6 +310,7 @@ class Diskstream : public SessionObject, public boost::noncopyable
 	sigc::connection plmod_connection;
 	sigc::connection plgone_connection;
 	sigc::connection plregion_connection;
+	sigc::connection ic_connection;
 
 	Flag _flags;
 
diff --git a/libs/ardour/ardour/session.h b/libs/ardour/ardour/session.h
index 1260e3e997..0e21d6ff97 100644
--- a/libs/ardour/ardour/session.h
+++ b/libs/ardour/ardour/session.h
@@ -38,7 +38,6 @@
 #include <glibmm/thread.h>
 
 #include "pbd/error.h"
-#include "pbd/pool.h"
 #include "pbd/rcu.h"
 #include "pbd/statefuldestructible.h"
 #include "pbd/undo.h"
@@ -50,9 +49,11 @@
 #include "pbd/stateful.h"
 
 #include "ardour/ardour.h"
+#include "ardour/click.h"
 #include "ardour/chan_count.h"
 #include "ardour/rc_configuration.h"
 #include "ardour/session_configuration.h"
+#include "ardour/session_event.h"
 #include "ardour/location.h"
 #include "ardour/timecode.h"
 #include "ardour/interpolation.h"
@@ -120,7 +121,7 @@ class VSTPlugin;
 
 extern void setup_enum_writer ();
 
-class Session : public PBD::StatefulDestructible, public boost::noncopyable
+class Session : public PBD::StatefulDestructible, public SessionEventManager, public boost::noncopyable
 {
   private:
 	typedef std::pair<boost::weak_ptr<Route>,bool> RouteBooleanState;
@@ -135,100 +136,6 @@ class Session : public PBD::StatefulDestructible, public boost::noncopyable
 		Recording = 2
 	};
 
-        struct Event {
-	        enum Type {
-			SetTransportSpeed,
-			SetDiskstreamSpeed,
-			Locate,
-			LocateRoll,
-			LocateRollLocate,
-			SetLoop,
-			PunchIn,
-			PunchOut,
-			RangeStop,
-			RangeLocate,
-			Overwrite,
-			SetSyncSource,
-			Audition,
-			InputConfigurationChange,
-			SetPlayAudioRange,
-			
-			/* only one of each of these events can be queued at any one time */
-			
-			StopOnce,
-			AutoLoop
-		};
-	    
-	         enum Action {
-			 Add,
-			 Remove,
-			 Replace,
-			 Clear
-		 };
-	    
-	    Type             type;
-	    Action           action;
-	    nframes64_t      action_frame;
-	    nframes64_t      target_frame;
-	    double           speed;
-	    
-	    union {
-		void*        ptr;
-		bool         yes_or_no;
-		nframes64_t  target2_frame;
-		Slave*       slave;
-		Route*       route;
-	    };
-
-	    union {
-		bool second_yes_or_no;
-	    };
-	    
-	    std::list<AudioRange> audio_range;
-	    std::list<MusicRange> music_range;
-	    
-	    boost::shared_ptr<Region> region;
-	    
-	    Event(Type t, Action a, nframes_t when, nframes_t where, double spd, bool yn = false, bool yn2 = false)
-			: type (t)
-			, action (a)
-			, action_frame (when)
-			, target_frame (where)
-			, speed (spd)
-			, yes_or_no (yn)
-			, second_yes_or_no (yn2)
-		{}
-
-	    void set_ptr (void* p) {
-		    ptr = p;
-	    }
-	    
-	    bool before (const Event& other) const {
-		    return action_frame < other.action_frame;
-	    }
-	    
-	    bool after (const Event& other) const {
-		    return action_frame > other.action_frame;
-	    }
-	    
-	    static bool compare (const Event *e1, const Event *e2) {
-		    return e1->before (*e2);
-	    }
-	    
-	    void *operator new (size_t) {
-		    return pool.alloc ();
-	    }
-	    
-	    void operator delete (void *ptr, size_t /*size*/) {
-		    pool.release (ptr);
-	    }
-	    
-	    static const nframes_t Immediate = 0;
-	    
-	private:
-	    static MultiAllocSingleReleasePool pool;
-	};
-
 	/* creating from an XML file */
 
 	Session (AudioEngine&,
@@ -458,10 +365,6 @@ class Session : public PBD::StatefulDestructible, public boost::noncopyable
 
 	void reset_input_monitor_state ();
 
-	void add_event (nframes_t action_frame, Event::Type type, nframes_t target_frame = 0);
-	void remove_event (nframes_t frame, Event::Type type);
-	void clear_events (Event::Type type);
-
 	nframes_t get_block_size()        const { return current_block_size; }
 	nframes_t worst_output_latency () const { return _worst_output_latency; }
 	nframes_t worst_input_latency ()  const { return _worst_input_latency; }
@@ -1160,8 +1063,6 @@ class Session : public PBD::StatefulDestructible, public boost::noncopyable
 
 	boost::scoped_ptr<SessionDirectory> _session_dir;
 
-	RingBuffer<Event*> pending_events;
-
 	void hookup_io ();
 	void when_engine_running ();
 	void graph_reordered ();
@@ -1247,27 +1148,6 @@ class Session : public PBD::StatefulDestructible, public boost::noncopyable
 	sigc::connection auto_loop_changed_connection;
 	void             auto_loop_changed (Location *);
 
-	typedef std::list<Event *> Events;
-	Events           events;
-	Events           immediate_events;
-	Events::iterator next_event;
-
-	/* there can only ever be one of each of these */
-
-	Event *auto_loop_event;
-	Event *punch_out_event;
-	Event *punch_in_event;
-
-	/* events */
-
-	void dump_events () const;
-	void queue_event (Event *ev);
-	void merge_event (Event*);
-	void replace_event (Event::Type, nframes_t action_frame, nframes_t target = 0);
-	bool _replace_event (Event*);
-	bool _remove_event (Event *);
-	void _clear_event_type (Event::Type);
-
 	void first_stage_init (std::string path, std::string snapshot_name);
 	int  second_stage_init (bool new_tracks);
 	void find_current_end ();
@@ -1299,8 +1179,12 @@ class Session : public PBD::StatefulDestructible, public boost::noncopyable
 
 	void *do_work();
 
+	/* SessionEventManager interface */
+
+	void queue_event (SessionEvent*);
+	void process_event (SessionEvent*);
 	void set_next_event ();
-	void process_event (Event *ev);
+	void cleanup_event (SessionEvent*,int);
 
 	/* MIDI Machine Control */
 
@@ -1585,34 +1469,12 @@ class Session : public PBD::StatefulDestructible, public boost::noncopyable
 	int  jack_sync_callback (jack_transport_state_t, jack_position_t*);
 	void reset_jack_connection (jack_client_t* jack);
 	void record_enable_change_all (bool yn);
+	void do_record_enable_change_all (RouteList*, bool);
 
 	XMLNode& state(bool);
 
 	/* click track */
 
-	struct Click {
-		nframes_t start;
-		nframes_t duration;
-		nframes_t offset;
-		const Sample *data;
-
-		Click (nframes_t s, nframes_t d, const Sample *b)
-			: start (s), duration (d), data (b) { offset = 0; }
-
-		void *operator new (size_t) {
-			return pool.alloc ();
-		};
-
-		void operator delete(void *ptr, size_t /*size*/) {
-			pool.release (ptr);
-		}
-
-	private:
-		static Pool pool;
-	};
-
-	typedef std::list<Click*> Clicks;
-
 	Clicks                 clicks;
 	bool                  _clicking;
 	boost::shared_ptr<IO> _click_io;
diff --git a/libs/ardour/ardour/session_event.h b/libs/ardour/ardour/session_event.h
new file mode 100644
index 0000000000..767c374988
--- /dev/null
+++ b/libs/ardour/ardour/session_event.h
@@ -0,0 +1,152 @@
+#ifndef __ardour_session_event_h__
+#define __ardour_session_event_h__
+
+#include <list>
+#include <boost/shared_ptr.hpp>
+#include <sigc++/signal.h>
+
+#include "pbd/pool.h"
+#include "pbd/ringbuffer.h"
+
+#include "ardour/types.h"
+
+namespace ARDOUR {
+
+class Slave;
+class Region;
+
+struct SessionEvent {
+    enum Type {
+	    SetTransportSpeed,
+	    SetDiskstreamSpeed,
+	    Locate,
+	    LocateRoll,
+	    LocateRollLocate,
+	    SetLoop,
+	    PunchIn,
+	    PunchOut,
+	    RangeStop,
+	    RangeLocate,
+	    Overwrite,
+	    SetSyncSource,
+	    Audition,
+	    InputConfigurationChange,
+	    SetPlayAudioRange,
+	    SetRecordEnable,
+
+	    /* only one of each of these events can be queued at any one time */
+	    
+	    StopOnce,
+	    AutoLoop
+    };
+    
+    enum Action {
+	    Add,
+	    Remove,
+	    Replace,
+	    Clear
+    };
+    
+    Type             type;
+    Action           action;
+    nframes64_t      action_frame;
+    nframes64_t      target_frame;
+    double           speed;
+    
+    union {
+	void*        ptr;
+	bool         yes_or_no;
+	nframes64_t  target2_frame;
+	Slave*       slave;
+	Route*       route;
+    };
+    
+    union {
+	bool second_yes_or_no;
+	RouteList* routes;
+    };
+
+    std::list<AudioRange> audio_range;
+    std::list<MusicRange> music_range;
+    
+    boost::shared_ptr<Region> region;
+
+    sigc::signal<void,SessionEvent*,int> Complete;
+    
+    SessionEvent (Type t, Action a, nframes_t when, nframes_t where, double spd, bool yn = false, bool yn2 = false)
+	    : type (t)
+	    , action (a)
+	    , action_frame (when)
+	    , target_frame (where)
+	    , speed (spd)
+	    , yes_or_no (yn)
+	    , second_yes_or_no (yn2) {}
+
+    void set_ptr (void* p) {
+	    ptr = p;
+    }
+    
+    bool before (const SessionEvent& other) const {
+	    return action_frame < other.action_frame;
+    }
+    
+    bool after (const SessionEvent& other) const {
+	    return action_frame > other.action_frame;
+    }
+    
+    static bool compare (const SessionEvent *e1, const SessionEvent *e2) {
+	    return e1->before (*e2);
+    }
+    
+    void *operator new (size_t) {
+	    return pool.alloc ();
+    }
+    
+    void operator delete (void *ptr, size_t /*size*/) {
+	    pool.release (ptr);
+    }
+    
+    static const nframes_t Immediate = 0;
+    
+private:
+    static MultiAllocSingleReleasePool pool;
+};
+
+class SessionEventManager {
+   public:
+        SessionEventManager () : pending_events (2048){}
+        virtual ~SessionEventManager() {}
+
+	void add_event (nframes64_t action_frame, SessionEvent::Type type, nframes64_t target_frame = 0);
+	void remove_event (nframes64_t frame, SessionEvent::Type type);
+	void clear_events (SessionEvent::Type type);
+
+
+  protected:
+        RingBuffer<SessionEvent*> pending_events;
+	typedef std::list<SessionEvent *> Events;
+	Events           events;
+	Events           immediate_events;
+	Events::iterator next_event;
+
+	/* there can only ever be one of each of these */
+
+	SessionEvent *auto_loop_event;
+	SessionEvent *punch_out_event;
+        SessionEvent *punch_in_event;
+    
+	void dump_events () const;
+	void merge_event (SessionEvent*);
+	void replace_event (SessionEvent::Type, nframes64_t action_frame, nframes64_t target = 0);
+	bool _replace_event (SessionEvent*);
+	bool _remove_event (SessionEvent *);
+	void _clear_event_type (SessionEvent::Type);
+
+        virtual void process_event(SessionEvent*) = 0;
+        virtual void queue_event (SessionEvent *ev) = 0; 
+        virtual void set_next_event () = 0;
+};
+
+} /* namespace */
+
+#endif /* __ardour_session_event_h__ */
diff --git a/libs/ardour/ardour/track.h b/libs/ardour/ardour/track.h
index 02cab70a84..82cb83ad16 100644
--- a/libs/ardour/ardour/track.h
+++ b/libs/ardour/ardour/track.h
@@ -144,7 +144,6 @@ class Track : public Route
 	FreezeRecord          _freeze_record;
 	XMLNode*              pending_state;
 	sigc::connection      recenable_connection;
-	sigc::connection      ic_connection;
 	bool                  _destructive;
 
 	boost::shared_ptr<RecEnableControllable> _rec_enable_control;
diff --git a/libs/ardour/audio_diskstream.cc b/libs/ardour/audio_diskstream.cc
index e72f6d0ef6..c53d327b7f 100644
--- a/libs/ardour/audio_diskstream.cc
+++ b/libs/ardour/audio_diskstream.cc
@@ -1651,15 +1651,6 @@ AudioDiskstream::set_record_enabled (bool yn)
 		return;
 	}
 
-	if (yn && channels.reader()->front()->source == 0) {
-
-		/* pick up connections not initiated *from* the IO object
-		   we're associated with.
-		*/
-
-		get_input_sources ();
-	}
-
 	/* yes, i know that this not proof against race conditions, but its
 	   good enough. i think.
 	*/
diff --git a/libs/ardour/audio_track.cc b/libs/ardour/audio_track.cc
index a7f795ba8e..93814bcc14 100644
--- a/libs/ardour/audio_track.cc
+++ b/libs/ardour/audio_track.cc
@@ -193,9 +193,6 @@ AudioTrack::set_diskstream (boost::shared_ptr<AudioDiskstream> ds, void * /*src*
 	_diskstream->set_record_enabled (false);
 	_diskstream->monitor_input (false);
 
-	ic_connection.disconnect();
-	ic_connection = _input->changed.connect (mem_fun (*_diskstream, &Diskstream::handle_input_change));
-
 	DiskstreamChanged (); /* EMIT SIGNAL */
 
 	return 0;
diff --git a/libs/ardour/diskstream.cc b/libs/ardour/diskstream.cc
index e2dfc27100..b1d5a92355 100644
--- a/libs/ardour/diskstream.cc
+++ b/libs/ardour/diskstream.cc
@@ -141,6 +141,10 @@ Diskstream::set_route (Route& r)
 {
 	_route = &r;
 	_io = _route->input();
+
+	ic_connection.disconnect();
+	ic_connection = _io->changed.connect (mem_fun (*this, &Diskstream::handle_input_change));
+
 	input_change_pending = ConfigurationChanged;
 	non_realtime_input_change ();
 	set_align_style_from_io ();
diff --git a/libs/ardour/enums.cc b/libs/ardour/enums.cc
index 4b82950f3e..aa7dda9e50 100644
--- a/libs/ardour/enums.cc
+++ b/libs/ardour/enums.cc
@@ -76,7 +76,7 @@ setup_enum_writer ()
 	ShuttleBehaviour _ShuttleBehaviour;
 	ShuttleUnits _ShuttleUnits;
 	Session::RecordState _Session_RecordState;
-	Session::Event::Type _Session_Event_Type;
+	SessionEvent::Type _SessionEvent_Type;
 	TimecodeFormat _Session_TimecodeFormat;
 	Session::PullupFormat _Session_PullupFormat;
 	AudioRegion::FadeShape _AudioRegion_FadeShape;
@@ -290,24 +290,25 @@ setup_enum_writer ()
 	REGISTER_CLASS_ENUM (Session, Recording);
 	REGISTER (_Session_RecordState);
 
-	REGISTER_CLASS_ENUM (Session::Event, SetTransportSpeed);
-	REGISTER_CLASS_ENUM (Session::Event, SetDiskstreamSpeed);
-	REGISTER_CLASS_ENUM (Session::Event, Locate);
-	REGISTER_CLASS_ENUM (Session::Event, LocateRoll);
-	REGISTER_CLASS_ENUM (Session::Event, LocateRollLocate);
-	REGISTER_CLASS_ENUM (Session::Event, SetLoop);
-	REGISTER_CLASS_ENUM (Session::Event, PunchIn);
-	REGISTER_CLASS_ENUM (Session::Event, PunchOut);
-	REGISTER_CLASS_ENUM (Session::Event, RangeStop);
-	REGISTER_CLASS_ENUM (Session::Event, RangeLocate);
-	REGISTER_CLASS_ENUM (Session::Event, Overwrite);
-	REGISTER_CLASS_ENUM (Session::Event, SetSyncSource);
-	REGISTER_CLASS_ENUM (Session::Event, Audition);
-	REGISTER_CLASS_ENUM (Session::Event, InputConfigurationChange);
-	REGISTER_CLASS_ENUM (Session::Event, SetPlayAudioRange);
-	REGISTER_CLASS_ENUM (Session::Event, StopOnce);
-	REGISTER_CLASS_ENUM (Session::Event, AutoLoop);
-	REGISTER (_Session_Event_Type);
+	REGISTER_CLASS_ENUM (SessionEvent, SetTransportSpeed);
+	REGISTER_CLASS_ENUM (SessionEvent, SetDiskstreamSpeed);
+	REGISTER_CLASS_ENUM (SessionEvent, Locate);
+	REGISTER_CLASS_ENUM (SessionEvent, LocateRoll);
+	REGISTER_CLASS_ENUM (SessionEvent, LocateRollLocate);
+	REGISTER_CLASS_ENUM (SessionEvent, SetLoop);
+	REGISTER_CLASS_ENUM (SessionEvent, PunchIn);
+	REGISTER_CLASS_ENUM (SessionEvent, PunchOut);
+	REGISTER_CLASS_ENUM (SessionEvent, RangeStop);
+	REGISTER_CLASS_ENUM (SessionEvent, RangeLocate);
+	REGISTER_CLASS_ENUM (SessionEvent, Overwrite);
+	REGISTER_CLASS_ENUM (SessionEvent, SetSyncSource);
+	REGISTER_CLASS_ENUM (SessionEvent, Audition);
+	REGISTER_CLASS_ENUM (SessionEvent, InputConfigurationChange);
+	REGISTER_CLASS_ENUM (SessionEvent, SetPlayAudioRange);
+	REGISTER_CLASS_ENUM (SessionEvent, SetRecordEnable);
+	REGISTER_CLASS_ENUM (SessionEvent, StopOnce);
+	REGISTER_CLASS_ENUM (SessionEvent, AutoLoop);
+	REGISTER (_SessionEvent_Type);
 
 	REGISTER_CLASS_ENUM (Session, Stopped);
 	REGISTER_CLASS_ENUM (Session, Waiting);
diff --git a/libs/ardour/midi_diskstream.cc b/libs/ardour/midi_diskstream.cc
index 3712e74676..7787a9ff5a 100644
--- a/libs/ardour/midi_diskstream.cc
+++ b/libs/ardour/midi_diskstream.cc
@@ -1128,15 +1128,6 @@ MidiDiskstream::set_record_enabled (bool yn)
 
 	assert(!destructive());
 
-	if (yn && _source_port == 0) {
-
-		/* pick up connections not initiated *from* the IO object
-		   we're associated with.
-		*/
-
-		get_input_sources ();
-	}
-
 	/* yes, i know that this not proof against race conditions, but its
 	   good enough. i think.
 	*/
diff --git a/libs/ardour/midi_track.cc b/libs/ardour/midi_track.cc
index 2aac811e65..3c13a7635c 100644
--- a/libs/ardour/midi_track.cc
+++ b/libs/ardour/midi_track.cc
@@ -111,9 +111,6 @@ MidiTrack::set_diskstream (boost::shared_ptr<MidiDiskstream> ds)
 	_diskstream->set_record_enabled (false);
 	//_diskstream->monitor_input (false);
 
-	ic_connection.disconnect();
-	ic_connection = _input->changed.connect (mem_fun (*_diskstream, &MidiDiskstream::handle_input_change));
-
 	DiskstreamChanged (); /* EMIT SIGNAL */
 
 	return 0;
diff --git a/libs/ardour/session.cc b/libs/ardour/session.cc
index 82ca9eee98..8270399d63 100644
--- a/libs/ardour/session.cc
+++ b/libs/ardour/session.cc
@@ -133,7 +133,6 @@ Session::Session (AudioEngine &eng,
 	  _midi_port (default_midi_port),
 	  _midi_clock_port (default_midi_clock_port),
 	  _session_dir (new SessionDirectory(fullpath)),
-	  pending_events (2048),
 	  state_tree (0),
 	  _butler (new Butler (this)),
 	  _post_transport_work (0),
@@ -219,7 +218,6 @@ Session::Session (AudioEngine &eng,
 	  _midi_port (default_midi_port),
 	  _midi_clock_port (default_midi_clock_port),
 	  _session_dir ( new SessionDirectory(fullpath)),
-	  pending_events (2048),
 	  state_tree (0),
 	  _butler (new Butler (this)),
 	  _post_transport_work (0),
@@ -916,7 +914,7 @@ Session::reset_input_monitor_state ()
 void
 Session::auto_punch_start_changed (Location* location)
 {
-	replace_event (Event::PunchIn, location->start());
+	replace_event (SessionEvent::PunchIn, location->start());
 
 	if (get_record_enabled() && config.get_punch_in()) {
 		/* capture start has been changed, so save new pending state */
@@ -929,7 +927,7 @@ Session::auto_punch_end_changed (Location* location)
 {
 	nframes_t when_to_stop = location->end();
 	// when_to_stop += _worst_output_latency + _worst_input_latency;
-	replace_event (Event::PunchOut, when_to_stop);
+	replace_event (SessionEvent::PunchOut, when_to_stop);
 }
 
 void
@@ -937,15 +935,15 @@ Session::auto_punch_changed (Location* location)
 {
 	nframes_t when_to_stop = location->end();
 
-	replace_event (Event::PunchIn, location->start());
+	replace_event (SessionEvent::PunchIn, location->start());
 	//when_to_stop += _worst_output_latency + _worst_input_latency;
-	replace_event (Event::PunchOut, when_to_stop);
+	replace_event (SessionEvent::PunchOut, when_to_stop);
 }
 
 void
 Session::auto_loop_changed (Location* location)
 {
-	replace_event (Event::AutoLoop, location->end(), location->start());
+	replace_event (SessionEvent::AutoLoop, location->end(), location->start());
 
 	if (transport_rolling() && play_loop) {
 
@@ -954,7 +952,7 @@ Session::auto_loop_changed (Location* location)
 
 		if (_transport_frame < location->start() || _transport_frame > location->end()) {
 			// relocate to beginning of loop
-			clear_events (Event::LocateRoll);
+			clear_events (SessionEvent::LocateRoll);
 
 			request_locate (location->start(), true);
 
@@ -966,8 +964,8 @@ Session::auto_loop_changed (Location* location)
 			loop_changing = true;
 
 			if (location->end() > last_loopend) {
-				clear_events (Event::LocateRoll);
-				Event *ev = new Event (Event::LocateRoll, Event::Add, last_loopend, last_loopend, 0, true);
+				clear_events (SessionEvent::LocateRoll);
+				SessionEvent *ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, last_loopend, last_loopend, 0, true);
 				queue_event (ev);
 			}
 
@@ -987,8 +985,8 @@ Session::set_auto_punch_location (Location* location)
 		auto_punch_end_changed_connection.disconnect();
 		auto_punch_changed_connection.disconnect();
 		existing->set_auto_punch (false, this);
-		remove_event (existing->start(), Event::PunchIn);
-		clear_events (Event::PunchOut);
+		remove_event (existing->start(), SessionEvent::PunchIn);
+		clear_events (SessionEvent::PunchOut);
 		auto_punch_location_changed (0);
 	}
 
@@ -1029,7 +1027,7 @@ Session::set_auto_loop_location (Location* location)
 		auto_loop_end_changed_connection.disconnect();
 		auto_loop_changed_connection.disconnect();
 		existing->set_auto_loop (false, this);
-		remove_event (existing->end(), Event::AutoLoop);
+		remove_event (existing->end(), SessionEvent::AutoLoop);
 		auto_loop_location_changed (0);
 	}
 
@@ -3424,7 +3422,7 @@ Session::set_audition (boost::shared_ptr<Region> r)
 void
 Session::audition_playlist ()
 {
-	Event* ev = new Event (Event::Audition, Event::Add, Event::Immediate, 0, 0.0);
+	SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
 	ev->region.reset ();
 	queue_event (ev);
 }
@@ -3444,7 +3442,7 @@ Session::non_realtime_set_audition ()
 void
 Session::audition_region (boost::shared_ptr<Region> r)
 {
-	Event* ev = new Event (Event::Audition, Event::Add, Event::Immediate, 0, 0.0);
+	SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
 	ev->region = r;
 	queue_event (ev);
 }
@@ -3601,12 +3599,20 @@ Session::graph_reordered ()
 void
 Session::record_disenable_all ()
 {
+	if (!writable()) {
+		return;
+	}
+
 	record_enable_change_all (false);
 }
 
 void
 Session::record_enable_all ()
 {
+	if (!writable()) {
+		return;
+	}
+
 	record_enable_change_all (true);
 }
 
@@ -3614,16 +3620,33 @@ void
 Session::record_enable_change_all (bool yn)
 {
 	shared_ptr<RouteList> r = routes.reader ();
+	RouteList* tracks = new RouteList;
 
 	for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 		boost::shared_ptr<Track> t;
 
+		if (boost::dynamic_pointer_cast<Track>(*i) != 0) {
+			tracks->push_back (*i);
+		}
+	}
+
+	SessionEvent* ev = new SessionEvent (SessionEvent::SetRecordEnable, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0, yn);
+
+	ev->routes = tracks;
+	ev->Complete.connect (mem_fun (*this, &Session::cleanup_event));
+	queue_event (ev);
+}
+
+void
+Session::do_record_enable_change_all (RouteList* rl, bool yn)
+{
+	for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
+		boost::shared_ptr<Track> t;
+
 		if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
 			t->set_record_enable (yn, this);
 		}
 	}
-
-	/* since we don't keep rec-enable state, don't mark session dirty */
 }
 
 void
diff --git a/libs/ardour/session_butler.cc b/libs/ardour/session_butler.cc
index 0ffc14ff3a..156784875a 100644
--- a/libs/ardour/session_butler.cc
+++ b/libs/ardour/session_butler.cc
@@ -75,7 +75,7 @@ Session::schedule_curve_reallocation ()
 void
 Session::request_overwrite_buffer (Diskstream* stream)
 {
-	Event *ev = new Event (Event::Overwrite, Event::Add, Event::Immediate, 0, 0, 0.0);
+	SessionEvent *ev = new SessionEvent (SessionEvent::Overwrite, SessionEvent::Add, SessionEvent::Immediate, 0, 0, 0.0);
 	ev->set_ptr (stream);
 	queue_event (ev);
 }
diff --git a/libs/ardour/session_click.cc b/libs/ardour/session_click.cc
index 2e7e077ce7..363c5911b8 100644
--- a/libs/ardour/session_click.cc
+++ b/libs/ardour/session_click.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 20002 Paul Davis
+    Copyright (C) 2002 Paul Davis
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -35,7 +35,7 @@ using namespace std;
 using namespace ARDOUR;
 using namespace PBD;
 
-Pool Session::Click::pool ("click", sizeof (Click), 128);
+Pool Click::pool ("click", sizeof (Click), 128);
 
 void
 Session::click (nframes_t start, nframes_t nframes)
diff --git a/libs/ardour/session_events.cc b/libs/ardour/session_events.cc
index 88a34d5f36..98620e269f 100644
--- a/libs/ardour/session_events.cc
+++ b/libs/ardour/session_events.cc
@@ -24,13 +24,12 @@
 
 #include "pbd/error.h"
 #include "pbd/enumwriter.h"
-#include <glibmm/thread.h>
 
 #include "ardour/ardour.h"
 #include "ardour/audio_diskstream.h"
 #include "ardour/butler.h"
 #include "ardour/debug.h"
-#include "ardour/session.h"
+#include "ardour/session_event.h"
 
 #include "i18n.h"
 
@@ -38,39 +37,39 @@ using namespace std;
 using namespace ARDOUR;
 using namespace PBD;
 
-MultiAllocSingleReleasePool Session::Event::pool ("event", sizeof (Session::Event), 512);
+MultiAllocSingleReleasePool SessionEvent::pool ("event", sizeof (SessionEvent), 512);
 
 void
-Session::add_event (nframes_t frame, Event::Type type, nframes_t target_frame)
+SessionEventManager::add_event (nframes64_t frame, SessionEvent::Type type, nframes64_t target_frame)
 {
-	Event* ev = new Event (type, Event::Add, frame, target_frame, 0);
+	SessionEvent* ev = new SessionEvent (type, SessionEvent::Add, frame, target_frame, 0);
 	queue_event (ev);
 }
 
 void
-Session::remove_event (nframes_t frame, Event::Type type)
+SessionEventManager::remove_event (nframes64_t frame, SessionEvent::Type type)
 {
-	Event* ev = new Event (type, Event::Remove, frame, 0, 0);
+	SessionEvent* ev = new SessionEvent (type, SessionEvent::Remove, frame, 0, 0);
 	queue_event (ev);
 }
 
 void
-Session::replace_event (Event::Type type, nframes_t frame, nframes_t target)
+SessionEventManager::replace_event (SessionEvent::Type type, nframes64_t frame, nframes64_t target)
 {
-	Event* ev = new Event (type, Event::Replace, frame, target, 0);
+	SessionEvent* ev = new SessionEvent (type, SessionEvent::Replace, frame, target, 0);
 	queue_event (ev);
 }
 
 void
-Session::clear_events (Event::Type type)
+SessionEventManager::clear_events (SessionEvent::Type type)
 {
-	Event* ev = new Event (type, Event::Clear, 0, 0, 0);
+	SessionEvent* ev = new SessionEvent (type, SessionEvent::Clear, 0, 0, 0);
 	queue_event (ev);
 }
 
 
 void
-Session::dump_events () const
+SessionEventManager::dump_events () const
 {
 	cerr << "EVENT DUMP" << endl;
 	for (Events::const_iterator i = events.begin(); i != events.end(); ++i) {
@@ -93,34 +92,24 @@ Session::dump_events () const
 }
 
 void
-Session::queue_event (Event* ev)
-{
-	if (_state_of_the_state & Loading) {
-		merge_event (ev);
-	} else {
-		pending_events.write (&ev, 1);
-	}
-}
-
-void
-Session::merge_event (Event* ev)
+SessionEventManager::merge_event (SessionEvent* ev)
 {
 	switch (ev->action) {
-	case Event::Remove:
+	case SessionEvent::Remove:
 		_remove_event (ev);
 		delete ev;
 		return;
 
-	case Event::Replace:
+	case SessionEvent::Replace:
 		_replace_event (ev);
 		return;
 
-	case Event::Clear:
+	case SessionEvent::Clear:
 		_clear_event_type (ev->type);
 		delete ev;
 		return;
 
-	case Event::Add:
+	case SessionEvent::Add:
 		break;
 	}
 
@@ -132,8 +121,8 @@ Session::merge_event (Event* ev)
 	}
 
 	switch (ev->type) {
-	case Event::AutoLoop:
-	case Event::StopOnce:
+	case SessionEvent::AutoLoop:
+	case SessionEvent::StopOnce:
 		_clear_event_type (ev->type);
 		break;
 
@@ -148,14 +137,14 @@ Session::merge_event (Event* ev)
 	}
 
 	events.insert (events.begin(), ev);
-	events.sort (Event::compare);
+	events.sort (SessionEvent::compare);
 	next_event = events.begin();
 	set_next_event ();
 }
 
 /** @return true when @a ev is deleted. */
 bool
-Session::_replace_event (Event* ev)
+SessionEventManager::_replace_event (SessionEvent* ev)
 {
 	bool ret = false;
 	Events::iterator i;
@@ -178,7 +167,7 @@ Session::_replace_event (Event* ev)
 		events.insert (events.begin(), ev);
 	}
 
-	events.sort (Event::compare);
+	events.sort (SessionEvent::compare);
 	next_event = events.end();
 	set_next_event ();
 
@@ -187,7 +176,7 @@ Session::_replace_event (Event* ev)
 
 /** @return true when @a ev is deleted. */
 bool
-Session::_remove_event (Session::Event* ev)
+SessionEventManager::_remove_event (SessionEvent* ev)
 {
 	bool ret = false;
 	Events::iterator i;
@@ -215,7 +204,7 @@ Session::_remove_event (Session::Event* ev)
 }
 
 void
-Session::_clear_event_type (Event::Type type)
+SessionEventManager::_clear_event_type (SessionEvent::Type type)
 {
 	Events::iterator i, tmp;
 
@@ -251,179 +240,3 @@ Session::_clear_event_type (Event::Type type)
 	set_next_event ();
 }
 
-void
-Session::set_next_event ()
-{
-	if (events.empty()) {
-		next_event = events.end();
-		return;
-	}
-
-	if (next_event == events.end()) {
-		next_event = events.begin();
-	}
-
-	if ((*next_event)->action_frame > _transport_frame) {
-		next_event = events.begin();
-	}
-
-	for (; next_event != events.end(); ++next_event) {
-		if ((*next_event)->action_frame >= _transport_frame) {
-			break;
-		}
-	}
-}
-
-void
-Session::process_event (Event* ev)
-{
-	bool remove = true;
-	bool del = true;
-
-	/* if we're in the middle of a state change (i.e. waiting
-	   for the butler thread to complete the non-realtime
-	   part of the change), we'll just have to queue this
-	   event for a time when the change is complete.
-	*/
-
-	if (non_realtime_work_pending()) {
-
-		/* except locates, which we have the capability to handle */
-
-		if (ev->type != Event::Locate) {
-			immediate_events.insert (immediate_events.end(), ev);
-			_remove_event (ev);
-			return;
-		}
-	}
-
-	DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("Processing event: %1 @ %2\n", enum_2_string (ev->type), _transport_frame));
-
-	switch (ev->type) {
-	case Event::SetLoop:
-		set_play_loop (ev->yes_or_no);
-		break;
-
-	case Event::AutoLoop:
-		if (play_loop) {
-			start_locate (ev->target_frame, true, false, Config->get_seamless_loop());
-		}
-		remove = false;
-		del = false;
-		break;
-
-	case Event::Locate:
-		if (ev->yes_or_no) {
-			// cerr << "forced locate to " << ev->target_frame << endl;
-			locate (ev->target_frame, false, true, false);
-		} else {
-			// cerr << "soft locate to " << ev->target_frame << endl;
-			start_locate (ev->target_frame, false, true, false);
-		}
-		_send_timecode_update = true;
-		break;
-
-	case Event::LocateRoll:
-		if (ev->yes_or_no) {
-			// cerr << "forced locate to+roll " << ev->target_frame << endl;
-			locate (ev->target_frame, true, true, false);
-		} else {
-			// cerr << "soft locate to+roll " << ev->target_frame << endl;
-			start_locate (ev->target_frame, true, true, false);
-		}
-		_send_timecode_update = true;
-		break;
-
-	case Event::LocateRollLocate:
-		// locate is handled by ::request_roll_at_and_return()
-		_requested_return_frame = ev->target_frame;
-		request_locate (ev->target2_frame, true);
-		break;
-
-
-	case Event::SetTransportSpeed:
-		set_transport_speed (ev->speed, ev->yes_or_no, ev->second_yes_or_no);
-		break;
-
-	case Event::PunchIn:
-		// cerr << "PunchIN at " << transport_frame() << endl;
-		if (config.get_punch_in() && record_status() == Enabled) {
-			enable_record ();
-		}
-		remove = false;
-		del = false;
-		break;
-
-	case Event::PunchOut:
-		// cerr << "PunchOUT at " << transport_frame() << endl;
-		if (config.get_punch_out()) {
-			step_back_from_record ();
-		}
-		remove = false;
-		del = false;
-		break;
-
-	case Event::StopOnce:
-		if (!non_realtime_work_pending()) {
-			stop_transport (ev->yes_or_no);
-			_clear_event_type (Event::StopOnce);
-		}
-		remove = false;
-		del = false;
-		break;
-
-	case Event::RangeStop:
-		if (!non_realtime_work_pending()) {
-			stop_transport (ev->yes_or_no);
-		}
-		remove = false;
-		del = false;
-		break;
-
-	case Event::RangeLocate:
-		start_locate (ev->target_frame, true, true, false);
-		remove = false;
-		del = false;
-		break;
-
-	case Event::Overwrite:
-		overwrite_some_buffers (static_cast<Diskstream*>(ev->ptr));
-		break;
-
-	case Event::SetDiskstreamSpeed:
-		set_diskstream_speed (static_cast<Diskstream*> (ev->ptr), ev->speed);
-		break;
-
-	case Event::SetSyncSource:
-		use_sync_source (ev->slave);
-		break;
-
-	case Event::Audition:
-		set_audition (ev->region);
-		// drop reference to region
-		ev->region.reset ();
-		break;
-
-	case Event::InputConfigurationChange:
-		add_post_transport_work (PostTransportInputChange);
-		_butler->schedule_transport_work ();
-		break;
-
-	case Event::SetPlayAudioRange:
-		set_play_range (ev->audio_range, (ev->speed == 1.0f));
-		break;
-
-	default:
-	  fatal << string_compose(_("Programming error: illegal event type in process_event (%1)"), ev->type) << endmsg;
-		/*NOTREACHED*/
-		break;
-	};
-
-	if (remove) {
-		del = del && !_remove_event (ev);
-	}
-
-	if (del) {
-		delete ev;
-	}
-}
diff --git a/libs/ardour/session_process.cc b/libs/ardour/session_process.cc
index d7a92de3b2..329bb62174 100644
--- a/libs/ardour/session_process.cc
+++ b/libs/ardour/session_process.cc
@@ -23,6 +23,7 @@
 #include <unistd.h>
 
 #include "pbd/error.h"
+#include "pbd/enumwriter.h"
 
 #include <glibmm/thread.h>
 
@@ -274,7 +275,7 @@ Session::commit_diskstreams (nframes_t nframes, bool &needs_butler)
 void
 Session::process_with_events (nframes_t nframes)
 {
-	Event*         ev;
+	SessionEvent*         ev;
 	nframes_t      this_nframes;
 	nframes_t      end_frame;
 	bool           session_needs_butler = false;
@@ -299,7 +300,7 @@ Session::process_with_events (nframes_t nframes)
 	*/
 
 	while (!non_realtime_work_pending() && !immediate_events.empty()) {
-		Event *ev = immediate_events.front ();
+		SessionEvent *ev = immediate_events.front ();
 		immediate_events.pop_front ();
 		process_event (ev);
 	}
@@ -334,7 +335,7 @@ Session::process_with_events (nframes_t nframes)
 	end_frame = _transport_frame + (nframes_t)frames_moved;
 
 	{
-		Event* this_event;
+		SessionEvent* this_event;
 		Events::iterator the_next_one;
 
 		if (!process_can_proceed()) {
@@ -863,7 +864,7 @@ Session::process_without_events (nframes_t nframes)
 void
 Session::process_audition (nframes_t nframes)
 {
-	Event* ev;
+	SessionEvent* ev;
 	boost::shared_ptr<RouteList> r = routes.reader ();
 
 	for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
@@ -890,7 +891,7 @@ Session::process_audition (nframes_t nframes)
 	*/
 
 	while (!non_realtime_work_pending() && !immediate_events.empty()) {
-		Event *ev = immediate_events.front ();
+		SessionEvent *ev = immediate_events.front ();
 		immediate_events.pop_front ();
 		process_event (ev);
 	}
@@ -947,3 +948,209 @@ Session::maybe_sync_start (nframes_t& nframes)
 	return false;
 }
 
+void
+Session::queue_event (SessionEvent* ev)
+{
+	if (_state_of_the_state & Deletion) {
+		return;
+	} else if (_state_of_the_state & Loading) {
+		merge_event (ev);
+	} else {
+		pending_events.write (&ev, 1);
+	}
+}
+
+void
+Session::set_next_event ()
+{
+	if (events.empty()) {
+		next_event = events.end();
+		return;
+	}
+
+	if (next_event == events.end()) {
+		next_event = events.begin();
+	}
+
+	if ((*next_event)->action_frame > _transport_frame) {
+		next_event = events.begin();
+	}
+
+	for (; next_event != events.end(); ++next_event) {
+		if ((*next_event)->action_frame >= _transport_frame) {
+			break;
+		}
+	}
+}
+
+void
+Session::cleanup_event (SessionEvent* ev, int status)
+{
+	switch (ev->type) {
+	case SessionEvent::SetRecordEnable:
+		delete ev->routes;
+		break;
+	default:
+		break;
+	}
+}
+
+void
+Session::process_event (SessionEvent* ev)
+{
+	bool remove = true;
+	bool del = true;
+
+	/* if we're in the middle of a state change (i.e. waiting
+	   for the butler thread to complete the non-realtime
+	   part of the change), we'll just have to queue this
+	   event for a time when the change is complete.
+	*/
+
+	if (non_realtime_work_pending()) {
+
+		/* except locates, which we have the capability to handle */
+
+		if (ev->type != SessionEvent::Locate) {
+			immediate_events.insert (immediate_events.end(), ev);
+			_remove_event (ev);
+			return;
+		}
+	}
+
+	DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("Processing event: %1 @ %2\n", enum_2_string (ev->type), _transport_frame));
+
+	switch (ev->type) {
+	case SessionEvent::SetLoop:
+		set_play_loop (ev->yes_or_no);
+		break;
+
+	case SessionEvent::AutoLoop:
+		if (play_loop) {
+			start_locate (ev->target_frame, true, false, Config->get_seamless_loop());
+		}
+		remove = false;
+		del = false;
+		break;
+
+	case SessionEvent::Locate:
+		if (ev->yes_or_no) {
+			// cerr << "forced locate to " << ev->target_frame << endl;
+			locate (ev->target_frame, false, true, false);
+		} else {
+			// cerr << "soft locate to " << ev->target_frame << endl;
+			start_locate (ev->target_frame, false, true, false);
+		}
+		_send_timecode_update = true;
+		break;
+
+	case SessionEvent::LocateRoll:
+		if (ev->yes_or_no) {
+			// cerr << "forced locate to+roll " << ev->target_frame << endl;
+			locate (ev->target_frame, true, true, false);
+		} else {
+			// cerr << "soft locate to+roll " << ev->target_frame << endl;
+			start_locate (ev->target_frame, true, true, false);
+		}
+		_send_timecode_update = true;
+		break;
+
+	case SessionEvent::LocateRollLocate:
+		// locate is handled by ::request_roll_at_and_return()
+		_requested_return_frame = ev->target_frame;
+		request_locate (ev->target2_frame, true);
+		break;
+
+
+	case SessionEvent::SetTransportSpeed:
+		set_transport_speed (ev->speed, ev->yes_or_no, ev->second_yes_or_no);
+		break;
+
+	case SessionEvent::PunchIn:
+		// cerr << "PunchIN at " << transport_frame() << endl;
+		if (config.get_punch_in() && record_status() == Enabled) {
+			enable_record ();
+		}
+		remove = false;
+		del = false;
+		break;
+
+	case SessionEvent::PunchOut:
+		// cerr << "PunchOUT at " << transport_frame() << endl;
+		if (config.get_punch_out()) {
+			step_back_from_record ();
+		}
+		remove = false;
+		del = false;
+		break;
+
+	case SessionEvent::StopOnce:
+		if (!non_realtime_work_pending()) {
+			stop_transport (ev->yes_or_no);
+			_clear_event_type (SessionEvent::StopOnce);
+		}
+		remove = false;
+		del = false;
+		break;
+
+	case SessionEvent::RangeStop:
+		if (!non_realtime_work_pending()) {
+			stop_transport (ev->yes_or_no);
+		}
+		remove = false;
+		del = false;
+		break;
+
+	case SessionEvent::RangeLocate:
+		start_locate (ev->target_frame, true, true, false);
+		remove = false;
+		del = false;
+		break;
+
+	case SessionEvent::Overwrite:
+		overwrite_some_buffers (static_cast<Diskstream*>(ev->ptr));
+		break;
+
+	case SessionEvent::SetDiskstreamSpeed:
+		set_diskstream_speed (static_cast<Diskstream*> (ev->ptr), ev->speed);
+		break;
+
+	case SessionEvent::SetSyncSource:
+		use_sync_source (ev->slave);
+		break;
+
+	case SessionEvent::Audition:
+		set_audition (ev->region);
+		// drop reference to region
+		ev->region.reset ();
+		break;
+
+	case SessionEvent::InputConfigurationChange:
+		add_post_transport_work (PostTransportInputChange);
+		_butler->schedule_transport_work ();
+		break;
+
+	case SessionEvent::SetPlayAudioRange:
+		set_play_range (ev->audio_range, (ev->speed == 1.0f));
+		break;
+
+	case SessionEvent::SetRecordEnable:
+		do_record_enable_change_all (ev->routes, ev->yes_or_no);
+		break;
+
+	default:
+	  fatal << string_compose(_("Programming error: illegal event type in process_event (%1)"), ev->type) << endmsg;
+		/*NOTREACHED*/
+		break;
+	};
+
+	if (remove) {
+		del = del && !_remove_event (ev);
+	}
+
+	ev->Complete (ev, 0); /* EMIT SIGNAL */
+
+	if (del) {
+		delete ev;
+	}
+}
diff --git a/libs/ardour/session_state.cc b/libs/ardour/session_state.cc
index 55cf473683..79c937daeb 100644
--- a/libs/ardour/session_state.cc
+++ b/libs/ardour/session_state.cc
@@ -2947,9 +2947,9 @@ Session::config_changed (std::string p, bool ours)
 		if ((location = _locations.auto_punch_location()) != 0) {
 
 			if (config.get_punch_in ()) {
-				replace_event (Event::PunchIn, location->start());
+				replace_event (SessionEvent::PunchIn, location->start());
 			} else {
-				remove_event (location->start(), Event::PunchIn);
+				remove_event (location->start(), SessionEvent::PunchIn);
 			}
 		}
 
@@ -2960,9 +2960,9 @@ Session::config_changed (std::string p, bool ours)
 		if ((location = _locations.auto_punch_location()) != 0) {
 
 			if (config.get_punch_out()) {
-				replace_event (Event::PunchOut, location->end());
+				replace_event (SessionEvent::PunchOut, location->end());
 			} else {
-				clear_events (Event::PunchOut);
+				clear_events (SessionEvent::PunchOut);
 			}
 		}
 
diff --git a/libs/ardour/session_transport.cc b/libs/ardour/session_transport.cc
index 4055889c9c..36e910374b 100644
--- a/libs/ardour/session_transport.cc
+++ b/libs/ardour/session_transport.cc
@@ -73,7 +73,7 @@ void
 Session::request_input_change_handling ()
 {
 	if (!(_state_of_the_state & (InitialConnecting|Deletion))) {
-		Event* ev = new Event (Event::InputConfigurationChange, Event::Add, Event::Immediate, 0, 0.0);
+		SessionEvent* ev = new SessionEvent (SessionEvent::InputConfigurationChange, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
 		queue_event (ev);
 	}
 }
@@ -81,7 +81,7 @@ Session::request_input_change_handling ()
 void
 Session::request_sync_source (Slave* new_slave)
 {
-	Event* ev = new Event (Event::SetSyncSource, Event::Add, Event::Immediate, 0, 0.0);
+	SessionEvent* ev = new SessionEvent (SessionEvent::SetSyncSource, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
 	bool seamless;
 
 	seamless = Config->get_seamless_loop ();
@@ -104,7 +104,7 @@ Session::request_sync_source (Slave* new_slave)
 void
 Session::request_transport_speed (double speed)
 {
-	Event* ev = new Event (Event::SetTransportSpeed, Event::Add, Event::Immediate, 0, speed);
+	SessionEvent* ev = new SessionEvent (SessionEvent::SetTransportSpeed, SessionEvent::Add, SessionEvent::Immediate, 0, speed);
 	DEBUG_TRACE (DEBUG::Transport, string_compose ("Request transport speed = %1\n", speed));
 	queue_event (ev);
 }
@@ -112,7 +112,7 @@ Session::request_transport_speed (double speed)
 void
 Session::request_diskstream_speed (Diskstream& ds, double speed)
 {
-	Event* ev = new Event (Event::SetDiskstreamSpeed, Event::Add, Event::Immediate, 0, speed);
+	SessionEvent* ev = new SessionEvent (SessionEvent::SetDiskstreamSpeed, SessionEvent::Add, SessionEvent::Immediate, 0, speed);
 	ev->set_ptr (&ds);
 	queue_event (ev);
 }
@@ -120,7 +120,7 @@ Session::request_diskstream_speed (Diskstream& ds, double speed)
 void
 Session::request_stop (bool abort, bool clear_state)
 {
-	Event* ev = new Event (Event::SetTransportSpeed, Event::Add, Event::Immediate, 0, 0.0, abort, clear_state);
+	SessionEvent* ev = new SessionEvent (SessionEvent::SetTransportSpeed, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0, abort, clear_state);
 	DEBUG_TRACE (DEBUG::Transport, string_compose ("Request transport stop, abort = %1, clear state = %2\n", abort, clear_state));
 	queue_event (ev);
 }
@@ -128,7 +128,7 @@ Session::request_stop (bool abort, bool clear_state)
 void
 Session::request_locate (nframes_t target_frame, bool with_roll)
 {
-	Event *ev = new Event (with_roll ? Event::LocateRoll : Event::Locate, Event::Add, Event::Immediate, target_frame, 0, false);
+	SessionEvent *ev = new SessionEvent (with_roll ? SessionEvent::LocateRoll : SessionEvent::Locate, SessionEvent::Add, SessionEvent::Immediate, target_frame, 0, false);
 	DEBUG_TRACE (DEBUG::Transport, string_compose ("Request locate to %1\n", target_frame));
 	queue_event (ev);
 }
@@ -136,7 +136,7 @@ Session::request_locate (nframes_t target_frame, bool with_roll)
 void
 Session::force_locate (nframes64_t target_frame, bool with_roll)
 {
-	Event *ev = new Event (with_roll ? Event::LocateRoll : Event::Locate, Event::Add, Event::Immediate, target_frame, 0, true);
+	SessionEvent *ev = new SessionEvent (with_roll ? SessionEvent::LocateRoll : SessionEvent::Locate, SessionEvent::Add, SessionEvent::Immediate, target_frame, 0, true);
 	DEBUG_TRACE (DEBUG::Transport, string_compose ("Request forced locate to %1\n", target_frame));
 	queue_event (ev);
 }
@@ -144,7 +144,7 @@ Session::force_locate (nframes64_t target_frame, bool with_roll)
 void
 Session::request_play_loop (bool yn, bool leave_rolling)
 {
-	Event* ev;
+	SessionEvent* ev;
 	Location *location = _locations.auto_loop_location();
 
 	if (location == 0 && yn) {
@@ -153,7 +153,7 @@ Session::request_play_loop (bool yn, bool leave_rolling)
 		return;
 	}
 
-	ev = new Event (Event::SetLoop, Event::Add, Event::Immediate, 0, (leave_rolling ? 1.0 : 0.0), yn);
+	ev = new SessionEvent (SessionEvent::SetLoop, SessionEvent::Add, SessionEvent::Immediate, 0, (leave_rolling ? 1.0 : 0.0), yn);
 	DEBUG_TRACE (DEBUG::Transport, string_compose ("Request set loop = %1, leave rolling ? %2\n", yn, leave_rolling));
 	queue_event (ev);
 
@@ -167,7 +167,7 @@ Session::request_play_loop (bool yn, bool leave_rolling)
 void
 Session::request_play_range (list<AudioRange>* range, bool leave_rolling)
 {
-	Event* ev = new Event (Event::SetPlayAudioRange, Event::Add, Event::Immediate, 0, (leave_rolling ? 1.0 : 0.0));
+	SessionEvent* ev = new SessionEvent (SessionEvent::SetPlayAudioRange, SessionEvent::Add, SessionEvent::Immediate, 0, (leave_rolling ? 1.0 : 0.0));
 	if (range) {
 		ev->audio_range = *range;
 	} else {
@@ -222,9 +222,9 @@ Session::realtime_stop (bool abort, bool clear_state)
 		add_post_transport_work (todo);
 	}
 
-	_clear_event_type (Event::StopOnce);
-	_clear_event_type (Event::RangeStop);
-	_clear_event_type (Event::RangeLocate);
+	_clear_event_type (SessionEvent::StopOnce);
+	_clear_event_type (SessionEvent::RangeStop);
+	_clear_event_type (SessionEvent::RangeLocate);
 
 	disable_record (true);
 
@@ -615,7 +615,7 @@ void
 Session::unset_play_loop ()
 {
 	play_loop = false;
-	clear_events (Event::AutoLoop);
+	clear_events (SessionEvent::AutoLoop);
 	
 	// set all diskstreams to NOT use internal looping
 	boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
@@ -676,7 +676,7 @@ Session::set_play_loop (bool yn)
 			
 			/* put the loop event into the event list */
 			
-			Event* event = new Event (Event::AutoLoop, Event::Replace, loc->end(), loc->start(), 0.0f);
+			SessionEvent* event = new SessionEvent (SessionEvent::AutoLoop, SessionEvent::Replace, loc->end(), loc->start(), 0.0f);
 			merge_event (event);
 
 			/* locate to start of loop and roll. If doing seamless loop, force a 
@@ -1033,7 +1033,7 @@ Session::stop_transport (bool abort, bool clear_state)
 		   and then we'll really be stopped.
 		*/
 
-		Event *ev = new Event (Event::StopOnce, Event::Replace,
+		SessionEvent *ev = new SessionEvent (SessionEvent::StopOnce, SessionEvent::Replace,
 				       _transport_frame + _worst_output_latency - current_block_size,
 				       0, 0, abort);
 
@@ -1276,14 +1276,14 @@ void
 Session::unset_play_range ()
 {
 	_play_range = false;
-	_clear_event_type (Event::RangeStop);
-	_clear_event_type (Event::RangeLocate);
+	_clear_event_type (SessionEvent::RangeStop);
+	_clear_event_type (SessionEvent::RangeLocate);
 }
 
 void
 Session::set_play_range (list<AudioRange>& range, bool leave_rolling)
 {
-	Event* ev;
+	SessionEvent* ev;
 
 	/* Called from event-processing context */
 
@@ -1294,7 +1294,7 @@ Session::set_play_range (list<AudioRange>& range, bool leave_rolling)
 		 */
 		if (!leave_rolling) {
 			/* stop transport */
-			Event* ev = new Event (Event::SetTransportSpeed, Event::Add, Event::Immediate, 0, 0.0f, false);
+			SessionEvent* ev = new SessionEvent (SessionEvent::SetTransportSpeed, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0f, false);
 			merge_event (ev);
 		}
 		return;
@@ -1329,9 +1329,9 @@ Session::set_play_range (list<AudioRange>& range, bool leave_rolling)
 			}
 			
 			if (next == range.end()) {
-				ev = new Event (Event::RangeStop, Event::Add, requested_frame, 0, 0.0f);
+				ev = new SessionEvent (SessionEvent::RangeStop, SessionEvent::Add, requested_frame, 0, 0.0f);
 			} else {
-				ev = new Event (Event::RangeLocate, Event::Add, requested_frame, (*next).start, 0.0f);
+				ev = new SessionEvent (SessionEvent::RangeLocate, SessionEvent::Add, requested_frame, (*next).start, 0.0f);
 			}
 			
 			merge_event (ev);
@@ -1341,7 +1341,7 @@ Session::set_play_range (list<AudioRange>& range, bool leave_rolling)
 		
 	} else if (sz == 1) {
 
-		ev = new Event (Event::RangeStop, Event::Add, range.front().end, 0, 0.0f);
+		ev = new SessionEvent (SessionEvent::RangeStop, SessionEvent::Add, range.front().end, 0, 0.0f);
 		merge_event (ev);
 		
 	} 
@@ -1352,7 +1352,7 @@ Session::set_play_range (list<AudioRange>& range, bool leave_rolling)
 
 	/* now start rolling at the right place */
 
-	ev = new Event (Event::LocateRoll, Event::Add, Event::Immediate, range.front().start, 0.0f, false);
+	ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, SessionEvent::Immediate, range.front().start, 0.0f, false);
 	merge_event (ev);
 	
 	TransportStateChange ();
@@ -1370,7 +1370,7 @@ Session::request_bounded_roll (nframes_t start, nframes_t end)
 void
 Session::request_roll_at_and_return (nframes_t start, nframes_t return_to)
 {
-	Event *ev = new Event (Event::LocateRollLocate, Event::Add, Event::Immediate, return_to, 1.0);
+	SessionEvent *ev = new SessionEvent (SessionEvent::LocateRollLocate, SessionEvent::Add, SessionEvent::Immediate, return_to, 1.0);
 	ev->target2_frame = start;
 	queue_event (ev);
 }
diff --git a/libs/ardour/track.cc b/libs/ardour/track.cc
index 01201d38e7..acf0c50e18 100644
--- a/libs/ardour/track.cc
+++ b/libs/ardour/track.cc
@@ -192,13 +192,17 @@ Track::set_record_enable (bool yn, void *src)
 
 	_diskstream->set_record_enabled (yn);
 
+#if 0
 	if (_diskstream->record_enabled()) {
 		set_meter_point (MeterInput, this);
 	} else {
 		set_meter_point (_saved_meter_point, this);
 	}
+#endif
 
+	cerr << "4\n";
 	_rec_enable_control->Changed ();
+	cerr << "5\n";
 }