globally remove all trailing whitespace from ardour code base.

Paul Davis was responsible for introducing almost all of this.

56 files changed, 259 insertions, 259 deletions

diff --git a/libs/ardour/ardour/analyser.h b/libs/ardour/ardour/analyser.h
index cef71186cc..8e757ef4e9 100644
--- a/libs/ardour/ardour/analyser.h
+++ b/libs/ardour/ardour/analyser.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012 Paul Davis 
+    Copyright (C) 2012 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
diff --git a/libs/ardour/ardour/async_midi_port.h b/libs/ardour/ardour/async_midi_port.h
index cbe9bb1a9c..db86fda798 100644
--- a/libs/ardour/ardour/async_midi_port.h
+++ b/libs/ardour/ardour/async_midi_port.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 1998-2010 Paul Barton-Davis 
+    Copyright (C) 1998-2010 Paul Barton-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
     the Free Software Foundation; either version 2 of the License, or
@@ -51,9 +51,9 @@ class LIBARDOUR_API AsyncMIDIPort : public ARDOUR::MidiPort, public MIDI::Port {
 
 	void cycle_start (pframes_t nframes);
 	void cycle_end (pframes_t nframes);
-    
+
         /* called from non-RT context */
-    
+
 	void parse (framecnt_t timestamp);
 	int write (const MIDI::byte *msg, size_t msglen, MIDI::timestamp_t timestamp);
         int read (MIDI::byte *buf, size_t bufsize);
diff --git a/libs/ardour/ardour/audio_backend.h b/libs/ardour/ardour/audio_backend.h
index a0893b846a..73310bddb6 100644
--- a/libs/ardour/ardour/audio_backend.h
+++ b/libs/ardour/ardour/audio_backend.h
@@ -37,7 +37,7 @@
     #define ARDOURBACKEND_API LIBARDOUR_DLL_EXPORT
 #else
     #define ARDOURBACKEND_API LIBARDOUR_DLL_IMPORT
-#endif 
+#endif
 #define ARDOURBACKEND_LOCAL LIBARDOUR_DLL_LOCAL
 
 namespace ARDOUR {
@@ -46,7 +46,7 @@ struct LIBARDOUR_API AudioBackendInfo {
     const char* name;
 
     /** Using arg1 and arg2, initialize this audiobackend.
-     * 
+     *
      * Returns zero on success, non-zero otherwise.
      */
     int (*instantiate) (const std::string& arg1, const std::string& arg2);
@@ -56,7 +56,7 @@ struct LIBARDOUR_API AudioBackendInfo {
     int (*deinstantiate) (void);
 
     /** Factory method to create an AudioBackend-derived class.
-     * 
+     *
      * Returns a valid shared_ptr to the object if successfull,
      * or a "null" shared_ptr otherwise.
      */
@@ -85,7 +85,7 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
 
     AudioBackend (AudioEngine& e, AudioBackendInfo& i) : PortEngine (e), _info (i), engine (e) {}
     virtual ~AudioBackend () {}
-    
+
 	enum ErrorCode {
 		NoError = 0,
 		BackendInitializationError = -64,
@@ -156,7 +156,7 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
      * before any device can be selected. Return false otherwise.
      *
      * Intended mainly to differentiate between meta-APIs like JACK
-     * which can still expose different backends (such as ALSA or CoreAudio 
+     * which can still expose different backends (such as ALSA or CoreAudio
      * or FFADO or netjack) and those like ASIO or CoreAudio which
      * do not.
      */
@@ -180,7 +180,7 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
     virtual int set_driver (const std::string& /*drivername*/) { return 0; }
 
     /** used to list device names along with whether or not they are currently
-     *  available. 
+     *  available.
     */
     struct DeviceStatus {
 	std::string name;
@@ -330,12 +330,12 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
     virtual bool can_change_sample_rate_when_running () const = 0;
     /* Return true if the derived class can change the buffer size of the
      * device in use while the device is already being used. Return false
-     * otherwise. 
+     * otherwise.
      */
     virtual bool can_change_buffer_size_when_running () const = 0;
 
     /* Set the hardware parameters.
-     * 
+     *
      * If called when the current state is stopped or paused,
      * the changes will not take effect until the state changes to running.
      *
@@ -382,7 +382,7 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
      * If @param yn is true, then the hardware will interleave
      * samples for successive channels; otherwise, the hardware will store
      * samples for a single channel contiguously.
-     * 
+     *
      * Setting this does not change the fact that all data streams
      * to and from Ports are mono (essentially, non-interleaved)
      */
@@ -393,12 +393,12 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
     /** Set the number of output channels that should be used
      */
     virtual int set_output_channels (uint32_t) = 0;
-    /** Set the (additional) input latency that cannot be determined via 
+    /** Set the (additional) input latency that cannot be determined via
      * the implementation's underlying code (e.g. latency from
      * external D-A/D-A converters. Units are samples.
      */
     virtual int set_systemic_input_latency (uint32_t) = 0;
-    /** Set the (additional) output latency that cannot be determined via 
+    /** Set the (additional) output latency that cannot be determined via
      * the implementation's underlying code (e.g. latency from
      * external D-A/D-A converters. Units are samples.
      */
@@ -432,7 +432,7 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
      */
     virtual std::string  driver_name() const { return std::string(); }
 
-    /** Return the name of a control application for the 
+    /** Return the name of a control application for the
      * selected/in-use device. If no such application exists,
      * or if no device has been selected or is in-use,
      * return an empty string.
@@ -445,7 +445,7 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
     virtual void launch_control_app () = 0;
 
     /* @return a vector of strings that describe the available
-     * MIDI options. 
+     * MIDI options.
      *
      * These can be presented to the user to decide which
      * MIDI drivers, options etc. can be used. The returned strings
@@ -477,11 +477,11 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
     virtual bool can_set_systemic_midi_latencies () const = 0;
 
     /* State Control */
- 
+
     /** Start using the device named in the most recent call
      * to set_device(), with the parameters set by various
      * the most recent calls to set_sample_rate() etc. etc.
-     * 
+     *
      * At some undetermined time after this function is successfully called,
      * the backend will start calling the ::process_callback() method of
      * the AudioEngine referenced by @param engine. These calls will
@@ -507,28 +507,28 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
      * this pattern, or possibly just this:
      *
      * http://stackoverflow.com/questions/12139786/good-pratice-default-arguments-for-pure-virtual-method
-     */ 
+     */
     int start (bool for_latency_measurement=false) {
 	    return _start (for_latency_measurement);
     }
 
-    /** Stop using the device currently in use. 
+    /** Stop using the device currently in use.
      *
      * If the function is successfully called, no subsequent calls to the
      * process_callback() of @param engine will be made after the function
      * returns, until parameters are reset and start() are called again.
-     * 
+     *
      * The backend is considered to be un-configured after a successful
      * return, and requires calls to set hardware parameters before it can be
      * start()-ed again. See pause() for a way to avoid this. stop() should
-     * only be used when reconfiguration is required OR when there are no 
+     * only be used when reconfiguration is required OR when there are no
      * plans to use the backend in the future with a reconfiguration.
      *
      * Return zero if successful, 1 if the device is not in use, negative values on error
      */
     virtual int stop () = 0;
 
-	 /** Reset device. 
+	 /** Reset device.
      *
      * Return zero if successful, negative values on error
      */
@@ -557,8 +557,8 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
      * from 0.0 to 1.0
      *
      * E.g. if the buffer size represents 5msec and current processing
-     * takes 1msec, the returned value should be 0.2. 
-     * 
+     * takes 1msec, the returned value should be 0.2.
+     *
      * Implementations can feel free to smooth the values returned over
      * time (e.g. high pass filtering, or its equivalent).
      */
@@ -567,11 +567,11 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
     /* Transport Control (JACK is the only audio API that currently offers
        the concept of shared transport control)
     */
-    
-    /** Attempt to change the transport state to TransportRolling. 
+
+    /** Attempt to change the transport state to TransportRolling.
      */
     virtual void transport_start () {}
-    /** Attempt to change the transport state to TransportStopped. 
+    /** Attempt to change the transport state to TransportStopped.
      */
     virtual void transport_stop () {}
     /** return the current transport state
@@ -589,7 +589,7 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
      * timebase, otherwise cease to be the time master for the same.
      *
      * Return zero on success, non-zero otherwise
-     * 
+     *
      * JACK is the only currently known audio API with the concept of a shared
      * transport timebase.
      */
@@ -597,16 +597,16 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
 
     virtual int        usecs_per_cycle () const { return 1000000 * (buffer_size() / sample_rate()); }
     virtual size_t     raw_buffer_size (DataType t) = 0;
-    
+
     /* Process time */
-    
+
     /** return the time according to the sample clock in use, measured in
      * samples since an arbitrary zero time in the past. The value should
      * increase monotonically and linearly, without interruption from any
      * source (including CPU frequency scaling).
      *
      * It is extremely likely that any implementation will use a DLL, since
-     * this function can be called from any thread, at any time, and must be 
+     * this function can be called from any thread, at any time, and must be
      * able to accurately determine the correct sample time.
      *
      * Can be called from any thread.
@@ -620,7 +620,7 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
 
     /** Return the time since the current buffer process cycle started,
      * in samples, according to the sample clock in use.
-     * 
+     *
      * Can ONLY be called from within a process() callback tree (which
      * implies that it can only be called by a process thread)
      */
@@ -652,7 +652,7 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
     virtual int create_process_thread (boost::function<void()> func) = 0;
 
     /** Wait for all processing threads to exit.
-     * 
+     *
      * Return zero on success, non-zero on failure.
      */
     virtual int join_process_threads () = 0;
@@ -687,7 +687,7 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
      }
 
   protected:
-     AudioBackendInfo&  _info; 
+     AudioBackendInfo&  _info;
      AudioEngine&        engine;
 
      virtual int _start (bool for_latency_measurement) = 0;
@@ -696,4 +696,4 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
 } // namespace
 
 #endif /* __libardour_audiobackend_h__ */
-    
+
diff --git a/libs/ardour/ardour/audio_diskstream.h b/libs/ardour/ardour/audio_diskstream.h
index 33126b5baf..21a1789468 100644
--- a/libs/ardour/ardour/audio_diskstream.h
+++ b/libs/ardour/ardour/audio_diskstream.h
@@ -244,7 +244,7 @@ class LIBARDOUR_API AudioDiskstream : public Diskstream
 
         bool prep_record_enable ();
 	bool prep_record_disable ();
-    
+
 	// Working buffers for do_refill (butler thread)
 	static void allocate_working_buffers();
 	static void free_working_buffers();
diff --git a/libs/ardour/ardour/audio_port.h b/libs/ardour/ardour/audio_port.h
index ca5f183a13..384de3ef5d 100644
--- a/libs/ardour/ardour/audio_port.h
+++ b/libs/ardour/ardour/audio_port.h
@@ -54,7 +54,7 @@ class LIBARDOUR_API AudioPort : public Port
 
   private:
 	AudioBuffer* _buffer;
-        bool         _buf_valid; 
+        bool         _buf_valid;
 };
 
 } // namespace ARDOUR
diff --git a/libs/ardour/ardour/audio_track.h b/libs/ardour/ardour/audio_track.h
index 0bc8be81f4..e4a5dc356d 100644
--- a/libs/ardour/ardour/audio_track.h
+++ b/libs/ardour/ardour/audio_track.h
@@ -55,7 +55,7 @@ class LIBARDOUR_API AudioTrack : public Track
 
 	bool bounceable (boost::shared_ptr<Processor>, bool include_endpoint) const;
 	boost::shared_ptr<Region> bounce (InterThreadInfo&);
-	boost::shared_ptr<Region> bounce_range (framepos_t start, framepos_t end, InterThreadInfo&, 
+	boost::shared_ptr<Region> bounce_range (framepos_t start, framepos_t end, InterThreadInfo&,
 						boost::shared_ptr<Processor> endpoint, bool include_endpoint);
 	int export_stuff (BufferSet& bufs, framepos_t start_frame, framecnt_t nframes,
 			  boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze);
diff --git a/libs/ardour/ardour/audioengine.h b/libs/ardour/ardour/audioengine.h
index fcb1226e1a..e2ae52996d 100644
--- a/libs/ardour/ardour/audioengine.h
+++ b/libs/ardour/ardour/audioengine.h
@@ -75,7 +75,7 @@ class LIBARDOUR_API AudioEngine : public SessionHandlePtr, public PortManager
 
 	ProcessThread* main_thread() const { return _main_thread; }
 
-	/* START BACKEND PROXY API 
+	/* START BACKEND PROXY API
 	 *
 	 * See audio_backend.h for full documentation and semantics. These wrappers
 	 * just forward to a backend implementation.
@@ -139,7 +139,7 @@ class LIBARDOUR_API AudioEngine : public SessionHandlePtr, public PortManager
 	}
 
 	framecnt_t processed_frames() const { return _processed_frames; }
-    
+
 	void set_session (Session *);
 	void remove_session (); // not a replacement for SessionHandle::session_going_away()
 	Session* session() const { return _session; }
@@ -150,19 +150,19 @@ class LIBARDOUR_API AudioEngine : public SessionHandlePtr, public PortManager
 	    public:
 		virtual const char *what() const throw() { return "could not connect to engine backend"; }
 	};
-    
+
 	void split_cycle (pframes_t offset);
-    
+
 	int  reset_timebase ();
-    
+
 	void update_latencies ();
-    
+
 	/* this signal is sent for every process() cycle while freewheeling.
 	   (the regular process() call to session->process() is not made)
 	*/
-    
+
 	PBD::Signal1<int, pframes_t> Freewheel;
-    
+
 	PBD::Signal0<void> Xrun;
 
 	/** this signal is emitted if the sample rate changes */
@@ -175,30 +175,30 @@ class LIBARDOUR_API AudioEngine : public SessionHandlePtr, public PortManager
 	PBD::Signal0<void> DeviceError;
 
 	/* this signal is emitted if the device list changed */
-    
+
 	PBD::Signal0<void> DeviceListChanged;
-    
+
 	/* this signal is sent if the backend ever disconnects us */
-    
+
 	PBD::Signal1<void,const char*> Halted;
-    
+
 	/* these two are emitted when the engine itself is
 	   started and stopped
 	*/
-    
+
 	PBD::Signal0<void> Running;
 	PBD::Signal0<void> Stopped;
 
 	/* these two are emitted when a device reset is initiated/finished
 	 */
-    
+
 	PBD::Signal0<void> DeviceResetStarted;
 	PBD::Signal0<void> DeviceResetFinished;
 
 	static AudioEngine* instance() { return _instance; }
 	static void destroy();
 	void died ();
-    
+
 	/* The backend will cause these at the appropriate time(s)
 	 */
 	int  process_callback (pframes_t nframes);
diff --git a/libs/ardour/ardour/audioregion.h b/libs/ardour/ardour/audioregion.h
index 9172021e97..3de6de11fa 100644
--- a/libs/ardour/ardour/audioregion.h
+++ b/libs/ardour/ardour/audioregion.h
@@ -73,11 +73,11 @@ class LIBARDOUR_API AudioRegion : public Region
 	bool speed_mismatch (float) const;
 
 	boost::shared_ptr<AudioSource> audio_source (uint32_t n=0) const;
-    
+
     // if several audio files associated with a region,
     // information about file with MAX channel count will be provided
     uint32_t get_related_audio_file_channel_count () const;
-    
+
 	void   set_scale_amplitude (gain_t);
 	gain_t scale_amplitude() const { return _scale_amplitude; }
 
diff --git a/libs/ardour/ardour/buffer_manager.h b/libs/ardour/ardour/buffer_manager.h
index c73b59b763..1614854a89 100644
--- a/libs/ardour/ardour/buffer_manager.h
+++ b/libs/ardour/ardour/buffer_manager.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012 Paul Davis 
+    Copyright (C) 2012 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
diff --git a/libs/ardour/ardour/coreaudiosource.h b/libs/ardour/ardour/coreaudiosource.h
index 44016b46a4..d8175877b8 100644
--- a/libs/ardour/ardour/coreaudiosource.h
+++ b/libs/ardour/ardour/coreaudiosource.h
@@ -40,7 +40,7 @@ class LIBARDOUR_API CoreAudioSource : public AudioFileSource {
 	int update_header (framepos_t when, struct tm&, time_t);
 
     uint32_t channel_count () const { return n_channels; }
-    
+
 	int flush_header () {return 0;};
 	void set_header_timeline_position () {};
 	bool clamped_at_unity () const { return false; }
diff --git a/libs/ardour/ardour/data_type.h b/libs/ardour/ardour/data_type.h
index 2a4514a5cf..bc59aebeb6 100644
--- a/libs/ardour/ardour/data_type.h
+++ b/libs/ardour/ardour/data_type.h
@@ -81,7 +81,7 @@ public:
 		default:    return "unknown"; // reeeally shouldn't ever happen
 		}
 	}
-    
+
 	const char* to_i18n_string () const;
 
 	inline operator uint32_t() const { return (uint32_t)_symbol; }
diff --git a/libs/ardour/ardour/directory_names.h b/libs/ardour/ardour/directory_names.h
index 5c0eae909c..c2b4783be9 100644
--- a/libs/ardour/ardour/directory_names.h
+++ b/libs/ardour/ardour/directory_names.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012 Paul Davis 
+    Copyright (C) 2012 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
diff --git a/libs/ardour/ardour/engine_state_controller.h b/libs/ardour/ardour/engine_state_controller.h
index 737fb3b579..76ed08b3ab 100644
--- a/libs/ardour/ardour/engine_state_controller.h
+++ b/libs/ardour/ardour/engine_state_controller.h
@@ -1,20 +1,20 @@
 /*
   Copyright (C) 2014 Waves Audio Ltd.
- 
+
   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
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 #ifndef __gtk2_ardour__engine_state_controller__
@@ -29,7 +29,7 @@
 namespace ARDOUR {
 
 class AudioBackendInfo;
-    
+
 /**
  * @class EngineStateController
  * @brief EngineStateController class.
@@ -40,33 +40,33 @@ class AudioBackendInfo;
 class EngineStateController
 {
                                         public:
-    
+
 	// public data types:
-    
-	/** 
+
+	/**
 	 * @struct PortState
 	 * Structure which represents AudioPort state
 	 */
 	struct PortState {
 		std::string name; ///< Audio Port name
 		bool active;      ///< Audio Port state
-        
+
 		PortState ()
 			: name("")
 			, active(false)
 		{
 		}
-        
+
 		PortState (const std::string& name)
 			: name(name)
 			, active(false)
 		{
 		}
-        
+
 		bool operator==(const PortState& rhs) {return rhs.name == name; }
-        
+
 	};
-    
+
 	/// @typedef Type for the list of all available audio ports
 	typedef std::list<PortState> PortStateList;
 
@@ -81,7 +81,7 @@ class EngineStateController
 		bool available;       ///< Midi Port availability - if it is physicaly available or not
 		bool scene_connected; ///< Is midi port used for scene MIDI marker in/out
 		bool mtc_in;          ///< Is midi port used as MTC in
-        
+
 		MidiPortState(const std::string& name)
 			: name(name)
 			, active(false)
@@ -89,89 +89,89 @@ class EngineStateController
 			, scene_connected(false)
 			, mtc_in(false)
 		{}
-        
+
 		bool operator==(const MidiPortState& rhs)
 		{
 			return name == rhs.name;
 		}
 	};
-    
+
 	/// @typedef Type for the list of MidiPorts ever registered in the system
 	typedef std::list<MidiPortState> MidiPortStateList;
-    
+
 
 	//Interfaces
-    
+
 	/** Get an instance of EngineStateController singleton.
 	 * @return EngineStateController instance pointer
 	 */
 	static EngineStateController* instance ();
-    
+
 	/** Associate session with EngineStateController instance.
 	 */
 	void set_session (Session* session);
-    
+
 	/** Remove link to the associated session.
 	 */
 	void remove_session ();
-    
+
 	//////////////////////////////////////////////////////////////////////////////////////////////////////////
 	// General backend/device information methods
-    
+
 	/** Provides names of all available backends.
 	 *
 	 * @param[out] available_backends - vector of available backends
 	 */
 	void available_backends (std::vector<const AudioBackendInfo*>& available_backends);
-    
+
 	/** Provides the name of currently used backend.
 	 *
 	 * @return the name of currently used backend
 	 */
 	const std::string& get_current_backend_name() const;
-    
+
 	/** Provides the name of currently used device.
 	 *
 	 * @return the name of currently used device
 	 */
 	const std::string& get_current_device_name () const;
-    
+
 	/** Provides names for all available devices.
 	 *
 	 * @param[out] device_vector - vector of available devices
 	 */
 	void enumerate_devices (std::vector<ARDOUR::AudioBackend::DeviceStatus>& device_vector) const;
-    
+
 	/** Get sample rate used by current device.
 	 *
 	 * @return current sample rate
 	 */
 	ARDOUR::framecnt_t get_current_sample_rate () const;
-    
+
 	/** Get default sample rate for current backend.
 	 *
 	 * @return default sample rate for current backend
 	 */
 	ARDOUR::framecnt_t get_default_sample_rate () const;
-    
+
 	/** Get sample rates which are supported by current device and current backend.
 	 *
 	 * @param[out] sample_rates - vector of supported sample rates
 	 */
 	void available_sample_rates_for_current_device (std::vector<float>& sample_rates) const;
-    
+
 	/** Get buffer size used by current device.
 	 *
 	 * @return current buffer size
 	 */
 	ARDOUR::pframes_t get_current_buffer_size () const;
-    
+
 	/** Get default buffer size for current backend.
 	 *
 	 * @return default buffer size for current backend
 	 */
 	ARDOUR::pframes_t get_default_buffer_size () const;
-    
+
 	/** Get buffer sizes which are supported by current device and current backend.
 	 *
 	 * @param[out] buffer_sizes - vector of supported buffer_sizes
@@ -180,7 +180,7 @@ class EngineStateController
 
 	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 	// device state control methods
-    
+
 	/** Get the number of all enabled Audio inputs.
 	 *
 	 * @return number of all enabled Audio inputs
@@ -191,7 +191,7 @@ class EngineStateController
 	 * @return number of all enabled Audio outputs
 	 */
 	uint32_t            get_available_outputs_count () const;
-    
+
 	/** Get vector of all enabled physical Audio input port names.
 	 *
 	 * @param[out] port_names - vector of all enabled Audio input names
@@ -202,7 +202,7 @@ class EngineStateController
 	 * @param[out] port_names - vector of all enabled Audio input names
 	 */
 	void                get_physical_audio_outputs (std::vector<std::string>& port_names);
-    
+
 	/** Get vector of all enabled physical MIDI input port names.
 	 *
 	 * @param[out] port_names - vector of all enabled MIDI input names
@@ -213,7 +213,7 @@ class EngineStateController
 	 * @param[out] port_names - vector of all enabled MIDI output names
 	 */
 	void                get_physical_midi_outputs (std::vector<std::string>& port_names);
-    
+
 	/** Sets new state to all Audio inputs.
 	 *
 	 * @param[in] state - new state
@@ -224,7 +224,7 @@ class EngineStateController
 	 * @param[in] state - new state
 	 */
 	void                set_state_to_all_outputs(bool state);
-    
+
 	/** Get vector of states for all physical Audio input ports.
 	 *
 	 * @param[out] channel_states - vector of input port states
@@ -235,7 +235,7 @@ class EngineStateController
 	 * @param[out] channel_states - vector of output port states
 	 */
 	void                get_physical_audio_output_states(std::vector<PortState>& channel_states);
-    
+
 	/** Set state of the specified Audio input port.
 	 *
 	 * @param[in] port_name - input name
@@ -248,7 +248,7 @@ class EngineStateController
 	 * @param[in] state - new state
 	 */
 	void                set_physical_audio_output_state(const std::string& port_name, bool state);
-    
+
 	/** Get state of the specified Audio input port.
 	 *
 	 * @param[in] port_name - input name
@@ -261,7 +261,7 @@ class EngineStateController
 	 * @return output state
 	 */
 	bool                get_physical_audio_output_state(const std::string& port_name);
-    
+
 
 	/** Get vector of all enabled MIDI input port names.
 	 *
@@ -290,7 +290,7 @@ class EngineStateController
 	 * return name of ltc source port
 	 */
 	std::string          get_ltc_source_port ();
-    
+
 	/** Set ltc output port
 	 *
 	 * @param[in] port - name of ltc output port
@@ -301,7 +301,7 @@ class EngineStateController
 	 * return name of ltc output port
 	 */
 	std::string         get_ltc_output_port ();
-    
+
 	/** Set state of the specified MIDI input port.
 	 *
 	 * @param[in] port_name - input name
@@ -328,7 +328,7 @@ class EngineStateController
 	 * @return output state
 	 */
 	bool                get_physical_midi_output_state(const std::string& port_name, bool& scene_connected);
-    
+
 	/** Set state of Scene In connection for the specified MIDI input port.
 	 *
 	 * @param[in] port_name - input name
@@ -341,30 +341,30 @@ class EngineStateController
 	 * @param[in] state - new state
 	 */
 	void                set_physical_midi_scenen_out_connection_state(const std::string&, bool);
-    
+
 	/** Disocnnect all MIDI input ports from Scene In.
 	 */
 	void                set_all_midi_scene_inputs_disconnected();
 	/** Disocnnect all MIDI output ports from Scene Out.
 	 */
 	void                set_all_midi_scene_outputs_disconnected();
-    
+
 	/** Set MIDI TimeCode input port
 	 * @note There is a sense to choose MIDI TimeCode input only because
 	 * our MIDI TimeCode is propagated to all midi output ports.
 	 */
 	void                set_mtc_source_port (const std::string&);
-    
+
 	/** Check if AudioEngine setup is required
 	 * @return true if setup is required, otherwise - false
 	 */
 	bool                is_setup_required() const {return ARDOUR::AudioEngine::instance()->setup_required (); }
-    
+
 	////////////////////////////////////////////////////////////////////////////////////////////////////
 	// Methods set parameters inside the controller
 	// the state of engine won't change untill we make a "push" of this state to the backend
 	// NOTE: Use push_state_to_backend() method to update backend with the most recent controller state
-    
+
 	/** Set new sample rate for current device in EngineStateController database
 	 * @note Use push_state_to_backend() method to update backend/device state with the most recent controller state
 	 * @param sample_rate - new sample rate
@@ -375,7 +375,7 @@ class EngineStateController
 	 * @param buffer_size - new buffer size
 	 */
 	bool        set_new_buffer_size_in_controller(pframes_t buffer_size);
-    
+
 	/** @brief push current controller state to backend.
 	 * Propagate and set all current EngineStateController parameters to the backend
 	 * @note Engine will be restarted if it's running when this method is called.
@@ -397,7 +397,7 @@ class EngineStateController
 	 */
 	bool        set_new_device_as_current(const std::string& device_name);
 
-    
+
 	////////////////////////////////////////////////////////////////////////////////////////////////////
 	// Methods to save/serialize setting states
 
@@ -408,7 +408,7 @@ class EngineStateController
 	/** Save Audio/Midi settings (entire EngineStateController database) to config persistently
 	 */
 	void        save_audio_midi_settings();
-    
+
 	////////////////////////////////////////////////////////////////////////////////////////////////////
 	//UPDATE SIGNALS
 	/** This signal is emitted if the sample rate changes */
@@ -428,7 +428,7 @@ class EngineStateController
 	PBD::Signal0<void> EngineStopped;
 	/** This signal is emitted if Engine processing is terminated */
 	PBD::Signal0<void> EngineHalted;
-    
+
 	/** This signal is emitted if the AUDIO input channel configuration changes */
 	PBD::Signal0<void> InputConfigChanged;
 	/** This signal is emitted if the AUDIO output channel configuration changes */
@@ -437,7 +437,7 @@ class EngineStateController
 	 * @note By output connection mode "Stereo Out" or "Multi Out" is meant
 	 */
 	PBD::Signal0<void> OutputConnectionModeChanged;
-    
+
 	/** This signals is emitted if the MIDI input channel configuration changes */
 	PBD::Signal0<void> MIDIInputConfigChanged;
 	/** This signals is emitted if the MIDI output channel configuration changes */
@@ -446,23 +446,23 @@ class EngineStateController
 	PBD::Signal2<void, const std::vector<std::string>&, bool> MIDISceneInputConnectionChanged;
 	/** This signals is emitted if the MIDI Scene Out connection changes */
 	PBD::Signal2<void, const std::vector<std::string>&, bool> MIDISceneOutputConnectionChanged;
-    
+
 	/** This signal is emitted if the MTC Input channel is changed */
 	PBD::Signal1<void, const std::string&> MTCInputChanged;
-    
+
 	/** This signal is emitted if new Audio/MIDI ports are registered or unregistered */
 	PBD::Signal0<void> PortRegistrationChanged;
-    
+
                                         private:
 
 	EngineStateController(); /// singleton
 	~EngineStateController(); /// singleton
 	EngineStateController(const EngineStateController& ); /// prohibited
 	EngineStateController& operator=(const EngineStateController&); /// prohibited
-    
+
 	////////////////////////////////////////////////////////////////////////////////////////////
 	// private data structures
-    
+
 	/** @struct Engine state
 	 * @brief State structure.
 	 * Contains information about single device/backend state
@@ -477,7 +477,7 @@ class EngineStateController
 		PortStateList multi_out_channel_states; ///< states of device Audio inputs in Multi Out mode
 		PortStateList stereo_out_channel_states; ///< states of device Audio inputs in Stereo Out mode
 		bool active; ///< was this state the most recent active one
-        
+
 		State()
 			: sample_rate(0)
 			, buffer_size(0)
@@ -487,19 +487,19 @@ class EngineStateController
 			, active (false)
 		{
 		}
-        
+
 		bool operator==(const State& rhs)
 		{
 			return (backend_name == rhs.backend_name) && (device_name == rhs.device_name);
 		}
-        
+
 		/** Forms string name for the state
 		 * @return name string
 		 */
 		std::string form_state_name() {
 			return std::string("State:" + backend_name + ":" + device_name);
 		}
-        
+
 		/** @struct StatepPredicate
 		 * This predicate is used to identify a state during search in the list of states
 		 */
@@ -509,26 +509,26 @@ class EngineStateController
 				: _backend_name (backend_name)
 				, _device_name (device_name)
 			{}
-            
+
 			bool operator()(boost::shared_ptr<ARDOUR::EngineStateController::State> rhs)
 			{
 				return (_backend_name == rhs->backend_name) && (_device_name == rhs->device_name);
 			}
-            
+
 		                                        private:
 			std::string _backend_name;
 			std::string _device_name;
 		};
 	};
-    
+
 	/// @typedef Type for the state pointer
 	typedef boost::shared_ptr<State> StatePtr;
 	/// @typedef Type for the list of states
 	typedef std::list<StatePtr> StateList;
-    
+
 	////////////////////////////////////////////////////////////////////////////////////////////////////
 	// methods to manage setting states
-    
+
 	/** Deserializes and loads Engine and Audio port states from the config to EngineStateController
 	 */
 	void _deserialize_and_load_engine_states();
@@ -543,13 +543,13 @@ class EngineStateController
 	 * @param[in,out] audio_midi_settings_node - node to serialize the satets to
 	 */
 	void _serialize_midi_port_states(XMLNode* audio_midi_settings_node);
-    
+
 	/** Provides initial state configuration.
 	 * It loades the last active state if there is one and it is aplicable.
 	 * Otherwise default state (None device with default sample rate and buffer size) is loaded.
 	 */
 	void _do_initial_engine_setup();
-    
+
 	/** Loades provided state.
 	 * @note It's possible that provided state can't be loaded
 	 * (device disconnected or reqested parameters are not supported anymore).
@@ -557,15 +557,15 @@ class EngineStateController
 	 * @return true on success, otherwise - false
 	 */
 	bool _apply_state(const StatePtr& state);
-    
+
 	/** Gets available device channels from engine and updates internal controller state
 	 */
 	void _update_device_channels_state();
-    
+
 	/** Check "Stereo Out" mode channels state configuration and make it correspond Stereo Out mode requirements
 	 */
 	void _refresh_stereo_out_channel_states();
-    
+
 	////////////////////////////////////////////////////////////////////////////////////////////////////////////
 	// internal helper functions
 	/** make sure that current device parameters are supported and fit session requirements
@@ -579,7 +579,7 @@ class EngineStateController
 	/** change ltc source port in case of the output ports list change
 	 */
 	void _update_ltc_output_port ();
-    
+
 	/** check that port is still existed in the list of input ports
 	    @param[in] port - port name
 	    @return true if current port is existed, otherwise - false
@@ -626,18 +626,18 @@ class EngineStateController
 	 */
 	void _on_session_loaded();
 	////////////////////////////////////////
-        
+
 	////////////////////////////////////////
 	// attributes
 	StatePtr _current_state; ///< current state pointer
 	// list of system states
 	StateList _states; ///< list of all available states
-    
+
 	MidiPortStateList _midi_inputs; ///< midi input states
 	MidiPortStateList _midi_outputs; ///< midi output states
-    
+
 	std::string _last_used_real_device; ///< last active non-default (real) device
-    
+
 	Session* _session; ///< current session
 
 	// Engine connections stuff
@@ -649,5 +649,5 @@ class EngineStateController
 };
 
 } // namespace ARDOUR
-    
+
 #endif /* defined(__gtk2_ardour__engine_state_controller__) */
diff --git a/libs/ardour/ardour/export_graph_builder.h b/libs/ardour/ardour/export_graph_builder.h
index 5dc6cd7ac2..3e9fb58a15 100644
--- a/libs/ardour/ardour/export_graph_builder.h
+++ b/libs/ardour/ardour/export_graph_builder.h
@@ -75,7 +75,7 @@ class LIBARDOUR_API ExportGraphBuilder
   private:
 
 	void add_split_config (FileSpec const & config);
-    
+
 	class Encoder {
             public:
 		template <typename T> boost::shared_ptr<AudioGrapher::Sink<T> > init (FileSpec const & new_config);
@@ -99,7 +99,7 @@ class LIBARDOUR_API ExportGraphBuilder
 		PBD::ScopedConnection  copy_files_connection;
 
 		std::string writer_filename;
-        
+
 		// Only one of these should be available at a time
 		FloatWriterPtr float_writer;
 		IntWriterPtr   int_writer;
@@ -175,7 +175,7 @@ class LIBARDOUR_API ExportGraphBuilder
 		FloatSinkPtr sink ();
 		void add_child (FileSpec const & new_config);
 		void remove_children (bool remove_out_files);
-        
+
 		bool operator== (FileSpec const & other_config) const;
 
 	                                        private:
diff --git a/libs/ardour/ardour/export_multiplication.h b/libs/ardour/ardour/export_multiplication.h
index 32622d7fea..cb6af793f1 100644
--- a/libs/ardour/ardour/export_multiplication.h
+++ b/libs/ardour/ardour/export_multiplication.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012 Paul Davis 
+    Copyright (C) 2012 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
diff --git a/libs/ardour/ardour/filename_extensions.h b/libs/ardour/ardour/filename_extensions.h
index c0725932fa..2eb933d936 100644
--- a/libs/ardour/ardour/filename_extensions.h
+++ b/libs/ardour/ardour/filename_extensions.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012 Paul Davis 
+    Copyright (C) 2012 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
diff --git a/libs/ardour/ardour/filesystem_paths.h b/libs/ardour/ardour/filesystem_paths.h
index cc1a21c45e..83f50fd169 100644
--- a/libs/ardour/ardour/filesystem_paths.h
+++ b/libs/ardour/ardour/filesystem_paths.h
@@ -27,14 +27,14 @@
 namespace ARDOUR {
 
 	/**
-	 * @return the path to the directory used to store user specific 
+	 * @return the path to the directory used to store user specific
 	 * configuration files for the given @param version of the program.
 	 * If @param version is negative, the build-time string PROGRAM_VERSION
 	 * will be used to determine the version number.
 	 *
 	 * @post user_config_directory() exists IF version was negative.
 	 *
-	 * 
+	 *
 	 */
         LIBARDOUR_API std::string user_config_directory (int version = -1);
 
@@ -48,8 +48,8 @@ namespace ARDOUR {
 	/**
 	 * @return the path used to store a persistent indication
 	 * that the given version of the program has been used before.
-	 * 
-	 * @param version is the version to check for. If unspecified, 
+	 *
+	 * @param version is the version to check for. If unspecified,
 	 * it defaults to the current (build-time) version of the program.
 	 */
 	LIBARDOUR_API std::string been_here_before_path (int version = -1);
diff --git a/libs/ardour/ardour/libardour_visibility.h b/libs/ardour/ardour/libardour_visibility.h
index 917307732c..dde3f1d11b 100644
--- a/libs/ardour/ardour/libardour_visibility.h
+++ b/libs/ardour/ardour/libardour_visibility.h
@@ -38,7 +38,7 @@
     #define LIBARDOUR_API LIBARDOUR_DLL_EXPORT
   #else
     #define LIBARDOUR_API LIBARDOUR_DLL_IMPORT
-  #endif 
+  #endif
   #define LIBARDOUR_LOCAL LIBARDOUR_DLL_LOCAL
 #endif
 
diff --git a/libs/ardour/ardour/linux_vst_support.h b/libs/ardour/ardour/linux_vst_support.h
index 8575e2a72a..954a465c05 100644
--- a/libs/ardour/ardour/linux_vst_support.h
+++ b/libs/ardour/ardour/linux_vst_support.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012 Paul Davis 
+    Copyright (C) 2012 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
@@ -31,7 +31,7 @@
 /******************************************************************************************/
 /*VSTFX - an engine to manage native linux VST plugins - derived from FST for Windows VSTs*/
 /******************************************************************************************/
- 
+
 LIBARDOUR_API extern void (*vstfx_error_callback)(const char *msg);
 
 LIBARDOUR_API void vstfx_set_error_function (void (*func)(const char *));
diff --git a/libs/ardour/ardour/location.h b/libs/ardour/ardour/location.h
index 6b1f89dab3..f564757e1a 100644
--- a/libs/ardour/ardour/location.h
+++ b/libs/ardour/ardour/location.h
@@ -61,7 +61,7 @@ class LIBARDOUR_API Location : public SessionHandleRef, public PBD::StatefulDest
 	Location (const Location& other);
 	Location (Session &, const XMLNode&);
 	Location* operator= (const Location& other);
-    
+
 	bool operator==(const Location& other);
 
 	bool locked() const { return _locked; }
@@ -120,18 +120,18 @@ class LIBARDOUR_API Location : public SessionHandleRef, public PBD::StatefulDest
 	static PBD::Signal1<void,Location*> changed;
 
 	/* these are member signals for objects that care only about
-	   changes to this object 
+	   changes to this object
 	*/
 
 	PBD::Signal0<void> Changed;
-    
+
 	PBD::Signal0<void> NameChanged;
 	PBD::Signal0<void> EndChanged;
 	PBD::Signal0<void> StartChanged;
 	PBD::Signal0<void> FlagsChanged;
 	PBD::Signal0<void> LockChanged;
 	PBD::Signal0<void> PositionLockStyleChanged;
-        
+
 	/* CD Track / CD-Text info */
 
 	std::map<std::string, std::string> cd_info;
@@ -146,7 +146,7 @@ class LIBARDOUR_API Location : public SessionHandleRef, public PBD::StatefulDest
 
 	static PBD::Signal0<void> scene_changed; /* for use by backend scene change management, class level */
         PBD::Signal0<void> SceneChangeChanged;   /* for use by objects interested in this object */
-        
+
   private:
 	std::string        _name;
 	framepos_t         _start;
@@ -157,7 +157,7 @@ class LIBARDOUR_API Location : public SessionHandleRef, public PBD::StatefulDest
 	bool               _locked;
 	PositionLockStyle  _position_lock_style;
 	boost::shared_ptr<SceneChange> _scene_change;
-    
+
 	void set_mark (bool yn);
 	bool set_flag_internal (bool yn, Flags flag);
 	void recompute_bbt_from_frames ();
@@ -201,7 +201,7 @@ class LIBARDOUR_API Locations : public SessionHandleRef, public PBD::StatefulDes
 	void marks_either_side (framepos_t const, framepos_t &, framepos_t &) const;
 
 	void find_all_between (framepos_t start, framepos_t, LocationList&, Location::Flags);
-    
+
 	PBD::Signal1<void,Location*> current_changed;
 
 	/* Objects that care about individual addition and removal of Locations should connect to added/removed.
diff --git a/libs/ardour/ardour/midi_diskstream.h b/libs/ardour/ardour/midi_diskstream.h
index dac262e269..b55a976023 100644
--- a/libs/ardour/ardour/midi_diskstream.h
+++ b/libs/ardour/ardour/midi_diskstream.h
@@ -170,7 +170,7 @@ class LIBARDOUR_API MidiDiskstream : public Diskstream
 
 	bool prep_record_enable ();
 	bool prep_record_disable ();
-    
+
 	MidiRingBuffer<framepos_t>*  _playback_buf;
 	MidiRingBuffer<framepos_t>*  _capture_buf;
 	boost::weak_ptr<MidiPort>    _source_port;
diff --git a/libs/ardour/ardour/midi_ui.h b/libs/ardour/ardour/midi_ui.h
index 9b9ed1153a..2df5ea020d 100644
--- a/libs/ardour/ardour/midi_ui.h
+++ b/libs/ardour/ardour/midi_ui.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012 Paul Davis 
+    Copyright (C) 2012 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
diff --git a/libs/ardour/ardour/midiport_manager.h b/libs/ardour/ardour/midiport_manager.h
index 4d6453b5cb..fade9c8beb 100644
--- a/libs/ardour/ardour/midiport_manager.h
+++ b/libs/ardour/ardour/midiport_manager.h
@@ -1,6 +1,6 @@
 /*
     Copyright (C) 1998 Paul Barton-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
     the Free Software Foundation; either version 2 of the License, or
@@ -45,12 +45,12 @@ class LIBARDOUR_API MidiPortManager {
 	
     /* Ports used for control. These are read/written to outside of the
      * process callback (asynchronously with respect to when data
-     * actually arrives). 
+     * actually arrives).
      *
      * More detail: we do actually read/write data for these ports
      * inside the process callback, but incoming data is only parsed
      * and outgoing data is only generated *outside* the process
-     * callback. 
+     * callback.
      */
 
     MIDI::Port* midi_input_port () const { return _midi_input_port; }
@@ -59,7 +59,7 @@ class LIBARDOUR_API MidiPortManager {
     MIDI::Port* mmc_output_port () const { return _mmc_output_port; }
     MIDI::Port* scene_input_port () const { return _scene_input_port; }
     MIDI::Port* scene_output_port () const { return _scene_output_port; }
-    
+
     boost::shared_ptr<MidiPort> mmc_in() const { return boost::dynamic_pointer_cast<MidiPort>(_mmc_in); }
     boost::shared_ptr<MidiPort> mmc_out() const { return boost::dynamic_pointer_cast<MidiPort>(_mmc_out); }
 
@@ -74,7 +74,7 @@ class LIBARDOUR_API MidiPortManager {
     boost::shared_ptr<MidiPort> mtc_output_port() const { return _mtc_output_port; }
     boost::shared_ptr<MidiPort> midi_clock_input_port() const { return _midi_clock_input_port; }
     boost::shared_ptr<MidiPort> midi_clock_output_port() const { return _midi_clock_output_port; }
-    
+
     void set_midi_port_states (const XMLNodeList&);
     std::list<XMLNode*> get_midi_port_states () const;
 
diff --git a/libs/ardour/ardour/movable.h b/libs/ardour/ardour/movable.h
index df63987f4f..0114b99ea5 100644
--- a/libs/ardour/ardour/movable.h
+++ b/libs/ardour/ardour/movable.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012 Paul Davis 
+    Copyright (C) 2012 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
diff --git a/libs/ardour/ardour/panner.h b/libs/ardour/ardour/panner.h
index 211ad0ca8e..56c65a4dc2 100644
--- a/libs/ardour/ardour/panner.h
+++ b/libs/ardour/ardour/panner.h
@@ -44,7 +44,7 @@
     #define ARDOURPANNER_API LIBARDOUR_DLL_EXPORT
   #else
     #define ARDOURPANNER_API LIBARDOUR_DLL_IMPORT
-  #endif 
+  #endif
 #define ARDOURPANNER_LOCAL LIBARDOUR_DLL_LOCAL
 
 namespace ARDOUR {
diff --git a/libs/ardour/ardour/panner_manager.h b/libs/ardour/ardour/panner_manager.h
index 73d667424f..2103fc2bea 100644
--- a/libs/ardour/ardour/panner_manager.h
+++ b/libs/ardour/ardour/panner_manager.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012 Paul Davis 
+    Copyright (C) 2012 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
diff --git a/libs/ardour/ardour/playlist.h b/libs/ardour/ardour/playlist.h
index eadd237143..1b3f1d530f 100644
--- a/libs/ardour/ardour/playlist.h
+++ b/libs/ardour/ardour/playlist.h
@@ -250,7 +250,7 @@ public:
 
     class RegionWriteLock : public Glib::Threads::RWLock::WriterLock {
     public:
-	    RegionWriteLock (Playlist *pl, bool do_block_notify = true) 
+	    RegionWriteLock (Playlist *pl, bool do_block_notify = true)
                     : Glib::Threads::RWLock::WriterLock (pl->region_lock)
                     , playlist (pl)
                     , block_notify (do_block_notify) {
diff --git a/libs/ardour/ardour/plugin.h b/libs/ardour/ardour/plugin.h
index ed028e3572..c927c1c061 100644
--- a/libs/ardour/ardour/plugin.h
+++ b/libs/ardour/ardour/plugin.h
@@ -67,7 +67,7 @@ class LIBARDOUR_API PluginInfo {
 	std::string unique_id;
 
 	virtual PluginPtr load (Session& session) = 0;
-	virtual bool is_instrument() const; 
+	virtual bool is_instrument() const;
 
 	/* NOTE: this block of virtual methods looks like the interface
 	   to a Processor, but Plugin does not inherit from Processor.
@@ -144,11 +144,11 @@ class LIBARDOUR_API Plugin : public PBD::StatefulDestructible, public Latent
 	struct PresetRecord {
 	    PresetRecord () : number (-1), user (true) {}
 	    PresetRecord (const std::string& u, const std::string& l, int n = -1, bool s = true) : uri (u), label (l), number (n), user (s)  {}
-	    
+	
 	    bool operator!= (PresetRecord const & a) const {
 		    return number != a.number || uri != a.uri || label != a.label;
 	    }
-	    
+	
 	    std::string uri;
 	    std::string label;
 	    int number; // if <0, invalid
diff --git a/libs/ardour/ardour/port_engine.h b/libs/ardour/ardour/port_engine.h
index 26e52b9dfd..5d187062eb 100644
--- a/libs/ardour/ardour/port_engine.h
+++ b/libs/ardour/ardour/port_engine.h
@@ -34,14 +34,14 @@ namespace ARDOUR {
 class PortManager;
 
 /** PortEngine is an abstract base class that defines the functionality
- * required by Ardour. 
- * 
+ * required by Ardour.
+ *
  * A Port is basically an endpoint for a datastream (which can either be
  * continuous, like audio, or event-based, like MIDI). Ports have buffers
  * associated with them into which data can be written (if they are output
  * ports) and from which data can be read (if they input ports). Ports can be
  * connected together so that data written to an output port can be read from
- * an input port. These connections can be 1:1, 1:N OR N:1. 
+ * an input port. These connections can be 1:1, 1:N OR N:1.
  *
  * Ports may be associated with software only, or with hardware.  Hardware
  * related ports are often referred to as physical, and correspond to some
@@ -66,7 +66,7 @@ class PortManager;
  *                  come from the "outside world" if the terminal port is also
  *                  physical, or will have been synthesized by the entity that
  *                  owns the terminal port.
- *                  
+ *
  * <b>playback latency</b>: how long until the data written to the buffer of
  *                   port will reach a terminal port.
  *
@@ -79,34 +79,34 @@ class LIBARDOUR_API PortEngine {
   public:
     PortEngine (PortManager& pm) : manager (pm) {}
     virtual ~PortEngine() {}
-    
+
     /** Return a private, type-free pointer to any data
      * that might be useful to a concrete implementation
      */
     virtual void* private_handle() const = 0;
 
     /* We use void* here so that the API can be defined for any implementation.
-     * 
+     *
      * We could theoretically use a template (PortEngine<T>) and define
      * PortHandle as T, but this complicates the desired inheritance
      * pattern in which FooPortEngine handles things for the Foo API,
      * rather than being a derivative of PortEngine<Foo>.
     */
-       
+
     typedef void* PortHandle;
 
     /** Return the name of this process as used by the port manager
      * when naming ports.
      */
     virtual const std::string& my_name() const = 0;
- 
+
     /** Return true if the underlying mechanism/API is still available
      * for us to utilize. return false if some or all of the AudioBackend
      * API can no longer be effectively used.
      */
     virtual bool available() const = 0;
 
-    /** Return the maximum size of a port name 
+    /** Return the maximum size of a port name
      */
     virtual uint32_t port_name_size() const = 0;
 
@@ -149,9 +149,9 @@ class LIBARDOUR_API PortEngine {
      *
      * To avoid selecting by name, pass an empty string for @param
      * port_name_pattern.
-     * 
+     *
      * To avoid selecting by type, pass DataType::NIL as @param type.
-     * 
+     *
      * To avoid selecting by flags, pass PortFlags (0) as @param flags.
      */
     virtual int get_ports (const std::string& port_name_pattern, DataType type, PortFlags flags, std::vector<std::string>& ports) const = 0;
@@ -173,7 +173,7 @@ class LIBARDOUR_API PortEngine {
      * is connected to.
      */
     virtual void       unregister_port (PortHandle) = 0;
-    
+
     /* Connection management */
 
     /** Ensure that data written to the port named by @param src will be
@@ -182,20 +182,20 @@ class LIBARDOUR_API PortEngine {
     */
     virtual int   connect (const std::string& src, const std::string& dst) = 0;
 
-    /** Remove any existing connection between the ports named by @param src and 
+    /** Remove any existing connection between the ports named by @param src and
      * @param dst. Return zero on success, non-zero otherwise.
      */
     virtual int   disconnect (const std::string& src, const std::string& dst) = 0;
-    
-    
+
+
     /** Ensure that data written to the port referenced by @param portwill be
      * readable from the port named by @param dst. Return zero on success,
      * non-zero otherwise.
     */
     virtual int   connect (PortHandle src, const std::string& dst) = 0;
-    /** Remove any existing connection between the port referenced by @param src and 
+    /** Remove any existing connection between the port referenced by @param src and
      * the port named @param dst. Return zero on success, non-zero otherwise.
-     */ 
+     */
     virtual int   disconnect (PortHandle src, const std::string& dst) = 0;
 
     /** Remove all connections between the port referred to by @param port and
@@ -227,10 +227,10 @@ class LIBARDOUR_API PortEngine {
     /** Retrieve a MIDI event from the data at @param port_buffer. The event
     number to be retrieved is given by @param event_index (a value of zero
     indicates that the first event in the port_buffer should be retrieved).
-    * 
+    *
     * The data associated with the event will be copied into the buffer at
     * @param buf and the number of bytes written will be stored in @param
-    * size. The timestamp of the event (which is always relative to the start 
+    * size. The timestamp of the event (which is always relative to the start
     * of the current process cycle, in samples) will be stored in @param
     * timestamp
     */
@@ -241,7 +241,7 @@ class LIBARDOUR_API PortEngine {
      * port_buffer. The MIDI event will be marked with a time given by @param
      * timestamp. Return zero on success, non-zero otherwise.
      *
-     * Events  must be added monotonically to a port buffer. An attempt to 
+     * Events  must be added monotonically to a port buffer. An attempt to
      * add a non-monotonic event (e.g. out-of-order) will cause this method
      * to return a failure status.
      */
@@ -270,13 +270,13 @@ class LIBARDOUR_API PortEngine {
      * APIs can offer it.
      */
     virtual bool  can_monitor_input() const = 0;
-    /** Increment or decrement the number of requests to monitor the input 
+    /** Increment or decrement the number of requests to monitor the input
      * of the hardware channel represented by the port referred to by @param
      * port.
      *
      * If the number of requests rises above zero, input monitoring will
      * be enabled (if can_monitor_input() returns true for the implementation).
-     * 
+     *
      * If the number of requests falls to zero, input monitoring will be
      * disabled (if can_monitor_input() returns true for the implementation)
      */
@@ -296,7 +296,7 @@ class LIBARDOUR_API PortEngine {
 
     /* Latency management
      */
-    
+
     /** Set the latency range for the port referred to by @param port to @param
      * r. The playback range will be set if @param for_playback is true,
      * otherwise the capture range will be set.
@@ -349,11 +349,11 @@ class LIBARDOUR_API PortEngine {
      * schedule MIDI events within their buffers. It is a bit odd that we
      * expose this here, because it is also exposed by AudioBackend, but they
      * only have access to a PortEngine object, not an AudioBackend.
-     * 
-     * Return the time according to the sample clock in use when the current 
-     * buffer process cycle began. 
      *
-     * XXX to be removed after some more design cleanup. 
+     * Return the time according to the sample clock in use when the current
+     * buffer process cycle began.
+     *
+     * XXX to be removed after some more design cleanup.
      */
     virtual framepos_t sample_time_at_cycle_start () = 0;
 
diff --git a/libs/ardour/ardour/port_manager.h b/libs/ardour/ardour/port_manager.h
index e40c80c1b2..d76016c6a3 100644
--- a/libs/ardour/ardour/port_manager.h
+++ b/libs/ardour/ardour/port_manager.h
@@ -40,12 +40,12 @@ namespace ARDOUR {
 class PortEngine;
 class AudioBackend;
 
-class LIBARDOUR_API PortManager 
+class LIBARDOUR_API PortManager
 {
   public:
 	typedef std::map<std::string,boost::shared_ptr<Port> > Ports;
 	typedef std::list<boost::shared_ptr<Port> > PortList;
-    
+
 	PortManager ();
 	virtual ~PortManager() {}
 
@@ -55,13 +55,13 @@ class LIBARDOUR_API PortManager
 	std::string my_name() const;
 
 	/* Port registration */
-    
+
 	boost::shared_ptr<Port> register_input_port (DataType, const std::string& portname, bool async = false);
 	boost::shared_ptr<Port> register_output_port (DataType, const std::string& portname, bool async = false);
 	int unregister_port (boost::shared_ptr<Port>);
-    
+
 	/* Port connectivity */
-    
+
 	int  connect (const std::string& source, const std::string& destination);
 	int  disconnect (const std::string& source, const std::string& destination);
 	int  disconnect (boost::shared_ptr<Port>);
@@ -82,9 +82,9 @@ class LIBARDOUR_API PortManager
 	std::string             get_pretty_name_by_name (const std::string& portname) const;
 	bool                    port_is_mine (const std::string& fullname) const;
 	bool                    port_name_prefix_is_unique (const std::string& first_part_of_port_name) const;
-    
+
 	/* other Port management */
-    
+
 	bool      port_is_physical (const std::string&) const;
 	void      get_physical_outputs (DataType type, std::vector<std::string>&);
 	void      get_physical_inputs (DataType type, std::vector<std::string>&);
@@ -95,13 +95,13 @@ class LIBARDOUR_API PortManager
 	int get_ports (DataType, PortList&);
 
 	void remove_all_ports ();
-    
+
 	/* per-Port monitoring */
-    
+
 	bool can_request_input_monitoring () const;
 	void request_input_monitoring (const std::string&, bool) const;
 	void ensure_input_monitoring (const std::string&, bool) const;
-    
+
 	class PortRegistrationFailure : public std::exception {
 	                                        public:
 		PortRegistrationFailure (std::string const & why = "")
@@ -116,7 +116,7 @@ class LIBARDOUR_API PortManager
 	};
 
 	/* the port engine will invoke these callbacks when the time is right */
-    
+
 	void registration_callback ();
 	int graph_order_callback ();
 	void connect_callback (const std::string&, const std::string&, bool connection);
@@ -128,7 +128,7 @@ class LIBARDOUR_API PortManager
 
 	/** Emitted if a Port is registered or unregistered */
 	PBD::Signal0<void> PortRegisteredOrUnregistered;
-    
+
 	/** Emitted if a Port is connected or disconnected.
 	 *  The Port parameters are the ports being connected / disconnected, or 0 if they are not known to Ardour.
 	 *  The std::string parameters are the (long) port names.
diff --git a/libs/ardour/ardour/process_thread.h b/libs/ardour/ardour/process_thread.h
index 67bd07dbfe..ee2e522378 100644
--- a/libs/ardour/ardour/process_thread.h
+++ b/libs/ardour/ardour/process_thread.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012 Paul Davis 
+    Copyright (C) 2012 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
diff --git a/libs/ardour/ardour/rc_configuration_vars.h b/libs/ardour/ardour/rc_configuration_vars.h
index afa74325c0..eedd619375 100644
--- a/libs/ardour/ardour/rc_configuration_vars.h
+++ b/libs/ardour/ardour/rc_configuration_vars.h
@@ -35,8 +35,8 @@
 /* IO connection */
 
 CONFIG_VARIABLE (bool, auto_connect_standard_busses, "auto-connect-standard-busses", true)
-/* this variable is used to indicate output mode in Waves Tracks: 
-   "Multi Out" == AutoConnectPhysical and "Stereo Out" == AutoConnectMaster 
+/* this variable is used to indicate output mode in Waves Tracks:
+   "Multi Out" == AutoConnectPhysical and "Stereo Out" == AutoConnectMaster
 */
 CONFIG_VARIABLE (AutoConnectOption, output_auto_connect, "output-auto-connect", AutoConnectMaster)
 CONFIG_VARIABLE (AutoConnectOption, input_auto_connect, "input-auto-connect", AutoConnectPhysical)
diff --git a/libs/ardour/ardour/readable.h b/libs/ardour/ardour/readable.h
index 18190436df..4098e26e40 100644
--- a/libs/ardour/ardour/readable.h
+++ b/libs/ardour/ardour/readable.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012 Paul Davis 
+    Copyright (C) 2012 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
diff --git a/libs/ardour/ardour/region_factory.h b/libs/ardour/ardour/region_factory.h
index a9b73dc462..d5228fadb7 100644
--- a/libs/ardour/ardour/region_factory.h
+++ b/libs/ardour/ardour/region_factory.h
@@ -117,7 +117,7 @@ public:
 	 * announce=false but they still need to be in the map soon after
 	 * creation.
 	 */
-	 
+	
 	static void map_add (boost::shared_ptr<Region>);
 
   private:
diff --git a/libs/ardour/ardour/revision.h b/libs/ardour/ardour/revision.h
index 69c7519e01..7d746f2e2f 100644
--- a/libs/ardour/ardour/revision.h
+++ b/libs/ardour/ardour/revision.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012 Paul Davis 
+    Copyright (C) 2012 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
diff --git a/libs/ardour/ardour/route.h b/libs/ardour/ardour/route.h
index 82450a67d7..c4decd48c8 100644
--- a/libs/ardour/ardour/route.h
+++ b/libs/ardour/ardour/route.h
@@ -442,7 +442,7 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou
 
 	void protect_automation ();
 
-	enum { 
+	enum {
 		/* These numbers are taken from MIDI Machine Control,
 		   which can only control up to 317 tracks without
 		   doing sysex segmentation.
diff --git a/libs/ardour/ardour/scene_change.h b/libs/ardour/ardour/scene_change.h
index 661d2238b7..1513622ed0 100644
--- a/libs/ardour/ardour/scene_change.h
+++ b/libs/ardour/ardour/scene_change.h
@@ -43,7 +43,7 @@ class SceneChange : public PBD::Stateful
 
         bool active () const { return _active; }
         void set_active (bool);
-        
+
         PBD::Signal0<void> ColorChanged;
         PBD::Signal0<void> ActiveChanged;
 
diff --git a/libs/ardour/ardour/scene_changer.h b/libs/ardour/ardour/scene_changer.h
index d606dd13db..6019ed9c6c 100644
--- a/libs/ardour/ardour/scene_changer.h
+++ b/libs/ardour/ardour/scene_changer.h
@@ -34,7 +34,7 @@ class Parser;
 class Port;
 }
 
-namespace ARDOUR 
+namespace ARDOUR
 {
 
 class Session;
diff --git a/libs/ardour/ardour/search_paths.h b/libs/ardour/ardour/search_paths.h
index 1815bc077c..3eea49164c 100644
--- a/libs/ardour/ardour/search_paths.h
+++ b/libs/ardour/ardour/search_paths.h
@@ -1,6 +1,6 @@
 /*
-    Copyright (C) 2011 Tim Mayberry 
-    Copyright (C) 2013 Paul Davis 
+    Copyright (C) 2011 Tim Mayberry
+    Copyright (C) 2013 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
diff --git a/libs/ardour/ardour/session.h b/libs/ardour/ardour/session.h
index 2ee625f89c..2bc992bb10 100644
--- a/libs/ardour/ardour/session.h
+++ b/libs/ardour/ardour/session.h
@@ -481,10 +481,10 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	 *
 	 * Argument is the snapshot name to use when saving.
 	 */
-	PBD::Signal1<void,std::string> SaveSessionRequested; 
+	PBD::Signal1<void,std::string> SaveSessionRequested;
 
 	/* emitted during a session save to allow other entities to add state, via
-	 * extra XML, to the session state 
+	 * extra XML, to the session state
 	 */
 	PBD::Signal0<void> SessionSaveUnderway;
 
@@ -568,7 +568,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	std::list<boost::shared_ptr<MidiTrack> > new_midi_track (
 		const ChanCount& input, const ChanCount& output,
 		boost::shared_ptr<PluginInfo> instrument = boost::shared_ptr<PluginInfo>(),
-		TrackMode mode = Normal, 
+		TrackMode mode = Normal,
 		RouteGroup* route_group = 0, uint32_t how_many = 1, std::string name_template = ""
 		);
 
@@ -1030,7 +1030,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	boost::shared_ptr<MidiPort> midi_clock_input_port () const;
 	boost::shared_ptr<MidiPort> mtc_output_port () const;
 	boost::shared_ptr<MidiPort> mtc_input_port () const;
-    
+
 	MIDI::MachineControl& mmc() { return *_mmc; }
 
 	void reconnect_midi_scene_ports (bool);
@@ -1301,7 +1301,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	void consolidate_skips (Location*);
 	void sync_locations_to_skips ();
 	void _sync_locations_to_skips ();
-    
+
 	PBD::ScopedConnectionList skip_update_connections;
 	bool _ignore_skips_updates;
 
diff --git a/libs/ardour/ardour/session_configuration_vars.h b/libs/ardour/ardour/session_configuration_vars.h
index 750e0aafd8..25625e2948 100644
--- a/libs/ardour/ardour/session_configuration_vars.h
+++ b/libs/ardour/ardour/session_configuration_vars.h
@@ -81,7 +81,7 @@ CONFIG_VARIABLE (uint32_t, meterbridge_label_height,  "meterbridge-label-height"
 /* This variable was not discussed with Ardour developers and is considered
    weakly conceived. It is also poorly named, since we have "groups" already
    present in libardour but this variable has nothing to do with it. There
-   should have been more discussion about what was required and the best 
+   should have been more discussion about what was required and the best
    way to accomplish it.
 */
 CONFIG_VARIABLE (bool, enable_group_edit, "enable-group-edit", false)
diff --git a/libs/ardour/ardour/session_event.h b/libs/ardour/ardour/session_event.h
index a8c17a1ddb..02759bba7e 100644
--- a/libs/ardour/ardour/session_event.h
+++ b/libs/ardour/ardour/session_event.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012 Paul Davis 
+    Copyright (C) 2012 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
diff --git a/libs/ardour/ardour/session_metadata.h b/libs/ardour/ardour/session_metadata.h
index c2ab947dfe..a8fb977e51 100644
--- a/libs/ardour/ardour/session_metadata.h
+++ b/libs/ardour/ardour/session_metadata.h
@@ -136,7 +136,7 @@ class LIBARDOUR_API SessionMetadata : public PBD::StatefulDestructible
 
   private:
 
-	static SessionMetadata *_metadata;  //singleton instance 
+	static SessionMetadata *_metadata;  //singleton instance
 
 	typedef std::pair<std::string, std::string> Property;
 	typedef std::map<std::string, std::string> PropertyMap;
diff --git a/libs/ardour/ardour/session_utils.h b/libs/ardour/ardour/session_utils.h
index bd9cc92267..870f3daaa7 100644
--- a/libs/ardour/ardour/session_utils.h
+++ b/libs/ardour/ardour/session_utils.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012 Paul Davis 
+    Copyright (C) 2012 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
diff --git a/libs/ardour/ardour/sndfilesource.h b/libs/ardour/ardour/sndfilesource.h
index 45e049e35f..4579a32b6d 100644
--- a/libs/ardour/ardour/sndfilesource.h
+++ b/libs/ardour/ardour/sndfilesource.h
@@ -45,7 +45,7 @@ class LIBARDOUR_API SndFileSource : public AudioFileSource {
 	SndFileSource (Session&, const std::string& path, int chn);
 
 	/** Constructor to be called for existing in-session files during
-	 * session loading 
+	 * session loading
 	 */
 	SndFileSource (Session&, const XMLNode&);
 
diff --git a/libs/ardour/ardour/source_factory.h b/libs/ardour/ardour/source_factory.h
index a41cd36258..b1ee6438f5 100644
--- a/libs/ardour/ardour/source_factory.h
+++ b/libs/ardour/ardour/source_factory.h
@@ -48,12 +48,12 @@ class LIBARDOUR_API SourceFactory {
 
 	static boost::shared_ptr<Source> createExternal
 		(DataType type, Session&,
-		 const std::string& path, 
+		 const std::string& path,
 		 int chn, Source::Flag flags, bool announce = true, bool async = false);
 
 	static boost::shared_ptr<Source> createWritable
 		(DataType type, Session&,
-		 const std::string& path, 
+		 const std::string& path,
 		 bool destructive, framecnt_t rate, bool announce = true, bool async = false);
 
 
diff --git a/libs/ardour/ardour/template_utils.h b/libs/ardour/ardour/template_utils.h
index dc56c53c44..b2f155ee45 100644
--- a/libs/ardour/ardour/template_utils.h
+++ b/libs/ardour/ardour/template_utils.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012 Paul Davis 
+    Copyright (C) 2012 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
diff --git a/libs/ardour/ardour/tempo.h b/libs/ardour/ardour/tempo.h
index d5ae2959c6..09b3d8b5eb 100644
--- a/libs/ardour/ardour/tempo.h
+++ b/libs/ardour/ardour/tempo.h
@@ -158,7 +158,7 @@ class LIBARDOUR_API TempoSection : public MetricSection, public Tempo {
 	   the tempo section is located in. A value of 0.0 indicates that
 	   it occurs on the first beat of the bar, a value of 0.5 indicates
 	   that it occurs halfway through the bar and so on.
-	   
+	
 	   this enables us to keep the tempo change at the same relative
 	   position within the bar if/when the meter changes.
 	*/
@@ -224,7 +224,7 @@ class LIBARDOUR_API TempoMap : public PBD::StatefulDestructible
 		const TempoSection* tempo;
 		uint32_t            bar;
 		uint32_t            beat;
-            
+
 		BBTPoint (const MeterSection& m, const TempoSection& t, framepos_t f,
 		          uint32_t b, uint32_t e)
 			: frame (f), meter (&m), tempo (&t), bar (b), beat (e) {}
@@ -242,22 +242,22 @@ class LIBARDOUR_API TempoMap : public PBD::StatefulDestructible
 		(obj.*method)(metrics);
 	}
 
-	void get_grid (BBTPointList::const_iterator&, BBTPointList::const_iterator&, 
+	void get_grid (BBTPointList::const_iterator&, BBTPointList::const_iterator&,
 	               framepos_t start, framepos_t end);
 	
-	/* TEMPO- AND METER-SENSITIVE FUNCTIONS 
+	/* TEMPO- AND METER-SENSITIVE FUNCTIONS
 
 	   bbt_time(), bbt_time_rt(), frame_time() and bbt_duration_at()
 	   are all sensitive to tempo and meter, and will give answers
 	   that align with the grid formed by tempo and meter sections.
-	   
-	   They SHOULD NOT be used to determine the position of events 
+	
+	   They SHOULD NOT be used to determine the position of events
 	   whose location is canonically defined in beats.
 	*/
 
 	void bbt_time (framepos_t when, Timecode::BBT_Time&);
 
-	/* realtime safe variant of ::bbt_time(), will throw 
+	/* realtime safe variant of ::bbt_time(), will throw
 	   std::logic_error if the map is not large enough
 	   to provide an answer.
 	*/
@@ -266,12 +266,12 @@ class LIBARDOUR_API TempoMap : public PBD::StatefulDestructible
 	framecnt_t bbt_duration_at (framepos_t, const Timecode::BBT_Time&, int dir);
 
 	/* TEMPO-SENSITIVE FUNCTIONS
-	   
+	
 	   These next 4 functions will all take tempo in account and should be
 	   used to determine position (and in the last case, distance in beats)
 	   when tempo matters but meter does not.
 
-	   They SHOULD be used to determine the position of events 
+	   They SHOULD be used to determine the position of events
 	   whose location is canonically defined in beats.
 	*/
 
@@ -348,7 +348,7 @@ class LIBARDOUR_API TempoMap : public PBD::StatefulDestructible
 	void extend_map (framepos_t end);
 	void require_map_to (framepos_t pos);
 	void require_map_to (const Timecode::BBT_Time&);
-	void _extend_map (TempoSection* tempo, MeterSection* meter, 
+	void _extend_map (TempoSection* tempo, MeterSection* meter,
 	                  Metrics::iterator next_metric,
 	                  Timecode::BBT_Time current, framepos_t current_frame, framepos_t end);
 
diff --git a/libs/ardour/ardour/thread_buffers.h b/libs/ardour/ardour/thread_buffers.h
index 5ea352f2ef..f018ee4c22 100644
--- a/libs/ardour/ardour/thread_buffers.h
+++ b/libs/ardour/ardour/thread_buffers.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012 Paul Davis 
+    Copyright (C) 2012 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
diff --git a/libs/ardour/ardour/ticker.h b/libs/ardour/ardour/ticker.h
index 0e5c3c80f4..fbca0161d4 100644
--- a/libs/ardour/ardour/ticker.h
+++ b/libs/ardour/ardour/ticker.h
@@ -73,7 +73,7 @@ public:
 
     class Position;
     boost::scoped_ptr<Position> _pos;
-    
+
     double one_ppqn_in_frames (framepos_t transport_position);
 
     void send_midi_clock_event (pframes_t offset, pframes_t nframes);
@@ -83,6 +83,6 @@ public:
     void send_position_event (uint32_t midi_clocks, pframes_t offset, pframes_t nframes);
 };
 }
- // namespace 
+ // namespace
 
 #endif /* __libardour_ticker_h__ */
diff --git a/libs/ardour/ardour/track.h b/libs/ardour/ardour/track.h
index f699b5d5d3..2d67a0aa75 100644
--- a/libs/ardour/ardour/track.h
+++ b/libs/ardour/ardour/track.h
@@ -94,7 +94,7 @@ class LIBARDOUR_API Track : public Route, public PublicDiskstream
 	 */
 	virtual bool bounceable (boost::shared_ptr<Processor> endpoint, bool include_endpoint) const = 0;
 	virtual boost::shared_ptr<Region> bounce (InterThreadInfo&) = 0;
-	virtual boost::shared_ptr<Region> bounce_range (framepos_t start, framepos_t end, InterThreadInfo&, 
+	virtual boost::shared_ptr<Region> bounce_range (framepos_t start, framepos_t end, InterThreadInfo&,
 							boost::shared_ptr<Processor> endpoint, bool include_endpoint) = 0;
 	virtual int export_stuff (BufferSet& bufs, framepos_t start_frame, framecnt_t nframes,
 				  boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) = 0;
diff --git a/libs/ardour/ardour/trimmable.h b/libs/ardour/ardour/trimmable.h
index 07e2c809a3..d3fbf6b8f8 100644
--- a/libs/ardour/ardour/trimmable.h
+++ b/libs/ardour/ardour/trimmable.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012 Paul Davis 
+    Copyright (C) 2012 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
diff --git a/libs/ardour/ardour/types.h b/libs/ardour/ardour/types.h
index 5bd7b87929..d4c65f3871 100644
--- a/libs/ardour/ardour/types.h
+++ b/libs/ardour/ardour/types.h
@@ -457,7 +457,7 @@ namespace ARDOUR {
 		AutoConnectPhysical = 0x1,
 		AutoConnectMaster = 0x2
 	};
-        
+
     enum TracksAutoNamingRule {
         UseDefaultNames = 0x1,
         NameAfterDriver = 0x2
@@ -610,8 +610,8 @@ namespace ARDOUR {
 		   this equality cannot be assumed.
 		*/
 		TransportStopped = 0,
-		TransportRolling = 1, 
-		TransportLooping = 2, 
+		TransportRolling = 1,
+		TransportLooping = 2,
 		TransportStarting = 3,
 	};
 
@@ -619,7 +619,7 @@ namespace ARDOUR {
 		/* these values happen to match the constants used by JACK but
 		   this equality cannot be assumed.
 		*/
-		IsInput = 0x1, 
+		IsInput = 0x1,
 		IsOutput = 0x2,
 		IsPhysical = 0x4,
 		CanMonitor = 0x8,
@@ -730,7 +730,7 @@ session_frame_to_track_frame (ARDOUR::framepos_t session_frame, double speed)
 static inline ARDOUR::framepos_t
 track_frame_to_session_frame (ARDOUR::framepos_t track_frame, double speed)
 {
-	/* NB - do we need a check for speed == 0 ??? */ 
+	/* NB - do we need a check for speed == 0 ??? */
 	long double result = (long double) track_frame / (long double) speed;
 
 	if (result >= (long double) ARDOUR::max_framepos) {
diff --git a/libs/ardour/ardour/utils.h b/libs/ardour/ardour/utils.h
index 7be346256e..d073588b9e 100644
--- a/libs/ardour/ardour/utils.h
+++ b/libs/ardour/ardour/utils.h
@@ -110,9 +110,9 @@ slider_position_to_gain (double pos)
 #ifndef OLD_GAIN_MATH
 	/* 5th order polynomial function fit to data from a TC Spectra console
 	   fader (image of fader gradations).
-	 
+	
 	   y = a + bx1 + cx2 + dx3 + fx4 + gx5
-	   
+	
 	   a = -1.1945480381045521E-02
 	   b =  1.5809476525537265E+00
 	   c = -1.5850710838966151E+01
diff --git a/libs/ardour/ardour/vestige/aeffectx.h b/libs/ardour/ardour/vestige/aeffectx.h
index 5b7d69c411..f09c009993 100644
--- a/libs/ardour/ardour/vestige/aeffectx.h
+++ b/libs/ardour/ardour/vestige/aeffectx.h
@@ -2,7 +2,7 @@
  * aeffectx.h - simple header to allow VeSTige compilation and eventually work
  *
  * Copyright (c) 2006 Javier Serrano Polo <jasp00/at/users.sourceforge.net>
- * 
+ *
  * This file is part of Linux MultiMedia Studio - http://lmms.sourceforge.net
  *
  * This program is free software; you can redistribute it and/or
diff --git a/libs/ardour/ardour/vst_types.h b/libs/ardour/ardour/vst_types.h
index 35b52435ab..9d4fc3450f 100644
--- a/libs/ardour/ardour/vst_types.h
+++ b/libs/ardour/ardour/vst_types.h
@@ -34,13 +34,13 @@ struct LIBARDOUR_API _VSTKey
 
 typedef struct _VSTKey VSTKey;
 
-struct LIBARDOUR_API _VSTInfo 
+struct LIBARDOUR_API _VSTInfo
 {
 	char  *name;
 	char  *creator;
 	int    UniqueID;
 	char  *Category;
-    
+
 	int    numInputs;
 	int    numOutputs;
 	int    numParams;