Index: ps/trunk/source/graphics/Color.h
===================================================================
--- ps/trunk/source/graphics/Color.h	(revision 22688)
+++ ps/trunk/source/graphics/Color.h	(revision 22689)
@@ -1,76 +1,84 @@
 /* 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.
 	 * @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/CDropDown.cpp
===================================================================
--- ps/trunk/source/gui/CDropDown.cpp	(revision 22688)
+++ ps/trunk/source/gui/CDropDown.cpp	(revision 22689)
@@ -1,559 +1,559 @@
 /* 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;
 		CGUIList* pList;
 		GUI<bool>::GetSetting(this, "scrollbar", scrollbar);
 		GUI<CGUIList>::GetSettingPointer(this, "list", pList);
 		float scroll = 0.f;
 		if (scrollbar)
 			scroll = GetScrollBar(0).GetPos();
 
 		CRect rect = GetListRect();
 		mouse.y += scroll;
 		int set = -1;
 		for (int i = 0; i < (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)
 		{
 			CGUIList* pList;
 			GUI<CGUIList>::GetSettingPointer(this, "list", pList);
 			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();
 
 				CGUIList* pList;
 				GUI<CGUIList>::GetSettingPointer(this, "list", pList);
 				// 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 < (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((int)(pList->m_Items[i].GetRawString().LowerCase()[j]) - (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);
 
 	CGUISpriteInstance* sprite;
 	CGUISpriteInstance* sprite2;
 	CGUISpriteInstance* sprite2_second;
 	int cell_id, selected = 0;
 	CGUIColor color;
 
 	bool enabled;
 	GUI<bool>::GetSetting(this, "enabled", enabled);
 
 	GUI<CGUISpriteInstance>::GetSettingPointer(this, "sprite2", 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);
 
 	GUI<CGUISpriteInstance>::GetSettingPointer(this, enabled ? "sprite" : "sprite_disabled", sprite);
-	GetGUI()->DrawSprite(*sprite, cell_id, bz, m_CachedActualSize);
+	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)
 		{
 			GUI<CGUISpriteInstance>::GetSettingPointer(this, "sprite2_disabled", sprite2_second);
-			GetGUI()->DrawSprite(GUI<>::FallBackSprite(*sprite2_second, *sprite2), cell_id, bz+0.05f, rect);
+			m_pGUI->DrawSprite(*sprite2_second || *sprite2, cell_id, bz + 0.05f, rect);
 		}
 		else if (m_Open)
 		{
 			GUI<CGUISpriteInstance>::GetSettingPointer(this, "sprite2_pressed", sprite2_second);
-			GetGUI()->DrawSprite(GUI<>::FallBackSprite(*sprite2_second, *sprite2), cell_id, bz+0.05f, rect);
+			m_pGUI->DrawSprite(*sprite2_second || *sprite2, cell_id, bz + 0.05f, rect);
 		}
 		else if (m_MouseHovering)
 		{
 			GUI<CGUISpriteInstance>::GetSettingPointer(this, "sprite2_over", sprite2_second);
-			GetGUI()->DrawSprite(GUI<>::FallBackSprite(*sprite2_second, *sprite2), cell_id, bz+0.05f, rect);
+			m_pGUI->DrawSprite(*sprite2_second || *sprite2, cell_id, bz + 0.05f, rect);
 		}
 		else
-			GetGUI()->DrawSprite(*sprite2, cell_id, bz+0.05f, rect);
+			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);
 
 		CPos pos(m_CachedActualSize.left, m_CachedActualSize.top);
 		DrawText(selected, color, pos, bz+0.1f, cliparea);
 	}
 
 	bool* scrollbar = NULL;
 	bool old;
 	GUI<bool>::GetSettingPointer(this, "scrollbar", scrollbar);
 
 	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 22688)
+++ ps/trunk/source/gui/CGUI.cpp	(revision 22689)
@@ -1,1373 +1,1373 @@
 /* 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.IsEmpty())
+	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))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_BackColor = color;
 		}
 		else if (attr_name == "bordercolor")
 		{
 			CGUIColor color;
 			if (!GUI<CGUIColor>::ParseString(this, attr_value, color))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_BorderColor = color;
 		}
 		else if (attr_name == "border")
 		{
 			bool b;
 			if (!GUI<bool>::ParseString(this, attr_value, b))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_Border = b;
 		}
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 
 	// Look for effects
 	for (XMBElement child : Element.GetChildNodes())
 	{
 		CStr ElementName(pFile->GetElementString(child.GetNodeName()));
 		if (ElementName == "effect")
 		{
 			if (Image->m_Effects)
 				LOGERROR("GUI <image> must not have more than one <effect>");
 			else
 			{
 				Image->m_Effects = 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))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr.Value);
 			else effects.m_AddColor = color;
 		}
 		else if (attr_name == "grayscale")
 			effects.m_Greyscale = true;
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 }
 
 void CGUI::Xeromyces_ReadStyle(XMBElement Element, CXeromyces* pFile)
 {
 	SGUIStyle style;
 	CStr name;
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 
 		// The "name" setting is actually the name of the style
 		//  and not a new default
 		if (attr_name == "name")
 			name = attr.Value;
 		else
 			style.m_SettingsDefaults.emplace(attr_name, attr.Value.FromUTF8());
 	}
 
 	m_Styles.erase(name);
 	m_Styles.emplace(name, std::move(style));
 }
 
 void CGUI::Xeromyces_ReadScrollBarStyle(XMBElement Element, CXeromyces* pFile)
 {
 	SGUIScrollBarStyle scrollbar;
 	CStr name;
 
 	// Setup some defaults.
 	scrollbar.m_MinimumBarSize = 0.f;
 	// Using 1.0e10 as a substitute for infinity
 	scrollbar.m_MaximumBarSize = 1.0e10;
 	scrollbar.m_UseEdgeButtons = false;
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name = pFile->GetAttributeString(attr.Name);
 		CStr attr_value(attr.Value);
 
 		if (attr_value == "null")
 			continue;
 
 		if (attr_name == "name")
 			name = attr_value;
 		else if (attr_name == "show_edge_buttons")
 		{
 			bool b;
 			if (!GUI<bool>::ParseString(this, attr_value.FromUTF8(), b))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr_value);
 			else
 				scrollbar.m_UseEdgeButtons = b;
 		}
 		else if (attr_name == "width")
 		{
 			float f;
 			if (!GUI<float>::ParseString(this, attr_value.FromUTF8(), f))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr_value);
 			else
 				scrollbar.m_Width = f;
 		}
 		else if (attr_name == "minimum_bar_size")
 		{
 			float f;
 			if (!GUI<float>::ParseString(this, attr_value.FromUTF8(), f))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr_value);
 			else
 				scrollbar.m_MinimumBarSize = f;
 		}
 		else if (attr_name == "maximum_bar_size")
 		{
 			float f;
 			if (!GUI<float>::ParseString(this, attr_value.FromUTF8(), f))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr_value);
 			else
 				scrollbar.m_MaximumBarSize = f;
 		}
 		else if (attr_name == "sprite_button_top")
 			scrollbar.m_SpriteButtonTop = attr_value;
 		else if (attr_name == "sprite_button_top_pressed")
 			scrollbar.m_SpriteButtonTopPressed = attr_value;
 		else if (attr_name == "sprite_button_top_disabled")
 			scrollbar.m_SpriteButtonTopDisabled = attr_value;
 		else if (attr_name == "sprite_button_top_over")
 			scrollbar.m_SpriteButtonTopOver = attr_value;
 		else if (attr_name == "sprite_button_bottom")
 			scrollbar.m_SpriteButtonBottom = attr_value;
 		else if (attr_name == "sprite_button_bottom_pressed")
 			scrollbar.m_SpriteButtonBottomPressed = attr_value;
 		else if (attr_name == "sprite_button_bottom_disabled")
 			scrollbar.m_SpriteButtonBottomDisabled = attr_value;
 		else if (attr_name == "sprite_button_bottom_over")
 			scrollbar.m_SpriteButtonBottomOver = attr_value;
 		else if (attr_name == "sprite_back_vertical")
 			scrollbar.m_SpriteBackVertical = attr_value;
 		else if (attr_name == "sprite_bar_vertical")
 			scrollbar.m_SpriteBarVertical = attr_value;
 		else if (attr_name == "sprite_bar_vertical_over")
 			scrollbar.m_SpriteBarVerticalOver = attr_value;
 		else if (attr_name == "sprite_bar_vertical_pressed")
 			scrollbar.m_SpriteBarVerticalPressed = attr_value;
 	}
 
 	m_ScrollBarStyles.erase(name);
 	m_ScrollBarStyles.emplace(name, std::move(scrollbar));
 }
 
 void CGUI::Xeromyces_ReadIcon(XMBElement Element, CXeromyces* pFile)
 {
 	SGUIIcon icon;
 	CStr name;
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 		CStr attr_value(attr.Value);
 
 		if (attr_value == "null")
 			continue;
 
 		if (attr_name == "name")
 			name = attr_value;
 		else if (attr_name == "sprite")
 			icon.m_SpriteName = attr_value;
 		else if (attr_name == "size")
 		{
 			CSize size;
 			if (!GUI<CSize>::ParseString(this, attr_value.FromUTF8(), size))
 				LOGERROR("Error parsing '%s' (\"%s\") inside <icon>.", attr_name, attr_value);
 			else
 				icon.m_Size = size;
 		}
 		else if (attr_name == "cell_id")
 		{
 			int cell_id;
 			if (!GUI<int>::ParseString(this, attr_value.FromUTF8(), cell_id))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\") inside <icon>.", attr_name, attr_value);
 			else
 				icon.m_CellID = cell_id;
 		}
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 
 	m_Icons.erase(name);
 	m_Icons.emplace(name, std::move(icon));
 }
 
 void CGUI::Xeromyces_ReadTooltip(XMBElement Element, CXeromyces* pFile)
 {
 	IGUIObject* object = new CTooltip(this);
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 		CStr attr_value(attr.Value);
 
 		if (attr_name == "name")
 			object->SetName("__tooltip_" + attr_value);
 		else
 			object->SetSetting(attr_name, attr_value.FromUTF8());
 	}
 
 	AddObject(object);
 }
 
 void CGUI::Xeromyces_ReadColor(XMBElement Element, CXeromyces* pFile)
 {
 	XMBAttributeList attributes = Element.GetAttributes();
 
 	CGUIColor color;
 	CStr name = attributes.GetNamedItem(pFile->GetAttributeID("name"));
 
 	// Try parsing value
 	CStr value(Element.GetText());
 	if (value.empty())
 		return;
 
 	// Try setting color to value
 	if (!color.ParseString(this, value))
 	{
 		LOGERROR("GUI: Unable to create custom color '%s'. Invalid color syntax.", name.c_str());
 		return;
 	}
 
 	m_PreDefinedColors[name] = color;
 }
Index: ps/trunk/source/gui/CGUIColor.h
===================================================================
--- ps/trunk/source/gui/CGUIColor.h	(revision 22688)
+++ ps/trunk/source/gui/CGUIColor.h	(revision 22689)
@@ -1,45 +1,55 @@
 /* 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
 {
 	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/CGUIScrollBarVertical.cpp
===================================================================
--- ps/trunk/source/gui/CGUIScrollBarVertical.cpp	(revision 22688)
+++ ps/trunk/source/gui/CGUIScrollBarVertical.cpp	(revision 22689)
@@ -1,202 +1,202 @@
 /* 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 "CGUIScrollBarVertical.h"
 
 #include "GUI.h"
 
 #include "ps/CLogger.h"
 
 
 CGUIScrollBarVertical::CGUIScrollBarVertical(CGUI* pGUI)
  : IGUIScrollBar(pGUI)
 {
 }
 
 CGUIScrollBarVertical::~CGUIScrollBarVertical()
 {
 }
 
 void CGUIScrollBarVertical::SetPosFromMousePos(const CPos& mouse)
 {
 	if (!GetStyle())
 		return;
 
 	/**
 	 * Calculate the position for the top of the item being scrolled
 	 */
 	float emptyBackground = m_Length - m_BarSize;
 
 	if (GetStyle()->m_UseEdgeButtons)
 		emptyBackground -= GetStyle()->m_Width * 2;
 
 	m_Pos = m_PosWhenPressed + GetMaxPos() * (mouse.y - m_BarPressedAtPos.y) / emptyBackground;
 }
 
 void CGUIScrollBarVertical::Draw()
 {
 	if (!GetStyle())
 	{
 		LOGWARNING("Attempt to draw scrollbar without a style.");
 		return;
 	}
 
-	if (GetGUI() && IsVisible())
+	if (IsVisible())
 	{
 		CRect outline = GetOuterRect();
 
-		GetGUI()->DrawSprite(
+		m_pGUI->DrawSprite(
 			GetStyle()->m_SpriteBackVertical,
 			0,
 			m_Z+0.1f,
 			CRect(
 				outline.left,
 				outline.top + (GetStyle()->m_UseEdgeButtons ? GetStyle()->m_Width : 0),
 				outline.right,
 				outline.bottom - (GetStyle()->m_UseEdgeButtons ? GetStyle()->m_Width : 0)
 			)
 		);
 
 		if (GetStyle()->m_UseEdgeButtons)
 		{
 			const CGUISpriteInstance* button_top;
 			const CGUISpriteInstance* button_bottom;
 
 			if (m_ButtonMinusHovered)
 			{
 				if (m_ButtonMinusPressed)
-					button_top = &GUI<>::FallBackSprite(GetStyle()->m_SpriteButtonTopPressed, GetStyle()->m_SpriteButtonTop);
+					button_top = &(GetStyle()->m_SpriteButtonTopPressed || GetStyle()->m_SpriteButtonTop);
 				else
-					button_top = &GUI<>::FallBackSprite(GetStyle()->m_SpriteButtonTopOver, GetStyle()->m_SpriteButtonTop);
+					button_top = &(GetStyle()->m_SpriteButtonTopOver || GetStyle()->m_SpriteButtonTop);
 			}
 			else
 				button_top = &GetStyle()->m_SpriteButtonTop;
 
 			if (m_ButtonPlusHovered)
 			{
 				if (m_ButtonPlusPressed)
-					button_bottom = &GUI<>::FallBackSprite(GetStyle()->m_SpriteButtonBottomPressed, GetStyle()->m_SpriteButtonBottom);
+					button_bottom = &(GetStyle()->m_SpriteButtonBottomPressed || GetStyle()->m_SpriteButtonBottom);
 				else
-					button_bottom = &GUI<>::FallBackSprite(GetStyle()->m_SpriteButtonBottomOver, GetStyle()->m_SpriteButtonBottom);
+					button_bottom = &(GetStyle()->m_SpriteButtonBottomOver || GetStyle()->m_SpriteButtonBottom);
 			}
 			else
 				button_bottom = &GetStyle()->m_SpriteButtonBottom;
 
-			GetGUI()->DrawSprite(
+			m_pGUI->DrawSprite(
 				*button_top,
 				0,
 				m_Z+0.2f,
 				CRect(
 					outline.left,
 					outline.top,
 					outline.right,
 					outline.top+GetStyle()->m_Width
 				)
 			);
 
-			GetGUI()->DrawSprite(
+			m_pGUI->DrawSprite(
 				*button_bottom,
 				0,
 				m_Z+0.2f,
 				CRect(
 					outline.left,
 					outline.bottom-GetStyle()->m_Width,
 					outline.right,
 					outline.bottom
 				)
 			);
 		}
 
-		GetGUI()->DrawSprite(
+		m_pGUI->DrawSprite(
 			GetStyle()->m_SpriteBarVertical,
 			0,
 			m_Z + 0.2f,
 			GetBarRect()
 		);
 	}
 }
 
 void CGUIScrollBarVertical::HandleMessage(SGUIMessage& Message)
 {
 	IGUIScrollBar::HandleMessage(Message);
 }
 
 CRect CGUIScrollBarVertical::GetBarRect() const
 {
 	CRect ret;
 	if (!GetStyle())
 		return ret;
 
 	// Get from where the scroll area begins to where it ends
 	float from = m_Y;
 	float to = m_Y + m_Length - m_BarSize;
 
 	if (GetStyle()->m_UseEdgeButtons)
 	{
 		from += GetStyle()->m_Width;
 		to -= GetStyle()->m_Width;
 	}
 
 	ret.top = from + (to - from) * m_Pos / GetMaxPos();
 	ret.bottom = ret.top + m_BarSize;
 	ret.right = m_X + (m_RightAligned ? 0 : GetStyle()->m_Width);
 	ret.left = ret.right - GetStyle()->m_Width;
 
 	return ret;
 }
 
 CRect CGUIScrollBarVertical::GetOuterRect() const
 {
 	CRect ret;
 	if (!GetStyle())
 		return ret;
 
 	ret.top = m_Y;
 	ret.bottom = m_Y+m_Length;
 	ret.right = m_X + (m_RightAligned ? 0 : GetStyle()->m_Width);
 	ret.left = ret.right - GetStyle()->m_Width;
 
 	return ret;
 }
 
 bool CGUIScrollBarVertical::HoveringButtonMinus(const CPos& mouse)
 {
 	if (!GetStyle())
 		return false;
 
 	float StartX = m_RightAligned ? m_X-GetStyle()->m_Width : m_X;
 
 	return mouse.x >= StartX &&
 	       mouse.x <= StartX + GetStyle()->m_Width &&
 	       mouse.y >= m_Y &&
 	       mouse.y <= m_Y + GetStyle()->m_Width;
 }
 
 bool CGUIScrollBarVertical::HoveringButtonPlus(const CPos& mouse)
 {
 	if (!GetStyle())
 		return false;
 
 	float StartX = m_RightAligned ? m_X-GetStyle()->m_Width : m_X;
 
 	return mouse.x > StartX &&
 	       mouse.x < StartX + GetStyle()->m_Width &&
 	       mouse.y > m_Y + m_Length - GetStyle()->m_Width &&
 	       mouse.y < m_Y + m_Length;
 }
Index: ps/trunk/source/gui/CGUISprite.cpp
===================================================================
--- ps/trunk/source/gui/CGUISprite.cpp	(revision 22688)
+++ ps/trunk/source/gui/CGUISprite.cpp	(revision 22689)
@@ -1,69 +1,64 @@
 /* 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 "CGUISprite.h"
 
 CGUISprite::~CGUISprite()
 {
 	for (SGUIImage* const& img : m_Images)
 		delete img;
 }
 
 void CGUISprite::AddImage(SGUIImage* image)
 {
 	m_Images.push_back(image);
 }
 
 void CGUISpriteInstance::Draw(const CGUI* pGUI, const CRect& Size, int CellID, std::map<CStr, const CGUISprite*>& Sprites, float Z) const
 {
 	if (m_CachedSize != Size || m_CachedCellID != CellID)
 	{
 		GUIRenderer::UpdateDrawCallCache(pGUI, m_DrawCallCache, m_SpriteName, Size, CellID, Sprites);
 		m_CachedSize = Size;
 		m_CachedCellID = CellID;
 	}
 	GUIRenderer::Draw(m_DrawCallCache, Z);
 }
 
-bool CGUISpriteInstance::IsEmpty() const
-{
-	return m_SpriteName.empty();
-}
-
 // Plus a load of constructors / assignment operators, which don't copy the
 // DrawCall cache (to avoid losing track of who has allocated various bits
 // of data):
 
 CGUISpriteInstance::CGUISpriteInstance()
 	: m_CachedCellID(-1)
 {
 }
 
 CGUISpriteInstance::CGUISpriteInstance(const CStr& SpriteName)
 	: m_SpriteName(SpriteName), m_CachedCellID(-1)
 {
 }
 
 void CGUISpriteInstance::SetName(const CStr& SpriteName)
 {
 	m_SpriteName = SpriteName;
 	m_CachedSize = CRect();
 	m_DrawCallCache.clear();
 	m_CachedCellID = -1;
 }
Index: ps/trunk/source/gui/CGUISprite.h
===================================================================
--- ps/trunk/source/gui/CGUISprite.h	(revision 22688)
+++ ps/trunk/source/gui/CGUISprite.h	(revision 22689)
@@ -1,180 +1,203 @@
 /* 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/>.
  */
 
 /*
 A GUI Sprite
 
 --Overview--
 
 	A GUI Sprite, which is actually a collage of several
 	sprites.
 
 --Usage--
 
 	Used internally and declared in XML files, read documentations
 	on how.
 
 --More info--
 
 	Check GUI.h
 
 */
 
 #ifndef INCLUDED_CGUISPRITE
 #define INCLUDED_CGUISPRITE
 
 #include "GUIbase.h"
 
 #include "lib/res/graphics/ogl_tex.h"
 
 #include <memory>
 
 struct SGUIImageEffects
 {
 	SGUIImageEffects() : m_Greyscale(false) {}
 	CGUIColor m_AddColor;
 	CGUIColor m_SolidColor;
 	bool m_Greyscale;
 };
 
 /**
  * A CGUISprite is actually a collage of several <b>real</b>
  * sprites, this struct represents is such real sprite.
  */
 struct SGUIImage
 {
 	NONCOPYABLE(SGUIImage);
 public:
 	SGUIImage() :
 		m_FixedHAspectRatio(0.f), m_RoundCoordinates(true), m_WrapMode(GL_REPEAT),
 		m_Effects(), m_Border(false), m_DeltaZ(0.f)
 	{
 	}
 
 	// Filename of the texture
 	VfsPath			m_TextureName;
 
 	// Image placement (relative to object)
 	CClientArea		m_Size;
 
 	// Texture placement (relative to image placement)
 	CClientArea		m_TextureSize;
 
 	// Because OpenGL wants textures in squares with a power of 2 (64x64, 256x256)
 	//  it's sometimes tedious to adjust this. So this value simulates which area
 	//  is the real texture
 	CRect			m_TexturePlacementInFile;
 
 	// For textures that contain a collection of icons (e.g. unit portraits), this
 	//  will be set to the size of one icon. An object's cell-id will determine
 	//  which part of the texture is used.
 	//  Equal to CSize(0,0) for non-celled textures.
 	CSize			m_CellSize;
 
 	/**
 	 * If non-zero, then the image's width will be adjusted when rendering so that
 	 * the width:height ratio equals this value.
 	 */
 	float			m_FixedHAspectRatio;
 
 	/**
 	 * If true, the image's coordinates will be rounded to integer pixels when
 	 * rendering, to avoid blurry filtering.
 	 */
 	bool			m_RoundCoordinates;
 
 	/**
 	 * Texture wrapping mode (GL_REPEAT, GL_CLAMP_TO_EDGE, etc)
 	 */
 	GLint			m_WrapMode;
 
 	// Visual effects (e.g. color modulation)
 	std::shared_ptr<SGUIImageEffects> m_Effects;
 
 	// Color
 	CGUIColor m_BackColor;
 	CGUIColor m_BorderColor;
 
 	// 0 or 1 pixel border is the only option
 	bool			m_Border;
 
 	/**
 	 * Z value modification of the image.
 	 * Inputted in XML as x-level, although it just an easier and safer
 	 * way of declaring delta-z.
 	 */
 	float			m_DeltaZ;
 };
 
 /**
  * The GUI sprite, is actually several real sprites (images)
  * like a collage. View the section \<sprites\> in the GUI
  * TDD for more information.
  *
  * Drawing routine is located in CGUI
  *
  * @see CGUI#DrawSprite
  */
 class CGUISprite
 {
 	NONCOPYABLE(CGUISprite);
 public:
 	CGUISprite() {}
 	virtual ~CGUISprite();
 
 	/**
 	 * Adds an image to the sprite collage.
 	 *
 	 * @param image Adds this image to the sprite collage.
 	 */
 	void AddImage(SGUIImage*);
 
 	/// List of images
 	std::vector<SGUIImage*> m_Images;
 };
 
 #include "GUIRenderer.h"
 
 // An instance of a sprite, usually stored in IGUIObjects - basically a string
 // giving the sprite's name, but with some extra data to cache rendering
 // calculations between draw calls.
 class CGUISpriteInstance
 {
 public:
 	NONCOPYABLE(CGUISpriteInstance);
 	MOVABLE(CGUISpriteInstance);
 
 	CGUISpriteInstance();
 	CGUISpriteInstance(const CStr& SpriteName);
 
 	void Draw(const CGUI* pGUI, const CRect& Size, int CellID, std::map<CStr, const CGUISprite*>& Sprites, float Z) const;
-	bool IsEmpty() const;
+
+	/**
+	 * Whether this Sprite has no texture name set.
+	 */
+	operator bool() const { return !m_SpriteName.empty(); };
+
+	/**
+	 * Returns this spirte if it has been set, otherwise the given fallback sprite.
+	 */
+	const CGUISpriteInstance& operator||(const CGUISpriteInstance& fallback) const
+	{
+		if (*this)
+			return *this;
+		return fallback;
+	}
+
+	/**
+	 * Returns the sprite texture name.
+	 */
 	const CStr& GetName() const { return m_SpriteName; }
+
+	/**
+	 * Changes the texture name.
+	 * Use as rarely as possible, because it clears the draw cache.
+	 */
 	void SetName(const CStr& SpriteName);
 
 private:
 	CStr m_SpriteName;
 
 	// Stored drawing calls, for more efficient rendering
 	mutable GUIRenderer::DrawCalls m_DrawCallCache;
 	// Relevant details of previously rendered sprite; the cache is invalidated
 	// whenever any of these values changes.
 	mutable CRect m_CachedSize;
 	mutable int m_CachedCellID;
 };
 
 #endif // INCLUDED_CGUISPRITE
Index: ps/trunk/source/gui/GUIutil.h
===================================================================
--- ps/trunk/source/gui/GUIutil.h	(revision 22688)
+++ ps/trunk/source/gui/GUIutil.h	(revision 22689)
@@ -1,361 +1,333 @@
 /* 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 util
 
 --Overview--
 
 	Contains help class GUI<>, which gives us templated
 	 parameter to all functions within GUI.
 
 --More info--
 
 	Check GUI.h
 
 */
 
 #ifndef INCLUDED_GUIUTIL
 #define INCLUDED_GUIUTIL
 
 #include "gui/CGUI.h"
 #include "gui/CGUISprite.h"
 #include "gui/GUIbase.h"
 #include "gui/IGUIObject.h"
 
 #include <functional>
 
 class CClientArea;
 class CGUIString;
 template<typename T> class GUI;
 
 class IGUISetting
 {
 public:
 	NONCOPYABLE(IGUISetting);
 
 	IGUISetting() = default;
 	virtual ~IGUISetting() = default;
 
 	/**
 	 * Parses the given string and assigns to the setting value. Used for parsing XML attributes.
 	 */
 	virtual bool FromString(const CStrW& Value, const bool& SkipMessage) = 0;
 
 	/**
 	 * Parses the given JS::Value using ScriptInterface::FromJSVal and assigns it to the setting data.
 	 */
 	virtual bool FromJSVal(JSContext* cx, JS::HandleValue Value) = 0;
 
 	/**
 	 * Converts the setting data to a JS::Value using ScriptInterface::ToJSVal.
 	 */
 	virtual void ToJSVal(JSContext* cx, JS::MutableHandleValue Value) = 0;
 };
 
 template<typename T>
 class CGUISetting : public IGUISetting
 {
 	friend class GUI<T>;
 
 public:
 	NONCOPYABLE(CGUISetting);
 
 	CGUISetting(IGUIObject& pObject, const CStr& Name);
 
 	/**
 	 * Parses the given string and assigns to the setting value. Used for parsing XML attributes.
 	 */
 	bool FromString(const CStrW& Value, const bool& SkipMessage) override;
 
 	/**
 	 * Parses the given JS::Value using ScriptInterface::FromJSVal and assigns it to the setting data.
 	 */
 	bool FromJSVal(JSContext* cx, JS::HandleValue Value) override;
 
 	/**
 	 * Converts the setting data to a JS::Value using ScriptInterface::ToJSVal.
 	 */
 	void ToJSVal(JSContext* cx, JS::MutableHandleValue Value) override;
 
 private:
 
 	/**
 	 * The object that stores this setting.
 	 */
 	IGUIObject& m_pObject;
 
 	/**
 	 * Property name identifying the setting.
 	 */
 	const CStr m_Name;
 
 	/**
 	 * Holds the value of the setting..
 	 */
 	T m_pSetting;
 };
 
 template <typename T>
 bool __ParseString(const CGUI* pGUI, const CStrW& Value, T& tOutput);
 
 struct SGUIMessage;
 
 /**
  * Includes static functions that needs one template
  * argument.
  *
  * int is only to please functions that doesn't even use T
  * and are only within this class because it's convenient
  */
 template <typename T=int>
 class GUI
 {
 	// Private functions further ahead
 	friend class CGUI;
 	friend class IGUIObject;
 
 public:
 	NONCOPYABLE(GUI);
 
 	// Like GetSetting (below), but doesn't make a copy of the value
 	// (so it can be modified later)
 	static PSRETURN GetSettingPointer(const IGUIObject* pObject, const CStr& Setting, T*& Value);
 
 	/**
 	 * Retrieves a setting by name from object pointer
 	 *
 	 * @param pObject Object pointer
 	 * @param Setting Setting by name
 	 * @param Value Stores value here, note type T!
 	 */
 	static PSRETURN GetSetting(const IGUIObject* pObject, const CStr& Setting, T& Value);
 
 	/**
 	 * Sets a value by name using a real datatype as input.
 	 *
 	 * This is the official way of setting a setting, no other
 	 *  way should only cautiously be used!
 	 *
 	 * This variant will use the move-assignment.
 	 *
 	 * @param pObject Object pointer
 	 * @param Setting Setting by name
 	 * @param Value Sets value to this, note type T!
 	 * @param SkipMessage Does not send a GUIM_SETTINGS_UPDATED if true
 	 */
 	static PSRETURN SetSetting(IGUIObject* pObject, const CStr& Setting, T& Value, const bool& SkipMessage = false);
 
 	/**
 	 * This variant will copy the value.
 	 */
 	static PSRETURN SetSetting(IGUIObject* pObject, const CStr& Setting, const T& Value, const bool& SkipMessage = false);
 
 	/**
-	 * This will return the value of the first sprite if it's not null,
-	 * if it is null, it will return the value of the second sprite, if
-	 * that one is null, then null it is.
-	 *
-	 * @param prim Primary sprite that should be used
-	 * @param sec Secondary sprite if Primary should fail
-	 * @return Resulting string
-	 */
-	static const CGUISpriteInstance& FallBackSprite(const CGUISpriteInstance& prim, const CGUISpriteInstance& sec)
-	{
-		return (prim.IsEmpty() ? sec : prim);
-	}
-
-	/**
-	 * Same principle as FallBackSprite
-	 *
-	 * @param prim Primary color that should be used
-	 * @param sec Secondary color if Primary should fail
-	 * @return Resulting color
-	 * @see FallBackSprite
-	 */
-	static CGUIColor FallBackColor(const CGUIColor& prim, const CGUIColor& sec)
-	{
-		// CGUIColor() == null.
-		return ((prim!=CGUIColor())?(prim):(sec));
-	}
-
-	/**
 	 * Sets a value by setting and object name using a real
 	 * datatype as input.
 	 *
 	 * This is just a wrapper for __ParseString() which really
 	 * works the magic.
 	 *
 	 * @param Value The value in string form, like "0 0 100% 100%"
 	 * @param tOutput Parsed value of type T
 	 * @return True at success.
 	 *
 	 * @see __ParseString()
 	 */
 	static bool ParseString(const CGUI* pGUI, const CStrW& Value, T& tOutput)
 	{
 		return __ParseString<T>(pGUI, Value, tOutput);
 	}
 
 private:
 
 	/**
 	 * Changes the value of the setting by calling the valueSet functon that performs either a copy or move assignment.
 	 * Updates some internal data depending on the setting changed.
 	 */
 	static PSRETURN SetSettingWrap(IGUIObject* pObject, const CStr& Setting, const T& Value, const bool& SkipMessage, const std::function<void()>& valueSet);
 
 	// templated typedef of function pointer
 	typedef void (IGUIObject::*void_Object_pFunction_argT)(const T& arg);
 	typedef void (IGUIObject::*void_Object_pFunction_argRefT)(T& arg);
 	typedef void (IGUIObject::*void_Object_pFunction)();
 	typedef void (IGUIObject::*void_Object_pFunction_argTJS)(const T& arg, JS::HandleValueArray paramData);
 
 	/**
 	 * If you want to call a IGUIObject-function
 	 * on not just an object, but also on ALL of their children
 	 * you want to use this recursion system.
 	 * It recurses an object calling a function on itself
 	 * and all children (and so forth).
 	 *
 	 * <b>Restrictions:</b>\n
 	 * You can also set restrictions, so that if the recursion
 	 * reaches an objects with certain setup, it just doesn't
 	 * call the function on the object, nor it's children for
 	 * that matter. i.e. it cuts that object off from the
 	 * recursion tree. What setups that can cause restrictions
 	 * are hardcoded and specific. Check out the defines
 	 * GUIRR_* for all different setups.
 	 *
 	 * Error reports are either logged or thrown out of RecurseObject.
 	 * Always use it with try/catch!
 	 *
 	 * @param RR Recurse Restrictions, set to 0 if no restrictions
 	 * @param pObject Top object, this is where the iteration starts
 	 * @param pFunc Function to recurse
 	 * @param Argument Argument for pFunc of type T
 	 * @throws PSERROR Depends on what pFunc might throw. PSERROR is standard.
 	 *			Itself doesn't throw anything.
 	*/
 	static void RecurseObject(int RR, IGUIObject* pObject, void_Object_pFunction_argT pFunc, const T& Argument)
 	{
 		// TODO Gee: Don't run this for the base object.
 		if (CheckIfRestricted(RR, pObject))
 			return;
 
 		(pObject->*pFunc)(Argument);
 
 		// Iterate children
 		for (IGUIObject* const& obj : *pObject)
 			RecurseObject(RR, obj, pFunc, Argument);
 	}
 
 	/**
 	 * Argument is reference.
 	 *
 	 * @see RecurseObject()
 	 */
 	static void RecurseObject(int RR, IGUIObject* pObject, void_Object_pFunction_argRefT pFunc, T& Argument)
 	{
 		if (CheckIfRestricted(RR, pObject))
 			return;
 
 		(pObject->*pFunc)(Argument);
 
 		// Iterate children
 		for (IGUIObject* const& obj : *pObject)
 			RecurseObject(RR, obj, pFunc, Argument);
 	}
 
 	static void RecurseObject(int RR, IGUIObject* pObject, void_Object_pFunction_argTJS pFunc, const T& Argument, JS::HandleValueArray paramData)
 	{
 		if (CheckIfRestricted(RR, pObject))
 			return;
 
 		(pObject->*pFunc)(Argument, paramData);
 
 		// Iterate children
 		for (IGUIObject* const& obj : *pObject)
 			RecurseObject(RR, obj, pFunc, Argument, paramData);
 	}
 
 	/**
 	 * With no argument.
 	 *
 	 * @see RecurseObject()
 	 */
 	static void RecurseObject(int RR, IGUIObject* pObject, void_Object_pFunction pFunc)
 	{
 		if (CheckIfRestricted(RR, pObject))
 			return;
 
 		(pObject->*pFunc)();
 
 		// Iterate children
 		for (IGUIObject* const& obj : *pObject)
 			RecurseObject(RR, obj, pFunc);
 	}
 
 	/**
 	 * Checks restrictions for the iteration, for instance if
 	 * you tell the recursor to avoid all hidden objects, it
 	 * will, and this function checks a certain object's
 	 * restriction values.
 	 *
 	 * @param RR What kind of restriction, for instance hidden or disabled
 	 * @param pObject Object
 	 * @return true if restricted
 	 */
 	static bool CheckIfRestricted(int RR, IGUIObject* pObject)
 	{
 		// Statically initialise some strings, so we don't have to do
 		// lots of allocation every time this function is called
 		static const CStr strHidden("hidden");
 		static const CStr strEnabled("enabled");
 		static const CStr strGhost("ghost");
 
 		if (RR & GUIRR_HIDDEN)
 		{
 			bool hidden = true;
 			GUI<bool>::GetSetting(pObject, strHidden, hidden);
 
 			if (hidden)
 				return true;
 		}
 		if (RR & GUIRR_DISABLED)
 		{
 			bool enabled = false;
 			GUI<bool>::GetSetting(pObject, strEnabled, enabled);
 
 			if (!enabled)
 				return true;
 		}
 		if (RR & GUIRR_GHOST)
 		{
 			bool ghost = true;
 			GUI<bool>::GetSetting(pObject, strGhost, ghost);
 
 			if (ghost)
 				return true;
 		}
 
 		// false means not restricted
 		return false;
 	}
 };
 
 #endif // INCLUDED_GUIUTIL
Index: ps/trunk/source/gui/IGUIButtonBehavior.cpp
===================================================================
--- ps/trunk/source/gui/IGUIButtonBehavior.cpp	(revision 22688)
+++ ps/trunk/source/gui/IGUIButtonBehavior.cpp	(revision 22689)
@@ -1,183 +1,183 @@
 /* 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()
 {
 	CGUIColor color, color2;
 
 	// Yes, the object must possess these settings. They are standard
 	GUI<CGUIColor>::GetSetting(this, "textcolor", color);
 
 	bool enabled;
 	GUI<bool>::GetSetting(this, "enabled", enabled);
 
 	if (!enabled)
 	{
 		GUI<CGUIColor>::GetSetting(this, "textcolor_disabled", color2);
-		return GUI<>::FallBackColor(color2, color);
+		return color2 || color;
 	}
 	else if (m_MouseHovering)
 	{
 		if (m_Pressed)
 		{
 			GUI<CGUIColor>::GetSetting(this, "textcolor_pressed", color2);
-			return GUI<>::FallBackColor(color2, color);
+			return color2 || color;
 		}
 		else
 		{
 			GUI<CGUIColor>::GetSetting(this, "textcolor_over", color2);
-			return GUI<>::FallBackColor(color2, color);
+			return color2 || color;
 		}
 	}
 	else
 		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)
-		GetGUI()->DrawSprite(GUI<>::FallBackSprite(sprite_disabled, sprite), cell_id, z, rect);
+		m_pGUI->DrawSprite(sprite_disabled || sprite, cell_id, z, rect);
 	else if (m_MouseHovering)
 	{
 		if (m_Pressed)
-			GetGUI()->DrawSprite(GUI<>::FallBackSprite(sprite_pressed, sprite), cell_id, z, rect);
+			m_pGUI->DrawSprite(sprite_pressed || sprite, cell_id, z, rect);
 		else
-			GetGUI()->DrawSprite(GUI<>::FallBackSprite(sprite_over, sprite), cell_id, z, rect);
+			m_pGUI->DrawSprite(sprite_over || sprite, cell_id, z, rect);
 	}
 	else
-		GetGUI()->DrawSprite(sprite, cell_id, z, rect);
+		m_pGUI->DrawSprite(sprite, cell_id, z, rect);
 }