Index: ps/trunk/source/gui/IGUIObject.cpp
===================================================================
--- ps/trunk/source/gui/IGUIObject.cpp	(revision 22592)
+++ ps/trunk/source/gui/IGUIObject.cpp	(revision 22593)
@@ -1,573 +1,577 @@
 /* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "GUI.h"
 
 #include "gui/scripting/JSInterface_GUITypes.h"
 #include "gui/scripting/JSInterface_IGUIObject.h"
 
 #include "ps/GameSetup/Config.h"
 #include "ps/CLogger.h"
 #include "ps/Profile.h"
 #include "scriptinterface/ScriptInterface.h"
 
 template<typename T>
 void SGUISetting::Init(IGUIObject& pObject, const CStr& Name)
 {
 	m_pSetting = new T();
 
 	m_FromJSVal = [Name, &pObject](JSContext* cx, JS::HandleValue v) {
 		T value;
 		if (!ScriptInterface::FromJSVal<T>(cx, v, value))
 			return false;
 
 		GUI<T>::SetSetting(&pObject, Name, value);
 		return true;
 	};
 
 	m_ToJSVal = [Name, this](JSContext* cx, JS::MutableHandleValue v) {
 		ScriptInterface::ToJSVal<T>(cx, v, *static_cast<T*>(m_pSetting));
 	};
 }
 
 IGUIObject::IGUIObject(CGUI* pGUI)
 	: m_pGUI(pGUI), m_pParent(NULL), m_MouseHovering(false), m_LastClickTime()
 {
 	AddSetting(GUIST_bool,			"enabled");
 	AddSetting(GUIST_bool,			"hidden");
 	AddSetting(GUIST_CClientArea,	"size");
 	AddSetting(GUIST_CStr,			"style");
 	AddSetting(GUIST_CStr,			"hotkey");
 	AddSetting(GUIST_float,			"z");
 	AddSetting(GUIST_bool,			"absolute");
 	AddSetting(GUIST_bool,			"ghost");
 	AddSetting(GUIST_float,			"aspectratio");
 	AddSetting(GUIST_CStrW,			"tooltip");
 	AddSetting(GUIST_CStr,			"tooltip_style");
 
 	// Setup important defaults
 	GUI<bool>::SetSetting(this, "hidden", false);
 	GUI<bool>::SetSetting(this, "ghost", false);
 	GUI<bool>::SetSetting(this, "enabled", true);
 	GUI<bool>::SetSetting(this, "absolute", true);
 }
 
 IGUIObject::~IGUIObject()
 {
 	for (const std::pair<CStr, SGUISetting>& p : m_Settings)
 		switch (p.second.m_Type)
 		{
 			// delete() needs to know the type of the variable - never delete a void*
 #define TYPE(t) case GUIST_##t: delete (t*)p.second.m_pSetting; break;
 #include "GUItypes.h"
 #undef TYPE
 		default:
 			debug_warn(L"Invalid setting type");
 		}
 
 	if (!m_ScriptHandlers.empty())
 		JS_RemoveExtraGCRootsTracer(m_pGUI->GetScriptInterface()->GetJSRuntime(), Trace, this);
 }
 
 //-------------------------------------------------------------------
 //  Functions
 //-------------------------------------------------------------------
 
 void IGUIObject::AddChild(IGUIObject* pChild)
 {
 //	ENSURE(pChild);
 
 	pChild->SetParent(this);
 
 	m_Children.push_back(pChild);
 
 	// If this (not the child) object is already attached
 	//  to a CGUI, it pGUI pointer will be non-null.
 	//  This will mean we'll have to check if we're using
 	//  names already used.
 	if (pChild->GetGUI())
 	{
 		try
 		{
 			// Atomic function, if it fails it won't
 			//  have changed anything
 			//UpdateObjects();
 			pChild->GetGUI()->UpdateObjects();
 		}
 		catch (PSERROR_GUI&)
 		{
 			// If anything went wrong, reverse what we did and throw
 			//  an exception telling it never added a child
 			m_Children.erase(m_Children.end()-1);
 
 			throw;
 		}
 	}
 	// else do nothing
 }
 
 void IGUIObject::AddToPointersMap(map_pObjects& ObjectMap)
 {
 	// Just don't do anything about the top node
 	if (m_pParent == NULL)
 		return;
 
 	// Now actually add this one
 	//  notice we won't add it if it's doesn't have any parent
 	//  (i.e. being the base object)
 	if (m_Name.empty())
 	{
 		throw PSERROR_GUI_ObjectNeedsName();
 	}
 	if (ObjectMap.count(m_Name) > 0)
 	{
 		throw PSERROR_GUI_NameAmbiguity(m_Name.c_str());
 	}
 	else
 	{
 		ObjectMap[m_Name] = this;
 	}
 }
 
 void IGUIObject::Destroy()
 {
 	// Is there anything besides the children to destroy?
 }
 
 void IGUIObject::AddSetting(const EGUISettingType& Type, const CStr& Name)
 {
 	// Is name already taken?
 	if (m_Settings.count(Name) >= 1)
 		return;
 
 	// Construct, and set type
 	m_Settings[Name].m_Type = Type;
 
 	switch (Type)
 	{
 #define TYPE(type) \
 	case GUIST_##type: \
 		m_Settings[Name].Init<type>(*this, Name);\
 		break;
 
 		// Construct the setting.
 		#include "GUItypes.h"
 
 #undef TYPE
 
 	default:
 		debug_warn(L"IGUIObject::AddSetting failed, type not recognized!");
 		break;
 	}
 }
 
 
 bool IGUIObject::MouseOver()
 {
 	if (!GetGUI())
 		throw PSERROR_GUI_OperationNeedsGUIObject();
 
 	return m_CachedActualSize.PointInside(GetMousePos());
 }
 
 bool IGUIObject::MouseOverIcon()
 {
 	return false;
 }
 
 CPos IGUIObject::GetMousePos() const
 {
 	if (GetGUI())
 		return GetGUI()->m_MousePos;
 
 	return CPos();
 }
 
 void IGUIObject::UpdateMouseOver(IGUIObject* const& pMouseOver)
 {
 	if (pMouseOver == this)
 	{
 		if (!m_MouseHovering)
 			SendEvent(GUIM_MOUSE_ENTER, "mouseenter");
 
 		m_MouseHovering = true;
 
 		SendEvent(GUIM_MOUSE_OVER, "mousemove");
 	}
 	else
 	{
 		if (m_MouseHovering)
 		{
 			m_MouseHovering = false;
 			SendEvent(GUIM_MOUSE_LEAVE, "mouseleave");
 		}
 	}
 }
 
 bool IGUIObject::SettingExists(const CStr& Setting) const
 {
 	// Because GetOffsets will direct dynamically defined
 	//  classes with polymorphism to respective ms_SettingsInfo
 	//  we need to make no further updates on this function
 	//  in derived classes.
 	//return (GetSettingsInfo().count(Setting) >= 1);
 	return (m_Settings.count(Setting) >= 1);
 }
 
 PSRETURN IGUIObject::SetSetting(const CStr& Setting, const CStrW& Value, const bool& SkipMessage)
 {
 	if (!SettingExists(Setting))
 		return PSRETURN_GUI_InvalidSetting;
 
 	SGUISetting set = m_Settings[Setting];
 
 #define TYPE(type) \
 	else if (set.m_Type == GUIST_##type) \
 	{ \
 		type _Value; \
 		if (!GUI<type>::ParseString(Value, _Value)) \
 			return PSRETURN_GUI_UnableToParse; \
 		GUI<type>::SetSetting(this, Setting, _Value, SkipMessage); \
 	}
 
 	if (0)
 		;
 #include "GUItypes.h"
 #undef TYPE
 	else
 	{
 		// Why does it always fail?
 		//return PS_FAIL;
 		return LogInvalidSettings(Setting);
 	}
 	return PSRETURN_OK;
 }
 
 
 
 PSRETURN IGUIObject::GetSettingType(const CStr& Setting, EGUISettingType& Type) const
 {
 	if (!SettingExists(Setting))
 		return LogInvalidSettings(Setting);
 
 	if (m_Settings.find(Setting) == m_Settings.end())
 		return LogInvalidSettings(Setting);
 
 	Type = m_Settings.find(Setting)->second.m_Type;
 
 	return PSRETURN_OK;
 }
 
 
 void IGUIObject::ChooseMouseOverAndClosest(IGUIObject*& pObject)
 {
 	if (!MouseOver())
 		return;
 
 	// Check if we've got competition at all
 	if (pObject == NULL)
 	{
 		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)
 	{
 		if (m_pParent->m_pParent == NULL)
 			return NULL;
 	}
 
 	return m_pParent;
 }
 
 void IGUIObject::ResetStates()
 {
 	// Notify the gui that we aren't hovered anymore
 	UpdateMouseOver(nullptr);
 }
 
 void IGUIObject::UpdateCachedSize()
 {
 	bool absolute;
 	GUI<bool>::GetSetting(this, "absolute", absolute);
 
 	float aspectratio = 0.f;
 	GUI<float>::GetSetting(this, "aspectratio", aspectratio);
 
 	CClientArea ca;
 	GUI<CClientArea>::GetSetting(this, "size", ca);
 
 	// 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 (absolute == false && m_pParent && !IsRootObject())
 		m_CachedActualSize = ca.GetClientArea(m_pParent->m_CachedActualSize);
 	else
 		m_CachedActualSize = ca.GetClientArea(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 (aspectratio)
 	{
 		if (m_CachedActualSize.GetWidth() > m_CachedActualSize.GetHeight()*aspectratio)
 		{
 			float delta = m_CachedActualSize.GetWidth() - m_CachedActualSize.GetHeight()*aspectratio;
 			m_CachedActualSize.left += delta/2.f;
 			m_CachedActualSize.right -= delta/2.f;
 		}
 		else
 		{
 			float delta = m_CachedActualSize.GetHeight() - m_CachedActualSize.GetWidth()/aspectratio;
 			m_CachedActualSize.bottom -= delta/2.f;
 			m_CachedActualSize.top += delta/2.f;
 		}
 	}
 }
 
 void IGUIObject::LoadStyle(CGUI& GUIinstance, const CStr& StyleName)
 {
 	// Fetch style
 	if (GUIinstance.m_Styles.count(StyleName) == 1)
 	{
 		LoadStyle(GUIinstance.m_Styles[StyleName]);
 	}
 	else
 	{
 		debug_warn(L"IGUIObject::LoadStyle failed");
 	}
 }
 
 void IGUIObject::LoadStyle(const SGUIStyle& Style)
 {
 	// Iterate settings, it won't be able to set them all probably, but that doesn't matter
 	for (const std::pair<CStr, CStrW>& p : Style.m_SettingsDefaults)
 	{
 		// Try set setting in object
 		SetSetting(p.first, p.second);
 
 		// It doesn't matter if it fail, it's not suppose to be able to set every setting.
 		//  since it's generic.
 
 		// The beauty with styles is that it can contain more settings
 		//  than exists for the objects using it. So if the SetSetting
 		//  fails, don't care.
 	}
 }
 
 float IGUIObject::GetBufferedZ() const
 {
 	bool absolute;
 	GUI<bool>::GetSetting(this, "absolute", absolute);
 
 	float Z;
 	GUI<float>::GetSetting(this, "z", Z);
 
 	if (absolute)
 		return Z;
 	else
 	{
 		if (GetParent())
 			return GetParent()->GetBufferedZ() + Z;
 		else
 		{
 			// 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 Z;
 		}
 	}
 }
 
 void IGUIObject::RegisterScriptHandler(const CStr& Action, const CStr& Code, CGUI* pGUI)
 {
 	if(!GetGUI())
 		throw PSERROR_GUI_OperationNeedsGUIObject();
 
 	JSContext* cx = pGUI->GetScriptInterface()->GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedValue globalVal(cx, pGUI->GetGlobalObject());
 	JS::RootedObject globalObj(cx, &globalVal.toObject());
 
 	const int paramCount = 1;
 	const char* paramNames[paramCount] = { "mouse" };
 
 	// Location to report errors from
 	CStr CodeName = GetName()+" "+Action;
 
 	// Generate a unique name
 	static int x = 0;
 	char buf[64];
 	sprintf_s(buf, ARRAY_SIZE(buf), "__eventhandler%d (%s)", x++, Action.c_str());
 
 	JS::CompileOptions options(cx);
 	options.setFileAndLine(CodeName.c_str(), 0);
 	options.setCompileAndGo(true);
 
 	JS::RootedFunction func(cx);
 	JS::AutoObjectVector emptyScopeChain(cx);
 	if (!JS::CompileFunction(cx, emptyScopeChain, options, buf, paramCount, paramNames, Code.c_str(), Code.length(), &func))
 	{
 		LOGERROR("RegisterScriptHandler: Failed to compile the script for %s", Action.c_str());
 		return;
 	}
 
 	JS::RootedObject funcObj(cx, JS_GetFunctionObject(func));
 	SetScriptHandler(Action, funcObj);
 }
 
 void IGUIObject::SetScriptHandler(const CStr& Action, JS::HandleObject Function)
 {
 	ENSURE(m_pGUI && "A GUI must be associated with the GUIObject before adding ScriptHandlers!");
 
 	if (m_ScriptHandlers.empty())
 		JS_AddExtraGCRootsTracer(m_pGUI->GetScriptInterface()->GetJSRuntime(), Trace, this);
 
 	m_ScriptHandlers[Action] = JS::Heap<JSObject*>(Function);
 }
 
 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);
 }
 
 void IGUIObject::ScriptEvent(const CStr& Action)
 {
 	std::map<CStr, JS::Heap<JSObject*> >::iterator it = m_ScriptHandlers.find(Action);
 	if (it == m_ScriptHandlers.end())
 		return;
 
 	JSContext* cx = m_pGUI->GetScriptInterface()->GetContext();
 	JSAutoRequest rq(cx);
 
 	// Set up the 'mouse' parameter
 	JS::RootedValue mouse(cx);
 
 	m_pGUI->GetScriptInterface()->CreateObject(
 		&mouse,
 		"x", m_pGUI->m_MousePos.x,
 		"y", m_pGUI->m_MousePos.y,
 		"buttons", m_pGUI->m_MouseButtons);
 
 	JS::AutoValueVector paramData(cx);
 	paramData.append(mouse);
 	JS::RootedObject obj(cx, GetJSObject());
 	JS::RootedValue handlerVal(cx, JS::ObjectValue(*it->second));
 	JS::RootedValue result(cx);
 	bool ok = JS_CallFunctionValue(cx, obj, handlerVal, paramData, &result);
 	if (!ok)
 	{
 		// We have no way to propagate the script exception, so just ignore it
 		// and hope the caller checks JS_IsExceptionPending
 	}
 }
 
 void IGUIObject::ScriptEvent(const CStr& Action, JS::HandleValueArray paramData)
 {
 	std::map<CStr, JS::Heap<JSObject*> >::iterator it = m_ScriptHandlers.find(Action);
 	if (it == m_ScriptHandlers.end())
 		return;
 
 	JSContext* cx = m_pGUI->GetScriptInterface()->GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedObject obj(cx, GetJSObject());
 	JS::RootedValue handlerVal(cx, JS::ObjectValue(*it->second));
 	JS::RootedValue result(cx);
 
 	if (!JS_CallFunctionValue(cx, obj, handlerVal, paramData, &result))
 		JS_ReportError(cx, "Errors executing script action \"%s\"", Action.c_str());
 }
 
-JSObject* IGUIObject::GetJSObject()
+void IGUIObject::CreateJSObject()
 {
 	JSContext* cx = m_pGUI->GetScriptInterface()->GetContext();
 	JSAutoRequest rq(cx);
+
+	m_JSObject.init(cx, m_pGUI->GetScriptInterface()->CreateCustomObject("GUIObject"));
+	JS_SetPrivate(m_JSObject.get(), this);
+}
+
+JSObject* IGUIObject::GetJSObject()
+{
 	// Cache the object when somebody first asks for it, because otherwise
-	// we end up doing far too much object allocation. TODO: Would be nice to
-	// not have these objects hang around forever using up memory, though.
+	// we end up doing far too much object allocation.
 	if (!m_JSObject.initialized())
-	{
-		m_JSObject.init(cx, m_pGUI->GetScriptInterface()->CreateCustomObject("GUIObject"));
-		JS_SetPrivate(m_JSObject.get(), this);
-	}
+		CreateJSObject();
+
 	return m_JSObject.get();
 }
 
 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()
 {
 	GetGUI()->m_FocusedObject = this;
 }
 
 bool IGUIObject::IsFocused() const
 {
 	return GetGUI()->m_FocusedObject == this;
 }
 
 bool IGUIObject::IsRootObject() const
 {
 	return GetGUI() != 0 && m_pParent == GetGUI()->m_BaseObject;
 }
 
 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_CallObjectTracer(trc, &handler.second, "IGUIObject::m_ScriptHandlers");
 }
 
 PSRETURN IGUIObject::LogInvalidSettings(const CStr8& Setting) const
 {
 	LOGWARNING("IGUIObject: setting %s was not found on an object", Setting.c_str());
 	return PSRETURN_GUI_InvalidSetting;
 }
Index: ps/trunk/source/gui/IGUIObject.h
===================================================================
--- ps/trunk/source/gui/IGUIObject.h	(revision 22592)
+++ ps/trunk/source/gui/IGUIObject.h	(revision 22593)
@@ -1,543 +1,549 @@
 /* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /*
  * The base class of an object.
  * All objects are derived from this class.
  * It's an abstract data type, so it can't be used per se.
  * Also contains a Dummy object which is used for completely blank objects.
  */
 
 #ifndef INCLUDED_IGUIOBJECT
 #define INCLUDED_IGUIOBJECT
 
 #include "GUIbase.h"
 #include "GUItext.h"
 
 #include "gui/scripting/JSInterface_IGUIObject.h"
 #include "lib/input.h" // just for IN_PASS
 #include "ps/XML/Xeromyces.h"
 
 #include <functional>
 #include <string>
 #include <vector>
 
 struct SGUISetting;
 struct SGUIStyle;
 class CGUI;
 
 class JSObject;
 
 ERROR_TYPE(GUI, UnableToParse);
 
 /**
  * Setting Type
  * @see SGUISetting
  *
  * For use of later macros, all names should be GUIST_ followed
  * by the code name (case sensitive!).
  */
 #define TYPE(T) GUIST_##T,
 enum EGUISettingType
 {
 	#include "GUItypes.h"
 };
 #undef TYPE
 
 /**
  * A GUI Setting is anything that can be inputted from XML as
  * \<object\>-attributes (with exceptions). For instance:
  * \<object style="null"\>
  *
  * "style" will be a SGUISetting.
  */
 struct SGUISetting
 {
 	SGUISetting() : m_pSetting(NULL) {}
 
 	/**
 	 * Stores the instance of the setting type holding the setting data. Can be set from XML and JS.
 	 */
 	void				*m_pSetting;
 
 	EGUISettingType		m_Type;
 
 	template<typename T>
 	void Init(IGUIObject& pObject, const CStr& Name);
 
 	/**
 	 * Parses the given JS::Value using ScriptInterface::FromJSVal and assigns it to the setting data.
 	 */
 	std::function<bool(JSContext* cx, JS::HandleValue v)> m_FromJSVal;
 
 	/**
 	 * Converts the setting data to a JS::Value using ScriptInterface::ToJSVal.
 	 */
 	std::function<void(JSContext* cx, JS::MutableHandleValue v)> m_ToJSVal;
 };
 
 /**
  * GUI object such as a button or an input-box.
  * Abstract data type !
  */
 class IGUIObject
 {
 	friend class CGUI;
 	friend class IGUIScrollBar;
 	friend class GUITooltip;
 
 	// Allow getProperty to access things like GetParent()
 	friend bool JSI_IGUIObject::getProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::MutableHandleValue vp);
 	friend bool JSI_IGUIObject::setProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id, bool UNUSED(strict), JS::MutableHandleValue vp);
 	friend bool JSI_IGUIObject::getComputedSize(JSContext* cx, uint argc, JS::Value* vp);
 	friend bool JSI_IGUIObject::getTextSize(JSContext* cx, uint argc, JS::Value* vp);
 
 public:
 	IGUIObject(CGUI* pGUI);
 	virtual ~IGUIObject();
 
 	/**
 	 * Checks if mouse is hovering this object.
      * The mouse position is cached in CGUI.
 	 *
 	 * This function checks if the mouse is hovering the
 	 * rectangle that the base setting "size" makes.
 	 * Although it is virtual, so one could derive
 	 * an object from CButton, which changes only this
 	 * to checking the circle that "size" makes.
 	 *
 	 * @return true if mouse is hovering
 	 */
 	virtual bool MouseOver();
 
 	/**
 	 * Test if mouse position is over an icon
 	 */
 	virtual bool MouseOverIcon();
 
 	//--------------------------------------------------------
 	/** @name Leaf Functions */
 	//--------------------------------------------------------
 	//@{
 
 	/// Get object name, name is unique
 	const CStr& GetName() const { return m_Name; }
 
 	/// Get object name
 	void SetName(const CStr& Name) { m_Name = Name; }
 
 	// Get Presentable name.
 	//  Will change all internally set names to something like "<unnamed object>"
 	CStr GetPresentableName() const;
 
 	/**
 	 * Adds object and its children to the map, it's name being the
 	 * first part, and the second being itself.
 	 *
 	 * @param ObjectMap Adds this to the map_pObjects.
 	 *
 	 * @throws PSERROR_GUI_ObjectNeedsName Name is missing
 	 * @throws PSERROR_GUI_NameAmbiguity Name is already taken
 	 */
 	void AddToPointersMap(map_pObjects& ObjectMap);
 
 	/**
 	 * Notice nothing will be returned or thrown if the child hasn't
 	 * been inputted into the GUI yet. This is because that's were
 	 * all is checked. Now we're just linking two objects, but
 	 * it's when we're inputting them into the GUI we'll check
 	 * validity! Notice also when adding it to the GUI this function
 	 * will inevitably have been called by CGUI::AddObject which
 	 * will catch the throw and return the error code.
 	 * i.e. The user will never put in the situation wherein a throw
 	 * must be caught, the GUI's internal error handling will be
 	 * completely transparent to the interfacially sequential model.
 	 *
 	 * @param pChild Child to add
 	 *
 	 * @throws PSERROR_GUI from CGUI::UpdateObjects().
 	 */
 	void AddChild(IGUIObject* pChild);
 
 	//@}
 	//--------------------------------------------------------
 	/** @name Iterate
 	 * Used to iterate over all children of this object.
 	 */
 	//--------------------------------------------------------
 	//@{
 
 	vector_pObjects::iterator begin() { return m_Children.begin(); }
 	vector_pObjects::iterator end() { return m_Children.end(); }
 
 	//@}
 	//--------------------------------------------------------
 	/** @name Settings Management */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Checks if settings exists, only available for derived
 	 * classes that has this set up, that's why the base
 	 * class just returns false
 	 *
 	 * @param Setting setting name
 	 * @return True if settings exist.
 	 */
 	bool SettingExists(const CStr& Setting) const;
 
 	/**
 	 * All sizes are relative to resolution, and the calculation
 	 * is not wanted in real time, therefore it is cached, update
 	 * the cached size with this function.
 	 */
 	virtual void UpdateCachedSize();
 
 	/**
 	 * Reset internal state of this object.
 	 */
 	virtual void ResetStates();
 
 	/**
 	 * Set a setting by string, regardless of what type it is.
 	 *
 	 * example a CRect(10,10,20,20) would be "10 10 20 20"
 	 *
 	 * @param Setting Setting by name
 	 * @param Value Value to set to
 	 * @param SkipMessage Does not send a GUIM_SETTINGS_UPDATED if true
 	 *
 	 * @return PSRETURN (PSRETURN_OK if successful)
 	 */
 	PSRETURN SetSetting(const CStr& Setting, const CStrW& Value, const bool& SkipMessage = false);
 
 	/**
 	 * Retrieves the type of a named setting.
 	 *
 	 * @param Setting Setting by name
 	 * @param Type Stores an EGUISettingType
 	 * @return PSRETURN (PSRETURN_OK if successful)
 	 */
 	PSRETURN GetSettingType(const CStr& Setting, EGUISettingType& Type) const;
 
 	/**
 	 * Set the script handler for a particular object-specific action
 	 *
 	 * @param Action Name of action
 	 * @param Code Javascript code to execute when the action occurs
 	 * @param pGUI GUI instance to associate the script with
 	 */
 	void RegisterScriptHandler(const CStr& Action, const CStr& Code, CGUI* pGUI);
 
 	/**
+	 * Creates the JS Object representing this page upon first use.
+	 * Can be overridden by derived classes to extend it.
+	 */
+	virtual void CreateJSObject();
+
+	/**
 	 * Retrieves the JSObject representing this GUI object.
 	 */
 	JSObject* GetJSObject();
 
 	//@}
 protected:
 	//--------------------------------------------------------
 	/** @name Called by CGUI and friends
 	 *
 	 * Methods that the CGUI will call using
 	 * its friendship, these should not
 	 * be called by user.
 	 * These functions' security are a lot
 	 * what constitutes the GUI's
 	 */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Add a setting to m_Settings
 	 *
 	 * @param Type Setting type
 	 * @param Name Setting reference name
 	 */
 	void AddSetting(const EGUISettingType& Type, const CStr& Name);
 
 	/**
 	 * Calls Destroy on all children, and deallocates all memory.
 	 * MEGA TODO Should it destroy it's children?
 	 */
 	virtual void Destroy();
 
 public:
 	/**
      * This function is called with different messages
 	 * for instance when the mouse enters the object.
 	 *
 	 * @param Message GUI Message
 	 */
 	virtual void HandleMessage(SGUIMessage& UNUSED(Message)) {}
 
 protected:
 	/**
 	 * Draws the object.
 	 *
 	 * @throws	PSERROR if any. But this will mostlikely be
 	 *			very rare since if an object is drawn unsuccessfully
 	 *			it'll probably only output in the Error log, and not
 	 *			disrupt the whole GUI drawing.
 	 */
 	virtual void Draw() = 0;
 
 	/**
 	 * Some objects need to handle the SDL_Event_ manually.
 	 * For instance the input box.
 	 *
 	 * Only the object with focus will have this function called.
 	 *
 	 * Returns either IN_PASS or IN_HANDLED. If IN_HANDLED, then
 	 * the key won't be passed on and processed by other handlers.
 	 * This is used for keys that the GUI uses.
 	 */
 	virtual InReaction ManuallyHandleEvent(const SDL_Event_* UNUSED(ev)) { return IN_PASS; }
 
 	/**
 	 * Loads a style.
 	 *
 	 * @param GUIinstance Reference to the GUI
 	 * @param StyleName Style by name
 	 */
 	void LoadStyle(CGUI& GUIinstance, const CStr& StyleName);
 
 	/**
 	 * Loads a style.
 	 *
 	 * @param Style The style object.
 	 */
 	void LoadStyle(const SGUIStyle& Style);
 
 	/**
 	 * Returns not the Z value, but the actual buffered Z value, i.e. if it's
 	 * defined relative, then it will check its parent's Z value and add
 	 * the relativity.
 	 *
 	 * @return Actual Z value on the screen.
 	 */
 	virtual float GetBufferedZ() const;
 
 	/**
 	 * 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();
 
 protected:
 	/**
 	 * Check if object is focused.
 	 */
 	bool IsFocused() const;
 
 	/**
 	 * <b>NOTE!</b> This will not just return m_pParent, when that is
 	 * need use it! There is one exception to it, when the parent is
 	 * the top-node (the object that isn't a real object), this
 	 * will return NULL, so that the top-node's children are
 	 * seemingly parentless.
 	 *
 	 * @return Pointer to parent
 	 */
 	IGUIObject* GetParent() const;
 
 	/**
 	 * Get Mouse from CGUI.
 	 */
 	CPos GetMousePos() const;
 
 	/**
 	 * Handle additional children to the \<object\>-tag. In IGUIObject, this function does
 	 * nothing. In CList and CDropDown, it handles the \<item\>, used to build the data.
 	 *
 	 * Returning false means the object doesn't recognize the child. Should be reported.
 	 * Notice 'false' is default, because an object not using this function, should not
 	 * have any additional children (and this function should never be called).
 	 */
 	virtual bool HandleAdditionalChildren(const XMBElement& UNUSED(child), CXeromyces* UNUSED(pFile))
 	{
 		return false;
 	}
 
 	/**
 	 * Cached size, real size m_Size is actually dependent on resolution
 	 * and can have different *real* outcomes, this is the real outcome
 	 * cached to avoid slow calculations in real time.
 	 */
 	CRect m_CachedActualSize;
 
 	/**
 	 * Send event to this GUI object (HandleMessage and ScriptEvent)
 	 *
 	 * @param type Type of GUI message to be handled
 	 * @param EventName String representation of event name
 	 * @return IN_HANDLED if event was handled, or IN_PASS if skipped
 	 */
 	InReaction SendEvent(EGUIMessageType type, const CStr& EventName);
 
 	/**
 	 * Execute the script for a particular action.
 	 * Does nothing if no script has been registered for that action.
 	 * The mouse coordinates will be passed as the first argument.
 	 *
 	 * @param Action Name of action
 	 */
 	void ScriptEvent(const CStr& Action);
 
 	/**
 	 * Execute the script for a particular action.
 	 * Does nothing if no script has been registered for that action.
 	 *
 	 * @param Action Name of action
 	 * @param paramData JS::HandleValueArray arguments to pass to the event.
 	 */
 	void ScriptEvent(const CStr& Action, JS::HandleValueArray paramData);
 
 	void SetScriptHandler(const CStr& Action, JS::HandleObject Function);
 
 	/**
 	 * Inputes the object that is currently hovered, this function
 	 * updates this object accordingly (i.e. if it's the object
 	 * being inputted one thing happens, and not, another).
 	 *
 	 * @param pMouseOver	Object that is currently hovered,
 	 *						can OF COURSE be NULL too!
 	 */
 	void UpdateMouseOver(IGUIObject* const& pMouseOver);
 
 	//@}
 private:
 	//--------------------------------------------------------
 	/** @name Internal functions */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Inputs a reference pointer, checks if the new inputted object
 	 * if hovered, if so, then check if this's Z value is greater
 	 * than the inputted object... If so then the object is closer
 	 * and we'll replace the pointer with this.
 	 * Also Notice input can be NULL, which means the Z value demand
 	 *  is out. NOTICE you can't input NULL as const so you'll have
 	 * to set an object to NULL.
 	 *
 	 * @param pObject	Object pointer, can be either the old one, or
 	 *					the new one.
 	 */
 	void ChooseMouseOverAndClosest(IGUIObject*& pObject);
 
 	// Is the object a Root object, in philosophy, this means it
 	//  has got no parent, and technically, it's got the m_BaseObject
 	//  as parent.
 	bool IsRootObject() const;
 
 	/**
 	 * Logs an invalid setting search and returns the correct return result
 	 *
 	 * @return the error result
 	 */
 	PSRETURN LogInvalidSettings(const CStr8& Setting) const;
 
 	static void Trace(JSTracer* trc, void* data)
 	{
 		reinterpret_cast<IGUIObject*>(data)->TraceMember(trc);
 	}
 
 	void TraceMember(JSTracer* trc);
 
 	// Variables
 
 protected:
 	// Name of object
 	CStr									m_Name;
 
 	// Constructed on the heap, will be destroyed along with the the object
 	// TODO Gee: really the above?
 	vector_pObjects							m_Children;
 
 	// Pointer to parent
 	IGUIObject								*m_pParent;
 
 	//This represents the last click time for each mouse button
 	double m_LastClickTime[6];
 
 	/**
 	 * This is an array of true or false, each element is associated with
 	 * a string representing a setting. Number of elements is equal to
 	 * number of settings.
 	 *
 	 * A true means the setting has been manually set in the file when
 	 * read. This is important to know because I don't want to force
 	 * the user to include its \<styles\>-XML-files first, so somehow
 	 * the GUI needs to know which settings were set, and which is meant
 	 * to.
 	 */
 
 	// More variables
 
 	// Is mouse hovering the object? used with the function MouseOver()
 	bool									m_MouseHovering;
 
 	/**
 	 * Settings pool, all an object's settings are located here
 	 * If a derived object has got more settings that the base
 	 * settings, it's because they have a new version of the
 	 * function SetupSettings().
 	 *
 	 * @see SetupSettings()
 	 */
-	public:
+public:
 	std::map<CStr, SGUISetting>				m_Settings;
 
-private:
+protected:
 	// An object can't function stand alone
 	CGUI* const m_pGUI;
 
 	// Internal storage for registered script handlers.
 	std::map<CStr, JS::Heap<JSObject*> >	m_ScriptHandlers;
 
 	// Cached JSObject representing this GUI object
 	JS::PersistentRootedObject				m_JSObject;
 };
 
 
 /**
  * Dummy object used primarily for the root object
  * or objects of type 'empty'
  */
 class CGUIDummyObject : public IGUIObject
 {
 	GUI_OBJECT(CGUIDummyObject)
 
 public:
 	CGUIDummyObject(CGUI* pGUI) : IGUIObject(pGUI) {}
 
 	virtual void Draw() {}
 	// Empty can never be hovered. It is only a category.
 	virtual bool MouseOver() { return false; }
 };
 
 #endif // INCLUDED_IGUIOBJECT