Index: ps/trunk/source/gui/GUISettingTypes.h
===================================================================
--- ps/trunk/source/gui/GUISettingTypes.h	(revision 25391)
+++ ps/trunk/source/gui/GUISettingTypes.h	(nonexistent)
@@ -1,50 +0,0 @@
-/* Copyright (C) 2021 Wildfire Games.
- * This file is part of 0 A.D.
- *
- * 0 A.D. is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * 0 A.D. is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/*
-This file is used by all bits of GUI code that need to repeat some code
-for a variety of types (to avoid repeating the list of types in half a dozen
-places, and to make it much easier to add a new type). Just do
-		#define TYPE(T) your_code_involving_T;
-		#include "gui/SettingTypes/GUISettingTypes.h"
-		#undef TYPE
-to handle every possible type.
-*/
-
-#ifndef GUITYPE_IGNORE_COPYABLE
-#include "gui/SettingTypes/EAlign.h"
-TYPE(bool)
-TYPE(i32)
-TYPE(u32)
-TYPE(float)
-TYPE(EAlign)
-TYPE(EVAlign)
-TYPE(CVector2D)
-#endif
-
-#ifndef GUITYPE_IGNORE_NONCOPYABLE
-#include "gui/SettingTypes/CGUIList.h"
-#include "gui/SettingTypes/CGUISeries.h"
-TYPE(CGUISize)
-TYPE(CGUIColor)
-TYPE(CGUIList)
-TYPE(CGUISeries)
-TYPE(CGUISpriteInstance)
-TYPE(CGUIString)
-TYPE(CStr)
-TYPE(CStrW)
-#endif

Property changes on: ps/trunk/source/gui/GUISettingTypes.h
___________________________________________________________________
Deleted: svn:eol-style
## -1 +0,0 ##
-native
\ No newline at end of property
Index: ps/trunk/source/gui/ObjectTypes/CRadioButton.cpp
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CRadioButton.cpp	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CRadioButton.cpp	(revision 25392)
@@ -1,48 +1,48 @@
-/* Copyright (C) 2019 Wildfire Games.
+/* Copyright (C) 2021 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 "CRadioButton.h"
 
 CRadioButton::CRadioButton(CGUI& pGUI)
 	: CCheckBox(pGUI)
 {
 }
 
 void CRadioButton::HandleMessage(SGUIMessage& Message)
 {
 	IGUIButtonBehavior::HandleMessage(Message);
-
 	switch (Message.type)
 	{
 	case GUIM_PRESSED:
 		for (IGUIObject* const& obj : GetParent()->GetChildren())
 		{
 			// Notice, if you use other objects within the parent object that has got
 			//  the setting "checked", it too will change. Hence NO OTHER OBJECTS THAN
 			//  RADIO BUTTONS SHOULD BE WITHIN IT!
-			obj->SetSetting<bool>("checked", false, true);
+			// TODO: this should be enforced in the engine, and then we could cast IGUIObject* to CRadioButton*.
+			obj->SetSettingFromString("checked", L"false", true);
 		}
 
-		SetSetting<bool>("checked", true, true);
+		m_Checked.Set(true, true);
 		break;
 
 	default:
 		break;
 	}
 }
Index: ps/trunk/source/gui/ObjectTypes/CInput.h
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CInput.h	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CInput.h	(revision 25392)
@@ -1,239 +1,238 @@
 /* Copyright (C) 2021 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_CINPUT
 #define INCLUDED_CINPUT
 
 #include "gui/CGUISprite.h"
 #include "gui/ObjectBases/IGUIObject.h"
 #include "gui/ObjectBases/IGUIScrollBarOwner.h"
 #include "gui/SettingTypes/CGUIString.h"
 #include "lib/external_libraries/libsdl.h"
 
 #include <list>
 #include <vector>
 
 /**
  * Text field where you can input and edit the text.
  *
  * It doesn't use IGUITextOwner, because we don't need
  * any other features than word-wrapping, and we need to be
  * able to rapidly change the string.
  */
 class CInput : public IGUIObject, public IGUIScrollBarOwner
 {
 	GUI_OBJECT(CInput)
 
 protected: // forwards
 	struct SRow;
 
 public:
 	CInput(CGUI& pGUI);
 	virtual ~CInput();
 
 	/**
 	 * @see IGUIObject#ResetStates()
 	 */
 	virtual void ResetStates();
 
 	// Check where the mouse is hovering, and get the appropriate text position.
 	//  return is the text-position index.
 	int GetMouseHoveringTextPosition() const;
 
 	// Same as above, but only on one row in X, and a given value, not the mouse's.
 	//  wanted is filled with x if the row didn't extend as far as the mouse pos.
 	int GetXTextPosition(const std::list<SRow>::const_iterator& c, const float& x, float& wanted) const;
 
 protected:
 
 	void SetupGeneratedPlaceholderText();
 
 	/**
 	 * @see IGUIObject#HandleMessage()
 	 */
 	virtual void HandleMessage(SGUIMessage& Message);
 
 	/**
 	 * Handle events manually to catch keyboard inputting.
 	 */
 	virtual InReaction ManuallyHandleKeys(const SDL_Event_* ev);
 
 	/**
 	 * Handle events manually to catch keys which change the text.
 	 */
 	virtual void ManuallyMutableHandleKeyDownEvent(const SDL_Keycode keyCode);
 
 	/**
 	 * Handle events manually to catch keys which don't change the text.
 	 */
 	virtual void ManuallyImmutableHandleKeyDownEvent(const SDL_Keycode keyCode);
 
 	/**
 	 * Handle hotkey events (called by ManuallyHandleKeys)
 	 */
 	virtual InReaction ManuallyHandleHotkeyEvent(const SDL_Event_* ev);
 
 	/**
 	 * @see IGUIObject#UpdateCachedSize()
 	 */
 	virtual void UpdateCachedSize();
 
 	/**
 	 * Draws the Text
 	 */
 	virtual void Draw();
 
 	/**
 	 * Calculate m_CharacterPosition
 	 * the main task for this function is to perfom word-wrapping
 	 * You input from which character it has been changed, because
 	 * if we add a character to the very last end, we don't want
 	 * process everything all over again! Also notice you can
 	 * specify a 'to' also, it will only be used though if a '\n'
 	 * appears, because then the word-wrapping won't change after
 	 * that.
 	 */
 	void UpdateText(int from = 0, int to_before = -1, int to_after = -1);
 
 	/**
 	 * Draws the text generated for placeholder.
 	 *
 	 * @param z Z value
 	 * @param clipping Clipping rectangle, don't even add a parameter
 	 *        to get no clipping.
 	 */
 	virtual void DrawPlaceholderText(float z, const CRect& clipping = CRect());
 
 	/**
 	 * Delete the current selection. Also places the pointer at the
 	 * crack between the two segments kept.
 	 */
 	void DeleteCurSelection();
 
 	/**
 	 * Is text selected? It can be denote two ways, m_iBufferPos_Tail
 	 * being -1 or the same as m_iBufferPos. This makes for clearer
 	 * code.
 	 */
 	bool SelectingText() const;
 
 	/// Get area of where text can be drawn.
 	float GetTextAreaWidth();
 
 	/// Called every time the auto-scrolling should be checked.
 	void UpdateAutoScroll();
 
 	/// Clear composed IME input when supported (SDL2 only).
 	void ClearComposedText();
 
 	/// Updates the buffer (cursor) position exposed to JS.
 	void UpdateBufferPositionSetting();
 protected:
 	/// Cursor position
 	int m_iBufferPos;
 	/// Cursor position we started to select from. (-1 if not selecting)
 	/// (NB: Can be larger than m_iBufferPos if selecting from back to front.)
 	int m_iBufferPos_Tail;
 
 	/// If we're composing text with an IME
 	bool m_ComposingText;
 	/// The length and position of the current IME composition
 	int m_iComposedLength, m_iComposedPos;
 	/// The position to insert committed text
 	int m_iInsertPos;
 
 	// the outer vector is lines, and the inner is X positions
 	//  in a row. So that we can determine where characters are
 	//  placed. It's important because we need to know where the
 	//  pointer should be placed when the input control is pressed.
 	struct SRow
 	{
 		// Where the Row starts
 		int m_ListStart;
 
 		// List of X values for each character.
 		std::vector<float> m_ListOfX;
 	};
 
 	/**
 	 * List of rows to ease changing its size, so iterators stay valid.
 	 * For one-liners only one row is used.
 	 */
 	std::list<SRow> m_CharacterPositions;
 
 	// *** Things for a multi-lined input control *** //
 
 	/**
 	 * When you change row with up/down, and the row you jump to does
 	 * not have anything at that X position, then it will keep the
 	 * m_WantedX position in mind when switching to the next row.
 	 * It will keep on being used until it reach a row which meets the
 	 * requirements.
 	 * 0.0f means not in use.
 	 */
 	float m_WantedX;
 
 	/**
 	 * If we are in the process of selecting a larger selection of text
 	 * using the mouse click (hold) and drag, this is true.
 	 */
 	bool m_SelectingText;
 
 	/**
 	 * Whether the cached text is currently valid (if not then SetupText will be called by Draw)
 	 */
 	bool m_GeneratedPlaceholderTextValid;
 
 	CGUIText m_GeneratedPlaceholderText;
 
 	// *** Things for one-line input control *** //
 	float m_HorizontalScroll;
 
 	/// Used to store the previous time for flashing the cursor.
 	double m_PrevTime;
 
 	/// Cursor blink rate in seconds, if greater than 0.0.
 	double m_CursorBlinkRate;
 
 	/// If the cursor should be drawn or not.
 	bool m_CursorVisState;
 
 	static const CStr EventNameTextEdit;
 	static const CStr EventNamePress;
 	static const CStr EventNameTab;
 
-	// Settings
-	i32 m_BufferPosition;
-	float m_BufferZone;
-	CStrW m_Caption;
-	CGUIString m_PlaceholderText;
-	CStrW m_Font;
-	CStrW m_MaskChar;
-	bool m_Mask;
-	i32 m_MaxLength;
-	bool m_MultiLine;
-	bool m_Readonly;
-	bool m_ScrollBar;
-	CStr m_ScrollBarStyle;
-	CGUISpriteInstance m_Sprite;
-	CGUISpriteInstance m_SpriteSelectArea;
-	CGUIColor m_TextColor;
-	CGUIColor m_TextColorSelected;
-	CGUIColor m_PlaceholderColor;
+	CGUISimpleSetting<i32> m_BufferPosition;
+	CGUISimpleSetting<float> m_BufferZone;
+	CGUISimpleSetting<CStrW> m_Caption;
+	CGUISimpleSetting<CGUIString> m_PlaceholderText;
+	CGUISimpleSetting<CStrW> m_Font;
+	CGUISimpleSetting<CStrW> m_MaskChar;
+	CGUISimpleSetting<bool> m_Mask;
+	CGUISimpleSetting<i32> m_MaxLength;
+	CGUISimpleSetting<bool> m_MultiLine;
+	CGUISimpleSetting<bool> m_Readonly;
+	CGUISimpleSetting<bool> m_ScrollBar;
+	CGUISimpleSetting<CStr> m_ScrollBarStyle;
+	CGUISimpleSetting<CGUISpriteInstance> m_Sprite;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteSelectArea;
+	CGUISimpleSetting<CGUIColor> m_TextColor;
+	CGUISimpleSetting<CGUIColor> m_TextColorSelected;
+	CGUISimpleSetting<CGUIColor> m_PlaceholderColor;
 };
 
 #endif // INCLUDED_CINPUT
Index: ps/trunk/source/gui/CGUI.cpp
===================================================================
--- ps/trunk/source/gui/CGUI.cpp	(revision 25391)
+++ ps/trunk/source/gui/CGUI.cpp	(revision 25392)
@@ -1,1325 +1,1330 @@
 /* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "CGUI.h"
 
 #include "gui/IGUIScrollBar.h"
 #include "gui/ObjectTypes/CGUIDummyObject.h"
 #include "gui/ObjectTypes/CTooltip.h"
 #include "gui/Scripting/ScriptFunctions.h"
 #include "gui/Scripting/JSInterface_GUIProxy.h"
 #include "i18n/L10n.h"
 #include "lib/allocators/DynamicArena.h"
 #include "lib/allocators/STLAllocators.h"
 #include "lib/bits.h"
 #include "lib/input.h"
 #include "lib/sysdep/sysdep.h"
 #include "lib/timer.h"
 #include "lib/utf8.h"
 #include "ps/CLogger.h"
 #include "ps/Filesystem.h"
 #include "ps/GameSetup/Config.h"
 #include "ps/Globals.h"
 #include "ps/Hotkey.h"
 #include "ps/Profile.h"
 #include "ps/Pyrogenesis.h"
 #include "ps/XML/Xeromyces.h"
 #include "renderer/Renderer.h"
 #include "scriptinterface/ScriptContext.h"
 #include "scriptinterface/ScriptInterface.h"
 
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
 
 extern int g_yres;
 
 const double SELECT_DBLCLICK_RATE = 0.5;
 const u32 MAX_OBJECT_DEPTH = 100; // Max number of nesting for GUI includes. Used to detect recursive inclusion
 
 const CStr CGUI::EventNameLoad = "Load";
 const CStr CGUI::EventNameTick = "Tick";
 const CStr CGUI::EventNamePress = "Press";
 const CStr CGUI::EventNameKeyDown = "KeyDown";
 const CStr CGUI::EventNameRelease = "Release";
 const CStr CGUI::EventNameMouseRightPress = "MouseRightPress";
 const CStr CGUI::EventNameMouseLeftPress = "MouseLeftPress";
 const CStr CGUI::EventNameMouseWheelDown = "MouseWheelDown";
 const CStr CGUI::EventNameMouseWheelUp = "MouseWheelUp";
 const CStr CGUI::EventNameMouseLeftDoubleClick = "MouseLeftDoubleClick";
 const CStr CGUI::EventNameMouseLeftRelease = "MouseLeftRelease";
 const CStr CGUI::EventNameMouseRightDoubleClick = "MouseRightDoubleClick";
 const CStr CGUI::EventNameMouseRightRelease = "MouseRightRelease";
 
 namespace
 {
 
 struct VisibleObject
 {
 	IGUIObject* object;
 	// Index of the object in a depth-first search inside GUI tree.
 	size_t index;
 	// Cached value of GetBufferedZ to avoid recursive calls in a deep hierarchy.
 	float bufferedZ;
 };
 
 template<class Container>
 void CollectVisibleObjectsRecursively(const std::vector<IGUIObject*>& objects, Container* visibleObjects)
 {
 	for (IGUIObject* const& object : objects)
 	{
 		if (!object->IsHidden())
 		{
 			visibleObjects->emplace_back(VisibleObject{object, visibleObjects->size(), 0.0f});
 			CollectVisibleObjectsRecursively(object->GetChildren(), visibleObjects);
 		}
 	}
 }
 
 } // anonynous namespace
 
 CGUI::CGUI(const shared_ptr<ScriptContext>& context)
 	: m_BaseObject(std::make_unique<CGUIDummyObject>(*this)),
 	  m_FocusedObject(nullptr),
 	  m_InternalNameNumber(0),
 	  m_MouseButtons(0)
 {
 	m_ScriptInterface = std::make_shared<ScriptInterface>("Engine", "GUIPage", context);
 	m_ScriptInterface->SetCallbackData(this);
 
 	GuiScriptingInit(*m_ScriptInterface);
 	m_ScriptInterface->LoadGlobalScripts();
 }
 
 CGUI::~CGUI()
 {
 	for (const std::pair<const CStr, IGUIObject*>& p : m_pAllObjects)
 		delete p.second;
 
 	for (const std::pair<const CStr, const CGUISprite*>& p : m_Sprites)
 		delete p.second;
 }
 
 InReaction CGUI::HandleEvent(const SDL_Event_* ev)
 {
 	InReaction ret = IN_PASS;
 
 	if (ev->ev.type == SDL_HOTKEYDOWN || ev->ev.type == SDL_HOTKEYPRESS || ev->ev.type == SDL_HOTKEYUP)
 	{
 		const char* hotkey = static_cast<const char*>(ev->ev.user.data1);
 
 		const CStr& eventName = ev->ev.type == SDL_HOTKEYPRESS ? EventNamePress : ev->ev.type == SDL_HOTKEYDOWN ? EventNameKeyDown : EventNameRelease;
 
 		if (m_GlobalHotkeys.find(hotkey) != m_GlobalHotkeys.end() && m_GlobalHotkeys[hotkey].find(eventName) != m_GlobalHotkeys[hotkey].end())
 		{
 			ret = IN_HANDLED;
 
 			ScriptRequest rq(m_ScriptInterface);
 			JS::RootedObject globalObj(rq.cx, rq.glob);
 			JS::RootedValue result(rq.cx);
 			if (!JS_CallFunctionValue(rq.cx, globalObj, m_GlobalHotkeys[hotkey][eventName], JS::HandleValueArray::empty(), &result))
 				ScriptException::CatchPending(rq);
 		}
 
 		std::map<CStr, std::vector<IGUIObject*> >::iterator it = m_HotkeyObjects.find(hotkey);
 		if (it != m_HotkeyObjects.end())
 			for (IGUIObject* const& obj : it->second)
 			{
 				if (ev->ev.type == SDL_HOTKEYPRESS)
 					ret = obj->SendEvent(GUIM_PRESSED, EventNamePress);
 				else if (ev->ev.type == SDL_HOTKEYDOWN)
 					ret = obj->SendEvent(GUIM_KEYDOWN, EventNameKeyDown);
 				else
 					ret = obj->SendEvent(GUIM_RELEASED, EventNameRelease);
 			}
 	}
 
 	else if (ev->ev.type == SDL_MOUSEMOTION)
 	{
 		// Yes the mouse position is stored as float to avoid
 		//  constant conversions when operating in a
 		//  float-based environment.
 		m_MousePos = CVector2D((float)ev->ev.motion.x / g_GuiScale, (float)ev->ev.motion.y / g_GuiScale);
 
 		SGUIMessage msg(GUIM_MOUSE_MOTION);
 		m_BaseObject->RecurseObject(&IGUIObject::IsHiddenOrGhost, &IGUIObject::HandleMessage, msg);
 	}
 
 	// Update m_MouseButtons. (BUTTONUP is handled later.)
 	else if (ev->ev.type == SDL_MOUSEBUTTONDOWN)
 	{
 		switch (ev->ev.button.button)
 		{
 		case SDL_BUTTON_LEFT:
 		case SDL_BUTTON_RIGHT:
 		case SDL_BUTTON_MIDDLE:
 			m_MouseButtons |= Bit<unsigned int>(ev->ev.button.button);
 			break;
 		default:
 			break;
 		}
 	}
 
 	// Update m_MousePos (for delayed mouse button events)
 	CVector2D oldMousePos = m_MousePos;
 	if (ev->ev.type == SDL_MOUSEBUTTONDOWN || ev->ev.type == SDL_MOUSEBUTTONUP)
 	{
 		m_MousePos = CVector2D((float)ev->ev.button.x / g_GuiScale, (float)ev->ev.button.y / g_GuiScale);
 	}
 
 	// Allow the focused object to pre-empt regular GUI events.
 	if (GetFocusedObject())
 		ret = GetFocusedObject()->PreemptEvent(ev);
 
 	// Only one object can be hovered
 	// pNearest will after this point at the hovered object, possibly nullptr
 	IGUIObject* pNearest = FindObjectUnderMouse();
 
 	if (ret == IN_PASS)
 	{
 		// Now we'll call UpdateMouseOver on *all* objects,
 		// we'll input the one hovered, and they will each
 		// update their own data and send messages accordingly
 		m_BaseObject->RecurseObject(&IGUIObject::IsHiddenOrGhost, &IGUIObject::UpdateMouseOver, static_cast<IGUIObject* const&>(pNearest));
 
 		if (ev->ev.type == SDL_MOUSEBUTTONDOWN)
 		{
 			switch (ev->ev.button.button)
 			{
 			case SDL_BUTTON_LEFT:
 				// Focus the clicked object (or focus none if nothing clicked on)
 				SetFocusedObject(pNearest);
 
 				if (pNearest)
 					ret = pNearest->SendMouseEvent(GUIM_MOUSE_PRESS_LEFT, EventNameMouseLeftPress);
 				break;
 
 			case SDL_BUTTON_RIGHT:
 				if (pNearest)
 					ret = pNearest->SendMouseEvent(GUIM_MOUSE_PRESS_RIGHT, EventNameMouseRightPress);
 				break;
 
 			default:
 				break;
 			}
 		}
 		else if (ev->ev.type == SDL_MOUSEWHEEL && pNearest)
 		{
 			if (ev->ev.wheel.y < 0)
 				ret = pNearest->SendMouseEvent(GUIM_MOUSE_WHEEL_DOWN, EventNameMouseWheelDown);
 			else if (ev->ev.wheel.y > 0)
 				ret = pNearest->SendMouseEvent(GUIM_MOUSE_WHEEL_UP, EventNameMouseWheelUp);
 		}
 		else if (ev->ev.type == SDL_MOUSEBUTTONUP)
 		{
 			switch (ev->ev.button.button)
 			{
 			case SDL_BUTTON_LEFT:
 				if (pNearest)
 				{
 					double timeElapsed = timer_Time() - pNearest->m_LastClickTime[SDL_BUTTON_LEFT];
 					pNearest->m_LastClickTime[SDL_BUTTON_LEFT] = timer_Time();
 					if (timeElapsed < SELECT_DBLCLICK_RATE)
 						ret = pNearest->SendMouseEvent(GUIM_MOUSE_DBLCLICK_LEFT, EventNameMouseLeftDoubleClick);
 					else
 						ret = pNearest->SendMouseEvent(GUIM_MOUSE_RELEASE_LEFT, EventNameMouseLeftRelease);
 				}
 				break;
 			case SDL_BUTTON_RIGHT:
 				if (pNearest)
 				{
 					double timeElapsed = timer_Time() - pNearest->m_LastClickTime[SDL_BUTTON_RIGHT];
 					pNearest->m_LastClickTime[SDL_BUTTON_RIGHT] = timer_Time();
 					if (timeElapsed < SELECT_DBLCLICK_RATE)
 						ret = pNearest->SendMouseEvent(GUIM_MOUSE_DBLCLICK_RIGHT, EventNameMouseRightDoubleClick);
 					else
 						ret = pNearest->SendMouseEvent(GUIM_MOUSE_RELEASE_RIGHT, EventNameMouseRightRelease);
 				}
 				break;
 			}
 
 			// Reset all states on all visible objects
 			m_BaseObject->RecurseObject(&IGUIObject::IsHidden, &IGUIObject::ResetStates);
 
 			// Since the hover state will have been reset, we reload it.
 			m_BaseObject->RecurseObject(&IGUIObject::IsHiddenOrGhost, &IGUIObject::UpdateMouseOver, static_cast<IGUIObject* const&>(pNearest));
 		}
 	}
 
 	// BUTTONUP's effect on m_MouseButtons is handled after
 	// everything else, so that e.g. 'press' handlers (activated
 	// on button up) see which mouse button had been pressed.
 	if (ev->ev.type == SDL_MOUSEBUTTONUP)
 	{
 		switch (ev->ev.button.button)
 		{
 		case SDL_BUTTON_LEFT:
 		case SDL_BUTTON_RIGHT:
 		case SDL_BUTTON_MIDDLE:
 			m_MouseButtons &= ~Bit<unsigned int>(ev->ev.button.button);
 			break;
 		default:
 			break;
 		}
 	}
 
 	// Restore m_MousePos (for delayed mouse button events)
 	if (ev->ev.type == SDL_MOUSEBUTTONDOWN || ev->ev.type == SDL_MOUSEBUTTONUP)
 		m_MousePos = oldMousePos;
 
 	// Let GUI items handle keys after everything else, e.g. for input boxes.
 	if (ret == IN_PASS && GetFocusedObject())
 	{
 		if (ev->ev.type == SDL_KEYUP || ev->ev.type == SDL_KEYDOWN ||
 			ev->ev.type == SDL_HOTKEYUP || ev->ev.type == SDL_HOTKEYDOWN ||
 			ev->ev.type == SDL_TEXTINPUT || ev->ev.type == SDL_TEXTEDITING)
 			ret = GetFocusedObject()->ManuallyHandleKeys(ev);
 		// else will return IN_PASS because we never used the button.
 	}
 
 	return ret;
 }
 
 void CGUI::TickObjects()
 {
 	m_BaseObject->RecurseObject(&IGUIObject::IsHiddenOrGhost, &IGUIObject::Tick);
 	SendEventToAll(EventNameTick);
 	m_Tooltip.Update(FindObjectUnderMouse(), m_MousePos, *this);
 }
 
 void CGUI::SendEventToAll(const CStr& eventName)
 {
 	std::unordered_map<CStr, std::vector<IGUIObject*>>::iterator it = m_EventObjects.find(eventName);
 	if (it == m_EventObjects.end())
 		return;
 
 	std::vector<IGUIObject*> copy = it->second;
 	for (IGUIObject* object : copy)
 		object->ScriptEvent(eventName);
 }
 
 void CGUI::SendEventToAll(const CStr& eventName, const JS::HandleValueArray& paramData)
 {
 	std::unordered_map<CStr, std::vector<IGUIObject*>>::iterator it = m_EventObjects.find(eventName);
 	if (it == m_EventObjects.end())
 		return;
 
 	std::vector<IGUIObject*> copy = it->second;
 	for (IGUIObject* object : copy)
 		object->ScriptEvent(eventName, paramData);
 }
 
 void CGUI::Draw()
 {
 	using Arena = Allocators::DynamicArena<128 * KiB>;
 	using ObjectListAllocator = ProxyAllocator<VisibleObject, Arena>;
 	Arena arena;
 
 	std::vector<VisibleObject, ObjectListAllocator> visibleObjects((ObjectListAllocator(arena)));
 	CollectVisibleObjectsRecursively(m_BaseObject->GetChildren(), &visibleObjects);
 	for (VisibleObject& visibleObject : visibleObjects)
 		visibleObject.bufferedZ = visibleObject.object->GetBufferedZ();
 
 	std::sort(visibleObjects.begin(), visibleObjects.end(), [](const VisibleObject& visibleObject1, const VisibleObject& visibleObject2) -> bool {
 		if (visibleObject1.bufferedZ != visibleObject2.bufferedZ)
 			return visibleObject1.bufferedZ < visibleObject2.bufferedZ;
 		return visibleObject1.index < visibleObject2.index;
 	});
 	for (const VisibleObject& visibleObject : visibleObjects)
 		visibleObject.object->Draw();
 }
 
 void CGUI::DrawSprite(const CGUISpriteInstance& Sprite, const float& Z, const CRect& Rect, const CRect& UNUSED(Clipping))
 {
 	// If the sprite doesn't exist (name == ""), don't bother drawing anything
 	if (!Sprite)
 		return;
 
 	// TODO: Clipping?
 
 	Sprite.Draw(*this, Rect, m_Sprites, Z);
 }
 
 void CGUI::UpdateResolution()
 {
 	m_BaseObject->RecurseObject(nullptr, &IGUIObject::UpdateCachedSize);
 }
 
 IGUIObject* CGUI::ConstructObject(const CStr& str)
 {
 	std::map<CStr, ConstructObjectFunction>::iterator it = m_ObjectTypes.find(str);
 
 	if (it == m_ObjectTypes.end())
 		return nullptr;
 
 	return (*it->second)(*this);
 }
 
 bool CGUI::AddObject(IGUIObject& parent, IGUIObject& child)
 {
 	if (child.m_Name.empty())
 	{
 		LOGERROR("Can't register an object without name!");
 		return false;
 	}
 
 	if (m_pAllObjects.find(child.m_Name) != m_pAllObjects.end())
 	{
 		LOGERROR("Can't register more than one object of the name %s", child.m_Name.c_str());
 		return false;
 	}
 
 	m_pAllObjects[child.m_Name] = &child;
 	parent.RegisterChild(&child);
 	return true;
 }
 
 IGUIObject* CGUI::GetBaseObject()
 {
 	return m_BaseObject.get();
 };
 
 bool CGUI::ObjectExists(const CStr& Name) const
 {
 	return m_pAllObjects.find(Name) != m_pAllObjects.end();
 }
 
 IGUIObject* CGUI::FindObjectByName(const CStr& Name) const
 {
 	map_pObjects::const_iterator it = m_pAllObjects.find(Name);
 
 	if (it == m_pAllObjects.end())
 		return nullptr;
 
 	return it->second;
 }
 
 IGUIObject* CGUI::FindObjectUnderMouse()
 {
 	IGUIObject* pNearest = nullptr;
 	m_BaseObject->RecurseObject(&IGUIObject::IsHiddenOrGhost, &IGUIObject::ChooseMouseOverAndClosest, pNearest);
 	return pNearest;
 }
 
 void CGUI::SetFocusedObject(IGUIObject* pObject)
 {
 	if (pObject == m_FocusedObject)
 		return;
 
 	if (m_FocusedObject)
 	{
 		SGUIMessage msg(GUIM_LOST_FOCUS);
 		m_FocusedObject->HandleMessage(msg);
 	}
 
 	m_FocusedObject = pObject;
 
 	if (m_FocusedObject)
 	{
 		SGUIMessage msg(GUIM_GOT_FOCUS);
 		m_FocusedObject->HandleMessage(msg);
 	}
 }
 
 void CGUI::SetObjectStyle(IGUIObject* pObject, const CStr& styleName)
 {
 	// If the style is not recognised (or an empty string) then ApplyStyle will
 	// emit an error message. Thus we don't need to handle it here.
-	if (pObject->ApplyStyle(styleName))
-		pObject->m_Style = styleName;
+	pObject->ApplyStyle(styleName);
 }
 
 void CGUI::UnsetObjectStyle(IGUIObject* pObject)
 {
 	SetObjectStyle(pObject, "default");
 }
 
 void CGUI::SetObjectHotkey(IGUIObject* pObject, const CStr& hotkeyTag)
 {
 	if (!hotkeyTag.empty())
 		m_HotkeyObjects[hotkeyTag].push_back(pObject);
 }
 
 void CGUI::UnsetObjectHotkey(IGUIObject* pObject, const CStr& hotkeyTag)
 {
 	if (hotkeyTag.empty())
 		return;
 
 	std::vector<IGUIObject*>& assignment = m_HotkeyObjects[hotkeyTag];
 
 	assignment.erase(
 		std::remove_if(
 			assignment.begin(),
 			assignment.end(),
 			[&pObject](const IGUIObject* hotkeyObject)
 				{ return pObject == hotkeyObject; }),
 		assignment.end());
 }
 
 void CGUI::SetGlobalHotkey(const CStr& hotkeyTag, const CStr& eventName, JS::HandleValue function)
 {
 	ScriptRequest rq(*m_ScriptInterface);
 
 	if (hotkeyTag.empty())
 	{
 		ScriptException::Raise(rq, "Cannot assign a function to an empty hotkey identifier!");
 		return;
 	}
 
 	// Only support "Press", "Keydown" and "Release" events.
 	if (eventName != EventNamePress && eventName != EventNameKeyDown && eventName != EventNameRelease)
 	{
 		ScriptException::Raise(rq, "Cannot assign a function to an unsupported event!");
 		return;
 	}
 
 	if (!function.isObject() || !JS_ObjectIsFunction(&function.toObject()))
 	{
 		ScriptException::Raise(rq, "Cannot assign non-function value to global hotkey '%s'", hotkeyTag.c_str());
 		return;
 	}
 
 	UnsetGlobalHotkey(hotkeyTag, eventName);
 	m_GlobalHotkeys[hotkeyTag][eventName].init(rq.cx, function);
 }
 
 void CGUI::UnsetGlobalHotkey(const CStr& hotkeyTag, const CStr& eventName)
 {
 	std::map<CStr, std::map<CStr, JS::PersistentRootedValue>>::iterator it = m_GlobalHotkeys.find(hotkeyTag);
 	if (it == m_GlobalHotkeys.end())
 		return;
 
 	m_GlobalHotkeys[hotkeyTag].erase(eventName);
 
 	if (m_GlobalHotkeys.count(hotkeyTag) == 0)
 		m_GlobalHotkeys.erase(it);
 }
 
 const SGUIScrollBarStyle* CGUI::GetScrollBarStyle(const CStr& style) const
 {
 	std::map<CStr, const SGUIScrollBarStyle>::const_iterator it = m_ScrollBarStyles.find(style);
 	if (it == m_ScrollBarStyles.end())
 		return nullptr;
 
  	return &it->second;
 }
 
 /**
  * @callgraph
  */
 void CGUI::LoadXmlFile(const VfsPath& Filename, std::unordered_set<VfsPath>& Paths)
 {
 	Paths.insert(Filename);
 
 	CXeromyces xeroFile;
 	if (xeroFile.Load(g_VFS, Filename, "gui") != PSRETURN_OK)
 		return;
 
 	XMBElement node = xeroFile.GetRoot();
 	std::string_view root_name(xeroFile.GetElementStringView(node.GetNodeName()));
 
 	if (root_name == "objects")
 		Xeromyces_ReadRootObjects(xeroFile, node, Paths);
 	else if (root_name == "sprites")
 		Xeromyces_ReadRootSprites(xeroFile, node);
 	else if (root_name == "styles")
 		Xeromyces_ReadRootStyles(xeroFile, node);
 	else if (root_name == "setup")
 		Xeromyces_ReadRootSetup(xeroFile, node);
 	else
 		LOGERROR("CGUI::LoadXmlFile encountered an unknown XML root node type: %s", root_name.data());
 }
 
 void CGUI::LoadedXmlFiles()
 {
 	m_BaseObject->RecurseObject(nullptr, &IGUIObject::UpdateCachedSize);
 
 	SGUIMessage msg(GUIM_LOAD);
 	m_BaseObject->RecurseObject(nullptr, &IGUIObject::HandleMessage, msg);
 
 	SendEventToAll(EventNameLoad);
 }
 
 //===================================================================
 //	XML Reading Xeromyces Specific Sub-Routines
 //===================================================================
 
 void CGUI::Xeromyces_ReadRootObjects(const XMBData& xmb, XMBElement element, std::unordered_set<VfsPath>& Paths)
 {
 	int el_script = xmb.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(xmb, child, Paths);
 		else
 			// Read in this whole object into the GUI
 			Xeromyces_ReadObject(xmb, child, m_BaseObject.get(), subst, Paths, 0);
 	}
 }
 
 void CGUI::Xeromyces_ReadRootSprites(const XMBData& xmb, XMBElement element)
 {
 	for (XMBElement child : element.GetChildNodes())
 		Xeromyces_ReadSprite(xmb, child);
 }
 
 void CGUI::Xeromyces_ReadRootStyles(const XMBData& xmb, XMBElement element)
 {
 	for (XMBElement child : element.GetChildNodes())
 		Xeromyces_ReadStyle(xmb, child);
 }
 
 void CGUI::Xeromyces_ReadRootSetup(const XMBData& xmb, XMBElement element)
 {
 	for (XMBElement child : element.GetChildNodes())
 	{
 		std::string_view name(xmb.GetElementStringView(child.GetNodeName()));
 		if (name == "scrollbar")
 			Xeromyces_ReadScrollBarStyle(xmb, child);
 		else if (name == "icon")
 			Xeromyces_ReadIcon(xmb, child);
 		else if (name == "tooltip")
 			Xeromyces_ReadTooltip(xmb, child);
 		else if (name == "color")
 			Xeromyces_ReadColor(xmb, child);
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 }
 
 IGUIObject* CGUI::Xeromyces_ReadObject(const XMBData& xmb, XMBElement element, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::unordered_set<VfsPath>& Paths, u32 nesting_depth)
 {
 	ENSURE(pParent);
 
 	XMBAttributeList attributes = element.GetAttributes();
 
 	CStr type(attributes.GetNamedItem(xmb.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 nullptr;
 	}
 
 	// Cache some IDs for element attribute names, to avoid string comparisons
 	#define ELMT(x) int elmt_##x = xmb.GetElementID(#x)
 	#define ATTR(x) int attr_##x = xmb.GetAttributeID(#x)
 	ELMT(object);
 	ELMT(action);
 	ELMT(script);
 	ELMT(repeat);
 	ELMT(translatableAttribute);
 	ELMT(translate);
 	ELMT(attribute);
 	ELMT(keep);
 	ELMT(include);
 	ATTR(style);
 	ATTR(type);
 	ATTR(name);
 	ATTR(z);
 	ATTR(on);
 	ATTR(file);
 	ATTR(directory);
 	ATTR(id);
 	ATTR(context);
 
 	//
 	//	Read Style and set defaults
 	//
 	//	If the setting "style" is set, try loading that setting.
 	//
 	//	Always load default (if it's available) first!
 	//
 	SetObjectStyle(object, "default");
 
 	CStr argStyle(attributes.GetNamedItem(attr_style));
 	if (!argStyle.empty())
 		SetObjectStyle(object, argStyle);
 
 	bool NameSet = false;
 	bool ManuallySetZ = false;
 
 	CStrW inclusionPath;
 
 	for (XMBAttribute attr : attributes)
 	{
 		// If value is "null", then it is equivalent as never being entered
 		if (attr.Value == "null")
 			continue;
 
 		// Ignore "type" and "style", we've already checked it
 		if (attr.Name == attr_type || attr.Name == attr_style)
 			continue;
 
 		if (attr.Name == attr_name)
 		{
 			CStr name(attr.Value);
 
+			if (name.Left(2) == "__")
+			{
+				LOGERROR("GUI: Names starting with '__' are reserved for the engine (object: %s)", name.c_str());
+				continue;
+			}
+
 			for (const std::pair<CStr, CStr>& sub : NameSubst)
 				name.Replace(sub.first, sub.second);
 
 			object->SetName(name);
 			NameSet = true;
 			continue;
 		}
 
 		if (attr.Name == attr_z)
 			ManuallySetZ = true;
 
 		object->SetSettingFromString(xmb.GetAttributeString(attr.Name), attr.Value.FromUTF8(), false);
 	}
 
 	// Check if name isn't set, generate an internal name in that case.
 	if (!NameSet)
 	{
 		object->SetName("__internal(" + CStr::FromInt(m_InternalNameNumber) + ")");
 		++m_InternalNameNumber;
 	}
 
 	CStrW caption(element.GetText().FromUTF8());
 	if (!caption.empty())
 		object->SetSettingFromString("caption", caption, false);
 
 	for (XMBElement child : element.GetChildNodes())
 	{
 		// Check what name the elements got
 		int element_name = child.GetNodeName();
 
 		if (element_name == elmt_object)
 		{
 			// Call this function on the child
 			Xeromyces_ReadObject(xmb, child, object, NameSubst, Paths, nesting_depth);
 		}
 		else if (element_name == elmt_action)
 		{
 			// Scripted <action> element
 
 			// Check for a 'file' parameter
 			CStrW filename(child.GetAttributes().GetNamedItem(attr_file).FromUTF8());
 
 			CStr code;
 
 			// If there is a file, open it and use it as the code
 			if (!filename.empty())
 			{
 				Paths.insert(filename);
 				CVFSFile scriptfile;
 				if (scriptfile.Load(g_VFS, filename) != PSRETURN_OK)
 				{
 					LOGERROR("Error opening GUI script action file '%s'", utf8_from_wstring(filename));
 					continue;
 				}
 
 				code = scriptfile.DecodeUTF8(); // assume it's UTF-8
 			}
 
 			XMBElementList grandchildren = child.GetChildNodes();
 			if (!grandchildren.empty()) // The <action> element contains <keep> and <translate> tags.
 				for (XMBElement grandchild : grandchildren)
 				{
 					if (grandchild.GetNodeName() == elmt_translate)
 						code += g_L10n.Translate(grandchild.GetText());
 					else if (grandchild.GetNodeName() == elmt_keep)
 						code += grandchild.GetText();
 				}
 			else // It's pure JavaScript code.
 				// Read the inline code (concatenating to the file code, if both are specified)
 				code += CStr(child.GetText());
 
 			CStr eventName = child.GetAttributes().GetNamedItem(attr_on);
 			object->RegisterScriptHandler(eventName, code, *this);
 		}
 		else if (child.GetNodeName() == elmt_script)
 		{
 			Xeromyces_ReadScript(xmb, child, Paths);
 		}
 		else if (element_name == elmt_repeat)
 		{
 			Xeromyces_ReadRepeat(xmb, child, object, NameSubst, Paths, nesting_depth);
 		}
 		else if (element_name == elmt_translatableAttribute)
 		{
 			// This is an element in the form "<translatableAttribute id="attributeName">attributeValue</translatableAttribute>".
 			CStr attributeName(child.GetAttributes().GetNamedItem(attr_id)); // Read the attribute name.
 			if (attributeName.empty())
 			{
 				LOGERROR("GUI: 'translatableAttribute' XML element with empty 'id' XML attribute found. (object: %s)", object->GetPresentableName().c_str());
 				continue;
 			}
 
 			CStr value(child.GetText());
 			if (value.empty())
 				continue;
 
 			CStr context(child.GetAttributes().GetNamedItem(attr_context)); // Read the context if any.
 
 			CStr translatedValue = context.empty() ?
 				g_L10n.Translate(value) :
 				g_L10n.TranslateWithContext(context, value);
 
 			object->SetSettingFromString(attributeName, translatedValue.FromUTF8(), false);
 		}
 		else if (element_name == elmt_attribute)
 		{
 			// This is an element in the form "<attribute id="attributeName"><keep>Don't translate this part
 			// </keep><translate>but translate this one.</translate></attribute>".
 			CStr attributeName(child.GetAttributes().GetNamedItem(attr_id)); // Read the attribute name.
 			if (attributeName.empty())
 			{
 				LOGERROR("GUI: 'attribute' XML element with empty 'id' XML attribute found. (object: %s)", object->GetPresentableName().c_str());
 				continue;
 			}
 
 			CStr translatedValue;
 
 			for (XMBElement grandchild : child.GetChildNodes())
 			{
 				if (grandchild.GetNodeName() == elmt_translate)
 					translatedValue += g_L10n.Translate(grandchild.GetText());
 				else if (grandchild.GetNodeName() == elmt_keep)
 					translatedValue += grandchild.GetText();
 			}
 			object->SetSettingFromString(attributeName, translatedValue.FromUTF8(), false);
 		}
 		else if (element_name == elmt_include)
 		{
 			CStrW filename(child.GetAttributes().GetNamedItem(attr_file).FromUTF8());
 			CStrW directory(child.GetAttributes().GetNamedItem(attr_directory).FromUTF8());
 			if (!filename.empty())
 			{
 				if (!directory.empty())
 					LOGWARNING("GUI: Include element found with file name (%s) and directory name (%s). Only the file will be processed.", utf8_from_wstring(filename), utf8_from_wstring(directory));
 
 				Paths.insert(filename);
 
 				CXeromyces xeroIncluded;
 				if (xeroIncluded.Load(g_VFS, filename, "gui") != PSRETURN_OK)
 				{
 					LOGERROR("GUI: Error reading included XML: '%s'", utf8_from_wstring(filename));
 					continue;
 				}
 
 				XMBElement node = xeroIncluded.GetRoot();
 				if (node.GetNodeName() != xeroIncluded.GetElementID("object"))
 				{
 					LOGERROR("GUI: Error reading included XML: '%s', root element must have be of type 'object'.", utf8_from_wstring(filename));
 					continue;
 				}
 
 				if (nesting_depth+1 >= MAX_OBJECT_DEPTH)
 				{
 					LOGERROR("GUI: Too many nested GUI includes. Probably caused by a recursive include attribute. Abort rendering '%s'.", utf8_from_wstring(filename));
 					continue;
 				}
 
 				Xeromyces_ReadObject(xeroIncluded, node, 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(xeroIncluded, node, 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(xmb, child))
 				LOGERROR("GUI: (object: %s) Reading unknown children for its type", object->GetPresentableName().c_str());
 		}
 	}
 
 	object->AdditionalChildrenHandled();
 
 	if (!ManuallySetZ)
 	{
 		// Set it automatically to 10 plus its parents
 		if (object->m_Absolute)
 			// If the object is absolute, we'll have to get the parent's Z buffered,
 			// and add to that!
-			object->SetSetting<float>("z", pParent->GetBufferedZ() + 10.f, false);
+			object->m_Z.Set(pParent->GetBufferedZ() + 10.f, false);
 		else
 			// If the object is relative, then we'll just store Z as "10"
-			object->SetSetting<float>("z", 10.f, false);
+			object->m_Z.Set(10.f, false);
 	}
 
 	if (!AddObject(*pParent, *object))
 	{
 		delete object;
 		return nullptr;
 	}
 	return object;
 }
 
 void CGUI::Xeromyces_ReadRepeat(const XMBData& xmb, XMBElement element, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::unordered_set<VfsPath>& Paths, u32 nesting_depth)
 {
 	#define ELMT(x) int elmt_##x = xmb.GetElementID(#x)
 	#define ATTR(x) int attr_##x = xmb.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(xmb, child, pParent, NameSubst, Paths, nesting_depth);
 		}
 		NameSubst.pop_back();
 	}
 }
 
 void CGUI::Xeromyces_ReadScript(const XMBData& xmb, XMBElement element, std::unordered_set<VfsPath>& Paths)
 {
 	// Check for a 'file' parameter
 	CStrW fileAttr(element.GetAttributes().GetNamedItem(xmb.GetAttributeID("file")).FromUTF8());
 
 	// If there is a file specified, open and execute it
 	if (!fileAttr.empty())
 	{
 		if (!VfsPath(fileAttr).IsDirectory())
 		{
 			Paths.insert(fileAttr);
 			m_ScriptInterface->LoadGlobalScriptFile(fileAttr);
 		}
 		else
 			LOGERROR("GUI: Script path %s is not a file path", fileAttr.ToUTF8().c_str());
 	}
 
 	// If it has a directory attribute, read all JS files in that directory
 	CStrW directoryAttr(element.GetAttributes().GetNamedItem(xmb.GetAttributeID("directory")).FromUTF8());
 	if (!directoryAttr.empty())
 	{
 		if (VfsPath(directoryAttr).IsDirectory())
 		{
 			VfsPaths pathnames;
 			vfs::GetPathnames(g_VFS, directoryAttr, L"*.js", pathnames);
 			for (const VfsPath& path : pathnames)
 			{
 				// Only load new files (so when the insert succeeds)
 				if (Paths.insert(path).second)
 					m_ScriptInterface->LoadGlobalScriptFile(path);
 			}
 		}
 		else
 			LOGERROR("GUI: Script path %s is not a directory path", directoryAttr.ToUTF8().c_str());
 	}
 
 	CStr code(element.GetText());
 	if (!code.empty())
 		m_ScriptInterface->LoadGlobalScript(L"Some XML file", code);
 }
 
 void CGUI::Xeromyces_ReadSprite(const XMBData& xmb, XMBElement element)
 {
 	CGUISprite* Sprite = new CGUISprite;
 
 	// Get name, we know it exists because of DTD requirements
 	CStr name = element.GetAttributes().GetNamedItem(xmb.GetAttributeID("name"));
 
 	if (m_Sprites.find(name) != m_Sprites.end())
 		LOGWARNING("GUI sprite name '%s' used more than once; first definition will be discarded", name.c_str());
 
 	// shared_ptr to link the effect to every image, faster than copy.
 	std::shared_ptr<SGUIImageEffects> effects;
 
 	for (XMBElement child : element.GetChildNodes())
 	{
 		std::string_view ElementName(xmb.GetElementStringView(child.GetNodeName()));
 		if (ElementName == "image")
 			Xeromyces_ReadImage(xmb, child, *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(xmb, child, *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(const XMBData& xmb, XMBElement element, CGUISprite& parent)
 {
 	SGUIImage* Image = new SGUIImage();
 
 	// TODO Gee: Setup defaults here (or maybe they are in the SGUIImage ctor)
 
 	for (XMBAttribute attr : element.GetAttributes())
 	{
 		std::string_view attr_name(xmb.GetAttributeStringView(attr.Name));
 		CStrW attr_value(attr.Value.FromUTF8());
 
 		if (attr_name == "texture")
 		{
 			Image->m_TextureName = VfsPath("art/textures/ui") / attr_value;
 		}
 		else if (attr_name == "size")
 		{
 			Image->m_Size.FromString(attr.Value);
 		}
 		else if (attr_name == "texture_size")
 		{
 			Image->m_TextureSize.FromString(attr.Value);
 		}
 		else if (attr_name == "real_texture_placement")
 		{
 			CRect rect;
 			if (!ParseString<CRect>(this, attr_value, rect))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_TexturePlacementInFile = rect;
 		}
 		else if (attr_name == "fixed_h_aspect_ratio")
 		{
 			float val;
 			if (!ParseString<float>(this, attr_value, val))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_FixedHAspectRatio = val;
 		}
 		else if (attr_name == "round_coordinates")
 		{
 			bool b;
 			if (!ParseString<bool>(this, attr_value, b))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_RoundCoordinates = b;
 		}
 		else if (attr_name == "wrap_mode")
 		{
 			if (attr_value == L"repeat")
 				Image->m_WrapMode = GL_REPEAT;
 			else if (attr_value == L"mirrored_repeat")
 				Image->m_WrapMode = GL_MIRRORED_REPEAT;
 			else if (attr_value == L"clamp_to_edge")
 				Image->m_WrapMode = GL_CLAMP_TO_EDGE;
 			else
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 		}
 		else if (attr_name == "z_level")
 		{
 			float z_level;
 			if (!ParseString<float>(this, attr_value, z_level))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_DeltaZ = z_level/100.f;
 		}
 		else if (attr_name == "backcolor")
 		{
 			if (!ParseString<CGUIColor>(this, attr_value, Image->m_BackColor))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 		}
 		else if (attr_name == "bordercolor")
 		{
 			if (!ParseString<CGUIColor>(this, attr_value, Image->m_BorderColor))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 		}
 		else if (attr_name == "border")
 		{
 			bool b;
 			if (!ParseString<bool>(this, attr_value, b))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_Border = b;
 		}
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 
 	// Look for effects
 	for (XMBElement child : element.GetChildNodes())
 	{
 		std::string_view ElementName(xmb.GetElementStringView(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(xmb, child, *Image->m_Effects);
 			}
 		}
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 
 	parent.AddImage(Image);
 }
 
 void CGUI::Xeromyces_ReadEffects(const XMBData& xmb, XMBElement element, SGUIImageEffects& effects)
 {
 	for (XMBAttribute attr : element.GetAttributes())
 	{
 		std::string_view attr_name(xmb.GetAttributeStringView(attr.Name));
 		if (attr_name == "add_color")
 		{
 			if (!effects.m_AddColor.ParseString(*this, attr.Value, 0))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr.Value);
 		}
 		else if (attr_name == "grayscale")
 			effects.m_Greyscale = true;
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 }
 
 void CGUI::Xeromyces_ReadStyle(const XMBData& xmb, XMBElement element)
 {
 	SGUIStyle style;
 	CStr name;
 
 	for (XMBAttribute attr : element.GetAttributes())
 	{
 		std::string_view attr_name(xmb.GetAttributeStringView(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(std::string(attr_name), attr.Value.FromUTF8());
 	}
 
 	m_Styles.erase(name);
 	m_Styles.emplace(name, std::move(style));
 }
 
 void CGUI::Xeromyces_ReadScrollBarStyle(const XMBData& xmb, XMBElement element)
 {
 	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())
 	{
 		std::string_view attr_name(xmb.GetAttributeStringView(attr.Name));
 		CStr attr_value(attr.Value);
 
 		if (attr_value == "null")
 			continue;
 
 		if (attr_name == "name")
 			name = attr_value;
 		else if (attr_name == "show_edge_buttons")
 		{
 			bool b;
 			if (!ParseString<bool>(this, attr_value.FromUTF8(), b))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr_value);
 			else
 				scrollbar.m_UseEdgeButtons = b;
 		}
 		else if (attr_name == "width")
 		{
 			float f;
 			if (!ParseString<float>(this, attr_value.FromUTF8(), f))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr_value);
 			else
 				scrollbar.m_Width = f;
 		}
 		else if (attr_name == "minimum_bar_size")
 		{
 			float f;
 			if (!ParseString<float>(this, attr_value.FromUTF8(), f))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr_value);
 			else
 				scrollbar.m_MinimumBarSize = f;
 		}
 		else if (attr_name == "maximum_bar_size")
 		{
 			float f;
 			if (!ParseString<float>(this, attr_value.FromUTF8(), f))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr_value);
 			else
 				scrollbar.m_MaximumBarSize = f;
 		}
 		else if (attr_name == "sprite_button_top")
 			scrollbar.m_SpriteButtonTop = attr_value;
 		else if (attr_name == "sprite_button_top_pressed")
 			scrollbar.m_SpriteButtonTopPressed = attr_value;
 		else if (attr_name == "sprite_button_top_disabled")
 			scrollbar.m_SpriteButtonTopDisabled = attr_value;
 		else if (attr_name == "sprite_button_top_over")
 			scrollbar.m_SpriteButtonTopOver = attr_value;
 		else if (attr_name == "sprite_button_bottom")
 			scrollbar.m_SpriteButtonBottom = attr_value;
 		else if (attr_name == "sprite_button_bottom_pressed")
 			scrollbar.m_SpriteButtonBottomPressed = attr_value;
 		else if (attr_name == "sprite_button_bottom_disabled")
 			scrollbar.m_SpriteButtonBottomDisabled = attr_value;
 		else if (attr_name == "sprite_button_bottom_over")
 			scrollbar.m_SpriteButtonBottomOver = attr_value;
 		else if (attr_name == "sprite_back_vertical")
 			scrollbar.m_SpriteBackVertical = attr_value;
 		else if (attr_name == "sprite_bar_vertical")
 			scrollbar.m_SpriteBarVertical = attr_value;
 		else if (attr_name == "sprite_bar_vertical_over")
 			scrollbar.m_SpriteBarVerticalOver = attr_value;
 		else if (attr_name == "sprite_bar_vertical_pressed")
 			scrollbar.m_SpriteBarVerticalPressed = attr_value;
 	}
 
 	m_ScrollBarStyles.erase(name);
 	m_ScrollBarStyles.emplace(name, std::move(scrollbar));
 }
 
 void CGUI::Xeromyces_ReadIcon(const XMBData& xmb, XMBElement element)
 {
 	SGUIIcon icon;
 	CStr name;
 
 	for (XMBAttribute attr : element.GetAttributes())
 	{
 		std::string_view attr_name(xmb.GetAttributeStringView(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")
 		{
 			CSize2D size;
 			if (!ParseString<CSize2D>(this, attr_value.FromUTF8(), size))
 				LOGERROR("Error parsing '%s' (\"%s\") inside <icon>.", attr_name, attr_value);
 			else
 				icon.m_Size = size;
 		}
 		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(const XMBData& xmb, XMBElement element)
 {
 	IGUIObject* object = new CTooltip(*this);
 
 	for (XMBAttribute attr : element.GetAttributes())
 	{
 		std::string_view attr_name(xmb.GetAttributeStringView(attr.Name));
 		CStr attr_value(attr.Value);
 
 		if (attr_name == "name")
 			object->SetName("__tooltip_" + attr_value);
 		else
 			object->SetSettingFromString(std::string(attr_name), attr_value.FromUTF8(), true);
 	}
 
 	if (!AddObject(*m_BaseObject, *object))
 		delete object;
 }
 
 void CGUI::Xeromyces_ReadColor(const XMBData& xmb, XMBElement element)
 {
 	XMBAttributeList attributes = element.GetAttributes();
 	CStr name = attributes.GetNamedItem(xmb.GetAttributeID("name"));
 
 	// Try parsing value
 	CStr value(element.GetText());
 	if (value.empty())
 		return;
 
 	CColor color;
 	if (color.ParseString(value))
 	{
 		m_PreDefinedColors.erase(name);
 		m_PreDefinedColors.emplace(
 			std::piecewise_construct,
 			std::forward_as_tuple(name),
 			std::forward_as_tuple(color.r, color.g, color.b, color.a));
 	}
 	else
 		LOGERROR("GUI: Unable to create custom color '%s'. Invalid color syntax.", name.c_str());
 }
Index: ps/trunk/source/gui/CGUISetting.cpp
===================================================================
--- ps/trunk/source/gui/CGUISetting.cpp	(revision 25391)
+++ ps/trunk/source/gui/CGUISetting.cpp	(revision 25392)
@@ -1,89 +1,129 @@
 /* Copyright (C) 2021 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 "CGUISetting.h"
 
 #include "gui/CGUI.h"
 #include "ps/CLogger.h"
 #include "scriptinterface/ScriptInterface.h"
 
-template<typename T>
+IGUISetting::IGUISetting(const CStr& name, IGUIObject* owner) : m_pObject(*owner)
+{
+	m_pObject.RegisterSetting(name, this);
+}
 
-CGUISetting<T>::CGUISetting(IGUIObject& pObject, const CStr& Name, T& Value)
-	: m_pSetting(Value), m_Name(Name), m_pObject(pObject)
+IGUISetting::IGUISetting(IGUISetting&& o) : m_pObject(o.m_pObject)
 {
+	m_pObject.ReregisterSetting(o.GetName(), this);
 }
 
-template<typename T>
-bool CGUISetting<T>::FromString(const CStrW& Value, const bool SendMessage)
+bool IGUISetting::FromString(const CStrW& value, const bool sendMessage)
 {
-	T settingValue;
+	if (!DoFromString(value))
+		return false;
+
+	OnSettingChange(GetName(), sendMessage);
+	return true;
+}
 
-	if (!CGUI::ParseString<T>(&m_pObject.GetGUI(), Value, settingValue))
+/**
+ * Parses the given JS::Value using ScriptInterface::FromJSVal and assigns it to the setting data.
+ */
+bool IGUISetting::FromJSVal(const ScriptRequest& rq, JS::HandleValue value, const bool sendMessage)
+{
+	if (!DoFromJSVal(rq, value))
 		return false;
 
-	m_pObject.SetSetting<T>(m_Name, settingValue, SendMessage);
+	OnSettingChange(GetName(), sendMessage);
 	return true;
+}
+
+void IGUISetting::OnSettingChange(const CStr& setting, bool sendMessage)
+{
+	m_pObject.SettingChanged(setting, sendMessage);
+}
+
+template<typename T>
+bool CGUISimpleSetting<T>::DoFromString(const CStrW& value)
+{
+	return CGUI::ParseString<T>(&m_pObject.GetGUI(), value, m_Setting);
 };
 
 template<>
-bool CGUISetting<CGUIColor>::FromJSVal(const ScriptRequest& rq, JS::HandleValue Value, const bool SendMessage)
+bool CGUISimpleSetting<CGUIColor>::DoFromJSVal(const ScriptRequest& rq, JS::HandleValue value)
 {
-	CGUIColor settingValue;
-	if (Value.isString())
+	if (value.isString())
 	{
 		CStr name;
-		if (!ScriptInterface::FromJSVal(rq, Value, name))
+		if (!ScriptInterface::FromJSVal(rq, value, name))
 			return false;
 
-		if (!settingValue.ParseString(m_pObject.GetGUI(), name))
+		if (!m_Setting.ParseString(m_pObject.GetGUI(), name))
 		{
 			LOGERROR("Invalid color '%s'", name.c_str());
 			return false;
 		}
 	}
-	else if (!ScriptInterface::FromJSVal<CColor>(rq, Value, settingValue))
-		return false;
 
-	m_pObject.SetSetting<CGUIColor>(m_Name, settingValue, SendMessage);
-	return true;
+	return ScriptInterface::FromJSVal<CColor>(rq, value, m_Setting);
 };
 
 template<typename T>
-bool CGUISetting<T>::FromJSVal(const ScriptRequest& rq, JS::HandleValue Value, const bool SendMessage)
+bool CGUISimpleSetting<T>::DoFromJSVal(const ScriptRequest& rq, JS::HandleValue value)
 {
-	T settingValue;
-	if (!ScriptInterface::FromJSVal<T>(rq, Value, settingValue))
-		return false;
-
-	m_pObject.SetSetting<T>(m_Name, settingValue, SendMessage);
-	return true;
+	return ScriptInterface::FromJSVal<T>(rq, value, m_Setting);
 };
 
 template<typename T>
-void CGUISetting<T>::ToJSVal(const ScriptRequest& rq, JS::MutableHandleValue Value)
+void CGUISimpleSetting<T>::ToJSVal(const ScriptRequest& rq, JS::MutableHandleValue value)
 {
-	ScriptInterface::ToJSVal<T>(rq, Value, m_pSetting);
+	ScriptInterface::ToJSVal<T>(rq, value, m_Setting);
 };
 
+/**
+ * Explicitly instantiate CGUISimpleSetting for the basic types.
+ */
 #define TYPE(T) \
-	template class CGUISetting<T>; \
+	template class CGUISimpleSetting<T>;
+
+TYPE(bool)
+TYPE(i32)
+TYPE(u32)
+TYPE(float)
+TYPE(CVector2D)
+#include "ps/CStr.h"
+TYPE(CStr)
+TYPE(CStrW)
+// TODO: make these inherit from CGUISimpleSetting directly.
+#include "gui/SettingTypes/CGUISize.h"
+TYPE(CGUISize)
+TYPE(CGUIColor)
+#include "gui/CGUISprite.h"
+TYPE(CGUISpriteInstance)
+#include "gui/SettingTypes/CGUIString.h"
+TYPE(CGUIString)
+#include "gui/SettingTypes/EAlign.h"
+TYPE(EAlign)
+TYPE(EVAlign)
+#include "gui/SettingTypes/CGUIList.h"
+TYPE(CGUIList)
+#include "gui/SettingTypes/CGUISeries.h"
+TYPE(CGUISeries)
 
-#include "gui/GUISettingTypes.h"
 #undef TYPE
Index: ps/trunk/source/gui/CGUISetting.h
===================================================================
--- ps/trunk/source/gui/CGUISetting.h	(revision 25391)
+++ ps/trunk/source/gui/CGUISetting.h	(revision 25392)
@@ -1,97 +1,125 @@
-/* Copyright (C) 2019 Wildfire Games.
+/* Copyright (C) 2021 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_CGUISETTINGS
 #define INCLUDED_CGUISETTINGS
 
 #include "gui/ObjectBases/IGUIObject.h"
 
+class IGUIObject;
+class ScriptRequest;
+
 /**
  * This setting interface allows GUI objects to call setting function functions without having to know the setting type.
  * This is fact is used for setting the value from a JS value or XML value (string) and when deleting the setting,
  * when the type of the setting value is not known in advance.
  */
 class IGUISetting
 {
 public:
 	NONCOPYABLE(IGUISetting);
-
-	IGUISetting() = default;
-	virtual ~IGUISetting() = default;
+	IGUISetting(const CStr& name, IGUIObject* owner);
 
 	/**
 	 * Parses the given string and assigns to the setting value. Used for parsing XML attributes.
 	 */
-	virtual bool FromString(const CStrW& Value, const bool SendMessage) = 0;
+	bool FromString(const CStrW& value, const bool sendMessage);
 
 	/**
 	 * Parses the given JS::Value using ScriptInterface::FromJSVal and assigns it to the setting data.
 	 */
-	virtual bool FromJSVal(const ScriptRequest& rq, JS::HandleValue Value, const bool SendMessage) = 0;
+	bool FromJSVal(const ScriptRequest& rq, JS::HandleValue value, const bool sendMessage);
 
 	/**
 	 * Converts the setting data to a JS::Value using ScriptInterface::ToJSVal.
 	 */
-	virtual void ToJSVal(const ScriptRequest& rq, JS::MutableHandleValue Value) = 0;
-};
-
-template<typename T>
-class CGUISetting : public IGUISetting
-{
-public:
-	NONCOPYABLE(CGUISetting);
+	virtual void ToJSVal(const ScriptRequest& rq, JS::MutableHandleValue value) = 0;
 
-	CGUISetting(IGUIObject& pObject, const CStr& Name, T& Value);
-
-	/**
-	 * Parses the given string and assigns to the setting value. Used for parsing XML attributes.
-	 */
-	bool FromString(const CStrW& Value, const bool SendMessage) override;
+protected:
+	IGUISetting(IGUISetting&& o);
+	virtual ~IGUISetting() = default;
 
-	/**
-	 * Parses the given JS::Value using ScriptInterface::FromJSVal and assigns it to the setting data.
-	 */
-	bool FromJSVal(const ScriptRequest& rq, JS::HandleValue Value, const bool SendMessage) override;
+	virtual bool DoFromString(const CStrW& value) = 0;
+	virtual bool DoFromJSVal(const ScriptRequest& rq, JS::HandleValue value) = 0;
 
 	/**
-	 * Converts the setting data to a JS::Value using ScriptInterface::ToJSVal.
+	 * Triggers the IGUIObject logic when a setting changes.
+	 * This should be called by derived classes when something externally visible changes,
+	 * unless overloaded to provide similar behaviour.
 	 */
-	void ToJSVal(const ScriptRequest& rq, JS::MutableHandleValue Value) override;
+	virtual void OnSettingChange(const CStr& setting, bool sendMessage);
 
 	/**
-	 * These members are public because they are either unmodifiable or free to be modified.
-	 * In particular it avoids the need for setter templates specialized depending on copiability.
+	 * Return the name of the setting, from JS.
 	 */
+	virtual CStr GetName() const = 0;
 
 	/**
 	 * The object that stores this setting.
 	 */
 	IGUIObject& m_pObject;
+};
+
+/**
+ * Wraps a T. Makes sure the appropriate setting functions are called when modifying T,
+ * and likewise makes sure that JS/xml settings affect T appropriately,
+ * while being as transparent as possible to use from C++ code.
+ */
+template<typename T>
+class CGUISimpleSetting : public IGUISetting
+{
+public:
+	template<typename... Args>
+	CGUISimpleSetting(IGUIObject* pObject, const CStr& Name, Args&&... args)
+		: IGUISetting(Name, pObject), m_Name(Name), m_Setting(args...)
+	{}
+	NONCOPYABLE(CGUISimpleSetting);
+	MOVABLE(CGUISimpleSetting);
+
+	operator const T&() const { return m_Setting; }
+	const T& operator*() const { return m_Setting; }
+	const T* operator->() const { return &m_Setting; }
 
 	/**
-	 * Property name identifying the setting.
+	 * 'Uglified' getter when you want direct access without triggering messages.
 	 */
-	const CStr m_Name;
+	T& GetMutable() { return m_Setting; }
 
 	/**
-	 * Holds a reference to the value of the setting.
-	 * The setting value is stored in the member class to optimize for draw calls of that class.
+	 * 'Uglified' operator=, so that SendMessage is explicit.
 	 */
-	T& m_pSetting;
+	void Set(T value, bool sendMessage)
+	{
+		m_Setting = std::move(value);
+		OnSettingChange(m_Name, sendMessage);
+	}
+
+protected:
+	CStr GetName() const override
+	{
+		return m_Name;
+	}
+
+	bool DoFromString(const CStrW& value) override;
+	bool DoFromJSVal(const ScriptRequest& rq, JS::HandleValue value) override;
+	void ToJSVal(const ScriptRequest& rq, JS::MutableHandleValue value) override;
+
+	const CStr m_Name;
+	T m_Setting;
 };
 
 #endif // INCLUDED_CGUISETTINGS
Index: ps/trunk/source/gui/CGUIText.cpp
===================================================================
--- ps/trunk/source/gui/CGUIText.cpp	(revision 25391)
+++ ps/trunk/source/gui/CGUIText.cpp	(revision 25392)
@@ -1,478 +1,471 @@
 /* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "CGUIText.h"
 
 #include "graphics/FontMetrics.h"
 #include "graphics/ShaderManager.h"
 #include "graphics/TextRenderer.h"
 #include "gui/CGUI.h"
 #include "gui/ObjectBases/IGUIObject.h"
 #include "gui/SettingTypes/CGUIString.h"
 #include "renderer/Renderer.h"
 
 #include <math.h>
 
 extern int g_xres, g_yres;
 extern float g_GuiScale;
 
 // TODO Gee: CRect => CPoint ?
 void SGenerateTextImage::SetupSpriteCall(
 	const bool Left, CGUIText::SSpriteCall& SpriteCall, const float width, const float y,
 	const CSize2D& Size, const CStr& TextureName, const float BufferZone)
 {
 	// TODO Gee: Temp hardcoded values
 	SpriteCall.m_Area.top = y + BufferZone;
 	SpriteCall.m_Area.bottom = y + BufferZone + Size.Height;
 
 	if (Left)
 	{
 		SpriteCall.m_Area.left = BufferZone;
 		SpriteCall.m_Area.right = Size.Width + BufferZone;
 	}
 	else
 	{
 		SpriteCall.m_Area.left = width-BufferZone - Size.Width;
 		SpriteCall.m_Area.right = width-BufferZone;
 	}
 
 	SpriteCall.m_Sprite = TextureName;
 
 	m_YFrom = SpriteCall.m_Area.top - BufferZone;
 	m_YTo = SpriteCall.m_Area.bottom + BufferZone;
 	m_Indentation = Size.Width + BufferZone * 2;
 }
 
-CGUIText::CGUIText(const CGUI& pGUI, const CGUIString& string, const CStrW& FontW, const float Width, const float BufferZone, const IGUIObject* pObject)
+CGUIText::CGUIText(const CGUI& pGUI, const CGUIString& string, const CStrW& FontW, const float Width, const float BufferZone, const EAlign align, const IGUIObject* pObject)
 {
 	if (string.m_Words.empty())
 		return;
 
 	CStrIntern Font(FontW.ToUTF8());
 	float x = BufferZone, y = BufferZone; // drawing pointer
 	int from = 0;
 
 	bool FirstLine = true;	// Necessary because text in the first line is shorter
 							// (it doesn't count the line spacing)
 
 	// Images on the left or the right side.
 	SGenerateTextImages Images;
 	int pos_last_img = -1;	// Position in the string where last img (either left or right) were encountered.
 							//  in order to avoid duplicate processing.
 
-	// get the alignment type for the control we are computing the text for since
-	// we are computing the horizontal alignment in this method in order to not have
-	// to run through the TextCalls a second time in the CalculateTextPosition method again
-	EAlign align = EAlign::LEFT;
-	if (pObject->SettingExists("text_align"))
-		align = pObject->GetSetting<EAlign>("text_align");
-
 	// Go through string word by word
 	for (int i = 0; i < static_cast<int>(string.m_Words.size()) - 1; ++i)
 	{
 		// Pre-process each line one time, so we know which floating images
 		//  will be added for that line.
 
 		// Generated stuff is stored in Feedback.
 		CGUIString::SFeedback Feedback;
 
 		// Preliminary line height, used for word-wrapping with floating images.
 		float prelim_line_height = 0.f;
 
 		// Width and height of all text calls generated.
 		string.GenerateTextCall(pGUI, Feedback, Font, string.m_Words[i], string.m_Words[i+1], FirstLine);
 
 		SetupSpriteCalls(pGUI, Feedback.m_Images, y, Width, BufferZone, i, pos_last_img, Images);
 
 		pos_last_img = std::max(pos_last_img, i);
 
 		x += Feedback.m_Size.Width;
 		prelim_line_height = std::max(prelim_line_height, Feedback.m_Size.Height);
 
 		// If Width is 0, then there's no word-wrapping, disable NewLine.
 		if (((Width != 0 && (x > Width - BufferZone || Feedback.m_NewLine)) || i == static_cast<int>(string.m_Words.size()) - 2) &&
 		    ProcessLine(pGUI, string, Font, pObject, Images, align, prelim_line_height, Width, BufferZone, FirstLine, x, y, i, from))
 			return;
 	}
 }
 
 // Loop through our images queues, to see if images have been added.
 void CGUIText::SetupSpriteCalls(
 	const CGUI& pGUI,
 	const std::array<std::vector<CStr>, 2>& FeedbackImages,
 	const float y,
 	const float Width,
 	const float BufferZone,
 	const int i,
 	const int pos_last_img,
 	SGenerateTextImages& Images)
 {
 	// Check if this has already been processed.
 	//  Also, floating images are only applicable if Word-Wrapping is on
 	if (Width == 0 || i <= pos_last_img)
 		return;
 
 	// Loop left/right
 	for (int j = 0; j < 2; ++j)
 		for (const CStr& imgname : FeedbackImages[j])
 		{
 			SSpriteCall SpriteCall;
 			SGenerateTextImage Image;
 
 			// Y is if no other floating images is above, y. Else it is placed
 			//  after the last image, like a stack downwards.
 			float _y;
 			if (!Images[j].empty())
 				_y = std::max(y, Images[j].back().m_YTo);
 			else
 				_y = y;
 
 			const SGUIIcon& icon = pGUI.GetIcon(imgname);
 			Image.SetupSpriteCall(j == CGUIString::SFeedback::Left, SpriteCall, Width, _y, icon.m_Size, icon.m_SpriteName, BufferZone);
 
 			// Check if image is the lowest thing.
 			m_Size.Height = std::max(m_Size.Height, Image.m_YTo);
 
 			Images[j].emplace_back(Image);
 			m_SpriteCalls.emplace_back(std::move(SpriteCall));
 		}
 }
 
 // Now we'll do another loop to figure out the height and width of
 //  the line (the height of the largest character and the width is
 //  the sum of all of the individual widths). This
 //  couldn't be determined in the first loop (main loop)
 //  because it didn't regard images, so we don't know
 //  if all characters processed, will actually be involved
 //  in that line.
 void CGUIText::ComputeLineSize(
 	const CGUI& pGUI,
 	const CGUIString& string,
 	const CStrIntern& Font,
 	const bool FirstLine,
 	const float Width,
 	const float width_range_to,
 	const int i,
 	const int temp_from,
 	float& x,
 	CSize2D& line_size) const
 {
 	for (int j = temp_from; j <= i; ++j)
 	{
 		// We don't want to use Feedback now, so we'll have to use another one.
 		CGUIString::SFeedback Feedback2;
 
 		// Don't attach object, it'll suppress the errors
 		//  we want them to be reported in the final GenerateTextCall()
 		//  so that we don't get duplicates.
 		string.GenerateTextCall(pGUI, Feedback2, Font, string.m_Words[j], string.m_Words[j+1], FirstLine);
 
 		// Append X value.
 		x += Feedback2.m_Size.Width;
 
 		if (Width != 0 && x > width_range_to && j != temp_from && !Feedback2.m_NewLine)
 		{
 			// The calculated width of each word includes the space between the current
 			// word and the next. When we're wrapping, we need subtract the width of the
 			// space after the last word on the line before the wrap.
 			CFontMetrics currentFont(Font);
 			line_size.Width -= currentFont.GetCharacterWidth(*L" ");
 			break;
 		}
 
 		// Let line_size.cy be the maximum m_Height we encounter.
 		line_size.Height = std::max(line_size.Height, Feedback2.m_Size.Height);
 
 		// If the current word is an explicit new line ("\n"),
 		// break now before adding the width of this character.
 		// ("\n" doesn't have a glyph, thus is given the same width as
 		// the "missing glyph" character by CFont::GetCharacterWidth().)
 		if (Width != 0 && Feedback2.m_NewLine)
 			break;
 
 		line_size.Width += Feedback2.m_Size.Width;
 	}
 }
 
 bool CGUIText::ProcessLine(
 	const CGUI& pGUI,
 	const CGUIString& string,
 	const CStrIntern& Font,
 	const IGUIObject* pObject,
 	const SGenerateTextImages& Images,
 	const EAlign align,
 	const float prelim_line_height,
 	const float Width,
 	const float BufferZone,
 	bool& FirstLine,
 	float& x,
 	float& y,
 	int& i,
 	int& from)
 {
 	// Change 'from' to 'i', but first keep a copy of its value.
 	int temp_from = from;
 	from = i;
 
 	float width_range_from = BufferZone;
 	float width_range_to = Width - BufferZone;
 	ComputeLineRange(Images, y, Width, prelim_line_height, width_range_from, width_range_to);
 
 	// Reset X for the next loop
 	x = width_range_from;
 
 	CSize2D line_size;
 	ComputeLineSize(pGUI, string, Font, FirstLine, Width, width_range_to, i, temp_from, x, line_size);
 
 	// Reset x once more
 	x = width_range_from;
 
 	// Move down, because font drawing starts from the baseline
 	y += line_size.Height;
 
 	const float dx = GetLineOffset(align, width_range_from, width_range_to, line_size);
 
 	// Do the real processing now
 	const bool done = AssembleCalls(pGUI, string, Font, pObject, FirstLine, Width, width_range_to, dx, y, temp_from, i, x, from);
 
 	// Reset X
 	x = BufferZone;
 
 	// Update dimensions
 	m_Size.Width = std::max(m_Size.Width, line_size.Width + BufferZone * 2);
 	m_Size.Height = std::max(m_Size.Height, y + BufferZone);
 
 	FirstLine = false;
 
 	// Now if we entered as from = i, then we want
 	//  i being one minus that, so that it will become
 	//  the same i in the next loop. The difference is that
 	//  we're on a new line now.
 	i = from - 1;
 
 	return done;
 }
 
 // Decide width of the line. We need to iterate our floating images.
 //  this won't be exact because we're assuming the line_size.cy
 //  will be as our preliminary calculation said. But that may change,
 //  although we'd have to add a couple of more loops to try straightening
 //  this problem out, and it is very unlikely to happen noticeably if one
 //  structures his text in a stylistically pure fashion. Even if not, it
 //  is still quite unlikely it will happen.
 // Loop through left and right side, from and to.
 void CGUIText::ComputeLineRange(
 	const SGenerateTextImages& Images,
 	const float y,
 	const float Width,
 	const float prelim_line_height,
 	float& width_range_from,
 	float& width_range_to) const
 {
 	// Floating images are only applicable if word-wrapping is enabled.
 	if (Width == 0)
 		return;
 
 	for (int j = 0; j < 2; ++j)
 		for (const SGenerateTextImage& img : Images[j])
 		{
 			// We're working with two intervals here, the image's and the line height's.
 			//  let's find the union of these two.
 			float union_from, union_to;
 
 			union_from = std::max(y, img.m_YFrom);
 			union_to = std::min(y + prelim_line_height, img.m_YTo);
 
 			// The union is not empty
 			if (union_to > union_from)
 			{
 				if (j == 0)
 					width_range_from = std::max(width_range_from, img.m_Indentation);
 				else
 					width_range_to = std::min(width_range_to, Width - img.m_Indentation);
 			}
 		}
 }
 
 // compute offset based on what kind of alignment
 float CGUIText::GetLineOffset(
 	const EAlign align,
 	const float width_range_from,
 	const float width_range_to,
 	const CSize2D& line_size) const
 {
 	switch (align)
 	{
 	case EAlign::LEFT:
 		// don't add an offset
 		return 0.f;
 
 	case EAlign::CENTER:
 		return ((width_range_to - width_range_from) - line_size.Width) / 2;
 
 	case EAlign::RIGHT:
 		return width_range_to - line_size.Width;
 
 	default:
 		debug_warn(L"Broken EAlign in CGUIText()");
 		return 0.f;
 	}
 }
 
 bool CGUIText::AssembleCalls(
 	const CGUI& pGUI,
 	const CGUIString& string,
 	const CStrIntern& Font,
 	const IGUIObject* pObject,
 	const bool FirstLine,
 	const float Width,
 	const float width_range_to,
 	const float dx,
 	const float y,
 	const int temp_from,
 	const int i,
 	float& x,
 	int& from)
 {
 	bool done = false;
 
 	for (int j = temp_from; j <= i; ++j)
 	{
 		// We don't want to use Feedback now, so we'll have to use another one.
 		CGUIString::SFeedback Feedback2;
 
 		// Defaults
 		string.GenerateTextCall(pGUI, Feedback2, Font, string.m_Words[j], string.m_Words[j+1], FirstLine, pObject);
 
 		// Iterate all and set X/Y values
 		// Since X values are not set, we need to make an internal
 		//  iteration with an increment that will append the internal
 		//  x, that is what x_pointer is for.
 		float x_pointer = 0.f;
 
 		for (STextCall& tc : Feedback2.m_TextCalls)
 		{
 			tc.m_Pos = CVector2D(dx + x + x_pointer, y);
 
 			x_pointer += tc.m_Size.Width;
 
 			if (tc.m_pSpriteCall)
 				tc.m_pSpriteCall->m_Area += tc.m_Pos - CSize2D(0, tc.m_pSpriteCall->m_Area.GetHeight());
 		}
 
 		// Append X value.
 		x += Feedback2.m_Size.Width;
 
 		// The first word overrides the width limit, what we
 		//  do, in those cases, are just drawing that word even
 		//  though it'll extend the object.
 		if (Width != 0) // only if word-wrapping is applicable
 		{
 			if (Feedback2.m_NewLine)
 			{
 				from = j + 1;
 
 				// Sprite call can exist within only a newline segment,
 				//  therefore we need this.
 				if (!Feedback2.m_SpriteCalls.empty())
 				{
 					auto newEnd = std::remove_if(Feedback2.m_TextCalls.begin(), Feedback2.m_TextCalls.end(), [](const STextCall& call) { return !call.m_pSpriteCall; });
 					m_TextCalls.insert(
 						m_TextCalls.end(),
 						std::make_move_iterator(Feedback2.m_TextCalls.begin()),
 						std::make_move_iterator(newEnd));
 					m_SpriteCalls.insert(
 						m_SpriteCalls.end(),
 						std::make_move_iterator(Feedback2.m_SpriteCalls.begin()),
 						std::make_move_iterator(Feedback2.m_SpriteCalls.end()));
 				}
 				break;
 			}
 			else if (x > width_range_to && j == temp_from)
 			{
 				from = j+1;
 				// do not break, since we want it to be added to m_TextCalls
 			}
 			else if (x > width_range_to)
 			{
 				from = j;
 				break;
 			}
 		}
 
 		// Add the whole Feedback2.m_TextCalls to our m_TextCalls.
 		m_TextCalls.insert(
 			m_TextCalls.end(),
 			std::make_move_iterator(Feedback2.m_TextCalls.begin()),
 			std::make_move_iterator(Feedback2.m_TextCalls.end()));
 
 		m_SpriteCalls.insert(
 			m_SpriteCalls.end(),
 			std::make_move_iterator(Feedback2.m_SpriteCalls.begin()),
 			std::make_move_iterator(Feedback2.m_SpriteCalls.end()));
 
 		if (j == static_cast<int>(string.m_Words.size()) - 2)
 			done = true;
 	}
 
 	return done;
 }
 
 void CGUIText::Draw(CGUI& pGUI, const CGUIColor& DefaultColor, const CVector2D& pos, const float z, const CRect& clipping) const
 {
 	CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_gui_text);
 
 	tech->BeginPass();
 
 	bool isClipped = clipping != CRect();
 	if (isClipped)
 	{
 		glEnable(GL_SCISSOR_TEST);
 		glScissor(
 			clipping.left * g_GuiScale,
 			g_yres - clipping.bottom * g_GuiScale,
 			clipping.GetWidth() * g_GuiScale,
 			clipping.GetHeight() * g_GuiScale);
 	}
 
 	CTextRenderer textRenderer(tech->GetShader());
 	textRenderer.SetClippingRect(clipping);
 	textRenderer.Translate(0.0f, 0.0f, z);
 
 	for (const STextCall& tc : m_TextCalls)
 	{
 		// If this is just a placeholder for a sprite call, continue
 		if (tc.m_pSpriteCall)
 			continue;
 
 		textRenderer.Color(tc.m_UseCustomColor ? tc.m_Color : DefaultColor);
 		textRenderer.Font(tc.m_Font);
 		textRenderer.Put(floorf(pos.X + tc.m_Pos.X), floorf(pos.Y + tc.m_Pos.Y), &tc.m_String);
 	}
 
 	textRenderer.Render();
 
 	for (const SSpriteCall& sc : m_SpriteCalls)
 		pGUI.DrawSprite(sc.m_Sprite, z, sc.m_Area + pos);
 
 	if (isClipped)
 		glDisable(GL_SCISSOR_TEST);
 
 	tech->EndPass();
 }
Index: ps/trunk/source/gui/CGUIText.h
===================================================================
--- ps/trunk/source/gui/CGUIText.h	(revision 25391)
+++ ps/trunk/source/gui/CGUIText.h	(revision 25392)
@@ -1,280 +1,281 @@
 /* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef INCLUDED_GUITEXT
 #define INCLUDED_GUITEXT
 
 #include "gui/CGUISprite.h"
 #include "gui/SettingTypes/CGUIColor.h"
 #include "gui/SettingTypes/EAlign.h"
 #include "maths/Rect.h"
 #include "maths/Size2D.h"
 #include "maths/Vector2D.h"
 #include "ps/CStrIntern.h"
 
 #include <array>
 #include <list>
 #include <vector>
 
 class CGUI;
 class CGUIString;
 class IGUIObject;
 struct SGenerateTextImage;
 
 using SGenerateTextImages = std::array<std::vector<SGenerateTextImage>, 2>;
 
 /**
  * An CGUIText object is a parsed string, divided into
  * text-rendering components. Each component, being a
  * call to the Renderer. For instance, if you by tags
  * change the color, then the GUI will have to make
  * individual calls saying it want that color on the
  * text.
  *
  * For instance:
  * "Hello [b]there[/b] bunny!"
  *
  * That without word-wrapping would mean 3 components.
  * i.e. 3 calls to CRenderer. One drawing "Hello",
  * one drawing "there" in bold, and one drawing "bunny!".
  */
 class CGUIText
 {
 public:
 	/**
 	 * A sprite call to the CRenderer
 	 */
 	struct SSpriteCall
 	{
 		// The CGUISpriteInstance makes this uncopyable to avoid invalidating its draw cache
 		NONCOPYABLE(SSpriteCall);
 		MOVABLE(SSpriteCall);
 
 		SSpriteCall() {}
 
 		/**
 		 * Size and position of sprite
 		 */
 		CRect m_Area;
 
 		/**
 		 * Sprite from global GUI sprite database.
 		 */
 		CGUISpriteInstance m_Sprite;
 	};
 
 	/**
 	 * A text call to the CRenderer
 	 */
 	struct STextCall
 	{
 		NONCOPYABLE(STextCall);
 		MOVABLE(STextCall);
 
 		STextCall() :
 			m_UseCustomColor(false),
 			m_Bold(false), m_Italic(false), m_Underlined(false),
 			m_pSpriteCall(nullptr) {}
 
 		/**
 		 * Position
 		 */
 		CVector2D m_Pos;
 
 		/**
 		 * Size
 		 */
 		CSize2D m_Size;
 
 		/**
 		 * The string that is suppose to be rendered.
 		 */
 		CStrW m_String;
 
 		/**
 		 * Use custom color? If true then m_Color is used,
 		 * else the color inputted will be used.
 		 */
 		bool m_UseCustomColor;
 
 		/**
 		 * Color setup
 		 */
 		CGUIColor m_Color;
 
 		/**
 		 * Font name
 		 */
 		CStrIntern m_Font;
 
 		/**
 		 * Settings
 		 */
 		bool m_Bold, m_Italic, m_Underlined;
 
 		/**
 		 * Tooltip text
 		 */
 		CStrW m_Tooltip;
 
 		/**
 		 * *IF* an icon, then this is not nullptr.
 		 */
 		std::list<SSpriteCall>::pointer m_pSpriteCall;
 	};
 
 	// The SSpriteCall CGUISpriteInstance makes this uncopyable to avoid invalidating its draw cache.
 	// Also take advantage of exchanging the containers directly with move semantics.
 	NONCOPYABLE(CGUIText);
 	MOVABLE(CGUIText);
 
 	/**
 	 * Generates empty text.
 	 */
 	CGUIText() = default;
 
 	/**
 	 * Generate a CGUIText object from the inputted string.
 	 * The function will break down the string and its
 	 * tags to calculate exactly which rendering queries
 	 * will be sent to the Renderer. Also, horizontal alignment
 	 * is taken into acount in this method but NOT vertical alignment.
 	 *
 	 * @param Text Text to generate CGUIText object from
 	 * @param Font Default font, notice both Default color and default font
 	 *		  can be changed by tags.
 	 * @param Width Width, 0 if no word-wrapping.
 	 * @param BufferZone space between text and edge, and space between text and images.
+	 * @param Align Horizontal alignment (left / center / right).
 	 * @param pObject Optional parameter for error output. Used *only* if error parsing fails,
 	 *		  and we need to be able to output which object the error occurred in to aid the user.
 	 */
-	CGUIText(const CGUI& pGUI, const CGUIString& string, const CStrW& FontW, const float Width, const float BufferZone, const IGUIObject* pObject);
+	CGUIText(const CGUI& pGUI, const CGUIString& string, const CStrW& FontW, const float Width, const float BufferZone, const EAlign align, const IGUIObject* pObject);
 
 	/**
 	 * Draw this CGUIText object
 	 */
 	void Draw(CGUI& pGUI, const CGUIColor& DefaultColor, const CVector2D& pos, const float z, const CRect& clipping) const;
 
 	const CSize2D& GetSize() const { return m_Size; }
 
 	const std::list<SSpriteCall>& GetSpriteCalls() const { return m_SpriteCalls; }
 
 	const std::vector<STextCall>& GetTextCalls() const { return m_TextCalls; }
 
 	// Helper functions of the constructor
 	bool ProcessLine(
 		const CGUI& pGUI,
 		const CGUIString& string,
 		const CStrIntern& Font,
 		const IGUIObject* pObject,
 		const SGenerateTextImages& Images,
 		const EAlign align,
 		const float prelim_line_height,
 		const float Width,
 		const float BufferZone,
 		bool& FirstLine,
 		float& x,
 		float& y,
 		int& i,
 		int& from);
 
 	void SetupSpriteCalls(
 		const CGUI& pGUI,
 		const std::array<std::vector<CStr>, 2>& FeedbackImages,
 		const float y,
 		const float Width,
 		const float BufferZone,
 		const int i,
 		const int pos_last_img,
 		SGenerateTextImages& Images);
 
 	float GetLineOffset(
 		const EAlign align,
 		const float width_range_from,
 		const float width_range_to,
 		const CSize2D& line_size) const;
 
 	void ComputeLineRange(
 		const SGenerateTextImages& Images,
 		const float y,
 		const float Width,
 		const float prelim_line_height,
 		float& width_range_from,
 		float& width_range_to) const;
 
 	void ComputeLineSize(
 		const CGUI& pGUI,
 		const CGUIString& string,
 		const CStrIntern& Font,
 		const bool FirstLine,
 		const float Width,
 		const float width_range_to,
 		const int i,
 		const int temp_from,
 		float& x,
 		CSize2D& line_size) const;
 
 	bool AssembleCalls(
 		const CGUI& pGUI,
 		const CGUIString& string,
 		const CStrIntern& Font,
 		const IGUIObject* pObject,
 		const bool FirstLine,
 		const float Width,
 		const float width_range_to,
 		const float dx,
 		const float y,
 		const int temp_from,
 		const int i,
 		float& x,
 		int& from);
 
 	/**
 	 * List of TextCalls, for instance "Hello", "there!"
 	 */
 	std::vector<STextCall> m_TextCalls;
 
 	/**
 	 * List of sprites, or "icons" that should be rendered
 	 * along with the text.
 	 */
 	std::list<SSpriteCall> m_SpriteCalls; // list for consistent mem addresses
 										  // so that we can point to elements.
 	/**
 	 * Width and height of the whole output, used when setting up
 	 * scrollbars and such.
 	 */
 	CSize2D m_Size;
 };
 
 struct SGenerateTextImage
 {
 	// The image's starting location in Y
 	float m_YFrom;
 
 	// The image's end location in Y
 	float m_YTo;
 
 	// The image width in other words
 	float m_Indentation;
 
 	void SetupSpriteCall(
 		const bool Left, CGUIText::SSpriteCall& SpriteCall, const float width, const float y,
 		const CSize2D& Size, const CStr& TextureName, const float BufferZone);
 };
 
 #endif // INCLUDED_GUITEXT
Index: ps/trunk/source/gui/GUITooltip.cpp
===================================================================
--- ps/trunk/source/gui/GUITooltip.cpp	(revision 25391)
+++ ps/trunk/source/gui/GUITooltip.cpp	(revision 25392)
@@ -1,331 +1,319 @@
 /* Copyright (C) 2021 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 "GUITooltip.h"
 
 #include "gui/CGUI.h"
-#include "gui/ObjectBases/IGUIObject.h"
+#include "gui/ObjectTypes/CTooltip.h"
 #include "lib/timer.h"
 #include "ps/CLogger.h"
 
 /*
 	Tooltips:
 	When holding the mouse stationary over an object for some amount of time,
 	the tooltip is displayed. If the mouse moves off that object, the tooltip
 	disappears. If the mouse re-enters an object within a short time, the new
 	tooltip is displayed immediately. (This lets you run the mouse across a
 	series of buttons, without waiting ages for the text to pop up every time.)
 
 	See Visual Studio's toolbar buttons for an example.
 
 
 	Implemented as a state machine:
 
 	(where "*" lines are checked constantly, and "<" lines are handled
 	on entry to that state)
 
 	IN MOTION
 	* If the mouse stops, check whether it should have a tooltip and move to
 	  'STATIONARY, NO TOOLTIP' or 'STATIONARY, TOOLIP'
 	* If the mouse enters an object with a tooltip delay of 0, switch to 'SHOWING'
 
 	STATIONARY, NO TOOLTIP
 	* If the mouse moves, switch to 'IN MOTION'
 
 	STATIONARY, TOOLTIP
 	< Set target time = now + tooltip time
 	* If the mouse moves, switch to 'IN MOTION'
 	* If now > target time, switch to 'SHOWING'
 
 	SHOWING
 	< Start displaying the tooltip
 	* If the mouse leaves the object, check whether the new object has a tooltip
 	  and switch to 'SHOWING' or 'COOLING'
 
 	COOLING  (since I can't think of a better name)
 	< Stop displaying the tooltip
 	< Set target time = now + cooldown time
 	* If the mouse has moved and is over a tooltipped object, switch to 'SHOWING'
 	* If now > target time, switch to 'STATIONARY, NO TOOLTIP'
 */
 
 enum
 {
 	ST_IN_MOTION,
 	ST_STATIONARY_NO_TOOLTIP,
 	ST_STATIONARY_TOOLTIP,
 	ST_SHOWING,
 	ST_COOLING
 };
 
 GUITooltip::GUITooltip()
 : m_State(ST_IN_MOTION), m_PreviousObject(nullptr), m_PreviousTooltipName()
 {
 }
 
 const double CooldownTime = 0.25; // TODO: Don't hard-code this value
 
 bool GUITooltip::GetTooltip(IGUIObject* obj, CStr& style)
 {
 	if (!obj)
 		return false;
 
 	if (obj->GetTooltipText().empty())
 		return false;
 
 	style = obj->GetTooltipStyle();
 	if (style.empty())
 		style = "default";
 	return true;
 }
 
 void GUITooltip::ShowTooltip(IGUIObject* obj, const CVector2D& pos, const CStr& style, CGUI& pGUI)
 {
 	ENSURE(obj);
 
 	if (style.empty())
 		return;
 
-	// Must be a CTooltip*
-	IGUIObject* tooltipobj = pGUI.FindObjectByName("__tooltip_" + style);
+	// Objects in __tooltip_ are guaranteed to be CTooltip* by the engine.
+	CTooltip* tooltipobj = static_cast<CTooltip*>(pGUI.FindObjectByName("__tooltip_" + style));
 	if (!tooltipobj || !tooltipobj->SettingExists("use_object"))
 	{
 		LOGERROR("Cannot find tooltip named '%s'", style.c_str());
 		return;
 	}
 
-	IGUIObject* usedobj; // object actually used to display the tooltip in
+	IGUIObject* usedobj; // object actually used to display the tooltip in.
 
-	const CStr& usedObjectName = tooltipobj->GetSetting<CStr>("use_object");
+	const CStr& usedObjectName = tooltipobj->GetUsedObject();
 	if (usedObjectName.empty())
 	{
 		usedobj = tooltipobj;
-
-		if (usedobj->SettingExists("_mousepos"))
-		{
-			usedobj->SetSetting<CVector2D>("_mousepos", pos, true);
-		}
-		else
-		{
-			LOGERROR("Object '%s' used by tooltip '%s' isn't a tooltip object!", usedObjectName.c_str(), style.c_str());
-			return;
-		}
+		tooltipobj->SetMousePos(pos);
 	}
 	else
 	{
 		usedobj = pGUI.FindObjectByName(usedObjectName);
 		if (!usedobj)
 		{
 			LOGERROR("Cannot find object named '%s' used by tooltip '%s'", usedObjectName.c_str(), style.c_str());
 			return;
 		}
 	}
 
 	if (usedobj->SettingExists("caption"))
 	{
 		const CStrW& text = obj->GetTooltipText();
 		usedobj->SetSettingFromString("caption", text, true);
 	}
 	else
 	{
 		LOGERROR("Object '%s' used by tooltip '%s' must have a caption setting!", usedobj->GetPresentableName().c_str(), style.c_str());
 		return;
 	}
 
-	// Every IGUIObject has a "hidden" setting
-	usedobj->SetSetting<bool>("hidden", false, true);
+	usedobj->SetHidden(false);
 }
 
 void GUITooltip::HideTooltip(const CStr& style, CGUI& pGUI)
 {
 	if (style.empty())
 		return;
 
-	// Must be a CTooltip*
-	IGUIObject* tooltipobj = pGUI.FindObjectByName("__tooltip_" + style);
+	// Objects in __tooltip_ are guaranteed to be CTooltip* by the engine.
+	CTooltip* tooltipobj = static_cast<CTooltip*>(pGUI.FindObjectByName("__tooltip_" + style));
 	if (!tooltipobj || !tooltipobj->SettingExists("use_object") || !tooltipobj->SettingExists("hide_object"))
 	{
 		LOGERROR("Cannot find tooltip named '%s' or it is not a tooltip", style.c_str());
 		return;
 	}
-
-	const CStr& usedObjectName = tooltipobj->GetSetting<CStr>("use_object");
+	const CStr& usedObjectName = tooltipobj->GetUsedObject();
 	if (!usedObjectName.empty())
 	{
 		IGUIObject* usedobj = pGUI.FindObjectByName(usedObjectName);
 		if (usedobj && usedobj->SettingExists("caption"))
 		{
 			usedobj->SetSettingFromString("caption", L"", true);
 		}
 		else
 		{
 			LOGERROR("Object named '%s' used by tooltip '%s' does not exist or does not have a caption setting!", usedObjectName.c_str(), style.c_str());
 			return;
 		}
 
-		if (tooltipobj->GetSetting<bool>("hide_object"))
-			// Every IGUIObject has a "hidden" setting
-			usedobj->SetSetting<bool>("hidden", true, true);
+		if (tooltipobj->ShouldHideObject())
+			usedobj->SetHidden(true);
 	}
 	else
-		tooltipobj->SetSetting<bool>("hidden", true, true);
+		tooltipobj->SetHidden(true);
 }
 
 static i32 GetTooltipDelay(const CStr& style, CGUI& pGUI)
 {
-	// Must be a CTooltip*
-	IGUIObject* tooltipobj = pGUI.FindObjectByName("__tooltip_" + style);
+	// Objects in __tooltip_ are guaranteed to be CTooltip* by the engine.
+	CTooltip* tooltipobj = static_cast<CTooltip*>(pGUI.FindObjectByName("__tooltip_" + style));
 
 	if (!tooltipobj)
 	{
 		LOGERROR("Cannot find tooltip object named '%s'", style.c_str());
 		return 500;
 	}
 
-	return tooltipobj->GetSetting<i32>("delay");
+	return tooltipobj->GetTooltipDelay();
 }
 
 void GUITooltip::Update(IGUIObject* Nearest, const CVector2D& MousePos, CGUI& GUI)
 {
 	// Called once per frame, so efficiency isn't vital
 	double now = timer_Time();
 
 	CStr style;
 	int nextstate = -1;
 
 	switch (m_State)
 	{
 	case ST_IN_MOTION:
 		if (MousePos == m_PreviousMousePos)
 		{
 			if (GetTooltip(Nearest, style))
 				nextstate = ST_STATIONARY_TOOLTIP;
 			else
 				nextstate = ST_STATIONARY_NO_TOOLTIP;
 		}
 		else
 		{
 			// Check for movement onto a zero-delayed tooltip
 			if (GetTooltip(Nearest, style) && GetTooltipDelay(style, GUI)==0)
 			{
 				// Reset any previous tooltips completely
 				//m_Time = now + (double)GetTooltipDelay(style, GUI) / 1000.;
 				HideTooltip(m_PreviousTooltipName, GUI);
 
 				nextstate = ST_SHOWING;
 			}
 		}
 		break;
 
 	case ST_STATIONARY_NO_TOOLTIP:
 		if (MousePos != m_PreviousMousePos)
 			nextstate = ST_IN_MOTION;
 		break;
 
 	case ST_STATIONARY_TOOLTIP:
 		if (MousePos != m_PreviousMousePos)
 			nextstate = ST_IN_MOTION;
 		else if (now >= m_Time)
 		{
 			// Make sure the tooltip still exists
 			if (GetTooltip(Nearest, style))
 				nextstate = ST_SHOWING;
 			else
 			{
 				// Failed to retrieve style - the object has probably been
 				// altered, so just restart the process
 				nextstate = ST_IN_MOTION;
 			}
 		}
 		break;
 
 	case ST_SHOWING:
 		// Handle sub-object tooltips.
 		if (Nearest == m_PreviousObject)
 		{
 			// Still showing the same object's tooltip, but the text might have changed
 			if (GetTooltip(Nearest, style))
 				ShowTooltip(Nearest, MousePos, style, GUI);
 			else
 				nextstate = ST_COOLING;
 		}
 		else
 		{
 			// Mouse moved onto a new object
 			if (GetTooltip(Nearest, style))
 			{
 				CStr style_old;
 
 				// If we're displaying a tooltip with no delay, then we want to
 				//  reset so that other object that should have delay can't
 				//  "ride this tail", it have to wait.
 				// Notice that this doesn't apply to when you go from one delay=0
 				//  to another delay=0
 				if (GetTooltip(m_PreviousObject, style_old) && GetTooltipDelay(style_old, GUI) == 0 &&
 					GetTooltipDelay(style, GUI) != 0)
 				{
 					HideTooltip(m_PreviousTooltipName, GUI);
 					nextstate = ST_IN_MOTION;
 				}
 				else
 				{
 					// Hide old scrollbar
 					HideTooltip(m_PreviousTooltipName, GUI);
 					nextstate = ST_SHOWING;
 				}
 			}
 			else
 				nextstate = ST_COOLING;
 		}
 		break;
 
 	case ST_COOLING:
 		if (GetTooltip(Nearest, style))
 			nextstate = ST_SHOWING;
 		else if (now >= m_Time)
 			nextstate = ST_IN_MOTION;
 		break;
 	}
 
 	// Handle state-entry code:
 	if (nextstate != -1)
 	{
 		switch (nextstate)
 		{
 		case ST_STATIONARY_TOOLTIP:
 			m_Time = now + (double)GetTooltipDelay(style, GUI) / 1000.;
 			break;
 
 		case ST_SHOWING:
 			ShowTooltip(Nearest, MousePos, style, GUI);
 			m_PreviousTooltipName = style;
 			break;
 
 		case ST_COOLING:
 			HideTooltip(m_PreviousTooltipName, GUI);
 			m_Time = now + CooldownTime;
 			break;
 		}
 
 		m_State = nextstate;
 	}
 
 	m_PreviousMousePos = MousePos;
 	m_PreviousObject = Nearest;
 }
Index: ps/trunk/source/gui/ObjectBases/IGUIButtonBehavior.cpp
===================================================================
--- ps/trunk/source/gui/ObjectBases/IGUIButtonBehavior.cpp	(revision 25391)
+++ ps/trunk/source/gui/ObjectBases/IGUIButtonBehavior.cpp	(revision 25392)
@@ -1,156 +1,151 @@
 /* Copyright (C) 2021 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 "IGUIButtonBehavior.h"
 
 #include "gui/CGUISprite.h"
 
 const CStr IGUIButtonBehavior::EventNamePress = "Press";
 const CStr IGUIButtonBehavior::EventNamePressRight = "PressRight";
 const CStr IGUIButtonBehavior::EventNamePressRightDisabled = "PressRightDisabled";
 const CStr IGUIButtonBehavior::EventNameDoublePress = "DoublePress";
 const CStr IGUIButtonBehavior::EventNameDoublePressRight = "DoublePressRight";
 const CStr IGUIButtonBehavior::EventNameRelease = "Release";
 const CStr IGUIButtonBehavior::EventNameReleaseRight = "ReleaseRight";
 
 IGUIButtonBehavior::IGUIButtonBehavior(IGUIObject& pObject)
 	: m_pObject(pObject),
 	  m_Pressed(),
 	  m_PressedRight(),
-	  m_SoundDisabled(),
-	  m_SoundEnter(),
-	  m_SoundLeave(),
-	  m_SoundPressed(),
-	  m_SoundReleased()
+	  m_SoundDisabled(&pObject, "sound_disabled"),
+	  m_SoundEnter(&pObject, "sound_enter"),
+	  m_SoundLeave(&pObject, "sound_leave"),
+	  m_SoundPressed(&pObject, "sound_pressed"),
+	  m_SoundReleased(&pObject, "sound_released")
 {
-	m_pObject.RegisterSetting("sound_disabled", m_SoundDisabled);
-	m_pObject.RegisterSetting("sound_enter", m_SoundEnter);
-	m_pObject.RegisterSetting("sound_leave", m_SoundLeave);
-	m_pObject.RegisterSetting("sound_pressed", m_SoundPressed);
-	m_pObject.RegisterSetting("sound_released", m_SoundReleased);
 }
 
 IGUIButtonBehavior::~IGUIButtonBehavior()
 {
 }
 
 void IGUIButtonBehavior::ResetStates()
 {
 	if (m_Pressed)
 	{
 		m_Pressed = false;
 		m_pObject.PlaySound(m_SoundReleased);
 		m_pObject.SendEvent(GUIM_PRESSED_MOUSE_RELEASE, EventNameRelease);
 	}
 
 	if (m_PressedRight)
 	{
 		m_PressedRight = false;
 		m_pObject.PlaySound(m_SoundReleased);
 		m_pObject.SendEvent(GUIM_PRESSED_MOUSE_RELEASE_RIGHT, EventNameReleaseRight);
 	}
 }
 
 void IGUIButtonBehavior::HandleMessage(SGUIMessage& Message)
 {
 	// TODO Gee: easier access functions
 	switch (Message.type)
 	{
 	case GUIM_MOUSE_ENTER:
 		if (m_pObject.IsEnabled())
 			m_pObject.PlaySound(m_SoundEnter);
 		break;
 
 	case GUIM_MOUSE_LEAVE:
 		if (m_pObject.IsEnabled())
 			m_pObject.PlaySound(m_SoundLeave);
 		break;
 
 	case GUIM_MOUSE_DBLCLICK_LEFT:
 		if (!m_pObject.IsEnabled())
 			break;
 
 		// Since GUIM_MOUSE_PRESS_LEFT also gets called twice in a
 		// doubleclick event, we let it handle playing sounds.
 		m_pObject.SendEvent(GUIM_DOUBLE_PRESSED, EventNameDoublePress);
 		break;
 
 	case GUIM_MOUSE_PRESS_LEFT:
 		if (!m_pObject.IsEnabled())
 		{
 			m_pObject.PlaySound(m_SoundDisabled);
 			break;
 		}
 
 		m_pObject.PlaySound(m_SoundPressed);
 		m_pObject.SendEvent(GUIM_PRESSED, EventNamePress);
 		m_Pressed = true;
 		break;
 
 	case GUIM_MOUSE_DBLCLICK_RIGHT:
 		if (!m_pObject.IsEnabled())
 			break;
 
 		// Since GUIM_MOUSE_PRESS_RIGHT also gets called twice in a
 		// doubleclick event, we let it handle playing sounds.
 		m_pObject.SendEvent(GUIM_DOUBLE_PRESSED_MOUSE_RIGHT, EventNameDoublePressRight);
 		break;
 
 	case GUIM_MOUSE_PRESS_RIGHT:
 		if (!m_pObject.IsEnabled())
 		{
 			m_pObject.SendEvent(GUIM_PRESSED_MOUSE_RIGHT_DISABLED, EventNamePressRightDisabled);
 			m_pObject.PlaySound(m_SoundDisabled);
 			break;
 		}
 
 		// Button was right-clicked
 		m_pObject.PlaySound(m_SoundPressed);
 		m_pObject.SendEvent(GUIM_PRESSED_MOUSE_RIGHT, EventNamePressRight);
 		m_PressedRight = true;
 		break;
 
 	case GUIM_MOUSE_RELEASE_RIGHT:
 		if (m_pObject.IsEnabled())
 			ResetStates();
 		break;
 
 	case GUIM_MOUSE_RELEASE_LEFT:
 		if (m_pObject.IsEnabled())
 			ResetStates();
 		break;
 
 	default:
 		break;
 	}
 }
 
 const CGUISpriteInstance& IGUIButtonBehavior::GetButtonSprite(const CGUISpriteInstance& sprite, const CGUISpriteInstance& sprite_over, const CGUISpriteInstance& sprite_pressed, const CGUISpriteInstance& sprite_disabled) const
 {
 	if (!m_pObject.IsEnabled())
 		return sprite_disabled ? sprite_disabled : sprite;
 
 	if (!m_pObject.IsMouseHovering())
 		return sprite;
 
 	if (m_Pressed)
 		return sprite_pressed ? sprite_pressed : sprite;
 
 	return sprite_over ? sprite_over : sprite;
 }
Index: ps/trunk/source/gui/ObjectBases/IGUIButtonBehavior.h
===================================================================
--- ps/trunk/source/gui/ObjectBases/IGUIButtonBehavior.h	(revision 25391)
+++ ps/trunk/source/gui/ObjectBases/IGUIButtonBehavior.h	(revision 25392)
@@ -1,102 +1,101 @@
-/* Copyright (C) 2020 Wildfire Games.
+/* Copyright (C) 2021 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/>.
  */
 
 /*
 	Interface class that enhance the IGUIObject with
 	 buttony behavior (click and release to click a button),
 	 and the GUI message GUIM_PRESSED.
 	When creating a class with extended settings and
 	 buttony behavior, just do a multiple inheritance.
 */
 
 #ifndef INCLUDED_IGUIBUTTONBEHAVIOR
 #define INCLUDED_IGUIBUTTONBEHAVIOR
 
 #include "gui/ObjectBases/IGUIObject.h"
 #include "ps/CStr.h"
 
 class CGUISpriteInstance;
 
 /**
  * Appends button behaviours to the IGUIObject.
  * Can be used with multiple inheritance alongside
  * IGUISettingsObject and such.
  */
 class IGUIButtonBehavior
 {
 	NONCOPYABLE(IGUIButtonBehavior);
 
 public:
 	IGUIButtonBehavior(IGUIObject& pObject);
 	virtual ~IGUIButtonBehavior();
 
 	/**
 	 * @see IGUIObject#HandleMessage()
 	 */
 	virtual void HandleMessage(SGUIMessage& Message);
 
 	/**
 	 * This is a function that lets a button being drawn,
 	 * it regards if it's over, disabled, pressed and such.
 	 *
 	 * @param sprite Sprite drawn when not pressed, hovered or disabled
 	 * @param sprite_over Sprite drawn when m_MouseHovering is true
 	 * @param sprite_pressed Sprite drawn when m_Pressed is true
 	 * @param sprite_disabled Sprite drawn when "enabled" is false
 	 */
 	const CGUISpriteInstance& GetButtonSprite(const CGUISpriteInstance& sprite, const CGUISpriteInstance& sprite_over, const CGUISpriteInstance& sprite_pressed, const CGUISpriteInstance& sprite_disabled) const;
 
 protected:
 	static const CStr EventNamePress;
 	static const CStr EventNamePressRight;
 	static const CStr EventNamePressRightDisabled;
 	static const CStr EventNameDoublePress;
 	static const CStr EventNameDoublePressRight;
 	static const CStr EventNameRelease;
 	static const CStr EventNameReleaseRight;
 
 	/**
 	 * @see IGUIObject#ResetStates()
 	 */
 	virtual void ResetStates();
 
 	/**
 	 * Everybody knows how a button works, you don't simply press it,
 	 * you have to first press the button, and then release it...
 	 * in between those two steps you can actually leave the button
 	 * area, as long as you release it within the button area... Anyway
 	 * this lets us know we are done with step one (clicking).
 	 */
 	bool m_Pressed;
 	bool m_PressedRight;
 
-	// Settings
-	CStrW m_SoundDisabled;
-	CStrW m_SoundEnter;
-	CStrW m_SoundLeave;
-	CStrW m_SoundPressed;
-	CStrW m_SoundReleased;
+	CGUISimpleSetting<CStrW> m_SoundDisabled;
+	CGUISimpleSetting<CStrW> m_SoundEnter;
+	CGUISimpleSetting<CStrW> m_SoundLeave;
+	CGUISimpleSetting<CStrW> m_SoundPressed;
+	CGUISimpleSetting<CStrW> m_SoundReleased;
 
 private:
 	/**
 	 * Reference to the IGUIObject.
 	 * Private, because we don't want to inherit it in multiple classes.
 	 */
 	IGUIObject& m_pObject;
 };
 
 #endif // INCLUDED_IGUIBUTTONBEHAVIOR
Index: ps/trunk/source/gui/ObjectBases/IGUIObject.cpp
===================================================================
--- ps/trunk/source/gui/ObjectBases/IGUIObject.cpp	(revision 25391)
+++ ps/trunk/source/gui/ObjectBases/IGUIObject.cpp	(revision 25392)
@@ -1,570 +1,500 @@
 /* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "IGUIObject.h"
 
 #include "gui/CGUI.h"
 #include "gui/CGUISetting.h"
 #include "gui/Scripting/JSInterface_GUIProxy.h"
 #include "js/Conversions.h"
 #include "ps/CLogger.h"
 #include "ps/GameSetup/Config.h"
 #include "ps/Profile.h"
 #include "scriptinterface/ScriptContext.h"
 #include "scriptinterface/ScriptExtraHeaders.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "soundmanager/ISoundManager.h"
 
 #include <algorithm>
 #include <unordered_map>
 
 const CStr IGUIObject::EventNameMouseEnter = "MouseEnter";
 const CStr IGUIObject::EventNameMouseMove = "MouseMove";
 const CStr IGUIObject::EventNameMouseLeave = "MouseLeave";
 
 IGUIObject::IGUIObject(CGUI& pGUI)
 	: m_pGUI(pGUI),
 	  m_pParent(),
 	  m_MouseHovering(),
 	  m_LastClickTime(),
-	  m_Enabled(),
-	  m_Hidden(),
-	  m_Size(),
-	  m_Style(),
-	  m_Hotkey(),
-	  m_Z(),
-	  m_Absolute(),
-	  m_Ghost(),
-	  m_AspectRatio(),
-	  m_Tooltip(),
-	  m_TooltipStyle()
-{
-	RegisterSetting("enabled", m_Enabled);
-	RegisterSetting("hidden", m_Hidden);
-	RegisterSetting("size", m_Size);
-	RegisterSetting("style", m_Style);
-	RegisterSetting("hotkey", m_Hotkey);
-	RegisterSetting("z", m_Z);
-	RegisterSetting("absolute", m_Absolute);
-	RegisterSetting("ghost", m_Ghost);
-	RegisterSetting("aspectratio", m_AspectRatio);
-	RegisterSetting("tooltip", m_Tooltip);
-	RegisterSetting("tooltip_style", m_TooltipStyle);
-
-	// Setup important defaults
-	// TODO: Should be in the default style?
-	SetSetting<bool>("hidden", false, true);
-	SetSetting<bool>("ghost", false, true);
-	SetSetting<bool>("enabled", true, true);
-	SetSetting<bool>("absolute", true, true);
+	  m_Enabled(this, "enabled", true),
+	  m_Hidden(this, "hidden", false),
+	  m_Size(this, "size"),
+	  m_Style(this, "style"),
+	  m_Hotkey(this, "hotkey"),
+	  m_Z(this, "z"),
+	  m_Absolute(this, "absolute", true),
+	  m_Ghost(this, "ghost", false),
+	  m_AspectRatio(this, "aspectratio"),
+	  m_Tooltip(this, "tooltip"),
+	  m_TooltipStyle(this, "tooltip_style")
+{
 }
 
 IGUIObject::~IGUIObject()
 {
-	for (const std::pair<const CStr, IGUISetting*>& p : m_Settings)
-		delete p.second;
-
 	if (!m_ScriptHandlers.empty())
 		JS_RemoveExtraGCRootsTracer(m_pGUI.GetScriptInterface()->GetGeneralJSContext(), Trace, this);
 
 	// m_Children is deleted along all other GUI Objects in the CGUI destructor
 }
 
 void IGUIObject::RegisterChild(IGUIObject* child)
 {
 	child->SetParent(this);
 	m_Children.push_back(child);
 }
 
 void IGUIObject::UnregisterChild(IGUIObject* child)
 {
 	std::vector<IGUIObject*>::iterator it = std::find(m_Children.begin(), m_Children.end(), child);
 	if (it != m_Children.end())
 	{
 		(*it)->m_pParent = nullptr;
 		m_Children.erase(it);
 	}
 }
 
-template<typename T>
-void IGUIObject::RegisterSetting(const CStr& Name, T& Value)
+void IGUIObject::RegisterSetting(const CStr& Name, IGUISetting* setting)
 {
 	if (SettingExists(Name))
 		LOGERROR("The setting '%s' already exists on the object '%s'!", Name.c_str(), GetPresentableName().c_str());
 	else
-		m_Settings.emplace(Name, new CGUISetting<T>(*this, Name, Value));
-}
-
-bool IGUIObject::SettingExists(const CStr& Setting) const
-{
-	return m_Settings.find(Setting) != m_Settings.end();
+		m_Settings.emplace(Name, setting);
 }
 
-template <typename T>
-T& IGUIObject::GetSetting(const CStr& Setting)
+void IGUIObject::ReregisterSetting(const CStr& Name, IGUISetting* setting)
 {
-	return static_cast<CGUISetting<T>* >(m_Settings.at(Setting))->m_pSetting;
+	if (!SettingExists(Name))
+		LOGERROR("The setting '%s' must already exist on the object '%s'!", Name.c_str(), GetPresentableName().c_str());
+	else
+		m_Settings.at(Name) = setting;
 }
 
-template <typename T>
-const T& IGUIObject::GetSetting(const CStr& Setting) const
+bool IGUIObject::SettingExists(const CStr& Setting) const
 {
-	return static_cast<CGUISetting<T>* >(m_Settings.at(Setting))->m_pSetting;
+	return m_Settings.find(Setting) != m_Settings.end();
 }
 
 bool IGUIObject::SetSettingFromString(const CStr& Setting, const CStrW& Value, const bool SendMessage)
 {
 	const std::map<CStr, IGUISetting*>::iterator it = m_Settings.find(Setting);
 	if (it == m_Settings.end())
 	{
 		LOGERROR("GUI object '%s' has no property called '%s', can't set parse and set value '%s'", GetPresentableName().c_str(), Setting.c_str(), Value.ToUTF8().c_str());
 		return false;
 	}
 	return it->second->FromString(Value, SendMessage);
 }
 
-template <typename T>
-void IGUIObject::SetSetting(const CStr& Setting, T& Value, const bool SendMessage)
-{
-	PreSettingChange(Setting);
-	static_cast<CGUISetting<T>* >(m_Settings.at(Setting))->m_pSetting = std::move(Value);
-	SettingChanged(Setting, SendMessage);
-}
-
-template <typename T>
-void IGUIObject::SetSetting(const CStr& Setting, const T& Value, const bool SendMessage)
-{
-	PreSettingChange(Setting);
-	static_cast<CGUISetting<T>* >(m_Settings.at(Setting))->m_pSetting = Value;
-	SettingChanged(Setting, SendMessage);
-}
-
-void IGUIObject::PreSettingChange(const CStr& Setting)
-{
-	if (Setting == "hotkey")
-		m_pGUI.UnsetObjectHotkey(this, GetSetting<CStr>(Setting));
-}
-
 void IGUIObject::SettingChanged(const CStr& Setting, const bool SendMessage)
 {
 	if (Setting == "size")
 	{
 		// If setting was "size", we need to re-cache itself and all children
 		RecurseObject(nullptr, &IGUIObject::UpdateCachedSize);
 	}
 	else if (Setting == "hidden")
 	{
 		// Hiding an object requires us to reset it and all children
 		if (m_Hidden)
 			RecurseObject(nullptr, &IGUIObject::ResetStates);
 	}
-	else if (Setting == "hotkey")
-		m_pGUI.SetObjectHotkey(this, GetSetting<CStr>(Setting));
 	else if (Setting == "style")
-		m_pGUI.SetObjectStyle(this, GetSetting<CStr>(Setting));
+		m_pGUI.SetObjectStyle(this, m_Style);
 
 	if (SendMessage)
 	{
 		SGUIMessage msg(GUIM_SETTINGS_UPDATED, Setting);
 		HandleMessage(msg);
 	}
 }
 
 bool IGUIObject::IsMouseOver() const
 {
 	return m_CachedActualSize.PointInside(m_pGUI.GetMousePos());
 }
 
 void IGUIObject::UpdateMouseOver(IGUIObject* const& pMouseOver)
 {
 	if (pMouseOver == this)
 	{
 		if (!m_MouseHovering)
 			SendMouseEvent(GUIM_MOUSE_ENTER,EventNameMouseEnter);
 
 		m_MouseHovering = true;
 
 		SendMouseEvent(GUIM_MOUSE_OVER, EventNameMouseMove);
 	}
 	else
 	{
 		if (m_MouseHovering)
 		{
 			m_MouseHovering = false;
 			SendMouseEvent(GUIM_MOUSE_LEAVE, EventNameMouseLeave);
 		}
 	}
 }
 
 void IGUIObject::ChooseMouseOverAndClosest(IGUIObject*& pObject)
 {
 	if (!IsMouseOver())
 		return;
 
 	// Check if we've got competition at all
 	if (pObject == nullptr)
 	{
 		pObject = this;
 		return;
 	}
 
 	// Or if it's closer
 	if (GetBufferedZ() >= pObject->GetBufferedZ())
 	{
 		pObject = this;
 		return;
 	}
 }
 
 IGUIObject* IGUIObject::GetParent() const
 {
 	// Important, we're not using GetParent() for these
 	//  checks, that could screw it up
 	if (m_pParent && m_pParent->m_pParent == nullptr)
 		return nullptr;
 
 	return m_pParent;
 }
 
 void IGUIObject::ResetStates()
 {
 	// Notify the gui that we aren't hovered anymore
 	UpdateMouseOver(nullptr);
 }
 
 void IGUIObject::UpdateCachedSize()
 {
 	// If absolute="false" and the object has got a parent,
 	//  use its cached size instead of the screen. Notice
 	//  it must have just been cached for it to work.
 	if (!m_Absolute && m_pParent && !IsRootObject())
-		m_CachedActualSize = m_Size.GetSize(m_pParent->m_CachedActualSize);
+		m_CachedActualSize = m_Size->GetSize(m_pParent->m_CachedActualSize);
 	else
-		m_CachedActualSize = m_Size.GetSize(CRect(0.f, 0.f, g_xres / g_GuiScale, g_yres / g_GuiScale));
+		m_CachedActualSize = m_Size->GetSize(CRect(0.f, 0.f, g_xres / g_GuiScale, g_yres / g_GuiScale));
 
 	// In a few cases, GUI objects have to resize to fill the screen
 	// but maintain a constant aspect ratio.
 	// Adjust the size to be the max possible, centered in the original size:
 	if (m_AspectRatio)
 	{
 		if (m_CachedActualSize.GetWidth() > m_CachedActualSize.GetHeight() * m_AspectRatio)
 		{
 			float delta = m_CachedActualSize.GetWidth() - m_CachedActualSize.GetHeight() * m_AspectRatio;
 			m_CachedActualSize.left += delta/2.f;
 			m_CachedActualSize.right -= delta/2.f;
 		}
 		else
 		{
 			float delta = m_CachedActualSize.GetHeight() - m_CachedActualSize.GetWidth() / m_AspectRatio;
 			m_CachedActualSize.bottom -= delta/2.f;
 			m_CachedActualSize.top += delta/2.f;
 		}
 	}
 }
 
 CRect IGUIObject::GetComputedSize()
 {
 	UpdateCachedSize();
 	return m_CachedActualSize;
 }
 
 
 bool IGUIObject::ApplyStyle(const CStr& StyleName)
 {
 	if (!m_pGUI.HasStyle(StyleName))
 	{
 		LOGERROR("IGUIObject: Trying to use style '%s' that doesn't exist.", StyleName.c_str());
 		return false;
 	}
 
 	// The default style may specify settings for any GUI object.
 	// Other styles are reported if they specify a Setting that does not exist,
 	// so that the XML author is informed and can correct the style.
 
 	for (const std::pair<const CStr, CStrW>& p : m_pGUI.GetStyle(StyleName).m_SettingsDefaults)
 	{
 		if (SettingExists(p.first))
-			SetSettingFromString(p.first, p.second, true);
+			m_Settings.at(p.first)->FromString(p.second, true);
 		else if (StyleName != "default")
 			LOGWARNING("GUI object has no setting \"%s\", but the style \"%s\" defines it", p.first, StyleName.c_str());
 	}
 	return true;
 }
 
 float IGUIObject::GetBufferedZ() const
 {
 	if (m_Absolute)
 		return m_Z;
 
 	if (GetParent())
 		return GetParent()->GetBufferedZ() + m_Z;
 
 	// In philosophy, a parentless object shouldn't be able to have a relative sizing,
 	//  but we'll accept it so that absolute can be used as default without a complaint.
 	//  Also, you could consider those objects children to the screen resolution.
 	return m_Z;
 }
 
 void IGUIObject::RegisterScriptHandler(const CStr& eventName, const CStr& Code, CGUI& pGUI)
 {
 	ScriptRequest rq(pGUI.GetScriptInterface());
 
 	const int paramCount = 1;
 	const char* paramNames[paramCount] = { "mouse" };
 
 	// Location to report errors from
 	CStr CodeName = GetName() + " " + eventName;
 
 	// Generate a unique name
 	static int x = 0;
 	char buf[64];
 	sprintf_s(buf, ARRAY_SIZE(buf), "__eventhandler%d (%s)", x++, eventName.c_str());
 
 	// TODO: this is essentially the same code as ScriptInterface::LoadScript (with a tweak for the argument).
 	JS::CompileOptions options(rq.cx);
 	options.setFileAndLine(CodeName.c_str(), 0);
 	options.setIsRunOnce(false);
 
 	JS::SourceText<mozilla::Utf8Unit> src;
 	ENSURE(src.init(rq.cx, Code.c_str(), Code.length(), JS::SourceOwnership::Borrowed));
 	JS::RootedObjectVector emptyScopeChain(rq.cx);
 	JS::RootedFunction func(rq.cx, JS::CompileFunction(rq.cx, emptyScopeChain, options, buf, paramCount, paramNames, src));
 	if (func == nullptr)
 	{
 		LOGERROR("RegisterScriptHandler: Failed to compile the script for %s", eventName.c_str());
 		return;
 	}
 
 	JS::RootedObject funcObj(rq.cx, JS_GetFunctionObject(func));
 	SetScriptHandler(eventName, funcObj);
 }
 
 void IGUIObject::SetScriptHandler(const CStr& eventName, JS::HandleObject Function)
 {
 	if (m_ScriptHandlers.empty())
 		JS_AddExtraGCRootsTracer(m_pGUI.GetScriptInterface()->GetGeneralJSContext(), Trace, this);
 
 	m_ScriptHandlers[eventName] = JS::Heap<JSObject*>(Function);
 
 	if (std::find(m_pGUI.m_EventObjects[eventName].begin(), m_pGUI.m_EventObjects[eventName].end(), this) == m_pGUI.m_EventObjects[eventName].end())
 		m_pGUI.m_EventObjects[eventName].emplace_back(this);
 }
 
 void IGUIObject::UnsetScriptHandler(const CStr& eventName)
 {
 	std::map<CStr, JS::Heap<JSObject*> >::iterator it = m_ScriptHandlers.find(eventName);
 
 	if (it == m_ScriptHandlers.end())
 		return;
 
 	m_ScriptHandlers.erase(it);
 
 	if (m_ScriptHandlers.empty())
 		JS_RemoveExtraGCRootsTracer(m_pGUI.GetScriptInterface()->GetGeneralJSContext(), Trace, this);
 
 	std::unordered_map<CStr, std::vector<IGUIObject*>>::iterator it2 = m_pGUI.m_EventObjects.find(eventName);
 	if (it2 == m_pGUI.m_EventObjects.end())
 		return;
 
 	std::vector<IGUIObject*>& handlers = it2->second;
 	handlers.erase(std::remove(handlers.begin(), handlers.end(), this), handlers.end());
 
 	if (handlers.empty())
 		m_pGUI.m_EventObjects.erase(it2);
 }
 
 InReaction IGUIObject::SendEvent(EGUIMessageType type, const CStr& eventName)
 {
 	PROFILE2_EVENT("gui event");
 	PROFILE2_ATTR("type: %s", eventName.c_str());
 	PROFILE2_ATTR("object: %s", m_Name.c_str());
 
 	SGUIMessage msg(type);
 	HandleMessage(msg);
 
 	ScriptEvent(eventName);
 
 	return msg.skipped ? IN_PASS : IN_HANDLED;
 }
 
 InReaction IGUIObject::SendMouseEvent(EGUIMessageType type, const CStr& eventName)
 {
 	PROFILE2_EVENT("gui mouse event");
 	PROFILE2_ATTR("type: %s", eventName.c_str());
 	PROFILE2_ATTR("object: %s", m_Name.c_str());
 
 	SGUIMessage msg(type);
 	HandleMessage(msg);
 
 	ScriptRequest rq(m_pGUI.GetScriptInterface());
 
 	// Set up the 'mouse' parameter
 	JS::RootedValue mouse(rq.cx);
 
 	const CVector2D& mousePos = m_pGUI.GetMousePos();
 
 	ScriptInterface::CreateObject(
 		rq,
 		&mouse,
 		"x", mousePos.X,
 		"y", mousePos.Y,
 		"buttons", m_pGUI.GetMouseButtons());
 	JS::RootedValueVector paramData(rq.cx);
 	ignore_result(paramData.append(mouse));
 	ScriptEvent(eventName, paramData);
 
 	return msg.skipped ? IN_PASS : IN_HANDLED;
 }
 
 void IGUIObject::ScriptEvent(const CStr& eventName)
 {
 	ScriptEventWithReturn(eventName);
 }
 
 bool IGUIObject::ScriptEventWithReturn(const CStr& eventName)
 {
 	if (m_ScriptHandlers.find(eventName) == m_ScriptHandlers.end())
 		return false;
 
 	ScriptRequest rq(m_pGUI.GetScriptInterface());
 	JS::RootedValueVector paramData(rq.cx);
 	return ScriptEventWithReturn(eventName, paramData);
 }
 
 void IGUIObject::ScriptEvent(const CStr& eventName, const JS::HandleValueArray& paramData)
 {
 	ScriptEventWithReturn(eventName, paramData);
 }
 
 bool IGUIObject::ScriptEventWithReturn(const CStr& eventName, const JS::HandleValueArray& paramData)
 {
 	std::map<CStr, JS::Heap<JSObject*> >::iterator it = m_ScriptHandlers.find(eventName);
 	if (it == m_ScriptHandlers.end())
 		return false;
 
 	ScriptRequest rq(m_pGUI.GetScriptInterface());
 	JS::RootedObject obj(rq.cx, GetJSObject());
 	JS::RootedValue handlerVal(rq.cx, JS::ObjectValue(*it->second));
 	JS::RootedValue result(rq.cx);
 
 	if (!JS_CallFunctionValue(rq.cx, obj, handlerVal, paramData, &result))
 	{
 		LOGERROR("Errors executing script event \"%s\"", eventName.c_str());
 		ScriptException::CatchPending(rq);
 		return false;
 	}
 	return JS::ToBoolean(result);
 }
 
 JSObject* IGUIObject::GetJSObject()
 {
 	// Cache the object when somebody first asks for it, because otherwise
 	// we end up doing far too much object allocation.
 	if (!m_JSObject)
 		CreateJSObject();
 
 	return m_JSObject->Get();
 }
 
 bool IGUIObject::IsEnabled() const
 {
 	return m_Enabled;
 }
 
 bool IGUIObject::IsHidden() const
 {
 	return m_Hidden;
 }
 
 bool IGUIObject::IsHiddenOrGhost() const
 {
 	return m_Hidden || m_Ghost;
 }
 
 void IGUIObject::PlaySound(const CStrW& soundPath) const
 {
 	if (g_SoundManager && !soundPath.empty())
 		g_SoundManager->PlayAsUI(soundPath.c_str(), false);
 }
 
 CStr IGUIObject::GetPresentableName() const
 {
 	// __internal(), must be at least 13 letters to be able to be
 	//  an internal name
 	if (m_Name.length() <= 12)
 		return m_Name;
 
 	if (m_Name.substr(0, 10) == "__internal")
 		return CStr("[unnamed object]");
 	else
 		return m_Name;
 }
 
 void IGUIObject::SetFocus()
 {
 	m_pGUI.SetFocusedObject(this);
 }
 
 void IGUIObject::ReleaseFocus()
 {
 	m_pGUI.SetFocusedObject(nullptr);
 }
 
 bool IGUIObject::IsFocused() const
 {
 	return m_pGUI.GetFocusedObject() == this;
 }
 
 bool IGUIObject::IsBaseObject() const
 {
 	return this == m_pGUI.GetBaseObject();
 }
 
 bool IGUIObject::IsRootObject() const
 {
 	return m_pParent == m_pGUI.GetBaseObject();
 }
 
 void IGUIObject::TraceMember(JSTracer* trc)
 {
 	// Please ensure to adapt the Tracer enabling and disabling in accordance with the GC things traced!
 
 	for (std::pair<const CStr, JS::Heap<JSObject*>>& handler : m_ScriptHandlers)
 		JS::TraceEdge(trc, &handler.second, "IGUIObject::m_ScriptHandlers");
 }
-
-// Instantiate templated functions:
-// These functions avoid copies by working with a reference and move semantics.
-#define TYPE(T) \
-	template void IGUIObject::RegisterSetting<T>(const CStr& Name, T& Value); \
-	template T& IGUIObject::GetSetting<T>(const CStr& Setting); \
-	template const T& IGUIObject::GetSetting<T>(const CStr& Setting) const; \
-	template void IGUIObject::SetSetting<T>(const CStr& Setting, T& Value, const bool SendMessage); \
-
-#include "gui/GUISettingTypes.h"
-#undef TYPE
-
-// Copying functions - discouraged except for primitives.
-#define TYPE(T) \
-	template void IGUIObject::SetSetting<T>(const CStr& Setting, const T& Value, const bool SendMessage); \
-
-#define GUITYPE_IGNORE_NONCOPYABLE
-#include "gui/GUISettingTypes.h"
-#undef GUITYPE_IGNORE_NONCOPYABLE
-#undef TYPE
Index: ps/trunk/source/gui/ObjectBases/IGUIObject.h
===================================================================
--- ps/trunk/source/gui/ObjectBases/IGUIObject.h	(revision 25391)
+++ ps/trunk/source/gui/ObjectBases/IGUIObject.h	(revision 25392)
@@ -1,562 +1,538 @@
 /* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /*
  * The base class of an object.
  * All objects are derived from this class.
  * It's an abstract data type, so it can't be used per se.
  * Also contains a Dummy object which is used for completely blank objects.
  */
 
 #ifndef INCLUDED_IGUIOBJECT
 #define INCLUDED_IGUIOBJECT
 
+#include "gui/CGUISetting.h"
+#include "gui/SettingTypes/CGUIHotkey.h"
 #include "gui/SettingTypes/CGUISize.h"
 #include "gui/SGUIMessage.h"
 #include "lib/input.h" // just for IN_PASS
 #include "ps/XML/Xeromyces.h"
 #include "scriptinterface/ScriptTypes.h"
 
 #include <map>
 #include <vector>
 
 class CGUI;
 class IGUIObject;
 class IGUIProxyObject;
 class IGUISetting;
 
 template <typename T>
 class JSI_GUIProxy;
 
 #define GUI_OBJECT(obj) \
 public: \
 	static IGUIObject* ConstructObject(CGUI& pGUI) \
 		{ return new obj(pGUI); }
 
 /**
  * GUI object such as a button or an input-box.
  * Abstract data type !
  */
 class IGUIObject
 {
 	friend class CGUI;
 
+	// For triggering message update handlers.
+	friend class IGUISetting;
+
 	// Allow getProperty to access things like GetParent()
 	template <typename T>
 	friend class JSI_GUIProxy;
 
 public:
 	NONCOPYABLE(IGUIObject);
 
 	IGUIObject(CGUI& pGUI);
 	virtual ~IGUIObject();
 
 	/**
 	 * This function checks if the mouse is hovering the
 	 * rectangle that the base setting "size" makes.
 	 * Although it is virtual, so one could derive
 	 * an object from CButton, which changes only this
 	 * to checking the circle that "size" makes.
 	 *
 	 * This function also returns true if there is a different
 	 * GUI object shown on top of this one.
 	 */
 	virtual bool IsMouseOver() const;
 
 	/**
 	 * This function returns true if the mouse is hovering
 	 * over this GUI object and if this GUI object is the
 	 * topmost object in that screen location.
 	 * For example when hovering dropdown list items, the
 	 * buttons beneath the list won't return true here.
 	 */
 	virtual bool IsMouseHovering() const { return m_MouseHovering; }
 
 	//--------------------------------------------------------
 	/** @name Leaf Functions */
 	//--------------------------------------------------------
 	//@{
 
 	/// Get object name, name is unique
 	const CStr& GetName() const { return m_Name; }
 
 	/// Get object name
 	void SetName(const CStr& Name) { m_Name = Name; }
 
 	// Get Presentable name.
 	//  Will change all internally set names to something like "<unnamed object>"
 	CStr GetPresentableName() const;
 
 	/**
 	 * Return all child objects of the current object.
 	 */
 	const std::vector<IGUIObject*>& GetChildren() const { return m_Children; }
 
 	//@}
 	//--------------------------------------------------------
 	/** @name Settings Management */
 	//--------------------------------------------------------
 	//@{
 
 	/**
-	 * Registers the given setting variables with the GUI object.
+	 * Registers the given setting with the GUI object.
 	 * Enable XML and JS to modify the given variable.
-	 *
-	 * @param Type Setting type
-	 * @param Name Setting reference name
 	 */
-	template<typename T>
-	void RegisterSetting(const CStr& Name, T& Value);
+	void RegisterSetting(const CStr& Name, IGUISetting* setting);
+	void ReregisterSetting(const CStr& Name, IGUISetting* setting);
 
 	/**
 	 * Returns whether there is a setting with the given name registered.
 	 *
 	 * @param Setting setting name
 	 * @return True if settings exist.
 	 */
 	bool SettingExists(const CStr& Setting) const;
 
 	/**
-	 * Get a mutable reference to the setting.
-	 * If no such setting exists, an exception of type std::out_of_range is thrown.
-	 * If the value is modified, there is no GUIM_SETTINGS_UPDATED message sent.
-	 */
-	template <typename T>
-	T& GetSetting(const CStr& Setting);
-
-	template <typename T>
-	const T& GetSetting(const CStr& Setting) const;
-
-	/**
 	 * Set a setting by string, regardless of what type it is.
 	 * Used to parse setting values from XML files.
 	 * For example a CRect(10,10,20,20) is created from "10 10 20 20".
-	 * Returns false if the conversion fails, otherwise true.
+	 * @return false if the setting does not exist or the conversion fails, otherwise true.
 	 */
 	bool SetSettingFromString(const CStr& Setting, const CStrW& Value, const bool SendMessage);
 
 	/**
-	 * Assigns the given value to the setting identified by the given name.
-	 * Uses move semantics, so do not read from Value after this call.
-	 *
-	 * @param SendMessage If true, a GUIM_SETTINGS_UPDATED message will be broadcasted to all GUI objects.
-	 */
-	template <typename T>
-	void SetSetting(const CStr& Setting, T& Value, const bool SendMessage);
-
-	/**
-	 * This variant will copy the value.
-	 */
-	template <typename T>
-	void SetSetting(const CStr& Setting, const T& Value, const bool SendMessage);
-
-	/**
 	 * Returns whether this object is set to be hidden or ghost.
 	 */
 	bool IsEnabled() const;
 
 	/**
 	 * Returns whether this is object is set to be hidden.
 	 */
 	bool IsHidden() const;
 
+	void SetHidden(bool hidden) { m_Hidden.Set(hidden, true); }
+
 	/**
 	 * Returns whether this object is set to be hidden or ghost.
 	 */
 	bool IsHiddenOrGhost() const;
 
 	/**
 	 * Retrieves the configured sound filename from the given setting name and plays that once.
 	 */
 	void PlaySound(const CStrW& soundPath) const;
 
 	/**
 	 * Send event to this GUI object (HandleMessage and ScriptEvent)
 	 *
 	 * @param type Type of GUI message to be handled
 	 * @param eventName String representation of event name
 	 * @return IN_HANDLED if event was handled, or IN_PASS if skipped
 	 */
 	InReaction SendEvent(EGUIMessageType type, const CStr& eventName);
 
 	/**
 	 * Same as SendEvent, but passes mouse coordinates and button state as an argument.
 	 */
 	InReaction SendMouseEvent(EGUIMessageType type, const CStr& eventName);
 
 	/**
 	 * All sizes are relative to resolution, and the calculation
 	 * is not wanted in real time, therefore it is cached, update
 	 * the cached size with this function.
 	 */
 	virtual void UpdateCachedSize();
 
 	/**
 	 * Updates and returns the size of the object.
 	 */
 	CRect GetComputedSize();
 
 	virtual const CStrW& GetTooltipText() const { return m_Tooltip; }
 	virtual const CStr& GetTooltipStyle() const { return m_TooltipStyle; }
 
 	/**
 	 * Reset internal state of this object.
 	 */
 	virtual void ResetStates();
 
 	/**
 	 * Set the script handler for a particular object-specific action
 	 *
 	 * @param eventName Name of action
 	 * @param Code Javascript code to execute when the action occurs
 	 * @param pGUI GUI instance to associate the script with
 	 */
 	void RegisterScriptHandler(const CStr& eventName, const CStr& Code, CGUI& pGUI);
 
 	/**
 	 * Retrieves the JSObject representing this GUI object.
 	 */
 	JSObject* GetJSObject();
 
 	//@}
 protected:
 	//--------------------------------------------------------
 	/** @name Called by CGUI and friends
 	 *
 	 * Methods that the CGUI will call using
 	 * its friendship, these should not
 	 * be called by user.
 	 * TODO: this comment is old and the following interface should be cleaned up.
 	 */
 	//--------------------------------------------------------
 	//@{
 
 public:
 
 	/**
 	 * Called on every GUI tick unless the object or one of its parent is hidden/ghost.
 	 */
 	virtual void Tick() {};
 
 	/**
      * This function is called with different messages
 	 * for instance when the mouse enters the object.
 	 *
 	 * @param Message GUI Message
 	 */
 	virtual void HandleMessage(SGUIMessage& UNUSED(Message)) {}
 
 	/**
 	 * Calls an IGUIObject member function recursively on this object and its children.
 	 * Aborts recursion at IGUIObjects that have the isRestricted function return true.
 	 * The arguments of the callback function must be references.
 	*/
 	template<typename... Args>
 	void RecurseObject(bool(IGUIObject::*isRestricted)() const, void(IGUIObject::*callbackFunction)(Args... args), Args&&... args)
 	{
 		if (!IsBaseObject())
 		{
 			if (isRestricted && (this->*isRestricted)())
 				return;
 
 			(this->*callbackFunction)(args...);
 		}
 
 		for (IGUIObject* const& obj : m_Children)
 			obj->RecurseObject(isRestricted, callbackFunction, args...);
 	}
 
 protected:
 	/**
 	 * Draws the object.
 	 */
 	virtual void Draw() = 0;
 
 	/**
 	 * Some objects need to be able to pre-emptively process SDL_Event_.
 	 *
 	 * Only the object with focus will have this function called.
 	 *
 	 * Returns either IN_PASS or IN_HANDLED. If IN_HANDLED, then
 	 * the event won't be passed on and processed by other handlers.
 	 */
 	virtual InReaction PreemptEvent(const SDL_Event_* UNUSED(ev)) { return IN_PASS; }
 
 	/**
 	 * Some objects need to handle the text-related SDL_Event_ manually.
 	 * For instance the input box.
 	 *
 	 * Only the object with focus will have this function called.
 	 *
 	 * Returns either IN_PASS or IN_HANDLED. If IN_HANDLED, then
 	 * the key won't be passed on and processed by other handlers.
 	 * This is used for keys that the GUI uses.
 	 */
 	virtual InReaction ManuallyHandleKeys(const SDL_Event_* UNUSED(ev)) { return IN_PASS; }
 
 	/**
 	 * Applies the given style to the object.
 	 *
 	 * Returns false if the style is not recognised (and thus has
 	 * not been applied).
 	 */
 	bool ApplyStyle(const CStr& StyleName);
 
 	/**
 	 * Returns not the Z value, but the actual buffered Z value, i.e. if it's
 	 * defined relative, then it will check its parent's Z value and add
 	 * the relativity.
 	 *
 	 * @return Actual Z value on the screen.
 	 */
 	virtual float GetBufferedZ() const;
 
 	/**
 	 * Add an object to the hierarchy.
 	 */
 	void RegisterChild(IGUIObject* child);
 
 	/**
 	 * Remove an object from the hierarchy.
 	 */
 	void UnregisterChild(IGUIObject* child);
 
 	/**
 	 * Set parent of this object
 	 */
 	void SetParent(IGUIObject* pParent) { m_pParent = pParent; }
 
 public:
 
 	CGUI& GetGUI() { return m_pGUI; }
 	const CGUI& GetGUI() const { return m_pGUI; }
 
 	/**
 	 * Take focus!
 	 */
 	void SetFocus();
 
 	/**
 	 * Release focus.
 	 */
 	void ReleaseFocus();
 
 protected:
 	/**
 	 * Check if object is focused.
 	 */
 	bool IsFocused() const;
 
 	/**
 	 * <b>NOTE!</b> This will not just return m_pParent, when that is
 	 * need use it! There is one exception to it, when the parent is
 	 * the top-node (the object that isn't a real object), this
 	 * will return nullptr, so that the top-node's children are
 	 * seemingly parentless.
 	 *
 	 * @return Pointer to parent
 	 */
 	IGUIObject* GetParent() const;
 
 	/**
 	 * Handle additional children to the \<object\>-tag. In IGUIObject, this function does
 	 * nothing. In CList and CDropDown, it handles the \<item\>, used to build the data.
 	 *
 	 * Returning false means the object doesn't recognize the child. Should be reported.
 	 * Notice 'false' is default, because an object not using this function, should not
 	 * have any additional children (and this function should never be called).
 	 */
 	virtual bool HandleAdditionalChildren(const XMBData& UNUSED(file), const XMBElement& UNUSED(child))
 	{
 		return false;
 	}
 
 	/**
 	 * Allow the GUI object to process after all child items were handled.
 	 * Useful to avoid iterator invalidation with push_back calls.
 	 */
 	virtual void AdditionalChildrenHandled() {}
 
 	/**
 	 * Cached size, real size m_Size is actually dependent on resolution
 	 * and can have different *real* outcomes, this is the real outcome
 	 * cached to avoid slow calculations in real time.
 	 */
 	CRect m_CachedActualSize;
 
 	/**
 	 * Execute the script for a particular action.
 	 * Does nothing if no script has been registered for that action.
 	 * The mouse coordinates will be passed as the first argument.
 	 *
 	 * @param eventName Name of action
 	 */
 	void ScriptEvent(const CStr& eventName);
 
 	/**
 	 * Execute the script for a particular action.
 	 * Does nothing if no script has been registered for that action.
 	 * The mouse coordinates will be passed as the first argument.
 	 *
 	 * @param eventName Name of action
 	 *
 	 * @return True if the script returned something truthy.
 	 */
 	bool ScriptEventWithReturn(const CStr& eventName);
 
 	/**
 	 * Execute the script for a particular action.
 	 * Does nothing if no script has been registered for that action.
 	 *
 	 * @param eventName Name of action
 	 * @param paramData JS::HandleValueArray arguments to pass to the event.
 	 */
 	void ScriptEvent(const CStr& eventName, const JS::HandleValueArray& paramData);
 
 	/**
 	 * Execute the script for a particular action.
 	 * Does nothing if no script has been registered for that action.
 	 *
 	 * @param eventName Name of action
 	 * @param paramData JS::HandleValueArray arguments to pass to the event.
 	 *
 	 * @return True if the script returned something truthy.
 	 */
 	bool ScriptEventWithReturn(const CStr& eventName, const JS::HandleValueArray& paramData);
 
 	/**
 	 * Assigns a JS function to the event name.
 	 */
 	void SetScriptHandler(const CStr& eventName, JS::HandleObject Function);
 
 	/**
 	 * Deletes an event handler assigned to the given name, if such a handler exists.
 	 */
 	void UnsetScriptHandler(const CStr& eventName);
 
 	/**
 	 * Inputes the object that is currently hovered, this function
 	 * updates this object accordingly (i.e. if it's the object
 	 * being inputted one thing happens, and not, another).
 	 *
 	 * @param pMouseOver Object that is currently hovered, can be nullptr too!
 	 */
 	void UpdateMouseOver(IGUIObject* const& pMouseOver);
 
 	//@}
 private:
 	//--------------------------------------------------------
 	/** @name Internal functions */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Creates the JS object representing this page upon first use.
 	 * This function (and its derived versions) are defined in the GUIProxy implementation file for convenience.
 	 */
 	virtual void CreateJSObject();
 
 	/**
 	 * Updates some internal data depending on the setting changed.
 	 */
-	void PreSettingChange(const CStr& Setting);
 	void SettingChanged(const CStr& Setting, const bool SendMessage);
 
 	/**
 	 * Inputs a reference pointer, checks if the new inputted object
 	 * if hovered, if so, then check if this's Z value is greater
 	 * than the inputted object... If so then the object is closer
 	 * and we'll replace the pointer with this.
 	 * Also Notice input can be nullptr, which means the Z value demand
 	 *  is out. NOTICE you can't input nullptr as const so you'll have
 	 * to set an object to nullptr.
 	 *
 	 * @param pObject	Object pointer, can be either the old one, or
 	 *					the new one.
 	 */
 	void ChooseMouseOverAndClosest(IGUIObject*& pObject);
 
 	/**
 	 * Returns whether this is the object all other objects are descendants of.
 	 */
 	bool IsBaseObject() const;
 
 	/**
 	 * Returns whether this object is a child of the base object.
 	 */
 	bool IsRootObject() const;
 
 	static void Trace(JSTracer* trc, void* data)
 	{
 		reinterpret_cast<IGUIObject*>(data)->TraceMember(trc);
 	}
 
 	void TraceMember(JSTracer* trc);
 
 // Variables
 protected:
 	static const CStr EventNameMouseEnter;
 	static const CStr EventNameMouseMove;
 	static const CStr EventNameMouseLeave;
 
 	// Name of object
 	CStr m_Name;
 
 	// Constructed on the heap, will be destroyed along with the the CGUI
 	std::vector<IGUIObject*> m_Children;
 
 	// Pointer to parent
 	IGUIObject* m_pParent;
 
 	//This represents the last click time for each mouse button
 	double m_LastClickTime[6];
 
 	/**
 	 * This variable is true if the mouse is hovering this object and
 	 * this object is the topmost object shown in this location.
 	 */
 	bool m_MouseHovering;
 
 	/**
 	 * Settings pool, all an object's settings are located here
 	 */
 	std::map<CStr, IGUISetting*> m_Settings;
 
 	// An object can't function stand alone
 	CGUI& m_pGUI;
 
 	// Internal storage for registered script handlers.
 	std::map<CStr, JS::Heap<JSObject*> > m_ScriptHandlers;
 
 	// Cached JSObject representing this GUI object.
 	std::unique_ptr<IGUIProxyObject> m_JSObject;
 
-	// Cache references to settings for performance
-	bool m_Enabled;
-	bool m_Hidden;
-	CGUISize m_Size;
-	CStr m_Style;
-	CStr m_Hotkey;
-	float m_Z;
-	bool m_Absolute;
-	bool m_Ghost;
-	float m_AspectRatio;
-	CStrW m_Tooltip;
-	CStr m_TooltipStyle;
+	CGUISimpleSetting<bool> m_Enabled;
+	CGUISimpleSetting<bool> m_Hidden;
+	CGUISimpleSetting<CGUISize> m_Size;
+	CGUISimpleSetting<CStr> m_Style;
+	CGUIHotkey m_Hotkey;
+	CGUISimpleSetting<float> m_Z;
+	CGUISimpleSetting<bool> m_Absolute;
+	CGUISimpleSetting<bool> m_Ghost;
+	CGUISimpleSetting<float> m_AspectRatio;
+	CGUISimpleSetting<CStrW> m_Tooltip;
+	CGUISimpleSetting<CStr> m_TooltipStyle;
 };
 
 #endif // INCLUDED_IGUIOBJECT
Index: ps/trunk/source/gui/ObjectBases/IGUITextOwner.cpp
===================================================================
--- ps/trunk/source/gui/ObjectBases/IGUITextOwner.cpp	(revision 25391)
+++ ps/trunk/source/gui/ObjectBases/IGUITextOwner.cpp	(revision 25392)
@@ -1,123 +1,125 @@
 /* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "IGUITextOwner.h"
 
 #include "gui/CGUI.h"
 #include "gui/SGUIMessage.h"
 #include "gui/ObjectBases/IGUIObject.h"
 #include "gui/SettingTypes/CGUIString.h"
 #include "maths/Vector2D.h"
 
 #include <math.h>
 
 IGUITextOwner::IGUITextOwner(IGUIObject& pObject)
-	: m_pObject(pObject),
-	  m_GeneratedTextsValid()
+: m_pObject(pObject),
+	m_GeneratedTextsValid(),
+	m_TextAlign(&pObject, "text_align", EAlign::LEFT),
+	m_TextVAlign(&pObject, "text_valign", EVAlign::TOP)
 {
 }
 
 IGUITextOwner::~IGUITextOwner()
 {
 }
 
 CGUIText& IGUITextOwner::AddText()
 {
 	m_GeneratedTexts.emplace_back();
 	return m_GeneratedTexts.back();
 }
 
 CGUIText& IGUITextOwner::AddText(const CGUIString& Text, const CStrW& Font, const float& Width, const float& BufferZone)
 {
 	// Avoids a move constructor
-	m_GeneratedTexts.emplace_back(m_pObject.GetGUI(), Text, Font, Width, BufferZone, &m_pObject);
+	m_GeneratedTexts.emplace_back(m_pObject.GetGUI(), Text, Font, Width, BufferZone, m_TextAlign, &m_pObject);
 	return m_GeneratedTexts.back();
 }
 
 void IGUITextOwner::HandleMessage(SGUIMessage& Message)
 {
 	switch (Message.type)
 	{
 	case GUIM_SETTINGS_UPDATED:
 		// Everything that can change the visual appearance.
 		//  it is assumed that the text of the object will be dependent on
 		//  these. Although that is not certain, but one will have to manually
 		//  change it and disregard this function.
 		if (Message.value == "size" || Message.value == "tooltip" ||
 			Message.value == "absolute" || Message.value == "caption" ||
 			Message.value == "font" || Message.value == "textcolor" ||
 			Message.value == "text_align" || Message.value == "text_valign" ||
 			Message.value == "buffer_zone")
 		{
 			m_GeneratedTextsValid = false;
 		}
 		break;
 
 	default:
 		break;
 	}
 }
 
 void IGUITextOwner::UpdateCachedSize()
 {
 	// update our text positions
 	m_GeneratedTextsValid = false;
 }
 
 void IGUITextOwner::UpdateText()
 {
 	if (!m_GeneratedTextsValid)
 	{
 		SetupText();
 		m_GeneratedTextsValid = true;
 	}
 }
 
 void IGUITextOwner::DrawText(size_t index, const CGUIColor& color, const CVector2D& pos, float z, const CRect& clipping)
 {
 	UpdateText();
 
 	ENSURE(index < m_GeneratedTexts.size() && "Trying to draw a Text Index within a IGUITextOwner that doesn't exist");
 
 	m_GeneratedTexts.at(index).Draw(m_pObject.GetGUI(), color, pos, z, clipping);
 }
 
 void IGUITextOwner::CalculateTextPosition(CRect& ObjSize, CVector2D& TextPos, CGUIText& Text)
 {
 	// The horizontal Alignment is now computed in GenerateText in order to not have to
 	// loop through all of the TextCall objects again.
 	TextPos.X = ObjSize.left;
 
-	switch (m_pObject.GetSetting<EVAlign>("text_valign"))
+	switch (m_TextVAlign)
 	{
 	case EVAlign::TOP:
 		TextPos.Y = ObjSize.top;
 		break;
 	case EVAlign::CENTER:
 		// Round to integer pixel values, else the fonts look awful
 		TextPos.Y = floorf(ObjSize.CenterPoint().Y - Text.GetSize().Height / 2.f);
 		break;
 	case EVAlign::BOTTOM:
 		TextPos.Y = ObjSize.bottom - Text.GetSize().Height;
 		break;
 	default:
 		debug_warn(L"Broken EVAlign in CButton::SetupText()");
 		break;
 	}
 }
Index: ps/trunk/source/gui/ObjectBases/IGUITextOwner.h
===================================================================
--- ps/trunk/source/gui/ObjectBases/IGUITextOwner.h	(revision 25391)
+++ ps/trunk/source/gui/ObjectBases/IGUITextOwner.h	(revision 25392)
@@ -1,123 +1,128 @@
 /* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /*
 GUI Object Base - Text Owner
 
 --Overview--
 
 	Interface class that enhance the IGUIObject with
 	 cached CGUIStrings. This class is not at all needed,
 	 and many controls that will use CGUIStrings might
 	 not use this, but does help for regular usage such
 	 as a text-box, a button, a radio button etc.
 */
 
 #ifndef INCLUDED_IGUITEXTOWNER
 #define INCLUDED_IGUITEXTOWNER
 
+#include "gui/CGUISetting.h"
+#include "gui/SettingTypes/EAlign.h"
 #include "maths/Rect.h"
 
 #include <vector>
 
 struct CGUIColor;
 struct SGUIMessage;
 class CGUIText;
 class CGUIString;
 class IGUIObject;
 
 class CStrW;
 class CVector2D;
 
 /**
  * Framework for handling Output text.
  */
 class IGUITextOwner
 {
 	NONCOPYABLE(IGUITextOwner);
 
 public:
 	IGUITextOwner(IGUIObject& pObject);
 	virtual ~IGUITextOwner();
 
 	/**
 	 * Adds a text object.
 	 */
 	CGUIText& AddText();
 
 	/**
 	 * Adds a text generated by the given arguments.
 	 */
 	CGUIText& AddText(const CGUIString& Text, const CStrW& Font, const float& Width, const float& BufferZone);
 
 	/**
 	 * @see IGUIObject#HandleMessage()
 	 */
 	virtual void HandleMessage(SGUIMessage& Message);
 
 	/**
 	 * @see IGUIObject#UpdateCachedSize()
 	 */
 	virtual void UpdateCachedSize();
 
 	/**
 	 * Draws the Text.
 	 *
 	 * @param index Index value of text. Mostly this will be 0
 	 * @param color
 	 * @param pos Position
 	 * @param z Z value
 	 * @param clipping Clipping rectangle, don't even add a parameter
 	 *		  to get no clipping.
 	 */
 	virtual void DrawText(size_t index, const CGUIColor& color, const CVector2D& pos, float z, const CRect& clipping = CRect());
 
 protected:
 	/**
 	 * Setup texts. Functions that sets up all texts when changes have been made.
 	 */
 	virtual void SetupText() = 0;
 
 	/**
 	 * Regenerate the text in case it is invalid. Should only be called when inevitable.
 	 */
 	virtual void UpdateText();
 
 	/**
 	 * Whether the cached text is currently valid (if not then SetupText will be called by Draw)
 	 */
 	bool m_GeneratedTextsValid;
 
 	/**
 	 * Texts that are generated and ready to be rendered.
 	 */
 	std::vector<CGUIText> m_GeneratedTexts;
 
 	/**
 	 * Calculate the position for the text, based on the alignment.
 	 */
 	void CalculateTextPosition(CRect& ObjSize, CVector2D& TextPos, CGUIText& Text);
 
+	CGUISimpleSetting<EAlign> m_TextAlign;
+	CGUISimpleSetting<EVAlign> m_TextVAlign;
+
 private:
 	/**
 	 * Reference to the IGUIObject.
 	 * Private, because we don't want to inherit it in multiple classes.
 	 */
 	IGUIObject& m_pObject;
 };
 
 #endif // INCLUDED_IGUITEXTOWNER
Index: ps/trunk/source/gui/ObjectTypes/CButton.cpp
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CButton.cpp	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CButton.cpp	(revision 25392)
@@ -1,122 +1,106 @@
 /* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "CButton.h"
 
 #include "gui/CGUI.h"
 #include "gui/CGUIText.h"
 #include "gui/SettingTypes/CGUIColor.h"
 
 CButton::CButton(CGUI& pGUI)
 	: IGUIObject(pGUI),
 	  IGUIButtonBehavior(*static_cast<IGUIObject*>(this)),
 	  IGUITextOwner(*static_cast<IGUIObject*>(this)),
-	  m_BufferZone(),
-	  m_Caption(),
-	  m_Font(),
-	  m_Sprite(),
-	  m_SpriteOver(),
-	  m_SpritePressed(),
-	  m_SpriteDisabled(),
-	  m_TextAlign(),
-	  m_TextVAlign(),
-	  m_TextColor(),
-	  m_TextColorOver(),
-	  m_TextColorPressed(),
-	  m_TextColorDisabled()
-{
-	RegisterSetting("buffer_zone", m_BufferZone);
-	RegisterSetting("caption", m_Caption);
-	RegisterSetting("font", m_Font);
-	RegisterSetting("sprite", m_Sprite);
-	RegisterSetting("sprite_over", m_SpriteOver);
-	RegisterSetting("sprite_pressed", m_SpritePressed);
-	RegisterSetting("sprite_disabled", m_SpriteDisabled);
-	RegisterSetting("text_align", m_TextAlign);
-	RegisterSetting("text_valign", m_TextVAlign);
-	RegisterSetting("textcolor", m_TextColor);
-	RegisterSetting("textcolor_over", m_TextColorOver);
-	RegisterSetting("textcolor_pressed", m_TextColorPressed);
-	RegisterSetting("textcolor_disabled", m_TextColorDisabled);
-
+	  m_BufferZone(this, "buffer_zone"),
+	  m_Caption(this, "caption"),
+	  m_Font(this, "font"),
+	  m_Sprite(this, "sprite"),
+	  m_SpriteOver(this, "sprite_over"),
+	  m_SpritePressed(this, "sprite_pressed"),
+	  m_SpriteDisabled(this, "sprite_disabled"),
+	  m_TextColor(this, "textcolor"),
+	  m_TextColorOver(this, "textcolor_over"),
+	  m_TextColorPressed(this, "textcolor_pressed"),
+	  m_TextColorDisabled(this, "textcolor_disabled")
+{
 	AddText();
 }
 
 CButton::~CButton()
 {
 }
 
 void CButton::SetupText()
 {
 	ENSURE(m_GeneratedTexts.size() == 1);
 
-	m_GeneratedTexts[0] = CGUIText(m_pGUI, m_Caption, m_Font, m_CachedActualSize.GetWidth(), m_BufferZone, this);
+	m_GeneratedTexts[0] = CGUIText(m_pGUI, m_Caption, m_Font, m_CachedActualSize.GetWidth(), m_BufferZone, m_TextAlign, this);
 	CalculateTextPosition(m_CachedActualSize, m_TextPos, m_GeneratedTexts[0]);
 }
 
 void CButton::ResetStates()
 {
 	IGUIObject::ResetStates();
 	IGUIButtonBehavior::ResetStates();
 }
 
 void CButton::UpdateCachedSize()
 {
 	IGUIObject::UpdateCachedSize();
 	IGUITextOwner::UpdateCachedSize();
 }
 
 CSize2D CButton::GetTextSize()
 {
 	UpdateText();
 	return m_GeneratedTexts[0].GetSize();
 }
 
 void CButton::HandleMessage(SGUIMessage& Message)
 {
 	IGUIObject::HandleMessage(Message);
 	IGUIButtonBehavior::HandleMessage(Message);
 	IGUITextOwner::HandleMessage(Message);
 }
 
 void CButton::Draw()
 {
 	const float bz = GetBufferedZ();
 
 	m_pGUI.DrawSprite(
 		GetButtonSprite(m_Sprite, m_SpriteOver, m_SpritePressed, m_SpriteDisabled),
 		bz,
 		m_CachedActualSize);
 
 	DrawText(0, ChooseColor(), m_TextPos, bz + 0.1f);
 }
 
 const CGUIColor& CButton::ChooseColor()
 {
 	if (!m_Enabled)
-		return m_TextColorDisabled ? m_TextColorDisabled : m_TextColor;
+		return *m_TextColorDisabled ? m_TextColorDisabled : m_TextColor;
 
 	if (!m_MouseHovering)
 		return m_TextColor;
 
 	if (m_Pressed)
-		return m_TextColorPressed ? m_TextColorPressed : m_TextColor;
+		return *m_TextColorPressed ? m_TextColorPressed : m_TextColor;
 
-	return m_TextColorOver ? m_TextColorOver : m_TextColor;
+	return *m_TextColorOver ? m_TextColorOver : m_TextColor;
 }
Index: ps/trunk/source/gui/ObjectTypes/CButton.h
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CButton.h	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CButton.h	(revision 25392)
@@ -1,95 +1,93 @@
 /* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef INCLUDED_CBUTTON
 #define INCLUDED_CBUTTON
 
 #include "gui/CGUISprite.h"
 #include "gui/ObjectBases/IGUIButtonBehavior.h"
 #include "gui/ObjectBases/IGUIObject.h"
 #include "gui/ObjectBases/IGUITextOwner.h"
 #include "gui/SettingTypes/CGUIString.h"
 #include "maths/Vector2D.h"
 
 class CButton : public IGUIObject, public IGUITextOwner, public IGUIButtonBehavior
 {
 	GUI_OBJECT(CButton)
 public:
 	CButton(CGUI& pGUI);
 	virtual ~CButton();
 
 	/**
 	 * @see IGUIObject#ResetStates()
 	 */
 	virtual void ResetStates();
 
 	/**
 	 * @see IGUIObject#UpdateCachedSize()
 	 */
 	virtual void UpdateCachedSize();
 
 	/**
 	 * @return the object text size.
 	 */
 	CSize2D GetTextSize();
 
 	/**
 	 * @see IGUIObject#HandleMessage()
 	 */
 	virtual void HandleMessage(SGUIMessage& Message);
 
 	/**
 	 * Draws the Button
 	 */
 	virtual void Draw();
 
 protected:
 	/**
 	 * Sets up text, should be called every time changes has been
 	 * made that can change the visual.
 	 */
 	void SetupText();
 
 	/**
 	 * Picks the text color depending on current object settings.
 	 */
 	const CGUIColor& ChooseColor();
 
 	/**
 	 * Placement of text.
 	 */
 	CVector2D m_TextPos;
 
 	virtual void CreateJSObject();
 
 	// Settings
-	float m_BufferZone;
-	CGUIString m_Caption;
-	CStrW m_Font;
-	CGUISpriteInstance m_Sprite;
-	CGUISpriteInstance m_SpriteOver;
-	CGUISpriteInstance m_SpritePressed;
-	CGUISpriteInstance m_SpriteDisabled;
-	EAlign m_TextAlign;
-	EVAlign m_TextVAlign;
-	CGUIColor m_TextColor;
-	CGUIColor m_TextColorOver;
-	CGUIColor m_TextColorPressed;
-	CGUIColor m_TextColorDisabled;
+	CGUISimpleSetting<float> m_BufferZone;
+	CGUISimpleSetting<CGUIString> m_Caption;
+	CGUISimpleSetting<CStrW> m_Font;
+	CGUISimpleSetting<CGUISpriteInstance> m_Sprite;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteOver;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpritePressed;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteDisabled;
+	CGUISimpleSetting<CGUIColor> m_TextColor;
+	CGUISimpleSetting<CGUIColor> m_TextColorOver;
+	CGUISimpleSetting<CGUIColor> m_TextColorPressed;
+	CGUISimpleSetting<CGUIColor> m_TextColorDisabled;
 };
 
 #endif // INCLUDED_CBUTTON
Index: ps/trunk/source/gui/ObjectTypes/CChart.cpp
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CChart.cpp	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CChart.cpp	(revision 25392)
@@ -1,309 +1,299 @@
 /* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "CChart.h"
 
 #include "graphics/ShaderManager.h"
 #include "gui/GUIMatrix.h"
 #include "gui/SettingTypes/CGUIList.h"
 #include "gui/SettingTypes/CGUISeries.h"
 #include "gui/SettingTypes/CGUIString.h"
 #include "ps/CLogger.h"
 #include "ps/Profile.h"
 #include "renderer/Renderer.h"
 
 #include <cmath>
 
 CChart::CChart(CGUI& pGUI)
 	: IGUIObject(pGUI),
 	  IGUITextOwner(*static_cast<IGUIObject*>(this)),
-	  m_AxisColor(),
-	  m_AxisWidth(),
-	  m_BufferZone(),
-	  m_Font(),
-	  m_FormatX(),
-	  m_FormatY(),
-	  m_SeriesColor(),
-	  m_SeriesSetting(),
-	  m_TextAlign()
-{
-	RegisterSetting("axis_color", m_AxisColor);
-	RegisterSetting("axis_width", m_AxisWidth);
-	RegisterSetting("buffer_zone", m_BufferZone);
-	RegisterSetting("font", m_Font);
-	RegisterSetting("format_x", m_FormatX);
-	RegisterSetting("format_y", m_FormatY);
-	RegisterSetting("series_color", m_SeriesColor);
-	RegisterSetting("series", m_SeriesSetting);
-	RegisterSetting("text_align", m_TextAlign);
+	  m_AxisColor(this, "axis_color"),
+	  m_AxisWidth(this, "axis_width"),
+	  m_BufferZone(this, "buffer_zone"),
+	  m_Font(this, "font"),
+	  m_FormatX(this, "format_x"),
+	  m_FormatY(this, "format_y"),
+	  m_SeriesColor(this, "series_color"),
+	  m_SeriesSetting(this, "series")
+{
 }
 
 CChart::~CChart()
 {
 }
 
 void CChart::UpdateCachedSize()
 {
 	IGUIObject::UpdateCachedSize();
 	IGUITextOwner::UpdateCachedSize();
 }
 
 void CChart::HandleMessage(SGUIMessage& Message)
 {
 	IGUIObject::HandleMessage(Message);
 	// IGUITextOwner::HandleMessage(Message); performed in UpdateSeries
 
 	// TODO: implement zoom
 	if(Message.type == GUIM_SETTINGS_UPDATED)
 		UpdateSeries();
 }
 
 void CChart::DrawLine(const CShaderProgramPtr& shader, const CGUIColor& color, const std::vector<float>& vertices) const
 {
 	shader->Uniform(str_color, color);
 	shader->VertexPointer(3, GL_FLOAT, 0, &vertices[0]);
 	shader->AssertPointersBound();
 
 #if !CONFIG2_GLES
 	glEnable(GL_LINE_SMOOTH);
 #endif
 	glLineWidth(1.1f);
 	if (!g_Renderer.DoSkipSubmit())
 		glDrawArrays(GL_LINE_STRIP, 0, vertices.size() / 3);
 	glLineWidth(1.0f);
 #if !CONFIG2_GLES
 	glDisable(GL_LINE_SMOOTH);
 #endif
 }
 
 void CChart::DrawTriangleStrip(const CShaderProgramPtr& shader, const CGUIColor& color, const std::vector<float>& vertices) const
 {
 	shader->Uniform(str_color, color);
 	shader->VertexPointer(3, GL_FLOAT, 0, &vertices[0]);
 	shader->AssertPointersBound();
 
 	if (!g_Renderer.DoSkipSubmit())
 		glDrawArrays(GL_TRIANGLE_STRIP, 0, vertices.size() / 3);
 }
 
 void CChart::DrawAxes(const CShaderProgramPtr& shader) const
 {
 	const float bz = GetBufferedZ();
 	CRect rect = GetChartRect();
 	std::vector<float> vertices;
 	vertices.reserve(30);
 #define ADD(x, y) vertices.push_back(x); vertices.push_back(y); vertices.push_back(bz + 0.5f);
 	ADD(m_CachedActualSize.right, m_CachedActualSize.bottom);
 	ADD(rect.right + m_AxisWidth, rect.bottom);
 	ADD(m_CachedActualSize.left, m_CachedActualSize.bottom);
 	ADD(rect.left, rect.bottom);
 	ADD(m_CachedActualSize.left, m_CachedActualSize.top);
 	ADD(rect.left, rect.top - m_AxisWidth);
 #undef ADD
 	DrawTriangleStrip(shader, m_AxisColor, vertices);
 }
 
 void CChart::Draw()
 {
 	PROFILE3("render chart");
 
 	if (m_Series.empty())
 		return;
 
 	const float bz = GetBufferedZ();
 	CRect rect = GetChartRect();
 	const float width = rect.GetWidth();
 	const float height = rect.GetHeight();
 
 	// Setup the render state
 	CMatrix3D transform = GetDefaultGuiMatrix();
 	CShaderDefines lineDefines;
 	CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_gui_solid, g_Renderer.GetSystemShaderDefines(), lineDefines);
 	tech->BeginPass();
 	CShaderProgramPtr shader = tech->GetShader();
 	shader->Uniform(str_transform, transform);
 
 	CVector2D scale(width / (m_RightTop.X - m_LeftBottom.X), height / (m_RightTop.Y - m_LeftBottom.Y));
 	for (const CChartData& data : m_Series)
 	{
 		if (data.m_Points.empty())
 			continue;
 
 		std::vector<float> vertices;
 		for (const CVector2D& point : data.m_Points)
 		{
 			if (fabs(point.X) != std::numeric_limits<float>::infinity() && fabs(point.Y) != std::numeric_limits<float>::infinity())
 			{
 				vertices.push_back(rect.left + (point.X - m_LeftBottom.X) * scale.X);
 				vertices.push_back(rect.bottom - (point.Y - m_LeftBottom.Y) * scale.Y);
 				vertices.push_back(bz + 0.5f);
 			}
 			else
 			{
 				DrawLine(shader, data.m_Color, vertices);
 				vertices.clear();
 			}
 		}
 		if (!vertices.empty())
 			DrawLine(shader, data.m_Color, vertices);
 	}
 
 	if (m_AxisWidth > 0)
 		DrawAxes(shader);
 
 	tech->EndPass();
 
 	for (size_t i = 0; i < m_TextPositions.size(); ++i)
 		DrawText(i, CGUIColor(1.f, 1.f, 1.f, 1.f), m_TextPositions[i], bz + 0.5f);
 }
 
 CRect CChart::GetChartRect() const
 {
 	return CRect(
 		m_CachedActualSize.TopLeft() + CVector2D(m_AxisWidth, m_AxisWidth),
 		m_CachedActualSize.BottomRight() - CVector2D(m_AxisWidth, m_AxisWidth)
 	);
 }
 
 void CChart::UpdateSeries()
 {
 	m_Series.clear();
-	m_Series.resize(m_SeriesSetting.m_Series.size());
+	m_Series.resize(m_SeriesSetting->m_Series.size());
 
-	for (size_t i = 0; i < m_SeriesSetting.m_Series.size(); ++i)
+	for (size_t i = 0; i < m_SeriesSetting->m_Series.size(); ++i)
 	{
 		CChartData& data = m_Series[i];
 
-		if (i < m_SeriesColor.m_Items.size() && !data.m_Color.ParseString(m_pGUI, m_SeriesColor.m_Items[i].GetOriginalString().ToUTF8(), 0))
-			LOGWARNING("GUI: Error parsing 'series_color' (\"%s\")", utf8_from_wstring(m_SeriesColor.m_Items[i].GetOriginalString()));
+		if (i < m_SeriesColor->m_Items.size() && !data.m_Color.ParseString(m_pGUI, m_SeriesColor->m_Items[i].GetOriginalString().ToUTF8(), 0))
+			LOGWARNING("GUI: Error parsing 'series_color' (\"%s\")", utf8_from_wstring(m_SeriesColor->m_Items[i].GetOriginalString()));
 
-		data.m_Points = m_SeriesSetting.m_Series[i];
+		data.m_Points = m_SeriesSetting->m_Series[i];
 	}
 	UpdateBounds();
 
 	SetupText();
 }
 
 void CChart::SetupText()
 {
 	m_GeneratedTexts.clear();
 	m_TextPositions.clear();
 
 	if (m_Series.empty())
 		return;
 
 	// Add Y-axis
 	const float height = GetChartRect().GetHeight();
 	// TODO: split values depend on the format;
 	if (m_EqualY)
 	{
 		// We don't need to generate many items for equal values
 		AddFormattedValue(m_FormatY, m_RightTop.Y, m_Font, m_BufferZone);
 		m_TextPositions.emplace_back(GetChartRect().TopLeft());
 	}
 	else
 		for (int i = 0; i < 3; ++i)
 		{
 			AddFormattedValue(m_FormatY, m_RightTop.Y - (m_RightTop.Y - m_LeftBottom.Y) / 3.f * i, m_Font, m_BufferZone);
 			m_TextPositions.emplace_back(GetChartRect().TopLeft() + CVector2D(0.f, height / 3.f * i));
 		}
 
 	// Add X-axis
 	const float width = GetChartRect().GetWidth();
 	if (m_EqualX)
 	{
 		CSize2D text_size = AddFormattedValue(m_FormatX, m_RightTop.X, m_Font, m_BufferZone);
 		m_TextPositions.emplace_back(GetChartRect().BottomRight() - text_size);
 	}
 	else
 		for (int i = 0; i < 3; ++i)
 		{
 			CSize2D text_size = AddFormattedValue(m_FormatX, m_RightTop.X - (m_RightTop.X - m_LeftBottom.X) / 3 * i, m_Font, m_BufferZone);
 			m_TextPositions.emplace_back(GetChartRect().BottomRight() - text_size - CVector2D(width / 3 * i, 0.f));
 		}
 }
 
 CSize2D CChart::AddFormattedValue(const CStrW& format, const float value, const CStrW& font, const float buffer_zone)
 {
 	// TODO: we need to catch cases with equal formatted values.
 	CGUIString gui_str;
 	if (format == L"DECIMAL2")
 	{
 		wchar_t buffer[64];
 		swprintf(buffer, 64, L"%.2f", value);
 		gui_str.SetValue(buffer);
 	}
 	else if (format == L"INTEGER")
 	{
 		wchar_t buffer[64];
 		swprintf(buffer, 64, L"%d", std::lround(value));
 		gui_str.SetValue(buffer);
 	}
 	else if (format == L"DURATION_SHORT")
 	{
 		const int seconds = value;
 		wchar_t buffer[64];
 		swprintf(buffer, 64, L"%d:%02d", seconds / 60, seconds % 60);
 		gui_str.SetValue(buffer);
 	}
 	else if (format == L"PERCENTAGE")
 	{
 		wchar_t buffer[64];
 		swprintf(buffer, 64, L"%d%%", std::lround(value));
 		gui_str.SetValue(buffer);
 	}
 	else
 	{
 		LOGERROR("Unsupported chart format: " + format.EscapeToPrintableASCII());
 		return CSize2D();
 	}
 
 	return AddText(gui_str, font, 0, buffer_zone).GetSize();
 }
 
 void CChart::UpdateBounds()
 {
 	if (m_Series.empty() || m_Series[0].m_Points.empty())
 	{
 		m_LeftBottom = m_RightTop = CVector2D(0.f, 0.f);
 		return;
 	}
 
 	m_LeftBottom = m_RightTop = m_Series[0].m_Points[0];
 	for (const CChartData& data : m_Series)
 		for (const CVector2D& point : data.m_Points)
 		{
 			if (fabs(point.X) != std::numeric_limits<float>::infinity() && point.X < m_LeftBottom.X)
 				m_LeftBottom.X = point.X;
 			if (fabs(point.Y) != std::numeric_limits<float>::infinity() && point.Y < m_LeftBottom.Y)
 				m_LeftBottom.Y = point.Y;
 
 			if (fabs(point.X) != std::numeric_limits<float>::infinity() && point.X > m_RightTop.X)
 				m_RightTop.X = point.X;
 			if (fabs(point.Y) != std::numeric_limits<float>::infinity() && point.Y > m_RightTop.Y)
 				m_RightTop.Y = point.Y;
 		}
 
 	m_EqualY = m_RightTop.Y == m_LeftBottom.Y;
 	if (m_EqualY)
 		m_RightTop.Y += 1;
 	m_EqualX = m_RightTop.X == m_LeftBottom.X;
 	if (m_EqualX)
 		m_RightTop.X += 1;
 }
Index: ps/trunk/source/gui/ObjectTypes/CChart.h
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CChart.h	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CChart.h	(revision 25392)
@@ -1,113 +1,112 @@
 /* Copyright (C) 2021 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_CCHART
 #define INCLUDED_CCHART
 
 #include "graphics/ShaderProgramPtr.h"
 #include "gui/ObjectBases/IGUIObject.h"
 #include "gui/ObjectBases/IGUITextOwner.h"
 #include "gui/SettingTypes/CGUIColor.h"
 #include "gui/SettingTypes/CGUIList.h"
 #include "gui/SettingTypes/CGUISeries.h"
 #include "maths/Size2D.h"
 #include "maths/Vector2D.h"
 
 #include <vector>
 
 struct CChartData
 {
 	// Avoid copying the container.
 	NONCOPYABLE(CChartData);
 	MOVABLE(CChartData);
 	CChartData() = default;
 
 	CGUIColor m_Color;
 	std::vector<CVector2D> m_Points;
 };
 
 /**
  * Chart for a data visualization as lines or points
  */
 class CChart : public IGUIObject, public IGUITextOwner
 {
 	GUI_OBJECT(CChart)
 
 public:
 	CChart(CGUI& pGUI);
 	virtual ~CChart();
 
 protected:
 	/**
 	 * @see IGUIObject#UpdateCachedSize()
 	 */
 	void UpdateCachedSize();
 
 	/**
 	 * @see IGUIObject#HandleMessage()
 	 */
 	virtual void HandleMessage(SGUIMessage& Message);
 
 	/**
 	 * Draws the Chart
 	 */
 	virtual void Draw();
 
 	virtual CRect GetChartRect() const;
 
 	void UpdateSeries();
 
 	void SetupText();
 
 	std::vector<CChartData> m_Series;
 
 	CVector2D m_LeftBottom, m_RightTop;
 
 	std::vector<CVector2D> m_TextPositions;
 
 	bool m_EqualX, m_EqualY;
 
 	// Settings
-	CGUIColor m_AxisColor;
-	float m_AxisWidth;
-	float m_BufferZone;
-	CStrW m_Font;
-	CStrW m_FormatX;
-	CStrW m_FormatY;
-	CGUIList m_SeriesColor;
-	CGUISeries m_SeriesSetting;
-	EAlign m_TextAlign;
+	CGUISimpleSetting<CGUIColor> m_AxisColor;
+	CGUISimpleSetting<float> m_AxisWidth;
+	CGUISimpleSetting<float> m_BufferZone;
+	CGUISimpleSetting<CStrW> m_Font;
+	CGUISimpleSetting<CStrW> m_FormatX;
+	CGUISimpleSetting<CStrW> m_FormatY;
+	CGUISimpleSetting<CGUIList> m_SeriesColor;
+	CGUISimpleSetting<CGUISeries> m_SeriesSetting;
 
 private:
 	/**
 	 * Helper functions
 	 */
 	void DrawLine(const CShaderProgramPtr& shader, const CGUIColor& color, const std::vector<float>& vertices) const;
 
 	// Draws the triangle sequence so that the each next triangle has a common edge with the previous one.
 	// If we need to draw n triangles, we need only n + 2 points.
 	void DrawTriangleStrip(const CShaderProgramPtr& shader, const CGUIColor& color, const std::vector<float>& vertices) const;
 
 	// Represents axes as triangles and draws them with DrawTriangleStrip.
 	void DrawAxes(const CShaderProgramPtr& shader) const;
 
 	CSize2D AddFormattedValue(const CStrW& format, const float value, const CStrW& font, const float buffer_zone);
 
 	void UpdateBounds();
 };
 
 #endif // INCLUDED_CCHART
Index: ps/trunk/source/gui/ObjectTypes/CCheckBox.cpp
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CCheckBox.cpp	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CCheckBox.cpp	(revision 25392)
@@ -1,84 +1,75 @@
 /* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "CCheckBox.h"
 
 #include "gui/CGUI.h"
 
 CCheckBox::CCheckBox(CGUI& pGUI)
 	: IGUIObject(pGUI),
 	  IGUIButtonBehavior(*static_cast<IGUIObject*>(this)),
-	  m_Checked(),
-	  m_SpriteUnchecked(),
-	  m_SpriteUncheckedOver(),
-	  m_SpriteUncheckedPressed(),
-	  m_SpriteUncheckedDisabled(),
-	  m_SpriteChecked(),
-	  m_SpriteCheckedOver(),
-	  m_SpriteCheckedPressed(),
-	  m_SpriteCheckedDisabled()
+	  m_Checked(this, "checked"),
+	  m_SpriteUnchecked(this, "sprite"),
+	  m_SpriteUncheckedOver(this, "sprite_over"),
+	  m_SpriteUncheckedPressed(this, "sprite_pressed"),
+	  m_SpriteUncheckedDisabled(this, "sprite_disabled"),
+	  m_SpriteChecked(this, "sprite2"),
+	  m_SpriteCheckedOver(this, "sprite2_over"),
+	  m_SpriteCheckedPressed(this, "sprite2_pressed"),
+	  m_SpriteCheckedDisabled(this, "sprite2_disabled")
 {
-	RegisterSetting("checked", m_Checked),
-	RegisterSetting("sprite", m_SpriteUnchecked);
-	RegisterSetting("sprite_over", m_SpriteUncheckedOver);
-	RegisterSetting("sprite_pressed", m_SpriteUncheckedPressed);
-	RegisterSetting("sprite_disabled", m_SpriteUncheckedDisabled);
-	RegisterSetting("sprite2", m_SpriteChecked);
-	RegisterSetting("sprite2_over", m_SpriteCheckedOver);
-	RegisterSetting("sprite2_pressed", m_SpriteCheckedPressed);
-	RegisterSetting("sprite2_disabled", m_SpriteCheckedDisabled);
 }
 
 CCheckBox::~CCheckBox()
 {
 }
 
 void CCheckBox::ResetStates()
 {
 	IGUIObject::ResetStates();
 	IGUIButtonBehavior::ResetStates();
 }
 
 void CCheckBox::HandleMessage(SGUIMessage& Message)
 {
 	IGUIObject::HandleMessage(Message);
 	IGUIButtonBehavior::HandleMessage(Message);
 
 	switch (Message.type)
 	{
 	case GUIM_PRESSED:
 	{
-		SetSetting<bool>("checked", !m_Checked, true);
+		m_Checked.Set(!m_Checked, true);
 		break;
 	}
 
 	default:
 		break;
 	}
 }
 
 void CCheckBox::Draw()
 {
 	m_pGUI.DrawSprite(
 		m_Checked ?
 			GetButtonSprite(m_SpriteChecked, m_SpriteCheckedOver, m_SpriteCheckedPressed, m_SpriteCheckedDisabled) :
 			GetButtonSprite(m_SpriteUnchecked, m_SpriteUncheckedOver, m_SpriteUncheckedPressed, m_SpriteUncheckedDisabled),
 		GetBufferedZ(),
 		m_CachedActualSize);
 }
Index: ps/trunk/source/gui/ObjectTypes/CCheckBox.h
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CCheckBox.h	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CCheckBox.h	(revision 25392)
@@ -1,61 +1,61 @@
 /* Copyright (C) 2021 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_CCHECKBOX
 #define INCLUDED_CCHECKBOX
 
 #include "gui/CGUISprite.h"
 #include "gui/ObjectBases/IGUIObject.h"
 #include "gui/ObjectBases/IGUIButtonBehavior.h"
 
 class CCheckBox : public IGUIObject, public IGUIButtonBehavior
 {
 	GUI_OBJECT(CCheckBox)
 
 public:
 	CCheckBox(CGUI& pGUI);
 	virtual ~CCheckBox();
 
 	/**
 	 * @see IGUIObject#ResetStates()
 	 */
 	virtual void ResetStates();
 
 	/**
 	 * @see IGUIObject#HandleMessage()
 	 */
 	virtual void HandleMessage(SGUIMessage& Message);
 
 	/**
 	 * Draws the control
 	 */
 	virtual void Draw();
 
 protected:
 	// Settings
-	bool m_Checked;
-	CGUISpriteInstance m_SpriteUnchecked;
-	CGUISpriteInstance m_SpriteUncheckedOver;
-	CGUISpriteInstance m_SpriteUncheckedPressed;
-	CGUISpriteInstance m_SpriteUncheckedDisabled;
-	CGUISpriteInstance m_SpriteChecked;
-	CGUISpriteInstance m_SpriteCheckedOver;
-	CGUISpriteInstance m_SpriteCheckedPressed;
-	CGUISpriteInstance m_SpriteCheckedDisabled;
+	CGUISimpleSetting<bool> m_Checked;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteUnchecked;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteUncheckedOver;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteUncheckedPressed;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteUncheckedDisabled;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteChecked;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteCheckedOver;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteCheckedPressed;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteCheckedDisabled;
 };
 
 #endif // INCLUDED_CCHECKBOX
Index: ps/trunk/source/gui/ObjectTypes/CDropDown.cpp
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CDropDown.cpp	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CDropDown.cpp	(revision 25392)
@@ -1,505 +1,486 @@
 /* Copyright (C) 2021 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/CGUI.h"
 #include "gui/IGUIScrollBar.h"
 #include "gui/SettingTypes/CGUIColor.h"
 #include "gui/SettingTypes/CGUIList.h"
 #include "lib/external_libraries/libsdl.h"
 #include "lib/timer.h"
 #include "ps/Profile.h"
 
 CDropDown::CDropDown(CGUI& pGUI)
 	: CList(pGUI),
 	  m_Open(),
 	  m_HideScrollBar(),
 	  m_ElementHighlight(-1),
-	  m_ButtonWidth(),
-	  m_DropDownSize(),
-	  m_DropDownBuffer(),
-	  m_MinimumVisibleItems(),
-	  m_SoundClosed(),
-	  m_SoundEnter(),
-	  m_SoundLeave(),
-	  m_SoundOpened(),
-	  m_SpriteDisabled(),
-	  m_SpriteList(),
-	  m_Sprite2(),
-	  m_Sprite2Over(),
-	  m_Sprite2Pressed(),
-	  m_Sprite2Disabled(),
-	  m_TextColorDisabled(),
-	  m_TextVAlign()
-{
-	RegisterSetting("button_width", m_ButtonWidth);
-	RegisterSetting("dropdown_size", m_DropDownSize);
-	RegisterSetting("dropdown_buffer", m_DropDownBuffer);
-	RegisterSetting("minimum_visible_items", m_MinimumVisibleItems);
-	RegisterSetting("sound_closed", m_SoundClosed);
-	RegisterSetting("sound_enter", m_SoundEnter);
-	RegisterSetting("sound_leave", m_SoundLeave);
-	RegisterSetting("sound_opened", m_SoundOpened);
-	// Setting "sprite" is registered by CList and used as the background
-	RegisterSetting("sprite_disabled", m_SpriteDisabled);
-	RegisterSetting("sprite_list", m_SpriteList); // Background of the drop down list
-	RegisterSetting("sprite2", m_Sprite2); // Button that sits to the right
-	RegisterSetting("sprite2_over", m_Sprite2Over);
-	RegisterSetting("sprite2_pressed", m_Sprite2Pressed);
-	RegisterSetting("sprite2_disabled", m_Sprite2Disabled);
-	RegisterSetting("textcolor_disabled", m_TextColorDisabled);
-	RegisterSetting("text_valign", m_TextVAlign);
-	// Add these in CList! And implement TODO
-	//RegisterSetting("textcolor_over");
-	//RegisterSetting("textcolor_pressed");
-
-	// Scrollbar is forced to be true.
-	SetSetting<bool>("scrollbar", true, true);
+	  m_ButtonWidth(this, "button_width"),
+	  m_DropDownSize(this, "dropdown_size"),
+	  m_DropDownBuffer(this, "dropdown_buffer"),
+	  m_MinimumVisibleItems(this, "minimum_visible_items"),
+	  m_SoundClosed(this, "sound_closed"),
+	  m_SoundEnter(this, "sound_enter"),
+	  m_SoundLeave(this, "sound_leave"),
+	  m_SoundOpened(this, "sound_opened"),
+	  // Setting "sprite" is registered by CList and used as the background
+	  m_SpriteDisabled(this, "sprite_disabled"),
+	  m_SpriteList(this, "sprite_list"), // Background of the drop down list
+	  m_Sprite2(this, "sprite2"), // Button that sits to the right
+	  m_Sprite2Over(this, "sprite2_over"),
+	  m_Sprite2Pressed(this, "sprite2_pressed"),
+	  m_Sprite2Disabled(this, "sprite2_disabled"),
+	  m_TextColorDisabled(this, "textcolor_disabled")
+	  // Add these in CList! And implement TODO
+	  //RegisterSetting("textcolor_over");
+	  //RegisterSetting("textcolor_pressed");
+{
+	m_ScrollBar.Set(true, true);
 }
 
 CDropDown::~CDropDown()
 {
 }
 
 void CDropDown::SetupText()
 {
 	SetupListRect();
 	CList::SetupText();
 }
 
 void CDropDown::UpdateCachedSize()
 {
 	CList::UpdateCachedSize();
 	SetupText();
 }
 
 void CDropDown::HandleMessage(SGUIMessage& Message)
 {
 	// CList::HandleMessage(Message); placed after the switch!
 
 	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;
 
 		CVector2D mouse = m_pGUI.GetMousePos();
 
 		if (!GetListRect().PointInside(mouse))
 			break;
 
 		const float scroll = m_ScrollBar ? GetScrollBar(0).GetPos() : 0.f;
 
 		CRect rect = GetListRect();
 		mouse.Y += scroll;
 		int set = -1;
-		for (int i = 0; i < static_cast<int>(m_List.m_Items.size()); ++i)
+		for (int i = 0; i < static_cast<int>(m_List->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:
 	{
 		if (m_Enabled)
 			PlaySound(m_SoundEnter);
 		break;
 	}
 
 	case GUIM_MOUSE_LEAVE:
 	{
 		m_ElementHighlight = m_Selected;
 
 		if (m_Enabled)
 			PlaySound(m_SoundLeave);
 		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:
 	{
 		if (!m_Enabled)
 		{
 			PlaySound(m_SoundDisabled);
 			break;
 		}
 
 		if (!m_Open)
 		{
-			if (m_List.m_Items.empty())
+			if (m_List->m_Items.empty())
 				return;
 
 			m_Open = true;
 			GetScrollBar(0).SetZ(GetBufferedZ());
 			m_ElementHighlight = m_Selected;
 
 			// Start at the position of the selected item, if possible.
 			GetScrollBar(0).SetPos(m_ItemsYPositions.empty() ? 0 : m_ItemsYPositions[m_ElementHighlight] - 60);
 
 			PlaySound(m_SoundOpened);
 			return; // overshadow
 		}
 		else
 		{
 			const CVector2D& 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());
 				PlaySound(m_SoundClosed);
 				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:
 	{
 		// Don't switch elements by scrolling when open, causes a confusing interaction between this and the scrollbar.
 		if (m_Open || !m_Enabled)
 			break;
 
 		m_ElementHighlight = m_Selected;
 
 		if (m_ElementHighlight + 1 >= (int)m_ItemsYPositions.size() - 1)
 			break;
 
 		++m_ElementHighlight;
-		SetSetting<i32>("selected", m_ElementHighlight, true);
+		m_Selected.Set(m_ElementHighlight, true);
 		break;
 	}
 
 	case GUIM_MOUSE_WHEEL_UP:
 	{
 		// Don't switch elements by scrolling when open, causes a confusing interaction between this and the scrollbar.
 		if (m_Open || !m_Enabled)
 			break;
 
 		m_ElementHighlight = m_Selected;
 		if (m_ElementHighlight - 1 < 0)
 			break;
 
 		--m_ElementHighlight;
-		SetSetting<i32>("selected", m_ElementHighlight, true);
+		m_Selected.Set(m_ElementHighlight, true);
 		break;
 	}
 
 	case GUIM_LOST_FOCUS:
 	{
 		if (m_Open)
 			PlaySound(m_SoundClosed);
 
 		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::ManuallyHandleKeys(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::ManuallyHandleKeys()
-			SetSetting<i32>("selected", m_ElementHighlight, true);
+			m_Selected.Set(m_ElementHighlight, true);
 			update_highlight = true;
 			break;
 
 		default:
 			// If we have typed 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_1 && szChar <= SDLK_KP_0)))
 			{
 				// 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();
 
 				// let's look for the closest element
 				// basically it's alphabetic order and "as many letters as we can get".
 				int closest = -1;
 				int bestIndex = -1;
 				int difference = 1250;
-				for (int i = 0; i < static_cast<int>(m_List.m_Items.size()); ++i)
+				for (int i = 0; i < static_cast<int>(m_List->m_Items.size()); ++i)
 				{
 					int indexOfDifference = 0;
 					int diff = 0;
 					for (size_t j = 0; j < m_InputBuffer.length(); ++j)
 					{
-						diff = std::abs(static_cast<int>(m_List.m_Items[i].GetRawString().LowerCase()[j]) - static_cast<int>(m_InputBuffer[j]));
+						diff = std::abs(static_cast<int>(m_List->m_Items[i].GetRawString().LowerCase()[j]) - static_cast<int>(m_InputBuffer[j]));
 						if (diff == 0)
 							indexOfDifference = j+1;
 						else
 							break;
 					}
 					if (indexOfDifference > bestIndex || (indexOfDifference >= bestIndex && diff < difference))
 					{
 						bestIndex = indexOfDifference;
 						closest = i;
 						difference = diff;
 					}
 				}
 				// let's select the closest element. There should basically always be one.
 				if (closest != -1)
 				{
-					SetSetting<i32>("selected", closest, true);
+					m_Selected.Set(closest, true);
 					update_highlight = true;
 					GetScrollBar(0).SetPos(m_ItemsYPositions[closest] - 60);
 				}
 				result = IN_HANDLED;
 			}
 			break;
 		}
 	}
 
 	if (CList::ManuallyHandleKeys(ev) == IN_HANDLED)
 		result = IN_HANDLED;
 
 	if (update_highlight)
 		m_ElementHighlight = m_Selected;
 
 	return result;
 }
 
 void CDropDown::SetupListRect()
 {
 	extern int g_yres;
 	extern float g_GuiScale;
 	const float yres = g_yres / g_GuiScale;
 
 	if (m_ItemsYPositions.empty())
 	{
 		m_CachedListRect = CRect(m_CachedActualSize.left, m_CachedActualSize.bottom + m_DropDownBuffer,
 		                         m_CachedActualSize.right, m_CachedActualSize.bottom + m_DropDownBuffer + m_DropDownSize);
 		m_HideScrollBar = false;
 	}
 	// Too many items so use a scrollbar
 	else if (m_ItemsYPositions.back() > m_DropDownSize)
 	{
 		// Place items below if at least some items can be placed below
 		if (m_CachedActualSize.bottom + m_DropDownBuffer + m_DropDownSize <= yres)
 			m_CachedListRect = CRect(m_CachedActualSize.left, m_CachedActualSize.bottom + m_DropDownBuffer,
 			                         m_CachedActualSize.right, m_CachedActualSize.bottom + m_DropDownBuffer + m_DropDownSize);
 		else if ((m_ItemsYPositions.size() > m_MinimumVisibleItems && yres - m_CachedActualSize.bottom - m_DropDownBuffer >= m_ItemsYPositions[m_MinimumVisibleItems]) ||
 		         m_CachedActualSize.top < yres - m_CachedActualSize.bottom)
 			m_CachedListRect = CRect(m_CachedActualSize.left, m_CachedActualSize.bottom + m_DropDownBuffer,
 			                         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 - m_DropDownBuffer - m_DropDownSize),
 			                         m_CachedActualSize.right, m_CachedActualSize.top - m_DropDownBuffer);
 
 		m_HideScrollBar = false;
 	}
 	else
 	{
 		// Enough space below, no scrollbar needed
 		if (m_CachedActualSize.bottom + m_DropDownBuffer + m_ItemsYPositions.back() <= yres)
 		{
 			m_CachedListRect = CRect(m_CachedActualSize.left, m_CachedActualSize.bottom + m_DropDownBuffer,
 			                         m_CachedActualSize.right, m_CachedActualSize.bottom + m_DropDownBuffer + 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() > m_MinimumVisibleItems && yres - m_CachedActualSize.bottom - m_DropDownBuffer >= m_ItemsYPositions[m_MinimumVisibleItems]) ||
 		         m_CachedActualSize.top < yres - m_CachedActualSize.bottom)
 		{
 			m_CachedListRect = CRect(m_CachedActualSize.left, m_CachedActualSize.bottom + m_DropDownBuffer,
 			                         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 - m_DropDownBuffer - m_ItemsYPositions.back()),
 			                         m_CachedActualSize.right, m_CachedActualSize.top - m_DropDownBuffer);
 			m_HideScrollBar = m_CachedActualSize.top > m_ItemsYPositions.back() + m_DropDownBuffer;
 		}
 	}
 }
 
 CRect CDropDown::GetListRect() const
 {
 	return m_CachedListRect;
 }
 
 bool CDropDown::IsMouseOver() const
 {
 	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()
 {
 	const float bz = GetBufferedZ();
 	const CGUISpriteInstance& sprite = m_Enabled ? m_Sprite : m_SpriteDisabled;
 
 	m_pGUI.DrawSprite(sprite, bz, m_CachedActualSize);
 
 	if (m_ButtonWidth > 0.f)
 	{
 		CRect rect(m_CachedActualSize.right - m_ButtonWidth, m_CachedActualSize.top,
 				   m_CachedActualSize.right, m_CachedActualSize.bottom);
 
 		if (!m_Enabled)
 		{
-			m_pGUI.DrawSprite(m_Sprite2Disabled ? m_Sprite2Disabled : m_Sprite2, bz + 0.05f, rect);
+			m_pGUI.DrawSprite(*m_Sprite2Disabled ? m_Sprite2Disabled : m_Sprite2, bz + 0.05f, rect);
 		}
 		else if (m_Open)
 		{
-			m_pGUI.DrawSprite(m_Sprite2Pressed ? m_Sprite2Pressed : m_Sprite2, bz + 0.05f, rect);
+			m_pGUI.DrawSprite(*m_Sprite2Pressed ? m_Sprite2Pressed : m_Sprite2, bz + 0.05f, rect);
 		}
 		else if (m_MouseHovering)
 		{
-			m_pGUI.DrawSprite(m_Sprite2Over ? m_Sprite2Over : m_Sprite2, bz + 0.05f, rect);
+			m_pGUI.DrawSprite(*m_Sprite2Over ? m_Sprite2Over : m_Sprite2, bz + 0.05f, rect);
 		}
 		else
 			m_pGUI.DrawSprite(m_Sprite2, bz + 0.05f, rect);
 	}
 
 	if (m_Selected != -1) // TODO: Maybe check validity completely?
 	{
 		CRect cliparea(m_CachedActualSize.left, m_CachedActualSize.top,
 					   m_CachedActualSize.right - m_ButtonWidth, m_CachedActualSize.bottom);
 
 		CVector2D pos(m_CachedActualSize.left, m_CachedActualSize.top);
 		DrawText(m_Selected, m_Enabled ? m_TextColorSelected : m_TextColorDisabled, pos, bz + 0.1f, cliparea);
 	}
 
 	if (m_Open)
 	{
 		// Disable scrollbar during drawing without sending a setting-changed message
 		const bool old = m_ScrollBar;
 
 		// TODO: drawScrollbar as an argument of DrawList?
 		if (m_HideScrollBar)
-			m_ScrollBar = false;
+			m_ScrollBar.Set(false, false);
 
 		DrawList(m_ElementHighlight, m_SpriteList, m_SpriteSelectArea, m_TextColor);
 
 		if (m_HideScrollBar)
-			m_ScrollBar = old;
+			m_ScrollBar.Set(old, false);
 	}
 }
 
 // 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/ObjectTypes/CDropDown.h
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CDropDown.h	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CDropDown.h	(revision 25392)
@@ -1,144 +1,143 @@
 /* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /*
 GUI Object - Drop Down (list)
 
 --Overview--
 
 	Works just like a list-box, but it hides
 	all the elements that aren't selected. They
 	can be brought up by pressing the control.
 */
 
 #ifndef INCLUDED_CDROPDOWN
 #define INCLUDED_CDROPDOWN
 
 #include "gui/CGUISprite.h"
 #include "gui/ObjectBases/IGUIObject.h"
 #include "gui/ObjectTypes/CList.h"
 #include "maths/Vector2D.h"
 
 #include <string>
 
 /**
  * Drop Down
  *
  * The control can be pressed, but we will not inherent
  * this behavior from IGUIButtonBehavior, because when
  * you press this control, the list with elements will
  * immediately appear, and not first after release
  * (which is the whole gist of the IGUIButtonBehavior).
  */
 class CDropDown : public CList
 {
 	GUI_OBJECT(CDropDown)
 
 public:
 	CDropDown(CGUI& pGUI);
 	virtual ~CDropDown();
 
 	/**
 	 * @see IGUIObject#HandleMessage()
 	 */
 	virtual void HandleMessage(SGUIMessage& Message);
 
 	/**
 	 * Handle events manually to catch keyboard inputting.
 	 */
 	virtual InReaction ManuallyHandleKeys(const SDL_Event_* ev);
 
 	/**
 	 * Draws the Button
 	 */
 	virtual void Draw();
 
 	// This is one of the few classes we actually need to redefine this function
 	//  this is because the size of the control changes whether it is open
 	//  or closed.
 	virtual bool IsMouseOver() const;
 
 	virtual float GetBufferedZ() const;
 
 protected:
 	/**
 	 * If the size changed, the texts have to be updated as
 	 * the word wrapping depends on the size.
 	 */
 	virtual void UpdateCachedSize();
 
 	/**
 	 * Sets up text, should be called every time changes has been
 	 * made that can change the visual.
 	 */
 	void SetupText();
 
 	// Sets up the cached GetListRect. Decided whether it should
 	//  have a scrollbar, and so on.
 	virtual void SetupListRect();
 
 	// Specify a new List rectangle.
 	virtual CRect GetListRect() const;
 
 	/**
 	 * Placement of text.
 	 */
 	CVector2D m_TextPos;
 
 	// Is the dropdown opened?
 	bool m_Open;
 
 	// I didn't cache this at first, but it's just as easy as caching
 	//  m_CachedActualSize, so I thought, what the heck it's used a lot.
 	CRect m_CachedListRect;
 
 	// Hide scrollbar when it's not needed
 	bool m_HideScrollBar;
 
 	// Not necessarily the element that is selected, this is just
 	//  which element should be highlighted. When opening the dropdown
 	//  it is set to "selected", but then when moving the mouse it will
 	//  change.
 	int m_ElementHighlight;
 
 	// Stores any text entered by the user for quick access to an element
 	// (ie if you type "acro" it will take you to acropolis).
 	std::string m_InputBuffer;
 
 	// used to know if we want to restart anew or add to m_inputbuffer.
 	double m_TimeOfLastInput;
 
 	// Settings
-	float m_ButtonWidth;
-	float m_DropDownSize;
-	float m_DropDownBuffer;
-	u32 m_MinimumVisibleItems;
-	CStrW m_SoundClosed;
-	CStrW m_SoundEnter;
-	CStrW m_SoundLeave;
-	CStrW m_SoundOpened;
-	CGUISpriteInstance m_SpriteDisabled;
-	CGUISpriteInstance m_SpriteList;
-	CGUISpriteInstance m_Sprite2;
-	CGUISpriteInstance m_Sprite2Over;
-	CGUISpriteInstance m_Sprite2Pressed;
-	CGUISpriteInstance m_Sprite2Disabled;
-	CGUIColor m_TextColorDisabled;
-	EVAlign m_TextVAlign;
+	CGUISimpleSetting<float> m_ButtonWidth;
+	CGUISimpleSetting<float> m_DropDownSize;
+	CGUISimpleSetting<float> m_DropDownBuffer;
+	CGUISimpleSetting<u32> m_MinimumVisibleItems;
+	CGUISimpleSetting<CStrW> m_SoundClosed;
+	CGUISimpleSetting<CStrW> m_SoundEnter;
+	CGUISimpleSetting<CStrW> m_SoundLeave;
+	CGUISimpleSetting<CStrW> m_SoundOpened;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteDisabled;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteList;
+	CGUISimpleSetting<CGUISpriteInstance> m_Sprite2;
+	CGUISimpleSetting<CGUISpriteInstance> m_Sprite2Over;
+	CGUISimpleSetting<CGUISpriteInstance> m_Sprite2Pressed;
+	CGUISimpleSetting<CGUISpriteInstance> m_Sprite2Disabled;
+	CGUISimpleSetting<CGUIColor> m_TextColorDisabled;
 };
 
 #endif // INCLUDED_CDROPDOWN
Index: ps/trunk/source/gui/ObjectTypes/CHotkeyPicker.cpp
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CHotkeyPicker.cpp	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CHotkeyPicker.cpp	(revision 25392)
@@ -1,194 +1,193 @@
-/* Copyright (C) 2020 Wildfire Games.
+/* Copyright (C) 2021 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 "CHotkeyPicker.h"
 
 #include "gui/ObjectBases/IGUIObject.h"
 #include "lib/timer.h"
 #include "ps/CLogger.h"
 #include "ps/Hotkey.h"
 #include "ps/KeyName.h"
 #include "scriptinterface/ScriptConversions.h"
 
 
 const CStr CHotkeyPicker::EventNameCombination = "Combination";
 const CStr CHotkeyPicker::EventNameKeyChange = "KeyChange";
 
 // Don't send the scancode, JS doesn't care.
 template<> void ScriptInterface::ToJSVal(const ScriptRequest& rq, JS::MutableHandleValue ret, const CHotkeyPicker::Key& val)
 {
 	ScriptInterface::ToJSVal(rq, ret, val.scancodeName);
 }
 
 // Unused, but JSVAL_VECTOR requires it.
 template<> bool ScriptInterface::FromJSVal(const ScriptRequest&, const JS::HandleValue, CHotkeyPicker::Key&)
 {
 	LOGWARNING("FromJSVal<CHotkeyPicker>: Not implemented");
 	return false;
 }
 
 JSVAL_VECTOR(CHotkeyPicker::Key);
 
-CHotkeyPicker::CHotkeyPicker(CGUI& pGUI) : IGUIObject(pGUI), m_TimeToCombination(1.f)
+CHotkeyPicker::CHotkeyPicker(CGUI& pGUI) : IGUIObject(pGUI), m_TimeToCombination(this, "time_to_combination", 1.f)
 {
-	RegisterSetting("time_to_combination", m_TimeToCombination);
 	// 8 keys at the same time is probably more than we'll ever need.
 	m_KeysPressed.reserve(8);
 }
 
 CHotkeyPicker::~CHotkeyPicker()
 {
 }
 
 void CHotkeyPicker::FireEvent(const CStr& event)
 {
 	ScriptRequest rq(*m_pGUI.GetScriptInterface());
 
 	JS::RootedValueArray<1> args(rq.cx);
 	JS::RootedValue keys(rq.cx);
 	m_pGUI.GetScriptInterface()->ToJSVal(rq, &keys, m_KeysPressed);
 	args[0].set(keys);
 	ScriptEvent(event, args);
 }
 
 void CHotkeyPicker::Tick()
 {
 	if (m_KeysPressed.size() == 0)
 		return;
 
 	double time = timer_Time();
 	if (time - m_LastKeyChange < m_TimeToCombination)
 		return;
 
 	FireEvent(EventNameCombination);
 
 	return;
 }
 
 void CHotkeyPicker::HandleMessage(SGUIMessage& Message)
 {
 	IGUIObject::HandleMessage(Message);
 	switch (Message.type)
 	{
 	case GUIM_GOT_FOCUS:
 	case GUIM_LOST_FOCUS:
 	{
 		m_KeysPressed.clear();
 		m_LastKeyChange = timer_Time();
 		break;
 	}
 	default:
 		break;
 	}
 }
 
 InReaction CHotkeyPicker::PreemptEvent(const SDL_Event_* ev)
 {
 	switch (ev->ev.type)
 	{
 	// Handle the same mouse events that hotkeys handle
 	case SDL_MOUSEBUTTONDOWN:
 	case SDL_MOUSEBUTTONUP:
 	case SDL_MOUSEWHEEL:
 	{
 		SDL_Scancode scancode;
 
 		if (ev->ev.type != SDL_MOUSEWHEEL)
 		{
 			// Wait a little bit -> this gets triggered when clicking on a button,
 			// but after the button click is processed, thus immediately triggering...
 			if (timer_Time()-m_LastKeyChange < 0.2)
 				return IN_HANDLED;
 			// This is from hotkeyHandler - not sure what it does in all honesty.
 			if(ev->ev.button.button >= SDL_BUTTON_X1)
 				scancode = static_cast<SDL_Scancode>(MOUSE_BASE + (int)ev->ev.button.button + 2);
 			else
 				scancode = static_cast<SDL_Scancode>(MOUSE_BASE + (int)ev->ev.button.button);
 		}
 		else
 		{
 			if (ev->ev.wheel.y > 0)
 				scancode = static_cast<SDL_Scancode>(MOUSE_WHEELUP);
 			else if (ev->ev.wheel.y < 0)
 				scancode = static_cast<SDL_Scancode>(MOUSE_WHEELDOWN);
 			else if (ev->ev.wheel.x > 0)
 				scancode = static_cast<SDL_Scancode>(MOUSE_X2);
 			else if (ev->ev.wheel.x < 0)
 				scancode = static_cast<SDL_Scancode>(MOUSE_X1);
 			else
 				return IN_HANDLED;
 		}
 		// Don't handle keys and mouse together except for modifiers.
 		m_KeysPressed.erase(std::remove_if(m_KeysPressed.begin(), m_KeysPressed.end(), [](const Key& k) {
 			return static_cast<int>(k.code) < UNIFIED_SHIFT || static_cast<int>(k.code) >= UNIFIED_LAST; } ), m_KeysPressed.end());
 		m_KeysPressed.emplace_back(Key{scancode, FindScancodeName(scancode)});
 		// For mouse events, assume we immediately want to return.
 		FireEvent(EventNameCombination);
 
 		return IN_HANDLED;
 	}
 	case SDL_KEYDOWN:
 	case SDL_KEYUP:
 	{
 		SDL_Scancode scancode = ev->ev.key.keysym.scancode;
 
 		// Don't handle caps-lock, it doesn't really work in-game and it's a weird hotkey.
 		if (scancode == SDL_SCANCODE_CAPSLOCK)
 			return IN_PASS;
 
 		if (scancode == SDL_SCANCODE_LSHIFT || scancode == SDL_SCANCODE_RSHIFT)
 			scancode = static_cast<SDL_Scancode>(UNIFIED_SHIFT);
 		else if (scancode == SDL_SCANCODE_LCTRL || scancode == SDL_SCANCODE_RCTRL)
 			scancode = static_cast<SDL_Scancode>(UNIFIED_CTRL);
 		else if (scancode == SDL_SCANCODE_LALT || scancode == SDL_SCANCODE_RALT)
 			scancode = static_cast<SDL_Scancode>(UNIFIED_ALT);
 		else if (scancode == SDL_SCANCODE_LGUI || scancode == SDL_SCANCODE_RGUI)
 			scancode = static_cast<SDL_Scancode>(UNIFIED_SUPER);
 
 		if (ev->ev.type == SDL_KEYDOWN)
 		{
 			std::vector<Key>::const_iterator it = \
 				std::find_if(m_KeysPressed.begin(), m_KeysPressed.end(), [&scancode](Key& k) { return k.code == scancode; });
 			// Can happen if multiple keys are mapped the same.
 			if (it != m_KeysPressed.end())
 				return IN_HANDLED;
 			m_KeysPressed.emplace_back(Key{scancode, FindScancodeName(scancode)});
 		}
 		else
 		{
 			std::vector<Key>::const_iterator it = \
 				std::find_if(m_KeysPressed.begin(), m_KeysPressed.end(), [&scancode](Key& k) { return k.code == scancode; });
 			// Might happen if a key was down before this object is created.
 			if (it == m_KeysPressed.end())
 				return IN_HANDLED;
 			m_KeysPressed.erase(it);
 		}
 
 		FireEvent(EventNameKeyChange);
 
 		// Register after-JS in case this takes a while (probably not but it doesn't hurt).
 		m_LastKeyChange = timer_Time();
 		return IN_HANDLED;
 	}
 	default:
 	{
 		return IN_PASS;
 	}
 	}
 }
Index: ps/trunk/source/gui/ObjectTypes/CHotkeyPicker.h
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CHotkeyPicker.h	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CHotkeyPicker.h	(revision 25392)
@@ -1,80 +1,80 @@
-/* Copyright (C) 2020 Wildfire Games.
+/* Copyright (C) 2021 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_CHOTKEYPICKER
 #define INCLUDED_CHOTKEYPICKER
 
 #include "gui/CGUI.h"
 #include "gui/ObjectBases/IGUIObject.h"
 #include "lib/external_libraries/libsdl.h"
 #include "ps/CStr.h"
 
 #include <vector>
 
 class ScriptInterface;
 
 /**
  * When in focus, returns all currently pressed keys.
  * After a set time without changes, it will trigger a "combination" event.
  *
  * Used to create new hotkey combinations in-game. Mostly custom.
  * This object does not draw anything.
  */
 class CHotkeyPicker : public IGUIObject
 {
 	GUI_OBJECT(CHotkeyPicker)
 
 	friend class ScriptInterface;
 public:
 	CHotkeyPicker(CGUI& pGUI);
 	virtual ~CHotkeyPicker();
 
 	// Do nothing.
 	virtual void Draw() {};
 
 	// Checks if the timer has passed and we need to fire a "combination" event.
 	virtual void Tick();
 
 	// React to blur/focus.
 	virtual void HandleMessage(SGUIMessage& Message);
 
 	// Pre-empt events: this is our sole purpose.
 	virtual InReaction PreemptEvent(const SDL_Event_* ev);
 protected:
 	// Fire an event with m_KeysPressed as argument.
 	void FireEvent(const CStr& event);
 
 	// Time without changes until a "combination" event is sent.
-	float m_TimeToCombination;
+	CGUISimpleSetting<float> m_TimeToCombination;
 	// Time of the last registered key change.
 	double m_LastKeyChange;
 
 	// Keep track of which keys we are pressing, and precompute their name for JS code.
 	struct Key
 	{
 		// The scancode is used for fast comparisons.
 		SDL_Scancode code;
 		// This is the name ultimately stored in the config file.
 		CStr scancodeName;
 	};
 	std::vector<Key> m_KeysPressed;
 
 	static const CStr EventNameCombination;
 	static const CStr EventNameKeyChange;
 };
 
 #endif // INCLUDED_CHOTKEYPICKER
Index: ps/trunk/source/gui/ObjectTypes/CImage.cpp
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CImage.cpp	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CImage.cpp	(revision 25392)
@@ -1,38 +1,37 @@
 /* Copyright (C) 2021 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 "CImage.h"
 
 #include "gui/CGUI.h"
 
 CImage::CImage(CGUI& pGUI)
 	: IGUIObject(pGUI),
-	  m_Sprite()
+	  m_Sprite(this, "sprite")
 {
-	RegisterSetting("sprite", m_Sprite);
 }
 
 CImage::~CImage()
 {
 }
 
 void CImage::Draw()
 {
 	m_pGUI.DrawSprite(m_Sprite, GetBufferedZ(), m_CachedActualSize);
 }
Index: ps/trunk/source/gui/ObjectTypes/CImage.h
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CImage.h	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CImage.h	(revision 25392)
@@ -1,52 +1,51 @@
 /* Copyright (C) 2021 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_CIMAGE
 #define INCLUDED_CIMAGE
 
 #include "gui/CGUISprite.h"
 #include "gui/ObjectBases/IGUIObject.h"
 
 /**
  * Object just for drawing a sprite. Like CText, without the
  * possibility to draw text.
  *
  * Created, because I've seen the user being indecisive about
  * what control to use in these situations. I've seen button
  * without functionality used, and that is a lot of unnecessary
  * overhead. That's why I thought I'd go with an intuitive
  * control.
  */
 class CImage : public IGUIObject
 {
 	GUI_OBJECT(CImage)
 
 public:
 	CImage(CGUI& pGUI);
 	virtual ~CImage();
 
 protected:
 	/**
 	 * Draws the Image
 	 */
 	virtual void Draw();
 
-	// Settings
-	CGUISpriteInstance m_Sprite;
+	CGUISimpleSetting<CGUISpriteInstance> m_Sprite;
 };
 
 #endif // INCLUDED_CIMAGE
Index: ps/trunk/source/gui/ObjectTypes/CInput.cpp
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CInput.cpp	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CInput.cpp	(revision 25392)
@@ -1,2111 +1,2114 @@
 /* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "CInput.h"
 
 #include "graphics/FontMetrics.h"
 #include "graphics/ShaderManager.h"
 #include "graphics/TextRenderer.h"
 #include "gui/CGUI.h"
 #include "gui/CGUIScrollBarVertical.h"
 #include "lib/timer.h"
 #include "lib/utf8.h"
 #include "ps/ConfigDB.h"
 #include "ps/GameSetup/Config.h"
 #include "ps/Globals.h"
 #include "ps/Hotkey.h"
 #include "renderer/Renderer.h"
 
 #include <sstream>
 
 extern int g_yres;
 
 const CStr CInput::EventNameTextEdit = "TextEdit";
 const CStr CInput::EventNamePress = "Press";
 const CStr CInput::EventNameTab = "Tab";
 
 CInput::CInput(CGUI& pGUI)
 	:
 	IGUIObject(pGUI),
 	IGUIScrollBarOwner(*static_cast<IGUIObject*>(this)),
 	m_iBufferPos(-1),
 	m_iBufferPos_Tail(-1),
 	m_SelectingText(),
 	m_HorizontalScroll(),
 	m_PrevTime(),
 	m_CursorVisState(true),
 	m_CursorBlinkRate(0.5),
 	m_ComposingText(),
 	m_GeneratedPlaceholderTextValid(false),
 	m_iComposedLength(),
 	m_iComposedPos(),
 	m_iInsertPos(),
-	m_BufferPosition(),
-	m_BufferZone(),
-	m_Caption(),
-	m_Font(),
-	m_MaskChar(),
-	m_Mask(),
-	m_MaxLength(),
-	m_MultiLine(),
-	m_Readonly(),
-	m_ScrollBar(),
-	m_ScrollBarStyle(),
-	m_Sprite(),
-	m_SpriteSelectArea(),
-	m_TextColor(),
-	m_TextColorSelected()
-{
-	RegisterSetting("buffer_position", m_BufferPosition);
-	RegisterSetting("buffer_zone", m_BufferZone);
-	RegisterSetting("caption", m_Caption);
-	RegisterSetting("font", m_Font);
-	RegisterSetting("mask_char", m_MaskChar);
-	RegisterSetting("mask", m_Mask);
-	RegisterSetting("max_length", m_MaxLength);
-	RegisterSetting("multiline", m_MultiLine);
-	RegisterSetting("readonly", m_Readonly);
-	RegisterSetting("scrollbar", m_ScrollBar);
-	RegisterSetting("scrollbar_style", m_ScrollBarStyle);
-	RegisterSetting("sprite", m_Sprite);
-	RegisterSetting("sprite_selectarea", m_SpriteSelectArea);
-	RegisterSetting("textcolor", m_TextColor);
-	RegisterSetting("textcolor_selected", m_TextColorSelected);
-	RegisterSetting("placeholder_text", m_PlaceholderText);
-	RegisterSetting("placeholder_color", m_PlaceholderColor);
-
+	m_BufferPosition(this, "buffer_position"),
+	m_BufferZone(this, "buffer_zone"),
+	m_Caption(this, "caption"),
+	m_Font(this, "font"),
+	m_MaskChar(this, "mask_char"),
+	m_Mask(this, "mask"),
+	m_MaxLength(this, "max_length"),
+	m_MultiLine(this, "multiline"),
+	m_Readonly(this, "readonly"),
+	m_ScrollBar(this, "scrollbar"),
+	m_ScrollBarStyle(this, "scrollbar_style"),
+	m_Sprite(this, "sprite"),
+	m_SpriteSelectArea(this, "sprite_selectarea"),
+	m_TextColor(this, "textcolor"),
+	m_TextColorSelected(this, "textcolor_selected"),
+	m_PlaceholderText(this, "placeholder_text"),
+	m_PlaceholderColor(this, "placeholder_color")
+{
 	CFG_GET_VAL("gui.cursorblinkrate", m_CursorBlinkRate);
 
 	CGUIScrollBarVertical* bar = new CGUIScrollBarVertical(pGUI);
 	bar->SetRightAligned(true);
 	AddScrollBar(bar);
 }
 
 CInput::~CInput()
 {
 }
 
 void CInput::UpdateBufferPositionSetting()
 {
-	SetSetting<i32>("buffer_position", m_iBufferPos, false);
+	m_BufferPosition.Set(m_iBufferPos, false);
 }
 
 void CInput::ClearComposedText()
 {
-	m_Caption.erase(m_iInsertPos, m_iComposedLength);
+	m_Caption.GetMutable().erase(m_iInsertPos, m_iComposedLength);
 	m_iBufferPos = m_iInsertPos;
 	UpdateBufferPositionSetting();
 	m_iComposedLength = 0;
 	m_iComposedPos = 0;
 }
 
 InReaction CInput::ManuallyHandleKeys(const SDL_Event_* ev)
 {
 	ENSURE(m_iBufferPos != -1);
 
+	// Get direct access to silently mutate m_Caption.
+	// (Messages don't currently need to be sent)
+	CStrW& caption = m_Caption.GetMutable();
+
 	switch (ev->ev.type)
 	{
 	case SDL_HOTKEYDOWN:
 	{
 		if (m_ComposingText)
 			return IN_HANDLED;
 
 		return ManuallyHandleHotkeyEvent(ev);
 	}
 	// SDL2 has a new method of text input that better supports Unicode and CJK
 	// see https://wiki.libsdl.org/Tutorials/TextInput
 	case SDL_TEXTINPUT:
 	{
 		if (m_Readonly)
 			return IN_PASS;
 
 		// Text has been committed, either single key presses or through an IME
 		std::wstring text = wstring_from_utf8(ev->ev.text.text);
 
 		// Check max length
-		if (m_MaxLength != 0 && m_Caption.length() + text.length() > static_cast<size_t>(m_MaxLength))
+		if (m_MaxLength != 0 && caption.length() + text.length() > static_cast<size_t>(m_MaxLength))
 			return IN_HANDLED;
 
 		m_WantedX = 0.0f;
 
 		if (SelectingText())
 			DeleteCurSelection();
 
 		if (m_ComposingText)
 		{
 			ClearComposedText();
 			m_ComposingText = false;
 		}
 
-		if (m_iBufferPos == static_cast<int>(m_Caption.length()))
-			m_Caption.append(text);
+		if (m_iBufferPos == static_cast<int>(caption.length()))
+			caption.append(text);
 		else
-			m_Caption.insert(m_iBufferPos, text);
+			caption.insert(m_iBufferPos, text);
 
 		UpdateText(m_iBufferPos, m_iBufferPos, m_iBufferPos+1);
 
 		m_iBufferPos += text.length();
 		UpdateBufferPositionSetting();
 		m_iBufferPos_Tail = -1;
 
 		UpdateAutoScroll();
 		SendEvent(GUIM_TEXTEDIT, EventNameTextEdit);
 
 		return IN_HANDLED;
 	}
 	case SDL_TEXTEDITING:
 	{
 		if (m_Readonly)
 			return IN_PASS;
 
 		// Text is being composed with an IME
 		// TODO: indicate this by e.g. underlining the uncommitted text
 		const char* rawText = ev->ev.edit.text;
 		int rawLength = strlen(rawText);
 		std::wstring wtext = wstring_from_utf8(rawText);
 
 		m_WantedX = 0.0f;
 
 		if (SelectingText())
 			DeleteCurSelection();
 
 		// Remember cursor position when text composition begins
 		if (!m_ComposingText)
 			m_iInsertPos = m_iBufferPos;
 		else
 		{
 			// Composed text is replaced each time
 			ClearComposedText();
 		}
 
 		m_ComposingText = ev->ev.edit.start != 0 || rawLength != 0;
 		if (m_ComposingText)
 		{
-			m_Caption.insert(m_iInsertPos, wtext);
+			caption.insert(m_iInsertPos, wtext);
 
 			// The text buffer is limited to SDL_TEXTEDITINGEVENT_TEXT_SIZE bytes, yet start
 			// increases without limit, so don't let it advance beyond the composed text length
 			m_iComposedLength = wtext.length();
 			m_iComposedPos = ev->ev.edit.start < m_iComposedLength ? ev->ev.edit.start : m_iComposedLength;
 			m_iBufferPos = m_iInsertPos + m_iComposedPos;
 
 			// TODO: composed text selection - what does ev.edit.length do?
 			m_iBufferPos_Tail = -1;
 		}
 
 		UpdateBufferPositionSetting();
 		UpdateText(m_iBufferPos, m_iBufferPos, m_iBufferPos+1);
 
 		UpdateAutoScroll();
 		SendEvent(GUIM_TEXTEDIT, EventNameTextEdit);
 
 		return IN_HANDLED;
 	}
 	case SDL_KEYDOWN:
 	case SDL_KEYUP:
 	{
 		// Since the GUI framework doesn't handle to set settings
 		//  in Unicode (CStrW), we'll simply retrieve the actual
 		//  pointer and edit that.
 		SDL_Keycode keyCode = ev->ev.key.keysym.sym;
 
 		// We have a probably printable key - we should return HANDLED so it can't trigger hotkeys.
 		// However, if Ctrl/Meta modifiers are active, just pass it through instead,
 		// assuming that we are indeed trying to trigger hotkeys (e.g. copy/paste).
 		// Escape & the "cancel" hotkey are also passed through to allow closing dialogs easily.
 		// See also similar logic in CConsole.cpp
 		// NB: this assumes that Ctrl/GUI aren't used in the Manually* functions below,
 		// as those code paths would obviously never be taken.
 		if (keyCode == SDLK_ESCAPE || EventWillFireHotkey(ev, "cancel") ||
 		     g_scancodes[SDL_SCANCODE_LCTRL] || g_scancodes[SDL_SCANCODE_RCTRL] ||
 		     g_scancodes[SDL_SCANCODE_LGUI] || g_scancodes[SDL_SCANCODE_RGUI])
 			return IN_PASS;
 
 		if (m_ComposingText)
 			return IN_HANDLED;
 
 		if (ev->ev.type == SDL_KEYDOWN)
 		{
 			ManuallyImmutableHandleKeyDownEvent(keyCode);
 			ManuallyMutableHandleKeyDownEvent(keyCode);
 
 			UpdateBufferPositionSetting();
 		}
 		return IN_HANDLED;
 	}
 	default:
 	{
 		return IN_PASS;
 	}
 	}
 }
 
 void CInput::ManuallyMutableHandleKeyDownEvent(const SDL_Keycode keyCode)
 {
 	if (m_Readonly)
 		return;
 
 	wchar_t cooked = 0;
 
+	// Get direct access to silently mutate m_Caption.
+	// (Messages don't currently need to be sent)
+	CStrW& caption = m_Caption.GetMutable();
+
 	switch (keyCode)
 	{
 	case SDLK_TAB:
 	{
 		SendEvent(GUIM_TAB, EventNameTab);
 		// Don't send a textedit event, because it should only
 		// be sent if the GUI control changes the text
 		break;
 	}
 	case SDLK_BACKSPACE:
 	{
 		m_WantedX = 0.0f;
 
 		if (SelectingText())
 			DeleteCurSelection();
 		else
 		{
 			m_iBufferPos_Tail = -1;
 
-			if (m_Caption.empty() || m_iBufferPos == 0)
+			if (caption.empty() || m_iBufferPos == 0)
 				break;
 
-			if (m_iBufferPos == static_cast<int>(m_Caption.length()))
-				m_Caption = m_Caption.Left(static_cast<long>(m_Caption.length()) - 1);
+			if (m_iBufferPos == static_cast<int>(caption.length()))
+				caption = caption.Left(static_cast<long>(caption.length()) - 1);
 			else
-				m_Caption =
-					m_Caption.Left(m_iBufferPos - 1) +
-					m_Caption.Right(static_cast<long>(m_Caption.length()) - m_iBufferPos);
+				caption =
+					caption.Left(m_iBufferPos - 1) +
+					caption.Right(static_cast<long>(caption.length()) - m_iBufferPos);
 
 			--m_iBufferPos;
 
 			UpdateText(m_iBufferPos, m_iBufferPos + 1, m_iBufferPos);
 		}
 
 		UpdateAutoScroll();
 		SendEvent(GUIM_TEXTEDIT, EventNameTextEdit);
 		break;
 	}
 	case SDLK_DELETE:
 	{
 		m_WantedX = 0.0f;
 
 		if (SelectingText())
 			DeleteCurSelection();
 		else
 		{
-			if (m_Caption.empty() || m_iBufferPos == static_cast<int>(m_Caption.length()))
+			if (caption.empty() || m_iBufferPos == static_cast<int>(caption.length()))
 				break;
 
-			m_Caption =
-				m_Caption.Left(m_iBufferPos) +
-				m_Caption.Right(static_cast<long>(m_Caption.length()) - (m_iBufferPos + 1));
+			caption =
+				caption.Left(m_iBufferPos) +
+				caption.Right(static_cast<long>(caption.length()) - (m_iBufferPos + 1));
 
 			UpdateText(m_iBufferPos, m_iBufferPos + 1, m_iBufferPos);
 		}
 
 		UpdateAutoScroll();
 		SendEvent(GUIM_TEXTEDIT, EventNameTextEdit);
 		break;
 	}
 	case SDLK_KP_ENTER:
 	case SDLK_RETURN:
 	{
 		// 'Return' should do a Press event for single liners (e.g. submitting forms)
 		//  otherwise a '\n' character will be added.
 		if (!m_MultiLine)
 		{
 			SendEvent(GUIM_PRESSED, EventNamePress);
 			break;
 		}
 
 		cooked = '\n'; // Change to '\n' and do default:
 		FALLTHROUGH;
 	}
 	default: // Insert a character
 	{
 		// Regular input is handled via SDL_TEXTINPUT, so we should ignore it here.
 		if (cooked == 0)
 			return;
 
 		// Check max length
-		if (m_MaxLength != 0 && m_Caption.length() >= static_cast<size_t>(m_MaxLength))
+		if (m_MaxLength != 0 && caption.length() >= static_cast<size_t>(m_MaxLength))
 			break;
 
 		m_WantedX = 0.0f;
 
 		if (SelectingText())
 			DeleteCurSelection();
 		m_iBufferPos_Tail = -1;
 
-		if (m_iBufferPos == static_cast<int>(m_Caption.length()))
-			m_Caption += cooked;
+		if (m_iBufferPos == static_cast<int>(caption.length()))
+			caption += cooked;
 		else
-			m_Caption =
-				m_Caption.Left(m_iBufferPos) + cooked +
-				m_Caption.Right(static_cast<long>(m_Caption.length()) - m_iBufferPos);
+			caption =
+				caption.Left(m_iBufferPos) + cooked +
+				caption.Right(static_cast<long>(caption.length()) - m_iBufferPos);
 
 		UpdateText(m_iBufferPos, m_iBufferPos, m_iBufferPos + 1);
 
 		++m_iBufferPos;
 
 		UpdateAutoScroll();
 		SendEvent(GUIM_TEXTEDIT, EventNameTextEdit);
 		break;
 	}
 	}
 }
 
 void CInput::ManuallyImmutableHandleKeyDownEvent(const SDL_Keycode keyCode)
 {
 	bool shiftKeyPressed = g_scancodes[SDL_SCANCODE_LSHIFT] || g_scancodes[SDL_SCANCODE_RSHIFT];
 
+	const CStrW& caption = *m_Caption;
+
 	switch (keyCode)
 	{
 	case SDLK_HOME:
 	{
 		// If there's not a selection, we should create one now
 		if (!shiftKeyPressed)
 		{
 			// Make sure a selection isn't created.
 			m_iBufferPos_Tail = -1;
 		}
 		else if (!SelectingText())
 		{
 			// Place tail at the current point:
 			m_iBufferPos_Tail = m_iBufferPos;
 		}
 
 		m_iBufferPos = 0;
 		m_WantedX = 0.0f;
 
 		UpdateAutoScroll();
 		break;
 	}
 	case SDLK_END:
 	{
 		// If there's not a selection, we should create one now
 		if (!shiftKeyPressed)
 		{
 			// Make sure a selection isn't created.
 			m_iBufferPos_Tail = -1;
 		}
 		else if (!SelectingText())
 		{
 			// Place tail at the current point:
 			m_iBufferPos_Tail = m_iBufferPos;
 		}
 
-		m_iBufferPos = static_cast<long>(m_Caption.length());
+		m_iBufferPos = static_cast<long>(caption.length());
 		m_WantedX = 0.0f;
 
 		UpdateAutoScroll();
 		break;
 	}
 	/**
 	 * Conventions for Left/Right when text is selected:
 	 *
 	 * References:
 	 *
 	 * Visual Studio
 	 *  Visual Studio has the 'newer' approach, used by newer versions of
 	 * things, and in newer applications. A left press will always place
 	 * the pointer on the left edge of the selection, and then of course
 	 * remove the selection. Right will do the exact same thing.
 	 * If you have the pointer on the right edge and press right, it will
 	 * in other words just remove the selection.
 	 *
 	 * Windows (eg. Notepad)
 	 *  A left press always takes the pointer a step to the left and
 	 * removes the selection as if it were never there in the first place.
 	 * Right of course does the same thing but to the right.
 	 *
 	 * I chose the Visual Studio convention. Used also in Word, gtk 2.0, MSN
 	 * Messenger.
 	 */
 	case SDLK_LEFT:
 	{
 		m_WantedX = 0.f;
 
 		if (shiftKeyPressed || !SelectingText())
 		{
 			if (!shiftKeyPressed)
 				m_iBufferPos_Tail = -1;
 			else if (!SelectingText())
 				m_iBufferPos_Tail = m_iBufferPos;
 
 			if (m_iBufferPos > 0)
 				--m_iBufferPos;
 		}
 		else
 		{
 			if (m_iBufferPos_Tail < m_iBufferPos)
 				m_iBufferPos = m_iBufferPos_Tail;
 
 			m_iBufferPos_Tail = -1;
 		}
 
 		UpdateAutoScroll();
 		break;
 	}
 	case SDLK_RIGHT:
 	{
 		m_WantedX = 0.0f;
 
 		if (shiftKeyPressed || !SelectingText())
 		{
 			if (!shiftKeyPressed)
 				m_iBufferPos_Tail = -1;
 			else if (!SelectingText())
 				m_iBufferPos_Tail = m_iBufferPos;
 
-			if (m_iBufferPos < static_cast<int>(m_Caption.length()))
+			if (m_iBufferPos < static_cast<int>(caption.length()))
 				++m_iBufferPos;
 		}
 		else
 		{
 			if (m_iBufferPos_Tail > m_iBufferPos)
 				m_iBufferPos = m_iBufferPos_Tail;
 
 			m_iBufferPos_Tail = -1;
 		}
 
 		UpdateAutoScroll();
 		break;
 	}
 	/**
 	 * Conventions for Up/Down when text is selected:
 	 *
 	 * References:
 	 *
 	 * Visual Studio
 	 *  Visual Studio has a very strange approach, down takes you below the
 	 * selection to the next row, and up to the one prior to the whole
 	 * selection. The weird part is that it is always aligned as the
 	 * 'pointer'. I decided this is to much work for something that is
 	 * a bit arbitrary
 	 *
 	 * Windows (eg. Notepad)
 	 *  Just like with left/right, the selection is destroyed and it moves
 	 * just as if there never were a selection.
 	 *
 	 * I chose the Notepad convention even though I use the VS convention with
 	 * left/right.
 	 */
 	case SDLK_UP:
 	{
 		if (!shiftKeyPressed)
 			m_iBufferPos_Tail = -1;
 		else if (!SelectingText())
 			m_iBufferPos_Tail = m_iBufferPos;
 
 		std::list<SRow>::iterator current = m_CharacterPositions.begin();
 		while (current != m_CharacterPositions.end())
 		{
 			if (m_iBufferPos >= current->m_ListStart &&
 			    m_iBufferPos <= current->m_ListStart + (int)current->m_ListOfX.size())
 				break;
 
 			++current;
 		}
 
 		float pos_x;
 		if (m_iBufferPos - current->m_ListStart == 0)
 			pos_x = 0.f;
 		else
 			pos_x = current->m_ListOfX[m_iBufferPos - current->m_ListStart - 1];
 
 		if (m_WantedX > pos_x)
 			pos_x = m_WantedX;
 
 		// Now change row:
 		if (current != m_CharacterPositions.begin())
 		{
 			--current;
 
 			// Find X-position:
 			m_iBufferPos = current->m_ListStart + GetXTextPosition(current, pos_x, m_WantedX);
 		}
 		// else we can't move up
 
 		UpdateAutoScroll();
 		break;
 	}
 	case SDLK_DOWN:
 	{
 		if (!shiftKeyPressed)
 			m_iBufferPos_Tail = -1;
 		else if (!SelectingText())
 			m_iBufferPos_Tail = m_iBufferPos;
 
 		std::list<SRow>::iterator current = m_CharacterPositions.begin();
 		while (current != m_CharacterPositions.end())
 		{
 			if (m_iBufferPos >= current->m_ListStart &&
 			    m_iBufferPos <= current->m_ListStart + (int)current->m_ListOfX.size())
 				break;
 
 			++current;
 		}
 
 		float pos_x;
 
 		if (m_iBufferPos - current->m_ListStart == 0)
 			pos_x = 0.f;
 		else
 			pos_x = current->m_ListOfX[m_iBufferPos - current->m_ListStart - 1];
 
 		if (m_WantedX > pos_x)
 			pos_x = m_WantedX;
 
 		// Now change row:
 		// Add first, so we can check if it's .end()
 		++current;
 		if (current != m_CharacterPositions.end())
 		{
 			// Find X-position:
 			m_iBufferPos = current->m_ListStart + GetXTextPosition(current, pos_x, m_WantedX);
 		}
 		// else we can't move up
 
 		UpdateAutoScroll();
 		break;
 	}
 	case SDLK_PAGEUP:
 	{
 		GetScrollBar(0).ScrollMinusPlenty();
 		UpdateAutoScroll();
 		break;
 	}
 	case SDLK_PAGEDOWN:
 	{
 		GetScrollBar(0).ScrollPlusPlenty();
 		UpdateAutoScroll();
 		break;
 	}
 	default:
 	{
 		break;
 	}
 	}
 }
 
 void CInput::SetupGeneratedPlaceholderText()
 {
-	m_GeneratedPlaceholderText = CGUIText(m_pGUI, m_PlaceholderText, m_Font, 0, m_BufferZone, this);
+	m_GeneratedPlaceholderText = CGUIText(m_pGUI, m_PlaceholderText, m_Font, 0, m_BufferZone, EAlign::LEFT, this);
 	m_GeneratedPlaceholderTextValid = true;
 }
 
 InReaction CInput::ManuallyHandleHotkeyEvent(const SDL_Event_* ev)
 {
 	bool shiftKeyPressed = g_scancodes[SDL_SCANCODE_LSHIFT] || g_scancodes[SDL_SCANCODE_RSHIFT];
 
 	std::string hotkey = static_cast<const char*>(ev->ev.user.data1);
 
+	// Get direct access to silently mutate m_Caption.
+	// (Messages don't currently need to be sent)
+	CStrW& caption = m_Caption.GetMutable();
+
 	if (hotkey == "paste")
 	{
 		if (m_Readonly)
 			return IN_PASS;
 
 		m_WantedX = 0.0f;
 
 		char* utf8_text = SDL_GetClipboardText();
 		if (!utf8_text)
 			return IN_HANDLED;
 
 		std::wstring text = wstring_from_utf8(utf8_text);
 		SDL_free(utf8_text);
 
 		// Check max length
-		if (m_MaxLength != 0 && m_Caption.length() + text.length() > static_cast<size_t>(m_MaxLength))
-			text = text.substr(0, static_cast<size_t>(m_MaxLength) - m_Caption.length());
+		if (m_MaxLength != 0 && caption.length() + text.length() > static_cast<size_t>(m_MaxLength))
+			text = text.substr(0, static_cast<size_t>(m_MaxLength) - caption.length());
 
 		if (SelectingText())
 			DeleteCurSelection();
 
-		if (m_iBufferPos == static_cast<int>(m_Caption.length()))
-			m_Caption += text;
+		if (m_iBufferPos == static_cast<int>(caption.length()))
+			caption += text;
 		else
-			m_Caption =
-				m_Caption.Left(m_iBufferPos) + text +
-				m_Caption.Right(static_cast<long>(m_Caption.length()) - m_iBufferPos);
+			caption =
+				caption.Left(m_iBufferPos) + text +
+				caption.Right(static_cast<long>(caption.length()) - m_iBufferPos);
 
 		UpdateText(m_iBufferPos, m_iBufferPos, m_iBufferPos+1);
 
 		m_iBufferPos += static_cast<int>(text.size());
 		UpdateAutoScroll();
 		UpdateBufferPositionSetting();
 
 		SendEvent(GUIM_TEXTEDIT, EventNameTextEdit);
 
 		return IN_HANDLED;
 	}
 	else if (hotkey == "copy" || hotkey == "cut")
 	{
 		if (m_Readonly && hotkey == "cut")
 			return IN_PASS;
 
 		m_WantedX = 0.0f;
 
 		if (SelectingText())
 		{
 			int virtualFrom;
 			int virtualTo;
 
 			if (m_iBufferPos_Tail >= m_iBufferPos)
 			{
 				virtualFrom = m_iBufferPos;
 				virtualTo = m_iBufferPos_Tail;
 			}
 			else
 			{
 				virtualFrom = m_iBufferPos_Tail;
 				virtualTo = m_iBufferPos;
 			}
 
-			CStrW text = m_Caption.Left(virtualTo).Right(virtualTo - virtualFrom);
+			CStrW text = caption.Left(virtualTo).Right(virtualTo - virtualFrom);
 
 			SDL_SetClipboardText(text.ToUTF8().c_str());
 
 			if (hotkey == "cut")
 			{
 				DeleteCurSelection();
 				UpdateAutoScroll();
 				SendEvent(GUIM_TEXTEDIT, EventNameTextEdit);
 			}
 		}
 
 		return IN_HANDLED;
 	}
 	else if (hotkey == "text.delete.left")
 	{
 		if (m_Readonly)
 			return IN_PASS;
 
 		m_WantedX = 0.0f;
 
 		if (SelectingText())
 			DeleteCurSelection();
 
-		if (!m_Caption.empty() && m_iBufferPos != 0)
+		if (!caption.empty() && m_iBufferPos != 0)
 		{
 			m_iBufferPos_Tail = m_iBufferPos;
-			CStrW searchString = m_Caption.Left(m_iBufferPos);
+			CStrW searchString = caption.Left(m_iBufferPos);
 
 			// If we are starting in whitespace, adjust position until we get a non whitespace
 			while (m_iBufferPos > 0)
 			{
 				if (!iswspace(searchString[m_iBufferPos - 1]))
 					break;
 
 				m_iBufferPos--;
 			}
 
 			// If we end up on a punctuation char we just delete it (treat punct like a word)
 			if (iswpunct(searchString[m_iBufferPos - 1]))
 				m_iBufferPos--;
 			else
 			{
 				// Now we are on a non white space character, adjust position to char after next whitespace char is found
 				while (m_iBufferPos > 0)
 				{
 					if (iswspace(searchString[m_iBufferPos - 1]) || iswpunct(searchString[m_iBufferPos - 1]))
 						break;
 
 					m_iBufferPos--;
 				}
 			}
 
 			UpdateBufferPositionSetting();
 			DeleteCurSelection();
 			SendEvent(GUIM_TEXTEDIT, EventNameTextEdit);
 		}
 		UpdateAutoScroll();
 		return IN_HANDLED;
 	}
 	else if (hotkey == "text.delete.right")
 	{
 		if (m_Readonly)
 			return IN_PASS;
 
 		m_WantedX = 0.0f;
 
 		if (SelectingText())
 			DeleteCurSelection();
 
-		if (!m_Caption.empty() && m_iBufferPos < static_cast<int>(m_Caption.length()))
+		if (!caption.empty() && m_iBufferPos < static_cast<int>(caption.length()))
 		{
 			// Delete the word to the right of the cursor
 			m_iBufferPos_Tail = m_iBufferPos;
 
 			// Delete chars to the right unit we hit whitespace
-			while (++m_iBufferPos < static_cast<int>(m_Caption.length()))
+			while (++m_iBufferPos < static_cast<int>(caption.length()))
 			{
-				if (iswspace(m_Caption[m_iBufferPos]) || iswpunct(m_Caption[m_iBufferPos]))
+				if (iswspace(caption[m_iBufferPos]) || iswpunct(caption[m_iBufferPos]))
 					break;
 			}
 
 			// Eliminate any whitespace behind the word we just deleted
-			while (m_iBufferPos < static_cast<int>(m_Caption.length()))
+			while (m_iBufferPos < static_cast<int>(caption.length()))
 			{
-				if (!iswspace(m_Caption[m_iBufferPos]))
+				if (!iswspace(caption[m_iBufferPos]))
 					break;
 
 				++m_iBufferPos;
 			}
 			UpdateBufferPositionSetting();
 			DeleteCurSelection();
 		}
 		UpdateAutoScroll();
 		SendEvent(GUIM_TEXTEDIT, EventNameTextEdit);
 		return IN_HANDLED;
 	}
 	else if (hotkey == "text.move.left")
 	{
 		m_WantedX = 0.0f;
 
 		if (shiftKeyPressed || !SelectingText())
 		{
 			if (!shiftKeyPressed)
 				m_iBufferPos_Tail = -1;
 			else if (!SelectingText())
 				m_iBufferPos_Tail = m_iBufferPos;
 
-			if (!m_Caption.empty() && m_iBufferPos != 0)
+			if (!caption.empty() && m_iBufferPos != 0)
 			{
-				CStrW searchString = m_Caption.Left(m_iBufferPos);
+				CStrW searchString = caption.Left(m_iBufferPos);
 
 				// If we are starting in whitespace, adjust position until we get a non whitespace
 				while (m_iBufferPos > 0)
 				{
 					if (!iswspace(searchString[m_iBufferPos - 1]))
 						break;
 
 					m_iBufferPos--;
 				}
 
 				// If we end up on a puctuation char we just select it (treat punct like a word)
 				if (iswpunct(searchString[m_iBufferPos - 1]))
 					m_iBufferPos--;
 				else
 				{
 					// Now we are on a non white space character, adjust position to char after next whitespace char is found
 					while (m_iBufferPos > 0)
 					{
 						if (iswspace(searchString[m_iBufferPos - 1]) || iswpunct(searchString[m_iBufferPos - 1]))
 							break;
 
 						m_iBufferPos--;
 					}
 				}
 			}
 		}
 		else
 		{
 			if (m_iBufferPos_Tail < m_iBufferPos)
 				m_iBufferPos = m_iBufferPos_Tail;
 
 			m_iBufferPos_Tail = -1;
 		}
 
 		UpdateBufferPositionSetting();
 		UpdateAutoScroll();
 
 		return IN_HANDLED;
 	}
 	else if (hotkey == "text.move.right")
 	{
 		m_WantedX = 0.0f;
 
 		if (shiftKeyPressed || !SelectingText())
 		{
 			if (!shiftKeyPressed)
 				m_iBufferPos_Tail = -1;
 			else if (!SelectingText())
 				m_iBufferPos_Tail = m_iBufferPos;
 
-			if (!m_Caption.empty() && m_iBufferPos < static_cast<int>(m_Caption.length()))
+			if (!caption.empty() && m_iBufferPos < static_cast<int>(caption.length()))
 			{
 				// Select chars to the right until we hit whitespace
-				while (++m_iBufferPos < static_cast<int>(m_Caption.length()))
+				while (++m_iBufferPos < static_cast<int>(caption.length()))
 				{
-					if (iswspace(m_Caption[m_iBufferPos]) || iswpunct(m_Caption[m_iBufferPos]))
+					if (iswspace(caption[m_iBufferPos]) || iswpunct(caption[m_iBufferPos]))
 						break;
 				}
 
 				// Also select any whitespace following the word we just selected
-				while (m_iBufferPos < static_cast<int>(m_Caption.length()))
+				while (m_iBufferPos < static_cast<int>(caption.length()))
 				{
-					if (!iswspace(m_Caption[m_iBufferPos]))
+					if (!iswspace(caption[m_iBufferPos]))
 						break;
 
 					++m_iBufferPos;
 				}
 			}
 		}
 		else
 		{
 			if (m_iBufferPos_Tail > m_iBufferPos)
 				m_iBufferPos = m_iBufferPos_Tail;
 
 			m_iBufferPos_Tail = -1;
 		}
 
 		UpdateBufferPositionSetting();
 		UpdateAutoScroll();
 
 		return IN_HANDLED;
 	}
 
 	return IN_PASS;
 }
 
 void CInput::ResetStates()
 {
 	IGUIObject::ResetStates();
 	IGUIScrollBarOwner::ResetStates();
 }
 
 void CInput::HandleMessage(SGUIMessage& Message)
 {
 	IGUIObject::HandleMessage(Message);
 	IGUIScrollBarOwner::HandleMessage(Message);
 
+	// Cleans up operator[] usage.
+	const CStrW& caption = *m_Caption;
+
 	switch (Message.type)
 	{
 	case GUIM_SETTINGS_UPDATED:
 	{
 		// Update scroll-bar
 		// TODO Gee: (2004-09-01) Is this really updated each time it should?
 		if (m_ScrollBar &&
 			(Message.value == "size" ||
 			 Message.value == "z" ||
 			 Message.value == "absolute"))
 		{
 			GetScrollBar(0).SetX(m_CachedActualSize.right);
 			GetScrollBar(0).SetY(m_CachedActualSize.top);
 			GetScrollBar(0).SetZ(GetBufferedZ());
 			GetScrollBar(0).SetLength(m_CachedActualSize.bottom - m_CachedActualSize.top);
 		}
 
 		// Update scrollbar
 		if (Message.value == "scrollbar_style")
 			GetScrollBar(0).SetScrollBarStyle(m_ScrollBarStyle);
 
 		if (Message.value == "buffer_position")
 		{
 			m_iBufferPos = m_MaxLength != 0 ? std::min(m_MaxLength, m_BufferPosition) : m_BufferPosition;
 			m_iBufferPos_Tail = -1; // position change resets selection
 		}
 
 		if (Message.value == "size" ||
 			Message.value == "z" ||
 			Message.value == "font" ||
 			Message.value == "absolute" ||
 			Message.value == "caption" ||
 			Message.value == "scrollbar" ||
 			Message.value == "scrollbar_style")
 		{
 			UpdateText();
 		}
 
 		if (Message.value == "multiline")
 		{
 			if (!m_MultiLine)
 				GetScrollBar(0).SetLength(0.f);
 			else
 				GetScrollBar(0).SetLength(m_CachedActualSize.bottom - m_CachedActualSize.top);
 
 			UpdateText();
 		}
 
 		if (Message.value == "placeholder_text" ||
 			Message.value == "size" ||
 			Message.value == "font" ||
 			Message.value == "z" ||
 			Message.value == "text_valign")
 		{
 			m_GeneratedPlaceholderTextValid = false;
 		}
 
 		UpdateAutoScroll();
 
 		break;
 	}
 	case GUIM_MOUSE_PRESS_LEFT:
 	{
 		// Check if we're selecting the scrollbar
 		if (m_ScrollBar &&
 		    m_MultiLine &&
 		    GetScrollBar(0).GetStyle())
 		{
 			if (m_pGUI.GetMousePos().X > m_CachedActualSize.right - GetScrollBar(0).GetStyle()->m_Width)
 				break;
 		}
 
 		if (m_ComposingText)
 			break;
 
 		// Okay, this section is about pressing the mouse and
 		//  choosing where the point should be placed. For
 		//  instance, if we press between a and b, the point
 		//  should of course be placed accordingly. Other
 		//  special cases are handled like the input box norms.
 		if (g_scancodes[SDL_SCANCODE_LSHIFT] || g_scancodes[SDL_SCANCODE_RSHIFT])
 			m_iBufferPos = GetMouseHoveringTextPosition();
 		else
 			m_iBufferPos = m_iBufferPos_Tail = GetMouseHoveringTextPosition();
 
 		m_SelectingText = true;
 
 		UpdateAutoScroll();
 
 		// If we immediately release the button it will just be seen as a click
 		//  for the user though.
 		break;
 	}
 	case GUIM_MOUSE_DBLCLICK_LEFT:
 	{
 		if (m_ComposingText)
 			break;
 
-		if (m_Caption.empty())
+		if (caption.empty())
 			break;
 
 		m_iBufferPos = m_iBufferPos_Tail = GetMouseHoveringTextPosition();
 
-		if (m_iBufferPos >= (int)m_Caption.length())
-			m_iBufferPos = m_iBufferPos_Tail = m_Caption.length() - 1;
+		if (m_iBufferPos >= (int)caption.length())
+			m_iBufferPos = m_iBufferPos_Tail = caption.length() - 1;
 
 		// See if we are clicking over whitespace
-		if (iswspace(m_Caption[m_iBufferPos]))
+		if (iswspace(caption[m_iBufferPos]))
 		{
 			// see if we are in a section of whitespace greater than one character
-			if ((m_iBufferPos + 1 < (int) m_Caption.length() && iswspace(m_Caption[m_iBufferPos + 1])) ||
-				(m_iBufferPos - 1 > 0 && iswspace(m_Caption[m_iBufferPos - 1])))
+			if ((m_iBufferPos + 1 < (int) caption.length() && iswspace(caption[m_iBufferPos + 1])) ||
+				(m_iBufferPos - 1 > 0 && iswspace(caption[m_iBufferPos - 1])))
 			{
 				//
 				// We are clicking in an area with more than one whitespace character
 				// so we select both the word to the left and then the word to the right
 				//
 				// [1] First the left
 				// skip the whitespace
 				while (m_iBufferPos > 0)
 				{
-					if (!iswspace(m_Caption[m_iBufferPos - 1]))
+					if (!iswspace(caption[m_iBufferPos - 1]))
 						break;
 
 					m_iBufferPos--;
 				}
 				// now go until we hit white space or punctuation
 				while (m_iBufferPos > 0)
 				{
-					if (iswspace(m_Caption[m_iBufferPos - 1]))
+					if (iswspace(caption[m_iBufferPos - 1]))
 						break;
 
 					m_iBufferPos--;
 
-					if (iswpunct(m_Caption[m_iBufferPos]))
+					if (iswpunct(caption[m_iBufferPos]))
 						break;
 				}
 
 				// [2] Then the right
 				// go right until we are not in whitespace
-				while (++m_iBufferPos_Tail < static_cast<int>(m_Caption.length()))
+				while (++m_iBufferPos_Tail < static_cast<int>(caption.length()))
 				{
-					if (!iswspace(m_Caption[m_iBufferPos_Tail]))
+					if (!iswspace(caption[m_iBufferPos_Tail]))
 						break;
 				}
 
-				if (m_iBufferPos_Tail == static_cast<int>(m_Caption.length()))
+				if (m_iBufferPos_Tail == static_cast<int>(caption.length()))
 					break;
 
 				// now go to the right until we hit whitespace or punctuation
-				while (++m_iBufferPos_Tail < static_cast<int>(m_Caption.length()))
+				while (++m_iBufferPos_Tail < static_cast<int>(caption.length()))
 				{
-					if (iswspace(m_Caption[m_iBufferPos_Tail]) || iswpunct(m_Caption[m_iBufferPos_Tail]))
+					if (iswspace(caption[m_iBufferPos_Tail]) || iswpunct(caption[m_iBufferPos_Tail]))
 						break;
 				}
 			}
 			else
 			{
 				// single whitespace so select word to the right
-				while (++m_iBufferPos_Tail < static_cast<int>(m_Caption.length()))
+				while (++m_iBufferPos_Tail < static_cast<int>(caption.length()))
 				{
-					if (!iswspace(m_Caption[m_iBufferPos_Tail]))
+					if (!iswspace(caption[m_iBufferPos_Tail]))
 						break;
 				}
 
-				if (m_iBufferPos_Tail == static_cast<int>(m_Caption.length()))
+				if (m_iBufferPos_Tail == static_cast<int>(caption.length()))
 					break;
 
 				// Don't include the leading whitespace
 				m_iBufferPos = m_iBufferPos_Tail;
 
 				// now go to the right until we hit whitespace or punctuation
-				while (++m_iBufferPos_Tail < static_cast<int>(m_Caption.length()))
+				while (++m_iBufferPos_Tail < static_cast<int>(caption.length()))
 				{
-					if (iswspace(m_Caption[m_iBufferPos_Tail]) || iswpunct(m_Caption[m_iBufferPos_Tail]))
+					if (iswspace(caption[m_iBufferPos_Tail]) || iswpunct(caption[m_iBufferPos_Tail]))
 						break;
 				}
 			}
 		}
 		else
 		{
 			// clicked on non-whitespace so select current word
 			// go until we hit white space or punctuation
 			while (m_iBufferPos > 0)
 			{
-				if (iswspace(m_Caption[m_iBufferPos - 1]))
+				if (iswspace(caption[m_iBufferPos - 1]))
 					break;
 
 				m_iBufferPos--;
 
-				if (iswpunct(m_Caption[m_iBufferPos]))
+				if (iswpunct(caption[m_iBufferPos]))
 					break;
 			}
 			// go to the right until we hit whitespace or punctuation
-			while (++m_iBufferPos_Tail < static_cast<int>(m_Caption.length()))
-				if (iswspace(m_Caption[m_iBufferPos_Tail]) || iswpunct(m_Caption[m_iBufferPos_Tail]))
+			while (++m_iBufferPos_Tail < static_cast<int>(caption.length()))
+				if (iswspace(caption[m_iBufferPos_Tail]) || iswpunct(caption[m_iBufferPos_Tail]))
 					break;
 		}
 		UpdateAutoScroll();
 		break;
 	}
 	case GUIM_MOUSE_RELEASE_LEFT:
 	{
 		if (m_SelectingText)
 			m_SelectingText = false;
 		break;
 	}
 	case GUIM_MOUSE_MOTION:
 	{
 		// If we just pressed down and started to move before releasing
 		//  this is one way of selecting larger portions of text.
 		if (m_SelectingText)
 		{
 			// Actually, first we need to re-check that the mouse button is
 			//  really pressed (it can be released while outside the control.
 			if (!g_mouse_buttons[SDL_BUTTON_LEFT])
 				m_SelectingText = false;
 			else
 				m_iBufferPos = GetMouseHoveringTextPosition();
 			UpdateAutoScroll();
 		}
 		break;
 	}
 	case GUIM_LOAD:
 	{
 		GetScrollBar(0).SetX(m_CachedActualSize.right);
 		GetScrollBar(0).SetY(m_CachedActualSize.top);
 		GetScrollBar(0).SetZ(GetBufferedZ());
 		GetScrollBar(0).SetLength(m_CachedActualSize.bottom - m_CachedActualSize.top);
 		GetScrollBar(0).SetScrollBarStyle(m_ScrollBarStyle);
 
 		UpdateText();
 		UpdateAutoScroll();
 
 		break;
 	}
 	case GUIM_GOT_FOCUS:
 	{
 		m_iBufferPos = 0;
 		m_PrevTime = 0.0;
 		m_CursorVisState = false;
 
 		ResetActiveHotkeys();
 
 		// Tell the IME where to draw the candidate list
 		SDL_Rect rect;
 		rect.h = m_CachedActualSize.GetSize().Height;
 		rect.w = m_CachedActualSize.GetSize().Width;
 		rect.x = m_CachedActualSize.TopLeft().X;
 		rect.y = m_CachedActualSize.TopLeft().Y;
 		SDL_SetTextInputRect(&rect);
 		SDL_StartTextInput();
 		break;
 	}
 	case GUIM_LOST_FOCUS:
 	{
 		if (m_ComposingText)
 		{
 			// Simulate a final text editing event to clear the composition
 			SDL_Event_ evt;
 			evt.ev.type = SDL_TEXTEDITING;
 			evt.ev.edit.length = 0;
 			evt.ev.edit.start = 0;
 			evt.ev.edit.text[0] = 0;
 			ManuallyHandleKeys(&evt);
 		}
 		SDL_StopTextInput();
 
 		m_iBufferPos = -1;
 		m_iBufferPos_Tail = -1;
 		break;
 	}
 	default:
 	{
 		break;
 	}
 	}
 	UpdateBufferPositionSetting();
 }
 
 void CInput::UpdateCachedSize()
 {
 	// If an ancestor's size changed, this will let us intercept the change and
 	// update our scrollbar positions
 
 	IGUIObject::UpdateCachedSize();
 
 	if (m_ScrollBar)
 	{
 		GetScrollBar(0).SetX(m_CachedActualSize.right);
 		GetScrollBar(0).SetY(m_CachedActualSize.top);
 		GetScrollBar(0).SetZ(GetBufferedZ());
 		GetScrollBar(0).SetLength(m_CachedActualSize.bottom - m_CachedActualSize.top);
 	}
 
 	m_GeneratedPlaceholderTextValid = false;
 }
 
 void CInput::Draw()
 {
 	float bz = GetBufferedZ();
 
 	if (m_CursorBlinkRate > 0.0)
 	{
 		// check if the cursor visibility state needs to be changed
 		double currTime = timer_Time();
 		if (currTime - m_PrevTime >= m_CursorBlinkRate)
 		{
 			m_CursorVisState = !m_CursorVisState;
 			m_PrevTime = currTime;
 		}
 	}
 	else
 		// should always be visible
 		m_CursorVisState = true;
 
 	// First call draw on ScrollBarOwner
 	if (m_ScrollBar && m_MultiLine)
 		IGUIScrollBarOwner::Draw();
 
-	CStrIntern font_name(m_Font.ToUTF8());
+	CStrIntern font_name(m_Font->ToUTF8());
 
 	wchar_t mask_char = L'*';
-	if (m_Mask && m_MaskChar.length() > 0)
-		mask_char = m_MaskChar[0];
+	if (m_Mask && m_MaskChar->length() > 0)
+		mask_char = (*m_MaskChar)[0];
 
 	m_pGUI.DrawSprite(m_Sprite, bz, m_CachedActualSize);
 
 	float scroll = 0.f;
 	if (m_ScrollBar && m_MultiLine)
 		scroll = GetScrollBar(0).GetPos();
 
 	CFontMetrics font(font_name);
 
 	// We'll have to setup clipping manually, since we're doing the rendering manually.
 	CRect cliparea(m_CachedActualSize);
 
 	// First we'll figure out the clipping area, which is the cached actual size
 	//  substracted by an optional scrollbar
 	if (m_ScrollBar)
 	{
 		scroll = GetScrollBar(0).GetPos();
 
 		// substract scrollbar from cliparea
 		if (cliparea.right > GetScrollBar(0).GetOuterRect().left &&
 		    cliparea.right <= GetScrollBar(0).GetOuterRect().right)
 			cliparea.right = GetScrollBar(0).GetOuterRect().left;
 
 		if (cliparea.left >= GetScrollBar(0).GetOuterRect().left &&
 		    cliparea.left < GetScrollBar(0).GetOuterRect().right)
 			cliparea.left = GetScrollBar(0).GetOuterRect().right;
 	}
 
 	if (cliparea != CRect())
 	{
 		glEnable(GL_SCISSOR_TEST);
 		glScissor(
 			cliparea.left * g_GuiScale,
 			g_yres - cliparea.bottom * g_GuiScale,
 			cliparea.GetWidth() * g_GuiScale,
 			cliparea.GetHeight() * g_GuiScale);
 	}
 
 	// These are useful later.
 	int VirtualFrom, VirtualTo;
 
 	if (m_iBufferPos_Tail >= m_iBufferPos)
 	{
 		VirtualFrom = m_iBufferPos;
 		VirtualTo = m_iBufferPos_Tail;
 	}
 	else
 	{
 		VirtualFrom = m_iBufferPos_Tail;
 		VirtualTo = m_iBufferPos;
 	}
 
 	// Get the height of this font.
 	float h = (float)font.GetHeight();
 	float ls = (float)font.GetLineSpacing();
 
 	CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_gui_text);
 
 	CTextRenderer textRenderer(tech->GetShader());
 	textRenderer.Font(font_name);
 
 	// Set the Z to somewhat more, so we can draw a selected area between the
 	//  the control and the text.
 	textRenderer.Translate(
 		(float)(int)(m_CachedActualSize.left) + m_BufferZone,
 		(float)(int)(m_CachedActualSize.top+h) + m_BufferZone,
 		bz+0.1f);
 
 	// U+FE33: PRESENTATION FORM FOR VERTICAL LOW LINE
 	// (sort of like a | which is aligned to the left of most characters)
 
 	float buffered_y = -scroll + m_BufferZone;
 
 	// When selecting larger areas, we need to draw a rectangle box
 	//  around it, and this is to keep track of where the box
 	//  started, because we need to follow the iteration until we
 	//  reach the end, before we can actually draw it.
 	bool drawing_box = false;
 	float box_x = 0.f;
 
 	float x_pointer = 0.f;
 
 	// If we have a selecting box (i.e. when you have selected letters, not just when
 	//  the pointer is between two letters) we need to process all letters once
 	//  before we do it the second time and render all the text. We can't do it
 	//  in the same loop because text will have been drawn, so it will disappear when
 	//  drawn behind the text that has already been drawn. Confusing, well it's necessary
 	//  (I think).
 
 	if (SelectingText())
 	{
 		// Now m_iBufferPos_Tail can be of both sides of m_iBufferPos,
 		//  just like you can select from right to left, as you can
 		//  left to right. Is there a difference? Yes, the pointer
 		//  be placed accordingly, so that if you select shift and
 		//  expand this selection, it will expand on appropriate side.
 		// Anyway, since the drawing procedure needs "To" to be
 		//  greater than from, we need virtual values that might switch
 		//  place.
 		int virtualFrom = 0;
 		int virtualTo = 0;
 
 		if (m_iBufferPos_Tail >= m_iBufferPos)
 		{
 			virtualFrom = m_iBufferPos;
 			virtualTo = m_iBufferPos_Tail;
 		}
 		else
 		{
 			virtualFrom = m_iBufferPos_Tail;
 			virtualTo = m_iBufferPos;
 		}
 
 
 		bool done = false;
 		for (std::list<SRow>::const_iterator it = m_CharacterPositions.begin();
 		     it != m_CharacterPositions.end();
 		     ++it, buffered_y += ls, x_pointer = 0.f)
 		{
 			if (m_MultiLine && buffered_y > m_CachedActualSize.GetHeight())
 				break;
 
 			// We might as well use 'i' here to iterate, because we need it
 			// (often compared against ints, so don't make it size_t)
 			for (int i = 0; i < (int)it->m_ListOfX.size()+2; ++i)
 			{
 				if (it->m_ListStart + i == virtualFrom)
 				{
 					// we won't actually draw it now, because we don't
 					//  know the width of each glyph to that position.
 					//  we need to go along with the iteration, and
 					//  make a mark where the box started:
 					drawing_box = true; // will turn false when finally rendered.
 
 					// Get current x position
 					box_x = x_pointer;
 				}
 
 				const bool at_end = (i == (int)it->m_ListOfX.size()+1);
 
 				if (drawing_box && (it->m_ListStart + i == virtualTo || at_end))
 				{
 					// Depending on if it's just a row change, or if it's
 					//  the end of the select box, do slightly different things.
 					if (at_end)
 					{
 						if (it->m_ListStart + i != virtualFrom)
 							// and actually add a white space! yes, this is done in any common input
 							x_pointer += font.GetCharacterWidth(L' ');
 					}
 					else
 					{
 						drawing_box = false;
 						done = true;
 					}
 
 					CRect rect;
 					// Set 'rect' depending on if it's a multiline control, or a one-line control
 					if (m_MultiLine)
 					{
 						rect = CRect(
 							m_CachedActualSize.left + box_x + m_BufferZone,
 							m_CachedActualSize.top + buffered_y + (h - ls) / 2,
 							m_CachedActualSize.left + x_pointer + m_BufferZone,
 							m_CachedActualSize.top + buffered_y + (h + ls) / 2);
 
 						if (rect.bottom < m_CachedActualSize.top)
 							continue;
 
 						if (rect.top < m_CachedActualSize.top)
 							rect.top = m_CachedActualSize.top;
 
 						if (rect.bottom > m_CachedActualSize.bottom)
 							rect.bottom = m_CachedActualSize.bottom;
 					}
 					else // if one-line
 					{
 						rect = CRect(
 							m_CachedActualSize.left + box_x + m_BufferZone - m_HorizontalScroll,
 							m_CachedActualSize.top + buffered_y + (h - ls) / 2,
 							m_CachedActualSize.left + x_pointer + m_BufferZone - m_HorizontalScroll,
 							m_CachedActualSize.top + buffered_y + (h + ls) / 2);
 
 						if (rect.left < m_CachedActualSize.left)
 							rect.left = m_CachedActualSize.left;
 
 						if (rect.right > m_CachedActualSize.right)
 							rect.right = m_CachedActualSize.right;
 					}
 
 					m_pGUI.DrawSprite(m_SpriteSelectArea, bz + 0.05f, rect);
 				}
 
 				if (i < (int)it->m_ListOfX.size())
 				{
 					if (!m_Mask)
-						x_pointer += font.GetCharacterWidth(m_Caption[it->m_ListStart + i]);
+						x_pointer += font.GetCharacterWidth((*m_Caption)[it->m_ListStart + i]);
 					else
 						x_pointer += font.GetCharacterWidth(mask_char);
 				}
 			}
 
 			if (done)
 				break;
 
 			// If we're about to draw a box, and all of a sudden changes
 			//  line, we need to draw that line's box, and then reset
 			//  the box drawing to the beginning of the new line.
 			if (drawing_box)
 				box_x = 0.f;
 		}
 	}
 
 	// Reset some from previous run
 	buffered_y = -scroll;
 
 	// Setup initial color (then it might change and change back, when drawing selected area)
 	textRenderer.Color(m_TextColor);
 
 	tech->BeginPass();
 
 	bool using_selected_color = false;
 
 	for (std::list<SRow>::const_iterator it = m_CharacterPositions.begin();
 	     it != m_CharacterPositions.end();
 	     ++it, buffered_y += ls)
 	{
 		if (buffered_y + m_BufferZone >= -ls || !m_MultiLine)
 		{
 			if (m_MultiLine && buffered_y + m_BufferZone > m_CachedActualSize.GetHeight())
 				break;
 
 			CMatrix3D savedTransform = textRenderer.GetTransform();
 
 			// Text must always be drawn in integer values. So we have to convert scroll
 			if (m_MultiLine)
 				textRenderer.Translate(0.f, -(float)(int)scroll, 0.f);
 			else
 				textRenderer.Translate(-(float)(int)m_HorizontalScroll, 0.f, 0.f);
 
 			// We might as well use 'i' here, because we need it
 			// (often compared against ints, so don't make it size_t)
 			for (int i = 0; i < (int)it->m_ListOfX.size()+1; ++i)
 			{
 				if (!m_MultiLine && i < (int)it->m_ListOfX.size())
 				{
 					if (it->m_ListOfX[i] - m_HorizontalScroll < -m_BufferZone)
 					{
 						// We still need to translate the OpenGL matrix
 						if (i == 0)
 							textRenderer.Translate(it->m_ListOfX[i], 0.f, 0.f);
 						else
 							textRenderer.Translate(it->m_ListOfX[i] - it->m_ListOfX[i-1], 0.f, 0.f);
 
 						continue;
 					}
 				}
 
 				// End of selected area, change back color
 				if (SelectingText() && it->m_ListStart + i == VirtualTo)
 				{
 					using_selected_color = false;
 					textRenderer.Color(m_TextColor);
 				}
 
 				// selecting only one, then we need only to draw a cursor.
 				if (i != (int)it->m_ListOfX.size() && it->m_ListStart + i == m_iBufferPos && m_CursorVisState)
 					textRenderer.Put(0.0f, 0.0f, L"_");
 
 				// Drawing selected area
 				if (SelectingText() &&
 				    it->m_ListStart + i >= VirtualFrom &&
 				    it->m_ListStart + i < VirtualTo &&
 				    !using_selected_color)
 				{
 					using_selected_color = true;
 					textRenderer.Color(m_TextColorSelected);
 				}
 
 				if (i != (int)it->m_ListOfX.size())
 				{
 					if (!m_Mask)
-						textRenderer.PrintfAdvance(L"%lc", m_Caption[it->m_ListStart + i]);
+						textRenderer.PrintfAdvance(L"%lc", (*m_Caption)[it->m_ListStart + i]);
 					else
 						textRenderer.PrintfAdvance(L"%lc", mask_char);
 				}
 
 				// check it's now outside a one-liner, then we'll break
 				if (!m_MultiLine && i < (int)it->m_ListOfX.size() &&
 				    it->m_ListOfX[i] - m_HorizontalScroll > m_CachedActualSize.GetWidth() - m_BufferZone)
 					break;
 			}
 
 			if (it->m_ListStart + (int)it->m_ListOfX.size() == m_iBufferPos)
 			{
 				textRenderer.Color(m_TextColor);
 				if (m_CursorVisState)
 					textRenderer.PutAdvance(L"_");
 
 				if (using_selected_color)
 					textRenderer.Color(m_TextColorSelected);
 			}
 
 			textRenderer.SetTransform(savedTransform);
 		}
 
 		textRenderer.Translate(0.f, ls, 0.f);
 	}
 
 	textRenderer.Render();
 
 	if (cliparea != CRect())
 		glDisable(GL_SCISSOR_TEST);
 
 	tech->EndPass();
 
-	if (m_Caption.empty() && !m_PlaceholderText.GetRawString().empty())
+	if (m_Caption->empty() && !m_PlaceholderText->GetRawString().empty())
 		DrawPlaceholderText(bz, cliparea);
 }
 
 void CInput::DrawPlaceholderText(float z, const CRect& clipping)
 {
 	if (!m_GeneratedPlaceholderTextValid)
 		SetupGeneratedPlaceholderText();
 
 	m_GeneratedPlaceholderText.Draw(m_pGUI, m_PlaceholderColor, m_CachedActualSize.TopLeft(), z, clipping);
 }
 
 void CInput::UpdateText(int from, int to_before, int to_after)
 {
-	if (m_MaxLength != 0 && m_Caption.length() > static_cast<size_t>(m_MaxLength))
-		m_Caption = m_Caption.substr(0, m_MaxLength);
+	CStrW& caption = m_Caption.GetMutable();
+
+	if (m_MaxLength != 0 && caption.length() > static_cast<size_t>(m_MaxLength))
+		caption = caption.substr(0, m_MaxLength);
 
-	CStrIntern font_name(m_Font.ToUTF8());
+	CStrIntern font_name(m_Font->ToUTF8());
 
 	wchar_t mask_char = L'*';
-	if (m_Mask && m_MaskChar.length() > 0)
-		mask_char = m_MaskChar[0];
+	if (m_Mask && m_MaskChar->length() > 0)
+		mask_char = (*m_MaskChar)[0];
 
 	// Ensure positions are valid after caption changes
-	m_iBufferPos = std::min(m_iBufferPos, static_cast<int>(m_Caption.size()));
-	m_iBufferPos_Tail = std::min(m_iBufferPos_Tail, static_cast<int>(m_Caption.size()));
+	m_iBufferPos = std::min(m_iBufferPos, static_cast<int>(caption.size()));
+	m_iBufferPos_Tail = std::min(m_iBufferPos_Tail, static_cast<int>(caption.size()));
 	UpdateBufferPositionSetting();
 
 	if (font_name.empty())
 	{
 		// Destroy everything stored, there's no font, so there can be no data.
 		m_CharacterPositions.clear();
 		return;
 	}
 
 	SRow row;
 	row.m_ListStart = 0;
 
 	int to = 0;	// make sure it's initialized
 
 	if (to_before == -1)
-		to = static_cast<int>(m_Caption.length());
+		to = static_cast<int>(caption.length());
 
 	CFontMetrics font(font_name);
 
 	std::list<SRow>::iterator current_line;
 
 	// Used to ... TODO
 	int check_point_row_start = -1;
 	int check_point_row_end = -1;
 
 	// Reset
 	if (from == 0 && to_before == -1)
 	{
 		m_CharacterPositions.clear();
 		current_line = m_CharacterPositions.begin();
 	}
 	else
 	{
 		ENSURE(to_before != -1);
 
 		std::list<SRow>::iterator destroy_row_from;
 		std::list<SRow>::iterator destroy_row_to;
 		// Used to check if the above has been set to anything,
 		//  previously a comparison like:
 		//  destroy_row_from == std::list<SRow>::iterator()
 		// ... was used, but it didn't work with GCC.
 		bool destroy_row_from_used = false;
 		bool destroy_row_to_used = false;
 
 		// Iterate, and remove everything between 'from' and 'to_before'
 		//  actually remove the entire lines they are on, it'll all have
 		//  to be redone. And when going along, we'll delete a row at a time
 		//  when continuing to see how much more after 'to' we need to remake.
 		int i = 0;
 		for (std::list<SRow>::iterator it = m_CharacterPositions.begin();
 		     it != m_CharacterPositions.end();
 		     ++it, ++i)
 		{
 			if (!destroy_row_from_used && it->m_ListStart > from)
 			{
 				// Destroy the previous line, and all to 'to_before'
 				destroy_row_from = it;
 				--destroy_row_from;
 
 				destroy_row_from_used = true;
 
 				// For the rare case that we might remove characters to a word
 				//  so that it suddenly fits on the previous row,
 				//  we need to by standards re-do the whole previous line too
 				//  (if one exists)
 				if (destroy_row_from != m_CharacterPositions.begin())
 					--destroy_row_from;
 			}
 
 			if (!destroy_row_to_used && it->m_ListStart > to_before)
 			{
 				destroy_row_to = it;
 				destroy_row_to_used = true;
 
 				// If it isn't the last row, we'll add another row to delete,
 				//  just so we can see if the last restorted line is
 				//  identical to what it was before. If it isn't, then we'll
 				//  have to continue.
 				// 'check_point_row_start' is where we store how the that
 				//  line looked.
 				if (destroy_row_to != m_CharacterPositions.end())
 				{
 					check_point_row_start = destroy_row_to->m_ListStart;
 					check_point_row_end = check_point_row_start + (int)destroy_row_to->m_ListOfX.size();
 					if (destroy_row_to->m_ListOfX.empty())
 						++check_point_row_end;
 				}
 
 				++destroy_row_to;
 				break;
 			}
 		}
 
 		if (!destroy_row_from_used)
 		{
 			destroy_row_from = m_CharacterPositions.end();
 			--destroy_row_from;
 
 			// As usual, let's destroy another row back
 			if (destroy_row_from != m_CharacterPositions.begin())
 				--destroy_row_from;
 
 			current_line = destroy_row_from;
 		}
 
 		if (!destroy_row_to_used)
 		{
 			destroy_row_to = m_CharacterPositions.end();
 			check_point_row_start = -1;
 		}
 
 		// set 'from' to the row we'll destroy from
 		//  and 'to' to the row we'll destroy to
 		from = destroy_row_from->m_ListStart;
 
 		if (destroy_row_to != m_CharacterPositions.end())
 			to = destroy_row_to->m_ListStart; // notice it will iterate [from, to), so it will never reach to.
 		else
-			to = static_cast<int>(m_Caption.length());
+			to = static_cast<int>(caption.length());
 
 
 		// Setup the first row
 		row.m_ListStart = destroy_row_from->m_ListStart;
 
 		std::list<SRow>::iterator temp_it = destroy_row_to;
 		--temp_it;
 
 		current_line = m_CharacterPositions.erase(destroy_row_from, destroy_row_to);
 
 		// If there has been a change in number of characters
 		//  we need to change all m_ListStart that comes after
 		//  the interval we just destroyed. We'll change all
 		//  values with the delta change of the string length.
 		int delta = to_after - to_before;
 		if (delta != 0)
 		{
 			for (std::list<SRow>::iterator it = current_line;
 			     it != m_CharacterPositions.end();
 			     ++it)
 				it->m_ListStart += delta;
 
 			// Update our check point too!
 			check_point_row_start += delta;
 			check_point_row_end += delta;
 
-			if (to != static_cast<int>(m_Caption.length()))
+			if (to != static_cast<int>(caption.length()))
 				to += delta;
 		}
 	}
 
 	int last_word_started = from;
 	float x_pos = 0.f;
 
 	//if (to_before != -1)
 	//	return;
 
 	for (int i = from; i < to; ++i)
 	{
-		if (m_Caption[i] == L'\n' && m_MultiLine)
+		if (caption[i] == L'\n' && m_MultiLine)
 		{
-			if (i == to-1 && to != static_cast<int>(m_Caption.length()))
+			if (i == to-1 && to != static_cast<int>(caption.length()))
 				break; // it will be added outside
 
 			current_line = m_CharacterPositions.insert(current_line, row);
 			++current_line;
 
 			// Setup the next row:
 			row.m_ListOfX.clear();
 			row.m_ListStart = i+1;
 			x_pos = 0.f;
 		}
 		else
 		{
-			if (m_Caption[i] == L' '/* || TODO Gee (2004-10-13): the '-' disappears, fix.
-				m_Caption[i] == L'-'*/)
+			if (caption[i] == L' '/* || TODO Gee (2004-10-13): the '-' disappears, fix.
+				caption[i] == L'-'*/)
 				last_word_started = i+1;
 
 			if (!m_Mask)
-				x_pos += font.GetCharacterWidth(m_Caption[i]);
+				x_pos += font.GetCharacterWidth(caption[i]);
 			else
 				x_pos += font.GetCharacterWidth(mask_char);
 
 			if (x_pos >= GetTextAreaWidth() && m_MultiLine)
 			{
 				// The following decides whether it will word-wrap a word,
 				//  or if it's only one word on the line, where it has to
 				//  break the word apart.
 				if (last_word_started == row.m_ListStart)
 				{
 					last_word_started = i;
 					row.m_ListOfX.resize(row.m_ListOfX.size() - (i-last_word_started));
 					//row.m_ListOfX.push_back(x_pos);
 					//continue;
 				}
 				else
 				{
 					// regular word-wrap
 					row.m_ListOfX.resize(row.m_ListOfX.size() - (i-last_word_started+1));
 				}
 
 				// Now, create a new line:
 				//  notice: when we enter a newline, you can stand with the cursor
 				//  both before and after that character, being on different
 				//  rows. With automatic word-wrapping, that is not possible. Which
 				//  is intuitively correct.
 
 				current_line = m_CharacterPositions.insert(current_line, row);
 				++current_line;
 
 				// Setup the next row:
 				row.m_ListOfX.clear();
 				row.m_ListStart = last_word_started;
 
 				i = last_word_started-1;
 
 				x_pos = 0.f;
 			}
 			else
 				// Get width of this character:
 				row.m_ListOfX.push_back(x_pos);
 		}
 
 		// Check if it's the last iteration, and we're not revising the whole string
 		//  because in that case, more word-wrapping might be needed.
 		//  also check if the current line isn't the end
 		if (to_before != -1 && i == to-1 && current_line != m_CharacterPositions.end())
 		{
 			// check all rows and see if any existing
 			if (row.m_ListStart != check_point_row_start)
 			{
 				std::list<SRow>::iterator destroy_row_from;
 				std::list<SRow>::iterator destroy_row_to;
 				// Are used to check if the above has been set to anything,
 				//  previously a comparison like:
 				//  destroy_row_from == std::list<SRow>::iterator()
 				//  was used, but it didn't work with GCC.
 				bool destroy_row_from_used = false;
 				bool destroy_row_to_used = false;
 
 				// Iterate, and remove everything between 'from' and 'to_before'
 				//  actually remove the entire lines they are on, it'll all have
 				//  to be redone. And when going along, we'll delete a row at a time
 				//  when continuing to see how much more after 'to' we need to remake.
 
 				for (std::list<SRow>::iterator it = m_CharacterPositions.begin();
 				     it != m_CharacterPositions.end();
 				     ++it)
 				{
 					if (!destroy_row_from_used && it->m_ListStart > check_point_row_start)
 					{
 						// Destroy the previous line, and all to 'to_before'
 						//if (i >= 2)
 						//	destroy_row_from = it-2;
 						//else
 						//	destroy_row_from = it-1;
 						destroy_row_from = it;
 						destroy_row_from_used = true;
 						//--destroy_row_from;
 					}
 
 					if (!destroy_row_to_used && it->m_ListStart > check_point_row_end)
 					{
 						destroy_row_to = it;
 						destroy_row_to_used = true;
 
 						// If it isn't the last row, we'll add another row to delete,
 						//  just so we can see if the last restorted line is
 						//  identical to what it was before. If it isn't, then we'll
 						//  have to continue.
 						// 'check_point_row_start' is where we store how the that
 						//  line looked.
 						if (destroy_row_to != m_CharacterPositions.end())
 						{
 							check_point_row_start = destroy_row_to->m_ListStart;
 							check_point_row_end = check_point_row_start + (int)destroy_row_to->m_ListOfX.size();
 							if (destroy_row_to->m_ListOfX.empty())
 								++check_point_row_end;
 						}
 						else
 							check_point_row_start = check_point_row_end = -1;
 
 						++destroy_row_to;
 						break;
 					}
 				}
 
 				if (!destroy_row_from_used)
 				{
 					destroy_row_from = m_CharacterPositions.end();
 					--destroy_row_from;
 
 					current_line = destroy_row_from;
 				}
 
 				if (!destroy_row_to_used)
 				{
 					destroy_row_to = m_CharacterPositions.end();
 					check_point_row_start = check_point_row_end = -1;
 				}
 
 				if (destroy_row_to != m_CharacterPositions.end())
 					to = destroy_row_to->m_ListStart; // notice it will iterate [from, to[, so it will never reach to.
 				else
-					to = static_cast<int>(m_Caption.length());
+					to = static_cast<int>(caption.length());
 
 
 				// Set current line, new rows will be added before current_line, so
 				//  we'll choose the destroy_row_to, because it won't be deleted
 				//  in the coming erase.
 				current_line = destroy_row_to;
 
 				m_CharacterPositions.erase(destroy_row_from, destroy_row_to);
 			}
 			// else, the for loop will end naturally.
 		}
 	}
 	// This is kind of special, when we renew a some lines, then the last
 	//  one will sometimes end with a space (' '), that really should
 	//  be omitted when word-wrapping. So we'll check if the last row
 	//  we'll add has got the same value as the next row.
 	if (current_line != m_CharacterPositions.end())
 	{
 		if (row.m_ListStart + (int)row.m_ListOfX.size() == current_line->m_ListStart)
 			row.m_ListOfX.resize(row.m_ListOfX.size()-1);
 	}
 
 	// add the final row (even if empty)
 	m_CharacterPositions.insert(current_line, row);
 
 	if (m_ScrollBar)
 	{
 		GetScrollBar(0).SetScrollRange(m_CharacterPositions.size() * font.GetLineSpacing() + m_BufferZone * 2.f);
 		GetScrollBar(0).SetScrollSpace(m_CachedActualSize.GetHeight());
 	}
 }
 
 int CInput::GetMouseHoveringTextPosition() const
 {
 	if (m_CharacterPositions.empty())
 		return 0;
 
 	// Return position
 	int retPosition;
 
 	std::list<SRow>::const_iterator current = m_CharacterPositions.begin();
 
 	CVector2D mouse = m_pGUI.GetMousePos();
 
 	if (m_MultiLine)
 	{
 		float scroll = 0.f;
 		if (m_ScrollBar)
 			scroll = GetScrollBarPos(0);
 
 		// Now get the height of the font.
 						// TODO: Get the real font
-		CFontMetrics font(CStrIntern(m_Font.ToUTF8()));
+		CFontMetrics font(CStrIntern(m_Font->ToUTF8()));
 		float spacing = (float)font.GetLineSpacing();
 
 		// Change mouse position relative to text.
 		mouse -= m_CachedActualSize.TopLeft();
 		mouse.X -= m_BufferZone;
 		mouse.Y += scroll - m_BufferZone;
 
 		int row = (int)((mouse.Y) / spacing);
 
 		if (row < 0)
 			row = 0;
 
 		if (row > (int)m_CharacterPositions.size()-1)
 			row = (int)m_CharacterPositions.size()-1;
 
 		// TODO Gee (2004-11-21): Okay, I need a 'std::list' for some reasons, but I would really like to
 		//  be able to get the specific element here. This is hopefully a temporary hack.
 
 		for (int i = 0; i < row; ++i)
 			++current;
 	}
 	else
 	{
 		// current is already set to begin,
 		//  but we'll change the mouse.x to fit our horizontal scrolling
 		mouse -= m_CachedActualSize.TopLeft();
 		mouse.X -= m_BufferZone - m_HorizontalScroll;
 		// mouse.y is moot
 	}
 
 	retPosition = current->m_ListStart;
 
 	// Okay, now loop through the glyphs to find the appropriate X position
 	float dummy;
 	retPosition += GetXTextPosition(current, mouse.X, dummy);
 
 	return retPosition;
 }
 
 // Does not process horizontal scrolling, 'x' must be modified before inputted.
 int CInput::GetXTextPosition(const std::list<SRow>::const_iterator& current, const float& x, float& wanted) const
 {
 	int ret = 0;
 	float previous = 0.f;
 	int i = 0;
 
 	for (std::vector<float>::const_iterator it = current->m_ListOfX.begin();
 	     it != current->m_ListOfX.end();
 	     ++it, ++i)
 	{
 		if (*it >= x)
 		{
 			if (x - previous >= *it - x)
 				ret += i+1;
 			else
 				ret += i;
 
 			break;
 		}
 		previous = *it;
 	}
 	// If a position wasn't found, we will assume the last
 	//  character of that line.
 	if (i == (int)current->m_ListOfX.size())
 	{
 		ret += i;
 		wanted = x;
 	}
 	else
 		wanted = 0.f;
 
 	return ret;
 }
 
 void CInput::DeleteCurSelection()
 {
 	int virtualFrom;
 	int virtualTo;
 
 	if (m_iBufferPos_Tail >= m_iBufferPos)
 	{
 		virtualFrom = m_iBufferPos;
 		virtualTo = m_iBufferPos_Tail;
 	}
 	else
 	{
 		virtualFrom = m_iBufferPos_Tail;
 		virtualTo = m_iBufferPos;
 	}
 
-	m_Caption =
-		m_Caption.Left(virtualFrom) +
-		m_Caption.Right(static_cast<long>(m_Caption.length()) - virtualTo);
+	// Silently change.
+	m_Caption.Set(m_Caption->Left(virtualFrom) + m_Caption->Right(static_cast<long>(m_Caption->length()) - virtualTo),
+				  false);
 
 	UpdateText(virtualFrom, virtualTo, virtualFrom);
 
 	// Remove selection
 	m_iBufferPos_Tail = -1;
 	m_iBufferPos = virtualFrom;
 	UpdateBufferPositionSetting();
 }
 
 bool CInput::SelectingText() const
 {
 	return m_iBufferPos_Tail != -1 &&
 		   m_iBufferPos_Tail != m_iBufferPos;
 }
 
 float CInput::GetTextAreaWidth()
 {
 	if (m_ScrollBar && GetScrollBar(0).GetStyle())
 		return m_CachedActualSize.GetWidth() - m_BufferZone * 2.f - GetScrollBar(0).GetStyle()->m_Width;
 
 	return m_CachedActualSize.GetWidth() - m_BufferZone * 2.f;
 }
 
 void CInput::UpdateAutoScroll()
 {
 	// Autoscrolling up and down
 	if (m_MultiLine)
 	{
 		if (!m_ScrollBar)
 			return;
 
 		const float scroll = GetScrollBar(0).GetPos();
 
 		// Now get the height of the font.
 						// TODO: Get the real font
-		CFontMetrics font(CStrIntern(m_Font.ToUTF8()));
+		CFontMetrics font(CStrIntern(m_Font->ToUTF8()));
 		float spacing = (float)font.GetLineSpacing();
 		//float height = font.GetHeight();
 
 		// TODO Gee (2004-11-21): Okay, I need a 'std::list' for some reasons, but I would really like to
 		//  be able to get the specific element here. This is hopefully a temporary hack.
 
 		std::list<SRow>::iterator current = m_CharacterPositions.begin();
 		int row = 0;
 		while (current != m_CharacterPositions.end())
 		{
 			if (m_iBufferPos >= current->m_ListStart &&
 			    m_iBufferPos <= current->m_ListStart + (int)current->m_ListOfX.size())
 				break;
 
 			++current;
 			++row;
 		}
 
 		// If scrolling down
 		if (-scroll + static_cast<float>(row + 1) * spacing + m_BufferZone * 2.f > m_CachedActualSize.GetHeight())
 		{
 			// Scroll so the selected row is shown completely, also with m_BufferZone length to the edge.
 			GetScrollBar(0).SetPos(static_cast<float>(row + 1) * spacing - m_CachedActualSize.GetHeight() + m_BufferZone * 2.f);
 		}
 		// If scrolling up
 		else if (-scroll + (float)row * spacing < 0.f)
 		{
 			// Scroll so the selected row is shown completely, also with m_BufferZone length to the edge.
 			GetScrollBar(0).SetPos((float)row * spacing);
 		}
 	}
 	else // autoscrolling left and right
 	{
 		// Get X position of position:
 		if (m_CharacterPositions.empty())
 			return;
 
 		float x_position = 0.f;
 		float x_total = 0.f;
 		if (!m_CharacterPositions.begin()->m_ListOfX.empty())
 		{
 
 			// Get position of m_iBufferPos
 			if ((int)m_CharacterPositions.begin()->m_ListOfX.size() >= m_iBufferPos &&
 				m_iBufferPos > 0)
 				x_position = m_CharacterPositions.begin()->m_ListOfX[m_iBufferPos-1];
 
 			// Get complete length:
 			x_total = m_CharacterPositions.begin()->m_ListOfX[m_CharacterPositions.begin()->m_ListOfX.size()-1];
 		}
 
 		// Check if outside to the right
 		if (x_position - m_HorizontalScroll + m_BufferZone * 2.f > m_CachedActualSize.GetWidth())
 			m_HorizontalScroll = x_position - m_CachedActualSize.GetWidth() + m_BufferZone * 2.f;
 
 		// Check if outside to the left
 		if (x_position - m_HorizontalScroll < 0.f)
 			m_HorizontalScroll = x_position;
 
 		// Check if the text doesn't even fill up to the right edge even though scrolling is done.
 		if (m_HorizontalScroll != 0.f &&
 			x_total - m_HorizontalScroll + m_BufferZone * 2.f < m_CachedActualSize.GetWidth())
 			m_HorizontalScroll = x_total - m_CachedActualSize.GetWidth() + m_BufferZone * 2.f;
 
 		// Now this is the fail-safe, if x_total isn't even the length of the control,
 		//  remove all scrolling
 		if (x_total + m_BufferZone * 2.f < m_CachedActualSize.GetWidth())
 			m_HorizontalScroll = 0.f;
 	}
 }
Index: ps/trunk/source/gui/ObjectTypes/CList.cpp
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CList.cpp	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CList.cpp	(revision 25392)
@@ -1,503 +1,479 @@
 /* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "CList.h"
 
 #include "gui/CGUI.h"
 #include "gui/CGUIScrollBarVertical.h"
 #include "gui/SettingTypes/CGUIColor.h"
 #include "gui/SettingTypes/CGUIList.h"
 #include "lib/external_libraries/libsdl.h"
 #include "lib/timer.h"
 
 const CStr CList::EventNameSelectionChange = "SelectionChange";
 const CStr CList::EventNameHoverChange = "HoverChange";
 const CStr CList::EventNameMouseLeftClickItem = "MouseLeftClickItem";
 const CStr CList::EventNameMouseLeftDoubleClickItem = "MouseLeftDoubleClickItem";
 
 CList::CList(CGUI& pGUI)
 	: IGUIObject(pGUI),
 	  IGUITextOwner(*static_cast<IGUIObject*>(this)),
 	  IGUIScrollBarOwner(*static_cast<IGUIObject*>(this)),
 	  m_Modified(false),
 	  m_PrevSelectedItem(-1),
 	  m_LastItemClickTime(0),
-	  m_BufferZone(),
-	  m_Font(),
-	  m_ScrollBar(),
-	  m_ScrollBarStyle(),
-	  m_ScrollBottom(false),
-	  m_SoundDisabled(),
-	  m_SoundSelected(),
-	  m_Sprite(),
-	  m_SpriteSelectArea(),
-	  m_TextAlign(),
-	  m_TextColor(),
-	  m_TextColorSelected(),
-	  m_Selected(),
-	  m_AutoScroll(),
-	  m_Hovered(),
-	  m_List(),
-	  m_ListData()
-{
-	RegisterSetting("buffer_zone", m_BufferZone);
-	RegisterSetting("font", m_Font);
-	RegisterSetting("scrollbar", m_ScrollBar);
-	RegisterSetting("scrollbar_style", m_ScrollBarStyle);
-	RegisterSetting("scroll_bottom", m_ScrollBottom);
-	RegisterSetting("sound_disabled", m_SoundDisabled);
-	RegisterSetting("sound_selected", m_SoundSelected);
-	RegisterSetting("sprite", m_Sprite);
-	// Add sprite_disabled! TODO
-	RegisterSetting("sprite_selectarea", m_SpriteSelectArea);
-	RegisterSetting("text_align", m_TextAlign);
-	RegisterSetting("textcolor", m_TextColor);
-	RegisterSetting("textcolor_selected", m_TextColorSelected);
-	RegisterSetting("selected", m_Selected); // Index selected. -1 is none.
-	RegisterSetting("auto_scroll", m_AutoScroll);
-	RegisterSetting("hovered", m_Hovered);
-	// Each list item has both a name (in 'list') and an associated data string (in 'list_data')
-	RegisterSetting("list", m_List);
-	RegisterSetting("list_data", m_ListData);
-
-	SetSetting<bool>("scrollbar", false, true);
-	SetSetting<i32>("selected", -1, true);
-	SetSetting<i32>("hovered", -1, true);
-	SetSetting<bool>("auto_scroll", false, true);
-
+	  m_BufferZone(this, "buffer_zone"),
+	  m_Font(this, "font"),
+	  m_ScrollBar(this, "scrollbar", false),
+	  m_ScrollBarStyle(this, "scrollbar_style"),
+	  m_ScrollBottom(this, "scroll_bottom", false),
+	  m_SoundDisabled(this, "sound_disabled"),
+	  m_SoundSelected(this, "sound_selected"),
+	  m_Sprite(this, "sprite"),
+	  // Add sprite_disabled! TODO
+	  m_SpriteSelectArea(this, "sprite_selectarea"),
+	  m_TextColor(this, "textcolor"),
+	  m_TextColorSelected(this, "textcolor_selected"),
+	  m_Selected(this, "selected", -1), // Index selected. -1 is none.
+	  m_AutoScroll(this, "auto_scroll", false),
+	  m_Hovered(this, "hovered", -1),
+	  // Each list item has both a name (in 'list') and an associated data string (in 'list_data')
+	  m_List(this, "list"),
+	  m_ListData(this, "list_data")
+{
 	// Add scroll-bar
 	CGUIScrollBarVertical* bar = new CGUIScrollBarVertical(pGUI);
 	bar->SetRightAligned(true);
 	AddScrollBar(bar);
 }
 
 CList::~CList()
 {
 }
 
 void CList::SetupText()
 {
 	SetupText(false);
 }
 
 void CList::SetupText(bool append)
 {
 	m_Modified = true;
 
 	if (!append)
 		// Delete all generated texts.
 		// TODO: try to be cleverer if we want to update items before the end.
 		m_GeneratedTexts.clear();
 
 	float width = GetListRect().GetWidth();
 
 	bool bottom = false;
 	if (m_ScrollBar && GetScrollBar(0).GetStyle())
 	{
 		if (m_ScrollBottom && GetScrollBar(0).GetPos() > GetScrollBar(0).GetMaxPos() - 1.5f)
 			bottom = true;
 
 		// remove scrollbar if applicable
 		width -= GetScrollBar(0).GetStyle()->m_Width;
 	}
 
 	// Generate texts
 	float buffered_y = 0.f;
 
 	if (append && !m_ItemsYPositions.empty())
 		buffered_y = m_ItemsYPositions.back();
 
-	m_ItemsYPositions.resize(m_List.m_Items.size() + 1);
+	m_ItemsYPositions.resize(m_List->m_Items.size() + 1);
 
-	for (size_t i = append ? m_List.m_Items.size() - 1 : 0; i < m_List.m_Items.size(); ++i)
+	for (size_t i = append ? m_List->m_Items.size() - 1 : 0; i < m_List->m_Items.size(); ++i)
 	{
 		CGUIText* text;
 
-		if (!m_List.m_Items[i].GetOriginalString().empty())
-			text = &AddText(m_List.m_Items[i], m_Font, width, m_BufferZone);
+		if (!m_List->m_Items[i].GetOriginalString().empty())
+			text = &AddText(m_List->m_Items[i], m_Font, width, m_BufferZone);
 		else
 		{
 			// Minimum height of a space character of the current font size
 			CGUIString align_string;
 			align_string.SetValue(L" ");
 			text = &AddText(align_string, m_Font, width, m_BufferZone);
 		}
 
 		m_ItemsYPositions[i] = buffered_y;
 		buffered_y += text->GetSize().Height;
 	}
 
-	m_ItemsYPositions[m_List.m_Items.size()] = buffered_y;
+	m_ItemsYPositions[m_List->m_Items.size()] = buffered_y;
 
 	// Setup scrollbar
 	if (m_ScrollBar)
 	{
 		GetScrollBar(0).SetScrollRange(m_ItemsYPositions.back());
 		GetScrollBar(0).SetScrollSpace(GetListRect().GetHeight());
 
 		CRect rect = GetListRect();
 		GetScrollBar(0).SetX(rect.right);
 		GetScrollBar(0).SetY(rect.top);
 		GetScrollBar(0).SetZ(GetBufferedZ());
 		GetScrollBar(0).SetLength(rect.bottom - rect.top);
 
 		if (bottom)
 			GetScrollBar(0).SetPos(GetScrollBar(0).GetMaxPos());
 	}
 }
 
 void CList::ResetStates()
 {
 	IGUIObject::ResetStates();
 	IGUIScrollBarOwner::ResetStates();
 }
 
 void CList::UpdateCachedSize()
 {
 	IGUIObject::UpdateCachedSize();
 	IGUITextOwner::UpdateCachedSize();
 }
 
 void CList::HandleMessage(SGUIMessage& Message)
 {
 	IGUIObject::HandleMessage(Message);
 	IGUIScrollBarOwner::HandleMessage(Message);
 	//IGUITextOwner::HandleMessage(Message); <== placed it after the switch instead!
 
 	m_Modified = false;
 	switch (Message.type)
 	{
 	case GUIM_SETTINGS_UPDATED:
 		if (Message.value == "list")
 			SetupText();
 
 		// If selected is changed, call "SelectionChange"
 		if (Message.value == "selected")
 		{
 			// TODO: Check range
 
 			if (m_AutoScroll)
 				UpdateAutoScroll();
 
 			ScriptEvent(EventNameSelectionChange);
 		}
 
 		if (Message.value == "scrollbar")
 			SetupText();
 
 		// Update scrollbar
 		if (Message.value == "scrollbar_style")
 		{
 			GetScrollBar(0).SetScrollBarStyle(m_ScrollBarStyle);
 			SetupText();
 		}
 
 		break;
 
 	case GUIM_MOUSE_PRESS_LEFT:
 	{
 		if (!m_Enabled)
 		{
 			PlaySound(m_SoundDisabled);
 			break;
 		}
 
 		int hovered = GetHoveredItem();
 		if (hovered == -1)
 			break;
-		SetSetting<i32>("selected", hovered, true);
+		m_Selected.Set(hovered, true);
 		UpdateAutoScroll();
 		PlaySound(m_SoundSelected);
 
 		if (timer_Time() - m_LastItemClickTime < SELECT_DBLCLICK_RATE && hovered == m_PrevSelectedItem)
 			this->SendMouseEvent(GUIM_MOUSE_DBLCLICK_LEFT_ITEM, EventNameMouseLeftDoubleClickItem);
 		else
 			this->SendMouseEvent(GUIM_MOUSE_PRESS_LEFT_ITEM, EventNameMouseLeftClickItem);
 
 		m_LastItemClickTime = timer_Time();
 		m_PrevSelectedItem = hovered;
 		break;
 	}
 
 	case GUIM_MOUSE_LEAVE:
 	{
 		if (m_Hovered == -1)
 			break;
 
-		SetSetting<i32>("hovered", -1, true);
+		m_Hovered.Set(-1, true);
 		ScriptEvent(EventNameHoverChange);
 		break;
 	}
 
 	case GUIM_MOUSE_OVER:
 	{
 		int hovered = GetHoveredItem();
 		if (hovered == m_Hovered)
 			break;
 
-		SetSetting<i32>("hovered", hovered, true);
+		m_Hovered.Set(hovered, true);
 		ScriptEvent(EventNameHoverChange);
 		break;
 	}
 
 	case GUIM_LOAD:
 	{
 		GetScrollBar(0).SetScrollBarStyle(m_ScrollBarStyle);
 		break;
 	}
 
 	default:
 		break;
 	}
 
 	IGUITextOwner::HandleMessage(Message);
 }
 
 InReaction CList::ManuallyHandleKeys(const SDL_Event_* ev)
 {
 	InReaction result = IN_PASS;
 
 	if (ev->ev.type == SDL_KEYDOWN)
 	{
 		int szChar = ev->ev.key.keysym.sym;
 
 		switch (szChar)
 		{
 		case SDLK_HOME:
 			SelectFirstElement();
 			UpdateAutoScroll();
 			result = IN_HANDLED;
 			break;
 
 		case SDLK_END:
 			SelectLastElement();
 			UpdateAutoScroll();
 			result = IN_HANDLED;
 			break;
 
 		case SDLK_UP:
 			SelectPrevElement();
 			UpdateAutoScroll();
 			result = IN_HANDLED;
 			break;
 
 		case SDLK_DOWN:
 			SelectNextElement();
 			UpdateAutoScroll();
 			result = IN_HANDLED;
 			break;
 
 		case SDLK_PAGEUP:
 			GetScrollBar(0).ScrollMinusPlenty();
 			result = IN_HANDLED;
 			break;
 
 		case SDLK_PAGEDOWN:
 			GetScrollBar(0).ScrollPlusPlenty();
 			result = IN_HANDLED;
 			break;
 
 		default: // Do nothing
 			result = IN_PASS;
 		}
 	}
 
 	return result;
 }
 
 void CList::Draw()
 {
 	DrawList(m_Selected, m_Sprite, m_SpriteSelectArea, m_TextColor);
 }
 
 void CList::DrawList(const int& selected, const CGUISpriteInstance& sprite, const CGUISpriteInstance& sprite_selectarea, const CGUIColor& textcolor)
 {
 	float bz = GetBufferedZ();
 
 	{
 		CRect rect = GetListRect();
 
 		m_pGUI.DrawSprite(sprite, bz, rect);
 
 		float scroll = 0.f;
 		if (m_ScrollBar)
 			scroll = GetScrollBar(0).GetPos();
 
 		if (selected >= 0 && selected+1 < (int)m_ItemsYPositions.size())
 		{
 			// Get rectangle of selection:
 			CRect rect_sel(rect.left, rect.top + m_ItemsYPositions[selected] - scroll,
 					       rect.right, rect.top + m_ItemsYPositions[selected+1] - scroll);
 
 			if (rect_sel.top <= rect.bottom &&
 				rect_sel.bottom >= rect.top)
 			{
 				if (rect_sel.bottom > rect.bottom)
 					rect_sel.bottom = rect.bottom;
 				if (rect_sel.top < rect.top)
 					rect_sel.top = rect.top;
 
 				if (m_ScrollBar)
 				{
 					// Remove any overlapping area of the scrollbar.
 					if (rect_sel.right > GetScrollBar(0).GetOuterRect().left &&
 						rect_sel.right <= GetScrollBar(0).GetOuterRect().right)
 						rect_sel.right = GetScrollBar(0).GetOuterRect().left;
 
 					if (rect_sel.left >= GetScrollBar(0).GetOuterRect().left &&
 						rect_sel.left < GetScrollBar(0).GetOuterRect().right)
 						rect_sel.left = GetScrollBar(0).GetOuterRect().right;
 				}
 
 				m_pGUI.DrawSprite(sprite_selectarea, bz + 0.05f, rect_sel);
 			}
 		}
 
-		for (size_t i = 0; i < m_List.m_Items.size(); ++i)
+		for (size_t i = 0; i < m_List->m_Items.size(); ++i)
 		{
 			if (m_ItemsYPositions[i+1] - scroll < 0 ||
 				m_ItemsYPositions[i] - scroll > rect.GetHeight())
 				continue;
 
 			// Clipping area (we'll have to substract the scrollbar)
 			CRect cliparea = GetListRect();
 
 			if (m_ScrollBar)
 			{
 				if (cliparea.right > GetScrollBar(0).GetOuterRect().left &&
 					cliparea.right <= GetScrollBar(0).GetOuterRect().right)
 					cliparea.right = GetScrollBar(0).GetOuterRect().left;
 
 				if (cliparea.left >= GetScrollBar(0).GetOuterRect().left &&
 					cliparea.left < GetScrollBar(0).GetOuterRect().right)
 					cliparea.left = GetScrollBar(0).GetOuterRect().right;
 			}
 
 			DrawText(i, textcolor, rect.TopLeft() - CVector2D(0.f, scroll - m_ItemsYPositions[i]), bz + 0.1f, cliparea);
 		}
 	}
 
 	if (m_ScrollBar)
 		IGUIScrollBarOwner::Draw();
 }
 
 void CList::AddItem(const CGUIString& str, const CGUIString& data)
 {
 	// Do not send a settings-changed message
-	m_List.m_Items.push_back(str);
-	m_ListData.m_Items.push_back(data);
+	m_List.GetMutable().m_Items.push_back(str);
+	m_ListData.GetMutable().m_Items.push_back(data);
 
 	SetupText(true);
 }
 
 void CList::AddItem(const CGUIString& strAndData)
 {
 	AddItem(strAndData, strAndData);
 }
 
 bool CList::HandleAdditionalChildren(const XMBData& xmb, const XMBElement& child)
 {
 	int elmt_item = xmb.GetElementID("item");
 
 	if (child.GetNodeName() == elmt_item)
 	{
 		CGUIString vlist;
 		vlist.SetValue(child.GetText().FromUTF8());
 		AddItem(vlist, vlist);
 		return true;
 	}
 
 	return false;
 }
 
 void CList::SelectNextElement()
 {
-	if (m_Selected != static_cast<int>(m_List.m_Items.size()) - 1)
+	if (m_Selected != static_cast<int>(m_List->m_Items.size()) - 1)
 	{
-		SetSetting<i32>("selected", m_Selected + 1, true);
+		m_Selected.Set(m_Selected + 1, true);
 		PlaySound(m_SoundSelected);
 	}
 }
 
 void CList::SelectPrevElement()
 {
 	if (m_Selected > 0)
 	{
-		SetSetting<i32>("selected", m_Selected - 1, true);
+		m_Selected.Set(m_Selected - 1, true);
 		PlaySound(m_SoundSelected);
 	}
 }
 
 void CList::SelectFirstElement()
 {
 	if (m_Selected >= 0)
-		SetSetting<i32>("selected", 0, true);
+		m_Selected.Set(0, true);
 }
 
 void CList::SelectLastElement()
 {
-	const int index = static_cast<int>(m_List.m_Items.size()) - 1;
+	const int index = static_cast<int>(m_List->m_Items.size()) - 1;
 
 	if (m_Selected != index)
-		SetSetting<i32>("selected", index, true);
+		m_Selected.Set(index, true);
 }
 
 void CList::UpdateAutoScroll()
 {
 	// No scrollbar, no scrolling (at least it's not made to work properly).
 	if (!m_ScrollBar || m_Selected < 0 || static_cast<std::size_t>(m_Selected) >= m_ItemsYPositions.size())
 		return;
 
 	float scroll = GetScrollBar(0).GetPos();
 
 	// Check upper boundary
 	if (m_ItemsYPositions[m_Selected] < scroll)
 	{
 		GetScrollBar(0).SetPos(m_ItemsYPositions[m_Selected]);
 		return; // this means, if it wants to align both up and down at the same time
 				//  this will have precedence.
 	}
 
 	// Check lower boundary
 	CRect rect = GetListRect();
 	if (m_ItemsYPositions[m_Selected+1]-rect.GetHeight() > scroll)
 		GetScrollBar(0).SetPos(m_ItemsYPositions[m_Selected+1]-rect.GetHeight());
 }
 
 int CList::GetHoveredItem()
 {
 	const float scroll = m_ScrollBar ? GetScrollBar(0).GetPos() : 0.f;
 
 	const CRect& rect = GetListRect();
 	CVector2D mouse = m_pGUI.GetMousePos();
 	mouse.Y += scroll;
 
 	// Mouse is over scrollbar
 	if (m_ScrollBar && GetScrollBar(0).IsVisible() &&
 	    mouse.X >= GetScrollBar(0).GetOuterRect().left &&
 	    mouse.X <= GetScrollBar(0).GetOuterRect().right)
 		return -1;
 
-	for (size_t i = 0; i < m_List.m_Items.size(); ++i)
+	for (size_t i = 0; i < m_List->m_Items.size(); ++i)
 		if (mouse.Y >= rect.top + m_ItemsYPositions[i] &&
 		    mouse.Y < rect.top + m_ItemsYPositions[i + 1])
 			return i;
 
 	return -1;
 }
Index: ps/trunk/source/gui/ObjectTypes/CMiniMap.cpp
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CMiniMap.cpp	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CMiniMap.cpp	(revision 25392)
@@ -1,787 +1,785 @@
 /* Copyright (C) 2021 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 "CMiniMap.h"
 
 #include "graphics/GameView.h"
 #include "graphics/LOSTexture.h"
 #include "graphics/MiniPatch.h"
 #include "graphics/Terrain.h"
 #include "graphics/TerrainTextureEntry.h"
 #include "graphics/TerrainTextureManager.h"
 #include "graphics/TerritoryTexture.h"
 #include "gui/CGUI.h"
 #include "gui/GUIManager.h"
 #include "gui/GUIMatrix.h"
 #include "lib/bits.h"
 #include "lib/external_libraries/libsdl.h"
 #include "lib/ogl.h"
 #include "lib/timer.h"
 #include "ps/ConfigDB.h"
 #include "ps/Filesystem.h"
 #include "ps/Game.h"
 #include "ps/GameSetup/Config.h"
 #include "ps/Profile.h"
 #include "ps/World.h"
 #include "ps/XML/Xeromyces.h"
 #include "renderer/Renderer.h"
 #include "renderer/RenderingOptions.h"
 #include "renderer/WaterManager.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "simulation2/Simulation2.h"
 #include "simulation2/components/ICmpMinimap.h"
 #include "simulation2/components/ICmpRangeManager.h"
 #include "simulation2/helpers/Los.h"
 #include "simulation2/system/ParamNode.h"
 
 #include <array>
 #include <cmath>
 #include <vector>
 
 extern bool g_GameRestarted;
 
 namespace
 {
 
 // Set max drawn entities to UINT16_MAX for now, which is more than enough
 // TODO: we should be cleverer about drawing them to reduce clutter
 const u16 MAX_ENTITIES_DRAWN = 65535;
 
 unsigned int ScaleColor(unsigned int color, float x)
 {
 	unsigned int r = unsigned(float(color & 0xff) * x);
 	unsigned int g = unsigned(float((color>>8) & 0xff) * x);
 	unsigned int b = unsigned(float((color>>16) & 0xff) * x);
 	return (0xff000000 | b | g<<8 | r<<16);
 }
 
 // Adds segments pieces lying inside the circle to lines.
 void CropPointsByCircle(const std::array<CVector3D, 4>& points, const CVector3D& center, const float radius, std::vector<CVector3D>* lines)
 {
 	constexpr float EPS = 1e-3f;
 	lines->reserve(points.size() * 2);
 	for (size_t idx = 0; idx < points.size(); ++idx)
 	{
 		const CVector3D& currentPoint = points[idx];
 		const CVector3D& nextPoint = points[(idx + 1) % points.size()];
 		const CVector3D direction = (nextPoint - currentPoint).Normalized();
 		const CVector3D normal(direction.Z, 0.0f, -direction.X);
 		const float offset = normal.Dot(currentPoint) - normal.Dot(center);
 		// We need to have lines only inside the circle.
 		if (std::abs(offset) + EPS >= radius)
 			continue;
 		const CVector3D closestPoint = center + normal * offset;
 		const float halfChordLength = sqrt(radius * radius - offset * offset);
 		const CVector3D intersectionA = closestPoint - direction * halfChordLength;
 		const CVector3D intersectionB = closestPoint + direction * halfChordLength;
 		// We have no intersection if the segment is lying outside of the circle.
 		if (direction.Dot(currentPoint) + EPS > direction.Dot(intersectionB) ||
 		    direction.Dot(nextPoint) - EPS < direction.Dot(intersectionA))
 			continue;
 
 		lines->emplace_back(
 			direction.Dot(currentPoint) > direction.Dot(intersectionA) ? currentPoint : intersectionA);
 		lines->emplace_back(
 			direction.Dot(nextPoint) < direction.Dot(intersectionB) ? nextPoint : intersectionB);
 	}
 }
 
 } // anonymous namespace
 
 const CStr CMiniMap::EventNameWorldClick = "WorldClick";
 
 CMiniMap::CMiniMap(CGUI& pGUI) :
 	IGUIObject(pGUI),
 	m_TerrainTexture(0), m_TerrainData(0), m_MapSize(0), m_Terrain(0), m_TerrainDirty(true), m_MapScale(1.f),
-	m_EntitiesDrawn(0), m_IndexArray(GL_STATIC_DRAW), m_VertexArray(GL_DYNAMIC_DRAW), m_Mask(false),
+	m_EntitiesDrawn(0), m_IndexArray(GL_STATIC_DRAW), m_VertexArray(GL_DYNAMIC_DRAW), m_Mask(this, "mask", false),
 	m_NextBlinkTime(0.0), m_PingDuration(25.0), m_BlinkState(false), m_WaterHeight(0.0)
 {
-	RegisterSetting("mask", m_Mask);
-
 	m_Clicking = false;
 	m_MouseHovering = false;
 
 	// Register Relax NG validator
 	CXeromyces::AddValidator(g_VFS, "pathfinder", "simulation/data/pathfinder.rng");
 
 	m_ShallowPassageHeight = GetShallowPassageHeight();
 
 	m_AttributePos.type = GL_FLOAT;
 	m_AttributePos.elems = 2;
 	m_VertexArray.AddAttribute(&m_AttributePos);
 
 	m_AttributeColor.type = GL_UNSIGNED_BYTE;
 	m_AttributeColor.elems = 4;
 	m_VertexArray.AddAttribute(&m_AttributeColor);
 
 	m_VertexArray.SetNumVertices(MAX_ENTITIES_DRAWN);
 	m_VertexArray.Layout();
 
 	m_IndexArray.SetNumVertices(MAX_ENTITIES_DRAWN);
 	m_IndexArray.Layout();
 	VertexArrayIterator<u16> index = m_IndexArray.GetIterator();
 	for (u16 i = 0; i < MAX_ENTITIES_DRAWN; ++i)
 		*index++ = i;
 	m_IndexArray.Upload();
 	m_IndexArray.FreeBackingStore();
 
 
 	VertexArrayIterator<float[2]> attrPos = m_AttributePos.GetIterator<float[2]>();
 	VertexArrayIterator<u8[4]> attrColor = m_AttributeColor.GetIterator<u8[4]>();
 	for (u16 i = 0; i < MAX_ENTITIES_DRAWN; ++i)
 	{
 		(*attrColor)[0] = 0;
 		(*attrColor)[1] = 0;
 		(*attrColor)[2] = 0;
 		(*attrColor)[3] = 0;
 		++attrColor;
 
 		(*attrPos)[0] = -10000.0f;
 		(*attrPos)[1] = -10000.0f;
 
 		++attrPos;
 
 	}
 	m_VertexArray.Upload();
 
 	double blinkDuration = 1.0;
 
 	// Tests won't have config initialised
 	if (CConfigDB::IsInitialised())
 	{
 		CFG_GET_VAL("gui.session.minimap.pingduration", m_PingDuration);
 		CFG_GET_VAL("gui.session.minimap.blinkduration", blinkDuration);
 	}
 	m_HalfBlinkDuration = blinkDuration/2;
 }
 
 CMiniMap::~CMiniMap()
 {
 	Destroy();
 }
 
 void CMiniMap::HandleMessage(SGUIMessage& Message)
 {
 	IGUIObject::HandleMessage(Message);
 	switch (Message.type)
 	{
 	case GUIM_MOUSE_PRESS_LEFT:
 		if (m_MouseHovering)
 		{
 			if (!CMiniMap::FireWorldClickEvent(SDL_BUTTON_LEFT, 1))
 			{
 				SetCameraPos();
 				m_Clicking = true;
 			}
 		}
 		break;
 	case GUIM_MOUSE_RELEASE_LEFT:
 		if (m_MouseHovering && m_Clicking)
 			SetCameraPos();
 		m_Clicking = false;
 		break;
 	case GUIM_MOUSE_DBLCLICK_LEFT:
 		if (m_MouseHovering && m_Clicking)
 			SetCameraPos();
 		m_Clicking = false;
 		break;
 	case GUIM_MOUSE_ENTER:
 		m_MouseHovering = true;
 		break;
 	case GUIM_MOUSE_LEAVE:
 		m_Clicking = false;
 		m_MouseHovering = false;
 		break;
 	case GUIM_MOUSE_RELEASE_RIGHT:
 		CMiniMap::FireWorldClickEvent(SDL_BUTTON_RIGHT, 1);
 		break;
 	case GUIM_MOUSE_DBLCLICK_RIGHT:
 		CMiniMap::FireWorldClickEvent(SDL_BUTTON_RIGHT, 2);
 		break;
 	case GUIM_MOUSE_MOTION:
 		if (m_MouseHovering && m_Clicking)
 			SetCameraPos();
 		break;
 	case GUIM_MOUSE_WHEEL_DOWN:
 	case GUIM_MOUSE_WHEEL_UP:
 		Message.Skip();
 		break;
 
 	default:
 		break;
 	}
 }
 
 bool CMiniMap::IsMouseOver() const
 {
 	// Get the mouse position.
 	const CVector2D& mousePos = m_pGUI.GetMousePos();
 	// Get the position of the center of the minimap.
 	CVector2D minimapCenter = CVector2D(m_CachedActualSize.left + m_CachedActualSize.GetWidth() / 2.0, m_CachedActualSize.bottom - m_CachedActualSize.GetHeight() / 2.0);
 	// Take the magnitude of the difference of the mouse position and minimap center.
 	double distFromCenter = sqrt(pow((mousePos.X - minimapCenter.X), 2) + pow((mousePos.Y - minimapCenter.Y), 2));
 	// If the distance is less then the radius of the minimap (half the width) the mouse is over the minimap.
 	if (distFromCenter < m_CachedActualSize.GetWidth() / 2.0)
 		return true;
 	else
 		return false;
 }
 
 void CMiniMap::GetMouseWorldCoordinates(float& x, float& z) const
 {
 	// Determine X and Z according to proportion of mouse position and minimap
 
 	const CVector2D& mousePos = m_pGUI.GetMousePos();
 
 	float px = (mousePos.X - m_CachedActualSize.left) / m_CachedActualSize.GetWidth();
 	float py = (m_CachedActualSize.bottom - mousePos.Y) / m_CachedActualSize.GetHeight();
 
 	float angle = GetAngle();
 
 	// Scale world coordinates for shrunken square map
 	x = TERRAIN_TILE_SIZE * m_MapSize * (m_MapScale * (cos(angle)*(px-0.5) - sin(angle)*(py-0.5)) + 0.5);
 	z = TERRAIN_TILE_SIZE * m_MapSize * (m_MapScale * (cos(angle)*(py-0.5) + sin(angle)*(px-0.5)) + 0.5);
 }
 
 void CMiniMap::SetCameraPos()
 {
 	CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
 
 	CVector3D target;
 	GetMouseWorldCoordinates(target.X, target.Z);
 	target.Y = terrain->GetExactGroundLevel(target.X, target.Z);
 	g_Game->GetView()->MoveCameraTarget(target);
 }
 
 float CMiniMap::GetAngle() const
 {
 	CVector3D cameraIn = m_Camera->GetOrientation().GetIn();
 	return -atan2(cameraIn.X, cameraIn.Z);
 }
 
 bool CMiniMap::FireWorldClickEvent(int button, int UNUSED(clicks))
 {
 	ScriptRequest rq(g_GUI->GetActiveGUI()->GetScriptInterface());
 
 	float x, z;
 	GetMouseWorldCoordinates(x, z);
 
 	JS::RootedValue coords(rq.cx);
 	ScriptInterface::CreateObject(rq, &coords, "x", x, "z", z);
 
 	JS::RootedValue buttonJs(rq.cx);
 	ScriptInterface::ToJSVal(rq, &buttonJs, button);
 
 	JS::RootedValueVector paramData(rq.cx);
 	ignore_result(paramData.append(coords));
 	ignore_result(paramData.append(buttonJs));
 
 	return ScriptEventWithReturn(EventNameWorldClick, paramData);
 }
 
 // This sets up and draws the rectangle on the minimap
 //  which represents the view of the camera in the world.
 void CMiniMap::DrawViewRect(const CMatrix3D& transform) const
 {
 	// Compute the camera frustum intersected with a fixed-height plane.
 	// Use the water height as a fixed base height, which should be the lowest we can go
 	float h = g_Renderer.GetWaterManager()->m_WaterHeight;
 	const float width = m_CachedActualSize.GetWidth();
 	const float height = m_CachedActualSize.GetHeight();
 	const float invTileMapSize = 1.0f / float(TERRAIN_TILE_SIZE * m_MapSize);
 
 	const std::array<CVector3D, 4> hitPoints = {
 		m_Camera->GetWorldCoordinates(0, g_Renderer.GetHeight(), h),
 		m_Camera->GetWorldCoordinates(g_Renderer.GetWidth(), g_Renderer.GetHeight(), h),
 		m_Camera->GetWorldCoordinates(g_Renderer.GetWidth(), 0, h),
 		m_Camera->GetWorldCoordinates(0, 0, h)
 	};
 
 	std::vector<CVector3D> lines;
 	// We need to prevent drawing view bounds out of the map.
 	const float halfMapSize = static_cast<float>((m_MapSize - 1) * TERRAIN_TILE_SIZE) * 0.5f;
 	CropPointsByCircle(hitPoints, CVector3D(halfMapSize, 0.0f, halfMapSize), halfMapSize * m_MapScale, &lines);
 	if (lines.empty())
 		return;
 
 	std::vector<float> vertices;
 	vertices.reserve(lines.size() * 2);
 	for (const CVector3D& point : lines)
 	{
 		// Convert to minimap space.
 		vertices.emplace_back(width * point.X * invTileMapSize);
 		vertices.emplace_back(-(height * point.Z * invTileMapSize));
 	}
 
 	// Enable Scissoring to restrict the rectangle to only the minimap.
 	glScissor(
 		m_CachedActualSize.left * g_GuiScale,
 		g_Renderer.GetHeight() - m_CachedActualSize.bottom * g_GuiScale,
 		width * g_GuiScale,
 		height * g_GuiScale);
 	glEnable(GL_SCISSOR_TEST);
 	glLineWidth(2.0f);
 
 	CShaderDefines lineDefines;
 	lineDefines.Add(str_MINIMAP_LINE, str_1);
 	CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), lineDefines);
 	tech->BeginPass();
 	CShaderProgramPtr shader = tech->GetShader();
 	shader->Uniform(str_transform, transform);
 	shader->Uniform(str_color, 1.0f, 0.3f, 0.3f, 1.0f);
 
 	shader->VertexPointer(2, GL_FLOAT, 0, vertices.data());
 	shader->AssertPointersBound();
 
 	if (!g_Renderer.DoSkipSubmit())
 		glDrawArrays(GL_LINES, 0, vertices.size() / 2);
 
 	tech->EndPass();
 
 	glLineWidth(1.0f);
 	glDisable(GL_SCISSOR_TEST);
 }
 
 struct MinimapUnitVertex
 {
 	// This struct is copyable for convenience and because to move is to copy for primitives.
 	u8 r, g, b, a;
 	float x, y;
 };
 
 // Adds a vertex to the passed VertexArray
 static void inline addVertex(const MinimapUnitVertex& v,
 					  VertexArrayIterator<u8[4]>& attrColor,
 					  VertexArrayIterator<float[2]>& attrPos)
 {
 	(*attrColor)[0] = v.r;
 	(*attrColor)[1] = v.g;
 	(*attrColor)[2] = v.b;
 	(*attrColor)[3] = v.a;
 	++attrColor;
 
 	(*attrPos)[0] = v.x;
 	(*attrPos)[1] = v.y;
 
 	++attrPos;
 }
 
 
 void CMiniMap::DrawTexture(CShaderProgramPtr shader, float coordMax, float angle, float x, float y, float x2, float y2, float z) const
 {
 	// Rotate the texture coordinates (0,0)-(coordMax,coordMax) around their center point (m,m)
 	// Scale square maps to fit in circular minimap area
 	const float s = sin(angle) * m_MapScale;
 	const float c = cos(angle) * m_MapScale;
 	const float m = coordMax / 2.f;
 
 	float quadTex[] = {
 		m*(-c + s + 1.f), m*(-c + -s + 1.f),
 		m*(c + s + 1.f), m*(-c + s + 1.f),
 		m*(c + -s + 1.f), m*(c + s + 1.f),
 
 		m*(c + -s + 1.f), m*(c + s + 1.f),
 		m*(-c + -s + 1.f), m*(c + -s + 1.f),
 		m*(-c + s + 1.f), m*(-c + -s + 1.f)
 	};
 	float quadVerts[] = {
 		x, y, z,
 		x2, y, z,
 		x2, y2, z,
 
 		x2, y2, z,
 		x, y2, z,
 		x, y, z
 	};
 
 	shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, 0, quadTex);
 	shader->VertexPointer(3, GL_FLOAT, 0, quadVerts);
 	shader->AssertPointersBound();
 
 	if (!g_Renderer.DoSkipSubmit())
 		glDrawArrays(GL_TRIANGLES, 0, 6);
 }
 
 // TODO: render the minimap in a framebuffer and just draw the frambuffer texture
 //	most of the time, updating the framebuffer twice a frame.
 // Here it updates as ping-pong either texture or vertex array each sec to lower gpu stalling
 // (those operations cause a gpu sync, which slows down the way gpu works)
 void CMiniMap::Draw()
 {
 	PROFILE3("render minimap");
 
 	// The terrain isn't actually initialized until the map is loaded, which
 	// happens when the game is started, so abort until then.
 	if (!g_Game || !g_Game->IsGameStarted())
 		return;
 
 	CSimulation2* sim = g_Game->GetSimulation2();
 	CmpPtr<ICmpRangeManager> cmpRangeManager(*sim, SYSTEM_ENTITY);
 	ENSURE(cmpRangeManager);
 
 	// Set our globals in case they hadn't been set before
 	m_Camera = g_Game->GetView()->GetCamera();
 	m_Terrain = g_Game->GetWorld()->GetTerrain();
 	m_Width  = (u32)(m_CachedActualSize.right - m_CachedActualSize.left);
 	m_Height = (u32)(m_CachedActualSize.bottom - m_CachedActualSize.top);
 	m_MapSize = m_Terrain->GetVerticesPerSide();
 	m_TextureSize = (GLsizei)round_up_to_pow2((size_t)m_MapSize);
 	m_MapScale = (cmpRangeManager->GetLosCircular() ? 1.f : 1.414f);
 
 	if (!m_TerrainTexture || g_GameRestarted)
 		CreateTextures();
 
 
 	// only update 2x / second
 	// (note: since units only move a few pixels per second on the minimap,
 	// we can get away with infrequent updates; this is slow)
 	// TODO: Update all but camera at same speed as simulation
 	static double last_time;
 	const double cur_time = timer_Time();
 	const bool doUpdate = cur_time - last_time > 0.5;
 	if (doUpdate)
 	{
 		last_time = cur_time;
 		if (m_TerrainDirty || m_WaterHeight != g_Renderer.GetWaterManager()->m_WaterHeight)
 			RebuildTerrainTexture();
 	}
 
 	const float x = m_CachedActualSize.left, y = m_CachedActualSize.bottom;
 	const float x2 = m_CachedActualSize.right, y2 = m_CachedActualSize.top;
 	const float z = GetBufferedZ();
 	const float texCoordMax = (float)(m_MapSize - 1) / (float)m_TextureSize;
 	const float angle = GetAngle();
 	const float unitScale = (cmpRangeManager->GetLosCircular() ? 1.f : m_MapScale/2.f);
 
 	CLOSTexture& losTexture = g_Game->GetView()->GetLOSTexture();
 
 	CShaderProgramPtr shader;
 	CShaderTechniquePtr tech;
 
 	CShaderDefines baseDefines;
 	baseDefines.Add(str_MINIMAP_BASE, str_1);
 	if (m_Mask)
 		baseDefines.Add(str_MINIMAP_MASK, str_1);
 
 	tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), baseDefines);
 	tech->BeginPass();
 	shader = tech->GetShader();
 
 	// Draw the main textured quad
 	shader->BindTexture(str_baseTex, m_TerrainTexture);
 	if (m_Mask)
 	{
 		shader->BindTexture(str_maskTex, losTexture.GetTexture());
 		CMatrix3D maskTextureTransform = *losTexture.GetMinimapTextureMatrix();
 		// We need to have texture coordinates in the same coordinate space.
 		const float scale = 1.0f / texCoordMax;
 		maskTextureTransform.Scale(scale, scale, 1.0f);
 		shader->Uniform(str_maskTextureTransform, maskTextureTransform);
 	}
 	const CMatrix3D baseTransform = GetDefaultGuiMatrix();
 	CMatrix3D baseTextureTransform;
 	baseTextureTransform.SetIdentity();
 	shader->Uniform(str_transform, baseTransform);
 	shader->Uniform(str_textureTransform, baseTextureTransform);
 
 	if (m_Mask)
 	{
 		glEnable(GL_BLEND);
 		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	}
 
 	DrawTexture(shader, texCoordMax, angle, x, y, x2, y2, z);
 
 	if (!m_Mask)
 	{
 		glEnable(GL_BLEND);
 		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	}
 
 	// Draw territory boundaries
 	CTerritoryTexture& territoryTexture = g_Game->GetView()->GetTerritoryTexture();
 
 	shader->BindTexture(str_baseTex, territoryTexture.GetTexture());
 	if (m_Mask)
 	{
 		shader->BindTexture(str_maskTex, losTexture.GetTexture());
 		shader->Uniform(str_maskTextureTransform, *losTexture.GetMinimapTextureMatrix());
 	}
 	const CMatrix3D* territoryTransform = territoryTexture.GetMinimapTextureMatrix();
 	shader->Uniform(str_transform, baseTransform);
 	shader->Uniform(str_textureTransform, *territoryTransform);
 
 	DrawTexture(shader, 1.0f, angle, x, y, x2, y2, z);
 	tech->EndPass();
 
 	// Draw the LOS quad in black, using alpha values from the LOS texture
 	if (!m_Mask)
 	{
 		CShaderDefines losDefines;
 		losDefines.Add(str_MINIMAP_LOS, str_1);
 		tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), losDefines);
 		tech->BeginPass();
 		shader = tech->GetShader();
 		shader->BindTexture(str_baseTex, losTexture.GetTexture());
 
 		const CMatrix3D* losTransform = losTexture.GetMinimapTextureMatrix();
 		shader->Uniform(str_transform, baseTransform);
 		shader->Uniform(str_textureTransform, *losTransform);
 
 		DrawTexture(shader, 1.0f, angle, x, y, x2, y2, z);
 		tech->EndPass();
 	}
 
 	glDisable(GL_BLEND);
 
 	PROFILE_START("minimap units");
 
 	CShaderDefines pointDefines;
 	pointDefines.Add(str_MINIMAP_POINT, str_1);
 	tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), pointDefines);
 	tech->BeginPass();
 	shader = tech->GetShader();
 	shader->Uniform(str_transform, baseTransform);
 	shader->Uniform(str_pointSize, 3.f);
 
 	CMatrix3D unitMatrix;
 	unitMatrix.SetIdentity();
 	// Center the minimap on the origin of the axis of rotation.
 	unitMatrix.Translate(-(x2 - x) / 2.f, -(y2 - y) / 2.f, 0.f);
 	// Rotate the map.
 	unitMatrix.RotateZ(angle);
 	// Scale square maps to fit.
 	unitMatrix.Scale(unitScale, unitScale, 1.f);
 	// Move the minimap back to it's starting position.
 	unitMatrix.Translate((x2 - x) / 2.f, (y2 - y) / 2.f, 0.f);
 	// Move the minimap to it's final location.
 	unitMatrix.Translate(x, y, z);
 	// Apply the gui matrix.
 	unitMatrix *= GetDefaultGuiMatrix();
 	// Load the transform into the shader.
 	shader->Uniform(str_transform, unitMatrix);
 
 	const float sx = (float)m_Width / ((m_MapSize - 1) * TERRAIN_TILE_SIZE);
 	const float sy = (float)m_Height / ((m_MapSize - 1) * TERRAIN_TILE_SIZE);
 
 	CSimulation2::InterfaceList ents = sim->GetEntitiesWithInterface(IID_Minimap);
 
 	if (doUpdate)
 	{
 		VertexArrayIterator<float[2]> attrPos = m_AttributePos.GetIterator<float[2]>();
 		VertexArrayIterator<u8[4]> attrColor = m_AttributeColor.GetIterator<u8[4]>();
 
 		m_EntitiesDrawn = 0;
 		MinimapUnitVertex v;
 		std::vector<MinimapUnitVertex> pingingVertices;
 		pingingVertices.reserve(MAX_ENTITIES_DRAWN / 2);
 
 		if (cur_time > m_NextBlinkTime)
 		{
 			m_BlinkState = !m_BlinkState;
 			m_NextBlinkTime = cur_time + m_HalfBlinkDuration;
 		}
 
 		entity_pos_t posX, posZ;
 		for (CSimulation2::InterfaceList::const_iterator it = ents.begin(); it != ents.end(); ++it)
 		{
 			ICmpMinimap* cmpMinimap = static_cast<ICmpMinimap*>(it->second);
 			if (cmpMinimap->GetRenderData(v.r, v.g, v.b, posX, posZ))
 			{
 				LosVisibility vis = cmpRangeManager->GetLosVisibility(it->first, g_Game->GetSimulation2()->GetSimContext().GetCurrentDisplayedPlayer());
 				if (vis != LosVisibility::HIDDEN)
 				{
 					v.a = 255;
 					v.x = posX.ToFloat() * sx;
 					v.y = -posZ.ToFloat() * sy;
 
 					// Check minimap pinging to indicate something
 					if (m_BlinkState && cmpMinimap->CheckPing(cur_time, m_PingDuration))
 					{
 						v.r = 255; // ping color is white
 						v.g = 255;
 						v.b = 255;
 						pingingVertices.push_back(v);
 					}
 					else
 					{
 						addVertex(v, attrColor, attrPos);
 						++m_EntitiesDrawn;
 					}
 				}
 			}
 		}
 
 		// Add the pinged vertices at the end, so they are drawn on top
 		for (const MinimapUnitVertex& vertex : pingingVertices)
 		{
 			addVertex(vertex, attrColor, attrPos);
 			++m_EntitiesDrawn;
 		}
 
 		ENSURE(m_EntitiesDrawn < MAX_ENTITIES_DRAWN);
 		m_VertexArray.Upload();
 	}
 
 	m_VertexArray.PrepareForRendering();
 
 	if (m_EntitiesDrawn > 0)
 	{
 #if !CONFIG2_GLES
 		glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
 #endif
 
 		u8* indexBase = m_IndexArray.Bind();
 		u8* base = m_VertexArray.Bind();
 		const GLsizei stride = (GLsizei)m_VertexArray.GetStride();
 
 		shader->VertexPointer(2, GL_FLOAT, stride, base + m_AttributePos.offset);
 		shader->ColorPointer(4, GL_UNSIGNED_BYTE, stride, base + m_AttributeColor.offset);
 		shader->AssertPointersBound();
 
 		if (!g_Renderer.DoSkipSubmit())
 			glDrawElements(GL_POINTS, (GLsizei)(m_EntitiesDrawn), GL_UNSIGNED_SHORT, indexBase);
 
 		g_Renderer.GetStats().m_DrawCalls++;
 		CVertexBuffer::Unbind();
 
 #if !CONFIG2_GLES
 		glDisable(GL_VERTEX_PROGRAM_POINT_SIZE);
 #endif
 	}
 
 	tech->EndPass();
 
 	DrawViewRect(unitMatrix);
 
 	PROFILE_END("minimap units");
 }
 
 void CMiniMap::CreateTextures()
 {
 	Destroy();
 
 	// Create terrain texture
 	glGenTextures(1, &m_TerrainTexture);
 	g_Renderer.BindTexture(0, m_TerrainTexture);
 
 	// Initialise texture with solid black, for the areas we don't
 	// overwrite with glTexSubImage2D later
 	u32* texData = new u32[m_TextureSize * m_TextureSize];
 	for (ssize_t i = 0; i < m_TextureSize * m_TextureSize; ++i)
 		texData[i] = 0xFF000000;
 	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_TextureSize, m_TextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, texData);
 	delete[] texData;
 
 	m_TerrainData = new u32[(m_MapSize - 1) * (m_MapSize - 1)];
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
 	// Rebuild and upload both of them
 	RebuildTerrainTexture();
 }
 
 
 void CMiniMap::RebuildTerrainTexture()
 {
 	u32 x = 0;
 	u32 y = 0;
 	u32 w = m_MapSize - 1;
 	u32 h = m_MapSize - 1;
 	m_WaterHeight = g_Renderer.GetWaterManager()->m_WaterHeight;
 
 	m_TerrainDirty = false;
 
 	for (u32 j = 0; j < h; ++j)
 	{
 		u32* dataPtr = m_TerrainData + ((y + j) * (m_MapSize - 1)) + x;
 		for (u32 i = 0; i < w; ++i)
 		{
 			float avgHeight = ( m_Terrain->GetVertexGroundLevel((int)i, (int)j)
 					+ m_Terrain->GetVertexGroundLevel((int)i+1, (int)j)
 					+ m_Terrain->GetVertexGroundLevel((int)i, (int)j+1)
 					+ m_Terrain->GetVertexGroundLevel((int)i+1, (int)j+1)
 				) / 4.0f;
 
 			if (avgHeight < m_WaterHeight && avgHeight > m_WaterHeight - m_ShallowPassageHeight)
 			{
 				// shallow water
 				*dataPtr++ = 0xffc09870;
 			}
 			else if (avgHeight < m_WaterHeight)
 			{
 				// Set water as constant color for consistency on different maps
 				*dataPtr++ = 0xffa07850;
 			}
 			else
 			{
 				int hmap = ((int)m_Terrain->GetHeightMap()[(y + j) * m_MapSize + x + i]) >> 8;
 				int val = (hmap / 3) + 170;
 
 				u32 color = 0xFFFFFFFF;
 
 				CMiniPatch* mp = m_Terrain->GetTile(x + i, y + j);
 				if (mp)
 				{
 					CTerrainTextureEntry* tex = mp->GetTextureEntry();
 					if (tex)
 					{
 						// If the texture can't be loaded yet, set the dirty flags
 						// so we'll try regenerating the terrain texture again soon
 						if(!tex->GetTexture()->TryLoad())
 							m_TerrainDirty = true;
 
 						color = tex->GetBaseColor();
 					}
 				}
 
 				*dataPtr++ = ScaleColor(color, float(val) / 255.0f);
 			}
 		}
 	}
 
 	// Upload the texture
 	g_Renderer.BindTexture(0, m_TerrainTexture);
 	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_MapSize - 1, m_MapSize - 1, GL_RGBA, GL_UNSIGNED_BYTE, m_TerrainData);
 }
 
 void CMiniMap::Destroy()
 {
 	if (m_TerrainTexture)
 	{
 		glDeleteTextures(1, &m_TerrainTexture);
 		m_TerrainTexture = 0;
 	}
 
 	SAFE_ARRAY_DELETE(m_TerrainData);
 }
 
 // static
 float CMiniMap::GetShallowPassageHeight()
 {
 	float shallowPassageHeight = 0.0f;
 	CParamNode externalParamNode;
 	CParamNode::LoadXML(externalParamNode, L"simulation/data/pathfinder.xml", "pathfinder");
 	const CParamNode pathingSettings = externalParamNode.GetChild("Pathfinder").GetChild("PassabilityClasses");
 	if (pathingSettings.GetChild("default").IsOk() && pathingSettings.GetChild("default").GetChild("MaxWaterDepth").IsOk())
 		shallowPassageHeight = pathingSettings.GetChild("default").GetChild("MaxWaterDepth").ToFloat();
 	return shallowPassageHeight;
 }
Index: ps/trunk/source/gui/ObjectTypes/COList.cpp
===================================================================
--- ps/trunk/source/gui/ObjectTypes/COList.cpp	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/COList.cpp	(revision 25392)
@@ -1,442 +1,431 @@
 /* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "COList.h"
 
 #include "gui/CGUI.h"
 #include "gui/IGUIScrollBar.h"
 #include "gui/SettingTypes/CGUIColor.h"
 #include "gui/SettingTypes/CGUIList.h"
 #include "i18n/L10n.h"
 #include "ps/CLogger.h"
 
 const float SORT_SPRITE_DIM = 16.0f;
 const CVector2D COLUMN_SHIFT = CVector2D(0, 4);
 
 const CStr COList::EventNameSelectionColumnChange = "SelectionColumnChange";
 
 COList::COList(CGUI& pGUI)
 	: CList(pGUI),
-	  m_SpriteHeading(),
-	  m_Sortable(),
-	  m_SelectedColumn(),
-	  m_SelectedColumnOrder(),
-	  m_SpriteAsc(),
-	  m_SpriteDesc(),
-	  m_SpriteNotSorted()
+	  m_SpriteHeading(this, "sprite_heading"),
+	  m_Sortable(this, "sortable"), // The actual sorting is done in JS for more versatility
+	  m_SelectedColumn(this, "selected_column"),
+	  m_SelectedColumnOrder(this, "selected_column_order"),
+	  m_SpriteAsc(this, "sprite_asc"), // Show the order of sorting
+	  m_SpriteDesc(this, "sprite_desc"),
+	  m_SpriteNotSorted(this, "sprite_not_sorted")
 {
-	RegisterSetting("sprite_heading", m_SpriteHeading);
-	RegisterSetting("sortable", m_Sortable); // The actual sorting is done in JS for more versatility
-	RegisterSetting("selected_column", m_SelectedColumn);
-	RegisterSetting("selected_column_order", m_SelectedColumnOrder);
-	RegisterSetting("sprite_asc", m_SpriteAsc);  // Show the order of sorting
-	RegisterSetting("sprite_desc", m_SpriteDesc);
-	RegisterSetting("sprite_not_sorted", m_SpriteNotSorted);
 }
 
 void COList::SetupText()
 {
-	m_ItemsYPositions.resize(m_List.m_Items.size() + 1);
+	m_ItemsYPositions.resize(m_List->m_Items.size() + 1);
 
 	// Delete all generated texts. Some could probably be saved,
 	//  but this is easier, and this function will never be called
 	//  continuously, or even often, so it'll probably be okay.
 	m_GeneratedTexts.clear();
 
 	m_TotalAvailableColumnWidth = GetListRect().GetWidth();
 	// remove scrollbar if applicable
 	if (m_ScrollBar && GetScrollBar(0).GetStyle())
 		m_TotalAvailableColumnWidth -= GetScrollBar(0).GetStyle()->m_Width;
 
 	m_HeadingHeight = SORT_SPRITE_DIM; // At least the size of the sorting sprite
 
 	for (const COListColumn& column : m_Columns)
 	{
 		float width = column.m_Width;
 		if (column.m_Width > 0 && column.m_Width < 1)
 			width *= m_TotalAvailableColumnWidth;
 
 		CGUIString gui_string;
 		gui_string.SetValue(column.m_Heading);
 
 		const CGUIText& text = AddText(gui_string, m_Font, width, m_BufferZone);
 		m_HeadingHeight = std::max(m_HeadingHeight, text.GetSize().Height + COLUMN_SHIFT.Y);
 	}
 
 	// Generate texts
 	float buffered_y = 0.f;
 
-	for (size_t i = 0; i < m_List.m_Items.size(); ++i)
+	for (size_t i = 0; i < m_List->m_Items.size(); ++i)
 	{
 		m_ItemsYPositions[i] = buffered_y;
 		float shift = 0.0f;
 		for (const COListColumn& column : m_Columns)
 		{
 			float width = column.m_Width;
 			if (column.m_Width > 0 && column.m_Width < 1)
 				width *= m_TotalAvailableColumnWidth;
 
 			CGUIText* text;
-			if (!column.m_List.m_Items[i].GetOriginalString().empty())
-				text = &AddText(column.m_List.m_Items[i], m_Font, width, m_BufferZone);
+			if (!column.m_List->m_Items[i].GetOriginalString().empty())
+				text = &AddText(column.m_List->m_Items[i], m_Font, width, m_BufferZone);
 			else
 			{
 				// Minimum height of a space character of the current font size
 				CGUIString align_string;
 				align_string.SetValue(L" ");
 				text = &AddText(align_string, m_Font, width, m_BufferZone);
 			}
 			shift = std::max(shift, text->GetSize().Height);
 		}
 		buffered_y += shift;
 	}
 
-	m_ItemsYPositions[m_List.m_Items.size()] = buffered_y;
+	m_ItemsYPositions[m_List->m_Items.size()] = buffered_y;
 
 	if (m_ScrollBar)
 	{
 		CRect rect = GetListRect();
 		GetScrollBar(0).SetScrollRange(m_ItemsYPositions.back());
 		GetScrollBar(0).SetScrollSpace(rect.GetHeight());
 
 		GetScrollBar(0).SetX(rect.right);
 		GetScrollBar(0).SetY(rect.top);
 		GetScrollBar(0).SetZ(GetBufferedZ());
 		GetScrollBar(0).SetLength(rect.bottom - rect.top);
 	}
 }
 
 CRect COList::GetListRect() const
 {
 	return m_CachedActualSize + CRect(0, m_HeadingHeight, 0, 0);
 }
 
 void COList::HandleMessage(SGUIMessage& Message)
 {
 	CList::HandleMessage(Message);
 
 	switch (Message.type)
 	{
 	// If somebody clicks on the column heading
 	case GUIM_MOUSE_PRESS_LEFT:
 	{
 		if (!m_Sortable)
 			return;
 
 		const CVector2D& mouse = m_pGUI.GetMousePos();
 		if (!m_CachedActualSize.PointInside(mouse))
 			return;
 
 		float xpos = 0;
 		for (const COListColumn& column : m_Columns)
 		{
 			if (column.m_Hidden)
 				continue;
 
 			float width = column.m_Width;
 			// Check if it's a decimal value, and if so, assume relative positioning.
 			if (column.m_Width < 1 && column.m_Width > 0)
 				width *= m_TotalAvailableColumnWidth;
 			CVector2D leftTopCorner = m_CachedActualSize.TopLeft() + CVector2D(xpos, 0);
 			if (mouse.X >= leftTopCorner.X &&
 				mouse.X < leftTopCorner.X + width &&
 				mouse.Y < leftTopCorner.Y + m_HeadingHeight)
 			{
-				if (column.m_Id != m_SelectedColumn)
+				if (column.m_Id != static_cast<CStr>(m_SelectedColumn))
 				{
-					SetSetting<i32>("selected_column_order", -1, true);
+					m_SelectedColumnOrder.Set(-1, true);
 					CStr selected_column = column.m_Id;
-					SetSetting<CStr>("selected_column", selected_column, true);
+					m_SelectedColumn.Set(selected_column, true);
 				}
 				else
-					SetSetting<i32>("selected_column_order", -m_SelectedColumnOrder, true);
+					m_SelectedColumnOrder.Set(-m_SelectedColumnOrder, true);
 
 				ScriptEvent(EventNameSelectionColumnChange);
 				PlaySound(m_SoundSelected);
 				return;
 			}
 			xpos += width;
 		}
 		return;
 	}
 	default:
 		return;
 	}
 }
 
 bool COList::HandleAdditionalChildren(const XMBData& xmb, const XMBElement& child)
 {
 	#define ELMT(x) int elmt_##x = xmb.GetElementID(#x)
 	#define ATTR(x) int attr_##x = xmb.GetAttributeID(#x)
 	ELMT(item);
 	ELMT(column);
 	ELMT(translatableAttribute);
 	ATTR(id);
 	ATTR(context);
 
 	if (child.GetNodeName() == elmt_item)
 	{
 		CGUIString vlist;
 		vlist.SetValue(child.GetText().FromUTF8());
 		AddItem(vlist, vlist);
 		return true;
 	}
 	else if (child.GetNodeName() == elmt_column)
 	{
-		COListColumn column;
+		CStr id;
+		XERO_ITER_ATTR(child, attr)
+		{
+			if (attr.Name == attr_id)
+				id = attr.Value;
+		}
+
+		COListColumn column(this, id);
 
 		for (XMBAttribute attr : child.GetAttributes())
 		{
 			std::string_view attr_name(xmb.GetAttributeStringView(attr.Name));
 			CStr attr_value(attr.Value);
 
 			if (attr_name == "color")
 			{
 				if (!CGUI::ParseString<CGUIColor>(&m_pGUI, attr_value.FromUTF8(), column.m_TextColor))
 					LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name.data(), attr_value.c_str());
 			}
-			else if (attr_name == "id")
-			{
-				column.m_Id = attr_value;
-			}
 			else if (attr_name == "hidden")
 			{
 				bool hidden = false;
 				if (!CGUI::ParseString<bool>(&m_pGUI, attr_value.FromUTF8(), hidden))
 					LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name.data(), attr_value.c_str());
 				else
-					column.m_Hidden = hidden;
+					column.m_Hidden.Set(hidden, false);
 			}
 			else if (attr_name == "width")
 			{
 				float width;
 				if (!CGUI::ParseString<float>(&m_pGUI, attr_value.FromUTF8(), width))
 					LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name.data(), attr_value.c_str());
 				else
 				{
 					// Check if it's a relative value, and save as decimal if so.
 					if (attr_value.find("%") != std::string::npos)
 						width = width / 100.f;
 					column.m_Width = width;
 				}
 			}
 			else if (attr_name == "heading")
 			{
 				column.m_Heading = attr_value.FromUTF8();
 			}
 		}
 
 		for (XMBElement grandchild : child.GetChildNodes())
 		{
 			if (grandchild.GetNodeName() != elmt_translatableAttribute)
 				continue;
 
 			CStr attributeName(grandchild.GetAttributes().GetNamedItem(attr_id));
 			// only the heading is translatable for list column
 			if (attributeName.empty() || attributeName != "heading")
 			{
 				LOGERROR("GUI: translatable attribute in olist column that isn't a heading. (object: %s)", this->GetPresentableName().c_str());
 				continue;
 			}
 
 			CStr value(grandchild.GetText());
 			if (value.empty())
 				continue;
 
 			CStr context(grandchild.GetAttributes().GetNamedItem(attr_context)); // Read the context if any.
 			if (!context.empty())
 			{
 				CStr translatedValue(g_L10n.TranslateWithContext(context, value));
 				column.m_Heading = translatedValue.FromUTF8();
 			}
 			else
 			{
 				CStr translatedValue(g_L10n.Translate(value));
 				column.m_Heading = translatedValue.FromUTF8();
 			}
 		}
 
 		m_Columns.emplace_back(std::move(column));
 		return true;
 	}
 
 	return false;
 }
 
 void COList::AdditionalChildrenHandled()
 {
 	SetupText();
-
-	// Do this after the last push_back call to avoid iterator invalidation
-	for (COListColumn& column : m_Columns)
-	{
-		RegisterSetting("list_" + column.m_Id, column.m_List);
-		RegisterSetting("hidden_" + column.m_Id, column.m_Hidden);
-	}
 }
 
 void COList::DrawList(const int& selected, const CGUISpriteInstance& sprite, const CGUISpriteInstance& sprite_selected, const CGUIColor& textcolor)
 {
 	const float bz = GetBufferedZ();
 
 	if (m_ScrollBar)
 		IGUIScrollBarOwner::Draw();
 
 	CRect rect = GetListRect();
 
 	m_pGUI.DrawSprite(sprite, bz, rect);
 
 	float scroll = 0.f;
 	if (m_ScrollBar)
 		scroll = GetScrollBar(0).GetPos();
 
 	// Draw item selection
 	if (selected != -1)
 	{
 		ENSURE(selected >= 0 && selected+1 < (int)m_ItemsYPositions.size());
 
 		// Get rectangle of selection:
 		CRect rect_sel(rect.left, rect.top + m_ItemsYPositions[selected] - scroll,
 		               rect.right, rect.top + m_ItemsYPositions[selected+1] - scroll);
 
 		if (rect_sel.top <= rect.bottom &&
 			rect_sel.bottom >= rect.top)
 		{
 			if (rect_sel.bottom > rect.bottom)
 				rect_sel.bottom = rect.bottom;
 			if (rect_sel.top < rect.top)
 				rect_sel.top = rect.top;
 
 			if (m_ScrollBar)
 			{
 				// Remove any overlapping area of the scrollbar.
 				if (rect_sel.right > GetScrollBar(0).GetOuterRect().left &&
 					rect_sel.right <= GetScrollBar(0).GetOuterRect().right)
 					rect_sel.right = GetScrollBar(0).GetOuterRect().left;
 
 				if (rect_sel.left >= GetScrollBar(0).GetOuterRect().left &&
 					rect_sel.left < GetScrollBar(0).GetOuterRect().right)
 					rect_sel.left = GetScrollBar(0).GetOuterRect().right;
 			}
 
 			// Draw item selection
 			m_pGUI.DrawSprite(sprite_selected, bz + 0.05f, rect_sel);
 		}
 	}
 
 	// Draw line above column header
 	CRect rect_head(m_CachedActualSize.left, m_CachedActualSize.top, m_CachedActualSize.right,
 									m_CachedActualSize.top + m_HeadingHeight);
 	m_pGUI.DrawSprite(m_SpriteHeading, bz, rect_head);
 
 	// Draw column headers
 	float xpos = 0;
 	size_t col = 0;
 	for (const COListColumn& column : m_Columns)
 	{
 		if (column.m_Hidden)
 		{
 			++col;
 			continue;
 		}
 
 		// Check if it's a decimal value, and if so, assume relative positioning.
 		float width = column.m_Width;
 		if (column.m_Width < 1 && column.m_Width > 0)
 			width *= m_TotalAvailableColumnWidth;
 
 		CVector2D leftTopCorner = m_CachedActualSize.TopLeft() + CVector2D(xpos, 0);
 
 		// Draw sort arrows in colum header
 		if (m_Sortable)
 		{
 			const CGUISpriteInstance* pSprite;
-			if (m_SelectedColumn == column.m_Id)
+			if (*m_SelectedColumn == column.m_Id)
 			{
 				if (m_SelectedColumnOrder == 0)
 					LOGERROR("selected_column_order must not be 0");
 
 				if (m_SelectedColumnOrder != -1)
-					pSprite = &m_SpriteAsc;
+					pSprite = &*m_SpriteAsc;
 				else
-					pSprite = &m_SpriteDesc;
+					pSprite = &*m_SpriteDesc;
 			}
 			else
-				pSprite = &m_SpriteNotSorted;
+				pSprite = &*m_SpriteNotSorted;
 
 			m_pGUI.DrawSprite(*pSprite, bz + 0.1f, CRect(leftTopCorner + CVector2D(width - SORT_SPRITE_DIM, 0), leftTopCorner + CVector2D(width, SORT_SPRITE_DIM)));
 		}
 
 		// Draw column header text
 		DrawText(col, textcolor, leftTopCorner + COLUMN_SHIFT, bz + 0.1f, rect_head);
 		xpos += width;
 		++col;
 	}
 
 	// Draw list items for each column
 	const size_t objectsCount = m_Columns.size();
-	for (size_t i = 0; i < m_List.m_Items.size(); ++i)
+	for (size_t i = 0; i < m_List->m_Items.size(); ++i)
 	{
 		if (m_ItemsYPositions[i+1] - scroll < 0 ||
 			m_ItemsYPositions[i] - scroll > rect.GetHeight())
 			continue;
 
 		const float rowHeight = m_ItemsYPositions[i+1] - m_ItemsYPositions[i];
 
 		// Clipping area (we'll have to substract the scrollbar)
 		CRect cliparea = GetListRect();
 
 		if (m_ScrollBar)
 		{
 			if (cliparea.right > GetScrollBar(0).GetOuterRect().left &&
 				cliparea.right <= GetScrollBar(0).GetOuterRect().right)
 				cliparea.right = GetScrollBar(0).GetOuterRect().left;
 
 			if (cliparea.left >= GetScrollBar(0).GetOuterRect().left &&
 				cliparea.left < GetScrollBar(0).GetOuterRect().right)
 				cliparea.left = GetScrollBar(0).GetOuterRect().right;
 		}
 
 		// Draw all items for that column
 		xpos = 0;
 		for (size_t colIdx = 0; colIdx < m_Columns.size(); ++colIdx)
 		{
 			const COListColumn& column = m_Columns[colIdx];
 			if (column.m_Hidden)
 				continue;
 
 			// Determine text position and width
 			const CVector2D textPos = rect.TopLeft() + CVector2D(xpos, -scroll + m_ItemsYPositions[i]);
 
 			float width = column.m_Width;
 			// Check if it's a decimal value, and if so, assume relative positioning.
 			if (column.m_Width < 1 && column.m_Width > 0)
 				width *= m_TotalAvailableColumnWidth;
 
 			// Clip text to the column (to prevent drawing text into the neighboring column)
 			CRect cliparea2 = cliparea;
 			cliparea2.right = std::min(cliparea2.right, textPos.X + width);
 			cliparea2.bottom = std::min(cliparea2.bottom, textPos.Y + rowHeight);
 
 			// Draw list item
 			DrawText(objectsCount * (i +/*Heading*/1) + colIdx, column.m_TextColor, textPos, bz + 0.1f, cliparea2);
 			xpos += width;
 		}
 	}
 }
Index: ps/trunk/source/gui/ObjectTypes/CProgressBar.cpp
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CProgressBar.cpp	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CProgressBar.cpp	(revision 25392)
@@ -1,69 +1,66 @@
 /* Copyright (C) 2021 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 "CProgressBar.h"
 
 #include "gui/CGUI.h"
 
 CProgressBar::CProgressBar(CGUI& pGUI)
 	: IGUIObject(pGUI),
-	  m_SpriteBackground(),
-	  m_SpriteBar(),
-	  m_Progress()
+	  m_SpriteBackground(this, "sprite_background"),
+	  m_SpriteBar(this, "sprite_bar"),
+	  m_Progress(this, "progress") // Between 0 and 100.
 {
-	RegisterSetting("sprite_background", m_SpriteBackground);
-	RegisterSetting("sprite_bar", m_SpriteBar);
-	RegisterSetting("progress", m_Progress); // between 0 and 100
 }
 
 CProgressBar::~CProgressBar()
 {
 }
 
 void CProgressBar::HandleMessage(SGUIMessage& Message)
 {
 	IGUIObject::HandleMessage(Message);
 
 	switch (Message.type)
 	{
 	case GUIM_SETTINGS_UPDATED:
 		if (Message.value == "progress")
 		{
 			if (m_Progress > 100.f)
-				SetSetting<float>("progress", 100.f, true);
+				m_Progress.Set(100.f, true);
 			else if (m_Progress < 0.f)
-				SetSetting<float>("progress", 0.f, true);
+				m_Progress.Set(0.f, true);
 		}
 		break;
 	default:
 		break;
 	}
 }
 
 void CProgressBar::Draw()
 {
 	float bz = GetBufferedZ();
 
 	m_pGUI.DrawSprite(m_SpriteBackground, bz, m_CachedActualSize);
 
 	// Get size of bar (notice it is drawn slightly closer, to appear above the background)
 	CRect size = m_CachedActualSize;
 	size.right = size.left + m_CachedActualSize.GetWidth() * (m_Progress / 100.f),
 	m_pGUI.DrawSprite(m_SpriteBar, bz + 0.01f, size);
 }
Index: ps/trunk/source/gui/ObjectTypes/CRadioButton.h
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CRadioButton.h	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CRadioButton.h	(revision 25392)
@@ -1,42 +1,42 @@
-/* Copyright (C) 2019 Wildfire Games.
+/* Copyright (C) 2021 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_CRADIOBUTTON
 #define INCLUDED_CRADIOBUTTON
 
 #include "gui/ObjectTypes/CCheckBox.h"
 
 /**
- * Just like a check box, but it'll nullify its siblings (of the same kind),
+ * Just like a check box, but it'll nullify its siblings,
  * and it won't switch itself.
  *
  * @see CCheckBox
  */
 class CRadioButton : public CCheckBox
 {
 	GUI_OBJECT(CRadioButton)
 
 public:
 	CRadioButton(CGUI& pGUI);
 
 	/**
 	 * @see IGUIObject#HandleMessage()
 	 */
 	virtual void HandleMessage(SGUIMessage& Message);
 };
 
 #endif // INCLUDED_CRADIOBUTTON
Index: ps/trunk/source/gui/ObjectTypes/CText.cpp
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CText.cpp	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CText.cpp	(revision 25392)
@@ -1,243 +1,223 @@
 /* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "CText.h"
 
 #include "gui/CGUI.h"
 #include "gui/CGUIScrollBarVertical.h"
 #include "gui/CGUIText.h"
 
 CText::CText(CGUI& pGUI)
 	: IGUIObject(pGUI),
 	  IGUIScrollBarOwner(*static_cast<IGUIObject*>(this)),
 	  IGUITextOwner(*static_cast<IGUIObject*>(this)),
-	  m_BufferZone(),
-	  m_Caption(),
-	  m_Clip(),
-	  m_Font(),
-	  m_ScrollBar(),
-	  m_ScrollBarStyle(),
-	  m_ScrollBottom(),
-	  m_ScrollTop(),
-	  m_Sprite(),
-	  m_TextAlign(),
-	  m_TextVAlign(),
-	  m_TextColor(),
-	  m_TextColorDisabled()
-{
-	RegisterSetting("buffer_zone", m_BufferZone);
-	RegisterSetting("caption", m_Caption);
-	RegisterSetting("clip", m_Clip);
-	RegisterSetting("font", m_Font);
-	RegisterSetting("scrollbar", m_ScrollBar);
-	RegisterSetting("scrollbar_style", m_ScrollBarStyle);
-	RegisterSetting("scroll_bottom", m_ScrollBottom);
-	RegisterSetting("scroll_top", m_ScrollTop);
-	RegisterSetting("sprite", m_Sprite);
-	RegisterSetting("text_align", m_TextAlign);
-	RegisterSetting("text_valign", m_TextVAlign);
-	RegisterSetting("textcolor", m_TextColor);
-	RegisterSetting("textcolor_disabled", m_TextColorDisabled);
-
-	//SetSetting<bool>("ghost", true, true);
-	SetSetting<bool>("scrollbar", false, true);
-	SetSetting<bool>("clip", true, true);
-
+	  m_BufferZone(this, "buffer_zone"),
+	  m_Caption(this, "caption"),
+	  m_Clip(this, "clip", true),
+	  m_Font(this, "font"),
+	  m_ScrollBar(this, "scrollbar", false),
+	  m_ScrollBarStyle(this, "scrollbar_style"),
+	  m_ScrollBottom(this, "scroll_bottom"),
+	  m_ScrollTop(this, "scroll_top"),
+	  m_Sprite(this, "sprite"),
+	  m_TextColor(this, "textcolor"),
+	  m_TextColorDisabled(this, "textcolor_disabled")
+{
 	// Add scroll-bar
 	CGUIScrollBarVertical* bar = new CGUIScrollBarVertical(pGUI);
 	bar->SetRightAligned(true);
 	AddScrollBar(bar);
 
 	// Add text
 	AddText();
 }
 
 CText::~CText()
 {
 }
 
 void CText::SetupText()
 {
 	if (m_GeneratedTexts.empty())
 		return;
 
 	float width = m_CachedActualSize.GetWidth();
 	// remove scrollbar if applicable
 	if (m_ScrollBar && GetScrollBar(0).GetStyle())
 		width -= GetScrollBar(0).GetStyle()->m_Width;
 
-	m_GeneratedTexts[0] = CGUIText(m_pGUI, m_Caption, m_Font, width, m_BufferZone, this);
+	m_GeneratedTexts[0] = CGUIText(m_pGUI, m_Caption, m_Font, width, m_BufferZone, m_TextAlign, this);
 
 	if (!m_ScrollBar)
 		CalculateTextPosition(m_CachedActualSize, m_TextPos, m_GeneratedTexts[0]);
 
 	// Setup scrollbar
 	if (m_ScrollBar)
 	{
 		// If we are currently scrolled to the bottom of the text,
 		// then add more lines of text, update the scrollbar so we
 		// stick to the bottom.
 		// (Use 1.5px delta so this triggers the first time caption is set)
 		bool bottom = false;
 		if (m_ScrollBottom && GetScrollBar(0).GetPos() > GetScrollBar(0).GetMaxPos() - 1.5f)
 			bottom = true;
 
 		GetScrollBar(0).SetScrollRange(m_GeneratedTexts[0].GetSize().Height);
 		GetScrollBar(0).SetScrollSpace(m_CachedActualSize.GetHeight());
 
 		GetScrollBar(0).SetX(m_CachedActualSize.right);
 		GetScrollBar(0).SetY(m_CachedActualSize.top);
 		GetScrollBar(0).SetZ(GetBufferedZ());
 		GetScrollBar(0).SetLength(m_CachedActualSize.bottom - m_CachedActualSize.top);
 
 		if (bottom)
 			GetScrollBar(0).SetPos(GetScrollBar(0).GetMaxPos());
 
 		if (m_ScrollTop)
 			GetScrollBar(0).SetPos(0.0f);
 	}
 }
 
 void CText::ResetStates()
 {
 	IGUIObject::ResetStates();
 	IGUIScrollBarOwner::ResetStates();
 }
 
 void CText::UpdateCachedSize()
 {
 	IGUIObject::UpdateCachedSize();
 	IGUITextOwner::UpdateCachedSize();
 }
 
 CSize2D CText::GetTextSize()
 {
 	UpdateText();
 	return m_GeneratedTexts[0].GetSize();
 }
 
 const CStrW& CText::GetTooltipText() const
 {
 	for (const CGUIText& text : m_GeneratedTexts)
 		for (const CGUIText::STextCall& textChunk : text.GetTextCalls())
 		{
 			if (textChunk.m_Tooltip.empty())
 				continue;
 			CRect area(textChunk.m_Pos - CVector2D(0.f, textChunk.m_Size.Height), textChunk.m_Size);
 			if (area.PointInside(m_pGUI.GetMousePos() - m_CachedActualSize.TopLeft()))
 				return textChunk.m_Tooltip;
 		}
 	return m_Tooltip;
 }
 
 void CText::HandleMessage(SGUIMessage& Message)
 {
 	IGUIObject::HandleMessage(Message);
 	IGUIScrollBarOwner::HandleMessage(Message);
 	//IGUITextOwner::HandleMessage(Message); <== placed it after the switch instead!
 
 	switch (Message.type)
 	{
 	case GUIM_SETTINGS_UPDATED:
 		if (Message.value == "scrollbar")
 			SetupText();
 
 		// Update scrollbar
 		if (Message.value == "scrollbar_style")
 		{
 			GetScrollBar(0).SetScrollBarStyle(m_ScrollBarStyle);
 			SetupText();
 		}
 
 		break;
 
 	case GUIM_MOUSE_WHEEL_DOWN:
 	{
 		GetScrollBar(0).ScrollPlus();
 		// Since the scroll was changed, let's simulate a mouse movement
 		//  to check if scrollbar now is hovered
 		SGUIMessage msg(GUIM_MOUSE_MOTION);
 		HandleMessage(msg);
 		break;
 	}
 	case GUIM_MOUSE_WHEEL_UP:
 	{
 		GetScrollBar(0).ScrollMinus();
 		// Since the scroll was changed, let's simulate a mouse movement
 		//  to check if scrollbar now is hovered
 		SGUIMessage msg(GUIM_MOUSE_MOTION);
 		HandleMessage(msg);
 		break;
 	}
 	case GUIM_LOAD:
 	{
 		GetScrollBar(0).SetX(m_CachedActualSize.right);
 		GetScrollBar(0).SetY(m_CachedActualSize.top);
 		GetScrollBar(0).SetZ(GetBufferedZ());
 		GetScrollBar(0).SetLength(m_CachedActualSize.bottom - m_CachedActualSize.top);
 		GetScrollBar(0).SetScrollBarStyle(m_ScrollBarStyle);
 		break;
 	}
 
 	default:
 		break;
 	}
 
 	IGUITextOwner::HandleMessage(Message);
 }
 
 void CText::Draw()
 {
 	float bz = GetBufferedZ();
 
 	if (m_ScrollBar)
 		IGUIScrollBarOwner::Draw();
 
 	m_pGUI.DrawSprite(m_Sprite, bz, m_CachedActualSize);
 
 	float scroll = 0.f;
 	if (m_ScrollBar)
 		scroll = GetScrollBar(0).GetPos();
 
 	// Clipping area (we'll have to subtract the scrollbar)
 	CRect cliparea;
 	if (m_Clip)
 	{
 		cliparea = m_CachedActualSize;
 
 		if (m_ScrollBar)
 		{
 			// subtract scrollbar from cliparea
 			if (cliparea.right > GetScrollBar(0).GetOuterRect().left &&
 			    cliparea.right <= GetScrollBar(0).GetOuterRect().right)
 				cliparea.right = GetScrollBar(0).GetOuterRect().left;
 
 			if (cliparea.left >= GetScrollBar(0).GetOuterRect().left &&
 			    cliparea.left < GetScrollBar(0).GetOuterRect().right)
 				cliparea.left = GetScrollBar(0).GetOuterRect().right;
 		}
 	}
 
 	const CGUIColor& color = m_Enabled ? m_TextColor : m_TextColorDisabled;
 
 	if (m_ScrollBar)
 		DrawText(0, color, m_CachedActualSize.TopLeft() - CVector2D(0.f, scroll), bz + 0.1f, cliparea);
 	else
 		DrawText(0, color, m_TextPos, bz + 0.1f, cliparea);
 }
Index: ps/trunk/source/gui/ObjectTypes/CTooltip.h
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CTooltip.h	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CTooltip.h	(revision 25392)
@@ -1,72 +1,75 @@
 /* Copyright (C) 2021 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_CTOOLTIP
 #define INCLUDED_CTOOLTIP
 
 #include "gui/CGUISprite.h"
 #include "gui/ObjectBases/IGUIObject.h"
 #include "gui/ObjectBases/IGUITextOwner.h"
 #include "gui/SettingTypes/CGUIString.h"
 #include "maths/Vector2D.h"
 
 /**
  * Dynamic tooltips. Similar to CText.
  */
 class CTooltip : public IGUIObject, public IGUITextOwner
 {
 	GUI_OBJECT(CTooltip)
 
 public:
 	CTooltip(CGUI& pGUI);
 	virtual ~CTooltip();
 
+	const CStr& GetUsedObject() const { return m_UseObject; }
+	i32 GetTooltipDelay() const { return m_Delay; }
+	bool ShouldHideObject() const { return m_HideObject; }
+	void SetMousePos(const CVector2D& vec) { m_MousePos.Set(vec, true); }
+
 protected:
 	void SetupText();
 
 	/**
 	 * @see IGUIObject#UpdateCachedSize()
 	 */
 	void UpdateCachedSize();
 
 	/**
 	 * @see IGUIObject#HandleMessage()
 	 */
 	virtual void HandleMessage(SGUIMessage& Message);
 
 	virtual void Draw();
 
 	virtual float GetBufferedZ() const;
 
-	// Settings
-	float m_BufferZone;
-	CGUIString m_Caption;
-	CStrW m_Font;
-	CGUISpriteInstance m_Sprite;
-	i32 m_Delay;
-	CGUIColor m_TextColor;
-	float m_MaxWidth;
-	CVector2D m_Offset;
-	EVAlign m_Anchor;
-	EAlign m_TextAlign;
-	bool m_Independent;
-	CVector2D m_MousePos;
-	CStr m_UseObject;
-	bool m_HideObject;
+	CGUISimpleSetting<float> m_BufferZone;
+	CGUISimpleSetting<CGUIString> m_Caption;
+	CGUISimpleSetting<CStrW> m_Font;
+	CGUISimpleSetting<CGUISpriteInstance> m_Sprite;
+	CGUISimpleSetting<i32> m_Delay;
+	CGUISimpleSetting<CGUIColor> m_TextColor;
+	CGUISimpleSetting<float> m_MaxWidth;
+	CGUISimpleSetting<CVector2D> m_Offset;
+	CGUISimpleSetting<EVAlign> m_Anchor;
+	CGUISimpleSetting<bool> m_Independent;
+	CGUISimpleSetting<CVector2D> m_MousePos;
+	CGUISimpleSetting<CStr> m_UseObject;
+	CGUISimpleSetting<bool> m_HideObject;
 };
 
 #endif // INCLUDED_CTOOLTIP
Index: ps/trunk/source/scriptinterface/ScriptConversions.h
===================================================================
--- ps/trunk/source/scriptinterface/ScriptConversions.h	(revision 25391)
+++ ps/trunk/source/scriptinterface/ScriptConversions.h	(revision 25392)
@@ -1,109 +1,110 @@
-/* Copyright (C) 2020 Wildfire Games.
+/* Copyright (C) 2021 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_SCRIPTCONVERSIONS
 #define INCLUDED_SCRIPTCONVERSIONS
 
 #include "ScriptInterface.h"
 #include "scriptinterface/ScriptExtraHeaders.h" // for typed arrays
 
 #include <limits>
 
 template<typename T> static void ToJSVal_vector(const ScriptRequest& rq, JS::MutableHandleValue ret, const std::vector<T>& val)
 {
 	JS::RootedObject obj(rq.cx, JS::NewArrayObject(rq.cx, 0));
 	if (!obj)
 	{
 		ret.setUndefined();
 		return;
 	}
 
 	ENSURE(val.size() <= std::numeric_limits<u32>::max());
 	for (u32 i = 0; i < val.size(); ++i)
 	{
 		JS::RootedValue el(rq.cx);
 		ScriptInterface::ToJSVal<T>(rq, &el, val[i]);
 		JS_SetElement(rq.cx, obj, i, el);
 	}
 	ret.setObject(*obj);
 }
 
 #define FAIL(msg) STMT(ScriptException::Raise(rq, msg); return false)
 
 template<typename T> static bool FromJSVal_vector(const ScriptRequest& rq, JS::HandleValue v, std::vector<T>& out)
 {
 	JS::RootedObject obj(rq.cx);
 	if (!v.isObject())
 		FAIL("Argument must be an array");
 
 	bool isArray;
 	obj = &v.toObject();
 	if ((!JS::IsArrayObject(rq.cx, obj, &isArray) || !isArray) && !JS_IsTypedArrayObject(obj))
 		FAIL("Argument must be an array");
 
 	u32 length;
 	if (!JS::GetArrayLength(rq.cx, obj, &length))
 		FAIL("Failed to get array length");
 
+	out.clear();
 	out.reserve(length);
 	for (u32 i = 0; i < length; ++i)
 	{
 		JS::RootedValue el(rq.cx);
 		if (!JS_GetElement(rq.cx, obj, i, &el))
 			FAIL("Failed to read array element");
 		T el2;
 		if (!ScriptInterface::FromJSVal<T>(rq, el, el2))
 			return false;
 		out.push_back(el2);
 	}
 	return true;
 }
 
 #undef FAIL
 
 #define JSVAL_VECTOR(T) \
 template<> void ScriptInterface::ToJSVal<std::vector<T> >(const ScriptRequest& rq, JS::MutableHandleValue ret, const std::vector<T>& val) \
 { \
 	ToJSVal_vector(rq, ret, val); \
 } \
 template<> bool ScriptInterface::FromJSVal<std::vector<T> >(const ScriptRequest& rq, JS::HandleValue v, std::vector<T>& out) \
 { \
 	return FromJSVal_vector(rq, v, out); \
 }
 
 template<typename T> bool ScriptInterface::FromJSProperty(const ScriptRequest& rq, const JS::HandleValue val, const char* name, T& ret, bool strict)
 {
 	if (!val.isObject())
 		return false;
 
 	JS::RootedObject obj(rq.cx, &val.toObject());
 
 	bool hasProperty;
 	if (!JS_HasProperty(rq.cx, obj, name, &hasProperty) || !hasProperty)
 		return false;
 
 	JS::RootedValue value(rq.cx);
 	if (!JS_GetProperty(rq.cx, obj, name, &value))
 		return false;
 
 	if (strict && value.isNull())
 		return false;
 
 	return FromJSVal(rq, value, ret);
 }
 
 #endif //INCLUDED_SCRIPTCONVERSIONS
Index: ps/trunk/source/gui/ObjectTypes/CSlider.h
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CSlider.h	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CSlider.h	(revision 25392)
@@ -1,75 +1,75 @@
 /* Copyright (C) 2021 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_CSLIDER
 #define INCLUDED_CSLIDER
 
 #include "gui/CGUISprite.h"
 #include "gui/ObjectBases/IGUIButtonBehavior.h"
 #include "gui/ObjectBases/IGUIObject.h"
 #include "maths/Vector2D.h"
 
 class CSlider : public IGUIObject, public IGUIButtonBehavior
 {
 	GUI_OBJECT(CSlider)
 
 public:
 	CSlider(CGUI& pGUI);
 	virtual ~CSlider();
 
 protected:
 	static const CStr EventNameValueChange;
 
 	/**
 	 * @see IGUIObject#ResetStates()
 	 */
 	virtual void ResetStates();
 
 	/**
 	 * @see IGUIObject#HandleMessage()
 	 */
 	virtual void HandleMessage(SGUIMessage& Message);
 
 	virtual void Draw();
 
 	/**
 	 * Change settings and send the script event
 	 */
 	void UpdateValue();
 
 	CRect GetButtonRect() const;
 
 	/**
 	 * @return ratio between the value of the slider and its actual size in the GUI
 	 */
 	float GetSliderRatio() const;
 
 	void IncrementallyChangeValue(const float value);
 
 	// Settings
-	float m_ButtonSide;
-	float m_MinValue;
-	float m_MaxValue;
-	CGUISpriteInstance m_Sprite;
-	CGUISpriteInstance m_SpriteBar;
-	float m_Value;
+	CGUISimpleSetting<float> m_ButtonSide;
+	CGUISimpleSetting<float> m_MinValue;
+	CGUISimpleSetting<float> m_MaxValue;
+	CGUISimpleSetting<CGUISpriteInstance> m_Sprite;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteBar;
+	CGUISimpleSetting<float> m_Value;
 
 private:
 	CVector2D m_Mouse;
 };
 
 #endif // INCLUDED_CSLIDER
Index: ps/trunk/source/gui/ObjectTypes/CTooltip.cpp
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CTooltip.cpp	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CTooltip.cpp	(revision 25392)
@@ -1,167 +1,145 @@
 /* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "CTooltip.h"
 
 #include "gui/CGUI.h"
 #include "gui/SettingTypes/CGUIString.h"
 #include "gui/CGUIText.h"
 
 #include <algorithm>
 
 CTooltip::CTooltip(CGUI& pGUI)
 	: IGUIObject(pGUI),
 	  IGUITextOwner(*static_cast<IGUIObject*>(this)),
-	  m_BufferZone(),
-	  m_Caption(),
-	  m_Font(),
-	  m_Sprite(),
-	  m_Delay(),
-	  m_TextColor(),
-	  m_MaxWidth(),
-	  m_Offset(),
-	  m_Anchor(),
-	  m_TextAlign(),
-	  m_Independent(),
-	  m_MousePos(),
-	  m_UseObject(),
-	  m_HideObject()
-{
-	// If the tooltip is an object by itself:
-	RegisterSetting("buffer_zone", m_BufferZone);
-	RegisterSetting("caption", m_Caption);
-	RegisterSetting("font", m_Font);
-	RegisterSetting("sprite", m_Sprite);
-	RegisterSetting("delay", m_Delay); // in milliseconds
-	RegisterSetting("textcolor", m_TextColor);
-	RegisterSetting("maxwidth", m_MaxWidth);
-	RegisterSetting("offset", m_Offset);
-	RegisterSetting("anchor", m_Anchor);
-	RegisterSetting("text_align", m_TextAlign);
-	// This is used for tooltips that are hidden/revealed manually by scripts, rather than through the standard tooltip display mechanism
-	RegisterSetting("independent", m_Independent);
-	// Private settings:
-	// This is set by GUITooltip
-	RegisterSetting("_mousepos", m_MousePos);
-	// If the tooltip is just a reference to another object:
-	RegisterSetting("use_object", m_UseObject);
-	RegisterSetting("hide_object", m_HideObject);
-
-	// Defaults
-	SetSetting<i32>("delay", 500, true);
-	SetSetting<EVAlign>("anchor", EVAlign::BOTTOM, true);
-	SetSetting<EAlign>("text_align", EAlign::LEFT, true);
-
+	  m_BufferZone(this, "buffer_zone"),
+	  m_Caption(this, "caption"),
+	  m_Font(this, "font"),
+	  m_Sprite(this, "sprite"),
+	  m_Delay(this, "delay", 500), // in milliseconds
+	  m_TextColor(this, "textcolor"),
+	  m_MaxWidth(this, "maxwidth"),
+	  m_Offset(this, "offset"),
+	  m_Anchor(this, "anchor", EVAlign::BOTTOM),
+	  // This is used for tooltips that are hidden/revealed manually by scripts, rather than through the standard tooltip display mechanism
+	  m_Independent(this, "independent"),
+	  // Private settings:
+	  // This is set by GUITooltip
+	  m_MousePos(this, "_mousepos"),
+	  // If the tooltip is just a reference to another object:
+	  m_UseObject(this, "use_object"),
+	  m_HideObject(this, "hide_object")
+{
 	// Set up a blank piece of text, to be replaced with a more
 	// interesting message later
 	AddText();
 }
 
 CTooltip::~CTooltip()
 {
 }
 
 void CTooltip::SetupText()
 {
 	ENSURE(m_GeneratedTexts.size() == 1);
 
-	m_GeneratedTexts[0] = CGUIText(m_pGUI, m_Caption, m_Font, m_MaxWidth, m_BufferZone, this);
+	m_GeneratedTexts[0] = CGUIText(m_pGUI, m_Caption, m_Font, m_MaxWidth, m_BufferZone, m_TextAlign, this);
 
 	// Position the tooltip relative to the mouse:
 
 	const CVector2D& mousepos = m_Independent ? m_pGUI.GetMousePos() : m_MousePos;
 
 	float textwidth = m_GeneratedTexts[0].GetSize().Width;
 	float textheight = m_GeneratedTexts[0].GetSize().Height;
 
 	CGUISize size;
-	size.pixel.left = mousepos.X + m_Offset.X;
+	size.pixel.left = mousepos.X + m_Offset->X;
 	size.pixel.right = size.pixel.left + textwidth;
 
 	switch (m_Anchor)
 	{
 	case EVAlign::TOP:
-		size.pixel.top = mousepos.Y + m_Offset.Y;
+		size.pixel.top = mousepos.Y + m_Offset->Y;
 		size.pixel.bottom = size.pixel.top + textheight;
 		break;
 	case EVAlign::BOTTOM:
-		size.pixel.bottom = mousepos.Y + m_Offset.Y;
+		size.pixel.bottom = mousepos.Y + m_Offset->Y;
 		size.pixel.top = size.pixel.bottom - textheight;
 		break;
 	case EVAlign::CENTER:
-		size.pixel.top = mousepos.Y + m_Offset.Y - textheight/2.f;
+		size.pixel.top = mousepos.Y + m_Offset->Y - textheight/2.f;
 		size.pixel.bottom = size.pixel.top + textwidth;
 		break;
 	default:
 		debug_warn(L"Invalid EVAlign!");
 	}
 
 
 	// Reposition the tooltip if it's falling off the screen:
 
 	extern int g_xres, g_yres;
 	extern float g_GuiScale;
 	float screenw = g_xres / g_GuiScale;
 	float screenh = g_yres / g_GuiScale;
 
 	if (size.pixel.top < 0.f)
 		size.pixel.bottom -= size.pixel.top, size.pixel.top = 0.f;
 	else if (size.pixel.bottom > screenh)
 		size.pixel.top -= (size.pixel.bottom-screenh), size.pixel.bottom = screenh;
 
 	if (size.pixel.left < 0.f)
 		size.pixel.right -= size.pixel.left, size.pixel.left = 0.f;
 	else if (size.pixel.right > screenw)
 		size.pixel.left -= (size.pixel.right-screenw), size.pixel.right = screenw;
 
-	SetSetting<CGUISize>("size", size, true);
+	m_Size.Set(size, true);
 }
 
 void CTooltip::UpdateCachedSize()
 {
 	IGUIObject::UpdateCachedSize();
 	IGUITextOwner::UpdateCachedSize();
 }
 
 void CTooltip::HandleMessage(SGUIMessage& Message)
 {
 	IGUIObject::HandleMessage(Message);
 	IGUITextOwner::HandleMessage(Message);
 }
 
 void CTooltip::Draw()
 {
 	// Normally IGUITextOwner will handle this updating but since SetupText can modify the position
 	// we need to call it now *before* we do the rest of the drawing
 	if (!m_GeneratedTextsValid)
 	{
 		SetupText();
 		m_GeneratedTextsValid = true;
 	}
 
 	const float z = GetBufferedZ();
 	m_pGUI.DrawSprite(m_Sprite, z, m_CachedActualSize);
 	DrawText(0, m_TextColor, m_CachedActualSize.TopLeft(), z + 0.1f);
 }
 
 float CTooltip::GetBufferedZ() const
 {
 	// TODO: Find a nicer way of putting the tooltip on top of everything else.
 	return 900.f;
 }
Index: ps/trunk/source/gui/SettingTypes/CGUIHotkey.h
===================================================================
--- ps/trunk/source/gui/SettingTypes/CGUIHotkey.h	(nonexistent)
+++ ps/trunk/source/gui/SettingTypes/CGUIHotkey.h	(revision 25392)
@@ -0,0 +1,40 @@
+/* Copyright (C) 2021 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_CGUIHOTKEY
+#define INCLUDED_CGUIHOTKEY
+
+#include "gui/CGUISetting.h"
+#include "ps/CStr.h"
+
+/**
+ * Manages a hotkey setting for a GUI object.
+ */
+class CGUIHotkey : public CGUISimpleSetting<CStr>
+{
+public:
+	CGUIHotkey(IGUIObject* pObject, const CStr& Name) : CGUISimpleSetting<CStr>(pObject, Name)
+	{}
+	NONCOPYABLE(CGUIHotkey);
+	MOVABLE(CGUIHotkey);
+
+	bool DoFromString(const CStrW& value) override;
+	bool DoFromJSVal(const ScriptRequest& rq, JS::HandleValue value) override;
+	void OnSettingChange(const CStr& setting, bool sendMessage) override;
+};
+
+#endif // INCLUDED_CGUIHOTKEY

Property changes on: ps/trunk/source/gui/SettingTypes/CGUIHotkey.h
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: ps/trunk/source/gui/ObjectTypes/CList.h
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CList.h	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CList.h	(revision 25392)
@@ -1,164 +1,162 @@
 /* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef INCLUDED_CLIST
 #define INCLUDED_CLIST
 
 #include "gui/CGUISprite.h"
 #include "gui/ObjectBases/IGUIObject.h"
 #include "gui/ObjectBases/IGUIScrollBarOwner.h"
 #include "gui/ObjectBases/IGUITextOwner.h"
 #include "gui/SettingTypes/CGUIList.h"
 
 #include <vector>
 
 /**
  * Create a list of elements, where one can be selected
  * by the user. The control will use a pre-processed
  * text-object for each element, which will be managed
  * by the IGUITextOwner structure.
  *
  * A scroll-bar will appear when needed. This will be
  * achieved with the IGUIScrollBarOwner structure.
  */
 class CList : public IGUIObject, public IGUIScrollBarOwner, public IGUITextOwner
 {
 	GUI_OBJECT(CList)
 public:
 	CList(CGUI& pGUI);
 	virtual ~CList();
 
 	/**
 	 * @see IGUIObject#ResetStates()
 	 */
 	virtual void ResetStates();
 
 	/**
 	 * @see IGUIObject#UpdateCachedSize()
 	 */
 	virtual void UpdateCachedSize();
 
 	/**
 	 * Adds an item last to the list.
 	 */
 	virtual void AddItem(const CGUIString& str, const CGUIString& data);
 
 	/**
 	 * Add an item where both parameters are identical.
 	 */
 	void AddItem(const CGUIString& strAndData);
 
 protected:
 	/**
 	 * Sets up text, should be called every time changes has been
 	 * made that can change the visual.
 	 * @param append - if true, we assume we only need to render the new element at the end of the list.
 	 */
 	virtual void SetupText();
 	virtual void SetupText(bool append);
 
 	/**
 	 * @see IGUIObject#HandleMessage()
 	 */
 	virtual void HandleMessage(SGUIMessage& Message);
 
 	/**
 	 * Handle events manually to catch keyboard inputting.
 	 */
 	virtual InReaction ManuallyHandleKeys(const SDL_Event_* ev);
 
 	/**
 	 * Draws the List box
 	 */
 	virtual void Draw();
 
 	virtual void CreateJSObject();
 
 	/**
 	 * Easy select elements functions
 	 */
 	virtual void SelectNextElement();
 	virtual void SelectPrevElement();
 	virtual void SelectFirstElement();
 	virtual void SelectLastElement();
 
 	/**
 	 * Handle the \<item\> tag.
 	 */
 	virtual bool HandleAdditionalChildren(const XMBData& xmb, const XMBElement& child);
 
 	// Called every time the auto-scrolling should be checked.
 	void UpdateAutoScroll();
 
 	// Extended drawing interface, this is so that classes built on the this one
 	//  can use other sprite names.
 	virtual void DrawList(const int& selected, const CGUISpriteInstance& sprite, const CGUISpriteInstance& sprite_selected, const CGUIColor& textcolor);
 
 	// Get the area of the list. This is so that it can easily be changed, like in CDropDown
 	//  where the area is not equal to m_CachedActualSize.
 	virtual CRect GetListRect() const { return m_CachedActualSize; }
 
 	// Returns whether SetupText() has run since the last message was received
 	// (and thus whether list items have possibly changed).
 	virtual bool GetModified() const { return m_Modified; }
 
 	/**
 	 * List of each element's relative y position. Will be
 	 * one larger than m_Items, because it will end with the
 	 * bottom of the last element. First element will always
 	 * be zero, but still stored for easy handling.
 	 */
 	std::vector<float> m_ItemsYPositions;
 
 	virtual int GetHoveredItem();
 
-	// Settings
-	float m_BufferZone;
-	CStrW m_Font;
-	bool m_ScrollBar;
-	CStr m_ScrollBarStyle;
-	bool m_ScrollBottom;
-	CStrW m_SoundDisabled;
-	CStrW m_SoundSelected;
-	CGUISpriteInstance m_Sprite;
-	CGUISpriteInstance m_SpriteSelectArea;
-	EAlign m_TextAlign;
-	CGUIColor m_TextColor;
-	CGUIColor m_TextColorSelected;
-	i32 m_Selected;
-	bool m_AutoScroll;
-	i32 m_Hovered;
-	CGUIList m_List;
-	CGUIList m_ListData;
+	CGUISimpleSetting<float> m_BufferZone;
+	CGUISimpleSetting<CStrW> m_Font;
+	CGUISimpleSetting<bool> m_ScrollBar;
+	CGUISimpleSetting<CStr> m_ScrollBarStyle;
+	CGUISimpleSetting<bool> m_ScrollBottom;
+	CGUISimpleSetting<CStrW> m_SoundDisabled;
+	CGUISimpleSetting<CStrW> m_SoundSelected;
+	CGUISimpleSetting<CGUISpriteInstance> m_Sprite;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteSelectArea;
+	CGUISimpleSetting<CGUIColor> m_TextColor;
+	CGUISimpleSetting<CGUIColor> m_TextColorSelected;
+	CGUISimpleSetting<i32> m_Selected;
+	CGUISimpleSetting<bool> m_AutoScroll;
+	CGUISimpleSetting<i32> m_Hovered;
+	CGUISimpleSetting<CGUIList> m_List;
+	CGUISimpleSetting<CGUIList> m_ListData;
 
 private:
 	static const CStr EventNameSelectionChange;
 	static const CStr EventNameHoverChange;
 	static const CStr EventNameMouseLeftClickItem;
 	static const CStr EventNameMouseLeftDoubleClickItem;
 
 	// Whether the list's items have been modified since last handling a message.
 	bool m_Modified;
 
 	// Used for doubleclick registration
 	int m_PrevSelectedItem;
 
 	// Last time a click on an item was issued
 	double m_LastItemClickTime;
 };
 
 #endif // INCLUDED_CLIST
Index: ps/trunk/source/gui/ObjectTypes/CMiniMap.h
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CMiniMap.h	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CMiniMap.h	(revision 25392)
@@ -1,126 +1,126 @@
-/* Copyright (C) 2020 Wildfire Games.
+/* Copyright (C) 2021 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_MINIMAP
 #define INCLUDED_MINIMAP
 
 #include "graphics/ShaderProgramPtr.h"
 #include "gui/ObjectBases/IGUIObject.h"
 #include "renderer/VertexArray.h"
 
 class CCamera;
 class CMatrix3D;
 class CTerrain;
 
 class CMiniMap : public IGUIObject
 {
 	GUI_OBJECT(CMiniMap)
 public:
 	CMiniMap(CGUI& pGUI);
 	virtual ~CMiniMap();
 
 	/**
 	 * @return The maximum height for unit passage in water.
 	 */
 	static float GetShallowPassageHeight();
 
 protected:
 	virtual void Draw();
 
 	/**
 	 * @see IGUIObject#HandleMessage()
 	 */
 	virtual void HandleMessage(SGUIMessage& Message);
 
 	/**
 	 * @see IGUIObject#IsMouseOver()
 	 */
 	virtual bool IsMouseOver() const;
 
 	// create the minimap textures
 	void CreateTextures();
 
 	// rebuild the terrain texture map
 	void RebuildTerrainTexture();
 
 	// destroy and free any memory and textures
 	void Destroy();
 
 	void SetCameraPos();
 
 	bool FireWorldClickEvent(int button, int clicks);
 
 	static const CStr EventNameWorldClick;
 
 	// the terrain we are mini-mapping
 	const CTerrain* m_Terrain;
 
 	const CCamera* m_Camera;
 
 	//Whether or not the mouse is currently down
 	bool m_Clicking;
 
 	// minimap texture handles
 	GLuint m_TerrainTexture;
 
 	// texture data
 	u32* m_TerrainData;
 
 	// whether we need to regenerate the terrain texture
 	bool m_TerrainDirty;
 
 	// Whether to draw a black square around and under the minimap.
-	bool m_Mask;
+	CGUISimpleSetting<bool> m_Mask;
 
 	ssize_t m_Width, m_Height;
 
 	// map size
 	ssize_t m_MapSize;
 
 	// texture size
 	GLsizei m_TextureSize;
 
 	// 1.f if map is circular or 1.414f if square (to shrink it inside the circle)
 	float m_MapScale;
 
 	// maximal water height to allow the passage of a unit (for underwater shallows).
 	float m_ShallowPassageHeight;
 
 	float m_WaterHeight;
 
 	void DrawTexture(CShaderProgramPtr shader, float coordMax, float angle, float x, float y, float x2, float y2, float z) const;
 
 	void DrawViewRect(const CMatrix3D& transform) const;
 
 	void GetMouseWorldCoordinates(float& x, float& z) const;
 
 	float GetAngle() const;
 
 	VertexIndexArray m_IndexArray;
 	VertexArray m_VertexArray;
 	VertexArray::Attribute m_AttributePos;
 	VertexArray::Attribute m_AttributeColor;
 
 	size_t m_EntitiesDrawn;
 
 	double m_PingDuration;
 	double m_HalfBlinkDuration;
 	double m_NextBlinkTime;
 	bool m_BlinkState;
 };
 
 #endif // INCLUDED_MINIMAP
Index: ps/trunk/source/gui/ObjectTypes/COList.h
===================================================================
--- ps/trunk/source/gui/ObjectTypes/COList.h	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/COList.h	(revision 25392)
@@ -1,93 +1,95 @@
 /* Copyright (C) 2021 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_COLIST
 #define INCLUDED_COLIST
 
 #include "gui/ObjectTypes/CList.h"
 #include "gui/SettingTypes/CGUIColor.h"
 
 #include <vector>
 
 /**
  * Represents a column.
  */
-struct COListColumn
+class COListColumn
 {
+public:
+	COListColumn(IGUIObject* owner, const CStr& cid)
+		: m_Width(0), m_Id(cid), m_List(owner, "list_" + cid), m_Hidden(owner, "hidden_" + cid, false)
+	{}
 	// Avoid copying the strings.
 	NONCOPYABLE(COListColumn);
 	MOVABLE(COListColumn);
-	COListColumn() : m_Width(0), m_Hidden(false) {}
 	CGUIColor m_TextColor;
 	CStr m_Id;
 	float m_Width;
 	CStrW m_Heading; // CGUIString??
-	CGUIList m_List;
-	bool m_Hidden;
+	CGUISimpleSetting<CGUIList> m_List;
+	CGUISimpleSetting<bool> m_Hidden;
 };
 
 /**
  * Multi-column list. One row can be selected by the user.
  * Individual cells are clipped if the contained text is too long.
  *
  * The list can be sorted dynamically by JS code when a
  * heading is clicked.
  * A scroll-bar will appear when needed.
  */
 class COList : public CList
 {
 	GUI_OBJECT(COList)
 
 public:
 	COList(CGUI& pGUI);
 
 protected:
 	void SetupText();
 	void HandleMessage(SGUIMessage& Message);
 
 	/**
 	 * Handle the \<item\> tag.
 	 */
 	virtual bool HandleAdditionalChildren(const XMBData& xmb, const XMBElement& child);
 	virtual void AdditionalChildrenHandled();
 
 	void DrawList(const int& selected, const CGUISpriteInstance& sprite, const CGUISpriteInstance& sprite_selected, const CGUIColor& textcolor);
 
 	virtual CRect GetListRect() const;
 
 	/**
 	 * Available columns.
 	 */
 	std::vector<COListColumn> m_Columns;
 
-	// Settings
-	CGUISpriteInstance m_SpriteHeading;
-	bool m_Sortable;
-	CStr m_SelectedColumn;
-	i32 m_SelectedColumnOrder;
-	CGUISpriteInstance m_SpriteAsc;
-	CGUISpriteInstance m_SpriteDesc;
-	CGUISpriteInstance m_SpriteNotSorted;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteHeading;
+	CGUISimpleSetting<bool> m_Sortable;
+	CGUISimpleSetting<CStr> m_SelectedColumn;
+	CGUISimpleSetting<i32> m_SelectedColumnOrder;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteAsc;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteDesc;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteNotSorted;
 
 private:
 	static const CStr EventNameSelectionColumnChange;
 
 	// Width of space available for columns
 	float m_TotalAvailableColumnWidth;
 	float m_HeadingHeight;
 };
 
 #endif // INCLUDED_COLIST
Index: ps/trunk/source/gui/ObjectTypes/CProgressBar.h
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CProgressBar.h	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CProgressBar.h	(revision 25392)
@@ -1,53 +1,53 @@
-/* Copyright (C) 2019 Wildfire Games.
+/* Copyright (C) 2021 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_CPROGRESSBAR
 #define INCLUDED_CPROGRESSBAR
 
 #include "gui/ObjectBases/IGUIObject.h"
 #include "gui/CGUISprite.h"
 
 /**
  * Object used to draw a value (e.g. progress) from 0 to 100 visually.
  */
 class CProgressBar : public IGUIObject
 {
 	GUI_OBJECT(CProgressBar)
 
 public:
 	CProgressBar(CGUI& pGUI);
 	virtual ~CProgressBar();
 
 protected:
 	/**
 	 * Draws the progress bar
 	 */
 	virtual void Draw();
 
 	/**
 	 * @see IGUIObject#HandleMessage()
 	 * If the progress is changed, ensure the interval is between 0 and 100.
 	 */
 	void HandleMessage(SGUIMessage& Message);
 
 	// Settings
-	CGUISpriteInstance m_SpriteBackground;
-	CGUISpriteInstance m_SpriteBar;
-	float m_Progress;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteBackground;
+	CGUISimpleSetting<CGUISpriteInstance> m_SpriteBar;
+	CGUISimpleSetting<float> m_Progress;
 };
 
 #endif // INCLUDED_CPROGRESSBAR
Index: ps/trunk/source/gui/ObjectTypes/CSlider.cpp
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CSlider.cpp	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CSlider.cpp	(revision 25392)
@@ -1,132 +1,126 @@
 /* Copyright (C) 2021 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 "CSlider.h"
 
 #include "gui/CGUI.h"
 #include "maths/MathUtil.h"
 
 const CStr CSlider::EventNameValueChange = "ValueChange";
 
 CSlider::CSlider(CGUI& pGUI)
 	: IGUIObject(pGUI),
 	  IGUIButtonBehavior(*static_cast<IGUIObject*>(this)),
-	  m_ButtonSide(),
-	  m_MaxValue(),
-	  m_MinValue(),
-	  m_Sprite(),
-	  m_SpriteBar(),
-	  m_Value()
-{
-	RegisterSetting("button_width", m_ButtonSide);
-	RegisterSetting("max_value", m_MaxValue);
-	RegisterSetting("min_value", m_MinValue);
-	RegisterSetting("sprite", m_Sprite);
-	RegisterSetting("sprite_bar", m_SpriteBar);
-	RegisterSetting("value", m_Value);
-
-	m_Value = Clamp(m_Value, m_MinValue, m_MaxValue);
+	  m_ButtonSide(this, "button_width"),
+	  m_MaxValue(this, "max_value"),
+	  m_MinValue(this, "min_value"),
+	  m_Sprite(this, "sprite"),
+	  m_SpriteBar(this, "sprite_bar"),
+	  m_Value(this, "value")
+{
+	m_Value.Set(Clamp<float>(m_Value, m_MinValue, m_MaxValue), false);
 }
 
 CSlider::~CSlider()
 {
 }
 
 void CSlider::ResetStates()
 {
 	IGUIObject::ResetStates();
 	IGUIButtonBehavior::ResetStates();
 }
 
 float CSlider::GetSliderRatio() const
 {
 	return (m_MaxValue - m_MinValue) / (m_CachedActualSize.GetWidth() - m_ButtonSide);
 }
 
 void CSlider::IncrementallyChangeValue(const float difference)
 {
-	m_Value = Clamp(m_Value + difference, m_MinValue, m_MaxValue);
+	m_Value.Set(Clamp<float>(m_Value + difference, m_MinValue, m_MaxValue), true);
 	UpdateValue();
 }
 
 void CSlider::HandleMessage(SGUIMessage& Message)
 {
 	IGUIObject::HandleMessage(Message);
 	IGUIButtonBehavior::HandleMessage(Message);
 
 	switch (Message.type)
 	{
+	/*
 	case GUIM_SETTINGS_UPDATED:
 	{
-		m_Value = Clamp(m_Value, m_MinValue, m_MaxValue);
+		m_Value.Set(Clamp<float>(m_Value, m_MinValue, m_MaxValue), true);
 		break;
 	}
+	*/
 	case GUIM_MOUSE_WHEEL_DOWN:
 	{
 		if (m_Pressed)
 			break;
 		IncrementallyChangeValue(-0.01f);
 		break;
 	}
 	case GUIM_MOUSE_WHEEL_UP:
 	{
 		if (m_Pressed)
 			break;
 		IncrementallyChangeValue(0.01f);
 		break;
 	}
 	case GUIM_MOUSE_PRESS_LEFT:
 		FALLTHROUGH;
 	case GUIM_MOUSE_MOTION:
 	{
 		if (m_Pressed)
 		{
 			m_Mouse = m_pGUI.GetMousePos();
 			IncrementallyChangeValue((m_Mouse.X - GetButtonRect().CenterPoint().X) * GetSliderRatio());
 		}
 		break;
 	}
 	default:
 		break;
 	}
 }
 
 void CSlider::Draw()
 {
 	CRect slider_line(m_CachedActualSize);
 	slider_line.left += m_ButtonSide / 2.0f;
 	slider_line.right -= m_ButtonSide / 2.0f;
 	float bz = GetBufferedZ();
 	m_pGUI.DrawSprite(m_SpriteBar, bz, slider_line);
 	m_pGUI.DrawSprite(m_Sprite, bz, GetButtonRect());
 }
 
 void CSlider::UpdateValue()
 {
-	SetSetting<float>("value", m_Value, true);
 	ScriptEvent(EventNameValueChange);
 }
 
 CRect CSlider::GetButtonRect() const
 {
 	float ratio = m_MaxValue > m_MinValue ? (m_Value - m_MinValue) / (m_MaxValue - m_MinValue) : 0.0f;
 	float x = m_CachedActualSize.left + ratio * (m_CachedActualSize.GetWidth() - m_ButtonSide);
 	float y = m_CachedActualSize.top + (m_CachedActualSize.GetHeight() - m_ButtonSide) / 2.0;
 	return CRect(x, y, x + m_ButtonSide, y + m_ButtonSide);
 }
Index: ps/trunk/source/gui/ObjectTypes/CText.h
===================================================================
--- ps/trunk/source/gui/ObjectTypes/CText.h	(revision 25391)
+++ ps/trunk/source/gui/ObjectTypes/CText.h	(revision 25392)
@@ -1,93 +1,90 @@
 /* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef INCLUDED_CTEXT
 #define INCLUDED_CTEXT
 
 #include "gui/CGUISprite.h"
 #include "gui/ObjectBases/IGUIObject.h"
 #include "gui/ObjectBases/IGUIScrollBarOwner.h"
 #include "gui/ObjectBases/IGUITextOwner.h"
 #include "gui/SettingTypes/CGUIString.h"
 
 /**
  * Text field that just displays static text.
  */
 class CText : public IGUIObject, public IGUIScrollBarOwner, public IGUITextOwner
 {
 	GUI_OBJECT(CText)
 public:
 	CText(CGUI& pGUI);
 	virtual ~CText();
 
 	/**
 	 * @see IGUIObject#ResetStates()
 	 */
 	virtual void ResetStates();
 
 	/**
 	 * @see IGUIObject#UpdateCachedSize()
 	 */
 	virtual void UpdateCachedSize();
 
 	/**
 	 * @return the object text size.
 	 */
 	CSize2D GetTextSize();
 
 	virtual const CStrW& GetTooltipText() const;
 protected:
 	/**
 	 * Sets up text, should be called every time changes has been
 	 * made that can change the visual.
 	 */
 	void SetupText();
 
 	/**
 	 * @see IGUIObject#HandleMessage()
 	 */
 	virtual void HandleMessage(SGUIMessage& Message);
 
 	/**
 	 * Draws the Text
 	 */
 	virtual void Draw();
 
 	virtual void CreateJSObject();
 
 	/**
 	 * Placement of text. Ignored when scrollbars are active.
 	 */
 	CVector2D m_TextPos;
 
-	// Settings
-	float m_BufferZone;
-	CGUIString m_Caption;
-	bool m_Clip;
-	CStrW m_Font;
-	bool m_ScrollBar;
-	CStr m_ScrollBarStyle;
-	bool m_ScrollBottom;
-	bool m_ScrollTop;
-	CGUISpriteInstance m_Sprite;
-	EAlign m_TextAlign;
-	EVAlign m_TextVAlign;
-	CGUIColor m_TextColor;
-	CGUIColor m_TextColorDisabled;
+	CGUISimpleSetting<float> m_BufferZone;
+	CGUISimpleSetting<CGUIString> m_Caption;
+	CGUISimpleSetting<bool> m_Clip;
+	CGUISimpleSetting<CStrW> m_Font;
+	CGUISimpleSetting<bool> m_ScrollBar;
+	CGUISimpleSetting<CStr> m_ScrollBarStyle;
+	CGUISimpleSetting<bool> m_ScrollBottom;
+	CGUISimpleSetting<bool> m_ScrollTop;
+	CGUISimpleSetting<CGUISpriteInstance> m_Sprite;
+	CGUISimpleSetting<CGUIColor> m_TextColor;
+	CGUISimpleSetting<CGUIColor> m_TextColorDisabled;
 };
 
 #endif // INCLUDED_CTEXT
Index: ps/trunk/source/gui/SettingTypes/CGUIHotkey.cpp
===================================================================
--- ps/trunk/source/gui/SettingTypes/CGUIHotkey.cpp	(nonexistent)
+++ ps/trunk/source/gui/SettingTypes/CGUIHotkey.cpp	(revision 25392)
@@ -0,0 +1,46 @@
+/* Copyright (C) 2021 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 "CGUIHotkey.h"
+
+#include "gui/ObjectBases/IGUIObject.h"
+#include "scriptinterface/ScriptInterface.h"
+
+bool CGUIHotkey::DoFromString(const CStrW& value)
+{
+	m_pObject.GetGUI().UnsetObjectHotkey(&m_pObject, m_Setting);
+	m_Setting = value.ToUTF8();
+	m_pObject.GetGUI().SetObjectHotkey(&m_pObject, m_Setting);
+	return true;
+}
+
+bool CGUIHotkey::DoFromJSVal(const ScriptRequest& rq, JS::HandleValue value)
+{
+	m_pObject.GetGUI().UnsetObjectHotkey(&m_pObject, m_Setting);
+	if (!ScriptInterface::FromJSVal(rq, value, m_Setting))
+		return false;
+	m_pObject.GetGUI().SetObjectHotkey(&m_pObject, m_Setting);
+	return true;
+}
+
+void CGUIHotkey::OnSettingChange(const CStr& setting, bool sendMessage)
+{
+	IGUISetting::OnSettingChange(setting, sendMessage);
+}
+

Property changes on: ps/trunk/source/gui/SettingTypes/CGUIHotkey.cpp
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property