Index: ps/trunk/source/graphics/ColladaManager.h
===================================================================
--- ps/trunk/source/graphics/ColladaManager.h	(revision 13418)
+++ ps/trunk/source/graphics/ColladaManager.h	(revision 13419)
@@ -1,76 +1,78 @@
-/* Copyright (C) 2012 Wildfire Games.
+/* Copyright (C) 2013 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. 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.
  *
  * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef INCLUDED_COLLADAMANAGER
 #define INCLUDED_COLLADAMANAGER
 
 #include "lib/file/vfs/vfs.h"
 
 class CStr8;
 class CColladaManagerImpl;
 class MD5;
 
 class CColladaManager
 {
+	NONCOPYABLE(CColladaManager);
+
 public:
 	enum FileType { PMD, PSA };
 
 	CColladaManager(const PIVFS& vfs);
 	~CColladaManager();
 
 	/**
 	 * Returns the VFS path to a PMD/PSA file for the given source file.
 	 * Performs a (cached) conversion from COLLADA if necessary.
 	 *
 	 * @param pathnameNoExtension path and name, minus extension, of file to load.
 	 *		  One of either "sourceName.pmd" or "sourceName.dae" should exist.
 	 * @param type FileType, .pmd or .psa
 	 *
 	 * @return full VFS path (including extension) of file to load; or empty
 	 * string if there was a problem and it could not be loaded. Doesn't knowingly
 	 * return an invalid path.
 	 */
 	VfsPath GetLoadablePath(const VfsPath& pathnameNoExtension, FileType type);
 
 	/**
 	 * Converts DAE to archive cached .pmd/psa and outputs the resulting path
 	 * (used by archive builder)
 	 *
 	 * @param[in] sourcePath path of the .dae to load
 	 * @param[in] type FileType, .pmd or .psa
 	 * @param[out] archiveCachePath output path of the cached file
 	 *
 	 * @return true if COLLADA converter completed successfully; or false if it failed
 	 */
 	bool GenerateCachedFile(const VfsPath& sourcePath, FileType type, VfsPath& archiveCachePath);
 
 private:
 	/**
 	 * Creates MD5 hash key from skeletons.xml info and COLLADA converter version,
 	 * used to invalidate cached .pmd/psas
 	 *
 	 * @param[out] hash resulting MD5 hash
 	 * @param[out] version version passed to CCacheLoader, used if code change should force
 	 *		  cache invalidation
 	 */
 	void PrepareCacheKey(MD5& hash, u32& version);
 
 	CColladaManagerImpl* m;
 	PIVFS m_VFS;
 };
 
 #endif // INCLUDED_COLLADAMANAGER
Index: ps/trunk/source/graphics/MapGenerator.h
===================================================================
--- ps/trunk/source/graphics/MapGenerator.h	(revision 13418)
+++ ps/trunk/source/graphics/MapGenerator.h	(revision 13419)
@@ -1,145 +1,146 @@
-/* Copyright (C) 2011 Wildfire Games.
+/* Copyright (C) 2013 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. 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.
  *
  * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef INCLUDED_MAPGENERATOR
 #define INCLUDED_MAPGENERATOR
 
 #include "ps/FileIo.h"
 #include "ps/ThreadUtil.h"
 #include "scriptinterface/ScriptInterface.h"
 
 #include <boost/random/linear_congruential.hpp>
 
 #include <set>
 
 class CMapGeneratorWorker;
 
 /**
  * Random map generator interface. Initialized by CMapReader and then checked
  * periodically during loading, until it's finished (progress value is 0).
  *
  * The actual work is performed by CMapGeneratorWorker in a separate thread.
  */
 class CMapGenerator
 {
+	NONCOPYABLE(CMapGenerator);
 
 public:
 	CMapGenerator();
 	~CMapGenerator();
 
 	/**
 	 * Start the map generator thread
 	 *
 	 * @param scriptFile The VFS path for the script, e.g. "maps/random/latium.js"
 	 * @param settings JSON string containing settings for the map generator
 	 */
 	void GenerateMap(const VfsPath& scriptFile, const std::string& settings);
 
 	/**
 	 * Get status of the map generator thread
 	 *
 	 * @return Progress percentage 1-100 if active, 0 when finished, or -1 on error 
 	 */
 	int GetProgress();
 
 	/**
 	 * Get random map data, according to this format:
 	 * http://trac.wildfiregames.com/wiki/Random_Map_Generator_Internals#Dataformat
 	 *
 	 * @return StructuredClone containing map data
 	 */
 	shared_ptr<ScriptInterface::StructuredClone> GetResults();
 
 private:
 	CMapGeneratorWorker* m_Worker;
 
 };
 
 /**
  * Random map generator worker thread.
  * (This is run in a thread so that the GUI remains responsive while loading)
  *
  * Thread-safety:
  * - Initialize and constructor/destructor must be called from the main thread.
  * - ScriptInterface created and destroyed by thread
  * - StructuredClone used to return JS map data - jsvals can't be used across threads/runtimes
  */
 class CMapGeneratorWorker
 {
 public:
 	CMapGeneratorWorker();
 	~CMapGeneratorWorker();
 
 	/**
 	 * Start the map generator thread
 	 *
 	 * @param scriptFile The VFS path for the script, e.g. "maps/random/latium.js"
 	 * @param settings JSON string containing settings for the map generator
 	 */
 	void Initialize(const VfsPath& scriptFile, const std::string& settings);
 
 	/**
 	 * Get status of the map generator thread
 	 *
 	 * @return Progress percentage 1-100 if active, 0 when finished, or -1 on error 
 	 */
 	int GetProgress();
 
 	/**
 	 * Get random map data, according to this format:
 	 * http://trac.wildfiregames.com/wiki/Random_Map_Generator_Internals#Dataformat
 	 *
 	 * @return StructuredClone containing map data
 	 */
 	shared_ptr<ScriptInterface::StructuredClone> GetResults();
 	
 private:
 // Mapgen
 
 	/**
 	 * Load all scripts of the given library
 	 * 
 	 * @param libraryName String specifying name of the library (subfolder of ../maps/random/)
 	 * @return true if all scripts ran successfully, false if there's an error
 	 */
 	bool LoadScripts(const std::wstring& libraryName);
 	
 	// callbacks for script functions
 	static bool LoadLibrary(void* cbdata, std::wstring name);
 	static void ExportMap(void* cbdata, CScriptValRooted data);
 	static void SetProgress(void* cbdata, int progress);
 	static void MaybeGC(void* cbdata);
 	static std::vector<std::string> GetCivData(void* cbdata);
 
 	std::set<std::wstring> m_LoadedLibraries;
 	shared_ptr<ScriptInterface::StructuredClone> m_MapData;
 	boost::rand48 m_MapGenRNG;
 	int m_Progress;
 	ScriptInterface* m_ScriptInterface;
 	VfsPath m_ScriptPath;
 	std::string m_Settings;
 
 // Thread
 	static void* RunThread(void* data);
 	bool Run();
 
 	pthread_t m_WorkerThread;
 	CMutex m_WorkerMutex;
 };
 
 
 #endif	//INCLUDED_MAPGENERATOR
Index: ps/trunk/source/graphics/TextureManager.h
===================================================================
--- ps/trunk/source/graphics/TextureManager.h	(revision 13418)
+++ ps/trunk/source/graphics/TextureManager.h	(revision 13419)
@@ -1,289 +1,291 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2013 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. 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.
  *
  * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef INCLUDED_TEXTUREMANAGER
 #define INCLUDED_TEXTUREMANAGER
 
 #include "Texture.h"
 
 #include "lib/ogl.h"
 #include "lib/file/vfs/vfs.h"
 #include "lib/res/handle.h"
 
 #include <boost/weak_ptr.hpp>
 
 class CTextureProperties;
 class CTextureManagerImpl;
 
 /**
  * Texture manager with asynchronous loading and automatic DDS conversion/compression.
  *
  * Input textures can be any format. They will be converted to DDS using settings defined
  * in files named "texture.xml", in the same directory as the texture and in its parent
  * directories. See CTextureConverter for the XML syntax. The DDS file will be cached
  * for faster loading in the future.
  *
  * Typically the graphics code will initialise many textures at the start of the game,
  * mostly for off-screen objects, by calling CreateTexture().
  * Loading texture data may be very slow (especially if it needs to be converted
  * to DDS), and we don't want the game to become unresponsive.
  * CreateTexture therefore returns an object immediately, without loading the
  * texture. If the object is never used then the data will never be loaded.
  *
  * Typically, the renderer will call CTexture::Bind() when it wants to use the
  * texture. This will trigger the loading of the texture data. If it can be loaded
  * quickly (i.e. there is already a cached DDS version), then it will be loaded before
  * the function returns, and the texture can be rendered as normal.
  *
  * If loading will take a long time, then Bind() binds a default placeholder texture
  * and starts loading the texture in the background. It will use the correct texture
  * when the renderer next calls Bind() after the load has finished.
  *
  * It is also possible to prefetch textures which are not being rendered yet, but
  * are expected to be rendered soon (e.g. for off-screen terrain tiles).
  * These will be loaded in the background, when there are no higher-priority textures
  * to load.
  *
  * The same texture file can be safely loaded multiple times with different GL parameters
  * (but this should be avoided whenever possible, as it wastes VRAM).
  *
  * For release packages, DDS files can be precached by appending ".dds" to their name,
  * which will be used instead of doing runtime conversion. This means most players should
  * never experience the slow asynchronous conversion behaviour.
  * These cache files will typically be packed into an archive for faster loading;
  * if no archive cache is available then the source file will be converted and stored
  * as a loose cache file on the user's disk.
  */
 class CTextureManager
 {
+	NONCOPYABLE(CTextureManager);
+
 public:
 	/**
 	 * Construct texture manager. vfs must be the VFS instance used for all textures
 	 * loaded from this object.
 	 * highQuality is slower and intended for batch-conversion modes.
 	 * disableGL is intended for tests, and will disable all GL uploads.
 	 */
 	CTextureManager(PIVFS vfs, bool highQuality, bool disableGL);
 
 	~CTextureManager();
 
 	/**
 	 * Create a texture with the given GL properties.
 	 * The texture data will not be loaded immediately.
 	 */
 	CTexturePtr CreateTexture(const CTextureProperties& props);
 
 	/**
 	 * Returns a magenta texture. Use this for highlighting errors
 	 * (e.g. missing terrain textures).
 	 */
 	CTexturePtr GetErrorTexture();
 
 	/**
 	 * Work on asynchronous texture loading operations, if any.
 	 * Returns true if it did any work.
 	 * The caller should typically loop this per frame until it returns
 	 * false or exceeds the allocated time for this frame.
 	 */
 	bool MakeProgress();
 
 	/**
 	 * Synchronously converts and compresses and saves the texture,
 	 * and returns the output path (minus a "cache/" prefix). This
 	 * is intended for pre-caching textures in release archives.
 	 * @return true on success
 	 */
 	bool GenerateCachedTexture(const VfsPath& path, VfsPath& outputPath);
 
 private:
 	CTextureManagerImpl* m;
 };
 
 /**
  * Represents the filename and GL parameters of a texture,
  * for passing to CTextureManager::CreateTexture.
  */
 class CTextureProperties
 {
 	friend class CTextureManagerImpl;
 	friend struct TextureCacheCmp;
 	friend struct TPequal_to;
 	friend struct TPhash;
 
 public:
 	/**
 	 * Use the given texture name, and default GL parameters.
 	 */
 	explicit CTextureProperties(const VfsPath& path) :
 		m_Path(path), m_Filter(GL_LINEAR_MIPMAP_LINEAR),
 		m_WrapS(GL_REPEAT), m_WrapT(GL_REPEAT), m_Aniso(1.0f)
 	{
 	}
 
 	/**
 	 * Set min/mag filter mode (typically GL_LINEAR_MIPMAP_LINEAR, GL_NEAREST, etc).
 	 */
 	void SetFilter(GLint filter) { m_Filter = filter; }
 
 	/**
 	 * Set wrapping mode (typically GL_REPEAT, GL_CLAMP_TO_EDGE, etc).
 	 */
 	void SetWrap(GLint wrap) { m_WrapS = wrap; m_WrapT = wrap; }
 
 	/**
 	 * Set wrapping mode (typically GL_REPEAT, GL_CLAMP_TO_EDGE, etc),
 	 * separately for S and T.
 	 */
 	void SetWrap(GLint wrap_s, GLint wrap_t) { m_WrapS = wrap_s; m_WrapT = wrap_t; }
 
 	/**
 	 * Set maximum anisotropy value. Must be >= 1.0. Should be a power of 2.
 	 */
 	void SetMaxAnisotropy(float aniso) { m_Aniso = aniso; }
 
 	// TODO: rather than this static definition of texture properties
 	// (especially anisotropy), maybe we want something that can be more
 	// easily tweaked in an Options menu? e.g. the caller just specifies
 	// "terrain texture mode" and we combine it with the user's options.
 	// That'd let us dynamically change texture properties easily.
 	//
 	// enum EQualityMode
 	// {
 	//   NONE,
 	//   TERRAIN,
 	//   MODEL,
 	//   GUI
 	// }
 	// void SetQuality(EQualityMode mode, float anisotropy, float lodbias, int reducemipmaps, ...);
 	//
 	// or something a bit like that.
 
 private:
 	VfsPath m_Path;
 	GLint m_Filter;
 	GLint m_WrapS;
 	GLint m_WrapT;
 	float m_Aniso;
 };
 
 /**
  * Represents a texture object.
  * The texture data may or may not have been loaded yet.
  * Before it has been loaded, all operations will act on a default
  * 1x1-pixel grey texture instead.
  */
 class CTexture
 {
 	friend class CTextureManagerImpl;
 	friend struct TextureCacheCmp;
 	friend struct TPequal_to;
 	friend struct TPhash;
 
 	// Only the texture manager can create these
 	explicit CTexture(Handle handle, const CTextureProperties& props, CTextureManagerImpl* textureManager);
 
 	NONCOPYABLE(CTexture);
 
 public:
 
 	~CTexture();
 
 	/**
 	 * Returns the width (in pixels) of the current texture.
 	 */
 	size_t GetWidth() const;
 
 	/**
 	 * Returns the height (in pixels) of the current texture.
 	 */
 	size_t GetHeight() const;
 
 	/**
 	 * Returns whether the current texture has an alpha channel.
 	 */
 	bool HasAlpha() const;
 
 	/**
 	 * Returns the ARGB value of the lowest mipmap level (i.e. the
 	 * average of the whole texture).
 	 * Returns 0 if the texture has no mipmaps.
 	 */
 	u32 GetBaseColour() const;
 
 	/**
 	 * Bind the texture to the given GL texture unit.
 	 * If the texture data hasn't been loaded yet, this may wait a short while to
 	 * load it. If loading takes too long then it will return sooner and the data will
 	 * be loaded in a background thread, so this does not guarantee the texture really
 	 * will be loaded.
 	 */
 	void Bind(size_t unit = 0);
 
 	/**
 	 * Returns a ogl_tex handle, for later binding. See comments from Bind().
 	 */
 	Handle GetHandle();
 
 	/**
 	 * Attempt to load the texture data quickly, as with Bind().
 	 * Returns whether the texture data is currently loaded.
 	 */
 	bool TryLoad();
 
 	/**
 	 * Returns whether the texture data is currently loaded.
 	 */
 	bool IsLoaded();
 
 	/**
 	 * Activate the prefetching optimisation for this texture.
 	 * Use this if it is likely the texture will be needed in the near future.
 	 * It will be loaded in the background so that it is likely to be ready when
 	 * it is used by Bind().
 	 */
 	void Prefetch();
 
 private:
 	/**
 	 * Replace the Handle stored by this object.
 	 * If takeOwnership is true, it will not increment the Handle's reference count.
 	 */
 	void SetHandle(Handle handle, bool takeOwnership = false);
 
 	const CTextureProperties m_Properties;
 
 	Handle m_Handle;
 	u32 m_BaseColour;
 
 	enum {
 		UNLOADED, // loading has not started
 		PREFETCH_NEEDS_LOADING, // was prefetched; currently waiting to try loading from cache
 		PREFETCH_NEEDS_CONVERTING, // was prefetched; currently waiting to be sent to the texture converter
 		PREFETCH_IS_CONVERTING, // was prefetched; currently being processed by the texture converter
 		HIGH_NEEDS_CONVERTING, // high-priority; currently waiting to be sent to the texture converter
 		HIGH_IS_CONVERTING, // high-priority; currently being processed by the texture converter
 		LOADED // loading has completed (successfully or not)
 	} m_State;
 
 	CTextureManagerImpl* m_TextureManager;
 
 	// Self-reference to let us recover the CTexturePtr for this object.
 	// (weak pointer to avoid cycles)
 	boost::weak_ptr<CTexture> m_Self;
 };
 
 #endif // INCLUDED_TEXTUREMANAGER
Index: ps/trunk/source/gui/CGUI.h
===================================================================
--- ps/trunk/source/gui/CGUI.h	(revision 13418)
+++ ps/trunk/source/gui/CGUI.h	(revision 13419)
@@ -1,683 +1,685 @@
 /* Copyright (C) 2013 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. 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.
  *
  * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /*
 CGUI
 
 --Overview--
 
 	This is the top class of the whole GUI, all objects
 	and settings are stored within this class.
 
 --More info--
 
 	Check GUI.h
 
 */
 
 #ifndef INCLUDED_CGUI
 #define INCLUDED_CGUI
 
 //--------------------------------------------------------
 //  Includes / Compiler directives
 //--------------------------------------------------------
 // NOTE: GUI.h included at the bottom of this file (has to be after CGUI class
 // definition)
 
 #include "GUITooltip.h"
 #include "GUIbase.h"
 
 #include "ps/Overlay.h" // CPos and CRect
 
 #include "lib/input.h"
 
 #include "ps/XML/Xeromyces.h"
 
 #include <boost/unordered_set.hpp>
 
 //--------------------------------------------------------
 //  Macros
 //--------------------------------------------------------
 
 //--------------------------------------------------------
 //  Types
 //--------------------------------------------------------
 
 //--------------------------------------------------------
 //  Error declarations
 //--------------------------------------------------------
 
 ERROR_TYPE(GUI, JSOpenFailed);
 
 //--------------------------------------------------------
 //  Declarations
 //--------------------------------------------------------
 
 /**
  * Contains a list of values for new defaults to objects.
  */
 struct SGUIStyle
 {
 	// A list of defaults for 
 	std::map<CStr, CStrW> m_SettingsDefaults;
 };
 
 struct JSObject; // The GUI stores a JSObject*, so needs to know that JSObject exists
 class IGUIObject;
 class CGUISpriteInstance;
 struct SGUIText;
 struct CColor;
 struct SGUIText;
 struct SGUIIcon;
 class CGUIString;
 class CGUISprite;
 struct SGUIImageEffects;
 struct SGUIScrollBarStyle;
 class GUITooltip;
 
 /**
  * The main object that represents a whole GUI page.
  *
  * No interfacial functions throws.
  */
 class CGUI
 {
+	NONCOPYABLE(CGUI);
+	
 	friend class IGUIObject;
 	friend class IGUIScrollBarOwner;
 	friend class CInternalCGUIAccessorBase;
 
 private:
 	// Private typedefs
 	typedef IGUIObject *(*ConstructObjectFunction)();
 
 public:
 	CGUI();
 	~CGUI();
 
 	/**
 	 * Initializes GUI script classes
 	 */
 	static void ScriptingInit();
 
 	/**
 	 * Initializes the GUI, needs to be called before the GUI is used
 	 */
 	void Initialize();
 	
 	/**
 	 * Performs processing that should happen every frame
 	 * (including sending the "Tick" event to scripts)
 	 */
 	void TickObjects();
 
 	/**
 	 * Sends a specified script event to every object
 	 *
 	 * @param EventName String representation of event name
 	 */
 	void SendEventToAll(const CStr& EventName);
 
 	/**
 	 * Displays the whole GUI
 	 */
 	void Draw();
 
 	/**
 	 * Draw GUI Sprite
 	 *
 	 * @param Sprite Object referring to the sprite (which also caches
 	 *        calculations for faster rendering)
 	 * @param CellID Number of the icon cell to use. (Ignored if this sprite doesn't
 	 *        have any images with "cell-size")
 	 * @param Z Drawing order, depth value
 	 * @param Rect Position and Size
 	 * @param Clipping The sprite shouldn't be drawn outside this rectangle
 	 */
 	void DrawSprite(const CGUISpriteInstance& Sprite, int CellID, const float &Z, 
 					const CRect &Rect, const CRect &Clipping=CRect());
 
 	/**
 	 * Draw a SGUIText object
 	 *
 	 * @param Text Text object.
 	 * @param DefaultColor Color used if no tag applied.
 	 * @param pos position
 	 * @param z z value.
 	 * @param clipping
 	 */
 	void DrawText(SGUIText &Text, const CColor &DefaultColor, 
 				  const CPos &pos, const float &z, const CRect &clipping);
 
 	/**
 	 * Clean up, call this to clean up all memory allocated
 	 * within the GUI.
 	 */
 	void Destroy();
 
 	/**
 	 * The replacement of Process(), handles an SDL_Event_
 	 *
 	 * @param ev SDL Event, like mouse/keyboard input
 	 */
 	InReaction HandleEvent(const SDL_Event_* ev);
 
 	/**
 	 * Load a GUI XML file into the GUI.
 	 *
 	 * <b>VERY IMPORTANT!</b> All \<styles\>-files must be read before
 	 * everything else!
 	 *
 	 * @param Filename Name of file
 	 * @param Paths Set of paths; all XML and JS files loaded will be added to this
 	 */
 	void LoadXmlFile(const VfsPath& Filename, boost::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Checks if object exists and return true or false accordingly
 	 *
 	 * @param Name String name of object
 	 * @return true if object exists
 	 */
 	bool ObjectExists(const CStr& Name) const;
 
 
 	/**
 	 * Returns the GUI object with the desired name, or NULL
 	 * if no match is found,
 	 *
 	 * @param Name String name of object
 	 * @return Matching object, or NULL
 	 */
 	IGUIObject* FindObjectByName(const CStr& Name) const;
 
 	/**
 	 * Returns the GUI object under the mouse, or NULL if none.
 	 */
 	IGUIObject* FindObjectUnderMouse() const;
 
 	/**
 	 * The GUI needs to have all object types inputted and
 	 * their constructors. Also it needs to associate a type
 	 * by a string name of the type.
 	 * 
 	 * To add a type:
 	 * @code
 	 * AddObjectType("button", &CButton::ConstructObject);
 	 * @endcode
 	 *
 	 * @param str Reference name of object type
 	 * @param pFunc Pointer of function ConstuctObject() in the object
 	 *
 	 * @see CGUI#ConstructObject()
 	 */
 	void AddObjectType(const CStr& str, ConstructObjectFunction pFunc) { m_ObjectTypes[str] = pFunc; }
 
 	/**
 	 * Update Resolution, should be called every time the resolution
 	 * of the OpenGL screen has been changed, this is because it needs
 	 * to re-cache all its actual sizes
 	 *
 	 * Needs no input since screen resolution is global.
 	 *
 	 * @see IGUIObject#UpdateCachedSize()
 	 */
 	void UpdateResolution();
 
 	/**
 	 * Generate a SGUIText object from the inputted string.
 	 * The function will break down the string and its
 	 * tags to calculate exactly which rendering queries
 	 * will be sent to the Renderer. Also, horizontal alignment
 	 * is taken into acount in this method but NOT vertical alignment.
 	 *
 	 * Done through the CGUI since it can communicate with 
 	 *
 	 * @param Text Text to generate SGUIText object from
 	 * @param Font Default font, notice both Default color and default font
 	 *		  can be changed by tags.
 	 * @param Width Width, 0 if no word-wrapping.
 	 * @param BufferZone space between text and edge, and space between text and images.
 	 * @param pObject Optional parameter for error output. Used *only* if error parsing fails, 
 	 *		  and we need to be able to output which object the error occured in to aid the user. 
 	 */
 	SGUIText GenerateText(const CGUIString &Text, const CStrW& Font,
 						  const float &Width, const float &BufferZone,
 						  const IGUIObject *pObject=NULL);
 
 	/**
 	 * Returns the JSObject* associated with the GUI
 	 *
 	 * @return The relevant JS object
 	 */
 	JSObject* GetScriptObject() { return m_ScriptObject; }
 
 	/**
 	 * Check if an icon exists
 	 */
 	bool IconExists(const CStr& str) const { return (m_Icons.count(str) != 0); }
 
 	/**
 	 * Get Icon (a copy, can never be changed)
 	 */
 	SGUIIcon GetIcon(const CStr& str) const { return m_Icons.find(str)->second; }
 
 	/**
 	 * Get pre-defined color (if it exists)
 	 * Returns false if it fails.
 	 */
 	bool GetPreDefinedColor(const CStr& name, CColor &Output);
 
 private:
 
 	/**
 	 * Updates the object pointers, needs to be called each
 	 * time an object has been added or removed.
 	 *
 	 * This function is atomic, meaning if it throws anything, it will
 	 * have seen it through that nothing was ultimately changed.
 	 *
 	 * @throws PSERROR_GUI that is thrown from IGUIObject::AddToPointersMap().
 	 */
 	void UpdateObjects();
 
 	/**
 	 * Adds an object to the GUI's object database
 	 * Private, since you can only add objects through 
 	 * XML files. Why? Because it enables the GUI to
 	 * be much more encapsulated and safe.
 	 *
 	 * @throws	Rethrows PSERROR_GUI from IGUIObject::AddChild().
 	 */
 	void AddObject(IGUIObject* pObject);
 
 	/**
 	 * You input the name of the object type, and let's
 	 * say you input "button", then it will construct a
 	 * CGUIObjet* as a CButton.
 	 *
 	 * @param str Name of object type
 	 * @return Newly constructed IGUIObject (but constructed as a subclass)
 	 */
 	IGUIObject *ConstructObject(const CStr& str);
 
 	/**
 	 * Get Focused Object.
 	 */
 	IGUIObject *GetFocusedObject() { return m_FocusedObject; }
 
 public:
 	/**
 	 * Change focus to new object.
 	 * Will send LOST_FOCUS/GOT_FOCUS messages as appropriate.
 	 * pObject can be NULL to remove all focus.
 	 */
 	void SetFocusedObject(IGUIObject* pObject);
 
 private:
 	//--------------------------------------------------------
 	/** @name XML Reading Xeromyces specific subroutines
 	 *
 	 * These does not throw!
 	 * Because when reading in XML files, it won't be fatal
 	 * if an error occurs, perhaps one particular object
 	 * fails, but it'll still continue reading in the next.
 	 * All Error are reported with ReportParseError
 	 */
 	//--------------------------------------------------------
 
 	/*
 		Xeromyces_* functions tree
 		<objects> (ReadRootObjects)
 		 |
 		 +-<script> (ReadScript)
 		 |
 		 +-<object> (ReadObject)
 			|
 			+-<action>
 			|
 			+-Optional Type Extensions (IGUIObject::ReadExtendedElement) TODO
 			|
 			+-<<object>> *recursive*
 
 
 		<styles> (ReadRootStyles)
 		 |
 		 +-<style> (ReadStyle)
 
 
 		<sprites> (ReadRootSprites)
 		 |
 		 +-<sprite> (ReadSprite)
 			|
 			+-<image> (ReadImage)
 
 
 		<setup> (ReadRootSetup)
 		 |
 		 +-<tooltip> (ReadToolTip)
 		 |
 		 +-<scrollbar> (ReadScrollBar)
 		 |
 		 +-<icon> (ReadIcon)
 		 |
 		 +-<color> (ReadColor)
 	*/
 	//@{
 
 	// Read Roots
 
 	/**
 	 * Reads in the root element \<objects\> (the DOMElement).
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the objects-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param Paths		Collects the set of all XML/JS files that are loaded
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadRootObjects(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Reads in the root element \<sprites\> (the DOMElement).
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the sprites-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadRootSprites(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the root element \<styles\> (the DOMElement).
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the styles-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadRootStyles(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the root element \<setup\> (the DOMElement).
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the setup-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadRootSetup(XMBElement Element, CXeromyces* pFile);
 
 	// Read Subs
 
 	/**
 	 * Notice! Recursive function!
 	 *
 	 * Read in an \<object\> (the XMBElement) and stores it
 	 * as a child in the pParent.
 	 *
 	 * It will also check the object's children and call this function
 	 * on them too. Also it will call all other functions that reads
 	 * in other stuff that can be found within an object. Check the
 	 * tree in the beginning of this class' Xeromyces_* section.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the object-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param pParent	Parent to add this object as child in.
 	 * @param NameSubst	A set of substitution strings that will be
 	 * 					applied to all object names within this object.
 	 * @param Paths		Output set of file paths that this GUI object
 	 * 					relies on.
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadObject(XMBElement Element, CXeromyces* pFile, IGUIObject *pParent, const std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Reads in the element \<repeat\>, which repeats its child \<object\>s
 	 * 'count' times, replacing the string "[n]" in its descendants' names
 	 * with "[0]", "[1]", etc.
 	 */
 	void Xeromyces_ReadRepeat(XMBElement Element, CXeromyces* pFile, IGUIObject *pParent, boost::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Reads in the element \<script\> (the XMBElement) and executes
 	 * the script's code.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the script-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param Paths		Output set of file paths that this script is loaded from.
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadScript(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Reads in the element \<sprite\> (the XMBElement) and stores the
 	 * result in a new CGUISprite.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the sprite-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadSprite(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<image\> (the XMBElement) and stores the
 	 * result within the CGUISprite.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the image-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param parent	Parent sprite.
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadImage(XMBElement Element, CXeromyces* pFile, CGUISprite &parent);
 
 	/**
 	 * Reads in the element \<effect\> (the XMBElement) and stores the
 	 * result within the SGUIImageEffects.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the image-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param effects	Effects object to add this effect to.
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadEffects(XMBElement Element, CXeromyces* pFile, SGUIImageEffects &effects);
 
 	/**
 	 * Reads in the element \<style\> (the XMBElement) and stores the
 	 * result in m_Styles.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the style-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadStyle(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<scrollbar\> (the XMBElement) and stores the
 	 * result in m_ScrollBarStyles.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the scrollbar-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadScrollBarStyle(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<icon\> (the XMBElement) and stores the
 	 * result in m_Icons.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the scrollbar-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadIcon(XMBElement Element, CXeromyces* pFile);
 	
 	/**
 	 * Reads in the element \<tooltip\> (the XMBElement) and stores the
 	 * result as an object with the name __tooltip_#.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the scrollbar-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadTooltip(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<color\> (the XMBElement) and stores the
 	 * result in m_PreDefinedColors
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the scrollbar-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadColor(XMBElement Element, CXeromyces* pFile);
 
 	//@}
 
 private:
 
 	// Variables
 
 	//--------------------------------------------------------
 	/** @name Miscellaneous */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * An JSObject* under which all GUI JavaScript things will
 	 * be created, so that they can be garbage-collected
 	 * when the GUI shuts down.
 	 */
 	JSObject* m_ScriptObject;
 
 	/**
 	 * don't want to pass this around with the 
 	 * ChooseMouseOverAndClosest broadcast -
 	 * we'd need to pack this and pNearest in a struct
 	 */
 	CPos m_MousePos;
 
 	/**
 	 * Indicates which buttons are pressed (bit 0 = LMB,
 	 * bit 1 = RMB, bit 2 = MMB)
 	 */
 	unsigned int m_MouseButtons;
 
 	// Tooltip
 	GUITooltip m_Tooltip;
 
 	/**
 	 * This is a bank of custom colors, it is simply a look up table that
 	 * will return a color object when someone inputs the name of that
 	 * color. Of course the colors have to be declared in XML, there are
 	 * no hard-coded values.
 	 */
 	std::map<CStr, CColor>	m_PreDefinedColors;
 
 	//@}
 	//--------------------------------------------------------
 	/** @name Objects */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Base Object, all its children are considered parentless
 	 * because this is not a real object per se.
 	 */
 	IGUIObject* m_BaseObject;
 
 	/**
 	 * Focused object!
 	 * Say an input box that is selected. That one is focused.
 	 * There can only be one focused object.
 	 */
 	IGUIObject* m_FocusedObject;
 
 	/** 
 	 * Just pointers for fast name access, each object
 	 * is really constructed within its parent for easy
 	 * recursive management.
 	 * Notice m_BaseObject won't belong here since it's
 	 * not considered a real object.
 	 */
 	map_pObjects m_pAllObjects;
 
 	/**
 	 * Number of object that has been given name automatically.
 	 * the name given will be '__internal(#)', the number (#)
 	 * being this variable. When an object's name has been set
 	 * as followed, the value will increment.
 	 */
 	int m_InternalNameNumber;
 
 	/**
 	 * Function pointers to functions that constructs
 	 * IGUIObjects by name... For instance m_ObjectTypes["button"]
 	 * is filled with a function that will "return new CButton();"
 	 */
 	std::map<CStr, ConstructObjectFunction>	m_ObjectTypes;
 
 	/**
 	 * Map from hotkey names to objects that listen to the hotkey.
 	 * (This is an optimisation to avoid recursing over the whole GUI
 	 * tree every time a hotkey is pressed).
 	 * Currently this is only set at load time - dynamic changes to an
 	 * object's hotkey property will be ignored.
 	 */
 	std::map<CStr, std::vector<IGUIObject*> > m_HotkeyObjects;
 
 	//--------------------------------------------------------
 	//	Databases
 	//--------------------------------------------------------
 
 	// Sprites
 	std::map<CStr, CGUISprite> m_Sprites;
 
 	// Styles
 	std::map<CStr, SGUIStyle> m_Styles;
 
 	// Scroll-bar styles
 	std::map<CStr, SGUIScrollBarStyle> m_ScrollBarStyles;
 
 	// Icons
 	std::map<CStr, SGUIIcon> m_Icons;
 };
 
 #endif
Index: ps/trunk/source/maths/Noise.h
===================================================================
--- ps/trunk/source/maths/Noise.h	(revision 13418)
+++ ps/trunk/source/maths/Noise.h	(revision 13419)
@@ -1,66 +1,70 @@
-/* Copyright (C) 2009 Wildfire Games.
+/* Copyright (C) 2013 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. 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.
  *
  * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /*
  * 2D and 3D seamless Perlin noise
  */
 
 // Based on http://www.cs.cmu.edu/~mzucker/code/perlin-noise-math-faq.html 
 // and http://mrl.nyu.edu/~perlin/paper445.pdf.
 // Not optimized for speed yet.
 
 #ifndef INCLUDED_NOISE
 #define INCLUDED_NOISE
 
 #include "Vector2D.h"
 #include "Vector3D.h"
 #include "MathUtil.h"
 
 class Noise2D
 {
+	NONCOPYABLE(Noise2D);
+
 	/// Frequency in X and Y
 	int freq;
 
 	/// freq*freq random gradient vectors in the unit cube
 	CVector2D** grads;
 public:
 	Noise2D(int freq);
 	~Noise2D();
 	
 	/// Evaluate the noise function at a given point
 	float operator() (float x, float y);
 };
 
 class Noise3D 
 {
+	NONCOPYABLE(Noise3D);
+
 	/// Frequency in X and Y
 	int freq;
 
 	/// Frequency in Z (vertical frequency)
 	int vfreq;
 
 	/// freq*freq*vfreq random gradient vectors in the unit cube
 	CVector3D*** grads;
 public:
 	Noise3D(int freq, int vfreq);
 	~Noise3D();
 	
 	/// Evaluate the noise function at a given point
 	float operator() (float x, float y, float z);
 };
 
 #endif
Index: ps/trunk/source/maths/scripting/JSInterface_Vector3D.h
===================================================================
--- ps/trunk/source/maths/scripting/JSInterface_Vector3D.h	(revision 13418)
+++ ps/trunk/source/maths/scripting/JSInterface_Vector3D.h	(revision 13419)
@@ -1,66 +1,69 @@
-/* Copyright (C) 2009 Wildfire Games.
+/* Copyright (C) 2013 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. 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.
  *
  * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 // JSInterface_Entity.h
 //
 // 
 // A JavaScript class representing a Pyrogenesis CVector3D object.
 //
 // Usage: Used when manipulating objects of class 'Vector3D' in JavaScript.
 
 #include "scripting/ScriptingHost.h"
 #include "maths/Vector3D.h"
 
 #ifndef INCLUDED_JSI_VECTOR3
 #define INCLUDED_JSI_VECTOR3
 
 namespace JSI_Vector3D
 {
 	enum 
 	{
 		component_x,
 		component_y,
 		component_z
 	};
 	JSBool toString(JSContext* cx, uintN argc, jsval* vp);
 
 	struct Vector3D_Info
 	{
+		NONCOPYABLE(Vector3D_Info);
+	public:
+
 		IPropertyOwner* owner;
 		void (IPropertyOwner::*updateFn)();
 		void (IPropertyOwner::*freshenFn)();
 		CVector3D* vector;
 		Vector3D_Info();
 		Vector3D_Info(float x, float y, float z);
 		Vector3D_Info(const CVector3D& copy);
 		Vector3D_Info(CVector3D* attach, IPropertyOwner* _owner);
 		Vector3D_Info(CVector3D* attach, IPropertyOwner* _owner, void(IPropertyOwner::*_updateFn)(void));
 		Vector3D_Info(CVector3D* attach, IPropertyOwner* _owner, void(IPropertyOwner::*_updateFn)(void), void(IPropertyOwner::*_freshenFn)(void));
 		~Vector3D_Info();
 	};
 	extern JSClass JSI_class;
 	extern JSPropertySpec JSI_props[];
 	extern JSFunctionSpec JSI_methods[];
 
 	JSBool getProperty(JSContext* cx, JSObject* obj, jsid id, jsval* vp);
 	JSBool setProperty(JSContext* cx, JSObject* obj, jsid id, JSBool strict, jsval* vp);
 	void finalize(JSContext* cx, JSObject* obj);
 	JSBool construct(JSContext* cx, uintN argc, jsval* vp);
 	void init();
 }
 
 #endif
Index: ps/trunk/source/ps/CConsole.h
===================================================================
--- ps/trunk/source/ps/CConsole.h	(revision 13418)
+++ ps/trunk/source/ps/CConsole.h	(revision 13419)
@@ -1,152 +1,154 @@
 /* Copyright (C) 2013 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. 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.
  *
  * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /*
  * Implements the in-game console with scripting support.
  */
 
 #ifndef INCLUDED_CCONSOLE
 #define INCLUDED_CCONSOLE
 
 #include <stdarg.h>
 #include <string>
 #include <deque>
 #include <map>
 
 #include "lib/input.h"
 #include "lib/file/vfs/vfs_path.h"
 #include "ps/CStr.h"
 #include "ps/ThreadUtil.h"
 
 class CShaderProgram;
 typedef shared_ptr<CShaderProgram> CShaderProgramPtr;
 
 class CTextRenderer;
 
 #define CONSOLE_BUFFER_SIZE 1024 // for text being typed into the console
 #define CONSOLE_MESSAGE_SIZE 1024 // for messages being printed into the console
 
 #define CONSOLE_FONT L"mono-10"
 
 /**
  * In-game console.
  *
  * Thread-safety:
  * - Expected to be constructed/destructed in the main thread.
  * - InsertMessage may be called from any thread while the object is alive.
  */
 class CConsole
 {
+	NONCOPYABLE(CConsole);
+
 public:
 	CConsole();
 	~CConsole();
 
 	void SetSize(float X = 300, float Y = 0, float W = 800, float H = 600);
 	void UpdateScreenSize(int w, int h);
 
 	void ToggleVisible();
 	void SetVisible(bool visible);
 
 	void SetCursorBlinkRate(double rate);
 
 	/**
 	 * @param deltaRealTime Elapsed real time since the last frame.
 	 */
 	void Update(const float deltaRealTime);
 
 	void Render();
 
 	void InsertMessage(const wchar_t* szMessage, ...) WPRINTF_ARGS(2);
 	void InsertChar(const int szChar, const wchar_t cooked);
 
 	void ReceivedChatMessage(const wchar_t *pSender, const wchar_t *szMessage);
 
 	void SetBuffer(const wchar_t* szMessage);
 
 	void UseHistoryFile(const VfsPath& filename, int historysize);
 
 	// Only returns a pointer to the buffer; copy out of here if you want to keep it.
 	const wchar_t* GetBuffer();
 	void FlushBuffer();
 
 	bool IsActive() { return m_bVisible; }
 
 	int m_iFontHeight;
 	int m_iFontWidth;
 	int m_iFontOffset; // distance to move up before drawing
 	size_t m_charsPerPage;
 
 private:
 	// Lock for all state modified by InsertMessage
 	CMutex m_Mutex;
 
 	float m_fX;
 	float m_fY;
 
 	float m_fHeight;
 	float m_fWidth;
 
 	// "position" in show/hide animation, how visible the console is (0..1).
 	// allows implementing other animations than sliding, e.g. fading in/out.
 	float m_fVisibleFrac;
 	
 	std::deque<std::wstring> m_deqMsgHistory; // protected by m_Mutex
 	std::deque<std::wstring> m_deqBufHistory;
 
 	int m_iMsgHistPos;
 
 	wchar_t* m_szBuffer;
 	int	m_iBufferPos;
 	int	m_iBufferLength;
 
 	VfsPath m_sHistoryFile;
 	int m_MaxHistoryLines;
 
 	bool m_bFocus;
 	bool m_bVisible;	// console is to be drawn
 	bool m_bToggle;		// show/hide animation is currently active
 	double m_prevTime;	// the previous time the cursor draw state changed (used for blinking cursor)
 	bool m_bCursorVisState;	// if the cursor should be drawn or not
 	double m_cursorBlinkRate;	// cursor blink rate in seconds, if greater than 0.0
 
 	void ToLower(wchar_t* szMessage, size_t iSize = 0);
 	void Trim(wchar_t* szMessage, const wchar_t cChar = 32, size_t iSize = 0);
 
 	void DrawWindow(CShaderProgramPtr& shader);
 	void DrawHistory(CTextRenderer& textRenderer);
 	void DrawBuffer(CTextRenderer& textRenderer);
 	void DrawCursor(CTextRenderer& textRenderer);
 
 	bool IsEOB() { return (m_iBufferPos == m_iBufferLength); } // Is end of Buffer?
 	bool IsBOB() { return (m_iBufferPos == 0); } // Is beginning of Buffer?
 	bool IsFull() { return (m_iBufferLength == CONSOLE_BUFFER_SIZE); }
 	bool IsEmpty() { return (m_iBufferLength == 0); }
 
 	void ProcessBuffer(const wchar_t* szLine);
 
 	// Insert message without printf-style formatting, and without length limits
 	void InsertMessageRaw(const CStrW& message);
 
 	void LoadHistory();
 	void SaveHistory();
 };
 
 extern CConsole* g_Console;
 
 extern InReaction conInputHandler(const SDL_Event_* ev);
 
 #endif
Index: ps/trunk/source/ps/Profile.h
===================================================================
--- ps/trunk/source/ps/Profile.h	(revision 13418)
+++ ps/trunk/source/ps/Profile.h	(revision 13419)
@@ -1,204 +1,206 @@
-/* Copyright (C) 2011 Wildfire Games.
+/* Copyright (C) 2013 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. 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.
  *
  * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /*
  * GPG3-style hierarchical profiler
  */
 
 #ifndef INCLUDED_PROFILE
 #define INCLUDED_PROFILE
 
 #include <vector>
 
 #include "lib/adts/ring_buf.h"
 #include "ps/Profiler2.h"
 #include "ps/Singleton.h"
 #include "ps/ThreadUtil.h"
 
 #define PROFILE_AMORTIZE_FRAMES 30
 #define PROFILE_AMORTIZE_TURNS 1
 
 class CProfileManager;
 class CProfileNodeTable;
 
 class CStr8;
 class CStrW;
 
 class CProfileNode
 {
+	NONCOPYABLE(CProfileNode);
+
 	friend class CProfileManager;
 	friend class CProfileNodeTable;
 	
 	const char* name;
 
 	int calls_frame_current;
 	int calls_turn_current;
 	RingBuf<int, PROFILE_AMORTIZE_FRAMES> calls_per_frame;
 	RingBuf<int, PROFILE_AMORTIZE_TURNS> calls_per_turn;
 
 	double time_frame_current;
 	double time_turn_current;
 	RingBuf<double, PROFILE_AMORTIZE_FRAMES> time_per_frame;
 	RingBuf<double, PROFILE_AMORTIZE_TURNS> time_per_turn;
 
 	long mallocs_frame_current;
 	long mallocs_turn_current;
 	RingBuf<long, PROFILE_AMORTIZE_FRAMES> mallocs_per_frame;
 	RingBuf<long, PROFILE_AMORTIZE_TURNS> mallocs_per_turn;
 
 	double start;
 	long start_mallocs;
 	int recursion;
 
 	CProfileNode* parent;
 	std::vector<CProfileNode*> children;
 	std::vector<CProfileNode*> script_children;
 	CProfileNodeTable* display_table;
 
 public:
 	typedef std::vector<CProfileNode*>::iterator profile_iterator;
 	typedef std::vector<CProfileNode*>::const_iterator const_profile_iterator;
 
 	CProfileNode( const char* name, CProfileNode* parent );
 	~CProfileNode();
 
 	const char* GetName() const { return name; }
 
 	double GetFrameCalls() const;
 	double GetFrameTime() const;
 	double GetTurnCalls() const;
 	double GetTurnTime() const;
 	double GetFrameMallocs() const;
 	double GetTurnMallocs() const;
 
 	const CProfileNode* GetChild( const char* name ) const;
 	const CProfileNode* GetScriptChild( const char* name ) const;
 	const std::vector<CProfileNode*>* GetChildren() const { return( &children ); }
 	const std::vector<CProfileNode*>* GetScriptChildren() const { return( &script_children ); }
 
 	bool CanExpand();
 
 	CProfileNode* GetChild( const char* name );
 	CProfileNode* GetScriptChild( const char* name );
 	CProfileNode* GetParent() const { return( parent ); }
 
 	// Resets timing information for this node and all its children
 	void Reset();
 	// Resets frame timings for this node and all its children
 	void Frame();
 	// Resets turn timings for this node and all its children
 	void Turn();
 	// Enters the node
 	void Call();
 	// Leaves the node. Returns true if the node has actually been left
 	bool Return();
 };
 
 class CProfileManager : public Singleton<CProfileManager>
 {
 	CProfileNode* root;
 	CProfileNode* current;
 
 	bool needs_structural_reset;
 
 	void PerformStructuralReset();
 
 public:
 	CProfileManager();
 	~CProfileManager();
 
 	// Begins timing for a named subsection
 	void Start( const char* name );
 	void StartScript( const char* name );
 
 	// Ends timing for the current subsection
 	void Stop();
 
 	// Resets all timing information
 	void Reset();
 	// Resets frame timing information
 	void Frame();
 	// Resets turn timing information
 	// (Must not be called before Frame)
 	void Turn();
 	// Resets absolutely everything, at the end of this frame
 	void StructuralReset();
 
 	inline const CProfileNode* GetCurrent() { return( current ); }
 	inline const CProfileNode* GetRoot() { return( root ); }
 };
 
 #define g_Profiler CProfileManager::GetSingleton()
 
 class CProfileSample
 {
 public:
 	CProfileSample(const char* name)
 	{
 		if (CProfileManager::IsInitialised())
 		{
 			// The profiler is only safe to use on the main thread
 			ENSURE(ThreadUtil::IsMainThread());
 
 			g_Profiler.Start(name);
 		}
 	}
 	~CProfileSample()
 	{
 		if (CProfileManager::IsInitialised())
 			g_Profiler.Stop();
 	}
 };
 
 class CProfileSampleScript
 {
 public:
 	CProfileSampleScript( const char* name )
 	{
 		if (CProfileManager::IsInitialised())
 		{
 			// The profiler is only safe to use on the main thread,
 			// but scripts get run on other threads too so we need to
 			// conditionally enable the profiler.
 			// (This usually only gets used in debug mode so performance
 			// doesn't matter much.)
 			if (ThreadUtil::IsMainThread())
 				g_Profiler.StartScript( name );
 		}
 	}
 	~CProfileSampleScript()
 	{
 		if (CProfileManager::IsInitialised())
 			if (ThreadUtil::IsMainThread())
 				g_Profiler.Stop();
 	}
 };
 
 // Put a PROFILE("xyz") block at the start of all code to be profiled.
 // Profile blocks last until the end of the containing scope.
 #define PROFILE(name) CProfileSample __profile(name)
 // Cheat a bit to make things slightly easier on the user
 #define PROFILE_START(name) { CProfileSample __profile(name)
 #define PROFILE_END(name) }
 
 // Do both old and new profilers simultaneously (1+2=3), for convenience.
 #define PROFILE3(name) PROFILE(name); PROFILE2(name)
 
 // Also do GPU
 #define PROFILE3_GPU(name) PROFILE(name); PROFILE2(name); PROFILE2_GPU(name)
 
 #endif // INCLUDED_PROFILE
Index: ps/trunk/source/renderer/OverlayRenderer.h
===================================================================
--- ps/trunk/source/renderer/OverlayRenderer.h	(revision 13418)
+++ ps/trunk/source/renderer/OverlayRenderer.h	(revision 13419)
@@ -1,137 +1,139 @@
-/* Copyright (C) 2012 Wildfire Games.
+/* Copyright (C) 2013 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. 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.
  *
  * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef INCLUDED_OVERLAYRENDERER
 #define INCLUDED_OVERLAYRENDERER
 
 #include "graphics/ShaderManager.h"
 
 struct SOverlayLine;
 struct SOverlayTexturedLine;
 struct SOverlaySprite;
 struct SOverlayQuad;
 class CCamera;
 
 struct OverlayRendererInternals;
 
 /**
  * Class OverlayRenderer: Render various bits of data that overlay the
  * game world (selection circles, health bars, etc).
  */
 class OverlayRenderer
 {
+	NONCOPYABLE(OverlayRenderer);
+
 public:
 	OverlayRenderer();
 	~OverlayRenderer();
 
 	/**
 	 * Performs one-time initialization. Called by CRenderer::Open after graphics
 	 * capabilities and the shader path have been determined (notably VBO support).
 	 */
 	void Initialize();
 
 	/**
 	 * Add a line overlay for rendering in this frame.
 	 * @param overlay Must be non-null. The pointed-to object must remain valid at least
 	 *                until the end of the frame.
 	 */
 	void Submit(SOverlayLine* overlay);
 
 	/**
 	 * Add a textured line overlay for rendering in this frame.
 	 * @param overlay Must be non-null. The pointed-to object must remain valid at least
 	 *                until the end of the frame.
 	 */
 	void Submit(SOverlayTexturedLine* overlay);
 
 	/**
 	 * Add a sprite overlay for rendering in this frame.
 	 * @param overlay Must be non-null. The pointed-to object must remain valid at least
 	 *                until the end of the frame.
 	 */
 	void Submit(SOverlaySprite* overlay);
 
 	/**
 	 * Add a textured quad overlay for rendering in this frame.
 	 * @param overlay Must be non-null. The pointed-to object must remain valid at least
 	 *                until the end of the frame.
 	 */
 	void Submit(SOverlayQuad* overlay);
 
 	/**
 	 * Prepare internal data structures for rendering.
 	 * Must be called after all Submit calls for a frame, and before
 	 * any rendering calls.
 	 */
 	void PrepareForRendering();
 
 	/**
 	 * Reset the list of submitted overlays.
 	 */
 	void EndFrame();
 
 	/**
 	 * Render all the submitted overlays that are embedded in the world
 	 * (i.e. rendered behind other objects in the normal 3D way)
 	 * and should be drawn before water (i.e. may be visible under the water)
 	 */
 	void RenderOverlaysBeforeWater();
 
 	/**
 	 * Render all the submitted overlays that are embedded in the world
 	 * (i.e. rendered behind other objects in the normal 3D way)
 	 * and should be drawn after water (i.e. may be visible on top of the water)
 	 */
 	void RenderOverlaysAfterWater();
 
 	/**
 	 * Render all the submitted overlays that should appear on top of everything
 	 * in the world.
 	 * @param viewCamera camera to be used for billboard computations
 	 */
 	void RenderForegroundOverlays(const CCamera& viewCamera);
 
 	/// Small vertical offset of overlays from terrain to prevent visual glitches
 	static const float OVERLAY_VOFFSET;
 
 private:
 	
 	/**
 	 * Helper method; renders all overlay lines currently registered in the internals. Batch-
 	 * renders textured overlay lines batched according to their visibility status by delegating
 	 * to RenderTexturedOverlayLines(CShaderProgramPtr, bool).
 	 */
 	void RenderTexturedOverlayLines();
 
 	/**
 	 * Helper method; renders those overlay lines currently registered in the internals (i.e.
 	 * in m->texlines) for which the 'always visible' flag equals @p alwaysVisible. Used for
 	 * batch rendering the overlay lines according to their alwaysVisible status, as this
 	 * requires a separate shader to be used.
 	 */
 	void RenderTexturedOverlayLines(CShaderProgramPtr shader, bool alwaysVisible);
 
 	/**
 	 * Helper method; batch-renders all registered quad overlays, batched by their texture for effiency.
 	 */
 	void RenderQuadOverlays();
 
 private:
 	OverlayRendererInternals* m;
 };
 
 #endif // INCLUDED_OVERLAYRENDERER
Index: ps/trunk/source/renderer/ParticleRenderer.h
===================================================================
--- ps/trunk/source/renderer/ParticleRenderer.h	(revision 13418)
+++ ps/trunk/source/renderer/ParticleRenderer.h	(revision 13419)
@@ -1,67 +1,69 @@
-/* Copyright (C) 2011 Wildfire Games.
+/* Copyright (C) 2013 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. 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.
  *
  * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef INCLUDED_PARTICLERENDERER
 #define INCLUDED_PARTICLERENDERER
 
 class CParticleEmitter;
 
 struct ParticleRendererInternals;
 
 #include "graphics/ShaderProgram.h"
 
 /**
  * Render particles.
  */
 class ParticleRenderer
 {
+	NONCOPYABLE(ParticleRenderer);
+
 public:
 	ParticleRenderer();
 	~ParticleRenderer();
 
 	/**
 	 * Add an emitter for rendering in this frame.
 	 */
 	void Submit(CParticleEmitter* emitter);
 
 	/**
 	 * Prepare internal data structures for rendering.
 	 * Must be called after all Submit calls for a frame, and before
 	 * any rendering calls.
 	 */
 	void PrepareForRendering(const CShaderDefines& context);
 
 	/**
 	 * Reset the list of submitted overlays.
 	 */
 	void EndFrame();
 
 	/**
 	 * Render all the submitted particles.
 	 */
 	void RenderParticles(bool solidColor = false);
 
 	/**
 	 * Render bounding boxes for all the submitted emitters.
 	 */
 	void RenderBounds(CShaderProgramPtr& shader);
 
 private:
 	ParticleRendererInternals* m;
 };
 
 #endif // INCLUDED_PARTICLERENDERER
Index: ps/trunk/source/renderer/VertexBuffer.h
===================================================================
--- ps/trunk/source/renderer/VertexBuffer.h	(revision 13418)
+++ ps/trunk/source/renderer/VertexBuffer.h	(revision 13419)
@@ -1,118 +1,120 @@
-/* Copyright (C) 2012 Wildfire Games.
+/* Copyright (C) 2013 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. 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.
  *
  * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /*
  * encapsulation of VBOs with batching and sharing
  */
 
 #ifndef INCLUDED_VERTEXBUFFER
 #define INCLUDED_VERTEXBUFFER
 
 #include "lib/res/graphics/ogl_tex.h"
 
 #include <list>
 #include <vector>
 
 // Absolute maximum (bytewise) size of each GL vertex buffer object.
 // Make it large enough for the maximum feasible mesh size (64K vertexes,
 // 32 bytes per vertex in ShaderModelRenderer).
 // TODO: measure what influence this has on performance
 #define MAX_VB_SIZE_BYTES		(4*1024*1024)
 
 /**
  * CVertexBuffer: encapsulation of ARB_vertex_buffer_object, also supplying 
  * some additional functionality for sharing buffers between multiple objects
  */
 class CVertexBuffer
 {
+	NONCOPYABLE(CVertexBuffer);
+
 public:
 
 	/// VBChunk: describes a portion of this vertex buffer
 	struct VBChunk
 	{
 		/// Owning (parent) vertex buffer
 		CVertexBuffer* m_Owner;
 		/// Start index of this chunk in owner
 		size_t m_Index;
 		/// Number of vertices used by chunk
 		size_t m_Count;
 
 	private:
 		// Only CVertexBuffer can construct/delete these
 		// (Other people should use g_VBMan.Allocate, g_VBMan.Release)
 		friend class CVertexBuffer;
 		VBChunk() {}
 		~VBChunk() {}
 	};
 
 public:
 	// constructor, destructor
 	CVertexBuffer(size_t vertexSize, GLenum usage, GLenum target);
 	~CVertexBuffer();
 
 	/// Bind to this buffer; return pointer to address required as parameter
 	/// to glVertexPointer ( + etc) calls
 	u8* Bind();
 
 	/// Get the address that Bind() will return, without actually binding
 	u8* GetBindAddress();
 
 	/// Unbind any currently-bound buffer, so glVertexPointer etc calls will not attempt to use it
 	static void Unbind();
 
 	/// Update vertex data for given chunk. Transfers the provided data to the actual OpenGL vertex buffer.
 	void UpdateChunkVertices(VBChunk* chunk, void* data);
 
 	size_t GetVertexSize() const { return m_VertexSize; }
 	size_t GetBytesReserved() const;
 	size_t GetBytesAllocated() const;
 
 	/// Returns true if this vertex buffer is compatible with the specified vertex type and intended usage.
 	bool CompatibleVertexType(size_t vertexSize, GLenum usage, GLenum target);
 
 	void DumpStatus();
 
 protected:
 	friend class CVertexBufferManager;		// allow allocate only via CVertexBufferManager
 	
 	/// Try to allocate a buffer of given number of vertices (each of given size), 
 	/// and with the given type - return null if no free chunks available
 	VBChunk* Allocate(size_t vertexSize, size_t numVertices, GLenum usage, GLenum target);
 	/// Return given chunk to this buffer
 	void Release(VBChunk* chunk);
 	
 	
 private:	
 	/// Vertex size of this vertex buffer
 	size_t m_VertexSize;
 	/// Number of vertices of above size in this buffer
 	size_t m_MaxVertices;
 	/// List of free chunks in this buffer
 	std::list<VBChunk*> m_FreeList;
 	/// Available free vertices - total of all free vertices in the free list
 	size_t m_FreeVertices;
 	/// Handle to the actual GL vertex buffer object
 	GLuint m_Handle;
 	/// Raw system memory for systems not supporting VBOs
 	u8* m_SysMem;
 	/// Usage type of the buffer (GL_STATIC_DRAW etc)
 	GLenum m_Usage;
 	/// Buffer target (GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER)
 	GLenum m_Target;
 };
 
 #endif
Index: ps/trunk/source/scriptinterface/ThreadDebugger.cpp
===================================================================
--- ps/trunk/source/scriptinterface/ThreadDebugger.cpp	(revision 13418)
+++ ps/trunk/source/scriptinterface/ThreadDebugger.cpp	(revision 13419)
@@ -1,933 +1,936 @@
 /* Copyright (C) 2013 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. 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.
  *
  * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
  
 #include "precompiled.h"
 
 #include "ThreadDebugger.h"
 #include "lib/utf8.h"
 #include "ps/CLogger.h"
 
 #include <map>
 #include <queue>
 
 // Hooks
 
 CMutex ThrowHandlerMutex;
 static JSTrapStatus ThrowHandler_(JSContext* cx, JSScript* script, jsbytecode* pc, jsval* rval, void* closure)
 {
 	CScopeLock lock(ThrowHandlerMutex);
 	CThreadDebugger* pThreadDebugger = (CThreadDebugger*) closure;
 	return pThreadDebugger->ThrowHandler(cx, script, pc, rval);
 }
 
 CMutex TrapHandlerMutex;
 static JSTrapStatus TrapHandler_(JSContext* cx, JSScript* script, jsbytecode* pc, jsval* rval, jsval closure) 
 {
 	CScopeLock lock(TrapHandlerMutex);
 	CThreadDebugger* pThreadDebugger = (CThreadDebugger*) JSVAL_TO_PRIVATE(closure);
 	jsval val = JSVAL_NULL;
 	return pThreadDebugger->TrapHandler(cx, script, pc, rval, val);
 }
 
 CMutex StepHandlerMutex;
 JSTrapStatus StepHandler_(JSContext* cx, JSScript* script, jsbytecode* pc, jsval* rval, void* closure)
 {
 	CScopeLock lock(StepHandlerMutex);
 	CThreadDebugger* pThreadDebugger = (CThreadDebugger*) closure;
 	jsval val = JSVAL_VOID;
 	return pThreadDebugger->StepHandler(cx, script, pc, rval, &val);
 }
 
 CMutex StepIntoHandlerMutex;
 JSTrapStatus StepIntoHandler_(JSContext* cx, JSScript* script, jsbytecode* pc, jsval* rval, void* closure)
 {
 	CScopeLock lock(StepIntoHandlerMutex);
 	CThreadDebugger* pThreadDebugger = (CThreadDebugger*) closure;
 	return pThreadDebugger->StepIntoHandler(cx, script, pc, rval, NULL);
 }
 
 CMutex NewScriptHookMutex;
 void NewScriptHook_(JSContext* cx, const char* filename, unsigned lineno, JSScript* script, JSFunction* fun, void* callerdata)
 {
 	CScopeLock lock(NewScriptHookMutex);
 	CThreadDebugger* pThreadDebugger = (CThreadDebugger*) callerdata;
 	return pThreadDebugger->NewScriptHook(cx, filename, lineno, script, fun, NULL);
 }
 
 CMutex DestroyScriptHookMutex;
 void DestroyScriptHook_(JSContext* cx, JSScript* script, void* callerdata)
 {
 	CScopeLock lock(DestroyScriptHookMutex);
 	CThreadDebugger* pThreadDebugger = (CThreadDebugger*) callerdata;
 	return pThreadDebugger->DestroyScriptHook(cx, script);
 }
 
 CMutex StepOutHandlerMutex;
 JSTrapStatus StepOutHandler_(JSContext* cx, JSScript* script, jsbytecode* pc, jsval* rval, void* closure)
 {
 	CScopeLock lock(StepOutHandlerMutex);
 	CThreadDebugger* pThreadDebugger = (CThreadDebugger*) closure;
 	return pThreadDebugger->StepOutHandler(cx, script, pc, rval, NULL);
 }
 
 CMutex CheckForBreakRequestHandlerMutex;
 JSTrapStatus CheckForBreakRequestHandler_(JSContext* cx, JSScript* script, jsbytecode* pc, jsval* rval, void* closure)
 {
 	CScopeLock lock(CheckForBreakRequestHandlerMutex);
 	CThreadDebugger* pThreadDebugger = (CThreadDebugger*) closure;
 	return pThreadDebugger->CheckForBreakRequestHandler(cx, script, pc, rval, NULL);
 }
 
 CMutex CallHookMutex;
 static void* CallHook_(JSContext* cx, JSStackFrame* fp, JSBool before, JSBool* UNUSED(ok), void* closure)
 {
 	CScopeLock lock(CallHookMutex);
 	CThreadDebugger* pThreadDebugger = (CThreadDebugger*) closure;
 	if (before)
 	{
 		JSScript* script;
 		script = JS_GetFrameScript(cx, fp);
 		const char* fileName = JS_GetScriptFilename(cx, script);
 		uint lineno = JS_GetScriptBaseLineNumber(cx, script);
 		JSFunction* fun = JS_GetFrameFunction(cx, fp);
 		pThreadDebugger->ExecuteHook(cx, fileName, lineno, script, fun, closure);
 	}
 	
 	return closure;
 }
 
 /// ThreadDebugger_impl
 
 struct StackInfoRequest
 {
 	STACK_INFO requestType;
 	uint nestingLevel;
 	SDL_sem* semaphore;
 };
 
 struct trapLocation
 {
 	jsbytecode* pBytecode;
 	JSScript* pScript;
 	uint firstLineInFunction;
 	uint lastLineInFunction;
 };
 
 struct ThreadDebugger_impl
 {
+	NONCOPYABLE(ThreadDebugger_impl);
+public:
+
 	ThreadDebugger_impl();
 	~ThreadDebugger_impl();
 
 	CMutex m_Mutex;
 	CMutex m_ActiveBreakpointsMutex;
 	CMutex m_NextDbgCmdMutex;
 	CMutex m_IsInBreakMutex;
 
 	// This member could actually be used by other threads via CompareScriptInterfacePtr(), but that should be safe
 	ScriptInterface* m_pScriptInterface; 
 	CDebuggingServer* m_pDebuggingServer;
 	// We store the pointer on the heap because the stack frame becomes invalid in certain cases
 	// and spidermonkey throws errors if it detects a pointer on the stack.
 	// We only use the pointer for comparing it with the current stack pointer and we don't try to access it, so it
 	// shouldn't be a problem.
 	JSStackFrame** m_pLastBreakFrame;
 	uint m_ObjectReferenceID;
 
 	/// shared between multiple mongoose threads and one scriptinterface thread
 	std::string m_BreakFileName;
 	uint m_LastBreakLine;
 	bool m_IsInBreak;
 	DBGCMD m_NextDbgCmd;
 
 	std::queue<StackInfoRequest> m_StackInfoRequests;
 
 	std::map<std::string, std::map<uint, trapLocation> > m_LineToPCMap;
 	std::list<CActiveBreakPoint*> m_ActiveBreakPoints;
 	std::map<STACK_INFO, std::map<uint, std::string> > m_StackFrameData;
 	std::string m_Callstack;
 
 	/// shared between multiple mongoose threads (initialization may be an exception)
 	std::string m_Name;
 	uint m_ID;
 };
 
 ThreadDebugger_impl::ThreadDebugger_impl() :
 	m_NextDbgCmd(DBG_CMD_NONE), m_IsInBreak(false), m_pLastBreakFrame(new JSStackFrame*)
 {
 }
 
 ThreadDebugger_impl::~ThreadDebugger_impl()
 {
 	delete m_pLastBreakFrame;
 }
 
 /// CThreadDebugger
 
 void CThreadDebugger::ClearTrapsToRemove()
 {
 	CScopeLock lock(m->m_Mutex);
 	std::list<CActiveBreakPoint*>::iterator itr=m->m_ActiveBreakPoints.begin();
 	while (itr != m->m_ActiveBreakPoints.end())
 	{
 		if ((*itr)->m_ToRemove)
 		{
 				ClearTrap((*itr));
 				// Remove the breakpoint
 				delete (*itr);
 				itr = m->m_ActiveBreakPoints.erase(itr);
 
 		}
 		else
 			++itr;
 	}
 }
 
 void CThreadDebugger::ClearTrap(CActiveBreakPoint* activeBreakPoint)
 {
 	ENSURE(activeBreakPoint->m_Script != NULL && activeBreakPoint->m_Pc != NULL);
 	JSTrapHandler prevHandler;
 	jsval prevClosure;
 	JS_ClearTrap(m->m_pScriptInterface->GetContext(), activeBreakPoint->m_Script, activeBreakPoint->m_Pc, &prevHandler, &prevClosure);
 	activeBreakPoint->m_Script = NULL;
 	activeBreakPoint->m_Pc = NULL;
 }
 
 void CThreadDebugger::SetAllNewTraps()
 {
 	std::list<CBreakPoint>* pBreakPoints = NULL;
 	double breakPointsLockID;
 	breakPointsLockID = m->m_pDebuggingServer->AquireBreakPointAccess(&pBreakPoints);
 	std::list<CBreakPoint>::iterator itr = pBreakPoints->begin();
 	while (itr != pBreakPoints->end())
 	{
 		if (CheckIfMappingPresent((*itr).m_Filename, (*itr).m_UserLine))
 		{
 			// We must not set a new trap if we already have set a trap for this line of code.
 			// For lines without source code it's possible to have breakpoints set that actually refer to another line 
 			// that contains code. This situation is possible if the line containing the sourcecode already has a breakpoint
 			// set and the user sets another one by setting a breakpoint on a line directly above without sourcecode.
 			bool trapAlreadySet = false;
 			{
 				CScopeLock lock(m->m_Mutex);
 				std::list<CActiveBreakPoint*>::iterator itr1;
 				for (itr1 = m->m_ActiveBreakPoints.begin(); itr1 != m->m_ActiveBreakPoints.end(); ++itr1)
 				{
 					if ((*itr1)->m_ActualLine == (*itr).m_UserLine)
 						trapAlreadySet = true;
 				}
 			}
 
 			if (!trapAlreadySet)
 			{
 				CActiveBreakPoint* pActiveBreakPoint = new CActiveBreakPoint((*itr));
 				SetNewTrap(pActiveBreakPoint, (*itr).m_Filename, (*itr).m_UserLine);
 				{
 					CScopeLock lock(m->m_Mutex);
 					m->m_ActiveBreakPoints.push_back(pActiveBreakPoint);
 				}
 				itr = pBreakPoints->erase(itr);
 				continue;
 			}
 		}
 		++itr;
 	}
 	m->m_pDebuggingServer->ReleaseBreakPointAccess(breakPointsLockID);
 }
 
 bool CThreadDebugger::CheckIfMappingPresent(std::string filename, uint line)
 {
 	bool isPresent = (m->m_LineToPCMap.end() != m->m_LineToPCMap.find(filename) && m->m_LineToPCMap[filename].end() != m->m_LineToPCMap[filename].find(line));
 	return isPresent;
 }
 
 void CThreadDebugger::SetNewTrap(CActiveBreakPoint* activeBreakPoint, std::string filename, uint line)
 {
 	ENSURE(activeBreakPoint->m_Script == NULL); // The trap must not be set already!
 	ENSURE(CheckIfMappingPresent(filename, line)); // You have to check if the mapping exists before calling this function!
 
 	jsbytecode* pc = m->m_LineToPCMap[filename][line].pBytecode;
 	JSScript* script = m->m_LineToPCMap[filename][line].pScript;
 	activeBreakPoint->m_Script = script;
 	activeBreakPoint->m_Pc = pc;
 	ENSURE(script != NULL && pc != NULL);
 	activeBreakPoint->m_ActualLine = JS_PCToLineNumber(m->m_pScriptInterface->GetContext(), script, pc);
 	
 	JS_SetTrap(m->m_pScriptInterface->GetContext(), script, pc, TrapHandler_, PRIVATE_TO_JSVAL(this));
 }
 
 
 CThreadDebugger::CThreadDebugger() :
 	m(new ThreadDebugger_impl())
 {
 }
 
 CThreadDebugger::~CThreadDebugger()
 {
 	// Clear all Traps and Breakpoints that are marked for removal
 	ClearTrapsToRemove();
 	
 	// Return all breakpoints to the associated CDebuggingServer
 	ReturnActiveBreakPoints(NULL);
 
 	// Remove all the hooks because they store a pointer to this object
 	JS_SetExecuteHook(m->m_pScriptInterface->GetRuntime(), NULL, NULL);
 	JS_SetCallHook(m->m_pScriptInterface->GetRuntime(), NULL, NULL);
 	JS_SetNewScriptHook(m->m_pScriptInterface->GetRuntime(), NULL, NULL);
 	JS_SetDestroyScriptHook(m->m_pScriptInterface->GetRuntime(), NULL, NULL);
 }
 
 void CThreadDebugger::ReturnActiveBreakPoints(jsbytecode* pBytecode)
 {
 	CScopeLock lock(m->m_ActiveBreakpointsMutex);
 	std::list<CActiveBreakPoint*>::iterator itr;
 	itr = m->m_ActiveBreakPoints.begin();
 	while (itr != m->m_ActiveBreakPoints.end())
 	{
 		// Breakpoints marked for removal should be deleted instead of returned!
 		if ( ((*itr)->m_Pc == pBytecode || pBytecode == NULL) && !(*itr)->m_ToRemove )
 		{
 			std::list<CBreakPoint>* pBreakPoints;
 			double breakPointsLockID = m->m_pDebuggingServer->AquireBreakPointAccess(&pBreakPoints);
 			CBreakPoint breakPoint;
 			breakPoint.m_UserLine = (*itr)->m_UserLine;
 			breakPoint.m_Filename = (*itr)->m_Filename;
 			// All active breakpoints should have a trap set
 			ClearTrap((*itr));
 			pBreakPoints->push_back(breakPoint);
 			delete (*itr);
 			itr = m->m_ActiveBreakPoints.erase(itr);
 			m->m_pDebuggingServer->ReleaseBreakPointAccess(breakPointsLockID);
 		}
 		else
 			++itr;
 	}
 }
 
 void CThreadDebugger::Initialize(uint id, std::string name, ScriptInterface* pScriptInterface, CDebuggingServer* pDebuggingServer)
 {
 	ENSURE(id != 0);
 	m->m_ID = id;
 	m->m_Name = name;
 	m->m_pScriptInterface = pScriptInterface;
 	m->m_pDebuggingServer = pDebuggingServer;
 	JS_SetExecuteHook(m->m_pScriptInterface->GetRuntime(), CallHook_, (void*)this);
 	JS_SetCallHook(m->m_pScriptInterface->GetRuntime(), CallHook_, (void*)this);
 	JS_SetNewScriptHook(m->m_pScriptInterface->GetRuntime(), NewScriptHook_, (void*)this);
 	JS_SetDestroyScriptHook(m->m_pScriptInterface->GetRuntime(), DestroyScriptHook_, (void*)this);
 	JS_SetThrowHook(m->m_pScriptInterface->GetRuntime(), ThrowHandler_, (void*)this);
 	
 	if (m->m_pDebuggingServer->GetSettingSimultaneousThreadBreak())
 	{
 		// Setup a handler to check for break-requests from the DebuggingServer regularly
 		JS_SetInterrupt(m->m_pScriptInterface->GetRuntime(), CheckForBreakRequestHandler_, (void*)this);
 	}
 }
 
 JSTrapStatus CThreadDebugger::StepHandler(JSContext* cx, JSScript* script, jsbytecode* pc, jsval* rval, void* UNUSED(closure))
 {
 	// We break in two conditions
 	// 1. We are in the same frame but on a different line
 	//	  Note: On loops for example, we can go a few lines up again without leaving the current stack frame, so it's not necessarily 
 	//          a higher line number.
 	// 2. We are in a different Frame and m_pLastBreakFrame is not a parent of the current frame (because we stepped out of the function)
 	uint line = JS_PCToLineNumber(cx, script, pc);
 	JSStackFrame* iter = NULL;
 	JSStackFrame* pStackFrame;
 	pStackFrame = JS_FrameIterator(m->m_pScriptInterface->GetContext(), &iter);
 	uint lastBreakLine = GetLastBreakLine() ;
 	jsval val = JSVAL_VOID;
 	if ((*m->m_pLastBreakFrame == pStackFrame && lastBreakLine != line) || 
 		(*m->m_pLastBreakFrame != pStackFrame && !CurrentFrameIsChildOf(*m->m_pLastBreakFrame)))
 		return BreakHandler(cx, script, pc, rval, val, BREAK_SRC_INTERRUP);
 	else
 		return JSTRAP_CONTINUE;
 }
 
 JSTrapStatus CThreadDebugger::StepIntoHandler(JSContext *cx, JSScript *script, jsbytecode *pc, jsval *rval, void* UNUSED(closure))
 {
 	// We break when we are on the same stack frame but not on the same line 
 	// or when we are on another stack frame.
 	uint line = JS_PCToLineNumber(cx, script, pc);
 	JSStackFrame* iter = NULL;
 	JSStackFrame* pStackFrame;
 	pStackFrame = JS_FrameIterator(m->m_pScriptInterface->GetContext(), &iter);
 	uint lastBreakLine = GetLastBreakLine();
 	
 	jsval val = JSVAL_VOID;
 	if ((*m->m_pLastBreakFrame == pStackFrame && lastBreakLine != line) || *m->m_pLastBreakFrame != pStackFrame)
 		return BreakHandler(cx, script, pc, rval, val, BREAK_SRC_INTERRUP);
 	else
 		return JSTRAP_CONTINUE;
 }
 
 JSTrapStatus CThreadDebugger::StepOutHandler(JSContext *cx, JSScript *script, jsbytecode *pc, jsval *rval, void* UNUSED(closure))
 {
 	// We break when we are in a different Frame and m_pLastBreakFrame is not a parent of the current frame 
 	// (because we stepped out of the function)
 	JSStackFrame* iter = NULL;
 	JSStackFrame* pStackFrame;
 	pStackFrame = JS_FrameIterator(m->m_pScriptInterface->GetContext(), &iter);
 	if (pStackFrame != *m->m_pLastBreakFrame && !CurrentFrameIsChildOf(*m->m_pLastBreakFrame))
 	{
 		jsval val = JSVAL_VOID;
 		return BreakHandler(cx, script, pc, rval, val, BREAK_SRC_INTERRUP);
 	}
 	else
 		return JSTRAP_CONTINUE;
 }
 
 bool CThreadDebugger::CurrentFrameIsChildOf(JSStackFrame* pParentFrame)
 {
 	JSStackFrame* iter = NULL;
 	JSStackFrame* fp = JS_FrameIterator(m->m_pScriptInterface->GetContext(), &iter);
 	// Get the first parent Frame
 	fp = JS_FrameIterator(m->m_pScriptInterface->GetContext(), &iter);
 	while (fp)
 	{
 		if (fp == pParentFrame) 
 			return true;
 		fp = JS_FrameIterator(m->m_pScriptInterface->GetContext(), &iter);
 	}
 	return false;
 }
 
 JSTrapStatus CThreadDebugger::CheckForBreakRequestHandler(JSContext *cx, JSScript *script, jsbytecode *pc, jsval *rval, void* UNUSED(closure))
 {
 	jsval val = JSVAL_VOID;
 	if (m->m_pDebuggingServer->GetBreakRequestedByThread() || m->m_pDebuggingServer->GetBreakRequestedByUser())
 		return BreakHandler(cx, script, pc, rval, val, BREAK_SRC_INTERRUP);
 	else
 		return JSTRAP_CONTINUE;
 }
 
 JSTrapStatus CThreadDebugger::TrapHandler(JSContext *cx, JSScript *script, jsbytecode *pc, jsval *rval, jsval UNUSED(closure))
 {
 	jsval val = JSVAL_NULL;
 	return BreakHandler(cx, script, pc, rval, val, BREAK_SRC_TRAP);
 }
 
 JSTrapStatus CThreadDebugger::ThrowHandler(JSContext *cx, JSScript *script, jsbytecode *pc, jsval *rval)
 {
 	jsval jsexception;
 	JS_GetPendingException(cx, &jsexception);
 	if (JSVAL_IS_STRING(jsexception))
 	{
 		std::string str(JS_EncodeString(cx, JSVAL_TO_STRING(jsexception)));
 		if (str == "Breakpoint" || m->m_pDebuggingServer->GetSettingBreakOnException())
 		{
 			if (str == "Breakpoint")
 				JS_ClearPendingException(cx);
 			jsval val = JSVAL_NULL;
 			return BreakHandler(cx, script, pc, rval, val, BREAK_SRC_EXCEPTION);
 		}
 	}
 	return JSTRAP_CONTINUE;
 }
 
 JSTrapStatus CThreadDebugger::BreakHandler(JSContext* cx, JSScript* script, jsbytecode* pc, jsval* UNUSED(rval), jsval UNUSED(closure), BREAK_SRC breakSrc) 
 {
 	uint line = JS_PCToLineNumber(cx, script, pc);
 	std::string filename(JS_GetScriptFilename(cx, script));
 
 	SetIsInBreak(true);
 	SaveCallstack();
 	SetLastBreakLine(line);
 	SetBreakFileName(filename);
 	*m->m_pLastBreakFrame = NULL;
 	
 	if (breakSrc == BREAK_SRC_INTERRUP)
 	{
 		JS_ClearInterrupt(m->m_pScriptInterface->GetRuntime(), NULL, NULL);
 		JS_SetSingleStepMode(cx, script, false);
 	}
 	
 	if (m->m_pDebuggingServer->GetSettingSimultaneousThreadBreak())
 	{
 		m->m_pDebuggingServer->SetBreakRequestedByThread(true);
 	}
 	
 	// Wait until the user continues the execution
 	while (1)
 	{
 		DBGCMD nextDbgCmd = GetNextDbgCmd();
 		
 		while (!m->m_StackInfoRequests.empty())
 		{
 			StackInfoRequest request = m->m_StackInfoRequests.front();
 			SaveStackFrameData(request.requestType, request.nestingLevel);
 			SDL_SemPost(request.semaphore);
 			m->m_StackInfoRequests.pop();
 		}
 		
 		if (nextDbgCmd == DBG_CMD_NONE)
 		{
 			// Wait a while before checking for new m_NextDbgCmd again.
 			// We don't want this loop to take 100% of a CPU core for each thread that is in break mode.
 			// On the other hande we don't want the debugger to become unresponsive.
 			SDL_Delay(100);
 		}
 		else if (nextDbgCmd == DBG_CMD_SINGLESTEP || nextDbgCmd == DBG_CMD_STEPINTO || nextDbgCmd == DBG_CMD_STEPOUT)
 		{
 			JSStackFrame* iter = NULL;
 			*m->m_pLastBreakFrame = JS_FrameIterator(m->m_pScriptInterface->GetContext(), &iter);
 			
 			if (!JS_SetSingleStepMode(cx, script, true))
 				LOGERROR(L"JS_SetSingleStepMode returned false!"); // TODO: When can this happen?
 			else
 			{
 				if (nextDbgCmd == DBG_CMD_SINGLESTEP)
 				{
 					JS_SetInterrupt(m->m_pScriptInterface->GetRuntime(), StepHandler_, this);
 					break;
 				}
 				else if (nextDbgCmd == DBG_CMD_STEPINTO)
 				{
 					JS_SetInterrupt(m->m_pScriptInterface->GetRuntime(), StepIntoHandler_, this);
 					break;
 				}
 				else if (nextDbgCmd == DBG_CMD_STEPOUT)
 				{
 					JS_SetInterrupt(m->m_pScriptInterface->GetRuntime(), StepOutHandler_, this);
 					break;
 				}
 			}
 		}
 		else if (nextDbgCmd == DBG_CMD_CONTINUE)
 		{
 			if (!JS_SetSingleStepMode(cx, script, true))
 				LOGERROR(L"JS_SetSingleStepMode returned false!"); // TODO: When can this happen?
 			else
 			{
 				// Setup a handler to check for break-requests from the DebuggingServer regularly
 				JS_SetInterrupt(m->m_pScriptInterface->GetRuntime(), CheckForBreakRequestHandler_, this);
 			}
 			break;
 		}
 		else 
 			debug_warn("Invalid DBGCMD found in CThreadDebugger::BreakHandler!");
 	}
 	ClearTrapsToRemove();
 	SetAllNewTraps();
 	SetNextDbgCmd(DBG_CMD_NONE);
 	SetIsInBreak(false);
 	SetBreakFileName("");
 	
 	// All saved stack data becomes invalid
 	{
 		CScopeLock lock(m->m_Mutex);
 		m->m_StackFrameData.clear();
 	}
 	
 	return JSTRAP_CONTINUE;
 }
 
 void CThreadDebugger::NewScriptHook(JSContext* cx, const char* filename, unsigned lineno, JSScript* script, JSFunction* UNUSED(fun), void* UNUSED(callerdata))
 {
 	uint scriptExtent = JS_GetScriptLineExtent (cx, script);
 	std::string stringFileName(filename);
 	if (stringFileName == "")
 		return;
 
 	for (uint line = lineno; line < scriptExtent + lineno; ++line) 
 	{
 		// If we already have a mapping for this line, we check if the current scipt is more deeply nested.
 		// If it isn't more deeply nested, we don't overwrite the previous mapping
 		// The most deeply nested script is always the one that must be used!
 		uint firstLine = 0;
 		uint lastLine = 0;
 		jsbytecode* oldPC = NULL;
 		if (CheckIfMappingPresent(stringFileName, line))
 		{
 			firstLine = m->m_LineToPCMap[stringFileName][line].firstLineInFunction;
 			lastLine = m->m_LineToPCMap[stringFileName][line].lastLineInFunction;
 			
 			// If an entry nested equally is present too, we must overwrite it.
 			// The same script(function) can trigger a NewScriptHook multiple times without DestroyScriptHooks between these 
 			// calls. In this case the old script becomes invalid.
 			if (lineno < firstLine || scriptExtent + lineno > lastLine)
 				continue;
 			else
 				oldPC = m->m_LineToPCMap[stringFileName][line].pBytecode;
 				
 		}
 		jsbytecode* pc = JS_LineNumberToPC (cx, script, line);
 		m->m_LineToPCMap[stringFileName][line].pBytecode = pc;
 		m->m_LineToPCMap[stringFileName][line].pScript = script;
 		m->m_LineToPCMap[stringFileName][line].firstLineInFunction = lineno;
 		m->m_LineToPCMap[stringFileName][line].lastLineInFunction = lineno + scriptExtent;
 		
 		// If we are replacing a script, the associated traps become invalid
 		if (lineno == firstLine && scriptExtent + lineno == lastLine)
 		{
 			ReturnActiveBreakPoints(oldPC);
 			SetAllNewTraps();
 		}
 	}
 }
 
 void CThreadDebugger::DestroyScriptHook(JSContext* cx, JSScript* script)
 {
 	uint scriptExtent = JS_GetScriptLineExtent (cx, script);
 	uint baseLine = JS_GetScriptBaseLineNumber(cx, script);
 	
 	char* pStr = NULL;
 	pStr = (char*)JS_GetScriptFilename(cx, script);
 	if (pStr != NULL)
 	{
 		std::string fileName(pStr);
 
 		for (uint line = baseLine; line < scriptExtent + baseLine; ++line) 
 		{
 			if (CheckIfMappingPresent(fileName, line))
 			{
 				if (m->m_LineToPCMap[fileName][line].pScript == script)
 				{
 					ReturnActiveBreakPoints(m->m_LineToPCMap[fileName][line].pBytecode);
 					m->m_LineToPCMap[fileName].erase(line);
 					if (m->m_LineToPCMap[fileName].empty())
 						m->m_LineToPCMap.erase(fileName);
 				}
 			}
 		}
 	}
 }
 
 void CThreadDebugger::ExecuteHook(JSContext* UNUSED(cx), const char* UNUSED(filename), unsigned UNUSED(lineno), JSScript* UNUSED(script), JSFunction* UNUSED(fun), void* UNUSED(callerdata))
 {
 	// Search all breakpoints that have no trap set yet
 	{
 		PROFILE2("ExecuteHook");
 		SetAllNewTraps();
 	}
 	return;
 }
 
 bool CThreadDebugger::ToggleBreakPoint(std::string filename, uint userLine)
 {
 	CScopeLock lock(m->m_Mutex);
 	std::list<CActiveBreakPoint*>::iterator itr;
 	for (itr = m->m_ActiveBreakPoints.begin(); itr != m->m_ActiveBreakPoints.end(); ++itr)
 	{
 		if ((*itr)->m_UserLine == userLine && (*itr)->m_Filename == filename)
 		{
 			(*itr)->m_ToRemove = !(*itr)->m_ToRemove;
 			return true;
 		}
 	}
 	return false;
 }
 
 void CThreadDebugger::GetCallstack(std::stringstream& response)
 {
 	CScopeLock lock(m->m_Mutex);
 	response << m->m_Callstack;
 }
 
 void CThreadDebugger::SaveCallstack()
 {
 	ENSURE(GetIsInBreak());
 	
 	CScopeLock lock(m->m_Mutex);
 	
 	JSStackFrame *fp;
 	JSStackFrame *iter = 0;
 	std::string functionName;
 	jsint counter = 0;
 	
 	JSObject* jsArray;
 	jsArray = JS_NewArrayObject(m->m_pScriptInterface->GetContext(), 0, 0);
 	JSString* functionID;
 
 	fp = JS_FrameIterator(m->m_pScriptInterface->GetContext(), &iter);
 
 	while (fp)
 	{
 		JSFunction* fun = 0;
 		fun = JS_GetFrameFunction(m->m_pScriptInterface->GetContext(), fp);
 		if (NULL == fun)
 			functionID = JS_NewStringCopyZ(m->m_pScriptInterface->GetContext(), "null");
 		else
 		{
 			functionID = JS_GetFunctionId(fun);
 			if (NULL == functionID)
 				functionID = JS_NewStringCopyZ(m->m_pScriptInterface->GetContext(), "anonymous");
 		}
 
 		JSBool ret = JS_DefineElement(m->m_pScriptInterface->GetContext(), jsArray, counter, STRING_TO_JSVAL(functionID), NULL, NULL, 0);
 		ENSURE(ret);
 		fp = JS_FrameIterator(m->m_pScriptInterface->GetContext(), &iter);
 		counter++;
 	}
 	
 	m->m_Callstack = "";
 	m->m_Callstack = m->m_pScriptInterface->StringifyJSON(OBJECT_TO_JSVAL(jsArray), false).c_str();
 }
 
 void CThreadDebugger::GetStackFrameData(std::stringstream& response, uint nestingLevel, STACK_INFO stackInfoKind)
 {
 	// If the data is not yet cached, request it and wait until it's ready.
 	bool dataCached = false;
 	{
 		CScopeLock lock(m->m_Mutex);
 		dataCached = (!m->m_StackFrameData.empty() && m->m_StackFrameData[stackInfoKind].end() != m->m_StackFrameData[stackInfoKind].find(nestingLevel));
 	}
 
 	if (!dataCached)
 	{
 		SDL_sem* semaphore = SDL_CreateSemaphore(0);
 		AddStackInfoRequest(stackInfoKind, nestingLevel, semaphore);
 		SDL_SemWait(semaphore);
 		SDL_DestroySemaphore(semaphore);
 	}
 	
 	CScopeLock lock(m->m_Mutex);
 	{
 		response.str("");
 		response << m->m_StackFrameData[stackInfoKind][nestingLevel];
 	}
 }
 
 void CThreadDebugger::AddStackInfoRequest(STACK_INFO requestType, uint nestingLevel, SDL_sem* semaphore)
 {
 	StackInfoRequest request;
 	request.requestType = requestType;
 	request.semaphore = semaphore;
 	request.nestingLevel = nestingLevel;
 	m->m_StackInfoRequests.push(request);
 }
 
 void CThreadDebugger::SaveStackFrameData(STACK_INFO stackInfo, uint nestingLevel)
 {
 	ENSURE(GetIsInBreak());
 	
 	CScopeLock lock(m->m_Mutex);
 	JSStackFrame *fp;
 	JSStackFrame *iter = 0;
 	uint counter = 0;
 	jsval val;
 	
 	if (stackInfo == STACK_INFO_GLOBALOBJECT)
 	{
 		JSObject* obj;
 		obj = JS_GetGlobalForScopeChain(m->m_pScriptInterface->GetContext());
 		m->m_StackFrameData[stackInfo][nestingLevel] = StringifyCyclicJSON(OBJECT_TO_JSVAL(obj), false);
 	}
 	else
 	{
 		fp = JS_FrameIterator(m->m_pScriptInterface->GetContext(), &iter);
 		while (fp)
 		{
 			if (counter == nestingLevel)
 			{
 				if (stackInfo == STACK_INFO_LOCALS)
 				{
 					JSObject* obj;
 					obj = JS_GetFrameCallObject(m->m_pScriptInterface->GetContext(), fp);
 					//obj = JS_GetFrameScopeChain(m->m_pScriptInterface->GetContext(), fp);
 					m->m_StackFrameData[stackInfo][nestingLevel] = StringifyCyclicJSON(OBJECT_TO_JSVAL(obj), false);
 				}
 				else if (stackInfo == STACK_INFO_THIS)
 				{
 					if (JS_GetFrameThis(m->m_pScriptInterface->GetContext(), fp, &val))
 						m->m_StackFrameData[stackInfo][nestingLevel] = StringifyCyclicJSON(val, false);
 					else
 						m->m_StackFrameData[stackInfo][nestingLevel] = "";
 				}
 			}
 			
 			counter++;
 			fp = JS_FrameIterator(m->m_pScriptInterface->GetContext(), &iter);
 		}
 	}
 }
 
 
 /*
  * TODO: This is very hacky and ugly and should be improved. 
  * It replaces cyclic references with a notification that cyclic references are not supported. 
  * It would be better to create a format that supports cyclic references and allows the UI to display them correctly.
  * Unfortunately this seems to require writing (or embedding) a new serializer to JSON or something similar.
  * 
  * Some things about the implementation which aren't optimal:
  * 1. It uses globabl variables (they are limited to a namespace though)
  * 2. It has to work around a bug in Spidermonkey.
  * 3. It copies code from CScriptInterface. I did this to separate it cleanly because the debugger should not affect
  *    the rest of the game and because this part of code should be replaced anyway in the future.
  */
  
  namespace CyclicRefWorkaround
  {
 	std::set<JSObject*> g_ProcessedObjects;
 	jsval g_LastKey;
 	jsval g_LastValue;
 	bool g_RecursionDetectedInPrevReplacer = false;
 	uint g_countSameKeys = 0;
 
 	struct Stringifier
 	{
 		static JSBool callback(const jschar* buf, uint32 len, void* data)
 		{
 			utf16string str(buf, buf+len);
 			std::wstring strw(str.begin(), str.end());
 
 			Status err; // ignore Unicode errors
 			static_cast<Stringifier*>(data)->stream << utf8_from_wstring(strw, &err);
 			return JS_TRUE;
 		}
 
 		std::stringstream stream;
 	};
 	 
 	JSBool replacer(JSContext* cx, uintN UNUSED(argc), jsval* vp)
 	{
 		jsval value = JS_ARGV(cx, vp)[1];
 		jsval key = JS_ARGV(cx, vp)[0];
 		if (g_LastKey == key)
 			g_countSameKeys++;
 		else
 			g_countSameKeys = 0;
 		
 		if (JSVAL_IS_OBJECT(value))
 		{	
 			// Work around a spidermonkey bug that causes replacer to be called twice with the same key:
 			// https://bugzilla.mozilla.org/show_bug.cgi?id=636079
 			// TODO: Remove the workaround as soon as we upgrade to a newer version of Spidermonkey.
 
 			if (g_ProcessedObjects.end() == g_ProcessedObjects.find(JSVAL_TO_OBJECT(value)))
 			{
 					g_ProcessedObjects.insert(JSVAL_TO_OBJECT(value));
 			}
 			else if (g_countSameKeys %2 == 0 || g_RecursionDetectedInPrevReplacer)
 			{
 				g_RecursionDetectedInPrevReplacer = true;
 				jsval ret = STRING_TO_JSVAL(JS_NewStringCopyZ(cx, "Debugger: object removed from output because of cyclic reference."));
 				JS_SET_RVAL(cx, vp, ret);
 				g_LastKey = key;
 				g_LastValue = value;
 				return JS_TRUE;
 			}
 		}
 		g_LastKey = key;
 		g_LastValue = value;
 		g_RecursionDetectedInPrevReplacer = false;
 		JS_SET_RVAL(cx, vp, JS_ARGV(cx, vp)[1]);
 		return JS_TRUE;
 	}
  }
  
 std::string CThreadDebugger::StringifyCyclicJSON(jsval obj, bool indent)
 {
 	CyclicRefWorkaround::Stringifier str;
 	CyclicRefWorkaround::g_ProcessedObjects.clear();
 	CyclicRefWorkaround::g_LastKey = JSVAL_VOID;
 	
 	JSObject* pGlob = JSVAL_TO_OBJECT(m->m_pScriptInterface->GetGlobalObject());
 	JSFunction* fun = JS_DefineFunction(m->m_pScriptInterface->GetContext(), pGlob, "replacer", CyclicRefWorkaround::replacer, 0, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
 	JSObject* replacer = JS_GetFunctionObject(fun);
 	if (!JS_Stringify(m->m_pScriptInterface->GetContext(), &obj, replacer, indent ? INT_TO_JSVAL(2) : JSVAL_VOID, &CyclicRefWorkaround::Stringifier::callback, &str))
 	{
 		LOGERROR(L"StringifyJSON failed");
 		jsval exec;
 		jsval execString;
 		if (JS_GetPendingException(m->m_pScriptInterface->GetContext(), &exec))
 		{
 			if (JSVAL_IS_OBJECT(exec))
 			{
 				JS_GetProperty(m->m_pScriptInterface->GetContext(), JSVAL_TO_OBJECT(exec), "message", &execString);
 			
 				if (JSVAL_IS_STRING(execString))
 				{
 					std::string strExec = JS_EncodeString(m->m_pScriptInterface->GetContext(), JSVAL_TO_STRING(execString));
 					LOGERROR(L"Error: %hs", strExec.c_str());
 				}
 			}
 			
 		}			
 		JS_ClearPendingException(m->m_pScriptInterface->GetContext());
 		return "";
 	}
 
 	return str.stream.str();
 }
 
 
 bool CThreadDebugger::CompareScriptInterfacePtr(ScriptInterface* pScriptInterface)
 {
 	return (pScriptInterface == m->m_pScriptInterface);
 }
 
 
 std::string CThreadDebugger::GetBreakFileName()
 {
 	CScopeLock lock(m->m_Mutex);
 	return m->m_BreakFileName;
 }
 
 void CThreadDebugger::SetBreakFileName(std::string breakFileName)
 {
 	CScopeLock lock(m->m_Mutex);
 	m->m_BreakFileName = breakFileName;
 }
 
 uint CThreadDebugger::GetLastBreakLine()
 {
 	CScopeLock lock(m->m_Mutex);
 	return m->m_LastBreakLine;
 }
 
 void CThreadDebugger::SetLastBreakLine(uint breakLine)
 {
 	CScopeLock lock(m->m_Mutex);
 	m->m_LastBreakLine = breakLine;
 }
 
 bool CThreadDebugger::GetIsInBreak()
 {
 	CScopeLock lock(m->m_IsInBreakMutex);
 	return m->m_IsInBreak;
 }
 
 void CThreadDebugger::SetIsInBreak(bool isInBreak)
 {
 	CScopeLock lock(m->m_IsInBreakMutex);
 	m->m_IsInBreak = isInBreak;
 }
 
 void CThreadDebugger::SetNextDbgCmd(DBGCMD dbgCmd)
 {
 	CScopeLock lock(m->m_NextDbgCmdMutex);
 	m->m_NextDbgCmd = dbgCmd;
 }
 
 DBGCMD CThreadDebugger::GetNextDbgCmd()
 {
 	CScopeLock lock(m->m_NextDbgCmdMutex);
 	return m->m_NextDbgCmd;
 }
 
 std::string CThreadDebugger::GetName()
 {
 	CScopeLock lock(m->m_Mutex);
 	return m->m_Name;
 }
 
 uint CThreadDebugger::GetID()
 {
 	CScopeLock lock(m->m_Mutex);
 	return m->m_ID;
 }
 
Index: ps/trunk/source/soundmanager/SoundManager.cpp
===================================================================
--- ps/trunk/source/soundmanager/SoundManager.cpp	(revision 13418)
+++ ps/trunk/source/soundmanager/SoundManager.cpp	(revision 13419)
@@ -1,773 +1,775 @@
 /* Copyright (C) 2013 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. 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.
  *
  * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "SoundManager.h"
 
 #include "soundmanager/data/SoundData.h"
 #include "soundmanager/items/CSoundItem.h"
 #include "soundmanager/items/CBufferItem.h"
 #include "soundmanager/items/CStreamItem.h"
 #include "soundmanager/js/SoundPlayer.h"
 #include "soundmanager/js/AmbientSound.h"
 #include "soundmanager/js/MusicList.h"
 #include "soundmanager/js/MusicSound.h"
 #include "soundmanager/js/Sound.h"
 #include "lib/external_libraries/libsdl.h"
 #include "ps/CLogger.h"
 #include "ps/CStr.h"
 #include "ps/Profiler2.h"
 
 CSoundManager* g_SoundManager = NULL;
 
 #define		SOURCE_NUM		64
 
 #if CONFIG2_AUDIO
 
 class CSoundManagerWorker
 {
+	NONCOPYABLE(CSoundManagerWorker);
+
 public:
 	CSoundManagerWorker()
 	{
 		m_Items = new ItemsList;
 		m_DeadItems = new ItemsList;
 		m_Shutdown = false;
 		m_Enabled = false;
 
 		int ret = pthread_create(&m_WorkerThread, NULL, &RunThread, this);
 		ENSURE(ret == 0);
 	}
 
 	~CSoundManagerWorker()
 	{
 		delete m_Items;
 		CleanupItems();
 		delete m_DeadItems;
 	}
 
 	void SetEnabled(bool enabled)
 	{
 		CScopeLock lock(m_WorkerMutex);
 		if (enabled != m_Enabled)
 		{
 			m_Enabled = enabled;
 		}
 	}
 
 	bool Shutdown()
 	{
 		{
 			CScopeLock lock(m_WorkerMutex);
 
 			m_Shutdown = true;
 			m_Enabled = false;
 
 			ItemsList::iterator lstr = m_Items->begin();
 			while (lstr != m_Items->end())
 			{
 				delete *lstr;
 				++lstr;
 			}
 
 		}
 
 		pthread_join(m_WorkerThread, NULL);
 
 		return true;
 	}
 
 	void addItem( ISoundItem* anItem )
 	{
 		CScopeLock lock(m_WorkerMutex);
 		m_Items->push_back( anItem );
 	}
 
 	void CleanupItems()
 	{
 		CScopeLock lock(m_DeadItemsMutex);
 		AL_CHECK
 		ItemsList::iterator deadItems = m_DeadItems->begin();
 		while (deadItems != m_DeadItems->end())
 		{   
 			delete *deadItems;
 			++deadItems;
 
 			AL_CHECK
 		}
 		m_DeadItems->clear();
 	}
 
 private:
 	static void* RunThread(void* data)
 	{
 		debug_SetThreadName("CSoundManagerWorker");
 		g_Profiler2.RegisterCurrentThread("soundmanager");
 
 		static_cast<CSoundManagerWorker*>(data)->Run();
 
 		return NULL;
 	}
 
 	void Run()
 	{
 		while ( true )
 		{
 			g_Profiler2.RecordRegionLeave("semaphore wait");
 
 			// Handle shutdown requests as soon as possible
 			if (GetShutdown())
 				return;
 
 			// If we're not enabled, ignore this wakeup
 			if (!GetEnabled())
 				continue;
 
 			int pauseTime = 500;
 			if ( g_SoundManager->InDistress() )
 				pauseTime = 50;
 
 			{
 				CScopeLock lock(m_WorkerMutex);
 		
 				ItemsList::iterator lstr = m_Items->begin();
 				ItemsList* nextItemList = new ItemsList;
 
 
 				while (lstr != m_Items->end()) {
 
 					AL_CHECK
 					if ((*lstr)->IdleTask())
 					{
 						if ( (pauseTime == 1000) && (*lstr)->IsFading() )
 							pauseTime = 100;
 
 						nextItemList->push_back(*lstr);
 					}
 					else
 					{
 						CScopeLock lock(m_DeadItemsMutex);
 						m_DeadItems->push_back(*lstr);
 					}
 					++lstr;
 
 					AL_CHECK
 				}
 
 				delete m_Items;
 				m_Items = nextItemList;
 
 				AL_CHECK
 			}
 			SDL_Delay( pauseTime );
 		}
 	}
 
 	bool GetEnabled()
 	{
 		CScopeLock lock(m_WorkerMutex);
 		return m_Enabled;
 	}
 
 	bool GetShutdown()
 	{
 		CScopeLock lock(m_WorkerMutex);
 		return m_Shutdown;
 	}
 
 
 
 private:
 	// Thread-related members:
 	pthread_t m_WorkerThread;
 	CMutex m_WorkerMutex;
 	CMutex m_DeadItemsMutex;
 
 	// Shared by main thread and worker thread:
 	// These variables are all protected by a mutexes
 	ItemsList* m_Items;
 	ItemsList* m_DeadItems;
 
 	bool m_Enabled;
 	bool m_Shutdown;
 
 	CSoundManagerWorker(CSoundManager* UNUSED(other)){};
 };
 #endif
 
 void CSoundManager::ScriptingInit()
 {
 	JAmbientSound::ScriptingInit();
 	JMusicSound::ScriptingInit();
 	JSound::ScriptingInit();
 	JSoundPlayer::ScriptingInit();
 	JMusicList::ScriptingInit();
 }
 
 
 #if CONFIG2_AUDIO
 
 
 void CSoundManager::CreateSoundManager()
 {
 	g_SoundManager = new CSoundManager();
 }
 
 void CSoundManager::SetEnabled(bool doEnable)
 {
 	if ( g_SoundManager && !doEnable ) 
 	{
 		SAFE_DELETE(g_SoundManager);
 	}
 	else if ( ! g_SoundManager && doEnable ) 
 	{
 		CSoundManager::CreateSoundManager();
 	}
 }
 
 void CSoundManager::al_ReportError(ALenum err, const char* caller, int line)
 {
 	LOGERROR(L"OpenAL error: %hs; called from %hs (line %d)\n", alGetString(err), caller, line);
 }
 
 void CSoundManager::al_check(const char* caller, int line)
 {
 	ALenum err = alGetError();
 	if (err != AL_NO_ERROR)
 		al_ReportError(err, caller, line);
 }
 
 CSoundManager::CSoundManager()
 {
 	m_CurrentEnvirons	= 0;
 	m_ALSourceBuffer	= NULL;
 	m_Device	= NULL;
 	m_Context	= NULL;
 	m_Worker	= NULL;
 	m_PlayListItems	= NULL;
 	m_CurrentTune		= 0;
 	m_Gain				= 1;
 	m_MusicGain			= 1;
 	m_AmbientGain		= 1;
 	m_ActionGain		= 1;
 	m_BufferCount		= 50;
 	m_BufferSize		= 65536;
 	m_SoundEnabled		= true;
 	m_MusicEnabled		= true;
 	m_MusicPaused     = false;
 	m_AmbientPaused   = false;
 	m_ActionPaused     = false;
 
 	m_DistressTime	= 0;
 	m_DistressErrCount = 0;
 
 	m_PlayingPlaylist = false;
 	m_LoopingPlaylist = false;
 	m_RunningPlaylist = false;
 	m_PlaylistGap      = 0;
 
 	m_Enabled = false;
 	AlcInit();
 
 	if ( m_Enabled )
 	{
 		InitListener();
 
 		m_PlayListItems = new PlayList;
 
 		m_Worker = new CSoundManagerWorker();
 		m_Worker->SetEnabled( true );
 	}
 }
 
 CSoundManager::~CSoundManager()
 {
 	if (m_Worker )
 	{
 		AL_CHECK
 		m_Worker->Shutdown();
 		AL_CHECK
 		m_Worker->CleanupItems();
 		AL_CHECK
 
 		delete m_Worker;
 	}
 	AL_CHECK
 
 	if ( m_PlayListItems )
 		delete m_PlayListItems;
 
 	if ( m_ALSourceBuffer != NULL )
 		delete[] m_ALSourceBuffer;
 
 	if ( m_Context )
 		alcDestroyContext(m_Context);
 	
 	if ( m_Device )
 		alcCloseDevice(m_Device);
 }
 
 
 
 Status CSoundManager::AlcInit()
 {	
 	Status ret = INFO::OK;
 
 	m_Device = alcOpenDevice(NULL);
 	if (m_Device)
 	{
 		ALCint attribs[] = {ALC_STEREO_SOURCES, 16, 0};
 		m_Context = alcCreateContext(m_Device, &attribs[0]);
 
 		if (m_Context)
 		{
 			alcMakeContextCurrent(m_Context);
 			m_ALSourceBuffer = new ALSourceHolder[SOURCE_NUM];
 			ALuint* sourceList = new ALuint[SOURCE_NUM];
 
 			alGenSources( SOURCE_NUM, sourceList);
 			ALCenum err = alcGetError(m_Device);
 
 
 			if ( err == ALC_NO_ERROR )
 			{
 				for ( int x=0; x<SOURCE_NUM;x++)
 				{
 					m_ALSourceBuffer[x].ALSource 	= sourceList[x];
 					m_ALSourceBuffer[x].SourceItem 	= NULL;
 
 				}
 				m_Enabled = true;
 			}
 			else
 			{
 				LOGERROR(L"error in gensource = %d", err);
 			}
 			delete[] sourceList;
 		}
 	}
 
 	// check if init succeeded.
 	// some OpenAL implementations don't indicate failure here correctly;
 	// we need to check if the device and context pointers are actually valid.
 	ALCenum err = alcGetError(m_Device);
 	const char* dev_name = (const char*)alcGetString(m_Device, ALC_DEVICE_SPECIFIER);
 
 	if(err == ALC_NO_ERROR && m_Device && m_Context)
 		debug_printf(L"Sound: AlcInit success, using %hs\n", dev_name);
 	else
 	{
 		LOGERROR(L"Sound: AlcInit failed, m_Device=%p m_Context=%p dev_name=%hs err=%d\n", m_Device, m_Context, dev_name, err);
 
 
 
 // FIXME Hack to get around exclusive access to the sound device
 #if OS_UNIX
 		ret = INFO::OK;
 #else
 		ret = ERR::FAIL;
 #endif // !OS_UNIX
 	}
 
 	return ret;
 }
 
 bool CSoundManager::InDistress()
 {
 	CScopeLock lock(m_DistressMutex);
 
 	if ( m_DistressTime == 0 )
 		return false;
 	else if ( (timer_Time() - m_DistressTime) > 10 )
 	{
 		m_DistressTime = 0;
 // Coming out of distress mode
 		m_DistressErrCount = 0;
 		return false;
 	}
 
 	return true;
 }
 
 void CSoundManager::SetDistressThroughShortage()
 {
 	CScopeLock lock(m_DistressMutex);
 
 // Going into distress for normal reasons
 	
 	m_DistressTime = timer_Time();
 }
 
 void CSoundManager::SetDistressThroughError()
 {
 	CScopeLock lock(m_DistressMutex);
 
 // Going into distress due to unknown error
 	
 	m_DistressTime = timer_Time();
 	m_DistressErrCount++;
 }
 
 
 
 ALuint CSoundManager::GetALSource( ISoundItem* anItem)
 {
 	for ( int x=0; x<SOURCE_NUM;x++)
 	{
 		if ( ! m_ALSourceBuffer[x].SourceItem )
 		{
 			m_ALSourceBuffer[x].SourceItem = anItem;
 			return m_ALSourceBuffer[x].ALSource;
 		}
 	}
 	SetDistressThroughShortage();
 	return 0;
 }
 
 void CSoundManager::ReleaseALSource(ALuint theSource)
 {
 	for ( int x=0; x<SOURCE_NUM;x++)
 	{
 		if ( m_ALSourceBuffer[x].ALSource == theSource )
 		{
 			m_ALSourceBuffer[x].SourceItem = NULL;
 			return;
 		}
 	}
 }
 
 void CSoundManager::SetMemoryUsage(long bufferSize, int bufferCount)
 {
 	m_BufferCount = bufferCount;
 	m_BufferSize = bufferSize;
 }
 long CSoundManager::GetBufferCount()
 {
 	return m_BufferCount;
 }
 long CSoundManager::GetBufferSize()
 {
 	return m_BufferSize;
 }
 
 void CSoundManager::AddPlayListItem( const VfsPath& itemPath)
 {
   m_PlayListItems->push_back( itemPath );
 }
 
 void CSoundManager::ClearPlayListItems()
 {
   if ( m_PlayingPlaylist )
     SetMusicItem( NULL );
 
   m_PlayingPlaylist = false;
   m_LoopingPlaylist = false;
   m_RunningPlaylist = false;
 
   m_PlayListItems->clear();
 }
 
 void CSoundManager::StartPlayList( bool doLoop )
 {
   if ( !m_PlayListItems->empty() )
   {
     m_PlayingPlaylist = true;
     m_LoopingPlaylist = doLoop;
     m_RunningPlaylist = false;
     
     ISoundItem* aSnd = g_SoundManager->LoadItem( (m_PlayListItems->at( 0 )) );
     if ( aSnd )
       SetMusicItem( aSnd );
     else
     {
       SetMusicItem( NULL );
     }
   }
 }
 
 
 void CSoundManager::SetMasterGain(float gain)
 {
 	if ( m_Enabled )
 	{
 		m_Gain = gain;
 		alListenerf( AL_GAIN, m_Gain);
 		AL_CHECK
 	}
 }
 
 void CSoundManager::SetMusicGain(float gain)
 {
 	m_MusicGain = gain;
 }
 void CSoundManager::SetAmbientGain(float gain)
 {
 	m_AmbientGain = gain;
 }
 void CSoundManager::SetActionGain(float gain)
 {
 	m_ActionGain = gain;
 }
 
 
 ISoundItem* CSoundManager::LoadItem(const VfsPath& itemPath)
 {	
 	AL_CHECK
 
 	if ( m_Enabled )
 	{
 		CSoundData* itemData = CSoundData::SoundDataFromFile(itemPath);
 
 		AL_CHECK
 		if ( itemData )
 			return CSoundManager::ItemForData( itemData );
 	}
 
 	return NULL;
 }
 
 ISoundItem* CSoundManager::ItemForData(CSoundData* itemData)
 {	
 	AL_CHECK
 	ISoundItem* answer = NULL;
 
 	AL_CHECK
 	
 	if ( m_Enabled && (itemData != NULL) )
 	{
 		if (itemData->IsOneShot())
 		{
 			if (itemData->GetBufferCount() == 1)
 				answer = new CSoundItem(itemData);
 			else
 				answer = new CBufferItem(itemData);
 		}
 		else
 		{
 			answer = new CStreamItem(itemData);
 		}
 
 		if ( answer && m_Worker )
 			m_Worker->addItem( answer );
 	}
 
 	
 	return answer;
 }
 
 void CSoundManager::IdleTask()
 {
 	if ( m_Enabled )
 	{
 		if (m_CurrentTune)
 		{
 			m_CurrentTune->EnsurePlay();
 			if ( m_PlayingPlaylist && m_RunningPlaylist )
 			{
 				if ( m_CurrentTune->Finished() )
 				{
 					if ( m_PlaylistGap == 0 )
 					{
 						m_PlaylistGap = timer_Time() + 15;
 					}
 					else if ( m_PlaylistGap < timer_Time() )
 					{
 						m_PlaylistGap = 0;
 						PlayList::iterator it = find (m_PlayListItems->begin(), m_PlayListItems->end(), *(m_CurrentTune->GetName()) );
 						++it;
 
 						Path nextPath;
 						if ( it == m_PlayListItems->end() )
 							nextPath = m_PlayListItems->at( 0 );
 						else
 							nextPath = *it;
 
 						ISoundItem* aSnd = g_SoundManager->LoadItem( nextPath );
 						if ( aSnd )
 							SetMusicItem( aSnd );
 					}
 				}
 			}
 		}
 
 		if (m_CurrentEnvirons)
 			m_CurrentEnvirons->EnsurePlay();
 
 		if (m_Worker)
 			m_Worker->CleanupItems();
 
 	}
 }
 
 ISoundItem*	CSoundManager::ItemForEntity( entity_id_t UNUSED(source), CSoundData* sndData)
 {
 	ISoundItem* currentItem = NULL;
 
 	if ( m_Enabled )
 		currentItem = ItemForData( sndData );
 
 	return currentItem;
 }
 
 
 void CSoundManager::InitListener()
 {
 	ALfloat listenerPos[]={0.0,0.0,0.0};
 	ALfloat listenerVel[]={0.0,0.0,0.0};
 	ALfloat	listenerOri[]={0.0,0.0,-1.0, 0.0,1.0,0.0};
 
 	alListenerfv(AL_POSITION,listenerPos);
 	alListenerfv(AL_VELOCITY,listenerVel);
 	alListenerfv(AL_ORIENTATION,listenerOri);
 
 	alDistanceModel(AL_LINEAR_DISTANCE);
 }
 
 void CSoundManager::PlayActionItem(ISoundItem* anItem)
 {
 	if (anItem)
 	{
 		if (m_Enabled && (m_ActionGain > 0))
 		{
 			anItem->SetGain( m_ActionGain );
 			anItem->Play();
 			AL_CHECK
 		}
 	}
 }
 
 void CSoundManager::PlayGroupItem(ISoundItem* anItem, ALfloat groupGain )
 {
 	if (anItem)
 	{
 		if (m_Enabled && (m_ActionGain > 0)) {
 			anItem->SetGain(m_ActionGain * groupGain);
 			anItem->PlayAndDelete();
 			AL_CHECK
 		}
 	}
 }
 
 void CSoundManager::SetMusicEnabled (bool isEnabled)
 {
 	if (m_CurrentTune && !isEnabled)
 	{
 		m_CurrentTune->FadeAndDelete(1.00);
 		m_CurrentTune = 0L;
 	}
 	m_MusicEnabled = isEnabled;
 }
 
 void CSoundManager::SetMusicItem(ISoundItem* anItem)
 {
 	AL_CHECK
 	if (m_CurrentTune)
 	{
 		m_CurrentTune->FadeAndDelete(2.00);
 		m_CurrentTune = 0L;
 	}
 
 	IdleTask();
 
 	if (anItem)
 	{
 		if (m_MusicEnabled && m_Enabled)
 		{
 			m_CurrentTune = anItem;
 			m_CurrentTune->SetGain(0);
 
 			if ( m_PlayingPlaylist )
 			{
 				m_RunningPlaylist = true;
 				m_CurrentTune->Play();
 			}
 			else
 				m_CurrentTune->PlayLoop();
 
 			m_CurrentTune->FadeToIn( m_MusicGain, 1.00);
 		}
 		else
 		{
 			anItem->StopAndDelete();
 		}
 	}
 	AL_CHECK
 }
 
 void CSoundManager::SetAmbientItem(ISoundItem* anItem)
 {
 	if (m_CurrentEnvirons)
 	{
 		m_CurrentEnvirons->FadeAndDelete(3.00);
 		m_CurrentEnvirons = 0L;
 	}
 	IdleTask();
 	
 	if (anItem)
 	{
 		if (m_Enabled && (m_AmbientGain > 0))
 		{
 			m_CurrentEnvirons = anItem;
 			m_CurrentEnvirons->SetGain(0);
 			m_CurrentEnvirons->PlayLoop();
 			m_CurrentEnvirons->FadeToIn( m_AmbientGain, 2.00);
 		}
 	}
 	AL_CHECK
 }
 
 
 void CSoundManager::Pause(bool pauseIt)
 {
   PauseMusic(pauseIt);
   PauseAmbient(pauseIt);
   PauseAction(pauseIt);
 }
 
 void CSoundManager::PauseMusic (bool pauseIt)
 {
 	if (m_CurrentTune && pauseIt && !m_MusicPaused )
 	{
 		m_CurrentTune->FadeAndPause( 1.0 );
 	}
 	else if ( m_CurrentTune && m_MusicPaused && !pauseIt )
 	{
 		m_CurrentTune->SetGain(0);
 		m_CurrentTune->Resume();
 		m_CurrentTune->FadeToIn( m_MusicGain, 1.0);
 	}
 	m_MusicPaused = pauseIt;
 }
 
 void CSoundManager::PauseAmbient (bool pauseIt)
 {
   if (m_CurrentEnvirons && pauseIt)
     m_CurrentEnvirons->Pause();
   else if ( m_CurrentEnvirons )
     m_CurrentEnvirons->Resume();
 
   m_AmbientPaused = pauseIt;
 }
 
 void CSoundManager::PauseAction (bool pauseIt)
 {
   m_ActionPaused = pauseIt;
 }
 
 
 #endif // CONFIG2_AUDIO
 
Index: ps/trunk/source/soundmanager/SoundManager.h
===================================================================
--- ps/trunk/source/soundmanager/SoundManager.h	(revision 13418)
+++ ps/trunk/source/soundmanager/SoundManager.h	(revision 13419)
@@ -1,165 +1,167 @@
-/* Copyright (C) 2012 Wildfire Games.
+/* Copyright (C) 2013 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. 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.
  *
  * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef INCLUDED_SOUNDMANAGER_H
 #define INCLUDED_SOUNDMANAGER_H
 
 #include "lib/config2.h"
 
 #if CONFIG2_AUDIO
 
 #include "lib/file/vfs/vfs_path.h"
 #include "soundmanager/items/ISoundItem.h"
 #include "simulation2/system/Entity.h"
 #include "soundmanager/data/SoundData.h"
 #include "soundmanager/items/ISoundItem.h"
 #include "ps/Profiler2.h"
 
 #include <vector>
 #include <map>
 
 #define AL_CHECK CSoundManager::al_check(__func__, __LINE__);
 
 typedef std::vector<VfsPath> PlayList;
 typedef std::vector<ISoundItem*> ItemsList;
 typedef std::map<entity_id_t, ISoundItem*> ItemsMap;
 
 class CSoundManagerWorker;
 
 
 struct ALSourceHolder
 {
 	/// Title of the column
 	ALuint 		ALSource;
 	ISoundItem*	SourceItem;
 };
 
 class CSoundManager
 {
+	NONCOPYABLE(CSoundManager);
+
 protected:
 
 	ALuint m_ALEnvironment;
 	ALCcontext* m_Context;
 	ALCdevice* m_Device;
 	ISoundItem* m_CurrentTune;
 	ISoundItem* m_CurrentEnvirons;
 	CSoundManagerWorker* m_Worker;
 	CMutex m_DistressMutex;
 	PlayList* m_PlayListItems;
 
 	float m_Gain;
 	float m_MusicGain;
 	float m_AmbientGain;
 	float m_ActionGain;
 	bool m_Enabled;
 	long m_BufferSize;
 	int m_BufferCount;
 	bool m_MusicEnabled;
 	bool m_SoundEnabled;
 
 	bool m_MusicPaused;
 	bool m_AmbientPaused;
 	bool m_ActionPaused;
 	bool m_RunningPlaylist;
  	bool m_PlayingPlaylist;
   bool m_LoopingPlaylist;
 
 	long m_PlaylistGap;
 	long m_DistressErrCount;
 	long m_DistressTime;
 
 	ALSourceHolder* m_ALSourceBuffer;
 
 public:
 	CSoundManager();
 	virtual ~CSoundManager();
 
 	ISoundItem* LoadItem(const VfsPath& itemPath);
 	ISoundItem* ItemForData(CSoundData* itemData);
 	ISoundItem* ItemForEntity( entity_id_t source, CSoundData* sndData);
 
 	void ClearPlayListItems();
 	void StartPlayList( bool doLoop );
 	void AddPlayListItem( const VfsPath& itemPath);
 
 	static void ScriptingInit();
 	static void CreateSoundManager();
 	static void SetEnabled(bool doEnable);
 	
 	static void al_ReportError(ALenum err, const char* caller, int line);
 	static void al_check(const char* caller, int line);
 
 	void SetMusicEnabled (bool isEnabled);
 	void setSoundEnabled( bool enabled );
 
 	ALuint GetALSource(ISoundItem* anItem);
 	void ReleaseALSource(ALuint theSource);
 	ISoundItem* ItemFromData(CSoundData* itemData);
 
 	ISoundItem* ItemFromWAV(VfsPath& fname);
 	ISoundItem* ItemFromOgg(VfsPath& fname);
 
 	ISoundItem* GetSoundItem(unsigned long itemRow);
 	unsigned long Count();
 	void IdleTask();
 	
 	void SetMemoryUsage(long bufferSize, int bufferCount);
 	long GetBufferCount();
 	long GetBufferSize();
 
 	void SetMusicItem(ISoundItem* anItem);
 	void SetAmbientItem(ISoundItem* anItem);
 	void PlayActionItem(ISoundItem* anItem);
 	void PlayGroupItem(ISoundItem* anItem, ALfloat groupGain);
 
 	void SetMasterGain(float gain);
 	void SetMusicGain(float gain);
 	void SetAmbientGain(float gain);
 	void SetActionGain(float gain);
 	bool InDistress();
 	void SetDistressThroughShortage();
 	void SetDistressThroughError();
 
 	void Pause(bool pauseIt);
 	void PauseMusic (bool pauseIt);
 	void PauseAmbient (bool pauseIt);
 	void PauseAction (bool pauseIt);
 
 protected:
 	void InitListener();
 	virtual Status AlcInit();
 
 private:
 	CSoundManager(CSoundManager* UNUSED(other)){};
 };
 
 #else // !CONFIG2_AUDIO
 
 #define AL_CHECK
 
 class CSoundManager
 {
 public:
 	static void ScriptingInit();
 };
 #endif // !CONFIG2_AUDIO
 
 
 extern CSoundManager*  g_SoundManager;
 
 #endif // INCLUDED_SOUNDMANAGER_H
 
Index: ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/Tools/Common/Tools.h
===================================================================
--- ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/Tools/Common/Tools.h	(revision 13418)
+++ ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/Tools/Common/Tools.h	(revision 13419)
@@ -1,168 +1,172 @@
-/* Copyright (C) 2011 Wildfire Games.
+/* Copyright (C) 2013 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. 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.
  *
  * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef INCLUDED_TOOLS
 #define INCLUDED_TOOLS
 
 #include "General/AtlasWindowCommand.h"
 #include "General/Observable.h"
 
 class wxMouseEvent;
 class wxKeyEvent;
 class ScenarioEditor;
 
 class ITool : public wxObject
 {
 public:
 	enum KeyEventType { KEY_DOWN, KEY_UP, KEY_CHAR };
 
 	virtual void Init(void* initData, ScenarioEditor* scenarioEditor) = 0;
 	virtual void Shutdown() = 0;
 	virtual bool OnMouse(wxMouseEvent& evt) = 0; // return true if handled
 	virtual bool OnKey(wxKeyEvent& evt, KeyEventType dir) = 0; // return true if handled
 	virtual void OnTick(float dt) = 0; // dt in seconds
 
 	virtual ~ITool() {};
 };
 
 struct ToolManagerImpl;
 class ToolManager
 {
+private: // NONCOPYABLE
+	ToolManager(const ToolManager&);
+	const ToolManager& operator=(const ToolManager&);
+
 public:
 	ToolManager(ScenarioEditor* scenarioEditor);
 	~ToolManager();
 	ObservablePtr<ITool>& GetCurrentTool();
 	wxString GetCurrentToolName();
 	void SetCurrentTool(const wxString& name, void* initData = NULL);
 private:
 	ToolManagerImpl* m;
 	ScenarioEditor* m_ScenarioEditor;
 };
 
 class ToolButton;
 extern void RegisterToolButton(ToolButton* button, const wxString& toolName);
 extern void RegisterToolBarButton(wxToolBar* toolbar, int buttonId, const wxString& toolName);
 
 //////////////////////////////////////////////////////////////////////////
 
 
 namespace AtlasMessage { struct mWorldCommand; }
 class WorldCommand : public AtlasWindowCommand
 {
 	DECLARE_CLASS(WorldCommand);
 
 	bool m_AlreadyDone;
 public:
 	WorldCommand(AtlasMessage::mWorldCommand* command);
 	~WorldCommand();
 	bool Do();
 	bool Undo();
 	bool Merge(AtlasWindowCommand* previousCommand);
 
 private:
 	AtlasMessage::mWorldCommand* m_Command;
 };
 
 #define POST_COMMAND(type, data) ScenarioEditor::GetCommandProc().Submit(new WorldCommand(new AtlasMessage::m##type(AtlasMessage::d##type data)))
 
 //////////////////////////////////////////////////////////////////////////
 
 #define SET_STATE(s) obj->SetState(&obj->s)
 
 template <typename T>
 class StateDrivenTool : public ITool
 {
 public:
 	StateDrivenTool()
 		: m_CurrentState(&Disabled), m_ScenarioEditor(NULL)
 	{
 	}
 
 	virtual void Init(void* WXUNUSED(initData), ScenarioEditor* scenarioEditor)
 	{
 		m_ScenarioEditor = scenarioEditor;
 	}
 
 	virtual void Shutdown()
 	{
 		// This can't be done in the destructor, because ~StateDrivenTool
 		// is not called until after the subclass has been destroyed and its
 		// vtable (containing OnDisable) has been removed.
 		SetState(&Disabled);
 	}
 
 protected:
 	// Called when the tool is enabled/disabled; always called in zero or
 	// more enable-->disable pairs per object instance.
 	virtual void OnEnable() {}
 	virtual void OnDisable() {}
 
 	struct State
 	{
 		virtual ~State() {}
 		virtual void OnEnter(T* WXUNUSED(obj)) {}
 		virtual void OnLeave(T* WXUNUSED(obj)) {}
 		virtual void OnTick (T* WXUNUSED(obj), float WXUNUSED(dt)) {}
 
 		// Should return true if the event has been handled (else the event will
 		// be passed to a lower-priority level)
 		virtual bool OnMouse(T* WXUNUSED(obj), wxMouseEvent& WXUNUSED(evt)) { return false; }
 		virtual bool OnKey(T* WXUNUSED(obj), wxKeyEvent& WXUNUSED(evt), KeyEventType WXUNUSED(type)) { return false; }
 	};
 
 
 	struct sDisabled : public State
 	{
 		void OnEnter(T* obj) { obj->OnDisable(); }
 		void OnLeave(T* obj) { obj->OnEnable(); }
 	}
 	Disabled;
 
 	void SetState(State* state)
 	{
 		m_CurrentState->OnLeave(static_cast<T*>(this));
 		// this cast is safe as long as the class is used as in
 		// "class Something : public StateDrivenTool<Something> { ... }"
 		m_CurrentState = state;
 		m_CurrentState->OnEnter(static_cast<T*>(this));
 	}
 
 	ScenarioEditor& GetScenarioEditor() { wxASSERT(m_ScenarioEditor); return *m_ScenarioEditor; }
 
 private:
 	State* m_CurrentState;
 
 	ScenarioEditor* m_ScenarioEditor; // not NULL, except before Init has been called
 
 	virtual bool OnMouse(wxMouseEvent& evt)
 	{
 		return m_CurrentState->OnMouse(static_cast<T*>(this), evt);
 	}
 
 	virtual bool OnKey(wxKeyEvent& evt, KeyEventType dir)
 	{
 		return m_CurrentState->OnKey(static_cast<T*>(this), evt, dir);
 	}
 
 	virtual void OnTick(float dt)
 	{
 		m_CurrentState->OnTick(static_cast<T*>(this), dt);
 	}
 };
 
 
 #endif // INCLUDED_TOOLS