Index: ps/trunk/source/gui/CGUI.cpp
===================================================================
--- ps/trunk/source/gui/CGUI.cpp	(revision 23066)
+++ ps/trunk/source/gui/CGUI.cpp	(revision 23067)
@@ -1,1346 +1,1302 @@
 /* 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 "CGUI.h"
 
 #include "gui/IGUIScrollBar.h"
 #include "gui/ObjectTypes/CButton.h"
 #include "gui/ObjectTypes/CChart.h"
 #include "gui/ObjectTypes/CCheckBox.h"
 #include "gui/ObjectTypes/CDropDown.h"
 #include "gui/ObjectTypes/CImage.h"
 #include "gui/ObjectTypes/CInput.h"
 #include "gui/ObjectTypes/CList.h"
 #include "gui/ObjectTypes/CMiniMap.h"
 #include "gui/ObjectTypes/COList.h"
 #include "gui/ObjectTypes/CProgressBar.h"
 #include "gui/ObjectTypes/CRadioButton.h"
 #include "gui/ObjectTypes/CSlider.h"
 #include "gui/ObjectTypes/CText.h"
 #include "gui/ObjectTypes/CTooltip.h"
 #include "gui/Scripting/ScriptFunctions.h"
 #include "i18n/L10n.h"
 #include "lib/bits.h"
 #include "lib/input.h"
 #include "lib/sysdep/sysdep.h"
 #include "lib/timer.h"
 #include "lib/utf8.h"
 #include "ps/CLogger.h"
 #include "ps/Filesystem.h"
 #include "ps/GameSetup/Config.h"
 #include "ps/Globals.h"
 #include "ps/Hotkey.h"
 #include "ps/Profile.h"
 #include "ps/Pyrogenesis.h"
 #include "ps/XML/Xeromyces.h"
 #include "renderer/Renderer.h"
 #include "scriptinterface/ScriptInterface.h"
 
 #include <string>
 
 extern int g_yres;
 
 const double SELECT_DBLCLICK_RATE = 0.5;
 const u32 MAX_OBJECT_DEPTH = 100; // Max number of nesting for GUI includes. Used to detect recursive inclusion
 
 InReaction CGUI::HandleEvent(const SDL_Event_* ev)
 {
 	InReaction ret = IN_PASS;
 
 	if (ev->ev.type == SDL_HOTKEYDOWN || ev->ev.type == SDL_HOTKEYUP)
 	{
 		const char* hotkey = static_cast<const char*>(ev->ev.user.data1);
 
 		if (m_GlobalHotkeys.find(hotkey) != m_GlobalHotkeys.end() && ev->ev.type == SDL_HOTKEYDOWN)
 		{
 			ret = IN_HANDLED;
 
 			JSContext* cx = m_ScriptInterface->GetContext();
 			JSAutoRequest rq(cx);
 			JS::RootedObject globalObj(cx, &GetGlobalObject().toObject());
 			JS::RootedValue result(cx);
 			JS_CallFunctionValue(cx, globalObj, m_GlobalHotkeys[hotkey], JS::HandleValueArray::empty(), &result);
 		}
 
 		std::map<CStr, std::vector<IGUIObject*> >::iterator it = m_HotkeyObjects.find(hotkey);
 		if (it != m_HotkeyObjects.end())
 			for (IGUIObject* const& obj : it->second)
 			{
 				if (ev->ev.type == SDL_HOTKEYDOWN)
 					ret = obj->SendEvent(GUIM_PRESSED, "press");
 				else
 					ret = obj->SendEvent(GUIM_RELEASED, "release");
 			}
 	}
 
 	else if (ev->ev.type == SDL_MOUSEMOTION)
 	{
 		// Yes the mouse position is stored as float to avoid
 		//  constant conversions when operating in a
 		//  float-based environment.
 		m_MousePos = CPos((float)ev->ev.motion.x / g_GuiScale, (float)ev->ev.motion.y / g_GuiScale);
 
 		SGUIMessage msg(GUIM_MOUSE_MOTION);
 		m_BaseObject.RecurseObject(&IGUIObject::IsHiddenOrGhost, &IGUIObject::HandleMessage, msg);
 	}
 
 	// Update m_MouseButtons. (BUTTONUP is handled later.)
 	else if (ev->ev.type == SDL_MOUSEBUTTONDOWN)
 	{
 		switch (ev->ev.button.button)
 		{
 		case SDL_BUTTON_LEFT:
 		case SDL_BUTTON_RIGHT:
 		case SDL_BUTTON_MIDDLE:
 			m_MouseButtons |= Bit<unsigned int>(ev->ev.button.button);
 			break;
 		default:
 			break;
 		}
 	}
 
 	// Update m_MousePos (for delayed mouse button events)
 	CPos oldMousePos = m_MousePos;
 	if (ev->ev.type == SDL_MOUSEBUTTONDOWN || ev->ev.type == SDL_MOUSEBUTTONUP)
 	{
 		m_MousePos = CPos((float)ev->ev.button.x / g_GuiScale, (float)ev->ev.button.y / g_GuiScale);
 	}
 
 	// Only one object can be hovered
 	IGUIObject* pNearest = nullptr;
 
 	// TODO Gee: (2004-09-08) Big TODO, don't do the below if the SDL_Event is something like a keypress!
-	try
 	{
 		PROFILE("mouse events");
 		// TODO Gee: Optimizations needed!
 		//  these two recursive function are quite overhead heavy.
 
 		// pNearest will after this point at the hovered object, possibly nullptr
 		pNearest = FindObjectUnderMouse();
 
 		// Now we'll call UpdateMouseOver on *all* objects,
 		//  we'll input the one hovered, and they will each
 		//  update their own data and send messages accordingly
 		m_BaseObject.RecurseObject(&IGUIObject::IsHiddenOrGhost, &IGUIObject::UpdateMouseOver, static_cast<IGUIObject* const&>(pNearest));
 
 		if (ev->ev.type == SDL_MOUSEBUTTONDOWN)
 		{
 			switch (ev->ev.button.button)
 			{
 			case SDL_BUTTON_LEFT:
 				// Focus the clicked object (or focus none if nothing clicked on)
 				SetFocusedObject(pNearest);
 
 				if (pNearest)
 					ret = pNearest->SendEvent(GUIM_MOUSE_PRESS_LEFT, "mouseleftpress");
 				break;
 
 			case SDL_BUTTON_RIGHT:
 				if (pNearest)
 					ret = pNearest->SendEvent(GUIM_MOUSE_PRESS_RIGHT, "mouserightpress");
 				break;
 
 			default:
 				break;
 			}
 		}
 		else if (ev->ev.type == SDL_MOUSEWHEEL && pNearest)
 		{
 			if (ev->ev.wheel.y < 0)
 				ret = pNearest->SendEvent(GUIM_MOUSE_WHEEL_DOWN, "mousewheeldown");
 			else if (ev->ev.wheel.y > 0)
 				ret = pNearest->SendEvent(GUIM_MOUSE_WHEEL_UP, "mousewheelup");
 		}
 		else if (ev->ev.type == SDL_MOUSEBUTTONUP)
 		{
 			switch (ev->ev.button.button)
 			{
 			case SDL_BUTTON_LEFT:
 				if (pNearest)
 				{
 					double timeElapsed = timer_Time() - pNearest->m_LastClickTime[SDL_BUTTON_LEFT];
 					pNearest->m_LastClickTime[SDL_BUTTON_LEFT] = timer_Time();
 
 					if (timeElapsed < SELECT_DBLCLICK_RATE)
 						ret = pNearest->SendEvent(GUIM_MOUSE_DBLCLICK_LEFT, "mouseleftdoubleclick");
 					else
 						ret = pNearest->SendEvent(GUIM_MOUSE_RELEASE_LEFT, "mouseleftrelease");
 				}
 				break;
 			case SDL_BUTTON_RIGHT:
 				if (pNearest)
 				{
 					double timeElapsed = timer_Time() - pNearest->m_LastClickTime[SDL_BUTTON_RIGHT];
 					pNearest->m_LastClickTime[SDL_BUTTON_RIGHT] = timer_Time();
 
 					if (timeElapsed < SELECT_DBLCLICK_RATE)
 						ret = pNearest->SendEvent(GUIM_MOUSE_DBLCLICK_RIGHT, "mouserightdoubleclick");
 					else
 						ret = pNearest->SendEvent(GUIM_MOUSE_RELEASE_RIGHT, "mouserightrelease");
 				}
 				break;
 			}
 
 			// Reset all states on all visible objects
 			m_BaseObject.RecurseObject(&IGUIObject::IsHidden, &IGUIObject::ResetStates);
 
 			// Since the hover state will have been reset, we reload it.
 			m_BaseObject.RecurseObject(&IGUIObject::IsHiddenOrGhost, &IGUIObject::UpdateMouseOver, static_cast<IGUIObject* const&>(pNearest));
 		}
 	}
-	catch (PSERROR_GUI& e)
-	{
-		UNUSED2(e);
-		debug_warn(L"CGUI::HandleEvent error");
-		// TODO Gee: Handle
-	}
 
 	// BUTTONUP's effect on m_MouseButtons is handled after
 	// everything else, so that e.g. 'press' handlers (activated
 	// on button up) see which mouse button had been pressed.
 	if (ev->ev.type == SDL_MOUSEBUTTONUP)
 	{
 		switch (ev->ev.button.button)
 		{
 		case SDL_BUTTON_LEFT:
 		case SDL_BUTTON_RIGHT:
 		case SDL_BUTTON_MIDDLE:
 			m_MouseButtons &= ~Bit<unsigned int>(ev->ev.button.button);
 			break;
 		default:
 			break;
 		}
 	}
 
 	// Restore m_MousePos (for delayed mouse button events)
 	if (ev->ev.type == SDL_MOUSEBUTTONDOWN || ev->ev.type == SDL_MOUSEBUTTONUP)
 		m_MousePos = oldMousePos;
 
 	// Handle keys for input boxes
 	if (GetFocusedObject())
 	{
 		if ((ev->ev.type == SDL_KEYDOWN &&
 		     ev->ev.key.keysym.sym != SDLK_ESCAPE &&
 		     !g_keys[SDLK_LCTRL] && !g_keys[SDLK_RCTRL] &&
 		     !g_keys[SDLK_LALT] && !g_keys[SDLK_RALT]) ||
 		    ev->ev.type == SDL_HOTKEYDOWN ||
 		    ev->ev.type == SDL_TEXTINPUT ||
 		    ev->ev.type == SDL_TEXTEDITING)
 		{
 			ret = GetFocusedObject()->ManuallyHandleEvent(ev);
 		}
 		// else will return IN_PASS because we never used the button.
 	}
 
 	return ret;
 }
 
 void CGUI::TickObjects()
 {
 	const CStr action = "tick";
 	m_BaseObject.RecurseObject(nullptr, &IGUIObject::ScriptEvent, action);
 
 	m_Tooltip.Update(FindObjectUnderMouse(), m_MousePos, *this);
 }
 
 void CGUI::SendEventToAll(const CStr& EventName)
 {
 	// janwas 2006-03-03: spoke with Ykkrosh about EventName case.
 	// when registering, case is converted to lower - this avoids surprise
 	// if someone were to get the case wrong and then not notice their
 	// handler is never called. however, until now, the other end
 	// (sending events here) wasn't converting to lower case,
 	// leading to a similar problem.
 	// now fixed; case is irrelevant since all are converted to lower.
 	const CStr EventNameLower = EventName.LowerCase();
 	m_BaseObject.RecurseObject(nullptr, &IGUIObject::ScriptEvent, EventNameLower);
 }
 
 void CGUI::SendEventToAll(const CStr& EventName, const JS::HandleValueArray& paramData)
 {
 	const CStr EventNameLower = EventName.LowerCase();
 	m_BaseObject.RecurseObject(nullptr, &IGUIObject::ScriptEvent, EventNameLower, paramData);
 }
 
 CGUI::CGUI(const shared_ptr<ScriptRuntime>& runtime)
 	: m_MouseButtons(0), m_FocusedObject(nullptr), m_InternalNameNumber(0), m_BaseObject(*this)
 {
 	m_ScriptInterface.reset(new ScriptInterface("Engine", "GUIPage", runtime));
 	m_ScriptInterface->SetCallbackData(this);
 
 	GuiScriptingInit(*m_ScriptInterface);
 	m_ScriptInterface->LoadGlobalScripts();
 }
 
 CGUI::~CGUI()
 {
 	for (const std::pair<CStr, IGUIObject*>& p : m_pAllObjects)
 		delete p.second;
 
 	for (const std::pair<CStr, const CGUISprite*>& p : m_Sprites)
 		delete p.second;
 }
 
 IGUIObject* CGUI::ConstructObject(const CStr& str)
 {
 	std::map<CStr, ConstructObjectFunction>::iterator it = m_ObjectTypes.find(str);
 	if (it != m_ObjectTypes.end())
 		return (*it->second)(*this);
 
 	// Error reporting will be handled with the nullptr return.
 	return nullptr;
 }
 
 void CGUI::Initialize()
 {
 	// Add base types!
 	//  You can also add types outside the GUI to extend the flexibility of the GUI.
 	//  Pyrogenesis though will have all the object types inserted from here.
 	AddObjectType("empty",			&CGUIDummyObject::ConstructObject);
 	AddObjectType("button",			&CButton::ConstructObject);
 	AddObjectType("image",			&CImage::ConstructObject);
 	AddObjectType("text",			&CText::ConstructObject);
 	AddObjectType("checkbox",		&CCheckBox::ConstructObject);
 	AddObjectType("radiobutton",	&CRadioButton::ConstructObject);
 	AddObjectType("progressbar",	&CProgressBar::ConstructObject);
 	AddObjectType("minimap",        &CMiniMap::ConstructObject);
 	AddObjectType("input",			&CInput::ConstructObject);
 	AddObjectType("list",			&CList::ConstructObject);
 	AddObjectType("olist",			&COList::ConstructObject);
 	AddObjectType("dropdown",		&CDropDown::ConstructObject);
 	AddObjectType("tooltip",		&CTooltip::ConstructObject);
 	AddObjectType("chart",			&CChart::ConstructObject);
 	AddObjectType("slider",			&CSlider::ConstructObject);
 }
 
 void CGUI::Draw()
 {
 	// Clear the depth buffer, so the GUI is
 	// drawn on top of everything else
 	glClear(GL_DEPTH_BUFFER_BIT);
 
-	try
-	{
-		m_BaseObject.RecurseObject(&IGUIObject::IsHidden, &IGUIObject::Draw);
-	}
-	catch (PSERROR_GUI& e)
-	{
-		LOGERROR("GUI draw error: %s", e.what());
-	}
+	m_BaseObject.RecurseObject(&IGUIObject::IsHidden, &IGUIObject::Draw);
 }
 
 void CGUI::DrawSprite(const CGUISpriteInstance& Sprite, int CellID, const float& Z, const CRect& Rect, const CRect& UNUSED(Clipping))
 {
 	// If the sprite doesn't exist (name == ""), don't bother drawing anything
 	if (!Sprite)
 		return;
 
 	// TODO: Clipping?
 
 	Sprite.Draw(*this, Rect, CellID, m_Sprites, Z);
 }
 
 void CGUI::UpdateResolution()
 {
-	// Update ALL cached
 	m_BaseObject.RecurseObject(nullptr, &IGUIObject::UpdateCachedSize);
 }
 
-void CGUI::AddObject(IGUIObject* pObject)
+bool CGUI::AddObject(IGUIObject& parent, IGUIObject& child)
 {
-	try
-	{
-		m_BaseObject.AddChild(pObject);
-
-		// Cache tree
-		pObject->RecurseObject(nullptr, &IGUIObject::UpdateCachedSize);
-
-		SGUIMessage msg(GUIM_LOAD);
-		pObject->RecurseObject(nullptr, &IGUIObject::HandleMessage, msg);
-	}
-	catch (PSERROR_GUI&)
+	if (child.m_Name.empty())
 	{
-		throw;
+		LOGERROR("Can't register an object without name!");
+		return false;
 	}
-}
 
-void CGUI::UpdateObjects()
-{
-	// We'll fill a temporary map until we know everything succeeded
-	map_pObjects AllObjects;
-
-	try
+	if (m_pAllObjects.find(child.m_Name) != m_pAllObjects.end())
 	{
-		// Fill freshly
-		m_BaseObject.RecurseObject(nullptr, &IGUIObject::AddToPointersMap, AllObjects);
-	}
-	catch (PSERROR_GUI&)
-	{
-		throw;
+		LOGERROR("Can't register more than one object of the name %s", child.m_Name.c_str());
+		return false;
 	}
 
-	// Else actually update the real one
-	m_pAllObjects.swap(AllObjects);
+	m_pAllObjects[child.m_Name] = &child;
+	parent.AddChild(child);
+	return true;
 }
 
 bool CGUI::ObjectExists(const CStr& Name) const
 {
 	return m_pAllObjects.find(Name) != m_pAllObjects.end();
 }
 
 IGUIObject* CGUI::FindObjectByName(const CStr& Name) const
 {
 	map_pObjects::const_iterator it = m_pAllObjects.find(Name);
 
 	if (it == m_pAllObjects.end())
 		return nullptr;
 
 	return it->second;
 }
 
 IGUIObject* CGUI::FindObjectUnderMouse()
 {
 	IGUIObject* pNearest = nullptr;
 	m_BaseObject.RecurseObject(&IGUIObject::IsHiddenOrGhost, &IGUIObject::ChooseMouseOverAndClosest, pNearest);
 	return pNearest;
 }
 
 void CGUI::SetFocusedObject(IGUIObject* pObject)
 {
 	if (pObject == m_FocusedObject)
 		return;
 
 	if (m_FocusedObject)
 	{
 		SGUIMessage msg(GUIM_LOST_FOCUS);
 		m_FocusedObject->HandleMessage(msg);
 	}
 
 	m_FocusedObject = pObject;
 
 	if (m_FocusedObject)
 	{
 		SGUIMessage msg(GUIM_GOT_FOCUS);
 		m_FocusedObject->HandleMessage(msg);
 	}
 }
 
 void CGUI::SetObjectHotkey(IGUIObject* pObject, const CStr& hotkeyTag)
 {
 	if (!hotkeyTag.empty())
 		m_HotkeyObjects[hotkeyTag].push_back(pObject);
 }
 
 void CGUI::UnsetObjectHotkey(IGUIObject* pObject, const CStr& hotkeyTag)
 {
 	if (hotkeyTag.empty())
 		return;
 
 	std::vector<IGUIObject*>& assignment = m_HotkeyObjects[hotkeyTag];
 
 	assignment.erase(
 		std::remove_if(
 			assignment.begin(),
 			assignment.end(),
 			[&pObject](const IGUIObject* hotkeyObject)
 				{ return pObject == hotkeyObject; }),
 		assignment.end());
 }
 
 void CGUI::SetGlobalHotkey(const CStr& hotkeyTag, JS::HandleValue function)
 {
 	JSContext* cx = m_ScriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 
 	if (hotkeyTag.empty())
 	{
 		JS_ReportError(cx, "Cannot assign a function to an empty hotkey identifier!");
 		return;
 	}
 
 	if (!function.isObject() || !JS_ObjectIsFunction(cx, &function.toObject()))
 	{
 		JS_ReportError(cx, "Cannot assign non-function value to global hotkey '%s'", hotkeyTag.c_str());
 		return;
 	}
 
 	UnsetGlobalHotkey(hotkeyTag);
 	m_GlobalHotkeys[hotkeyTag].init(cx, function);
 }
 
 void CGUI::UnsetGlobalHotkey(const CStr& hotkeyTag)
 {
 	m_GlobalHotkeys.erase(hotkeyTag);
 }
 
 const SGUIScrollBarStyle* CGUI::GetScrollBarStyle(const CStr& style) const
 {
 	std::map<CStr, const SGUIScrollBarStyle>::const_iterator it = m_ScrollBarStyles.find(style);
 	if (it == m_ScrollBarStyles.end())
 		return nullptr;
 
  	return &it->second;
 }
 
 /**
  * @callgraph
  */
 void CGUI::LoadXmlFile(const VfsPath& Filename, boost::unordered_set<VfsPath>& Paths)
 {
 	Paths.insert(Filename);
 
 	CXeromyces XeroFile;
 	if (XeroFile.Load(g_VFS, Filename, "gui") != PSRETURN_OK)
 		return;
 
 	XMBElement node = XeroFile.GetRoot();
-
 	CStr root_name(XeroFile.GetElementString(node.GetNodeName()));
-	try
-	{
-		if (root_name == "objects")
-		{
-			Xeromyces_ReadRootObjects(node, &XeroFile, Paths);
 
-			// Re-cache all values so these gets cached too.
-			//UpdateResolution();
-		}
-		else if (root_name == "sprites")
-			Xeromyces_ReadRootSprites(node, &XeroFile);
-		else if (root_name == "styles")
-			Xeromyces_ReadRootStyles(node, &XeroFile);
-		else if (root_name == "setup")
-			Xeromyces_ReadRootSetup(node, &XeroFile);
-		else
-			debug_warn(L"CGUI::LoadXmlFile error");
-	}
-	catch (PSERROR_GUI& e)
-	{
-		LOGERROR("Errors loading GUI file %s (%u)", Filename.string8(), e.getCode());
-		return;
-	}
+	if (root_name == "objects")
+		Xeromyces_ReadRootObjects(node, &XeroFile, Paths);
+	else if (root_name == "sprites")
+		Xeromyces_ReadRootSprites(node, &XeroFile);
+	else if (root_name == "styles")
+		Xeromyces_ReadRootStyles(node, &XeroFile);
+	else if (root_name == "setup")
+		Xeromyces_ReadRootSetup(node, &XeroFile);
+	else
+		LOGERROR("CGUI::LoadXmlFile encountered an unknown XML root node type: %s", root_name.c_str());
+}
+
+void CGUI::LoadedXmlFiles()
+{
+	m_BaseObject.RecurseObject(nullptr, &IGUIObject::UpdateCachedSize);
+
+	SGUIMessage msg(GUIM_LOAD);
+	m_BaseObject.RecurseObject(nullptr, &IGUIObject::HandleMessage, msg);
+
+	SendEventToAll("load");
 }
 
 //===================================================================
 //	XML Reading Xeromyces Specific Sub-Routines
 //===================================================================
 
 void CGUI::Xeromyces_ReadRootObjects(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths)
 {
 	int el_script = pFile->GetElementID("script");
 
 	std::vector<std::pair<CStr, CStr> > subst;
 
 	// Iterate main children
 	//  they should all be <object> or <script> elements
 	for (XMBElement child : Element.GetChildNodes())
 	{
 		if (child.GetNodeName() == el_script)
 			// Execute the inline script
 			Xeromyces_ReadScript(child, pFile, Paths);
 		else
 			// Read in this whole object into the GUI
 			Xeromyces_ReadObject(child, pFile, &m_BaseObject, subst, Paths, 0);
 	}
 }
 
 void CGUI::Xeromyces_ReadRootSprites(XMBElement Element, CXeromyces* pFile)
 {
 	for (XMBElement child : Element.GetChildNodes())
 		Xeromyces_ReadSprite(child, pFile);
 }
 
 void CGUI::Xeromyces_ReadRootStyles(XMBElement Element, CXeromyces* pFile)
 {
 	for (XMBElement child : Element.GetChildNodes())
 		Xeromyces_ReadStyle(child, pFile);
 }
 
 void CGUI::Xeromyces_ReadRootSetup(XMBElement Element, CXeromyces* pFile)
 {
 	for (XMBElement child : Element.GetChildNodes())
 	{
 		CStr name(pFile->GetElementString(child.GetNodeName()));
 
 		if (name == "scrollbar")
 			Xeromyces_ReadScrollBarStyle(child, pFile);
 		else if (name == "icon")
 			Xeromyces_ReadIcon(child, pFile);
 		else if (name == "tooltip")
 			Xeromyces_ReadTooltip(child, pFile);
 		else if (name == "color")
 			Xeromyces_ReadColor(child, pFile);
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 }
 
 void CGUI::Xeromyces_ReadObject(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths, u32 nesting_depth)
 {
 	ENSURE(pParent);
 
 	XMBAttributeList attributes = Element.GetAttributes();
 
 	CStr type(attributes.GetNamedItem(pFile->GetAttributeID("type")));
 	if (type.empty())
 		type = "empty";
 
 	// Construct object from specified type
 	//  henceforth, we need to do a rollback before aborting.
 	//  i.e. releasing this object
 	IGUIObject* object = ConstructObject(type);
 
 	if (!object)
 	{
 		LOGERROR("GUI: Unrecognized object type \"%s\"", type.c_str());
 		return;
 	}
 
 	// Cache some IDs for element attribute names, to avoid string comparisons
 	#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
 	#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
 	ELMT(object);
 	ELMT(action);
 	ELMT(repeat);
 	ELMT(translatableAttribute);
 	ELMT(translate);
 	ELMT(attribute);
 	ELMT(keep);
 	ELMT(include);
 	ATTR(style);
 	ATTR(type);
 	ATTR(name);
 	ATTR(z);
 	ATTR(on);
 	ATTR(file);
 	ATTR(directory);
 	ATTR(id);
 	ATTR(context);
 
 	//
 	//	Read Style and set defaults
 	//
 	//	If the setting "style" is set, try loading that setting.
 	//
 	//	Always load default (if it's available) first!
 	//
 	CStr argStyle(attributes.GetNamedItem(attr_style));
 
 	if (m_Styles.find("default") != m_Styles.end())
 		object->LoadStyle("default");
 
 	if (!argStyle.empty())
 	{
 		if (m_Styles.find(argStyle) == m_Styles.end())
 			LOGERROR("GUI: Trying to use style '%s' that doesn't exist.", argStyle.c_str());
 		else
 			object->LoadStyle(argStyle);
 	}
 
 	bool NameSet = false;
 	bool ManuallySetZ = false;
 
 	CStrW inclusionPath;
 
 	for (XMBAttribute attr : attributes)
 	{
 		// If value is "null", then it is equivalent as never being entered
-		if (CStr(attr.Value) == "null")
+		if (attr.Value == "null")
 			continue;
 
 		// Ignore "type" and "style", we've already checked it
 		if (attr.Name == attr_type || attr.Name == attr_style)
 			continue;
 
 		if (attr.Name == attr_name)
 		{
 			CStr name(attr.Value);
 
 			for (const std::pair<CStr, CStr>& sub : NameSubst)
 				name.Replace(sub.first, sub.second);
 
 			object->SetName(name);
 			NameSet = true;
 			continue;
 		}
 
 		if (attr.Name == attr_z)
 			ManuallySetZ = true;
 
 		object->SetSettingFromString(pFile->GetAttributeString(attr.Name), attr.Value.FromUTF8(), false);
 	}
 
 	// Check if name isn't set, generate an internal name in that case.
 	if (!NameSet)
 	{
 		object->SetName("__internal(" + CStr::FromInt(m_InternalNameNumber) + ")");
 		++m_InternalNameNumber;
 	}
 
 	CStrW caption(Element.GetText().FromUTF8());
 	if (!caption.empty())
 		object->SetSettingFromString("caption", caption, false);
 
 	for (XMBElement child : Element.GetChildNodes())
 	{
 		// Check what name the elements got
 		int element_name = child.GetNodeName();
 
 		if (element_name == elmt_object)
 		{
 			// Call this function on the child
 			Xeromyces_ReadObject(child, pFile, object, NameSubst, Paths, nesting_depth);
 		}
 		else if (element_name == elmt_action)
 		{
 			// Scripted <action> element
 
 			// Check for a 'file' parameter
 			CStrW filename(child.GetAttributes().GetNamedItem(attr_file).FromUTF8());
 
 			CStr code;
 
 			// If there is a file, open it and use it as the code
 			if (!filename.empty())
 			{
 				Paths.insert(filename);
 				CVFSFile scriptfile;
 				if (scriptfile.Load(g_VFS, filename) != PSRETURN_OK)
 				{
 					LOGERROR("Error opening GUI script action file '%s'", utf8_from_wstring(filename));
-					throw PSERROR_GUI_JSOpenFailed();
+					continue;
 				}
 
 				code = scriptfile.DecodeUTF8(); // assume it's UTF-8
 			}
 
 			XMBElementList grandchildren = child.GetChildNodes();
 			if (!grandchildren.empty()) // The <action> element contains <keep> and <translate> tags.
 				for (XMBElement grandchild : grandchildren)
 				{
 					if (grandchild.GetNodeName() == elmt_translate)
 						code += g_L10n.Translate(grandchild.GetText());
 					else if (grandchild.GetNodeName() == elmt_keep)
 						code += grandchild.GetText();
 				}
 			else // It’s pure JavaScript code.
 				// Read the inline code (concatenating to the file code, if both are specified)
 				code += CStr(child.GetText());
 
 			CStr action = CStr(child.GetAttributes().GetNamedItem(attr_on));
 
 			object->RegisterScriptHandler(action.LowerCase(), code, *this);
 		}
 		else if (element_name == elmt_repeat)
 		{
 			Xeromyces_ReadRepeat(child, pFile, object, NameSubst, Paths, nesting_depth);
 		}
 		else if (element_name == elmt_translatableAttribute)
 		{
 			// This is an element in the form “<translatableAttribute id="attributeName">attributeValue</translatableAttribute>”.
 			CStr attributeName(child.GetAttributes().GetNamedItem(attr_id)); // Read the attribute name.
 			if (attributeName.empty())
 			{
 				LOGERROR("GUI: ‘translatableAttribute’ XML element with empty ‘id’ XML attribute found. (object: %s)", object->GetPresentableName().c_str());
 				continue;
 			}
 
 			CStr value(child.GetText());
 			if (value.empty())
 				continue;
 
 			CStr context(child.GetAttributes().GetNamedItem(attr_context)); // Read the context if any.
 
 			CStr translatedValue = context.empty() ?
 				g_L10n.Translate(value) :
 				g_L10n.TranslateWithContext(context, value);
 
 			object->SetSettingFromString(attributeName, translatedValue.FromUTF8(), false);
 		}
 		else if (element_name == elmt_attribute)
 		{
 			// This is an element in the form “<attribute id="attributeName"><keep>Don’t translate this part
 			// </keep><translate>but translate this one.</translate></attribute>”.
 			CStr attributeName(child.GetAttributes().GetNamedItem(attr_id)); // Read the attribute name.
 			if (attributeName.empty())
 			{
 				LOGERROR("GUI: ‘attribute’ XML element with empty ‘id’ XML attribute found. (object: %s)", object->GetPresentableName().c_str());
 				continue;
 			}
 
 			CStr translatedValue;
 
 			for (XMBElement grandchild : child.GetChildNodes())
 			{
 				if (grandchild.GetNodeName() == elmt_translate)
 					translatedValue += g_L10n.Translate(grandchild.GetText());
 				else if (grandchild.GetNodeName() == elmt_keep)
 					translatedValue += grandchild.GetText();
 			}
 			object->SetSettingFromString(attributeName, translatedValue.FromUTF8(), false);
 		}
 		else if (element_name == elmt_include)
 		{
 			CStrW filename(child.GetAttributes().GetNamedItem(attr_file).FromUTF8());
 			CStrW directory(child.GetAttributes().GetNamedItem(attr_directory).FromUTF8());
 			if (!filename.empty())
 			{
 				if (!directory.empty())
 					LOGWARNING("GUI: Include element found with file name (%s) and directory name (%s). Only the file will be processed.", utf8_from_wstring(filename), utf8_from_wstring(directory));
 
 				Paths.insert(filename);
 
 				CXeromyces XeroIncluded;
 				if (XeroIncluded.Load(g_VFS, filename, "gui") != PSRETURN_OK)
 				{
 					LOGERROR("GUI: Error reading included XML: '%s'", utf8_from_wstring(filename));
 					continue;
 				}
 
 				XMBElement node = XeroIncluded.GetRoot();
 				if (node.GetNodeName() != XeroIncluded.GetElementID("object"))
 				{
 					LOGERROR("GUI: Error reading included XML: '%s', root element must have be of type 'object'.", utf8_from_wstring(filename));
 					continue;
 				}
 
 				if (nesting_depth+1 >= MAX_OBJECT_DEPTH)
 				{
 					LOGERROR("GUI: Too many nested GUI includes. Probably caused by a recursive include attribute. Abort rendering '%s'.", utf8_from_wstring(filename));
 					continue;
 				}
 
 				Xeromyces_ReadObject(node, &XeroIncluded, object, NameSubst, Paths, nesting_depth+1);
 			}
 			else if (!directory.empty())
 			{
 				if (nesting_depth+1 >= MAX_OBJECT_DEPTH)
 				{
 					LOGERROR("GUI: Too many nested GUI includes. Probably caused by a recursive include attribute. Abort rendering '%s'.", utf8_from_wstring(directory));
 					continue;
 				}
 
 				VfsPaths pathnames;
 				vfs::GetPathnames(g_VFS, directory, L"*.xml", pathnames);
 				for (const VfsPath& path : pathnames)
 				{
 					// as opposed to loading scripts, don't care if it's loaded before
 					// one might use the same parts of the GUI in different situations
 					Paths.insert(path);
 					CXeromyces XeroIncluded;
 					if (XeroIncluded.Load(g_VFS, path, "gui") != PSRETURN_OK)
 					{
 						LOGERROR("GUI: Error reading included XML: '%s'", path.string8());
 						continue;
 					}
 
 					XMBElement node = XeroIncluded.GetRoot();
 					if (node.GetNodeName() != XeroIncluded.GetElementID("object"))
 					{
 						LOGERROR("GUI: Error reading included XML: '%s', root element must have be of type 'object'.", path.string8());
 						continue;
 					}
 					Xeromyces_ReadObject(node, &XeroIncluded, object, NameSubst, Paths, nesting_depth+1);
 				}
 
 			}
 			else
 				LOGERROR("GUI: 'include' XML element must have valid 'file' or 'directory' attribute found. (object %s)", object->GetPresentableName().c_str());
 		}
 		else
 		{
 			// Try making the object read the tag.
 			if (!object->HandleAdditionalChildren(child, pFile))
 				LOGERROR("GUI: (object: %s) Reading unknown children for its type", object->GetPresentableName().c_str());
 		}
 	}
 
 	object->AdditionalChildrenHandled();
 
 	if (!ManuallySetZ)
 	{
 		// Set it automatically to 10 plus its parents
 		if (object->m_Absolute)
 			// If the object is absolute, we'll have to get the parent's Z buffered,
 			// and add to that!
 			object->SetSetting<float>("z", pParent->GetBufferedZ() + 10.f, false);
 		else
 			// If the object is relative, then we'll just store Z as "10"
 			object->SetSetting<float>("z", 10.f, false);
 	}
 
-	try
-	{
-		if (pParent == &m_BaseObject)
-			AddObject(object);
-		else
-			pParent->AddChild(object);
-	}
-	catch (PSERROR_GUI& e)
-	{
-		LOGERROR("GUI error: %s", e.what());
-	}
+	if (!AddObject(*pParent, *object))
+		delete object;
 }
 
 void CGUI::Xeromyces_ReadRepeat(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths, u32 nesting_depth)
 {
 	#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
 	#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
 	ELMT(object);
 	ATTR(count);
 	ATTR(var);
 
 	XMBAttributeList attributes = Element.GetAttributes();
 
 	int count = CStr(attributes.GetNamedItem(attr_count)).ToInt();
 	CStr var("["+attributes.GetNamedItem(attr_var)+"]");
 	if (var.size() < 3)
 		var = "[n]";
 
 	for (int n = 0; n < count; ++n)
 	{
 		NameSubst.emplace_back(var, "[" + CStr::FromInt(n) + "]");
 
 		XERO_ITER_EL(Element, child)
 		{
 			if (child.GetNodeName() == elmt_object)
 				Xeromyces_ReadObject(child, pFile, pParent, NameSubst, Paths, nesting_depth);
 		}
 		NameSubst.pop_back();
 	}
 }
 
 void CGUI::Xeromyces_ReadScript(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths)
 {
 	// Check for a 'file' parameter
 	CStrW file(Element.GetAttributes().GetNamedItem(pFile->GetAttributeID("file")).FromUTF8());
 
 	// If there is a file specified, open and execute it
 	if (!file.empty())
 	{
 		Paths.insert(file);
 		try
 		{
 			m_ScriptInterface->LoadGlobalScriptFile(file);
 		}
 		catch (PSERROR_Scripting& e)
 		{
 			LOGERROR("GUI: Error executing script %s: %s", utf8_from_wstring(file), e.what());
 		}
 	}
 
 	// If it has a directory attribute, read all JS files in that directory
 	CStrW directory(Element.GetAttributes().GetNamedItem(pFile->GetAttributeID("directory")).FromUTF8());
 	if (!directory.empty())
 	{
 		VfsPaths pathnames;
 		vfs::GetPathnames(g_VFS, directory, L"*.js", pathnames);
 		for (const VfsPath& path : pathnames)
 		{
 			// Only load new files (so when the insert succeeds)
 			if (Paths.insert(path).second)
 				try
 				{
 					m_ScriptInterface->LoadGlobalScriptFile(path);
 				}
 				catch (PSERROR_Scripting& e)
 				{
 					LOGERROR("GUI: Error executing script %s: %s", path.string8(), e.what());
 				}
 		}
 	}
 
 	// Execute inline scripts
 	try
 	{
 		CStr code(Element.GetText());
 		if (!code.empty())
 			m_ScriptInterface->LoadGlobalScript(L"Some XML file", code.FromUTF8());
 	}
 	catch (PSERROR_Scripting& e)
 	{
 		LOGERROR("GUI: Error executing inline script: %s", e.what());
 	}
 }
 
 void CGUI::Xeromyces_ReadSprite(XMBElement Element, CXeromyces* pFile)
 {
 	CGUISprite* Sprite = new CGUISprite;
 
 	// Get name, we know it exists because of DTD requirements
 	CStr name = Element.GetAttributes().GetNamedItem(pFile->GetAttributeID("name"));
 
 	if (m_Sprites.find(name) != m_Sprites.end())
 		LOGWARNING("GUI sprite name '%s' used more than once; first definition will be discarded", name.c_str());
 
 	// shared_ptr to link the effect to every image, faster than copy.
 	std::shared_ptr<SGUIImageEffects> effects;
 
 	for (XMBElement child : Element.GetChildNodes())
 	{
 		CStr ElementName(pFile->GetElementString(child.GetNodeName()));
 
 		if (ElementName == "image")
 			Xeromyces_ReadImage(child, pFile, *Sprite);
 		else if (ElementName == "effect")
 		{
 			if (effects)
 				LOGERROR("GUI <sprite> must not have more than one <effect>");
 			else
 			{
 				effects = std::make_shared<SGUIImageEffects>();
 				Xeromyces_ReadEffects(child, pFile, *effects);
 			}
 		}
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 
 	// Apply the effects to every image (unless the image overrides it with
 	// different effects)
 	if (effects)
 		for (SGUIImage* const& img : Sprite->m_Images)
 			if (!img->m_Effects)
 				img->m_Effects = effects;
 
 	m_Sprites.erase(name);
 	m_Sprites.emplace(name, Sprite);
 }
 
 void CGUI::Xeromyces_ReadImage(XMBElement Element, CXeromyces* pFile, CGUISprite& parent)
 {
 	SGUIImage* Image = new SGUIImage();
 
 	// TODO Gee: Setup defaults here (or maybe they are in the SGUIImage ctor)
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 		CStrW attr_value(attr.Value.FromUTF8());
 
 		if (attr_name == "texture")
 		{
 			Image->m_TextureName = VfsPath("art/textures/ui") / attr_value;
 		}
 		else if (attr_name == "size")
 		{
 			Image->m_Size.FromString(attr.Value);
 		}
 		else if (attr_name == "texture_size")
 		{
 			Image->m_TextureSize.FromString(attr.Value);
 		}
 		else if (attr_name == "real_texture_placement")
 		{
 			CRect rect;
 			if (!ParseString<CRect>(this, attr_value, rect))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_TexturePlacementInFile = rect;
 		}
 		else if (attr_name == "cell_size")
 		{
 			CSize size;
 			if (!ParseString<CSize>(this, attr_value, size))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_CellSize = size;
 		}
 		else if (attr_name == "fixed_h_aspect_ratio")
 		{
 			float val;
 			if (!ParseString<float>(this, attr_value, val))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_FixedHAspectRatio = val;
 		}
 		else if (attr_name == "round_coordinates")
 		{
 			bool b;
 			if (!ParseString<bool>(this, attr_value, b))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_RoundCoordinates = b;
 		}
 		else if (attr_name == "wrap_mode")
 		{
 			if (attr_value == L"repeat")
 				Image->m_WrapMode = GL_REPEAT;
 			else if (attr_value == L"mirrored_repeat")
 				Image->m_WrapMode = GL_MIRRORED_REPEAT;
 			else if (attr_value == L"clamp_to_edge")
 				Image->m_WrapMode = GL_CLAMP_TO_EDGE;
 			else
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 		}
 		else if (attr_name == "z_level")
 		{
 			float z_level;
 			if (!ParseString<float>(this, attr_value, z_level))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_DeltaZ = z_level/100.f;
 		}
 		else if (attr_name == "backcolor")
 		{
 			if (!ParseString<CGUIColor>(this, attr_value, Image->m_BackColor))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 		}
 		else if (attr_name == "bordercolor")
 		{
 			if (!ParseString<CGUIColor>(this, attr_value, Image->m_BorderColor))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 		}
 		else if (attr_name == "border")
 		{
 			bool b;
 			if (!ParseString<bool>(this, attr_value, b))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_Border = b;
 		}
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 
 	// Look for effects
 	for (XMBElement child : Element.GetChildNodes())
 	{
 		CStr ElementName(pFile->GetElementString(child.GetNodeName()));
 		if (ElementName == "effect")
 		{
 			if (Image->m_Effects)
 				LOGERROR("GUI <image> must not have more than one <effect>");
 			else
 			{
 				Image->m_Effects = std::make_shared<SGUIImageEffects>();
 				Xeromyces_ReadEffects(child, pFile, *Image->m_Effects);
 			}
 		}
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 
 	parent.AddImage(Image);
 }
 
 void CGUI::Xeromyces_ReadEffects(XMBElement Element, CXeromyces* pFile, SGUIImageEffects& effects)
 {
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 
 		if (attr_name == "add_color")
 		{
 			if (!effects.m_AddColor.ParseString(*this, attr.Value, 0))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr.Value);
 		}
 		else if (attr_name == "grayscale")
 			effects.m_Greyscale = true;
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 }
 
 void CGUI::Xeromyces_ReadStyle(XMBElement Element, CXeromyces* pFile)
 {
 	SGUIStyle style;
 	CStr name;
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 
 		// The "name" setting is actually the name of the style
 		//  and not a new default
 		if (attr_name == "name")
 			name = attr.Value;
 		else
 			style.m_SettingsDefaults.emplace(attr_name, attr.Value.FromUTF8());
 	}
 
 	m_Styles.erase(name);
 	m_Styles.emplace(name, std::move(style));
 }
 
 void CGUI::Xeromyces_ReadScrollBarStyle(XMBElement Element, CXeromyces* pFile)
 {
 	SGUIScrollBarStyle scrollbar;
 	CStr name;
 
 	// Setup some defaults.
 	scrollbar.m_MinimumBarSize = 0.f;
 	// Using 1.0e10 as a substitute for infinity
 	scrollbar.m_MaximumBarSize = 1.0e10;
 	scrollbar.m_UseEdgeButtons = false;
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name = pFile->GetAttributeString(attr.Name);
 		CStr attr_value(attr.Value);
 
 		if (attr_value == "null")
 			continue;
 
 		if (attr_name == "name")
 			name = attr_value;
 		else if (attr_name == "show_edge_buttons")
 		{
 			bool b;
 			if (!ParseString<bool>(this, attr_value.FromUTF8(), b))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr_value);
 			else
 				scrollbar.m_UseEdgeButtons = b;
 		}
 		else if (attr_name == "width")
 		{
 			float f;
 			if (!ParseString<float>(this, attr_value.FromUTF8(), f))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr_value);
 			else
 				scrollbar.m_Width = f;
 		}
 		else if (attr_name == "minimum_bar_size")
 		{
 			float f;
 			if (!ParseString<float>(this, attr_value.FromUTF8(), f))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr_value);
 			else
 				scrollbar.m_MinimumBarSize = f;
 		}
 		else if (attr_name == "maximum_bar_size")
 		{
 			float f;
 			if (!ParseString<float>(this, attr_value.FromUTF8(), f))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr_value);
 			else
 				scrollbar.m_MaximumBarSize = f;
 		}
 		else if (attr_name == "sprite_button_top")
 			scrollbar.m_SpriteButtonTop = attr_value;
 		else if (attr_name == "sprite_button_top_pressed")
 			scrollbar.m_SpriteButtonTopPressed = attr_value;
 		else if (attr_name == "sprite_button_top_disabled")
 			scrollbar.m_SpriteButtonTopDisabled = attr_value;
 		else if (attr_name == "sprite_button_top_over")
 			scrollbar.m_SpriteButtonTopOver = attr_value;
 		else if (attr_name == "sprite_button_bottom")
 			scrollbar.m_SpriteButtonBottom = attr_value;
 		else if (attr_name == "sprite_button_bottom_pressed")
 			scrollbar.m_SpriteButtonBottomPressed = attr_value;
 		else if (attr_name == "sprite_button_bottom_disabled")
 			scrollbar.m_SpriteButtonBottomDisabled = attr_value;
 		else if (attr_name == "sprite_button_bottom_over")
 			scrollbar.m_SpriteButtonBottomOver = attr_value;
 		else if (attr_name == "sprite_back_vertical")
 			scrollbar.m_SpriteBackVertical = attr_value;
 		else if (attr_name == "sprite_bar_vertical")
 			scrollbar.m_SpriteBarVertical = attr_value;
 		else if (attr_name == "sprite_bar_vertical_over")
 			scrollbar.m_SpriteBarVerticalOver = attr_value;
 		else if (attr_name == "sprite_bar_vertical_pressed")
 			scrollbar.m_SpriteBarVerticalPressed = attr_value;
 	}
 
 	m_ScrollBarStyles.erase(name);
 	m_ScrollBarStyles.emplace(name, std::move(scrollbar));
 }
 
 void CGUI::Xeromyces_ReadIcon(XMBElement Element, CXeromyces* pFile)
 {
 	SGUIIcon icon;
 	CStr name;
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 		CStr attr_value(attr.Value);
 
 		if (attr_value == "null")
 			continue;
 
 		if (attr_name == "name")
 			name = attr_value;
 		else if (attr_name == "sprite")
 			icon.m_SpriteName = attr_value;
 		else if (attr_name == "size")
 		{
 			CSize size;
 			if (!ParseString<CSize>(this, attr_value.FromUTF8(), size))
 				LOGERROR("Error parsing '%s' (\"%s\") inside <icon>.", attr_name, attr_value);
 			else
 				icon.m_Size = size;
 		}
 		else if (attr_name == "cell_id")
 		{
 			int cell_id;
 			if (!ParseString<int>(this, attr_value.FromUTF8(), cell_id))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\") inside <icon>.", attr_name, attr_value);
 			else
 				icon.m_CellID = cell_id;
 		}
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 
 	m_Icons.erase(name);
 	m_Icons.emplace(name, std::move(icon));
 }
 
 void CGUI::Xeromyces_ReadTooltip(XMBElement Element, CXeromyces* pFile)
 {
 	IGUIObject* object = new CTooltip(*this);
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 		CStr attr_value(attr.Value);
 
 		if (attr_name == "name")
 			object->SetName("__tooltip_" + attr_value);
 		else
 			object->SetSettingFromString(attr_name, attr_value.FromUTF8(), true);
 	}
 
-	AddObject(object);
+	if (!AddObject(m_BaseObject, *object))
+		delete object;
 }
 
 void CGUI::Xeromyces_ReadColor(XMBElement Element, CXeromyces* pFile)
 {
 	XMBAttributeList attributes = Element.GetAttributes();
 	CStr name = attributes.GetNamedItem(pFile->GetAttributeID("name"));
 
 	// Try parsing value
 	CStr value(Element.GetText());
 	if (value.empty())
 		return;
 
 	CColor color;
 	if (color.ParseString(value))
 	{
 		m_PreDefinedColors.erase(name);
 		m_PreDefinedColors.emplace(
 			std::piecewise_construct,
 			std::forward_as_tuple(name),
 			std::forward_as_tuple(color.r, color.g, color.b, color.a));
 	}
 	else
 		LOGERROR("GUI: Unable to create custom color '%s'. Invalid color syntax.", name.c_str());
 }
Index: ps/trunk/source/gui/CGUI.h
===================================================================
--- ps/trunk/source/gui/CGUI.h	(revision 23066)
+++ ps/trunk/source/gui/CGUI.h	(revision 23067)
@@ -1,650 +1,638 @@
 /* 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 "gui/GUITooltip.h"
 #include "gui/ObjectTypes/CGUIDummyObject.h"
 #include "gui/SettingTypes/CGUIColor.h"
 #include "gui/SGUIIcon.h"
 #include "gui/SGUIStyle.h"
 #include "lib/input.h"
 #include "ps/Shapes.h"
 #include "ps/XML/Xeromyces.h"
 #include "scriptinterface/ScriptInterface.h"
 
 #include <boost/unordered_set.hpp>
 #include <map>
 #include <vector>
 
-ERROR_TYPE(GUI, JSOpenFailed);
-
 extern const double SELECT_DBLCLICK_RATE;
 
 class CGUISpriteInstance;
 class CGUISprite;
 class IGUIObject;
 struct SGUIImageEffects;
 struct SGUIScrollBarStyle;
 
 /**
  * The main object that represents a whole GUI page.
  *
  * No interfacial functions throws.
  */
 class CGUI
 {
 	NONCOPYABLE(CGUI);
 
 private:
 	// Private typedefs
 	using ConstructObjectFunction = IGUIObject* (*)(CGUI&);
 
 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, const 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());
 
 	/**
 	 * 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);
 
 	/**
+	 * Called after all XML files linked in the page file were loaded.
+	 */
+	void LoadedXmlFiles();
+
+	/**
 	 * Allows the JS side to modify the hotkey setting assigned to a GUI object.
 	 */
 	void SetObjectHotkey(IGUIObject* pObject, const CStr& hotkeyTag);
 	void UnsetObjectHotkey(IGUIObject* pObject, const CStr& hotkeyTag);
 
 	/**
 	 * Allows the JS side to add or remove global hotkeys.
 	 */
 	void SetGlobalHotkey(const CStr& hotkeyTag, JS::HandleValue function);
 	void UnsetGlobalHotkey(const CStr& hotkeyTag);
 
 	/**
 	 * Return the object which is an ancestor of every other GUI object.
 	 */
 	CGUIDummyObject& GetBaseObject() { return m_BaseObject; };
 
 	/**
 	 * 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 nullptr
 	 * if no match is found,
 	 *
 	 * @param Name String name of object
 	 * @return Matching object, or nullptr
 	 */
 	IGUIObject* FindObjectByName(const CStr& Name) const;
 
 	/**
 	 * Returns the GUI object under the mouse, or nullptr if none.
 	 */
 	IGUIObject* FindObjectUnderMouse();
 
 	/**
 	 * Returns the current screen coordinates of the cursor.
 	 */
 	const CPos& GetMousePos() const { return m_MousePos; };
 
 	/**
 	 * Returns the currently pressed mouse buttons.
 	 */
 	const unsigned int& GetMouseButtons() { return m_MouseButtons; };
 
 	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();
 
 	/**
 	 * Check if an icon exists
 	 */
 	bool HasIcon(const CStr& name) const { return (m_Icons.find(name) != m_Icons.end()); }
 
 	/**
 	 * Get Icon (a const reference, can never be changed)
 	 */
 	const SGUIIcon& GetIcon(const CStr& name) const { return m_Icons.at(name); }
 
 	/**
 	 * Check if a style exists
 	 */
 	bool HasStyle(const CStr& name) const { return (m_Styles.find(name) != m_Styles.end()); }
 
 	/**
 	 * Get Style if it exists, otherwise throws an exception.
 	 */
 	const SGUIStyle& GetStyle(const CStr& name) const { return m_Styles.at(name); }
 
 	/**
 	 * Check if a predefined color of that name exists.
 	 */
 	bool HasPreDefinedColor(const CStr& name) const { return (m_PreDefinedColors.find(name) != m_PreDefinedColors.end()); }
 
 	/**
 	 * Resolve the predefined color if it exists, otherwise throws an exception.
 	 */
 	const CGUIColor& GetPreDefinedColor(const CStr& name) const { return m_PreDefinedColors.at(name); }
 
 	shared_ptr<ScriptInterface> GetScriptInterface() { return m_ScriptInterface; };
 	JS::Value GetGlobalObject() { return m_ScriptInterface->GetGlobalObject(); };
 
-	/**
-	 * 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();
-
 private:
 	/**
-	 * 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().
+	 * The CGUI takes ownership of the child object and links the parent with the child.
+	 * Returns false on failure to take over ownership of the child object.
 	 */
-	void AddObject(IGUIObject* pObject);
+	bool AddObject(IGUIObject& parent, IGUIObject& child);
 
 	/**
 	 * 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);
 
 public:
 	/**
 	 * Get Focused Object.
 	 */
 	IGUIObject* GetFocusedObject() { return m_FocusedObject; }
 
 	/**
 	 * Change focus to new object.
 	 * Will send LOST_FOCUS/GOT_FOCUS messages as appropriate.
 	 * pObject can be nullptr to remove all focus.
 	 */
 	void SetFocusedObject(IGUIObject* pObject);
 
 	/**
 	 * Reads a string value and modifies the given value of type T if successful.
 	 * Does not change the value upon conversion failure.
 	 *
 	 * @param pGUI The GUI page which may contain data relevant to the parsing
 	 *             (for example predefined colors).
 	 * @param Value The value in string form, like "0 0 100% 100%"
 	 * @param tOutput Parsed value of type T
 	 * @return True at success.
 	 */
 	template <typename T>
 	static bool ParseString(const CGUI* pGUI, const CStrW& Value, T& tOutput);
 
 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;
 
 	//@}
 	//--------------------------------------------------------
 	/** @name Objects */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Base Object, all its children are considered parentless
 	 * because this is not a real object per se.
 	 */
 	CGUIDummyObject 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).
 	 */
 	std::map<CStr, std::vector<IGUIObject*> > m_HotkeyObjects;
 
 	/**
 	 * Map from hotkey names to functions that are triggered if the hotkey is pressed.
 	 * Contrary to object hotkeys, this allows for only one global function per hotkey name.
 	 */
 	std::map<CStr, JS::PersistentRootedValue> m_GlobalHotkeys;
 
 	//--------------------------------------------------------
 	//	Databases
 	//	These are loaded from XML files and marked as noncopyable and const to
 	//	rule out unintentional modification and copy, especially during Draw calls.
 	//--------------------------------------------------------
 
 	// Colors
 	std::map<CStr, const CGUIColor> m_PreDefinedColors;
 
 	// Sprites
 	std::map<CStr, const CGUISprite*> m_Sprites;
 
 	// Styles
 	std::map<CStr, const SGUIStyle> m_Styles;
 
 	// Scroll-bar styles
 	std::map<CStr, const SGUIScrollBarStyle> m_ScrollBarStyles;
 
 	// Icons
 	std::map<CStr, const SGUIIcon> m_Icons;
 };
 
 #endif // INCLUDED_CGUI
Index: ps/trunk/source/gui/GUIManager.cpp
===================================================================
--- ps/trunk/source/gui/GUIManager.cpp	(revision 23066)
+++ ps/trunk/source/gui/GUIManager.cpp	(revision 23067)
@@ -1,402 +1,402 @@
 /* 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 "GUIManager.h"
 
 #include "gui/CGUI.h"
 #include "lib/timer.h"
 #include "ps/CLogger.h"
 #include "ps/Filesystem.h"
 #include "ps/GameSetup/Config.h"
 #include "ps/Profile.h"
 #include "ps/XML/Xeromyces.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "scriptinterface/ScriptRuntime.h"
 
 CGUIManager* g_GUI = nullptr;
 
 
 // General TODOs:
 //
 // A lot of the CGUI data could (and should) be shared between
 // multiple pages, instead of treating them as completely independent, to save
 // memory and loading time.
 
 
 // called from main loop when (input) events are received.
 // event is passed to other handlers if false is returned.
 // trampoline: we don't want to make the HandleEvent implementation static
 InReaction gui_handler(const SDL_Event_* ev)
 {
 	if (!g_GUI)
 		return IN_PASS;
 
 	PROFILE("GUI event handler");
 	return g_GUI->HandleEvent(ev);
 }
 
 static Status ReloadChangedFileCB(void* param, const VfsPath& path)
 {
 	return static_cast<CGUIManager*>(param)->ReloadChangedFile(path);
 }
 
 CGUIManager::CGUIManager()
 {
 	m_ScriptRuntime = g_ScriptRuntime;
 	m_ScriptInterface.reset(new ScriptInterface("Engine", "GUIManager", m_ScriptRuntime));
 	m_ScriptInterface->SetCallbackData(this);
 	m_ScriptInterface->LoadGlobalScripts();
 
 	if (!CXeromyces::AddValidator(g_VFS, "gui_page", "gui/gui_page.rng"))
 		LOGERROR("CGUIManager: failed to load GUI page grammar file 'gui/gui_page.rng'");
 	if (!CXeromyces::AddValidator(g_VFS, "gui", "gui/gui.rng"))
 		LOGERROR("CGUIManager: failed to load GUI XML grammar file 'gui/gui.rng'");
 
 	RegisterFileReloadFunc(ReloadChangedFileCB, this);
 }
 
 CGUIManager::~CGUIManager()
 {
 	UnregisterFileReloadFunc(ReloadChangedFileCB, this);
 }
 
 size_t CGUIManager::GetPageCount() const
 {
 	return m_PageStack.size();
 }
 
 void CGUIManager::SwitchPage(const CStrW& pageName, ScriptInterface* srcScriptInterface, JS::HandleValue initData)
 {
 	// The page stack is cleared (including the script context where initData came from),
 	// therefore we have to clone initData.
 
 	shared_ptr<ScriptInterface::StructuredClone> initDataClone;
 	if (!initData.isUndefined())
 		initDataClone = srcScriptInterface->WriteStructuredClone(initData);
 
 	m_PageStack.clear();
 
 	PushPage(pageName, initDataClone, JS::UndefinedHandleValue);
 }
 
 void CGUIManager::PushPage(const CStrW& pageName, shared_ptr<ScriptInterface::StructuredClone> initData, JS::HandleValue callbackFunction)
 {
 	// Store the callback handler in the current GUI page before opening the new one
 	if (!m_PageStack.empty() && !callbackFunction.isUndefined())
 		m_PageStack.back().SetCallbackFunction(*m_ScriptInterface, callbackFunction);
 
 	// Push the page prior to loading its contents, because that may push
 	// another GUI page on init which should be pushed on top of this new page.
 	m_PageStack.emplace_back(pageName, initData);
 	m_PageStack.back().LoadPage(m_ScriptRuntime);
 
 	ResetCursor();
 }
 
 void CGUIManager::PopPage(shared_ptr<ScriptInterface::StructuredClone> args)
 {
 	if (m_PageStack.size() < 2)
 	{
 		debug_warn(L"Tried to pop GUI page when there's < 2 in the stack");
 		return;
 	}
 
 	m_PageStack.pop_back();
 	m_PageStack.back().PerformCallbackFunction(args);
 }
 
 CGUIManager::SGUIPage::SGUIPage(const CStrW& pageName, const shared_ptr<ScriptInterface::StructuredClone> initData)
 	: name(pageName), initData(initData), inputs(), gui(), callbackFunction()
 {
 }
 
 void CGUIManager::SGUIPage::LoadPage(shared_ptr<ScriptRuntime> scriptRuntime)
 {
 	// If we're hotloading then try to grab some data from the previous page
 	shared_ptr<ScriptInterface::StructuredClone> hotloadData;
 	if (gui)
 	{
 		shared_ptr<ScriptInterface> scriptInterface = gui->GetScriptInterface();
 		JSContext* cx = scriptInterface->GetContext();
 		JSAutoRequest rq(cx);
 
 		JS::RootedValue global(cx, scriptInterface->GetGlobalObject());
 		JS::RootedValue hotloadDataVal(cx);
 		scriptInterface->CallFunction(global, "getHotloadData", &hotloadDataVal);
 		hotloadData = scriptInterface->WriteStructuredClone(hotloadDataVal);
 	}
 
 	inputs.clear();
 	gui.reset(new CGUI(scriptRuntime));
 
 	gui->Initialize();
 
 	VfsPath path = VfsPath("gui") / name;
 	inputs.insert(path);
 
 	CXeromyces xero;
 	if (xero.Load(g_VFS, path, "gui_page") != PSRETURN_OK)
 		// Fail silently (Xeromyces reported the error)
 		return;
 
 	int elmt_page = xero.GetElementID("page");
 	int elmt_include = xero.GetElementID("include");
 
 	XMBElement root = xero.GetRoot();
 
 	if (root.GetNodeName() != elmt_page)
 	{
 		LOGERROR("GUI page '%s' must have root element <page>", utf8_from_wstring(name));
 		return;
 	}
 
 	XERO_ITER_EL(root, node)
 	{
 		if (node.GetNodeName() != elmt_include)
 		{
 			LOGERROR("GUI page '%s' must only have <include> elements inside <page>", utf8_from_wstring(name));
 			continue;
 		}
 
 		std::string name = node.GetText();
 		CStrW nameW (node.GetText().FromUTF8());
 
 		PROFILE2("load gui xml");
 		PROFILE2_ATTR("name: %s", name.c_str());
 
 		TIMER(nameW.c_str());
 		if (name.back() == '/')
 		{
 			VfsPath directory = VfsPath("gui") / nameW;
 			VfsPaths pathnames;
 			vfs::GetPathnames(g_VFS, directory, L"*.xml", pathnames);
 			for (const VfsPath& path : pathnames)
 				gui->LoadXmlFile(path, inputs);
 		}
 		else
 		{
 			VfsPath path = VfsPath("gui") / nameW;
 			gui->LoadXmlFile(path, inputs);
 		}
 	}
 
-	gui->SendEventToAll("load");
+	gui->LoadedXmlFiles();
 
 	shared_ptr<ScriptInterface> scriptInterface = gui->GetScriptInterface();
 	JSContext* cx = scriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedValue initDataVal(cx);
 	JS::RootedValue hotloadDataVal(cx);
 	JS::RootedValue global(cx, scriptInterface->GetGlobalObject());
 
 	if (initData)
 		scriptInterface->ReadStructuredClone(initData, &initDataVal);
 
 	if (hotloadData)
 		scriptInterface->ReadStructuredClone(hotloadData, &hotloadDataVal);
 
 	if (scriptInterface->HasProperty(global, "init") &&
 	    !scriptInterface->CallFunctionVoid(global, "init", initDataVal, hotloadDataVal))
 		LOGERROR("GUI page '%s': Failed to call init() function", utf8_from_wstring(name));
 }
 
 void CGUIManager::SGUIPage::SetCallbackFunction(ScriptInterface& scriptInterface, JS::HandleValue callbackFunc)
 {
 	if (!callbackFunc.isObject())
 	{
 		LOGERROR("Given callback handler is not an object!");
 		return;
 	}
 
 	// Does not require JSAutoRequest
 	if (!JS_ObjectIsFunction(scriptInterface.GetContext(), &callbackFunc.toObject()))
 	{
 		LOGERROR("Given callback handler is not a function!");
 		return;
 	}
 
 	callbackFunction = std::make_shared<JS::PersistentRootedValue>(scriptInterface.GetJSRuntime(), callbackFunc);
 }
 
 void CGUIManager::SGUIPage::PerformCallbackFunction(shared_ptr<ScriptInterface::StructuredClone> args)
 {
 	if (!callbackFunction)
 		return;
 
 	shared_ptr<ScriptInterface> scriptInterface = gui->GetScriptInterface();
 	JSContext* cx = scriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedObject globalObj(cx, &scriptInterface->GetGlobalObject().toObject());
 
 	JS::RootedValue funcVal(cx, *callbackFunction);
 
 	// Delete the callback function, so that it is not called again
 	callbackFunction.reset();
 
 	JS::RootedValue argVal(cx);
 	if (args)
 		scriptInterface->ReadStructuredClone(args, &argVal);
 
 	JS::AutoValueVector paramData(cx);
 	paramData.append(argVal);
 
 	JS::RootedValue result(cx);
 
 	JS_CallFunctionValue(cx, globalObj, funcVal, paramData, &result);
 }
 
 Status CGUIManager::ReloadChangedFile(const VfsPath& path)
 {
 	for (SGUIPage& p : m_PageStack)
 		if (p.inputs.find(path) != p.inputs.end())
 		{
 			LOGMESSAGE("GUI file '%s' changed - reloading page '%s'", path.string8(), utf8_from_wstring(p.name));
 			p.LoadPage(m_ScriptRuntime);
 			// TODO: this can crash if LoadPage runs an init script which modifies the page stack and breaks our iterators
 		}
 
 	return INFO::OK;
 }
 
 Status CGUIManager::ReloadAllPages()
 {
 	// TODO: this can crash if LoadPage runs an init script which modifies the page stack and breaks our iterators
 	for (SGUIPage& p : m_PageStack)
 		p.LoadPage(m_ScriptRuntime);
 
 	return INFO::OK;
 }
 
 void CGUIManager::ResetCursor()
 {
 	g_CursorName = g_DefaultCursor;
 }
 
 InReaction CGUIManager::HandleEvent(const SDL_Event_* ev)
 {
 	// We want scripts to have access to the raw input events, so they can do complex
 	// processing when necessary (e.g. for unit selection and camera movement).
 	// Sometimes they'll want to be layered behind the GUI widgets (e.g. to detect mousedowns on the
 	// visible game area), sometimes they'll want to intercepts events before the GUI (e.g.
 	// to capture all mouse events until a mouseup after dragging).
 	// So we call two separate handler functions:
 
 	bool handled = false;
 
 	{
 		PROFILE("handleInputBeforeGui");
 		JSContext* cx = top()->GetScriptInterface()->GetContext();
 		JSAutoRequest rq(cx);
 		JS::RootedValue global(cx, top()->GetGlobalObject());
 		if (top()->GetScriptInterface()->CallFunction(global, "handleInputBeforeGui", handled, *ev, top()->FindObjectUnderMouse()))
 			if (handled)
 				return IN_HANDLED;
 	}
 
 	{
 		PROFILE("handle event in native GUI");
 		InReaction r = top()->HandleEvent(ev);
 		if (r != IN_PASS)
 			return r;
 	}
 
 	{
 		// We can't take the following lines out of this scope because top() may be another gui page than it was when calling handleInputBeforeGui!
 		JSContext* cx = top()->GetScriptInterface()->GetContext();
 		JSAutoRequest rq(cx);
 		JS::RootedValue global(cx, top()->GetGlobalObject());
 
 		PROFILE("handleInputAfterGui");
 		if (top()->GetScriptInterface()->CallFunction(global, "handleInputAfterGui", handled, *ev))
 			if (handled)
 				return IN_HANDLED;
 	}
 
 	return IN_PASS;
 }
 
 void CGUIManager::SendEventToAll(const CStr& eventName) const
 {
 	top()->SendEventToAll(eventName);
 }
 
 void CGUIManager::SendEventToAll(const CStr& eventName, JS::HandleValueArray paramData) const
 {
 	top()->SendEventToAll(eventName, paramData);
 }
 
 void CGUIManager::TickObjects()
 {
 	PROFILE3("gui tick");
 
 	// We share the script runtime with everything else that runs in the same thread.
 	// This call makes sure we trigger GC regularly even if the simulation is not running.
 	m_ScriptInterface->GetRuntime()->MaybeIncrementalGC(1.0f);
 
 	// Save an immutable copy so iterators aren't invalidated by tick handlers
 	PageStackType pageStack = m_PageStack;
 
 	for (const SGUIPage& p : pageStack)
 		p.gui->TickObjects();
 }
 
 void CGUIManager::Draw() const
 {
 	PROFILE3_GPU("gui");
 
 	for (const SGUIPage& p : m_PageStack)
 		p.gui->Draw();
 }
 
 void CGUIManager::UpdateResolution()
 {
 	// Save an immutable copy so iterators aren't invalidated by event handlers
 	PageStackType pageStack = m_PageStack;
 
 	for (const SGUIPage& p : pageStack)
 	{
 		p.gui->UpdateResolution();
 		p.gui->SendEventToAll("WindowResized");
 	}
 }
 
 bool CGUIManager::TemplateExists(const std::string& templateName) const
 {
 	return m_TemplateLoader.TemplateExists(templateName);
 }
 
 const CParamNode& CGUIManager::GetTemplate(const std::string& templateName)
 {
 	const CParamNode& templateRoot = m_TemplateLoader.GetTemplateFileData(templateName).GetChild("Entity");
 	if (!templateRoot.IsOk())
 		LOGERROR("Invalid template found for '%s'", templateName.c_str());
 
 	return templateRoot;
 }
 
 // This returns a shared_ptr to make sure the CGUI doesn't get deallocated
 // while we're in the middle of calling a function on it (e.g. if a GUI script
 // calls SwitchPage)
 shared_ptr<CGUI> CGUIManager::top() const
 {
 	ENSURE(m_PageStack.size());
 	return m_PageStack.back().gui;
 }
Index: ps/trunk/source/gui/ObjectBases/IGUIObject.cpp
===================================================================
--- ps/trunk/source/gui/ObjectBases/IGUIObject.cpp	(revision 23066)
+++ ps/trunk/source/gui/ObjectBases/IGUIObject.cpp	(revision 23067)
@@ -1,550 +1,502 @@
 /* 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 "IGUIObject.h"
 
 #include "gui/CGUI.h"
 #include "gui/CGUISetting.h"
 #include "ps/CLogger.h"
 #include "ps/GameSetup/Config.h"
 #include "ps/Profile.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "soundmanager/ISoundManager.h"
 
 IGUIObject::IGUIObject(CGUI& pGUI)
 	: m_pGUI(pGUI),
 	  m_pParent(),
 	  m_MouseHovering(),
 	  m_LastClickTime(),
 	  m_Enabled(),
 	  m_Hidden(),
 	  m_Size(),
 	  m_Style(),
 	  m_Hotkey(),
 	  m_Z(),
 	  m_Absolute(),
 	  m_Ghost(),
 	  m_AspectRatio(),
 	  m_Tooltip(),
 	  m_TooltipStyle()
 {
 	RegisterSetting("enabled", m_Enabled);
 	RegisterSetting("hidden", m_Hidden);
 	RegisterSetting("size", m_Size);
 	RegisterSetting("style", m_Style);
 	RegisterSetting("hotkey", m_Hotkey);
 	RegisterSetting("z", m_Z);
 	RegisterSetting("absolute", m_Absolute);
 	RegisterSetting("ghost", m_Ghost);
 	RegisterSetting("aspectratio", m_AspectRatio);
 	RegisterSetting("tooltip", m_Tooltip);
 	RegisterSetting("tooltip_style", m_TooltipStyle);
 
 	// Setup important defaults
 	// TODO: Should be in the default style?
 	SetSetting<bool>("hidden", false, true);
 	SetSetting<bool>("ghost", false, true);
 	SetSetting<bool>("enabled", true, true);
 	SetSetting<bool>("absolute", true, true);
 }
 
 IGUIObject::~IGUIObject()
 {
 	for (const std::pair<CStr, IGUISetting*>& p : m_Settings)
 		delete p.second;
 
 	if (!m_ScriptHandlers.empty())
 		JS_RemoveExtraGCRootsTracer(m_pGUI.GetScriptInterface()->GetJSRuntime(), Trace, this);
-}
-
-//-------------------------------------------------------------------
-//  Functions
-//-------------------------------------------------------------------
-
-void IGUIObject::AddChild(IGUIObject* pChild)
-{
-//	ENSURE(pChild);
-
-	pChild->SetParent(this);
-
-	m_Children.push_back(pChild);
 
-	{
-		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
+	// m_Children is deleted along all other GUI Objects in the CGUI destructor
 }
 
-void IGUIObject::AddToPointersMap(map_pObjects& ObjectMap)
+void IGUIObject::AddChild(IGUIObject& pChild)
 {
-	// Just don't do anything about the top node
-	if (m_pParent == nullptr)
-		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.find(m_Name) != ObjectMap.end())
-	{
-		throw PSERROR_GUI_NameAmbiguity(m_Name.c_str());
-	}
-	else
-	{
-		ObjectMap[m_Name] = this;
-	}
+	pChild.SetParent(this);
+	m_Children.push_back(&pChild);
 }
 
 template<typename T>
 void IGUIObject::RegisterSetting(const CStr& Name, T& Value)
 {
 	if (SettingExists(Name))
 		LOGERROR("The setting '%s' already exists on the object '%s'!", Name.c_str(), GetPresentableName().c_str());
 	else
 		m_Settings.emplace(Name, new CGUISetting<T>(*this, Name, Value));
 }
 
 bool IGUIObject::SettingExists(const CStr& Setting) const
 {
 	return m_Settings.find(Setting) != m_Settings.end();
 }
 
 template <typename T>
 T& IGUIObject::GetSetting(const CStr& Setting)
 {
 	return static_cast<CGUISetting<T>* >(m_Settings.at(Setting))->m_pSetting;
 }
 
 template <typename T>
 const T& IGUIObject::GetSetting(const CStr& Setting) const
 {
 	return static_cast<CGUISetting<T>* >(m_Settings.at(Setting))->m_pSetting;
 }
 
 bool IGUIObject::SetSettingFromString(const CStr& Setting, const CStrW& Value, const bool SendMessage)
 {
 	const std::map<CStr, IGUISetting*>::iterator it = m_Settings.find(Setting);
 	if (it == m_Settings.end())
 	{
 		LOGERROR("GUI object '%s' has no property called '%s', can't set parse and set value '%s'", GetPresentableName().c_str(), Setting.c_str(), Value.ToUTF8().c_str());
 		return false;
 	}
 	return it->second->FromString(Value, SendMessage);
 }
 
 template <typename T>
 void IGUIObject::SetSetting(const CStr& Setting, T& Value, const bool SendMessage)
 {
 	PreSettingChange(Setting);
 	static_cast<CGUISetting<T>* >(m_Settings.at(Setting))->m_pSetting = std::move(Value);
 	SettingChanged(Setting, SendMessage);
 }
 
 template <typename T>
 void IGUIObject::SetSetting(const CStr& Setting, const T& Value, const bool SendMessage)
 {
 	PreSettingChange(Setting);
 	static_cast<CGUISetting<T>* >(m_Settings.at(Setting))->m_pSetting = Value;
 	SettingChanged(Setting, SendMessage);
 }
 
 void IGUIObject::PreSettingChange(const CStr& Setting)
 {
 	if (Setting == "hotkey")
 		m_pGUI.UnsetObjectHotkey(this, GetSetting<CStr>(Setting));
 }
 
 void IGUIObject::SettingChanged(const CStr& Setting, const bool SendMessage)
 {
 	if (Setting == "size")
 	{
 		// If setting was "size", we need to re-cache itself and all children
 		RecurseObject(nullptr, &IGUIObject::UpdateCachedSize);
 	}
 	else if (Setting == "hidden")
 	{
 		// Hiding an object requires us to reset it and all children
 		if (m_Hidden)
 			RecurseObject(nullptr, &IGUIObject::ResetStates);
 	}
 	else if (Setting == "hotkey")
 		m_pGUI.SetObjectHotkey(this, GetSetting<CStr>(Setting));
 
 	if (SendMessage)
 	{
 		SGUIMessage msg(GUIM_SETTINGS_UPDATED, Setting);
 		HandleMessage(msg);
 	}
 }
 
 bool IGUIObject::IsMouseOver() const
 {
 	return m_CachedActualSize.PointInside(m_pGUI.GetMousePos());
 }
 
 bool IGUIObject::MouseOverIcon()
 {
 	return false;
 }
 
 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");
 		}
 	}
 }
 
 void IGUIObject::ChooseMouseOverAndClosest(IGUIObject*& pObject)
 {
 	if (!IsMouseOver())
 		return;
 
 	// Check if we've got competition at all
 	if (pObject == nullptr)
 	{
 		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 && m_pParent->m_pParent == nullptr)
 		return nullptr;
 
 	return m_pParent;
 }
 
 void IGUIObject::ResetStates()
 {
 	// Notify the gui that we aren't hovered anymore
 	UpdateMouseOver(nullptr);
 }
 
 void IGUIObject::UpdateCachedSize()
 {
 	// 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 (!m_Absolute && m_pParent && !IsRootObject())
 		m_CachedActualSize = m_Size.GetSize(m_pParent->m_CachedActualSize);
 	else
 		m_CachedActualSize = m_Size.GetSize(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 (m_AspectRatio)
 	{
 		if (m_CachedActualSize.GetWidth() > m_CachedActualSize.GetHeight() * m_AspectRatio)
 		{
 			float delta = m_CachedActualSize.GetWidth() - m_CachedActualSize.GetHeight() * m_AspectRatio;
 			m_CachedActualSize.left += delta/2.f;
 			m_CachedActualSize.right -= delta/2.f;
 		}
 		else
 		{
 			float delta = m_CachedActualSize.GetHeight() - m_CachedActualSize.GetWidth() / m_AspectRatio;
 			m_CachedActualSize.bottom -= delta/2.f;
 			m_CachedActualSize.top += delta/2.f;
 		}
 	}
 }
 
 void IGUIObject::LoadStyle(const CStr& StyleName)
 {
 	if (!m_pGUI.HasStyle(StyleName))
 		debug_warn(L"IGUIObject::LoadStyle failed");
 
 	// The default style may specify settings for any GUI object.
 	// Other styles are reported if they specify a Setting that does not exist,
 	// so that the XML author is informed and can correct the style.
 
 	for (const std::pair<CStr, CStrW>& p : m_pGUI.GetStyle(StyleName).m_SettingsDefaults)
 	{
 		if (SettingExists(p.first))
 			SetSettingFromString(p.first, p.second, true);
 		else if (StyleName != "default")
 			LOGWARNING("GUI object has no setting \"%s\", but the style \"%s\" defines it", p.first, StyleName.c_str());
 	}
 }
 
 float IGUIObject::GetBufferedZ() const
 {
 	if (m_Absolute)
 		return m_Z;
 
 	if (GetParent())
 		return GetParent()->GetBufferedZ() + m_Z;
 
 	// 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 m_Z;
 }
 
 void IGUIObject::RegisterScriptHandler(const CStr& Action, const CStr& Code, CGUI& pGUI)
 {
 	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.setIsRunOnce(false);
 
 	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)
 {
 	if (m_ScriptHandlers.empty())
 		JS_AddExtraGCRootsTracer(m_pGUI.GetScriptInterface()->GetJSRuntime(), Trace, this);
 
 	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);
 
 	const CPos& mousePos = m_pGUI.GetMousePos();
 
 	ScriptInterface::CreateObject(
 		cx,
 		&mouse,
 		"x", mousePos.x,
 		"y", mousePos.y,
 		"buttons", m_pGUI.GetMouseButtons());
 
 	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, const 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());
 }
 
 void IGUIObject::CreateJSObject()
 {
 	JSContext* cx = m_pGUI.GetScriptInterface()->GetContext();
 	JSAutoRequest rq(cx);
 
 	m_JSObject.init(cx, m_pGUI.GetScriptInterface()->CreateCustomObject("GUIObject"));
 	JS_SetPrivate(m_JSObject.get(), this);
 
 	RegisterScriptFunctions();
 }
 
 JSObject* IGUIObject::GetJSObject()
 {
 	// Cache the object when somebody first asks for it, because otherwise
 	// we end up doing far too much object allocation.
 	if (!m_JSObject.initialized())
 		CreateJSObject();
 
 	return m_JSObject.get();
 }
 
 bool IGUIObject::IsEnabled() const
 {
 	return m_Enabled;
 }
 
 bool IGUIObject::IsHidden() const
 {
 	return m_Hidden;
 }
 
 bool IGUIObject::IsHiddenOrGhost() const
 {
 	return m_Hidden || m_Ghost;
 }
 
 void IGUIObject::PlaySound(const CStrW& soundPath) const
 {
 	if (g_SoundManager && !soundPath.empty())
 		g_SoundManager->PlayAsUI(soundPath.c_str(), false);
 }
 
 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()
 {
 	m_pGUI.SetFocusedObject(this);
 }
 
 bool IGUIObject::IsFocused() const
 {
 	return m_pGUI.GetFocusedObject() == this;
 }
 
 bool IGUIObject::IsBaseObject() const
 {
 	return this == &m_pGUI.GetBaseObject();
 }
 
 bool IGUIObject::IsRootObject() const
 {
 	return m_pParent == &m_pGUI.GetBaseObject();
 }
 
 void IGUIObject::TraceMember(JSTracer* trc)
 {
 	// Please ensure to adapt the Tracer enabling and disabling in accordance with the GC things traced!
 
 	for (std::pair<const CStr, JS::Heap<JSObject*>>& handler : m_ScriptHandlers)
 		JS_CallObjectTracer(trc, &handler.second, "IGUIObject::m_ScriptHandlers");
 }
 
 // Instantiate templated functions:
 // These functions avoid copies by working with a reference and move semantics.
 #define TYPE(T) \
 	template void IGUIObject::RegisterSetting<T>(const CStr& Name, T& Value); \
 	template T& IGUIObject::GetSetting<T>(const CStr& Setting); \
 	template const T& IGUIObject::GetSetting<T>(const CStr& Setting) const; \
 	template void IGUIObject::SetSetting<T>(const CStr& Setting, T& Value, const bool SendMessage); \
 
 #include "gui/GUISettingTypes.h"
 #undef TYPE
 
 // Copying functions - discouraged except for primitives.
 #define TYPE(T) \
 	template void IGUIObject::SetSetting<T>(const CStr& Setting, const T& Value, const bool SendMessage); \
 
 #define GUITYPE_IGNORE_NONCOPYABLE
 #include "gui/GUISettingTypes.h"
 #undef GUITYPE_IGNORE_NONCOPYABLE
 #undef TYPE
Index: ps/trunk/source/gui/ObjectBases/IGUIObject.h
===================================================================
--- ps/trunk/source/gui/ObjectBases/IGUIObject.h	(revision 23066)
+++ ps/trunk/source/gui/ObjectBases/IGUIObject.h	(revision 23067)
@@ -1,525 +1,501 @@
 /* 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 "gui/Scripting/JSInterface_IGUIObject.h"
 #include "gui/SettingTypes/CGUISize.h"
 #include "gui/SGUIMessage.h"
 #include "lib/input.h" // just for IN_PASS
 #include "ps/XML/Xeromyces.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
 class CGUI;
 class IGUIObject;
 class IGUISetting;
 
 using map_pObjects = std::map<CStr, IGUIObject*>;
 
 #define GUI_OBJECT(obj) \
 public: \
 	static IGUIObject* ConstructObject(CGUI& pGUI) \
 		{ return new obj(pGUI); }
 
 /**
  * GUI object such as a button or an input-box.
  * Abstract data type !
  */
 class IGUIObject
 {
 	friend class CGUI;
 
 	// 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, JS::MutableHandleValue vp, JS::ObjectOpResult& result);
 	friend bool JSI_IGUIObject::getComputedSize(JSContext* cx, uint argc, JS::Value* vp);
 
 public:
 	NONCOPYABLE(IGUIObject);
 
 	IGUIObject(CGUI& pGUI);
 	virtual ~IGUIObject();
 
 	/**
 	 * 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.
 	 *
 	 * This function also returns true if there is a different
 	 * GUI object shown on top of this one.
 	 */
 	virtual bool IsMouseOver() const;
 
 	/**
 	 * This function returns true if the mouse is hovering
 	 * over this GUI object and if this GUI object is the
 	 * topmost object in that screen location.
 	 * For example when hovering dropdown list items, the
 	 * buttons beneath the list won't return true here.
 	 */
 	virtual bool IsMouseHovering() const { return m_MouseHovering; }
 
 	/**
 	 * 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().
+	 * Builds the object hierarchy with references.
 	 */
-	void AddChild(IGUIObject* pChild);
+	void AddChild(IGUIObject& pChild);
 
 	/**
 	 * Return all child objects of the current object.
 	 */
 	const std::vector<IGUIObject*>& GetChildren() const { return m_Children; }
 
 	//@}
 	//--------------------------------------------------------
 	/** @name Settings Management */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Registers the given setting variables with the GUI object.
 	 * Enable XML and JS to modify the given variable.
 	 *
 	 * @param Type Setting type
 	 * @param Name Setting reference name
 	 */
 	template<typename T>
 	void RegisterSetting(const CStr& Name, T& Value);
 
 	/**
 	 * Returns whether there is a setting with the given name registered.
 	 *
 	 * @param Setting setting name
 	 * @return True if settings exist.
 	 */
 	bool SettingExists(const CStr& Setting) const;
 
 	/**
 	 * Get a mutable reference to the setting.
 	 * If no such setting exists, an exception of type std::out_of_range is thrown.
 	 * If the value is modified, there is no GUIM_SETTINGS_UPDATED message sent.
 	 */
 	template <typename T>
 	T& GetSetting(const CStr& Setting);
 
 	template <typename T>
 	const T& GetSetting(const CStr& Setting) const;
 
 	/**
 	 * Set a setting by string, regardless of what type it is.
 	 * Used to parse setting values from XML files.
 	 * For example a CRect(10,10,20,20) is created from "10 10 20 20".
 	 * Returns false if the conversion fails, otherwise true.
 	 */
 	bool SetSettingFromString(const CStr& Setting, const CStrW& Value, const bool SendMessage);
 
 	/**
 	 * Assigns the given value to the setting identified by the given name.
 	 * Uses move semantics, so do not read from Value after this call.
 	 *
 	 * @param SendMessage If true, a GUIM_SETTINGS_UPDATED message will be broadcasted to all GUI objects.
 	 */
 	template <typename T>
 	void SetSetting(const CStr& Setting, T& Value, const bool SendMessage);
 
 	/**
 	 * This variant will copy the value.
 	 */
 	template <typename T>
 	void SetSetting(const CStr& Setting, const T& Value, const bool SendMessage);
 
 	/**
 	 * Returns whether this object is set to be hidden or ghost.
 	 */
 	bool IsEnabled() const;
 
 	/**
 	 * Returns whether this is object is set to be hidden.
 	 */
 	bool IsHidden() const;
 
 	/**
 	 * Returns whether this object is set to be hidden or ghost.
 	 */
 	bool IsHiddenOrGhost() const;
 
 	/**
 	 * Retrieves the configured sound filename from the given setting name and plays that once.
 	 */
 	void PlaySound(const CStrW& soundPath) const;
 
 	/**
 	 * 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);
 
 	/**
 	 * 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 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);
 
 	/**
 	 * Inheriting classes may append JS functions to the JS object representing this class.
 	 */
 	virtual void RegisterScriptFunctions() {}
 
 	/**
 	 * 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
 	 */
 	//--------------------------------------------------------
 	//@{
 
 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)) {}
 
 	/**
 	 * Calls an IGUIObject member function recursively on this object and its children.
 	 * Aborts recursion at IGUIObjects that have the isRestricted function return true.
 	 * The arguments of the callback function must be references.
 	*/
 	template<typename... Args>
 	void RecurseObject(bool(IGUIObject::*isRestricted)() const, void(IGUIObject::*callbackFunction)(Args... args), Args&&... args)
 	{
 		if (!IsBaseObject())
 		{
 			if (isRestricted && (this->*isRestricted)())
 				return;
 
 			(this->*callbackFunction)(args...);
 		}
 
 		for (IGUIObject* const& obj : m_Children)
 			obj->RecurseObject(isRestricted, callbackFunction, args...);
 	}
 
 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.
 	 */
 	void LoadStyle(const CStr& StyleName);
 
 	/**
 	 * 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;
 
 	/**
 	 * Set parent of this object
 	 */
 	void SetParent(IGUIObject* pParent) { m_pParent = pParent; }
 
 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 nullptr, so that the top-node's children are
 	 * seemingly parentless.
 	 *
 	 * @return Pointer to parent
 	 */
 	IGUIObject* GetParent() 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;
 	}
 
 	/**
 	 * Allow the GUI object to process after all child items were handled.
 	 * Useful to avoid iterator invalidation with push_back calls.
 	 */
 	virtual void AdditionalChildrenHandled() {}
 
 	/**
 	 * 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;
 
 	/**
 	 * 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, const 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 be nullptr too!
 	 */
 	void UpdateMouseOver(IGUIObject* const& pMouseOver);
 
 	//@}
 private:
 	//--------------------------------------------------------
 	/** @name Internal functions */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Creates the JS object representing this page upon first use.
 	 */
 	void CreateJSObject();
 
 	/**
 	 * Updates some internal data depending on the setting changed.
 	 */
 	void PreSettingChange(const CStr& Setting);
 	void SettingChanged(const CStr& Setting, const bool SendMessage);
 
 	/**
 	 * 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 nullptr, which means the Z value demand
 	 *  is out. NOTICE you can't input nullptr as const so you'll have
 	 * to set an object to nullptr.
 	 *
 	 * @param pObject	Object pointer, can be either the old one, or
 	 *					the new one.
 	 */
 	void ChooseMouseOverAndClosest(IGUIObject*& pObject);
 
 	/**
 	 * Returns whether this is the object all other objects are descendants of.
 	 */
 	bool IsBaseObject() const;
 
 	/**
 	 * Returns whether this object is a child of the base object.
 	 */
 	bool IsRootObject() 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 CGUI
 	std::vector<IGUIObject*> m_Children;
 
 	// Pointer to parent
 	IGUIObject* m_pParent;
 
 	//This represents the last click time for each mouse button
 	double m_LastClickTime[6];
 
 	/**
 	 * This variable is true if the mouse is hovering this object and
 	 * this object is the topmost object shown in this location.
 	 */
 	bool m_MouseHovering;
 
 	/**
 	 * Settings pool, all an object's settings are located here
 	 */
 	std::map<CStr, IGUISetting*> m_Settings;
 
 	// 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;
 
 	// Cache references to settings for performance
 	bool m_Enabled;
 	bool m_Hidden;
 	CGUISize m_Size;
 	CStr m_Style;
 	CStr m_Hotkey;
 	float m_Z;
 	bool m_Absolute;
 	bool m_Ghost;
 	float m_AspectRatio;
 	CStrW m_Tooltip;
 	CStr m_TooltipStyle;
 };
 
 #endif // INCLUDED_IGUIOBJECT
Index: ps/trunk/source/gui/SGUIMessage.h
===================================================================
--- ps/trunk/source/gui/SGUIMessage.h	(revision 23066)
+++ ps/trunk/source/gui/SGUIMessage.h	(revision 23067)
@@ -1,95 +1,95 @@
 /* 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/>.
  */
 
 #ifndef INCLUDED_SGUIMESSAGE
 #define INCLUDED_SGUIMESSAGE
 
 #include "ps/CStr.h"
 
 /**
  * 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_LOAD, // Called after all objects were 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
 {
 	// This should be passed as a const reference or pointer.
 	NONCOPYABLE(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;
 };
 
 #endif // INCLUDED_SGUIMESSAGE
Index: ps/trunk/source/gui/SettingTypes/CGUISize.h
===================================================================
--- ps/trunk/source/gui/SettingTypes/CGUISize.h	(revision 23066)
+++ ps/trunk/source/gui/SettingTypes/CGUISize.h	(revision 23067)
@@ -1,83 +1,74 @@
 /* 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/>.
  */
 
 #ifndef INCLUDED_CGUISIZE
 #define INCLUDED_CGUISIZE
 
 #include "ps/CStr.h"
-#include "ps/Errors.h"
 #include "ps/Shapes.h"
 #include "scriptinterface/ScriptInterface.h"
 
 /**
  * This class represents a rectangle relative to a parent rectangle
  * The value can be initialized from a string or JS object.
  */
 class CGUISize
 {
 public:
 	// COPYABLE, since there are only primitives involved, making move and copy identical,
 	// and since some temporaries cannot be avoided.
 	CGUISize();
 	CGUISize(const CRect& pixel, const CRect& percent);
 
 	static CGUISize Full();
 
 	/// Pixel modifiers
 	CRect pixel;
 
 	/// Percent modifiers
 	CRect percent;
 
 	/**
 	 * Get client area rectangle when the parent is given
 	 */
 	CRect GetSize(const CRect& parent) const;
 
 	/**
 	 * The value 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, otherwise size will remain unchanged.
 	 */
 	bool FromString(const CStr& Value);
 
 	bool operator==(const CGUISize& 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, InvalidSetting);
-ERROR_TYPE(GUI, OperationNeedsGUIObject);
-ERROR_TYPE(GUI, NameAmbiguity);
-ERROR_TYPE(GUI, ObjectNeedsName);
-
 #endif // INCLUDED_CGUISIZE
Index: ps/trunk/source/ps/Errors.cpp
===================================================================
--- ps/trunk/source/ps/Errors.cpp	(revision 23066)
+++ ps/trunk/source/ps/Errors.cpp	(revision 23067)
@@ -1,504 +1,450 @@
 // 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_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_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_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; };
 class PSERROR_Xeromyces_XMLValidationFailed : public PSERROR_Xeromyces { public: PSERROR_Xeromyces_XMLValidationFailed(); PSERROR_Xeromyces_XMLValidationFailed(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_ObjectNeedsName = 0x06000004;
-extern const PSRETURN PSRETURN_GUI_OperationNeedsGUIObject = 0x06000005;
-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_CreateObjectFailed = 0x08000002;
-extern const PSRETURN PSRETURN_Scripting_DefineConstantFailed = 0x08000003;
-extern const PSRETURN PSRETURN_Scripting_RegisterFunctionFailed = 0x08000004;
-extern const PSRETURN PSRETURN_Scripting_SetupFailed = 0x08000005;
-extern const PSRETURN PSRETURN_Scripting_TypeDoesNotExist = 0x08000006;
-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 PSRETURN_Xeromyces_XMLValidationFailed = 0x0b000003;
+extern const PSRETURN PSRETURN_Game_World_MapLoadFailed = 0x06030001;
+extern const PSRETURN PSRETURN_Scripting_DefineType_AlreadyExists = 0x07010001;
+extern const PSRETURN PSRETURN_Scripting_DefineType_CreationFailed = 0x07010002;
+extern const PSRETURN PSRETURN_Scripting_LoadFile_EvalErrors = 0x07020001;
+extern const PSRETURN PSRETURN_Scripting_LoadFile_OpenFailed = 0x07020002;
+extern const PSRETURN PSRETURN_Scripting_CallFunctionFailed = 0x07000001;
+extern const PSRETURN PSRETURN_Scripting_CreateObjectFailed = 0x07000002;
+extern const PSRETURN PSRETURN_Scripting_DefineConstantFailed = 0x07000003;
+extern const PSRETURN PSRETURN_Scripting_RegisterFunctionFailed = 0x07000004;
+extern const PSRETURN PSRETURN_Scripting_SetupFailed = 0x07000005;
+extern const PSRETURN PSRETURN_Scripting_TypeDoesNotExist = 0x07000006;
+extern const PSRETURN PSRETURN_Serialize_InvalidCharInString = 0x08000001;
+extern const PSRETURN PSRETURN_Serialize_InvalidScriptValue = 0x08000002;
+extern const PSRETURN PSRETURN_Serialize_OutOfBounds = 0x08000003;
+extern const PSRETURN PSRETURN_Serialize_ScriptError = 0x08000004;
+extern const PSRETURN PSRETURN_System_RequiredExtensionsMissing = 0x09000001;
+extern const PSRETURN PSRETURN_System_SDLInitFailed = 0x09000002;
+extern const PSRETURN PSRETURN_System_VmodeFailed = 0x09000003;
+extern const PSRETURN PSRETURN_Xeromyces_XMLOpenFailed = 0x0a000001;
+extern const PSRETURN PSRETURN_Xeromyces_XMLParseError = 0x0a000002;
+extern const PSRETURN PSRETURN_Xeromyces_XMLValidationFailed = 0x0a000003;
 
 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 CODE__PSRETURN_Game = 0x06000000;
 extern const PSRETURN MASK__PSRETURN_Scripting = 0xff000000;
-extern const PSRETURN CODE__PSRETURN_Scripting = 0x08000000;
+extern const PSRETURN CODE__PSRETURN_Scripting = 0x07000000;
 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 CODE__PSRETURN_Serialize = 0x08000000;
+extern const PSRETURN MASK__PSRETURN_System = 0xff000000;
+extern const PSRETURN CODE__PSRETURN_System = 0x09000000;
+extern const PSRETURN MASK__PSRETURN_Xeromyces = 0x0a000000;
+extern const PSRETURN CODE__PSRETURN_Xeromyces = 0x0a000000;
 extern const PSRETURN MASK__PSRETURN_Game_World = 0xffff0000;
-extern const PSRETURN CODE__PSRETURN_Game_World = 0x07030000;
+extern const PSRETURN CODE__PSRETURN_Game_World = 0x06030000;
 extern const PSRETURN MASK__PSRETURN_Scripting_DefineType = 0xffff0000;
-extern const PSRETURN CODE__PSRETURN_Scripting_DefineType = 0x08010000;
+extern const PSRETURN CODE__PSRETURN_Scripting_DefineType = 0x07010000;
 extern const PSRETURN MASK__PSRETURN_Scripting_LoadFile = 0xffff0000;
-extern const PSRETURN CODE__PSRETURN_Scripting_LoadFile = 0x08020000;
+extern const PSRETURN CODE__PSRETURN_Scripting_LoadFile = 0x07020000;
 
 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_ObjectNeedsName = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_GUI_ObjectNeedsName = 0x06000004;
-extern const PSRETURN MASK__PSRETURN_GUI_OperationNeedsGUIObject = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_GUI_OperationNeedsGUIObject = 0x06000005;
 extern const PSRETURN MASK__PSRETURN_Game_World_MapLoadFailed = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_Game_World_MapLoadFailed = 0x07030001;
+extern const PSRETURN CODE__PSRETURN_Game_World_MapLoadFailed = 0x06030001;
 extern const PSRETURN MASK__PSRETURN_Scripting_DefineType_AlreadyExists = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_Scripting_DefineType_AlreadyExists = 0x08010001;
+extern const PSRETURN CODE__PSRETURN_Scripting_DefineType_AlreadyExists = 0x07010001;
 extern const PSRETURN MASK__PSRETURN_Scripting_DefineType_CreationFailed = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_Scripting_DefineType_CreationFailed = 0x08010002;
+extern const PSRETURN CODE__PSRETURN_Scripting_DefineType_CreationFailed = 0x07010002;
 extern const PSRETURN MASK__PSRETURN_Scripting_LoadFile_EvalErrors = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_Scripting_LoadFile_EvalErrors = 0x08020001;
+extern const PSRETURN CODE__PSRETURN_Scripting_LoadFile_EvalErrors = 0x07020001;
 extern const PSRETURN MASK__PSRETURN_Scripting_LoadFile_OpenFailed = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_Scripting_LoadFile_OpenFailed = 0x08020002;
+extern const PSRETURN CODE__PSRETURN_Scripting_LoadFile_OpenFailed = 0x07020002;
 extern const PSRETURN MASK__PSRETURN_Scripting_CallFunctionFailed = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_Scripting_CallFunctionFailed = 0x08000001;
+extern const PSRETURN CODE__PSRETURN_Scripting_CallFunctionFailed = 0x07000001;
 extern const PSRETURN MASK__PSRETURN_Scripting_CreateObjectFailed = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_Scripting_CreateObjectFailed = 0x08000002;
+extern const PSRETURN CODE__PSRETURN_Scripting_CreateObjectFailed = 0x07000002;
 extern const PSRETURN MASK__PSRETURN_Scripting_DefineConstantFailed = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_Scripting_DefineConstantFailed = 0x08000003;
+extern const PSRETURN CODE__PSRETURN_Scripting_DefineConstantFailed = 0x07000003;
 extern const PSRETURN MASK__PSRETURN_Scripting_RegisterFunctionFailed = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_Scripting_RegisterFunctionFailed = 0x08000004;
+extern const PSRETURN CODE__PSRETURN_Scripting_RegisterFunctionFailed = 0x07000004;
 extern const PSRETURN MASK__PSRETURN_Scripting_SetupFailed = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_Scripting_SetupFailed = 0x08000005;
+extern const PSRETURN CODE__PSRETURN_Scripting_SetupFailed = 0x07000005;
 extern const PSRETURN MASK__PSRETURN_Scripting_TypeDoesNotExist = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_Scripting_TypeDoesNotExist = 0x08000006;
+extern const PSRETURN CODE__PSRETURN_Scripting_TypeDoesNotExist = 0x07000006;
 extern const PSRETURN MASK__PSRETURN_Serialize_InvalidCharInString = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_Serialize_InvalidCharInString = 0x09000001;
+extern const PSRETURN CODE__PSRETURN_Serialize_InvalidCharInString = 0x08000001;
 extern const PSRETURN MASK__PSRETURN_Serialize_InvalidScriptValue = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_Serialize_InvalidScriptValue = 0x09000002;
+extern const PSRETURN CODE__PSRETURN_Serialize_InvalidScriptValue = 0x08000002;
 extern const PSRETURN MASK__PSRETURN_Serialize_OutOfBounds = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_Serialize_OutOfBounds = 0x09000003;
+extern const PSRETURN CODE__PSRETURN_Serialize_OutOfBounds = 0x08000003;
 extern const PSRETURN MASK__PSRETURN_Serialize_ScriptError = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_Serialize_ScriptError = 0x09000004;
+extern const PSRETURN CODE__PSRETURN_Serialize_ScriptError = 0x08000004;
 extern const PSRETURN MASK__PSRETURN_System_RequiredExtensionsMissing = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_System_RequiredExtensionsMissing = 0x0a000001;
+extern const PSRETURN CODE__PSRETURN_System_RequiredExtensionsMissing = 0x09000001;
 extern const PSRETURN MASK__PSRETURN_System_SDLInitFailed = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_System_SDLInitFailed = 0x0a000002;
+extern const PSRETURN CODE__PSRETURN_System_SDLInitFailed = 0x09000002;
 extern const PSRETURN MASK__PSRETURN_System_VmodeFailed = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_System_VmodeFailed = 0x0a000003;
+extern const PSRETURN CODE__PSRETURN_System_VmodeFailed = 0x09000003;
 extern const PSRETURN MASK__PSRETURN_Xeromyces_XMLOpenFailed = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_Xeromyces_XMLOpenFailed = 0x0b000001;
+extern const PSRETURN CODE__PSRETURN_Xeromyces_XMLOpenFailed = 0x0a000001;
 extern const PSRETURN MASK__PSRETURN_Xeromyces_XMLParseError = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_Xeromyces_XMLParseError = 0x0b000002;
+extern const PSRETURN CODE__PSRETURN_Xeromyces_XMLParseError = 0x0a000002;
 extern const PSRETURN MASK__PSRETURN_Xeromyces_XMLValidationFailed = 0xffffffff;
-extern const PSRETURN CODE__PSRETURN_Xeromyces_XMLValidationFailed = 0x0b000003;
+extern const PSRETURN CODE__PSRETURN_Xeromyces_XMLValidationFailed = 0x0a000003;
 
 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_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 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 0x06000005; }
-
 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; }
+PSRETURN PSERROR_Game_World_MapLoadFailed::getCode() const { return 0x06030001; }
 
 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; }
+PSRETURN PSERROR_Scripting_DefineType_AlreadyExists::getCode() const { return 0x07010001; }
 
 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; }
+PSRETURN PSERROR_Scripting_DefineType_CreationFailed::getCode() const { return 0x07010002; }
 
 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; }
+PSRETURN PSERROR_Scripting_LoadFile_EvalErrors::getCode() const { return 0x07020001; }
 
 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; }
+PSRETURN PSERROR_Scripting_LoadFile_OpenFailed::getCode() const { return 0x07020002; }
 
 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; }
+PSRETURN PSERROR_Scripting_CallFunctionFailed::getCode() const { return 0x07000001; }
 
 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 0x08000002; }
+PSRETURN PSERROR_Scripting_CreateObjectFailed::getCode() const { return 0x07000002; }
 
 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 0x08000003; }
+PSRETURN PSERROR_Scripting_DefineConstantFailed::getCode() const { return 0x07000003; }
 
 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 0x08000004; }
+PSRETURN PSERROR_Scripting_RegisterFunctionFailed::getCode() const { return 0x07000004; }
 
 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 0x08000005; }
+PSRETURN PSERROR_Scripting_SetupFailed::getCode() const { return 0x07000005; }
 
 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 0x08000006; }
+PSRETURN PSERROR_Scripting_TypeDoesNotExist::getCode() const { return 0x07000006; }
 
 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; }
+PSRETURN PSERROR_Serialize_InvalidCharInString::getCode() const { return 0x08000001; }
 
 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; }
+PSRETURN PSERROR_Serialize_InvalidScriptValue::getCode() const { return 0x08000002; }
 
 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; }
+PSRETURN PSERROR_Serialize_OutOfBounds::getCode() const { return 0x08000003; }
 
 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; }
+PSRETURN PSERROR_Serialize_ScriptError::getCode() const { return 0x08000004; }
 
 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; }
+PSRETURN PSERROR_System_RequiredExtensionsMissing::getCode() const { return 0x09000001; }
 
 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; }
+PSRETURN PSERROR_System_SDLInitFailed::getCode() const { return 0x09000002; }
 
 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; }
+PSRETURN PSERROR_System_VmodeFailed::getCode() const { return 0x09000003; }
 
 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; }
+PSRETURN PSERROR_Xeromyces_XMLOpenFailed::getCode() const { return 0x0a000001; }
 
 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; }
+PSRETURN PSERROR_Xeromyces_XMLParseError::getCode() const { return 0x0a000002; }
 
 PSERROR_Xeromyces_XMLValidationFailed::PSERROR_Xeromyces_XMLValidationFailed() : PSERROR_Xeromyces(NULL) { }
 PSERROR_Xeromyces_XMLValidationFailed::PSERROR_Xeromyces_XMLValidationFailed(const char* msg) : PSERROR_Xeromyces(msg) { }
-PSRETURN PSERROR_Xeromyces_XMLValidationFailed::getCode() const { return 0x0b000003; }
+PSRETURN PSERROR_Xeromyces_XMLValidationFailed::getCode() const { return 0x0a000003; }
 
 
 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_ObjectNeedsName";
-	case 0x06000005: return "GUI_OperationNeedsGUIObject";
-	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_CreateObjectFailed";
-	case 0x08000003: return "Scripting_DefineConstantFailed";
-	case 0x08000004: return "Scripting_RegisterFunctionFailed";
-	case 0x08000005: return "Scripting_SetupFailed";
-	case 0x08000006: 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";
-	case 0x0b000003: return "Xeromyces_XMLValidationFailed";
+	case 0x06030001: return "Game_World_MapLoadFailed";
+	case 0x07010001: return "Scripting_DefineType_AlreadyExists";
+	case 0x07010002: return "Scripting_DefineType_CreationFailed";
+	case 0x07020001: return "Scripting_LoadFile_EvalErrors";
+	case 0x07020002: return "Scripting_LoadFile_OpenFailed";
+	case 0x07000001: return "Scripting_CallFunctionFailed";
+	case 0x07000002: return "Scripting_CreateObjectFailed";
+	case 0x07000003: return "Scripting_DefineConstantFailed";
+	case 0x07000004: return "Scripting_RegisterFunctionFailed";
+	case 0x07000005: return "Scripting_SetupFailed";
+	case 0x07000006: return "Scripting_TypeDoesNotExist";
+	case 0x08000001: return "Serialize_InvalidCharInString";
+	case 0x08000002: return "Serialize_InvalidScriptValue";
+	case 0x08000003: return "Serialize_OutOfBounds";
+	case 0x08000004: return "Serialize_ScriptError";
+	case 0x09000001: return "System_RequiredExtensionsMissing";
+	case 0x09000002: return "System_SDLInitFailed";
+	case 0x09000003: return "System_VmodeFailed";
+	case 0x0a000001: return "Xeromyces_XMLOpenFailed";
+	case 0x0a000002: return "Xeromyces_XMLParseError";
+	case 0x0a000003: return "Xeromyces_XMLValidationFailed";
 
 	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_ObjectNeedsName(); break;
-	case 0x06000005: throw PSERROR_GUI_OperationNeedsGUIObject(); 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_CreateObjectFailed(); break;
-	case 0x08000003: throw PSERROR_Scripting_DefineConstantFailed(); break;
-	case 0x08000004: throw PSERROR_Scripting_RegisterFunctionFailed(); break;
-	case 0x08000005: throw PSERROR_Scripting_SetupFailed(); break;
-	case 0x08000006: 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;
-	case 0x0b000003: throw PSERROR_Xeromyces_XMLValidationFailed(); break;
+	case 0x06030001: throw PSERROR_Game_World_MapLoadFailed(); break;
+	case 0x07010001: throw PSERROR_Scripting_DefineType_AlreadyExists(); break;
+	case 0x07010002: throw PSERROR_Scripting_DefineType_CreationFailed(); break;
+	case 0x07020001: throw PSERROR_Scripting_LoadFile_EvalErrors(); break;
+	case 0x07020002: throw PSERROR_Scripting_LoadFile_OpenFailed(); break;
+	case 0x07000001: throw PSERROR_Scripting_CallFunctionFailed(); break;
+	case 0x07000002: throw PSERROR_Scripting_CreateObjectFailed(); break;
+	case 0x07000003: throw PSERROR_Scripting_DefineConstantFailed(); break;
+	case 0x07000004: throw PSERROR_Scripting_RegisterFunctionFailed(); break;
+	case 0x07000005: throw PSERROR_Scripting_SetupFailed(); break;
+	case 0x07000006: throw PSERROR_Scripting_TypeDoesNotExist(); break;
+	case 0x08000001: throw PSERROR_Serialize_InvalidCharInString(); break;
+	case 0x08000002: throw PSERROR_Serialize_InvalidScriptValue(); break;
+	case 0x08000003: throw PSERROR_Serialize_OutOfBounds(); break;
+	case 0x08000004: throw PSERROR_Serialize_ScriptError(); break;
+	case 0x09000001: throw PSERROR_System_RequiredExtensionsMissing(); break;
+	case 0x09000002: throw PSERROR_System_SDLInitFailed(); break;
+	case 0x09000003: throw PSERROR_System_VmodeFailed(); break;
+	case 0x0a000001: throw PSERROR_Xeromyces_XMLOpenFailed(); break;
+	case 0x0a000002: throw PSERROR_Xeromyces_XMLParseError(); break;
+	case 0x0a000003: throw PSERROR_Xeromyces_XMLValidationFailed(); break;
 
 	default: throw PSERROR_Error_InvalidError(); // Hmm...
 	}
 }