Index: ps/trunk/source/graphics/Color.cpp
===================================================================
--- ps/trunk/source/graphics/Color.cpp	(revision 22693)
+++ ps/trunk/source/graphics/Color.cpp	(revision 22694)
@@ -1,147 +1,150 @@
 /* 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 "graphics/Color.h"
 
 #include "graphics/SColor.h"
 #include "maths/MathUtil.h"
 #include "ps/CLogger.h"
 #include "ps/CStr.h"
 
 #if HAVE_SSE
 # include <xmmintrin.h>
 # include "lib/sysdep/arch/x86_x64/x86_x64.h"
 #endif
 
 static SColor4ub fallback_ConvertRGBColorTo4ub(const RGBColor& src)
 {
 	SColor4ub result;
 	result.R = clamp(static_cast<int>(src.X * 255), 0, 255);
 	result.G = clamp(static_cast<int>(src.Y * 255), 0, 255);
 	result.B = clamp(static_cast<int>(src.Z * 255), 0, 255);
 	result.A = 255;
 	return result;
 }
 
 // on IA32, this is replaced by an SSE assembly version in ia32.cpp
 SColor4ub (*ConvertRGBColorTo4ub)(const RGBColor& src) = fallback_ConvertRGBColorTo4ub;
 
 
 // Assembler-optimized function for color conversion
 #if HAVE_SSE
 static SColor4ub sse_ConvertRGBColorTo4ub(const RGBColor& src)
 {
 	const __m128 zero = _mm_setzero_ps();
 	const __m128 _255 = _mm_set_ss(255.0f);
 	__m128 r = _mm_load_ss(&src.X);
 	__m128 g = _mm_load_ss(&src.Y);
 	__m128 b = _mm_load_ss(&src.Z);
 
 	// C = min(255, 255*max(C, 0)) ( == clamp(255*C, 0, 255) )
 	r = _mm_max_ss(r, zero);
 	g = _mm_max_ss(g, zero);
 	b = _mm_max_ss(b, zero);
 
 	r = _mm_mul_ss(r, _255);
 	g = _mm_mul_ss(g, _255);
 	b = _mm_mul_ss(b, _255);
 
 	r = _mm_min_ss(r, _255);
 	g = _mm_min_ss(g, _255);
 	b = _mm_min_ss(b, _255);
 
 	// convert to integer and combine channels using bit logic
 	int ri = _mm_cvtss_si32(r);
 	int gi = _mm_cvtss_si32(g);
 	int bi = _mm_cvtss_si32(b);
 
 	return SColor4ub(ri, gi, bi, 0xFF);
 }
 #endif
 
 void ColorActivateFastImpl()
 {
 	if(0)
 	{
 	}
 #if HAVE_SSE
 	else if (x86_x64::Cap(x86_x64::CAP_SSE))
 	{
 		ConvertRGBColorTo4ub = sse_ConvertRGBColorTo4ub;
 	}
 #endif
 	else
 	{
 		debug_printf("No SSE available. Slow fallback routines will be used.\n");
 	}
 }
 
+/**
+ * Important: This function does not modify the value if parsing fails.
+ */
 bool CColor::ParseString(const CStr8& value, int defaultAlpha)
 {
 	const size_t NUM_VALS = 4;
 	int values[NUM_VALS] = { 0, 0, 0, defaultAlpha };
 	std::stringstream stream;
 	stream.str(value);
 	// Parse each value
 	size_t i;
 	for (i = 0; i < NUM_VALS; ++i)
 	{
 		if (stream.eof())
 			break;
 
 		stream >> values[i];
 		if ((stream.rdstate() & std::stringstream::failbit) != 0)
 		{
 			LOGWARNING("Unable to parse CColor parameters. Your input: '%s'", value.c_str());
 			return false;
 		}
 		if (values[i] < 0 || values[i] > 255)
 		{
 			LOGWARNING("Invalid value (<0 or >255) when parsing CColor parameters. Your input: '%s'", value.c_str());
 			return false;
 		}
 	}
 
 	if (i < 3)
 	{
 		LOGWARNING("Not enough parameters when parsing as CColor. Your input: '%s'", value.c_str());
 		return false;
 	}
 	if (!stream.eof())
 	{
 		LOGWARNING("Too many parameters when parsing as CColor. Your input: '%s'", value.c_str());
 		return false;
 	}
 
 	r = values[0] / 255.f;
 	g = values[1] / 255.f;
 	b = values[2] / 255.f;
 	a = values[3] / 255.f;
 
 	return true;
 }
 
 bool CColor::operator==(const CColor& color) const
 {
 	return
 		r == color.r &&
 		g == color.g &&
 		b == color.b &&
 		a == color.a;
 }
Index: ps/trunk/source/graphics/Color.h
===================================================================
--- ps/trunk/source/graphics/Color.h	(revision 22693)
+++ ps/trunk/source/graphics/Color.h	(revision 22694)
@@ -1,84 +1,85 @@
 /* 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_COLOR
 #define INCLUDED_COLOR
 
 #include "graphics/SColor.h"
 #include "maths/Vector3D.h"
 #include "maths/Vector4D.h"
 
 // Simple defines for 3 and 4 component floating point colors - just map to
 // corresponding vector types.
 typedef CVector3D RGBColor;
 typedef CVector4D RGBAColor;
 
 // Convert float RGB(A) colors to unsigned byte.
 // Exposed as function pointer because it is set at init-time to
 // one of several implementations depending on CPU caps.
 extern SColor4ub (*ConvertRGBColorTo4ub)(const RGBColor& src);
 
 // call once ia32_Init has run; detects CPU caps and activates the best
 // possible codepath.
 extern void ColorActivateFastImpl();
 
 class CStr8;
 
 struct CColor
 {
 	CColor() : r(-1.f), g(-1.f), b(-1.f), a(1.f) {}
 	CColor(float cr, float cg, float cb, float ca) : r(cr), g(cg), b(cb), a(ca) {}
 
 	/**
 	 * Returns whether this has been set to a valid color.
 	 */
 	operator bool() const
 	{
 		return r >= 0 && g >= 0 && b >= 0 && a >= 0;
 	}
 
 	/**
 	 * Try to parse @p Value as a color. Returns true on success, false otherwise.
+	 * Leaves the color unchanged if it failed.
 	 * @param value Should be "r g b" or "r g b a" where each value is an integer in [0,255].
 	 * @param defaultAlpha The alpha value that is used if the format of @p Value is "r g b".
 	 */
 	bool ParseString(const CStr8& value, int defaultAlpha = 255);
 
 	bool operator==(const CColor& color) const;
 	bool operator!=(const CColor& color) const
 	{
 		return !(*this == color);
 	}
 
 	// For passing to glColor[34]fv:
 	const float* FloatArray() const { return &r; }
 
 	// For passing to CRenderer:
 	SColor4ub AsSColor4ub() const
 	{
 		return SColor4ub(
 			static_cast<u8>(r * 255.f),
 			static_cast<u8>(g * 255.f),
 			static_cast<u8>(b * 255.f),
 			static_cast<u8>(a * 255.f)
 		);
 	}
 
 	float r, g, b, a;
 };
 
 #endif // INCLUDED_COLOR
Index: ps/trunk/source/gui/CButton.cpp
===================================================================
--- ps/trunk/source/gui/CButton.cpp	(revision 22693)
+++ ps/trunk/source/gui/CButton.cpp	(revision 22694)
@@ -1,109 +1,108 @@
 /* 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");
 
 	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";
 
 	const CGUIString& caption = GUI<CGUIString>::GetSetting(this, "caption");
 
 	float buffer_zone = 0.f;
 	GUI<float>::GetSetting(this, "buffer_zone", buffer_zone);
 
 	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();
 
 	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");
 
 	CGUISpriteInstance& sprite = GUI<CGUISpriteInstance>::GetSetting(this, strSprite);
 	CGUISpriteInstance& sprite_over = GUI<CGUISpriteInstance>::GetSetting(this, strSpriteOver);
 	CGUISpriteInstance& sprite_pressed = GUI<CGUISpriteInstance>::GetSetting(this, strSpritePressed);
 	CGUISpriteInstance& sprite_disabled = GUI<CGUISpriteInstance>::GetSetting(this, strSpriteDisabled);
 
 	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);
+	DrawText(0, ChooseColor(), m_TextPos, bz + 0.1f);
 }
Index: ps/trunk/source/gui/CChart.cpp
===================================================================
--- ps/trunk/source/gui/CChart.cpp	(revision 22693)
+++ ps/trunk/source/gui/CChart.cpp	(revision 22694)
@@ -1,321 +1,319 @@
 /* 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);
+	DrawTriangleStrip(shader, GUI<CGUIColor>::GetSetting(this, "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()
 {
 	const CGUISeries& pSeries = GUI<CGUISeries>::GetSetting(this, "series");
 	const CGUIList& pSeriesColor = GUI<CGUIList>::GetSetting(this, "series_color");
 
 	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()
 {
 	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();
 	}
 
 	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/CDropDown.cpp
===================================================================
--- ps/trunk/source/gui/CDropDown.cpp	(revision 22693)
+++ ps/trunk/source/gui/CDropDown.cpp	(revision 22694)
@@ -1,552 +1,552 @@
 /* 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 "CDropDown.h"
 
 #include "gui/CGUIColor.h"
 #include "lib/external_libraries/libsdl.h"
 #include "lib/ogl.h"
 #include "lib/timer.h"
 #include "ps/CLogger.h"
 #include "soundmanager/ISoundManager.h"
 
 CDropDown::CDropDown(CGUI* pGUI)
 	: CList(pGUI), IGUIObject(pGUI),
 	  m_Open(false), m_HideScrollBar(false), m_ElementHighlight(-1)
 {
 	AddSetting<float>("button_width");
 	AddSetting<float>("dropdown_size");
 	AddSetting<float>("dropdown_buffer");
 	AddSetting<uint>("minimum_visible_items");
 //	AddSetting<CStrW, "font");
 	AddSetting<CStrW>("sound_closed");
 	AddSetting<CStrW>("sound_disabled");
 	AddSetting<CStrW>("sound_enter");
 	AddSetting<CStrW>("sound_leave");
 	AddSetting<CStrW>("sound_opened");
 	AddSetting<CGUISpriteInstance>("sprite");				// Background that sits around the size
 	AddSetting<CGUISpriteInstance>("sprite_disabled");
 	AddSetting<CGUISpriteInstance>("sprite_list");			// Background of the drop down list
 	AddSetting<CGUISpriteInstance>("sprite2");				// Button that sits to the right
 	AddSetting<CGUISpriteInstance>("sprite2_over");
 	AddSetting<CGUISpriteInstance>("sprite2_pressed");
 	AddSetting<CGUISpriteInstance>("sprite2_disabled");
 	AddSetting<EVAlign>("text_valign");
 
 	// Add these in CList! And implement TODO
 	//AddSetting<CGUIColor>("textcolor_over");
 	//AddSetting<CGUIColor>("textcolor_pressed");
 	AddSetting<CGUIColor>("textcolor_selected");
 	AddSetting<CGUIColor>("textcolor_disabled");
 
 	// Scrollbar is forced to be true.
 	GUI<bool>::SetSetting(this, "scrollbar", true);
 }
 
 CDropDown::~CDropDown()
 {
 }
 
 void CDropDown::SetupText()
 {
 	SetupListRect();
 	CList::SetupText();
 }
 
 void CDropDown::UpdateCachedSize()
 {
 	CList::UpdateCachedSize();
 	SetupText();
 }
 
 void CDropDown::HandleMessage(SGUIMessage& Message)
 {
 	// Important
 
 	switch (Message.type)
 	{
 	case GUIM_SETTINGS_UPDATED:
 	{
 		// Update cached list rect
 		if (Message.value == "size" ||
 			Message.value == "absolute" ||
 			Message.value == "dropdown_size" ||
 			Message.value == "dropdown_buffer" ||
 			Message.value == "minimum_visible_items" ||
 			Message.value == "scrollbar_style" ||
 			Message.value == "button_width")
 		{
 			SetupListRect();
 		}
 
 		break;
 	}
 
 	case GUIM_MOUSE_MOTION:
 	{
 		if (!m_Open)
 			break;
 
 		CPos mouse = m_pGUI->GetMousePos();
 
 		if (!GetListRect().PointInside(mouse))
 			break;
 
 		bool scrollbar;
 		const CGUIList& pList = GUI<CGUIList>::GetSetting(this, "list");
 		GUI<bool>::GetSetting(this, "scrollbar", scrollbar);
 		float scroll = 0.f;
 		if (scrollbar)
 			scroll = GetScrollBar(0).GetPos();
 
 		CRect rect = GetListRect();
 		mouse.y += scroll;
 		int set = -1;
 		for (int i = 0; i < static_cast<int>(pList.m_Items.size()); ++i)
 		{
 			if (mouse.y >= rect.top + m_ItemsYPositions[i] &&
 				mouse.y < rect.top + m_ItemsYPositions[i+1] &&
 				// mouse is not over scroll-bar
 				(m_HideScrollBar ||
 					mouse.x < GetScrollBar(0).GetOuterRect().left ||
 					mouse.x > GetScrollBar(0).GetOuterRect().right))
 			{
 				set = i;
 			}
 		}
 
 		if (set != -1)
 		{
 			m_ElementHighlight = set;
 			//UpdateAutoScroll();
 		}
 
 		break;
 	}
 
 	case GUIM_MOUSE_ENTER:
 	{
 		bool enabled;
 		GUI<bool>::GetSetting(this, "enabled", enabled);
 		if (!enabled)
 			break;
 
 		CStrW soundPath;
 		if (g_SoundManager && GUI<CStrW>::GetSetting(this, "sound_enter", soundPath) == PSRETURN_OK && !soundPath.empty())
 			g_SoundManager->PlayAsUI(soundPath.c_str(), false);
 		break;
 	}
 
 	case GUIM_MOUSE_LEAVE:
 	{
 		GUI<int>::GetSetting(this, "selected", m_ElementHighlight);
 
 		bool enabled;
 		GUI<bool>::GetSetting(this, "enabled", enabled);
 		if (!enabled)
 			break;
 
 		CStrW soundPath;
 		if (g_SoundManager && GUI<CStrW>::GetSetting(this, "sound_leave", soundPath) == PSRETURN_OK && !soundPath.empty())
 			g_SoundManager->PlayAsUI(soundPath.c_str(), false);
 		break;
 	}
 
 	// We can't inherent this routine from CList, because we need to include
 	// a mouse click to open the dropdown, also the coordinates are changed.
 	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;
 		}
 
 		if (!m_Open)
 		{
 			const CGUIList& pList = GUI<CGUIList>::GetSetting(this, "list");
 			if (pList.m_Items.empty())
 				return;
 
 			m_Open = true;
 			GetScrollBar(0).SetZ(GetBufferedZ());
 			GUI<int>::GetSetting(this, "selected", m_ElementHighlight);
 
 			// Start at the position of the selected item, if possible.
 			GetScrollBar(0).SetPos(m_ItemsYPositions.empty() ? 0 : m_ItemsYPositions[m_ElementHighlight] - 60);
 
 			CStrW soundPath;
 			if (g_SoundManager && GUI<CStrW>::GetSetting(this, "sound_opened", soundPath) == PSRETURN_OK && !soundPath.empty())
 				g_SoundManager->PlayAsUI(soundPath.c_str(), false);
 
 			return; // overshadow
 		}
 		else
 		{
 			const CPos& mouse = m_pGUI->GetMousePos();
 
 			// If the regular area is pressed, then abort, and close.
 			if (m_CachedActualSize.PointInside(mouse))
 			{
 				m_Open = false;
 				GetScrollBar(0).SetZ(GetBufferedZ());
 
 				CStrW soundPath;
 				if (g_SoundManager && GUI<CStrW>::GetSetting(this, "sound_closed", soundPath) == PSRETURN_OK && !soundPath.empty())
 					g_SoundManager->PlayAsUI(soundPath.c_str(), false);
 
 				return; // overshadow
 			}
 
 			if (m_HideScrollBar ||
 				mouse.x < GetScrollBar(0).GetOuterRect().left ||
 				mouse.x > GetScrollBar(0).GetOuterRect().right ||
 				mouse.y < GetListRect().top)
 			{
 				m_Open = false;
 				GetScrollBar(0).SetZ(GetBufferedZ());
 			}
 		}
 		break;
 	}
 
 	case GUIM_MOUSE_WHEEL_DOWN:
 	{
 		bool enabled;
 		GUI<bool>::GetSetting(this, "enabled", enabled);
 
 		// Don't switch elements by scrolling when open, causes a confusing interaction between this and the scrollbar.
 		if (m_Open || !enabled)
 			break;
 
 		GUI<int>::GetSetting(this, "selected", m_ElementHighlight);
 		if (m_ElementHighlight + 1 >= (int)m_ItemsYPositions.size() - 1)
 			break;
 
 		++m_ElementHighlight;
 		GUI<int>::SetSetting(this, "selected", m_ElementHighlight);
 		break;
 	}
 
 	case GUIM_MOUSE_WHEEL_UP:
 	{
 		bool enabled;
 		GUI<bool>::GetSetting(this, "enabled", enabled);
 
 		// Don't switch elements by scrolling when open, causes a confusing interaction between this and the scrollbar.
 		if (m_Open || !enabled)
 			break;
 
 		GUI<int>::GetSetting(this, "selected", m_ElementHighlight);
 		if (m_ElementHighlight - 1 < 0)
 			break;
 
 		m_ElementHighlight--;
 		GUI<int>::SetSetting(this, "selected", m_ElementHighlight);
 		break;
 	}
 
 	case GUIM_LOST_FOCUS:
 	{
 		if (m_Open)
 		{
 			CStrW soundPath;
 			if (g_SoundManager && GUI<CStrW>::GetSetting(this, "sound_closed", soundPath) == PSRETURN_OK && !soundPath.empty())
 				g_SoundManager->PlayAsUI(soundPath.c_str(), false);
 		}
 		m_Open = false;
 		break;
 	}
 
 	case GUIM_LOAD:
 		SetupListRect();
 		break;
 
 	default:
 		break;
 	}
 
 	// Important that this is after, so that overshadowed implementations aren't processed
 	CList::HandleMessage(Message);
 
 	// As HandleMessage functions return void, we need to manually verify
 	// whether the child list's items were modified.
 	if (CList::GetModified())
 		SetupText();
 }
 
 InReaction CDropDown::ManuallyHandleEvent(const SDL_Event_* ev)
 {
 	InReaction result = IN_PASS;
 	bool update_highlight = false;
 
 	if (ev->ev.type == SDL_KEYDOWN)
 	{
 		int szChar = ev->ev.key.keysym.sym;
 
 		switch (szChar)
 		{
 		case '\r':
 			m_Open = false;
 			result = IN_HANDLED;
 			break;
 
 		case SDLK_HOME:
 		case SDLK_END:
 		case SDLK_UP:
 		case SDLK_DOWN:
 		case SDLK_PAGEUP:
 		case SDLK_PAGEDOWN:
 			if (!m_Open)
 				return IN_PASS;
 			// Set current selected item to highlighted, before
 			//  then really processing these in CList::ManuallyHandleEvent()
 			GUI<int>::SetSetting(this, "selected", m_ElementHighlight);
 			update_highlight = true;
 			break;
 
 		default:
 			// If we have inputed a character try to get the closest element to it.
 			// TODO: not too nice and doesn't deal with dashes.
 			if (m_Open && ((szChar >= SDLK_a && szChar <= SDLK_z) || szChar == SDLK_SPACE
 						   || (szChar >= SDLK_0 && szChar <= SDLK_9)
 						   || (szChar >= SDLK_KP_0 && szChar <= SDLK_KP_9)))
 			{
 				// arbitrary 1 second limit to add to string or start fresh.
 				// maximal amount of characters is 100, which imo is far more than enough.
 				if (timer_Time() - m_TimeOfLastInput > 1.0 || m_InputBuffer.length() >= 100)
 					m_InputBuffer = szChar;
 				else
 					m_InputBuffer += szChar;
 
 				m_TimeOfLastInput = timer_Time();
 
 				const CGUIList& pList = GUI<CGUIList>::GetSetting(this, "list");
 				// let's look for the closest element
 				// basically it's alphabetic order and "as many letters as we can get".
 				int closest = -1;
 				int bestIndex = -1;
 				int difference = 1250;
 				for (int i = 0; i < static_cast<int>(pList.m_Items.size()); ++i)
 				{
 					int indexOfDifference = 0;
 					int diff = 0;
 					for (size_t j = 0; j < m_InputBuffer.length(); ++j)
 					{
 						diff = std::abs(static_cast<int>(pList.m_Items[i].GetRawString().LowerCase()[j]) - static_cast<int>(m_InputBuffer[j]));
 						if (diff == 0)
 							indexOfDifference = j+1;
 						else
 							break;
 					}
 					if (indexOfDifference > bestIndex || (indexOfDifference >= bestIndex && diff < difference))
 					{
 						bestIndex = indexOfDifference;
 						closest = i;
 						difference = diff;
 					}
 				}
 				// let's select the closest element. There should basically always be one.
 				if (closest != -1)
 				{
 					GUI<int>::SetSetting(this, "selected", closest);
 					update_highlight = true;
 					GetScrollBar(0).SetPos(m_ItemsYPositions[closest] - 60);
 				}
 				result = IN_HANDLED;
 			}
 			break;
 		}
 	}
 
 	if (CList::ManuallyHandleEvent(ev) == IN_HANDLED)
 		result = IN_HANDLED;
 
 	if (update_highlight)
 		GUI<int>::GetSetting(this, "selected", m_ElementHighlight);
 
 	return result;
 }
 
 void CDropDown::SetupListRect()
 {
 	extern int g_yres;
 	extern float g_GuiScale;
 	float size, buffer, yres;
 	yres = g_yres / g_GuiScale;
 	u32 minimumVisibleItems;
 	GUI<float>::GetSetting(this, "dropdown_size", size);
 	GUI<float>::GetSetting(this, "dropdown_buffer", buffer);
 	GUI<u32>::GetSetting(this, "minimum_visible_items", minimumVisibleItems);
 
 	if (m_ItemsYPositions.empty())
 	{
 		m_CachedListRect = CRect(m_CachedActualSize.left, m_CachedActualSize.bottom + buffer,
 		                         m_CachedActualSize.right, m_CachedActualSize.bottom + buffer + size);
 		m_HideScrollBar = false;
 	}
 	// Too many items so use a scrollbar
 	else if (m_ItemsYPositions.back() > size)
 	{
 		// Place items below if at least some items can be placed below
 		if (m_CachedActualSize.bottom + buffer + size <= yres)
 			m_CachedListRect = CRect(m_CachedActualSize.left, m_CachedActualSize.bottom + buffer,
 			                         m_CachedActualSize.right, m_CachedActualSize.bottom + buffer + size);
 		else if ((m_ItemsYPositions.size() > minimumVisibleItems && yres - m_CachedActualSize.bottom - buffer >= m_ItemsYPositions[minimumVisibleItems]) ||
 		         m_CachedActualSize.top < yres - m_CachedActualSize.bottom)
 			m_CachedListRect = CRect(m_CachedActualSize.left, m_CachedActualSize.bottom + buffer,
 			                         m_CachedActualSize.right, yres);
 		// Not enough space below, thus place items above
 		else
 			m_CachedListRect = CRect(m_CachedActualSize.left, std::max(0.f, m_CachedActualSize.top - buffer - size),
 			                         m_CachedActualSize.right, m_CachedActualSize.top - buffer);
 
 		m_HideScrollBar = false;
 	}
 	else
 	{
 		// Enough space below, no scrollbar needed
 		if (m_CachedActualSize.bottom + buffer + m_ItemsYPositions.back() <= yres)
 		{
 			m_CachedListRect = CRect(m_CachedActualSize.left, m_CachedActualSize.bottom + buffer,
 			                         m_CachedActualSize.right, m_CachedActualSize.bottom + buffer + m_ItemsYPositions.back());
 			m_HideScrollBar = true;
 		}
 		// Enough space below for some items, but not all, so place items below and use a scrollbar
 		else if ((m_ItemsYPositions.size() > minimumVisibleItems && yres - m_CachedActualSize.bottom - buffer >= m_ItemsYPositions[minimumVisibleItems]) ||
 		         m_CachedActualSize.top < yres - m_CachedActualSize.bottom)
 		{
 			m_CachedListRect = CRect(m_CachedActualSize.left, m_CachedActualSize.bottom + buffer,
 			                         m_CachedActualSize.right, yres);
 			m_HideScrollBar = false;
 		}
 		// Not enough space below, thus place items above. Hide the scrollbar accordingly
 		else
 		{
 			m_CachedListRect = CRect(m_CachedActualSize.left, std::max(0.f, m_CachedActualSize.top - buffer - m_ItemsYPositions.back()),
 			                         m_CachedActualSize.right, m_CachedActualSize.top - buffer);
 			m_HideScrollBar = m_CachedActualSize.top > m_ItemsYPositions.back() + buffer;
 		}
 	}
 }
 
 CRect CDropDown::GetListRect() const
 {
 	return m_CachedListRect;
 }
 
 bool CDropDown::MouseOver()
 {
 	if (m_Open)
 	{
 		CRect rect(m_CachedActualSize.left, std::min(m_CachedActualSize.top, GetListRect().top),
 		           m_CachedActualSize.right, std::max(m_CachedActualSize.bottom, GetListRect().bottom));
 		return rect.PointInside(m_pGUI->GetMousePos());
 	}
 	else
 		return m_CachedActualSize.PointInside(m_pGUI->GetMousePos());
 }
 
 void CDropDown::Draw()
 {
 	float bz = GetBufferedZ();
 
 	float dropdown_size, button_width;
 	GUI<float>::GetSetting(this, "dropdown_size", dropdown_size);
 	GUI<float>::GetSetting(this, "button_width", button_width);
 
 	int cell_id, selected = 0;
-	CGUIColor color;
 
 	bool enabled;
 	GUI<bool>::GetSetting(this, "enabled", enabled);
 
 	CGUISpriteInstance& sprite = GUI<CGUISpriteInstance>::GetSetting(this, enabled ? "sprite" : "sprite_disabled");
 	CGUISpriteInstance& sprite2 = GUI<CGUISpriteInstance>::GetSetting(this, "sprite2");
 
 	GUI<int>::GetSetting(this, "cell_id", cell_id);
 	GUI<int>::GetSetting(this, "selected", selected);
-	GUI<CGUIColor>::GetSetting(this, enabled ? "textcolor_selected" : "textcolor_disabled", color);
 
 	m_pGUI->DrawSprite(sprite, cell_id, bz, m_CachedActualSize);
 
 	if (button_width > 0.f)
 	{
 		CRect rect(m_CachedActualSize.right-button_width, m_CachedActualSize.top,
 				   m_CachedActualSize.right, m_CachedActualSize.bottom);
 
 		if (!enabled)
 		{
 			CGUISpriteInstance& sprite2_second = GUI<CGUISpriteInstance>::GetSetting(this, "sprite2_disabled");
 			m_pGUI->DrawSprite(sprite2_second || sprite2, cell_id, bz + 0.05f, rect);
 		}
 		else if (m_Open)
 		{
 			CGUISpriteInstance& sprite2_second = GUI<CGUISpriteInstance>::GetSetting(this, "sprite2_pressed");
 			m_pGUI->DrawSprite(sprite2_second || sprite2, cell_id, bz + 0.05f, rect);
 		}
 		else if (m_MouseHovering)
 		{
 			CGUISpriteInstance& sprite2_second = GUI<CGUISpriteInstance>::GetSetting(this, "sprite2_over");
 			m_pGUI->DrawSprite(sprite2_second || sprite2, cell_id, bz + 0.05f, rect);
 		}
 		else
 			m_pGUI->DrawSprite(sprite2, cell_id, bz + 0.05f, rect);
 	}
 
 	if (selected != -1) // TODO: Maybe check validity completely?
 	{
 		CRect cliparea(m_CachedActualSize.left, m_CachedActualSize.top,
 					   m_CachedActualSize.right-button_width, m_CachedActualSize.bottom);
 
+		const CGUIColor& color = GUI<CGUIColor>::GetSetting(this, enabled ? "textcolor_selected" : "textcolor_disabled");
+
 		CPos pos(m_CachedActualSize.left, m_CachedActualSize.top);
 		DrawText(selected, color, pos, bz+0.1f, cliparea);
 	}
 
 	// Disable scrollbar during drawing without sending a setting-changed message
 	bool& scrollbar = GUI<bool>::GetSetting(this, "scrollbar");
 	bool old = scrollbar;
 
 	if (m_Open)
 	{
 		if (m_HideScrollBar)
 			scrollbar = false;
 
 		DrawList(m_ElementHighlight, "sprite_list", "sprite_selectarea", "textcolor");
 
 		if (m_HideScrollBar)
 			scrollbar = old;
 	}
 }
 
 // When a dropdown list is opened, it needs to be visible above all the other
 // controls on the page. The only way I can think of to do this is to increase
 // its z value when opened, so that it's probably on top.
 float CDropDown::GetBufferedZ() const
 {
 	float bz = CList::GetBufferedZ();
 	if (m_Open)
 		return std::min(bz + 500.f, 1000.f); // TODO - don't use magic number for max z value
 	else
 		return bz;
 }
Index: ps/trunk/source/gui/CGUI.cpp
===================================================================
--- ps/trunk/source/gui/CGUI.cpp	(revision 22693)
+++ ps/trunk/source/gui/CGUI.cpp	(revision 22694)
@@ -1,1373 +1,1356 @@
 /* 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 "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)
 		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;
 }
 
-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());
 
 	// shared_ptr to link the effect to every sprite, faster than copy.
 	std::shared_ptr<SGUIImageEffects> effects;
 
 	for (XMBElement child : Element.GetChildNodes())
 	{
 		CStr ElementName(pFile->GetElementString(child.GetNodeName()));
 
 		if (ElementName == "image")
 			Xeromyces_ReadImage(child, pFile, *Sprite);
 		else if (ElementName == "effect")
 		{
 			if (effects)
 				LOGERROR("GUI <sprite> must not have more than one <effect>");
 			else
 			{
 				effects = std::make_shared<SGUIImageEffects>();
 				Xeromyces_ReadEffects(child, pFile, *effects);
 			}
 		}
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 
 	// Apply the effects to every image (unless the image overrides it with
 	// different effects)
 	if (effects)
 		for (SGUIImage* const& img : Sprite->m_Images)
 			if (!img->m_Effects)
 				img->m_Effects = effects;
 
 	m_Sprites.erase(name);
 	m_Sprites.emplace(name, Sprite);
 }
 
 void CGUI::Xeromyces_ReadImage(XMBElement Element, CXeromyces* pFile, CGUISprite& parent)
 {
 	SGUIImage* Image = new SGUIImage;
 
 	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))
+			if (!GUI<CGUIColor>::ParseString(this, attr_value, Image->m_BackColor))
 				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))
+			if (!GUI<CGUIColor>::ParseString(this, attr_value, Image->m_BorderColor))
 				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 = std::make_shared<SGUIImageEffects>();
 				Xeromyces_ReadEffects(child, pFile, *Image->m_Effects);
 			}
 		}
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 
 	parent.AddImage(Image);
 }
 
 void CGUI::Xeromyces_ReadEffects(XMBElement Element, CXeromyces* pFile, SGUIImageEffects& effects)
 {
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 
 		if (attr_name == "add_color")
 		{
-			CGUIColor color;
-			if (!color.ParseString(this, attr.Value, 0))
+			if (!effects.m_AddColor.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))
+	CColor color;
+	if (color.ParseString(value))
 	{
-		LOGERROR("GUI: Unable to create custom color '%s'. Invalid color syntax.", name.c_str());
-		return;
+		m_PreDefinedColors.erase(name);
+		m_PreDefinedColors.emplace(
+			std::piecewise_construct,
+			std::forward_as_tuple(name),
+			std::forward_as_tuple(color.r, color.g, color.b, color.a));
 	}
-
-	m_PreDefinedColors[name] = color;
+	else
+		LOGERROR("GUI: Unable to create custom color '%s'. Invalid color syntax.", name.c_str());
 }
Index: ps/trunk/source/gui/CGUI.h
===================================================================
--- ps/trunk/source/gui/CGUI.h	(revision 22693)
+++ ps/trunk/source/gui/CGUI.h	(revision 22694)
@@ -1,642 +1,641 @@
 /* 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 CGUIColor;
 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());
 
 	/**
 	 * 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();
 
 	/**
 	 * 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.
+	 * Check if a predefined color of that name exists.
 	 */
-	bool GetPreDefinedColor(const CStr& name, CGUIColor& Output) const;
+	bool HasPreDefinedColor(const CStr& name) const { return (m_PreDefinedColors.count(name) != 0); }
+
+	/**
+	 * Resolve the predefined color if it exists, otherwise throws an exception.
+	 */
+	const CGUIColor& GetPreDefinedColor(const CStr& name) const { return m_PreDefinedColors.at(name); }
 
 	shared_ptr<ScriptInterface> GetScriptInterface() { return m_ScriptInterface; };
 	JS::Value GetGlobalObject() { return m_ScriptInterface->GetGlobalObject(); };
 
 	/**
 	 * Updates the object pointers, needs to be called each
 	 * time an object has been added or removed.
 	 *
 	 * This function is atomic, meaning if it throws anything, it will
 	 * have seen it through that nothing was ultimately changed.
 	 *
 	 * @throws PSERROR_GUI that is thrown from IGUIObject::AddToPointersMap().
 	 */
 	void UpdateObjects();
 
 private:
 	/**
 	 * Adds an object to the GUI's object database
 	 * Private, since you can only add objects through
 	 * XML files. Why? Because it enables the GUI to
 	 * be much more encapsulated and safe.
 	 *
 	 * @throws	Rethrows PSERROR_GUI from IGUIObject::AddChild().
 	 */
 	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.
 	//--------------------------------------------------------
 
+	// Colors
+	std::map<CStr, const CGUIColor> m_PreDefinedColors;
+
 	// Sprites
 	std::map<CStr, const CGUISprite*> m_Sprites;
 
 	// Styles
 	std::map<CStr, const SGUIStyle> m_Styles;
 
 	// Scroll-bar styles
 	std::map<CStr, const SGUIScrollBarStyle> m_ScrollBarStyles;
 
 	// Icons
 	std::map<CStr, const SGUIIcon> m_Icons;
 };
 
 #endif // INCLUDED_CGUI
Index: ps/trunk/source/gui/CGUIColor.cpp
===================================================================
--- ps/trunk/source/gui/CGUIColor.cpp	(revision 22693)
+++ ps/trunk/source/gui/CGUIColor.cpp	(revision 22694)
@@ -1,27 +1,39 @@
 /* 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 "CGUIColor.h"
 #include "ps/CStr.h"
 #include "gui/CGUI.h"
 
 bool CGUIColor::ParseString(const CGUI* pGUI, const CStr& value, int defaultAlpha)
 {
-	return (pGUI != nullptr && pGUI->GetPreDefinedColor(value, *this)) || CColor::ParseString(value, defaultAlpha);
+	if (pGUI != nullptr && pGUI->HasPreDefinedColor(value))
+	{
+		const CGUIColor& color = pGUI->GetPreDefinedColor(value);
+
+		// Explicit copy assignment
+		r = color.r;
+		g = color.g;
+		b = color.b;
+		a = color.a;
+		return true;
+	}
+
+	return CColor::ParseString(value, defaultAlpha);
 }
Index: ps/trunk/source/gui/CGUIColor.h
===================================================================
--- ps/trunk/source/gui/CGUIColor.h	(revision 22693)
+++ ps/trunk/source/gui/CGUIColor.h	(revision 22694)
@@ -1,55 +1,61 @@
 /* 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_GUICOLOR
 #define INCLUDED_GUICOLOR
 
 #include "graphics/Color.h"
 #include "ps/CStr.h"
 
 class CGUI;
 
 /**
  * Same as the CColor class, but this one can also parse colors predefined in the GUI page (such as "yellow").
  */
 struct CGUIColor : CColor
 {
+	// Take advantage of compiler warnings if unintentionally copying this
+	NONCOPYABLE(CGUIColor);
+
+	// Defines move semantics so that the structs using the class can use it.
+	MOVABLE(CGUIColor);
+
 	CGUIColor() : CColor() {}
 
 	CGUIColor(float r, float g, float b, float a) : CColor(r, g, b, a) {}
 
 	/**
 	 * Returns this color if it has been set, otherwise the given fallback color.
 	 */
 	const CGUIColor& operator||(const CGUIColor& fallback) const
 	{
 		if (*this)
 			return *this;
 		return fallback;
 	}
 
 	/**
 	 * Load color depending on current GUI page.
 	 */
 	bool ParseString(const CGUI* pGUI, const CStr& value, int defaultAlpha = 255);
 
 	/**
 	 * Ensure that all users check for predefined colors.
 	 */
 	bool ParseString(const CStr& value, int defaultAlpha = 255) = delete;
 };
 #endif // INCLUDED_GUICOLOR
Index: ps/trunk/source/gui/CGUIText.cpp
===================================================================
--- ps/trunk/source/gui/CGUIText.cpp	(revision 22693)
+++ ps/trunk/source/gui/CGUIText.cpp	(revision 22694)
@@ -1,471 +1,469 @@
 /* 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.Color(tc.m_UseCustomColor ? tc.m_Color : DefaultColor);
 		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();
 }
Index: ps/trunk/source/gui/CInput.cpp
===================================================================
--- ps/trunk/source/gui/CInput.cpp	(revision 22693)
+++ ps/trunk/source/gui/CInput.cpp	(revision 22694)
@@ -1,2130 +1,2129 @@
 /* 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 "CInput.h"
 
 #include "gui/CGUIScrollBarVertical.h"
 #include "gui/GUI.h"
 #include "graphics/FontMetrics.h"
 #include "graphics/ShaderManager.h"
 #include "graphics/TextRenderer.h"
 #include "lib/ogl.h"
 #include "lib/sysdep/clipboard.h"
 #include "lib/timer.h"
 #include "lib/utf8.h"
 #include "ps/CLogger.h"
 #include "ps/ConfigDB.h"
 #include "ps/GameSetup/Config.h"
 #include "ps/Globals.h"
 #include "ps/Hotkey.h"
 #include "renderer/Renderer.h"
 
 #include <sstream>
 
 extern int g_yres;
 
 CInput::CInput(CGUI* pGUI)
 	: IGUIObject(pGUI), IGUIScrollBarOwner(pGUI),
 	m_iBufferPos(-1), m_iBufferPos_Tail(-1), m_SelectingText(false), m_HorizontalScroll(0.f),
 	m_PrevTime(0.0), m_CursorVisState(true), m_CursorBlinkRate(0.5), m_ComposingText(false),
 	m_iComposedLength(0), m_iComposedPos(0), m_iInsertPos(0), m_Readonly(false)
 {
 	AddSetting<i32>("buffer_position");
 	AddSetting<float>("buffer_zone");
 	AddSetting<CStrW>("caption");
 	AddSetting<i32>("cell_id");
 	AddSetting<CStrW>("font");
 	AddSetting<CStrW>("mask_char");
 	AddSetting<bool>("mask");
 	AddSetting<i32>("max_length");
 	AddSetting<bool>("multiline");
 	AddSetting<bool>("readonly");
 	AddSetting<bool>("scrollbar");
 	AddSetting<CStr>("scrollbar_style");
 	AddSetting<CGUISpriteInstance>("sprite");
 	AddSetting<CGUISpriteInstance>("sprite_selectarea");
 	AddSetting<CGUIColor>("textcolor");
 	AddSetting<CGUIColor>("textcolor_selected");
 	AddSetting<CStrW>("tooltip");
 	AddSetting<CStr>("tooltip_style");
 
 	CFG_GET_VAL("gui.cursorblinkrate", m_CursorBlinkRate);
 
 	CGUIScrollBarVertical* bar = new CGUIScrollBarVertical(pGUI);
 	bar->SetRightAligned(true);
 	AddScrollBar(bar);
 }
 
 CInput::~CInput()
 {
 }
 
 void CInput::UpdateBufferPositionSetting()
 {
 	GUI<i32>::SetSetting(this, "buffer_position", m_iBufferPos, true);
 }
 
 void CInput::ClearComposedText()
 {
 	CStrW& pCaption = GUI<CStrW>::GetSetting(this, "caption");
 	pCaption.erase(m_iInsertPos, m_iComposedLength);
 	m_iBufferPos = m_iInsertPos;
 	UpdateBufferPositionSetting();
 	m_iComposedLength = 0;
 	m_iComposedPos = 0;
 }
 
 InReaction CInput::ManuallyHandleEvent(const SDL_Event_* ev)
 {
 	ENSURE(m_iBufferPos != -1);
 
 	switch (ev->ev.type)
 	{
 	case SDL_HOTKEYDOWN:
 	{
 		if (m_ComposingText)
 			return IN_HANDLED;
 
 		return ManuallyHandleHotkeyEvent(ev);
 	}
 	// SDL2 has a new method of text input that better supports Unicode and CJK
 	// see https://wiki.libsdl.org/Tutorials/TextInput
 	case SDL_TEXTINPUT:
 	{
 		if (m_Readonly)
 			return IN_PASS;
 
 		// Text has been committed, either single key presses or through an IME
 		CStrW& pCaption = GUI<CStrW>::GetSetting(this, "caption");
 		std::wstring text = wstring_from_utf8(ev->ev.text.text);
 
 		m_WantedX = 0.0f;
 
 		if (SelectingText())
 			DeleteCurSelection();
 
 		if (m_ComposingText)
 		{
 			ClearComposedText();
 			m_ComposingText = false;
 		}
 
 		if (m_iBufferPos == static_cast<int>(pCaption.length()))
 			pCaption.append(text);
 		else
 			pCaption.insert(m_iBufferPos, text);
 
 		UpdateText(m_iBufferPos, m_iBufferPos, m_iBufferPos+1);
 
 		m_iBufferPos += text.length();
 		UpdateBufferPositionSetting();
 		m_iBufferPos_Tail = -1;
 
 		UpdateAutoScroll();
 		SendEvent(GUIM_TEXTEDIT, "textedit");
 
 		return IN_HANDLED;
 	}
 	case SDL_TEXTEDITING:
 	{
 		if (m_Readonly)
 			return IN_PASS;
 
 		// Text is being composed with an IME
 		// TODO: indicate this by e.g. underlining the uncommitted text
 		CStrW& pCaption = GUI<CStrW>::GetSetting(this, "caption");
 		const char* rawText = ev->ev.edit.text;
 		int rawLength = strlen(rawText);
 		std::wstring wtext = wstring_from_utf8(rawText);
 
 		debug_printf("SDL_TEXTEDITING: text=%s, start=%d, length=%d\n", rawText, ev->ev.edit.start, ev->ev.edit.length);
 		m_WantedX = 0.0f;
 
 		if (SelectingText())
 			DeleteCurSelection();
 
 		// Remember cursor position when text composition begins
 		if (!m_ComposingText)
 			m_iInsertPos = m_iBufferPos;
 		else
 		{
 			// Composed text is replaced each time
 			ClearComposedText();
 		}
 
 		m_ComposingText = ev->ev.edit.start != 0 || rawLength != 0;
 		if (m_ComposingText)
 		{
 			pCaption.insert(m_iInsertPos, wtext);
 
 			// The text buffer is limited to SDL_TEXTEDITINGEVENT_TEXT_SIZE bytes, yet start
 			// increases without limit, so don't let it advance beyond the composed text length
 			m_iComposedLength = wtext.length();
 			m_iComposedPos = ev->ev.edit.start < m_iComposedLength ? ev->ev.edit.start : m_iComposedLength;
 			m_iBufferPos = m_iInsertPos + m_iComposedPos;
 
 			// TODO: composed text selection - what does ev.edit.length do?
 			m_iBufferPos_Tail = -1;
 		}
 
 		UpdateBufferPositionSetting();
 		UpdateText(m_iBufferPos, m_iBufferPos, m_iBufferPos+1);
 
 		UpdateAutoScroll();
 		SendEvent(GUIM_TEXTEDIT, "textedit");
 
 		return IN_HANDLED;
 	}
 	case SDL_KEYDOWN:
 	{
 		if (m_ComposingText)
 			return IN_HANDLED;
 
 		// Since the GUI framework doesn't handle to set settings
 		//  in Unicode (CStrW), we'll simply retrieve the actual
 		//  pointer and edit that.
 		CStrW& pCaption = GUI<CStrW>::GetSetting(this, "caption");
 		SDL_Keycode keyCode = ev->ev.key.keysym.sym;
 
 		ManuallyImmutableHandleKeyDownEvent(keyCode, pCaption);
 		ManuallyMutableHandleKeyDownEvent(keyCode, pCaption);
 
 		UpdateBufferPositionSetting();
 		return IN_HANDLED;
 	}
 	default:
 	{
 		return IN_PASS;
 	}
 	}
 }
 
 void CInput::ManuallyMutableHandleKeyDownEvent(const SDL_Keycode keyCode, CStrW& pCaption)
 {
 	if (m_Readonly)
 		return;
 
 	wchar_t cooked = 0;
 
 	switch (keyCode)
 	{
 	case SDLK_TAB:
 	{
 		SendEvent(GUIM_TAB, "tab");
 		// Don't send a textedit event, because it should only
 		// be sent if the GUI control changes the text
 		break;
 	}
 	case SDLK_BACKSPACE:
 	{
 		m_WantedX = 0.0f;
 
 		if (SelectingText())
 			DeleteCurSelection();
 		else
 		{
 			m_iBufferPos_Tail = -1;
 
 			if (pCaption.empty() || m_iBufferPos == 0)
 				break;
 
 			if (m_iBufferPos == static_cast<int>(pCaption.length()))
 				pCaption = pCaption.Left(static_cast<long>(pCaption.length()) - 1);
 			else
 				pCaption =
 					pCaption.Left(m_iBufferPos - 1) +
 					pCaption.Right(static_cast<long>(pCaption.length()) - m_iBufferPos);
 
 			--m_iBufferPos;
 
 			UpdateText(m_iBufferPos, m_iBufferPos + 1, m_iBufferPos);
 		}
 
 		UpdateAutoScroll();
 		SendEvent(GUIM_TEXTEDIT, "textedit");
 		break;
 	}
 	case SDLK_DELETE:
 	{
 		m_WantedX = 0.0f;
 
 		if (SelectingText())
 			DeleteCurSelection();
 		else
 		{
 			if (pCaption.empty() || m_iBufferPos == static_cast<int>(pCaption.length()))
 				break;
 
 			pCaption =
 				pCaption.Left(m_iBufferPos) +
 				pCaption.Right(static_cast<long>(pCaption.length()) - (m_iBufferPos + 1));
 
 			UpdateText(m_iBufferPos, m_iBufferPos + 1, m_iBufferPos);
 		}
 
 		UpdateAutoScroll();
 		SendEvent(GUIM_TEXTEDIT, "textedit");
 		break;
 	}
 	case SDLK_KP_ENTER:
 	case SDLK_RETURN:
 	{
 		// 'Return' should do a Press event for single liners (e.g. submitting forms)
 		//  otherwise a '\n' character will be added.
 		bool multiline;
 		GUI<bool>::GetSetting(this, "multiline", multiline);
 		if (!multiline)
 		{
 			SendEvent(GUIM_PRESSED, "press");
 			break;
 		}
 
 		cooked = '\n'; // Change to '\n' and do default:
 		FALLTHROUGH;
 	}
 	default: // Insert a character
 	{
 		// In SDL2, we no longer get Unicode wchars via SDL_Keysym
 		// we use text input events instead and they provide UTF-8 chars
 		if (cooked == 0)
 			return;
 
 		// check max length
 		int max_length;
 		GUI<int>::GetSetting(this, "max_length", max_length);
 		if (max_length != 0 && static_cast<int>(pCaption.length()) >= max_length)
 			break;
 
 		m_WantedX = 0.0f;
 
 		if (SelectingText())
 			DeleteCurSelection();
 		m_iBufferPos_Tail = -1;
 
 		if (m_iBufferPos == static_cast<int>(pCaption.length()))
 			pCaption += cooked;
 		else
 			pCaption =
 				pCaption.Left(m_iBufferPos) + cooked +
 				pCaption.Right(static_cast<long>(pCaption.length()) - m_iBufferPos);
 
 		UpdateText(m_iBufferPos, m_iBufferPos, m_iBufferPos + 1);
 
 		++m_iBufferPos;
 
 		UpdateAutoScroll();
 		SendEvent(GUIM_TEXTEDIT, "textedit");
 		break;
 	}
 	}
 }
 
 void CInput::ManuallyImmutableHandleKeyDownEvent(const SDL_Keycode keyCode, CStrW& pCaption)
 {
 	bool shiftKeyPressed = g_keys[SDLK_RSHIFT] || g_keys[SDLK_LSHIFT];
 
 	switch (keyCode)
 	{
 	case SDLK_HOME:
 	{
 		// If there's not a selection, we should create one now
 		if (!shiftKeyPressed)
 		{
 			// Make sure a selection isn't created.
 			m_iBufferPos_Tail = -1;
 		}
 		else if (!SelectingText())
 		{
 			// Place tail at the current point:
 			m_iBufferPos_Tail = m_iBufferPos;
 		}
 
 		m_iBufferPos = 0;
 		m_WantedX = 0.0f;
 
 		UpdateAutoScroll();
 		break;
 	}
 	case SDLK_END:
 	{
 		// If there's not a selection, we should create one now
 		if (!shiftKeyPressed)
 		{
 			// Make sure a selection isn't created.
 			m_iBufferPos_Tail = -1;
 		}
 		else if (!SelectingText())
 		{
 			// Place tail at the current point:
 			m_iBufferPos_Tail = m_iBufferPos;
 		}
 
 		m_iBufferPos = static_cast<long>(pCaption.length());
 		m_WantedX = 0.0f;
 
 		UpdateAutoScroll();
 		break;
 	}
 	/**
 	 * Conventions for Left/Right when text is selected:
 	 *
 	 * References:
 	 *
 	 * Visual Studio
 	 *  Visual Studio has the 'newer' approach, used by newer versions of
 	 * things, and in newer applications. A left press will always place
 	 * the pointer on the left edge of the selection, and then of course
 	 * remove the selection. Right will do the exact same thing.
 	 * If you have the pointer on the right edge and press right, it will
 	 * in other words just remove the selection.
 	 *
 	 * Windows (eg. Notepad)
 	 *  A left press always takes the pointer a step to the left and
 	 * removes the selection as if it were never there in the first place.
 	 * Right of course does the same thing but to the right.
 	 *
 	 * I chose the Visual Studio convention. Used also in Word, gtk 2.0, MSN
 	 * Messenger.
 	 */
 	case SDLK_LEFT:
 	{
 		m_WantedX = 0.f;
 
 		if (shiftKeyPressed || !SelectingText())
 		{
 			if (!shiftKeyPressed)
 				m_iBufferPos_Tail = -1;
 			else if (!SelectingText())
 				m_iBufferPos_Tail = m_iBufferPos;
 
 			if (m_iBufferPos > 0)
 				--m_iBufferPos;
 		}
 		else
 		{
 			if (m_iBufferPos_Tail < m_iBufferPos)
 				m_iBufferPos = m_iBufferPos_Tail;
 
 			m_iBufferPos_Tail = -1;
 		}
 
 		UpdateAutoScroll();
 		break;
 	}
 	case SDLK_RIGHT:
 	{
 		m_WantedX = 0.0f;
 
 		if (shiftKeyPressed || !SelectingText())
 		{
 			if (!shiftKeyPressed)
 				m_iBufferPos_Tail = -1;
 			else if (!SelectingText())
 				m_iBufferPos_Tail = m_iBufferPos;
 
 			if (m_iBufferPos < static_cast<int>(pCaption.length()))
 				++m_iBufferPos;
 		}
 		else
 		{
 			if (m_iBufferPos_Tail > m_iBufferPos)
 				m_iBufferPos = m_iBufferPos_Tail;
 
 			m_iBufferPos_Tail = -1;
 		}
 
 		UpdateAutoScroll();
 		break;
 	}
 	/**
 	 * Conventions for Up/Down when text is selected:
 	 *
 	 * References:
 	 *
 	 * Visual Studio
 	 *  Visual Studio has a very strange approach, down takes you below the
 	 * selection to the next row, and up to the one prior to the whole
 	 * selection. The weird part is that it is always aligned as the
 	 * 'pointer'. I decided this is to much work for something that is
 	 * a bit arbitrary
 	 *
 	 * Windows (eg. Notepad)
 	 *  Just like with left/right, the selection is destroyed and it moves
 	 * just as if there never were a selection.
 	 *
 	 * I chose the Notepad convention even though I use the VS convention with
 	 * left/right.
 	 */
 	case SDLK_UP:
 	{
 		if (!shiftKeyPressed)
 			m_iBufferPos_Tail = -1;
 		else if (!SelectingText())
 			m_iBufferPos_Tail = m_iBufferPos;
 
 		std::list<SRow>::iterator current = m_CharacterPositions.begin();
 		while (current != m_CharacterPositions.end())
 		{
 			if (m_iBufferPos >= current->m_ListStart &&
 			    m_iBufferPos <= current->m_ListStart + (int)current->m_ListOfX.size())
 				break;
 
 			++current;
 		}
 
 		float pos_x;
 		if (m_iBufferPos - current->m_ListStart == 0)
 			pos_x = 0.f;
 		else
 			pos_x = current->m_ListOfX[m_iBufferPos - current->m_ListStart - 1];
 
 		if (m_WantedX > pos_x)
 			pos_x = m_WantedX;
 
 		// Now change row:
 		if (current != m_CharacterPositions.begin())
 		{
 			--current;
 
 			// Find X-position:
 			m_iBufferPos = current->m_ListStart + GetXTextPosition(current, pos_x, m_WantedX);
 		}
 		// else we can't move up
 
 		UpdateAutoScroll();
 		break;
 	}
 	case SDLK_DOWN:
 	{
 		if (!shiftKeyPressed)
 			m_iBufferPos_Tail = -1;
 		else if (!SelectingText())
 			m_iBufferPos_Tail = m_iBufferPos;
 
 		std::list<SRow>::iterator current = m_CharacterPositions.begin();
 		while (current != m_CharacterPositions.end())
 		{
 			if (m_iBufferPos >= current->m_ListStart &&
 			    m_iBufferPos <= current->m_ListStart + (int)current->m_ListOfX.size())
 				break;
 
 			++current;
 		}
 
 		float pos_x;
 
 		if (m_iBufferPos - current->m_ListStart == 0)
 			pos_x = 0.f;
 		else
 			pos_x = current->m_ListOfX[m_iBufferPos - current->m_ListStart - 1];
 
 		if (m_WantedX > pos_x)
 			pos_x = m_WantedX;
 
 		// Now change row:
 		// Add first, so we can check if it's .end()
 		++current;
 		if (current != m_CharacterPositions.end())
 		{
 			// Find X-position:
 			m_iBufferPos = current->m_ListStart + GetXTextPosition(current, pos_x, m_WantedX);
 		}
 		// else we can't move up
 
 		UpdateAutoScroll();
 		break;
 	}
 	case SDLK_PAGEUP:
 	{
 		GetScrollBar(0).ScrollMinusPlenty();
 		UpdateAutoScroll();
 		break;
 	}
 	case SDLK_PAGEDOWN:
 	{
 		GetScrollBar(0).ScrollPlusPlenty();
 		UpdateAutoScroll();
 		break;
 	}
 	default:
 	{
 		break;
 	}
 	}
 }
 
 InReaction CInput::ManuallyHandleHotkeyEvent(const SDL_Event_* ev)
 {
 	CStrW& pCaption = GUI<CStrW>::GetSetting(this, "caption");
 
 	bool shiftKeyPressed = g_keys[SDLK_RSHIFT] || g_keys[SDLK_LSHIFT];
 
 	std::string hotkey = static_cast<const char*>(ev->ev.user.data1);
 
 	if (hotkey == "paste")
 	{
 		if (m_Readonly)
 			return IN_PASS;
 
 		m_WantedX = 0.0f;
 
 		wchar_t* text = sys_clipboard_get();
 		if (text)
 		{
 			if (SelectingText())
 				DeleteCurSelection();
 
 			if (m_iBufferPos == static_cast<int>(pCaption.length()))
 				pCaption += text;
 			else
 				pCaption =
 					pCaption.Left(m_iBufferPos) + text +
 					pCaption.Right(static_cast<long>(pCaption.length()) - m_iBufferPos);
 
 			UpdateText(m_iBufferPos, m_iBufferPos, m_iBufferPos+1);
 
 			m_iBufferPos += (int)wcslen(text);
 			UpdateAutoScroll();
 			UpdateBufferPositionSetting();
 
 			sys_clipboard_free(text);
 
 			SendEvent(GUIM_TEXTEDIT, "textedit");
 		}
 
 		return IN_HANDLED;
 	}
 	else if (hotkey == "copy" || hotkey == "cut")
 	{
 		if (m_Readonly && hotkey == "cut")
 			return IN_PASS;
 
 		m_WantedX = 0.0f;
 
 		if (SelectingText())
 		{
 			int virtualFrom;
 			int virtualTo;
 
 			if (m_iBufferPos_Tail >= m_iBufferPos)
 			{
 				virtualFrom = m_iBufferPos;
 				virtualTo = m_iBufferPos_Tail;
 			}
 			else
 			{
 				virtualFrom = m_iBufferPos_Tail;
 				virtualTo = m_iBufferPos;
 			}
 
 			CStrW text = (pCaption.Left(virtualTo)).Right(virtualTo - virtualFrom);
 
 			sys_clipboard_set(&text[0]);
 
 			if (hotkey == "cut")
 			{
 				DeleteCurSelection();
 				UpdateAutoScroll();
 				SendEvent(GUIM_TEXTEDIT, "textedit");
 			}
 		}
 
 		return IN_HANDLED;
 	}
 	else if (hotkey == "text.delete.left")
 	{
 		if (m_Readonly)
 			return IN_PASS;
 
 		m_WantedX = 0.0f;
 
 		if (SelectingText())
 			DeleteCurSelection();
 
 		if (!pCaption.empty() && m_iBufferPos != 0)
 		{
 			m_iBufferPos_Tail = m_iBufferPos;
 			CStrW searchString = pCaption.Left(m_iBufferPos);
 
 			// If we are starting in whitespace, adjust position until we get a non whitespace
 			while (m_iBufferPos > 0)
 			{
 				if (!iswspace(searchString[m_iBufferPos - 1]))
 					break;
 
 				m_iBufferPos--;
 			}
 
 			// If we end up on a punctuation char we just delete it (treat punct like a word)
 			if (iswpunct(searchString[m_iBufferPos - 1]))
 				m_iBufferPos--;
 			else
 			{
 				// Now we are on a non white space character, adjust position to char after next whitespace char is found
 				while (m_iBufferPos > 0)
 				{
 					if (iswspace(searchString[m_iBufferPos - 1]) || iswpunct(searchString[m_iBufferPos - 1]))
 						break;
 
 					m_iBufferPos--;
 				}
 			}
 
 			UpdateBufferPositionSetting();
 			DeleteCurSelection();
 			SendEvent(GUIM_TEXTEDIT, "textedit");
 		}
 		UpdateAutoScroll();
 		return IN_HANDLED;
 	}
 	else if (hotkey == "text.delete.right")
 	{
 		if (m_Readonly)
 			return IN_PASS;
 
 		m_WantedX = 0.0f;
 
 		if (SelectingText())
 			DeleteCurSelection();
 
 		if (!pCaption.empty() && m_iBufferPos < static_cast<int>(pCaption.length()))
 		{
 			// Delete the word to the right of the cursor
 			m_iBufferPos_Tail = m_iBufferPos;
 
 			// Delete chars to the right unit we hit whitespace
 			while (++m_iBufferPos < static_cast<int>(pCaption.length()))
 			{
 				if (iswspace(pCaption[m_iBufferPos]) || iswpunct(pCaption[m_iBufferPos]))
 					break;
 			}
 
 			// Eliminate any whitespace behind the word we just deleted
 			while (m_iBufferPos < static_cast<int>(pCaption.length()))
 			{
 				if (!iswspace(pCaption[m_iBufferPos]))
 					break;
 
 				++m_iBufferPos;
 			}
 			UpdateBufferPositionSetting();
 			DeleteCurSelection();
 		}
 		UpdateAutoScroll();
 		SendEvent(GUIM_TEXTEDIT, "textedit");
 		return IN_HANDLED;
 	}
 	else if (hotkey == "text.move.left")
 	{
 		m_WantedX = 0.0f;
 
 		if (shiftKeyPressed || !SelectingText())
 		{
 			if (!shiftKeyPressed)
 				m_iBufferPos_Tail = -1;
 			else if (!SelectingText())
 				m_iBufferPos_Tail = m_iBufferPos;
 
 			if (!pCaption.empty() && m_iBufferPos != 0)
 			{
 				CStrW searchString = pCaption.Left(m_iBufferPos);
 
 				// If we are starting in whitespace, adjust position until we get a non whitespace
 				while (m_iBufferPos > 0)
 				{
 					if (!iswspace(searchString[m_iBufferPos - 1]))
 						break;
 
 					m_iBufferPos--;
 				}
 
 				// If we end up on a puctuation char we just select it (treat punct like a word)
 				if (iswpunct(searchString[m_iBufferPos - 1]))
 					m_iBufferPos--;
 				else
 				{
 					// Now we are on a non white space character, adjust position to char after next whitespace char is found
 					while (m_iBufferPos > 0)
 					{
 						if (iswspace(searchString[m_iBufferPos - 1]) || iswpunct(searchString[m_iBufferPos - 1]))
 							break;
 
 						m_iBufferPos--;
 					}
 				}
 			}
 		}
 		else
 		{
 			if (m_iBufferPos_Tail < m_iBufferPos)
 				m_iBufferPos = m_iBufferPos_Tail;
 
 			m_iBufferPos_Tail = -1;
 		}
 
 		UpdateBufferPositionSetting();
 		UpdateAutoScroll();
 
 		return IN_HANDLED;
 	}
 	else if (hotkey == "text.move.right")
 	{
 		m_WantedX = 0.0f;
 
 		if (shiftKeyPressed || !SelectingText())
 		{
 			if (!shiftKeyPressed)
 				m_iBufferPos_Tail = -1;
 			else if (!SelectingText())
 				m_iBufferPos_Tail = m_iBufferPos;
 
 			if (!pCaption.empty() && m_iBufferPos < static_cast<int>(pCaption.length()))
 			{
 				// Select chars to the right until we hit whitespace
 				while (++m_iBufferPos < static_cast<int>(pCaption.length()))
 				{
 					if (iswspace(pCaption[m_iBufferPos]) || iswpunct(pCaption[m_iBufferPos]))
 						break;
 				}
 
 				// Also select any whitespace following the word we just selected
 				while (m_iBufferPos < static_cast<int>(pCaption.length()))
 				{
 					if (!iswspace(pCaption[m_iBufferPos]))
 						break;
 
 					++m_iBufferPos;
 				}
 			}
 		}
 		else
 		{
 			if (m_iBufferPos_Tail > m_iBufferPos)
 				m_iBufferPos = m_iBufferPos_Tail;
 
 			m_iBufferPos_Tail = -1;
 		}
 
 		UpdateBufferPositionSetting();
 		UpdateAutoScroll();
 
 		return IN_HANDLED;
 	}
 
 	return IN_PASS;
 }
 
 
 void CInput::HandleMessage(SGUIMessage& Message)
 {
 	IGUIScrollBarOwner::HandleMessage(Message);
 
 	switch (Message.type)
 	{
 	case GUIM_SETTINGS_UPDATED:
 	{
 		bool scrollbar;
 		GUI<bool>::GetSetting(this, "scrollbar", scrollbar);
 
 		// Update scroll-bar
 		// TODO Gee: (2004-09-01) Is this really updated each time it should?
 		if (scrollbar &&
 			(Message.value == CStr("size") ||
 			 Message.value == CStr("z") ||
 			 Message.value == CStr("absolute")))
 		{
 			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);
 		}
 
 		// Update scrollbar
 		if (Message.value == CStr("scrollbar_style"))
 		{
 			CStr scrollbar_style;
 			GUI<CStr>::GetSetting(this, Message.value, scrollbar_style);
 
 			GetScrollBar(0).SetScrollBarStyle(scrollbar_style);
 		}
 
 		if (Message.value == CStr("buffer_position"))
 		{
 			GUI<int>::GetSetting(this, Message.value, m_iBufferPos);
 			m_iBufferPos_Tail = -1; // position change resets selection
 		}
 
 		if (Message.value == CStr("size") ||
 			Message.value == CStr("z") ||
 			Message.value == CStr("font") ||
 			Message.value == CStr("absolute") ||
 			Message.value == CStr("caption") ||
 			Message.value == CStr("scrollbar") ||
 			Message.value == CStr("scrollbar_style"))
 		{
 			UpdateText();
 		}
 
 		if (Message.value == CStr("multiline"))
 		{
 			bool multiline;
 			GUI<bool>::GetSetting(this, "multiline", multiline);
 
 			if (!multiline)
 				GetScrollBar(0).SetLength(0.f);
 			else
 				GetScrollBar(0).SetLength(m_CachedActualSize.bottom - m_CachedActualSize.top);
 
 			UpdateText();
 		}
 
 		UpdateAutoScroll();
 
 		if (Message.value == CStr("readonly"))
 			GUI<bool>::GetSetting(this, "readonly", m_Readonly);
 
 		break;
 	}
 	case GUIM_MOUSE_PRESS_LEFT:
 	{
 		bool scrollbar, multiline;
 		GUI<bool>::GetSetting(this, "scrollbar", scrollbar);
 		GUI<bool>::GetSetting(this, "multiline", multiline);
 
 		// Check if we're selecting the scrollbar
 		if (GetScrollBar(0).GetStyle() && multiline)
 		{
 			if (m_pGUI->GetMousePos().x > m_CachedActualSize.right - GetScrollBar(0).GetStyle()->m_Width)
 				break;
 		}
 
 		if (m_ComposingText)
 			break;
 
 		// Okay, this section is about pressing the mouse and
 		//  choosing where the point should be placed. For
 		//  instance, if we press between a and b, the point
 		//  should of course be placed accordingly. Other
 		//  special cases are handled like the input box norms.
 		if (g_keys[SDLK_RSHIFT] || g_keys[SDLK_LSHIFT])
 			m_iBufferPos = GetMouseHoveringTextPosition();
 		else
 			m_iBufferPos = m_iBufferPos_Tail = GetMouseHoveringTextPosition();
 
 		m_SelectingText = true;
 
 		UpdateAutoScroll();
 
 		// If we immediately release the button it will just be seen as a click
 		//  for the user though.
 		break;
 	}
 	case GUIM_MOUSE_DBLCLICK_LEFT:
 	{
 		if (m_ComposingText)
 			break;
 
 		const CStrW& pCaption = GUI<CStrW>::GetSetting(this, "caption");
 
 		if (pCaption.empty())
 			break;
 
 		m_iBufferPos = m_iBufferPos_Tail = GetMouseHoveringTextPosition();
 
 		if (m_iBufferPos >= (int)pCaption.length())
 			m_iBufferPos = m_iBufferPos_Tail = pCaption.length() - 1;
 
 		// See if we are clicking over whitespace
 		if (iswspace(pCaption[m_iBufferPos]))
 		{
 			// see if we are in a section of whitespace greater than one character
 			if ((m_iBufferPos + 1 < (int) pCaption.length() && iswspace(pCaption[m_iBufferPos + 1])) ||
 				(m_iBufferPos - 1 > 0 && iswspace(pCaption[m_iBufferPos - 1])))
 			{
 				//
 				// We are clicking in an area with more than one whitespace character
 				// so we select both the word to the left and then the word to the right
 				//
 				// [1] First the left
 				// skip the whitespace
 				while (m_iBufferPos > 0)
 				{
 					if (!iswspace(pCaption[m_iBufferPos - 1]))
 						break;
 
 					m_iBufferPos--;
 				}
 				// now go until we hit white space or punctuation
 				while (m_iBufferPos > 0)
 				{
 					if (iswspace(pCaption[m_iBufferPos - 1]))
 						break;
 
 					m_iBufferPos--;
 
 					if (iswpunct(pCaption[m_iBufferPos]))
 						break;
 				}
 
 				// [2] Then the right
 				// go right until we are not in whitespace
 				while (++m_iBufferPos_Tail < static_cast<int>(pCaption.length()))
 				{
 					if (!iswspace(pCaption[m_iBufferPos_Tail]))
 						break;
 				}
 
 				if (m_iBufferPos_Tail == static_cast<int>(pCaption.length()))
 					break;
 
 				// now go to the right until we hit whitespace or punctuation
 				while (++m_iBufferPos_Tail < static_cast<int>(pCaption.length()))
 				{
 					if (iswspace(pCaption[m_iBufferPos_Tail]) || iswpunct(pCaption[m_iBufferPos_Tail]))
 						break;
 				}
 			}
 			else
 			{
 				// single whitespace so select word to the right
 				while (++m_iBufferPos_Tail < static_cast<int>(pCaption.length()))
 				{
 					if (!iswspace(pCaption[m_iBufferPos_Tail]))
 						break;
 				}
 
 				if (m_iBufferPos_Tail == static_cast<int>(pCaption.length()))
 					break;
 
 				// Don't include the leading whitespace
 				m_iBufferPos = m_iBufferPos_Tail;
 
 				// now go to the right until we hit whitespace or punctuation
 				while (++m_iBufferPos_Tail < static_cast<int>(pCaption.length()))
 				{
 					if (iswspace(pCaption[m_iBufferPos_Tail]) || iswpunct(pCaption[m_iBufferPos_Tail]))
 						break;
 				}
 			}
 		}
 		else
 		{
 			// clicked on non-whitespace so select current word
 			// go until we hit white space or punctuation
 			while (m_iBufferPos > 0)
 			{
 				if (iswspace(pCaption[m_iBufferPos - 1]))
 					break;
 
 				m_iBufferPos--;
 
 				if (iswpunct(pCaption[m_iBufferPos]))
 					break;
 			}
 			// go to the right until we hit whitespace or punctuation
 			while (++m_iBufferPos_Tail < static_cast<int>(pCaption.length()))
 				if (iswspace(pCaption[m_iBufferPos_Tail]) || iswpunct(pCaption[m_iBufferPos_Tail]))
 					break;
 		}
 		UpdateAutoScroll();
 		break;
 	}
 	case GUIM_MOUSE_RELEASE_LEFT:
 	{
 		if (m_SelectingText)
 			m_SelectingText = false;
 		break;
 	}
 	case GUIM_MOUSE_MOTION:
 	{
 		// If we just pressed down and started to move before releasing
 		//  this is one way of selecting larger portions of text.
 		if (m_SelectingText)
 		{
 			// Actually, first we need to re-check that the mouse button is
 			//  really pressed (it can be released while outside the control.
 			if (!g_mouse_buttons[SDL_BUTTON_LEFT])
 				m_SelectingText = false;
 			else
 				m_iBufferPos = GetMouseHoveringTextPosition();
 			UpdateAutoScroll();
 		}
 		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);
 
 		UpdateText();
 		UpdateAutoScroll();
 
 		GUI<bool>::GetSetting(this, "readonly", m_Readonly);
 		break;
 	}
 	case GUIM_GOT_FOCUS:
 	{
 		m_iBufferPos = 0;
 		m_PrevTime = 0.0;
 		m_CursorVisState = false;
 
 		// Tell the IME where to draw the candidate list
 		SDL_Rect rect;
 		rect.h = m_CachedActualSize.GetSize().cy;
 		rect.w = m_CachedActualSize.GetSize().cx;
 		rect.x = m_CachedActualSize.TopLeft().x;
 		rect.y = m_CachedActualSize.TopLeft().y;
 		SDL_SetTextInputRect(&rect);
 		SDL_StartTextInput();
 		break;
 	}
 	case GUIM_LOST_FOCUS:
 	{
 		if (m_ComposingText)
 		{
 			// Simulate a final text editing event to clear the composition
 			SDL_Event_ evt;
 			evt.ev.type = SDL_TEXTEDITING;
 			evt.ev.edit.length = 0;
 			evt.ev.edit.start = 0;
 			evt.ev.edit.text[0] = 0;
 			ManuallyHandleEvent(&evt);
 		}
 		SDL_StopTextInput();
 
 		m_iBufferPos = -1;
 		m_iBufferPos_Tail = -1;
 		break;
 	}
 	default:
 	{
 		break;
 	}
 	}
 	UpdateBufferPositionSetting();
 }
 
 void CInput::UpdateCachedSize()
 {
 	// If an ancestor's size changed, this will let us intercept the change and
 	// update our scrollbar positions
 
 	IGUIObject::UpdateCachedSize();
 
 	bool scrollbar;
 	GUI<bool>::GetSetting(this, "scrollbar", scrollbar);
 	if (scrollbar)
 	{
 		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);
 	}
 }
 
 void CInput::Draw()
 {
 	float bz = GetBufferedZ();
 
 	if (m_CursorBlinkRate > 0.0)
 	{
 		// check if the cursor visibility state needs to be changed
 		double currTime = timer_Time();
 		if (currTime - m_PrevTime >= m_CursorBlinkRate)
 		{
 			m_CursorVisState = !m_CursorVisState;
 			m_PrevTime = currTime;
 		}
 	}
 	else
 		// should always be visible
 		m_CursorVisState = true;
 
 	// First call draw on ScrollBarOwner
 	bool scrollbar;
 	float buffer_zone;
 	bool multiline;
 	bool mask;
 	GUI<bool>::GetSetting(this, "scrollbar", scrollbar);
 	GUI<float>::GetSetting(this, "buffer_zone", buffer_zone);
 	GUI<bool>::GetSetting(this, "multiline", multiline);
 	GUI<bool>::GetSetting(this, "mask", mask);
 
 	if (scrollbar && multiline)
 		IGUIScrollBarOwner::Draw();
 
 	CStrW font_name_w;
-	CGUIColor color, color_selected;
 	GUI<CStrW>::GetSetting(this, "font", font_name_w);
-	GUI<CGUIColor>::GetSetting(this, "textcolor", color);
-	GUI<CGUIColor>::GetSetting(this, "textcolor_selected", color_selected);
+	const CGUIColor& color = GUI<CGUIColor>::GetSetting(this, "textcolor");
+	const CGUIColor& color_selected = GUI<CGUIColor>::GetSetting(this, "textcolor_selected");
 	CStrIntern font_name(font_name_w.ToUTF8());
 
 	const CStrW& pCaption = GUI<CStrW>::GetSetting(this, "caption");
 	wchar_t mask_char = L'*';
 	if (mask)
 	{
 		CStrW maskStr;
 		GUI<CStrW>::GetSetting(this, "mask_char", maskStr);
 		if (maskStr.length() > 0)
 			mask_char = maskStr[0];
 	}
 
 	CGUISpriteInstance& sprite = GUI<CGUISpriteInstance>::GetSetting(this, "sprite");
 	CGUISpriteInstance& sprite_selectarea = GUI<CGUISpriteInstance>::GetSetting(this, "sprite_selectarea");
 
 	int cell_id;
 	GUI<int>::GetSetting(this, "cell_id", cell_id);
 
 	m_pGUI->DrawSprite(sprite, cell_id, bz, m_CachedActualSize);
 
 	float scroll = 0.f;
 	if (scrollbar && multiline)
 		scroll = GetScrollBar(0).GetPos();
 
 	CFontMetrics font(font_name);
 
 	// We'll have to setup clipping manually, since we're doing the rendering manually.
 	CRect cliparea(m_CachedActualSize);
 
 	// First we'll figure out the clipping area, which is the cached actual size
 	//  substracted by an optional scrollbar
 	if (scrollbar)
 	{
 		scroll = GetScrollBar(0).GetPos();
 
 		// substract 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;
 	}
 
 	if (cliparea != CRect())
 	{
 		glEnable(GL_SCISSOR_TEST);
 		glScissor(
 			cliparea.left * g_GuiScale,
 			g_yres - cliparea.bottom * g_GuiScale,
 			cliparea.GetWidth() * g_GuiScale,
 			cliparea.GetHeight() * g_GuiScale);
 	}
 
 	// These are useful later.
 	int VirtualFrom, VirtualTo;
 
 	if (m_iBufferPos_Tail >= m_iBufferPos)
 	{
 		VirtualFrom = m_iBufferPos;
 		VirtualTo = m_iBufferPos_Tail;
 	}
 	else
 	{
 		VirtualFrom = m_iBufferPos_Tail;
 		VirtualTo = m_iBufferPos;
 	}
 
 	// Get the height of this font.
 	float h = (float)font.GetHeight();
 	float ls = (float)font.GetLineSpacing();
 
 	CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_gui_text);
 
 	CTextRenderer textRenderer(tech->GetShader());
 	textRenderer.Font(font_name);
 
 	// Set the Z to somewhat more, so we can draw a selected area between the
 	//  the control and the text.
 	textRenderer.Translate(
 		(float)(int)(m_CachedActualSize.left) + buffer_zone,
 		(float)(int)(m_CachedActualSize.top+h) + buffer_zone,
 		bz+0.1f);
 
 	// U+FE33: PRESENTATION FORM FOR VERTICAL LOW LINE
 	// (sort of like a | which is aligned to the left of most characters)
 
 	float buffered_y = -scroll+buffer_zone;
 
 	// When selecting larger areas, we need to draw a rectangle box
 	//  around it, and this is to keep track of where the box
 	//  started, because we need to follow the iteration until we
 	//  reach the end, before we can actually draw it.
 	bool drawing_box = false;
 	float box_x = 0.f;
 
 	float x_pointer = 0.f;
 
 	// If we have a selecting box (i.e. when you have selected letters, not just when
 	//  the pointer is between two letters) we need to process all letters once
 	//  before we do it the second time and render all the text. We can't do it
 	//  in the same loop because text will have been drawn, so it will disappear when
 	//  drawn behind the text that has already been drawn. Confusing, well it's necessary
 	//  (I think).
 
 	if (SelectingText())
 	{
 		// Now m_iBufferPos_Tail can be of both sides of m_iBufferPos,
 		//  just like you can select from right to left, as you can
 		//  left to right. Is there a difference? Yes, the pointer
 		//  be placed accordingly, so that if you select shift and
 		//  expand this selection, it will expand on appropriate side.
 		// Anyway, since the drawing procedure needs "To" to be
 		//  greater than from, we need virtual values that might switch
 		//  place.
 
 		int VirtualFrom, VirtualTo;
 
 		if (m_iBufferPos_Tail >= m_iBufferPos)
 		{
 			VirtualFrom = m_iBufferPos;
 			VirtualTo = m_iBufferPos_Tail;
 		}
 		else
 		{
 			VirtualFrom = m_iBufferPos_Tail;
 			VirtualTo = m_iBufferPos;
 		}
 
 
 		bool done = false;
 		for (std::list<SRow>::const_iterator it = m_CharacterPositions.begin();
 		     it != m_CharacterPositions.end();
 		     ++it, buffered_y += ls, x_pointer = 0.f)
 		{
 			if (multiline && buffered_y > m_CachedActualSize.GetHeight())
 				break;
 
 			// We might as well use 'i' here to iterate, because we need it
 			// (often compared against ints, so don't make it size_t)
 			for (int i = 0; i < (int)it->m_ListOfX.size()+2; ++i)
 			{
 				if (it->m_ListStart + i == VirtualFrom)
 				{
 					// we won't actually draw it now, because we don't
 					//  know the width of each glyph to that position.
 					//  we need to go along with the iteration, and
 					//  make a mark where the box started:
 					drawing_box = true; // will turn false when finally rendered.
 
 					// Get current x position
 					box_x = x_pointer;
 				}
 
 				const bool at_end = (i == (int)it->m_ListOfX.size()+1);
 
 				if (drawing_box && (it->m_ListStart + i == VirtualTo || at_end))
 				{
 					// Depending on if it's just a row change, or if it's
 					//  the end of the select box, do slightly different things.
 					if (at_end)
 					{
 						if (it->m_ListStart + i != VirtualFrom)
 							// and actually add a white space! yes, this is done in any common input
 							x_pointer += (float)font.GetCharacterWidth(L' ');
 					}
 					else
 					{
 						drawing_box = false;
 						done = true;
 					}
 
 					CRect rect;
 					// Set 'rect' depending on if it's a multiline control, or a one-line control
 					if (multiline)
 					{
 						rect = CRect(
 							m_CachedActualSize.left + box_x + buffer_zone,
 							m_CachedActualSize.top + buffered_y + (h - ls) / 2,
 							m_CachedActualSize.left + x_pointer + buffer_zone,
 							m_CachedActualSize.top + buffered_y + (h + ls) / 2);
 
 						if (rect.bottom < m_CachedActualSize.top)
 							continue;
 
 						if (rect.top < m_CachedActualSize.top)
 							rect.top = m_CachedActualSize.top;
 
 						if (rect.bottom > m_CachedActualSize.bottom)
 							rect.bottom = m_CachedActualSize.bottom;
 					}
 					else // if one-line
 					{
 						rect = CRect(
 							m_CachedActualSize.left + box_x + buffer_zone - m_HorizontalScroll,
 							m_CachedActualSize.top + buffered_y + (h - ls) / 2,
 							m_CachedActualSize.left + x_pointer + buffer_zone - m_HorizontalScroll,
 							m_CachedActualSize.top + buffered_y + (h + ls) / 2);
 
 						if (rect.left < m_CachedActualSize.left)
 							rect.left = m_CachedActualSize.left;
 
 						if (rect.right > m_CachedActualSize.right)
 							rect.right = m_CachedActualSize.right;
 					}
 
 					m_pGUI->DrawSprite(sprite_selectarea, cell_id, bz+0.05f, rect);
 				}
 
 				if (i < (int)it->m_ListOfX.size())
 				{
 					if (!mask)
 						x_pointer += (float)font.GetCharacterWidth(pCaption[it->m_ListStart + i]);
 					else
 						x_pointer += (float)font.GetCharacterWidth(mask_char);
 				}
 			}
 
 			if (done)
 				break;
 
 			// If we're about to draw a box, and all of a sudden changes
 			//  line, we need to draw that line's box, and then reset
 			//  the box drawing to the beginning of the new line.
 			if (drawing_box)
 				box_x = 0.f;
 		}
 	}
 
 	// Reset some from previous run
 	buffered_y = -scroll;
 
 	// Setup initial color (then it might change and change back, when drawing selected area)
 	textRenderer.Color(color);
 
 	tech->BeginPass();
 
 	bool using_selected_color = false;
 
 	for (std::list<SRow>::const_iterator it = m_CharacterPositions.begin();
 	     it != m_CharacterPositions.end();
 	     ++it, buffered_y += ls)
 	{
 		if (buffered_y + buffer_zone >= -ls || !multiline)
 		{
 			if (multiline && buffered_y + buffer_zone > m_CachedActualSize.GetHeight())
 				break;
 
 			CMatrix3D savedTransform = textRenderer.GetTransform();
 
 			// Text must always be drawn in integer values. So we have to convert scroll
 			if (multiline)
 				textRenderer.Translate(0.f, -(float)(int)scroll, 0.f);
 			else
 				textRenderer.Translate(-(float)(int)m_HorizontalScroll, 0.f, 0.f);
 
 			// We might as well use 'i' here, because we need it
 			// (often compared against ints, so don't make it size_t)
 			for (int i = 0; i < (int)it->m_ListOfX.size()+1; ++i)
 			{
 				if (!multiline && i < (int)it->m_ListOfX.size())
 				{
 					if (it->m_ListOfX[i] - m_HorizontalScroll < -buffer_zone)
 					{
 						// We still need to translate the OpenGL matrix
 						if (i == 0)
 							textRenderer.Translate(it->m_ListOfX[i], 0.f, 0.f);
 						else
 							textRenderer.Translate(it->m_ListOfX[i] - it->m_ListOfX[i-1], 0.f, 0.f);
 
 						continue;
 					}
 				}
 
 				// End of selected area, change back color
 				if (SelectingText() && it->m_ListStart + i == VirtualTo)
 				{
 					using_selected_color = false;
 					textRenderer.Color(color);
 				}
 
 				// selecting only one, then we need only to draw a cursor.
 				if (i != (int)it->m_ListOfX.size() && it->m_ListStart + i == m_iBufferPos && m_CursorVisState)
 					textRenderer.Put(0.0f, 0.0f, L"_");
 
 				// Drawing selected area
 				if (SelectingText() &&
 				    it->m_ListStart + i >= VirtualFrom &&
 				    it->m_ListStart + i < VirtualTo &&
 				    !using_selected_color)
 				{
 					using_selected_color = true;
 					textRenderer.Color(color_selected);
 				}
 
 				if (i != (int)it->m_ListOfX.size())
 				{
 					if (!mask)
 						textRenderer.PrintfAdvance(L"%lc", pCaption[it->m_ListStart + i]);
 					else
 						textRenderer.PrintfAdvance(L"%lc", mask_char);
 				}
 
 				// check it's now outside a one-liner, then we'll break
 				if (!multiline && i < (int)it->m_ListOfX.size() &&
 				    it->m_ListOfX[i] - m_HorizontalScroll > m_CachedActualSize.GetWidth() - buffer_zone)
 					break;
 			}
 
 			if (it->m_ListStart + (int)it->m_ListOfX.size() == m_iBufferPos)
 			{
 				textRenderer.Color(color);
 				if (m_CursorVisState)
 					textRenderer.PutAdvance(L"_");
 
 				if (using_selected_color)
 					textRenderer.Color(color_selected);
 			}
 
 			textRenderer.SetTransform(savedTransform);
 		}
 
 		textRenderer.Translate(0.f, ls, 0.f);
 	}
 
 	textRenderer.Render();
 
 	if (cliparea != CRect())
 		glDisable(GL_SCISSOR_TEST);
 
 	tech->EndPass();
 }
 
 void CInput::UpdateText(int from, int to_before, int to_after)
 {
 	CStrW caption;
 	CStrW font_name_w;
 	float buffer_zone;
 	bool multiline;
 	bool mask;
 	GUI<CStrW>::GetSetting(this, "font", font_name_w);
 	GUI<CStrW>::GetSetting(this, "caption", caption);
 	GUI<float>::GetSetting(this, "buffer_zone", buffer_zone);
 	GUI<bool>::GetSetting(this, "multiline", multiline);
 	GUI<bool>::GetSetting(this, "mask", mask);
 	CStrIntern font_name(font_name_w.ToUTF8());
 
 	wchar_t mask_char = L'*';
 	if (mask)
 	{
 		CStrW maskStr;
 		GUI<CStrW>::GetSetting(this, "mask_char", maskStr);
 		if (maskStr.length() > 0)
 			mask_char = maskStr[0];
 	}
 
 	// Ensure positions are valid after caption changes
 	m_iBufferPos = std::min(m_iBufferPos, (int)caption.size());
 	m_iBufferPos_Tail = std::min(m_iBufferPos_Tail, (int)caption.size());
 	UpdateBufferPositionSetting();
 
 	if (font_name.empty())
 	{
 		// Destroy everything stored, there's no font, so there can be no data.
 		m_CharacterPositions.clear();
 		return;
 	}
 
 	SRow row;
 	row.m_ListStart = 0;
 
 	int to = 0;	// make sure it's initialized
 
 	if (to_before == -1)
 		to = (int)caption.length();
 
 	CFontMetrics font(font_name);
 
 	std::list<SRow>::iterator current_line;
 
 	// Used to ... TODO
 	int check_point_row_start = -1;
 	int check_point_row_end = -1;
 
 	// Reset
 	if (from == 0 && to_before == -1)
 	{
 		m_CharacterPositions.clear();
 		current_line = m_CharacterPositions.begin();
 	}
 	else
 	{
 		ENSURE(to_before != -1);
 
 		std::list<SRow>::iterator destroy_row_from;
 		std::list<SRow>::iterator destroy_row_to;
 		// Used to check if the above has been set to anything,
 		//  previously a comparison like:
 		//  destroy_row_from == std::list<SRow>::iterator()
 		// ... was used, but it didn't work with GCC.
 		bool destroy_row_from_used = false;
 		bool destroy_row_to_used = false;
 
 		// Iterate, and remove everything between 'from' and 'to_before'
 		//  actually remove the entire lines they are on, it'll all have
 		//  to be redone. And when going along, we'll delete a row at a time
 		//  when continuing to see how much more after 'to' we need to remake.
 		int i = 0;
 		for (std::list<SRow>::iterator it = m_CharacterPositions.begin();
 		     it != m_CharacterPositions.end();
 		     ++it, ++i)
 		{
 			if (!destroy_row_from_used && it->m_ListStart > from)
 			{
 				// Destroy the previous line, and all to 'to_before'
 				destroy_row_from = it;
 				--destroy_row_from;
 
 				destroy_row_from_used = true;
 
 				// For the rare case that we might remove characters to a word
 				//  so that it suddenly fits on the previous row,
 				//  we need to by standards re-do the whole previous line too
 				//  (if one exists)
 				if (destroy_row_from != m_CharacterPositions.begin())
 					--destroy_row_from;
 			}
 
 			if (!destroy_row_to_used && it->m_ListStart > to_before)
 			{
 				destroy_row_to = it;
 				destroy_row_to_used = true;
 
 				// If it isn't the last row, we'll add another row to delete,
 				//  just so we can see if the last restorted line is
 				//  identical to what it was before. If it isn't, then we'll
 				//  have to continue.
 				// 'check_point_row_start' is where we store how the that
 				//  line looked.
 				if (destroy_row_to != m_CharacterPositions.end())
 				{
 					check_point_row_start = destroy_row_to->m_ListStart;
 					check_point_row_end = check_point_row_start + (int)destroy_row_to->m_ListOfX.size();
 					if (destroy_row_to->m_ListOfX.empty())
 						++check_point_row_end;
 				}
 
 				++destroy_row_to;
 				break;
 			}
 		}
 
 		if (!destroy_row_from_used)
 		{
 			destroy_row_from = m_CharacterPositions.end();
 			--destroy_row_from;
 
 			// As usual, let's destroy another row back
 			if (destroy_row_from != m_CharacterPositions.begin())
 				--destroy_row_from;
 
 			current_line = destroy_row_from;
 		}
 
 		if (!destroy_row_to_used)
 		{
 			destroy_row_to = m_CharacterPositions.end();
 			check_point_row_start = -1;
 		}
 
 		// set 'from' to the row we'll destroy from
 		//  and 'to' to the row we'll destroy to
 		from = destroy_row_from->m_ListStart;
 
 		if (destroy_row_to != m_CharacterPositions.end())
 			to = destroy_row_to->m_ListStart; // notice it will iterate [from, to), so it will never reach to.
 		else
 			to = (int)caption.length();
 
 
 		// Setup the first row
 		row.m_ListStart = destroy_row_from->m_ListStart;
 
 		std::list<SRow>::iterator temp_it = destroy_row_to;
 		--temp_it;
 
 		current_line = m_CharacterPositions.erase(destroy_row_from, destroy_row_to);
 
 		// If there has been a change in number of characters
 		//  we need to change all m_ListStart that comes after
 		//  the interval we just destroyed. We'll change all
 		//  values with the delta change of the string length.
 		int delta = to_after - to_before;
 		if (delta != 0)
 		{
 			for (std::list<SRow>::iterator it = current_line;
 			     it != m_CharacterPositions.end();
 			     ++it)
 				it->m_ListStart += delta;
 
 			// Update our check point too!
 			check_point_row_start += delta;
 			check_point_row_end += delta;
 
 			if (to != (int)caption.length())
 				to += delta;
 		}
 	}
 
 	int last_word_started = from;
 	float x_pos = 0.f;
 
 	//if (to_before != -1)
 	//	return;
 
 	for (int i = from; i < to; ++i)
 	{
 		if (caption[i] == L'\n' && multiline)
 		{
 			if (i == to-1 && to != (int)caption.length())
 				break; // it will be added outside
 
 			current_line = m_CharacterPositions.insert(current_line, row);
 			++current_line;
 
 			// Setup the next row:
 			row.m_ListOfX.clear();
 			row.m_ListStart = i+1;
 			x_pos = 0.f;
 		}
 		else
 		{
 			if (caption[i] == L' '/* || TODO Gee (2004-10-13): the '-' disappears, fix.
 				caption[i] == L'-'*/)
 				last_word_started = i+1;
 
 			if (!mask)
 				x_pos += (float)font.GetCharacterWidth(caption[i]);
 			else
 				x_pos += (float)font.GetCharacterWidth(mask_char);
 
 			if (x_pos >= GetTextAreaWidth() && multiline)
 			{
 				// The following decides whether it will word-wrap a word,
 				//  or if it's only one word on the line, where it has to
 				//  break the word apart.
 				if (last_word_started == row.m_ListStart)
 				{
 					last_word_started = i;
 					row.m_ListOfX.resize(row.m_ListOfX.size() - (i-last_word_started));
 					//row.m_ListOfX.push_back(x_pos);
 					//continue;
 				}
 				else
 				{
 					// regular word-wrap
 					row.m_ListOfX.resize(row.m_ListOfX.size() - (i-last_word_started+1));
 				}
 
 				// Now, create a new line:
 				//  notice: when we enter a newline, you can stand with the cursor
 				//  both before and after that character, being on different
 				//  rows. With automatic word-wrapping, that is not possible. Which
 				//  is intuitively correct.
 
 				current_line = m_CharacterPositions.insert(current_line, row);
 				++current_line;
 
 				// Setup the next row:
 				row.m_ListOfX.clear();
 				row.m_ListStart = last_word_started;
 
 				i = last_word_started-1;
 
 				x_pos = 0.f;
 			}
 			else
 				// Get width of this character:
 				row.m_ListOfX.push_back(x_pos);
 		}
 
 		// Check if it's the last iteration, and we're not revising the whole string
 		//  because in that case, more word-wrapping might be needed.
 		//  also check if the current line isn't the end
 		if (to_before != -1 && i == to-1 && current_line != m_CharacterPositions.end())
 		{
 			// check all rows and see if any existing
 			if (row.m_ListStart != check_point_row_start)
 			{
 				std::list<SRow>::iterator destroy_row_from;
 				std::list<SRow>::iterator destroy_row_to;
 				// Are used to check if the above has been set to anything,
 				//  previously a comparison like:
 				//  destroy_row_from == std::list<SRow>::iterator()
 				//  was used, but it didn't work with GCC.
 				bool destroy_row_from_used = false;
 				bool destroy_row_to_used = false;
 
 				// Iterate, and remove everything between 'from' and 'to_before'
 				//  actually remove the entire lines they are on, it'll all have
 				//  to be redone. And when going along, we'll delete a row at a time
 				//  when continuing to see how much more after 'to' we need to remake.
 				int i = 0;
 				for (std::list<SRow>::iterator it = m_CharacterPositions.begin();
 				     it != m_CharacterPositions.end();
 				     ++it, ++i)
 				{
 					if (!destroy_row_from_used && it->m_ListStart > check_point_row_start)
 					{
 						// Destroy the previous line, and all to 'to_before'
 						//if (i >= 2)
 						//	destroy_row_from = it-2;
 						//else
 						//	destroy_row_from = it-1;
 						destroy_row_from = it;
 						destroy_row_from_used = true;
 						//--destroy_row_from;
 					}
 
 					if (!destroy_row_to_used && it->m_ListStart > check_point_row_end)
 					{
 						destroy_row_to = it;
 						destroy_row_to_used = true;
 
 						// If it isn't the last row, we'll add another row to delete,
 						//  just so we can see if the last restorted line is
 						//  identical to what it was before. If it isn't, then we'll
 						//  have to continue.
 						// 'check_point_row_start' is where we store how the that
 						//  line looked.
 						if (destroy_row_to != m_CharacterPositions.end())
 						{
 							check_point_row_start = destroy_row_to->m_ListStart;
 							check_point_row_end = check_point_row_start + (int)destroy_row_to->m_ListOfX.size();
 							if (destroy_row_to->m_ListOfX.empty())
 								++check_point_row_end;
 						}
 						else
 							check_point_row_start = check_point_row_end = -1;
 
 						++destroy_row_to;
 						break;
 					}
 				}
 
 				if (!destroy_row_from_used)
 				{
 					destroy_row_from = m_CharacterPositions.end();
 					--destroy_row_from;
 
 					current_line = destroy_row_from;
 				}
 
 				if (!destroy_row_to_used)
 				{
 					destroy_row_to = m_CharacterPositions.end();
 					check_point_row_start = check_point_row_end = -1;
 				}
 
 				if (destroy_row_to != m_CharacterPositions.end())
 					to = destroy_row_to->m_ListStart; // notice it will iterate [from, to[, so it will never reach to.
 				else
 					to = (int)caption.length();
 
 
 				// Set current line, new rows will be added before current_line, so
 				//  we'll choose the destroy_row_to, because it won't be deleted
 				//  in the coming erase.
 				current_line = destroy_row_to;
 
 				m_CharacterPositions.erase(destroy_row_from, destroy_row_to);
 			}
 			// else, the for loop will end naturally.
 		}
 	}
 	// This is kind of special, when we renew a some lines, then the last
 	//  one will sometimes end with a space (' '), that really should
 	//  be omitted when word-wrapping. So we'll check if the last row
 	//  we'll add has got the same value as the next row.
 	if (current_line != m_CharacterPositions.end())
 	{
 		if (row.m_ListStart + (int)row.m_ListOfX.size() == current_line->m_ListStart)
 			row.m_ListOfX.resize(row.m_ListOfX.size()-1);
 	}
 
 	// add the final row (even if empty)
 	m_CharacterPositions.insert(current_line, row);
 
 	bool scrollbar;
 	GUI<bool>::GetSetting(this, "scrollbar", scrollbar);
 	if (scrollbar)
 	{
 		GetScrollBar(0).SetScrollRange(m_CharacterPositions.size() * font.GetLineSpacing() + buffer_zone*2.f);
 		GetScrollBar(0).SetScrollSpace(m_CachedActualSize.GetHeight());
 	}
 }
 
 int CInput::GetMouseHoveringTextPosition() const
 {
 	if (m_CharacterPositions.empty())
 		return 0;
 
 	// Return position
 	int retPosition;
 
 	float buffer_zone;
 	bool multiline;
 	GUI<float>::GetSetting(this, "buffer_zone", buffer_zone);
 	GUI<bool>::GetSetting(this, "multiline", multiline);
 
 	std::list<SRow>::const_iterator current = m_CharacterPositions.begin();
 
 	CPos mouse = m_pGUI->GetMousePos();
 
 	if (multiline)
 	{
 		CStrW font_name_w;
 		bool scrollbar;
 		GUI<CStrW>::GetSetting(this, "font", font_name_w);
 		GUI<bool>::GetSetting(this, "scrollbar", scrollbar);
 		CStrIntern font_name(font_name_w.ToUTF8());
 
 		float scroll = 0.f;
 		if (scrollbar)
 			scroll = GetScrollBarPos(0);
 
 		// Now get the height of the font.
 						// TODO: Get the real font
 		CFontMetrics font(font_name);
 		float spacing = (float)font.GetLineSpacing();
 
 		// Change mouse position relative to text.
 		mouse -= m_CachedActualSize.TopLeft();
 		mouse.x -= buffer_zone;
 		mouse.y += scroll - buffer_zone;
 
 		int row = (int)((mouse.y) / spacing);
 
 		if (row < 0)
 			row = 0;
 
 		if (row > (int)m_CharacterPositions.size()-1)
 			row = (int)m_CharacterPositions.size()-1;
 
 		// TODO Gee (2004-11-21): Okay, I need a 'std::list' for some reasons, but I would really like to
 		//  be able to get the specific element here. This is hopefully a temporary hack.
 
 		for (int i = 0; i < row; ++i)
 			++current;
 	}
 	else
 	{
 		// current is already set to begin,
 		//  but we'll change the mouse.x to fit our horizontal scrolling
 		mouse -= m_CachedActualSize.TopLeft();
 		mouse.x -= buffer_zone - m_HorizontalScroll;
 		// mouse.y is moot
 	}
 
 	retPosition = current->m_ListStart;
 
 	// Okay, now loop through the glyphs to find the appropriate X position
 	float dummy;
 	retPosition += GetXTextPosition(current, mouse.x, dummy);
 
 	return retPosition;
 }
 
 // Does not process horizontal scrolling, 'x' must be modified before inputted.
 int CInput::GetXTextPosition(const std::list<SRow>::const_iterator& current, const float& x, float& wanted) const
 {
 	int ret = 0;
 	float previous = 0.f;
 	int i = 0;
 
 	for (std::vector<float>::const_iterator it = current->m_ListOfX.begin();
 	     it != current->m_ListOfX.end();
 	     ++it, ++i)
 	{
 		if (*it >= x)
 		{
 			if (x - previous >= *it - x)
 				ret += i+1;
 			else
 				ret += i;
 
 			break;
 		}
 		previous = *it;
 	}
 	// If a position wasn't found, we will assume the last
 	//  character of that line.
 	if (i == (int)current->m_ListOfX.size())
 	{
 		ret += i;
 		wanted = x;
 	}
 	else
 		wanted = 0.f;
 
 	return ret;
 }
 
 void CInput::DeleteCurSelection()
 {
 	CStrW& pCaption = GUI<CStrW>::GetSetting(this, "caption");
 
 	int virtualFrom;
 	int virtualTo;
 
 	if (m_iBufferPos_Tail >= m_iBufferPos)
 	{
 		virtualFrom = m_iBufferPos;
 		virtualTo = m_iBufferPos_Tail;
 	}
 	else
 	{
 		virtualFrom = m_iBufferPos_Tail;
 		virtualTo = m_iBufferPos;
 	}
 
 	pCaption =
 		pCaption.Left(virtualFrom) +
 		pCaption.Right(static_cast<long>(pCaption.length()) - virtualTo);
 
 	UpdateText(virtualFrom, virtualTo, virtualFrom);
 
 	// Remove selection
 	m_iBufferPos_Tail = -1;
 	m_iBufferPos = virtualFrom;
 	UpdateBufferPositionSetting();
 }
 
 bool CInput::SelectingText() const
 {
 	return m_iBufferPos_Tail != -1 &&
 		   m_iBufferPos_Tail != m_iBufferPos;
 }
 
 float CInput::GetTextAreaWidth()
 {
 	bool scrollbar;
 	float buffer_zone;
 	GUI<bool>::GetSetting(this, "scrollbar", scrollbar);
 	GUI<float>::GetSetting(this, "buffer_zone", buffer_zone);
 
 	if (scrollbar && GetScrollBar(0).GetStyle())
 		return m_CachedActualSize.GetWidth() - buffer_zone*2.f - GetScrollBar(0).GetStyle()->m_Width;
 	else
 		return m_CachedActualSize.GetWidth() - buffer_zone*2.f;
 }
 
 void CInput::UpdateAutoScroll()
 {
 	float buffer_zone;
 	bool multiline;
 	GUI<float>::GetSetting(this, "buffer_zone", buffer_zone);
 	GUI<bool>::GetSetting(this, "multiline", multiline);
 
 	// Autoscrolling up and down
 	if (multiline)
 	{
 		CStrW font_name_w;
 		bool scrollbar;
 		GUI<CStrW>::GetSetting(this, "font", font_name_w);
 		GUI<bool>::GetSetting(this, "scrollbar", scrollbar);
 		CStrIntern font_name(font_name_w.ToUTF8());
 
 		float scroll = 0.f;
 		if (!scrollbar)
 			return;
 
 		scroll = GetScrollBar(0).GetPos();
 
 		// Now get the height of the font.
 						// TODO: Get the real font
 		CFontMetrics font(font_name);
 		float spacing = (float)font.GetLineSpacing();
 		//float height = font.GetHeight();
 
 		// TODO Gee (2004-11-21): Okay, I need a 'std::list' for some reasons, but I would really like to
 		//  be able to get the specific element here. This is hopefully a temporary hack.
 
 		std::list<SRow>::iterator current = m_CharacterPositions.begin();
 		int row = 0;
 		while (current != m_CharacterPositions.end())
 		{
 			if (m_iBufferPos >= current->m_ListStart &&
 			    m_iBufferPos <= current->m_ListStart + (int)current->m_ListOfX.size())
 				break;
 
 			++current;
 			++row;
 		}
 
 		// If scrolling down
 		if (-scroll + (float)(row+1) * spacing + buffer_zone*2.f > m_CachedActualSize.GetHeight())
 		{
 			// Scroll so the selected row is shown completely, also with buffer_zone length to the edge.
 			GetScrollBar(0).SetPos((float)(row+1) * spacing - m_CachedActualSize.GetHeight() + buffer_zone*2.f);
 		}
 		// If scrolling up
 		else if (-scroll + (float)row * spacing < 0.f)
 		{
 			// Scroll so the selected row is shown completely, also with buffer_zone length to the edge.
 			GetScrollBar(0).SetPos((float)row * spacing);
 		}
 	}
 	else // autoscrolling left and right
 	{
 		// Get X position of position:
 		if (m_CharacterPositions.empty())
 			return;
 
 		float x_position = 0.f;
 		float x_total = 0.f;
 		if (!m_CharacterPositions.begin()->m_ListOfX.empty())
 		{
 
 			// Get position of m_iBufferPos
 			if ((int)m_CharacterPositions.begin()->m_ListOfX.size() >= m_iBufferPos &&
 				m_iBufferPos > 0)
 				x_position = m_CharacterPositions.begin()->m_ListOfX[m_iBufferPos-1];
 
 			// Get complete length:
 			x_total = m_CharacterPositions.begin()->m_ListOfX[m_CharacterPositions.begin()->m_ListOfX.size()-1];
 		}
 
 		// Check if outside to the right
 		if (x_position - m_HorizontalScroll + buffer_zone*2.f > m_CachedActualSize.GetWidth())
 			m_HorizontalScroll = x_position - m_CachedActualSize.GetWidth() + buffer_zone*2.f;
 
 		// Check if outside to the left
 		if (x_position - m_HorizontalScroll < 0.f)
 			m_HorizontalScroll = x_position;
 
 		// Check if the text doesn't even fill up to the right edge even though scrolling is done.
 		if (m_HorizontalScroll != 0.f &&
 			x_total - m_HorizontalScroll + buffer_zone*2.f < m_CachedActualSize.GetWidth())
 			m_HorizontalScroll = x_total - m_CachedActualSize.GetWidth() + buffer_zone*2.f;
 
 		// Now this is the fail-safe, if x_total isn't even the length of the control,
 		//  remove all scrolling
 		if (x_total + buffer_zone*2.f < m_CachedActualSize.GetWidth())
 			m_HorizontalScroll = 0.f;
 	}
 }
Index: ps/trunk/source/gui/CList.cpp
===================================================================
--- ps/trunk/source/gui/CList.cpp	(revision 22693)
+++ ps/trunk/source/gui/CList.cpp	(revision 22694)
@@ -1,527 +1,525 @@
 /* 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;
 	const CGUIList& pList = GUI<CGUIList>::GetSetting(this, "list");
 
 	//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.
 	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)
 	{
 		CGUIText* text;
 
 		if (!pList.m_Items[i].GetOriginalString().empty())
 			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 = &AddText(align_string, font, width, buffer_zone, this);
 		}
 
 		m_ItemsYPositions[i] = buffered_y;
 		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 = GUI<CGUISpriteInstance>::GetSetting(this, _sprite);
 		CGUISpriteInstance& sprite_selectarea = GUI<CGUISpriteInstance>::GetSetting(this, _sprite_selected);
 
 		const int cell_id = GUI<int>::GetSetting(this, "cell_id");
 		m_pGUI->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;
 				}
 
 				m_pGUI->DrawSprite(sprite_selectarea, cell_id, bz+0.05f, rect_sel);
 			}
 		}
 
-		CGUIColor color;
-		GUI<CGUIColor>::GetSetting(this, _textcolor, color);
-
 		const CGUIList& pList = GUI<CGUIList>::GetSetting(this, "list");
+		const CGUIColor& color = GUI<CGUIColor>::GetSetting(this, _textcolor);
 
 		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);
+			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)
 {
 	CGUIString gui_string;
 	gui_string.SetValue(str);
 
 	// Do not send a settings-changed message
 	CGUIList& pList = GUI<CGUIList>::GetSetting(this, "list");
 	pList.m_Items.push_back(gui_string);
 
 	CGUIString data_string;
 	data_string.SetValue(data);
 	CGUIList& pListData = GUI<CGUIList>::GetSetting(this, "list_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");
 
 	const CGUIList& pList = GUI<CGUIList>::GetSetting(this, "list");
 
 	if (selected != static_cast<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");
 
 	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()
 {
 	if (GUI<int>::GetSetting(this, "selected") >= 0)
 		GUI<int>::SetSetting(this, "selected", 0);
 }
 
 void CList::SelectLastElement()
 {
 	const CGUIList& pList = GUI<CGUIList>::GetSetting(this, "list");
 	const int index = static_cast<int>(pList.m_Items.size()) - 1;
 
 	if (GUI<int>::GetSetting(this, "selected") != index)
 		GUI<int>::SetSetting(this, "selected", index);
 }
 
 void CList::UpdateAutoScroll()
 {
 	const int selected = GUI<int>::GetSetting(this, "selected");
 	const bool scrollbar = GUI<bool>::GetSetting(this, "scrollbar");
 
 	// No scrollbar, no scrolling (at least it's not made to work properly).
 	if (!scrollbar || selected < 0 || static_cast<std::size_t>(selected) >= m_ItemsYPositions.size())
 		return;
 
 	float 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()
 {
 	const bool scrollbar = GUI<bool>::GetSetting(this, "scrollbar");
 	const float scroll = scrollbar ? GetScrollBar(0).GetPos() : 0.f;
 
 	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;
 
 	const CGUIList& pList = GUI<CGUIList>::GetSetting(this, "list");
 	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 22693)
+++ ps/trunk/source/gui/COList.cpp	(revision 22694)
@@ -1,474 +1,470 @@
 /* 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()
 {
 	const CGUIList& pList = GUI<CGUIList>::GetSetting(this, "list");
 	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.
 	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;
 
 		CGUIString gui_string;
 		gui_string.SetValue(column.m_Heading);
 
 		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>::GetSetting(this, "list_" + column.m_Id);
 			CGUIText* text;
 			if (!pList_c.m_Items[i].GetOriginalString().empty())
 				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 = &AddText(align_string, font, width, buffer_zone, this);
 			}
 			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))
+				if (!GUI<CGUIColor>::ParseString(m_pGUI, attr_value.FromUTF8(), column.m_TextColor))
 					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 = GUI<CGUISpriteInstance>::GetSetting(this, _sprite);
 	CGUISpriteInstance& sprite_selectarea = GUI<CGUISpriteInstance>::GetSetting(this, _sprite_selected);
 
 	int cell_id;
 	GUI<int>::GetSetting(this, "cell_id", cell_id);
 
 	m_pGUI->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
 			m_pGUI->DrawSprite(sprite_selectarea, cell_id, bz+0.05f, rect_sel);
 		}
 	}
 
 	// Draw line above column header
 	CGUISpriteInstance& sprite_heading = GUI<CGUISpriteInstance>::GetSetting(this, "sprite_heading");
 	CRect rect_head(m_CachedActualSize.left, m_CachedActualSize.top, m_CachedActualSize.right,
 									m_CachedActualSize.top + m_HeadingHeight);
 	m_pGUI->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);
+	const CGUIColor& color = GUI<CGUIColor>::GetSetting(this, _textcolor);
 
 	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)
 		{
 			CStr spriteName;
 			if (selectedColumn == m_Columns[col].m_Id)
 			{
 				if (selectedColumnOrder == 0)
 					LOGERROR("selected_column_order must not be 0");
 
 				if (selectedColumnOrder != -1)
 					spriteName = "sprite_asc";
 				else
 					spriteName = "sprite_desc";
 			}
 			else
 				spriteName = "sprite_not_sorted";
 
 			CGUISpriteInstance& sprite = GUI<CGUISpriteInstance>::GetSetting(this, spriteName);
 			m_pGUI->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 CGUIList& pList = GUI<CGUIList>::GetSetting(this, "list");
 	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 22693)
+++ ps/trunk/source/gui/CText.cpp	(revision 22694)
@@ -1,262 +1,261 @@
 /* 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();
 }
 
 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";
 
 	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;
 
 	const CGUIString& caption = GUI<CGUIString>::GetSetting(this, "caption");
 	const float buffer_zone = GUI<float>::GetSetting(this, "buffer_zone");
 
 	m_GeneratedTexts[0] = CGUIText(m_pGUI, caption, font, width, buffer_zone, this);
 
 	if (!scrollbar)
 		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].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 = GUI<CGUISpriteInstance>::GetSetting(this, "sprite");
 
 	int cell_id;
 	bool clip;
 	GUI<int>::GetSetting(this, "cell_id", cell_id);
 	GUI<bool>::GetSetting(this, "clip", clip);
 
 	m_pGUI->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);
+	const CGUIColor& color = GUI<CGUIColor>::GetSetting(this, enabled ? "textcolor" : "textcolor_disabled");
 
 	if (scrollbar)
-		DrawText(0, color, m_CachedActualSize.TopLeft() - CPos(0.f, scroll), bz+0.1f, cliparea);
+		DrawText(0, color, m_CachedActualSize.TopLeft() - CPos(0.f, scroll), bz + 0.1f, cliparea);
 	else
-		DrawText(0, color, m_TextPos, bz+0.1f, cliparea);
+		DrawText(0, color, m_TextPos, bz + 0.1f, cliparea);
 }
 
 bool CText::MouseOverIcon()
 {
 	for (const CGUIText& guitext : m_GeneratedTexts)
 		for (const CGUIText::SSpriteCall& spritecall : guitext.GetSpriteCalls())
 		{
 			// Check mouse over sprite
 			if (!spritecall.m_Area.PointInside(m_pGUI->GetMousePos() - m_CachedActualSize.TopLeft()))
 				continue;
 
 			// If tooltip exists, set the property
 			if (!spritecall.m_Tooltip.empty())
 			{
 				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 22693)
+++ ps/trunk/source/gui/CTooltip.cpp	(revision 22694)
@@ -1,167 +1,165 @@
 /* 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();
 }
 
 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);
 
 	const CGUIString& caption = GUI<CGUIString>::GetSetting(this, "caption");
 
 	float max_width = 0.f;
 	GUI<float>::GetSetting(this, "maxwidth", max_width);
 
 	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].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>::GetSetting(this, "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;
 	}
 
 	m_pGUI->DrawSprite(sprite, 0, z, m_CachedActualSize);
 
-	CGUIColor color;
-	GUI<CGUIColor>::GetSetting(this, "textcolor", color);
-
+	const CGUIColor& color = GUI<CGUIColor>::GetSetting(this, "textcolor");
 	DrawText(0, color, m_CachedActualSize.TopLeft(), z+0.1f);
 }
Index: ps/trunk/source/gui/GUIRenderer.cpp
===================================================================
--- ps/trunk/source/gui/GUIRenderer.cpp	(revision 22693)
+++ ps/trunk/source/gui/GUIRenderer.cpp	(revision 22694)
@@ -1,468 +1,468 @@
 /* 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 "GUIRenderer.h"
 
 #include "graphics/ShaderManager.h"
 #include "graphics/TextureManager.h"
 #include "gui/CGUIColor.h"
 #include "gui/GUIutil.h"
 #include "gui/GUIMatrix.h"
 #include "i18n/L10n.h"
 #include "lib/ogl.h"
 #include "lib/utf8.h"
 #include "lib/res/h_mgr.h"
 #include "lib/tex/tex.h"
 #include "ps/CLogger.h"
 #include "ps/Filesystem.h"
 #include "renderer/Renderer.h"
 
 
 using namespace GUIRenderer;
 
 
 DrawCalls::DrawCalls()
 {
 }
 
 // DrawCalls needs to be copyable, so it can be used in other copyable types.
 // But actually copying data is hard, since we'd need to avoid losing track of
 // who owns various pointers, so instead we just return an empty list.
 // The list should get filled in again (by GUIRenderer::UpdateDrawCallCache)
 // before it's used for rendering. (TODO: Is this class actually used safely
 // in practice?)
 
 DrawCalls::DrawCalls(const DrawCalls&)
 	: std::vector<SDrawCall>()
 {
 }
 
 DrawCalls& DrawCalls::operator=(const DrawCalls&)
 {
 	return *this;
 }
 
 
 void GUIRenderer::UpdateDrawCallCache(const CGUI* pGUI, DrawCalls& Calls, const CStr& SpriteName, const CRect& Size, int CellID, std::map<CStr, const CGUISprite*>& Sprites)
 {
 	// This is called only when something has changed (like the size of the
 	// sprite), so it doesn't need to be particularly efficient.
 
 	// Clean up the old data
 	Calls.clear();
 
 	// If this object has zero size, there's nothing to render. (This happens
 	// with e.g. tooltips that have zero size before they're first drawn, so
 	// it isn't necessarily an error.)
 	if (Size.left == Size.right && Size.top == Size.bottom)
 		return;
 
 
 	std::map<CStr, const CGUISprite*>::iterator it(Sprites.find(SpriteName));
 	if (it == Sprites.end())
 	{
 		/*
 		 * Sprite not found. Check whether this a special sprite,
 		 * and if so create a new sprite:
 		 * "stretched:filename.ext" - stretched image
 		 * "stretched:grayscale:filename.ext" - stretched grayscale image.
 		 * "cropped:0.5, 0.25"    - stretch this ratio (x,y) of the top left of the image
 		 * "color:r g b a"        - solid color
 		 *     > "textureAsMask"  - when using color, use the (optional) texture alpha channel as mask.
 		 * These can be combined, but they must be separated by a ":"
 		 * so you can have a white overlay over an stretched grayscale image with:
 		 * "grayscale:color:255 255 255 100:stretched:filename.ext"
 		 */
 		// Check that this can be a special sprite.
 		if (SpriteName.ReverseFind(":") == -1 && SpriteName.Find("color(") == -1)
 		{
 			LOGERROR("Trying to use a sprite that doesn't exist (\"%s\").", SpriteName.c_str());
 			return;
 		}
 		CGUISprite* Sprite = new CGUISprite;
 		VfsPath TextureName = VfsPath("art/textures/ui") / wstring_from_utf8(SpriteName.AfterLast(":"));
 		if (SpriteName.Find("stretched:") != -1)
 		{
 			// TODO: Should check (nicely) that this is a valid file?
 			SGUIImage* Image = new SGUIImage;
 
 			Image->m_TextureName = TextureName;
 			// Allow grayscale images for disabled portraits
 			if (SpriteName.Find("grayscale:") != -1)
 			{
 				Image->m_Effects = std::make_shared<SGUIImageEffects>();
 				Image->m_Effects->m_Greyscale = true;
 			}
 
 			CClientArea ca(CRect(0, 0, 0, 0), CRect(0, 0, 100, 100));
 			Image->m_Size = ca;
 			Image->m_TextureSize = ca;
 
 			Sprite->AddImage(Image);
 
 			Sprites[SpriteName] = Sprite;
 		}
 		else if (SpriteName.Find("cropped:") != -1)
 		{
 			// TODO: Should check (nicely) that this is a valid file?
 			SGUIImage* Image = new SGUIImage;
 
 			CStr info = SpriteName.AfterLast("cropped:").BeforeFirst(":");
 			double xRatio = info.BeforeFirst(",").ToDouble();
 			double yRatio = info.AfterLast(",").ToDouble();
 
 			Image->m_TextureName = TextureName;
 
 			CClientArea ca(CRect(0, 0, 0, 0), CRect(0, 0, 100, 100));
 			CClientArea cb(CRect(0, 0, 0, 0), CRect(0, 0, 100/xRatio, 100/yRatio));
 			Image->m_Size = ca;
 			Image->m_TextureSize = cb;
 
 			Sprite->AddImage(Image);
 
 			Sprites[SpriteName] = Sprite;
 		}
 		if (SpriteName.Find("color:") != -1)
 		{
 			CStrW value = wstring_from_utf8(SpriteName.AfterLast("color:").BeforeFirst(":"));
-			CGUIColor color;
-
-			// Check color is valid
-			if (!GUI<CGUIColor>::ParseString(pGUI, value, color))
-			{
-				LOGERROR("GUI: Error parsing sprite 'color' (\"%s\")", utf8_from_wstring(value));
-				return;
-			}
 
 			SGUIImage* Image = new SGUIImage;
+			CGUIColor* color;
 
 			// If we are using a mask, this is an effect.
 			// Otherwise we can fallback to the "back color" attribute
 			// TODO: we are assuming there is a filename here.
 			if (SpriteName.Find("textureAsMask:") != -1)
 			{
 				Image->m_TextureName = TextureName;
 				Image->m_Effects = std::make_shared<SGUIImageEffects>();
-				Image->m_Effects->m_SolidColor = color;
+				color = &Image->m_Effects->m_SolidColor;
 			}
 			else
-				Image->m_BackColor = color;
+				color = &Image->m_BackColor;
+
+			// Check color is valid
+			if (!GUI<CGUIColor>::ParseString(pGUI, value, *color))
+			{
+				LOGERROR("GUI: Error parsing sprite 'color' (\"%s\")", utf8_from_wstring(value));
+				return;
+			}
 
 			CClientArea ca(CRect(0, 0, 0, 0), CRect(0, 0, 100, 100));
 			Image->m_Size = ca;
 			Image->m_TextureSize = ca;
 
 			Sprite->AddImage(Image);
 
 			Sprites[SpriteName] = Sprite;
 		}
 		it = Sprites.find(SpriteName);
 
 		// Otherwise, just complain and give up:
 		if (it == Sprites.end())
 		{
 			SAFE_DELETE(Sprite);
 			LOGERROR("Trying to use a sprite that doesn't exist (\"%s\").", SpriteName.c_str());
 			return;
 		}
 	}
 
 	Calls.reserve(it->second->m_Images.size());
 
 	// Iterate through all the sprite's images, loading the texture and
 	// calculating the texture coordinates
 	std::vector<SGUIImage*>::const_iterator cit;
 	for (cit = it->second->m_Images.begin(); cit != it->second->m_Images.end(); ++cit)
 	{
 		SDrawCall Call(*cit); // pointers are safe since we never modify sprites/images after startup
 
 		CRect ObjectSize = (*cit)->m_Size.GetClientArea(Size);
 
 		if (ObjectSize.GetWidth() == 0.0 || ObjectSize.GetHeight() == 0.0)
 		{
 			// Zero sized object. Don't report as an error, since it's common for e.g. hitpoint bars.
 			continue; // i.e. don't continue with this image
 		}
 
 		Call.m_Vertices = ObjectSize;
 		if ((*cit)->m_RoundCoordinates)
 		{
 			// Round the vertex coordinates to integers, to avoid ugly filtering artifacts
 			Call.m_Vertices.left = (int)(Call.m_Vertices.left + 0.5f);
 			Call.m_Vertices.right = (int)(Call.m_Vertices.right + 0.5f);
 			Call.m_Vertices.top = (int)(Call.m_Vertices.top + 0.5f);
 			Call.m_Vertices.bottom = (int)(Call.m_Vertices.bottom + 0.5f);
 		}
 
 		if (!(*cit)->m_TextureName.empty())
 		{
 			CTextureProperties textureProps(g_L10n.LocalizePath((*cit)->m_TextureName));
 			textureProps.SetWrap((*cit)->m_WrapMode);
 			CTexturePtr texture = g_Renderer.GetTextureManager().CreateTexture(textureProps);
 			texture->Prefetch();
 			Call.m_HasTexture = true;
 			Call.m_Texture = texture;
 
 			Call.m_EnableBlending = false; // will be overridden if the texture has an alpha channel
 
 			Call.m_ObjectSize = ObjectSize;
 			Call.m_CellID = CellID;
 		}
 		else
 		{
 			Call.m_HasTexture = false;
 			// Enable blending if it's transparent (allowing a little error in the calculations)
 			Call.m_EnableBlending = !(fabs((*cit)->m_BackColor.a - 1.0f) < 0.0000001f);
 		}
 
-		Call.m_BackColor = (*cit)->m_BackColor;
-		Call.m_BorderColor = (*cit)->m_Border ? (*cit)->m_BorderColor : CGUIColor();
+		Call.m_BackColor = &(*cit)->m_BackColor;
+		Call.m_BorderColor = (*cit)->m_Border ? &(*cit)->m_BorderColor : nullptr;
 		Call.m_DeltaZ = (*cit)->m_DeltaZ;
 
 		if (!Call.m_HasTexture)
 		{
 			Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect(str_gui_solid);
 		}
 		else if ((*cit)->m_Effects)
 		{
 			if ((*cit)->m_Effects->m_AddColor != CGUIColor())
 			{
 				Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect(str_gui_add);
 				Call.m_ShaderColorParameter = (*cit)->m_Effects->m_AddColor;
 				// Always enable blending if something's being subtracted from
 				// the alpha channel
 				if ((*cit)->m_Effects->m_AddColor.a < 0.f)
 					Call.m_EnableBlending = true;
 			}
 			else if ((*cit)->m_Effects->m_Greyscale)
 			{
 				Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect(str_gui_grayscale);
 			}
 			else if ((*cit)->m_Effects->m_SolidColor != CGUIColor())
 			{
 				Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect(str_gui_solid_mask);
 				Call.m_ShaderColorParameter = (*cit)->m_Effects->m_SolidColor;
 				Call.m_EnableBlending = !(fabs((*cit)->m_Effects->m_SolidColor.a - 1.0f) < 0.0000001f);
 			}
 			else /* Slight confusion - why no effects? */
 			{
 				Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect(str_gui_basic);
 			}
 		}
 		else
 		{
 			Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect(str_gui_basic);
 		}
 
 		Calls.push_back(Call);
 	}
 }
 
 CRect SDrawCall::ComputeTexCoords() const
 {
 	float TexWidth = m_Texture->GetWidth();
 	float TexHeight = m_Texture->GetHeight();
 
 	if (!TexWidth || !TexHeight)
 		return CRect(0, 0, 1, 1);
 
 	// Textures are positioned by defining a rectangular block of the
 	// texture (usually the whole texture), and a rectangular block on
 	// the screen. The texture is positioned to make those blocks line up.
 
 	// Get the screen's position/size for the block
 	CRect BlockScreen = m_Image->m_TextureSize.GetClientArea(m_ObjectSize);
 
 	if (m_Image->m_FixedHAspectRatio)
 		BlockScreen.right = BlockScreen.left + BlockScreen.GetHeight() * m_Image->m_FixedHAspectRatio;
 
 	// Get the texture's position/size for the block:
 	CRect BlockTex;
 
 	// "real_texture_placement" overrides everything
 	if (m_Image->m_TexturePlacementInFile != CRect())
 	{
 		BlockTex = m_Image->m_TexturePlacementInFile;
 	}
 	// Check whether this sprite has "cell_size" set (and non-zero)
 	else if ((int)m_Image->m_CellSize.cx)
 	{
 		int cols = (int)TexWidth / (int)m_Image->m_CellSize.cx;
 		if (cols == 0)
 			cols = 1; // avoid divide-by-zero
 		int col = m_CellID % cols;
 		int row = m_CellID / cols;
 		BlockTex = CRect(m_Image->m_CellSize.cx*col, m_Image->m_CellSize.cy*row,
 		                 m_Image->m_CellSize.cx*(col+1), m_Image->m_CellSize.cy*(row+1));
 	}
 	// Use the whole texture
 	else
 		BlockTex = CRect(0, 0, TexWidth, TexHeight);
 
 	// When rendering, BlockTex will be transformed onto BlockScreen.
 	// Also, TexCoords will be transformed onto ObjectSize (giving the
 	// UV coords at each vertex of the object). We know everything
 	// except for TexCoords, so calculate it:
 
 	CPos translation (BlockTex.TopLeft()-BlockScreen.TopLeft());
 	float ScaleW = BlockTex.GetWidth()/BlockScreen.GetWidth();
 	float ScaleH = BlockTex.GetHeight()/BlockScreen.GetHeight();
 
 	CRect TexCoords (
 				// Resize (translating to/from the origin, so the
 				// topleft corner stays in the same place)
 				(m_ObjectSize-m_ObjectSize.TopLeft())
 				.Scale(ScaleW, ScaleH)
 				+ m_ObjectSize.TopLeft()
 				// Translate from BlockTex to BlockScreen
 				+ translation
 	);
 
 	// The tex coords need to be scaled so that (texwidth,texheight) is
 	// mapped onto (1,1)
 	TexCoords.left   /= TexWidth;
 	TexCoords.right  /= TexWidth;
 	TexCoords.top    /= TexHeight;
 	TexCoords.bottom /= TexHeight;
 
 	return TexCoords;
 }
 
 void GUIRenderer::Draw(DrawCalls& Calls, float Z)
 {
 	// Called every frame, to draw the object (based on cached calculations)
 
 	// TODO: batching by shader/texture/etc would be nice
 
 	CMatrix3D matrix = GetDefaultGuiMatrix();
 
 	glDisable(GL_BLEND);
 
 	// Set LOD bias so mipmapped textures are prettier
 #if CONFIG2_GLES
 #warning TODO: implement GUI LOD bias for GLES
 #else
 	glTexEnvf(GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS, -1.f);
 #endif
 
 	// Iterate through each DrawCall, and execute whatever drawing code is being called
 	for (DrawCalls::const_iterator cit = Calls.begin(); cit != Calls.end(); ++cit)
 	{
 		cit->m_Shader->BeginPass();
 		CShaderProgramPtr shader = cit->m_Shader->GetShader();
 		shader->Uniform(str_transform, matrix);
 
 		if (cit->m_HasTexture)
 		{
 			shader->Uniform(str_color, cit->m_ShaderColorParameter);
 			shader->BindTexture(str_tex, cit->m_Texture);
 
 			if (cit->m_EnableBlending || cit->m_Texture->HasAlpha()) // (shouldn't call HasAlpha before BindTexture)
 			{
 				glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 				glEnable(GL_BLEND);
 			}
 
 			CRect TexCoords = cit->ComputeTexCoords();
 
 			// Ensure the quad has the correct winding order, and update texcoords to match
 			CRect Verts = cit->m_Vertices;
 			if (Verts.right < Verts.left)
 			{
 				std::swap(Verts.right, Verts.left);
 				std::swap(TexCoords.right, TexCoords.left);
 			}
 			if (Verts.bottom < Verts.top)
 			{
 				std::swap(Verts.bottom, Verts.top);
 				std::swap(TexCoords.bottom, TexCoords.top);
 			}
 
 			std::vector<float> data;
 #define ADD(u, v, x, y, z) STMT(data.push_back(u); data.push_back(v); data.push_back(x); data.push_back(y); data.push_back(z))
 			ADD(TexCoords.left, TexCoords.bottom, Verts.left, Verts.bottom, Z + cit->m_DeltaZ);
 			ADD(TexCoords.right, TexCoords.bottom, Verts.right, Verts.bottom, Z + cit->m_DeltaZ);
 			ADD(TexCoords.right, TexCoords.top, Verts.right, Verts.top, Z + cit->m_DeltaZ);
 
 			ADD(TexCoords.right, TexCoords.top, Verts.right, Verts.top, Z + cit->m_DeltaZ);
 			ADD(TexCoords.left, TexCoords.top, Verts.left, Verts.top, Z + cit->m_DeltaZ);
 			ADD(TexCoords.left, TexCoords.bottom, Verts.left, Verts.bottom, Z + cit->m_DeltaZ);
 #undef ADD
 
 			shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, 5*sizeof(float), &data[0]);
 			shader->VertexPointer(3, GL_FLOAT, 5*sizeof(float), &data[2]);
 			glDrawArrays(GL_TRIANGLES, 0, 6);
 		}
 		else
 		{
-			shader->Uniform(str_color, cit->m_BackColor);
+			shader->Uniform(str_color, *cit->m_BackColor);
 
 			if (cit->m_EnableBlending)
 			{
 				glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 				glEnable(GL_BLEND);
 			}
 
 			// Ensure the quad has the correct winding order
 			CRect Verts = cit->m_Vertices;
 			if (Verts.right < Verts.left)
 				std::swap(Verts.right, Verts.left);
 			if (Verts.bottom < Verts.top)
 				std::swap(Verts.bottom, Verts.top);
 
 			std::vector<float> data;
 #define ADD(x, y, z) STMT(data.push_back(x); data.push_back(y); data.push_back(z))
 			ADD(Verts.left, Verts.bottom, Z + cit->m_DeltaZ);
 			ADD(Verts.right, Verts.bottom, Z + cit->m_DeltaZ);
 			ADD(Verts.right, Verts.top, Z + cit->m_DeltaZ);
 
 			ADD(Verts.right, Verts.top, Z + cit->m_DeltaZ);
 			ADD(Verts.left, Verts.top, Z + cit->m_DeltaZ);
 			ADD(Verts.left, Verts.bottom, Z + cit->m_DeltaZ);
 
 			shader->VertexPointer(3, GL_FLOAT, 3*sizeof(float), &data[0]);
 			glDrawArrays(GL_TRIANGLES, 0, 6);
 
-			if (cit->m_BorderColor != CGUIColor())
+			if (cit->m_BorderColor != nullptr)
 			{
-				shader->Uniform(str_color, cit->m_BorderColor);
+				shader->Uniform(str_color, *cit->m_BorderColor);
 
 				data.clear();
 				ADD(Verts.left + 0.5f, Verts.top + 0.5f, Z + cit->m_DeltaZ);
 				ADD(Verts.right - 0.5f, Verts.top + 0.5f, Z + cit->m_DeltaZ);
 				ADD(Verts.right - 0.5f, Verts.bottom - 0.5f, Z + cit->m_DeltaZ);
 				ADD(Verts.left + 0.5f, Verts.bottom - 0.5f, Z + cit->m_DeltaZ);
 
 				shader->VertexPointer(3, GL_FLOAT, 3*sizeof(float), &data[0]);
 				glDrawArrays(GL_LINE_LOOP, 0, 4);
 			}
 #undef ADD
 		}
 
 		cit->m_Shader->EndPass();
 
 		glDisable(GL_BLEND);
 	}
 
 #if CONFIG2_GLES
 #warning TODO: implement GUI LOD bias for GLES
 #else
 	glTexEnvf(GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS, 0.f);
 #endif
 }
Index: ps/trunk/source/gui/GUIRenderer.h
===================================================================
--- ps/trunk/source/gui/GUIRenderer.h	(revision 22693)
+++ ps/trunk/source/gui/GUIRenderer.h	(revision 22694)
@@ -1,79 +1,79 @@
 /* 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_GUIRENDERER
 #define INCLUDED_GUIRENDERER
 
 #include "graphics/ShaderTechnique.h"
 #include "graphics/Texture.h"
 #include "gui/CGUIColor.h"
 #include "lib/res/handle.h"
 #include "ps/CStr.h"
 #include "ps/Shapes.h"
 
 #include <vector>
 
 struct SGUIImageEffects;
 struct SGUIImage;
 
 namespace GUIRenderer
 {
 	struct SDrawCall
 	{
 		SDrawCall(const SGUIImage* image) : m_Image(image) {}
 		CRect ComputeTexCoords() const;
 
 		const SGUIImage* m_Image;
 
 		bool m_HasTexture;
 		CTexturePtr m_Texture;
 
 		CRect m_ObjectSize;
 		int m_CellID;
 
 		bool m_EnableBlending;
 
 		CShaderTechniquePtr m_Shader;
 		CColor m_ShaderColorParameter;
 
 		CRect m_Vertices;
 		float m_DeltaZ;
 
-		CGUIColor m_BorderColor; // == CGUIColor() for no border
-		CGUIColor m_BackColor;
+		CGUIColor* m_BorderColor; // == nullptr for no border
+		CGUIColor* m_BackColor;
 	};
 
 	class DrawCalls : public std::vector<SDrawCall>
 	{
 	public:
 		DrawCalls();
 		// Copy/assignment results in an empty list, not an actual copy
 		DrawCalls(const DrawCalls&);
 		DrawCalls& operator=(const DrawCalls&);
 	};
 }
 
 #include "gui/CGUISprite.h"
 
 namespace GUIRenderer
 {
 	void UpdateDrawCallCache(const CGUI* pGUI, DrawCalls& Calls, const CStr& SpriteName, const CRect& Size, int CellID, std::map<CStr, const CGUISprite*>& Sprites);
 
 	void Draw(DrawCalls& Calls, float Z);
 }
 
 #endif // INCLUDED_GUIRENDERER
Index: ps/trunk/source/gui/GUItypes.h
===================================================================
--- ps/trunk/source/gui/GUItypes.h	(revision 22693)
+++ ps/trunk/source/gui/GUItypes.h	(revision 22694)
@@ -1,47 +1,47 @@
 /* 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 file is used by all bits of GUI code that need to repeat some code
 for a variety of types (to avoid repeating the list of types in half a dozen
 places, and to make it much easier to add a new type). Just do
 		#define TYPE(T) your_code_involving_T;
 		#include "GUItypes.h"
 		#undef TYPE
 to handle every possible type.
 */
 
 #ifndef GUITYPE_IGNORE_COPYABLE
 TYPE(bool)
 TYPE(i32)
 TYPE(u32)
 TYPE(float)
-TYPE(CGUIColor)
 TYPE(CStr)
 TYPE(CStrW)
 TYPE(EAlign)
 TYPE(EVAlign)
 TYPE(CPos)
 #endif
 
 #ifndef GUITYPE_IGNORE_NONCOPYABLE
 TYPE(CClientArea)
+TYPE(CGUIColor)
 TYPE(CGUIList)
 TYPE(CGUISeries)
 TYPE(CGUISpriteInstance)
 TYPE(CGUIString)
 #endif
Index: ps/trunk/source/gui/IGUIButtonBehavior.cpp
===================================================================
--- ps/trunk/source/gui/IGUIButtonBehavior.cpp	(revision 22693)
+++ ps/trunk/source/gui/IGUIButtonBehavior.cpp	(revision 22694)
@@ -1,183 +1,173 @@
 /* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "GUI.h"
 
 #include "ps/CLogger.h"
 #include "soundmanager/ISoundManager.h"
 
 IGUIButtonBehavior::IGUIButtonBehavior(CGUI* pGUI)
 	: IGUIObject(pGUI), m_Pressed(false)
 {
 }
 
 IGUIButtonBehavior::~IGUIButtonBehavior()
 {
 }
 
 void IGUIButtonBehavior::HandleMessage(SGUIMessage& Message)
 {
 	bool enabled;
 	GUI<bool>::GetSetting(this, "enabled", enabled);
 	CStrW soundPath;
 	// TODO Gee: easier access functions
 	switch (Message.type)
 	{
 	case GUIM_MOUSE_ENTER:
 		if (!enabled)
 			break;
 
 		if (g_SoundManager && GUI<CStrW>::GetSetting(this, "sound_enter", soundPath) == PSRETURN_OK && !soundPath.empty())
 			g_SoundManager->PlayAsUI(soundPath.c_str(), false);
 		break;
 
 	case GUIM_MOUSE_LEAVE:
 		if (!enabled)
 			break;
 
 		if (g_SoundManager && GUI<CStrW>::GetSetting(this, "sound_leave", soundPath) == PSRETURN_OK && !soundPath.empty())
 			g_SoundManager->PlayAsUI(soundPath.c_str(), false);
 		break;
 
 	case GUIM_MOUSE_DBLCLICK_LEFT:
 		if (!enabled)
 			break;
 
 		// Since GUIM_MOUSE_PRESS_LEFT also gets called twice in a
 		// doubleclick event, we let it handle playing sounds.
 		SendEvent(GUIM_DOUBLE_PRESSED, "doublepress");
 		break;
 
 	case GUIM_MOUSE_PRESS_LEFT:
 		if (!enabled)
 		{
 			if (g_SoundManager && GUI<CStrW>::GetSetting(this, "sound_disabled", soundPath) == PSRETURN_OK && !soundPath.empty())
 				g_SoundManager->PlayAsUI(soundPath.c_str(), false);
 			break;
 		}
 
 		// Button was clicked
 		if (g_SoundManager && GUI<CStrW>::GetSetting(this, "sound_pressed", soundPath) == PSRETURN_OK && !soundPath.empty())
 			g_SoundManager->PlayAsUI(soundPath.c_str(), false);
 		SendEvent(GUIM_PRESSED, "press");
 		m_Pressed = true;
 		break;
 
 	case GUIM_MOUSE_DBLCLICK_RIGHT:
 		if (!enabled)
 			break;
 
 		// Since GUIM_MOUSE_PRESS_RIGHT also gets called twice in a
 		// doubleclick event, we let it handle playing sounds.
 		SendEvent(GUIM_DOUBLE_PRESSED_MOUSE_RIGHT, "doublepressright");
 		break;
 
 	case GUIM_MOUSE_PRESS_RIGHT:
 		if (!enabled)
 		{
 			if (g_SoundManager && GUI<CStrW>::GetSetting(this, "sound_disabled", soundPath) == PSRETURN_OK && !soundPath.empty())
 				g_SoundManager->PlayAsUI(soundPath.c_str(), false);
 			break;
 		}
 
 		// Button was right-clicked
 		if (g_SoundManager && GUI<CStrW>::GetSetting(this, "sound_pressed", soundPath) == PSRETURN_OK && !soundPath.empty())
 			g_SoundManager->PlayAsUI(soundPath.c_str(), false);
 		SendEvent(GUIM_PRESSED_MOUSE_RIGHT, "pressright");
 		m_PressedRight = true;
 		break;
 
 	case GUIM_MOUSE_RELEASE_RIGHT:
 		if (!enabled)
 			break;
 
 		if (m_PressedRight)
 		{
 			m_PressedRight = false;
 			if (g_SoundManager && GUI<CStrW>::GetSetting(this, "sound_released", soundPath) == PSRETURN_OK && !soundPath.empty())
 				g_SoundManager->PlayAsUI(soundPath.c_str(), false);
 		}
 		break;
 
 	case GUIM_MOUSE_RELEASE_LEFT:
 		if (!enabled)
 			break;
 
 		if (m_Pressed)
 		{
 			m_Pressed = false;
 			if (g_SoundManager && GUI<CStrW>::GetSetting(this, "sound_released", soundPath) == PSRETURN_OK && !soundPath.empty())
 				g_SoundManager->PlayAsUI(soundPath.c_str(), false);
 		}
 		break;
 
 	default:
 		break;
 	}
 }
 
-CGUIColor IGUIButtonBehavior::ChooseColor()
+const CGUIColor& IGUIButtonBehavior::ChooseColor()
 {
-	CGUIColor color, color2;
-
 	// Yes, the object must possess these settings. They are standard
-	GUI<CGUIColor>::GetSetting(this, "textcolor", color);
+	const CGUIColor& color = GUI<CGUIColor>::GetSetting(this, "textcolor");
 
 	bool enabled;
 	GUI<bool>::GetSetting(this, "enabled", enabled);
 
 	if (!enabled)
-	{
-		GUI<CGUIColor>::GetSetting(this, "textcolor_disabled", color2);
-		return color2 || color;
-	}
-	else if (m_MouseHovering)
+		return GUI<CGUIColor>::GetSetting(this, "textcolor_disabled") || color;
+
+	if (m_MouseHovering)
 	{
 		if (m_Pressed)
-		{
-			GUI<CGUIColor>::GetSetting(this, "textcolor_pressed", color2);
-			return color2 || color;
-		}
+			return GUI<CGUIColor>::GetSetting(this, "textcolor_pressed") || color;
 		else
-		{
-			GUI<CGUIColor>::GetSetting(this, "textcolor_over", color2);
-			return color2 || color;
-		}
+			return GUI<CGUIColor>::GetSetting(this, "textcolor_over") || color;
 	}
-	else
-		return color;
+
+	return color;
 }
 
 void IGUIButtonBehavior::DrawButton(const CRect& rect, const float& z, CGUISpriteInstance& sprite, CGUISpriteInstance& sprite_over, CGUISpriteInstance& sprite_pressed, CGUISpriteInstance& sprite_disabled, int cell_id)
 {
 	bool enabled;
 	GUI<bool>::GetSetting(this, "enabled", enabled);
 
 	if (!enabled)
 		m_pGUI->DrawSprite(sprite_disabled || sprite, cell_id, z, rect);
 	else if (m_MouseHovering)
 	{
 		if (m_Pressed)
 			m_pGUI->DrawSprite(sprite_pressed || sprite, cell_id, z, rect);
 		else
 			m_pGUI->DrawSprite(sprite_over || sprite, cell_id, z, rect);
 	}
 	else
 		m_pGUI->DrawSprite(sprite, cell_id, z, rect);
 }
Index: ps/trunk/source/gui/IGUIButtonBehavior.h
===================================================================
--- ps/trunk/source/gui/IGUIButtonBehavior.h	(revision 22693)
+++ ps/trunk/source/gui/IGUIButtonBehavior.h	(revision 22694)
@@ -1,111 +1,111 @@
 /* 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 - Button Behavior
 
 --Overview--
 
 	Interface class that enhance the IGUIObject with
 	 buttony behavior (click and release to click a button),
 	 and the GUI message GUIM_PRESSED.
 	When creating a class with extended settings and
 	 buttony behavior, just do a multiple inheritance.
 
 --More info--
 
 	Check GUI.h
 
 */
 
 #ifndef INCLUDED_IGUIBUTTONBEHAVIOR
 #define INCLUDED_IGUIBUTTONBEHAVIOR
 
 #include "gui/GUI.h"
 
 class CGUISpriteInstance;
 
 /**
  * Appends button behaviours to the IGUIObject.
  * Can be used with multiple inheritance alongside
  * IGUISettingsObject and such.
  *
  * @see IGUIObject
  */
 class IGUIButtonBehavior : virtual public IGUIObject
 {
 public:
 	IGUIButtonBehavior(CGUI* pGUI);
 	virtual ~IGUIButtonBehavior();
 
 	/**
 	 * @see IGUIObject#HandleMessage()
 	 */
 	virtual void HandleMessage(SGUIMessage& Message);
 
 	/**
 	 * This is a function that lets a button being drawn,
 	 * it regards if it's over, disabled, pressed and such.
 	 * You input sprite names and area and it'll output
 	 * it accordingly.
 	 *
 	 * This class is meant to be used manually in Draw()
 	 *
 	 * @param rect Rectangle in which the sprite should be drawn
 	 * @param z Z-value
 	 * @param sprite Sprite drawn when not pressed, hovered or disabled
 	 * @param sprite_over Sprite drawn when m_MouseHovering is true
 	 * @param sprite_pressed Sprite drawn when m_Pressed is true
 	 * @param sprite_disabled Sprite drawn when "enabled" is false
 	 * @param cell_id Identifies the icon to be used (if the sprite contains
 	 *                cell-using images)
 	 */
 	void DrawButton(const CRect& rect, const float& z, CGUISpriteInstance& sprite, CGUISpriteInstance& sprite_over, CGUISpriteInstance& sprite_pressed, CGUISpriteInstance& sprite_disabled, int cell_id);
 
 	/**
 	 * Choosing which color of the following according to object enabled/hovered/pressed status:
 	 *		textcolor_disabled	-- disabled
 	 *		textcolor_pressed	-- pressed
 	 *		textcolor_over		-- hovered
 	 */
-	CGUIColor ChooseColor();
+	const CGUIColor& ChooseColor();
 
 
 protected:
 	/**
 	 * @see IGUIObject#ResetStates()
 	 */
 	virtual void ResetStates()
 	{
 		// Notify the gui that we aren't hovered anymore
 		UpdateMouseOver(NULL);
 		m_Pressed = false;
 		m_PressedRight = false;
 	}
 
 	/**
 	 * Everybody knows how a button works, you don't simply press it,
 	 * you have to first press the button, and then release it...
 	 * in between those two steps you can actually leave the button
 	 * area, as long as you release it within the button area... Anyway
 	 * this lets us know we are done with step one (clicking).
 	 */
 	bool							m_Pressed;
 	bool							m_PressedRight;
 };
 
 #endif // INCLUDED_IGUIBUTTONBEHAVIOR