Index: ps/trunk/source/gui/CGUI.cpp
===================================================================
--- ps/trunk/source/gui/CGUI.cpp	(revision 24383)
+++ ps/trunk/source/gui/CGUI.cpp	(revision 24384)
@@ -1,1299 +1,1300 @@
 /* Copyright (C) 2020 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/CGUIDummyObject.h"
 #include "gui/ObjectTypes/CTooltip.h"
 #include "gui/Scripting/ScriptFunctions.h"
+#include "gui/Scripting/JSInterface_GUIProxy.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/ScriptContext.h"
 #include "scriptinterface/ScriptInterface.h"
 
 #include <string>
 #include <unordered_set>
 
 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
 
 const CStr CGUI::EventNameLoad = "Load";
 const CStr CGUI::EventNameTick = "Tick";
 const CStr CGUI::EventNamePress = "Press";
 const CStr CGUI::EventNameKeyDown = "KeyDown";
 const CStr CGUI::EventNameRelease = "Release";
 const CStr CGUI::EventNameMouseRightPress = "MouseRightPress";
 const CStr CGUI::EventNameMouseLeftPress = "MouseLeftPress";
 const CStr CGUI::EventNameMouseWheelDown = "MouseWheelDown";
 const CStr CGUI::EventNameMouseWheelUp = "MouseWheelUp";
 const CStr CGUI::EventNameMouseLeftDoubleClick = "MouseLeftDoubleClick";
 const CStr CGUI::EventNameMouseLeftRelease = "MouseLeftRelease";
 const CStr CGUI::EventNameMouseRightDoubleClick = "MouseRightDoubleClick";
 const CStr CGUI::EventNameMouseRightRelease = "MouseRightRelease";
 
 CGUI::CGUI(const shared_ptr<ScriptContext>& context)
 	: m_BaseObject(new CGUIDummyObject(*this)),
 	  m_FocusedObject(nullptr),
 	  m_InternalNameNumber(0),
 	  m_MouseButtons(0)
 {
 	m_ScriptInterface.reset(new ScriptInterface("Engine", "GUIPage", context));
 	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;
 }
 
 InReaction CGUI::HandleEvent(const SDL_Event_* ev)
 {
 	InReaction ret = IN_PASS;
 
 	if (ev->ev.type == SDL_HOTKEYDOWN || ev->ev.type == SDL_HOTKEYPRESS || ev->ev.type == SDL_HOTKEYUP)
 	{
 		const char* hotkey = static_cast<const char*>(ev->ev.user.data1);
 
 		const CStr& eventName = ev->ev.type == SDL_HOTKEYPRESS ? EventNamePress : ev->ev.type == SDL_HOTKEYDOWN ? EventNameKeyDown : EventNameRelease;
 
 		if (m_GlobalHotkeys.find(hotkey) != m_GlobalHotkeys.end() && m_GlobalHotkeys[hotkey].find(eventName) != m_GlobalHotkeys[hotkey].end())
 		{
 			ret = IN_HANDLED;
 
 			ScriptRequest rq(m_ScriptInterface);
 			JS::RootedObject globalObj(rq.cx, rq.glob);
 			JS::RootedValue result(rq.cx);
 			if (!JS_CallFunctionValue(rq.cx, globalObj, m_GlobalHotkeys[hotkey][eventName], JS::HandleValueArray::empty(), &result))
 				ScriptException::CatchPending(rq);
 		}
 
 		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_HOTKEYPRESS)
 					ret = obj->SendEvent(GUIM_PRESSED, EventNamePress);
 				else if (ev->ev.type == SDL_HOTKEYDOWN)
 					ret = obj->SendEvent(GUIM_KEYDOWN, EventNameKeyDown);
 				else
 					ret = obj->SendEvent(GUIM_RELEASED, EventNameRelease);
 			}
 	}
 
 	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);
 	}
 
 	// Allow the focused object to pre-empt regular GUI events.
 	if (GetFocusedObject())
 		ret = GetFocusedObject()->PreemptEvent(ev);
 
 	// Only one object can be hovered
 	// pNearest will after this point at the hovered object, possibly nullptr
 	IGUIObject* pNearest = FindObjectUnderMouse();
 
 	if (ret == IN_PASS)
 	{
 		// 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->SendMouseEvent(GUIM_MOUSE_PRESS_LEFT, EventNameMouseLeftPress);
 				break;
 
 			case SDL_BUTTON_RIGHT:
 				if (pNearest)
 					ret = pNearest->SendMouseEvent(GUIM_MOUSE_PRESS_RIGHT, EventNameMouseRightPress);
 				break;
 
 			default:
 				break;
 			}
 		}
 		else if (ev->ev.type == SDL_MOUSEWHEEL && pNearest)
 		{
 			if (ev->ev.wheel.y < 0)
 				ret = pNearest->SendMouseEvent(GUIM_MOUSE_WHEEL_DOWN, EventNameMouseWheelDown);
 			else if (ev->ev.wheel.y > 0)
 				ret = pNearest->SendMouseEvent(GUIM_MOUSE_WHEEL_UP, EventNameMouseWheelUp);
 		}
 		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->SendMouseEvent(GUIM_MOUSE_DBLCLICK_LEFT, EventNameMouseLeftDoubleClick);
 					else
 						ret = pNearest->SendMouseEvent(GUIM_MOUSE_RELEASE_LEFT, EventNameMouseLeftRelease);
 				}
 				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->SendMouseEvent(GUIM_MOUSE_DBLCLICK_RIGHT, EventNameMouseRightDoubleClick);
 					else
 						ret = pNearest->SendMouseEvent(GUIM_MOUSE_RELEASE_RIGHT, EventNameMouseRightRelease);
 				}
 				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));
 		}
 	}
 
 	// 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;
 
 	// Let GUI items handle keys after everything else, e.g. for input boxes.
 	if (ret == IN_PASS && GetFocusedObject())
 	{
 		if (ev->ev.type == SDL_KEYUP || ev->ev.type == SDL_KEYDOWN ||
 			ev->ev.type == SDL_HOTKEYUP || ev->ev.type == SDL_HOTKEYDOWN ||
 			ev->ev.type == SDL_TEXTINPUT || ev->ev.type == SDL_TEXTEDITING)
 			ret = GetFocusedObject()->ManuallyHandleKeys(ev);
 		// else will return IN_PASS because we never used the button.
 	}
 
 	return ret;
 }
 
 void CGUI::TickObjects()
 {
 	m_BaseObject->RecurseObject(&IGUIObject::IsHiddenOrGhost, &IGUIObject::Tick);
 	SendEventToAll(EventNameTick);
 	m_Tooltip.Update(FindObjectUnderMouse(), m_MousePos, *this);
 }
 
 void CGUI::SendEventToAll(const CStr& eventName)
 {
 	auto it = m_EventIGUIObjects.find(eventName);
 	if (it == m_EventIGUIObjects.end())
 		return;
 
 	std::set<IGUIObject*> copy = it->second;
 	for (IGUIObject* pIGUIObject : copy)
 		pIGUIObject->ScriptEvent(eventName);
 }
 
 void CGUI::SendEventToAll(const CStr& eventName, const JS::HandleValueArray& paramData)
 {
 	auto it = m_EventIGUIObjects.find(eventName);
 	if (it == m_EventIGUIObjects.end())
 		return;
 
 	std::set<IGUIObject*> copy = it->second;
 	for (IGUIObject* pIGUIObject : copy)
 		pIGUIObject->ScriptEvent(eventName, paramData);
 }
 
 void CGUI::Draw()
 {
 	// Clear the depth buffer, so the GUI is
 	// drawn on top of everything else
 	glClear(GL_DEPTH_BUFFER_BIT);
 
 	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()
 {
 	m_BaseObject->RecurseObject(nullptr, &IGUIObject::UpdateCachedSize);
 }
 
 IGUIObject* CGUI::ConstructObject(const CStr& str)
 {
 	std::map<CStr, ConstructObjectFunction>::iterator it = m_ObjectTypes.find(str);
 
 	if (it == m_ObjectTypes.end())
 		return nullptr;
 
 	return (*it->second)(*this);
 }
 
 bool CGUI::AddObject(IGUIObject& parent, IGUIObject& child)
 {
 	if (child.m_Name.empty())
 	{
 		LOGERROR("Can't register an object without name!");
 		return false;
 	}
 
 	if (m_pAllObjects.find(child.m_Name) != m_pAllObjects.end())
 	{
 		LOGERROR("Can't register more than one object of the name %s", child.m_Name.c_str());
 		return false;
 	}
 
 	m_pAllObjects[child.m_Name] = &child;
 	parent.AddChild(child);
 	return true;
 }
 
 IGUIObject* CGUI::GetBaseObject()
 {
 	return m_BaseObject.get();
 };
 
 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::SetObjectStyle(IGUIObject* pObject, const CStr& styleName)
 {
 	// If the style is not recognised (or an empty string) then ApplyStyle will
 	// emit an error message. Thus we don't need to handle it here.
 	if (pObject->ApplyStyle(styleName))
 		pObject->m_Style = styleName;
 }
 
 void CGUI::UnsetObjectStyle(IGUIObject* pObject)
 {
 	SetObjectStyle(pObject, "default");
 }
 
 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, const CStr& eventName, JS::HandleValue function)
 {
 	ScriptRequest rq(*m_ScriptInterface);
 
 	if (hotkeyTag.empty())
 	{
 		ScriptException::Raise(rq, "Cannot assign a function to an empty hotkey identifier!");
 		return;
 	}
 
 	// Only support "Press", "Keydown" and "Release" events.
 	if (eventName != EventNamePress && eventName != EventNameKeyDown && eventName != EventNameRelease)
 	{
 		ScriptException::Raise(rq, "Cannot assign a function to an unsupported event!");
 		return;
 	}
 
 	if (!function.isObject() || !JS_ObjectIsFunction(&function.toObject()))
 	{
 		ScriptException::Raise(rq, "Cannot assign non-function value to global hotkey '%s'", hotkeyTag.c_str());
 		return;
 	}
 
 	UnsetGlobalHotkey(hotkeyTag, eventName);
 	m_GlobalHotkeys[hotkeyTag][eventName].init(rq.cx, function);
 }
 
 void CGUI::UnsetGlobalHotkey(const CStr& hotkeyTag, const CStr& eventName)
 {
 	std::map<CStr, std::map<CStr, JS::PersistentRootedValue>>::iterator it = m_GlobalHotkeys.find(hotkeyTag);
 	if (it == m_GlobalHotkeys.end())
 		return;
 
 	m_GlobalHotkeys[hotkeyTag].erase(eventName);
 
 	if (m_GlobalHotkeys.count(hotkeyTag) == 0)
 		m_GlobalHotkeys.erase(it);
 }
 
 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, std::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()));
 
 	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(EventNameLoad);
 }
 
 //===================================================================
 //	XML Reading Xeromyces Specific Sub-Routines
 //===================================================================
 
 void CGUI::Xeromyces_ReadRootObjects(XMBElement Element, CXeromyces* pFile, std::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.get(), 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, std::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(script);
 	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!
 	//
 	SetObjectStyle(object, "default");
 
 	CStr argStyle(attributes.GetNamedItem(attr_style));
 	if (!argStyle.empty())
 		SetObjectStyle(object, 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 (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));
 					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 eventName = child.GetAttributes().GetNamedItem(attr_on);
 			object->RegisterScriptHandler(eventName, code, *this);
 		}
 		else if (child.GetNodeName() == elmt_script)
 		{
 			Xeromyces_ReadScript(child, pFile, Paths);
 		}
 		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);
 	}
 
 	if (!AddObject(*pParent, *object))
 		delete object;
 }
 
 void CGUI::Xeromyces_ReadRepeat(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::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, std::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())
 	{
 		if (!VfsPath(file).IsDirectory())
 		{
 			Paths.insert(file);
 			m_ScriptInterface->LoadGlobalScriptFile(file);
 		}
 		else
 			LOGERROR("GUI: Script path %s is not a file path", file.ToUTF8().c_str());
 	}
 
 	// 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())
 	{
 		if (VfsPath(directory).IsDirectory())
 		{
 			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)
 					m_ScriptInterface->LoadGlobalScriptFile(path);
 			}
 		}
 		else
 			LOGERROR("GUI: Script path %s is not a directory path", directory.ToUTF8().c_str());
 	}
 
 	CStr code(Element.GetText());
 	if (!code.empty())
 		m_ScriptInterface->LoadGlobalScript(L"Some XML file", code);
 }
 
 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);
 	}
 
 	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 24383)
+++ ps/trunk/source/gui/CGUI.h	(revision 24384)
@@ -1,685 +1,687 @@
 /* Copyright (C) 2020 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/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 <map>
 #include <set>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 extern const double SELECT_DBLCLICK_RATE;
 
 class CGUISpriteInstance;
 class CGUISprite;
 class IGUIObject;
 struct SGUIImageEffects;
 struct SGUIScrollBarStyle;
 
 namespace js { class BaseProxyHandler; }
+class GUIProxyProps;
 
 using map_pObjects = std::map<CStr, IGUIObject*>;
 
 /**
  * The main object that represents a whole GUI page.
  */
 class CGUI
 {
 	NONCOPYABLE(CGUI);
 
 private:
 	// Private typedefs
 	using ConstructObjectFunction = IGUIObject* (*)(CGUI&);
 
 public:
 	CGUI(const shared_ptr<ScriptContext>& context);
 	~CGUI();
 
 	/**
 	 * Informs the GUI page which GUI object types may be constructed from XML.
 	 */
 	void AddObjectTypes();
 
 	/**
 	 * 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, std::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 modify the style setting assigned to a GUI object.
 	 */
 	void SetObjectStyle(IGUIObject* pObject, const CStr& styleName);
 	void UnsetObjectStyle(IGUIObject* pObject);
 
 	/**
 	 * Allows the JS side to add or remove global hotkeys.
 	 */
 	void SetGlobalHotkey(const CStr& hotkeyTag, const CStr& eventName, JS::HandleValue function);
 	void UnsetGlobalHotkey(const CStr& hotkeyTag, const CStr& eventName);
 
 	/**
 	 * Return the object which is an ancestor of every other GUI object.
 	 */
 	IGUIObject* GetBaseObject();
 
 	/**
 	 * 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); }
 
-	void* GetProxyData(const js::BaseProxyHandler* ptr) { return m_ProxyData.at(ptr); }
+	GUIProxyProps* GetProxyData(const js::BaseProxyHandler* ptr) { return m_ProxyData.at(ptr).get(); }
 
 	shared_ptr<ScriptInterface> GetScriptInterface() { return m_ScriptInterface; };
 
 private:
 	/**
 	 * 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.
 	 */
 	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, std::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, std::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, std::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, std::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.
 	 */
 	std::unique_ptr<IGUIObject> m_BaseObject;
 
 	/**
 	 * Focused object!
 	 * Say an input box that is selected. That one is focused.
 	 * There can only be one focused object.
 	 */
 	IGUIObject* m_FocusedObject;
 
 	/**
 	 * Just pointers for fast name access, each object
 	 * is really constructed within its parent for easy
 	 * recursive management.
 	 * Notice m_BaseObject won't belong here since it's
 	 * not considered a real object.
 	 */
 	map_pObjects m_pAllObjects;
 
 	/**
 	 * Number of object that has been given name automatically.
 	 * the name given will be '__internal(#)', the number (#)
 	 * being this variable. When an object's name has been set
 	 * as followed, the value will increment.
 	 */
 	int m_InternalNameNumber;
 
 	/**
 	 * Function pointers to functions that constructs
 	 * IGUIObjects by name... For instance m_ObjectTypes["button"]
 	 * is filled with a function that will "return new CButton();"
 	 */
 	std::map<CStr, ConstructObjectFunction> m_ObjectTypes;
 
 	/**
-	 * This is intended to store the JS Functions returned when accessing some object properties.
-	 * It's not a great solution, but I can't find a better one at the moment.
+	 * This is intended to store the JSFunction when accessing certain properties.
 	 * The problem is that these functions are per-scriptInterface, and proxy handlers aren't.
 	 * So we know what we want to store, but we don't really have anywhere to store it.
 	 * It would be simpler to recreate the functions on every JS call, but that is slower
 	 * (this may or may not matter now and in the future).
-	 * Another alternative would be to store them on each proxied object, but that wastes memory.
+	 * It's not a great solution, but I can't find a better one at the moment.
+	 * An alternative would be to store these on the proxy's prototype,
+	 * but that embarks a lot of un-necessary code.
 	 */
-	std::unordered_map<const js::BaseProxyHandler*, void*> m_ProxyData;
+	std::unordered_map<const js::BaseProxyHandler*, std::unique_ptr<GUIProxyProps>> m_ProxyData;
 
 	/**
 	 * 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 maps of eventNames to functions that are triggered
 	 * when the hotkey goes through the event. Contrary to object hotkeys, this
 	 * allows for only one global function per hotkey name per event type.
 	 */
 	std::map<CStr, std::map<CStr, JS::PersistentRootedValue>> m_GlobalHotkeys;
 
 	/**
 	 * XML and JS can subscribe handlers to events identified by these names.
 	 * Store in static const members to avoid string copies, gain compile errors when misspelling and
 	 * to allow reuse in other classes.
 	 */
 	static const CStr EventNameLoad;
 	static const CStr EventNameTick;
 	static const CStr EventNamePress;
 	static const CStr EventNameKeyDown;
 	static const CStr EventNameRelease;
 	static const CStr EventNameMouseRightPress;
 	static const CStr EventNameMouseLeftPress;
 	static const CStr EventNameMouseWheelDown;
 	static const CStr EventNameMouseWheelUp;
 	static const CStr EventNameMouseLeftDoubleClick;
 	static const CStr EventNameMouseLeftRelease;
 	static const CStr EventNameMouseRightDoubleClick;
 	static const CStr EventNameMouseRightRelease;
 
 	//--------------------------------------------------------
 	//	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;
 
 public:
 	/**
 	 * Stores all the IGUIObject which listen to a given event.
 	 */
 	std::map<CStr, std::set<IGUIObject*>> m_EventIGUIObjects;
 };
 
 #endif // INCLUDED_CGUI
Index: ps/trunk/source/gui/ObjectBases/IGUIObject.cpp
===================================================================
--- ps/trunk/source/gui/ObjectBases/IGUIObject.cpp	(revision 24383)
+++ ps/trunk/source/gui/ObjectBases/IGUIObject.cpp	(revision 24384)
@@ -1,591 +1,584 @@
 /* Copyright (C) 2020 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 "gui/Scripting/JSInterface_GUIProxy.h"
 #include "js/Conversions.h"
 #include "ps/CLogger.h"
 #include "ps/GameSetup/Config.h"
 #include "ps/Profile.h"
 #include "scriptinterface/ScriptContext.h"
 #include "scriptinterface/ScriptExtraHeaders.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "soundmanager/ISoundManager.h"
 
 const CStr IGUIObject::EventNameMouseEnter = "MouseEnter";
 const CStr IGUIObject::EventNameMouseMove = "MouseMove";
 const CStr IGUIObject::EventNameMouseLeave = "MouseLeave";
 
 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()->GetGeneralJSContext(), Trace, this);
 
 	// m_Children is deleted along all other GUI Objects in the CGUI destructor
 }
 
 void IGUIObject::AddChild(IGUIObject& pChild)
 {
 	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));
 	else if (Setting == "style")
 		m_pGUI.SetObjectStyle(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)
 			SendMouseEvent(GUIM_MOUSE_ENTER,EventNameMouseEnter);
 
 		m_MouseHovering = true;
 
 		SendMouseEvent(GUIM_MOUSE_OVER, EventNameMouseMove);
 	}
 	else
 	{
 		if (m_MouseHovering)
 		{
 			m_MouseHovering = false;
 			SendMouseEvent(GUIM_MOUSE_LEAVE, EventNameMouseLeave);
 		}
 	}
 }
 
 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;
 		}
 	}
 }
 
 bool IGUIObject::ApplyStyle(const CStr& StyleName)
 {
 	if (!m_pGUI.HasStyle(StyleName))
 	{
 		LOGERROR("IGUIObject: Trying to use style '%s' that doesn't exist.", StyleName.c_str());
 		return false;
 	}
 
 	// 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());
 	}
 	return true;
 }
 
 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& eventName, const CStr& Code, CGUI& pGUI)
 {
 	ScriptRequest rq(pGUI.GetScriptInterface());
 
 	const int paramCount = 1;
 	const char* paramNames[paramCount] = { "mouse" };
 
 	// Location to report errors from
 	CStr CodeName = GetName() + " " + eventName;
 
 	// Generate a unique name
 	static int x = 0;
 	char buf[64];
 	sprintf_s(buf, ARRAY_SIZE(buf), "__eventhandler%d (%s)", x++, eventName.c_str());
 
 	// TODO: this is essentially the same code as ScriptInterface::LoadScript (with a tweak for the argument).
 	JS::CompileOptions options(rq.cx);
 	options.setFileAndLine(CodeName.c_str(), 0);
 	options.setIsRunOnce(false);
 
 	JS::SourceText<mozilla::Utf8Unit> src;
 	ENSURE(src.init(rq.cx, Code.c_str(), Code.length(), JS::SourceOwnership::Borrowed));
 	JS::RootedObjectVector emptyScopeChain(rq.cx);
 	JS::RootedFunction func(rq.cx, JS::CompileFunction(rq.cx, emptyScopeChain, options, buf, paramCount, paramNames, src));
 	if (func == nullptr)
 	{
 		LOGERROR("RegisterScriptHandler: Failed to compile the script for %s", eventName.c_str());
 		return;
 	}
 
 	JS::RootedObject funcObj(rq.cx, JS_GetFunctionObject(func));
 	SetScriptHandler(eventName, funcObj);
 }
 
 void IGUIObject::SetScriptHandler(const CStr& eventName, JS::HandleObject Function)
 {
 	if (m_ScriptHandlers.empty())
 		JS_AddExtraGCRootsTracer(m_pGUI.GetScriptInterface()->GetGeneralJSContext(), Trace, this);
 
 	m_ScriptHandlers[eventName] = JS::Heap<JSObject*>(Function);
 
 	auto it = m_pGUI.m_EventIGUIObjects.find(eventName);
 	if (it == m_pGUI.m_EventIGUIObjects.end())
 		m_pGUI.m_EventIGUIObjects.emplace(eventName, std::set<IGUIObject*>{this});
 	else
 		it->second.insert(this);
 }
 
 void IGUIObject::UnsetScriptHandler(const CStr& eventName)
 {
 	std::map<CStr, JS::Heap<JSObject*> >::iterator it = m_ScriptHandlers.find(eventName);
 
 	if (it == m_ScriptHandlers.end())
 		return;
 
 	m_ScriptHandlers.erase(it);
 
 	if (m_ScriptHandlers.empty())
 		JS_RemoveExtraGCRootsTracer(m_pGUI.GetScriptInterface()->GetGeneralJSContext(), Trace, this);
 	{
 		auto it = m_pGUI.m_EventIGUIObjects.find(eventName);
 		if (it != m_pGUI.m_EventIGUIObjects.end())
 		{
 			it->second.erase(this);
 			if (!it->second.size())
 				m_pGUI.m_EventIGUIObjects.erase(eventName);
 		}
 	}
 }
 
 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;
 }
 
 InReaction IGUIObject::SendMouseEvent(EGUIMessageType type, const CStr& eventName)
 {
 	PROFILE2_EVENT("gui mouse event");
 	PROFILE2_ATTR("type: %s", eventName.c_str());
 	PROFILE2_ATTR("object: %s", m_Name.c_str());
 
 	SGUIMessage msg(type);
 	HandleMessage(msg);
 
 	ScriptRequest rq(m_pGUI.GetScriptInterface());
 
 	// Set up the 'mouse' parameter
 	JS::RootedValue mouse(rq.cx);
 
 	const CPos& mousePos = m_pGUI.GetMousePos();
 
 	ScriptInterface::CreateObject(
 		rq,
 		&mouse,
 		"x", mousePos.x,
 		"y", mousePos.y,
 		"buttons", m_pGUI.GetMouseButtons());
 	JS::RootedValueVector paramData(rq.cx);
 	DISCARD paramData.append(mouse);
 	ScriptEvent(eventName, paramData);
 
 	return msg.skipped ? IN_PASS : IN_HANDLED;
 }
 
 void IGUIObject::ScriptEvent(const CStr& eventName)
 {
 	ScriptEventWithReturn(eventName);
 }
 
 bool IGUIObject::ScriptEventWithReturn(const CStr& eventName)
 {
 	if (m_ScriptHandlers.find(eventName) == m_ScriptHandlers.end())
 		return false;
 
 	ScriptRequest rq(m_pGUI.GetScriptInterface());
 	JS::RootedValueVector paramData(rq.cx);
 	return ScriptEventWithReturn(eventName, paramData);
 }
 
 void IGUIObject::ScriptEvent(const CStr& eventName, const JS::HandleValueArray& paramData)
 {
 	ScriptEventWithReturn(eventName, paramData);
 }
 
 bool IGUIObject::ScriptEventWithReturn(const CStr& eventName, const JS::HandleValueArray& paramData)
 {
 	std::map<CStr, JS::Heap<JSObject*> >::iterator it = m_ScriptHandlers.find(eventName);
 	if (it == m_ScriptHandlers.end())
 		return false;
 
 	ScriptRequest rq(m_pGUI.GetScriptInterface());
 	JS::RootedObject obj(rq.cx, GetJSObject());
 	JS::RootedValue handlerVal(rq.cx, JS::ObjectValue(*it->second));
 	JS::RootedValue result(rq.cx);
 
 	if (!JS_CallFunctionValue(rq.cx, obj, handlerVal, paramData, &result))
 	{
 		LOGERROR("Errors executing script event \"%s\"", eventName.c_str());
 		ScriptException::CatchPending(rq);
 		return false;
 	}
 	return JS::ToBoolean(result);
 }
 
 void IGUIObject::CreateJSObject()
 {
 	ScriptRequest rq(m_pGUI.GetScriptInterface());
-
-	js::ProxyOptions options;
-	options.setClass(&JSI_GUIProxy<IGUIObject>::ClassDefinition());
-
-	JS::RootedValue cppObj(rq.cx), data(rq.cx);
-	cppObj.get().setPrivate(this);
-	data.get().setPrivate(GetGUI().GetProxyData(&JSI_GUIProxy<IGUIObject>::Singleton()));
-	m_JSObject.init(rq.cx, js::NewProxyObject(rq.cx, &JSI_GUIProxy<IGUIObject>::Singleton(), cppObj, nullptr, options));
-	js::SetProxyReservedSlot(m_JSObject, 0, data);
+	using ProxyHandler = JSI_GUIProxy<std::remove_pointer_t<decltype(this)>>;
+	ProxyHandler::CreateJSObject(rq, this, GetGUI().GetProxyData(&ProxyHandler::Singleton()), m_JSObject);
 }
 
 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();
 }
 
 void IGUIObject::toString(ScriptInterface& scriptInterface, JS::MutableHandleValue ret)
 {
 	ScriptRequest rq(scriptInterface);
 	ScriptInterface::ToJSVal(rq, ret, "[GUIObject: " + GetName() + "]");
 }
 
 void IGUIObject::focus(ScriptInterface& UNUSED(scriptInterface), JS::MutableHandleValue ret)
 {
 	GetGUI().SetFocusedObject(this);
 	ret.setUndefined();
 }
 
 void IGUIObject::blur(ScriptInterface& UNUSED(scriptInterface), JS::MutableHandleValue ret)
 {
 	GetGUI().SetFocusedObject(nullptr);
 	ret.setUndefined();
 }
 
 void IGUIObject::getComputedSize(ScriptInterface& scriptInterface, JS::MutableHandleValue ret)
 {
 	UpdateCachedSize();
 	ScriptRequest rq(scriptInterface);
 	ScriptInterface::ToJSVal(rq, ret, m_CachedActualSize);
 }
 
 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::TraceEdge(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/ObjectTypes/CButton.cpp
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CButton.cpp	(revision 24383)
+++ ps/trunk/source/gui/ObjectTypes/CButton.cpp	(revision 24384)
@@ -1,141 +1,134 @@
 /* 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 "CButton.h"
 
 #include "gui/CGUI.h"
 #include "gui/CGUIText.h"
 #include "gui/Scripting/JSInterface_GUIProxy.h"
 #include "gui/SettingTypes/CGUIColor.h"
 
 CButton::CButton(CGUI& pGUI)
 	: IGUIObject(pGUI),
 	  IGUIButtonBehavior(*static_cast<IGUIObject*>(this)),
 	  IGUITextOwner(*static_cast<IGUIObject*>(this)),
 	  m_BufferZone(),
 	  m_CellID(),
 	  m_Caption(),
 	  m_Font(),
 	  m_Sprite(),
 	  m_SpriteOver(),
 	  m_SpritePressed(),
 	  m_SpriteDisabled(),
 	  m_TextAlign(),
 	  m_TextVAlign(),
 	  m_TextColor(),
 	  m_TextColorOver(),
 	  m_TextColorPressed(),
 	  m_TextColorDisabled()
 {
 	RegisterSetting("buffer_zone", m_BufferZone);
 	RegisterSetting("cell_id", m_CellID);
 	RegisterSetting("caption", m_Caption);
 	RegisterSetting("font", m_Font);
 	RegisterSetting("sprite", m_Sprite);
 	RegisterSetting("sprite_over", m_SpriteOver);
 	RegisterSetting("sprite_pressed", m_SpritePressed);
 	RegisterSetting("sprite_disabled", m_SpriteDisabled);
 	RegisterSetting("text_align", m_TextAlign);
 	RegisterSetting("text_valign", m_TextVAlign);
 	RegisterSetting("textcolor", m_TextColor);
 	RegisterSetting("textcolor_over", m_TextColorOver);
 	RegisterSetting("textcolor_pressed", m_TextColorPressed);
 	RegisterSetting("textcolor_disabled", m_TextColorDisabled);
 
 	AddText();
 }
 
 CButton::~CButton()
 {
 }
 
 void CButton::SetupText()
 {
 	ENSURE(m_GeneratedTexts.size() == 1);
 
 	m_GeneratedTexts[0] = CGUIText(m_pGUI, m_Caption, m_Font, m_CachedActualSize.GetWidth(), m_BufferZone, this);
 	CalculateTextPosition(m_CachedActualSize, m_TextPos, m_GeneratedTexts[0]);
 }
 
 void CButton::ResetStates()
 {
 	IGUIObject::ResetStates();
 	IGUIButtonBehavior::ResetStates();
 }
 
 void CButton::UpdateCachedSize()
 {
 	IGUIObject::UpdateCachedSize();
 	IGUITextOwner::UpdateCachedSize();
 }
 
 void CButton::HandleMessage(SGUIMessage& Message)
 {
 	IGUIObject::HandleMessage(Message);
 	IGUIButtonBehavior::HandleMessage(Message);
 	IGUITextOwner::HandleMessage(Message);
 }
 
 void CButton::Draw()
 {
 	const float bz = GetBufferedZ();
 
 	m_pGUI.DrawSprite(
 		GetButtonSprite(m_Sprite, m_SpriteOver, m_SpritePressed, m_SpriteDisabled),
 		m_CellID,
 		bz,
 		m_CachedActualSize);
 
 	DrawText(0, ChooseColor(), m_TextPos, bz + 0.1f);
 }
 
 const CGUIColor& CButton::ChooseColor()
 {
 	if (!m_Enabled)
 		return m_TextColorDisabled || m_TextColor;
 
 	if (!m_MouseHovering)
 		return m_TextColor;
 
 	if (m_Pressed)
 		return m_TextColorPressed || m_TextColor;
 
 	return m_TextColorOver || m_TextColor;
 }
 
-void CButton::CreateJSObject()
-{
-	ScriptRequest rq(m_pGUI.GetScriptInterface());
-
-	js::ProxyOptions options;
-	options.setClass(&JSI_GUIProxy<CButton>::ClassDefinition());
-
-	JS::RootedValue cppObj(rq.cx), data(rq.cx);
-	cppObj.get().setPrivate(this);
-	data.get().setPrivate(GetGUI().GetProxyData(&JSI_GUIProxy<CButton>::Singleton()));
-	m_JSObject.init(rq.cx, js::NewProxyObject(rq.cx, &JSI_GUIProxy<CButton>::Singleton(), cppObj, nullptr, options));
-	js::SetProxyReservedSlot(m_JSObject, 0, data);
-}
-
 void CButton::getTextSize(ScriptInterface& scriptInterface, JS::MutableHandleValue ret)
 {
 	ScriptRequest rq(scriptInterface);
 	UpdateText();
 	ScriptInterface::ToJSVal(rq, ret, m_GeneratedTexts[0].GetSize());
 }
+
+void CButton::CreateJSObject()
+{
+	ScriptRequest rq(m_pGUI.GetScriptInterface());
+	using ProxyHandler = JSI_GUIProxy<std::remove_pointer_t<decltype(this)>>;
+	ProxyHandler::CreateJSObject(rq, this, GetGUI().GetProxyData(&ProxyHandler::Singleton()), m_JSObject);
+}
Index: ps/trunk/source/gui/ObjectTypes/CButton.h
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CButton.h	(revision 24383)
+++ ps/trunk/source/gui/ObjectTypes/CButton.h	(revision 24384)
@@ -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_CBUTTON
 #define INCLUDED_CBUTTON
 
 #include "gui/CGUISprite.h"
 #include "gui/ObjectBases/IGUIButtonBehavior.h"
 #include "gui/ObjectBases/IGUIObject.h"
 #include "gui/ObjectBases/IGUITextOwner.h"
 #include "gui/SettingTypes/CGUIString.h"
 
 class CButton : public IGUIObject, public IGUITextOwner, public IGUIButtonBehavior
 {
 	GUI_OBJECT(CButton)
-
-	friend JSI_GUIProxy<CButton>;
-
 public:
 	CButton(CGUI& pGUI);
 	virtual ~CButton();
 
 	/**
 	 * @see IGUIObject#ResetStates()
 	 */
 	virtual void ResetStates();
 
 	/**
 	 * @see IGUIObject#UpdateCachedSize()
 	 */
 	virtual void UpdateCachedSize();
 
 	/**
 	 * @see IGUIObject#HandleMessage()
 	 */
 	virtual void HandleMessage(SGUIMessage& Message);
 
 	/**
 	 * Draws the Button
 	 */
 	virtual void Draw();
 
+	/**
+	 * Populate @param ret with the object's text size.
+	 */
+	void getTextSize(ScriptInterface& scriptInterface, JS::MutableHandleValue ret);
+
 protected:
 	/**
 	 * Sets up text, should be called every time changes has been
 	 * made that can change the visual.
 	 */
 	void SetupText();
 
 	/**
 	 * Picks the text color depending on current object settings.
 	 */
 	const CGUIColor& ChooseColor();
 
 	/**
 	 * Placement of text.
 	 */
 	CPos m_TextPos;
 
 	virtual void CreateJSObject();
 
-	void getTextSize(ScriptInterface& scriptInterface, JS::MutableHandleValue ret);
-
 	// Settings
 	float m_BufferZone;
 	i32 m_CellID;
 	CGUIString m_Caption;
 	CStrW m_Font;
 	CGUISpriteInstance m_Sprite;
 	CGUISpriteInstance m_SpriteOver;
 	CGUISpriteInstance m_SpritePressed;
 	CGUISpriteInstance m_SpriteDisabled;
 	EAlign m_TextAlign;
 	EVAlign m_TextVAlign;
 	CGUIColor m_TextColor;
 	CGUIColor m_TextColorOver;
 	CGUIColor m_TextColorPressed;
 	CGUIColor m_TextColorDisabled;
 };
 
 #endif // INCLUDED_CBUTTON
Index: ps/trunk/source/gui/ObjectTypes/CList.cpp
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CList.cpp	(revision 24383)
+++ ps/trunk/source/gui/ObjectTypes/CList.cpp	(revision 24384)
@@ -1,517 +1,510 @@
 /* Copyright (C) 2020 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 "CList.h"
 
 #include "gui/CGUI.h"
 #include "gui/CGUIScrollBarVertical.h"
 #include "gui/SettingTypes/CGUIColor.h"
 #include "gui/SettingTypes/CGUIList.h"
 #include "gui/Scripting/JSInterface_GUIProxy.h"
 #include "lib/external_libraries/libsdl.h"
 #include "lib/timer.h"
 
 const CStr CList::EventNameSelectionChange = "SelectionChange";
 const CStr CList::EventNameHoverChange = "HoverChange";
 const CStr CList::EventNameMouseLeftClickItem = "MouseLeftClickItem";
 const CStr CList::EventNameMouseLeftDoubleClickItem = "MouseLeftDoubleClickItem";
 
 CList::CList(CGUI& pGUI)
 	: IGUIObject(pGUI),
 	  IGUITextOwner(*static_cast<IGUIObject*>(this)),
 	  IGUIScrollBarOwner(*static_cast<IGUIObject*>(this)),
 	  m_Modified(false),
 	  m_PrevSelectedItem(-1),
 	  m_LastItemClickTime(0),
 	  m_BufferZone(),
 	  m_Font(),
 	  m_ScrollBar(),
 	  m_ScrollBarStyle(),
 	  m_ScrollBottom(false),
 	  m_SoundDisabled(),
 	  m_SoundSelected(),
 	  m_Sprite(),
 	  m_SpriteSelectArea(),
 	  m_CellID(),
 	  m_TextAlign(),
 	  m_TextColor(),
 	  m_TextColorSelected(),
 	  m_Selected(),
 	  m_AutoScroll(),
 	  m_Hovered(),
 	  m_List(),
 	  m_ListData()
 {
 	RegisterSetting("buffer_zone", m_BufferZone);
 	RegisterSetting("font", m_Font);
 	RegisterSetting("scrollbar", m_ScrollBar);
 	RegisterSetting("scrollbar_style", m_ScrollBarStyle);
 	RegisterSetting("scroll_bottom", m_ScrollBottom);
 	RegisterSetting("sound_disabled", m_SoundDisabled);
 	RegisterSetting("sound_selected", m_SoundSelected);
 	RegisterSetting("sprite", m_Sprite);
 	// Add sprite_disabled! TODO
 	RegisterSetting("sprite_selectarea", m_SpriteSelectArea);
 	RegisterSetting("cell_id", m_CellID);
 	RegisterSetting("text_align", m_TextAlign);
 	RegisterSetting("textcolor", m_TextColor);
 	RegisterSetting("textcolor_selected", m_TextColorSelected);
 	RegisterSetting("selected", m_Selected); // Index selected. -1 is none.
 	RegisterSetting("auto_scroll", m_AutoScroll);
 	RegisterSetting("hovered", m_Hovered);
 	// Each list item has both a name (in 'list') and an associated data string (in 'list_data')
 	RegisterSetting("list", m_List);
 	RegisterSetting("list_data", m_ListData);
 
 	SetSetting<bool>("scrollbar", false, true);
 	SetSetting<i32>("selected", -1, true);
 	SetSetting<i32>("hovered", -1, true);
 	SetSetting<bool>("auto_scroll", false, true);
 
 	// Add scroll-bar
 	CGUIScrollBarVertical* bar = new CGUIScrollBarVertical(pGUI);
 	bar->SetRightAligned(true);
 	AddScrollBar(bar);
 }
 
 CList::~CList()
 {
 }
 
 void CList::SetupText()
 {
 	SetupText(false);
 }
 
 void CList::SetupText(bool append)
 {
 	m_Modified = true;
 
 	if (!append)
 		// Delete all generated texts.
 		// TODO: try to be cleverer if we want to update items before the end.
 		m_GeneratedTexts.clear();
 
 	float width = GetListRect().GetWidth();
 
 	bool bottom = false;
 	if (m_ScrollBar && GetScrollBar(0).GetStyle())
 	{
 		if (m_ScrollBottom && GetScrollBar(0).GetPos() > GetScrollBar(0).GetMaxPos() - 1.5f)
 			bottom = true;
 
 		// remove scrollbar if applicable
 		width -= GetScrollBar(0).GetStyle()->m_Width;
 	}
 
 	// Generate texts
 	float buffered_y = 0.f;
 
 	if (append && !m_ItemsYPositions.empty())
 		buffered_y = m_ItemsYPositions.back();
 
 	m_ItemsYPositions.resize(m_List.m_Items.size() + 1);
 
 	for (size_t i = append ? m_List.m_Items.size() - 1 : 0; i < m_List.m_Items.size(); ++i)
 	{
 		CGUIText* text;
 
 		if (!m_List.m_Items[i].GetOriginalString().empty())
 			text = &AddText(m_List.m_Items[i], m_Font, width, m_BufferZone);
 		else
 		{
 			// Minimum height of a space character of the current font size
 			CGUIString align_string;
 			align_string.SetValue(L" ");
 			text = &AddText(align_string, m_Font, width, m_BufferZone);
 		}
 
 		m_ItemsYPositions[i] = buffered_y;
 		buffered_y += text->GetSize().cy;
 	}
 
 	m_ItemsYPositions[m_List.m_Items.size()] = buffered_y;
 
 	// Setup scrollbar
 	if (m_ScrollBar)
 	{
 		GetScrollBar(0).SetScrollRange(m_ItemsYPositions.back());
 		GetScrollBar(0).SetScrollSpace(GetListRect().GetHeight());
 
 		CRect rect = GetListRect();
 		GetScrollBar(0).SetX(rect.right);
 		GetScrollBar(0).SetY(rect.top);
 		GetScrollBar(0).SetZ(GetBufferedZ());
 		GetScrollBar(0).SetLength(rect.bottom - rect.top);
 
 		if (bottom)
 			GetScrollBar(0).SetPos(GetScrollBar(0).GetMaxPos());
 	}
 }
 
 void CList::ResetStates()
 {
 	IGUIObject::ResetStates();
 	IGUIScrollBarOwner::ResetStates();
 }
 
 void CList::UpdateCachedSize()
 {
 	IGUIObject::UpdateCachedSize();
 	IGUITextOwner::UpdateCachedSize();
 }
 
 void CList::HandleMessage(SGUIMessage& Message)
 {
 	IGUIObject::HandleMessage(Message);
 	IGUIScrollBarOwner::HandleMessage(Message);
 	//IGUITextOwner::HandleMessage(Message); <== placed it after the switch instead!
 
 	m_Modified = false;
 	switch (Message.type)
 	{
 	case GUIM_SETTINGS_UPDATED:
 		if (Message.value == "list")
 			SetupText();
 
 		// If selected is changed, call "SelectionChange"
 		if (Message.value == "selected")
 		{
 			// TODO: Check range
 
 			if (m_AutoScroll)
 				UpdateAutoScroll();
 
 			ScriptEvent(EventNameSelectionChange);
 		}
 
 		if (Message.value == "scrollbar")
 			SetupText();
 
 		// Update scrollbar
 		if (Message.value == "scrollbar_style")
 		{
 			GetScrollBar(0).SetScrollBarStyle(m_ScrollBarStyle);
 			SetupText();
 		}
 
 		break;
 
 	case GUIM_MOUSE_PRESS_LEFT:
 	{
 		if (!m_Enabled)
 		{
 			PlaySound(m_SoundDisabled);
 			break;
 		}
 
 		int hovered = GetHoveredItem();
 		if (hovered == -1)
 			break;
 		SetSetting<i32>("selected", hovered, true);
 		UpdateAutoScroll();
 		PlaySound(m_SoundSelected);
 
 		if (timer_Time() - m_LastItemClickTime < SELECT_DBLCLICK_RATE && hovered == m_PrevSelectedItem)
 			this->SendMouseEvent(GUIM_MOUSE_DBLCLICK_LEFT_ITEM, EventNameMouseLeftDoubleClickItem);
 		else
 			this->SendMouseEvent(GUIM_MOUSE_PRESS_LEFT_ITEM, EventNameMouseLeftClickItem);
 
 		m_LastItemClickTime = timer_Time();
 		m_PrevSelectedItem = hovered;
 		break;
 	}
 
 	case GUIM_MOUSE_LEAVE:
 	{
 		if (m_Hovered == -1)
 			break;
 
 		SetSetting<i32>("hovered", -1, true);
 		ScriptEvent(EventNameHoverChange);
 		break;
 	}
 
 	case GUIM_MOUSE_OVER:
 	{
 		int hovered = GetHoveredItem();
 		if (hovered == m_Hovered)
 			break;
 
 		SetSetting<i32>("hovered", hovered, true);
 		ScriptEvent(EventNameHoverChange);
 		break;
 	}
 
 	case GUIM_LOAD:
 	{
 		GetScrollBar(0).SetScrollBarStyle(m_ScrollBarStyle);
 		break;
 	}
 
 	default:
 		break;
 	}
 
 	IGUITextOwner::HandleMessage(Message);
 }
 
 InReaction CList::ManuallyHandleKeys(const SDL_Event_* ev)
 {
 	InReaction result = IN_PASS;
 
 	if (ev->ev.type == SDL_KEYDOWN)
 	{
 		int szChar = ev->ev.key.keysym.sym;
 
 		switch (szChar)
 		{
 		case SDLK_HOME:
 			SelectFirstElement();
 			UpdateAutoScroll();
 			result = IN_HANDLED;
 			break;
 
 		case SDLK_END:
 			SelectLastElement();
 			UpdateAutoScroll();
 			result = IN_HANDLED;
 			break;
 
 		case SDLK_UP:
 			SelectPrevElement();
 			UpdateAutoScroll();
 			result = IN_HANDLED;
 			break;
 
 		case SDLK_DOWN:
 			SelectNextElement();
 			UpdateAutoScroll();
 			result = IN_HANDLED;
 			break;
 
 		case SDLK_PAGEUP:
 			GetScrollBar(0).ScrollMinusPlenty();
 			result = IN_HANDLED;
 			break;
 
 		case SDLK_PAGEDOWN:
 			GetScrollBar(0).ScrollPlusPlenty();
 			result = IN_HANDLED;
 			break;
 
 		default: // Do nothing
 			result = IN_PASS;
 		}
 	}
 
 	return result;
 }
 
 void CList::Draw()
 {
 	DrawList(m_Selected, m_Sprite, m_SpriteSelectArea, m_TextColor);
 }
 
 void CList::DrawList(const int& selected, const CGUISpriteInstance& sprite, const CGUISpriteInstance& sprite_selectarea, const CGUIColor& textcolor)
 {
 	float bz = GetBufferedZ();
 
 	// First call draw on ScrollBarOwner
 	if (m_ScrollBar)
 		IGUIScrollBarOwner::Draw();
 
 	{
 		CRect rect = GetListRect();
 
 		m_pGUI.DrawSprite(sprite, m_CellID, bz, rect);
 
 		float scroll = 0.f;
 		if (m_ScrollBar)
 			scroll = GetScrollBar(0).GetPos();
 
 		if (selected >= 0 && selected+1 < (int)m_ItemsYPositions.size())
 		{
 			// Get rectangle of selection:
 			CRect rect_sel(rect.left, rect.top + m_ItemsYPositions[selected] - scroll,
 					       rect.right, rect.top + m_ItemsYPositions[selected+1] - scroll);
 
 			if (rect_sel.top <= rect.bottom &&
 				rect_sel.bottom >= rect.top)
 			{
 				if (rect_sel.bottom > rect.bottom)
 					rect_sel.bottom = rect.bottom;
 				if (rect_sel.top < rect.top)
 					rect_sel.top = rect.top;
 
 				if (m_ScrollBar)
 				{
 					// Remove any overlapping area of the scrollbar.
 					if (rect_sel.right > GetScrollBar(0).GetOuterRect().left &&
 						rect_sel.right <= GetScrollBar(0).GetOuterRect().right)
 						rect_sel.right = GetScrollBar(0).GetOuterRect().left;
 
 					if (rect_sel.left >= GetScrollBar(0).GetOuterRect().left &&
 						rect_sel.left < GetScrollBar(0).GetOuterRect().right)
 						rect_sel.left = GetScrollBar(0).GetOuterRect().right;
 				}
 
 				m_pGUI.DrawSprite(sprite_selectarea, m_CellID, bz + 0.05f, rect_sel);
 			}
 		}
 
 		for (size_t i = 0; i < m_List.m_Items.size(); ++i)
 		{
 			if (m_ItemsYPositions[i+1] - scroll < 0 ||
 				m_ItemsYPositions[i] - scroll > rect.GetHeight())
 				continue;
 
 			// Clipping area (we'll have to substract the scrollbar)
 			CRect cliparea = GetListRect();
 
 			if (m_ScrollBar)
 			{
 				if (cliparea.right > GetScrollBar(0).GetOuterRect().left &&
 					cliparea.right <= GetScrollBar(0).GetOuterRect().right)
 					cliparea.right = GetScrollBar(0).GetOuterRect().left;
 
 				if (cliparea.left >= GetScrollBar(0).GetOuterRect().left &&
 					cliparea.left < GetScrollBar(0).GetOuterRect().right)
 					cliparea.left = GetScrollBar(0).GetOuterRect().right;
 			}
 
 			DrawText(i, textcolor, rect.TopLeft() - CPos(0.f, scroll - m_ItemsYPositions[i]), bz + 0.1f, cliparea);
 		}
 	}
 }
 
 void CList::AddItem(const CGUIString& str, const CGUIString& data)
 {
 	// Do not send a settings-changed message
 	m_List.m_Items.push_back(str);
 	m_ListData.m_Items.push_back(data);
 
 	SetupText(true);
 }
 
 bool CList::HandleAdditionalChildren(const XMBElement& child, CXeromyces* pFile)
 {
 	int elmt_item = pFile->GetElementID("item");
 
 	if (child.GetNodeName() == elmt_item)
 	{
 		CGUIString vlist;
 		vlist.SetValue(child.GetText().FromUTF8());
 		AddItem(vlist, vlist);
 		return true;
 	}
 
 	return false;
 }
 
 void CList::SelectNextElement()
 {
 	if (m_Selected != static_cast<int>(m_List.m_Items.size()) - 1)
 	{
 		SetSetting<i32>("selected", m_Selected + 1, true);
 		PlaySound(m_SoundSelected);
 	}
 }
 
 void CList::SelectPrevElement()
 {
 	if (m_Selected > 0)
 	{
 		SetSetting<i32>("selected", m_Selected - 1, true);
 		PlaySound(m_SoundSelected);
 	}
 }
 
 void CList::SelectFirstElement()
 {
 	if (m_Selected >= 0)
 		SetSetting<i32>("selected", 0, true);
 }
 
 void CList::SelectLastElement()
 {
 	const int index = static_cast<int>(m_List.m_Items.size()) - 1;
 
 	if (m_Selected != index)
 		SetSetting<i32>("selected", index, true);
 }
 
 void CList::UpdateAutoScroll()
 {
 	// No scrollbar, no scrolling (at least it's not made to work properly).
 	if (!m_ScrollBar || m_Selected < 0 || static_cast<std::size_t>(m_Selected) >= m_ItemsYPositions.size())
 		return;
 
 	float scroll = GetScrollBar(0).GetPos();
 
 	// Check upper boundary
 	if (m_ItemsYPositions[m_Selected] < scroll)
 	{
 		GetScrollBar(0).SetPos(m_ItemsYPositions[m_Selected]);
 		return; // this means, if it wants to align both up and down at the same time
 				//  this will have precedence.
 	}
 
 	// Check lower boundary
 	CRect rect = GetListRect();
 	if (m_ItemsYPositions[m_Selected+1]-rect.GetHeight() > scroll)
 		GetScrollBar(0).SetPos(m_ItemsYPositions[m_Selected+1]-rect.GetHeight());
 }
 
 int CList::GetHoveredItem()
 {
 	const float scroll = m_ScrollBar ? GetScrollBar(0).GetPos() : 0.f;
 
 	const CRect& rect = GetListRect();
 	CPos mouse = m_pGUI.GetMousePos();
 	mouse.y += scroll;
 
 	// Mouse is over scrollbar
 	if (m_ScrollBar && GetScrollBar(0).IsVisible() &&
 	    mouse.x >= GetScrollBar(0).GetOuterRect().left &&
 	    mouse.x <= GetScrollBar(0).GetOuterRect().right)
 		return -1;
 
 	for (size_t i = 0; i < m_List.m_Items.size(); ++i)
 		if (mouse.y >= rect.top + m_ItemsYPositions[i] &&
 		    mouse.y < rect.top + m_ItemsYPositions[i + 1])
 			return i;
 
 	return -1;
 }
 
 void CList::CreateJSObject()
 {
 	ScriptRequest rq(m_pGUI.GetScriptInterface());
-
-	js::ProxyOptions options;
-	options.setClass(&JSI_GUIProxy<CList>::ClassDefinition());
-
-	JS::RootedValue cppObj(rq.cx), data(rq.cx);
-	cppObj.get().setPrivate(this);
-	data.get().setPrivate(GetGUI().GetProxyData(&JSI_GUIProxy<CList>::Singleton()));
-	m_JSObject.init(rq.cx, js::NewProxyObject(rq.cx, &JSI_GUIProxy<CList>::Singleton(), cppObj, nullptr, options));
-	js::SetProxyReservedSlot(m_JSObject, 0, data);
+	using ProxyHandler = JSI_GUIProxy<std::remove_pointer_t<decltype(this)>>;
+	ProxyHandler::CreateJSObject(rq, this, GetGUI().GetProxyData(&ProxyHandler::Singleton()), m_JSObject);
 }
 
Index: ps/trunk/source/gui/ObjectTypes/CList.h
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CList.h	(revision 24383)
+++ ps/trunk/source/gui/ObjectTypes/CList.h	(revision 24384)
@@ -1,163 +1,160 @@
 /* Copyright (C) 2020 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_CLIST
 #define INCLUDED_CLIST
 
 #include "gui/CGUISprite.h"
 #include "gui/ObjectBases/IGUIObject.h"
 #include "gui/ObjectBases/IGUIScrollBarOwner.h"
 #include "gui/ObjectBases/IGUITextOwner.h"
 #include "gui/SettingTypes/CGUIList.h"
 
 #include <vector>
 
 /**
  * Create a list of elements, where one can be selected
  * by the user. The control will use a pre-processed
  * text-object for each element, which will be managed
  * by the IGUITextOwner structure.
  *
  * A scroll-bar will appear when needed. This will be
  * achieved with the IGUIScrollBarOwner structure.
  */
 class CList : public IGUIObject, public IGUIScrollBarOwner, public IGUITextOwner
 {
 	GUI_OBJECT(CList)
-
-	friend JSI_GUIProxy<CList>;
-
 public:
 	CList(CGUI& pGUI);
 	virtual ~CList();
 
 	/**
 	 * @see IGUIObject#ResetStates()
 	 */
 	virtual void ResetStates();
 
 	/**
 	 * @see IGUIObject#UpdateCachedSize()
 	 */
 	virtual void UpdateCachedSize();
 
 	/**
 	 * Adds an item last to the list.
 	 */
 	virtual void AddItem(const CGUIString& str, const CGUIString& data);
 
 protected:
 	/**
 	 * Sets up text, should be called every time changes has been
 	 * made that can change the visual.
 	 * @param append - if true, we assume we only need to render the new element at the end of the list.
 	 */
 	virtual void SetupText();
 	virtual void SetupText(bool append);
 
 	/**
 	 * @see IGUIObject#HandleMessage()
 	 */
 	virtual void HandleMessage(SGUIMessage& Message);
 
 	/**
 	 * Handle events manually to catch keyboard inputting.
 	 */
 	virtual InReaction ManuallyHandleKeys(const SDL_Event_* ev);
 
 	/**
 	 * Draws the List box
 	 */
 	virtual void Draw();
 
 	virtual void CreateJSObject();
 
 	/**
 	 * Easy select elements functions
 	 */
 	virtual void SelectNextElement();
 	virtual void SelectPrevElement();
 	virtual void SelectFirstElement();
 	virtual void SelectLastElement();
 
 	/**
 	 * Handle the \<item\> tag.
 	 */
 	virtual bool HandleAdditionalChildren(const XMBElement& child, CXeromyces* pFile);
 
 	// Called every time the auto-scrolling should be checked.
 	void UpdateAutoScroll();
 
 	// Extended drawing interface, this is so that classes built on the this one
 	//  can use other sprite names.
 	virtual void DrawList(const int& selected, const CGUISpriteInstance& sprite, const CGUISpriteInstance& sprite_selected, const CGUIColor& textcolor);
 
 	// Get the area of the list. This is so that it can easily be changed, like in CDropDown
 	//  where the area is not equal to m_CachedActualSize.
 	virtual CRect GetListRect() const { return m_CachedActualSize; }
 
 	// Returns whether SetupText() has run since the last message was received
 	// (and thus whether list items have possibly changed).
 	virtual bool GetModified() const { return m_Modified; }
 
 	/**
 	 * List of each element's relative y position. Will be
 	 * one larger than m_Items, because it will end with the
 	 * bottom of the last element. First element will always
 	 * be zero, but still stored for easy handling.
 	 */
 	std::vector<float> m_ItemsYPositions;
 
 	virtual int GetHoveredItem();
 
 	// Settings
 	float m_BufferZone;
 	CStrW m_Font;
 	bool m_ScrollBar;
 	CStr m_ScrollBarStyle;
 	bool m_ScrollBottom;
 	CStrW m_SoundDisabled;
 	CStrW m_SoundSelected;
 	CGUISpriteInstance m_Sprite;
 	CGUISpriteInstance m_SpriteSelectArea;
 	i32 m_CellID;
 	EAlign m_TextAlign;
 	CGUIColor m_TextColor;
 	CGUIColor m_TextColorSelected;
 	i32 m_Selected;
 	bool m_AutoScroll;
 	i32 m_Hovered;
 	CGUIList m_List;
 	CGUIList m_ListData;
 
 private:
 	static const CStr EventNameSelectionChange;
 	static const CStr EventNameHoverChange;
 	static const CStr EventNameMouseLeftClickItem;
 	static const CStr EventNameMouseLeftDoubleClickItem;
 
 	// Whether the list's items have been modified since last handling a message.
 	bool m_Modified;
 
 	// Used for doubleclick registration
 	int m_PrevSelectedItem;
 
 	// Last time a click on an item was issued
 	double m_LastItemClickTime;
 };
 
 #endif // INCLUDED_CLIST
Index: ps/trunk/source/gui/ObjectTypes/CText.cpp
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CText.cpp	(revision 24383)
+++ ps/trunk/source/gui/ObjectTypes/CText.cpp	(revision 24384)
@@ -1,276 +1,269 @@
 /* Copyright (C) 2020 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 "CText.h"
 
 #include "gui/CGUI.h"
 #include "gui/CGUIScrollBarVertical.h"
 #include "gui/CGUIText.h"
 #include "gui/Scripting/JSInterface_GUIProxy.h"
 #include "scriptinterface/ScriptInterface.h"
 
 CText::CText(CGUI& pGUI)
 	: IGUIObject(pGUI),
 	  IGUIScrollBarOwner(*static_cast<IGUIObject*>(this)),
 	  IGUITextOwner(*static_cast<IGUIObject*>(this)),
 	  m_BufferZone(),
 	  m_Caption(),
 	  m_CellID(),
 	  m_Clip(),
 	  m_Font(),
 	  m_ScrollBar(),
 	  m_ScrollBarStyle(),
 	  m_ScrollBottom(),
 	  m_ScrollTop(),
 	  m_Sprite(),
 	  m_TextAlign(),
 	  m_TextVAlign(),
 	  m_TextColor(),
 	  m_TextColorDisabled(),
 	  m_IconTooltip(),
 	  m_IconTooltipStyle()
 {
 	RegisterSetting("buffer_zone", m_BufferZone);
 	RegisterSetting("caption", m_Caption);
 	RegisterSetting("cell_id", m_CellID);
 	RegisterSetting("clip", m_Clip);
 	RegisterSetting("font", m_Font);
 	RegisterSetting("scrollbar", m_ScrollBar);
 	RegisterSetting("scrollbar_style", m_ScrollBarStyle);
 	RegisterSetting("scroll_bottom", m_ScrollBottom);
 	RegisterSetting("scroll_top", m_ScrollTop);
 	RegisterSetting("sprite", m_Sprite);
 	RegisterSetting("text_align", m_TextAlign);
 	RegisterSetting("text_valign", m_TextVAlign);
 	RegisterSetting("textcolor", m_TextColor);
 	RegisterSetting("textcolor_disabled", m_TextColorDisabled);
 	// Private settings
 	RegisterSetting("_icon_tooltip", m_IconTooltip);
 	RegisterSetting("_icon_tooltip_style", m_IconTooltipStyle);
 
 	//SetSetting<bool>("ghost", true, true);
 	SetSetting<bool>("scrollbar", false, true);
 	SetSetting<bool>("clip", true, true);
 
 	// Add scroll-bar
 	CGUIScrollBarVertical* bar = new CGUIScrollBarVertical(pGUI);
 	bar->SetRightAligned(true);
 	AddScrollBar(bar);
 
 	// Add text
 	AddText();
 }
 
 CText::~CText()
 {
 }
 
 void CText::SetupText()
 {
 	if (m_GeneratedTexts.empty())
 		return;
 
 	float width = m_CachedActualSize.GetWidth();
 	// remove scrollbar if applicable
 	if (m_ScrollBar && GetScrollBar(0).GetStyle())
 		width -= GetScrollBar(0).GetStyle()->m_Width;
 
 	m_GeneratedTexts[0] = CGUIText(m_pGUI, m_Caption, m_Font, width, m_BufferZone, this);
 
 	if (!m_ScrollBar)
 		CalculateTextPosition(m_CachedActualSize, m_TextPos, m_GeneratedTexts[0]);
 
 	// Setup scrollbar
 	if (m_ScrollBar)
 	{
 		// If we are currently scrolled to the bottom of the text,
 		// then add more lines of text, update the scrollbar so we
 		// stick to the bottom.
 		// (Use 1.5px delta so this triggers the first time caption is set)
 		bool bottom = false;
 		if (m_ScrollBottom && GetScrollBar(0).GetPos() > GetScrollBar(0).GetMaxPos() - 1.5f)
 			bottom = true;
 
 		GetScrollBar(0).SetScrollRange(m_GeneratedTexts[0].GetSize().cy);
 		GetScrollBar(0).SetScrollSpace(m_CachedActualSize.GetHeight());
 
 		GetScrollBar(0).SetX(m_CachedActualSize.right);
 		GetScrollBar(0).SetY(m_CachedActualSize.top);
 		GetScrollBar(0).SetZ(GetBufferedZ());
 		GetScrollBar(0).SetLength(m_CachedActualSize.bottom - m_CachedActualSize.top);
 
 		if (bottom)
 			GetScrollBar(0).SetPos(GetScrollBar(0).GetMaxPos());
 
 		if (m_ScrollTop)
 			GetScrollBar(0).SetPos(0.0f);
 	}
 }
 
 void CText::ResetStates()
 {
 	IGUIObject::ResetStates();
 	IGUIScrollBarOwner::ResetStates();
 }
 
 void CText::UpdateCachedSize()
 {
 	IGUIObject::UpdateCachedSize();
 	IGUITextOwner::UpdateCachedSize();
 }
 
 void CText::HandleMessage(SGUIMessage& Message)
 {
 	IGUIObject::HandleMessage(Message);
 	IGUIScrollBarOwner::HandleMessage(Message);
 	//IGUITextOwner::HandleMessage(Message); <== placed it after the switch instead!
 
 	switch (Message.type)
 	{
 	case GUIM_SETTINGS_UPDATED:
 		if (Message.value == "scrollbar")
 			SetupText();
 
 		// Update scrollbar
 		if (Message.value == "scrollbar_style")
 		{
 			GetScrollBar(0).SetScrollBarStyle(m_ScrollBarStyle);
 			SetupText();
 		}
 
 		break;
 
 	case GUIM_MOUSE_WHEEL_DOWN:
 	{
 		GetScrollBar(0).ScrollPlus();
 		// Since the scroll was changed, let's simulate a mouse movement
 		//  to check if scrollbar now is hovered
 		SGUIMessage msg(GUIM_MOUSE_MOTION);
 		HandleMessage(msg);
 		break;
 	}
 	case GUIM_MOUSE_WHEEL_UP:
 	{
 		GetScrollBar(0).ScrollMinus();
 		// Since the scroll was changed, let's simulate a mouse movement
 		//  to check if scrollbar now is hovered
 		SGUIMessage msg(GUIM_MOUSE_MOTION);
 		HandleMessage(msg);
 		break;
 	}
 	case GUIM_LOAD:
 	{
 		GetScrollBar(0).SetX(m_CachedActualSize.right);
 		GetScrollBar(0).SetY(m_CachedActualSize.top);
 		GetScrollBar(0).SetZ(GetBufferedZ());
 		GetScrollBar(0).SetLength(m_CachedActualSize.bottom - m_CachedActualSize.top);
 		GetScrollBar(0).SetScrollBarStyle(m_ScrollBarStyle);
 		break;
 	}
 
 	default:
 		break;
 	}
 
 	IGUITextOwner::HandleMessage(Message);
 }
 
 void CText::Draw()
 {
 	float bz = GetBufferedZ();
 
 	if (m_ScrollBar)
 		IGUIScrollBarOwner::Draw();
 
 	m_pGUI.DrawSprite(m_Sprite, m_CellID, bz, m_CachedActualSize);
 
 	float scroll = 0.f;
 	if (m_ScrollBar)
 		scroll = GetScrollBar(0).GetPos();
 
 	// Clipping area (we'll have to subtract the scrollbar)
 	CRect cliparea;
 	if (m_Clip)
 	{
 		cliparea = m_CachedActualSize;
 
 		if (m_ScrollBar)
 		{
 			// subtract scrollbar from cliparea
 			if (cliparea.right > GetScrollBar(0).GetOuterRect().left &&
 			    cliparea.right <= GetScrollBar(0).GetOuterRect().right)
 				cliparea.right = GetScrollBar(0).GetOuterRect().left;
 
 			if (cliparea.left >= GetScrollBar(0).GetOuterRect().left &&
 			    cliparea.left < GetScrollBar(0).GetOuterRect().right)
 				cliparea.left = GetScrollBar(0).GetOuterRect().right;
 		}
 	}
 
 	const CGUIColor& color = m_Enabled ? m_TextColor : m_TextColorDisabled;
 
 	if (m_ScrollBar)
 		DrawText(0, color, m_CachedActualSize.TopLeft() - CPos(0.f, scroll), bz + 0.1f, cliparea);
 	else
 		DrawText(0, color, m_TextPos, bz + 0.1f, cliparea);
 }
 
 bool CText::MouseOverIcon()
 {
 	for (const CGUIText& guitext : m_GeneratedTexts)
 		for (const CGUIText::SSpriteCall& spritecall : guitext.GetSpriteCalls())
 		{
 			// Check mouse over sprite
 			if (!spritecall.m_Area.PointInside(m_pGUI.GetMousePos() - m_CachedActualSize.TopLeft()))
 				continue;
 
 			// If tooltip exists, set the property
 			if (!spritecall.m_Tooltip.empty())
 			{
 				SetSettingFromString("_icon_tooltip_style", spritecall.m_TooltipStyle, true);
 				SetSettingFromString("_icon_tooltip", spritecall.m_Tooltip, true);
 			}
 
 			return true;
 		}
 
 	return false;
 }
 
 
 void CText::CreateJSObject()
 {
 	ScriptRequest rq(m_pGUI.GetScriptInterface());
-
-	js::ProxyOptions options;
-	options.setClass(&JSI_GUIProxy<CText>::ClassDefinition());
-
-	JS::RootedValue cppObj(rq.cx), data(rq.cx);
-	cppObj.get().setPrivate(this);
-	data.get().setPrivate(GetGUI().GetProxyData(&JSI_GUIProxy<CText>::Singleton()));
-	m_JSObject.init(rq.cx, js::NewProxyObject(rq.cx, &JSI_GUIProxy<CText>::Singleton(), cppObj, nullptr, options));
-	js::SetProxyReservedSlot(m_JSObject, 0, data);
+	using ProxyHandler = JSI_GUIProxy<std::remove_pointer_t<decltype(this)>>;
+	ProxyHandler::CreateJSObject(rq, this, GetGUI().GetProxyData(&ProxyHandler::Singleton()), m_JSObject);
 }
 
 void CText::getTextSize(ScriptInterface& scriptInterface, JS::MutableHandleValue ret)
 {
 	ScriptRequest rq(scriptInterface);
 	UpdateText();
 	ScriptInterface::ToJSVal(rq, ret, m_GeneratedTexts[0].GetSize());
 }
Index: ps/trunk/source/gui/ObjectTypes/CText.h
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CText.h	(revision 24383)
+++ ps/trunk/source/gui/ObjectTypes/CText.h	(revision 24384)
@@ -1,100 +1,99 @@
 /* Copyright (C) 2020 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_CTEXT
 #define INCLUDED_CTEXT
 
 #include "gui/CGUISprite.h"
 #include "gui/ObjectBases/IGUIObject.h"
 #include "gui/ObjectBases/IGUIScrollBarOwner.h"
 #include "gui/ObjectBases/IGUITextOwner.h"
 #include "gui/SettingTypes/CGUIString.h"
 
 /**
  * Text field that just displays static text.
  */
 class CText : public IGUIObject, public IGUIScrollBarOwner, public IGUITextOwner
 {
 	GUI_OBJECT(CText)
-
-	friend JSI_GUIProxy<CText>;
-
 public:
 	CText(CGUI& pGUI);
 	virtual ~CText();
 
 	/**
 	 * @see IGUIObject#ResetStates()
 	 */
 	virtual void ResetStates();
 
 	/**
 	 * @see IGUIObject#UpdateCachedSize()
 	 */
 	virtual void UpdateCachedSize();
 
 	/**
 	 * Test if mouse position is over an icon
 	 */
 	virtual bool MouseOverIcon();
 
+	/**
+	 * Populate @param ret with the object's text size.
+	 */
+	void getTextSize(ScriptInterface& scriptInterface, JS::MutableHandleValue ret);
 protected:
 	/**
 	 * Sets up text, should be called every time changes has been
 	 * made that can change the visual.
 	 */
 	void SetupText();
 
 	/**
 	 * @see IGUIObject#HandleMessage()
 	 */
 	virtual void HandleMessage(SGUIMessage& Message);
 
 	/**
 	 * Draws the Text
 	 */
 	virtual void Draw();
 
 	virtual void CreateJSObject();
 
-	void getTextSize(ScriptInterface& scriptInterface, JS::MutableHandleValue ret);
-
 	/**
 	 * Placement of text. Ignored when scrollbars are active.
 	 */
 	CPos m_TextPos;
 
 	// Settings
 	float m_BufferZone;
 	CGUIString m_Caption;
 	i32 m_CellID;
 	bool m_Clip;
 	CStrW m_Font;
 	bool m_ScrollBar;
 	CStr m_ScrollBarStyle;
 	bool m_ScrollBottom;
 	bool m_ScrollTop;
 	CGUISpriteInstance m_Sprite;
 	EAlign m_TextAlign;
 	EVAlign m_TextVAlign;
 	CGUIColor m_TextColor;
 	CGUIColor m_TextColorDisabled;
 	CStrW m_IconTooltip;
 	CStr m_IconTooltipStyle;
 };
 
 #endif // INCLUDED_CTEXT
Index: ps/trunk/source/gui/Scripting/JSInterface_CButton.cpp
===================================================================
--- ps/trunk/source/gui/Scripting/JSInterface_CButton.cpp	(revision 24383)
+++ ps/trunk/source/gui/Scripting/JSInterface_CButton.cpp	(revision 24384)
@@ -1,81 +1,38 @@
 /* Copyright (C) 2020 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 "JSInterface_GUIProxy.h"
-
-#include "gui/CGUI.h"
-#include "gui/CGUISetting.h"
-#include "gui/ObjectBases/IGUIObject.h"
-#include "gui/ObjectTypes/CButton.h"
-#include "ps/CLogger.h"
-#include "scriptinterface/ScriptExtraHeaders.h"
-#include "scriptinterface/ScriptInterface.h"
-
-#include <string>
-
-// Include the definition of the generic templates.
 #include "JSInterface_GUIProxy_impl.h"
 
-namespace
-{
-struct SData
-{
-	JS::PersistentRootedObject m_ToString;
-	JS::PersistentRootedObject m_Focus;
-	JS::PersistentRootedObject m_Blur;
-	JS::PersistentRootedObject m_GetComputedSize;
-	JS::PersistentRootedObject m_GetTextSize;
-};
-}
+#include "gui/ObjectTypes/CButton.h"
 
-template <>
-bool JSI_GUIProxy<CButton>::FuncGetter(JS::HandleObject proxy, const std::string& propName, JS::MutableHandleValue vp) const
-{
-	const SData& data = *static_cast<const SData*>(js::GetProxyReservedSlot(proxy, 0).toPrivate());
-	if (propName == "toString")
-		return vp.setObjectOrNull(data.m_ToString), true;
-	if (propName == "focus")
-		return vp.setObjectOrNull(data.m_Focus), true;
-	if (propName == "blur")
-		return vp.setObjectOrNull(data.m_Blur), true;
-	if (propName == "getComputedSize")
-		return vp.setObjectOrNull(data.m_GetComputedSize), true;
-	if (propName == "getTextSize")
-		return vp.setObjectOrNull(data.m_GetTextSize), true;
-	return false;
-}
+using GUIObjectType = CButton;
 
-template <>
-std::pair<const js::BaseProxyHandler*, void*> JSI_GUIProxy<CButton>::CreateData(ScriptInterface& scriptInterface)
+template<>
+void JSI_GUIProxy<GUIObjectType>::CreateFunctions(const ScriptRequest& rq, GUIProxyProps* cache)
 {
-	SData* data = new SData();
-	ScriptRequest rq(scriptInterface);
-
-#define func(class, func) &apply_to<CButton, class, &class::func>
-	data->m_ToString.init(rq.cx, JS_GetFunctionObject(JS_NewFunction(rq.cx, func(IGUIObject, toString), 0, 0, "toString")));
-	data->m_Focus.init(rq.cx, JS_GetFunctionObject(JS_NewFunction(rq.cx, func(IGUIObject, focus), 0, 0, "focus")));
-	data->m_Blur.init(rq.cx, JS_GetFunctionObject(JS_NewFunction(rq.cx, func(IGUIObject, blur), 0, 0, "blur")));
-	data->m_GetComputedSize.init(rq.cx, JS_GetFunctionObject(JS_NewFunction(rq.cx, func(IGUIObject, getComputedSize), 0, 0, "getComputedSize")));
-	data->m_GetTextSize.init(rq.cx, JS_GetFunctionObject(JS_NewFunction(rq.cx, func(CButton, getTextSize), 0, 0, "getTextSize")));
+#define func(class, func) &JSInterface_GUIProxy::apply_to<GUIObjectType, class, &class::func>
+	cache->setFunction(rq, "toString", func(IGUIObject, toString), 0);
+	cache->setFunction(rq, "focus", func(IGUIObject, focus), 0);
+	cache->setFunction(rq, "blur", func(IGUIObject, blur), 0);
+	cache->setFunction(rq, "getComputedSize", func(IGUIObject, getComputedSize), 0);
+	cache->setFunction(rq, "getTextSize", func(GUIObjectType, getTextSize), 0);
 #undef func
-
-	return { &Singleton(), data };
 }
 
-template class JSI_GUIProxy<CButton>;
+template class JSI_GUIProxy<GUIObjectType>;
Index: ps/trunk/source/gui/Scripting/JSInterface_CList.cpp
===================================================================
--- ps/trunk/source/gui/Scripting/JSInterface_CList.cpp	(revision 24383)
+++ ps/trunk/source/gui/Scripting/JSInterface_CList.cpp	(revision 24384)
@@ -1,97 +1,54 @@
 /* Copyright (C) 2020 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 "JSInterface_GUIProxy.h"
-
-#include "gui/CGUI.h"
-#include "gui/CGUISetting.h"
-#include "gui/ObjectBases/IGUIObject.h"
-#include "gui/ObjectTypes/CList.h"
-#include "ps/CLogger.h"
-#include "scriptinterface/ScriptExtraHeaders.h"
-#include "scriptinterface/ScriptInterface.h"
-
-#include <string>
-
-// Include the definition of the generic templates.
 #include "JSInterface_GUIProxy_impl.h"
 
-namespace
-{
-struct SData
-{
-	JS::PersistentRootedObject m_ToString;
-	JS::PersistentRootedObject m_Focus;
-	JS::PersistentRootedObject m_Blur;
-	JS::PersistentRootedObject m_GetComputedSize;
-	JS::PersistentRootedObject m_AddItem;
-};
+#include "gui/ObjectTypes/CList.h"
 
 bool CList_AddItem(JSContext* cx, uint argc, JS::Value* vp)
 {
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 	CList* e = static_cast<CList*>(js::GetProxyPrivate(args.thisv().toObjectOrNull()).toPrivate());
 	if (!e)
 		return false;
 
 	ScriptInterface& scriptInterface = *ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface;
 	ScriptRequest rq(scriptInterface);
 	CGUIString text;
 	if (!ScriptInterface::FromJSVal(rq, args.get(0), text))
 		return false;
 	e->AddItem(text, text);
 	return true;
 }
-}
 
-template <>
-bool JSI_GUIProxy<CList>::FuncGetter(JS::HandleObject proxy, const std::string& propName, JS::MutableHandleValue vp) const
-{
-	const SData& data = *static_cast<const SData*>(js::GetProxyReservedSlot(proxy, 0).toPrivate());
-	if (propName == "toString")
-		return vp.setObjectOrNull(data.m_ToString), true;
-	if (propName == "focus")
-		return vp.setObjectOrNull(data.m_Focus), true;
-	if (propName == "blur")
-		return vp.setObjectOrNull(data.m_Blur), true;
-	if (propName == "getComputedSize")
-		return vp.setObjectOrNull(data.m_GetComputedSize), true;
-	if (propName == "addItem")
-		return vp.setObjectOrNull(data.m_AddItem), true;
-	return false;
-}
+using GUIObjectType = CList;
 
-template <>
-std::pair<const js::BaseProxyHandler*, void*> JSI_GUIProxy<CList>::CreateData(ScriptInterface& scriptInterface)
+template<>
+void JSI_GUIProxy<GUIObjectType>::CreateFunctions(const ScriptRequest& rq, GUIProxyProps* cache)
 {
-	SData* data = new SData();
-	ScriptRequest rq(scriptInterface);
-
-#define func(class, func) &apply_to<CList, class, &class::func>
-	data->m_ToString.init(rq.cx, JS_GetFunctionObject(JS_NewFunction(rq.cx, func(IGUIObject, toString), 0, 0, "toString")));
-	data->m_Focus.init(rq.cx, JS_GetFunctionObject(JS_NewFunction(rq.cx, func(IGUIObject, focus), 0, 0, "focus")));
-	data->m_Blur.init(rq.cx, JS_GetFunctionObject(JS_NewFunction(rq.cx, func(IGUIObject, blur), 0, 0, "blur")));
-	data->m_GetComputedSize.init(rq.cx, JS_GetFunctionObject(JS_NewFunction(rq.cx, func(IGUIObject, getComputedSize), 0, 0, "getComputedSize")));
+#define func(class, func) &JSInterface_GUIProxy::apply_to<GUIObjectType, class, &class::func>
+	cache->setFunction(rq, "toString", func(IGUIObject, toString), 0);
+	cache->setFunction(rq, "focus", func(IGUIObject, focus), 0);
+	cache->setFunction(rq, "blur", func(IGUIObject, blur), 0);
+	cache->setFunction(rq, "getComputedSize", func(IGUIObject, getComputedSize), 0);
 #undef func
-	data->m_AddItem.init(rq.cx, JS_GetFunctionObject(JS_NewFunction(rq.cx, CList_AddItem, 1, 0, "addItem")));
-
-	return { &Singleton(), data };
+	cache->setFunction(rq, "addItem", CList_AddItem, 1);
 }
 
-template class JSI_GUIProxy<CList>;
+template class JSI_GUIProxy<GUIObjectType>;
Index: ps/trunk/source/gui/Scripting/JSInterface_CText.cpp
===================================================================
--- ps/trunk/source/gui/Scripting/JSInterface_CText.cpp	(revision 24383)
+++ ps/trunk/source/gui/Scripting/JSInterface_CText.cpp	(revision 24384)
@@ -1,81 +1,38 @@
 /* Copyright (C) 2020 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 "JSInterface_GUIProxy.h"
-
-#include "gui/CGUI.h"
-#include "gui/CGUISetting.h"
-#include "gui/ObjectBases/IGUIObject.h"
-#include "gui/ObjectTypes/CText.h"
-#include "ps/CLogger.h"
-#include "scriptinterface/ScriptExtraHeaders.h"
-#include "scriptinterface/ScriptInterface.h"
-
-#include <string>
-
-// Include the definition of the generic templates.
 #include "JSInterface_GUIProxy_impl.h"
 
-namespace
-{
-struct SData
-{
-	JS::PersistentRootedObject m_ToString;
-	JS::PersistentRootedObject m_Focus;
-	JS::PersistentRootedObject m_Blur;
-	JS::PersistentRootedObject m_GetComputedSize;
-	JS::PersistentRootedObject m_GetTextSize;
-};
-}
+#include "gui/ObjectTypes/CText.h"
 
-template <>
-bool JSI_GUIProxy<CText>::FuncGetter(JS::HandleObject proxy, const std::string& propName, JS::MutableHandleValue vp) const
-{
-	const SData& data = *static_cast<const SData*>(js::GetProxyReservedSlot(proxy, 0).toPrivate());
-	if (propName == "toString")
-		return vp.setObjectOrNull(data.m_ToString), true;
-	if (propName == "focus")
-		return vp.setObjectOrNull(data.m_Focus), true;
-	if (propName == "blur")
-		return vp.setObjectOrNull(data.m_Blur), true;
-	if (propName == "getComputedSize")
-		return vp.setObjectOrNull(data.m_GetComputedSize), true;
-	if (propName == "getTextSize")
-		return vp.setObjectOrNull(data.m_GetTextSize), true;
-	return false;
-}
+using GUIObjectType = CText;
 
-template <>
-std::pair<const js::BaseProxyHandler*, void*> JSI_GUIProxy<CText>::CreateData(ScriptInterface& scriptInterface)
+template<>
+void JSI_GUIProxy<GUIObjectType>::CreateFunctions(const ScriptRequest& rq, GUIProxyProps* cache)
 {
-	SData* data = new SData();
-	ScriptRequest rq(scriptInterface);
-
-#define func(class, func) &apply_to<CText, class, &class::func>
-	data->m_ToString.init(rq.cx, JS_GetFunctionObject(JS_NewFunction(rq.cx, func(IGUIObject, toString), 0, 0, "toString")));
-	data->m_Focus.init(rq.cx, JS_GetFunctionObject(JS_NewFunction(rq.cx, func(IGUIObject, focus), 0, 0, "focus")));
-	data->m_Blur.init(rq.cx, JS_GetFunctionObject(JS_NewFunction(rq.cx, func(IGUIObject, blur), 0, 0, "blur")));
-	data->m_GetComputedSize.init(rq.cx, JS_GetFunctionObject(JS_NewFunction(rq.cx, func(IGUIObject, getComputedSize), 0, 0, "getComputedSize")));
-	data->m_GetTextSize.init(rq.cx, JS_GetFunctionObject(JS_NewFunction(rq.cx, func(CText, getTextSize), 0, 0, "getTextSize")));
+#define func(class, func) &JSInterface_GUIProxy::apply_to<GUIObjectType, class, &class::func>
+	cache->setFunction(rq, "toString", func(IGUIObject, toString), 0);
+	cache->setFunction(rq, "focus", func(IGUIObject, focus), 0);
+	cache->setFunction(rq, "blur", func(IGUIObject, blur), 0);
+	cache->setFunction(rq, "getComputedSize", func(IGUIObject, getComputedSize), 0);
+	cache->setFunction(rq, "getTextSize", func(GUIObjectType, getTextSize), 0);
 #undef func
-
-	return { &Singleton(), data };
 }
 
-template class JSI_GUIProxy<CText>;
+template class JSI_GUIProxy<GUIObjectType>;
Index: ps/trunk/source/gui/Scripting/JSInterface_GUIProxy.h
===================================================================
--- ps/trunk/source/gui/Scripting/JSInterface_GUIProxy.h	(revision 24383)
+++ ps/trunk/source/gui/Scripting/JSInterface_GUIProxy.h	(revision 24384)
@@ -1,133 +1,171 @@
 /* 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_JSI_GUIPROXY
 #define INCLUDED_JSI_GUIPROXY
 
 #include "scriptinterface/ScriptExtraHeaders.h"
 
 #include <utility>
 
 class ScriptInterface;
+class ScriptRequest;
 
 // See JSI_GuiProxy below
 #if GCC_VERSION
 # pragma GCC diagnostic push
 # pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
 #elif MSC_VERSION
 # pragma warning(push, 1)
 # pragma warning(disable: 4265)
 #endif
 
 /**
+ * Proxies need to store some data whose lifetime is tied to an interface.
+ * This is the virtual interface of that data.
+ */
+class GUIProxyProps
+{
+public:
+	virtual ~GUIProxyProps() {};
+
+	// @return true if @param name exists in this cache.
+	virtual bool has(const std::string& name) const = 0;
+	// @return the JSFunction matching @param name. Must call has() first as it can assume existence.
+	virtual JSObject* get(const std::string& name) const = 0;
+	virtual bool setFunction(const ScriptRequest& rq, const std::string& name, JSNative function, int nargs) = 0;
+};
+
+/**
  * Handles the js interface with C++ GUI objects.
  * Proxy handlers must live for at least as long as the JS runtime
  * where a proxy object with that handler was created. The reason is that
  * proxy handlers are called during GC, such as on runtime destruction.
  * In practical terms, this means "just keep them static and store no data".
  *
  * GUI Objects only exist in C++ and have no JS-only properties.
  * As such, there is no "target" JS object that this proxy could point to,
  * and thus we should inherit from BaseProxyHandler and not js::Wrapper.
+ *
+ * Proxies can be used with prototypes and almost treated like regular JS objects.
+ * However, the default implementation embarks a lot of code that we don't really need here,
+ * since the only fanciness is that we cache JSFunction* properties.
+ * As such, these GUI proxies don't have one and instead override get/set directly.
+ *
+ * To add a new JSI_GUIProxy, you'll need to:
+ *  - overload the GUI Object's CreateJSObject with the correct types and pointers
+ *  - change the CGUI::AddObjectTypes method
+ *  - explicitly instantiate the template.
+ *
  */
 template<typename GUIObjectType>
 class JSI_GUIProxy : public js::BaseProxyHandler
 {
 public:
 	// Access the js::Class of the Proxy.
 	static JSClass& ClassDefinition();
 
 	// For convenience, this is the single instantiated JSI_GUIProxy.
 	static JSI_GUIProxy& Singleton();
 
-	static std::pair<const js::BaseProxyHandler*, void*> CreateData(ScriptInterface& scriptInterface);
+	// Call this in CGUI::AddObjectTypes.
+	static std::pair<const js::BaseProxyHandler*, GUIProxyProps*> CreateData(ScriptInterface& scriptInterface);
+
+	static void CreateJSObject(const ScriptRequest& rq, GUIObjectType* ptr, GUIProxyProps* data, JS::PersistentRootedObject& val);
 protected:
 	// @param family can't be nullptr because that's used for some DOM object and it crashes.
 	JSI_GUIProxy() : BaseProxyHandler(this, false, false) {};
+
 	// Note: SM provides no virtual destructor for baseProxyHandler.
 	// This also enforces making proxy handlers dataless static variables.
 	~JSI_GUIProxy() {};
 
-	// This handles returning function properties.
-	// Specialize this.
-	bool FuncGetter(JS::HandleObject proxy, const std::string& propName, JS::MutableHandleValue vp) const;
+	// The default implementations need to know the type of the GUIProxyProps for this proxy type.
+	// This is done by specializing this struct's alias type.
+	struct PropCache;
+
+	// Specialize this to define the custom properties of this type.
+	static void CreateFunctions(const ScriptRequest& rq, GUIProxyProps* cache);
+
+	// This handles returning custom properties. Specialize this if needed.
+	bool PropGetter(JS::HandleObject proxy, const std::string& propName, JS::MutableHandleValue vp) const;
 protected:
 	// BaseProxyHandler interface below
 
 	// Handler for `object.x`
 	virtual bool get(JSContext* cx, JS::HandleObject proxy, JS::HandleValue receiver, JS::HandleId id, JS::MutableHandleValue vp) const override final;
 	// Handler for `object.x = y;`
 	virtual bool set(JSContext* cx, JS::HandleObject proxy, JS::HandleId id, JS::HandleValue vp,
 					 JS::HandleValue receiver, JS::ObjectOpResult& result) const final;
 	// Handler for `delete object.x;`
 	virtual bool delete_(JSContext* cx, JS::HandleObject proxy, JS::HandleId id, JS::ObjectOpResult& result) const override final;
 
 	// The following methods are not provided by BaseProxyHandler.
 	// We provide defaults that do nothing (some raise JS exceptions).
 
 	// The JS code will see undefined when querying a property descriptor.
 	virtual bool getOwnPropertyDescriptor(JSContext* UNUSED(cx), JS::HandleObject UNUSED(proxy), JS::HandleId UNUSED(id),
 										  JS::MutableHandle<JS::PropertyDescriptor> UNUSED(desc)) const override
 	{
 		return true;
 	}
 	// Throw an exception is JS code attempts defining a property.
 	virtual bool defineProperty(JSContext* UNUSED(cx), JS::HandleObject UNUSED(proxy), JS::HandleId UNUSED(id),
 								JS::Handle<JS::PropertyDescriptor> UNUSED(desc), JS::ObjectOpResult& UNUSED(result)) const override
 	{
 		return false;
 	}
 	// No accessible properties.
 	virtual bool ownPropertyKeys(JSContext* UNUSED(cx), JS::HandleObject UNUSED(proxy), JS::MutableHandleIdVector UNUSED(props)) const override
 	{
 		return true;
 	}
 	// Nothing to enumerate.
 	virtual bool enumerate(JSContext* UNUSED(cx), JS::HandleObject UNUSED(proxy), JS::MutableHandleIdVector UNUSED(props)) const override
 	{
 		return true;
 	}
 	// Throw an exception is JS attempts to query the prototype.
 	virtual bool getPrototypeIfOrdinary(JSContext* UNUSED(cx), JS::HandleObject UNUSED(proxy), bool* UNUSED(isOrdinary), JS::MutableHandleObject UNUSED(protop)) const override
 	{
 		return false;
 	}
 	// Throw an exception - no prototype to set.
 	virtual bool setImmutablePrototype(JSContext* UNUSED(cx), JS::HandleObject UNUSED(proxy), bool* UNUSED(succeeded)) const override
 	{
 		return false;
 	}
 	// We are not extensible.
 	virtual bool preventExtensions(JSContext* UNUSED(cx), JS::HandleObject UNUSED(proxy), JS::ObjectOpResult& UNUSED(result)) const override
 	{
 		return true;
 	}
 	virtual bool isExtensible(JSContext* UNUSED(cx), JS::HandleObject UNUSED(proxy), bool* extensible) const override
 	{
 		*extensible = false;
 		return true;
 	}
 };
 
 #if GCC_VERSION
 # pragma GCC diagnostic pop
 #elif MSC_VERSION
 # pragma warning(pop)
 #endif
 
 
 #endif // INCLUDED_JSI_GUIPROXY
Index: ps/trunk/source/gui/Scripting/JSInterface_GUIProxy_impl.h
===================================================================
--- ps/trunk/source/gui/Scripting/JSInterface_GUIProxy_impl.h	(revision 24383)
+++ ps/trunk/source/gui/Scripting/JSInterface_GUIProxy_impl.h	(revision 24384)
@@ -1,206 +1,291 @@
 /* Copyright (C) 2020 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 file is included directly into actual implementation files.
 
+#include "JSInterface_GUIProxy.h"
+
+#include "gui/CGUI.h"
+#include "gui/CGUISetting.h"
+#include "gui/ObjectBases/IGUIObject.h"
+#include "ps/CLogger.h"
+#include "scriptinterface/ScriptExtraHeaders.h"
+#include "scriptinterface/ScriptInterface.h"
+
+#include <string>
+
 template <typename T>
 JSClass& JSI_GUIProxy<T>::ClassDefinition()
 {
 	static JSClass c = PROXY_CLASS_DEF("GUIObjectProxy", JSCLASS_HAS_CACHED_PROTO(JSProto_Proxy) | JSCLASS_HAS_RESERVED_SLOTS(1));
 	return c;
 }
 
 template <typename T>
 JSI_GUIProxy<T>& JSI_GUIProxy<T>::Singleton()
 {
 	static JSI_GUIProxy<T> s;
 	return s;
 }
 
-namespace
+// Use a common namespace to avoid duplicating the symbols un-necessarily.
+namespace JSInterface_GUIProxy
 {
+/**
+ * Conveniently wrap a simple C++ function to a JSNative.
+ */
 template<class OG, class R, void (R::*funcptr)(ScriptInterface&, JS::MutableHandleValue)>
 inline bool apply_to(JSContext* cx, uint argc, JS::Value* vp)
 {
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 	OG* e = static_cast<OG*>(js::GetProxyPrivate(args.thisv().toObjectOrNull()).toPrivate());
 	if (!e)
 		return false;
 
 	(static_cast<R*>(e)->*(funcptr))(*(ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface), args.rval());
 
 	return true;
 }
+
+// Default implementation of the cache via unordered_map
+class MapCache : public GUIProxyProps
+{
+public:
+	virtual ~MapCache() {};
+
+	virtual bool has(const std::string& name) const override
+	{
+		return m_Functions.find(name) != m_Functions.end();
+	}
+
+	virtual JSObject* get(const std::string& name) const override
+	{
+		return m_Functions.at(name).get();
+	}
+
+	virtual bool setFunction(const ScriptRequest& rq, const std::string& name, JSNative function, int nargs) override
+	{
+		m_Functions[name].init(rq.cx, JS_GetFunctionObject(JS_NewFunction(rq.cx, function, nargs, 0, name.c_str())));
+		return true;
+	}
+
+protected:
+	std::unordered_map<std::string, JS::PersistentRootedObject> m_Functions;
+};
+}
+
+// The default propcache is a MapCache.
+template<typename T>
+struct JSI_GUIProxy<T>::PropCache
+{
+	using type = JSInterface_GUIProxy::MapCache;
+};
+
+template <typename T>
+bool JSI_GUIProxy<T>::PropGetter(JS::HandleObject proxy, const std::string& propName, JS::MutableHandleValue vp) const
+{
+	using PropertyCache = typename PropCache::type;
+	// Since we know at compile time what the type actually is, avoid the virtual call.
+	const PropertyCache* data = static_cast<const PropertyCache*>(static_cast<const GUIProxyProps*>(js::GetProxyReservedSlot(proxy, 0).toPrivate()));
+	if (data->has(propName))
+	{
+		vp.setObjectOrNull(data->get(propName));
+		return true;
+	}
+	return false;
+}
+
+template <typename T>
+std::pair<const js::BaseProxyHandler*, GUIProxyProps*> JSI_GUIProxy<T>::CreateData(ScriptInterface& scriptInterface)
+{
+	using PropertyCache = typename PropCache::type;
+	PropertyCache* data = new PropertyCache();
+	ScriptRequest rq(scriptInterface);
+	CreateFunctions(rq, data);
+	return { &Singleton(), data };
+}
+
+template<typename T>
+void JSI_GUIProxy<T>::CreateJSObject(const ScriptRequest& rq, T* ptr, GUIProxyProps* dataPtr, JS::PersistentRootedObject& val)
+{
+	js::ProxyOptions options;
+	options.setClass(&ClassDefinition());
+
+	JS::RootedValue cppObj(rq.cx), data(rq.cx);
+	cppObj.get().setPrivate(ptr);
+	data.get().setPrivate(static_cast<void*>(dataPtr));
+	val.init(rq.cx, js::NewProxyObject(rq.cx, &Singleton(), cppObj, nullptr, options));
+	js::SetProxyReservedSlot(val, 0, data);
 }
 
 template <typename T>
 bool JSI_GUIProxy<T>::get(JSContext* cx, JS::HandleObject proxy, JS::HandleValue UNUSED(receiver), JS::HandleId id, JS::MutableHandleValue vp) const
 {
 	ScriptInterface* pScriptInterface = ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface;
 	ScriptRequest rq(*pScriptInterface);
 
 	T* e = static_cast<T*>(js::GetProxyPrivate(proxy.get()).toPrivate());
 	if (!e)
 		return false;
 
 	JS::RootedValue idval(rq.cx);
 	if (!JS_IdToValue(rq.cx, id, &idval))
 		return false;
 
 	std::string propName;
 	if (!ScriptInterface::FromJSVal(rq, idval, propName))
 		return false;
 
 	// Return function properties. Specializable.
-	if (FuncGetter(proxy, propName, vp))
+	if (PropGetter(proxy, propName, vp))
 		return true;
 
 	// Use onWhatever to access event handlers
 	if (propName.substr(0, 2) == "on")
 	{
 		CStr eventName(propName.substr(2));
 		std::map<CStr, JS::Heap<JSObject*>>::iterator it = e->m_ScriptHandlers.find(eventName);
 		if (it == e->m_ScriptHandlers.end())
 			vp.setNull();
 		else
 			vp.setObject(*it->second.get());
 		return true;
 	}
 
 	if (propName == "parent")
 	{
 		IGUIObject* parent = e->GetParent();
 
 		if (parent)
 			vp.set(JS::ObjectValue(*parent->GetJSObject()));
 		else
 			vp.set(JS::NullValue());
 
 		return true;
 	}
 	else if (propName == "children")
 	{
 		ScriptInterface::CreateArray(rq, vp);
 
 		for (size_t i = 0; i < e->m_Children.size(); ++i)
 			pScriptInterface->SetPropertyInt(vp, i, e->m_Children[i]);
 
 		return true;
 	}
 	else if (propName == "name")
 	{
 		ScriptInterface::ToJSVal(rq, vp, e->GetName());
 		return true;
 	}
 	else if (e->SettingExists(propName))
 	{
 		e->m_Settings[propName]->ToJSVal(rq, vp);
 		return true;
 	}
 
 	LOGERROR("Property '%s' does not exist!", propName.c_str());
 	return false;
 }
 
 
 template <typename T>
 bool JSI_GUIProxy<T>::set(JSContext* cx, JS::HandleObject proxy, JS::HandleId id, JS::HandleValue vp,
 							JS::HandleValue UNUSED(receiver), JS::ObjectOpResult& result) const
 {
 	T* e = static_cast<T*>(js::GetProxyPrivate(proxy.get()).toPrivate());
 	if (!e)
 	{
 		LOGERROR("C++ GUI Object could not be found");
 		return result.fail(JSMSG_OBJECT_REQUIRED);
 	}
 
 	ScriptRequest rq(*ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface);
 
 	JS::RootedValue idval(rq.cx);
 	if (!JS_IdToValue(rq.cx, id, &idval))
 		return result.fail(JSMSG_BAD_PROP_ID);
 
 	std::string propName;
 	if (!ScriptInterface::FromJSVal(rq, idval, propName))
 		return result.fail(JSMSG_BAD_PROP_ID);
 
 	if (propName == "name")
 	{
 		std::string value;
 		if (!ScriptInterface::FromJSVal(rq, vp, value))
 			return result.fail(JSMSG_BAD_PROP_ID);
 		e->SetName(value);
 		return result.succeed();
 	}
 
 	JS::RootedObject vpObj(cx);
 	if (vp.isObject())
 		vpObj = &vp.toObject();
 
 	// Use onWhatever to set event handlers
 	if (propName.substr(0, 2) == "on")
 	{
 		if (vp.isPrimitive() || vp.isNull() || !JS_ObjectIsFunction(&vp.toObject()))
 		{
 			LOGERROR("on- event-handlers must be functions");
 			return result.fail(JSMSG_NOT_FUNCTION);
 		}
 
 		CStr eventName(propName.substr(2));
 		e->SetScriptHandler(eventName, vpObj);
 
 		return result.succeed();
 	}
 
 	if (e->SettingExists(propName))
 		return e->m_Settings[propName]->FromJSVal(rq, vp, true) ? result.succeed() : result.fail(JSMSG_USER_DEFINED_ERROR);
 
 	LOGERROR("Property '%s' does not exist!", propName.c_str());
 	return result.fail(JSMSG_BAD_PROP_ID);
 }
 
 template<typename T>
 bool JSI_GUIProxy<T>::delete_(JSContext* cx, JS::HandleObject proxy, JS::HandleId id, JS::ObjectOpResult& result) const
 {
 	T* e = static_cast<T*>(js::GetProxyPrivate(proxy.get()).toPrivate());
 	if (!e)
 	{
 		LOGERROR("C++ GUI Object could not be found");
 		return result.fail(JSMSG_OBJECT_REQUIRED);
 	}
 
 	ScriptRequest rq(*ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface);
 
 	JS::RootedValue idval(rq.cx);
 	if (!JS_IdToValue(rq.cx, id, &idval))
 		return result.fail(JSMSG_BAD_PROP_ID);
 
 	std::string propName;
 	if (!ScriptInterface::FromJSVal(rq, idval, propName))
 		return result.fail(JSMSG_BAD_PROP_ID);
 
 	// event handlers
 	if (propName.substr(0, 2) == "on")
 	{
 		CStr eventName(propName.substr(2));
 		e->UnsetScriptHandler(eventName);
 		return result.succeed();
 	}
 
 	LOGERROR("Only event handlers can be deleted from GUI objects!");
 	return result.fail(JSMSG_BAD_PROP_ID);
 }
Index: ps/trunk/source/gui/Scripting/JSInterface_IGUIObject.cpp
===================================================================
--- ps/trunk/source/gui/Scripting/JSInterface_IGUIObject.cpp	(revision 24383)
+++ ps/trunk/source/gui/Scripting/JSInterface_IGUIObject.cpp	(revision 24384)
@@ -1,75 +1,35 @@
 /* Copyright (C) 2020 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 "JSInterface_GUIProxy.h"
-
-#include "gui/CGUI.h"
-#include "gui/CGUISetting.h"
-#include "gui/ObjectBases/IGUIObject.h"
-#include "gui/ObjectTypes/CText.h"
-#include "ps/CLogger.h"
-#include "scriptinterface/ScriptExtraHeaders.h"
-#include "scriptinterface/ScriptInterface.h"
-
-#include <string>
-
-// Include the definition of the generic templates.
 #include "JSInterface_GUIProxy_impl.h"
 
-namespace
-{
-struct SData
-{
-	JS::PersistentRootedObject m_ToString;
-	JS::PersistentRootedObject m_Focus;
-	JS::PersistentRootedObject m_Blur;
-	JS::PersistentRootedObject m_GetComputedSize;
-};
-}
-
-template <>
-bool JSI_GUIProxy<IGUIObject>::FuncGetter(JS::HandleObject proxy, const std::string& propName, JS::MutableHandleValue vp) const
-{
-	const SData& data = *static_cast<const SData*>(js::GetProxyReservedSlot(proxy, 0).toPrivate());
-	if (propName == "toString")
-		return vp.setObjectOrNull(data.m_ToString), true;
-	if (propName == "focus")
-		return vp.setObjectOrNull(data.m_Focus), true;
-	if (propName == "blur")
-		return vp.setObjectOrNull(data.m_Blur), true;
-	if (propName == "getComputedSize")
-		return vp.setObjectOrNull(data.m_GetComputedSize), true;
-	return false;
-}
+using GUIObjectType = IGUIObject;
 
-template <>
-std::pair<const js::BaseProxyHandler*, void*> JSI_GUIProxy<IGUIObject>::CreateData(ScriptInterface& scriptInterface)
+template<>
+void JSI_GUIProxy<GUIObjectType>::CreateFunctions(const ScriptRequest& rq, GUIProxyProps* cache)
 {
-	SData* data = new SData();
-	ScriptRequest rq(scriptInterface);
-#define func(class, func) &apply_to<IGUIObject, class, &class::func>
-	data->m_ToString.init(rq.cx, JS_GetFunctionObject(JS_NewFunction(rq.cx, func(IGUIObject, toString), 0, 0, "toString")));
-	data->m_Focus.init(rq.cx, JS_GetFunctionObject(JS_NewFunction(rq.cx, func(IGUIObject, focus), 0, 0, "focus")));
-	data->m_Blur.init(rq.cx, JS_GetFunctionObject(JS_NewFunction(rq.cx, func(IGUIObject, blur), 0, 0, "blur")));
-	data->m_GetComputedSize.init(rq.cx, JS_GetFunctionObject(JS_NewFunction(rq.cx, func(IGUIObject, getComputedSize), 0, 0, "getComputedSize")));
+#define func(class, func) &JSInterface_GUIProxy::apply_to<GUIObjectType, class, &class::func>
+	cache->setFunction(rq, "toString", func(IGUIObject, toString), 0);
+	cache->setFunction(rq, "focus", func(IGUIObject, focus), 0);
+	cache->setFunction(rq, "blur", func(IGUIObject, blur), 0);
+	cache->setFunction(rq, "getComputedSize", func(IGUIObject, getComputedSize), 0);
 #undef func
-	return { &Singleton(), data };
 }
 
-template class JSI_GUIProxy<IGUIObject>;
+template class JSI_GUIProxy<GUIObjectType>;