Index: ps/trunk/source/gui/CGUI.h
===================================================================
--- ps/trunk/source/gui/CGUI.h	(revision 22562)
+++ ps/trunk/source/gui/CGUI.h	(revision 22563)
@@ -1,647 +1,646 @@
 /* Copyright (C) 2019 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/>.
  */
 
 /*
  * This is the top class of the whole GUI, all objects
  * and settings are stored within this class.
  */
 
 #ifndef INCLUDED_CGUI
 #define INCLUDED_CGUI
 
 #include "GUITooltip.h"
 #include "GUIbase.h"
 
 #include "lib/input.h"
 #include "ps/Shapes.h"
 #include "ps/XML/Xeromyces.h"
 #include "scriptinterface/ScriptInterface.h"
 
 #include <boost/unordered_set.hpp>
 
 ERROR_TYPE(GUI, JSOpenFailed);
 
 extern const double SELECT_DBLCLICK_RATE;
 
 /**
  * Contains a list of values for new defaults to objects.
  */
 struct SGUIStyle
 {
 	std::map<CStr, CStrW> m_SettingsDefaults;
 };
 
 class JSObject; // The GUI stores a JSObject*, so needs to know that JSObject exists
 class IGUIObject;
 class CGUISpriteInstance;
 struct SGUIText;
 struct CGUIColor;
 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 CInternalCGUIAccessorBase;
 
 private:
 	// Private typedefs
 	typedef IGUIObject *(*ConstructObjectFunction)();
 
 public:
 	CGUI(const shared_ptr<ScriptRuntime>& runtime);
 	~CGUI();
 
 	/**
 	 * 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);
 
 	/**
 	 * Sends a specified script event to every object
 	 *
 	 * @param EventName String representation of event name
 	 * @param paramData JS::HandleValueArray storing the arguments passed to the event handler.
 	 */
 	void SendEventToAll(const CStr& EventName, JS::HandleValueArray paramData);
 
 	/**
 	 * 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 CGUIColor& 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;
 
 	const SGUIScrollBarStyle* GetScrollBarStyle(const CStr& style) 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 occurred in to aid the user.
 	 */
 	SGUIText GenerateText(const CGUIString& Text, const CStrW& Font, const float& Width, const float& BufferZone, const IGUIObject* pObject = NULL);
 
 
 	/**
 	 * 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, CGUIColor& Output) const;
 
 	shared_ptr<ScriptInterface> GetScriptInterface() { return m_ScriptInterface; };
 	JS::Value GetGlobalObject() { return m_ScriptInterface->GetGlobalObject(); };
 
 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, std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths, u32 nesting_depth);
 
 	/**
 	 * Reads in the element \<repeat\>, which repeats its child \<object\>s
 	 * 'count' times, replacing the string "[n]" (or the value of the attribute
 	 * 'var' enclosed in square brackets) in its descendants' names with "[0]",
 	 * "[1]", etc.
 	 */
 	void Xeromyces_ReadRepeat(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths, u32 nesting_depth);
 
 	/**
 	 * 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 */
 	//--------------------------------------------------------
 	//@{
 
 	shared_ptr<ScriptInterface> m_ScriptInterface;
 
 	/**
 	 * 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, CGUIColor> 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 // INCLUDED_CGUI
Index: ps/trunk/source/gui/GUIbase.h
===================================================================
--- ps/trunk/source/gui/GUIbase.h	(revision 22562)
+++ ps/trunk/source/gui/GUIbase.h	(revision 22563)
@@ -1,220 +1,219 @@
 /* Copyright (C) 2019 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/>.
  */
 
 /*
 GUI Core, stuff that the whole GUI uses
 
 --Overview--
 
 	Contains defines, includes, types etc that the whole
 	 GUI should have included.
 
 --More info--
 
 	Check GUI.h
 
 */
 
 #ifndef INCLUDED_GUIBASE
 #define INCLUDED_GUIBASE
 
 #include <map>
 #include <vector>
 
 #include "gui/CGUIColor.h"
 #include "ps/CStr.h"
 #include "ps/Errors.h"
 // I would like to just forward declare CSize, but it doesn't
 //  seem to be defined anywhere in the predefined header.
 #include "ps/Shapes.h"
 #include "scriptinterface/ScriptInterface.h"
 
 class IGUIObject;
 
 // Object settings setups
 // Setup an object's ConstructObject function
 #define GUI_OBJECT(obj)													\
 public:																	\
 	static IGUIObject* ConstructObject() { return new obj(); }
 
 
 /**
  * Message types.
  * @see SGUIMessage
  */
 enum EGUIMessageType
 {
 	GUIM_MOUSE_OVER,
 	GUIM_MOUSE_ENTER,
 	GUIM_MOUSE_LEAVE,
 	GUIM_MOUSE_PRESS_LEFT,
 	GUIM_MOUSE_PRESS_LEFT_ITEM,
 	GUIM_MOUSE_PRESS_RIGHT,
 	GUIM_MOUSE_DOWN_LEFT,
 	GUIM_MOUSE_DOWN_RIGHT,
 	GUIM_MOUSE_DBLCLICK_LEFT,
 	GUIM_MOUSE_DBLCLICK_LEFT_ITEM, // Triggered when doubleclicking on a list item
 	GUIM_MOUSE_DBLCLICK_RIGHT,
 	GUIM_MOUSE_RELEASE_LEFT,
 	GUIM_MOUSE_RELEASE_RIGHT,
 	GUIM_MOUSE_WHEEL_UP,
 	GUIM_MOUSE_WHEEL_DOWN,
 	GUIM_SETTINGS_UPDATED,	// SGUIMessage.m_Value = name of setting
 	GUIM_PRESSED,
 	GUIM_RELEASED,
 	GUIM_DOUBLE_PRESSED,
 	GUIM_MOUSE_MOTION,
 	GUIM_LOAD,				// Called when an object is added to the GUI.
 	GUIM_GOT_FOCUS,
 	GUIM_LOST_FOCUS,
 	GUIM_PRESSED_MOUSE_RIGHT,
 	GUIM_DOUBLE_PRESSED_MOUSE_RIGHT,
 	GUIM_TAB,				// Used by CInput
 	GUIM_TEXTEDIT
 };
 
 /**
  * Message send to IGUIObject::HandleMessage() in order
  * to give life to Objects manually with
  * a derived HandleMessage().
  */
 struct SGUIMessage
 {
 	SGUIMessage(EGUIMessageType _type) : type(_type), skipped(false) {}
 	SGUIMessage(EGUIMessageType _type, const CStr& _value) : type(_type), value(_value), skipped(false) {}
 
 	/**
 	 * This method can be used to allow other event handlers to process this GUI event,
 	 * by default an event is not skipped (only the first handler will process it).
 	 *
 	 * @param skip true to allow further event handling, false to prevent it
 	 */
 	void Skip(bool skip = true) { skipped = skip; }
 
 	/**
 	 * Describes what the message regards
 	 */
 	EGUIMessageType type;
 
 	/**
 	 * Optional data
 	 */
 	CStr value;
 
 	/**
 	 * Flag that specifies if object skipped handling the event
 	 */
 	bool skipped;
 };
 
 /**
  * Recurse restrictions, when we recurse, if an object
  * is hidden for instance, you might want it to skip
  * the children also
  * Notice these are flags! and we don't really need one
  * for no restrictions, because then you'll just enter 0
  */
 enum
 {
 	GUIRR_HIDDEN		= 0x00000001,
 	GUIRR_DISABLED		= 0x00000010,
 	GUIRR_GHOST			= 0x00000100
 };
 
 // Text alignments
 enum EAlign { EAlign_Left, EAlign_Right, EAlign_Center };
 enum EVAlign { EVAlign_Top, EVAlign_Bottom, EVAlign_Center };
 
 // Typedefs
 typedef	std::map<CStr, IGUIObject*> map_pObjects;
 typedef std::vector<IGUIObject*> vector_pObjects;
 
 // Icon, you create them in the XML file with root element <setup>
 //  you use them in text owned by different objects... Such as CText.
 struct SGUIIcon
 {
 	SGUIIcon() : m_CellID(0) {}
 
 	// Sprite name of icon
 	CStr m_SpriteName;
 
 	// Size
 	CSize m_Size;
 
 	// Cell of texture to use; ignored unless the texture has specified cell-size
 	int m_CellID;
 };
 
 /**
  * Client Area is a rectangle relative to a parent rectangle
  *
  * You can input the whole value of the Client Area by
  * string. Like used in the GUI.
  */
 class CClientArea
 {
 public:
 	CClientArea();
 	CClientArea(const CStr& Value);
 	CClientArea(const CRect& pixel, const CRect& percent);
 
 	/// Pixel modifiers
 	CRect pixel;
 
 	/// Percent modifiers
 	CRect percent;
 
 	/**
 	 * Get client area rectangle when the parent is given
 	 */
 	CRect GetClientArea(const CRect& parent) const;
 
 	/**
 	 * The ClientArea can be set from a string looking like:
 	 *
 	 * "0 0 100% 100%"
 	 * "50%-10 50%-10 50%+10 50%+10"
 	 *
 	 * i.e. First percent modifier, then + or - and the pixel modifier.
 	 * Although you can use just the percent or the pixel modifier. Notice
 	 * though that the percent modifier must always be the first when
 	 * both modifiers are inputted.
 	 *
 	 * @return true if success, false if failure. If false then the client area
 	 *			will be unchanged.
 	 */
 	bool SetClientArea(const CStr& Value);
 
 	bool operator==(const CClientArea& other) const
 	{
 		return pixel == other.pixel && percent == other.percent;
 	}
 
 	void ToJSVal(JSContext* cx, JS::MutableHandleValue ret) const;
 	bool FromJSVal(JSContext* cx, JS::HandleValue v);
 };
 
 
 ERROR_GROUP(GUI);
 
-ERROR_TYPE(GUI, NullObjectProvided);
 ERROR_TYPE(GUI, InvalidSetting);
 ERROR_TYPE(GUI, OperationNeedsGUIObject);
 ERROR_TYPE(GUI, NameAmbiguity);
 ERROR_TYPE(GUI, ObjectNeedsName);
 
 #endif // INCLUDED_GUIBASE
Index: ps/trunk/source/gui/GUIutil.cpp
===================================================================
--- ps/trunk/source/gui/GUIutil.cpp	(revision 22562)
+++ ps/trunk/source/gui/GUIutil.cpp	(revision 22563)
@@ -1,429 +1,400 @@
 /* Copyright (C) 2019 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 "GUIutil.h"
 
 #include "gui/GUI.h"
 #include "gui/GUIManager.h"
 #include "maths/Matrix3D.h"
 #include "ps/CLogger.h"
 #include "ps/GameSetup/Config.h"
 
 extern int g_xres, g_yres;
 
 template <>
 bool __ParseString<bool>(const CStrW& Value, bool& Output)
 {
 	if (Value == L"true")
 		Output = true;
 	else if (Value == L"false")
 		Output = false;
 	else
 		return false;
 
 	return true;
 }
 
 template <>
 bool __ParseString<int>(const CStrW& Value, int& Output)
 {
 	Output = Value.ToInt();
 	return true;
 }
 
 template <>
 bool __ParseString<u32>(const CStrW& Value, u32& Output)
 {
 	Output = Value.ToUInt();
 	return true;
 }
 
 template <>
 bool __ParseString<float>(const CStrW& Value, float& Output)
 {
 	Output = Value.ToFloat();
 	return true;
 }
 
 template <>
 bool __ParseString<CRect>(const CStrW& Value, CRect& Output)
 {
 	const unsigned int NUM_COORDS = 4;
 	float coords[NUM_COORDS];
 	std::wstringstream stream;
 	stream.str(Value);
 	// Parse each coordinate
 	for (unsigned int i = 0; i < NUM_COORDS; ++i)
 	{
 		if (stream.eof())
 		{
 			LOGWARNING("Too few CRect parameters (min %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
 			return false;
 		}
 		stream >> coords[i];
 		if ((stream.rdstate() & std::wstringstream::failbit) != 0)
 		{
 			LOGWARNING("Unable to parse CRect parameters. Your input: '%s'", Value.ToUTF8().c_str());
 			return false;
 		}
 	}
 
 	if (!stream.eof())
 	{
 		LOGWARNING("Too many CRect parameters (max %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
 		return false;
 	}
 
 	// Finally the rectangle values
 	Output = CRect(coords[0], coords[1], coords[2], coords[3]);
 
 	return true;
 }
 
 template <>
 bool __ParseString<CClientArea>(const CStrW& Value, CClientArea& Output)
 {
 	return Output.SetClientArea(Value.ToUTF8());
 }
 
 template <>
 bool GUI<int>::ParseColor(const CStrW& Value, CGUIColor& Output, int DefaultAlpha)
 {
 	return Output.ParseString(Value.ToUTF8(), DefaultAlpha);
 }
 
 template <>
 bool __ParseString<CGUIColor>(const CStrW& Value, CGUIColor& Output)
 {
 	return Output.ParseString(Value.ToUTF8());
 }
 
 template <>
 bool __ParseString<CSize>(const CStrW& Value, CSize& Output)
 {
 	const unsigned int NUM_COORDS = 2;
 	float coords[NUM_COORDS];
 	std::wstringstream stream;
 	stream.str(Value);
 	// Parse each coordinate
 	for (unsigned int i = 0; i < NUM_COORDS; ++i)
 	{
 		if (stream.eof())
 		{
 			LOGWARNING("Too few CSize parameters (min %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
 			return false;
 		}
 		stream >> coords[i];
 		if ((stream.rdstate() & std::wstringstream::failbit) != 0)
 		{
 			LOGWARNING("Unable to parse CSize parameters. Your input: '%s'", Value.ToUTF8().c_str());
 			return false;
 		}
 	}
 
 	Output.cx = coords[0];
 	Output.cy = coords[1];
 
 	if (!stream.eof())
 	{
 		LOGWARNING("Too many CSize parameters (max %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
 		return false;
 	}
 
 	return true;
 }
 
 template <>
 bool __ParseString<CPos>(const CStrW& Value, CPos& Output)
 {
 	const unsigned int NUM_COORDS = 2;
 	float coords[NUM_COORDS];
 	std::wstringstream stream;
 	stream.str(Value);
 	// Parse each coordinate
 	for (unsigned int i = 0; i < NUM_COORDS; ++i)
 	{
 		if (stream.eof())
 		{
 			LOGWARNING("Too few CPos parameters (min %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
 			return false;
 		}
 		stream >> coords[i];
 		if ((stream.rdstate() & std::wstringstream::failbit) != 0)
 		{
 			LOGWARNING("Unable to parse CPos parameters. Your input: '%s'", Value.ToUTF8().c_str());
 			return false;
 		}
 	}
 
 	Output.x = coords[0];
 	Output.y = coords[1];
 
 	if (!stream.eof())
 	{
 		LOGWARNING("Too many CPos parameters (max %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
 		return false;
 	}
 
 	return true;
 }
 
 template <>
 bool __ParseString<EAlign>(const CStrW& Value, EAlign& Output)
 {
 	if (Value == L"left")
 		Output = EAlign_Left;
 	else if (Value == L"center")
 		Output = EAlign_Center;
 	else if (Value == L"right")
 		Output = EAlign_Right;
 	else
 		return false;
 
 	return true;
 }
 
 template <>
 bool __ParseString<EVAlign>(const CStrW& Value, EVAlign& Output)
 {
 	if (Value == L"top")
 		Output = EVAlign_Top;
 	else if (Value == L"center")
 		Output = EVAlign_Center;
 	else if (Value == L"bottom")
 		Output = EVAlign_Bottom;
 	else
 		return false;
 
 	return true;
 }
 
 template <>
 bool __ParseString<CGUIString>(const CStrW& Value, CGUIString& Output)
 {
 	Output.SetValue(Value);
 	return true;
 }
 
 template <>
 bool __ParseString<CStr>(const CStrW& Value, CStr& Output)
 {
 	// Do very little.
 	Output = Value.ToUTF8();
 	return true;
 }
 
 template <>
 bool __ParseString<CStrW>(const CStrW& Value, CStrW& Output)
 {
 	Output = Value;
 	return true;
 }
 
 template <>
 bool __ParseString<CGUISpriteInstance>(const CStrW& Value, CGUISpriteInstance& Output)
 {
 	Output = CGUISpriteInstance(Value.ToUTF8());
 	return true;
 }
 
 template <>
 bool __ParseString<CGUIList>(const CStrW& UNUSED(Value), CGUIList& UNUSED(Output))
 {
 	return false;
 }
 
 template <>
 bool __ParseString<CGUISeries>(const CStrW& UNUSED(Value), CGUISeries& UNUSED(Output))
 {
 	return false;
 }
 
-//--------------------------------------------------------
-
 CMatrix3D GetDefaultGuiMatrix()
 {
 	float xres = g_xres / g_GuiScale;
 	float yres = g_yres / g_GuiScale;
 
 	CMatrix3D m;
 	m.SetIdentity();
 	m.Scale(1.0f, -1.f, 1.0f);
 	m.Translate(0.0f, yres, -1000.0f);
 
 	CMatrix3D proj;
 	proj.SetOrtho(0.f, xres, 0.f, yres, -1.f, 1000.f);
 	m = proj * m;
 
 	return m;
 }
 
-//--------------------------------------------------------
-//  Utilities implementation
-//--------------------------------------------------------
-IGUIObject* CInternalCGUIAccessorBase::GetObjectPointer(CGUI& GUIinstance, const CStr& Object)
-{
-	return GUIinstance.FindObjectByName(Object);
-}
-
-const IGUIObject* CInternalCGUIAccessorBase::GetObjectPointer(const CGUI& GUIinstance, const CStr& Object)
-{
-	return GUIinstance.FindObjectByName(Object);
-}
-
-void CInternalCGUIAccessorBase::QueryResetting(IGUIObject* pObject)
-{
-	GUI<>::RecurseObject(0, pObject, &IGUIObject::ResetStates);
-}
-
-void CInternalCGUIAccessorBase::HandleMessage(IGUIObject* pObject, SGUIMessage& message)
-{
-	pObject->HandleMessage(message);
-}
-
-
-
 #ifndef NDEBUG
 	#define TYPE(T) \
 		template<> void CheckType<T>(const IGUIObject* obj, const CStr& setting) {	\
 			std::map<CStr, SGUISetting>::const_iterator it = obj->m_Settings.find(setting);	\
 			if (it == obj->m_Settings.end() || it->second.m_Type != GUIST_##T)	\
 			{	\
 				/* Abort now, to avoid corrupting everything by invalidly \
 					casting pointers */ \
 				DEBUG_DISPLAY_ERROR(L"FATAL ERROR: Inconsistent types in GUI");	\
 			}	\
 		}
 	#include "GUItypes.h"
 	#undef TYPE
 #endif
 
 
-//--------------------------------------------------------------------
-
 template <typename T>
 PSRETURN GUI<T>::GetSettingPointer(const IGUIObject* pObject, const CStr& Setting, T*& Value)
 {
 	ENSURE(pObject != NULL);
 
 	std::map<CStr, SGUISetting>::const_iterator it = pObject->m_Settings.find(Setting);
 	if (it == pObject->m_Settings.end())
 	{
 		LOGWARNING("setting %s was not found on object %s",
 			Setting.c_str(),
 			pObject->GetPresentableName().c_str());
 		return PSRETURN_GUI_InvalidSetting;
 	}
 
 	if (it->second.m_pSetting == NULL)
 		return PSRETURN_GUI_InvalidSetting;
 
 #ifndef NDEBUG
 	CheckType<T>(pObject, Setting);
 #endif
 
 	// Get value
 	Value = (T*)(it->second.m_pSetting);
 
 	return PSRETURN_OK;
 }
 
 template <typename T>
 PSRETURN GUI<T>::GetSetting(const IGUIObject* pObject, const CStr& Setting, T& Value)
 {
 	T* v = NULL;
 	PSRETURN ret = GetSettingPointer(pObject, Setting, v);
 	if (ret == PSRETURN_OK)
 		Value = *v;
 	return ret;
 }
 
 // Helper function for SetSetting
 template <typename T>
 bool IsBoolTrue(const T&)
 {
 	return false;
 }
 template <>
 bool IsBoolTrue<bool>(const bool& v)
 {
 	return v;
 }
 
 template <typename T>
 PSRETURN GUI<T>::SetSetting(IGUIObject* pObject, const CStr& Setting, const T& Value, const bool& SkipMessage)
 {
 	ENSURE(pObject != NULL);
 
 	if (!pObject->SettingExists(Setting))
 	{
 		LOGWARNING("setting %s was not found on object %s",
 			Setting.c_str(),
 			pObject->GetPresentableName().c_str());
 		return PSRETURN_GUI_InvalidSetting;
 	}
 
 #ifndef NDEBUG
 	CheckType<T>(pObject, Setting);
 #endif
 
 	// Set value
 	*(T*)pObject->m_Settings[Setting].m_pSetting = Value;
 
 	//
 	//	Some settings needs special attention at change
 	//
 
 	// If setting was "size", we need to re-cache itself and all children
 	if (Setting == "size")
 	{
 		RecurseObject(0, pObject, &IGUIObject::UpdateCachedSize);
 	}
 	else if (Setting == "hidden")
 	{
 		// Hiding an object requires us to reset it and all children
 		if (IsBoolTrue(Value))
-			QueryResetting(pObject);
+			RecurseObject(0, pObject, &IGUIObject::ResetStates);
 	}
 
 	if (!SkipMessage)
 	{
 		SGUIMessage msg(GUIM_SETTINGS_UPDATED, Setting);
-		HandleMessage(pObject, msg);
+		pObject->HandleMessage(msg);
 	}
 
 	return PSRETURN_OK;
 }
 
 // Instantiate templated functions:
 #define TYPE(T) \
 	template PSRETURN GUI<T>::GetSettingPointer(const IGUIObject* pObject, const CStr& Setting, T*& Value); \
 	template PSRETURN GUI<T>::GetSetting(const IGUIObject* pObject, const CStr& Setting, T& Value); \
 	template PSRETURN GUI<T>::SetSetting(IGUIObject* pObject, const CStr& Setting, const T& Value, const bool& SkipMessage);
 #define GUITYPE_IGNORE_CGUISpriteInstance
 #include "GUItypes.h"
 #undef GUITYPE_IGNORE_CGUISpriteInstance
 #undef TYPE
 
 // Don't instantiate GetSetting<CGUISpriteInstance> - this will cause linker errors if
 // you attempt to retrieve a sprite using GetSetting, since that copies the sprite
 // and will mess up the caching performed by DrawSprite. You have to use GetSettingPointer
 // instead. (This is mainly useful to stop me accidentally using the wrong function.)
 template PSRETURN GUI<CGUISpriteInstance>::GetSettingPointer(const IGUIObject* pObject, const CStr& Setting, CGUISpriteInstance*& Value);
 template PSRETURN GUI<CGUISpriteInstance>::SetSetting(IGUIObject* pObject, const CStr& Setting, const CGUISpriteInstance& Value, const bool& SkipMessage);
Index: ps/trunk/source/gui/GUIutil.h
===================================================================
--- ps/trunk/source/gui/GUIutil.h	(revision 22562)
+++ ps/trunk/source/gui/GUIutil.h	(revision 22563)
@@ -1,361 +1,290 @@
 /* Copyright (C) 2019 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/>.
  */
 
 /*
 GUI util
 
 --Overview--
 
 	Contains help class GUI<>, which gives us templated
 	 parameter to all functions within GUI.
 
 --More info--
 
 	Check GUI.h
 
 */
 
 #ifndef INCLUDED_GUIUTIL
 #define INCLUDED_GUIUTIL
 
 #include "gui/CGUI.h"
 #include "gui/CGUISprite.h"
 #include "gui/GUIbase.h"
 #include "gui/IGUIObject.h"
 
 class CClientArea;
 class CGUIString;
 class CMatrix3D;
 
 template <typename T>
 bool __ParseString(const CStrW& Value, T& tOutput);
 
 // Model-view-projection matrix with (0,0) in top-left of screen
 CMatrix3D GetDefaultGuiMatrix();
 
 struct SGUIMessage;
 
-/**
- * Base class to only the class GUI. This superclass is
- * kind of a templateless extention of the class GUI.
- * Used for other functions to friend with, because it
- * can't friend with GUI since it's templated (at least
- * not on all compilers we're using).
- */
-class CInternalCGUIAccessorBase
-{
-protected:
-	/// Get object pointer
-	static IGUIObject* GetObjectPointer(CGUI& GUIinstance, const CStr& Object);
-
-	/// const version
-	static const IGUIObject* GetObjectPointer(const CGUI& GUIinstance, const CStr& Object);
-
-	/// Wrapper for ResetStates
-	static void QueryResetting(IGUIObject* pObject);
-
-	static void HandleMessage(IGUIObject* pObject, SGUIMessage& message);
-};
-
-
 #ifndef NDEBUG
 // Used to ensure type-safety, sort of
 template<typename T> void CheckType(const IGUIObject* obj, const CStr& setting);
 #endif
 
 
 /**
  * Includes static functions that needs one template
  * argument.
  *
  * int is only to please functions that doesn't even use T
  * and are only within this class because it's convenient
  */
 template <typename T=int>
-class GUI : public CInternalCGUIAccessorBase
+class GUI
 {
 	// Private functions further ahead
 	friend class CGUI;
 	friend class IGUIObject;
-	friend class CInternalCGUIAccessorBase;
 
 public:
 
 	// Like GetSetting (below), but doesn't make a copy of the value
 	// (so it can be modified later)
 	static PSRETURN GetSettingPointer(const IGUIObject* pObject, const CStr& Setting, T*& Value);
 
 	/**
 	 * Retrieves a setting by name from object pointer
 	 *
 	 * @param pObject Object pointer
 	 * @param Setting Setting by name
 	 * @param Value Stores value here, note type T!
 	 */
 	static PSRETURN GetSetting(const IGUIObject* pObject, const CStr& Setting, T& Value);
 
 	/**
 	 * Sets a value by name using a real datatype as input.
 	 *
 	 * This is the official way of setting a setting, no other
 	 *  way should only cautiously be used!
 	 *
 	 * @param pObject Object pointer
 	 * @param Setting Setting by name
 	 * @param Value Sets value to this, note type T!
 	 * @param SkipMessage Does not send a GUIM_SETTINGS_UPDATED if true
 	 */
 	static PSRETURN SetSetting(IGUIObject* pObject, const CStr& Setting, const T& Value, const bool& SkipMessage = false);
 
 	/**
-	 * Retrieves a setting by settings name and object name
-	 *
-	 * @param GUIinstance GUI Object const ref
-	 * @param Object Object name
-	 * @param Setting Setting by name
-	 * @param Value Stores value here, note type T!
-	 */
-	static PSRETURN GetSetting(const CGUI& GUIinstance, const CStr& Object, const CStr& Setting, T& Value)
-	{
-		if (!GUIinstance.ObjectExists(Object))
-			return PSRETURN_GUI_NullObjectProvided;
-
-		// Retrieve pointer and call sibling function
-		const IGUIObject* pObject = GetObjectPointer(GUIinstance, Object);
-
-		return GetSetting(pObject, Setting, Value);
-	}
-
-	/**
-	 * Sets a value by setting and object name using a real
-	 * datatype as input
-	 *
-	 * This is just a wrapper so that we can type the object name
-	 *  and not input the actual pointer.
-	 *
-	 * @param GUIinstance GUI Object, reference since we'll be changing values
-	 * @param Object Object name
-	 * @param Setting Setting by name
-	 * @param Value Sets value to this, note type T!
-	 * @param SkipMessage Does not send a GUIM_SETTINGS_UPDATED if true
-	 */
-	static PSRETURN SetSetting(CGUI& GUIinstance, const CStr& Object, const CStr& Setting, const T& Value, const bool& SkipMessage = false)
-	{
-		if (!GUIinstance.ObjectExists(Object))
-			return PSRETURN_GUI_NullObjectProvided;
-
-		// Retrieve pointer and call sibling function
-
-		// Important, we don't want to use this T, we want
-		//  to use the standard T, since that will be the
-		//  one with the friend relationship
-		IGUIObject* pObject = GetObjectPointer(GUIinstance, Object);
-
-		return SetSetting(pObject, Setting, Value, SkipMessage);
-	}
-
-	/**
 	 * This will return the value of the first sprite if it's not null,
 	 * if it is null, it will return the value of the second sprite, if
 	 * that one is null, then null it is.
 	 *
 	 * @param prim Primary sprite that should be used
 	 * @param sec Secondary sprite if Primary should fail
 	 * @return Resulting string
 	 */
 	static const CGUISpriteInstance& FallBackSprite(const CGUISpriteInstance& prim, const CGUISpriteInstance& sec)
 	{
 		return (prim.IsEmpty() ? sec : prim);
 	}
 
 	/**
 	 * Same principle as FallBackSprite
 	 *
 	 * @param prim Primary color that should be used
 	 * @param sec Secondary color if Primary should fail
 	 * @return Resulting color
 	 * @see FallBackSprite
 	 */
 	static CGUIColor FallBackColor(const CGUIColor& prim, const CGUIColor& sec)
 	{
 		// CGUIColor() == null.
 		return ((prim!=CGUIColor())?(prim):(sec));
 	}
 
 	/**
 	 * Sets a value by setting and object name using a real
 	 * datatype as input.
 	 *
 	 * This is just a wrapper for __ParseString() which really
 	 * works the magic.
 	 *
 	 * @param Value The value in string form, like "0 0 100% 100%"
 	 * @param tOutput Parsed value of type T
 	 * @return True at success.
 	 *
 	 * @see __ParseString()
 	 */
 	static bool ParseString(const CStrW& Value, T& tOutput)
 	{
 		return __ParseString<T>(Value, tOutput);
 	}
 
 	static bool ParseColor(const CStrW& Value, CGUIColor& tOutput, int DefaultAlpha);
 
 private:
 
 	// templated typedef of function pointer
 	typedef void (IGUIObject::*void_Object_pFunction_argT)(const T& arg);
 	typedef void (IGUIObject::*void_Object_pFunction_argRefT)(T& arg);
 	typedef void (IGUIObject::*void_Object_pFunction)();
 	typedef void (IGUIObject::*void_Object_pFunction_argTJS)(const T& arg, JS::HandleValueArray paramData);
 
 	/**
 	 * If you want to call a IGUIObject-function
 	 * on not just an object, but also on ALL of their children
 	 * you want to use this recursion system.
 	 * It recurses an object calling a function on itself
 	 * and all children (and so forth).
 	 *
 	 * <b>Restrictions:</b>\n
 	 * You can also set restrictions, so that if the recursion
 	 * reaches an objects with certain setup, it just doesn't
 	 * call the function on the object, nor it's children for
 	 * that matter. i.e. it cuts that object off from the
 	 * recursion tree. What setups that can cause restrictions
 	 * are hardcoded and specific. Check out the defines
 	 * GUIRR_* for all different setups.
 	 *
 	 * Error reports are either logged or thrown out of RecurseObject.
 	 * Always use it with try/catch!
 	 *
 	 * @param RR Recurse Restrictions, set to 0 if no restrictions
 	 * @param pObject Top object, this is where the iteration starts
 	 * @param pFunc Function to recurse
 	 * @param Argument Argument for pFunc of type T
 	 * @throws PSERROR Depends on what pFunc might throw. PSERROR is standard.
 	 *			Itself doesn't throw anything.
 	*/
 	static void RecurseObject(int RR, IGUIObject* pObject, void_Object_pFunction_argT pFunc, const T& Argument)
 	{
 		// TODO Gee: Don't run this for the base object.
 		if (CheckIfRestricted(RR, pObject))
 			return;
 
 		(pObject->*pFunc)(Argument);
 
 		// Iterate children
 		for (IGUIObject* const& obj : *pObject)
 			RecurseObject(RR, obj, pFunc, Argument);
 	}
 
 	/**
 	 * Argument is reference.
 	 *
 	 * @see RecurseObject()
 	 */
 	static void RecurseObject(int RR, IGUIObject* pObject, void_Object_pFunction_argRefT pFunc, T& Argument)
 	{
 		if (CheckIfRestricted(RR, pObject))
 			return;
 
 		(pObject->*pFunc)(Argument);
 
 		// Iterate children
 		for (IGUIObject* const& obj : *pObject)
 			RecurseObject(RR, obj, pFunc, Argument);
 	}
 
 	static void RecurseObject(int RR, IGUIObject* pObject, void_Object_pFunction_argTJS pFunc, const T& Argument, JS::HandleValueArray paramData)
 	{
 		if (CheckIfRestricted(RR, pObject))
 			return;
 
 		(pObject->*pFunc)(Argument, paramData);
 
 		// Iterate children
 		for (IGUIObject* const& obj : *pObject)
 			RecurseObject(RR, obj, pFunc, Argument, paramData);
 	}
 
 	/**
 	 * With no argument.
 	 *
 	 * @see RecurseObject()
 	 */
 	static void RecurseObject(int RR, IGUIObject* pObject, void_Object_pFunction pFunc)
 	{
 		if (CheckIfRestricted(RR, pObject))
 			return;
 
 		(pObject->*pFunc)();
 
 		// Iterate children
 		for (IGUIObject* const& obj : *pObject)
 			RecurseObject(RR, obj, pFunc);
 	}
 
 private:
 	/**
 	 * Checks restrictions for the iteration, for instance if
 	 * you tell the recursor to avoid all hidden objects, it
 	 * will, and this function checks a certain object's
 	 * restriction values.
 	 *
 	 * @param RR What kind of restriction, for instance hidden or disabled
 	 * @param pObject Object
 	 * @return true if restricted
 	 */
 	static bool CheckIfRestricted(int RR, IGUIObject* pObject)
 	{
 		// Statically initialise some strings, so we don't have to do
 		// lots of allocation every time this function is called
 		static const CStr strHidden("hidden");
 		static const CStr strEnabled("enabled");
 		static const CStr strGhost("ghost");
 
 		if (RR & GUIRR_HIDDEN)
 		{
 			bool hidden = true;
 			GUI<bool>::GetSetting(pObject, strHidden, hidden);
 
 			if (hidden)
 				return true;
 		}
 		if (RR & GUIRR_DISABLED)
 		{
 			bool enabled = false;
 			GUI<bool>::GetSetting(pObject, strEnabled, enabled);
 
 			if (!enabled)
 				return true;
 		}
 		if (RR & GUIRR_GHOST)
 		{
 			bool ghost = true;
 			GUI<bool>::GetSetting(pObject, strGhost, ghost);
 
 			if (ghost)
 				return true;
 		}
 
 		// false means not restricted
 		return false;
 	}
 };
 
 #endif // INCLUDED_GUIUTIL
Index: ps/trunk/source/gui/IGUIObject.cpp
===================================================================
--- ps/trunk/source/gui/IGUIObject.cpp	(revision 22562)
+++ ps/trunk/source/gui/IGUIObject.cpp	(revision 22563)
@@ -1,551 +1,557 @@
 /* Copyright (C) 2019 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 "GUI.h"
 
 #include "gui/scripting/JSInterface_GUITypes.h"
 #include "gui/scripting/JSInterface_IGUIObject.h"
 
 #include "ps/GameSetup/Config.h"
 #include "ps/CLogger.h"
 #include "ps/Profile.h"
 #include "scriptinterface/ScriptInterface.h"
 
 
 IGUIObject::IGUIObject()
 	: m_pGUI(NULL), m_pParent(NULL), m_MouseHovering(false), m_LastClickTime()
 {
 	AddSetting(GUIST_bool,			"enabled");
 	AddSetting(GUIST_bool,			"hidden");
 	AddSetting(GUIST_CClientArea,	"size");
 	AddSetting(GUIST_CStr,			"style");
 	AddSetting(GUIST_CStr,			"hotkey");
 	AddSetting(GUIST_float,			"z");
 	AddSetting(GUIST_bool,			"absolute");
 	AddSetting(GUIST_bool,			"ghost");
 	AddSetting(GUIST_float,			"aspectratio");
 	AddSetting(GUIST_CStrW,			"tooltip");
 	AddSetting(GUIST_CStr,			"tooltip_style");
 
 	// Setup important defaults
 	GUI<bool>::SetSetting(this, "hidden", false);
 	GUI<bool>::SetSetting(this, "ghost", false);
 	GUI<bool>::SetSetting(this, "enabled", true);
 	GUI<bool>::SetSetting(this, "absolute", true);
 }
 
 IGUIObject::~IGUIObject()
 {
 	for (const std::pair<CStr, SGUISetting>& p : m_Settings)
 		switch (p.second.m_Type)
 		{
 			// delete() needs to know the type of the variable - never delete a void*
 #define TYPE(t) case GUIST_##t: delete (t*)p.second.m_pSetting; break;
 #include "GUItypes.h"
 #undef TYPE
 		default:
 			debug_warn(L"Invalid setting type");
 		}
 
 	if (m_pGUI)
 		JS_RemoveExtraGCRootsTracer(m_pGUI->GetScriptInterface()->GetJSRuntime(), Trace, this);
 }
 
 //-------------------------------------------------------------------
 //  Functions
 //-------------------------------------------------------------------
 void IGUIObject::SetGUI(CGUI* const& pGUI)
 {
 	if (!m_pGUI)
 		JS_AddExtraGCRootsTracer(pGUI->GetScriptInterface()->GetJSRuntime(), Trace, this);
 	m_pGUI = pGUI;
 }
 
 void IGUIObject::AddChild(IGUIObject* pChild)
 {
 //	ENSURE(pChild);
 
 	pChild->SetParent(this);
 
 	m_Children.push_back(pChild);
 
 	// If this (not the child) object is already attached
 	//  to a CGUI, it pGUI pointer will be non-null.
 	//  This will mean we'll have to check if we're using
 	//  names already used.
 	if (pChild->GetGUI())
 	{
 		try
 		{
 			// Atomic function, if it fails it won't
 			//  have changed anything
 			//UpdateObjects();
 			pChild->GetGUI()->UpdateObjects();
 		}
 		catch (PSERROR_GUI&)
 		{
 			// If anything went wrong, reverse what we did and throw
 			//  an exception telling it never added a child
 			m_Children.erase(m_Children.end()-1);
 
 			throw;
 		}
 	}
 	// else do nothing
 }
 
 void IGUIObject::AddToPointersMap(map_pObjects& ObjectMap)
 {
 	// Just don't do anything about the top node
 	if (m_pParent == NULL)
 		return;
 
 	// Now actually add this one
 	//  notice we won't add it if it's doesn't have any parent
 	//  (i.e. being the base object)
 	if (m_Name.empty())
 	{
 		throw PSERROR_GUI_ObjectNeedsName();
 	}
 	if (ObjectMap.count(m_Name) > 0)
 	{
 		throw PSERROR_GUI_NameAmbiguity(m_Name.c_str());
 	}
 	else
 	{
 		ObjectMap[m_Name] = this;
 	}
 }
 
 void IGUIObject::Destroy()
 {
 	// Is there anything besides the children to destroy?
 }
 
 void IGUIObject::AddSetting(const EGUISettingType& Type, const CStr& Name)
 {
 	// Is name already taken?
 	if (m_Settings.count(Name) >= 1)
 		return;
 
 	// Construct, and set type
 	m_Settings[Name].m_Type = Type;
 
 	switch (Type)
 	{
 #define TYPE(type) \
 	case GUIST_##type: \
 		m_Settings[Name].m_pSetting = new type(); \
 		break;
 
 		// Construct the setting.
 		#include "GUItypes.h"
 
 #undef TYPE
 
 	default:
 		debug_warn(L"IGUIObject::AddSetting failed, type not recognized!");
 		break;
 	}
 }
 
 
 bool IGUIObject::MouseOver()
 {
 	if (!GetGUI())
 		throw PSERROR_GUI_OperationNeedsGUIObject();
 
 	return m_CachedActualSize.PointInside(GetMousePos());
 }
 
 bool IGUIObject::MouseOverIcon()
 {
 	return false;
 }
 
 CPos IGUIObject::GetMousePos() const
 {
 	if (GetGUI())
 		return GetGUI()->m_MousePos;
 
 	return CPos();
 }
 
 void IGUIObject::UpdateMouseOver(IGUIObject* const& pMouseOver)
 {
 	if (pMouseOver == this)
 	{
 		if (!m_MouseHovering)
 			SendEvent(GUIM_MOUSE_ENTER, "mouseenter");
 
 		m_MouseHovering = true;
 
 		SendEvent(GUIM_MOUSE_OVER, "mousemove");
 	}
 	else
 	{
 		if (m_MouseHovering)
 		{
 			m_MouseHovering = false;
 			SendEvent(GUIM_MOUSE_LEAVE, "mouseleave");
 		}
 	}
 }
 
 bool IGUIObject::SettingExists(const CStr& Setting) const
 {
 	// Because GetOffsets will direct dynamically defined
 	//  classes with polymorphism to respective ms_SettingsInfo
 	//  we need to make no further updates on this function
 	//  in derived classes.
 	//return (GetSettingsInfo().count(Setting) >= 1);
 	return (m_Settings.count(Setting) >= 1);
 }
 
 PSRETURN IGUIObject::SetSetting(const CStr& Setting, const CStrW& Value, const bool& SkipMessage)
 {
 	if (!SettingExists(Setting))
 		return PSRETURN_GUI_InvalidSetting;
 
 	SGUISetting set = m_Settings[Setting];
 
 #define TYPE(type) \
 	else if (set.m_Type == GUIST_##type) \
 	{ \
 		type _Value; \
 		if (!GUI<type>::ParseString(Value, _Value)) \
 			return PSRETURN_GUI_UnableToParse; \
 		GUI<type>::SetSetting(this, Setting, _Value, SkipMessage); \
 	}
 
 	if (0)
 		;
 #include "GUItypes.h"
 #undef TYPE
 	else
 	{
 		// Why does it always fail?
 		//return PS_FAIL;
 		return LogInvalidSettings(Setting);
 	}
 	return PSRETURN_OK;
 }
 
 
 
 PSRETURN IGUIObject::GetSettingType(const CStr& Setting, EGUISettingType& Type) const
 {
 	if (!SettingExists(Setting))
 		return LogInvalidSettings(Setting);
 
 	if (m_Settings.find(Setting) == m_Settings.end())
 		return LogInvalidSettings(Setting);
 
 	Type = m_Settings.find(Setting)->second.m_Type;
 
 	return PSRETURN_OK;
 }
 
 
 void IGUIObject::ChooseMouseOverAndClosest(IGUIObject*& pObject)
 {
 	if (!MouseOver())
 		return;
 
 	// Check if we've got competition at all
 	if (pObject == NULL)
 	{
 		pObject = this;
 		return;
 	}
 
 	// Or if it's closer
 	if (GetBufferedZ() >= pObject->GetBufferedZ())
 	{
 		pObject = this;
 		return;
 	}
 }
 
 IGUIObject* IGUIObject::GetParent() const
 {
 	// Important, we're not using GetParent() for these
 	//  checks, that could screw it up
 	if (m_pParent)
 	{
 		if (m_pParent->m_pParent == NULL)
 			return NULL;
 	}
 
 	return m_pParent;
 }
 
+void IGUIObject::ResetStates()
+{
+	// Notify the gui that we aren't hovered anymore
+	UpdateMouseOver(nullptr);
+}
+
 void IGUIObject::UpdateCachedSize()
 {
 	bool absolute;
 	GUI<bool>::GetSetting(this, "absolute", absolute);
 
 	float aspectratio = 0.f;
 	GUI<float>::GetSetting(this, "aspectratio", aspectratio);
 
 	CClientArea ca;
 	GUI<CClientArea>::GetSetting(this, "size", ca);
 
 	// If absolute="false" and the object has got a parent,
 	//  use its cached size instead of the screen. Notice
 	//  it must have just been cached for it to work.
 	if (absolute == false && m_pParent && !IsRootObject())
 		m_CachedActualSize = ca.GetClientArea(m_pParent->m_CachedActualSize);
 	else
 		m_CachedActualSize = ca.GetClientArea(CRect(0.f, 0.f, g_xres / g_GuiScale, g_yres / g_GuiScale));
 
 	// In a few cases, GUI objects have to resize to fill the screen
 	// but maintain a constant aspect ratio.
 	// Adjust the size to be the max possible, centered in the original size:
 	if (aspectratio)
 	{
 		if (m_CachedActualSize.GetWidth() > m_CachedActualSize.GetHeight()*aspectratio)
 		{
 			float delta = m_CachedActualSize.GetWidth() - m_CachedActualSize.GetHeight()*aspectratio;
 			m_CachedActualSize.left += delta/2.f;
 			m_CachedActualSize.right -= delta/2.f;
 		}
 		else
 		{
 			float delta = m_CachedActualSize.GetHeight() - m_CachedActualSize.GetWidth()/aspectratio;
 			m_CachedActualSize.bottom -= delta/2.f;
 			m_CachedActualSize.top += delta/2.f;
 		}
 	}
 }
 
 void IGUIObject::LoadStyle(CGUI& GUIinstance, const CStr& StyleName)
 {
 	// Fetch style
 	if (GUIinstance.m_Styles.count(StyleName) == 1)
 	{
 		LoadStyle(GUIinstance.m_Styles[StyleName]);
 	}
 	else
 	{
 		debug_warn(L"IGUIObject::LoadStyle failed");
 	}
 }
 
 void IGUIObject::LoadStyle(const SGUIStyle& Style)
 {
 	// Iterate settings, it won't be able to set them all probably, but that doesn't matter
 	for (const std::pair<CStr, CStrW>& p : Style.m_SettingsDefaults)
 	{
 		// Try set setting in object
 		SetSetting(p.first, p.second);
 
 		// It doesn't matter if it fail, it's not suppose to be able to set every setting.
 		//  since it's generic.
 
 		// The beauty with styles is that it can contain more settings
 		//  than exists for the objects using it. So if the SetSetting
 		//  fails, don't care.
 	}
 }
 
 float IGUIObject::GetBufferedZ() const
 {
 	bool absolute;
 	GUI<bool>::GetSetting(this, "absolute", absolute);
 
 	float Z;
 	GUI<float>::GetSetting(this, "z", Z);
 
 	if (absolute)
 		return Z;
 	else
 	{
 		if (GetParent())
 			return GetParent()->GetBufferedZ() + Z;
 		else
 		{
 			// In philosophy, a parentless object shouldn't be able to have a relative sizing,
 			//  but we'll accept it so that absolute can be used as default without a complaint.
 			//  Also, you could consider those objects children to the screen resolution.
 			return Z;
 		}
 	}
 }
 
 void IGUIObject::RegisterScriptHandler(const CStr& Action, const CStr& Code, CGUI* pGUI)
 {
 	if(!GetGUI())
 		throw PSERROR_GUI_OperationNeedsGUIObject();
 
 	JSContext* cx = pGUI->GetScriptInterface()->GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedValue globalVal(cx, pGUI->GetGlobalObject());
 	JS::RootedObject globalObj(cx, &globalVal.toObject());
 
 	const int paramCount = 1;
 	const char* paramNames[paramCount] = { "mouse" };
 
 	// Location to report errors from
 	CStr CodeName = GetName()+" "+Action;
 
 	// Generate a unique name
 	static int x = 0;
 	char buf[64];
 	sprintf_s(buf, ARRAY_SIZE(buf), "__eventhandler%d (%s)", x++, Action.c_str());
 
 	JS::CompileOptions options(cx);
 	options.setFileAndLine(CodeName.c_str(), 0);
 	options.setCompileAndGo(true);
 
 	JS::RootedFunction func(cx);
 	JS::AutoObjectVector emptyScopeChain(cx);
 	if (!JS::CompileFunction(cx, emptyScopeChain, options, buf, paramCount, paramNames, Code.c_str(), Code.length(), &func))
 	{
 		LOGERROR("RegisterScriptHandler: Failed to compile the script for %s", Action.c_str());
 		return;
 	}
 
 	JS::RootedObject funcObj(cx, JS_GetFunctionObject(func));
 	SetScriptHandler(Action, funcObj);
 }
 
 void IGUIObject::SetScriptHandler(const CStr& Action, JS::HandleObject Function)
 {
 	// m_ScriptHandlers is only rooted after SetGUI() has been called (which sets up the GC trace callbacks),
 	// so we can't safely store objects in it if the GUI hasn't been set yet.
 	ENSURE(m_pGUI && "A GUI must be associated with the GUIObject before adding ScriptHandlers!");
 	m_ScriptHandlers[Action] = JS::Heap<JSObject*>(Function);
 }
 
 InReaction IGUIObject::SendEvent(EGUIMessageType type, const CStr& EventName)
 {
 	PROFILE2_EVENT("gui event");
 	PROFILE2_ATTR("type: %s", EventName.c_str());
 	PROFILE2_ATTR("object: %s", m_Name.c_str());
 
 	SGUIMessage msg(type);
 	HandleMessage(msg);
 
 	ScriptEvent(EventName);
 
 	return (msg.skipped ? IN_PASS : IN_HANDLED);
 }
 
 void IGUIObject::ScriptEvent(const CStr& Action)
 {
 	std::map<CStr, JS::Heap<JSObject*> >::iterator it = m_ScriptHandlers.find(Action);
 	if (it == m_ScriptHandlers.end())
 		return;
 
 	JSContext* cx = m_pGUI->GetScriptInterface()->GetContext();
 	JSAutoRequest rq(cx);
 
 	// Set up the 'mouse' parameter
 	JS::RootedValue mouse(cx);
 
 	m_pGUI->GetScriptInterface()->CreateObject(
 		&mouse,
 		"x", m_pGUI->m_MousePos.x,
 		"y", m_pGUI->m_MousePos.y,
 		"buttons", m_pGUI->m_MouseButtons);
 
 	JS::AutoValueVector paramData(cx);
 	paramData.append(mouse);
 	JS::RootedObject obj(cx, GetJSObject());
 	JS::RootedValue handlerVal(cx, JS::ObjectValue(*it->second));
 	JS::RootedValue result(cx);
 	bool ok = JS_CallFunctionValue(cx, obj, handlerVal, paramData, &result);
 	if (!ok)
 	{
 		// We have no way to propagate the script exception, so just ignore it
 		// and hope the caller checks JS_IsExceptionPending
 	}
 }
 
 void IGUIObject::ScriptEvent(const CStr& Action, JS::HandleValueArray paramData)
 {
 	std::map<CStr, JS::Heap<JSObject*> >::iterator it = m_ScriptHandlers.find(Action);
 	if (it == m_ScriptHandlers.end())
 		return;
 
 	JSContext* cx = m_pGUI->GetScriptInterface()->GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedObject obj(cx, GetJSObject());
 	JS::RootedValue handlerVal(cx, JS::ObjectValue(*it->second));
 	JS::RootedValue result(cx);
 
 	if (!JS_CallFunctionValue(cx, obj, handlerVal, paramData, &result))
 		JS_ReportError(cx, "Errors executing script action \"%s\"", Action.c_str());
 }
 
 JSObject* IGUIObject::GetJSObject()
 {
 	JSContext* cx = m_pGUI->GetScriptInterface()->GetContext();
 	JSAutoRequest rq(cx);
 	// Cache the object when somebody first asks for it, because otherwise
 	// we end up doing far too much object allocation. TODO: Would be nice to
 	// not have these objects hang around forever using up memory, though.
 	if (!m_JSObject.initialized())
 	{
 		m_JSObject.init(cx, m_pGUI->GetScriptInterface()->CreateCustomObject("GUIObject"));
 		JS_SetPrivate(m_JSObject.get(), this);
 	}
 	return m_JSObject.get();
 }
 
 CStr IGUIObject::GetPresentableName() const
 {
 	// __internal(), must be at least 13 letters to be able to be
 	//  an internal name
 	if (m_Name.length() <= 12)
 		return m_Name;
 
 	if (m_Name.substr(0, 10) == "__internal")
 		return CStr("[unnamed object]");
 	else
 		return m_Name;
 }
 
 void IGUIObject::SetFocus()
 {
 	GetGUI()->m_FocusedObject = this;
 }
 
 bool IGUIObject::IsFocused() const
 {
 	return GetGUI()->m_FocusedObject == this;
 }
 
 bool IGUIObject::IsRootObject() const
 {
 	return GetGUI() != 0 && m_pParent == GetGUI()->m_BaseObject;
 }
 
 void IGUIObject::TraceMember(JSTracer* trc)
 {
 	for (std::pair<const CStr, JS::Heap<JSObject*>>& handler : m_ScriptHandlers)
 		JS_CallObjectTracer(trc, &handler.second, "IGUIObject::m_ScriptHandlers");
 }
 
 PSRETURN IGUIObject::LogInvalidSettings(const CStr8& Setting) const
 {
 	LOGWARNING("IGUIObject: setting %s was not found on an object", Setting.c_str());
 	return PSRETURN_GUI_InvalidSetting;
 }
Index: ps/trunk/source/gui/IGUIObject.h
===================================================================
--- ps/trunk/source/gui/IGUIObject.h	(revision 22562)
+++ ps/trunk/source/gui/IGUIObject.h	(revision 22563)
@@ -1,530 +1,526 @@
 /* Copyright (C) 2019 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/>.
  */
 
 /*
  * The base class of an object.
  * All objects are derived from this class.
  * It's an abstract data type, so it can't be used per se.
  * Also contains a Dummy object which is used for completely blank objects.
  */
 
 #ifndef INCLUDED_IGUIOBJECT
 #define INCLUDED_IGUIOBJECT
 
 #include "GUIbase.h"
 #include "GUItext.h"
 
 #include "gui/scripting/JSInterface_IGUIObject.h"
 #include "lib/input.h" // just for IN_PASS
 #include "ps/XML/Xeromyces.h"
 
 #include <string>
 #include <vector>
 
 struct SGUISetting;
 struct SGUIStyle;
 class CGUI;
 
 class JSObject;
 
 ERROR_TYPE(GUI, UnableToParse);
 
 /**
  * Setting Type
  * @see SGUISetting
  *
  * For use of later macros, all names should be GUIST_ followed
  * by the code name (case sensitive!).
  */
 #define TYPE(T) GUIST_##T,
 enum EGUISettingType
 {
 	#include "GUItypes.h"
 };
 #undef TYPE
 
 /**
  * A GUI Setting is anything that can be inputted from XML as
  * \<object\>-attributes (with exceptions). For instance:
  * \<object style="null"\>
  *
  * "style" will be a SGUISetting.
  */
 struct SGUISetting
 {
 	SGUISetting() : m_pSetting(NULL) {}
 
 	void				*m_pSetting;
 	EGUISettingType		m_Type;
 };
 
 /**
  * GUI object such as a button or an input-box.
  * Abstract data type !
  */
 class IGUIObject
 {
 	friend class CGUI;
-	friend class CInternalCGUIAccessorBase;
 	friend class IGUIScrollBar;
 	friend class GUITooltip;
 
 	// Allow getProperty to access things like GetParent()
 	friend bool JSI_IGUIObject::getProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::MutableHandleValue vp);
 	friend bool JSI_IGUIObject::setProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id, bool UNUSED(strict), JS::MutableHandleValue vp);
 	friend bool JSI_IGUIObject::getComputedSize(JSContext* cx, uint argc, JS::Value* vp);
 	friend bool JSI_IGUIObject::getTextSize(JSContext* cx, uint argc, JS::Value* vp);
 
 public:
 	IGUIObject();
 	virtual ~IGUIObject();
 
 	/**
 	 * Checks if mouse is hovering this object.
      * The mouse position is cached in CGUI.
 	 *
 	 * This function checks if the mouse is hovering the
 	 * rectangle that the base setting "size" makes.
 	 * Although it is virtual, so one could derive
 	 * an object from CButton, which changes only this
 	 * to checking the circle that "size" makes.
 	 *
 	 * @return true if mouse is hovering
 	 */
 	virtual bool MouseOver();
 
 	/**
 	 * Test if mouse position is over an icon
 	 */
 	virtual bool MouseOverIcon();
 
 	//--------------------------------------------------------
 	/** @name Leaf Functions */
 	//--------------------------------------------------------
 	//@{
 
 	/// Get object name, name is unique
 	const CStr& GetName() const { return m_Name; }
 
 	/// Get object name
 	void SetName(const CStr& Name) { m_Name = Name; }
 
 	// Get Presentable name.
 	//  Will change all internally set names to something like "<unnamed object>"
 	CStr GetPresentableName() const;
 
 	/**
 	 * Adds object and its children to the map, it's name being the
 	 * first part, and the second being itself.
 	 *
 	 * @param ObjectMap Adds this to the map_pObjects.
 	 *
 	 * @throws PSERROR_GUI_ObjectNeedsName Name is missing
 	 * @throws PSERROR_GUI_NameAmbiguity Name is already taken
 	 */
 	void AddToPointersMap(map_pObjects& ObjectMap);
 
 	/**
 	 * Notice nothing will be returned or thrown if the child hasn't
 	 * been inputted into the GUI yet. This is because that's were
 	 * all is checked. Now we're just linking two objects, but
 	 * it's when we're inputting them into the GUI we'll check
 	 * validity! Notice also when adding it to the GUI this function
 	 * will inevitably have been called by CGUI::AddObject which
 	 * will catch the throw and return the error code.
 	 * i.e. The user will never put in the situation wherein a throw
 	 * must be caught, the GUI's internal error handling will be
 	 * completely transparent to the interfacially sequential model.
 	 *
 	 * @param pChild Child to add
 	 *
 	 * @throws PSERROR_GUI from CGUI::UpdateObjects().
 	 */
 	void AddChild(IGUIObject* pChild);
 
 	//@}
 	//--------------------------------------------------------
 	/** @name Iterate
 	 * Used to iterate over all children of this object.
 	 */
 	//--------------------------------------------------------
 	//@{
 
 	vector_pObjects::iterator begin() { return m_Children.begin(); }
 	vector_pObjects::iterator end() { return m_Children.end(); }
 
 	//@}
 	//--------------------------------------------------------
 	/** @name Settings Management */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Checks if settings exists, only available for derived
 	 * classes that has this set up, that's why the base
 	 * class just returns false
 	 *
 	 * @param Setting setting name
 	 * @return True if settings exist.
 	 */
 	bool SettingExists(const CStr& Setting) const;
 
 	/**
 	 * All sizes are relative to resolution, and the calculation
 	 * is not wanted in real time, therefore it is cached, update
 	 * the cached size with this function.
 	 */
 	virtual void UpdateCachedSize();
 
 	/**
+	 * Reset internal state of this object.
+	 */
+	virtual void ResetStates();
+
+	/**
 	 * Set a setting by string, regardless of what type it is.
 	 *
 	 * example a CRect(10,10,20,20) would be "10 10 20 20"
 	 *
 	 * @param Setting Setting by name
 	 * @param Value Value to set to
 	 * @param SkipMessage Does not send a GUIM_SETTINGS_UPDATED if true
 	 *
 	 * @return PSRETURN (PSRETURN_OK if successful)
 	 */
 	PSRETURN SetSetting(const CStr& Setting, const CStrW& Value, const bool& SkipMessage = false);
 
 	/**
 	 * Retrieves the type of a named setting.
 	 *
 	 * @param Setting Setting by name
 	 * @param Type Stores an EGUISettingType
 	 * @return PSRETURN (PSRETURN_OK if successful)
 	 */
 	PSRETURN GetSettingType(const CStr& Setting, EGUISettingType& Type) const;
 
 	/**
 	 * Set the script handler for a particular object-specific action
 	 *
 	 * @param Action Name of action
 	 * @param Code Javascript code to execute when the action occurs
 	 * @param pGUI GUI instance to associate the script with
 	 */
 	void RegisterScriptHandler(const CStr& Action, const CStr& Code, CGUI* pGUI);
 
 	/**
 	 * Retrieves the JSObject representing this GUI object.
 	 */
 	JSObject* GetJSObject();
 
 	//@}
 protected:
 	//--------------------------------------------------------
 	/** @name Called by CGUI and friends
 	 *
 	 * Methods that the CGUI will call using
 	 * its friendship, these should not
 	 * be called by user.
 	 * These functions' security are a lot
 	 * what constitutes the GUI's
 	 */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Add a setting to m_Settings
 	 *
 	 * @param Type Setting type
 	 * @param Name Setting reference name
 	 */
 	void AddSetting(const EGUISettingType& Type, const CStr& Name);
 
 	/**
 	 * Calls Destroy on all children, and deallocates all memory.
 	 * MEGA TODO Should it destroy it's children?
 	 */
 	virtual void Destroy();
 
 public:
 	/**
      * This function is called with different messages
 	 * for instance when the mouse enters the object.
 	 *
 	 * @param Message GUI Message
 	 */
 	virtual void HandleMessage(SGUIMessage& UNUSED(Message)) {}
 
 protected:
 	/**
 	 * Draws the object.
 	 *
 	 * @throws	PSERROR if any. But this will mostlikely be
 	 *			very rare since if an object is drawn unsuccessfully
 	 *			it'll probably only output in the Error log, and not
 	 *			disrupt the whole GUI drawing.
 	 */
 	virtual void Draw() = 0;
 
 	/**
 	 * Some objects need to handle the SDL_Event_ manually.
 	 * For instance the input box.
 	 *
 	 * Only the object with focus will have this function called.
 	 *
 	 * Returns either IN_PASS or IN_HANDLED. If IN_HANDLED, then
 	 * the key won't be passed on and processed by other handlers.
 	 * This is used for keys that the GUI uses.
 	 */
 	virtual InReaction ManuallyHandleEvent(const SDL_Event_* UNUSED(ev)) { return IN_PASS; }
 
 	/**
 	 * Loads a style.
 	 *
 	 * @param GUIinstance Reference to the GUI
 	 * @param StyleName Style by name
 	 */
 	void LoadStyle(CGUI& GUIinstance, const CStr& StyleName);
 
 	/**
 	 * Loads a style.
 	 *
 	 * @param Style The style object.
 	 */
 	void LoadStyle(const SGUIStyle& Style);
 
 	/**
 	 * Returns not the Z value, but the actual buffered Z value, i.e. if it's
 	 * defined relative, then it will check its parent's Z value and add
 	 * the relativity.
 	 *
 	 * @return Actual Z value on the screen.
 	 */
 	virtual float GetBufferedZ() const;
 
 	void SetGUI(CGUI* const& pGUI);
 
 	/**
 	 * Set parent of this object
 	 */
 	void SetParent(IGUIObject* pParent) { m_pParent = pParent; }
 
-	/**
-	 * Reset internal state of this object
-	 */
-	virtual void ResetStates()
-	{
-		// Notify the gui that we aren't hovered anymore
-		UpdateMouseOver(NULL);
-	}
-
 public:
+
 	CGUI* GetGUI() { return m_pGUI; }
 	const CGUI* GetGUI() const { return m_pGUI; }
 
 	/**
 	 * Take focus!
 	 */
 	void SetFocus();
 
 protected:
 	/**
 	 * Check if object is focused.
 	 */
 	bool IsFocused() const;
 
 	/**
 	 * <b>NOTE!</b> This will not just return m_pParent, when that is
 	 * need use it! There is one exception to it, when the parent is
 	 * the top-node (the object that isn't a real object), this
 	 * will return NULL, so that the top-node's children are
 	 * seemingly parentless.
 	 *
 	 * @return Pointer to parent
 	 */
 	IGUIObject* GetParent() const;
 
 	/**
 	 * Get Mouse from CGUI.
 	 */
 	CPos GetMousePos() const;
 
 	/**
 	 * Handle additional children to the \<object\>-tag. In IGUIObject, this function does
 	 * nothing. In CList and CDropDown, it handles the \<item\>, used to build the data.
 	 *
 	 * Returning false means the object doesn't recognize the child. Should be reported.
 	 * Notice 'false' is default, because an object not using this function, should not
 	 * have any additional children (and this function should never be called).
 	 */
 	virtual bool HandleAdditionalChildren(const XMBElement& UNUSED(child), CXeromyces* UNUSED(pFile))
 	{
 		return false;
 	}
 
 	/**
 	 * Cached size, real size m_Size is actually dependent on resolution
 	 * and can have different *real* outcomes, this is the real outcome
 	 * cached to avoid slow calculations in real time.
 	 */
 	CRect m_CachedActualSize;
 
 	/**
 	 * Send event to this GUI object (HandleMessage and ScriptEvent)
 	 *
 	 * @param type Type of GUI message to be handled
 	 * @param EventName String representation of event name
 	 * @return IN_HANDLED if event was handled, or IN_PASS if skipped
 	 */
 	InReaction SendEvent(EGUIMessageType type, const CStr& EventName);
 
 	/**
 	 * Execute the script for a particular action.
 	 * Does nothing if no script has been registered for that action.
 	 * The mouse coordinates will be passed as the first argument.
 	 *
 	 * @param Action Name of action
 	 */
 	void ScriptEvent(const CStr& Action);
 
 	/**
 	 * Execute the script for a particular action.
 	 * Does nothing if no script has been registered for that action.
 	 *
 	 * @param Action Name of action
 	 * @param paramData JS::HandleValueArray arguments to pass to the event.
 	 */
 	void ScriptEvent(const CStr& Action, JS::HandleValueArray paramData);
 
 	void SetScriptHandler(const CStr& Action, JS::HandleObject Function);
 
 	/**
 	 * Inputes the object that is currently hovered, this function
 	 * updates this object accordingly (i.e. if it's the object
 	 * being inputted one thing happens, and not, another).
 	 *
 	 * @param pMouseOver	Object that is currently hovered,
 	 *						can OF COURSE be NULL too!
 	 */
 	void UpdateMouseOver(IGUIObject* const& pMouseOver);
 
 	//@}
 private:
 	//--------------------------------------------------------
 	/** @name Internal functions */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Inputs a reference pointer, checks if the new inputted object
 	 * if hovered, if so, then check if this's Z value is greater
 	 * than the inputted object... If so then the object is closer
 	 * and we'll replace the pointer with this.
 	 * Also Notice input can be NULL, which means the Z value demand
 	 *  is out. NOTICE you can't input NULL as const so you'll have
 	 * to set an object to NULL.
 	 *
 	 * @param pObject	Object pointer, can be either the old one, or
 	 *					the new one.
 	 */
 	void ChooseMouseOverAndClosest(IGUIObject*& pObject);
 
 	// Is the object a Root object, in philosophy, this means it
 	//  has got no parent, and technically, it's got the m_BaseObject
 	//  as parent.
 	bool IsRootObject() const;
 
 	/**
 	 * Logs an invalid setting search and returns the correct return result
 	 *
 	 * @return the error result
 	 */
 	PSRETURN LogInvalidSettings(const CStr8& Setting) const;
 
 	static void Trace(JSTracer* trc, void* data)
 	{
 		reinterpret_cast<IGUIObject*>(data)->TraceMember(trc);
 	}
 
 	void TraceMember(JSTracer* trc);
 
 	// Variables
 
 protected:
 	// Name of object
 	CStr									m_Name;
 
 	// Constructed on the heap, will be destroyed along with the the object
 	// TODO Gee: really the above?
 	vector_pObjects							m_Children;
 
 	// Pointer to parent
 	IGUIObject								*m_pParent;
 
 	//This represents the last click time for each mouse button
 	double m_LastClickTime[6];
 
 	/**
 	 * This is an array of true or false, each element is associated with
 	 * a string representing a setting. Number of elements is equal to
 	 * number of settings.
 	 *
 	 * A true means the setting has been manually set in the file when
 	 * read. This is important to know because I don't want to force
 	 * the user to include its \<styles\>-XML-files first, so somehow
 	 * the GUI needs to know which settings were set, and which is meant
 	 * to.
 	 */
 
 	// More variables
 
 	// Is mouse hovering the object? used with the function MouseOver()
 	bool									m_MouseHovering;
 
 	/**
 	 * Settings pool, all an object's settings are located here
 	 * If a derived object has got more settings that the base
 	 * settings, it's because they have a new version of the
 	 * function SetupSettings().
 	 *
 	 * @see SetupSettings()
 	 */
 	public:
 	std::map<CStr, SGUISetting>				m_Settings;
 
 private:
 	// An object can't function stand alone
 	CGUI									*m_pGUI;
 
 	// Internal storage for registered script handlers.
 	std::map<CStr, JS::Heap<JSObject*> >	m_ScriptHandlers;
 
 	// Cached JSObject representing this GUI object
 	JS::PersistentRootedObject				m_JSObject;
 };
 
 
 /**
  * Dummy object used primarily for the root object
  * or objects of type 'empty'
  */
 class CGUIDummyObject : public IGUIObject
 {
 	GUI_OBJECT(CGUIDummyObject)
 
 public:
 
 	virtual void Draw() {}
 	// Empty can never be hovered. It is only a category.
 	virtual bool MouseOver() { return false; }
 };
 
 #endif // INCLUDED_IGUIOBJECT
Index: ps/trunk/source/ps/Errors.cpp
===================================================================
--- ps/trunk/source/ps/Errors.cpp	(revision 22562)
+++ ps/trunk/source/ps/Errors.cpp	(revision 22563)
@@ -1,524 +1,514 @@
 // Auto-generated by errorlist.pl - do not edit.
 
 #include "precompiled.h"
 
 #include "Errors.h"
 
 class PSERROR_CVFSFile : public PSERROR { protected: PSERROR_CVFSFile(const char* msg); };
 class PSERROR_Deserialize : public PSERROR { protected: PSERROR_Deserialize(const char* msg); };
 class PSERROR_DllLoader : public PSERROR { protected: PSERROR_DllLoader(const char* msg); };
 class PSERROR_Error : public PSERROR { protected: PSERROR_Error(const char* msg); };
 class PSERROR_File : public PSERROR { protected: PSERROR_File(const char* msg); };
 class PSERROR_GUI : public PSERROR { protected: PSERROR_GUI(const char* msg); };
 class PSERROR_Game : public PSERROR { protected: PSERROR_Game(const char* msg); };
 class PSERROR_Scripting : public PSERROR { protected: PSERROR_Scripting(const char* msg); };
 class PSERROR_Serialize : public PSERROR { protected: PSERROR_Serialize(const char* msg); };
 class PSERROR_System : public PSERROR { protected: PSERROR_System(const char* msg); };
 class PSERROR_Xeromyces : public PSERROR { protected: PSERROR_Xeromyces(const char* msg); };
 
 class PSERROR_Game_World : public PSERROR_Game { protected: PSERROR_Game_World(const char* msg); };
 class PSERROR_Scripting_DefineType : public PSERROR_Scripting { protected: PSERROR_Scripting_DefineType(const char* msg); };
 class PSERROR_Scripting_LoadFile : public PSERROR_Scripting { protected: PSERROR_Scripting_LoadFile(const char* msg); };
 
 class PSERROR_CVFSFile_AlreadyLoaded : public PSERROR_CVFSFile { public: PSERROR_CVFSFile_AlreadyLoaded(); PSERROR_CVFSFile_AlreadyLoaded(const char* msg); PSRETURN getCode() const; };
 class PSERROR_CVFSFile_LoadFailed : public PSERROR_CVFSFile { public: PSERROR_CVFSFile_LoadFailed(); PSERROR_CVFSFile_LoadFailed(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Deserialize_InvalidCharInString : public PSERROR_Deserialize { public: PSERROR_Deserialize_InvalidCharInString(); PSERROR_Deserialize_InvalidCharInString(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Deserialize_OutOfBounds : public PSERROR_Deserialize { public: PSERROR_Deserialize_OutOfBounds(); PSERROR_Deserialize_OutOfBounds(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Deserialize_ReadFailed : public PSERROR_Deserialize { public: PSERROR_Deserialize_ReadFailed(); PSERROR_Deserialize_ReadFailed(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Deserialize_ScriptError : public PSERROR_Deserialize { public: PSERROR_Deserialize_ScriptError(); PSERROR_Deserialize_ScriptError(const char* msg); PSRETURN getCode() const; };
 class PSERROR_DllLoader_DllNotLoaded : public PSERROR_DllLoader { public: PSERROR_DllLoader_DllNotLoaded(); PSERROR_DllLoader_DllNotLoaded(const char* msg); PSRETURN getCode() const; };
 class PSERROR_DllLoader_SymbolNotFound : public PSERROR_DllLoader { public: PSERROR_DllLoader_SymbolNotFound(); PSERROR_DllLoader_SymbolNotFound(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Error_InvalidError : public PSERROR_Error { public: PSERROR_Error_InvalidError(); PSERROR_Error_InvalidError(const char* msg); PSRETURN getCode() const; };
 class PSERROR_File_InvalidType : public PSERROR_File { public: PSERROR_File_InvalidType(); PSERROR_File_InvalidType(const char* msg); PSRETURN getCode() const; };
 class PSERROR_File_InvalidVersion : public PSERROR_File { public: PSERROR_File_InvalidVersion(); PSERROR_File_InvalidVersion(const char* msg); PSRETURN getCode() const; };
 class PSERROR_File_OpenFailed : public PSERROR_File { public: PSERROR_File_OpenFailed(); PSERROR_File_OpenFailed(const char* msg); PSRETURN getCode() const; };
 class PSERROR_File_ReadFailed : public PSERROR_File { public: PSERROR_File_ReadFailed(); PSERROR_File_ReadFailed(const char* msg); PSRETURN getCode() const; };
 class PSERROR_File_UnexpectedEOF : public PSERROR_File { public: PSERROR_File_UnexpectedEOF(); PSERROR_File_UnexpectedEOF(const char* msg); PSRETURN getCode() const; };
 class PSERROR_File_WriteFailed : public PSERROR_File { public: PSERROR_File_WriteFailed(); PSERROR_File_WriteFailed(const char* msg); PSRETURN getCode() const; };
 class PSERROR_GUI_InvalidSetting : public PSERROR_GUI { public: PSERROR_GUI_InvalidSetting(); PSERROR_GUI_InvalidSetting(const char* msg); PSRETURN getCode() const; };
 class PSERROR_GUI_JSOpenFailed : public PSERROR_GUI { public: PSERROR_GUI_JSOpenFailed(); PSERROR_GUI_JSOpenFailed(const char* msg); PSRETURN getCode() const; };
 class PSERROR_GUI_NameAmbiguity : public PSERROR_GUI { public: PSERROR_GUI_NameAmbiguity(); PSERROR_GUI_NameAmbiguity(const char* msg); PSRETURN getCode() const; };
-class PSERROR_GUI_NullObjectProvided : public PSERROR_GUI { public: PSERROR_GUI_NullObjectProvided(); PSERROR_GUI_NullObjectProvided(const char* msg); PSRETURN getCode() const; };
 class PSERROR_GUI_ObjectNeedsName : public PSERROR_GUI { public: PSERROR_GUI_ObjectNeedsName(); PSERROR_GUI_ObjectNeedsName(const char* msg); PSRETURN getCode() const; };
 class PSERROR_GUI_OperationNeedsGUIObject : public PSERROR_GUI { public: PSERROR_GUI_OperationNeedsGUIObject(); PSERROR_GUI_OperationNeedsGUIObject(const char* msg); PSRETURN getCode() const; };
 class PSERROR_GUI_UnableToParse : public PSERROR_GUI { public: PSERROR_GUI_UnableToParse(); PSERROR_GUI_UnableToParse(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Game_World_MapLoadFailed : public PSERROR_Game_World { public: PSERROR_Game_World_MapLoadFailed(); PSERROR_Game_World_MapLoadFailed(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Scripting_CallFunctionFailed : public PSERROR_Scripting { public: PSERROR_Scripting_CallFunctionFailed(); PSERROR_Scripting_CallFunctionFailed(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Scripting_ConversionFailed : public PSERROR_Scripting { public: PSERROR_Scripting_ConversionFailed(); PSERROR_Scripting_ConversionFailed(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Scripting_CreateObjectFailed : public PSERROR_Scripting { public: PSERROR_Scripting_CreateObjectFailed(); PSERROR_Scripting_CreateObjectFailed(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Scripting_DefineConstantFailed : public PSERROR_Scripting { public: PSERROR_Scripting_DefineConstantFailed(); PSERROR_Scripting_DefineConstantFailed(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Scripting_DefineType_AlreadyExists : public PSERROR_Scripting_DefineType { public: PSERROR_Scripting_DefineType_AlreadyExists(); PSERROR_Scripting_DefineType_AlreadyExists(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Scripting_DefineType_CreationFailed : public PSERROR_Scripting_DefineType { public: PSERROR_Scripting_DefineType_CreationFailed(); PSERROR_Scripting_DefineType_CreationFailed(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Scripting_LoadFile_EvalErrors : public PSERROR_Scripting_LoadFile { public: PSERROR_Scripting_LoadFile_EvalErrors(); PSERROR_Scripting_LoadFile_EvalErrors(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Scripting_LoadFile_OpenFailed : public PSERROR_Scripting_LoadFile { public: PSERROR_Scripting_LoadFile_OpenFailed(); PSERROR_Scripting_LoadFile_OpenFailed(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Scripting_RegisterFunctionFailed : public PSERROR_Scripting { public: PSERROR_Scripting_RegisterFunctionFailed(); PSERROR_Scripting_RegisterFunctionFailed(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Scripting_SetupFailed : public PSERROR_Scripting { public: PSERROR_Scripting_SetupFailed(); PSERROR_Scripting_SetupFailed(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Scripting_TypeDoesNotExist : public PSERROR_Scripting { public: PSERROR_Scripting_TypeDoesNotExist(); PSERROR_Scripting_TypeDoesNotExist(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Serialize_InvalidCharInString : public PSERROR_Serialize { public: PSERROR_Serialize_InvalidCharInString(); PSERROR_Serialize_InvalidCharInString(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Serialize_InvalidScriptValue : public PSERROR_Serialize { public: PSERROR_Serialize_InvalidScriptValue(); PSERROR_Serialize_InvalidScriptValue(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Serialize_OutOfBounds : public PSERROR_Serialize { public: PSERROR_Serialize_OutOfBounds(); PSERROR_Serialize_OutOfBounds(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Serialize_ScriptError : public PSERROR_Serialize { public: PSERROR_Serialize_ScriptError(); PSERROR_Serialize_ScriptError(const char* msg); PSRETURN getCode() const; };
 class PSERROR_System_RequiredExtensionsMissing : public PSERROR_System { public: PSERROR_System_RequiredExtensionsMissing(); PSERROR_System_RequiredExtensionsMissing(const char* msg); PSRETURN getCode() const; };
 class PSERROR_System_SDLInitFailed : public PSERROR_System { public: PSERROR_System_SDLInitFailed(); PSERROR_System_SDLInitFailed(const char* msg); PSRETURN getCode() const; };
 class PSERROR_System_VmodeFailed : public PSERROR_System { public: PSERROR_System_VmodeFailed(); PSERROR_System_VmodeFailed(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Xeromyces_XMLOpenFailed : public PSERROR_Xeromyces { public: PSERROR_Xeromyces_XMLOpenFailed(); PSERROR_Xeromyces_XMLOpenFailed(const char* msg); PSRETURN getCode() const; };
 class PSERROR_Xeromyces_XMLParseError : public PSERROR_Xeromyces { public: PSERROR_Xeromyces_XMLParseError(); PSERROR_Xeromyces_XMLParseError(const char* msg); PSRETURN getCode() const; };
 
 extern const PSRETURN PSRETURN_CVFSFile_AlreadyLoaded = 0x01000001;
 extern const PSRETURN PSRETURN_CVFSFile_LoadFailed = 0x01000002;
 extern const PSRETURN PSRETURN_Deserialize_InvalidCharInString = 0x02000001;
 extern const PSRETURN PSRETURN_Deserialize_OutOfBounds = 0x02000002;
 extern const PSRETURN PSRETURN_Deserialize_ReadFailed = 0x02000003;
 extern const PSRETURN PSRETURN_Deserialize_ScriptError = 0x02000004;
 extern const PSRETURN PSRETURN_DllLoader_DllNotLoaded = 0x03000001;
 extern const PSRETURN PSRETURN_DllLoader_SymbolNotFound = 0x03000002;
 extern const PSRETURN PSRETURN_Error_InvalidError = 0x04000001;
 extern const PSRETURN PSRETURN_File_InvalidType = 0x05000001;
 extern const PSRETURN PSRETURN_File_InvalidVersion = 0x05000002;
 extern const PSRETURN PSRETURN_File_OpenFailed = 0x05000003;
 extern const PSRETURN PSRETURN_File_ReadFailed = 0x05000004;
 extern const PSRETURN PSRETURN_File_UnexpectedEOF = 0x05000005;
 extern const PSRETURN PSRETURN_File_WriteFailed = 0x05000006;
 extern const PSRETURN PSRETURN_GUI_InvalidSetting = 0x06000001;
 extern const PSRETURN PSRETURN_GUI_JSOpenFailed = 0x06000002;
 extern const PSRETURN PSRETURN_GUI_NameAmbiguity = 0x06000003;
-extern const PSRETURN PSRETURN_GUI_NullObjectProvided = 0x06000004;
-extern const PSRETURN PSRETURN_GUI_ObjectNeedsName = 0x06000005;
-extern const PSRETURN PSRETURN_GUI_OperationNeedsGUIObject = 0x06000006;
-extern const PSRETURN PSRETURN_GUI_UnableToParse = 0x06000007;
+extern const PSRETURN PSRETURN_GUI_ObjectNeedsName = 0x06000004;
+extern const PSRETURN PSRETURN_GUI_OperationNeedsGUIObject = 0x06000005;
+extern const PSRETURN PSRETURN_GUI_UnableToParse = 0x06000006;
 extern const PSRETURN PSRETURN_Game_World_MapLoadFailed = 0x07030001;
 extern const PSRETURN PSRETURN_Scripting_DefineType_AlreadyExists = 0x08010001;
 extern const PSRETURN PSRETURN_Scripting_DefineType_CreationFailed = 0x08010002;
 extern const PSRETURN PSRETURN_Scripting_LoadFile_EvalErrors = 0x08020001;
 extern const PSRETURN PSRETURN_Scripting_LoadFile_OpenFailed = 0x08020002;
 extern const PSRETURN PSRETURN_Scripting_CallFunctionFailed = 0x08000001;
 extern const PSRETURN PSRETURN_Scripting_ConversionFailed = 0x08000002;
 extern const PSRETURN PSRETURN_Scripting_CreateObjectFailed = 0x08000003;
 extern const PSRETURN PSRETURN_Scripting_DefineConstantFailed = 0x08000004;
 extern const PSRETURN PSRETURN_Scripting_RegisterFunctionFailed = 0x08000005;
 extern const PSRETURN PSRETURN_Scripting_SetupFailed = 0x08000006;
 extern const PSRETURN PSRETURN_Scripting_TypeDoesNotExist = 0x08000007;
 extern const PSRETURN PSRETURN_Serialize_InvalidCharInString = 0x09000001;
 extern const PSRETURN PSRETURN_Serialize_InvalidScriptValue = 0x09000002;
 extern const PSRETURN PSRETURN_Serialize_OutOfBounds = 0x09000003;
 extern const PSRETURN PSRETURN_Serialize_ScriptError = 0x09000004;
 extern const PSRETURN PSRETURN_System_RequiredExtensionsMissing = 0x0a000001;
 extern const PSRETURN PSRETURN_System_SDLInitFailed = 0x0a000002;
 extern const PSRETURN PSRETURN_System_VmodeFailed = 0x0a000003;
 extern const PSRETURN PSRETURN_Xeromyces_XMLOpenFailed = 0x0b000001;
 extern const PSRETURN PSRETURN_Xeromyces_XMLParseError = 0x0b000002;
 
 extern const PSRETURN MASK__PSRETURN_CVFSFile = 0xff000000;
 extern const PSRETURN CODE__PSRETURN_CVFSFile = 0x01000000;
 extern const PSRETURN MASK__PSRETURN_Deserialize = 0xff000000;
 extern const PSRETURN CODE__PSRETURN_Deserialize = 0x02000000;
 extern const PSRETURN MASK__PSRETURN_DllLoader = 0xff000000;
 extern const PSRETURN CODE__PSRETURN_DllLoader = 0x03000000;
 extern const PSRETURN MASK__PSRETURN_Error = 0xff000000;
 extern const PSRETURN CODE__PSRETURN_Error = 0x04000000;
 extern const PSRETURN MASK__PSRETURN_File = 0xff000000;
 extern const PSRETURN CODE__PSRETURN_File = 0x05000000;
 extern const PSRETURN MASK__PSRETURN_GUI = 0xff000000;
 extern const PSRETURN CODE__PSRETURN_GUI = 0x06000000;
 extern const PSRETURN MASK__PSRETURN_Game = 0xff000000;
 extern const PSRETURN CODE__PSRETURN_Game = 0x07000000;
 extern const PSRETURN MASK__PSRETURN_Scripting = 0xff000000;
 extern const PSRETURN CODE__PSRETURN_Scripting = 0x08000000;
 extern const PSRETURN MASK__PSRETURN_Serialize = 0xff000000;
 extern const PSRETURN CODE__PSRETURN_Serialize = 0x09000000;
 extern const PSRETURN MASK__PSRETURN_System = 0x0a000000;
 extern const PSRETURN CODE__PSRETURN_System = 0x0a000000;
 extern const PSRETURN MASK__PSRETURN_Xeromyces = 0x0b000000;
 extern const PSRETURN CODE__PSRETURN_Xeromyces = 0x0b000000;
 extern const PSRETURN MASK__PSRETURN_Game_World = 0xffff0000;
 extern const PSRETURN CODE__PSRETURN_Game_World = 0x07030000;
 extern const PSRETURN MASK__PSRETURN_Scripting_DefineType = 0xffff0000;
 extern const PSRETURN CODE__PSRETURN_Scripting_DefineType = 0x08010000;
 extern const PSRETURN MASK__PSRETURN_Scripting_LoadFile = 0xffff0000;
 extern const PSRETURN CODE__PSRETURN_Scripting_LoadFile = 0x08020000;
 
 extern const PSRETURN MASK__PSRETURN_CVFSFile_AlreadyLoaded = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_CVFSFile_AlreadyLoaded = 0x01000001;
 extern const PSRETURN MASK__PSRETURN_CVFSFile_LoadFailed = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_CVFSFile_LoadFailed = 0x01000002;
 extern const PSRETURN MASK__PSRETURN_Deserialize_InvalidCharInString = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Deserialize_InvalidCharInString = 0x02000001;
 extern const PSRETURN MASK__PSRETURN_Deserialize_OutOfBounds = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Deserialize_OutOfBounds = 0x02000002;
 extern const PSRETURN MASK__PSRETURN_Deserialize_ReadFailed = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Deserialize_ReadFailed = 0x02000003;
 extern const PSRETURN MASK__PSRETURN_Deserialize_ScriptError = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Deserialize_ScriptError = 0x02000004;
 extern const PSRETURN MASK__PSRETURN_DllLoader_DllNotLoaded = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_DllLoader_DllNotLoaded = 0x03000001;
 extern const PSRETURN MASK__PSRETURN_DllLoader_SymbolNotFound = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_DllLoader_SymbolNotFound = 0x03000002;
 extern const PSRETURN MASK__PSRETURN_Error_InvalidError = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Error_InvalidError = 0x04000001;
 extern const PSRETURN MASK__PSRETURN_File_InvalidType = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_File_InvalidType = 0x05000001;
 extern const PSRETURN MASK__PSRETURN_File_InvalidVersion = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_File_InvalidVersion = 0x05000002;
 extern const PSRETURN MASK__PSRETURN_File_OpenFailed = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_File_OpenFailed = 0x05000003;
 extern const PSRETURN MASK__PSRETURN_File_ReadFailed = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_File_ReadFailed = 0x05000004;
 extern const PSRETURN MASK__PSRETURN_File_UnexpectedEOF = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_File_UnexpectedEOF = 0x05000005;
 extern const PSRETURN MASK__PSRETURN_File_WriteFailed = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_File_WriteFailed = 0x05000006;
 extern const PSRETURN MASK__PSRETURN_GUI_InvalidSetting = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_GUI_InvalidSetting = 0x06000001;
 extern const PSRETURN MASK__PSRETURN_GUI_JSOpenFailed = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_GUI_JSOpenFailed = 0x06000002;
 extern const PSRETURN MASK__PSRETURN_GUI_NameAmbiguity = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_GUI_NameAmbiguity = 0x06000003;
-extern const PSRETURN MASK__PSRETURN_GUI_NullObjectProvided = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_GUI_NullObjectProvided = 0x06000004;
 extern const PSRETURN MASK__PSRETURN_GUI_ObjectNeedsName = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_GUI_ObjectNeedsName = 0x06000005;
+extern const PSRETURN CODE__PSRETURN_GUI_ObjectNeedsName = 0x06000004;
 extern const PSRETURN MASK__PSRETURN_GUI_OperationNeedsGUIObject = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_GUI_OperationNeedsGUIObject = 0x06000006;
+extern const PSRETURN CODE__PSRETURN_GUI_OperationNeedsGUIObject = 0x06000005;
 extern const PSRETURN MASK__PSRETURN_GUI_UnableToParse = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_GUI_UnableToParse = 0x06000007;
+extern const PSRETURN CODE__PSRETURN_GUI_UnableToParse = 0x06000006;
 extern const PSRETURN MASK__PSRETURN_Game_World_MapLoadFailed = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Game_World_MapLoadFailed = 0x07030001;
 extern const PSRETURN MASK__PSRETURN_Scripting_DefineType_AlreadyExists = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Scripting_DefineType_AlreadyExists = 0x08010001;
 extern const PSRETURN MASK__PSRETURN_Scripting_DefineType_CreationFailed = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Scripting_DefineType_CreationFailed = 0x08010002;
 extern const PSRETURN MASK__PSRETURN_Scripting_LoadFile_EvalErrors = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Scripting_LoadFile_EvalErrors = 0x08020001;
 extern const PSRETURN MASK__PSRETURN_Scripting_LoadFile_OpenFailed = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Scripting_LoadFile_OpenFailed = 0x08020002;
 extern const PSRETURN MASK__PSRETURN_Scripting_CallFunctionFailed = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Scripting_CallFunctionFailed = 0x08000001;
 extern const PSRETURN MASK__PSRETURN_Scripting_ConversionFailed = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Scripting_ConversionFailed = 0x08000002;
 extern const PSRETURN MASK__PSRETURN_Scripting_CreateObjectFailed = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Scripting_CreateObjectFailed = 0x08000003;
 extern const PSRETURN MASK__PSRETURN_Scripting_DefineConstantFailed = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Scripting_DefineConstantFailed = 0x08000004;
 extern const PSRETURN MASK__PSRETURN_Scripting_RegisterFunctionFailed = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Scripting_RegisterFunctionFailed = 0x08000005;
 extern const PSRETURN MASK__PSRETURN_Scripting_SetupFailed = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Scripting_SetupFailed = 0x08000006;
 extern const PSRETURN MASK__PSRETURN_Scripting_TypeDoesNotExist = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Scripting_TypeDoesNotExist = 0x08000007;
 extern const PSRETURN MASK__PSRETURN_Serialize_InvalidCharInString = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Serialize_InvalidCharInString = 0x09000001;
 extern const PSRETURN MASK__PSRETURN_Serialize_InvalidScriptValue = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Serialize_InvalidScriptValue = 0x09000002;
 extern const PSRETURN MASK__PSRETURN_Serialize_OutOfBounds = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Serialize_OutOfBounds = 0x09000003;
 extern const PSRETURN MASK__PSRETURN_Serialize_ScriptError = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Serialize_ScriptError = 0x09000004;
 extern const PSRETURN MASK__PSRETURN_System_RequiredExtensionsMissing = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_System_RequiredExtensionsMissing = 0x0a000001;
 extern const PSRETURN MASK__PSRETURN_System_SDLInitFailed = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_System_SDLInitFailed = 0x0a000002;
 extern const PSRETURN MASK__PSRETURN_System_VmodeFailed = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_System_VmodeFailed = 0x0a000003;
 extern const PSRETURN MASK__PSRETURN_Xeromyces_XMLOpenFailed = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Xeromyces_XMLOpenFailed = 0x0b000001;
 extern const PSRETURN MASK__PSRETURN_Xeromyces_XMLParseError = 0xffffffff;
 extern const PSRETURN CODE__PSRETURN_Xeromyces_XMLParseError = 0x0b000002;
 
 PSERROR_CVFSFile::PSERROR_CVFSFile(const char* msg) : PSERROR(msg) { }
 PSERROR_Deserialize::PSERROR_Deserialize(const char* msg) : PSERROR(msg) { }
 PSERROR_DllLoader::PSERROR_DllLoader(const char* msg) : PSERROR(msg) { }
 PSERROR_Error::PSERROR_Error(const char* msg) : PSERROR(msg) { }
 PSERROR_File::PSERROR_File(const char* msg) : PSERROR(msg) { }
 PSERROR_GUI::PSERROR_GUI(const char* msg) : PSERROR(msg) { }
 PSERROR_Game::PSERROR_Game(const char* msg) : PSERROR(msg) { }
 PSERROR_Scripting::PSERROR_Scripting(const char* msg) : PSERROR(msg) { }
 PSERROR_Serialize::PSERROR_Serialize(const char* msg) : PSERROR(msg) { }
 PSERROR_System::PSERROR_System(const char* msg) : PSERROR(msg) { }
 PSERROR_Xeromyces::PSERROR_Xeromyces(const char* msg) : PSERROR(msg) { }
 PSERROR_Game_World::PSERROR_Game_World(const char* msg) : PSERROR_Game(msg) { }
 PSERROR_Scripting_DefineType::PSERROR_Scripting_DefineType(const char* msg) : PSERROR_Scripting(msg) { }
 PSERROR_Scripting_LoadFile::PSERROR_Scripting_LoadFile(const char* msg) : PSERROR_Scripting(msg) { }
 
 PSERROR_CVFSFile_AlreadyLoaded::PSERROR_CVFSFile_AlreadyLoaded() : PSERROR_CVFSFile(NULL) { }
 PSERROR_CVFSFile_AlreadyLoaded::PSERROR_CVFSFile_AlreadyLoaded(const char* msg) : PSERROR_CVFSFile(msg) { }
 PSRETURN PSERROR_CVFSFile_AlreadyLoaded::getCode() const { return 0x01000001; }
 
 PSERROR_CVFSFile_LoadFailed::PSERROR_CVFSFile_LoadFailed() : PSERROR_CVFSFile(NULL) { }
 PSERROR_CVFSFile_LoadFailed::PSERROR_CVFSFile_LoadFailed(const char* msg) : PSERROR_CVFSFile(msg) { }
 PSRETURN PSERROR_CVFSFile_LoadFailed::getCode() const { return 0x01000002; }
 
 PSERROR_Deserialize_InvalidCharInString::PSERROR_Deserialize_InvalidCharInString() : PSERROR_Deserialize(NULL) { }
 PSERROR_Deserialize_InvalidCharInString::PSERROR_Deserialize_InvalidCharInString(const char* msg) : PSERROR_Deserialize(msg) { }
 PSRETURN PSERROR_Deserialize_InvalidCharInString::getCode() const { return 0x02000001; }
 
 PSERROR_Deserialize_OutOfBounds::PSERROR_Deserialize_OutOfBounds() : PSERROR_Deserialize(NULL) { }
 PSERROR_Deserialize_OutOfBounds::PSERROR_Deserialize_OutOfBounds(const char* msg) : PSERROR_Deserialize(msg) { }
 PSRETURN PSERROR_Deserialize_OutOfBounds::getCode() const { return 0x02000002; }
 
 PSERROR_Deserialize_ReadFailed::PSERROR_Deserialize_ReadFailed() : PSERROR_Deserialize(NULL) { }
 PSERROR_Deserialize_ReadFailed::PSERROR_Deserialize_ReadFailed(const char* msg) : PSERROR_Deserialize(msg) { }
 PSRETURN PSERROR_Deserialize_ReadFailed::getCode() const { return 0x02000003; }
 
 PSERROR_Deserialize_ScriptError::PSERROR_Deserialize_ScriptError() : PSERROR_Deserialize(NULL) { }
 PSERROR_Deserialize_ScriptError::PSERROR_Deserialize_ScriptError(const char* msg) : PSERROR_Deserialize(msg) { }
 PSRETURN PSERROR_Deserialize_ScriptError::getCode() const { return 0x02000004; }
 
 PSERROR_DllLoader_DllNotLoaded::PSERROR_DllLoader_DllNotLoaded() : PSERROR_DllLoader(NULL) { }
 PSERROR_DllLoader_DllNotLoaded::PSERROR_DllLoader_DllNotLoaded(const char* msg) : PSERROR_DllLoader(msg) { }
 PSRETURN PSERROR_DllLoader_DllNotLoaded::getCode() const { return 0x03000001; }
 
 PSERROR_DllLoader_SymbolNotFound::PSERROR_DllLoader_SymbolNotFound() : PSERROR_DllLoader(NULL) { }
 PSERROR_DllLoader_SymbolNotFound::PSERROR_DllLoader_SymbolNotFound(const char* msg) : PSERROR_DllLoader(msg) { }
 PSRETURN PSERROR_DllLoader_SymbolNotFound::getCode() const { return 0x03000002; }
 
 PSERROR_Error_InvalidError::PSERROR_Error_InvalidError() : PSERROR_Error(NULL) { }
 PSERROR_Error_InvalidError::PSERROR_Error_InvalidError(const char* msg) : PSERROR_Error(msg) { }
 PSRETURN PSERROR_Error_InvalidError::getCode() const { return 0x04000001; }
 
 PSERROR_File_InvalidType::PSERROR_File_InvalidType() : PSERROR_File(NULL) { }
 PSERROR_File_InvalidType::PSERROR_File_InvalidType(const char* msg) : PSERROR_File(msg) { }
 PSRETURN PSERROR_File_InvalidType::getCode() const { return 0x05000001; }
 
 PSERROR_File_InvalidVersion::PSERROR_File_InvalidVersion() : PSERROR_File(NULL) { }
 PSERROR_File_InvalidVersion::PSERROR_File_InvalidVersion(const char* msg) : PSERROR_File(msg) { }
 PSRETURN PSERROR_File_InvalidVersion::getCode() const { return 0x05000002; }
 
 PSERROR_File_OpenFailed::PSERROR_File_OpenFailed() : PSERROR_File(NULL) { }
 PSERROR_File_OpenFailed::PSERROR_File_OpenFailed(const char* msg) : PSERROR_File(msg) { }
 PSRETURN PSERROR_File_OpenFailed::getCode() const { return 0x05000003; }
 
 PSERROR_File_ReadFailed::PSERROR_File_ReadFailed() : PSERROR_File(NULL) { }
 PSERROR_File_ReadFailed::PSERROR_File_ReadFailed(const char* msg) : PSERROR_File(msg) { }
 PSRETURN PSERROR_File_ReadFailed::getCode() const { return 0x05000004; }
 
 PSERROR_File_UnexpectedEOF::PSERROR_File_UnexpectedEOF() : PSERROR_File(NULL) { }
 PSERROR_File_UnexpectedEOF::PSERROR_File_UnexpectedEOF(const char* msg) : PSERROR_File(msg) { }
 PSRETURN PSERROR_File_UnexpectedEOF::getCode() const { return 0x05000005; }
 
 PSERROR_File_WriteFailed::PSERROR_File_WriteFailed() : PSERROR_File(NULL) { }
 PSERROR_File_WriteFailed::PSERROR_File_WriteFailed(const char* msg) : PSERROR_File(msg) { }
 PSRETURN PSERROR_File_WriteFailed::getCode() const { return 0x05000006; }
 
 PSERROR_GUI_InvalidSetting::PSERROR_GUI_InvalidSetting() : PSERROR_GUI(NULL) { }
 PSERROR_GUI_InvalidSetting::PSERROR_GUI_InvalidSetting(const char* msg) : PSERROR_GUI(msg) { }
 PSRETURN PSERROR_GUI_InvalidSetting::getCode() const { return 0x06000001; }
 
 PSERROR_GUI_JSOpenFailed::PSERROR_GUI_JSOpenFailed() : PSERROR_GUI(NULL) { }
 PSERROR_GUI_JSOpenFailed::PSERROR_GUI_JSOpenFailed(const char* msg) : PSERROR_GUI(msg) { }
 PSRETURN PSERROR_GUI_JSOpenFailed::getCode() const { return 0x06000002; }
 
 PSERROR_GUI_NameAmbiguity::PSERROR_GUI_NameAmbiguity() : PSERROR_GUI(NULL) { }
 PSERROR_GUI_NameAmbiguity::PSERROR_GUI_NameAmbiguity(const char* msg) : PSERROR_GUI(msg) { }
 PSRETURN PSERROR_GUI_NameAmbiguity::getCode() const { return 0x06000003; }
 
-PSERROR_GUI_NullObjectProvided::PSERROR_GUI_NullObjectProvided() : PSERROR_GUI(NULL) { }
-PSERROR_GUI_NullObjectProvided::PSERROR_GUI_NullObjectProvided(const char* msg) : PSERROR_GUI(msg) { }
-PSRETURN PSERROR_GUI_NullObjectProvided::getCode() const { return 0x06000004; }
-
 PSERROR_GUI_ObjectNeedsName::PSERROR_GUI_ObjectNeedsName() : PSERROR_GUI(NULL) { }
 PSERROR_GUI_ObjectNeedsName::PSERROR_GUI_ObjectNeedsName(const char* msg) : PSERROR_GUI(msg) { }
-PSRETURN PSERROR_GUI_ObjectNeedsName::getCode() const { return 0x06000005; }
+PSRETURN PSERROR_GUI_ObjectNeedsName::getCode() const { return 0x06000004; }
 
 PSERROR_GUI_OperationNeedsGUIObject::PSERROR_GUI_OperationNeedsGUIObject() : PSERROR_GUI(NULL) { }
 PSERROR_GUI_OperationNeedsGUIObject::PSERROR_GUI_OperationNeedsGUIObject(const char* msg) : PSERROR_GUI(msg) { }
-PSRETURN PSERROR_GUI_OperationNeedsGUIObject::getCode() const { return 0x06000006; }
+PSRETURN PSERROR_GUI_OperationNeedsGUIObject::getCode() const { return 0x06000005; }
 
 PSERROR_GUI_UnableToParse::PSERROR_GUI_UnableToParse() : PSERROR_GUI(NULL) { }
 PSERROR_GUI_UnableToParse::PSERROR_GUI_UnableToParse(const char* msg) : PSERROR_GUI(msg) { }
-PSRETURN PSERROR_GUI_UnableToParse::getCode() const { return 0x06000007; }
+PSRETURN PSERROR_GUI_UnableToParse::getCode() const { return 0x06000006; }
 
 PSERROR_Game_World_MapLoadFailed::PSERROR_Game_World_MapLoadFailed() : PSERROR_Game_World(NULL) { }
 PSERROR_Game_World_MapLoadFailed::PSERROR_Game_World_MapLoadFailed(const char* msg) : PSERROR_Game_World(msg) { }
 PSRETURN PSERROR_Game_World_MapLoadFailed::getCode() const { return 0x07030001; }
 
 PSERROR_Scripting_DefineType_AlreadyExists::PSERROR_Scripting_DefineType_AlreadyExists() : PSERROR_Scripting_DefineType(NULL) { }
 PSERROR_Scripting_DefineType_AlreadyExists::PSERROR_Scripting_DefineType_AlreadyExists(const char* msg) : PSERROR_Scripting_DefineType(msg) { }
 PSRETURN PSERROR_Scripting_DefineType_AlreadyExists::getCode() const { return 0x08010001; }
 
 PSERROR_Scripting_DefineType_CreationFailed::PSERROR_Scripting_DefineType_CreationFailed() : PSERROR_Scripting_DefineType(NULL) { }
 PSERROR_Scripting_DefineType_CreationFailed::PSERROR_Scripting_DefineType_CreationFailed(const char* msg) : PSERROR_Scripting_DefineType(msg) { }
 PSRETURN PSERROR_Scripting_DefineType_CreationFailed::getCode() const { return 0x08010002; }
 
 PSERROR_Scripting_LoadFile_EvalErrors::PSERROR_Scripting_LoadFile_EvalErrors() : PSERROR_Scripting_LoadFile(NULL) { }
 PSERROR_Scripting_LoadFile_EvalErrors::PSERROR_Scripting_LoadFile_EvalErrors(const char* msg) : PSERROR_Scripting_LoadFile(msg) { }
 PSRETURN PSERROR_Scripting_LoadFile_EvalErrors::getCode() const { return 0x08020001; }
 
 PSERROR_Scripting_LoadFile_OpenFailed::PSERROR_Scripting_LoadFile_OpenFailed() : PSERROR_Scripting_LoadFile(NULL) { }
 PSERROR_Scripting_LoadFile_OpenFailed::PSERROR_Scripting_LoadFile_OpenFailed(const char* msg) : PSERROR_Scripting_LoadFile(msg) { }
 PSRETURN PSERROR_Scripting_LoadFile_OpenFailed::getCode() const { return 0x08020002; }
 
 PSERROR_Scripting_CallFunctionFailed::PSERROR_Scripting_CallFunctionFailed() : PSERROR_Scripting(NULL) { }
 PSERROR_Scripting_CallFunctionFailed::PSERROR_Scripting_CallFunctionFailed(const char* msg) : PSERROR_Scripting(msg) { }
 PSRETURN PSERROR_Scripting_CallFunctionFailed::getCode() const { return 0x08000001; }
 
 PSERROR_Scripting_ConversionFailed::PSERROR_Scripting_ConversionFailed() : PSERROR_Scripting(NULL) { }
 PSERROR_Scripting_ConversionFailed::PSERROR_Scripting_ConversionFailed(const char* msg) : PSERROR_Scripting(msg) { }
 PSRETURN PSERROR_Scripting_ConversionFailed::getCode() const { return 0x08000002; }
 
 PSERROR_Scripting_CreateObjectFailed::PSERROR_Scripting_CreateObjectFailed() : PSERROR_Scripting(NULL) { }
 PSERROR_Scripting_CreateObjectFailed::PSERROR_Scripting_CreateObjectFailed(const char* msg) : PSERROR_Scripting(msg) { }
 PSRETURN PSERROR_Scripting_CreateObjectFailed::getCode() const { return 0x08000003; }
 
 PSERROR_Scripting_DefineConstantFailed::PSERROR_Scripting_DefineConstantFailed() : PSERROR_Scripting(NULL) { }
 PSERROR_Scripting_DefineConstantFailed::PSERROR_Scripting_DefineConstantFailed(const char* msg) : PSERROR_Scripting(msg) { }
 PSRETURN PSERROR_Scripting_DefineConstantFailed::getCode() const { return 0x08000004; }
 
 PSERROR_Scripting_RegisterFunctionFailed::PSERROR_Scripting_RegisterFunctionFailed() : PSERROR_Scripting(NULL) { }
 PSERROR_Scripting_RegisterFunctionFailed::PSERROR_Scripting_RegisterFunctionFailed(const char* msg) : PSERROR_Scripting(msg) { }
 PSRETURN PSERROR_Scripting_RegisterFunctionFailed::getCode() const { return 0x08000005; }
 
 PSERROR_Scripting_SetupFailed::PSERROR_Scripting_SetupFailed() : PSERROR_Scripting(NULL) { }
 PSERROR_Scripting_SetupFailed::PSERROR_Scripting_SetupFailed(const char* msg) : PSERROR_Scripting(msg) { }
 PSRETURN PSERROR_Scripting_SetupFailed::getCode() const { return 0x08000006; }
 
 PSERROR_Scripting_TypeDoesNotExist::PSERROR_Scripting_TypeDoesNotExist() : PSERROR_Scripting(NULL) { }
 PSERROR_Scripting_TypeDoesNotExist::PSERROR_Scripting_TypeDoesNotExist(const char* msg) : PSERROR_Scripting(msg) { }
 PSRETURN PSERROR_Scripting_TypeDoesNotExist::getCode() const { return 0x08000007; }
 
 PSERROR_Serialize_InvalidCharInString::PSERROR_Serialize_InvalidCharInString() : PSERROR_Serialize(NULL) { }
 PSERROR_Serialize_InvalidCharInString::PSERROR_Serialize_InvalidCharInString(const char* msg) : PSERROR_Serialize(msg) { }
 PSRETURN PSERROR_Serialize_InvalidCharInString::getCode() const { return 0x09000001; }
 
 PSERROR_Serialize_InvalidScriptValue::PSERROR_Serialize_InvalidScriptValue() : PSERROR_Serialize(NULL) { }
 PSERROR_Serialize_InvalidScriptValue::PSERROR_Serialize_InvalidScriptValue(const char* msg) : PSERROR_Serialize(msg) { }
 PSRETURN PSERROR_Serialize_InvalidScriptValue::getCode() const { return 0x09000002; }
 
 PSERROR_Serialize_OutOfBounds::PSERROR_Serialize_OutOfBounds() : PSERROR_Serialize(NULL) { }
 PSERROR_Serialize_OutOfBounds::PSERROR_Serialize_OutOfBounds(const char* msg) : PSERROR_Serialize(msg) { }
 PSRETURN PSERROR_Serialize_OutOfBounds::getCode() const { return 0x09000003; }
 
 PSERROR_Serialize_ScriptError::PSERROR_Serialize_ScriptError() : PSERROR_Serialize(NULL) { }
 PSERROR_Serialize_ScriptError::PSERROR_Serialize_ScriptError(const char* msg) : PSERROR_Serialize(msg) { }
 PSRETURN PSERROR_Serialize_ScriptError::getCode() const { return 0x09000004; }
 
 PSERROR_System_RequiredExtensionsMissing::PSERROR_System_RequiredExtensionsMissing() : PSERROR_System(NULL) { }
 PSERROR_System_RequiredExtensionsMissing::PSERROR_System_RequiredExtensionsMissing(const char* msg) : PSERROR_System(msg) { }
 PSRETURN PSERROR_System_RequiredExtensionsMissing::getCode() const { return 0x0a000001; }
 
 PSERROR_System_SDLInitFailed::PSERROR_System_SDLInitFailed() : PSERROR_System(NULL) { }
 PSERROR_System_SDLInitFailed::PSERROR_System_SDLInitFailed(const char* msg) : PSERROR_System(msg) { }
 PSRETURN PSERROR_System_SDLInitFailed::getCode() const { return 0x0a000002; }
 
 PSERROR_System_VmodeFailed::PSERROR_System_VmodeFailed() : PSERROR_System(NULL) { }
 PSERROR_System_VmodeFailed::PSERROR_System_VmodeFailed(const char* msg) : PSERROR_System(msg) { }
 PSRETURN PSERROR_System_VmodeFailed::getCode() const { return 0x0a000003; }
 
 PSERROR_Xeromyces_XMLOpenFailed::PSERROR_Xeromyces_XMLOpenFailed() : PSERROR_Xeromyces(NULL) { }
 PSERROR_Xeromyces_XMLOpenFailed::PSERROR_Xeromyces_XMLOpenFailed(const char* msg) : PSERROR_Xeromyces(msg) { }
 PSRETURN PSERROR_Xeromyces_XMLOpenFailed::getCode() const { return 0x0b000001; }
 
 PSERROR_Xeromyces_XMLParseError::PSERROR_Xeromyces_XMLParseError() : PSERROR_Xeromyces(NULL) { }
 PSERROR_Xeromyces_XMLParseError::PSERROR_Xeromyces_XMLParseError(const char* msg) : PSERROR_Xeromyces(msg) { }
 PSRETURN PSERROR_Xeromyces_XMLParseError::getCode() const { return 0x0b000002; }
 
 
 PSERROR::PSERROR(const char* msg) : m_msg(msg) { }
 
 const char* PSERROR::what() const throw ()
 {
 	return m_msg ? m_msg : GetErrorString(getCode());
 }
 
 const char* GetErrorString(PSRETURN code)
 {
 	switch (code)
 	{
 	case 0x01000001: return "CVFSFile_AlreadyLoaded";
 	case 0x01000002: return "CVFSFile_LoadFailed";
 	case 0x02000001: return "Deserialize_InvalidCharInString";
 	case 0x02000002: return "Deserialize_OutOfBounds";
 	case 0x02000003: return "Deserialize_ReadFailed";
 	case 0x02000004: return "Deserialize_ScriptError";
 	case 0x03000001: return "DllLoader_DllNotLoaded";
 	case 0x03000002: return "DllLoader_SymbolNotFound";
 	case 0x04000001: return "Error_InvalidError";
 	case 0x05000001: return "File_InvalidType";
 	case 0x05000002: return "File_InvalidVersion";
 	case 0x05000003: return "File_OpenFailed";
 	case 0x05000004: return "File_ReadFailed";
 	case 0x05000005: return "File_UnexpectedEOF";
 	case 0x05000006: return "File_WriteFailed";
 	case 0x06000001: return "GUI_InvalidSetting";
 	case 0x06000002: return "GUI_JSOpenFailed";
 	case 0x06000003: return "GUI_NameAmbiguity";
-	case 0x06000004: return "GUI_NullObjectProvided";
-	case 0x06000005: return "GUI_ObjectNeedsName";
-	case 0x06000006: return "GUI_OperationNeedsGUIObject";
-	case 0x06000007: return "GUI_UnableToParse";
+	case 0x06000004: return "GUI_ObjectNeedsName";
+	case 0x06000005: return "GUI_OperationNeedsGUIObject";
+	case 0x06000006: return "GUI_UnableToParse";
 	case 0x07030001: return "Game_World_MapLoadFailed";
 	case 0x08010001: return "Scripting_DefineType_AlreadyExists";
 	case 0x08010002: return "Scripting_DefineType_CreationFailed";
 	case 0x08020001: return "Scripting_LoadFile_EvalErrors";
 	case 0x08020002: return "Scripting_LoadFile_OpenFailed";
 	case 0x08000001: return "Scripting_CallFunctionFailed";
 	case 0x08000002: return "Scripting_ConversionFailed";
 	case 0x08000003: return "Scripting_CreateObjectFailed";
 	case 0x08000004: return "Scripting_DefineConstantFailed";
 	case 0x08000005: return "Scripting_RegisterFunctionFailed";
 	case 0x08000006: return "Scripting_SetupFailed";
 	case 0x08000007: return "Scripting_TypeDoesNotExist";
 	case 0x09000001: return "Serialize_InvalidCharInString";
 	case 0x09000002: return "Serialize_InvalidScriptValue";
 	case 0x09000003: return "Serialize_OutOfBounds";
 	case 0x09000004: return "Serialize_ScriptError";
 	case 0x0a000001: return "System_RequiredExtensionsMissing";
 	case 0x0a000002: return "System_SDLInitFailed";
 	case 0x0a000003: return "System_VmodeFailed";
 	case 0x0b000001: return "Xeromyces_XMLOpenFailed";
 	case 0x0b000002: return "Xeromyces_XMLParseError";
 
 	default: return "Unrecognised error";
 	}
 }
 
 void ThrowError(PSRETURN code)
 {
 	switch (code)  // Use 'break' in case someone tries to continue from the exception
 	{
 	case 0x01000001: throw PSERROR_CVFSFile_AlreadyLoaded(); break;
 	case 0x01000002: throw PSERROR_CVFSFile_LoadFailed(); break;
 	case 0x02000001: throw PSERROR_Deserialize_InvalidCharInString(); break;
 	case 0x02000002: throw PSERROR_Deserialize_OutOfBounds(); break;
 	case 0x02000003: throw PSERROR_Deserialize_ReadFailed(); break;
 	case 0x02000004: throw PSERROR_Deserialize_ScriptError(); break;
 	case 0x03000001: throw PSERROR_DllLoader_DllNotLoaded(); break;
 	case 0x03000002: throw PSERROR_DllLoader_SymbolNotFound(); break;
 	case 0x04000001: throw PSERROR_Error_InvalidError(); break;
 	case 0x05000001: throw PSERROR_File_InvalidType(); break;
 	case 0x05000002: throw PSERROR_File_InvalidVersion(); break;
 	case 0x05000003: throw PSERROR_File_OpenFailed(); break;
 	case 0x05000004: throw PSERROR_File_ReadFailed(); break;
 	case 0x05000005: throw PSERROR_File_UnexpectedEOF(); break;
 	case 0x05000006: throw PSERROR_File_WriteFailed(); break;
 	case 0x06000001: throw PSERROR_GUI_InvalidSetting(); break;
 	case 0x06000002: throw PSERROR_GUI_JSOpenFailed(); break;
 	case 0x06000003: throw PSERROR_GUI_NameAmbiguity(); break;
-	case 0x06000004: throw PSERROR_GUI_NullObjectProvided(); break;
-	case 0x06000005: throw PSERROR_GUI_ObjectNeedsName(); break;
-	case 0x06000006: throw PSERROR_GUI_OperationNeedsGUIObject(); break;
-	case 0x06000007: throw PSERROR_GUI_UnableToParse(); break;
+	case 0x06000004: throw PSERROR_GUI_ObjectNeedsName(); break;
+	case 0x06000005: throw PSERROR_GUI_OperationNeedsGUIObject(); break;
+	case 0x06000006: throw PSERROR_GUI_UnableToParse(); break;
 	case 0x07030001: throw PSERROR_Game_World_MapLoadFailed(); break;
 	case 0x08010001: throw PSERROR_Scripting_DefineType_AlreadyExists(); break;
 	case 0x08010002: throw PSERROR_Scripting_DefineType_CreationFailed(); break;
 	case 0x08020001: throw PSERROR_Scripting_LoadFile_EvalErrors(); break;
 	case 0x08020002: throw PSERROR_Scripting_LoadFile_OpenFailed(); break;
 	case 0x08000001: throw PSERROR_Scripting_CallFunctionFailed(); break;
 	case 0x08000002: throw PSERROR_Scripting_ConversionFailed(); break;
 	case 0x08000003: throw PSERROR_Scripting_CreateObjectFailed(); break;
 	case 0x08000004: throw PSERROR_Scripting_DefineConstantFailed(); break;
 	case 0x08000005: throw PSERROR_Scripting_RegisterFunctionFailed(); break;
 	case 0x08000006: throw PSERROR_Scripting_SetupFailed(); break;
 	case 0x08000007: throw PSERROR_Scripting_TypeDoesNotExist(); break;
 	case 0x09000001: throw PSERROR_Serialize_InvalidCharInString(); break;
 	case 0x09000002: throw PSERROR_Serialize_InvalidScriptValue(); break;
 	case 0x09000003: throw PSERROR_Serialize_OutOfBounds(); break;
 	case 0x09000004: throw PSERROR_Serialize_ScriptError(); break;
 	case 0x0a000001: throw PSERROR_System_RequiredExtensionsMissing(); break;
 	case 0x0a000002: throw PSERROR_System_SDLInitFailed(); break;
 	case 0x0a000003: throw PSERROR_System_VmodeFailed(); break;
 	case 0x0b000001: throw PSERROR_Xeromyces_XMLOpenFailed(); break;
 	case 0x0b000002: throw PSERROR_Xeromyces_XMLParseError(); break;
 
 	default: throw PSERROR_Error_InvalidError(); // Hmm...
 	}
 }