Index: ps/trunk/binaries/data/mods/public/gui/reference/viewer/viewer.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/reference/viewer/viewer.js	(revision 22133)
+++ ps/trunk/binaries/data/mods/public/gui/reference/viewer/viewer.js	(revision 22134)
@@ -1,225 +1,221 @@
 /**
  * Holder for the template file being displayed.
  */
 var g_Template = {};
 
 /**
  * Holder for the template lists generated by compileTemplateLists().
  */
 var g_TemplateLists = {};
 
 /**
  * Used to display textual information and the build/train lists of the
  * template being displayed.
  *
  * At present, these are drawn in the main body of the page.
  */
 var g_InfoFunctions = [
 	getEntityTooltip,
 	getHistoryTooltip,
 	getDescriptionTooltip,
 	getAurasTooltip,
 	getVisibleEntityClassesFormatted,
 	getBuiltByText,
 	getTrainedByText,
 	getResearchedByText,
 	getBuildText,
 	getTrainText,
 	getResearchText,
 	getUpgradeText
 ];
 
 /**
  * Override style so we can get a bigger specific name.
  */
 g_TooltipTextFormats.nameSpecificBig.font = "sans-bold-20";
 g_TooltipTextFormats.nameSpecificSmall.font = "sans-bold-16";
 g_TooltipTextFormats.nameGeneric.font = "sans-bold-16";
 
 /**
  * Path to unit rank icons.
  */
 var g_RankIconPath = "session/icons/ranks/";
 
 /**
  * Page initialisation. May also eventually pre-draw/arrange objects.
  *
  * @param {object} data - Contains the civCode and the name of the template to display.
  * @param {string} data.templateName
  * @param {string} [data.civ]
  * @param {*} [data.callback] - If set and loosely equivalent to true, a callback is
  *                              assumed to be setup ready be called by the Engine upon
  *                              closure of this page.
  */
 function init(data)
 {
 	if (!data || !data.templateName)
 	{
 		error("Viewer: No template provided");
 		closePage();
 		return;
 	}
 
 	if (data.callback)
 		g_CallbackSet = true;
 
 	let templateName = removeFiltersFromTemplateName(data.templateName);
 	let isTech = techDataExists(templateName);
 
 	// Attempt to get the civ code from the template, or, if
 	// it's a technology, from the researcher's template.
 	if (!isTech)
 	{
 		// Catch and redirect if template is a non-promotion variant of
 		// another (ie. units/{civ}_support_female_citizen_house).
 		templateName = getBaseTemplateName(templateName);
 
 		g_SelectedCiv = loadTemplate(templateName).Identity.Civ;
 	}
 
 	if (g_SelectedCiv == "gaia" && data.civ)
 		g_SelectedCiv = data.civ;
 
 	g_TemplateLists = compileTemplateLists(g_SelectedCiv);
 	g_CurrentModifiers = deriveModifications(g_AutoResearchTechList);
 
 	g_Template = isTech ? loadTechnology(templateName) : loadEntityTemplate(templateName);
 	if (!g_Template)
 	{
 		error("Viewer: unable to recognise or load template (" + templateName + ")");
 		closePage();
 		return;
 	}
 
 	g_StatsFunctions = [getEntityCostTooltip].concat(g_StatsFunctions);
 
 	draw();
 }
 
 /**
  * Populate the UI elements.
- *
- * @todo (c++ change) Implement and use a function that fetches height of rendered text block from text object.
  */
 function draw()
 {
 	Engine.GetGUIObjectByName("entityName").caption = getEntityNamesFormatted(g_Template);
 
 	let entityIcon = Engine.GetGUIObjectByName("entityIcon");
 	entityIcon.sprite = "stretched:session/portraits/" + g_Template.icon;
 
 	let entityStats = Engine.GetGUIObjectByName("entityStats");
 	entityStats.caption = buildText(g_Template, g_StatsFunctions);
 
-	// This is something of a crude hack. See above todo.
 	let entityInfo = Engine.GetGUIObjectByName("entityInfo");
-	let lines = entityStats.caption.split("\n").length;
-	let fontSize = +entityStats.font.split("-")[1] + 4;
 	let infoSize = entityInfo.size;
-	infoSize.top = Math.max(entityIcon.size.bottom, lines * fontSize + entityStats.size.top) + 8;
+	// The magic '8' below provides a gap between the bottom of the icon, and the start of the info text.
+	infoSize.top = Math.max(entityIcon.size.bottom + 8, entityStats.size.top + entityStats.getTextSize().height);
 	entityInfo.size = infoSize;
 
 	entityInfo.caption = buildText(g_Template, g_InfoFunctions, "\n\n");
 
 	if (g_Template.promotion)
 		Engine.GetGUIObjectByName("entityRankGlyph").sprite = "stretched:" + g_RankIconPath + g_Template.promotion.current_rank + ".png";
 	Engine.GetGUIObjectByName("entityRankGlyph").hidden = !g_Template.promotion;
 }
 
 function getBuiltByText(template)
 {
 	if (g_SelectedCiv == "gaia" || !g_TemplateLists.structures.has(template.name.internal))
 		return "";
 
 	let builders = g_TemplateLists.structures.get(template.name.internal);
 	if (!builders.length)
 		return "";
 
 	// Translation: Label before a list of the names of units that build the structure selected.
 	return buildListText(translate("Built by:"), builders.map(builder => getEntityNames(loadEntityTemplate(builder))));
 }
 
 function getTrainedByText(template)
 {
 	if (g_SelectedCiv == "gaia" || !g_TemplateLists.units.has(template.name.internal))
 		return "";
 
 	let trainers = g_TemplateLists.units.get(template.name.internal);
 	if (!trainers.length)
 		return "";
 
 	// Translation: Label before a list of the names of structures or units that train the unit selected.
 	return buildListText(translate("Trained by:"), trainers.map(trainer => getEntityNames(loadEntityTemplate(trainer))));
 }
 
 function getResearchedByText(template)
 {
 	if (g_SelectedCiv == "gaia" || !g_TemplateLists.techs.has(template.name.internal))
 		return "";
 
 	let researchers = g_TemplateLists.techs.get(template.name.internal);
 	if (!researchers.length)
 		return "";
 
 	// Translation: Label before a list of names of structures or units that research the technology selected.
 	return buildListText(translate("Researched at:"), researchers.map(researcher => getEntityNames(loadEntityTemplate(researcher))));
 }
 
 /**
  * @return {string} List of the names of the buildings the selected unit can build.
  */
 function getBuildText(template)
 {
 	if (!template.builder || !template.builder.length)
 		return "";
 
 	// Translation: Label before a list of the names of structures the selected unit can construct or build.
 	return buildListText(translate("Builds:"),
 		template.builder.map(prod => getEntityNames(loadEntityTemplate(prod))));
 }
 
 /**
  * @return {string} List of the names of the technologies the selected structure/unit can research.
  */
 function getResearchText(template)
 {
 	if (!template.production || !template.production.techs || !template.production.techs.length)
 		return "";
 
 	let researchNames = [];
 	for (let tech of template.production.techs)
 	{
 		let techTemplate = loadTechnology(tech);
 		if (techTemplate.reqs)
 			researchNames.push(getEntityNames(techTemplate));
 	}
 
 	// Translation: Label before a list of the names of technologies the selected unit or structure can research.
 	return buildListText(translate("Researches:"), researchNames);
 }
 
 /**
  * @return {string} List of the names of the units the selected unit can train.
  */
 function getTrainText(template)
 {
 	if (!template.production || !template.production.units || !template.production.units.length)
 		return "";
 
 	// Translation: Label before a list of the names of units the selected unit or structure can train.
 	return buildListText(translate("Trains:"),
 		template.production.units.map(prod => getEntityNames(loadEntityTemplate(prod))));
 }
 
 /**
  * @return {string} List of the names of the buildings/units the selected structure/unit can upgrade to.
  */
 function getUpgradeText(template)
 {
 	if (!template.upgrades)
 		return "";
 
 	// Translation: Label before a list of the names of units or structures the selected unit or structure can be upgradable to.
 	return buildListText(translate("Upgradable to:"),
 		template.upgrades.map(upgrade => getEntityNames(upgrade.name ? upgrade : loadEntityTemplate(upgrade.entity))));
 }
Index: ps/trunk/source/gui/CGUI.cpp
===================================================================
--- ps/trunk/source/gui/CGUI.cpp	(revision 22133)
+++ ps/trunk/source/gui/CGUI.cpp	(revision 22134)
@@ -1,1745 +1,1755 @@
-/* Copyright (C) 2018 Wildfire Games.
+/* 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 <stdarg.h>
 #include <string>
 
 #include "GUI.h"
 
 // Types - when including them into the engine.
 #include "CButton.h"
 #include "CChart.h"
 #include "CCheckBox.h"
 #include "CDropDown.h"
 #include "CImage.h"
 #include "CInput.h"
 #include "CList.h"
 #include "COList.h"
 #include "CProgressBar.h"
 #include "CRadioButton.h"
 #include "CSlider.h"
 #include "CText.h"
 #include "CTooltip.h"
 #include "MiniMap.h"
 
 #include "graphics/FontMetrics.h"
 #include "graphics/ShaderManager.h"
 #include "graphics/TextRenderer.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 "scripting/ScriptFunctions.h"
 #include "scriptinterface/ScriptInterface.h"
 
 extern int g_yres;
 
 const double SELECT_DBLCLICK_RATE = 0.5;
 const u32 MAX_OBJECT_DEPTH = 100; // Max number of nesting for GUI includes. Used to detect recursive inclusion
 
 InReaction CGUI::HandleEvent(const SDL_Event_* ev)
 {
 	InReaction ret = IN_PASS;
 
 	if (ev->ev.type == SDL_HOTKEYDOWN || ev->ev.type == SDL_HOTKEYUP)
 	{
 		const char* hotkey = static_cast<const char*>(ev->ev.user.data1);
 
 		std::map<CStr, std::vector<IGUIObject*> >::iterator it = m_HotkeyObjects.find(hotkey);
 		if (it != m_HotkeyObjects.end())
 			for (IGUIObject* const& obj : it->second)
 			{
 				// Update hotkey status before sending the event,
 				// else the status will be outdated when processing the GUI event.
 				HotkeyInputHandler(ev);
 				ret = IN_HANDLED;
 
 				if (ev->ev.type == SDL_HOTKEYDOWN)
 					obj->SendEvent(GUIM_PRESSED, "press");
 				else
 					obj->SendEvent(GUIM_RELEASED, "release");
 			}
 	}
 
 	else if (ev->ev.type == SDL_MOUSEMOTION)
 	{
 		// Yes the mouse position is stored as float to avoid
 		//  constant conversions when operating in a
 		//  float-based environment.
 		m_MousePos = CPos((float)ev->ev.motion.x / g_GuiScale, (float)ev->ev.motion.y / g_GuiScale);
 
 		SGUIMessage msg(GUIM_MOUSE_MOTION);
 		GUI<SGUIMessage>::RecurseObject(GUIRR_HIDDEN | GUIRR_GHOST, m_BaseObject,
 										&IGUIObject::HandleMessage,
 										msg);
 	}
 
 	// Update m_MouseButtons. (BUTTONUP is handled later.)
 	else if (ev->ev.type == SDL_MOUSEBUTTONDOWN)
 	{
 		switch (ev->ev.button.button)
 		{
 		case SDL_BUTTON_LEFT:
 		case SDL_BUTTON_RIGHT:
 		case SDL_BUTTON_MIDDLE:
 			m_MouseButtons |= Bit<unsigned int>(ev->ev.button.button);
 			break;
 		default:
 			break;
 		}
 	}
 
 	// Update m_MousePos (for delayed mouse button events)
 	CPos oldMousePos = m_MousePos;
 	if (ev->ev.type == SDL_MOUSEBUTTONDOWN || ev->ev.type == SDL_MOUSEBUTTONUP)
 	{
 		m_MousePos = CPos((float)ev->ev.button.x / g_GuiScale, (float)ev->ev.button.y / g_GuiScale);
 	}
 
 	// Only one object can be hovered
 	IGUIObject* pNearest = NULL;
 
 	// TODO Gee: (2004-09-08) Big TODO, don't do the below if the SDL_Event is something like a keypress!
 	try
 	{
 		PROFILE("mouse events");
 		// TODO Gee: Optimizations needed!
 		//  these two recursive function are quite overhead heavy.
 
 		// pNearest will after this point at the hovered object, possibly NULL
 		pNearest = FindObjectUnderMouse();
 
 		// Now we'll call UpdateMouseOver on *all* objects,
 		//  we'll input the one hovered, and they will each
 		//  update their own data and send messages accordingly
 		GUI<IGUIObject*>::RecurseObject(GUIRR_HIDDEN | GUIRR_GHOST,
 			m_BaseObject, &IGUIObject::UpdateMouseOver, pNearest);
 
 		if (ev->ev.type == SDL_MOUSEBUTTONDOWN)
 		{
 			switch (ev->ev.button.button)
 			{
 			case SDL_BUTTON_LEFT:
 				// Focus the clicked object (or focus none if nothing clicked on)
 				SetFocusedObject(pNearest);
 
 				if (pNearest)
 					ret = pNearest->SendEvent(GUIM_MOUSE_PRESS_LEFT, "mouseleftpress");
 				break;
 
 			case SDL_BUTTON_RIGHT:
 				if (pNearest)
 					ret = pNearest->SendEvent(GUIM_MOUSE_PRESS_RIGHT, "mouserightpress");
 				break;
 
 			default:
 				break;
 			}
 		}
 		else if (ev->ev.type == SDL_MOUSEWHEEL && pNearest)
 		{
 			if (ev->ev.wheel.y < 0)
 				ret = pNearest->SendEvent(GUIM_MOUSE_WHEEL_DOWN, "mousewheeldown");
 			else if (ev->ev.wheel.y > 0)
 				ret = pNearest->SendEvent(GUIM_MOUSE_WHEEL_UP, "mousewheelup");
 		}
 		else if (ev->ev.type == SDL_MOUSEBUTTONUP)
 		{
 			switch (ev->ev.button.button)
 			{
 			case SDL_BUTTON_LEFT:
 				if (pNearest)
 				{
 					double timeElapsed = timer_Time() - pNearest->m_LastClickTime[SDL_BUTTON_LEFT];
 					pNearest->m_LastClickTime[SDL_BUTTON_LEFT] = timer_Time();
 
 					if (timeElapsed < SELECT_DBLCLICK_RATE)
 						ret = pNearest->SendEvent(GUIM_MOUSE_DBLCLICK_LEFT, "mouseleftdoubleclick");
 					else
 						ret = pNearest->SendEvent(GUIM_MOUSE_RELEASE_LEFT, "mouseleftrelease");
 				}
 				break;
 			case SDL_BUTTON_RIGHT:
 				if (pNearest)
 				{
 					double timeElapsed = timer_Time() - pNearest->m_LastClickTime[SDL_BUTTON_RIGHT];
 					pNearest->m_LastClickTime[SDL_BUTTON_RIGHT] = timer_Time();
 
 					if (timeElapsed < SELECT_DBLCLICK_RATE)
 						ret = pNearest->SendEvent(GUIM_MOUSE_DBLCLICK_RIGHT, "mouserightdoubleclick");
 					else
 						ret = pNearest->SendEvent(GUIM_MOUSE_RELEASE_RIGHT, "mouserightrelease");
 				}
 				break;
 			}
 
 			// Reset all states on all visible objects
 			GUI<>::RecurseObject(GUIRR_HIDDEN, m_BaseObject,
 									&IGUIObject::ResetStates);
 
 			// Since the hover state will have been reset, we reload it.
 			GUI<IGUIObject*>::RecurseObject(GUIRR_HIDDEN | GUIRR_GHOST,
 				m_BaseObject, &IGUIObject::UpdateMouseOver, pNearest);
 		}
 	}
 	catch (PSERROR_GUI& e)
 	{
 		UNUSED2(e);
 		debug_warn(L"CGUI::HandleEvent error");
 		// TODO Gee: Handle
 	}
 
 	// BUTTONUP's effect on m_MouseButtons is handled after
 	// everything else, so that e.g. 'press' handlers (activated
 	// on button up) see which mouse button had been pressed.
 	if (ev->ev.type == SDL_MOUSEBUTTONUP)
 	{
 		switch (ev->ev.button.button)
 		{
 		case SDL_BUTTON_LEFT:
 		case SDL_BUTTON_RIGHT:
 		case SDL_BUTTON_MIDDLE:
 			m_MouseButtons &= ~Bit<unsigned int>(ev->ev.button.button);
 			break;
 		default:
 			break;
 		}
 	}
 
 	// Restore m_MousePos (for delayed mouse button events)
 	if (ev->ev.type == SDL_MOUSEBUTTONDOWN || ev->ev.type == SDL_MOUSEBUTTONUP)
 		m_MousePos = oldMousePos;
 
 	// Handle keys for input boxes
 	if (GetFocusedObject())
 	{
 		if ((ev->ev.type == SDL_KEYDOWN &&
 		     ev->ev.key.keysym.sym != SDLK_ESCAPE &&
 		     !g_keys[SDLK_LCTRL] && !g_keys[SDLK_RCTRL] &&
 		     !g_keys[SDLK_LALT] && !g_keys[SDLK_RALT]) ||
 		    ev->ev.type == SDL_HOTKEYDOWN ||
 		    ev->ev.type == SDL_TEXTINPUT ||
 		    ev->ev.type == SDL_TEXTEDITING)
 		{
 			ret = GetFocusedObject()->ManuallyHandleEvent(ev);
 		}
 		// else will return IN_PASS because we never used the button.
 	}
 
 	return ret;
 }
 
 void CGUI::TickObjects()
 {
 	CStr action = "tick";
 	GUI<CStr>::RecurseObject(0, m_BaseObject,
 							&IGUIObject::ScriptEvent, action);
 
 	m_Tooltip.Update(FindObjectUnderMouse(), m_MousePos, this);
 }
 
 void CGUI::SendEventToAll(const CStr& EventName)
 {
 	// janwas 2006-03-03: spoke with Ykkrosh about EventName case.
 	// when registering, case is converted to lower - this avoids surprise
 	// if someone were to get the case wrong and then not notice their
 	// handler is never called. however, until now, the other end
 	// (sending events here) wasn't converting to lower case,
 	// leading to a similar problem.
 	// now fixed; case is irrelevant since all are converted to lower.
 	GUI<CStr>::RecurseObject(0, m_BaseObject,
 		&IGUIObject::ScriptEvent, EventName.LowerCase());
 }
 
 CGUI::CGUI(const shared_ptr<ScriptRuntime>& runtime)
 	: m_MouseButtons(0), m_FocusedObject(NULL), m_InternalNameNumber(0)
 {
 	m_ScriptInterface.reset(new ScriptInterface("Engine", "GUIPage", runtime));
 	GuiScriptingInit(*m_ScriptInterface);
 	m_ScriptInterface->LoadGlobalScripts();
 	m_BaseObject = new CGUIDummyObject;
 	m_BaseObject->SetGUI(this);
 }
 
 CGUI::~CGUI()
 {
 	Destroy();
 
 	if (m_BaseObject)
 		delete m_BaseObject;
 }
 
 IGUIObject* CGUI::ConstructObject(const CStr& str)
 {
 	if (m_ObjectTypes.count(str) > 0)
 		return (*m_ObjectTypes[str])();
 	else
 	{
 		// Error reporting will be handled with the NULL return.
 		return NULL;
 	}
 }
 
 void CGUI::Initialize()
 {
 	// Add base types!
 	//  You can also add types outside the GUI to extend the flexibility of the GUI.
 	//  Pyrogenesis though will have all the object types inserted from here.
 	AddObjectType("empty",			&CGUIDummyObject::ConstructObject);
 	AddObjectType("button",			&CButton::ConstructObject);
 	AddObjectType("image",			&CImage::ConstructObject);
 	AddObjectType("text",			&CText::ConstructObject);
 	AddObjectType("checkbox",		&CCheckBox::ConstructObject);
 	AddObjectType("radiobutton",	&CRadioButton::ConstructObject);
 	AddObjectType("progressbar",	&CProgressBar::ConstructObject);
 	AddObjectType("minimap",        &CMiniMap::ConstructObject);
 	AddObjectType("input",			&CInput::ConstructObject);
 	AddObjectType("list",			&CList::ConstructObject);
 	AddObjectType("olist",			&COList::ConstructObject);
 	AddObjectType("dropdown",		&CDropDown::ConstructObject);
 	AddObjectType("tooltip",		&CTooltip::ConstructObject);
 	AddObjectType("chart",			&CChart::ConstructObject);
 	AddObjectType("slider",			&CSlider::ConstructObject);
 }
 
 void CGUI::Draw()
 {
 	// Clear the depth buffer, so the GUI is
 	// drawn on top of everything else
 	glClear(GL_DEPTH_BUFFER_BIT);
 
 	try
 	{
 		// Recurse IGUIObject::Draw() with restriction: hidden
 		//  meaning all hidden objects won't call Draw (nor will it recurse its children)
 		GUI<>::RecurseObject(GUIRR_HIDDEN, m_BaseObject, &IGUIObject::Draw);
 	}
 	catch (PSERROR_GUI& e)
 	{
 		LOGERROR("GUI draw error: %s", e.what());
 	}
 }
 
 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.IsEmpty())
 		return;
 
 	// TODO: Clipping?
 
 	Sprite.Draw(Rect, CellID, m_Sprites, Z);
 }
 
 void CGUI::Destroy()
 {
 	// We can use the map to delete all
 	//  now we don't want to cancel all if one Destroy fails
 	for (const std::pair<CStr, IGUIObject*>& p : m_pAllObjects)
 	{
 		try
 		{
 			p.second->Destroy();
 		}
 		catch (PSERROR_GUI& e)
 		{
 			UNUSED2(e);
 			debug_warn(L"CGUI::Destroy error");
 			// TODO Gee: Handle
 		}
 
 		delete p.second;
 	}
 	m_pAllObjects.clear();
 
 	for (const std::pair<CStr, CGUISprite*>& p : m_Sprites)
 		delete p.second;
 	m_Sprites.clear();
 	m_Icons.clear();
 }
 
 void CGUI::UpdateResolution()
 {
 	// Update ALL cached
 	GUI<>::RecurseObject(0, m_BaseObject, &IGUIObject::UpdateCachedSize);
 }
 
 void CGUI::AddObject(IGUIObject* pObject)
 {
 	try
 	{
 		// Add CGUI pointer
 		GUI<CGUI*>::RecurseObject(0, pObject, &IGUIObject::SetGUI, this);
 
 		m_BaseObject->AddChild(pObject);
 
 		// Cache tree
 		GUI<>::RecurseObject(0, pObject, &IGUIObject::UpdateCachedSize);
 
 		SGUIMessage msg(GUIM_LOAD);
 		GUI<SGUIMessage>::RecurseObject(0, pObject, &IGUIObject::HandleMessage, msg);
 	}
 	catch (PSERROR_GUI&)
 	{
 		throw;
 	}
 }
 
 void CGUI::UpdateObjects()
 {
 	// We'll fill a temporary map until we know everything succeeded
 	map_pObjects AllObjects;
 
 	try
 	{
 		// Fill freshly
 		GUI<map_pObjects>::RecurseObject(0, m_BaseObject, &IGUIObject::AddToPointersMap, AllObjects);
 	}
 	catch (PSERROR_GUI&)
 	{
 		throw;
 	}
 
 	// Else actually update the real one
 	m_pAllObjects.swap(AllObjects);
 }
 
 bool CGUI::ObjectExists(const CStr& Name) const
 {
 	return m_pAllObjects.count(Name) != 0;
 }
 
 IGUIObject* CGUI::FindObjectByName(const CStr& Name) const
 {
 	map_pObjects::const_iterator it = m_pAllObjects.find(Name);
 	if (it == m_pAllObjects.end())
 		return NULL;
 	else
 		return it->second;
 }
 
 IGUIObject* CGUI::FindObjectUnderMouse() const
 {
 	IGUIObject* pNearest = NULL;
 
 	GUI<IGUIObject*>::RecurseObject(GUIRR_HIDDEN | GUIRR_GHOST, m_BaseObject,
 		&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);
 	}
 }
 
+const SGUIScrollBarStyle* CGUI::GetScrollBarStyle(const CStr& style) const
+{
+	std::map<CStr, SGUIScrollBarStyle>::const_iterator it = m_ScrollBarStyles.find(style);
+	if (it == m_ScrollBarStyles.end())
+		return nullptr;
+
+ 	return &it->second;
+}
+
 // private struct used only in GenerateText(...)
 struct SGenerateTextImage
 {
 	float m_YFrom,			// The image's starting location in Y
 		  m_YTo,			// The image's end location in Y
 		  m_Indentation;	// The image width in other words
 
 	// Some help functions
 	// TODO Gee: CRect => CPoint ?
 	void SetupSpriteCall(const bool Left, SGUIText::SSpriteCall& SpriteCall,
 						 const float width, const float y,
 						 const CSize& Size, const CStr& TextureName,
 						 const float BufferZone, const int CellID)
 	{
 		// TODO Gee: Temp hardcoded values
 		SpriteCall.m_Area.top = y+BufferZone;
 		SpriteCall.m_Area.bottom = y+BufferZone + Size.cy;
 
 		if (Left)
 		{
 			SpriteCall.m_Area.left = BufferZone;
 			SpriteCall.m_Area.right = Size.cx+BufferZone;
 		}
 		else
 		{
 			SpriteCall.m_Area.left = width-BufferZone - Size.cx;
 			SpriteCall.m_Area.right = width-BufferZone;
 		}
 
 		SpriteCall.m_CellID = CellID;
 		SpriteCall.m_Sprite = TextureName;
 
 		m_YFrom = SpriteCall.m_Area.top-BufferZone;
 		m_YTo = SpriteCall.m_Area.bottom+BufferZone;
 		m_Indentation = Size.cx+BufferZone*2;
 	}
 };
 
 SGUIText CGUI::GenerateText(const CGUIString& string, const CStrW& FontW, const float& Width, const float& BufferZone, const IGUIObject* pObject)
 {
 	SGUIText Text;
 
 	CStrIntern Font(FontW.ToUTF8());
 
 	if (string.m_Words.empty())
 		return Text;
 
 	float x = BufferZone, y = BufferZone; // drawing pointer
 	int from = 0;
 	bool done = false;
 
 	bool FirstLine = true;	// Necessary because text in the first line is shorter
 							// (it doesn't count the line spacing)
 
 	// Images on the left or the right side.
 	std::vector<SGenerateTextImage> Images[2];
 	int pos_last_img = -1;	// Position in the string where last img (either left or right) were encountered.
 							//  in order to avoid duplicate processing.
 
 	// Easier to read.
 	bool WordWrapping = (Width != 0);
 
 	// get the alignment type for the control we are computing the text for since
 	// we are computing the horizontal alignment in this method in order to not have
 	// to run through the TextCalls a second time in the CalculateTextPosition method again
-	EAlign align;
-	GUI<EAlign>::GetSetting(pObject, "text_align", align);
+	EAlign align = EAlign_Left;
+	if (pObject->SettingExists("text_align"))
+		GUI<EAlign>::GetSetting(pObject, "text_align", align);
 
 	// Go through string word by word
 	for (int i = 0; i < (int)string.m_Words.size()-1 && !done; ++i)
 	{
 		// Pre-process each line one time, so we know which floating images
 		//  will be added for that line.
 
 		// Generated stuff is stored in Feedback.
 		CGUIString::SFeedback Feedback;
 
 		// Preliminary line_height, used for word-wrapping with floating images.
 		float prelim_line_height = 0.f;
 
 		// Width and height of all text calls generated.
 		string.GenerateTextCall(this, Feedback, Font,
 								string.m_Words[i], string.m_Words[i+1],
 								FirstLine);
 
 		// Loop through our images queues, to see if images has been added.
 
 		// Check if this has already been processed.
 		//  Also, floating images are only applicable if Word-Wrapping is on
 		if (WordWrapping && i > pos_last_img)
 		{
 			// Loop left/right
 			for (int j = 0; j < 2; ++j)
 			{
 				for (const CStr& imgname : Feedback.m_Images[j])
 				{
 					SGUIText::SSpriteCall SpriteCall;
 					SGenerateTextImage Image;
 
 					// Y is if no other floating images is above, y. Else it is placed
 					//  after the last image, like a stack downwards.
 					float _y;
 					if (!Images[j].empty())
 						_y = std::max(y, Images[j].back().m_YTo);
 					else
 						_y = y;
 
 					// Get Size from Icon database
 					SGUIIcon icon = GetIcon(imgname);
 
 					CSize size = icon.m_Size;
 					Image.SetupSpriteCall((j == CGUIString::SFeedback::Left), SpriteCall, Width, _y, size, icon.m_SpriteName, BufferZone, icon.m_CellID);
 
 					// Check if image is the lowest thing.
 					Text.m_Size.cy = std::max(Text.m_Size.cy, Image.m_YTo);
 
 					Images[j].push_back(Image);
 					Text.m_SpriteCalls.push_back(SpriteCall);
 				}
 			}
 		}
 
 		pos_last_img = std::max(pos_last_img, i);
 
 		x += Feedback.m_Size.cx;
 		prelim_line_height = std::max(prelim_line_height, Feedback.m_Size.cy);
 
 		// If Width is 0, then there's no word-wrapping, disable NewLine.
 		if ((WordWrapping && (x > Width-BufferZone || Feedback.m_NewLine)) || i == (int)string.m_Words.size()-2)
 		{
 			// Change 'from' to 'i', but first keep a copy of its value.
 			int temp_from = from;
 			from = i;
 
 			static const int From = 0, To = 1;
 			//int width_from=0, width_to=width;
 			float width_range[2];
 			width_range[From] = BufferZone;
 			width_range[To] = Width - BufferZone;
 
 			// Floating images are only applicable if word-wrapping is enabled.
 			if (WordWrapping)
 			{
 				// Decide width of the line. We need to iterate our floating images.
 				//  this won't be exact because we're assuming the line_height
 				//  will be as our preliminary calculation said. But that may change,
 				//  although we'd have to add a couple of more loops to try straightening
 				//  this problem out, and it is very unlikely to happen noticeably if one
 				//  structures his text in a stylistically pure fashion. Even if not, it
 				//  is still quite unlikely it will happen.
 				// Loop through left and right side, from and to.
 				for (int j = 0; j < 2; ++j)
 				{
 					for (const SGenerateTextImage& img : Images[j])
 					{
 						// We're working with two intervals here, the image's and the line height's.
 						//  let's find the union of these two.
 						float union_from, union_to;
 
 						union_from = std::max(y, img.m_YFrom);
 						union_to = std::min(y+prelim_line_height, img.m_YTo);
 
 						// The union is not empty
 						if (union_to > union_from)
 						{
 							if (j == From)
 								width_range[From] = std::max(width_range[From], img.m_Indentation);
 							else
 								width_range[To] = std::min(width_range[To], Width - img.m_Indentation);
 						}
 					}
 				}
 			}
 
 			// Reset X for the next loop
 			x = width_range[From];
 
 			// Now we'll do another loop to figure out the height and width of
 			//  the line (the height of the largest character and the width is
 			//  the sum of all of the individual widths). This
 			//  couldn't be determined in the first loop (main loop)
 			//  because it didn't regard images, so we don't know
 			//  if all characters processed, will actually be involved
 			//  in that line.
 			float line_height = 0.f;
 			float line_width = 0.f;
 			for (int j = temp_from; j <= i; ++j)
 			{
 				// We don't want to use Feedback now, so we'll have to use
 				//  another.
 				CGUIString::SFeedback Feedback2;
 
 				// Don't attach object, it'll suppress the errors
 				//  we want them to be reported in the final GenerateTextCall()
 				//  so that we don't get duplicates.
 				string.GenerateTextCall(this, Feedback2, Font,
 										string.m_Words[j], string.m_Words[j+1],
 										FirstLine);
 
 				// Append X value.
 				x += Feedback2.m_Size.cx;
 
 				if (WordWrapping && x > width_range[To] && j!=temp_from && !Feedback2.m_NewLine)
 				{
 					// The calculated width of each word includes the space between the current
 					// word and the next. When we're wrapping, we need subtract the width of the
 					// space after the last word on the line before the wrap.
 					CFontMetrics currentFont(Font);
 					line_width -= currentFont.GetCharacterWidth(*L" ");
 					break;
 				}
 
 				// Let line_height be the maximum m_Height we encounter.
 				line_height = std::max(line_height, Feedback2.m_Size.cy);
 
 				// If the current word is an explicit new line ("\n"),
 				// break now before adding the width of this character.
 				// ("\n" doesn't have a glyph, thus is given the same width as
 				// the "missing glyph" character by CFont::GetCharacterWidth().)
 				if (WordWrapping && Feedback2.m_NewLine)
 					break;
 
 				line_width += Feedback2.m_Size.cx;
 			}
 
 			float dx = 0.f;
 			// compute offset based on what kind of alignment
 			switch (align)
 			{
 			case EAlign_Left:
 				// don't add an offset
 				dx = 0.f;
 				break;
 
 			case EAlign_Center:
 				dx = ((width_range[To] - width_range[From]) - line_width) / 2;
 				break;
 
 			case EAlign_Right:
 				dx = width_range[To] - line_width;
 				break;
 
 			default:
 				debug_warn(L"Broken EAlign in CGUI::GenerateText()");
 				break;
 			}
 			// Reset x once more
 			x = width_range[From];
 			// Move down, because font drawing starts from the baseline
 			y += line_height;
 
 			// Do the real processing now
 			for (int j = temp_from; j <= i; ++j)
 			{
 				// We don't want to use Feedback now, so we'll have to use
 				//  another one.
 				CGUIString::SFeedback Feedback2;
 
 				// Defaults
 				string.GenerateTextCall(this, Feedback2, Font,
 										string.m_Words[j], string.m_Words[j+1],
 										FirstLine, pObject);
 
 				// Iterate all and set X/Y values
 				// Since X values are not set, we need to make an internal
 				//  iteration with an increment that will append the internal
 				//  x, that is what x_pointer is for.
 				float x_pointer = 0.f;
 
 				for (SGUIText::STextCall& tc : Feedback2.m_TextCalls)
 				{
 					tc.m_Pos = CPos(dx + x + x_pointer, y);
 
 					x_pointer += tc.m_Size.cx;
 
 					if (tc.m_pSpriteCall)
 						tc.m_pSpriteCall->m_Area += tc.m_Pos - CSize(0, tc.m_pSpriteCall->m_Area.GetHeight());
 				}
 
 				// Append X value.
 				x += Feedback2.m_Size.cx;
 
 				// The first word overrides the width limit, what we
 				//  do, in those cases, are just drawing that word even
 				//  though it'll extend the object.
 				if (WordWrapping) // only if word-wrapping is applicable
 				{
 					if (Feedback2.m_NewLine)
 					{
 						from = j+1;
 
 						// Sprite call can exist within only a newline segment,
 						//  therefore we need this.
 						Text.m_SpriteCalls.insert(Text.m_SpriteCalls.end(), Feedback2.m_SpriteCalls.begin(), Feedback2.m_SpriteCalls.end());
 						break;
 					}
 					else if (x > width_range[To] && j == temp_from)
 					{
 						from = j+1;
 						// do not break, since we want it to be added to m_TextCalls
 					}
 					else if (x > width_range[To])
 					{
 						from = j;
 						break;
 					}
 				}
 
 				// Add the whole Feedback2.m_TextCalls to our m_TextCalls.
 				Text.m_TextCalls.insert(Text.m_TextCalls.end(), Feedback2.m_TextCalls.begin(), Feedback2.m_TextCalls.end());
 				Text.m_SpriteCalls.insert(Text.m_SpriteCalls.end(), Feedback2.m_SpriteCalls.begin(), Feedback2.m_SpriteCalls.end());
 
 				if (j == (int)string.m_Words.size()-2)
 					done = true;
 			}
 
 			// Reset X
 			x = BufferZone;
 
 			// Update dimensions
 			Text.m_Size.cx = std::max(Text.m_Size.cx, line_width + BufferZone * 2);
 			Text.m_Size.cy = std::max(Text.m_Size.cy, y + BufferZone);
 
 			FirstLine = false;
 
 			// Now if we entered as from = i, then we want
 			//  i being one minus that, so that it will become
 			//  the same i in the next loop. The difference is that
 			//  we're on a new line now.
 			i = from-1;
 		}
 	}
 
 	return Text;
 }
 
 void CGUI::DrawText(SGUIText& Text, const CColor& DefaultColor, const CPos& pos, const float& z, const CRect& clipping)
 {
 	CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_gui_text);
 
 	tech->BeginPass();
 
 	bool isClipped = (clipping != CRect());
 	if (isClipped)
 	{
 		glEnable(GL_SCISSOR_TEST);
 		glScissor(
 			clipping.left * g_GuiScale,
 			g_yres - clipping.bottom * g_GuiScale,
 			clipping.GetWidth() * g_GuiScale,
 			clipping.GetHeight() * g_GuiScale);
 	}
 
 	CTextRenderer textRenderer(tech->GetShader());
 	textRenderer.SetClippingRect(clipping);
 	textRenderer.Translate(0.0f, 0.0f, z);
 
 	for (const SGUIText::STextCall& tc : Text.m_TextCalls)
 	{
 		// If this is just a placeholder for a sprite call, continue
 		if (tc.m_pSpriteCall)
 			continue;
 
 		CColor color = tc.m_UseCustomColor ? tc.m_Color : DefaultColor;
 
 		textRenderer.Color(color);
 		textRenderer.Font(tc.m_Font);
 		textRenderer.Put((float)(int)(pos.x + tc.m_Pos.x), (float)(int)(pos.y + tc.m_Pos.y), &tc.m_String);
 	}
 
 	textRenderer.Render();
 
 	for (const SGUIText::SSpriteCall& sc : Text.m_SpriteCalls)
 		DrawSprite(sc.m_Sprite, sc.m_CellID, z, sc.m_Area + pos);
 
 	if (isClipped)
 		glDisable(GL_SCISSOR_TEST);
 
 	tech->EndPass();
 }
 
 bool CGUI::GetPreDefinedColor(const CStr& name, CColor& Output) const
 {
 	std::map<CStr, CColor>::const_iterator cit = m_PreDefinedColors.find(name);
 	if (cit == m_PreDefinedColors.end())
 		return false;
 
 	Output = cit->second;
 	return true;
 }
 
 /**
  * @callgraph
  */
 void CGUI::LoadXmlFile(const VfsPath& Filename, boost::unordered_set<VfsPath>& Paths)
 {
 	Paths.insert(Filename);
 
 	CXeromyces XeroFile;
 	if (XeroFile.Load(g_VFS, Filename, "gui") != PSRETURN_OK)
 		return;
 
 	XMBElement node = XeroFile.GetRoot();
 
 	CStr root_name(XeroFile.GetElementString(node.GetNodeName()));
 	try
 	{
 		if (root_name == "objects")
 		{
 			Xeromyces_ReadRootObjects(node, &XeroFile, Paths);
 
 			// Re-cache all values so these gets cached too.
 			//UpdateResolution();
 		}
 		else if (root_name == "sprites")
 			Xeromyces_ReadRootSprites(node, &XeroFile);
 		else if (root_name == "styles")
 			Xeromyces_ReadRootStyles(node, &XeroFile);
 		else if (root_name == "setup")
 			Xeromyces_ReadRootSetup(node, &XeroFile);
 		else
 			debug_warn(L"CGUI::LoadXmlFile error");
 	}
 	catch (PSERROR_GUI& e)
 	{
 		LOGERROR("Errors loading GUI file %s (%u)", Filename.string8(), e.getCode());
 		return;
 	}
 }
 
 //===================================================================
 //	XML Reading Xeromyces Specific Sub-Routines
 //===================================================================
 
 void CGUI::Xeromyces_ReadRootObjects(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths)
 {
 	int el_script = pFile->GetElementID("script");
 
 	std::vector<std::pair<CStr, CStr> > subst;
 
 	// Iterate main children
 	//  they should all be <object> or <script> elements
 	for (XMBElement child : Element.GetChildNodes())
 	{
 		if (child.GetNodeName() == el_script)
 			// Execute the inline script
 			Xeromyces_ReadScript(child, pFile, Paths);
 		else
 			// Read in this whole object into the GUI
 			Xeromyces_ReadObject(child, pFile, m_BaseObject, subst, Paths, 0);
 	}
 }
 
 void CGUI::Xeromyces_ReadRootSprites(XMBElement Element, CXeromyces* pFile)
 {
 	for (XMBElement child : Element.GetChildNodes())
 		Xeromyces_ReadSprite(child, pFile);
 }
 
 void CGUI::Xeromyces_ReadRootStyles(XMBElement Element, CXeromyces* pFile)
 {
 	for (XMBElement child : Element.GetChildNodes())
 		Xeromyces_ReadStyle(child, pFile);
 }
 
 void CGUI::Xeromyces_ReadRootSetup(XMBElement Element, CXeromyces* pFile)
 {
 	for (XMBElement child : Element.GetChildNodes())
 	{
 		CStr name(pFile->GetElementString(child.GetNodeName()));
 
 		if (name == "scrollbar")
 			Xeromyces_ReadScrollBarStyle(child, pFile);
 		else if (name == "icon")
 			Xeromyces_ReadIcon(child, pFile);
 		else if (name == "tooltip")
 			Xeromyces_ReadTooltip(child, pFile);
 		else if (name == "color")
 			Xeromyces_ReadColor(child, pFile);
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 }
 
 void CGUI::Xeromyces_ReadObject(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths, u32 nesting_depth)
 {
 	ENSURE(pParent);
 
 	XMBAttributeList attributes = Element.GetAttributes();
 
 	CStr type(attributes.GetNamedItem(pFile->GetAttributeID("type")));
 	if (type.empty())
 		type = "empty";
 
 	// Construct object from specified type
 	//  henceforth, we need to do a rollback before aborting.
 	//  i.e. releasing this object
 	IGUIObject* object = ConstructObject(type);
 
 	if (!object)
 	{
 		LOGERROR("GUI: Unrecognized object type \"%s\"", type.c_str());
 		return;
 	}
 
 	// Cache some IDs for element attribute names, to avoid string comparisons
 	#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
 	#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
 	ELMT(object);
 	ELMT(action);
 	ELMT(repeat);
 	ELMT(translatableAttribute);
 	ELMT(translate);
 	ELMT(attribute);
 	ELMT(keep);
 	ELMT(include);
 	ATTR(style);
 	ATTR(type);
 	ATTR(name);
 	ATTR(hotkey);
 	ATTR(z);
 	ATTR(on);
 	ATTR(file);
 	ATTR(directory);
 	ATTR(id);
 	ATTR(context);
 
 	//
 	//	Read Style and set defaults
 	//
 	//	If the setting "style" is set, try loading that setting.
 	//
 	//	Always load default (if it's available) first!
 	//
 	CStr argStyle(attributes.GetNamedItem(attr_style));
 
 	if (m_Styles.count("default") == 1)
 		object->LoadStyle(*this, "default");
 
 	if (!argStyle.empty())
 	{
 		if (m_Styles.count(argStyle) == 0)
 			LOGERROR("GUI: Trying to use style '%s' that doesn't exist.", argStyle.c_str());
 		else
 			object->LoadStyle(*this, argStyle);
 	}
 
 	bool NameSet = false;
 	bool ManuallySetZ = false;
 
 	CStrW inclusionPath;
 	CStr hotkeyTag;
 
 	for (XMBAttribute attr : attributes)
 	{
 		// If value is "null", then it is equivalent as never being entered
 		if (CStr(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_hotkey)
 			hotkeyTag = attr.Value;
 
 		if (attr.Name == attr_z)
 			ManuallySetZ = true;
 
 		if (object->SetSetting(pFile->GetAttributeString(attr.Name), attr.Value.FromUTF8(), true) != PSRETURN_OK)
 			LOGERROR("GUI: (object: %s) Can't set \"%s\" to \"%s\"", object->GetPresentableName(), pFile->GetAttributeString(attr.Name), attr.Value);
 	}
 
 	// Check if name isn't set, generate an internal name in that case.
 	if (!NameSet)
 	{
 		object->SetName("__internal(" + CStr::FromInt(m_InternalNameNumber) + ")");
 		++m_InternalNameNumber;
 	}
 
 	if (!hotkeyTag.empty())
 		m_HotkeyObjects[hotkeyTag].push_back(object);
 
 	CStrW caption(Element.GetText().FromUTF8());
 	if (!caption.empty())
 		object->SetSetting("caption", caption, true);
 
 	for (XMBElement child : Element.GetChildNodes())
 	{
 		// Check what name the elements got
 		int element_name = child.GetNodeName();
 
 		if (element_name == elmt_object)
 		{
 			// Call this function on the child
 			Xeromyces_ReadObject(child, pFile, object, NameSubst, Paths, nesting_depth);
 		}
 		else if (element_name == elmt_action)
 		{
 			// Scripted <action> element
 
 			// Check for a 'file' parameter
 			CStrW filename(child.GetAttributes().GetNamedItem(attr_file).FromUTF8());
 
 			CStr code;
 
 			// If there is a file, open it and use it as the code
 			if (!filename.empty())
 			{
 				Paths.insert(filename);
 				CVFSFile scriptfile;
 				if (scriptfile.Load(g_VFS, filename) != PSRETURN_OK)
 				{
 					LOGERROR("Error opening GUI script action file '%s'", utf8_from_wstring(filename));
 					throw PSERROR_GUI_JSOpenFailed();
 				}
 
 				code = scriptfile.DecodeUTF8(); // assume it's UTF-8
 			}
 
 			XMBElementList grandchildren = child.GetChildNodes();
 			if (!grandchildren.empty()) // The <action> element contains <keep> and <translate> tags.
 				for (XMBElement grandchild : grandchildren)
 				{
 					if (grandchild.GetNodeName() == elmt_translate)
 						code += g_L10n.Translate(grandchild.GetText());
 					else if (grandchild.GetNodeName() == elmt_keep)
 						code += grandchild.GetText();
 				}
 			else // It’s pure JavaScript code.
 				// Read the inline code (concatenating to the file code, if both are specified)
 				code += CStr(child.GetText());
 
 			CStr action = CStr(child.GetAttributes().GetNamedItem(attr_on));
 
 			// We need to set the GUI this object belongs to because RegisterScriptHandler requires an associated GUI.
 			object->SetGUI(this);
 			object->RegisterScriptHandler(action.LowerCase(), code, this);
 		}
 		else if (element_name == elmt_repeat)
 		{
 			Xeromyces_ReadRepeat(child, pFile, object, NameSubst, Paths, nesting_depth);
 		}
 		else if (element_name == elmt_translatableAttribute)
 		{
 			// This is an element in the form “<translatableAttribute id="attributeName">attributeValue</translatableAttribute>”.
 			CStr attributeName(child.GetAttributes().GetNamedItem(attr_id)); // Read the attribute name.
 			if (attributeName.empty())
 			{
 				LOGERROR("GUI: ‘translatableAttribute’ XML element with empty ‘id’ XML attribute found. (object: %s)", object->GetPresentableName().c_str());
 				continue;
 			}
 
 			CStr value(child.GetText());
 			if (value.empty())
 				continue;
 
 			CStr context(child.GetAttributes().GetNamedItem(attr_context)); // Read the context if any.
 			if (!context.empty())
 			{
 				CStr translatedValue(g_L10n.TranslateWithContext(context, value));
 				object->SetSetting(attributeName, translatedValue.FromUTF8(), true);
 			}
 			else
 			{
 				CStr translatedValue(g_L10n.Translate(value));
 				object->SetSetting(attributeName, translatedValue.FromUTF8(), true);
 			}
 		}
 		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->SetSetting(attributeName, translatedValue.FromUTF8(), true);
 		}
 		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());
 		}
 	}
 
 	if (!ManuallySetZ)
 	{
 		// Set it automatically to 10 plus its parents
 		bool absolute;
 		GUI<bool>::GetSetting(object, "absolute", absolute);
 
 		if (absolute)
 			// If the object is absolute, we'll have to get the parent's Z buffered,
 			// and add to that!
 			GUI<float>::SetSetting(object, "z", pParent->GetBufferedZ() + 10.f, true);
 		else
 			// If the object is relative, then we'll just store Z as "10"
 			GUI<float>::SetSetting(object, "z", 10.f, true);
 	}
 
 	try
 	{
 		if (pParent == m_BaseObject)
 			AddObject(object);
 		else
 			pParent->AddChild(object);
 	}
 	catch (PSERROR_GUI& e)
 	{
 		LOGERROR("GUI error: %s", e.what());
 	}
 }
 
 void CGUI::Xeromyces_ReadRepeat(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths, u32 nesting_depth)
 {
 	#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
 	#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
 	ELMT(object);
 	ATTR(count);
 	ATTR(var);
 
 	XMBAttributeList attributes = Element.GetAttributes();
 
 	int count = CStr(attributes.GetNamedItem(attr_count)).ToInt();
 	CStr var("["+attributes.GetNamedItem(attr_var)+"]");
 	if (var.size() < 3)
 		var = "[n]";
 
 	for (int n = 0; n < count; ++n)
 	{
 		NameSubst.emplace_back(var, "[" + CStr::FromInt(n) + "]");
 
 		XERO_ITER_EL(Element, child)
 		{
 			if (child.GetNodeName() == elmt_object)
 				Xeromyces_ReadObject(child, pFile, pParent, NameSubst, Paths, nesting_depth);
 		}
 		NameSubst.pop_back();
 	}
 }
 
 void CGUI::Xeromyces_ReadScript(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths)
 {
 	// Check for a 'file' parameter
 	CStrW file(Element.GetAttributes().GetNamedItem(pFile->GetAttributeID("file")).FromUTF8());
 
 	// If there is a file specified, open and execute it
 	if (!file.empty())
 	{
 		Paths.insert(file);
 		try
 		{
 			m_ScriptInterface->LoadGlobalScriptFile(file);
 		}
 		catch (PSERROR_Scripting& e)
 		{
 			LOGERROR("GUI: Error executing script %s: %s", utf8_from_wstring(file), e.what());
 		}
 	}
 
 	// If it has a directory attribute, read all JS files in that directory
 	CStrW directory(Element.GetAttributes().GetNamedItem(pFile->GetAttributeID("directory")).FromUTF8());
 	if (!directory.empty())
 	{
 		VfsPaths pathnames;
 		vfs::GetPathnames(g_VFS, directory, L"*.js", pathnames);
 		for (const VfsPath& path : pathnames)
 		{
 			// Only load new files (so when the insert succeeds)
 			if (Paths.insert(path).second)
 				try
 				{
 					m_ScriptInterface->LoadGlobalScriptFile(path);
 				}
 				catch (PSERROR_Scripting& e)
 				{
 					LOGERROR("GUI: Error executing script %s: %s", path.string8(), e.what());
 				}
 		}
 	}
 
 	// Execute inline scripts
 	try
 	{
 		CStr code(Element.GetText());
 		if (!code.empty())
 			m_ScriptInterface->LoadGlobalScript(L"Some XML file", code.FromUTF8());
 	}
 	catch (PSERROR_Scripting& e)
 	{
 		LOGERROR("GUI: Error executing inline script: %s", e.what());
 	}
 }
 
 void CGUI::Xeromyces_ReadSprite(XMBElement Element, CXeromyces* pFile)
 {
 	CGUISprite* Sprite = new CGUISprite;
 
 	// Get name, we know it exists because of DTD requirements
 	CStr name = Element.GetAttributes().GetNamedItem(pFile->GetAttributeID("name"));
 
 	if (m_Sprites.find(name) != m_Sprites.end())
 		LOGWARNING("GUI sprite name '%s' used more than once; first definition will be discarded", name.c_str());
 
 	SGUIImageEffects* effects = NULL;
 
 	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 = new 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 = new SGUIImageEffects(*effects); // do a copy just so it can be deleted correctly later
 
 	delete effects;
 
 	m_Sprites[name] = Sprite;
 }
 
 void CGUI::Xeromyces_ReadImage(XMBElement Element, CXeromyces* pFile, CGUISprite& parent)
 {
 	SGUIImage* Image = new SGUIImage;
 
 	Image->m_TextureSize = CClientArea(CRect(0, 0, 0, 0), CRect(0, 0, 100, 100));
 	Image->m_Size = CClientArea(CRect(0, 0, 0, 0), CRect(0, 0, 100, 100));
 
 	// 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")
 		{
 			CClientArea ca;
 			if (!GUI<CClientArea>::ParseString(attr_value, ca))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_Size = ca;
 		}
 		else if (attr_name == "texture_size")
 		{
 			CClientArea ca;
 			if (!GUI<CClientArea>::ParseString(attr_value, ca))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_TextureSize = ca;
 		}
 		else if (attr_name == "real_texture_placement")
 		{
 			CRect rect;
 			if (!GUI<CRect>::ParseString(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 (!GUI<CSize>::ParseString(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 (!GUI<float>::ParseString(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 (!GUI<bool>::ParseString(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 (!GUI<float>::ParseString(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")
 		{
 			CColor color;
 			if (!GUI<CColor>::ParseString(attr_value, color))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_BackColor = color;
 		}
 		else if (attr_name == "bordercolor")
 		{
 			CColor color;
 			if (!GUI<CColor>::ParseString(attr_value, color))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_BorderColor = color;
 		}
 		else if (attr_name == "border")
 		{
 			bool b;
 			if (!GUI<bool>::ParseString(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 = new 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));
 		CStrW attr_value(attr.Value.FromUTF8());
 
 		if (attr_name == "add_color")
 		{
 			CColor color;
 			if (!GUI<int>::ParseColor(attr_value, color, 0))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else effects.m_AddColor = color;
 		}
 		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[attr_name] = attr.Value.FromUTF8();
 	}
 
 	m_Styles[name] = 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 (!GUI<bool>::ParseString(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 (!GUI<float>::ParseString(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 (!GUI<float>::ParseString(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 (!GUI<float>::ParseString(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[name] = 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 (!GUI<CSize>::ParseString(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 (!GUI<int>::ParseString(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[name] = icon;
 }
 
 void CGUI::Xeromyces_ReadTooltip(XMBElement Element, CXeromyces* pFile)
 {
 	IGUIObject* object = new CTooltip;
 
 	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->SetSetting(attr_name, attr_value.FromUTF8());
 	}
 
 	AddObject(object);
 }
 
 void CGUI::Xeromyces_ReadColor(XMBElement Element, CXeromyces* pFile)
 {
 	XMBAttributeList attributes = Element.GetAttributes();
 
 	CColor color;
 	CStr name = attributes.GetNamedItem(pFile->GetAttributeID("name"));
 
 	// Try parsing value
 	CStr value(Element.GetText());
 	if (value.empty())
 		return;
 
 	// Try setting color to value
 	if (!color.ParseString(value))
 	{
 		LOGERROR("GUI: Unable to create custom color '%s'. Invalid color syntax.", name.c_str());
 		return;
 	}
 
 	m_PreDefinedColors[name] = color;
 }
Index: ps/trunk/source/gui/CGUI.h
===================================================================
--- ps/trunk/source/gui/CGUI.h	(revision 22133)
+++ ps/trunk/source/gui/CGUI.h	(revision 22134)
@@ -1,638 +1,639 @@
-/* Copyright (C) 2017 Wildfire Games.
+/* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /*
  * This is the top class of the whole GUI, all objects
  * and settings are stored within this class.
  */
 
 #ifndef INCLUDED_CGUI
 #define INCLUDED_CGUI
 
 #include "GUITooltip.h"
 #include "GUIbase.h"
 
 #include "lib/input.h"
 #include "ps/Shapes.h"
 #include "ps/XML/Xeromyces.h"
 #include "scriptinterface/ScriptInterface.h"
 
 #include <boost/unordered_set.hpp>
 
 ERROR_TYPE(GUI, JSOpenFailed);
 
 extern const double SELECT_DBLCLICK_RATE;
 
 /**
  * Contains a list of values for new defaults to objects.
  */
 struct SGUIStyle
 {
 	std::map<CStr, CStrW> m_SettingsDefaults;
 };
 
 class JSObject; // The GUI stores a JSObject*, so needs to know that JSObject exists
 class IGUIObject;
 class CGUISpriteInstance;
 struct SGUIText;
 struct CColor;
 struct SGUIText;
 struct SGUIIcon;
 class CGUIString;
 class CGUISprite;
 struct SGUIImageEffects;
 struct SGUIScrollBarStyle;
 class GUITooltip;
 
 /**
  * The main object that represents a whole GUI page.
  *
  * No interfacial functions throws.
  */
 class CGUI
 {
 	NONCOPYABLE(CGUI);
 
 	friend class IGUIObject;
-	friend class IGUIScrollBarOwner;
 	friend class CInternalCGUIAccessorBase;
 
 private:
 	// Private typedefs
 	typedef IGUIObject *(*ConstructObjectFunction)();
 
 public:
 	CGUI(const shared_ptr<ScriptRuntime>& runtime);
 	~CGUI();
 
 	/**
 	 * Initializes the GUI, needs to be called before the GUI is used
 	 */
 	void Initialize();
 
 	/**
 	 * Performs processing that should happen every frame
 	 * (including sending the "Tick" event to scripts)
 	 */
 	void TickObjects();
 
 	/**
 	 * Sends a specified script event to every object
 	 *
 	 * @param EventName String representation of event name
 	 */
 	void SendEventToAll(const CStr& EventName);
 
 	/**
 	 * Displays the whole GUI
 	 */
 	void Draw();
 
 	/**
 	 * Draw GUI Sprite
 	 *
 	 * @param Sprite Object referring to the sprite (which also caches
 	 *        calculations for faster rendering)
 	 * @param CellID Number of the icon cell to use. (Ignored if this sprite doesn't
 	 *        have any images with "cell-size")
 	 * @param Z Drawing order, depth value
 	 * @param Rect Position and Size
 	 * @param Clipping The sprite shouldn't be drawn outside this rectangle
 	 */
 	void DrawSprite(const CGUISpriteInstance& Sprite, int CellID, const float& Z, const CRect& Rect, const CRect& Clipping = CRect());
 
 	/**
 	 * Draw a SGUIText object
 	 *
 	 * @param Text Text object.
 	 * @param DefaultColor Color used if no tag applied.
 	 * @param pos position
 	 * @param z z value.
 	 * @param clipping
 	 */
 	void DrawText(SGUIText& Text, const CColor& DefaultColor, const CPos& pos, const float& z, const CRect& clipping);
 
 	/**
 	 * Clean up, call this to clean up all memory allocated
 	 * within the GUI.
 	 */
 	void Destroy();
 
 	/**
 	 * The replacement of Process(), handles an SDL_Event_
 	 *
 	 * @param ev SDL Event, like mouse/keyboard input
 	 */
 	InReaction HandleEvent(const SDL_Event_* ev);
 
 	/**
 	 * Load a GUI XML file into the GUI.
 	 *
 	 * <b>VERY IMPORTANT!</b> All \<styles\>-files must be read before
 	 * everything else!
 	 *
 	 * @param Filename Name of file
 	 * @param Paths Set of paths; all XML and JS files loaded will be added to this
 	 */
 	void LoadXmlFile(const VfsPath& Filename, boost::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Checks if object exists and return true or false accordingly
 	 *
 	 * @param Name String name of object
 	 * @return true if object exists
 	 */
 	bool ObjectExists(const CStr& Name) const;
 
 
 	/**
 	 * Returns the GUI object with the desired name, or NULL
 	 * if no match is found,
 	 *
 	 * @param Name String name of object
 	 * @return Matching object, or NULL
 	 */
 	IGUIObject* FindObjectByName(const CStr& Name) const;
 
 	/**
 	 * Returns the GUI object under the mouse, or NULL if none.
 	 */
 	IGUIObject* FindObjectUnderMouse() const;
 
+	const SGUIScrollBarStyle* GetScrollBarStyle(const CStr& style) const;
+
 	/**
 	 * The GUI needs to have all object types inputted and
 	 * their constructors. Also it needs to associate a type
 	 * by a string name of the type.
 	 *
 	 * To add a type:
 	 * @code
 	 * AddObjectType("button", &CButton::ConstructObject);
 	 * @endcode
 	 *
 	 * @param str Reference name of object type
 	 * @param pFunc Pointer of function ConstuctObject() in the object
 	 *
 	 * @see CGUI#ConstructObject()
 	 */
 	void AddObjectType(const CStr& str, ConstructObjectFunction pFunc) { m_ObjectTypes[str] = pFunc; }
 
 	/**
 	 * Update Resolution, should be called every time the resolution
 	 * of the OpenGL screen has been changed, this is because it needs
 	 * to re-cache all its actual sizes
 	 *
 	 * Needs no input since screen resolution is global.
 	 *
 	 * @see IGUIObject#UpdateCachedSize()
 	 */
 	void UpdateResolution();
 
 	/**
 	 * Generate a SGUIText object from the inputted string.
 	 * The function will break down the string and its
 	 * tags to calculate exactly which rendering queries
 	 * will be sent to the Renderer. Also, horizontal alignment
 	 * is taken into acount in this method but NOT vertical alignment.
 	 *
 	 * Done through the CGUI since it can communicate with
 	 *
 	 * @param Text Text to generate SGUIText object from
 	 * @param Font Default font, notice both Default color and default font
 	 *		  can be changed by tags.
 	 * @param Width Width, 0 if no word-wrapping.
 	 * @param BufferZone space between text and edge, and space between text and images.
 	 * @param pObject Optional parameter for error output. Used *only* if error parsing fails,
 	 *		  and we need to be able to output which object the error occurred in to aid the user.
 	 */
 	SGUIText GenerateText(const CGUIString& Text, const CStrW& Font, const float& Width, const float& BufferZone, const IGUIObject* pObject = NULL);
 
 
 	/**
 	 * Check if an icon exists
 	 */
 	bool IconExists(const CStr& str) const { return (m_Icons.count(str) != 0); }
 
 	/**
 	 * Get Icon (a copy, can never be changed)
 	 */
 	SGUIIcon GetIcon(const CStr& str) const { return m_Icons.find(str)->second; }
 
 	/**
 	 * Get pre-defined color (if it exists)
 	 * Returns false if it fails.
 	 */
 	bool GetPreDefinedColor(const CStr& name, CColor& Output) const;
 
 	shared_ptr<ScriptInterface> GetScriptInterface() { return m_ScriptInterface; };
 	JS::Value GetGlobalObject() { return m_ScriptInterface->GetGlobalObject(); };
 
 private:
 
 	/**
 	 * Updates the object pointers, needs to be called each
 	 * time an object has been added or removed.
 	 *
 	 * This function is atomic, meaning if it throws anything, it will
 	 * have seen it through that nothing was ultimately changed.
 	 *
 	 * @throws PSERROR_GUI that is thrown from IGUIObject::AddToPointersMap().
 	 */
 	void UpdateObjects();
 
 	/**
 	 * Adds an object to the GUI's object database
 	 * Private, since you can only add objects through
 	 * XML files. Why? Because it enables the GUI to
 	 * be much more encapsulated and safe.
 	 *
 	 * @throws	Rethrows PSERROR_GUI from IGUIObject::AddChild().
 	 */
 	void AddObject(IGUIObject* pObject);
 
 	/**
 	 * You input the name of the object type, and let's
 	 * say you input "button", then it will construct a
 	 * CGUIObjet* as a CButton.
 	 *
 	 * @param str Name of object type
 	 * @return Newly constructed IGUIObject (but constructed as a subclass)
 	 */
 	IGUIObject* ConstructObject(const CStr& str);
 
 	/**
 	 * Get Focused Object.
 	 */
 	IGUIObject* GetFocusedObject() { return m_FocusedObject; }
 
 public:
 	/**
 	 * Change focus to new object.
 	 * Will send LOST_FOCUS/GOT_FOCUS messages as appropriate.
 	 * pObject can be NULL to remove all focus.
 	 */
 	void SetFocusedObject(IGUIObject* pObject);
 
 private:
 	//--------------------------------------------------------
 	/** @name XML Reading Xeromyces specific subroutines
 	 *
 	 * These does not throw!
 	 * Because when reading in XML files, it won't be fatal
 	 * if an error occurs, perhaps one particular object
 	 * fails, but it'll still continue reading in the next.
 	 * All Error are reported with ReportParseError
 	 */
 	//--------------------------------------------------------
 
 	/*
 		Xeromyces_* functions tree
 		<objects> (ReadRootObjects)
 		 |
 		 +-<script> (ReadScript)
 		 |
 		 +-<object> (ReadObject)
 			|
 			+-<action>
 			|
 			+-Optional Type Extensions (IGUIObject::ReadExtendedElement) TODO
 			|
 			+-<<object>> *recursive*
 
 
 		<styles> (ReadRootStyles)
 		 |
 		 +-<style> (ReadStyle)
 
 
 		<sprites> (ReadRootSprites)
 		 |
 		 +-<sprite> (ReadSprite)
 			|
 			+-<image> (ReadImage)
 
 
 		<setup> (ReadRootSetup)
 		 |
 		 +-<tooltip> (ReadToolTip)
 		 |
 		 +-<scrollbar> (ReadScrollBar)
 		 |
 		 +-<icon> (ReadIcon)
 		 |
 		 +-<color> (ReadColor)
 	*/
 	//@{
 
 	// Read Roots
 
 	/**
 	 * Reads in the root element \<objects\> (the DOMElement).
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the objects-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param Paths		Collects the set of all XML/JS files that are loaded
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadRootObjects(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Reads in the root element \<sprites\> (the DOMElement).
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the sprites-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadRootSprites(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the root element \<styles\> (the DOMElement).
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the styles-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadRootStyles(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the root element \<setup\> (the DOMElement).
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the setup-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadRootSetup(XMBElement Element, CXeromyces* pFile);
 
 	// Read Subs
 
 	/**
 	 * Notice! Recursive function!
 	 *
 	 * Read in an \<object\> (the XMBElement) and stores it
 	 * as a child in the pParent.
 	 *
 	 * It will also check the object's children and call this function
 	 * on them too. Also it will call all other functions that reads
 	 * in other stuff that can be found within an object. Check the
 	 * tree in the beginning of this class' Xeromyces_* section.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the object-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param pParent	Parent to add this object as child in.
 	 * @param NameSubst	A set of substitution strings that will be
 	 * 					applied to all object names within this object.
 	 * @param Paths		Output set of file paths that this GUI object
 	 * 					relies on.
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadObject(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths, u32 nesting_depth);
 
 	/**
 	 * Reads in the element \<repeat\>, which repeats its child \<object\>s
 	 * 'count' times, replacing the string "[n]" (or the value of the attribute
 	 * 'var' enclosed in square brackets) in its descendants' names with "[0]",
 	 * "[1]", etc.
 	 */
 	void Xeromyces_ReadRepeat(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths, u32 nesting_depth);
 
 	/**
 	 * Reads in the element \<script\> (the XMBElement) and executes
 	 * the script's code.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the script-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param Paths		Output set of file paths that this script is loaded from.
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadScript(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Reads in the element \<sprite\> (the XMBElement) and stores the
 	 * result in a new CGUISprite.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the sprite-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadSprite(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<image\> (the XMBElement) and stores the
 	 * result within the CGUISprite.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the image-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param parent	Parent sprite.
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadImage(XMBElement Element, CXeromyces* pFile, CGUISprite& parent);
 
 	/**
 	 * Reads in the element \<effect\> (the XMBElement) and stores the
 	 * result within the SGUIImageEffects.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the image-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param effects	Effects object to add this effect to.
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadEffects(XMBElement Element, CXeromyces* pFile, SGUIImageEffects& effects);
 
 	/**
 	 * Reads in the element \<style\> (the XMBElement) and stores the
 	 * result in m_Styles.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the style-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadStyle(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<scrollbar\> (the XMBElement) and stores the
 	 * result in m_ScrollBarStyles.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the scrollbar-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadScrollBarStyle(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<icon\> (the XMBElement) and stores the
 	 * result in m_Icons.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the scrollbar-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadIcon(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<tooltip\> (the XMBElement) and stores the
 	 * result as an object with the name __tooltip_#.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the scrollbar-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadTooltip(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<color\> (the XMBElement) and stores the
 	 * result in m_PreDefinedColors
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the scrollbar-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadColor(XMBElement Element, CXeromyces* pFile);
 
 	//@}
 
 private:
 
 	// Variables
 
 	//--------------------------------------------------------
 	/** @name Miscellaneous */
 	//--------------------------------------------------------
 	//@{
 
 	shared_ptr<ScriptInterface> m_ScriptInterface;
 
 	/**
 	 * don't want to pass this around with the
 	 * ChooseMouseOverAndClosest broadcast -
 	 * we'd need to pack this and pNearest in a struct
 	 */
 	CPos m_MousePos;
 
 	/**
 	 * Indicates which buttons are pressed (bit 0 = LMB,
 	 * bit 1 = RMB, bit 2 = MMB)
 	 */
 	unsigned int m_MouseButtons;
 
 	// Tooltip
 	GUITooltip m_Tooltip;
 
 	/**
 	 * This is a bank of custom colors, it is simply a look up table that
 	 * will return a color object when someone inputs the name of that
 	 * color. Of course the colors have to be declared in XML, there are
 	 * no hard-coded values.
 	 */
 	std::map<CStr, CColor>	m_PreDefinedColors;
 
 	//@}
 	//--------------------------------------------------------
 	/** @name Objects */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Base Object, all its children are considered parentless
 	 * because this is not a real object per se.
 	 */
 	IGUIObject* m_BaseObject;
 
 	/**
 	 * Focused object!
 	 * Say an input box that is selected. That one is focused.
 	 * There can only be one focused object.
 	 */
 	IGUIObject* m_FocusedObject;
 
 	/**
 	 * Just pointers for fast name access, each object
 	 * is really constructed within its parent for easy
 	 * recursive management.
 	 * Notice m_BaseObject won't belong here since it's
 	 * not considered a real object.
 	 */
 	map_pObjects m_pAllObjects;
 
 	/**
 	 * Number of object that has been given name automatically.
 	 * the name given will be '__internal(#)', the number (#)
 	 * being this variable. When an object's name has been set
 	 * as followed, the value will increment.
 	 */
 	int m_InternalNameNumber;
 
 	/**
 	 * Function pointers to functions that constructs
 	 * IGUIObjects by name... For instance m_ObjectTypes["button"]
 	 * is filled with a function that will "return new CButton();"
 	 */
 	std::map<CStr, ConstructObjectFunction>	m_ObjectTypes;
 
 	/**
 	 * Map from hotkey names to objects that listen to the hotkey.
 	 * (This is an optimisation to avoid recursing over the whole GUI
 	 * tree every time a hotkey is pressed).
 	 * Currently this is only set at load time - dynamic changes to an
 	 * object's hotkey property will be ignored.
 	 */
 	std::map<CStr, std::vector<IGUIObject*> > m_HotkeyObjects;
 
 	//--------------------------------------------------------
 	//	Databases
 	//--------------------------------------------------------
 
 	// Sprites
 	std::map<CStr, CGUISprite*> m_Sprites;
 
 	// Styles
 	std::map<CStr, SGUIStyle> m_Styles;
 
 	// Scroll-bar styles
 	std::map<CStr, SGUIScrollBarStyle> m_ScrollBarStyles;
 
 	// Icons
 	std::map<CStr, SGUIIcon> m_Icons;
 };
 
 #endif // INCLUDED_CGUI
Index: ps/trunk/source/gui/IGUIObject.h
===================================================================
--- ps/trunk/source/gui/IGUIObject.h	(revision 22133)
+++ ps/trunk/source/gui/IGUIObject.h	(revision 22134)
@@ -1,529 +1,530 @@
-/* Copyright (C) 2017 Wildfire Games.
+/* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /*
  * The base class of an object.
  * All objects are derived from this class.
  * It's an abstract data type, so it can't be used per se.
  * Also contains a Dummy object which is used for completely blank objects.
  */
 
 #ifndef INCLUDED_IGUIOBJECT
 #define INCLUDED_IGUIOBJECT
 
 #include "GUIbase.h"
 #include "GUItext.h"
 
 #include "gui/scripting/JSInterface_IGUIObject.h"
 #include "lib/input.h" // just for IN_PASS
 #include "ps/XML/Xeromyces.h"
 
 #include <string>
 #include <vector>
 
 struct SGUISetting;
 struct SGUIStyle;
 class CGUI;
 
 class JSObject;
 
 ERROR_TYPE(GUI, UnableToParse);
 
 /**
  * Setting Type
  * @see SGUISetting
  *
  * For use of later macros, all names should be GUIST_ followed
  * by the code name (case sensitive!).
  */
 #define TYPE(T) GUIST_##T,
 enum EGUISettingType
 {
 	#include "GUItypes.h"
 };
 #undef TYPE
 
 /**
  * A GUI Setting is anything that can be inputted from XML as
  * \<object\>-attributes (with exceptions). For instance:
  * \<object style="null"\>
  *
  * "style" will be a SGUISetting.
  */
 struct SGUISetting
 {
 	SGUISetting() : m_pSetting(NULL) {}
 
 	void				*m_pSetting;
 	EGUISettingType		m_Type;
 };
 
 /**
  * GUI object such as a button or an input-box.
  * Abstract data type !
  */
 class IGUIObject
 {
 	friend class CGUI;
 	friend class CInternalCGUIAccessorBase;
 	friend class IGUIScrollBar;
 	friend class GUITooltip;
 
 	// Allow getProperty to access things like GetParent()
 	friend bool JSI_IGUIObject::getProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::MutableHandleValue vp);
 	friend bool JSI_IGUIObject::setProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id, bool UNUSED(strict), JS::MutableHandleValue vp);
 	friend bool JSI_IGUIObject::getComputedSize(JSContext* cx, uint argc, JS::Value* vp);
+	friend bool JSI_IGUIObject::getTextSize(JSContext* cx, uint argc, JS::Value* vp);
 
 public:
 	IGUIObject();
 	virtual ~IGUIObject();
 
 	/**
 	 * Checks if mouse is hovering this object.
      * The mouse position is cached in CGUI.
 	 *
 	 * This function checks if the mouse is hovering the
 	 * rectangle that the base setting "size" makes.
 	 * Although it is virtual, so one could derive
 	 * an object from CButton, which changes only this
 	 * to checking the circle that "size" makes.
 	 *
 	 * @return true if mouse is hovering
 	 */
 	virtual bool MouseOver();
 
 	/**
 	 * Test if mouse position is over an icon
 	 */
 	virtual bool MouseOverIcon();
 
 	//--------------------------------------------------------
 	/** @name Leaf Functions */
 	//--------------------------------------------------------
 	//@{
 
 	/// Get object name, name is unique
 	const CStr& GetName() const { return m_Name; }
 
 	/// Get object name
 	void SetName(const CStr& Name) { m_Name = Name; }
 
 	// Get Presentable name.
 	//  Will change all internally set names to something like "<unnamed object>"
 	CStr GetPresentableName() const;
 
 	/**
 	 * Adds object and its children to the map, it's name being the
 	 * first part, and the second being itself.
 	 *
 	 * @param ObjectMap Adds this to the map_pObjects.
 	 *
 	 * @throws PSERROR_GUI_ObjectNeedsName Name is missing
 	 * @throws PSERROR_GUI_NameAmbiguity Name is already taken
 	 */
 	void AddToPointersMap(map_pObjects& ObjectMap);
 
 	/**
 	 * Notice nothing will be returned or thrown if the child hasn't
 	 * been inputted into the GUI yet. This is because that's were
 	 * all is checked. Now we're just linking two objects, but
 	 * it's when we're inputting them into the GUI we'll check
 	 * validity! Notice also when adding it to the GUI this function
 	 * will inevitably have been called by CGUI::AddObject which
 	 * will catch the throw and return the error code.
 	 * i.e. The user will never put in the situation wherein a throw
 	 * must be caught, the GUI's internal error handling will be
 	 * completely transparent to the interfacially sequential model.
 	 *
 	 * @param pChild Child to add
 	 *
 	 * @throws PSERROR_GUI from CGUI::UpdateObjects().
 	 */
 	void AddChild(IGUIObject* pChild);
 
 	//@}
 	//--------------------------------------------------------
 	/** @name Iterate
 	 * Used to iterate over all children of this object.
 	 */
 	//--------------------------------------------------------
 	//@{
 
 	vector_pObjects::iterator begin() { return m_Children.begin(); }
 	vector_pObjects::iterator end() { return m_Children.end(); }
 
 	//@}
 	//--------------------------------------------------------
 	/** @name Settings Management */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Checks if settings exists, only available for derived
 	 * classes that has this set up, that's why the base
 	 * class just returns false
 	 *
 	 * @param Setting setting name
 	 * @return True if settings exist.
 	 */
 	bool SettingExists(const CStr& Setting) const;
 
 	/**
 	 * All sizes are relative to resolution, and the calculation
 	 * is not wanted in real time, therefore it is cached, update
 	 * the cached size with this function.
 	 */
 	virtual void UpdateCachedSize();
 
 	/**
 	 * Set a setting by string, regardless of what type it is.
 	 *
 	 * example a CRect(10,10,20,20) would be "10 10 20 20"
 	 *
 	 * @param Setting Setting by name
 	 * @param Value Value to set to
 	 * @param SkipMessage Does not send a GUIM_SETTINGS_UPDATED if true
 	 *
 	 * @return PSRETURN (PSRETURN_OK if successful)
 	 */
 	PSRETURN SetSetting(const CStr& Setting, const CStrW& Value, const bool& SkipMessage = false);
 
 	/**
 	 * Retrieves the type of a named setting.
 	 *
 	 * @param Setting Setting by name
 	 * @param Type Stores an EGUISettingType
 	 * @return PSRETURN (PSRETURN_OK if successful)
 	 */
 	PSRETURN GetSettingType(const CStr& Setting, EGUISettingType& Type) const;
 
 	/**
 	 * Set the script handler for a particular object-specific action
 	 *
 	 * @param Action Name of action
 	 * @param Code Javascript code to execute when the action occurs
 	 * @param pGUI GUI instance to associate the script with
 	 */
 	void RegisterScriptHandler(const CStr& Action, const CStr& Code, CGUI* pGUI);
 
 	/**
 	 * Retrieves the JSObject representing this GUI object.
 	 */
 	JSObject* GetJSObject();
 
 	//@}
 protected:
 	//--------------------------------------------------------
 	/** @name Called by CGUI and friends
 	 *
 	 * Methods that the CGUI will call using
 	 * its friendship, these should not
 	 * be called by user.
 	 * These functions' security are a lot
 	 * what constitutes the GUI's
 	 */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Add a setting to m_Settings
 	 *
 	 * @param Type Setting type
 	 * @param Name Setting reference name
 	 */
 	void AddSetting(const EGUISettingType& Type, const CStr& Name);
 
 	/**
 	 * Calls Destroy on all children, and deallocates all memory.
 	 * MEGA TODO Should it destroy it's children?
 	 */
 	virtual void Destroy();
 
 public:
 	/**
      * This function is called with different messages
 	 * for instance when the mouse enters the object.
 	 *
 	 * @param Message GUI Message
 	 */
 	virtual void HandleMessage(SGUIMessage& UNUSED(Message)) {}
 
 protected:
 	/**
 	 * Draws the object.
 	 *
 	 * @throws	PSERROR if any. But this will mostlikely be
 	 *			very rare since if an object is drawn unsuccessfully
 	 *			it'll probably only output in the Error log, and not
 	 *			disrupt the whole GUI drawing.
 	 */
 	virtual void Draw() = 0;
 
 	/**
 	 * Some objects need to handle the SDL_Event_ manually.
 	 * For instance the input box.
 	 *
 	 * Only the object with focus will have this function called.
 	 *
 	 * Returns either IN_PASS or IN_HANDLED. If IN_HANDLED, then
 	 * the key won't be passed on and processed by other handlers.
 	 * This is used for keys that the GUI uses.
 	 */
 	virtual InReaction ManuallyHandleEvent(const SDL_Event_* UNUSED(ev)) { return IN_PASS; }
 
 	/**
 	 * Loads a style.
 	 *
 	 * @param GUIinstance Reference to the GUI
 	 * @param StyleName Style by name
 	 */
 	void LoadStyle(CGUI& GUIinstance, const CStr& StyleName);
 
 	/**
 	 * Loads a style.
 	 *
 	 * @param Style The style object.
 	 */
 	void LoadStyle(const SGUIStyle& Style);
 
 	/**
 	 * Returns not the Z value, but the actual buffered Z value, i.e. if it's
 	 * defined relative, then it will check its parent's Z value and add
 	 * the relativity.
 	 *
 	 * @return Actual Z value on the screen.
 	 */
 	virtual float GetBufferedZ() const;
 
 	void SetGUI(CGUI* const& pGUI);
 
 	/**
 	 * Set parent of this object
 	 */
 	void SetParent(IGUIObject* pParent) { m_pParent = pParent; }
 
 	/**
 	 * Reset internal state of this object
 	 */
 	virtual void ResetStates()
 	{
 		// Notify the gui that we aren't hovered anymore
 		UpdateMouseOver(NULL);
 	}
 
 public:
 	CGUI* GetGUI() { return m_pGUI; }
 	const CGUI* GetGUI() const { return m_pGUI; }
 
 	/**
 	 * Take focus!
 	 */
 	void SetFocus();
 
 protected:
 	/**
 	 * Check if object is focused.
 	 */
 	bool IsFocused() const;
 
 	/**
 	 * <b>NOTE!</b> This will not just return m_pParent, when that is
 	 * need use it! There is one exception to it, when the parent is
 	 * the top-node (the object that isn't a real object), this
 	 * will return NULL, so that the top-node's children are
 	 * seemingly parentless.
 	 *
 	 * @return Pointer to parent
 	 */
 	IGUIObject* GetParent() const;
 
 	/**
 	 * Get Mouse from CGUI.
 	 */
 	CPos GetMousePos() const;
 
 	/**
 	 * Handle additional children to the \<object\>-tag. In IGUIObject, this function does
 	 * nothing. In CList and CDropDown, it handles the \<item\>, used to build the data.
 	 *
 	 * Returning false means the object doesn't recognize the child. Should be reported.
 	 * Notice 'false' is default, because an object not using this function, should not
 	 * have any additional children (and this function should never be called).
 	 */
 	virtual bool HandleAdditionalChildren(const XMBElement& UNUSED(child), CXeromyces* UNUSED(pFile))
 	{
 		return false;
 	}
 
 	/**
 	 * Cached size, real size m_Size is actually dependent on resolution
 	 * and can have different *real* outcomes, this is the real outcome
 	 * cached to avoid slow calculations in real time.
 	 */
 	CRect m_CachedActualSize;
 
 	/**
 	 * Send event to this GUI object (HandleMessage and ScriptEvent)
 	 *
 	 * @param type Type of GUI message to be handled
 	 * @param EventName String representation of event name
 	 * @return IN_HANDLED if event was handled, or IN_PASS if skipped
 	 */
 	InReaction SendEvent(EGUIMessageType type, const CStr& EventName);
 
 	/**
 	 * Execute the script for a particular action.
 	 * Does nothing if no script has been registered for that action.
 	 * The mouse coordinates will be passed as the first argument.
 	 *
 	 * @param Action Name of action
 	 */
 	void ScriptEvent(const CStr& Action);
 
 	/**
 	 * Execute the script for a particular action.
 	 * Does nothing if no script has been registered for that action.
 	 *
 	 * @param Action Name of action
 	 * @param Argument Argument to pass to action
 	 */
 	void ScriptEvent(const CStr& Action, JS::HandleValue Argument);
 
 	void SetScriptHandler(const CStr& Action, JS::HandleObject Function);
 
 	/**
 	 * Inputes the object that is currently hovered, this function
 	 * updates this object accordingly (i.e. if it's the object
 	 * being inputted one thing happens, and not, another).
 	 *
 	 * @param pMouseOver	Object that is currently hovered,
 	 *						can OF COURSE be NULL too!
 	 */
 	void UpdateMouseOver(IGUIObject* const& pMouseOver);
 
 	//@}
 private:
 	//--------------------------------------------------------
 	/** @name Internal functions */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Inputs a reference pointer, checks if the new inputted object
 	 * if hovered, if so, then check if this's Z value is greater
 	 * than the inputted object... If so then the object is closer
 	 * and we'll replace the pointer with this.
 	 * Also Notice input can be NULL, which means the Z value demand
 	 *  is out. NOTICE you can't input NULL as const so you'll have
 	 * to set an object to NULL.
 	 *
 	 * @param pObject	Object pointer, can be either the old one, or
 	 *					the new one.
 	 */
 	void ChooseMouseOverAndClosest(IGUIObject*& pObject);
 
 	// Is the object a Root object, in philosophy, this means it
 	//  has got no parent, and technically, it's got the m_BaseObject
 	//  as parent.
 	bool IsRootObject() const;
 
 	/**
 	 * Logs an invalid setting search and returns the correct return result
 	 *
 	 * @return the error result
 	 */
 	PSRETURN LogInvalidSettings(const CStr8& Setting) const;
 
 	static void Trace(JSTracer* trc, void* data)
 	{
 		reinterpret_cast<IGUIObject*>(data)->TraceMember(trc);
 	}
 
 	void TraceMember(JSTracer* trc);
 
 	// Variables
 
 protected:
 	// Name of object
 	CStr									m_Name;
 
 	// Constructed on the heap, will be destroyed along with the the object
 	// TODO Gee: really the above?
 	vector_pObjects							m_Children;
 
 	// Pointer to parent
 	IGUIObject								*m_pParent;
 
 	//This represents the last click time for each mouse button
 	double m_LastClickTime[6];
 
 	/**
 	 * This is an array of true or false, each element is associated with
 	 * a string representing a setting. Number of elements is equal to
 	 * number of settings.
 	 *
 	 * A true means the setting has been manually set in the file when
 	 * read. This is important to know because I don't want to force
 	 * the user to include its \<styles\>-XML-files first, so somehow
 	 * the GUI needs to know which settings were set, and which is meant
 	 * to.
 	 */
 
 	// More variables
 
 	// Is mouse hovering the object? used with the function MouseOver()
 	bool									m_MouseHovering;
 
 	/**
 	 * Settings pool, all an object's settings are located here
 	 * If a derived object has got more settings that the base
 	 * settings, it's because they have a new version of the
 	 * function SetupSettings().
 	 *
 	 * @see SetupSettings()
 	 */
 	public:
 	std::map<CStr, SGUISetting>				m_Settings;
 
 private:
 	// An object can't function stand alone
 	CGUI									*m_pGUI;
 
 	// Internal storage for registered script handlers.
 	std::map<CStr, JS::Heap<JSObject*> >	m_ScriptHandlers;
 
 	// Cached JSObject representing this GUI object
 	JS::PersistentRootedObject				m_JSObject;
 };
 
 
 /**
  * Dummy object used primarily for the root object
  * or objects of type 'empty'
  */
 class CGUIDummyObject : public IGUIObject
 {
 	GUI_OBJECT(CGUIDummyObject)
 
 public:
 
 	virtual void Draw() {}
 	// Empty can never be hovered. It is only a category.
 	virtual bool MouseOver() { return false; }
 };
 
 #endif // INCLUDED_IGUIOBJECT
Index: ps/trunk/source/gui/IGUIScrollBarOwner.cpp
===================================================================
--- ps/trunk/source/gui/IGUIScrollBarOwner.cpp	(revision 22133)
+++ ps/trunk/source/gui/IGUIScrollBarOwner.cpp	(revision 22134)
@@ -1,80 +1,70 @@
-/* Copyright (C) 2015 Wildfire Games.
+/* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "GUI.h"
 
 IGUIScrollBarOwner::IGUIScrollBarOwner()
 {
 }
 
 IGUIScrollBarOwner::~IGUIScrollBarOwner()
 {
 	for (IGUIScrollBar* const& sb : m_ScrollBars)
 		delete sb;
 }
 
 void IGUIScrollBarOwner::ResetStates()
 {
 	IGUIObject::ResetStates();
 
 	for (IGUIScrollBar* const& sb : m_ScrollBars)
 		sb->SetBarPressed(false);
 }
 
 void IGUIScrollBarOwner::AddScrollBar(IGUIScrollBar* scrollbar)
 {
 	scrollbar->SetHostObject(this);
 	scrollbar->SetGUI(GetGUI());
 	m_ScrollBars.push_back(scrollbar);
 }
 
 const SGUIScrollBarStyle* IGUIScrollBarOwner::GetScrollBarStyle(const CStr& style) const
 {
 	if (!GetGUI())
-	{
-		// TODO Gee: Output in log
 		return NULL;
-	}
 
-	std::map<CStr, SGUIScrollBarStyle>::const_iterator it = GetGUI()->m_ScrollBarStyles.find(style);
-	if (it == GetGUI()->m_ScrollBarStyles.end())
-	{
-		// TODO Gee: Output in log
-		return NULL;
-	}
-
- 	return &it->second;
+	return GetGUI()->GetScrollBarStyle(style);
 }
 
 void IGUIScrollBarOwner::HandleMessage(SGUIMessage& msg)
 {
 	for (IGUIScrollBar* const& sb : m_ScrollBars)
 		sb->HandleMessage(msg);
 }
 
 void IGUIScrollBarOwner::Draw()
 {
 	for (IGUIScrollBar* const& sb : m_ScrollBars)
 		sb->Draw();
 }
 
 float IGUIScrollBarOwner::GetScrollBarPos(const int index) const
 {
 	return m_ScrollBars[index]->GetPos();
 }
Index: ps/trunk/source/gui/scripting/JSInterface_IGUIObject.cpp
===================================================================
--- ps/trunk/source/gui/scripting/JSInterface_IGUIObject.cpp	(revision 22133)
+++ ps/trunk/source/gui/scripting/JSInterface_IGUIObject.cpp	(revision 22134)
@@ -1,719 +1,792 @@
 /* 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 "JSInterface_IGUIObject.h"
 #include "JSInterface_GUITypes.h"
 
 #include "gui/IGUIObject.h"
 #include "gui/CGUI.h"
 #include "gui/IGUIScrollBar.h"
 #include "gui/CList.h"
 #include "gui/GUIManager.h"
 
 #include "ps/CLogger.h"
 
 #include "scriptinterface/ScriptInterface.h"
 #include "scriptinterface/ScriptExtraHeaders.h"
 
 JSClass JSI_IGUIObject::JSI_class = {
 	"GUIObject", JSCLASS_HAS_PRIVATE,
 	nullptr, nullptr,
 	JSI_IGUIObject::getProperty, JSI_IGUIObject::setProperty,
 	nullptr, nullptr, nullptr, nullptr,
 	nullptr, nullptr, JSI_IGUIObject::construct, nullptr
 };
 
 JSFunctionSpec JSI_IGUIObject::JSI_methods[] =
 {
 	JS_FN("toString", JSI_IGUIObject::toString, 0, 0),
 	JS_FN("focus", JSI_IGUIObject::focus, 0, 0),
 	JS_FN("blur", JSI_IGUIObject::blur, 0, 0),
 	JS_FN("getComputedSize", JSI_IGUIObject::getComputedSize, 0, 0),
+	JS_FN("getTextSize", JSI_IGUIObject::getTextSize, 0, 0),
 	JS_FS_END
 };
 
 bool JSI_IGUIObject::getProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::MutableHandleValue vp)
 {
 	JSAutoRequest rq(cx);
 	ScriptInterface* pScriptInterface = ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface;
 
 	IGUIObject* e = (IGUIObject*)JS_GetInstancePrivate(cx, obj, &JSI_IGUIObject::JSI_class, NULL);
 	if (!e)
 		return false;
 
 	JS::RootedValue idval(cx);
 	if (!JS_IdToValue(cx, id, &idval))
 		return false;
 
 	std::string propName;
 	if (!ScriptInterface::FromJSVal(cx, idval, propName))
 		return false;
 
 	// Skip some things which are known to be functions rather than properties.
 	// ("constructor" *must* be here, else it'll try to GetSettingType before
 	// the private IGUIObject* has been set (and thus crash). The others are
 	// partly for efficiency, and also to allow correct reporting of attempts to
 	// access nonexistent properties.)
 	if (propName == "constructor" ||
 		propName == "prototype"   ||
 		propName == "toString"    ||
 		propName == "toJSON"      ||
 		propName == "focus"       ||
 		propName == "blur"        ||
+		propName == "getTextSize" ||
 		propName == "getComputedSize"
 	   )
 		return true;
 
 	// Use onWhatever to access event handlers
 	if (propName.substr(0, 2) == "on")
 	{
 		CStr eventName(CStr(propName.substr(2)).LowerCase());
 		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")
 	{
 		JS::RootedObject obj(cx, JS_NewArrayObject(cx, JS::HandleValueArray::empty()));
 		vp.setObject(*obj);
 
 		for (size_t i = 0; i < e->m_Children.size(); ++i)
 		{
 			JS::RootedValue val(cx);
 			ScriptInterface::ToJSVal(cx, &val, e->m_Children[i]);
 			JS_SetElement(cx, obj, i, val);
 		}
 
 		return true;
 	}
 	else if (propName == "name")
 	{
 		vp.set(JS::StringValue(JS_NewStringCopyZ(cx, e->GetName().c_str())));
 		return true;
 	}
 	else
 	{
 		// Retrieve the setting's type (and make sure it actually exists)
 		EGUISettingType Type;
 		if (e->GetSettingType(propName, Type) != PSRETURN_OK)
 		{
 			JS_ReportError(cx, "Invalid GUIObject property '%s'", propName.c_str());
 			return false;
 		}
 
 		// (All the cases are in {...} to avoid scoping problems)
 		switch (Type)
 		{
 		case GUIST_bool:
 		{
 			bool value;
 			GUI<bool>::GetSetting(e, propName, value);
 			vp.set(JS::BooleanValue(value));
 			break;
 		}
 
 		case GUIST_int:
 		{
 			int value;
 			GUI<int>::GetSetting(e, propName, value);
 			vp.set(JS::Int32Value(value));
 			break;
 		}
 
 		case GUIST_uint:
 		{
 			u32 value;
 			GUI<u32>::GetSetting(e, propName, value);
 			if (value >= std::numeric_limits<u32>::max())
 				LOGERROR("Integer overflow on converting to GUIST_uint");
 			else
 				vp.set(JS::Int32Value(value));
 			break;
 		}
 
 		case GUIST_float:
 		{
 			float value;
 			GUI<float>::GetSetting(e, propName, value);
 			// Create a garbage-collectable double
 			vp.set(JS::NumberValue(value));
 			return !vp.isNull();
 		}
 
 		case GUIST_CColor:
 		{
 			CColor color;
 			GUI<CColor>::GetSetting(e, propName, color);
 			JS::RootedObject obj(cx, pScriptInterface->CreateCustomObject("GUIColor"));
 			vp.setObject(*obj);
 			JS::RootedValue c(cx);
 			// Attempt to minimise ugliness through macrosity
 #define P(x) \
 	c = JS::NumberValue(color.x); \
 	if (c.isNull()) \
 		return false; \
 	JS_SetProperty(cx, obj, #x, c)
 
 			P(r);
 			P(g);
 			P(b);
 			P(a);
 #undef P
 			break;
 		}
 
 		case GUIST_CClientArea:
 		{
 			CClientArea area;
 			GUI<CClientArea>::GetSetting(e, propName, area);
 
 			JS::RootedObject obj(cx, pScriptInterface->CreateCustomObject("GUISize"));
 			vp.setObject(*obj);
 			try
 			{
 #define P(x, y, z) pScriptInterface->SetProperty(vp, #z, area.x.y, false, true)
 				P(pixel,	left,	left);
 				P(pixel,	top,	top);
 				P(pixel,	right,	right);
 				P(pixel,	bottom,	bottom);
 				P(percent,	left,	rleft);
 				P(percent,	top,	rtop);
 				P(percent,	right,	rright);
 				P(percent,	bottom,	rbottom);
 #undef P
 			}
 			catch (PSERROR_Scripting_ConversionFailed&)
 			{
 				debug_warn(L"Error creating size object!");
 				break;
 			}
 
 			break;
 		}
 
 		case GUIST_CGUIString:
 		{
 			CGUIString value;
 			GUI<CGUIString>::GetSetting(e, propName, value);
 			ScriptInterface::ToJSVal(cx, vp, value.GetOriginalString());
 			break;
 		}
 
 		case GUIST_CStr:
 		{
 			CStr value;
 			GUI<CStr>::GetSetting(e, propName, value);
 			ScriptInterface::ToJSVal(cx, vp, value);
 			break;
 		}
 
 		case GUIST_CStrW:
 		{
 			CStrW value;
 			GUI<CStrW>::GetSetting(e, propName, value);
 			ScriptInterface::ToJSVal(cx, vp, value);
 			break;
 		}
 
 		case GUIST_CGUISpriteInstance:
 		{
 			CGUISpriteInstance *value;
 			GUI<CGUISpriteInstance>::GetSettingPointer(e, propName, value);
 			ScriptInterface::ToJSVal(cx, vp, value->GetName());
 			break;
 		}
 
 		case GUIST_EAlign:
 		{
 			EAlign value;
 			GUI<EAlign>::GetSetting(e, propName, value);
 			CStr word;
 			switch (value)
 			{
 			case EAlign_Left: word = "left"; break;
 			case EAlign_Right: word = "right"; break;
 			case EAlign_Center: word = "center"; break;
 			default: debug_warn(L"Invalid EAlign!"); word = "error"; break;
 			}
 			ScriptInterface::ToJSVal(cx, vp, word);
 			break;
 		}
 
 		case GUIST_EVAlign:
 		{
 			EVAlign value;
 			GUI<EVAlign>::GetSetting(e, propName, value);
 			CStr word;
 			switch (value)
 			{
 			case EVAlign_Top: word = "top"; break;
 			case EVAlign_Bottom: word = "bottom"; break;
 			case EVAlign_Center: word = "center"; break;
 			default: debug_warn(L"Invalid EVAlign!"); word = "error"; break;
 			}
 			ScriptInterface::ToJSVal(cx, vp, word);
 			break;
 		}
 
 		case GUIST_CGUIList:
 		{
 			CGUIList value;
 			GUI<CGUIList>::GetSetting(e, propName, value);
 			ScriptInterface::ToJSVal(cx, vp, value.m_Items);
 			break;
 		}
 
 		case GUIST_CGUISeries:
 		{
 			CGUISeries value;
 			GUI<CGUISeries>::GetSetting(e, propName, value);
 			ScriptInterface::ToJSVal(cx, vp, value.m_Series);
 			break;
 		}
 
 		default:
 			JS_ReportError(cx, "Setting '%s' uses an unimplemented type", propName.c_str());
 			DEBUG_WARN_ERR(ERR::LOGIC);
 			return false;
 		}
 
 		return true;
 	}
 }
 
 bool JSI_IGUIObject::setProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id, bool UNUSED(strict), JS::MutableHandleValue vp)
 {
 	IGUIObject* e = (IGUIObject*)JS_GetInstancePrivate(cx, obj, &JSI_IGUIObject::JSI_class, NULL);
 	if (!e)
 		return false;
 
 	JSAutoRequest rq(cx);
 	JS::RootedValue idval(cx);
 	if (!JS_IdToValue(cx, id, &idval))
 		return false;
 
 	std::string propName;
 	if (!ScriptInterface::FromJSVal(cx, idval, propName))
 		return false;
 
 	if (propName == "name")
 	{
 		std::string value;
 		if (!ScriptInterface::FromJSVal(cx, vp, value))
 			return false;
 		e->SetName(value);
 		return true;
 	}
 
 	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(cx, &vp.toObject()))
 		{
 			JS_ReportError(cx, "on- event-handlers must be functions");
 			return false;
 		}
 
 		CStr eventName(CStr(propName.substr(2)).LowerCase());
 		e->SetScriptHandler(eventName, vpObj);
 
 		return true;
 	}
 
 	// Retrieve the setting's type (and make sure it actually exists)
 	EGUISettingType Type;
 	if (e->GetSettingType(propName, Type) != PSRETURN_OK)
 	{
 		JS_ReportError(cx, "Invalid setting '%s'", propName.c_str());
 		return true;
 	}
 
 	switch (Type)
 	{
 	case GUIST_CStr:
 	{
 		std::string value;
 		if (!ScriptInterface::FromJSVal(cx, vp, value))
 			return false;
 
 		GUI<CStr>::SetSetting(e, propName, value);
 		break;
 	}
 
 	case GUIST_CStrW:
 	{
 		std::wstring value;
 		if (!ScriptInterface::FromJSVal(cx, vp, value))
 			return false;
 
 		GUI<CStrW>::SetSetting(e, propName, value);
 		break;
 	}
 
 	case GUIST_CGUISpriteInstance:
 	{
 		std::string value;
 		if (!ScriptInterface::FromJSVal(cx, vp, value))
 			return false;
 
 		GUI<CGUISpriteInstance>::SetSetting(e, propName, CGUISpriteInstance(value));
 		break;
 	}
 
 	case GUIST_CGUIString:
 	{
 		std::wstring value;
 		if (!ScriptInterface::FromJSVal(cx, vp, value))
 			return false;
 
 		CGUIString str;
 		str.SetValue(value);
 		GUI<CGUIString>::SetSetting(e, propName, str);
 		break;
 	}
 
 	case GUIST_EAlign:
 	{
 		std::string value;
 		if (!ScriptInterface::FromJSVal(cx, vp, value))
 			return false;
 
 		EAlign a;
 		if (value == "left") a = EAlign_Left;
 		else if (value == "right") a = EAlign_Right;
 		else if (value == "center" || value == "centre") a = EAlign_Center;
 		else
 		{
 			JS_ReportError(cx, "Invalid alignment (should be 'left', 'right' or 'center')");
 			return false;
 		}
 		GUI<EAlign>::SetSetting(e, propName, a);
 		break;
 	}
 
 	case GUIST_EVAlign:
 	{
 		std::string value;
 		if (!ScriptInterface::FromJSVal(cx, vp, value))
 			return false;
 
 		EVAlign a;
 		if (value == "top") a = EVAlign_Top;
 		else if (value == "bottom") a = EVAlign_Bottom;
 		else if (value == "center" || value == "centre") a = EVAlign_Center;
 		else
 		{
 			JS_ReportError(cx, "Invalid alignment (should be 'top', 'bottom' or 'center')");
 			return false;
 		}
 		GUI<EVAlign>::SetSetting(e, propName, a);
 		break;
 	}
 
 	case GUIST_int:
 	{
 		int value;
 		if (ScriptInterface::FromJSVal(cx, vp, value))
 			GUI<int>::SetSetting(e, propName, value);
 		else
 		{
 			JS_ReportError(cx, "Cannot convert value to int");
 			return false;
 		}
 		break;
 	}
 
 	case GUIST_uint:
 	{
 		u32 value;
 		if (ScriptInterface::FromJSVal(cx, vp, value))
 			GUI<u32>::SetSetting(e, propName, value);
 		else
 		{
 			JS_ReportError(cx, "Cannot convert value to u32");
 			return false;
 		}
 		break;
 	}
 
 	case GUIST_float:
 	{
 		double value;
 		if (JS::ToNumber(cx, vp, &value) == true)
 			GUI<float>::SetSetting(e, propName, (float)value);
 		else
 		{
 			JS_ReportError(cx, "Cannot convert value to float");
 			return false;
 		}
 		break;
 	}
 
 	case GUIST_bool:
 	{
 		bool value = JS::ToBoolean(vp);
 		GUI<bool>::SetSetting(e, propName, value);
 		break;
 	}
 
 	case GUIST_CClientArea:
 	{
 		if (vp.isString())
 		{
 			std::wstring value;
 			if (!ScriptInterface::FromJSVal(cx, vp, value))
 				return false;
 
 			if (e->SetSetting(propName, value) != PSRETURN_OK)
 			{
 				JS_ReportError(cx, "Invalid value for setting '%s'", propName.c_str());
 				return false;
 			}
 		}
 		else if (vp.isObject() && JS_InstanceOf(cx, vpObj, &JSI_GUISize::JSI_class, NULL))
 		{
 			CClientArea area;
 			GUI<CClientArea>::GetSetting(e, propName, area);
 
 			ScriptInterface* pScriptInterface = ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface;
 #define P(x, y, z) pScriptInterface->GetProperty(vp, #z, area.x.y)
 			P(pixel,	left,	left);
 			P(pixel,	top,	top);
 			P(pixel,	right,	right);
 			P(pixel,	bottom,	bottom);
 			P(percent,	left,	rleft);
 			P(percent,	top,	rtop);
 			P(percent,	right,	rright);
 			P(percent,	bottom,	rbottom);
 #undef P
 
 			GUI<CClientArea>::SetSetting(e, propName, area);
 		}
 		else
 		{
 			JS_ReportError(cx, "Size only accepts strings or GUISize objects");
 			return false;
 		}
 		break;
 	}
 
 	case GUIST_CColor:
 	{
 		if (vp.isString())
 		{
 			std::wstring value;
 			if (!ScriptInterface::FromJSVal(cx, vp, value))
 				return false;
 
 			if (e->SetSetting(propName, value) != PSRETURN_OK)
 			{
 				JS_ReportError(cx, "Invalid value for setting '%s'", propName.c_str());
 				return false;
 			}
 		}
 		else if (vp.isObject() && JS_InstanceOf(cx, vpObj, &JSI_GUIColor::JSI_class, NULL))
 		{
 			CColor color;
 			JS::RootedValue t(cx);
 			double s;
 #define PROP(x) \
 	JS_GetProperty(cx, vpObj, #x, &t); \
 	s = t.toDouble(); \
 	color.x = (float)s
 
 			PROP(r);
 			PROP(g);
 			PROP(b);
 			PROP(a);
 #undef PROP
 			GUI<CColor>::SetSetting(e, propName, color);
 		}
 		else
 		{
 			JS_ReportError(cx, "Color only accepts strings or GUIColor objects");
 			return false;
 		}
 		break;
 	}
 
 	case GUIST_CGUIList:
 	{
 		CGUIList list;
 		if (ScriptInterface::FromJSVal(cx, vp, list.m_Items))
 			GUI<CGUIList>::SetSetting(e, propName, list);
 		else
 		{
 			JS_ReportError(cx, "Failed to get list '%s'", propName.c_str());
 			return false;
 		}
 		break;
 	}
 
 	case GUIST_CGUISeries:
 	{
 		CGUISeries series;
 		if (ScriptInterface::FromJSVal(cx, vp, series.m_Series))
 			GUI<CGUISeries>::SetSetting(e, propName, series);
 		else
 		{
 			JS_ReportError(cx, "Invalid value for chart series '%s'", propName.c_str());
 			return false;
 		}
 		break;
 	}
 
 	default:
 		JS_ReportError(cx, "Setting '%s' uses an unimplemented type", propName.c_str());
 		break;
 	}
 
 	return !JS_IsExceptionPending(cx);
 }
 
 
 bool JSI_IGUIObject::construct(JSContext* cx, uint argc, JS::Value* vp)
 {
 	JSAutoRequest rq(cx);
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 	ScriptInterface* pScriptInterface = ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface;
 
 	if (args.length() == 0)
 	{
 		JS_ReportError(cx, "GUIObject has no default constructor");
 		return false;
 	}
 
 	JS::RootedObject obj(cx, pScriptInterface->CreateCustomObject("GUIObject"));
 
 	// Store the IGUIObject in the JS object's 'private' area
 	IGUIObject* guiObject = (IGUIObject*)args[0].get().toPrivate();
 	JS_SetPrivate(obj, guiObject);
 
 	args.rval().setObject(*obj);
 	return true;
 }
 
 void JSI_IGUIObject::init(ScriptInterface& scriptInterface)
 {
 	scriptInterface.DefineCustomObjectType(&JSI_class, construct, 1, nullptr, JSI_methods, nullptr, nullptr);
 }
 
 bool JSI_IGUIObject::toString(JSContext* cx, uint UNUSED(argc), JS::Value* vp)
 {
 	JSAutoRequest rq(cx);
 	JS::CallReceiver rec = JS::CallReceiverFromVp(vp);
 
 	JS::RootedObject thisObj(cx, JS_THIS_OBJECT(cx, vp));
 
 	IGUIObject* e = (IGUIObject*)JS_GetInstancePrivate(cx, thisObj, &JSI_IGUIObject::JSI_class, NULL);
 	if (!e)
 		return false;
 
 	char buffer[256];
 	snprintf(buffer, 256, "[GUIObject: %s]", e->GetName().c_str());
 	buffer[255] = 0;
 	rec.rval().setString(JS_NewStringCopyZ(cx, buffer));
 	return true;
 }
 
 bool JSI_IGUIObject::focus(JSContext* cx, uint UNUSED(argc), JS::Value* vp)
 {
 	JSAutoRequest rq(cx);
 	JS::CallReceiver rec = JS::CallReceiverFromVp(vp);
 
 	JS::RootedObject thisObj(cx, JS_THIS_OBJECT(cx, vp));
 
 	IGUIObject* e = (IGUIObject*)JS_GetInstancePrivate(cx, thisObj, &JSI_IGUIObject::JSI_class, NULL);
 	if (!e)
 		return false;
 
 	e->GetGUI()->SetFocusedObject(e);
 
 	rec.rval().setUndefined();
 	return true;
 }
 
 bool JSI_IGUIObject::blur(JSContext* cx, uint UNUSED(argc), JS::Value* vp)
 {
 	JSAutoRequest rq(cx);
 	JS::CallReceiver rec = JS::CallReceiverFromVp(vp);
 
 	JS::RootedObject thisObj(cx, JS_THIS_OBJECT(cx, vp));
 
 	IGUIObject* e = (IGUIObject*)JS_GetInstancePrivate(cx, thisObj, &JSI_IGUIObject::JSI_class, NULL);
 	if (!e)
 		return false;
 
 	e->GetGUI()->SetFocusedObject(NULL);
 
 	rec.rval().setUndefined();
 	return true;
 }
 
+bool JSI_IGUIObject::getTextSize(JSContext* cx, uint argc, JS::Value* vp)
+{
+	JSAutoRequest rq(cx);
+	JS::CallReceiver rec = JS::CallReceiverFromVp(vp);
+
+	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
+	JS::RootedObject thisObj(cx, &args.thisv().toObject());
+
+	IGUIObject* obj = (IGUIObject*)JS_GetInstancePrivate(cx, thisObj, &JSI_IGUIObject::JSI_class, NULL);
+
+	if (!obj || !obj->SettingExists("caption"))
+		return false;
+
+	CStrW font;
+	if (GUI<CStrW>::GetSetting(obj, "font", font) != PSRETURN_OK || font.empty())
+		font = L"default";
+
+	CGUIString caption;
+	EGUISettingType Type;
+	obj->GetSettingType("caption", Type);
+	if (Type == GUIST_CGUIString)
+		// CText, CButton, CCheckBox, CRadioButton
+		GUI<CGUIString>::GetSetting(obj, "caption", caption);
+	else if (Type == GUIST_CStrW)
+	{
+		// CInput
+		CStrW captionStr;
+		GUI<CStrW>::GetSetting(obj, "caption", captionStr);
+		caption.SetValue(captionStr);
+	}
+	else
+		return false;
+
+	obj->UpdateCachedSize();
+	float width = obj->m_CachedActualSize.GetWidth();
+
+	if (obj->SettingExists("scrollbar"))
+	{
+		bool scrollbar;
+		GUI<bool>::GetSetting(obj, "scrollbar", scrollbar);
+		if (scrollbar)
+		{
+			CStr scrollbar_style;
+			GUI<CStr>::GetSetting(obj, "scrollbar_style", scrollbar_style);
+			const SGUIScrollBarStyle* scrollbar_style_object = obj->GetGUI()->GetScrollBarStyle(scrollbar_style);
+			if (scrollbar_style_object)
+				width -= scrollbar_style_object->m_Width;
+		}
+	}
+
+	float buffer_zone = 0.f;
+	GUI<float>::GetSetting(obj, "buffer_zone", buffer_zone);
+	SGUIText text = obj->GetGUI()->GenerateText(caption, font, width, buffer_zone, obj);
+
+	JS::RootedValue objVal(cx, JS::ObjectValue(*JS_NewPlainObject(cx)));
+	try
+	{
+		ScriptInterface* pScriptInterface = ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface;
+		pScriptInterface->SetProperty(objVal, "width", text.m_Size.cx, false, true);
+		pScriptInterface->SetProperty(objVal, "height", text.m_Size.cy, false, true);
+	}
+	catch (PSERROR_Scripting_ConversionFailed&)
+	{
+		debug_warn(L"Error creating size object!");
+		return false;
+	}
+
+	rec.rval().set(objVal);
+	return true;
+}
+
 bool JSI_IGUIObject::getComputedSize(JSContext* cx, uint UNUSED(argc), JS::Value* vp)
 {
 	JSAutoRequest rq(cx);
 	JS::CallReceiver rec = JS::CallReceiverFromVp(vp);
 
 	JS::RootedObject thisObj(cx, JS_THIS_OBJECT(cx, vp));
 
 	IGUIObject* e = (IGUIObject*)JS_GetInstancePrivate(cx, thisObj, &JSI_IGUIObject::JSI_class, NULL);
 	if (!e)
 		return false;
 
 	e->UpdateCachedSize();
 	CRect size = e->m_CachedActualSize;
 
 	JS::RootedValue objVal(cx, JS::ObjectValue(*JS_NewPlainObject(cx)));
 	try
 	{
 		ScriptInterface* pScriptInterface = ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface;
 		pScriptInterface->SetProperty(objVal, "left", size.left, false, true);
 		pScriptInterface->SetProperty(objVal, "right", size.right, false, true);
 		pScriptInterface->SetProperty(objVal, "top", size.top, false, true);
 		pScriptInterface->SetProperty(objVal, "bottom", size.bottom, false, true);
 	}
 	catch (PSERROR_Scripting_ConversionFailed&)
 	{
 		debug_warn(L"Error creating size object!");
 		return false;
 	}
 
 	rec.rval().set(objVal);
 	return true;
 }
Index: ps/trunk/source/gui/scripting/JSInterface_IGUIObject.h
===================================================================
--- ps/trunk/source/gui/scripting/JSInterface_IGUIObject.h	(revision 22133)
+++ ps/trunk/source/gui/scripting/JSInterface_IGUIObject.h	(revision 22134)
@@ -1,37 +1,38 @@
 /* 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_IGUIOBJECT
 #define INCLUDED_JSI_IGUIOBJECT
 
 #include "scriptinterface/ScriptInterface.h"
 
 namespace JSI_IGUIObject
 {
 	extern JSClass JSI_class;
 	extern JSFunctionSpec JSI_methods[];
 	bool getProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::MutableHandleValue vp);
 	bool setProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id, bool UNUSED(strict), JS::MutableHandleValue vp);
 	bool construct(JSContext* cx, uint argc, JS::Value* vp);
 	bool toString(JSContext* cx, uint argc, JS::Value* vp);
 	bool focus(JSContext* cx, uint argc, JS::Value* vp);
 	bool blur(JSContext* cx, uint argc, JS::Value* vp);
 	bool getComputedSize(JSContext* cx, uint argc, JS::Value* vp);
+	bool getTextSize(JSContext* cx, uint argc, JS::Value* vp);
 	void init(ScriptInterface& scriptInterface);
 }
 
 #endif // INCLUDED_JSI_IGUIOBJECT