Index: ps/trunk/source/gui/GUItext.h
===================================================================
--- ps/trunk/source/gui/GUItext.h	(revision 22678)
+++ ps/trunk/source/gui/GUItext.h	(nonexistent)
@@ -1,153 +0,0 @@
-/* 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_GUITEXT
-#define INCLUDED_GUITEXT
-
-#include <list>
-
-#include "gui/CGUIColor.h"
-#include "gui/CGUISprite.h"
-#include "ps/CStrIntern.h"
-#include "ps/Shapes.h"
-
-/**
- * An SGUIText object is a parsed string, divided into
- * text-rendering components. Each component, being a
- * call to the Renderer. For instance, if you by tags
- * change the color, then the GUI will have to make
- * individual calls saying it want that color on the
- * text.
- *
- * For instance:
- * "Hello [b]there[/b] bunny!"
- *
- * That without word-wrapping would mean 3 components.
- * i.e. 3 calls to CRenderer. One drawing "Hello",
- * one drawing "there" in bold, and one drawing "bunny!".
- */
-struct SGUIText
-{
-	/**
-	 * A sprite call to the CRenderer
-	 */
-	struct SSpriteCall
-	{
-		// The CGUISpriteInstance makes this uncopyable to avoid invalidating its draw cache
-		NONCOPYABLE(SSpriteCall);
-		MOVABLE(SSpriteCall);
-
-		SSpriteCall() : m_CellID(0) {}
-
-		/**
-		 * Size and position of sprite
-		 */
-		CRect m_Area;
-
-		/**
-		 * Sprite from global GUI sprite database.
-		 */
-		CGUISpriteInstance m_Sprite;
-
-		int m_CellID;
-
-		/**
-		 * Tooltip text
-		 */
-		CStrW m_Tooltip;
-
-		/**
-		 * Tooltip style
-		 */
-		CStrW m_TooltipStyle;
-	};
-
-	/**
-	 * A text call to the CRenderer
-	 */
-	struct STextCall
-	{
-		NONCOPYABLE(STextCall);
-		MOVABLE(STextCall);
-
-		STextCall() :
-			m_UseCustomColor(false),
-			m_Bold(false), m_Italic(false), m_Underlined(false),
-			m_pSpriteCall(NULL) {}
-
-		/**
-		 * Position
-		 */
-		CPos m_Pos;
-
-		/**
-		 * Size
-		 */
-		CSize m_Size;
-
-		/**
-		 * The string that is suppose to be rendered.
-		 */
-		CStrW m_String;
-
-		/**
-		 * Use custom color? If true then m_Color is used,
-		 * else the color inputted will be used.
-		 */
-		bool m_UseCustomColor;
-
-		/**
-		 * Color setup
-		 */
-		CGUIColor m_Color;
-
-		/**
-		 * Font name
-		 */
-		CStrIntern m_Font;
-
-		/**
-		 * Settings
-		 */
-		bool m_Bold, m_Italic, m_Underlined;
-
-		/**
-		 * *IF* an icon, then this is not NULL.
-		 */
-		std::list<SSpriteCall>::pointer m_pSpriteCall;
-	};
-
-	/**
-	 * List of TextCalls, for instance "Hello", "there!"
-	 */
-	std::vector<STextCall> m_TextCalls;
-
-	/**
-	 * List of sprites, or "icons" that should be rendered
-	 * along with the text.
-	 */
-	std::list<SSpriteCall> m_SpriteCalls; // list for consistent mem addresses
-										  // so that we can point to elements.
-
-	/**
-	 * Width and height of the whole output, used when setting up
-	 * scrollbars and such.
-	 */
-	CSize m_Size;
-};
-
-#endif // INCLUDED_GUITEXT

Property changes on: ps/trunk/source/gui/GUItext.h
___________________________________________________________________
Deleted: svn:eol-style
## -1 +0,0 ##
-native
\ No newline at end of property
Index: ps/trunk/source/gui/CButton.cpp
===================================================================
--- ps/trunk/source/gui/CButton.cpp	(revision 22678)
+++ ps/trunk/source/gui/CButton.cpp	(revision 22679)
@@ -1,119 +1,119 @@
 /* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "CButton.h"
 
 #include "gui/CGUIColor.h"
 #include "lib/ogl.h"
 
 CButton::CButton(CGUI* pGUI)
 	: IGUIObject(pGUI), IGUIButtonBehavior(pGUI), IGUITextOwner(pGUI)
 {
 	AddSetting<float>("buffer_zone");
 	AddSetting<CGUIString>("caption");
 	AddSetting<int>("cell_id");
 	AddSetting<CStrW>("font");
 	AddSetting<CStrW>("sound_disabled");
 	AddSetting<CStrW>("sound_enter");
 	AddSetting<CStrW>("sound_leave");
 	AddSetting<CStrW>("sound_pressed");
 	AddSetting<CStrW>("sound_released");
 	AddSetting<CGUISpriteInstance>("sprite");
 	AddSetting<CGUISpriteInstance>("sprite_over");
 	AddSetting<CGUISpriteInstance>("sprite_pressed");
 	AddSetting<CGUISpriteInstance>("sprite_disabled");
 	AddSetting<EAlign>("text_align");
 	AddSetting<EVAlign>("text_valign");
 	AddSetting<CGUIColor>("textcolor");
 	AddSetting<CGUIColor>("textcolor_over");
 	AddSetting<CGUIColor>("textcolor_pressed");
 	AddSetting<CGUIColor>("textcolor_disabled");
 	AddSetting<CStrW>("tooltip");
 	AddSetting<CStr>("tooltip_style");
 
-	// Add text
-	AddText(new SGUIText());
+	AddText();
 }
 
 CButton::~CButton()
 {
 }
 
 void CButton::SetupText()
 {
 	ENSURE(m_GeneratedTexts.size() == 1);
 
 	CStrW font;
 	if (GUI<CStrW>::GetSetting(this, "font", font) != PSRETURN_OK || font.empty())
 		// Use the default if none is specified
 		// TODO Gee: (2004-08-14) Default should not be hard-coded, but be in styles!
 		font = L"default";
 
 	CGUIString* caption = nullptr;
 	GUI<CGUIString>::GetSettingPointer(this, "caption", caption);
 
 	float buffer_zone = 0.f;
 	GUI<float>::GetSetting(this, "buffer_zone", buffer_zone);
-	*m_GeneratedTexts[0] = GetGUI()->GenerateText(*caption, font, m_CachedActualSize.GetWidth(), buffer_zone, this);
 
-	CalculateTextPosition(m_CachedActualSize, m_TextPos, *m_GeneratedTexts[0]);
+	m_GeneratedTexts[0] = CGUIText(m_pGUI, *caption, font, m_CachedActualSize.GetWidth(), buffer_zone, this);
+
+	CalculateTextPosition(m_CachedActualSize, m_TextPos, m_GeneratedTexts[0]);
 }
 
 void CButton::HandleMessage(SGUIMessage& Message)
 {
 	// Important
 	IGUIButtonBehavior::HandleMessage(Message);
 	IGUITextOwner::HandleMessage(Message);
 }
 
 void CButton::Draw()
 {
 	float bz = GetBufferedZ();
 
 	CGUISpriteInstance* sprite;
 	CGUISpriteInstance* sprite_over;
 	CGUISpriteInstance* sprite_pressed;
 	CGUISpriteInstance* sprite_disabled;
 	int cell_id;
 
 	// Statically initialise some strings, so we don't have to do
 	// lots of allocation every time this function is called
 	static const CStr strSprite("sprite");
 	static const CStr strSpriteOver("sprite_over");
 	static const CStr strSpritePressed("sprite_pressed");
 	static const CStr strSpriteDisabled("sprite_disabled");
 	static const CStr strCellId("cell_id");
 
 	GUI<CGUISpriteInstance>::GetSettingPointer(this, strSprite, sprite);
 	GUI<CGUISpriteInstance>::GetSettingPointer(this, strSpriteOver, sprite_over);
 	GUI<CGUISpriteInstance>::GetSettingPointer(this, strSpritePressed, sprite_pressed);
 	GUI<CGUISpriteInstance>::GetSettingPointer(this, strSpriteDisabled, sprite_disabled);
 	GUI<int>::GetSetting(this, strCellId, cell_id);
 
 	DrawButton(m_CachedActualSize,
 			   bz,
 			   *sprite,
 			   *sprite_over,
 			   *sprite_pressed,
 			   *sprite_disabled,
 			   cell_id);
 
 	CGUIColor color = ChooseColor();
 	DrawText(0, color, m_TextPos, bz+0.1f);
 }
Index: ps/trunk/source/gui/CChart.cpp
===================================================================
--- ps/trunk/source/gui/CChart.cpp	(revision 22678)
+++ ps/trunk/source/gui/CChart.cpp	(revision 22679)
@@ -1,328 +1,324 @@
 /* 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 "CChart.h"
 
 #include "gui/CGUIColor.h"
 #include "gui/CGUIString.h"
 #include "gui/GUIMatrix.h"
 #include "graphics/ShaderManager.h"
 #include "i18n/L10n.h"
 #include "lib/ogl.h"
 #include "ps/CLogger.h"
 #include "renderer/Renderer.h"
 #include "third_party/cppformat/format.h"
 
 #include <cmath>
 
 CChart::CChart(CGUI* pGUI)
 	: IGUIObject(pGUI), IGUITextOwner(pGUI)
 {
 	AddSetting<CGUIColor>("axis_color");
 	AddSetting<float>("axis_width");
 	AddSetting<float>("buffer_zone");
 	AddSetting<CStrW>("font");
 	AddSetting<CStrW>("format_x");
 	AddSetting<CStrW>("format_y");
 	AddSetting<CGUIList>("series_color");
 	AddSetting<CGUISeries>("series");
 	AddSetting<EAlign>("text_align");
 
 	GUI<float>::GetSetting(this, "axis_width", m_AxisWidth);
 	GUI<CStrW>::GetSetting(this, "format_x", m_FormatX);
 	GUI<CStrW>::GetSetting(this, "format_y", m_FormatY);
 }
 
 CChart::~CChart()
 {
 }
 
 void CChart::HandleMessage(SGUIMessage& Message)
 {
 	// TODO: implement zoom
 	switch (Message.type)
 	{
 	case GUIM_SETTINGS_UPDATED:
 	{
 		GUI<float>::GetSetting(this, "axis_width", m_AxisWidth);
 		GUI<CStrW>::GetSetting(this, "format_x", m_FormatX);
 		GUI<CStrW>::GetSetting(this, "format_y", m_FormatY);
 
 		UpdateSeries();
 		break;
 	}
 	}
 }
 
 void CChart::DrawLine(const CShaderProgramPtr& shader, const CGUIColor& color, const std::vector<float>& vertices) const
 {
 	shader->Uniform(str_color, color);
 	shader->VertexPointer(3, GL_FLOAT, 0, &vertices[0]);
 	shader->AssertPointersBound();
 
 	glEnable(GL_LINE_SMOOTH);
 	glLineWidth(1.1f);
 	if (!g_Renderer.m_SkipSubmit)
 		glDrawArrays(GL_LINE_STRIP, 0, vertices.size() / 3);
 	glLineWidth(1.0f);
 	glDisable(GL_LINE_SMOOTH);
 }
 
 void CChart::DrawTriangleStrip(const CShaderProgramPtr& shader, const CGUIColor& color, const std::vector<float>& vertices) const
 {
 	shader->Uniform(str_color, color);
 	shader->VertexPointer(3, GL_FLOAT, 0, &vertices[0]);
 	shader->AssertPointersBound();
 
 	if (!g_Renderer.m_SkipSubmit)
 		glDrawArrays(GL_TRIANGLE_STRIP, 0, vertices.size() / 3);
 }
 
 void CChart::DrawAxes(const CShaderProgramPtr& shader) const
 {
 	const float bz = GetBufferedZ();
 	CRect rect = GetChartRect();
 	std::vector<float> vertices;
 	vertices.reserve(30);
 #define ADD(x, y) vertices.push_back(x); vertices.push_back(y); vertices.push_back(bz + 0.5f);
 	ADD(m_CachedActualSize.right, m_CachedActualSize.bottom);
 	ADD(rect.right + m_AxisWidth, rect.bottom);
 	ADD(m_CachedActualSize.left, m_CachedActualSize.bottom);
 	ADD(rect.left, rect.bottom);
 	ADD(m_CachedActualSize.left, m_CachedActualSize.top);
 	ADD(rect.left, rect.top - m_AxisWidth);
 #undef ADD
 	CGUIColor axis_color(0.5f, 0.5f, 0.5f, 1.f);
 	GUI<CGUIColor>::GetSetting(this, "axis_color", axis_color);
 	DrawTriangleStrip(shader, axis_color, vertices);
 }
 
 void CChart::Draw()
 {
 	PROFILE3("render chart");
 
 	if (m_Series.empty())
 		return;
 
 	const float bz = GetBufferedZ();
 	CRect rect = GetChartRect();
 	const float width = rect.GetWidth();
 	const float height = rect.GetHeight();
 
 	// Disable depth updates to prevent apparent z-fighting-related issues
 	//  with some drivers causing units to get drawn behind the texture.
 	glDepthMask(0);
 
 	// Setup the render state
 	CMatrix3D transform = GetDefaultGuiMatrix();
 	CShaderDefines lineDefines;
 	CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_gui_solid, g_Renderer.GetSystemShaderDefines(), lineDefines);
 	tech->BeginPass();
 	CShaderProgramPtr shader = tech->GetShader();
 	shader->Uniform(str_transform, transform);
 
 	CVector2D scale(width / (m_RightTop.X - m_LeftBottom.X), height / (m_RightTop.Y - m_LeftBottom.Y));
 	for (const CChartData& data : m_Series)
 	{
 		if (data.m_Points.empty())
 			continue;
 
 		std::vector<float> vertices;
 		for (const CVector2D& point : data.m_Points)
 		{
 			if (fabs(point.X) != std::numeric_limits<float>::infinity() && fabs(point.Y) != std::numeric_limits<float>::infinity())
 			{
 				vertices.push_back(rect.left + (point.X - m_LeftBottom.X) * scale.X);
 				vertices.push_back(rect.bottom - (point.Y - m_LeftBottom.Y) * scale.Y);
 				vertices.push_back(bz + 0.5f);
 			}
 			else
 			{
 				DrawLine(shader, data.m_Color, vertices);
 				vertices.clear();
 			}
 		}
 		if (!vertices.empty())
 			DrawLine(shader, data.m_Color, vertices);
 	}
 
 	if (m_AxisWidth > 0)
 		DrawAxes(shader);
 
 	tech->EndPass();
 
 	// Reset depth mask
 	glDepthMask(1);
 
 	for (size_t i = 0; i < m_TextPositions.size(); ++i)
 		DrawText(i, CGUIColor(1.f, 1.f, 1.f, 1.f), m_TextPositions[i], bz + 0.5f);
 }
 
 CRect CChart::GetChartRect() const
 {
 	return CRect(
 		m_CachedActualSize.TopLeft() + CPos(m_AxisWidth, m_AxisWidth),
 		m_CachedActualSize.BottomRight() - CPos(m_AxisWidth, m_AxisWidth)
 	);
 }
 
 void CChart::UpdateSeries()
 {
 	CGUISeries* pSeries;
 	GUI<CGUISeries>::GetSettingPointer(this, "series", pSeries);
 
 	CGUIList* pSeriesColor;
 	GUI<CGUIList>::GetSettingPointer(this, "series_color", pSeriesColor);
 
 	m_Series.clear();
 	m_Series.resize(pSeries->m_Series.size());
 	for (size_t i = 0; i < pSeries->m_Series.size(); ++i)
 	{
 		CChartData& data = m_Series[i];
 
 		if (i < pSeriesColor->m_Items.size() && !data.m_Color.ParseString(m_pGUI, pSeriesColor->m_Items[i].GetOriginalString().ToUTF8(), 0))
 			LOGWARNING("GUI: Error parsing 'series_color' (\"%s\")", utf8_from_wstring(pSeriesColor->m_Items[i].GetOriginalString()));
 
 		data.m_Points = pSeries->m_Series[i];
 	}
 	UpdateBounds();
 
 	SetupText();
 }
 
 void CChart::SetupText()
 {
-	for (SGUIText* t : m_GeneratedTexts)
-		delete t;
 	m_GeneratedTexts.clear();
 	m_TextPositions.clear();
 
 	if (m_Series.empty())
 		return;
 
 	CStrW font;
 	if (GUI<CStrW>::GetSetting(this, "font", font) != PSRETURN_OK || font.empty())
 		font = L"default";
 
 	float buffer_zone = 0.f;
 	GUI<float>::GetSetting(this, "buffer_zone", buffer_zone);
 
 	// Add Y-axis
 	GUI<CStrW>::GetSetting(this, "format_y", m_FormatY);
 	const float height = GetChartRect().GetHeight();
 	// TODO: split values depend on the format;
 	if (m_EqualY)
 	{
 		// We don't need to generate many items for equal values
 		AddFormattedValue(m_FormatY, m_RightTop.Y, font, buffer_zone);
 		m_TextPositions.emplace_back(GetChartRect().TopLeft());
 	}
 	else
 		for (int i = 0; i < 3; ++i)
 		{
 			AddFormattedValue(m_FormatY, m_RightTop.Y - (m_RightTop.Y - m_LeftBottom.Y) / 3.f * i, font, buffer_zone);
 			m_TextPositions.emplace_back(GetChartRect().TopLeft() + CPos(0.f, height / 3.f * i));
 		}
 
 	// Add X-axis
 	GUI<CStrW>::GetSetting(this, "format_x", m_FormatX);
 	const float width = GetChartRect().GetWidth();
 	if (m_EqualX)
 	{
 		CSize text_size = AddFormattedValue(m_FormatX, m_RightTop.X, font, buffer_zone);
 		m_TextPositions.emplace_back(GetChartRect().BottomRight() - text_size);
 	}
 	else
 		for (int i = 0; i < 3; ++i)
 		{
 			CSize text_size = AddFormattedValue(m_FormatX, m_RightTop.X - (m_RightTop.X - m_LeftBottom.X) / 3 * i, font, buffer_zone);
 			m_TextPositions.emplace_back(GetChartRect().BottomRight() - text_size - CPos(width / 3 * i, 0.f));
 		}
 }
 
 CSize CChart::AddFormattedValue(const CStrW& format, const float value, const CStrW& font, const float buffer_zone)
 {
 	// TODO: we need to catch cases with equal formatted values.
 	CGUIString gui_str;
 	if (format == L"DECIMAL2")
 	{
 		wchar_t buffer[64];
 		swprintf(buffer, 64, L"%.2f", value);
 		gui_str.SetValue(buffer);
 	}
 	else if (format == L"INTEGER")
 	{
 		wchar_t buffer[64];
 		swprintf(buffer, 64, L"%d", std::lround(value));
 		gui_str.SetValue(buffer);
 	}
 	else if (format == L"DURATION_SHORT")
 	{
 		const int seconds = value;
 		wchar_t buffer[64];
 		swprintf(buffer, 64, L"%d:%02d", seconds / 60, seconds % 60);
 		gui_str.SetValue(buffer);
 	}
 	else if (format == L"PERCENTAGE")
 	{
 		wchar_t buffer[64];
 		swprintf(buffer, 64, L"%d%%", std::lround(value));
 		gui_str.SetValue(buffer);
 	}
 	else
 	{
 		LOGERROR("Unsupported chart format: " + format.EscapeToPrintableASCII());
 		return CSize();
 	}
-	SGUIText* text = new SGUIText();
-	*text = GetGUI()->GenerateText(gui_str, font, 0, buffer_zone, this);
-	AddText(text);
-	return text->m_Size;
+
+	return AddText(gui_str, font, 0, buffer_zone, this).GetSize();
 }
 
 void CChart::UpdateBounds()
 {
 	if (m_Series.empty() || m_Series[0].m_Points.empty())
 	{
 		m_LeftBottom = m_RightTop = CVector2D(0.f, 0.f);
 		return;
 	}
 
 	m_LeftBottom = m_RightTop = m_Series[0].m_Points[0];
 	for (const CChartData& data : m_Series)
 		for (const CVector2D& point : data.m_Points)
 		{
 			if (fabs(point.X) != std::numeric_limits<float>::infinity() && point.X < m_LeftBottom.X)
 				m_LeftBottom.X = point.X;
 			if (fabs(point.Y) != std::numeric_limits<float>::infinity() && point.Y < m_LeftBottom.Y)
 				m_LeftBottom.Y = point.Y;
 
 			if (fabs(point.X) != std::numeric_limits<float>::infinity() && point.X > m_RightTop.X)
 				m_RightTop.X = point.X;
 			if (fabs(point.Y) != std::numeric_limits<float>::infinity() && point.Y > m_RightTop.Y)
 				m_RightTop.Y = point.Y;
 		}
 
 	m_EqualY = m_RightTop.Y == m_LeftBottom.Y;
 	if (m_EqualY)
 		m_RightTop.Y += 1;
 	m_EqualX = m_RightTop.X == m_LeftBottom.X;
 	if (m_EqualX)
 		m_RightTop.X += 1;
 }
Index: ps/trunk/source/gui/CCheckBox.cpp
===================================================================
--- ps/trunk/source/gui/CCheckBox.cpp	(revision 22678)
+++ ps/trunk/source/gui/CCheckBox.cpp	(revision 22679)
@@ -1,147 +1,147 @@
 /* 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 "CCheckBox.h"
 
 #include "gui/CGUIColor.h"
 #include "graphics/FontMetrics.h"
 #include "ps/CLogger.h"
 #include "ps/CStrIntern.h"
 
 /**
  * TODO: Since there is no call to DrawText, the checkbox won't render any text.
  * Thus the font, caption, textcolor and other settings have no effect.
  */
 CCheckBox::CCheckBox(CGUI* pGUI)
 	: IGUIObject(pGUI), IGUITextOwner(pGUI), IGUIButtonBehavior(pGUI)
 {
 	AddSetting<float>("buffer_zone");
 	AddSetting<CGUIString>("caption");
 	AddSetting<int>("cell_id");
 	AddSetting<bool>("checked");
 	AddSetting<CStrW>("font");
 	AddSetting<CStrW>("sound_disabled");
 	AddSetting<CStrW>("sound_enter");
 	AddSetting<CStrW>("sound_leave");
 	AddSetting<CStrW>("sound_pressed");
 	AddSetting<CStrW>("sound_released");
 	AddSetting<CGUISpriteInstance>("sprite");
 	AddSetting<CGUISpriteInstance>("sprite_over");
 	AddSetting<CGUISpriteInstance>("sprite_pressed");
 	AddSetting<CGUISpriteInstance>("sprite_disabled");
 	AddSetting<CGUISpriteInstance>("sprite2");
 	AddSetting<CGUISpriteInstance>("sprite2_over");
 	AddSetting<CGUISpriteInstance>("sprite2_pressed");
 	AddSetting<CGUISpriteInstance>("sprite2_disabled");
 	AddSetting<float>("square_side");
 	AddSetting<CGUIColor>("textcolor");
 	AddSetting<CGUIColor>("textcolor_over");
 	AddSetting<CGUIColor>("textcolor_pressed");
 	AddSetting<CGUIColor>("textcolor_disabled");
 	AddSetting<CStrW>("tooltip");
 	AddSetting<CStr>("tooltip_style");
 
-	AddText(new SGUIText());
+	AddText();
 }
 
 CCheckBox::~CCheckBox()
 {
 }
 
 void CCheckBox::SetupText()
 {
 	ENSURE(m_GeneratedTexts.size() == 1);
 
 	CStrW font;
 	if (GUI<CStrW>::GetSetting(this, "font", font) != PSRETURN_OK || font.empty())
 		// Use the default if none is specified
 		// TODO Gee: (2004-08-14) Default should not be hard-coded, but be in styles!
 		font = L"default";
 
 	float square_side;
 	GUI<float>::GetSetting(this, "square_side", square_side);
 
 	CGUIString* caption = nullptr;
 	GUI<CGUIString>::GetSettingPointer(this, "caption", caption);
 
 	float buffer_zone = 0.f;
 	GUI<float>::GetSetting(this, "buffer_zone", buffer_zone);
-	*m_GeneratedTexts[0] = GetGUI()->GenerateText(*caption, font, m_CachedActualSize.GetWidth()-square_side, 0.f, this);
+	m_GeneratedTexts[0] = CGUIText(m_pGUI, *caption, font, m_CachedActualSize.GetWidth() - square_side, 0.f, this);
 }
 
 void CCheckBox::HandleMessage(SGUIMessage& Message)
 {
 	// Important
 	IGUIButtonBehavior::HandleMessage(Message);
 	IGUITextOwner::HandleMessage(Message);
 
 	switch (Message.type)
 	{
 	case GUIM_PRESSED:
 	{
 		bool checked;
 
 		// Switch to opposite.
 		GUI<bool>::GetSetting(this, "checked", checked);
 		checked = !checked;
 		GUI<bool>::SetSetting(this, "checked", checked);
 		break;
 	}
 
 	default:
 		break;
 	}
 }
 
 void CCheckBox::Draw()
 {
 	float bz = GetBufferedZ();
 	bool checked;
 	int cell_id;
 	CGUISpriteInstance* sprite;
 	CGUISpriteInstance* sprite_over;
 	CGUISpriteInstance* sprite_pressed;
 	CGUISpriteInstance* sprite_disabled;
 
 	GUI<bool>::GetSetting(this, "checked", checked);
 	GUI<int>::GetSetting(this, "cell_id", cell_id);
 
 	if (checked)
 	{
 		GUI<CGUISpriteInstance>::GetSettingPointer(this, "sprite2", sprite);
 		GUI<CGUISpriteInstance>::GetSettingPointer(this, "sprite2_over", sprite_over);
 		GUI<CGUISpriteInstance>::GetSettingPointer(this, "sprite2_pressed", sprite_pressed);
 		GUI<CGUISpriteInstance>::GetSettingPointer(this, "sprite2_disabled", sprite_disabled);
 	}
 	else
 	{
 		GUI<CGUISpriteInstance>::GetSettingPointer(this, "sprite", sprite);
 		GUI<CGUISpriteInstance>::GetSettingPointer(this, "sprite_over", sprite_over);
 		GUI<CGUISpriteInstance>::GetSettingPointer(this, "sprite_pressed", sprite_pressed);
 		GUI<CGUISpriteInstance>::GetSettingPointer(this, "sprite_disabled", sprite_disabled);
 	}
 
 	DrawButton(m_CachedActualSize,
 			   bz,
 			   *sprite,
 			   *sprite_over,
 			   *sprite_pressed,
 			   *sprite_disabled,
 			   cell_id);
 }
Index: ps/trunk/source/gui/CGUI.cpp
===================================================================
--- ps/trunk/source/gui/CGUI.cpp	(revision 22678)
+++ ps/trunk/source/gui/CGUI.cpp	(revision 22679)
@@ -1,1769 +1,1374 @@
 /* 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());
 }
 
 void CGUI::SendEventToAll(const CStr& EventName, JS::HandleValueArray paramData)
 {
 	GUI<CStr>::RecurseObject(0, m_BaseObject, &IGUIObject::ScriptEvent, EventName.LowerCase(), paramData);
 }
 
 CGUI::CGUI(const shared_ptr<ScriptRuntime>& runtime)
 	: m_MouseButtons(0), m_FocusedObject(NULL), m_InternalNameNumber(0)
 {
 	m_ScriptInterface.reset(new ScriptInterface("Engine", "GUIPage", runtime));
 	m_ScriptInterface->SetCallbackData(this);
 
 	GuiScriptingInit(*m_ScriptInterface);
 	m_ScriptInterface->LoadGlobalScripts();
 
        m_BaseObject = new CGUIDummyObject(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])(this);
 
 	// Error reporting will be handled with the nullptr return.
 	return nullptr;
 }
 
 void CGUI::Initialize()
 {
 	// Add base types!
 	//  You can also add types outside the GUI to extend the flexibility of the GUI.
 	//  Pyrogenesis though will have all the object types inserted from here.
 	AddObjectType("empty",			&CGUIDummyObject::ConstructObject);
 	AddObjectType("button",			&CButton::ConstructObject);
 	AddObjectType("image",			&CImage::ConstructObject);
 	AddObjectType("text",			&CText::ConstructObject);
 	AddObjectType("checkbox",		&CCheckBox::ConstructObject);
 	AddObjectType("radiobutton",	&CRadioButton::ConstructObject);
 	AddObjectType("progressbar",	&CProgressBar::ConstructObject);
 	AddObjectType("minimap",        &CMiniMap::ConstructObject);
 	AddObjectType("input",			&CInput::ConstructObject);
 	AddObjectType("list",			&CList::ConstructObject);
 	AddObjectType("olist",			&COList::ConstructObject);
 	AddObjectType("dropdown",		&CDropDown::ConstructObject);
 	AddObjectType("tooltip",		&CTooltip::ConstructObject);
 	AddObjectType("chart",			&CChart::ConstructObject);
 	AddObjectType("slider",			&CSlider::ConstructObject);
 }
 
 void CGUI::Draw()
 {
 	// Clear the depth buffer, so the GUI is
 	// drawn on top of everything else
 	glClear(GL_DEPTH_BUFFER_BIT);
 
 	try
 	{
 		// 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(this, 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, const 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
 	{
 		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, const 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
-{
-	// Only primitve members, so move assignments are the same as copy assignments.
-
-	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 = 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
-					const SGUIIcon& icon = GetIcon(imgname);
-
-					const 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].emplace_back(Image);
-					Text.m_SpriteCalls.emplace_back(std::move(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(),
-							std::make_move_iterator(Feedback2.m_SpriteCalls.begin()),
-							std::make_move_iterator(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(),
-					std::make_move_iterator(Feedback2.m_TextCalls.begin()),
-					std::make_move_iterator(Feedback2.m_TextCalls.end()));
-
-				Text.m_SpriteCalls.insert(
-					Text.m_SpriteCalls.end(),
-					std::make_move_iterator(Feedback2.m_SpriteCalls.begin()),
-					std::make_move_iterator(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 CGUIColor& 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;
-
-		CGUIColor 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, CGUIColor& Output) const
 {
 	std::map<CStr, CGUIColor>::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));
 
 			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.erase(name);
 	m_Sprites.emplace(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(this, 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(this, 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(this, attr_value, rect))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_TexturePlacementInFile = rect;
 		}
 		else if (attr_name == "cell_size")
 		{
 			CSize size;
 			if (!GUI<CSize>::ParseString(this, attr_value, size))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_CellSize = size;
 		}
 		else if (attr_name == "fixed_h_aspect_ratio")
 		{
 			float val;
 			if (!GUI<float>::ParseString(this, attr_value, val))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_FixedHAspectRatio = val;
 		}
 		else if (attr_name == "round_coordinates")
 		{
 			bool b;
 			if (!GUI<bool>::ParseString(this, attr_value, b))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_RoundCoordinates = b;
 		}
 		else if (attr_name == "wrap_mode")
 		{
 			if (attr_value == L"repeat")
 				Image->m_WrapMode = GL_REPEAT;
 			else if (attr_value == L"mirrored_repeat")
 				Image->m_WrapMode = GL_MIRRORED_REPEAT;
 			else if (attr_value == L"clamp_to_edge")
 				Image->m_WrapMode = GL_CLAMP_TO_EDGE;
 			else
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 		}
 		else if (attr_name == "z_level")
 		{
 			float z_level;
 			if (!GUI<float>::ParseString(this, attr_value, z_level))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_DeltaZ = z_level/100.f;
 		}
 		else if (attr_name == "backcolor")
 		{
 			CGUIColor color;
 			if (!GUI<CGUIColor>::ParseString(this, 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")
 		{
 			CGUIColor color;
 			if (!GUI<CGUIColor>::ParseString(this, 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(this, attr_value, b))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_Border = b;
 		}
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 
 	// Look for effects
 	for (XMBElement child : Element.GetChildNodes())
 	{
 		CStr ElementName(pFile->GetElementString(child.GetNodeName()));
 		if (ElementName == "effect")
 		{
 			if (Image->m_Effects)
 				LOGERROR("GUI <image> must not have more than one <effect>");
 			else
 			{
 				Image->m_Effects = 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));
 
 		if (attr_name == "add_color")
 		{
 			CGUIColor color;
 			if (!color.ParseString(this, attr.Value, 0))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, 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.emplace(attr_name, attr.Value.FromUTF8());
 	}
 
 	m_Styles.erase(name);
 	m_Styles.emplace(name, std::move(style));
 }
 
 void CGUI::Xeromyces_ReadScrollBarStyle(XMBElement Element, CXeromyces* pFile)
 {
 	SGUIScrollBarStyle scrollbar;
 	CStr name;
 
 	// Setup some defaults.
 	scrollbar.m_MinimumBarSize = 0.f;
 	// Using 1.0e10 as a substitute for infinity
 	scrollbar.m_MaximumBarSize = 1.0e10;
 	scrollbar.m_UseEdgeButtons = false;
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name = pFile->GetAttributeString(attr.Name);
 		CStr attr_value(attr.Value);
 
 		if (attr_value == "null")
 			continue;
 
 		if (attr_name == "name")
 			name = attr_value;
 		else if (attr_name == "show_edge_buttons")
 		{
 			bool b;
 			if (!GUI<bool>::ParseString(this, attr_value.FromUTF8(), b))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr_value);
 			else
 				scrollbar.m_UseEdgeButtons = b;
 		}
 		else if (attr_name == "width")
 		{
 			float f;
 			if (!GUI<float>::ParseString(this, attr_value.FromUTF8(), f))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr_value);
 			else
 				scrollbar.m_Width = f;
 		}
 		else if (attr_name == "minimum_bar_size")
 		{
 			float f;
 			if (!GUI<float>::ParseString(this, attr_value.FromUTF8(), f))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr_value);
 			else
 				scrollbar.m_MinimumBarSize = f;
 		}
 		else if (attr_name == "maximum_bar_size")
 		{
 			float f;
 			if (!GUI<float>::ParseString(this, attr_value.FromUTF8(), f))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr_value);
 			else
 				scrollbar.m_MaximumBarSize = f;
 		}
 		else if (attr_name == "sprite_button_top")
 			scrollbar.m_SpriteButtonTop = attr_value;
 		else if (attr_name == "sprite_button_top_pressed")
 			scrollbar.m_SpriteButtonTopPressed = attr_value;
 		else if (attr_name == "sprite_button_top_disabled")
 			scrollbar.m_SpriteButtonTopDisabled = attr_value;
 		else if (attr_name == "sprite_button_top_over")
 			scrollbar.m_SpriteButtonTopOver = attr_value;
 		else if (attr_name == "sprite_button_bottom")
 			scrollbar.m_SpriteButtonBottom = attr_value;
 		else if (attr_name == "sprite_button_bottom_pressed")
 			scrollbar.m_SpriteButtonBottomPressed = attr_value;
 		else if (attr_name == "sprite_button_bottom_disabled")
 			scrollbar.m_SpriteButtonBottomDisabled = attr_value;
 		else if (attr_name == "sprite_button_bottom_over")
 			scrollbar.m_SpriteButtonBottomOver = attr_value;
 		else if (attr_name == "sprite_back_vertical")
 			scrollbar.m_SpriteBackVertical = attr_value;
 		else if (attr_name == "sprite_bar_vertical")
 			scrollbar.m_SpriteBarVertical = attr_value;
 		else if (attr_name == "sprite_bar_vertical_over")
 			scrollbar.m_SpriteBarVerticalOver = attr_value;
 		else if (attr_name == "sprite_bar_vertical_pressed")
 			scrollbar.m_SpriteBarVerticalPressed = attr_value;
 	}
 
 	m_ScrollBarStyles.erase(name);
 	m_ScrollBarStyles.emplace(name, std::move(scrollbar));
 }
 
 void CGUI::Xeromyces_ReadIcon(XMBElement Element, CXeromyces* pFile)
 {
 	SGUIIcon icon;
 	CStr name;
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 		CStr attr_value(attr.Value);
 
 		if (attr_value == "null")
 			continue;
 
 		if (attr_name == "name")
 			name = attr_value;
 		else if (attr_name == "sprite")
 			icon.m_SpriteName = attr_value;
 		else if (attr_name == "size")
 		{
 			CSize size;
 			if (!GUI<CSize>::ParseString(this, attr_value.FromUTF8(), size))
 				LOGERROR("Error parsing '%s' (\"%s\") inside <icon>.", attr_name, attr_value);
 			else
 				icon.m_Size = size;
 		}
 		else if (attr_name == "cell_id")
 		{
 			int cell_id;
 			if (!GUI<int>::ParseString(this, attr_value.FromUTF8(), cell_id))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\") inside <icon>.", attr_name, attr_value);
 			else
 				icon.m_CellID = cell_id;
 		}
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 
 	m_Icons.erase(name);
 	m_Icons.emplace(name, std::move(icon));
 }
 
 void CGUI::Xeromyces_ReadTooltip(XMBElement Element, CXeromyces* pFile)
 {
 	IGUIObject* object = new CTooltip(this);
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 		CStr attr_value(attr.Value);
 
 		if (attr_name == "name")
 			object->SetName("__tooltip_" + attr_value);
 		else
 			object->SetSetting(attr_name, attr_value.FromUTF8());
 	}
 
 	AddObject(object);
 }
 
 void CGUI::Xeromyces_ReadColor(XMBElement Element, CXeromyces* pFile)
 {
 	XMBAttributeList attributes = Element.GetAttributes();
 
 	CGUIColor 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(this, 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 22678)
+++ ps/trunk/source/gui/CGUI.h	(revision 22679)
@@ -1,673 +1,642 @@
 /* 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
 {
 	// Take advantage of moving the entire map instead and avoiding unintended copies.
 	NONCOPYABLE(SGUIStyle);
 	MOVABLE(SGUIStyle);
 	SGUIStyle() = default;
 
 	std::map<CStr, CStrW> m_SettingsDefaults;
 };
 
 class JSObject; // The GUI stores a JSObject*, so needs to know that JSObject exists
 class IGUIObject;
 class CGUISpriteInstance;
-struct SGUIText;
 struct CGUIColor;
-struct SGUIText;
+class CGUIText;
 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);
 
 private:
 	// Private typedefs
 	using ConstructObjectFunction = IGUIObject* (*)(CGUI*);
 
 public:
 	CGUI(const shared_ptr<ScriptRuntime>& runtime);
 	~CGUI();
 
 	/**
 	 * Initializes the GUI, needs to be called before the GUI is used
 	 */
 	void Initialize();
 
 	/**
 	 * Performs processing that should happen every frame
 	 * (including sending the "Tick" event to scripts)
 	 */
 	void TickObjects();
 
 	/**
 	 * Sends a specified script event to every object
 	 *
 	 * @param EventName String representation of event name
 	 */
 	void SendEventToAll(const CStr& EventName);
 
 	/**
 	 * Sends a specified script event to every object
 	 *
 	 * @param EventName String representation of event name
 	 * @param paramData JS::HandleValueArray storing the arguments passed to the event handler.
 	 */
 	void SendEventToAll(const CStr& EventName, JS::HandleValueArray paramData);
 
 	/**
 	 * Displays the whole GUI
 	 */
 	void Draw();
 
 	/**
 	 * Draw GUI Sprite
 	 *
 	 * @param Sprite Object referring to the sprite (which also caches
 	 *        calculations for faster rendering)
 	 * @param CellID Number of the icon cell to use. (Ignored if this sprite doesn't
 	 *        have any images with "cell-size")
 	 * @param Z Drawing order, depth value
 	 * @param Rect Position and Size
 	 * @param Clipping The sprite shouldn't be drawn outside this rectangle
 	 */
 	void DrawSprite(const CGUISpriteInstance& Sprite, int CellID, const float& Z, const CRect& Rect, const CRect& Clipping = CRect());
 
 	/**
-	 * Draw a SGUIText object
-	 *
-	 * @param Text Text object.
-	 * @param DefaultColor Color used if no tag applied.
-	 * @param pos position
-	 * @param z z value.
-	 * @param clipping
-	 */
-	void DrawText(SGUIText& Text, const CGUIColor& DefaultColor, const CPos& pos, const float& z, const CRect& clipping);
-
-	/**
 	 * Clean up, call this to clean up all memory allocated
 	 * within the GUI.
 	 */
 	void Destroy();
 
 	/**
 	 * The replacement of Process(), handles an SDL_Event_
 	 *
 	 * @param ev SDL Event, like mouse/keyboard input
 	 */
 	InReaction HandleEvent(const SDL_Event_* ev);
 
 	/**
 	 * Load a GUI XML file into the GUI.
 	 *
 	 * <b>VERY IMPORTANT!</b> All \<styles\>-files must be read before
 	 * everything else!
 	 *
 	 * @param Filename Name of file
 	 * @param Paths Set of paths; all XML and JS files loaded will be added to this
 	 */
 	void LoadXmlFile(const VfsPath& Filename, boost::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Return the object which is an ancestor of every other GUI object.
 	 */
 	IGUIObject* GetBaseObject() const { return m_BaseObject; };
 
 	/**
 	 * Checks if object exists and return true or false accordingly
 	 *
 	 * @param Name String name of object
 	 * @return true if object exists
 	 */
 	bool ObjectExists(const CStr& Name) const;
 
 	/**
 	 * Returns the GUI object with the desired name, or 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;
 
 	/**
 	 * Returns the current screen coordinates of the cursor.
 	 */
 	const CPos& GetMousePos() const { return m_MousePos; };
 
 	/**
 	 * Returns the currently pressed mouse buttons.
 	 */
 	const unsigned int& GetMouseButtons() { return m_MouseButtons; };
 
 	const SGUIScrollBarStyle* GetScrollBarStyle(const CStr& style) const;
 
 	/**
 	 * The GUI needs to have all object types inputted and
 	 * their constructors. Also it needs to associate a type
 	 * by a string name of the type.
 	 *
 	 * To add a type:
 	 * @code
 	 * AddObjectType("button", &CButton::ConstructObject);
 	 * @endcode
 	 *
 	 * @param str Reference name of object type
 	 * @param pFunc Pointer of function ConstuctObject() in the object
 	 *
 	 * @see CGUI#ConstructObject()
 	 */
 	void AddObjectType(const CStr& str, ConstructObjectFunction pFunc) { m_ObjectTypes[str] = pFunc; }
 
 	/**
 	 * Update Resolution, should be called every time the resolution
 	 * of the OpenGL screen has been changed, this is because it needs
 	 * to re-cache all its actual sizes
 	 *
 	 * Needs no input since screen resolution is global.
 	 *
 	 * @see IGUIObject#UpdateCachedSize()
 	 */
 	void UpdateResolution();
 
 	/**
-	 * 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 HasIcon(const CStr& name) const { return (m_Icons.count(name) != 0); }
 
 	/**
 	 * Get Icon (a const reference, can never be changed)
 	 */
 	const SGUIIcon& GetIcon(const CStr& name) const { return m_Icons.at(name); }
 
 	/**
 	 * Check if a style exists
 	 */
 	bool HasStyle(const CStr& name) const { return (m_Styles.count(name) != 0); }
 
 	/**
 	 * Get Style if it exists, otherwise throws an exception.
 	 */
 	const SGUIStyle& GetStyle(const CStr& name) const { return m_Styles.at(name); }
 
 	/**
 	 * Get pre-defined color (if it exists)
 	 * Returns false if it fails.
 	 */
 	bool GetPreDefinedColor(const CStr& name, CGUIColor& Output) const;
 
 	shared_ptr<ScriptInterface> GetScriptInterface() { return m_ScriptInterface; };
 	JS::Value GetGlobalObject() { return m_ScriptInterface->GetGlobalObject(); };
 
 	/**
 	 * Updates the object pointers, needs to be called each
 	 * time an object has been added or removed.
 	 *
 	 * This function is atomic, meaning if it throws anything, it will
 	 * have seen it through that nothing was ultimately changed.
 	 *
 	 * @throws PSERROR_GUI that is thrown from IGUIObject::AddToPointersMap().
 	 */
 	void UpdateObjects();
 
 private:
 	/**
 	 * Adds an object to the GUI's object database
 	 * Private, since you can only add objects through
 	 * XML files. Why? Because it enables the GUI to
 	 * be much more encapsulated and safe.
 	 *
 	 * @throws	Rethrows PSERROR_GUI from IGUIObject::AddChild().
 	 */
 	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);
 
 public:
 	/**
 	 * Get Focused Object.
 	 */
 	IGUIObject* GetFocusedObject() { return m_FocusedObject; }
 
 	/**
 	 * Change focus to new object.
 	 * Will send LOST_FOCUS/GOT_FOCUS messages as appropriate.
 	 * pObject can be NULL to remove all focus.
 	 */
 	void SetFocusedObject(IGUIObject* pObject);
 
 private:
 	//--------------------------------------------------------
 	/** @name XML Reading Xeromyces specific subroutines
 	 *
 	 * These does not throw!
 	 * Because when reading in XML files, it won't be fatal
 	 * if an error occurs, perhaps one particular object
 	 * fails, but it'll still continue reading in the next.
 	 * All Error are reported with ReportParseError
 	 */
 	//--------------------------------------------------------
 
 	/*
 		Xeromyces_* functions tree
 		<objects> (ReadRootObjects)
 		 |
 		 +-<script> (ReadScript)
 		 |
 		 +-<object> (ReadObject)
 			|
 			+-<action>
 			|
 			+-Optional Type Extensions (IGUIObject::ReadExtendedElement) TODO
 			|
 			+-<<object>> *recursive*
 
 
 		<styles> (ReadRootStyles)
 		 |
 		 +-<style> (ReadStyle)
 
 
 		<sprites> (ReadRootSprites)
 		 |
 		 +-<sprite> (ReadSprite)
 			|
 			+-<image> (ReadImage)
 
 
 		<setup> (ReadRootSetup)
 		 |
 		 +-<tooltip> (ReadToolTip)
 		 |
 		 +-<scrollbar> (ReadScrollBar)
 		 |
 		 +-<icon> (ReadIcon)
 		 |
 		 +-<color> (ReadColor)
 	*/
 	//@{
 
 	// Read Roots
 
 	/**
 	 * Reads in the root element \<objects\> (the DOMElement).
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the objects-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param Paths		Collects the set of all XML/JS files that are loaded
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadRootObjects(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Reads in the root element \<sprites\> (the DOMElement).
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the sprites-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadRootSprites(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the root element \<styles\> (the DOMElement).
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the styles-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadRootStyles(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the root element \<setup\> (the DOMElement).
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the setup-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadRootSetup(XMBElement Element, CXeromyces* pFile);
 
 	// Read Subs
 
 	/**
 	 * Notice! Recursive function!
 	 *
 	 * Read in an \<object\> (the XMBElement) and stores it
 	 * as a child in the pParent.
 	 *
 	 * It will also check the object's children and call this function
 	 * on them too. Also it will call all other functions that reads
 	 * in other stuff that can be found within an object. Check the
 	 * tree in the beginning of this class' Xeromyces_* section.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the object-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param pParent	Parent to add this object as child in.
 	 * @param NameSubst	A set of substitution strings that will be
 	 * 					applied to all object names within this object.
 	 * @param Paths		Output set of file paths that this GUI object
 	 * 					relies on.
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadObject(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths, u32 nesting_depth);
 
 	/**
 	 * Reads in the element \<repeat\>, which repeats its child \<object\>s
 	 * 'count' times, replacing the string "[n]" (or the value of the attribute
 	 * 'var' enclosed in square brackets) in its descendants' names with "[0]",
 	 * "[1]", etc.
 	 */
 	void Xeromyces_ReadRepeat(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths, u32 nesting_depth);
 
 	/**
 	 * Reads in the element \<script\> (the XMBElement) and executes
 	 * the script's code.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the script-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param Paths		Output set of file paths that this script is loaded from.
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadScript(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Reads in the element \<sprite\> (the XMBElement) and stores the
 	 * result in a new CGUISprite.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the sprite-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadSprite(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<image\> (the XMBElement) and stores the
 	 * result within the CGUISprite.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the image-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param parent	Parent sprite.
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadImage(XMBElement Element, CXeromyces* pFile, CGUISprite& parent);
 
 	/**
 	 * Reads in the element \<effect\> (the XMBElement) and stores the
 	 * result within the SGUIImageEffects.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the image-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param effects	Effects object to add this effect to.
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadEffects(XMBElement Element, CXeromyces* pFile, SGUIImageEffects& effects);
 
 	/**
 	 * Reads in the element \<style\> (the XMBElement) and stores the
 	 * result in m_Styles.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the style-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadStyle(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<scrollbar\> (the XMBElement) and stores the
 	 * result in m_ScrollBarStyles.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the scrollbar-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadScrollBarStyle(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<icon\> (the XMBElement) and stores the
 	 * result in m_Icons.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the scrollbar-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadIcon(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<tooltip\> (the XMBElement) and stores the
 	 * result as an object with the name __tooltip_#.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the scrollbar-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadTooltip(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<color\> (the XMBElement) and stores the
 	 * result in m_PreDefinedColors
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the scrollbar-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadColor(XMBElement Element, CXeromyces* pFile);
 
 	//@}
 
 private:
 
 	// Variables
 
 	//--------------------------------------------------------
 	/** @name Miscellaneous */
 	//--------------------------------------------------------
 	//@{
 
 	shared_ptr<ScriptInterface> m_ScriptInterface;
 
 	/**
 	 * don't want to pass this around with the
 	 * ChooseMouseOverAndClosest broadcast -
 	 * we'd need to pack this and pNearest in a struct
 	 */
 	CPos m_MousePos;
 
 	/**
 	 * Indicates which buttons are pressed (bit 0 = LMB,
 	 * bit 1 = RMB, bit 2 = MMB)
 	 */
 	unsigned int m_MouseButtons;
 
 	// Tooltip
 	GUITooltip m_Tooltip;
 
 	/**
 	 * This is a bank of custom colors, it is simply a look up table that
 	 * will return a color object when someone inputs the name of that
 	 * color. Of course the colors have to be declared in XML, there are
 	 * no hard-coded values.
 	 */
 	std::map<CStr, CGUIColor> m_PreDefinedColors;
 
 	//@}
 	//--------------------------------------------------------
 	/** @name Objects */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Base Object, all its children are considered parentless
 	 * because this is not a real object per se.
 	 */
 	IGUIObject* m_BaseObject;
 
 	/**
 	 * Focused object!
 	 * Say an input box that is selected. That one is focused.
 	 * There can only be one focused object.
 	 */
 	IGUIObject* m_FocusedObject;
 
 	/**
 	 * Just pointers for fast name access, each object
 	 * is really constructed within its parent for easy
 	 * recursive management.
 	 * Notice m_BaseObject won't belong here since it's
 	 * not considered a real object.
 	 */
 	map_pObjects m_pAllObjects;
 
 	/**
 	 * Number of object that has been given name automatically.
 	 * the name given will be '__internal(#)', the number (#)
 	 * being this variable. When an object's name has been set
 	 * as followed, the value will increment.
 	 */
 	int m_InternalNameNumber;
 
 	/**
 	 * Function pointers to functions that constructs
 	 * IGUIObjects by name... For instance m_ObjectTypes["button"]
 	 * is filled with a function that will "return new CButton();"
 	 */
 	std::map<CStr, ConstructObjectFunction>	m_ObjectTypes;
 
 	/**
 	 * Map from hotkey names to objects that listen to the hotkey.
 	 * (This is an optimisation to avoid recursing over the whole GUI
 	 * tree every time a hotkey is pressed).
 	 * Currently this is only set at load time - dynamic changes to an
 	 * object's hotkey property will be ignored.
 	 */
 	std::map<CStr, std::vector<IGUIObject*> > m_HotkeyObjects;
 
 	//--------------------------------------------------------
 	//	Databases
 	//	These are loaded from XML files and marked as noncopyable and const to
 	//	rule out unintentional modification and copy, especially during Draw calls.
 	//--------------------------------------------------------
 
 	// Sprites
 	std::map<CStr, const CGUISprite*> m_Sprites;
 
 	// Styles
 	std::map<CStr, const SGUIStyle> m_Styles;
 
 	// Scroll-bar styles
 	std::map<CStr, const SGUIScrollBarStyle> m_ScrollBarStyles;
 
 	// Icons
 	std::map<CStr, const SGUIIcon> m_Icons;
 };
 
 #endif // INCLUDED_CGUI
Index: ps/trunk/source/gui/CGUIString.cpp
===================================================================
--- ps/trunk/source/gui/CGUIString.cpp	(revision 22678)
+++ ps/trunk/source/gui/CGUIString.cpp	(revision 22679)
@@ -1,472 +1,474 @@
 /* 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 <algorithm>
+#include "CGUIString.h"
 
+#include "graphics/FontMetrics.h"
 #include "gui/GUI.h"
 #include "lib/utf8.h"
-#include "graphics/FontMetrics.h"
 #include "ps/CLogger.h"
 
+#include <algorithm>
+#include <array>
 
 // List of word delimiter bounds
 // The list contains ranges of word delimiters. The odd indexed chars are the start
 // of a range, the even are the end of a range. The list must be sorted in INCREASING ORDER
 static const int NUM_WORD_DELIMITERS = 4*2;
 static const u16 WordDelimiters[NUM_WORD_DELIMITERS] = {
 	' '   , ' ',    // spaces
 	'-'   , '-',    // hyphens
 	0x3000, 0x31FF, // ideographic symbols
 	0x3400, 0x9FFF
 // TODO add unicode blocks of other languages that don't use spaces
 };
 
 void CGUIString::SFeedback::Reset()
 {
 	m_Images[Left].clear();
 	m_Images[Right].clear();
 	m_TextCalls.clear();
 	m_SpriteCalls.clear();
 	m_Size = CSize();
 	m_NewLine = false;
 }
 
 void CGUIString::GenerateTextCall(const CGUI* pGUI, SFeedback& Feedback, CStrIntern DefaultFont, const int& from, const int& to, const bool FirstLine, const IGUIObject* pObject) const
 {
 	// Reset width and height, because they will be determined with incrementation
 	//  or comparisons.
 	Feedback.Reset();
 
 	// Check out which text chunk this is within.
 	for (const TextChunk& textChunk : m_TextChunks)
 	{
 		// Get the area that is overlapped by both the TextChunk and
 		//  by the from/to inputted.
 		int _from = std::max(from, textChunk.m_From);
 		int _to = std::min(to, textChunk.m_To);
 
 		// If from is larger than to, then they are not overlapping
 		if (_to == _from && textChunk.m_From == textChunk.m_To)
 		{
 			// These should never be able to have more than one tag.
 			ENSURE(textChunk.m_Tags.size() == 1);
 
 			// Icons and images are placed on exactly one position
 			//  in the words-list, and they can be counted twice if placed
 			//  on an edge. But there is always only one logical preference
 			//  that we want. This check filters the unwanted.
 
 			// it's in the end of one word, and the icon
 			//  should really belong to the beginning of the next one
 			if (_to == to && to >= 1 && to < (int)m_RawString.length())
 			{
 				if (m_RawString[to-1] == ' ' ||
 				    m_RawString[to-1] == '-' ||
 				    m_RawString[to-1] == '\n')
 					continue;
 			}
 			// This std::string is just a break
 			if (_from == from && from >= 1)
 			{
 				if (m_RawString[from] == '\n' &&
 				    m_RawString[from-1] != '\n' &&
 				    m_RawString[from-1] != ' ' &&
 				    m_RawString[from-1] != '-')
 					continue;
 			}
 
 			const TextChunk::Tag& tag = textChunk.m_Tags[0];
 			ENSURE(tag.m_TagType == TextChunk::Tag::TAG_IMGLEFT ||
 			       tag.m_TagType == TextChunk::Tag::TAG_IMGRIGHT ||
 			       tag.m_TagType == TextChunk::Tag::TAG_ICON);
 
 			const std::string& path = utf8_from_wstring(tag.m_TagValue);
 			if (!pGUI->HasIcon(path))
 			{
 				if (pObject)
 					LOGERROR("Trying to use an icon, imgleft or imgright-tag with an undefined icon (\"%s\").", path.c_str());
 				continue;
 			}
 
 			switch (tag.m_TagType)
 			{
 			case TextChunk::Tag::TAG_IMGLEFT:
 				Feedback.m_Images[SFeedback::Left].push_back(path);
 				break;
 			case TextChunk::Tag::TAG_IMGRIGHT:
 				Feedback.m_Images[SFeedback::Right].push_back(path);
 				break;
 			case TextChunk::Tag::TAG_ICON:
 			{
 				// We'll need to setup a text-call that will point
 				//  to the icon, this is to be able to iterate
 				//  through the text-calls without having to
 				//  complex the structure virtually for nothing more.
-				SGUIText::STextCall TextCall;
+				CGUIText::STextCall TextCall;
 
 				// Also add it to the sprites being rendered.
-				SGUIText::SSpriteCall SpriteCall;
+				CGUIText::SSpriteCall SpriteCall;
 
 				// Get Icon from icon database in pGUI
 				const SGUIIcon& icon = pGUI->GetIcon(path);
 
 				const CSize& size = icon.m_Size;
 
 				// append width, and make maximum height the height.
 				Feedback.m_Size.cx += size.cx;
 				Feedback.m_Size.cy = std::max(Feedback.m_Size.cy, size.cy);
 
 				// These are also needed later
 				TextCall.m_Size = size;
 				SpriteCall.m_Area = size;
 
 				// Handle additional attributes
 				for (const TextChunk::Tag::TagAttribute& tagAttrib : tag.m_TagAttributes)
 				{
 					if (tagAttrib.attrib == L"displace" && !tagAttrib.value.empty())
 					{
 						// Displace the sprite
 						CSize displacement;
 						// Parse the value
 						if (!GUI<CSize>::ParseString(pGUI, tagAttrib.value, displacement))
 							LOGERROR("Error parsing 'displace' value for tag [ICON]");
 						else
 							SpriteCall.m_Area += displacement;
 					}
 					else if (tagAttrib.attrib == L"tooltip")
 						SpriteCall.m_Tooltip = tagAttrib.value;
 					else if (tagAttrib.attrib == L"tooltip_style")
 						SpriteCall.m_TooltipStyle = tagAttrib.value;
 				}
 
 				SpriteCall.m_Sprite = icon.m_SpriteName;
 				SpriteCall.m_CellID = icon.m_CellID;
 
 				// Add sprite call
 				Feedback.m_SpriteCalls.push_back(std::move(SpriteCall));
 
 				// Finalize text call
 				TextCall.m_pSpriteCall = &Feedback.m_SpriteCalls.back();
 
 				// Add text call
 				Feedback.m_TextCalls.emplace_back(std::move(TextCall));
 
 				break;
 			}
 			NODEFAULT;
 			}
 		}
 		else if (_to > _from && !Feedback.m_NewLine)
 		{
-			SGUIText::STextCall TextCall;
+			CGUIText::STextCall TextCall;
 
 			// Set defaults
 			TextCall.m_Font = DefaultFont;
 			TextCall.m_UseCustomColor = false;
 
 			TextCall.m_String = m_RawString.substr(_from, _to-_from);
 
 			// Go through tags and apply changes.
 			for (const TextChunk::Tag& tag : textChunk.m_Tags)
 			{
 				switch (tag.m_TagType)
 				{
 				case TextChunk::Tag::TAG_COLOR:
 					TextCall.m_UseCustomColor = true;
 
 					if (!GUI<CGUIColor>::ParseString(pGUI, tag.m_TagValue, TextCall.m_Color) && pObject)
 						LOGERROR("Error parsing the value of a [color]-tag in GUI text when reading object \"%s\".", pObject->GetPresentableName().c_str());
 					break;
 				case TextChunk::Tag::TAG_FONT:
 					// TODO Gee: (2004-08-15) Check if Font exists?
 					TextCall.m_Font = CStrIntern(utf8_from_wstring(tag.m_TagValue));
 					break;
 				default:
 					LOGERROR("Encountered unexpected tag applied to text");
 					break;
 				}
 			}
 
 			// Calculate the size of the font
 			CSize size;
 			int cx, cy;
 			CFontMetrics font (TextCall.m_Font);
 			font.CalculateStringSize(TextCall.m_String.c_str(), cx, cy);
 			// For anything other than the first line, the line spacing
 			// needs to be considered rather than just the height of the text
 			if (!FirstLine)
 				cy = font.GetLineSpacing();
 
 			size.cx = (float)cx;
 			size.cy = (float)cy;
 
 			// Append width, and make maximum height the height.
 			Feedback.m_Size.cx += size.cx;
 			Feedback.m_Size.cy = std::max(Feedback.m_Size.cy, size.cy);
 
 			// These are also needed later
 			TextCall.m_Size = size;
 
 			if (!TextCall.m_String.empty() && TextCall.m_String[0] == '\n')
 				Feedback.m_NewLine = true;
 
 			// Add text-chunk
 			Feedback.m_TextCalls.emplace_back(std::move(TextCall));
 		}
 	}
 }
 
 bool CGUIString::TextChunk::Tag::SetTagType(const CStrW& tagtype)
 {
 	TagType t = GetTagType(tagtype);
 	if (t == TAG_INVALID)
 		return false;
 
 	m_TagType = t;
 	return true;
 }
 
 CGUIString::TextChunk::Tag::TagType CGUIString::TextChunk::Tag::GetTagType(const CStrW& tagtype) const
 {
 	if (tagtype == L"color")
 		return TAG_COLOR;
 	if (tagtype == L"font")
 		return TAG_FONT;
 	if (tagtype == L"icon")
 		return TAG_ICON;
 	if (tagtype == L"imgleft")
 		return TAG_IMGLEFT;
 	if (tagtype == L"imgright")
 		return TAG_IMGRIGHT;
 
 	return TAG_INVALID;
 }
 
 void CGUIString::SetValue(const CStrW& str)
 {
 	m_OriginalString = str;
 
 	m_TextChunks.clear();
 	m_Words.clear();
 	m_RawString.clear();
 
 	// Current Text Chunk
 	CGUIString::TextChunk CurrentTextChunk;
 	CurrentTextChunk.m_From = 0;
 
 	int l = str.length();
 	int rawpos = 0;
 	CStrW tag;
 	std::vector<CStrW> tags;
 	bool closing = false;
 	for (int p = 0; p < l; ++p)
 	{
 		TextChunk::Tag tag_;
 		switch (str[p])
 		{
 		case L'[':
 			CurrentTextChunk.m_To = rawpos;
 			// Add the current chunks if it is not empty
 			if (CurrentTextChunk.m_From != rawpos)
 				m_TextChunks.push_back(CurrentTextChunk);
 			CurrentTextChunk.m_From = rawpos;
 
 			closing = false;
 			if (++p == l)
 			{
 				LOGERROR("Partial tag at end of string '%s'", utf8_from_wstring(str));
 				break;
 			}
 			if (str[p] == L'/')
 			{
 				closing = true;
 				if (tags.empty())
 				{
 					LOGERROR("Encountered closing tag without having any open tags. At %d in '%s'", p, utf8_from_wstring(str));
 					break;
 				}
 				if (++p == l)
 				{
 					LOGERROR("Partial closing tag at end of string '%s'", utf8_from_wstring(str));
 					break;
 				}
 			}
 			tag.clear();
 			// Parse tag
 			for (; p < l && str[p] != L']'; ++p)
 			{
 				CStrW name, param;
 				switch (str[p])
 				{
 				case L' ':
 					if (closing) // We still parse them to make error handling cleaner
 						LOGERROR("Closing tags do not support parameters (at pos %d '%s')", p, utf8_from_wstring(str));
 
 					// parse something="something else"
 					for (++p; p < l && str[p] != L'='; ++p)
 						name.push_back(str[p]);
 
 					if (p == l)
 					{
 						LOGERROR("Parameter without value at pos %d '%s'", p, utf8_from_wstring(str));
 						break;
 					}
 					FALLTHROUGH;
 				case L'=':
 					// parse a quoted parameter
 					if (closing) // We still parse them to make error handling cleaner
 						LOGERROR("Closing tags do not support parameters (at pos %d '%s')", p, utf8_from_wstring(str));
 
 					if (++p == l)
 					{
 						LOGERROR("Expected parameter, got end of string '%s'", utf8_from_wstring(str));
 						break;
 					}
 					if (str[p] != L'"')
 					{
 						LOGERROR("Unquoted parameters are not supported (at pos %d '%s')", p, utf8_from_wstring(str));
 						break;
 					}
 					for (++p; p < l && str[p] != L'"'; ++p)
 					{
 						switch (str[p])
 						{
 						case L'\\':
 							if (++p == l)
 							{
 								LOGERROR("Escape character at end of string '%s'", utf8_from_wstring(str));
 								break;
 							}
 							// NOTE: We do not support \n in tag parameters
 							FALLTHROUGH;
 						default:
 							param.push_back(str[p]);
 						}
 					}
 
 					if (!name.empty())
 					{
 						TextChunk::Tag::TagAttribute a = {name, param};
 						tag_.m_TagAttributes.push_back(a);
 					}
 					else
 						tag_.m_TagValue = param;
 					break;
 				default:
 					tag.push_back(str[p]);
 					break;
 				}
 			}
 
 			if (!tag_.SetTagType(tag))
 			{
 				LOGERROR("Invalid tag '%s' at %d in '%s'", utf8_from_wstring(tag), p, utf8_from_wstring(str));
 				break;
 			}
 			if (!closing)
 			{
 				if (tag_.m_TagType == TextChunk::Tag::TAG_IMGRIGHT
 					|| tag_.m_TagType == TextChunk::Tag::TAG_IMGLEFT
 					|| tag_.m_TagType == TextChunk::Tag::TAG_ICON)
 				{
 					TextChunk FreshTextChunk = { rawpos, rawpos };
 					FreshTextChunk.m_Tags.push_back(tag_);
 					m_TextChunks.push_back(FreshTextChunk);
 				}
 				else
 				{
 					tags.push_back(tag);
 					CurrentTextChunk.m_Tags.push_back(tag_);
 				}
 			}
 			else
 			{
 				if (tag != tags.back())
 				{
 					LOGERROR("Closing tag '%s' does not match last opened tag '%s' at %d in '%s'", utf8_from_wstring(tag), utf8_from_wstring(tags.back()), p, utf8_from_wstring(str));
 					break;
 				}
 
 				tags.pop_back();
 				CurrentTextChunk.m_Tags.pop_back();
 			}
 			break;
 		case L'\\':
 			if (++p == l)
 			{
 				LOGERROR("Escape character at end of string '%s'", utf8_from_wstring(str));
 				break;
 			}
 			if (str[p] == L'n')
 			{
 				++rawpos;
 				m_RawString.push_back(L'\n');
 				break;
 			}
 			FALLTHROUGH;
 		default:
 			++rawpos;
 			m_RawString.push_back(str[p]);
 			break;
 		}
 	}
 
 	// Add the chunk after the last tag
 	if (CurrentTextChunk.m_From != rawpos)
 	{
 		CurrentTextChunk.m_To = rawpos;
 		m_TextChunks.push_back(CurrentTextChunk);
 	}
 
 
 	// Add a delimiter at start and at end, it helps when
 	//  processing later, because we don't have make exceptions for
 	//  those cases.
 	m_Words.push_back(0);
 
 	// Add word boundaries in increasing order
 	for (u32 i = 0; i < m_RawString.length(); ++i)
 	{
 		wchar_t c = m_RawString[i];
 		if (c == '\n')
 		{
 			m_Words.push_back((int)i);
 			m_Words.push_back((int)i+1);
 			continue;
 		}
 		for (int n = 0; n < NUM_WORD_DELIMITERS; n += 2)
 		{
 			if (c <= WordDelimiters[n+1])
 			{
 				if (c >= WordDelimiters[n])
 					m_Words.push_back((int)i+1);
 				// assume the WordDelimiters list is stored in increasing order
 				break;
 			}
 		}
 	}
 
 	m_Words.push_back((int)m_RawString.length());
 
 	// Remove duplicates (only if larger than 2)
 	if (m_Words.size() <= 2)
 		return;
 
 	m_Words.erase(std::unique(m_Words.begin(), m_Words.end()), m_Words.end());
 }
Index: ps/trunk/source/gui/CGUIString.h
===================================================================
--- ps/trunk/source/gui/CGUIString.h	(revision 22678)
+++ ps/trunk/source/gui/CGUIString.h	(revision 22679)
@@ -1,229 +1,220 @@
 /* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-/*
- * GUI text, handles text stuff
- *
- * --Overview--
- * Mainly contains struct SGUIText and friends.
- * Actual text processing is made in CGUI::GenerateText()
- *
- * --More info--
- * Check GUI.h
- *
- */
-
 #ifndef INCLUDED_CGUISTRING
 #define INCLUDED_CGUISTRING
 
-#include <list>
-
 #include "gui/CGUISprite.h"
-#include "gui/GUItext.h"
+#include "gui/CGUIText.h"
 #include "ps/CStrIntern.h"
 
+#include <array>
+#include <list>
+#include <vector>
+
 class CGUI;
 
 /**
  * String class, substitute for CStr, but that parses
  * the tags and builds up a list of all text that will
  * be different when outputted.
  *
- * The difference between CGUIString and SGUIText is that
+ * The difference between CGUIString and CGUIText is that
  * CGUIString is a string-class that parses the tags
- * when the value is set. The SGUIText is just a container
+ * when the value is set. The CGUIText is just a container
  * which stores the positions and settings of all text-calls
  * that will have to be made to the Renderer.
  */
 class CGUIString
 {
 public:
 	/**
 	 * A chunk of text that represents one call to the renderer.
 	 * In other words, all text in one chunk, will be drawn
 	 * exactly with the same settings.
 	 */
 	struct TextChunk
 	{
 		/**
 		 * A tag looks like this "Hello [b]there[/b] little"
 		 */
 		struct Tag
 		{
 			/**
 			 * Tag Type
 			 */
 			enum TagType
 			{
 				TAG_B,
 				TAG_I,
 				TAG_FONT,
 				TAG_SIZE,
 				TAG_COLOR,
 				TAG_IMGLEFT,
 				TAG_IMGRIGHT,
 				TAG_ICON,
 				TAG_INVALID
 			};
 
 			struct TagAttribute
 			{
 				std::wstring attrib;
 				std::wstring value;
 			};
 
 			/**
 			 * Set tag from string
 			 *
 			 * @param tagtype TagType by string, like 'img' for [img]
 			 * @return True if m_TagType was set.
 			 */
 			bool SetTagType(const CStrW& tagtype);
 			TagType GetTagType(const CStrW& tagtype) const;
 
 
 			/**
 			 * In [b="Hello"][/b]
 			 * m_TagType is TAG_B
 			 */
 			TagType m_TagType;
 
 			/**
 			 * In [b="Hello"][/b]
 			 * m_TagValue is 'Hello'
 			 */
 			std::wstring m_TagValue;
 
 			/**
 			 * Some tags need an additional attributes
 			 */
 			std::vector<TagAttribute> m_TagAttributes;
 		};
 
 		/**
 		 * m_From and m_To is the range of the string
 		 */
 		int m_From, m_To;
 
 		/**
 		 * Tags that are present. [a][b]
 		 */
 		std::vector<Tag> m_Tags;
 	};
 
 	/**
 	 * All data generated in GenerateTextCall()
 	 */
 	struct SFeedback
 	{
 		// Avoid copying the vector and list containers.
 		NONCOPYABLE(SFeedback);
 		MOVABLE(SFeedback);
 		SFeedback() = default;
 
 		// Constants
 		static const int Left = 0;
 		static const int Right = 1;
 
 		/**
 		 * Reset all member data.
 		 */
 		void Reset();
 
 		/**
 		 * Image stacks, for left and right floating images.
 		 */
-		std::vector<CStr> m_Images[2]; // left and right
+		std::array<std::vector<CStr>, 2> m_Images; // left and right
 
 		/**
 		 * Text and Sprite Calls.
 		 */
-		std::vector<SGUIText::STextCall> m_TextCalls;
-		std::list<SGUIText::SSpriteCall> m_SpriteCalls; // list for consistent mem addresses
-														//  so that we can point to elements.
+		std::vector<CGUIText::STextCall> m_TextCalls;
+
+		// list for consistent mem addresses so that we can point to elements.
+		std::list<CGUIText::SSpriteCall> m_SpriteCalls;
 
 		/**
 		 * Width and Height *feedback*
 		 */
 		CSize m_Size;
 
 		/**
 		 * If the word inputted was a new line.
 		 */
 		bool m_NewLine;
 	};
 
 	/**
 	 * Set the value, the string will automatically
 	 * be parsed when set.
 	 */
 	void SetValue(const CStrW& str);
 
 	/**
 	 * Get String, with tags
 	 */
 	const CStrW& GetOriginalString() const { return m_OriginalString; }
 
 	/**
 	 * Get String, stripped of tags
 	 */
 	const CStrW& GetRawString() const { return m_RawString; }
 
 	/**
 	 * Generate Text Call from specified range. The range
 	 * must span only within ONE TextChunk though. Otherwise
 	 * it can't be fit into a single Text Call
 	 *
 	 * Notice it won't make it complete, you will have to add
 	 * X/Y values and such.
 	 *
 	 * @param pGUI Pointer to CGUI object making this call, for e.g. icon retrieval.
 	 * @param Feedback contains all info that is generated.
 	 * @param DefaultFont Default Font
 	 * @param from From character n,
 	 * @param to to character n.
 	 * @param FirstLine Whether this is the first line of text, to calculate its height correctly
 	 * @param pObject Only for Error outputting, optional! If NULL
 	 *		  then no Errors will be reported! Useful when you need
 	 *		  to make several GenerateTextCall in different phases,
 	 *		  it avoids duplicates.
 	 */
 	void GenerateTextCall(const CGUI* pGUI, SFeedback& Feedback, CStrIntern DefaultFont, const int& from, const int& to, const bool FirstLine, const IGUIObject* pObject = NULL) const;
 
 	/**
 	 * Words
 	 */
 	std::vector<int> m_Words;
 
 private:
 	/**
 	 * TextChunks
 	 */
 	std::vector<TextChunk> m_TextChunks;
 
 	/**
 	 * The full raw string. Stripped of tags.
 	 */
 	CStrW m_RawString;
 
 	/**
 	 * The original string value passed to SetValue.
 	 */
 	CStrW m_OriginalString;
 };
 
 #endif // INCLUDED_CGUISTRING
Index: ps/trunk/source/gui/CGUIText.cpp
===================================================================
--- ps/trunk/source/gui/CGUIText.cpp	(nonexistent)
+++ ps/trunk/source/gui/CGUIText.cpp	(revision 22679)
@@ -0,0 +1,471 @@
+/* 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 "CGUIText.h"
+
+#include "gui/CGUIString.h"
+#include "gui/IGUIObject.h"
+#include "graphics/FontMetrics.h"
+#include "graphics/ShaderManager.h"
+#include "renderer/Renderer.h"
+
+#include <math.h>
+
+extern int g_xres, g_yres;
+extern float g_GuiScale;
+
+// TODO Gee: CRect => CPoint ?
+void SGenerateTextImage::SetupSpriteCall(
+	const bool Left, CGUIText::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;
+}
+
+CGUIText::CGUIText(const CGUI* pGUI, const CGUIString& string, const CStrW& FontW, const float Width, const float BufferZone, const IGUIObject* pObject)
+{
+	if (string.m_Words.empty())
+		return;
+
+	CStrIntern Font(FontW.ToUTF8());
+	float x = BufferZone, y = BufferZone; // drawing pointer
+	int from = 0;
+
+	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.
+	SGenerateTextImages Images;
+	int pos_last_img = -1;	// Position in the string where last img (either left or right) were encountered.
+							//  in order to avoid duplicate processing.
+
+	// 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 = 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 < static_cast<int>(string.m_Words.size()) - 1; ++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(pGUI, Feedback, Font, string.m_Words[i], string.m_Words[i+1], FirstLine);
+
+		SetupSpriteCalls(pGUI, Feedback.m_Images, y, Width, BufferZone, i, pos_last_img, Images);
+
+		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 (((Width != 0 && (x > Width - BufferZone || Feedback.m_NewLine)) || i == static_cast<int>(string.m_Words.size()) - 2) &&
+		    ProcessLine(pGUI, string, Font, pObject, Images, align, prelim_line_height, Width, BufferZone, FirstLine, x, y, i, from))
+			return;
+	}
+}
+
+// Loop through our images queues, to see if images have been added.
+void CGUIText::SetupSpriteCalls(
+	const CGUI* pGUI,
+	const std::array<std::vector<CStr>, 2>& FeedbackImages,
+	const float y,
+	const float Width,
+	const float BufferZone,
+	const int i,
+	const int pos_last_img,
+	SGenerateTextImages& Images)
+{
+	// Check if this has already been processed.
+	//  Also, floating images are only applicable if Word-Wrapping is on
+	if (Width == 0 || i <= pos_last_img)
+		return;
+
+	// Loop left/right
+	for (int j = 0; j < 2; ++j)
+		for (const CStr& imgname : FeedbackImages[j])
+		{
+			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;
+
+			const SGUIIcon& icon = pGUI->GetIcon(imgname);
+			Image.SetupSpriteCall(j == CGUIString::SFeedback::Left, SpriteCall, Width, _y, icon.m_Size, icon.m_SpriteName, BufferZone, icon.m_CellID);
+
+			// Check if image is the lowest thing.
+			m_Size.cy = std::max(m_Size.cy, Image.m_YTo);
+
+			Images[j].emplace_back(Image);
+			m_SpriteCalls.emplace_back(std::move(SpriteCall));
+		}
+}
+
+// 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.
+void CGUIText::ComputeLineSize(
+	const CGUI* pGUI,
+	const CGUIString& string,
+	const CStrIntern& Font,
+	const bool FirstLine,
+	const float Width,
+	const float width_range_to,
+	const int i,
+	const int temp_from,
+	float& x,
+	CSize& line_size) const
+{
+	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;
+
+		// 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(pGUI, Feedback2, Font, string.m_Words[j], string.m_Words[j+1], FirstLine);
+
+		// Append X value.
+		x += Feedback2.m_Size.cx;
+
+		if (Width != 0 && 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_size.cx -= currentFont.GetCharacterWidth(*L" ");
+			break;
+		}
+
+		// Let line_size.cy be the maximum m_Height we encounter.
+		line_size.cy = std::max(line_size.cy, 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 (Width != 0 && Feedback2.m_NewLine)
+			break;
+
+		line_size.cx += Feedback2.m_Size.cx;
+	}
+}
+
+bool CGUIText::ProcessLine(
+	const CGUI* pGUI,
+	const CGUIString& string,
+	const CStrIntern& Font,
+	const IGUIObject* pObject,
+	const SGenerateTextImages& Images,
+	const EAlign align,
+	const float prelim_line_height,
+	const float Width,
+	const float BufferZone,
+	bool& FirstLine,
+	float& x,
+	float& y,
+	int& i,
+	int& from)
+{
+	// Change 'from' to 'i', but first keep a copy of its value.
+	int temp_from = from;
+	from = i;
+
+	float width_range_from = BufferZone;
+	float width_range_to = Width - BufferZone;
+	ComputeLineRange(Images, y, Width, prelim_line_height, width_range_from, width_range_to);
+
+	// Reset X for the next loop
+	x = width_range_from;
+
+	CSize line_size;
+	ComputeLineSize(pGUI, string, Font, FirstLine, Width, width_range_to, i, temp_from, x, line_size);
+
+	// Reset x once more
+	x = width_range_from;
+
+	// Move down, because font drawing starts from the baseline
+	y += line_size.cy;
+
+	const float dx = GetLineOffset(align, width_range_from, width_range_to, line_size);
+
+	// Do the real processing now
+	const bool done = AssembleCalls(pGUI, string, Font, pObject, FirstLine, Width, width_range_to, dx, y, temp_from, i, x, from);
+
+	// Reset X
+	x = BufferZone;
+
+	// Update dimensions
+	m_Size.cx = std::max(m_Size.cx, line_size.cx + BufferZone * 2);
+	m_Size.cy = std::max(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 done;
+}
+
+// Decide width of the line. We need to iterate our floating images.
+//  this won't be exact because we're assuming the line_size.cy
+//  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.
+void CGUIText::ComputeLineRange(
+	const SGenerateTextImages& Images,
+	const float y,
+	const float Width,
+	const float prelim_line_height,
+	float& width_range_from,
+	float& width_range_to) const
+{
+	// Floating images are only applicable if word-wrapping is enabled.
+	if (Width == 0)
+		return;
+
+	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 == 0)
+					width_range_from = std::max(width_range_from, img.m_Indentation);
+				else
+					width_range_to = std::min(width_range_to, Width - img.m_Indentation);
+			}
+		}
+}
+
+// compute offset based on what kind of alignment
+float CGUIText::GetLineOffset(
+	const EAlign align,
+	const float width_range_from,
+	const float width_range_to,
+	const CSize& line_size) const
+{
+	switch (align)
+	{
+	case EAlign_Left:
+		// don't add an offset
+		return 0.f;
+
+	case EAlign_Center:
+		return ((width_range_to - width_range_from) - line_size.cx) / 2;
+
+	case EAlign_Right:
+		return width_range_to - line_size.cx;
+
+	default:
+		debug_warn(L"Broken EAlign in CGUIText()");
+		return 0.f;
+	}
+}
+
+bool CGUIText::AssembleCalls(
+	const CGUI* pGUI,
+	const CGUIString& string,
+	const CStrIntern& Font,
+	const IGUIObject* pObject,
+	const bool FirstLine,
+	const float Width,
+	const float width_range_to,
+	const float dx,
+	const float y,
+	const int temp_from,
+	const int i,
+	float& x,
+	int& from)
+{
+	bool done = false;
+
+	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(pGUI, 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 (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 (Width != 0) // 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.
+				m_SpriteCalls.insert(
+					m_SpriteCalls.end(),
+					std::make_move_iterator(Feedback2.m_SpriteCalls.begin()),
+					std::make_move_iterator(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.
+		m_TextCalls.insert(
+			m_TextCalls.end(),
+			std::make_move_iterator(Feedback2.m_TextCalls.begin()),
+			std::make_move_iterator(Feedback2.m_TextCalls.end()));
+
+		m_SpriteCalls.insert(
+			m_SpriteCalls.end(),
+			std::make_move_iterator(Feedback2.m_SpriteCalls.begin()),
+			std::make_move_iterator(Feedback2.m_SpriteCalls.end()));
+
+		if (j == static_cast<int>(string.m_Words.size()) - 2)
+			done = true;
+	}
+
+	return done;
+}
+
+void CGUIText::Draw(CGUI* pGUI, const CGUIColor& DefaultColor, const CPos& pos, const float z, const CRect& clipping) const
+{
+	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 STextCall& tc : m_TextCalls)
+	{
+		// If this is just a placeholder for a sprite call, continue
+		if (tc.m_pSpriteCall)
+			continue;
+
+		CGUIColor color = tc.m_UseCustomColor ? tc.m_Color : DefaultColor;
+
+		textRenderer.Color(color);
+		textRenderer.Font(tc.m_Font);
+		textRenderer.Put(floorf(pos.x + tc.m_Pos.x), floorf(pos.y + tc.m_Pos.y), &tc.m_String);
+	}
+
+	textRenderer.Render();
+
+	for (const SSpriteCall& sc : m_SpriteCalls)
+		pGUI->DrawSprite(sc.m_Sprite, sc.m_CellID, z, sc.m_Area + pos);
+
+	if (isClipped)
+		glDisable(GL_SCISSOR_TEST);
+
+	tech->EndPass();
+}

Property changes on: ps/trunk/source/gui/CGUIText.cpp
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: ps/trunk/source/gui/CGUIText.h
===================================================================
--- ps/trunk/source/gui/CGUIText.h	(nonexistent)
+++ ps/trunk/source/gui/CGUIText.h	(revision 22679)
@@ -0,0 +1,283 @@
+/* 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_GUITEXT
+#define INCLUDED_GUITEXT
+
+#include "gui/CGUIColor.h"
+#include "gui/CGUISprite.h"
+#include "gui/GUIutil.h"
+#include "graphics/TextRenderer.h"
+#include "ps/CStrIntern.h"
+#include "ps/Shapes.h"
+
+#include <array>
+#include <list>
+#include <vector>
+
+class CGUIString;
+struct SGenerateTextImage;
+using SGenerateTextImages = std::array<std::vector<SGenerateTextImage>, 2>;
+
+/**
+ * An CGUIText object is a parsed string, divided into
+ * text-rendering components. Each component, being a
+ * call to the Renderer. For instance, if you by tags
+ * change the color, then the GUI will have to make
+ * individual calls saying it want that color on the
+ * text.
+ *
+ * For instance:
+ * "Hello [b]there[/b] bunny!"
+ *
+ * That without word-wrapping would mean 3 components.
+ * i.e. 3 calls to CRenderer. One drawing "Hello",
+ * one drawing "there" in bold, and one drawing "bunny!".
+ */
+class CGUIText
+{
+public:
+	/**
+	 * A sprite call to the CRenderer
+	 */
+	struct SSpriteCall
+	{
+		// The CGUISpriteInstance makes this uncopyable to avoid invalidating its draw cache
+		NONCOPYABLE(SSpriteCall);
+		MOVABLE(SSpriteCall);
+
+		SSpriteCall() : m_CellID(0) {}
+
+		/**
+		 * Size and position of sprite
+		 */
+		CRect m_Area;
+
+		/**
+		 * Sprite from global GUI sprite database.
+		 */
+		CGUISpriteInstance m_Sprite;
+
+		int m_CellID;
+
+		/**
+		 * Tooltip text
+		 */
+		CStrW m_Tooltip;
+
+		/**
+		 * Tooltip style
+		 */
+		CStrW m_TooltipStyle;
+	};
+
+	/**
+	 * A text call to the CRenderer
+	 */
+	struct STextCall
+	{
+		NONCOPYABLE(STextCall);
+		MOVABLE(STextCall);
+
+		STextCall() :
+			m_UseCustomColor(false),
+			m_Bold(false), m_Italic(false), m_Underlined(false),
+			m_pSpriteCall(NULL) {}
+
+		/**
+		 * Position
+		 */
+		CPos m_Pos;
+
+		/**
+		 * Size
+		 */
+		CSize m_Size;
+
+		/**
+		 * The string that is suppose to be rendered.
+		 */
+		CStrW m_String;
+
+		/**
+		 * Use custom color? If true then m_Color is used,
+		 * else the color inputted will be used.
+		 */
+		bool m_UseCustomColor;
+
+		/**
+		 * Color setup
+		 */
+		CGUIColor m_Color;
+
+		/**
+		 * Font name
+		 */
+		CStrIntern m_Font;
+
+		/**
+		 * Settings
+		 */
+		bool m_Bold, m_Italic, m_Underlined;
+
+		/**
+		 * *IF* an icon, then this is not NULL.
+		 */
+		std::list<SSpriteCall>::pointer m_pSpriteCall;
+	};
+
+	// The SSpriteCall CGUISpriteInstance makes this uncopyable to avoid invalidating its draw cache.
+	// Also take advantage of exchanging the containers directly with move semantics.
+	NONCOPYABLE(CGUIText);
+	MOVABLE(CGUIText);
+
+	/**
+	 * Generates empty text.
+	 */
+	CGUIText() = default;
+
+	/**
+	 * Generate a CGUIText 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.
+	 *
+	 * @param Text Text to generate CGUIText 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.
+	 */
+	CGUIText(const CGUI* pGUI, const CGUIString& string, const CStrW& FontW, const float Width, const float BufferZone, const IGUIObject* pObject = nullptr);
+
+	/**
+	 * Draw this CGUIText object
+	 */
+	void Draw(CGUI* pGUI, const CGUIColor& DefaultColor, const CPos& pos, const float z, const CRect& clipping) const;
+
+	const CSize& GetSize() const { return m_Size; }
+
+	const std::list<SSpriteCall>& GetSpriteCalls() const { return m_SpriteCalls; }
+
+	const std::vector<STextCall>& GetTextCalls() const { return m_TextCalls; }
+
+	// Helper functions of the constructor
+	bool ProcessLine(
+		const CGUI* pGUI,
+		const CGUIString& string,
+		const CStrIntern& Font,
+		const IGUIObject* pObject,
+		const SGenerateTextImages& Images,
+		const EAlign align,
+		const float prelim_line_height,
+		const float Width,
+		const float BufferZone,
+		bool& FirstLine,
+		float& x,
+		float& y,
+		int& i,
+		int& from);
+
+	void SetupSpriteCalls(
+		const CGUI* pGUI,
+		const std::array<std::vector<CStr>, 2>& FeedbackImages,
+		const float y,
+		const float Width,
+		const float BufferZone,
+		const int i,
+		const int pos_last_img,
+		SGenerateTextImages& Images);
+
+	float GetLineOffset(
+		const EAlign align,
+		const float width_range_from,
+		const float width_range_to,
+		const CSize& line_size) const;
+
+	void ComputeLineRange(
+		const SGenerateTextImages& Images,
+		const float y,
+		const float Width,
+		const float prelim_line_height,
+		float& width_range_from,
+		float& width_range_to) const;
+
+	void ComputeLineSize(
+		const CGUI* pGUI,
+		const CGUIString& string,
+		const CStrIntern& Font,
+		const bool FirstLine,
+		const float Width,
+		const float width_range_to,
+		const int i,
+		const int temp_from,
+		float& x,
+		CSize& line_size) const;
+
+	bool AssembleCalls(
+		const CGUI* pGUI,
+		const CGUIString& string,
+		const CStrIntern& Font,
+		const IGUIObject* pObject,
+		const bool FirstLine,
+		const float Width,
+		const float width_range_to,
+		const float dx,
+		const float y,
+		const int temp_from,
+		const int i,
+		float& x,
+		int& from);
+
+	/**
+	 * List of TextCalls, for instance "Hello", "there!"
+	 */
+	std::vector<STextCall> m_TextCalls;
+
+	/**
+	 * List of sprites, or "icons" that should be rendered
+	 * along with the text.
+	 */
+	std::list<SSpriteCall> m_SpriteCalls; // list for consistent mem addresses
+										  // so that we can point to elements.
+	/**
+	 * Width and height of the whole output, used when setting up
+	 * scrollbars and such.
+	 */
+	CSize m_Size;
+};
+
+struct SGenerateTextImage
+{
+	// The image's starting location in Y
+	float m_YFrom;
+
+	// The image's end location in Y
+	float m_YTo;
+
+	// The image width in other words
+	float m_Indentation;
+
+	void SetupSpriteCall(
+		const bool Left, CGUIText::SSpriteCall& SpriteCall, const float width, const float y,
+		const CSize& Size, const CStr& TextureName, const float BufferZone, const int CellID);
+};
+
+#endif // INCLUDED_GUITEXT

Property changes on: ps/trunk/source/gui/CGUIText.h
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: ps/trunk/source/gui/CList.cpp
===================================================================
--- ps/trunk/source/gui/CList.cpp	(revision 22678)
+++ ps/trunk/source/gui/CList.cpp	(revision 22679)
@@ -1,554 +1,549 @@
 /* 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 "CList.h"
 
 #include "gui/CGUIColor.h"
 #include "gui/CGUIScrollBarVertical.h"
 #include "lib/external_libraries/libsdl.h"
 #include "ps/CLogger.h"
 #include "ps/Profile.h"
 #include "soundmanager/ISoundManager.h"
 
 
 CList::CList(CGUI* pGUI)
 	: IGUIObject(pGUI), IGUITextOwner(pGUI), IGUIScrollBarOwner(pGUI),
 	  m_Modified(false), m_PrevSelectedItem(-1), m_LastItemClickTime(0)
 {
 	// Add sprite_disabled! TODO
 	AddSetting<float>("buffer_zone");
 	AddSetting<CStrW>("font");
 	AddSetting<bool>("scrollbar");
 	AddSetting<CStr>("scrollbar_style");
 	AddSetting<CStrW>("sound_disabled");
 	AddSetting<CStrW>("sound_selected");
 	AddSetting<CGUISpriteInstance>("sprite");
 	AddSetting<CGUISpriteInstance>("sprite_selectarea");
 	AddSetting<int>(	"cell_id");
 	AddSetting<EAlign>("text_align");
 	AddSetting<CGUIColor>("textcolor");
 	AddSetting<CGUIColor>("textcolor_selected");
 	AddSetting<int>(	"selected");	// Index selected. -1 is none.
 	AddSetting<bool>("auto_scroll");
 	AddSetting<int>(	"hovered");
 	AddSetting<CStrW>("tooltip");
 	AddSetting<CStr>("tooltip_style");
 
 	// Each list item has both a name (in 'list') and an associated data string (in 'list_data')
 	AddSetting<CGUIList>("list");
 	AddSetting<CGUIList>("list_data");
 
 	GUI<bool>::SetSetting(this, "scrollbar", false);
 	GUI<int>::SetSetting(this, "selected", -1);
 	GUI<int>::SetSetting(this, "hovered", -1);
 	GUI<bool>::SetSetting(this, "auto_scroll", false);
 
 	// Add scroll-bar
 	CGUIScrollBarVertical* bar = new CGUIScrollBarVertical(pGUI);
 	bar->SetRightAligned(true);
 	AddScrollBar(bar);
 }
 
 CList::~CList()
 {
 }
 
 void CList::SetupText()
 {
 	m_Modified = true;
 	CGUIList* pList;
 	GUI<CGUIList>::GetSettingPointer(this, "list", pList);
 
 	//ENSURE(m_GeneratedTexts.size()>=1);
 
 	m_ItemsYPositions.resize(pList->m_Items.size()+1);
 
 	// Delete all generated texts. Some could probably be saved,
 	//  but this is easier, and this function will never be called
 	//  continuously, or even often, so it'll probably be okay.
-	for (SGUIText* const& t : m_GeneratedTexts)
-		delete t;
 	m_GeneratedTexts.clear();
 
 	CStrW font;
 	if (GUI<CStrW>::GetSetting(this, "font", font) != PSRETURN_OK || font.empty())
 		// Use the default if none is specified
 		// TODO Gee: (2004-08-14) Don't define standard like this. Do it with the default style.
 		font = L"default";
 
 	bool scrollbar;
 	GUI<bool>::GetSetting(this, "scrollbar", scrollbar);
 
 	float width = GetListRect().GetWidth();
 	// remove scrollbar if applicable
 	if (scrollbar && GetScrollBar(0).GetStyle())
 		width -= GetScrollBar(0).GetStyle()->m_Width;
 
 	float buffer_zone = 0.f;
 	GUI<float>::GetSetting(this, "buffer_zone", buffer_zone);
 
 	// Generate texts
 	float buffered_y = 0.f;
 
 	for (size_t i = 0; i < pList->m_Items.size(); ++i)
 	{
-		// Create a new SGUIText. Later on, input it using AddText()
-		SGUIText* text = new SGUIText();
+		CGUIText* text;
 
 		if (!pList->m_Items[i].GetOriginalString().empty())
-			*text = GetGUI()->GenerateText(pList->m_Items[i], font, width, buffer_zone, this);
+			text = &AddText(pList->m_Items[i], font, width, buffer_zone, this);
 		else
 		{
 			// Minimum height of a space character of the current font size
 			CGUIString align_string;
 			align_string.SetValue(L" ");
-			*text = GetGUI()->GenerateText(align_string, font, width, buffer_zone, this);
+			text = &AddText(align_string, font, width, buffer_zone, this);
 		}
 
 		m_ItemsYPositions[i] = buffered_y;
-		buffered_y += text->m_Size.cy;
-
-		AddText(text);
+		buffered_y += text->GetSize().cy;
 	}
 
 	m_ItemsYPositions[pList->m_Items.size()] = buffered_y;
 
 	// Setup scrollbar
 	if (scrollbar)
 	{
 		GetScrollBar(0).SetScrollRange(m_ItemsYPositions.back());
 		GetScrollBar(0).SetScrollSpace(GetListRect().GetHeight());
 
 		CRect rect = GetListRect();
 		GetScrollBar(0).SetX(rect.right);
 		GetScrollBar(0).SetY(rect.top);
 		GetScrollBar(0).SetZ(GetBufferedZ());
 		GetScrollBar(0).SetLength(rect.bottom - rect.top);
 	}
 }
 
 void CList::HandleMessage(SGUIMessage& Message)
 {
 	IGUIScrollBarOwner::HandleMessage(Message);
 	//IGUITextOwner::HandleMessage(Message); <== placed it after the switch instead!
 
 	m_Modified = false;
 	switch (Message.type)
 	{
 	case GUIM_SETTINGS_UPDATED:
 		if (Message.value == "list")
 			SetupText();
 
 		// If selected is changed, call "SelectionChange"
 		if (Message.value == "selected")
 		{
 			// TODO: Check range
 
 			bool auto_scroll;
 
 			GUI<bool>::GetSetting(this, "auto_scroll", auto_scroll);
 
 			if (auto_scroll)
 				UpdateAutoScroll();
 
 			// TODO only works if lower-case, shouldn't it be made case sensitive instead?
 			ScriptEvent("selectionchange");
 		}
 
 		if (Message.value == "scrollbar")
 			SetupText();
 
 		// Update scrollbar
 		if (Message.value == "scrollbar_style")
 		{
 			CStr scrollbar_style;
 			GUI<CStr>::GetSetting(this, Message.value, scrollbar_style);
 
 			GetScrollBar(0).SetScrollBarStyle(scrollbar_style);
 
 			SetupText();
 		}
 
 		break;
 
 	case GUIM_MOUSE_PRESS_LEFT:
 	{
 		bool enabled;
 		GUI<bool>::GetSetting(this, "enabled", enabled);
 		if (!enabled)
 		{
 			CStrW soundPath;
 			if (g_SoundManager && GUI<CStrW>::GetSetting(this, "sound_disabled", soundPath) == PSRETURN_OK && !soundPath.empty())
 				g_SoundManager->PlayAsUI(soundPath.c_str(), false);
 			break;
 		}
 
 		int hovered = GetHoveredItem();
 		if (hovered == -1)
 			break;
 		GUI<int>::SetSetting(this, "selected", hovered);
 		UpdateAutoScroll();
 
 		CStrW soundPath;
 		if (g_SoundManager && GUI<CStrW>::GetSetting(this, "sound_selected", soundPath) == PSRETURN_OK && !soundPath.empty())
 			g_SoundManager->PlayAsUI(soundPath.c_str(), false);
 
 		if (timer_Time() - m_LastItemClickTime < SELECT_DBLCLICK_RATE && hovered == m_PrevSelectedItem)
 			this->SendEvent(GUIM_MOUSE_DBLCLICK_LEFT_ITEM, "mouseleftdoubleclickitem");
 		else
 			this->SendEvent(GUIM_MOUSE_PRESS_LEFT_ITEM, "mouseleftclickitem");
 
 		m_LastItemClickTime = timer_Time();
 		m_PrevSelectedItem = hovered;
 		break;
 	}
 
 	case GUIM_MOUSE_LEAVE:
 	{
 		int hoveredSetting = -1;
 		GUI<int>::GetSetting(this, "hovered", hoveredSetting);
 		if (hoveredSetting == -1)
 			break;
 
 		GUI<int>::SetSetting(this, "hovered", -1);
 		ScriptEvent("hoverchange");
 		break;
 	}
 
 	case GUIM_MOUSE_OVER:
 	{
 		int hoveredSetting = -1;
 		GUI<int>::GetSetting(this, "hovered", hoveredSetting);
 
 		int hovered = GetHoveredItem();
 		if (hovered == hoveredSetting)
 			break;
 
 		GUI<int>::SetSetting(this, "hovered", hovered);
 		ScriptEvent("hoverchange");
 		break;
 	}
 
 	case GUIM_LOAD:
 	{
 		CStr scrollbar_style;
 		GUI<CStr>::GetSetting(this, "scrollbar_style", scrollbar_style);
 		GetScrollBar(0).SetScrollBarStyle(scrollbar_style);
 		break;
 	}
 
 	default:
 		break;
 	}
 
 	IGUITextOwner::HandleMessage(Message);
 }
 
 InReaction CList::ManuallyHandleEvent(const SDL_Event_* ev)
 {
 	InReaction result = IN_PASS;
 
 	if (ev->ev.type == SDL_KEYDOWN)
 	{
 		int szChar = ev->ev.key.keysym.sym;
 
 		switch (szChar)
 		{
 		case SDLK_HOME:
 			SelectFirstElement();
 			UpdateAutoScroll();
 			result = IN_HANDLED;
 			break;
 
 		case SDLK_END:
 			SelectLastElement();
 			UpdateAutoScroll();
 			result = IN_HANDLED;
 			break;
 
 		case SDLK_UP:
 			SelectPrevElement();
 			UpdateAutoScroll();
 			result = IN_HANDLED;
 			break;
 
 		case SDLK_DOWN:
 			SelectNextElement();
 			UpdateAutoScroll();
 			result = IN_HANDLED;
 			break;
 
 		case SDLK_PAGEUP:
 			GetScrollBar(0).ScrollMinusPlenty();
 			result = IN_HANDLED;
 			break;
 
 		case SDLK_PAGEDOWN:
 			GetScrollBar(0).ScrollPlusPlenty();
 			result = IN_HANDLED;
 			break;
 
 		default: // Do nothing
 			result = IN_PASS;
 		}
 	}
 
 	return result;
 }
 
 void CList::Draw()
 {
 	int selected;
 	GUI<int>::GetSetting(this, "selected", selected);
 
 	DrawList(selected, "sprite", "sprite_selectarea", "textcolor");
 }
 
 void CList::DrawList(const int& selected, const CStr& _sprite, const CStr& _sprite_selected, const CStr& _textcolor)
 {
 	float bz = GetBufferedZ();
 
 	// First call draw on ScrollBarOwner
 	bool scrollbar;
 	GUI<bool>::GetSetting(this, "scrollbar", scrollbar);
 
 	if (scrollbar)
 		IGUIScrollBarOwner::Draw();
 
 	if (GetGUI())
 	{
 		CRect rect = GetListRect();
 
 		CGUISpriteInstance* sprite = NULL;
 		CGUISpriteInstance* sprite_selectarea = NULL;
 		int cell_id;
 		GUI<CGUISpriteInstance>::GetSettingPointer(this, _sprite, sprite);
 		GUI<CGUISpriteInstance>::GetSettingPointer(this, _sprite_selected, sprite_selectarea);
 		GUI<int>::GetSetting(this, "cell_id", cell_id);
 
 		CGUIList* pList;
 		GUI<CGUIList>::GetSettingPointer(this, "list", pList);
 
 		GetGUI()->DrawSprite(*sprite, cell_id, bz, rect);
 
 		float scroll = 0.f;
 		if (scrollbar)
 			scroll = GetScrollBar(0).GetPos();
 
 		if (selected >= 0 && selected+1 < (int)m_ItemsYPositions.size())
 		{
 			// Get rectangle of selection:
 			CRect rect_sel(rect.left, rect.top + m_ItemsYPositions[selected] - scroll,
 					       rect.right, rect.top + m_ItemsYPositions[selected+1] - scroll);
 
 			if (rect_sel.top <= rect.bottom &&
 				rect_sel.bottom >= rect.top)
 			{
 				if (rect_sel.bottom > rect.bottom)
 					rect_sel.bottom = rect.bottom;
 				if (rect_sel.top < rect.top)
 					rect_sel.top = rect.top;
 
 				if (scrollbar)
 				{
 					// Remove any overlapping area of the scrollbar.
 					if (rect_sel.right > GetScrollBar(0).GetOuterRect().left &&
 						rect_sel.right <= GetScrollBar(0).GetOuterRect().right)
 						rect_sel.right = GetScrollBar(0).GetOuterRect().left;
 
 					if (rect_sel.left >= GetScrollBar(0).GetOuterRect().left &&
 						rect_sel.left < GetScrollBar(0).GetOuterRect().right)
 						rect_sel.left = GetScrollBar(0).GetOuterRect().right;
 				}
 
 				GetGUI()->DrawSprite(*sprite_selectarea, cell_id, bz+0.05f, rect_sel);
 			}
 		}
 
 		CGUIColor color;
 		GUI<CGUIColor>::GetSetting(this, _textcolor, color);
 
 		for (size_t i = 0; i < pList->m_Items.size(); ++i)
 		{
 			if (m_ItemsYPositions[i+1] - scroll < 0 ||
 				m_ItemsYPositions[i] - scroll > rect.GetHeight())
 				continue;
 
 			// Clipping area (we'll have to substract the scrollbar)
 			CRect cliparea = GetListRect();
 
 			if (scrollbar)
 			{
 				if (cliparea.right > GetScrollBar(0).GetOuterRect().left &&
 					cliparea.right <= GetScrollBar(0).GetOuterRect().right)
 					cliparea.right = GetScrollBar(0).GetOuterRect().left;
 
 				if (cliparea.left >= GetScrollBar(0).GetOuterRect().left &&
 					cliparea.left < GetScrollBar(0).GetOuterRect().right)
 					cliparea.left = GetScrollBar(0).GetOuterRect().right;
 			}
 
 			DrawText(i, color, rect.TopLeft() - CPos(0.f, scroll - m_ItemsYPositions[i]), bz+0.1f, cliparea);
 		}
 	}
 }
 
 void CList::AddItem(const CStrW& str, const CStrW& data)
 {
 	CGUIList* pList;
 	CGUIList* pListData;
 	GUI<CGUIList>::GetSettingPointer(this, "list", pList);
 	GUI<CGUIList>::GetSettingPointer(this, "list_data", pListData);
 
 	CGUIString gui_string;
 	gui_string.SetValue(str);
 	pList->m_Items.push_back(gui_string);
 
 	CGUIString data_string;
 	data_string.SetValue(data);
 	pListData->m_Items.push_back(data_string);
 
 	// TODO Temp
 	SetupText();
 }
 
 bool CList::HandleAdditionalChildren(const XMBElement& child, CXeromyces* pFile)
 {
 	int elmt_item = pFile->GetElementID("item");
 
 	if (child.GetNodeName() == elmt_item)
 	{
 		AddItem(child.GetText().FromUTF8(), child.GetText().FromUTF8());
 		return true;
 	}
 
 	return false;
 }
 
 void CList::SelectNextElement()
 {
 	int selected;
 	GUI<int>::GetSetting(this, "selected", selected);
 
 	CGUIList* pList;
 	GUI<CGUIList>::GetSettingPointer(this, "list", pList);
 
 	if (selected != (int)pList->m_Items.size()-1)
 	{
 		++selected;
 		GUI<int>::SetSetting(this, "selected", selected);
 
 		CStrW soundPath;
 		if (g_SoundManager && GUI<CStrW>::GetSetting(this, "sound_selected", soundPath) == PSRETURN_OK && !soundPath.empty())
 			g_SoundManager->PlayAsUI(soundPath.c_str(), false);
 	}
 }
 
 void CList::SelectPrevElement()
 {
 	int selected;
 	GUI<int>::GetSetting(this, "selected", selected);
 
 	if (selected > 0)
 	{
 		--selected;
 		GUI<int>::SetSetting(this, "selected", selected);
 
 		CStrW soundPath;
 		if (g_SoundManager && GUI<CStrW>::GetSetting(this, "sound_selected", soundPath) == PSRETURN_OK && !soundPath.empty())
 			g_SoundManager->PlayAsUI(soundPath.c_str(), false);
 	}
 }
 
 void CList::SelectFirstElement()
 {
 	int selected;
 	GUI<int>::GetSetting(this, "selected", selected);
 
 	if (selected >= 0)
 		GUI<int>::SetSetting(this, "selected", 0);
 }
 
 void CList::SelectLastElement()
 {
 	int selected;
 	GUI<int>::GetSetting(this, "selected", selected);
 
 	CGUIList* pList;
 	GUI<CGUIList>::GetSettingPointer(this, "list", pList);
 
 	if (selected != (int)pList->m_Items.size()-1)
 		GUI<int>::SetSetting(this, "selected", (int)pList->m_Items.size()-1);
 }
 
 void CList::UpdateAutoScroll()
 {
 	int selected;
 	bool scrollbar;
 	float scroll;
 	GUI<int>::GetSetting(this, "selected", selected);
 	GUI<bool>::GetSetting(this, "scrollbar", scrollbar);
 
 	// No scrollbar, no scrolling (at least it's not made to work properly).
 	if (!scrollbar || selected < 0 || (std::size_t) selected >= m_ItemsYPositions.size())
 		return;
 
 	scroll = GetScrollBar(0).GetPos();
 
 	// Check upper boundary
 	if (m_ItemsYPositions[selected] < scroll)
 	{
 		GetScrollBar(0).SetPos(m_ItemsYPositions[selected]);
 		return; // this means, if it wants to align both up and down at the same time
 				//  this will have precedence.
 	}
 
 	// Check lower boundary
 	CRect rect = GetListRect();
 	if (m_ItemsYPositions[selected+1]-rect.GetHeight() > scroll)
 		GetScrollBar(0).SetPos(m_ItemsYPositions[selected+1]-rect.GetHeight());
 }
 
 int CList::GetHoveredItem()
 {
 	bool scrollbar;
 	CGUIList* pList;
 	GUI<bool>::GetSetting(this, "scrollbar", scrollbar);
 	GUI<CGUIList>::GetSettingPointer(this, "list", pList);
 	float scroll = 0.f;
 	if (scrollbar)
 		scroll = GetScrollBar(0).GetPos();
 
 	const CRect& rect = GetListRect();
 	CPos mouse = m_pGUI->GetMousePos();
 	mouse.y += scroll;
 
 	// Mouse is over scrollbar
 	if (scrollbar && GetScrollBar(0).IsVisible() &&
 	    mouse.x >= GetScrollBar(0).GetOuterRect().left &&
 	    mouse.x <= GetScrollBar(0).GetOuterRect().right)
 		return -1;
 
 	for (size_t i = 0; i < pList->m_Items.size(); ++i)
 		if (mouse.y >= rect.top + m_ItemsYPositions[i] &&
 		    mouse.y < rect.top + m_ItemsYPositions[i + 1])
 			return i;
 
 	return -1;
 }
Index: ps/trunk/source/gui/COList.cpp
===================================================================
--- ps/trunk/source/gui/COList.cpp	(revision 22678)
+++ ps/trunk/source/gui/COList.cpp	(revision 22679)
@@ -1,484 +1,480 @@
 /* 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 "COList.h"
 
 #include "gui/CGUIColor.h"
 #include "i18n/L10n.h"
 #include "ps/CLogger.h"
 #include "soundmanager/ISoundManager.h"
 
 const float SORT_SPRITE_DIM = 16.0f;
 const CPos COLUMN_SHIFT = CPos(0, 4);
 
 COList::COList(CGUI* pGUI)
 	: CList(pGUI), IGUIObject(pGUI)
 {
 	AddSetting<CGUISpriteInstance>("sprite_heading");
 	AddSetting<bool>("sortable"); // The actual sorting is done in JS for more versatility
 	AddSetting<CStr>("selected_column");
 	AddSetting<int>("selected_column_order");
 	AddSetting<CGUISpriteInstance>("sprite_asc");  // Show the order of sorting
 	AddSetting<CGUISpriteInstance>("sprite_desc");
 	AddSetting<CGUISpriteInstance>("sprite_not_sorted");
 }
 
 void COList::SetupText()
 {
 	CGUIList* pList;
 	GUI<CGUIList>::GetSettingPointer(this, "list", pList);
 
 	m_ItemsYPositions.resize(pList->m_Items.size() + 1);
 
 	// Delete all generated texts. Some could probably be saved,
 	//  but this is easier, and this function will never be called
 	//  continuously, or even often, so it'll probably be okay.
-	for (SGUIText* const& t : m_GeneratedTexts)
-		delete t;
 	m_GeneratedTexts.clear();
 
 	CStrW font;
 	if (GUI<CStrW>::GetSetting(this, "font", font) != PSRETURN_OK || font.empty())
 		// Use the default if none is specified
 		// TODO Gee: (2004-08-14) Don't define standard like this. Do it with the default style.
 		font = L"default";
 
 	bool scrollbar;
 	GUI<bool>::GetSetting(this, "scrollbar", scrollbar);
 
 	m_TotalAvailableColumnWidth = GetListRect().GetWidth();
 	// remove scrollbar if applicable
 	if (scrollbar && GetScrollBar(0).GetStyle())
 		m_TotalAvailableColumnWidth -= GetScrollBar(0).GetStyle()->m_Width;
 
 	float buffer_zone = 0.f;
 	GUI<float>::GetSetting(this, "buffer_zone", buffer_zone);
 
 	m_HeadingHeight = SORT_SPRITE_DIM; // At least the size of the sorting sprite
 
 	for (const COListColumn& column : m_Columns)
 	{
 		float width = column.m_Width;
 		if (column.m_Width > 0 && column.m_Width < 1)
 			width *= m_TotalAvailableColumnWidth;
 
-		SGUIText* text = new SGUIText();
 		CGUIString gui_string;
 		gui_string.SetValue(column.m_Heading);
-		*text = GetGUI()->GenerateText(gui_string, font, width, buffer_zone, this);
-		AddText(text);
-		m_HeadingHeight = std::max(m_HeadingHeight, text->m_Size.cy + COLUMN_SHIFT.y);
+
+		const CGUIText& text = AddText(gui_string, font, width, buffer_zone, this);
+		m_HeadingHeight = std::max(m_HeadingHeight, text.GetSize().cy + COLUMN_SHIFT.y);
 	}
 
 	// Generate texts
 	float buffered_y = 0.f;
 
 	for (size_t i = 0; i < pList->m_Items.size(); ++i)
 	{
 		m_ItemsYPositions[i] = buffered_y;
 		float shift = 0.0f;
 		for (const COListColumn& column : m_Columns)
 		{
 			float width = column.m_Width;
 			if (column.m_Width > 0 && column.m_Width < 1)
 				width *= m_TotalAvailableColumnWidth;
 
 			CGUIList* pList_c;
 			GUI<CGUIList>::GetSettingPointer(this, "list_" + column.m_Id, pList_c);
-			SGUIText* text = new SGUIText();
+			CGUIText* text;
 			if (!pList_c->m_Items[i].GetOriginalString().empty())
-				*text = GetGUI()->GenerateText(pList_c->m_Items[i], font, width, buffer_zone, this);
+				text = &AddText(pList_c->m_Items[i], font, width, buffer_zone, this);
 			else
 			{
 				// Minimum height of a space character of the current font size
 				CGUIString align_string;
 				align_string.SetValue(L" ");
-				*text = GetGUI()->GenerateText(align_string, font, width, buffer_zone, this);
+				text = &AddText(align_string, font, width, buffer_zone, this);
 			}
-			shift = std::max(shift, text->m_Size.cy);
-			AddText(text);
+			shift = std::max(shift, text->GetSize().cy);
 		}
 		buffered_y += shift;
 	}
 
 	m_ItemsYPositions[pList->m_Items.size()] = buffered_y;
 
 	if (scrollbar)
 	{
 		CRect rect = GetListRect();
 		GetScrollBar(0).SetScrollRange(m_ItemsYPositions.back());
 		GetScrollBar(0).SetScrollSpace(rect.GetHeight());
 
 		GetScrollBar(0).SetX(rect.right);
 		GetScrollBar(0).SetY(rect.top);
 		GetScrollBar(0).SetZ(GetBufferedZ());
 		GetScrollBar(0).SetLength(rect.bottom - rect.top);
 	}
 }
 
 CRect COList::GetListRect() const
 {
 	return m_CachedActualSize + CRect(0, m_HeadingHeight, 0, 0);
 }
 
 void COList::HandleMessage(SGUIMessage& Message)
 {
 	CList::HandleMessage(Message);
 
 	switch (Message.type)
 	{
 	// If somebody clicks on the column heading
 	case GUIM_MOUSE_PRESS_LEFT:
 	{
 		bool sortable;
 		GUI<bool>::GetSetting(this, "sortable", sortable);
 		if (!sortable)
 			return;
 
 		const CPos& mouse = m_pGUI->GetMousePos();
 		if (!m_CachedActualSize.PointInside(mouse))
 			return;
 
 		CStr selectedColumn;
 		GUI<CStr>::GetSetting(this, "selected_column", selectedColumn);
 		int selectedColumnOrder;
 		GUI<int>::GetSetting(this, "selected_column_order", selectedColumnOrder);
 
 		float xpos = 0;
 		for (const COListColumn& column : m_Columns)
 		{
 			bool hidden = false;
 			GUI<bool>::GetSetting(this, "hidden_" + column.m_Id, hidden);
 			if (hidden)
 				continue;
 
 			float width = column.m_Width;
 			// Check if it's a decimal value, and if so, assume relative positioning.
 			if (column.m_Width < 1 && column.m_Width > 0)
 				width *= m_TotalAvailableColumnWidth;
 			CPos leftTopCorner = m_CachedActualSize.TopLeft() + CPos(xpos, 0);
 			if (mouse.x >= leftTopCorner.x &&
 				mouse.x < leftTopCorner.x + width &&
 				mouse.y < leftTopCorner.y + m_HeadingHeight)
 			{
 				if (column.m_Id != selectedColumn)
 				{
 					selectedColumnOrder = 1;
 					selectedColumn = column.m_Id;
 				}
 				else
 					selectedColumnOrder = -selectedColumnOrder;
 				GUI<CStr>::SetSetting(this, "selected_column", column.m_Id);
 				GUI<int>::SetSetting(this, "selected_column_order", selectedColumnOrder);
 				ScriptEvent("selectioncolumnchange");
 
 				CStrW soundPath;
 				if (g_SoundManager && GUI<CStrW>::GetSetting(this, "sound_selected", soundPath) == PSRETURN_OK && !soundPath.empty())
 					g_SoundManager->PlayAsUI(soundPath.c_str(), false);
 
 				return;
 			}
 			xpos += width;
 		}
 		return;
 	}
 	default:
 		return;
 	}
 }
 
 bool COList::HandleAdditionalChildren(const XMBElement& child, CXeromyces* pFile)
 {
 	#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
 	#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
 	ELMT(item);
 	ELMT(column);
 	ELMT(translatableAttribute);
 	ATTR(id);
 	ATTR(context);
 
 	if (child.GetNodeName() == elmt_item)
 	{
 		AddItem(child.GetText().FromUTF8(), child.GetText().FromUTF8());
 		return true;
 	}
 	else if (child.GetNodeName() == elmt_column)
 	{
 		COListColumn column;
 		bool hidden = false;
 
 		for (XMBAttribute attr : child.GetAttributes())
 		{
 			CStr attr_name(pFile->GetAttributeString(attr.Name));
 			CStr attr_value(attr.Value);
 
 			if (attr_name == "color")
 			{
 				CGUIColor color;
 				if (!GUI<CGUIColor>::ParseString(m_pGUI, attr_value.FromUTF8(), color))
 					LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name.c_str(), attr_value.c_str());
 				else
 					column.m_TextColor = color;
 			}
 			else if (attr_name == "id")
 			{
 				column.m_Id = attr_value;
 			}
 			else if (attr_name == "hidden")
 			{
 				if (!GUI<bool>::ParseString(m_pGUI, attr_value.FromUTF8(), hidden))
 					LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name.c_str(), attr_value.c_str());
 			}
 			else if (attr_name == "width")
 			{
 				float width;
 				if (!GUI<float>::ParseString(m_pGUI, attr_value.FromUTF8(), width))
 					LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name.c_str(), attr_value.c_str());
 				else
 				{
 					// Check if it's a relative value, and save as decimal if so.
 					if (attr_value.find("%") != std::string::npos)
 						width = width / 100.f;
 					column.m_Width = width;
 				}
 			}
 			else if (attr_name == "heading")
 			{
 				column.m_Heading = attr_value.FromUTF8();
 			}
 		}
 
 		for (XMBElement grandchild : child.GetChildNodes())
 		{
 			if (grandchild.GetNodeName() != elmt_translatableAttribute)
 				continue;
 
 			CStr attributeName(grandchild.GetAttributes().GetNamedItem(attr_id));
 			// only the heading is translatable for list column
 			if (attributeName.empty() || attributeName != "heading")
 			{
 				LOGERROR("GUI: translatable attribute in olist column that isn't a heading. (object: %s)", this->GetPresentableName().c_str());
 				continue;
 			}
 
 			CStr value(grandchild.GetText());
 			if (value.empty())
 				continue;
 
 			CStr context(grandchild.GetAttributes().GetNamedItem(attr_context)); // Read the context if any.
 			if (!context.empty())
 			{
 				CStr translatedValue(g_L10n.TranslateWithContext(context, value));
 				column.m_Heading = translatedValue.FromUTF8();
 			}
 			else
 			{
 				CStr translatedValue(g_L10n.Translate(value));
 				column.m_Heading = translatedValue.FromUTF8();
 			}
 		}
 
 		AddSetting<CGUIList>("list_" + column.m_Id);
 		AddSetting<bool>("hidden_" + column.m_Id);
 		GUI<bool>::SetSetting(this, "hidden_" + column.m_Id, hidden);
 
 		m_Columns.emplace_back(std::move(column));
 
 		SetupText();
 
 		return true;
 	}
 
 	return false;
 }
 
 void COList::DrawList(const int& selected, const CStr& _sprite, const CStr& _sprite_selected, const CStr& _textcolor)
 {
 	float bz = GetBufferedZ();
 
 	bool scrollbar;
 	GUI<bool>::GetSetting(this, "scrollbar", scrollbar);
 
 	if (scrollbar)
 		IGUIScrollBarOwner::Draw();
 
 	CRect rect = GetListRect();
 
 	CGUISpriteInstance* sprite = NULL;
 	CGUISpriteInstance* sprite_selectarea = NULL;
 	int cell_id;
 	GUI<CGUISpriteInstance>::GetSettingPointer(this, _sprite, sprite);
 	GUI<CGUISpriteInstance>::GetSettingPointer(this, _sprite_selected, sprite_selectarea);
 	GUI<int>::GetSetting(this, "cell_id", cell_id);
 
 	CGUIList* pList;
 	GUI<CGUIList>::GetSettingPointer(this, "list", pList);
 
 	GetGUI()->DrawSprite(*sprite, cell_id, bz, rect);
 
 	float scroll = 0.f;
 	if (scrollbar)
 		scroll = GetScrollBar(0).GetPos();
 
 	// Draw item selection
 	if (selected != -1)
 	{
 		ENSURE(selected >= 0 && selected+1 < (int)m_ItemsYPositions.size());
 
 		// Get rectangle of selection:
 		CRect rect_sel(rect.left, rect.top + m_ItemsYPositions[selected] - scroll,
 		               rect.right, rect.top + m_ItemsYPositions[selected+1] - scroll);
 
 		if (rect_sel.top <= rect.bottom &&
 			rect_sel.bottom >= rect.top)
 		{
 			if (rect_sel.bottom > rect.bottom)
 				rect_sel.bottom = rect.bottom;
 			if (rect_sel.top < rect.top)
 				rect_sel.top = rect.top;
 
 			if (scrollbar)
 			{
 				// Remove any overlapping area of the scrollbar.
 				if (rect_sel.right > GetScrollBar(0).GetOuterRect().left &&
 					rect_sel.right <= GetScrollBar(0).GetOuterRect().right)
 					rect_sel.right = GetScrollBar(0).GetOuterRect().left;
 
 				if (rect_sel.left >= GetScrollBar(0).GetOuterRect().left &&
 					rect_sel.left < GetScrollBar(0).GetOuterRect().right)
 					rect_sel.left = GetScrollBar(0).GetOuterRect().right;
 			}
 
 			// Draw item selection
 			GetGUI()->DrawSprite(*sprite_selectarea, cell_id, bz+0.05f, rect_sel);
 		}
 	}
 
 	// Draw line above column header
 	CGUISpriteInstance* sprite_heading = NULL;
 	GUI<CGUISpriteInstance>::GetSettingPointer(this, "sprite_heading", sprite_heading);
 	CRect rect_head(m_CachedActualSize.left, m_CachedActualSize.top, m_CachedActualSize.right,
 									m_CachedActualSize.top + m_HeadingHeight);
 	GetGUI()->DrawSprite(*sprite_heading, cell_id, bz, rect_head);
 
 	// Draw column headers
 	bool sortable;
 	GUI<bool>::GetSetting(this, "sortable", sortable);
 
 	CStr selectedColumn;
 	GUI<CStr>::GetSetting(this, "selected_column", selectedColumn);
 
 	int selectedColumnOrder;
 	GUI<int>::GetSetting(this, "selected_column_order", selectedColumnOrder);
 
 	CGUIColor color;
 	GUI<CGUIColor>::GetSetting(this, _textcolor, color);
 
 	float xpos = 0;
 	for (size_t col = 0; col < m_Columns.size(); ++col)
 	{
 		bool hidden = false;
 		GUI<bool>::GetSetting(this, "hidden_" + m_Columns[col].m_Id, hidden);
 		if (hidden)
 			continue;
 
 		// Check if it's a decimal value, and if so, assume relative positioning.
 		float width = m_Columns[col].m_Width;
 		if (m_Columns[col].m_Width < 1 && m_Columns[col].m_Width > 0)
 			width *= m_TotalAvailableColumnWidth;
 
 		CPos leftTopCorner = m_CachedActualSize.TopLeft() + CPos(xpos, 0);
 
 		// Draw sort arrows in colum header
 		if (sortable)
 		{
 			CGUISpriteInstance* sprite;
 			if (selectedColumn == m_Columns[col].m_Id)
 			{
 				if (selectedColumnOrder == 0)
 					LOGERROR("selected_column_order must not be 0");
 
 				if (selectedColumnOrder != -1)
 					GUI<CGUISpriteInstance>::GetSettingPointer(this, "sprite_asc", sprite);
 				else
 					GUI<CGUISpriteInstance>::GetSettingPointer(this, "sprite_desc", sprite);
 			}
 			else
 				GUI<CGUISpriteInstance>::GetSettingPointer(this, "sprite_not_sorted", sprite);
 
 			GetGUI()->DrawSprite(*sprite, cell_id, bz + 0.1f, CRect(leftTopCorner + CPos(width - SORT_SPRITE_DIM, 0), leftTopCorner + CPos(width, SORT_SPRITE_DIM)));
 		}
 
 		// Draw column header text
 		DrawText(col, color, leftTopCorner + COLUMN_SHIFT, bz + 0.1f, rect_head);
 		xpos += width;
 	}
 
 	// Draw list items for each column
 	const size_t objectsCount = m_Columns.size();
 	for (size_t i = 0; i < pList->m_Items.size(); ++i)
 	{
 		if (m_ItemsYPositions[i+1] - scroll < 0 ||
 			m_ItemsYPositions[i] - scroll > rect.GetHeight())
 			continue;
 
 		const float rowHeight = m_ItemsYPositions[i+1] - m_ItemsYPositions[i];
 
 		// Clipping area (we'll have to substract the scrollbar)
 		CRect cliparea = GetListRect();
 
 		if (scrollbar)
 		{
 			if (cliparea.right > GetScrollBar(0).GetOuterRect().left &&
 				cliparea.right <= GetScrollBar(0).GetOuterRect().right)
 				cliparea.right = GetScrollBar(0).GetOuterRect().left;
 
 			if (cliparea.left >= GetScrollBar(0).GetOuterRect().left &&
 				cliparea.left < GetScrollBar(0).GetOuterRect().right)
 				cliparea.left = GetScrollBar(0).GetOuterRect().right;
 		}
 
 		// Draw all items for that column
 		xpos = 0;
 		for (size_t col = 0; col < objectsCount; ++col)
 		{
 			bool hidden = false;
 			GUI<bool>::GetSetting(this, "hidden_" + m_Columns[col].m_Id, hidden);
 			if (hidden)
 				continue;
 
 			// Determine text position and width
 			const CPos textPos = rect.TopLeft() + CPos(xpos, -scroll + m_ItemsYPositions[i]);
 
 			float width = m_Columns[col].m_Width;
 			// Check if it's a decimal value, and if so, assume relative positioning.
 			if (m_Columns[col].m_Width < 1 && m_Columns[col].m_Width > 0)
 				width *= m_TotalAvailableColumnWidth;
 
 			// Clip text to the column (to prevent drawing text into the neighboring column)
 			CRect cliparea2 = cliparea;
 			cliparea2.right = std::min(cliparea2.right, textPos.x + width);
 			cliparea2.bottom = std::min(cliparea2.bottom, textPos.y + rowHeight);
 
 			// Draw list item
 			DrawText(objectsCount * (i +/*Heading*/1) + col, m_Columns[col].m_TextColor, textPos, bz + 0.1f, cliparea2);
 			xpos += width;
 		}
 	}
 }
Index: ps/trunk/source/gui/CText.cpp
===================================================================
--- ps/trunk/source/gui/CText.cpp	(revision 22678)
+++ ps/trunk/source/gui/CText.cpp	(revision 22679)
@@ -1,265 +1,265 @@
 /* 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 "CText.h"
 
 #include "gui/CGUIScrollBarVertical.h"
 #include "gui/GUI.h"
 #include "lib/ogl.h"
 
 CText::CText(CGUI* pGUI)
 	: IGUIObject(pGUI), IGUIScrollBarOwner(pGUI), IGUITextOwner(pGUI)
 {
 	AddSetting<float>("buffer_zone");
 	AddSetting<CGUIString>("caption");
 	AddSetting<int>("cell_id");
 	AddSetting<bool>("clip");
 	AddSetting<CStrW>("font");
 	AddSetting<bool>("scrollbar");
 	AddSetting<CStr>("scrollbar_style");
 	AddSetting<bool>("scroll_bottom");
 	AddSetting<bool>("scroll_top");
 	AddSetting<CGUISpriteInstance>("sprite");
 	AddSetting<EAlign>("text_align");
 	AddSetting<EVAlign>("text_valign");
 	AddSetting<CGUIColor>("textcolor");
 	AddSetting<CGUIColor>("textcolor_disabled");
 	AddSetting<CStrW>("tooltip");
 	AddSetting<CStr>("tooltip_style");
 
 	// Private settings
 	AddSetting<CStrW>("_icon_tooltip");
 	AddSetting<CStr>("_icon_tooltip_style");
 
 	//GUI<bool>::SetSetting(this, "ghost", true);
 	GUI<bool>::SetSetting(this, "scrollbar", false);
 	GUI<bool>::SetSetting(this, "clip", true);
 
 	// Add scroll-bar
 	CGUIScrollBarVertical* bar = new CGUIScrollBarVertical(pGUI);
 	bar->SetRightAligned(true);
 	AddScrollBar(bar);
 
 	// Add text
-	AddText(new SGUIText());
+	AddText();
 }
 
 CText::~CText()
 {
 }
 
 void CText::SetupText()
 {
 	if (m_GeneratedTexts.empty())
 		return;
 
 	CStrW font;
 	if (GUI<CStrW>::GetSetting(this, "font", font) != PSRETURN_OK || font.empty())
 		// Use the default if none is specified
 		// TODO Gee: (2004-08-14) Don't define standard like this. Do it with the default style.
 		font = L"default";
 
 	CGUIString* caption = nullptr;
 	GUI<CGUIString>::GetSettingPointer(this, "caption", caption);
 
 	bool scrollbar;
 	GUI<bool>::GetSetting(this, "scrollbar", scrollbar);
 
 	float width = m_CachedActualSize.GetWidth();
 	// remove scrollbar if applicable
 	if (scrollbar && GetScrollBar(0).GetStyle())
 		width -= GetScrollBar(0).GetStyle()->m_Width;
 
 
     float buffer_zone = 0.f;
 	GUI<float>::GetSetting(this, "buffer_zone", buffer_zone);
-	*m_GeneratedTexts[0] = GetGUI()->GenerateText(*caption, font, width, buffer_zone, this);
+	m_GeneratedTexts[0] = CGUIText(m_pGUI, *caption, font, width, buffer_zone, this);
 
 	if (!scrollbar)
-		CalculateTextPosition(m_CachedActualSize, m_TextPos, *m_GeneratedTexts[0]);
+		CalculateTextPosition(m_CachedActualSize, m_TextPos, m_GeneratedTexts[0]);
 
 	// Setup scrollbar
 	if (scrollbar)
 	{
 		bool scroll_top = false, scroll_bottom = false;
 		GUI<bool>::GetSetting(this, "scroll_bottom", scroll_bottom);
 		GUI<bool>::GetSetting(this, "scroll_top", scroll_top);
 
 		// If we are currently scrolled to the bottom of the text,
 		// then add more lines of text, update the scrollbar so we
 		// stick to the bottom.
 		// (Use 1.5px delta so this triggers the first time caption is set)
 		bool bottom = false;
 		if (scroll_bottom && GetScrollBar(0).GetPos() > GetScrollBar(0).GetMaxPos() - 1.5f)
 			bottom = true;
 
-		GetScrollBar(0).SetScrollRange(m_GeneratedTexts[0]->m_Size.cy);
+		GetScrollBar(0).SetScrollRange(m_GeneratedTexts[0].GetSize().cy);
 		GetScrollBar(0).SetScrollSpace(m_CachedActualSize.GetHeight());
 
 		GetScrollBar(0).SetX(m_CachedActualSize.right);
 		GetScrollBar(0).SetY(m_CachedActualSize.top);
 		GetScrollBar(0).SetZ(GetBufferedZ());
 		GetScrollBar(0).SetLength(m_CachedActualSize.bottom - m_CachedActualSize.top);
 
 		if (bottom)
 			GetScrollBar(0).SetPos(GetScrollBar(0).GetMaxPos());
 		if (scroll_top)
 			GetScrollBar(0).SetPos(0.0f);
 	}
 }
 
 void CText::HandleMessage(SGUIMessage& Message)
 {
 	IGUIScrollBarOwner::HandleMessage(Message);
 	//IGUITextOwner::HandleMessage(Message); <== placed it after the switch instead!
 
 	switch (Message.type)
 	{
 	case GUIM_SETTINGS_UPDATED:
 		if (Message.value == "scrollbar")
 			SetupText();
 
 		// Update scrollbar
 		if (Message.value == "scrollbar_style")
 		{
 			CStr scrollbar_style;
 			GUI<CStr>::GetSetting(this, Message.value, scrollbar_style);
 
 			GetScrollBar(0).SetScrollBarStyle(scrollbar_style);
 
 			SetupText();
 		}
 
 		break;
 
 	case GUIM_MOUSE_WHEEL_DOWN:
 	{
 		GetScrollBar(0).ScrollPlus();
 		// Since the scroll was changed, let's simulate a mouse movement
 		//  to check if scrollbar now is hovered
 		SGUIMessage msg(GUIM_MOUSE_MOTION);
 		HandleMessage(msg);
 		break;
 	}
 	case GUIM_MOUSE_WHEEL_UP:
 	{
 		GetScrollBar(0).ScrollMinus();
 		// Since the scroll was changed, let's simulate a mouse movement
 		//  to check if scrollbar now is hovered
 		SGUIMessage msg(GUIM_MOUSE_MOTION);
 		HandleMessage(msg);
 		break;
 	}
 	case GUIM_LOAD:
 	{
 		GetScrollBar(0).SetX(m_CachedActualSize.right);
 		GetScrollBar(0).SetY(m_CachedActualSize.top);
 		GetScrollBar(0).SetZ(GetBufferedZ());
 		GetScrollBar(0).SetLength(m_CachedActualSize.bottom - m_CachedActualSize.top);
 
 		CStr scrollbar_style;
 		GUI<CStr>::GetSetting(this, "scrollbar_style", scrollbar_style);
 		GetScrollBar(0).SetScrollBarStyle(scrollbar_style);
 		break;
 	}
 
 	default:
 		break;
 	}
 
 	IGUITextOwner::HandleMessage(Message);
 }
 
 void CText::Draw()
 {
 	float bz = GetBufferedZ();
 
 	// First call draw on ScrollBarOwner
 	bool scrollbar;
 	GUI<bool>::GetSetting(this, "scrollbar", scrollbar);
 
 	if (scrollbar)
 		// Draw scrollbar
 		IGUIScrollBarOwner::Draw();
 
 	CGUISpriteInstance* sprite;
 	int cell_id;
 	bool clip;
 	GUI<CGUISpriteInstance>::GetSettingPointer(this, "sprite", sprite);
 	GUI<int>::GetSetting(this, "cell_id", cell_id);
 	GUI<bool>::GetSetting(this, "clip", clip);
 
 	GetGUI()->DrawSprite(*sprite, cell_id, bz, m_CachedActualSize);
 
 	float scroll = 0.f;
 	if (scrollbar)
 		scroll = GetScrollBar(0).GetPos();
 
 	// Clipping area (we'll have to subtract the scrollbar)
 	CRect cliparea;
 	if (clip)
 	{
 		cliparea = m_CachedActualSize;
 
 		if (scrollbar)
 		{
 			// subtract scrollbar from cliparea
 			if (cliparea.right > GetScrollBar(0).GetOuterRect().left &&
 			    cliparea.right <= GetScrollBar(0).GetOuterRect().right)
 				cliparea.right = GetScrollBar(0).GetOuterRect().left;
 
 			if (cliparea.left >= GetScrollBar(0).GetOuterRect().left &&
 			    cliparea.left < GetScrollBar(0).GetOuterRect().right)
 				cliparea.left = GetScrollBar(0).GetOuterRect().right;
 		}
 	}
 
 	bool enabled;
 	GUI<bool>::GetSetting(this, "enabled", enabled);
 
 	CGUIColor color;
 	GUI<CGUIColor>::GetSetting(this, enabled ? "textcolor" : "textcolor_disabled", color);
 
 	if (scrollbar)
 		DrawText(0, color, m_CachedActualSize.TopLeft() - CPos(0.f, scroll), bz+0.1f, cliparea);
 	else
 		DrawText(0, color, m_TextPos, bz+0.1f, cliparea);
 }
 
 bool CText::MouseOverIcon()
 {
-	for (SGUIText* const& guitext : m_GeneratedTexts)
-		for (const SGUIText::SSpriteCall& spritecall : guitext->m_SpriteCalls)
+	for (const CGUIText& guitext : m_GeneratedTexts)
+		for (const CGUIText::SSpriteCall& spritecall : guitext.GetSpriteCalls())
 		{
 			// Check mouse over sprite
 			if (!spritecall.m_Area.PointInside(m_pGUI->GetMousePos() - m_CachedActualSize.TopLeft()))
 				continue;
 
 			// If tooltip exists, set the property
 			if (!spritecall.m_Tooltip.empty())
 			{
 				SetSetting("_icon_tooltip_style", spritecall.m_TooltipStyle);
 				SetSetting("_icon_tooltip", spritecall.m_Tooltip);
 			}
 
 			return true;
 		}
 
 	return false;
 }
Index: ps/trunk/source/gui/CTooltip.cpp
===================================================================
--- ps/trunk/source/gui/CTooltip.cpp	(revision 22678)
+++ ps/trunk/source/gui/CTooltip.cpp	(revision 22679)
@@ -1,170 +1,169 @@
 /* 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 "CTooltip.h"
 #include "CGUI.h"
 
 #include <algorithm>
 
 CTooltip::CTooltip(CGUI* pGUI)
 	: IGUIObject(pGUI), IGUITextOwner(pGUI)
 {
 	// If the tooltip is an object by itself:
 	AddSetting<float>("buffer_zone");
 	AddSetting<CGUIString>("caption");
 	AddSetting<CStrW>("font");
 	AddSetting<CGUISpriteInstance>("sprite");
 	AddSetting<int>("delay");
 	AddSetting<CGUIColor>("textcolor");
 	AddSetting<float>("maxwidth");
 	AddSetting<CPos>("offset");
 	AddSetting<EVAlign>("anchor");
 	AddSetting<EAlign>("text_align");
 	// This is used for tooltips that are hidden/revealed manually by scripts, rather than through the standard tooltip display mechanism
 	AddSetting<bool>("independent");
 
 	// If the tooltip is just a reference to another object:
 	AddSetting<CStr>("use_object");
 	AddSetting<bool>("hide_object");
 
 	// Private settings:
 	// This is set by GUITooltip
 	AddSetting<CPos>("_mousepos");
 
 	// Defaults
 	GUI<int>::SetSetting(this, "delay", 500);
 	GUI<EVAlign>::SetSetting(this, "anchor", EVAlign_Bottom);
 	GUI<EAlign>::SetSetting(this, "text_align", EAlign_Left);
 
 	// Set up a blank piece of text, to be replaced with a more
 	// interesting message later
-	AddText(new SGUIText());
+	AddText();
 }
 
 CTooltip::~CTooltip()
 {
 }
 
 void CTooltip::SetupText()
 {
 	ENSURE(m_GeneratedTexts.size() == 1);
 
 	CStrW font;
 	if (GUI<CStrW>::GetSetting(this, "font", font) != PSRETURN_OK || font.empty())
 		font = L"default";
 
 	float buffer_zone = 0.f;
 	GUI<float>::GetSetting(this, "buffer_zone", buffer_zone);
 
 	CGUIString* caption = nullptr;
 	GUI<CGUIString>::GetSettingPointer(this, "caption", caption);
 
 	float max_width = 0.f;
 	GUI<float>::GetSetting(this, "maxwidth", max_width);
 
-	*m_GeneratedTexts[0] = GetGUI()->GenerateText(*caption, font, max_width, buffer_zone, this);
-
+	m_GeneratedTexts[0] = CGUIText(m_pGUI, *caption, font, max_width, buffer_zone, this);
 
 	// Position the tooltip relative to the mouse:
 
 	CPos mousepos, offset;
 	EVAlign anchor;
 	bool independent;
 
 	GUI<bool>::GetSetting(this, "independent", independent);
 	if (independent)
 		mousepos = m_pGUI->GetMousePos();
 	else
 		GUI<CPos>::GetSetting(this, "_mousepos", mousepos);
 
 	GUI<CPos>::GetSetting(this, "offset", offset);
 	GUI<EVAlign>::GetSetting(this, "anchor", anchor);
 
-	float textwidth = m_GeneratedTexts[0]->m_Size.cx;
-	float textheight = m_GeneratedTexts[0]->m_Size.cy;
+	float textwidth = m_GeneratedTexts[0].GetSize().cx;
+	float textheight = m_GeneratedTexts[0].GetSize().cy;
 
 	CClientArea size;
 	size.pixel.left = mousepos.x + offset.x;
 	size.pixel.right = size.pixel.left + textwidth;
 	switch (anchor)
 	{
 	case EVAlign_Top:
 		size.pixel.top = mousepos.y + offset.y;
 		size.pixel.bottom = size.pixel.top + textheight;
 		break;
 	case EVAlign_Bottom:
 		size.pixel.bottom = mousepos.y + offset.y;
 		size.pixel.top = size.pixel.bottom - textheight;
 		break;
 	case EVAlign_Center:
 		size.pixel.top = mousepos.y + offset.y - textheight/2.f;
 		size.pixel.bottom = size.pixel.top + textwidth;
 		break;
 	default:
 		debug_warn(L"Invalid EVAlign!");
 	}
 
 
 	// Reposition the tooltip if it's falling off the screen:
 
 	extern int g_xres, g_yres;
 	extern float g_GuiScale;
 	float screenw = g_xres / g_GuiScale;
 	float screenh = g_yres / g_GuiScale;
 
 	if (size.pixel.top < 0.f)
 		size.pixel.bottom -= size.pixel.top, size.pixel.top = 0.f;
 	else if (size.pixel.bottom > screenh)
 		size.pixel.top -= (size.pixel.bottom-screenh), size.pixel.bottom = screenh;
 
 	if (size.pixel.left < 0.f)
 		size.pixel.right -= size.pixel.left, size.pixel.left = 0.f;
 	else if (size.pixel.right > screenw)
 		size.pixel.left -= (size.pixel.right-screenw), size.pixel.right = screenw;
 
 	GUI<CClientArea>::SetSetting(this, "size", size);
 }
 
 void CTooltip::HandleMessage(SGUIMessage& Message)
 {
 	IGUITextOwner::HandleMessage(Message);
 }
 
 void CTooltip::Draw()
 {
 	float z = 900.f; // TODO: Find a nicer way of putting the tooltip on top of everything else
 
 	CGUISpriteInstance* sprite;
 	GUI<CGUISpriteInstance>::GetSettingPointer(this, "sprite", sprite);
 
 	// Normally IGUITextOwner will handle this updating but since SetupText can modify the position
 	// we need to call it now *before* we do the rest of the drawing
 	if (!m_GeneratedTextsValid)
 	{
 		SetupText();
 		m_GeneratedTextsValid = true;
 	}
 
 	GetGUI()->DrawSprite(*sprite, 0, z, m_CachedActualSize);
 
 	CGUIColor color;
 	GUI<CGUIColor>::GetSetting(this, "textcolor", color);
 
 	DrawText(0, color, m_CachedActualSize.TopLeft(), z+0.1f);
 }
Index: ps/trunk/source/gui/GUI.h
===================================================================
--- ps/trunk/source/gui/GUI.h	(revision 22678)
+++ ps/trunk/source/gui/GUI.h	(revision 22679)
@@ -1,53 +1,39 @@
-/* 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/>.
  */
 
-/*
-GUI Inclusion file
-
---Overview--
-
-	Include this file and it will include the whole GUI.
-
---More info--
-
-	Check TDD for GUI Engine Documentation
-
-*/
-
-
 #ifndef INCLUDED_GUI
 #define INCLUDED_GUI
 
 #include <map>
 #include <stddef.h>
 #include <string>
 #include <vector>
 
 #include "ps/CStr.h"
 
 #include "CGUIList.h"
 #include "CGUISeries.h"
+#include "CGUIText.h"
 #include "GUIbase.h"
-#include "GUItext.h"
 #include "GUIutil.h"
 #include "IGUIButtonBehavior.h"
 #include "IGUIObject.h"
 #include "IGUIScrollBarOwner.h" // Required by IGUIScrollBar
 #include "IGUIScrollBar.h"
 #include "IGUITextOwner.h"
 
 #endif // INCLUDED_GUI
Index: ps/trunk/source/gui/IGUIObject.h
===================================================================
--- ps/trunk/source/gui/IGUIObject.h	(revision 22678)
+++ ps/trunk/source/gui/IGUIObject.h	(revision 22679)
@@ -1,486 +1,486 @@
 /* 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 "IGUIObject.h"
 
+#include "gui/GUIbase.h"
 #include "gui/scripting/JSInterface_IGUIObject.h"
 #include "lib/input.h" // just for IN_PASS
 #include "ps/XML/Xeromyces.h"
 
 #include <functional>
 #include <string>
 #include <vector>
 
 struct SGUIStyle;
 class CGUI;
 
 class JSObject;
 class IGUISetting;
 
 ERROR_TYPE(GUI, UnableToParse);
 
 /**
  * GUI object such as a button or an input-box.
  * Abstract data type !
  */
 class IGUIObject
 {
 	friend class CGUI;
 	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, JS::MutableHandleValue vp, JS::ObjectOpResult& result);
 	friend bool JSI_IGUIObject::getComputedSize(JSContext* cx, uint argc, JS::Value* vp);
 
 public:
 	NONCOPYABLE(IGUIObject);
 
 	IGUIObject(CGUI* pGUI);
 	virtual ~IGUIObject();
 
 	/**
 	 * 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 */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Returns whether there is a setting with the given name registered.
 	 *
 	 * @param Setting setting name
 	 * @return True if settings exist.
 	 */
 	bool SettingExists(const CStr& Setting) const;
 
 	/**
 	 * All sizes are relative to resolution, and the calculation
 	 * is not wanted in real time, therefore it is cached, update
 	 * the cached size with this function.
 	 */
 	virtual void UpdateCachedSize();
 
 	/**
 	 * Reset internal state of this object.
 	 */
 	virtual void ResetStates();
 
 	/**
 	 * Set a setting by string, regardless of what type it is.
 	 *
 	 * example a CRect(10,10,20,20) would be "10 10 20 20"
 	 *
 	 * @param Setting Setting by name
 	 * @param Value Value to set to
 	 * @param SkipMessage Does not send a GUIM_SETTINGS_UPDATED if true
 	 *
 	 * @return PSRETURN (PSRETURN_OK if successful)
 	 */
 	PSRETURN SetSetting(const CStr& Setting, const CStrW& Value, const bool& SkipMessage = false);
 
 	/**
 	 * 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);
 
 	/**
 	 * Creates the JS Object representing this page upon first use.
 	 * Can be overridden by derived classes to extend it.
 	 */
 	virtual void CreateJSObject();
 
 	/**
 	 * 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
 	 */
 	template<typename T> void AddSetting(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& pGUI, 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;
 
 	/**
 	 * Set parent of this object
 	 */
 	void SetParent(IGUIObject* pParent) { m_pParent = pParent; }
 
 public:
 
 	CGUI* GetGUI() { return m_pGUI; }
 	const CGUI* GetGUI() const { return m_pGUI; }
 
 	/**
 	 * Take focus!
 	 */
 	void SetFocus();
 
 	/**
 	 * Workaround to avoid a dynamic_cast which can be 80 times slower than this.
 	 */
 	virtual void* GetTextOwner() { return nullptr; }
 
 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;
 
 	/**
 	 * Handle additional children to the \<object\>-tag. In IGUIObject, this function does
 	 * nothing. In CList and CDropDown, it handles the \<item\>, used to build the data.
 	 *
 	 * Returning false means the object doesn't recognize the child. Should be reported.
 	 * Notice 'false' is default, because an object not using this function, should not
 	 * have any additional children (and this function should never be called).
 	 */
 	virtual bool HandleAdditionalChildren(const XMBElement& UNUSED(child), CXeromyces* UNUSED(pFile))
 	{
 		return false;
 	}
 
 	/**
 	 * Cached size, real size m_Size is actually dependent on resolution
 	 * and can have different *real* outcomes, this is the real outcome
 	 * cached to avoid slow calculations in real time.
 	 */
 	CRect m_CachedActualSize;
 
 	/**
 	 * Send event to this GUI object (HandleMessage and ScriptEvent)
 	 *
 	 * @param type Type of GUI message to be handled
 	 * @param EventName String representation of event name
 	 * @return IN_HANDLED if event was handled, or IN_PASS if skipped
 	 */
 	InReaction SendEvent(EGUIMessageType type, const CStr& EventName);
 
 	/**
 	 * Execute the script for a particular action.
 	 * Does nothing if no script has been registered for that action.
 	 * The mouse coordinates will be passed as the first argument.
 	 *
 	 * @param Action Name of action
 	 */
 	void ScriptEvent(const CStr& Action);
 
 	/**
 	 * Execute the script for a particular action.
 	 * Does nothing if no script has been registered for that action.
 	 *
 	 * @param Action Name of action
 	 * @param paramData JS::HandleValueArray arguments to pass to the event.
 	 */
 	void ScriptEvent(const CStr& Action, JS::HandleValueArray paramData);
 
 	void SetScriptHandler(const CStr& Action, JS::HandleObject Function);
 
 	/**
 	 * Inputes the object that is currently hovered, this function
 	 * updates this object accordingly (i.e. if it's the object
 	 * being inputted one thing happens, and not, another).
 	 *
 	 * @param pMouseOver	Object that is currently hovered,
 	 *						can OF COURSE be NULL too!
 	 */
 	void UpdateMouseOver(IGUIObject* const& pMouseOver);
 
 	//@}
 private:
 	//--------------------------------------------------------
 	/** @name Internal functions */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Inputs a reference pointer, checks if the new inputted object
 	 * if hovered, if so, then check if this's Z value is greater
 	 * than the inputted object... If so then the object is closer
 	 * and we'll replace the pointer with this.
 	 * Also Notice input can be NULL, which means the Z value demand
 	 *  is out. NOTICE you can't input NULL as const so you'll have
 	 * to set an object to NULL.
 	 *
 	 * @param pObject	Object pointer, can be either the old one, or
 	 *					the new one.
 	 */
 	void ChooseMouseOverAndClosest(IGUIObject*& pObject);
 
 	// Is the object a Root object, in philosophy, this means it
 	//  has got no parent, and technically, it's got the m_BaseObject
 	//  as parent.
 	bool IsRootObject() const;
 
 	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, IGUISetting*> m_Settings;
 
 protected:
 	// An object can't function stand alone
 	CGUI* const 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:
 	CGUIDummyObject(CGUI* pGUI) : IGUIObject(pGUI) {}
 
 	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/IGUITextOwner.cpp
===================================================================
--- ps/trunk/source/gui/IGUITextOwner.cpp	(revision 22678)
+++ ps/trunk/source/gui/IGUITextOwner.cpp	(revision 22679)
@@ -1,142 +1,149 @@
 /* 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 "IGUITextOwner.h"
 
 #include "gui/GUI.h"
 #include "gui/scripting/JSInterface_IGUITextOwner.h"
 
+#include <math.h>
+
 IGUITextOwner::IGUITextOwner(CGUI* pGUI)
 	: IGUIObject(pGUI), m_GeneratedTextsValid(false)
 {
 }
 
 IGUITextOwner::~IGUITextOwner()
 {
-	for (SGUIText* const& t : m_GeneratedTexts)
-		delete t;
 }
 
 void IGUITextOwner::CreateJSObject()
 {
 	IGUIObject::CreateJSObject();
 
 	JSI_IGUITextOwner::RegisterScriptFunctions(
 		GetGUI()->GetScriptInterface()->GetContext(), m_JSObject);
 }
 
-void IGUITextOwner::AddText(SGUIText* text)
+CGUIText& IGUITextOwner::AddText()
+{
+	m_GeneratedTexts.emplace_back();
+	return m_GeneratedTexts.back();
+}
+
+CGUIText& IGUITextOwner::AddText(const CGUIString& Text, const CStrW& Font, const float& Width, const float& BufferZone, const IGUIObject* pObject)
 {
-	m_GeneratedTexts.push_back(text);
+	// Avoids a move constructor
+	m_GeneratedTexts.emplace_back(m_pGUI, Text, Font, Width, BufferZone, pObject);
+	return m_GeneratedTexts.back();
 }
 
 void IGUITextOwner::HandleMessage(SGUIMessage& Message)
 {
 	switch (Message.type)
 	{
 	case GUIM_SETTINGS_UPDATED:
 		// Everything that can change the visual appearance.
 		//  it is assumed that the text of the object will be dependent on
 		//  these. Although that is not certain, but one will have to manually
 		//  change it and disregard this function.
 		// TODO Gee: (2004-09-07) Make sure this is all options that can affect the text.
 		if (Message.value == "size" || Message.value == "z" ||
 			Message.value == "absolute" || Message.value == "caption" ||
 			Message.value == "font" || Message.value == "textcolor" ||
 			Message.value == "text_align" || Message.value == "text_valign" ||
 			Message.value == "buffer_zone")
 		{
 			m_GeneratedTextsValid = false;
 		}
 		break;
 
 	default:
 		break;
 	}
 }
 
 void IGUITextOwner::UpdateCachedSize()
 {
 	// If an ancestor's size changed, this will let us intercept the change and
 	// update our text positions
 
 	IGUIObject::UpdateCachedSize();
 	m_GeneratedTextsValid = false;
 }
 
 void IGUITextOwner::DrawText(size_t index, const CGUIColor& color, const CPos& pos, float z, const CRect& clipping)
 {
 	if (!m_GeneratedTextsValid)
 	{
 		SetupText();
 		m_GeneratedTextsValid = true;
 	}
 
 	ENSURE(index < m_GeneratedTexts.size() && "Trying to draw a Text Index within a IGUITextOwner that doesn't exist");
 
-	if (GetGUI())
-		GetGUI()->DrawText(*m_GeneratedTexts[index], color, pos, z, clipping);
+	m_GeneratedTexts.at(index).Draw(m_pGUI, color, pos, z, clipping);
 }
 
-void IGUITextOwner::CalculateTextPosition(CRect& ObjSize, CPos& TextPos, SGUIText& Text)
+void IGUITextOwner::CalculateTextPosition(CRect& ObjSize, CPos& TextPos, CGUIText& Text)
 {
 	EVAlign valign;
 	GUI<EVAlign>::GetSetting(this, "text_valign", valign);
 
 	// The horizontal Alignment is now computed in GenerateText in order to not have to
 	// loop through all of the TextCall objects again.
 	TextPos.x = ObjSize.left;
 
 	switch (valign)
 	{
 	case EVAlign_Top:
 		TextPos.y = ObjSize.top;
 		break;
 	case EVAlign_Center:
 		// Round to integer pixel values, else the fonts look awful
-		TextPos.y = floorf(ObjSize.CenterPoint().y - Text.m_Size.cy/2.f);
+		TextPos.y = floorf(ObjSize.CenterPoint().y - Text.GetSize().cy / 2.f);
 		break;
 	case EVAlign_Bottom:
-		TextPos.y = ObjSize.bottom - Text.m_Size.cy;
+		TextPos.y = ObjSize.bottom - Text.GetSize().cy;
 		break;
 	default:
 		debug_warn(L"Broken EVAlign in CButton::SetupText()");
 		break;
 	}
 }
 
 CSize IGUITextOwner::CalculateTextSize()
 {
 	if (!m_GeneratedTextsValid)
 	{
 		SetupText();
 		m_GeneratedTextsValid = true;
 	}
 
 	if (m_GeneratedTexts.empty())
 		return CSize();
 
 	// GUI Object types that use multiple texts may override this function.
-	return m_GeneratedTexts[0]->m_Size;
+	return m_GeneratedTexts[0].GetSize();
 }
 
 bool IGUITextOwner::MouseOverIcon()
 {
 	return false;
 }
Index: ps/trunk/source/gui/IGUITextOwner.h
===================================================================
--- ps/trunk/source/gui/IGUITextOwner.h	(revision 22678)
+++ ps/trunk/source/gui/IGUITextOwner.h	(revision 22679)
@@ -1,124 +1,129 @@
 /* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /*
 GUI Object Base - Text Owner
 
 --Overview--
 
 	Interface class that enhance the IGUIObject with
 	 cached CGUIStrings. This class is not at all needed,
 	 and many controls that will use CGUIStrings might
 	 not use this, but does help for regular usage such
 	 as a text-box, a button, a radio button etc.
 
 --More info--
 
 	Check GUI.h
 
 */
 
 #ifndef INCLUDED_IGUITEXTOWNER
 #define INCLUDED_IGUITEXTOWNER
 
 #include "GUI.h"
 #include "gui/scripting/JSInterface_IGUITextOwner.h"
 
 /**
  * Framework for handling Output text.
  *
  * @see IGUIObject
  */
 class IGUITextOwner : virtual public IGUIObject
 {
 	friend bool JSI_IGUITextOwner::GetTextSize(JSContext* cx, uint argc, JS::Value* vp);
 
 public:
 	IGUITextOwner(CGUI* pGUI);
 	virtual ~IGUITextOwner();
 
 	/**
 	 * Adds a text object.
 	 */
-	void AddText(SGUIText* text);
+	CGUIText& AddText();
+
+	/**
+	 * Adds a text generated by the given arguments.
+	 */
+	CGUIText& AddText(const CGUIString& Text, const CStrW& Font, const float& Width, const float& BufferZone, const IGUIObject* pObject = nullptr);
 
 	/**
 	 * Subscribe the custom JS methods.
 	 */
 	void CreateJSObject();
 
 	/**
 	 * @see IGUIObject#HandleMessage()
 	 */
 	virtual void HandleMessage(SGUIMessage& Message);
 
 	/**
 	 * @see IGUIObject#UpdateCachedSize()
 	 */
 	virtual void UpdateCachedSize();
 
 	/**
 	 * Draws the Text.
 	 *
 	 * @param index Index value of text. Mostly this will be 0
 	 * @param color
 	 * @param pos Position
 	 * @param z Z value
 	 * @param clipping Clipping rectangle, don't even add a parameter
 	 *		  to get no clipping.
 	 */
 	virtual void DrawText(size_t index, const CGUIColor& color, const CPos& pos, float z, const CRect& clipping = CRect());
 
 	/**
 	 * Test if mouse position is over an icon
 	 */
 	virtual bool MouseOverIcon();
 
 	/**
 	 * Workaround to avoid a dynamic_cast which can be 80 times slower than this.
 	 */
 	virtual void* GetTextOwner() { return this; }
 
 protected:
 
 	/**
 	 * Setup texts. Functions that sets up all texts when changes have been made.
 	 */
 	virtual void SetupText() = 0;
 
 	/**
 	 * Whether the cached text is currently valid (if not then SetupText will be called by Draw)
 	 */
 	bool m_GeneratedTextsValid;
 
 	/**
 	 * Texts that are generated and ready to be rendered.
 	 */
-	std::vector<SGUIText*> m_GeneratedTexts;
+	std::vector<CGUIText> m_GeneratedTexts;
 
 	/**
 	 * Calculate the position for the text, based on the alignment.
 	 */
-	void CalculateTextPosition(CRect& ObjSize, CPos& TextPos, SGUIText& Text);
+	void CalculateTextPosition(CRect& ObjSize, CPos& TextPos, CGUIText& Text);
 
 	/**
 	 * Calculate the size of the first generated text.
 	 */
 	CSize CalculateTextSize();
 };
 
 #endif // INCLUDED_IGUITEXTOWNER