Index: ps/trunk/binaries/data/mods/_test.gui/gui/gui.rng
===================================================================
--- ps/trunk/binaries/data/mods/_test.gui/gui/gui.rng	(nonexistent)
+++ ps/trunk/binaries/data/mods/_test.gui/gui/gui.rng	(revision 22909)
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<grammar xmlns:a="http://relaxng.org/ns/compatibility/annotations/1.0" xmlns="http://relaxng.org/ns/structure/1.0" datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes">
+  <start>
+    <a:documentation/>
+    <!--
+      NOTE: To modify this Relax NG grammar, edit the Relax NG Compact (.rnc) file
+        and use a converter tool like trang to generate the Relax NG XML (.rng) file
+    -->
+    <a:documentation/>
+    <choice>
+      <ref name="objects"/>
+    </choice>
+  </start>
+  <define name="objects">
+    <element name="objects">
+      <zeroOrMore>
+        <choice>
+          <ref name="script"/>
+        </choice>
+      </zeroOrMore>
+    </element>
+  </define>
+  <define name="script">
+    <element name="script">
+      <interleave>
+        <text/>
+        <optional>
+          <attribute name="file"/>
+        </optional>
+        <optional>
+          <attribute name="directory"/>
+        </optional>
+      </interleave>
+    </element>
+  </define>
+</grammar>

Property changes on: ps/trunk/binaries/data/mods/_test.gui/gui/gui.rng
___________________________________________________________________
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Index: ps/trunk/binaries/data/mods/_test.gui/gui/gui_page.rng
===================================================================
--- ps/trunk/binaries/data/mods/_test.gui/gui/gui_page.rng	(nonexistent)
+++ ps/trunk/binaries/data/mods/_test.gui/gui/gui_page.rng	(revision 22909)
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<element name="page" xmlns:a="http://relaxng.org/ns/compatibility/annotations/1.0" xmlns="http://relaxng.org/ns/structure/1.0">
+  <a:documentation/>
+  <!--
+    NOTE: To modify this Relax NG grammar, edit the Relax NG Compact (.rnc) file
+      and use a converter tool like trang to generate the Relax NG XML (.rng) file
+  -->
+  <a:documentation/>
+  <zeroOrMore>
+    <element name="include">
+      <text/>
+    </element>
+  </zeroOrMore>
+</element>

Property changes on: ps/trunk/binaries/data/mods/_test.gui/gui/gui_page.rng
___________________________________________________________________
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Index: ps/trunk/binaries/data/mods/_test.gui/gui/hotkey.js
===================================================================
--- ps/trunk/binaries/data/mods/_test.gui/gui/hotkey.js	(nonexistent)
+++ ps/trunk/binaries/data/mods/_test.gui/gui/hotkey.js	(revision 22909)
@@ -0,0 +1,14 @@
+var state_before;
+var state_after;
+
+function handleInputBeforeGui(ev) {
+	if ((ev.type == "hotkeydown" || ev.type == "hotkeyup") && ev.hotkey == "test")
+		state_before = Engine.HotkeyIsPressed("test");
+	return false;
+}
+
+function handleInputAfterGui(ev) {
+	if ((ev.type == "hotkeydown" || ev.type == "hotkeyup") && ev.hotkey == "test")
+		state_after = Engine.HotkeyIsPressed("test");
+	return false;
+}

Property changes on: ps/trunk/binaries/data/mods/_test.gui/gui/hotkey.js
___________________________________________________________________
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Index: ps/trunk/binaries/data/mods/_test.gui/gui/hotkey.xml
===================================================================
--- ps/trunk/binaries/data/mods/_test.gui/gui/hotkey.xml	(nonexistent)
+++ ps/trunk/binaries/data/mods/_test.gui/gui/hotkey.xml	(revision 22909)
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<objects>
+	<script file="gui/hotkey.js"/>
+</objects>

Property changes on: ps/trunk/binaries/data/mods/_test.gui/gui/hotkey.xml
___________________________________________________________________
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Index: ps/trunk/binaries/data/mods/_test.gui/gui/page_hotkey.xml
===================================================================
--- ps/trunk/binaries/data/mods/_test.gui/gui/page_hotkey.xml	(nonexistent)
+++ ps/trunk/binaries/data/mods/_test.gui/gui/page_hotkey.xml	(revision 22909)
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<page>
+	<include>hotkey.xml</include>
+</page>

Property changes on: ps/trunk/binaries/data/mods/_test.gui/gui/page_hotkey.xml
___________________________________________________________________
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Index: ps/trunk/source/gui/CGUI.cpp
===================================================================
--- ps/trunk/source/gui/CGUI.cpp	(revision 22908)
+++ ps/trunk/source/gui/CGUI.cpp	(revision 22909)
@@ -1,1395 +1,1390 @@
 /* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include <stdarg.h>
 #include <string>
 
 #include "GUI.h"
 
 // Types - when including them into the engine.
 #include "CButton.h"
 #include "CChart.h"
 #include "CCheckBox.h"
 #include "CDropDown.h"
 #include "CImage.h"
 #include "CInput.h"
 #include "CList.h"
 #include "COList.h"
 #include "CProgressBar.h"
 #include "CRadioButton.h"
 #include "CSlider.h"
 #include "CText.h"
 #include "CTooltip.h"
 #include "MiniMap.h"
 
 #include "graphics/FontMetrics.h"
 #include "graphics/ShaderManager.h"
 #include "i18n/L10n.h"
 #include "lib/bits.h"
 #include "lib/input.h"
 #include "lib/sysdep/sysdep.h"
 #include "lib/timer.h"
 #include "lib/utf8.h"
 #include "ps/CLogger.h"
 #include "ps/Filesystem.h"
 #include "ps/GameSetup/Config.h"
 #include "ps/Globals.h"
 #include "ps/Hotkey.h"
 #include "ps/Profile.h"
 #include "ps/Pyrogenesis.h"
 #include "ps/XML/Xeromyces.h"
 #include "renderer/Renderer.h"
 #include "scripting/ScriptFunctions.h"
 #include "scriptinterface/ScriptInterface.h"
 
 extern int g_yres;
 
 const double SELECT_DBLCLICK_RATE = 0.5;
 const u32 MAX_OBJECT_DEPTH = 100; // Max number of nesting for GUI includes. Used to detect recursive inclusion
 
 InReaction CGUI::HandleEvent(const SDL_Event_* ev)
 {
 	InReaction ret = IN_PASS;
 
 	if (ev->ev.type == SDL_HOTKEYDOWN || ev->ev.type == SDL_HOTKEYUP)
 	{
 		const char* hotkey = static_cast<const char*>(ev->ev.user.data1);
 
 		if (m_GlobalHotkeys.count(hotkey))
 		{
 			HotkeyInputHandler(ev);
 			ret = IN_HANDLED;
 
 			JSContext* cx = m_ScriptInterface->GetContext();
 			JSAutoRequest rq(cx);
 			JS::RootedObject globalObj(cx, &GetGlobalObject().toObject());
 			JS::RootedValue result(cx);
 			JS_CallFunctionValue(cx, globalObj, m_GlobalHotkeys[hotkey], JS::HandleValueArray::empty(), &result);
 		}
 
 		std::map<CStr, std::vector<IGUIObject*> >::iterator it = m_HotkeyObjects.find(hotkey);
 		if (it != m_HotkeyObjects.end())
 			for (IGUIObject* const& obj : it->second)
 			{
-				// Update hotkey status before sending the event,
-				// else the status will be outdated when processing the GUI event.
-				HotkeyInputHandler(ev);
-				ret = IN_HANDLED;
-
 				if (ev->ev.type == SDL_HOTKEYDOWN)
-					obj->SendEvent(GUIM_PRESSED, "press");
+					ret = obj->SendEvent(GUIM_PRESSED, "press");
 				else
-					obj->SendEvent(GUIM_RELEASED, "release");
+					ret = obj->SendEvent(GUIM_RELEASED, "release");
 			}
 	}
 
 	else if (ev->ev.type == SDL_MOUSEMOTION)
 	{
 		// Yes the mouse position is stored as float to avoid
 		//  constant conversions when operating in a
 		//  float-based environment.
 		m_MousePos = CPos((float)ev->ev.motion.x / g_GuiScale, (float)ev->ev.motion.y / g_GuiScale);
 
 		SGUIMessage msg(GUIM_MOUSE_MOTION);
 		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)
 	CPos oldMousePos = m_MousePos;
 	if (ev->ev.type == SDL_MOUSEBUTTONDOWN || ev->ev.type == SDL_MOUSEBUTTONUP)
 	{
 		m_MousePos = CPos((float)ev->ev.button.x / g_GuiScale, (float)ev->ev.button.y / g_GuiScale);
 	}
 
 	// Only one object can be hovered
 	IGUIObject* pNearest = NULL;
 
 	// TODO Gee: (2004-09-08) Big TODO, don't do the below if the SDL_Event is something like a keypress!
 	try
 	{
 		PROFILE("mouse events");
 		// TODO Gee: Optimizations needed!
 		//  these two recursive function are quite overhead heavy.
 
 		// pNearest will after this point at the hovered object, possibly NULL
 		pNearest = FindObjectUnderMouse();
 
 		// Now we'll call UpdateMouseOver on *all* objects,
 		//  we'll input the one hovered, and they will each
 		//  update their own data and send messages accordingly
 		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->SendEvent(GUIM_MOUSE_PRESS_LEFT, "mouseleftpress");
 				break;
 
 			case SDL_BUTTON_RIGHT:
 				if (pNearest)
 					ret = pNearest->SendEvent(GUIM_MOUSE_PRESS_RIGHT, "mouserightpress");
 				break;
 
 			default:
 				break;
 			}
 		}
 		else if (ev->ev.type == SDL_MOUSEWHEEL && pNearest)
 		{
 			if (ev->ev.wheel.y < 0)
 				ret = pNearest->SendEvent(GUIM_MOUSE_WHEEL_DOWN, "mousewheeldown");
 			else if (ev->ev.wheel.y > 0)
 				ret = pNearest->SendEvent(GUIM_MOUSE_WHEEL_UP, "mousewheelup");
 		}
 		else if (ev->ev.type == SDL_MOUSEBUTTONUP)
 		{
 			switch (ev->ev.button.button)
 			{
 			case SDL_BUTTON_LEFT:
 				if (pNearest)
 				{
 					double timeElapsed = timer_Time() - pNearest->m_LastClickTime[SDL_BUTTON_LEFT];
 					pNearest->m_LastClickTime[SDL_BUTTON_LEFT] = timer_Time();
 
 					if (timeElapsed < SELECT_DBLCLICK_RATE)
 						ret = pNearest->SendEvent(GUIM_MOUSE_DBLCLICK_LEFT, "mouseleftdoubleclick");
 					else
 						ret = pNearest->SendEvent(GUIM_MOUSE_RELEASE_LEFT, "mouseleftrelease");
 				}
 				break;
 			case SDL_BUTTON_RIGHT:
 				if (pNearest)
 				{
 					double timeElapsed = timer_Time() - pNearest->m_LastClickTime[SDL_BUTTON_RIGHT];
 					pNearest->m_LastClickTime[SDL_BUTTON_RIGHT] = timer_Time();
 
 					if (timeElapsed < SELECT_DBLCLICK_RATE)
 						ret = pNearest->SendEvent(GUIM_MOUSE_DBLCLICK_RIGHT, "mouserightdoubleclick");
 					else
 						ret = pNearest->SendEvent(GUIM_MOUSE_RELEASE_RIGHT, "mouserightrelease");
 				}
 				break;
 			}
 
 			// Reset all states on all visible objects
 			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));
 		}
 	}
 	catch (PSERROR_GUI& e)
 	{
 		UNUSED2(e);
 		debug_warn(L"CGUI::HandleEvent error");
 		// TODO Gee: Handle
 	}
 
 	// BUTTONUP's effect on m_MouseButtons is handled after
 	// everything else, so that e.g. 'press' handlers (activated
 	// on button up) see which mouse button had been pressed.
 	if (ev->ev.type == SDL_MOUSEBUTTONUP)
 	{
 		switch (ev->ev.button.button)
 		{
 		case SDL_BUTTON_LEFT:
 		case SDL_BUTTON_RIGHT:
 		case SDL_BUTTON_MIDDLE:
 			m_MouseButtons &= ~Bit<unsigned int>(ev->ev.button.button);
 			break;
 		default:
 			break;
 		}
 	}
 
 	// Restore m_MousePos (for delayed mouse button events)
 	if (ev->ev.type == SDL_MOUSEBUTTONDOWN || ev->ev.type == SDL_MOUSEBUTTONUP)
 		m_MousePos = oldMousePos;
 
 	// Handle keys for input boxes
 	if (GetFocusedObject())
 	{
 		if ((ev->ev.type == SDL_KEYDOWN &&
 		     ev->ev.key.keysym.sym != SDLK_ESCAPE &&
 		     !g_keys[SDLK_LCTRL] && !g_keys[SDLK_RCTRL] &&
 		     !g_keys[SDLK_LALT] && !g_keys[SDLK_RALT]) ||
 		    ev->ev.type == SDL_HOTKEYDOWN ||
 		    ev->ev.type == SDL_TEXTINPUT ||
 		    ev->ev.type == SDL_TEXTEDITING)
 		{
 			ret = GetFocusedObject()->ManuallyHandleEvent(ev);
 		}
 		// else will return IN_PASS because we never used the button.
 	}
 
 	return ret;
 }
 
 void CGUI::TickObjects()
 {
 	const CStr action = "tick";
 	m_BaseObject->RecurseObject(nullptr, &IGUIObject::ScriptEvent, action);
 
 	m_Tooltip.Update(FindObjectUnderMouse(), m_MousePos, *this);
 }
 
 void CGUI::SendEventToAll(const CStr& EventName)
 {
 	// janwas 2006-03-03: spoke with Ykkrosh about EventName case.
 	// when registering, case is converted to lower - this avoids surprise
 	// if someone were to get the case wrong and then not notice their
 	// handler is never called. however, until now, the other end
 	// (sending events here) wasn't converting to lower case,
 	// leading to a similar problem.
 	// now fixed; case is irrelevant since all are converted to lower.
 	const CStr EventNameLower = EventName.LowerCase();
 	m_BaseObject->RecurseObject(nullptr, &IGUIObject::ScriptEvent, EventNameLower);
 }
 
 void CGUI::SendEventToAll(const CStr& EventName, const JS::HandleValueArray& paramData)
 {
 	const CStr EventNameLower = EventName.LowerCase();
 	m_BaseObject->RecurseObject(nullptr, &IGUIObject::ScriptEvent, EventNameLower, paramData);
 }
 
 CGUI::CGUI(const shared_ptr<ScriptRuntime>& runtime)
 	: m_MouseButtons(0), m_FocusedObject(NULL), m_InternalNameNumber(0)
 {
 	m_ScriptInterface.reset(new ScriptInterface("Engine", "GUIPage", runtime));
 	m_ScriptInterface->SetCallbackData(this);
 
 	GuiScriptingInit(*m_ScriptInterface);
 	m_ScriptInterface->LoadGlobalScripts();
 
 	m_BaseObject = new CGUIDummyObject(*this);
 }
 
 CGUI::~CGUI()
 {
 	Destroy();
 
 	if (m_BaseObject)
 		delete m_BaseObject;
 }
 
 IGUIObject* CGUI::ConstructObject(const CStr& str)
 {
 	if (m_ObjectTypes.count(str) > 0)
 		return (*m_ObjectTypes[str])(*this);
 
 	// Error reporting will be handled with the nullptr return.
 	return nullptr;
 }
 
 void CGUI::Initialize()
 {
 	// Add base types!
 	//  You can also add types outside the GUI to extend the flexibility of the GUI.
 	//  Pyrogenesis though will have all the object types inserted from here.
 	AddObjectType("empty",			&CGUIDummyObject::ConstructObject);
 	AddObjectType("button",			&CButton::ConstructObject);
 	AddObjectType("image",			&CImage::ConstructObject);
 	AddObjectType("text",			&CText::ConstructObject);
 	AddObjectType("checkbox",		&CCheckBox::ConstructObject);
 	AddObjectType("radiobutton",	&CRadioButton::ConstructObject);
 	AddObjectType("progressbar",	&CProgressBar::ConstructObject);
 	AddObjectType("minimap",        &CMiniMap::ConstructObject);
 	AddObjectType("input",			&CInput::ConstructObject);
 	AddObjectType("list",			&CList::ConstructObject);
 	AddObjectType("olist",			&COList::ConstructObject);
 	AddObjectType("dropdown",		&CDropDown::ConstructObject);
 	AddObjectType("tooltip",		&CTooltip::ConstructObject);
 	AddObjectType("chart",			&CChart::ConstructObject);
 	AddObjectType("slider",			&CSlider::ConstructObject);
 }
 
 void CGUI::Draw()
 {
 	// Clear the depth buffer, so the GUI is
 	// drawn on top of everything else
 	glClear(GL_DEPTH_BUFFER_BIT);
 
 	try
 	{
 		m_BaseObject->RecurseObject(&IGUIObject::IsHidden, &IGUIObject::Draw);
 	}
 	catch (PSERROR_GUI& e)
 	{
 		LOGERROR("GUI draw error: %s", e.what());
 	}
 }
 
 void CGUI::DrawSprite(const CGUISpriteInstance& Sprite, int CellID, const float& Z, const CRect& Rect, const CRect& UNUSED(Clipping))
 {
 	// If the sprite doesn't exist (name == ""), don't bother drawing anything
 	if (!Sprite)
 		return;
 
 	// TODO: Clipping?
 
 	Sprite.Draw(*this, Rect, CellID, m_Sprites, Z);
 }
 
 void CGUI::Destroy()
 {
 	// We can use the map to delete all
 	//  now we don't want to cancel all if one Destroy fails
 	for (const std::pair<CStr, IGUIObject*>& p : m_pAllObjects)
 	{
 		try
 		{
 			p.second->Destroy();
 		}
 		catch (PSERROR_GUI& e)
 		{
 			UNUSED2(e);
 			debug_warn(L"CGUI::Destroy error");
 			// TODO Gee: Handle
 		}
 
 		delete p.second;
 	}
 	m_pAllObjects.clear();
 
 	for (const std::pair<CStr, const CGUISprite*>& p : m_Sprites)
 		delete p.second;
 	m_Sprites.clear();
 	m_Icons.clear();
 }
 
 void CGUI::UpdateResolution()
 {
 	// Update ALL cached
 	m_BaseObject->RecurseObject(nullptr, &IGUIObject::UpdateCachedSize);
 }
 
 void CGUI::AddObject(IGUIObject* pObject)
 {
 	try
 	{
 		m_BaseObject->AddChild(pObject);
 
 		// Cache tree
 		pObject->RecurseObject(nullptr, &IGUIObject::UpdateCachedSize);
 
 		SGUIMessage msg(GUIM_LOAD);
 		pObject->RecurseObject(nullptr, &IGUIObject::HandleMessage, msg);
 	}
 	catch (PSERROR_GUI&)
 	{
 		throw;
 	}
 }
 
 void CGUI::UpdateObjects()
 {
 	// We'll fill a temporary map until we know everything succeeded
 	map_pObjects AllObjects;
 
 	try
 	{
 		// Fill freshly
 		m_BaseObject->RecurseObject(nullptr, &IGUIObject::AddToPointersMap, AllObjects);
 	}
 	catch (PSERROR_GUI&)
 	{
 		throw;
 	}
 
 	// Else actually update the real one
 	m_pAllObjects.swap(AllObjects);
 }
 
 bool CGUI::ObjectExists(const CStr& Name) const
 {
 	return m_pAllObjects.count(Name) != 0;
 }
 
 IGUIObject* CGUI::FindObjectByName(const CStr& Name) const
 {
 	map_pObjects::const_iterator it = m_pAllObjects.find(Name);
 	if (it == m_pAllObjects.end())
 		return NULL;
 	else
 		return it->second;
 }
 
 IGUIObject* CGUI::FindObjectUnderMouse() const
 {
 	IGUIObject* pNearest = NULL;
 	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::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, JS::HandleValue function)
 {
 	JSContext* cx = m_ScriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 
 	if (hotkeyTag.empty())
 	{
 		JS_ReportError(cx, "Cannot assign a function to an empty hotkey identifier!");
 		return;
 	}
 
 	if (!function.isObject() || !JS_ObjectIsFunction(cx, &function.toObject()))
 	{
 		JS_ReportError(cx, "Cannot assign non-function value to global hotkey '%s'", hotkeyTag.c_str());
 		return;
 	}
 
 	UnsetGlobalHotkey(hotkeyTag);
 	m_GlobalHotkeys[hotkeyTag].init(cx, function);
 }
 
 void CGUI::UnsetGlobalHotkey(const CStr& hotkeyTag)
 {
 	m_GlobalHotkeys.erase(hotkeyTag);
 }
 
 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, boost::unordered_set<VfsPath>& Paths)
 {
 	Paths.insert(Filename);
 
 	CXeromyces XeroFile;
 	if (XeroFile.Load(g_VFS, Filename, "gui") != PSRETURN_OK)
 		return;
 
 	XMBElement node = XeroFile.GetRoot();
 
 	CStr root_name(XeroFile.GetElementString(node.GetNodeName()));
 	try
 	{
 		if (root_name == "objects")
 		{
 			Xeromyces_ReadRootObjects(node, &XeroFile, Paths);
 
 			// Re-cache all values so these gets cached too.
 			//UpdateResolution();
 		}
 		else if (root_name == "sprites")
 			Xeromyces_ReadRootSprites(node, &XeroFile);
 		else if (root_name == "styles")
 			Xeromyces_ReadRootStyles(node, &XeroFile);
 		else if (root_name == "setup")
 			Xeromyces_ReadRootSetup(node, &XeroFile);
 		else
 			debug_warn(L"CGUI::LoadXmlFile error");
 	}
 	catch (PSERROR_GUI& e)
 	{
 		LOGERROR("Errors loading GUI file %s (%u)", Filename.string8(), e.getCode());
 		return;
 	}
 }
 
 //===================================================================
 //	XML Reading Xeromyces Specific Sub-Routines
 //===================================================================
 
 void CGUI::Xeromyces_ReadRootObjects(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths)
 {
 	int el_script = pFile->GetElementID("script");
 
 	std::vector<std::pair<CStr, CStr> > subst;
 
 	// Iterate main children
 	//  they should all be <object> or <script> elements
 	for (XMBElement child : Element.GetChildNodes())
 	{
 		if (child.GetNodeName() == el_script)
 			// Execute the inline script
 			Xeromyces_ReadScript(child, pFile, Paths);
 		else
 			// Read in this whole object into the GUI
 			Xeromyces_ReadObject(child, pFile, m_BaseObject, subst, Paths, 0);
 	}
 }
 
 void CGUI::Xeromyces_ReadRootSprites(XMBElement Element, CXeromyces* pFile)
 {
 	for (XMBElement child : Element.GetChildNodes())
 		Xeromyces_ReadSprite(child, pFile);
 }
 
 void CGUI::Xeromyces_ReadRootStyles(XMBElement Element, CXeromyces* pFile)
 {
 	for (XMBElement child : Element.GetChildNodes())
 		Xeromyces_ReadStyle(child, pFile);
 }
 
 void CGUI::Xeromyces_ReadRootSetup(XMBElement Element, CXeromyces* pFile)
 {
 	for (XMBElement child : Element.GetChildNodes())
 	{
 		CStr name(pFile->GetElementString(child.GetNodeName()));
 
 		if (name == "scrollbar")
 			Xeromyces_ReadScrollBarStyle(child, pFile);
 		else if (name == "icon")
 			Xeromyces_ReadIcon(child, pFile);
 		else if (name == "tooltip")
 			Xeromyces_ReadTooltip(child, pFile);
 		else if (name == "color")
 			Xeromyces_ReadColor(child, pFile);
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 }
 
 void CGUI::Xeromyces_ReadObject(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths, u32 nesting_depth)
 {
 	ENSURE(pParent);
 
 	XMBAttributeList attributes = Element.GetAttributes();
 
 	CStr type(attributes.GetNamedItem(pFile->GetAttributeID("type")));
 	if (type.empty())
 		type = "empty";
 
 	// Construct object from specified type
 	//  henceforth, we need to do a rollback before aborting.
 	//  i.e. releasing this object
 	IGUIObject* object = ConstructObject(type);
 
 	if (!object)
 	{
 		LOGERROR("GUI: Unrecognized object type \"%s\"", type.c_str());
 		return;
 	}
 
 	// Cache some IDs for element attribute names, to avoid string comparisons
 	#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
 	#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
 	ELMT(object);
 	ELMT(action);
 	ELMT(repeat);
 	ELMT(translatableAttribute);
 	ELMT(translate);
 	ELMT(attribute);
 	ELMT(keep);
 	ELMT(include);
 	ATTR(style);
 	ATTR(type);
 	ATTR(name);
 	ATTR(z);
 	ATTR(on);
 	ATTR(file);
 	ATTR(directory);
 	ATTR(id);
 	ATTR(context);
 
 	//
 	//	Read Style and set defaults
 	//
 	//	If the setting "style" is set, try loading that setting.
 	//
 	//	Always load default (if it's available) first!
 	//
 	CStr argStyle(attributes.GetNamedItem(attr_style));
 
 	if (m_Styles.count("default") == 1)
 		object->LoadStyle("default");
 
 	if (!argStyle.empty())
 	{
 		if (m_Styles.count(argStyle) == 0)
 			LOGERROR("GUI: Trying to use style '%s' that doesn't exist.", argStyle.c_str());
 		else
 			object->LoadStyle(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 (CStr(attr.Value) == "null")
 			continue;
 
 		// Ignore "type" and "style", we've already checked it
 		if (attr.Name == attr_type || attr.Name == attr_style)
 			continue;
 
 		if (attr.Name == attr_name)
 		{
 			CStr name(attr.Value);
 
 			for (const std::pair<CStr, CStr>& sub : NameSubst)
 				name.Replace(sub.first, sub.second);
 
 			object->SetName(name);
 			NameSet = true;
 			continue;
 		}
 
 		if (attr.Name == attr_z)
 			ManuallySetZ = true;
 
 		const CStr settingName = pFile->GetAttributeString(attr.Name);
 		if (object->SettingExists(settingName))
 			object->SetSettingFromString(settingName, attr.Value.FromUTF8(), false);
 		else
 			LOGERROR("GUI: (object: %s) Can't set \"%s\" to \"%s\"", object->GetPresentableName(), settingName, attr.Value);
 	}
 
 	// Check if name isn't set, generate an internal name in that case.
 	if (!NameSet)
 	{
 		object->SetName("__internal(" + CStr::FromInt(m_InternalNameNumber) + ")");
 		++m_InternalNameNumber;
 	}
 
 	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(child, pFile, object, NameSubst, Paths, nesting_depth);
 		}
 		else if (element_name == elmt_action)
 		{
 			// Scripted <action> element
 
 			// Check for a 'file' parameter
 			CStrW filename(child.GetAttributes().GetNamedItem(attr_file).FromUTF8());
 
 			CStr code;
 
 			// If there is a file, open it and use it as the code
 			if (!filename.empty())
 			{
 				Paths.insert(filename);
 				CVFSFile scriptfile;
 				if (scriptfile.Load(g_VFS, filename) != PSRETURN_OK)
 				{
 					LOGERROR("Error opening GUI script action file '%s'", utf8_from_wstring(filename));
 					throw PSERROR_GUI_JSOpenFailed();
 				}
 
 				code = scriptfile.DecodeUTF8(); // assume it's UTF-8
 			}
 
 			XMBElementList grandchildren = child.GetChildNodes();
 			if (!grandchildren.empty()) // The <action> element contains <keep> and <translate> tags.
 				for (XMBElement grandchild : grandchildren)
 				{
 					if (grandchild.GetNodeName() == elmt_translate)
 						code += g_L10n.Translate(grandchild.GetText());
 					else if (grandchild.GetNodeName() == elmt_keep)
 						code += grandchild.GetText();
 				}
 			else // It’s pure JavaScript code.
 				// Read the inline code (concatenating to the file code, if both are specified)
 				code += CStr(child.GetText());
 
 			CStr action = CStr(child.GetAttributes().GetNamedItem(attr_on));
 
 			object->RegisterScriptHandler(action.LowerCase(), code, *this);
 		}
 		else if (element_name == elmt_repeat)
 		{
 			Xeromyces_ReadRepeat(child, pFile, object, NameSubst, Paths, nesting_depth);
 		}
 		else if (element_name == elmt_translatableAttribute)
 		{
 			// This is an element in the form “<translatableAttribute id="attributeName">attributeValue</translatableAttribute>”.
 			CStr attributeName(child.GetAttributes().GetNamedItem(attr_id)); // Read the attribute name.
 			if (attributeName.empty())
 			{
 				LOGERROR("GUI: ‘translatableAttribute’ XML element with empty ‘id’ XML attribute found. (object: %s)", object->GetPresentableName().c_str());
 				continue;
 			}
 
 			CStr value(child.GetText());
 			if (value.empty())
 				continue;
 
 			CStr context(child.GetAttributes().GetNamedItem(attr_context)); // Read the context if any.
 
 			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(node, &XeroIncluded, object, NameSubst, Paths, nesting_depth+1);
 			}
 			else if (!directory.empty())
 			{
 				if (nesting_depth+1 >= MAX_OBJECT_DEPTH)
 				{
 					LOGERROR("GUI: Too many nested GUI includes. Probably caused by a recursive include attribute. Abort rendering '%s'.", utf8_from_wstring(directory));
 					continue;
 				}
 
 				VfsPaths pathnames;
 				vfs::GetPathnames(g_VFS, directory, L"*.xml", pathnames);
 				for (const VfsPath& path : pathnames)
 				{
 					// as opposed to loading scripts, don't care if it's loaded before
 					// one might use the same parts of the GUI in different situations
 					Paths.insert(path);
 					CXeromyces XeroIncluded;
 					if (XeroIncluded.Load(g_VFS, path, "gui") != PSRETURN_OK)
 					{
 						LOGERROR("GUI: Error reading included XML: '%s'", path.string8());
 						continue;
 					}
 
 					XMBElement node = XeroIncluded.GetRoot();
 					if (node.GetNodeName() != XeroIncluded.GetElementID("object"))
 					{
 						LOGERROR("GUI: Error reading included XML: '%s', root element must have be of type 'object'.", path.string8());
 						continue;
 					}
 					Xeromyces_ReadObject(node, &XeroIncluded, object, NameSubst, Paths, nesting_depth+1);
 				}
 
 			}
 			else
 				LOGERROR("GUI: 'include' XML element must have valid 'file' or 'directory' attribute found. (object %s)", object->GetPresentableName().c_str());
 		}
 		else
 		{
 			// Try making the object read the tag.
 			if (!object->HandleAdditionalChildren(child, pFile))
 				LOGERROR("GUI: (object: %s) Reading unknown children for its type", object->GetPresentableName().c_str());
 		}
 	}
 
 	if (!ManuallySetZ)
 	{
 		// Set it automatically to 10 plus its parents
 		if (object->GetSetting<bool>("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);
 		else
 			// If the object is relative, then we'll just store Z as "10"
 			object->SetSetting<float>("z", 10.f, false);
 	}
 
 	try
 	{
 		if (pParent == m_BaseObject)
 			AddObject(object);
 		else
 			pParent->AddChild(object);
 	}
 	catch (PSERROR_GUI& e)
 	{
 		LOGERROR("GUI error: %s", e.what());
 	}
 }
 
 void CGUI::Xeromyces_ReadRepeat(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths, u32 nesting_depth)
 {
 	#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
 	#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
 	ELMT(object);
 	ATTR(count);
 	ATTR(var);
 
 	XMBAttributeList attributes = Element.GetAttributes();
 
 	int count = CStr(attributes.GetNamedItem(attr_count)).ToInt();
 	CStr var("["+attributes.GetNamedItem(attr_var)+"]");
 	if (var.size() < 3)
 		var = "[n]";
 
 	for (int n = 0; n < count; ++n)
 	{
 		NameSubst.emplace_back(var, "[" + CStr::FromInt(n) + "]");
 
 		XERO_ITER_EL(Element, child)
 		{
 			if (child.GetNodeName() == elmt_object)
 				Xeromyces_ReadObject(child, pFile, pParent, NameSubst, Paths, nesting_depth);
 		}
 		NameSubst.pop_back();
 	}
 }
 
 void CGUI::Xeromyces_ReadScript(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths)
 {
 	// Check for a 'file' parameter
 	CStrW file(Element.GetAttributes().GetNamedItem(pFile->GetAttributeID("file")).FromUTF8());
 
 	// If there is a file specified, open and execute it
 	if (!file.empty())
 	{
 		Paths.insert(file);
 		try
 		{
 			m_ScriptInterface->LoadGlobalScriptFile(file);
 		}
 		catch (PSERROR_Scripting& e)
 		{
 			LOGERROR("GUI: Error executing script %s: %s", utf8_from_wstring(file), e.what());
 		}
 	}
 
 	// If it has a directory attribute, read all JS files in that directory
 	CStrW directory(Element.GetAttributes().GetNamedItem(pFile->GetAttributeID("directory")).FromUTF8());
 	if (!directory.empty())
 	{
 		VfsPaths pathnames;
 		vfs::GetPathnames(g_VFS, directory, L"*.js", pathnames);
 		for (const VfsPath& path : pathnames)
 		{
 			// Only load new files (so when the insert succeeds)
 			if (Paths.insert(path).second)
 				try
 				{
 					m_ScriptInterface->LoadGlobalScriptFile(path);
 				}
 				catch (PSERROR_Scripting& e)
 				{
 					LOGERROR("GUI: Error executing script %s: %s", path.string8(), e.what());
 				}
 		}
 	}
 
 	// Execute inline scripts
 	try
 	{
 		CStr code(Element.GetText());
 		if (!code.empty())
 			m_ScriptInterface->LoadGlobalScript(L"Some XML file", code.FromUTF8());
 	}
 	catch (PSERROR_Scripting& e)
 	{
 		LOGERROR("GUI: Error executing inline script: %s", e.what());
 	}
 }
 
 void CGUI::Xeromyces_ReadSprite(XMBElement Element, CXeromyces* pFile)
 {
 	CGUISprite* Sprite = new CGUISprite;
 
 	// Get name, we know it exists because of DTD requirements
 	CStr name = Element.GetAttributes().GetNamedItem(pFile->GetAttributeID("name"));
 
 	if (m_Sprites.find(name) != m_Sprites.end())
 		LOGWARNING("GUI sprite name '%s' used more than once; first definition will be discarded", name.c_str());
 
 	// shared_ptr to link the effect to every image, faster than copy.
 	std::shared_ptr<SGUIImageEffects> effects;
 
 	for (XMBElement child : Element.GetChildNodes())
 	{
 		CStr ElementName(pFile->GetElementString(child.GetNodeName()));
 
 		if (ElementName == "image")
 			Xeromyces_ReadImage(child, pFile, *Sprite);
 		else if (ElementName == "effect")
 		{
 			if (effects)
 				LOGERROR("GUI <sprite> must not have more than one <effect>");
 			else
 			{
 				effects = std::make_shared<SGUIImageEffects>();
 				Xeromyces_ReadEffects(child, pFile, *effects);
 			}
 		}
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 
 	// Apply the effects to every image (unless the image overrides it with
 	// different effects)
 	if (effects)
 		for (SGUIImage* const& img : Sprite->m_Images)
 			if (!img->m_Effects)
 				img->m_Effects = effects;
 
 	m_Sprites.erase(name);
 	m_Sprites.emplace(name, Sprite);
 }
 
 void CGUI::Xeromyces_ReadImage(XMBElement Element, CXeromyces* pFile, CGUISprite& parent)
 {
 	SGUIImage* Image = new SGUIImage;
 
 	Image->m_TextureSize = CClientArea(CRect(0, 0, 0, 0), CRect(0, 0, 100, 100));
 	Image->m_Size = CClientArea(CRect(0, 0, 0, 0), CRect(0, 0, 100, 100));
 
 	// TODO Gee: Setup defaults here (or maybe they are in the SGUIImage ctor)
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 		CStrW attr_value(attr.Value.FromUTF8());
 
 		if (attr_name == "texture")
 		{
 			Image->m_TextureName = VfsPath("art/textures/ui") / attr_value;
 		}
 		else if (attr_name == "size")
 		{
 			CClientArea ca;
 			if (!ParseString<CClientArea>(this, attr_value, ca))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_Size = ca;
 		}
 		else if (attr_name == "texture_size")
 		{
 			CClientArea ca;
 			if (!ParseString<CClientArea>(this, attr_value, ca))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_TextureSize = ca;
 		}
 		else if (attr_name == "real_texture_placement")
 		{
 			CRect rect;
 			if (!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 == "cell_size")
 		{
 			CSize size;
 			if (!ParseString<CSize>(this, attr_value, size))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_CellSize = size;
 		}
 		else if (attr_name == "fixed_h_aspect_ratio")
 		{
 			float val;
 			if (!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())
 	{
 		CStr ElementName(pFile->GetElementString(child.GetNodeName()));
 		if (ElementName == "effect")
 		{
 			if (Image->m_Effects)
 				LOGERROR("GUI <image> must not have more than one <effect>");
 			else
 			{
 				Image->m_Effects = std::make_shared<SGUIImageEffects>();
 				Xeromyces_ReadEffects(child, pFile, *Image->m_Effects);
 			}
 		}
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 
 	parent.AddImage(Image);
 }
 
 void CGUI::Xeromyces_ReadEffects(XMBElement Element, CXeromyces* pFile, SGUIImageEffects& effects)
 {
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 
 		if (attr_name == "add_color")
 		{
 			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(XMBElement Element, CXeromyces* pFile)
 {
 	SGUIStyle style;
 	CStr name;
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 
 		// The "name" setting is actually the name of the style
 		//  and not a new default
 		if (attr_name == "name")
 			name = attr.Value;
 		else
 			style.m_SettingsDefaults.emplace(attr_name, attr.Value.FromUTF8());
 	}
 
 	m_Styles.erase(name);
 	m_Styles.emplace(name, std::move(style));
 }
 
 void CGUI::Xeromyces_ReadScrollBarStyle(XMBElement Element, CXeromyces* pFile)
 {
 	SGUIScrollBarStyle scrollbar;
 	CStr name;
 
 	// Setup some defaults.
 	scrollbar.m_MinimumBarSize = 0.f;
 	// Using 1.0e10 as a substitute for infinity
 	scrollbar.m_MaximumBarSize = 1.0e10;
 	scrollbar.m_UseEdgeButtons = false;
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name = pFile->GetAttributeString(attr.Name);
 		CStr attr_value(attr.Value);
 
 		if (attr_value == "null")
 			continue;
 
 		if (attr_name == "name")
 			name = attr_value;
 		else if (attr_name == "show_edge_buttons")
 		{
 			bool b;
 			if (!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(XMBElement Element, CXeromyces* pFile)
 {
 	SGUIIcon icon;
 	CStr name;
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 		CStr attr_value(attr.Value);
 
 		if (attr_value == "null")
 			continue;
 
 		if (attr_name == "name")
 			name = attr_value;
 		else if (attr_name == "sprite")
 			icon.m_SpriteName = attr_value;
 		else if (attr_name == "size")
 		{
 			CSize size;
 			if (!ParseString<CSize>(this, attr_value.FromUTF8(), size))
 				LOGERROR("Error parsing '%s' (\"%s\") inside <icon>.", attr_name, attr_value);
 			else
 				icon.m_Size = size;
 		}
 		else if (attr_name == "cell_id")
 		{
 			int cell_id;
 			if (!ParseString<int>(this, attr_value.FromUTF8(), cell_id))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\") inside <icon>.", attr_name, attr_value);
 			else
 				icon.m_CellID = cell_id;
 		}
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 
 	m_Icons.erase(name);
 	m_Icons.emplace(name, std::move(icon));
 }
 
 void CGUI::Xeromyces_ReadTooltip(XMBElement Element, CXeromyces* pFile)
 {
 	IGUIObject* object = new CTooltip(*this);
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 		CStr attr_value(attr.Value);
 
 		if (attr_name == "name")
 			object->SetName("__tooltip_" + attr_value);
 		else
 			object->SetSettingFromString(attr_name, attr_value.FromUTF8(), true);
 	}
 
 	AddObject(object);
 }
 
 void CGUI::Xeromyces_ReadColor(XMBElement Element, CXeromyces* pFile)
 {
 	XMBAttributeList attributes = Element.GetAttributes();
 	CStr name = attributes.GetNamedItem(pFile->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/GUIManager.cpp
===================================================================
--- ps/trunk/source/gui/GUIManager.cpp	(revision 22908)
+++ ps/trunk/source/gui/GUIManager.cpp	(revision 22909)
@@ -1,423 +1,426 @@
 /* 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 "GUIManager.h"
 
 #include "gui/CGUI.h"
 #include "lib/timer.h"
 #include "ps/Filesystem.h"
 #include "ps/CLogger.h"
 #include "ps/Profile.h"
 #include "ps/XML/Xeromyces.h"
 #include "ps/GameSetup/Config.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "scriptinterface/ScriptRuntime.h"
 
 CGUIManager* g_GUI = NULL;
 
 
 // General TODOs:
 //
 // A lot of the CGUI data could (and should) be shared between
 // multiple pages, instead of treating them as completely independent, to save
 // memory and loading time.
 
 
 // called from main loop when (input) events are received.
 // event is passed to other handlers if false is returned.
 // trampoline: we don't want to make the HandleEvent implementation static
 InReaction gui_handler(const SDL_Event_* ev)
 {
+	if (!g_GUI)
+		return IN_PASS;
+
 	PROFILE("GUI event handler");
 	return g_GUI->HandleEvent(ev);
 }
 
 static Status ReloadChangedFileCB(void* param, const VfsPath& path)
 {
 	return static_cast<CGUIManager*>(param)->ReloadChangedFile(path);
 }
 
 CGUIManager::CGUIManager()
 {
 	m_ScriptRuntime = g_ScriptRuntime;
 	m_ScriptInterface.reset(new ScriptInterface("Engine", "GUIManager", m_ScriptRuntime));
 	m_ScriptInterface->SetCallbackData(this);
 	m_ScriptInterface->LoadGlobalScripts();
 
 	if (!CXeromyces::AddValidator(g_VFS, "gui_page", "gui/gui_page.rng"))
 		LOGERROR("CGUIManager: failed to load GUI page grammar file 'gui/gui_page.rng'");
 	if (!CXeromyces::AddValidator(g_VFS, "gui", "gui/gui.rng"))
 		LOGERROR("CGUIManager: failed to load GUI XML grammar file 'gui/gui.rng'");
 
 	RegisterFileReloadFunc(ReloadChangedFileCB, this);
 }
 
 CGUIManager::~CGUIManager()
 {
 	UnregisterFileReloadFunc(ReloadChangedFileCB, this);
 }
 
 size_t CGUIManager::GetPageCount() const
 {
 	return m_PageStack.size();
 }
 
 void CGUIManager::SwitchPage(const CStrW& pageName, ScriptInterface* srcScriptInterface, JS::HandleValue initData)
 {
 	// The page stack is cleared (including the script context where initData came from),
 	// therefore we have to clone initData.
 
 	shared_ptr<ScriptInterface::StructuredClone> initDataClone;
 	if (!initData.isUndefined())
 		initDataClone = srcScriptInterface->WriteStructuredClone(initData);
 
 	m_PageStack.clear();
 
 	PushPage(pageName, initDataClone, JS::UndefinedHandleValue);
 }
 
 void CGUIManager::PushPage(const CStrW& pageName, shared_ptr<ScriptInterface::StructuredClone> initData, JS::HandleValue callbackFunction)
 {
 	// Store the callback handler in the current GUI page before opening the new one
 	if (!m_PageStack.empty() && !callbackFunction.isUndefined())
 		m_PageStack.back().SetCallbackFunction(*m_ScriptInterface, callbackFunction);
 
 	// Push the page prior to loading its contents, because that may push
 	// another GUI page on init which should be pushed on top of this new page.
 	m_PageStack.emplace_back(pageName, initData);
 	m_PageStack.back().LoadPage(m_ScriptRuntime);
 
 	ResetCursor();
 }
 
 void CGUIManager::PopPage(shared_ptr<ScriptInterface::StructuredClone> args)
 {
 	if (m_PageStack.size() < 2)
 	{
 		debug_warn(L"Tried to pop GUI page when there's < 2 in the stack");
 		return;
 	}
 
 	m_PageStack.pop_back();
 	m_PageStack.back().PerformCallbackFunction(args);
 }
 
 CGUIManager::SGUIPage::SGUIPage(const CStrW& pageName, const shared_ptr<ScriptInterface::StructuredClone> initData)
 	: name(pageName), initData(initData), inputs(), gui(), callbackFunction()
 {
 }
 
 void CGUIManager::SGUIPage::LoadPage(shared_ptr<ScriptRuntime> scriptRuntime)
 {
 	// If we're hotloading then try to grab some data from the previous page
 	shared_ptr<ScriptInterface::StructuredClone> hotloadData;
 	if (gui)
 	{
 		shared_ptr<ScriptInterface> scriptInterface = gui->GetScriptInterface();
 		JSContext* cx = scriptInterface->GetContext();
 		JSAutoRequest rq(cx);
 
 		JS::RootedValue global(cx, scriptInterface->GetGlobalObject());
 		JS::RootedValue hotloadDataVal(cx);
 		scriptInterface->CallFunction(global, "getHotloadData", &hotloadDataVal);
 		hotloadData = scriptInterface->WriteStructuredClone(hotloadDataVal);
 	}
 
 	inputs.clear();
 	gui.reset(new CGUI(scriptRuntime));
 
 	gui->Initialize();
 
 	VfsPath path = VfsPath("gui") / name;
 	inputs.insert(path);
 
 	CXeromyces xero;
 	if (xero.Load(g_VFS, path, "gui_page") != PSRETURN_OK)
 		// Fail silently (Xeromyces reported the error)
 		return;
 
 	int elmt_page = xero.GetElementID("page");
 	int elmt_include = xero.GetElementID("include");
 
 	XMBElement root = xero.GetRoot();
 
 	if (root.GetNodeName() != elmt_page)
 	{
 		LOGERROR("GUI page '%s' must have root element <page>", utf8_from_wstring(name));
 		return;
 	}
 
 	XERO_ITER_EL(root, node)
 	{
 		if (node.GetNodeName() != elmt_include)
 		{
 			LOGERROR("GUI page '%s' must only have <include> elements inside <page>", utf8_from_wstring(name));
 			continue;
 		}
 
 		std::string name = node.GetText();
 		CStrW nameW (node.GetText().FromUTF8());
 
 		PROFILE2("load gui xml");
 		PROFILE2_ATTR("name: %s", name.c_str());
 
 		TIMER(nameW.c_str());
 		if (name.back() == '/')
 		{
 			VfsPath directory = VfsPath("gui") / nameW;
 			VfsPaths pathnames;
 			vfs::GetPathnames(g_VFS, directory, L"*.xml", pathnames);
 			for (const VfsPath& path : pathnames)
 				gui->LoadXmlFile(path, inputs);
 		}
 		else
 		{
 			VfsPath path = VfsPath("gui") / nameW;
 			gui->LoadXmlFile(path, inputs);
 		}
 	}
 
 	gui->SendEventToAll("load");
 
 	shared_ptr<ScriptInterface> scriptInterface = gui->GetScriptInterface();
 	JSContext* cx = scriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedValue initDataVal(cx);
 	JS::RootedValue hotloadDataVal(cx);
 	JS::RootedValue global(cx, scriptInterface->GetGlobalObject());
 
 	if (initData)
 		scriptInterface->ReadStructuredClone(initData, &initDataVal);
 
 	if (hotloadData)
 		scriptInterface->ReadStructuredClone(hotloadData, &hotloadDataVal);
 
 	if (scriptInterface->HasProperty(global, "init") &&
 	    !scriptInterface->CallFunctionVoid(global, "init", initDataVal, hotloadDataVal))
 		LOGERROR("GUI page '%s': Failed to call init() function", utf8_from_wstring(name));
 }
 
 void CGUIManager::SGUIPage::SetCallbackFunction(ScriptInterface& scriptInterface, JS::HandleValue callbackFunc)
 {
 	if (!callbackFunc.isObject())
 	{
 		LOGERROR("Given callback handler is not an object!");
 		return;
 	}
 
 	// Does not require JSAutoRequest
 	if (!JS_ObjectIsFunction(scriptInterface.GetContext(), &callbackFunc.toObject()))
 	{
 		LOGERROR("Given callback handler is not a function!");
 		return;
 	}
 
 	callbackFunction = std::make_shared<JS::PersistentRootedValue>(scriptInterface.GetJSRuntime(), callbackFunc);
 }
 
 void CGUIManager::SGUIPage::PerformCallbackFunction(shared_ptr<ScriptInterface::StructuredClone> args)
 {
 	if (!callbackFunction)
 		return;
 
 	shared_ptr<ScriptInterface> scriptInterface = gui->GetScriptInterface();
 	JSContext* cx = scriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedObject globalObj(cx, &scriptInterface->GetGlobalObject().toObject());
 
 	JS::RootedValue funcVal(cx, *callbackFunction);
 
 	// Delete the callback function, so that it is not called again
 	callbackFunction.reset();
 
 	JS::RootedValue argVal(cx);
 	if (args)
 		scriptInterface->ReadStructuredClone(args, &argVal);
 
 	JS::AutoValueVector paramData(cx);
 	paramData.append(argVal);
 
 	JS::RootedValue result(cx);
 
 	JS_CallFunctionValue(cx, globalObj, funcVal, paramData, &result);
 }
 
 Status CGUIManager::ReloadChangedFile(const VfsPath& path)
 {
 	for (SGUIPage& p : m_PageStack)
 		if (p.inputs.count(path))
 		{
 			LOGMESSAGE("GUI file '%s' changed - reloading page '%s'", path.string8(), utf8_from_wstring(p.name));
 			p.LoadPage(m_ScriptRuntime);
 			// TODO: this can crash if LoadPage runs an init script which modifies the page stack and breaks our iterators
 		}
 
 	return INFO::OK;
 }
 
 Status CGUIManager::ReloadAllPages()
 {
 	// TODO: this can crash if LoadPage runs an init script which modifies the page stack and breaks our iterators
 	for (SGUIPage& p : m_PageStack)
 		p.LoadPage(m_ScriptRuntime);
 
 	return INFO::OK;
 }
 
 void CGUIManager::ResetCursor()
 {
 	g_CursorName = g_DefaultCursor;
 }
 
 std::string CGUIManager::GetSavedGameData()
 {
 	shared_ptr<ScriptInterface> scriptInterface = top()->GetScriptInterface();
 	JSContext* cx = scriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedValue data(cx);
 	JS::RootedValue global(cx, top()->GetGlobalObject());
 	scriptInterface->CallFunction(global, "getSavedGameData", &data);
 	return scriptInterface->StringifyJSON(&data, false);
 }
 
 void CGUIManager::RestoreSavedGameData(const std::string& jsonData)
 {
 	shared_ptr<ScriptInterface> scriptInterface = top()->GetScriptInterface();
 	JSContext* cx = scriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedValue global(cx, top()->GetGlobalObject());
 	JS::RootedValue dataVal(cx);
 	scriptInterface->ParseJSON(jsonData, &dataVal);
 	scriptInterface->CallFunctionVoid(global, "restoreSavedGameData", dataVal);
 }
 
 InReaction CGUIManager::HandleEvent(const SDL_Event_* ev)
 {
 	// We want scripts to have access to the raw input events, so they can do complex
 	// processing when necessary (e.g. for unit selection and camera movement).
 	// Sometimes they'll want to be layered behind the GUI widgets (e.g. to detect mousedowns on the
 	// visible game area), sometimes they'll want to intercepts events before the GUI (e.g.
 	// to capture all mouse events until a mouseup after dragging).
 	// So we call two separate handler functions:
 
 	bool handled = false;
 
 	{
 		PROFILE("handleInputBeforeGui");
 		JSContext* cx = top()->GetScriptInterface()->GetContext();
 		JSAutoRequest rq(cx);
 		JS::RootedValue global(cx, top()->GetGlobalObject());
 		if (top()->GetScriptInterface()->CallFunction(global, "handleInputBeforeGui", handled, *ev, top()->FindObjectUnderMouse()))
 			if (handled)
 				return IN_HANDLED;
 	}
 
 	{
 		PROFILE("handle event in native GUI");
 		InReaction r = top()->HandleEvent(ev);
 		if (r != IN_PASS)
 			return r;
 	}
 
 	{
 		// We can't take the following lines out of this scope because top() may be another gui page than it was when calling handleInputBeforeGui!
 		JSContext* cx = top()->GetScriptInterface()->GetContext();
 		JSAutoRequest rq(cx);
 		JS::RootedValue global(cx, top()->GetGlobalObject());
 
 		PROFILE("handleInputAfterGui");
 		if (top()->GetScriptInterface()->CallFunction(global, "handleInputAfterGui", handled, *ev))
 			if (handled)
 				return IN_HANDLED;
 	}
 
 	return IN_PASS;
 }
 
 void CGUIManager::SendEventToAll(const CStr& eventName) const
 {
 	top()->SendEventToAll(eventName);
 }
 
 void CGUIManager::SendEventToAll(const CStr& eventName, JS::HandleValueArray paramData) const
 {
 	top()->SendEventToAll(eventName, paramData);
 }
 
 void CGUIManager::TickObjects()
 {
 	PROFILE3("gui tick");
 
 	// We share the script runtime with everything else that runs in the same thread.
 	// This call makes sure we trigger GC regularly even if the simulation is not running.
 	m_ScriptInterface->GetRuntime()->MaybeIncrementalGC(1.0f);
 
 	// Save an immutable copy so iterators aren't invalidated by tick handlers
 	PageStackType pageStack = m_PageStack;
 
 	for (const SGUIPage& p : pageStack)
 		p.gui->TickObjects();
 }
 
 void CGUIManager::Draw() const
 {
 	PROFILE3_GPU("gui");
 
 	for (const SGUIPage& p : m_PageStack)
 		p.gui->Draw();
 }
 
 void CGUIManager::UpdateResolution()
 {
 	// Save an immutable copy so iterators aren't invalidated by event handlers
 	PageStackType pageStack = m_PageStack;
 
 	for (const SGUIPage& p : pageStack)
 	{
 		p.gui->UpdateResolution();
 		p.gui->SendEventToAll("WindowResized");
 	}
 }
 
 bool CGUIManager::TemplateExists(const std::string& templateName) const
 {
 	return m_TemplateLoader.TemplateExists(templateName);
 }
 
 const CParamNode& CGUIManager::GetTemplate(const std::string& templateName)
 {
 	const CParamNode& templateRoot = m_TemplateLoader.GetTemplateFileData(templateName).GetChild("Entity");
 	if (!templateRoot.IsOk())
 		LOGERROR("Invalid template found for '%s'", templateName.c_str());
 
 	return templateRoot;
 }
 
 // This returns a shared_ptr to make sure the CGUI doesn't get deallocated
 // while we're in the middle of calling a function on it (e.g. if a GUI script
 // calls SwitchPage)
 shared_ptr<CGUI> CGUIManager::top() const
 {
 	ENSURE(m_PageStack.size());
 	return m_PageStack.back().gui;
 }
Index: ps/trunk/source/gui/tests/test_GuiManager.h
===================================================================
--- ps/trunk/source/gui/tests/test_GuiManager.h	(nonexistent)
+++ ps/trunk/source/gui/tests/test_GuiManager.h	(revision 22909)
@@ -0,0 +1,110 @@
+/* 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 "lib/self_test.h"
+
+#include "gui/GUIManager.h"
+
+#include "gui/CGUI.h"
+#include "ps/ConfigDB.h"
+#include "ps/Filesystem.h"
+#include "ps/GameSetup/GameSetup.h"
+#include "ps/Hotkey.h"
+#include "ps/XML/Xeromyces.h"
+
+class TestGuiManager : public CxxTest::TestSuite
+{
+	CConfigDB* configDB;
+public:
+
+	void setUp()
+	{
+		g_VFS = CreateVfs();
+		TS_ASSERT_OK(g_VFS->Mount(L"", DataDir()/"mods"/"_test.gui", VFS_MOUNT_MUST_EXIST));
+		TS_ASSERT_OK(g_VFS->Mount(L"cache", DataDir()/"mods"/"_testcache/"));
+
+		configDB = new CConfigDB;
+
+		CXeromyces::Startup();
+
+		g_GUI = new CGUIManager();
+	}
+
+	void tearDown()
+	{
+		delete g_GUI;
+		CXeromyces::Terminate();
+		delete configDB;
+		g_VFS.reset();
+		DeleteDirectory(DataDir()/"_testcache");
+	}
+
+	void test_hotkeysState()
+	{
+
+		// Load up a fake test hotkey when pressing 'a'.
+		const char* test_hotkey_name = "hotkey.test";
+		g_ConfigDB.SetValueString(CFG_USER, test_hotkey_name, "A");
+		LoadHotkeys();
+
+		// Load up a test page.
+		JS::RootedValue val(g_GUI->GetScriptInterface()->GetContext());
+		g_GUI->GetScriptInterface()->Eval("({})", &val);
+		std::shared_ptr<ScriptInterface::StructuredClone> data = g_GUI->GetScriptInterface()->WriteStructuredClone(JS::NullHandleValue);
+		g_GUI->PushPage(L"page_hotkey.xml", data, JS::UndefinedHandleValue);
+
+		// Press 'a'.
+		SDL_Event_ hotkeyNotification;
+		hotkeyNotification.ev.type = SDL_KEYDOWN;
+		hotkeyNotification.ev.key.keysym.sym = SDLK_a;
+
+		// Init input and poll the event.
+		InitInput();
+		in_push_priority_event(&hotkeyNotification);
+		SDL_Event_ ev;
+		while (in_poll_event(&ev))
+			in_dispatch_event(&ev);
+
+		// Ensure that our hotkey state was synchronised with the event itself.
+		bool hotkey_pressed_value = false;
+		JS::RootedValue js_hotkey_pressed_value(g_GUI->GetActiveGUI()->GetScriptInterface()->GetContext());
+		g_GUI->GetActiveGUI()->GetScriptInterface()->Eval("state_before", &js_hotkey_pressed_value);
+		g_GUI->GetActiveGUI()->GetScriptInterface()->FromJSVal(g_GUI->GetActiveGUI()->GetScriptInterface()->GetContext(), js_hotkey_pressed_value, hotkey_pressed_value);
+		TS_ASSERT_EQUALS(hotkey_pressed_value, true);
+
+		hotkey_pressed_value = false;
+		g_GUI->GetActiveGUI()->GetScriptInterface()->Eval("state_after", &js_hotkey_pressed_value);
+		g_GUI->GetActiveGUI()->GetScriptInterface()->FromJSVal(g_GUI->GetActiveGUI()->GetScriptInterface()->GetContext(), js_hotkey_pressed_value, hotkey_pressed_value);
+		TS_ASSERT_EQUALS(hotkey_pressed_value, true);
+
+		hotkeyNotification.ev.type = SDL_KEYUP;
+		in_push_priority_event(&hotkeyNotification);
+		while (in_poll_event(&ev))
+			in_dispatch_event(&ev);
+
+		hotkey_pressed_value = true;
+		g_GUI->GetActiveGUI()->GetScriptInterface()->Eval("state_before", &js_hotkey_pressed_value);
+		g_GUI->GetActiveGUI()->GetScriptInterface()->FromJSVal(g_GUI->GetActiveGUI()->GetScriptInterface()->GetContext(), js_hotkey_pressed_value, hotkey_pressed_value);
+		TS_ASSERT_EQUALS(hotkey_pressed_value, false);
+
+		hotkey_pressed_value = true;
+		g_GUI->GetActiveGUI()->GetScriptInterface()->Eval("state_after", &js_hotkey_pressed_value);
+		g_GUI->GetActiveGUI()->GetScriptInterface()->FromJSVal(g_GUI->GetActiveGUI()->GetScriptInterface()->GetContext(), js_hotkey_pressed_value, hotkey_pressed_value);
+		TS_ASSERT_EQUALS(hotkey_pressed_value, false);
+
+	}
+};

Property changes on: ps/trunk/source/gui/tests/test_GuiManager.h
___________________________________________________________________
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Index: ps/trunk/source/lib/file/common/trace.cpp
===================================================================
--- ps/trunk/source/lib/file/common/trace.cpp	(revision 22908)
+++ ps/trunk/source/lib/file/common/trace.cpp	(revision 22909)
@@ -1,235 +1,239 @@
-/* Copyright (C) 2015 Wildfire Games.
+/* Copyright (C) 2019 Wildfire Games.
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
  * without limitation the rights to use, copy, modify, merge, publish,
  * distribute, sublicense, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
  *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
 /*
  * IO event recording
  */
 
 #include "precompiled.h"
 #include "lib/file/common/trace.h"
 
 #include <cstdio>
 #include <sstream>
 
 #include "lib/allocators/pool.h"
 #include "lib/timer.h"	// timer_Time
 #include "lib/sysdep/sysdep.h"	// sys_OpenFile
 
 
 /*virtual*/ ITrace::~ITrace()
 {
 
 }
 
 
 //-----------------------------------------------------------------------------
 
 TraceEntry::TraceEntry(EAction action, const Path& pathname, size_t size)
 : m_timestamp((float)timer_Time())
 , m_action(action)
 , m_pathname(pathname)
 , m_size(size)
 {
 }
 
 
 TraceEntry::TraceEntry(const std::wstring& text)
 {
 	// swscanf is far too awkward to get working cross-platform,
 	// so use iostreams here instead
 
 	wchar_t dummy;
 	wchar_t action;
 
 	std::wstringstream stream(text);
 	stream >> m_timestamp;
 
 	stream >> dummy;
 	ENSURE(dummy == ':');
 
 	stream >> action;
 	ENSURE(action == 'L' || action == 'S');
 	m_action = (EAction)action;
 
 	stream >> dummy;
 	ENSURE(dummy == '"');
 
 	Path::String pathname;
 	std::getline(stream, pathname, L'"');
 	m_pathname = Path(pathname);
 
 	stream >> m_size;
 
 	ENSURE(stream.get() == '\n');
 	// NOTE: Don't use good() here - it fails due to a bug in older libc++ versions
 	ENSURE(!stream.bad() && !stream.fail());
 	ENSURE(stream.get() == WEOF);
 }
 
 
 std::wstring TraceEntry::EncodeAsText() const
 {
+	// Ensure timestamp gets correctly encoded.
+	char* oldLocale = setlocale(LC_ALL, "C");
+
 	const wchar_t action = (wchar_t)m_action;
 	wchar_t buf[1000];
 	swprintf_s(buf, ARRAY_SIZE(buf), L"%#010f: %c \"%ls\" %lu\n", m_timestamp, action, m_pathname.string().c_str(), (unsigned long)m_size);
+	setlocale(LC_ALL, oldLocale);
 	return buf;
 }
 
 
 //-----------------------------------------------------------------------------
 
 class Trace_Dummy : public ITrace
 {
 public:
 	Trace_Dummy(size_t UNUSED(maxSize))
 	{
 
 	}
 
 	virtual void NotifyLoad(const Path& UNUSED(pathname), size_t UNUSED(size))
 	{
 	}
 
 	virtual void NotifyStore(const Path& UNUSED(pathname), size_t UNUSED(size))
 	{
 	}
 
 	virtual Status Load(const OsPath& UNUSED(pathname))
 	{
 		return INFO::OK;
 	}
 
 	virtual Status Store(const OsPath& UNUSED(pathname)) const
 	{
 		return INFO::OK;
 	}
 
 	virtual const TraceEntry* Entries() const
 	{
 		return 0;
 	}
 
 	virtual size_t NumEntries() const
 	{
 		return 0;
 	}
 };
 
 
 //-----------------------------------------------------------------------------
 
 class Trace : public ITrace
 {
 public:
 	Trace(size_t maxSize)
 	{
 		(void)pool_create(&m_pool, maxSize, sizeof(TraceEntry));
 	}
 
 	virtual ~Trace()
 	{
 		for(size_t i = 0; i < NumEntries(); i++)
 		{
 			TraceEntry* entry = (TraceEntry*)(uintptr_t(m_pool.da.base) + i*m_pool.el_size);
 			entry->~TraceEntry();
 		}
 
 		(void)pool_destroy(&m_pool);
 	}
 
 	virtual void NotifyLoad(const Path& pathname, size_t size)
 	{
 		new(Allocate()) TraceEntry(TraceEntry::Load, pathname, size);
 	}
 
 	virtual void NotifyStore(const Path& pathname, size_t size)
 	{
 		new(Allocate()) TraceEntry(TraceEntry::Store, pathname, size);
 	}
 
 	virtual Status Load(const OsPath& pathname)
 	{
 		pool_free_all(&m_pool);
 
 		errno = 0;
 		FILE* file = sys_OpenFile(pathname, "rt");
 		if(!file)
 			WARN_RETURN(StatusFromErrno());
 
 		for(;;)
 		{
 			wchar_t text[500];
 			if(!fgetws(text, ARRAY_SIZE(text)-1, file))
 				break;
 			new(Allocate()) TraceEntry(text);
 		}
 		fclose(file);
 
 		return INFO::OK;
 	}
 
 	virtual Status Store(const OsPath& pathname) const
 	{
 		errno = 0;
 		FILE* file = sys_OpenFile(pathname, "at");
 		if(!file)
 			WARN_RETURN(StatusFromErrno());
 		for(size_t i = 0; i < NumEntries(); i++)
 		{
 			std::wstring text = Entries()[i].EncodeAsText();
 			fputws(text.c_str(), file);
 		}
 		(void)fclose(file);
 		return INFO::OK;
 	}
 
 	virtual const TraceEntry* Entries() const
 	{
 		return (const TraceEntry*)m_pool.da.base;
 	}
 
 	virtual size_t NumEntries() const
 	{
 		return m_pool.da.pos / m_pool.el_size;
 	}
 
 private:
 	void* Allocate()
 	{
 		void* p = pool_alloc(&m_pool, 0);
 		ENSURE(p);
 		return p;
 	}
 
 	Pool m_pool;
 };
 
 
 PITrace CreateDummyTrace(size_t maxSize)
 {
 	return PITrace(new Trace_Dummy(maxSize));
 }
 
 PITrace CreateTrace(size_t maxSize)
 {
 	return PITrace(new Trace(maxSize));
 }
Index: ps/trunk/source/ps/CConsole.cpp
===================================================================
--- ps/trunk/source/ps/CConsole.cpp	(revision 22908)
+++ ps/trunk/source/ps/CConsole.cpp	(revision 22909)
@@ -1,696 +1,699 @@
 /* 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/>.
  */
 
 /*
  * Implements the in-game console with scripting support.
  */
 
 #include "precompiled.h"
 #include <wctype.h>
 
 #include "CConsole.h"
 
 #include "graphics/FontMetrics.h"
 #include "graphics/ShaderManager.h"
 #include "graphics/TextRenderer.h"
 #include "gui/CGUI.h"
 #include "gui/GUIManager.h"
 #include "gui/GUIMatrix.h"
 #include "lib/ogl.h"
 #include "lib/sysdep/clipboard.h"
 #include "lib/timer.h"
 #include "lib/utf8.h"
 #include "maths/MathUtil.h"
 #include "network/NetClient.h"
 #include "network/NetServer.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 "renderer/Renderer.h"
 #include "scriptinterface/ScriptInterface.h"
 
 CConsole* g_Console = 0;
 
 CConsole::CConsole()
 {
 	m_bToggle = false;
 	m_bVisible = false;
 
 	m_fVisibleFrac = 0.0f;
 
 	m_szBuffer = new wchar_t[CONSOLE_BUFFER_SIZE];
 	FlushBuffer();
 
 	m_iMsgHistPos = 1;
 	m_charsPerPage = 0;
 
 	m_prevTime = 0.0;
 	m_bCursorVisState = true;
 	m_cursorBlinkRate = 0.5;
 
 	InsertMessage("[ 0 A.D. Console v0.14 ]");
 	InsertMessage("");
 }
 
 CConsole::~CConsole()
 {
 	delete[] m_szBuffer;
 }
 
 
 void CConsole::SetSize(float X, float Y, float W, float H)
 {
 	m_fX = X;
 	m_fY = Y;
 	m_fWidth = W;
 	m_fHeight = H;
 }
 
 void CConsole::UpdateScreenSize(int w, int h)
 {
 	float height = h * 0.6f;
 	SetSize(0, 0, w / g_GuiScale, height / g_GuiScale);
 }
 
 
 void CConsole::ToggleVisible()
 {
 	m_bToggle = true;
 	m_bVisible = !m_bVisible;
 
 	// TODO: this should be based on input focus, not visibility
 	if (m_bVisible)
 		SDL_StartTextInput();
 	else
 		SDL_StopTextInput();
 }
 
 void CConsole::SetVisible(bool visible)
 {
 	if (visible != m_bVisible)
 		m_bToggle = true;
 	m_bVisible = visible;
 	if (visible)
 	{
 		m_prevTime = 0.0;
 		m_bCursorVisState = false;
 	}
 }
 
 void CConsole::SetCursorBlinkRate(double rate)
 {
 	m_cursorBlinkRate = rate;
 }
 
 void CConsole::FlushBuffer()
 {
 	// Clear the buffer and set the cursor and length to 0
 	memset(m_szBuffer, '\0', sizeof(wchar_t) * CONSOLE_BUFFER_SIZE);
 	m_iBufferPos = m_iBufferLength = 0;
 }
 
 
 void CConsole::Update(const float deltaRealTime)
 {
 	if(m_bToggle)
 	{
 		const float AnimateTime = .30f;
 		const float Delta = deltaRealTime / AnimateTime;
 		if(m_bVisible)
 		{
 			m_fVisibleFrac += Delta;
 			if(m_fVisibleFrac > 1.0f)
 			{
 				m_fVisibleFrac = 1.0f;
 				m_bToggle = false;
 			}
 		}
 		else
 		{
 			m_fVisibleFrac -= Delta;
 			if(m_fVisibleFrac < 0.0f)
 			{
 				m_fVisibleFrac = 0.0f;
 				m_bToggle = false;
 			}
 		}
 	}
 }
 
 //Render Manager.
 void CConsole::Render()
 {
 	if (! (m_bVisible || m_bToggle) ) return;
 
 	PROFILE3_GPU("console");
 
 	glEnable(GL_BLEND);
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
 	CShaderTechniquePtr solidTech = g_Renderer.GetShaderManager().LoadEffect(str_gui_solid);
 	solidTech->BeginPass();
 	CShaderProgramPtr solidShader = solidTech->GetShader();
 
 	CMatrix3D transform = GetDefaultGuiMatrix();
 
 	// animation: slide in from top of screen
 	const float DeltaY = (1.0f - m_fVisibleFrac) * m_fHeight;
 	transform.PostTranslate(m_fX, m_fY - DeltaY, 0.0f); // move to window position
 	solidShader->Uniform(str_transform, transform);
 
 	DrawWindow(solidShader);
 
 	solidTech->EndPass();
 
 	CShaderTechniquePtr textTech = g_Renderer.GetShaderManager().LoadEffect(str_gui_text);
 	textTech->BeginPass();
 	CTextRenderer textRenderer(textTech->GetShader());
 	textRenderer.Font(CStrIntern(CONSOLE_FONT));
 	textRenderer.SetTransform(transform);
 
 	DrawHistory(textRenderer);
 	DrawBuffer(textRenderer);
 
 	textRenderer.Render();
 
 	textTech->EndPass();
 
 	glDisable(GL_BLEND);
 }
 
 
 void CConsole::DrawWindow(CShaderProgramPtr& shader)
 {
 	float boxVerts[] = {
 		m_fWidth, 0.0f,
 		1.0f, 0.0f,
 		1.0f, m_fHeight-1.0f,
 		m_fWidth, m_fHeight-1.0f
 	};
 
 	shader->VertexPointer(2, GL_FLOAT, 0, boxVerts);
 
 	// Draw Background
 	// Set the color to a translucent blue
 	shader->Uniform(str_color, 0.0f, 0.0f, 0.5f, 0.6f);
 	shader->AssertPointersBound();
 	glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
 	// Draw Border
 	// Set the color to a translucent yellow
 	shader->Uniform(str_color, 0.5f, 0.5f, 0.0f, 0.6f);
 	shader->AssertPointersBound();
 	glDrawArrays(GL_LINE_LOOP, 0, 4);
 
 	if (m_fHeight > m_iFontHeight + 4)
 	{
 		float lineVerts[] = {
 			0.0f, m_fHeight - (float)m_iFontHeight - 4.0f,
 			m_fWidth, m_fHeight - (float)m_iFontHeight - 4.0f
 		};
 		shader->VertexPointer(2, GL_FLOAT, 0, lineVerts);
 		shader->AssertPointersBound();
 		glDrawArrays(GL_LINES, 0, 2);
 	}
 }
 
 
 void CConsole::DrawHistory(CTextRenderer& textRenderer)
 {
 	int i = 1;
 
 	std::deque<std::wstring>::iterator Iter; //History iterator
 
 	std::lock_guard<std::mutex> lock(m_Mutex); // needed for safe access to m_deqMsgHistory
 
 	textRenderer.Color(1.0f, 1.0f, 1.0f);
 
 	for (Iter = m_deqMsgHistory.begin();
 			Iter != m_deqMsgHistory.end()
 				&& (((i - m_iMsgHistPos + 1) * m_iFontHeight) < m_fHeight);
 			++Iter)
 	{
 		if (i >= m_iMsgHistPos)
 			textRenderer.Put(9.0f, m_fHeight - (float)m_iFontOffset - (float)m_iFontHeight * (i - m_iMsgHistPos + 1), Iter->c_str());
 
 		i++;
 	}
 }
 
 // Renders the buffer to the screen.
 void CConsole::DrawBuffer(CTextRenderer& textRenderer)
 {
 	if (m_fHeight < m_iFontHeight)
 		return;
 
 	CMatrix3D savedTransform = textRenderer.GetTransform();
 
 	textRenderer.Translate(2.0f, m_fHeight - (float)m_iFontOffset + 1.0f, 0.0f);
 
 	textRenderer.Color(1.0f, 1.0f, 0.0f);
 	textRenderer.PutAdvance(L"]");
 
 	textRenderer.Color(1.0f, 1.0f, 1.0f);
 
 	if (m_iBufferPos == 0)
 		DrawCursor(textRenderer);
 
 	for (int i = 0; i < m_iBufferLength; i++)
 	{
 		textRenderer.PrintfAdvance(L"%lc", m_szBuffer[i]);
 		if (m_iBufferPos-1 == i)
 			DrawCursor(textRenderer);
 	}
 
 	textRenderer.SetTransform(savedTransform);
 }
 
 void CConsole::DrawCursor(CTextRenderer& textRenderer)
 {
 	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_bCursorVisState = !m_bCursorVisState;
 			m_prevTime = currTime;
 		}
 	}
 	else
 	{
 		// Should always be visible
 		m_bCursorVisState = true;
 	}
 
 	if(m_bCursorVisState)
 	{
 		// Slightly translucent yellow
 		textRenderer.Color(1.0f, 1.0f, 0.0f, 0.8f);
 
 		// Cursor character is chosen to be an underscore
 		textRenderer.Put(0.0f, 0.0f, L"_");
 
 		// Revert to the standard text color
 		textRenderer.Color(1.0f, 1.0f, 1.0f);
 	}
 }
 
 
 //Inserts a character into the buffer.
 void CConsole::InsertChar(const int szChar, const wchar_t cooked)
 {
 	static int iHistoryPos = -1;
 
 	if (!m_bVisible) return;
 
 	switch (szChar)
 	{
 	case SDLK_RETURN:
 		iHistoryPos = -1;
 		m_iMsgHistPos = 1;
 		ProcessBuffer(m_szBuffer);
 		FlushBuffer();
 		return;
 
 	case SDLK_TAB:
 		// Auto Complete
 		return;
 
 	case SDLK_BACKSPACE:
 		if (IsEmpty() || IsBOB()) return;
 
 		if (m_iBufferPos == m_iBufferLength)
 			m_szBuffer[m_iBufferPos - 1] = '\0';
 		else
 		{
 			for (int j = m_iBufferPos-1; j < m_iBufferLength-1; j++)
 				m_szBuffer[j] = m_szBuffer[j+1]; // move chars to left
 			m_szBuffer[m_iBufferLength-1] = '\0';
 		}
 
 		m_iBufferPos--;
 		m_iBufferLength--;
 		return;
 
 	case SDLK_DELETE:
 		if (IsEmpty() || IsEOB()) return;
 
 		if (m_iBufferPos == m_iBufferLength-1)
 		{
 			m_szBuffer[m_iBufferPos] = '\0';
 			m_iBufferLength--;
 		}
 		else
 		{
 			if (g_keys[SDLK_RCTRL] || g_keys[SDLK_LCTRL])
 			{
 				// Make Ctrl-Delete delete up to end of line
 				m_szBuffer[m_iBufferPos] = '\0';
 				m_iBufferLength = m_iBufferPos;
 			}
 			else
 			{
 				// Delete just one char and move the others left
 				for(int j=m_iBufferPos; j<m_iBufferLength-1; j++)
 					m_szBuffer[j] = m_szBuffer[j+1];
 				m_szBuffer[m_iBufferLength-1] = '\0';
 				m_iBufferLength--;
 			}
 		}
 
 		return;
 
 	case SDLK_HOME:
 		if (g_keys[SDLK_RCTRL] || g_keys[SDLK_LCTRL])
 		{
 			std::lock_guard<std::mutex> lock(m_Mutex); // needed for safe access to m_deqMsgHistory
 
 			int linesShown = (int)m_fHeight/m_iFontHeight - 4;
 			m_iMsgHistPos = clamp((int)m_deqMsgHistory.size() - linesShown, 1, (int)m_deqMsgHistory.size());
 		}
 		else
 		{
 			m_iBufferPos = 0;
 		}
 		return;
 
 	case SDLK_END:
 		if (g_keys[SDLK_RCTRL] || g_keys[SDLK_LCTRL])
 		{
 			m_iMsgHistPos = 1;
 		}
 		else
 		{
 			m_iBufferPos = m_iBufferLength;
 		}
 		return;
 
 	case SDLK_LEFT:
 		if (m_iBufferPos) m_iBufferPos--;
 		return;
 
 	case SDLK_RIGHT:
 		if (m_iBufferPos != m_iBufferLength) m_iBufferPos++;
 		return;
 
 	// BEGIN: Buffer History Lookup
 	case SDLK_UP:
 		if (m_deqBufHistory.size() && iHistoryPos != (int)m_deqBufHistory.size() - 1)
 		{
 			iHistoryPos++;
 			SetBuffer(m_deqBufHistory.at(iHistoryPos).c_str());
 			m_iBufferPos = m_iBufferLength;
 		}
 		return;
 
 	case SDLK_DOWN:
 		if (m_deqBufHistory.size())
 		{
 			if (iHistoryPos > 0)
 			{
 				iHistoryPos--;
 				SetBuffer(m_deqBufHistory.at(iHistoryPos).c_str());
 				m_iBufferPos = m_iBufferLength;
 			}
 			else if (iHistoryPos == 0)
 			{
 				iHistoryPos--;
 				FlushBuffer();
 			}
 		}
 		return;
 	// END: Buffer History Lookup
 
 	// BEGIN: Message History Lookup
 	case SDLK_PAGEUP:
 	{
 		std::lock_guard<std::mutex> lock(m_Mutex); // needed for safe access to m_deqMsgHistory
 
 		if (m_iMsgHistPos != (int)m_deqMsgHistory.size()) m_iMsgHistPos++;
 		return;
 	}
 
 	case SDLK_PAGEDOWN:
 		if (m_iMsgHistPos != 1) m_iMsgHistPos--;
 		return;
 	// END: Message History Lookup
 
 	default: //Insert a character
 		if (IsFull()) return;
 		if (cooked == 0) return;
 
 		if (IsEOB()) //are we at the end of the buffer?
 			m_szBuffer[m_iBufferPos] = cooked; //cat char onto end
 		else
 		{ //we need to insert
 			int i;
 			for(i=m_iBufferLength; i>m_iBufferPos; i--)
 				m_szBuffer[i] = m_szBuffer[i-1]; // move chars to right
 			m_szBuffer[i] = cooked;
 		}
 
 		m_iBufferPos++;
 		m_iBufferLength++;
 
 		return;
 	}
 }
 
 
 void CConsole::InsertMessage(const std::string& message)
 {
 	// (TODO: this text-wrapping is rubbish since we now use variable-width fonts)
 
 	//Insert newlines to wraparound text where needed
 	std::wstring wrapAround = wstring_from_utf8(message.c_str());
 	std::wstring newline(L"\n");
 	size_t oldNewline=0;
 	size_t distance;
 
 	//make sure everything has been initialized
 	if ( m_charsPerPage != 0 )
 	{
 		while ( oldNewline+m_charsPerPage < wrapAround.length() )
 		{
 			distance = wrapAround.find(newline, oldNewline) - oldNewline;
 			if ( distance > m_charsPerPage )
 			{
 				oldNewline += m_charsPerPage;
 				wrapAround.insert( oldNewline++, newline );
 			}
 			else
 				oldNewline += distance+1;
 		}
 	}
 	// Split into lines and add each one individually
 	oldNewline = 0;
 
 	{
 		std::lock_guard<std::mutex> lock(m_Mutex); // needed for safe access to m_deqMsgHistory
 
 		while ( (distance = wrapAround.find(newline, oldNewline)) != wrapAround.npos)
 		{
 			distance -= oldNewline;
 			m_deqMsgHistory.push_front(wrapAround.substr(oldNewline, distance));
 			oldNewline += distance+1;
 		}
 		m_deqMsgHistory.push_front(wrapAround.substr(oldNewline));
 	}
 }
 
 const wchar_t* CConsole::GetBuffer()
 {
 	m_szBuffer[m_iBufferLength] = 0;
 	return( m_szBuffer );
 }
 
 void CConsole::SetBuffer(const wchar_t* szMessage)
 {
 	int oldBufferPos = m_iBufferPos;	// remember since FlushBuffer will set it to 0
 
 	FlushBuffer();
 
 	wcsncpy(m_szBuffer, szMessage, CONSOLE_BUFFER_SIZE);
 	m_szBuffer[CONSOLE_BUFFER_SIZE-1] = 0;
 	m_iBufferLength = (int)wcslen(m_szBuffer);
 	m_iBufferPos = std::min(oldBufferPos, m_iBufferLength);
 }
 
 void CConsole::UseHistoryFile(const VfsPath& filename, int max_history_lines)
 {
 	m_MaxHistoryLines = max_history_lines;
 
 	m_sHistoryFile = filename;
 	LoadHistory();
 }
 
 void CConsole::ProcessBuffer(const wchar_t* szLine)
 {
 	shared_ptr<ScriptInterface> pScriptInterface = g_GUI->GetActiveGUI()->GetScriptInterface();
 	JSContext* cx = pScriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 
 	if (szLine == NULL) return;
 	if (wcslen(szLine) <= 0) return;
 
 	ENSURE(wcslen(szLine) < CONSOLE_BUFFER_SIZE);
 
 	m_deqBufHistory.push_front(szLine);
 	SaveHistory(); // Do this each line for the moment; if a script causes
 	               // a crash it's a useful record.
 
 	// Process it as JavaScript
 
 	JS::RootedValue rval(cx);
 	pScriptInterface->Eval(szLine, &rval);
 	if (!rval.isUndefined())
 		InsertMessage(pScriptInterface->ToString(&rval));
 }
 
 void CConsole::LoadHistory()
 {
 	// note: we don't care if this file doesn't exist or can't be read;
 	// just don't load anything in that case.
 
 	// do this before LoadFile to avoid an error message if file not found.
 	if (!VfsFileExists(m_sHistoryFile))
 		return;
 
 	shared_ptr<u8> buf; size_t buflen;
 	if (g_VFS->LoadFile(m_sHistoryFile, buf, buflen) < 0)
 		return;
 
 	CStr bytes ((char*)buf.get(), buflen);
 
 	CStrW str (bytes.FromUTF8());
 	size_t pos = 0;
 	while (pos != CStrW::npos)
 	{
 		pos = str.find('\n');
 		if (pos != CStrW::npos)
 		{
 			if (pos > 0)
 				m_deqBufHistory.push_front(str.Left(str[pos-1] == '\r' ? pos - 1 : pos));
 			str = str.substr(pos + 1);
 		}
 		else if (str.length() > 0)
 			m_deqBufHistory.push_front(str);
 	}
 }
 
 void CConsole::SaveHistory()
 {
 	WriteBuffer buffer;
 	const int linesToSkip = (int)m_deqBufHistory.size() - m_MaxHistoryLines;
 	std::deque<std::wstring>::reverse_iterator it = m_deqBufHistory.rbegin();
 	if(linesToSkip > 0)
 		std::advance(it, linesToSkip);
 	for (; it != m_deqBufHistory.rend(); ++it)
 	{
 		CStr8 line = CStrW(*it).ToUTF8();
 		buffer.Append(line.data(), line.length());
 		static const char newline = '\n';
 		buffer.Append(&newline, 1);
 	}
 	g_VFS->CreateFile(m_sHistoryFile, buffer.Data(), buffer.Size());
 }
 
 static bool isUnprintableChar(SDL_Keysym key)
 {
 	switch (key.sym)
 	{
 	// We want to allow some, which are handled specially
 	case SDLK_RETURN: case SDLK_TAB:
 	case SDLK_BACKSPACE: case SDLK_DELETE:
 	case SDLK_HOME: case SDLK_END:
 	case SDLK_LEFT: case SDLK_RIGHT:
 	case SDLK_UP: case SDLK_DOWN:
 	case SDLK_PAGEUP: case SDLK_PAGEDOWN:
 		return false;
 
 	// Ignore the others
 	default:
 		return true;
 	}
 }
 
 InReaction conInputHandler(const SDL_Event_* ev)
 {
+	if (!g_Console)
+		return IN_PASS;
+
 	if ((int)ev->ev.type == SDL_HOTKEYDOWN)
 	{
 		std::string hotkey = static_cast<const char*>(ev->ev.user.data1);
 
 		if (hotkey == "console.toggle")
 		{
 			g_Console->ToggleVisible();
 			return IN_HANDLED;
 		}
 		else if (g_Console->IsActive() && hotkey == "copy")
 		{
 			sys_clipboard_set(g_Console->GetBuffer());
 			return IN_HANDLED;
 		}
 		else if (g_Console->IsActive() && hotkey == "paste")
 		{
 			wchar_t* text = sys_clipboard_get();
 			if (text)
 			{
 				for (wchar_t* c = text; *c; c++)
 					g_Console->InsertChar(0, *c);
 
 				sys_clipboard_free(text);
 			}
 			return IN_HANDLED;
 		}
 	}
 
 	if (!g_Console->IsActive())
 		return IN_PASS;
 
 	// In SDL2, we no longer get Unicode wchars via SDL_Keysym
 	// we use text input events instead and they provide UTF-8 chars
 	if (ev->ev.type == SDL_TEXTINPUT && !HotkeyIsPressed("console.toggle"))
 	{
 		// TODO: this could be more efficient with an interface to insert UTF-8 strings directly
 		std::wstring wstr = wstring_from_utf8(ev->ev.text.text);
 		for (size_t i = 0; i < wstr.length(); ++i)
 			g_Console->InsertChar(0, wstr[i]);
 		return IN_HANDLED;
 	}
 	// TODO: text editing events for IME support
 
 	if (ev->ev.type != SDL_KEYDOWN)
 		return IN_PASS;
 
 	int sym = ev->ev.key.keysym.sym;
 
 	// Stop unprintable characters (ctrl+, alt+ and escape),
 	// also prevent ` and/or ~ appearing in console every time it's toggled.
 	if (!isUnprintableChar(ev->ev.key.keysym) &&
 		!HotkeyIsPressed("console.toggle"))
 	{
 		g_Console->InsertChar(sym, 0);
 		return IN_HANDLED;
 	}
 
 	return IN_PASS;
 }
Index: ps/trunk/source/ps/GameSetup/GameSetup.cpp
===================================================================
--- ps/trunk/source/ps/GameSetup/GameSetup.cpp	(revision 22908)
+++ ps/trunk/source/ps/GameSetup/GameSetup.cpp	(revision 22909)
@@ -1,1680 +1,1684 @@
 /* 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 "lib/app_hooks.h"
 #include "lib/config2.h"
 #include "lib/input.h"
 #include "lib/ogl.h"
 #include "lib/timer.h"
 #include "lib/external_libraries/libsdl.h"
 #include "lib/file/common/file_stats.h"
 #include "lib/res/h_mgr.h"
 #include "lib/res/graphics/cursor.h"
 #include "lib/sysdep/cursor.h"
 
 #include "graphics/CinemaManager.h"
 #include "graphics/FontMetrics.h"
 #include "graphics/GameView.h"
 #include "graphics/LightEnv.h"
 #include "graphics/MapReader.h"
 #include "graphics/MaterialManager.h"
 #include "graphics/TerrainTextureManager.h"
 #include "gui/GUI.h"
 #include "gui/GUIManager.h"
 #include "i18n/L10n.h"
 #include "maths/MathUtil.h"
 #include "network/NetServer.h"
 #include "network/NetClient.h"
 #include "network/NetMessage.h"
 #include "network/NetMessages.h"
 
 #include "ps/CConsole.h"
 #include "ps/CLogger.h"
 #include "ps/ConfigDB.h"
 #include "ps/Filesystem.h"
 #include "ps/Game.h"
 #include "ps/GameSetup/Atlas.h"
 #include "ps/GameSetup/GameSetup.h"
 #include "ps/GameSetup/Paths.h"
 #include "ps/GameSetup/Config.h"
 #include "ps/GameSetup/CmdLineArgs.h"
 #include "ps/GameSetup/HWDetect.h"
 #include "ps/Globals.h"
 #include "ps/Hotkey.h"
 #include "ps/Joystick.h"
 #include "ps/Loader.h"
 #include "ps/Mod.h"
 #include "ps/ModIo.h"
 #include "ps/Profile.h"
 #include "ps/ProfileViewer.h"
 #include "ps/Profiler2.h"
 #include "ps/Pyrogenesis.h"	// psSetLogDir
 #include "ps/scripting/JSInterface_Console.h"
 #include "ps/TouchInput.h"
 #include "ps/UserReport.h"
 #include "ps/Util.h"
 #include "ps/VideoMode.h"
 #include "ps/VisualReplay.h"
 #include "ps/World.h"
 
 #include "renderer/Renderer.h"
 #include "renderer/VertexBufferManager.h"
 #include "renderer/ModelRenderer.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "scriptinterface/ScriptStats.h"
 #include "scriptinterface/ScriptConversions.h"
 #include "scriptinterface/ScriptRuntime.h"
 #include "simulation2/Simulation2.h"
 #include "lobby/IXmppClient.h"
 #include "soundmanager/scripting/JSInterface_Sound.h"
 #include "soundmanager/ISoundManager.h"
 #include "tools/atlas/GameInterface/GameLoop.h"
 #include "tools/atlas/GameInterface/View.h"
 
 #if !(OS_WIN || OS_MACOSX || OS_ANDROID) // assume all other platforms use X11 for wxWidgets
 #define MUST_INIT_X11 1
 #include <X11/Xlib.h>
 #else
 #define MUST_INIT_X11 0
 #endif
 
 extern void RestartEngine();
 
 #include <iostream>
 
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/split.hpp>
 
 ERROR_GROUP(System);
 ERROR_TYPE(System, SDLInitFailed);
 ERROR_TYPE(System, VmodeFailed);
 ERROR_TYPE(System, RequiredExtensionsMissing);
 
 bool g_DoRenderGui = true;
 bool g_DoRenderLogger = true;
 bool g_DoRenderCursor = true;
 
 shared_ptr<ScriptRuntime> g_ScriptRuntime;
 
 static const int SANE_TEX_QUALITY_DEFAULT = 5;	// keep in sync with code
 
 bool g_InDevelopmentCopy;
 bool g_CheckedIfInDevelopmentCopy = false;
 
 static void SetTextureQuality(int quality)
 {
 	int q_flags;
 	GLint filter;
 
 retry:
 	// keep this in sync with SANE_TEX_QUALITY_DEFAULT
 	switch(quality)
 	{
 		// worst quality
 	case 0:
 		q_flags = OGL_TEX_HALF_RES|OGL_TEX_HALF_BPP;
 		filter = GL_NEAREST;
 		break;
 		// [perf] add bilinear filtering
 	case 1:
 		q_flags = OGL_TEX_HALF_RES|OGL_TEX_HALF_BPP;
 		filter = GL_LINEAR;
 		break;
 		// [vmem] no longer reduce resolution
 	case 2:
 		q_flags = OGL_TEX_HALF_BPP;
 		filter = GL_LINEAR;
 		break;
 		// [vmem] add mipmaps
 	case 3:
 		q_flags = OGL_TEX_HALF_BPP;
 		filter = GL_NEAREST_MIPMAP_LINEAR;
 		break;
 		// [perf] better filtering
 	case 4:
 		q_flags = OGL_TEX_HALF_BPP;
 		filter = GL_LINEAR_MIPMAP_LINEAR;
 		break;
 		// [vmem] no longer reduce bpp
 	case SANE_TEX_QUALITY_DEFAULT:
 		q_flags = OGL_TEX_FULL_QUALITY;
 		filter = GL_LINEAR_MIPMAP_LINEAR;
 		break;
 		// [perf] add anisotropy
 	case 6:
 		// TODO: add anisotropic filtering
 		q_flags = OGL_TEX_FULL_QUALITY;
 		filter = GL_LINEAR_MIPMAP_LINEAR;
 		break;
 		// invalid
 	default:
 		debug_warn(L"SetTextureQuality: invalid quality");
 		quality = SANE_TEX_QUALITY_DEFAULT;
 		// careful: recursion doesn't work and we don't want to duplicate
 		// the "sane" default values.
 		goto retry;
 	}
 
 	ogl_tex_set_defaults(q_flags, filter);
 }
 
 
 //----------------------------------------------------------------------------
 // GUI integration
 //----------------------------------------------------------------------------
 
 // display progress / description in loading screen
 void GUI_DisplayLoadProgress(int percent, const wchar_t* pending_task)
 {
 	const ScriptInterface& scriptInterface = *(g_GUI->GetActiveGUI()->GetScriptInterface());
 	JSContext* cx = scriptInterface.GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::AutoValueVector paramData(cx);
 
 	paramData.append(JS::NumberValue(percent));
 
 	JS::RootedValue valPendingTask(cx);
 	scriptInterface.ToJSVal(cx, &valPendingTask, pending_task);
 	paramData.append(valPendingTask);
 
 	g_GUI->GetActiveGUI()->SendEventToAll("GameLoadProgress", paramData);
 }
 
 bool ShouldRender()
 {
 	return !g_app_minimized && (g_app_has_focus || !g_VideoMode.IsInFullscreen());
 }
 
 
 void Render()
 {
 	// Do not render if not focused while in fullscreen or minimised,
 	// as that triggers a difficult-to-reproduce crash on some graphic cards.
 	if (!ShouldRender())
 		return;
 
 	PROFILE3("render");
 
 	ogl_WarnIfError();
 
 	g_Profiler2.RecordGPUFrameStart();
 
 	ogl_WarnIfError();
 
 	// prepare before starting the renderer frame
 	if (g_Game && g_Game->IsGameStarted())
 		g_Game->GetView()->BeginFrame();
 
 	if (g_Game)
 		g_Renderer.SetSimulation(g_Game->GetSimulation2());
 
 	// start new frame
 	g_Renderer.BeginFrame();
 
 	ogl_WarnIfError();
 
 	if (g_Game && g_Game->IsGameStarted())
 		g_Game->GetView()->Render();
 
 	ogl_WarnIfError();
 
 	g_Renderer.RenderTextOverlays();
 
 	// If we're in Atlas game view, render special tools
 	if (g_AtlasGameLoop && g_AtlasGameLoop->view)
 	{
 		g_AtlasGameLoop->view->DrawCinemaPathTool();
 		ogl_WarnIfError();
 	}
 
 	if (g_Game && g_Game->IsGameStarted())
 		g_Game->GetView()->GetCinema()->Render();
 
 	ogl_WarnIfError();
 
 	if (g_DoRenderGui)
 		g_GUI->Draw();
 
 	ogl_WarnIfError();
 
 	// If we're in Atlas game view, render special overlays (e.g. editor bandbox)
 	if (g_AtlasGameLoop && g_AtlasGameLoop->view)
 	{
 		g_AtlasGameLoop->view->DrawOverlays();
 		ogl_WarnIfError();
 	}
 
 	// Text:
 
  	glDisable(GL_DEPTH_TEST);
 
 	g_Console->Render();
 
 	ogl_WarnIfError();
 
 	if (g_DoRenderLogger)
 		g_Logger->Render();
 
 	ogl_WarnIfError();
 
 	// Profile information
 
 	g_ProfileViewer.RenderProfile();
 
 	ogl_WarnIfError();
 
 	// Draw the cursor (or set the Windows cursor, on Windows)
 	if (g_DoRenderCursor)
 	{
 		PROFILE3_GPU("cursor");
 		CStrW cursorName = g_CursorName;
 		if (cursorName.empty())
 		{
 			cursor_draw(g_VFS, NULL, g_mouse_x, g_yres-g_mouse_y, g_GuiScale, false);
 		}
 		else
 		{
 			bool forceGL = false;
 			CFG_GET_VAL("nohwcursor", forceGL);
 
 #if CONFIG2_GLES
 #warning TODO: implement cursors for GLES
 #else
 			// set up transform for GL cursor
 			glMatrixMode(GL_PROJECTION);
 			glPushMatrix();
 			glLoadIdentity();
 			glMatrixMode(GL_MODELVIEW);
 			glPushMatrix();
 			glLoadIdentity();
 			CMatrix3D transform;
 			transform.SetOrtho(0.f, (float)g_xres, 0.f, (float)g_yres, -1.f, 1000.f);
 			glLoadMatrixf(&transform._11);
 #endif
 
 #if OS_ANDROID
 #warning TODO: cursors for Android
 #else
 			if (cursor_draw(g_VFS, cursorName.c_str(), g_mouse_x, g_yres-g_mouse_y, g_GuiScale, forceGL) < 0)
 				LOGWARNING("Failed to draw cursor '%s'", utf8_from_wstring(cursorName));
 #endif
 
 #if CONFIG2_GLES
 #warning TODO: implement cursors for GLES
 #else
 			// restore transform
 			glMatrixMode(GL_PROJECTION);
 			glPopMatrix();
 			glMatrixMode(GL_MODELVIEW);
 			glPopMatrix();
 #endif
 		}
 	}
 
 	glEnable(GL_DEPTH_TEST);
 
 	g_Renderer.EndFrame();
 
 	PROFILE2_ATTR("draw calls: %d", (int)g_Renderer.GetStats().m_DrawCalls);
 	PROFILE2_ATTR("terrain tris: %d", (int)g_Renderer.GetStats().m_TerrainTris);
 	PROFILE2_ATTR("water tris: %d", (int)g_Renderer.GetStats().m_WaterTris);
 	PROFILE2_ATTR("model tris: %d", (int)g_Renderer.GetStats().m_ModelTris);
 	PROFILE2_ATTR("overlay tris: %d", (int)g_Renderer.GetStats().m_OverlayTris);
 	PROFILE2_ATTR("blend splats: %d", (int)g_Renderer.GetStats().m_BlendSplats);
 	PROFILE2_ATTR("particles: %d", (int)g_Renderer.GetStats().m_Particles);
 
 	ogl_WarnIfError();
 
 	g_Profiler2.RecordGPUFrameEnd();
 
 	ogl_WarnIfError();
 }
 
 ErrorReactionInternal psDisplayError(const wchar_t* UNUSED(text), size_t UNUSED(flags))
 {
 	// If we're fullscreen, then sometimes (at least on some particular drivers on Linux)
 	// displaying the error dialog hangs the desktop since the dialog box is behind the
 	// fullscreen window. So we just force the game to windowed mode before displaying the dialog.
 	// (But only if we're in the main thread, and not if we're being reentrant.)
 	if (ThreadUtil::IsMainThread())
 	{
 		static bool reentering = false;
 		if (!reentering)
 		{
 			reentering = true;
 			g_VideoMode.SetFullscreen(false);
 			reentering = false;
 		}
 	}
 
 	// We don't actually implement the error display here, so return appropriately
 	return ERI_NOT_IMPLEMENTED;
 }
 
 const std::vector<CStr>& GetMods(const CmdLineArgs& args, int flags)
 {
 	const bool init_mods = (flags & INIT_MODS) == INIT_MODS;
 	const bool add_user = !InDevelopmentCopy() && !args.Has("noUserMod");
 	const bool add_public = (flags & INIT_MODS_PUBLIC) == INIT_MODS_PUBLIC;
 
 	if (!init_mods)
 	{
 		// Add the user mod if it should be present
 		if (add_user && (g_modsLoaded.empty() || g_modsLoaded.back() != "user"))
 			g_modsLoaded.push_back("user");
 
 		return g_modsLoaded;
 	}
 
 	g_modsLoaded = args.GetMultiple("mod");
 
 	if (add_public)
 		g_modsLoaded.insert(g_modsLoaded.begin(), "public");
 
 	g_modsLoaded.insert(g_modsLoaded.begin(), "mod");
 
 	// Add the user mod if not explicitly disabled or we have a dev copy so
 	// that saved files end up in version control and not in the user mod.
 	if (add_user)
 		g_modsLoaded.push_back("user");
 
 	return g_modsLoaded;
 }
 
 void MountMods(const Paths& paths, const std::vector<CStr>& mods)
 {
 	OsPath modPath = paths.RData()/"mods";
 	OsPath modUserPath = paths.UserData()/"mods";
 	for (size_t i = 0; i < mods.size(); ++i)
 	{
 		size_t priority = (i+1)*2;	// mods are higher priority than regular mountings, which default to priority 0
 		size_t userFlags = VFS_MOUNT_WATCH|VFS_MOUNT_ARCHIVABLE|VFS_MOUNT_REPLACEABLE;
 		size_t baseFlags = userFlags|VFS_MOUNT_MUST_EXIST;
 
 		OsPath modName(mods[i]);
 		if (InDevelopmentCopy())
 		{
 			// We are running a dev copy, so only mount mods in the user mod path
 			// if the mod does not exist in the data path.
 			if (DirectoryExists(modPath / modName/""))
 				g_VFS->Mount(L"", modPath / modName/"", baseFlags, priority);
 			else
 				g_VFS->Mount(L"", modUserPath / modName/"", userFlags, priority);
 		}
 		else
 		{
 			g_VFS->Mount(L"", modPath / modName/"", baseFlags, priority);
 			// Ensure that user modified files are loaded, if they are present
 			g_VFS->Mount(L"", modUserPath / modName/"", userFlags, priority+1);
 		}
 	}
 }
 
 static void InitVfs(const CmdLineArgs& args, int flags)
 {
 	TIMER(L"InitVfs");
 
 	const bool setup_error = (flags & INIT_HAVE_DISPLAY_ERROR) == 0;
 
 	const Paths paths(args);
 
 	OsPath logs(paths.Logs());
 	CreateDirectories(logs, 0700);
 
 	psSetLogDir(logs);
 	// desired location for crashlog is now known. update AppHooks ASAP
 	// (particularly before the following error-prone operations):
 	AppHooks hooks = {0};
 	hooks.bundle_logs = psBundleLogs;
 	hooks.get_log_dir = psLogDir;
 	if (setup_error)
 		hooks.display_error = psDisplayError;
 	app_hooks_update(&hooks);
 
 	g_VFS = CreateVfs();
 
 	const OsPath readonlyConfig = paths.RData()/"config"/"";
 	g_VFS->Mount(L"config/", readonlyConfig);
 
 	// Engine localization files.
 	g_VFS->Mount(L"l10n/", paths.RData()/"l10n"/"");
 
 	MountMods(paths, GetMods(args, flags));
 
 	// We mount these dirs last as otherwise writing could result in files being placed in a mod's dir.
 	g_VFS->Mount(L"screenshots/", paths.UserData()/"screenshots"/"");
 	g_VFS->Mount(L"saves/", paths.UserData()/"saves"/"", VFS_MOUNT_WATCH);
 	// Mounting with highest priority, so that a mod supplied user.cfg is harmless
 	g_VFS->Mount(L"config/", readonlyConfig, 0, (size_t)-1);
 	if(readonlyConfig != paths.Config())
 		g_VFS->Mount(L"config/", paths.Config(), 0, (size_t)-1);
 
 	g_VFS->Mount(L"cache/", paths.Cache(), VFS_MOUNT_ARCHIVABLE);	// (adding XMBs to archive speeds up subsequent reads)
 
 	// note: don't bother with g_VFS->TextRepresentation - directories
 	// haven't yet been populated and are empty.
 }
 
 
 static void InitPs(bool setup_gui, const CStrW& gui_page, ScriptInterface* srcScriptInterface, JS::HandleValue initData)
 {
 	{
 		// console
 		TIMER(L"ps_console");
 
 		g_Console->UpdateScreenSize(g_xres, g_yres);
 
 		// Calculate and store the line spacing
 		CFontMetrics font(CStrIntern(CONSOLE_FONT));
 		g_Console->m_iFontHeight = font.GetLineSpacing();
 		g_Console->m_iFontWidth = font.GetCharacterWidth(L'C');
 		g_Console->m_charsPerPage = (size_t)(g_xres / g_Console->m_iFontWidth);
 		// Offset by an arbitrary amount, to make it fit more nicely
 		g_Console->m_iFontOffset = 7;
 
 		double blinkRate = 0.5;
 		CFG_GET_VAL("gui.cursorblinkrate", blinkRate);
 		g_Console->SetCursorBlinkRate(blinkRate);
 	}
 
 	// hotkeys
 	{
 		TIMER(L"ps_lang_hotkeys");
 		LoadHotkeys();
 	}
 
 	if (!setup_gui)
 	{
 		// We do actually need *some* kind of GUI loaded, so use the
 		// (currently empty) Atlas one
 		g_GUI->SwitchPage(L"page_atlas.xml", srcScriptInterface, initData);
 		return;
 	}
 
 	// GUI uses VFS, so this must come after VFS init.
 	g_GUI->SwitchPage(gui_page, srcScriptInterface, initData);
 }
 
 void InitPsAutostart(bool networked, JS::HandleValue attrs)
 {
 	// The GUI has not been initialized yet, so use the simulation scriptinterface for this variable
 	ScriptInterface& scriptInterface = g_Game->GetSimulation2()->GetScriptInterface();
 	JSContext* cx = scriptInterface.GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedValue playerAssignments(cx);
 	ScriptInterface::CreateObject(cx, &playerAssignments);
 
 	if (!networked)
 	{
 		JS::RootedValue localPlayer(cx);
 		ScriptInterface::CreateObject(cx, &localPlayer, "player", g_Game->GetPlayerID());
 		scriptInterface.SetProperty(playerAssignments, "local", localPlayer);
 	}
 
 	JS::RootedValue sessionInitData(cx);
 
 	ScriptInterface::CreateObject(
 		cx,
 		&sessionInitData,
 		"attribs", attrs,
 		"playerAssignments", playerAssignments);
 
 	InitPs(true, L"page_loading.xml", &scriptInterface, sessionInitData);
 }
 
 
-static void InitInput()
+void InitInput()
 {
 	g_Joystick.Initialise();
 
 	// register input handlers
 	// This stack is constructed so the first added, will be the last
 	//  one called. This is important, because each of the handlers
 	//  has the potential to block events to go further down
 	//  in the chain. I.e. the last one in the list added, is the
 	//  only handler that can block all messages before they are
 	//  processed.
 	in_add_handler(game_view_handler);
 
 	in_add_handler(CProfileViewer::InputThunk);
 
 	in_add_handler(conInputHandler);
 
 	in_add_handler(HotkeyInputHandler);
 
 	// gui_handler needs to be registered after (i.e. called before!) the
 	// hotkey handler so that input boxes can be typed in without
 	// setting off hotkeys.
 	in_add_handler(gui_handler);
 
 	in_add_handler(touch_input_handler);
 
 	// must be registered after (called before) the GUI which relies on these globals
 	in_add_handler(GlobalsInputHandler);
+
+	// Should be called first, this updates our hotkey press state
+	// so that js calls to HotkeyIsPressed are synched with events.
+	in_add_handler(HotkeyStateChange);
 }
 
 
 static void ShutdownPs()
 {
 	SAFE_DELETE(g_GUI);
 
 	UnloadHotkeys();
 
 	// disable the special Windows cursor, or free textures for OGL cursors
 	cursor_draw(g_VFS, 0, g_mouse_x, g_yres-g_mouse_y, 1.0, false);
 }
 
 
 static void InitRenderer()
 {
 	TIMER(L"InitRenderer");
 
 	if(g_NoGLS3TC)
 		ogl_tex_override(OGL_TEX_S3TC, OGL_TEX_DISABLE);
 	if(g_NoGLAutoMipmap)
 		ogl_tex_override(OGL_TEX_AUTO_MIPMAP_GEN, OGL_TEX_DISABLE);
 
 	// create renderer
 	new CRenderer;
 
 	g_RenderingOptions.ReadConfig();
 
 	// set renderer options from command line options - NOVBO must be set before opening the renderer
 	// and init them in the ConfigDB when needed
 	g_RenderingOptions.SetNoVBO(g_NoGLVBO);
 	g_RenderingOptions.SetShadows(g_Shadows);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "shadows", g_Shadows);
 
 	g_RenderingOptions.SetWaterEffects(g_WaterEffects);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "watereffects", g_WaterEffects);
 	g_RenderingOptions.SetWaterFancyEffects(g_WaterFancyEffects);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "waterfancyeffects", g_WaterFancyEffects);
 	g_RenderingOptions.SetWaterRealDepth(g_WaterRealDepth);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "waterrealdepth", g_WaterRealDepth);
 	g_RenderingOptions.SetWaterReflection(g_WaterReflection);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "waterreflection", g_WaterReflection);
 	g_RenderingOptions.SetWaterRefraction(g_WaterRefraction);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "waterrefraction", g_WaterRefraction);
 	g_RenderingOptions.SetWaterShadows(g_WaterShadows);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "watershadows", g_WaterShadows);
 
 	g_RenderingOptions.SetRenderPath(RenderPathEnum::FromString(g_RenderPath));
 	g_RenderingOptions.SetShadowPCF(g_ShadowPCF);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "shadowpcf", g_ShadowPCF);
 	g_RenderingOptions.SetParticles(g_Particles);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "particles", g_Particles);
 	g_RenderingOptions.SetFog(g_Fog);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "fog", g_Fog);
 	g_RenderingOptions.SetSilhouettes(g_Silhouettes);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "silhouettes", g_Silhouettes);
 	g_RenderingOptions.SetShowSky(g_ShowSky);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "showsky", g_ShowSky);
 	g_RenderingOptions.SetPreferGLSL(g_PreferGLSL);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "preferglsl", g_PreferGLSL);
 	g_RenderingOptions.SetPostProc(g_PostProc);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "postproc", g_PostProc);
 	g_RenderingOptions.SetSmoothLOS(g_SmoothLOS);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "smoothlos", g_SmoothLOS);
 
 	// create terrain related stuff
 	new CTerrainTextureManager;
 
 	g_Renderer.Open(g_xres, g_yres);
 
 	// Setup lighting environment. Since the Renderer accesses the
 	// lighting environment through a pointer, this has to be done before
 	// the first Frame.
 	g_Renderer.SetLightEnv(&g_LightEnv);
 
 	// I haven't seen the camera affecting GUI rendering and such, but the
 	// viewport has to be updated according to the video mode
 	SViewPort vp;
 	vp.m_X = 0;
 	vp.m_Y = 0;
 	vp.m_Width = g_xres;
 	vp.m_Height = g_yres;
 	g_Renderer.SetViewport(vp);
 
 	ColorActivateFastImpl();
 	ModelRenderer::Init();
 }
 
 static void InitSDL()
 {
 #if OS_LINUX
 	// In fullscreen mode when SDL is compiled with DGA support, the mouse
 	// sensitivity often appears to be unusably wrong (typically too low).
 	// (This seems to be reported almost exclusively on Ubuntu, but can be
 	// reproduced on Gentoo after explicitly enabling DGA.)
 	// Disabling the DGA mouse appears to fix that problem, and doesn't
 	// have any obvious negative effects.
 	setenv("SDL_VIDEO_X11_DGAMOUSE", "0", 0);
 #endif
 
 	if(SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER|SDL_INIT_NOPARACHUTE) < 0)
 	{
 		LOGERROR("SDL library initialization failed: %s", SDL_GetError());
 		throw PSERROR_System_SDLInitFailed();
 	}
 	atexit(SDL_Quit);
 
 	// Text input is active by default, disable it until it is actually needed.
 	SDL_StopTextInput();
 
 #if OS_MACOSX
 	// Some Mac mice only have one button, so they can't right-click
 	// but SDL2 can emulate that with Ctrl+Click
 	bool macMouse = false;
 	CFG_GET_VAL("macmouse", macMouse);
 	SDL_SetHint(SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK, macMouse ? "1" : "0");
 #endif
 }
 
 static void ShutdownSDL()
 {
 	SDL_Quit();
 	sys_cursor_reset();
 }
 
 
 void EndGame()
 {
 	if (g_Game && g_Game->IsGameStarted() && !g_Game->IsVisualReplay() &&
 	    g_AtlasGameLoop && !g_AtlasGameLoop->running && CRenderer::IsInitialised())
 		VisualReplay::SaveReplayMetadata(g_GUI->GetActiveGUI()->GetScriptInterface().get());
 
 	SAFE_DELETE(g_NetClient);
 	SAFE_DELETE(g_NetServer);
 	SAFE_DELETE(g_Game);
 
 	if (CRenderer::IsInitialised())
 	{
 		ISoundManager::CloseGame();
 		g_Renderer.ResetState();
 	}
 }
 
 void Shutdown(int flags)
 {
 	const bool hasRenderer = CRenderer::IsInitialised();
 
 	if ((flags & SHUTDOWN_FROM_CONFIG))
 		goto from_config;
 
 	EndGame();
 
 	SAFE_DELETE(g_XmppClient);
 
 	SAFE_DELETE(g_ModIo);
 
 	ShutdownPs();
 
 	TIMER_BEGIN(L"shutdown TexMan");
 	delete &g_TexMan;
 	TIMER_END(L"shutdown TexMan");
 
 	if (hasRenderer)
 	{
 		TIMER_BEGIN(L"shutdown Renderer");
 		g_Renderer.~CRenderer();
 		g_VBMan.Shutdown();
 		TIMER_END(L"shutdown Renderer");
 	}
 
 	g_Profiler2.ShutdownGPU();
 
 	// Free cursors before shutting down SDL, as they may depend on SDL.
 	cursor_shutdown();
 
 	TIMER_BEGIN(L"shutdown SDL");
 	ShutdownSDL();
 	TIMER_END(L"shutdown SDL");
 
 	if (hasRenderer)
 		g_VideoMode.Shutdown();
 
 	TIMER_BEGIN(L"shutdown UserReporter");
 	g_UserReporter.Deinitialize();
 	TIMER_END(L"shutdown UserReporter");
 
 	// Cleanup curl now that g_ModIo and g_UserReporter have been shutdown.
 	curl_global_cleanup();
 
 	delete &g_L10n;
 
 from_config:
 	TIMER_BEGIN(L"shutdown ConfigDB");
 	delete &g_ConfigDB;
 	TIMER_END(L"shutdown ConfigDB");
 
 	SAFE_DELETE(g_Console);
 
 	// This is needed to ensure that no callbacks from the JSAPI try to use
 	// the profiler when it's already destructed
 	g_ScriptRuntime.reset();
 
 	// resource
 	// first shut down all resource owners, and then the handle manager.
 	TIMER_BEGIN(L"resource modules");
 
 		ISoundManager::SetEnabled(false);
 
 		g_VFS.reset();
 
 		// this forcibly frees all open handles (thus preventing real leaks),
 		// and makes further access to h_mgr impossible.
 		h_mgr_shutdown();
 
 		file_stats_dump();
 
 	TIMER_END(L"resource modules");
 
 	TIMER_BEGIN(L"shutdown misc");
 		timer_DisplayClientTotals();
 
 		CNetHost::Deinitialize();
 
 		// should be last, since the above use them
 		SAFE_DELETE(g_Logger);
 		delete &g_Profiler;
 		delete &g_ProfileViewer;
 
 		SAFE_DELETE(g_ScriptStatsTable);
 	TIMER_END(L"shutdown misc");
 }
 
 #if OS_UNIX
 static void FixLocales()
 {
 #if OS_MACOSX || OS_BSD
 	// OS X requires a UTF-8 locale in LC_CTYPE so that *wprintf can handle
 	// wide characters. Peculiarly the string "UTF-8" seems to be acceptable
 	// despite not being a real locale, and it's conveniently language-agnostic,
 	// so use that.
 	setlocale(LC_CTYPE, "UTF-8");
 #endif
 
 
 	// On misconfigured systems with incorrect locale settings, we'll die
 	// with a C++ exception when some code (e.g. Boost) tries to use locales.
 	// To avoid death, we'll detect the problem here and warn the user and
 	// reset to the default C locale.
 
 
 	// For informing the user of the problem, use the list of env vars that
 	// glibc setlocale looks at. (LC_ALL is checked first, and LANG last.)
 	const char* const LocaleEnvVars[] = {
 		"LC_ALL",
 		"LC_COLLATE",
 		"LC_CTYPE",
 		"LC_MONETARY",
 		"LC_NUMERIC",
 		"LC_TIME",
 		"LC_MESSAGES",
 		"LANG"
 	};
 
 	try
 	{
 		// this constructor is similar to setlocale(LC_ALL, ""),
 		// but instead of returning NULL, it throws runtime_error
 		// when the first locale env variable found contains an invalid value
 		std::locale("");
 	}
 	catch (std::runtime_error&)
 	{
 		LOGWARNING("Invalid locale settings");
 
 		for (size_t i = 0; i < ARRAY_SIZE(LocaleEnvVars); i++)
 		{
 			if (char* envval = getenv(LocaleEnvVars[i]))
 				LOGWARNING("  %s=\"%s\"", LocaleEnvVars[i], envval);
 			else
 				LOGWARNING("  %s=\"(unset)\"", LocaleEnvVars[i]);
 		}
 
 		// We should set LC_ALL since it overrides LANG
 		if (setenv("LC_ALL", std::locale::classic().name().c_str(), 1))
 			debug_warn(L"Invalid locale settings, and unable to set LC_ALL env variable.");
 		else
 			LOGWARNING("Setting LC_ALL env variable to: %s", getenv("LC_ALL"));
 	}
 }
 #else
 static void FixLocales()
 {
 	// Do nothing on Windows
 }
 #endif
 
 void EarlyInit()
 {
 	// If you ever want to catch a particular allocation:
 	//_CrtSetBreakAlloc(232647);
 
 	ThreadUtil::SetMainThread();
 
 	debug_SetThreadName("main");
 	// add all debug_printf "tags" that we are interested in:
 	debug_filter_add("TIMER");
 
 	timer_LatchStartTime();
 
 	// initialise profiler early so it can profile startup,
 	// but only after LatchStartTime
 	g_Profiler2.Initialise();
 
 	FixLocales();
 
 	// Because we do GL calls from a secondary thread, Xlib needs to
 	// be told to support multiple threads safely.
 	// This is needed for Atlas, but we have to call it before any other
 	// Xlib functions (e.g. the ones used when drawing the main menu
 	// before launching Atlas)
 #if MUST_INIT_X11
 	int status = XInitThreads();
 	if (status == 0)
 		debug_printf("Error enabling thread-safety via XInitThreads\n");
 #endif
 
 	// Initialise the low-quality rand function
 	srand(time(NULL));	// NOTE: this rand should *not* be used for simulation!
 }
 
 bool Autostart(const CmdLineArgs& args);
 
 /**
  * Returns true if the user has intended to start a visual replay from command line.
  */
 bool AutostartVisualReplay(const std::string& replayFile);
 
 bool Init(const CmdLineArgs& args, int flags)
 {
 	h_mgr_init();
 
 	// Do this as soon as possible, because it chdirs
 	// and will mess up the error reporting if anything
 	// crashes before the working directory is set.
 	InitVfs(args, flags);
 
 	// This must come after VFS init, which sets the current directory
 	// (required for finding our output log files).
 	g_Logger = new CLogger;
 
 	new CProfileViewer;
 	new CProfileManager;	// before any script code
 
 	g_ScriptStatsTable = new CScriptStatsTable;
 	g_ProfileViewer.AddRootTable(g_ScriptStatsTable);
 
 	// Set up the console early, so that debugging
 	// messages can be logged to it. (The console's size
 	// and fonts are set later in InitPs())
 	g_Console = new CConsole();
 
 	// g_ConfigDB, command line args, globals
 	CONFIG_Init(args);
 
 	// Using a global object for the runtime is a workaround until Simulation and AI use
 	// their own threads and also their own runtimes.
 	const int runtimeSize = 384 * 1024 * 1024;
 	const int heapGrowthBytesGCTrigger = 20 * 1024 * 1024;
 	g_ScriptRuntime = ScriptInterface::CreateRuntime(shared_ptr<ScriptRuntime>(), runtimeSize, heapGrowthBytesGCTrigger);
 
 	Mod::CacheEnabledModVersions(g_ScriptRuntime);
 
 	// Special command-line mode to dump the entity schemas instead of running the game.
 	// (This must be done after loading VFS etc, but should be done before wasting time
 	// on anything else.)
 	if (args.Has("dumpSchema"))
 	{
 		CSimulation2 sim(NULL, g_ScriptRuntime, NULL);
 		sim.LoadDefaultScripts();
 		std::ofstream f("entity.rng", std::ios_base::out | std::ios_base::trunc);
 		f << sim.GenerateSchema();
 		std::cout << "Generated entity.rng\n";
 		exit(0);
 	}
 
 	CNetHost::Initialize();
 
 #if CONFIG2_AUDIO
 	if (!args.Has("autostart-nonvisual"))
 		ISoundManager::CreateSoundManager();
 #endif
 
 	// Check if there are mods specified on the command line,
 	// or if we already set the mods (~INIT_MODS),
 	// else check if there are mods that should be loaded specified
 	// in the config and load those (by aborting init and restarting
 	// the engine).
 	if (!args.Has("mod") && (flags & INIT_MODS) == INIT_MODS)
 	{
 		CStr modstring;
 		CFG_GET_VAL("mod.enabledmods", modstring);
 		if (!modstring.empty())
 		{
 			std::vector<CStr> mods;
 			boost::split(mods, modstring, boost::is_any_of(" "), boost::token_compress_on);
 			std::swap(g_modsLoaded, mods);
 
 			// Abort init and restart
 			RestartEngine();
 			return false;
 		}
 	}
 
 	new L10n;
 
 	// Optionally start profiler HTTP output automatically
 	// (By default it's only enabled by a hotkey, for security/performance)
 	bool profilerHTTPEnable = false;
 	CFG_GET_VAL("profiler2.autoenable", profilerHTTPEnable);
 	if (profilerHTTPEnable)
 		g_Profiler2.EnableHTTP();
 
 	// Initialise everything except Win32 sockets (because our networking
 	// system already inits those)
 	curl_global_init(CURL_GLOBAL_ALL & ~CURL_GLOBAL_WIN32);
 
 	if (!g_Quickstart)
 		g_UserReporter.Initialize(); // after config
 
 	PROFILE2_EVENT("Init finished");
 	return true;
 }
 
 void InitGraphics(const CmdLineArgs& args, int flags, const std::vector<CStr>& installedMods)
 {
 	const bool setup_vmode = (flags & INIT_HAVE_VMODE) == 0;
 
 	if(setup_vmode)
 	{
 		InitSDL();
 
 		if (!g_VideoMode.InitSDL())
 			throw PSERROR_System_VmodeFailed(); // abort startup
 	}
 
 	RunHardwareDetection();
 
 	const int quality = SANE_TEX_QUALITY_DEFAULT;	// TODO: set value from config file
 	SetTextureQuality(quality);
 
 	ogl_WarnIfError();
 
 	// Optionally start profiler GPU timings automatically
 	// (By default it's only enabled by a hotkey, for performance/compatibility)
 	bool profilerGPUEnable = false;
 	CFG_GET_VAL("profiler2.autoenable", profilerGPUEnable);
 	if (profilerGPUEnable)
 		g_Profiler2.EnableGPU();
 
 	if(!g_Quickstart)
 	{
 		WriteSystemInfo();
 		// note: no longer vfs_display here. it's dog-slow due to unbuffered
 		// file output and very rarely needed.
 	}
 
 	if(g_DisableAudio)
 		ISoundManager::SetEnabled(false);
 
 	g_GUI = new CGUIManager();
 
 	// (must come after SetVideoMode, since it calls ogl_Init)
 	if (ogl_HaveExtensions(0, "GL_ARB_vertex_program", "GL_ARB_fragment_program", NULL) != 0 // ARB
 		&& ogl_HaveExtensions(0, "GL_ARB_vertex_shader", "GL_ARB_fragment_shader", NULL) != 0) // GLSL
 	{
 		DEBUG_DISPLAY_ERROR(
 			L"Your graphics card doesn't appear to be fully compatible with OpenGL shaders."
 			L" In the future, the game will not support pre-shader graphics cards."
 			L" You are advised to try installing newer drivers and/or upgrade your graphics card."
 			L" For more information, please see http://www.wildfiregames.com/forum/index.php?showtopic=16734"
 		);
 		// TODO: actually quit once fixed function support is dropped
 	}
 
 	const char* missing = ogl_HaveExtensions(0,
 		"GL_ARB_multitexture",
 		"GL_EXT_draw_range_elements",
 		"GL_ARB_texture_env_combine",
 		"GL_ARB_texture_env_dot3",
 		NULL);
 	if(missing)
 	{
 		wchar_t buf[500];
 		swprintf_s(buf, ARRAY_SIZE(buf),
 			L"The %hs extension doesn't appear to be available on your computer."
 			L" The game may still work, though - you are welcome to try at your own risk."
 			L" If not or it doesn't look right, upgrade your graphics card.",
 			missing
 		);
 		DEBUG_DISPLAY_ERROR(buf);
 		// TODO: i18n
 	}
 
 	if (!ogl_HaveExtension("GL_ARB_texture_env_crossbar"))
 	{
 		DEBUG_DISPLAY_ERROR(
 			L"The GL_ARB_texture_env_crossbar extension doesn't appear to be available on your computer."
 			L" Shadows are not available and overall graphics quality might suffer."
 			L" You are advised to try installing newer drivers and/or upgrade your graphics card.");
 		g_Shadows = false;
 	}
 
 	ogl_WarnIfError();
 	InitRenderer();
 
 	InitInput();
 
 	ogl_WarnIfError();
 
 	// TODO: Is this the best place for this?
 	if (VfsDirectoryExists(L"maps/"))
 		CXeromyces::AddValidator(g_VFS, "map", "maps/scenario.rng");
 
 	try
 	{
 		if (!AutostartVisualReplay(args.Get("replay-visual")) && !Autostart(args))
 		{
 			const bool setup_gui = ((flags & INIT_NO_GUI) == 0);
 			// We only want to display the splash screen at startup
 			shared_ptr<ScriptInterface> scriptInterface = g_GUI->GetScriptInterface();
 			JSContext* cx = scriptInterface->GetContext();
 			JSAutoRequest rq(cx);
 			JS::RootedValue data(cx);
 			if (g_GUI)
 			{
 				ScriptInterface::CreateObject(cx, &data, "isStartup", true);
 				if (!installedMods.empty())
 					scriptInterface->SetProperty(data, "installedMods", installedMods);
 			}
 			InitPs(setup_gui, installedMods.empty() ? L"page_pregame.xml" : L"page_modmod.xml", g_GUI->GetScriptInterface().get(), data);
 		}
 	}
 	catch (PSERROR_Game_World_MapLoadFailed& e)
 	{
 		// Map Loading failed
 
 		// Start the engine so we have a GUI
 		InitPs(true, L"page_pregame.xml", NULL, JS::UndefinedHandleValue);
 
 		// Call script function to do the actual work
 		//	(delete game data, switch GUI page, show error, etc.)
 		CancelLoad(CStr(e.what()).FromUTF8());
 	}
 }
 
 void InitNonVisual(const CmdLineArgs& args)
 {
 	// Need some stuff for terrain movement costs:
 	// (TODO: this ought to be independent of any graphics code)
 	new CTerrainTextureManager;
 	g_TexMan.LoadTerrainTextures();
 	Autostart(args);
 }
 
 void RenderGui(bool RenderingState)
 {
 	g_DoRenderGui = RenderingState;
 }
 
 void RenderLogger(bool RenderingState)
 {
 	g_DoRenderLogger = RenderingState;
 }
 
 void RenderCursor(bool RenderingState)
 {
 	g_DoRenderCursor = RenderingState;
 }
 
 /**
  * Temporarily loads a scenario map and retrieves the "ScriptSettings" JSON
  * data from it.
  * The scenario map format is used for scenario and skirmish map types (random
  * games do not use a "map" (format) but a small JavaScript program which
  * creates a map on the fly). It contains a section to initialize the game
  * setup screen.
  * @param mapPath Absolute path (from VFS root) to the map file to peek in.
  * @return ScriptSettings in JSON format extracted from the map.
  */
 CStr8 LoadSettingsOfScenarioMap(const VfsPath &mapPath)
 {
 	CXeromyces mapFile;
 	const char *pathToSettings[] =
 	{
 		"Scenario", "ScriptSettings", ""	// Path to JSON data in map
 	};
 
 	Status loadResult = mapFile.Load(g_VFS, mapPath);
 
 	if (INFO::OK != loadResult)
 	{
 		LOGERROR("LoadSettingsOfScenarioMap: Unable to load map file '%s'", mapPath.string8());
 		throw PSERROR_Game_World_MapLoadFailed("Unable to load map file, check the path for typos.");
 	}
 	XMBElement mapElement = mapFile.GetRoot();
 
 	// Select the ScriptSettings node in the map file...
 	for (int i = 0; pathToSettings[i][0]; ++i)
 	{
 		int childId = mapFile.GetElementID(pathToSettings[i]);
 
 		XMBElementList nodes = mapElement.GetChildNodes();
 		auto it = std::find_if(nodes.begin(), nodes.end(), [&childId](const XMBElement& child) {
 			return child.GetNodeName() == childId;
 		});
 
 		if (it != nodes.end())
 			mapElement = *it;
 	}
 	// ... they contain a JSON document to initialize the game setup
 	// screen
 	return mapElement.GetText();
 }
 
 /*
  * Command line options for autostart
  * (keep synchronized with binaries/system/readme.txt):
  *
  * -autostart="TYPEDIR/MAPNAME"    enables autostart and sets MAPNAME;
  *                                 TYPEDIR is skirmishes, scenarios, or random
  * -autostart-seed=SEED            sets randomization seed value (default 0, use -1 for random)
  * -autostart-ai=PLAYER:AI         sets the AI for PLAYER (e.g. 2:petra)
  * -autostart-aidiff=PLAYER:DIFF   sets the DIFFiculty of PLAYER's AI
  *                                 (0: sandbox, 5: very hard)
  * -autostart-aiseed=AISEED        sets the seed used for the AI random
  *                                 generator (default 0, use -1 for random)
  * -autostart-player=NUMBER        sets the playerID in non-networked games (default 1, use -1 for observer)
  * -autostart-civ=PLAYER:CIV       sets PLAYER's civilisation to CIV
  *                                 (skirmish and random maps only)
  * -autostart-team=PLAYER:TEAM     sets the team for PLAYER (e.g. 2:2).
  * -autostart-ceasefire=NUM        sets a ceasefire duration NUM
  *                                 (default 0 minutes)
  * -autostart-nonvisual            disable any graphics and sounds
  * -autostart-victory=SCRIPTNAME   sets the victory conditions with SCRIPTNAME
  *                                 located in simulation/data/settings/victory_conditions/
  *                                 (default conquest). When the first given SCRIPTNAME is 
  *                                 "endless", no victory conditions will apply.
  * -autostart-wonderduration=NUM   sets the victory duration NUM for wonder victory condition
  *                                 (default 10 minutes)
  * -autostart-relicduration=NUM    sets the victory duration NUM for relic victory condition
  *                                 (default 10 minutes)
  * -autostart-reliccount=NUM       sets the number of relics for relic victory condition
  *                                 (default 2 relics)
  * -autostart-disable-replay       disable saving of replays
  *
  * Multiplayer:
  * -autostart-playername=NAME      sets local player NAME (default 'anonymous')
  * -autostart-host                 sets multiplayer host mode
  * -autostart-host-players=NUMBER  sets NUMBER of human players for multiplayer
  *                                 game (default 2)
  * -autostart-client=IP            sets multiplayer client to join host at
  *                                 given IP address
  * Random maps only:
  * -autostart-size=TILES           sets random map size in TILES (default 192)
  * -autostart-players=NUMBER       sets NUMBER of players on random map
  *                                 (default 2)
  *
  * Examples:
  * 1) "Bob" will host a 2 player game on the Arcadia map:
  * -autostart="scenarios/Arcadia" -autostart-host -autostart-host-players=2 -autostart-playername="Bob"
  *  "Alice" joins the match as player 2:
  * -autostart="scenarios/Arcadia" -autostart-client=127.0.0.1 -autostart-playername="Alice"
  * The players use the developer overlay to control players.
  *
  * 2) Load Alpine Lakes random map with random seed, 2 players (Athens and Britons), and player 2 is PetraBot:
  * -autostart="random/alpine_lakes" -autostart-seed=-1 -autostart-players=2 -autostart-civ=1:athen -autostart-civ=2:brit -autostart-ai=2:petra
  *
  * 3) Observe the PetraBot on a triggerscript map:
  * -autostart="random/jebel_barkal" -autostart-seed=-1 -autostart-players=2 -autostart-civ=1:athen -autostart-civ=2:brit -autostart-ai=1:petra -autostart-ai=2:petra -autostart-player=-1
  */
 bool Autostart(const CmdLineArgs& args)
 {
 	CStr autoStartName = args.Get("autostart");
 
 	if (autoStartName.empty())
 		return false;
 
 	g_Game = new CGame(!args.Has("autostart-disable-replay"));
 
 	ScriptInterface& scriptInterface = g_Game->GetSimulation2()->GetScriptInterface();
 	JSContext* cx = scriptInterface.GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedValue attrs(cx);
 	JS::RootedValue settings(cx);
 	JS::RootedValue playerData(cx);
 
 	ScriptInterface::CreateObject(cx, &attrs);
 	ScriptInterface::CreateObject(cx, &settings);
 	ScriptInterface::CreateArray(cx, &playerData);
 
 	// The directory in front of the actual map name indicates which type
 	// of map is being loaded. Drawback of this approach is the association
 	// of map types and folders is hard-coded, but benefits are:
 	// - No need to pass the map type via command line separately
 	// - Prevents mixing up of scenarios and skirmish maps to some degree
 	Path mapPath = Path(autoStartName);
 	std::wstring mapDirectory = mapPath.Parent().Filename().string();
 	std::string mapType;
 
 	if (mapDirectory == L"random")
 	{
 		// Random map definition will be loaded from JSON file, so we need to parse it
 		std::wstring scriptPath = L"maps/" + autoStartName.FromUTF8() + L".json";
 		JS::RootedValue scriptData(cx);
 		scriptInterface.ReadJSONFile(scriptPath, &scriptData);
 		if (!scriptData.isUndefined() && scriptInterface.GetProperty(scriptData, "settings", &settings))
 		{
 			// JSON loaded ok - copy script name over to game attributes
 			std::wstring scriptFile;
 			scriptInterface.GetProperty(settings, "Script", scriptFile);
 			scriptInterface.SetProperty(attrs, "script", scriptFile);				// RMS filename
 		}
 		else
 		{
 			// Problem with JSON file
 			LOGERROR("Autostart: Error reading random map script '%s'", utf8_from_wstring(scriptPath));
 			throw PSERROR_Game_World_MapLoadFailed("Error reading random map script.\nCheck application log for details.");
 		}
 
 		// Get optional map size argument (default 192)
 		uint mapSize = 192;
 		if (args.Has("autostart-size"))
 		{
 			CStr size = args.Get("autostart-size");
 			mapSize = size.ToUInt();
 		}
 
 		scriptInterface.SetProperty(settings, "Size", mapSize);		// Random map size (in patches)
 
 		// Get optional number of players (default 2)
 		size_t numPlayers = 2;
 		if (args.Has("autostart-players"))
 		{
 			CStr num = args.Get("autostart-players");
 			numPlayers = num.ToUInt();
 		}
 
 		// Set up player data
 		for (size_t i = 0; i < numPlayers; ++i)
 		{
 			JS::RootedValue player(cx);
 
 			// We could load player_defaults.json here, but that would complicate the logic
 			// even more and autostart is only intended for developers anyway
 			ScriptInterface::CreateObject(cx, &player, "Civ", "athen");
 
 			scriptInterface.SetPropertyInt(playerData, i, player);
 		}
 		mapType = "random";
 	}
 	else if (mapDirectory == L"scenarios" || mapDirectory == L"skirmishes")
 	{
 		// Initialize general settings from the map data so some values
 		// (e.g. name of map) are always present, even when autostart is
 		// partially configured
 		CStr8 mapSettingsJSON = LoadSettingsOfScenarioMap("maps/" + autoStartName + ".xml");
 		scriptInterface.ParseJSON(mapSettingsJSON, &settings);
 
 		// Initialize the playerData array being modified by autostart
 		// with the real map data, so sensible values are present:
 		scriptInterface.GetProperty(settings, "PlayerData", &playerData);
 
 		if (mapDirectory == L"scenarios")
 			mapType = "scenario";
 		else
 			mapType = "skirmish";
 	}
 	else
 	{
 		LOGERROR("Autostart: Unrecognized map type '%s'", utf8_from_wstring(mapDirectory));
 		throw PSERROR_Game_World_MapLoadFailed("Unrecognized map type.\nConsult readme.txt for the currently supported types.");
 	}
 
 	scriptInterface.SetProperty(attrs, "mapType", mapType);
 	scriptInterface.SetProperty(attrs, "map", "maps/" + autoStartName);
 	scriptInterface.SetProperty(settings, "mapType", mapType);
 	scriptInterface.SetProperty(settings, "CheatsEnabled", true);
 
 	// The seed is used for both random map generation and simulation
 	u32 seed = 0;
 	if (args.Has("autostart-seed"))
 	{
 		CStr seedArg = args.Get("autostart-seed");
 		if (seedArg == "-1")
 			seed = rand();
 		else
 			seed = seedArg.ToULong();
 	}
 	scriptInterface.SetProperty(settings, "Seed", seed);
 
 	// Set seed for AIs
 	u32 aiseed = 0;
 	if (args.Has("autostart-aiseed"))
 	{
 		CStr seedArg = args.Get("autostart-aiseed");
 		if (seedArg == "-1")
 			aiseed = rand();
 		else
 			aiseed = seedArg.ToULong();
 	}
 	scriptInterface.SetProperty(settings, "AISeed", aiseed);
 
 	// Set player data for AIs
 	//		attrs.settings = { PlayerData: [ { AI: ... }, ... ] }
 	//		            or = { PlayerData: [ null, { AI: ... }, ... ] } when gaia set
 	int offset = 1;
 	JS::RootedValue player(cx);
 	if (scriptInterface.GetPropertyInt(playerData, 0, &player) && player.isNull())
 		offset = 0;
 
 	// Set teams
 	if (args.Has("autostart-team"))
 	{
 		std::vector<CStr> civArgs = args.GetMultiple("autostart-team");
 		for (size_t i = 0; i < civArgs.size(); ++i)
 		{
 			int playerID = civArgs[i].BeforeFirst(":").ToInt();
 
 			// Instead of overwriting existing player data, modify the array
 			JS::RootedValue player(cx);
 			if (!scriptInterface.GetPropertyInt(playerData, playerID-offset, &player) || player.isUndefined())
 			{
 				if (mapDirectory == L"skirmishes")
 				{
 					// playerID is certainly bigger than this map player number
 					LOGWARNING("Autostart: Invalid player %d in autostart-team option", playerID);
 					continue;
 				}
 				ScriptInterface::CreateObject(cx, &player);
 			}
 
 			int teamID = civArgs[i].AfterFirst(":").ToInt() - 1;
 			scriptInterface.SetProperty(player, "Team", teamID);
 			scriptInterface.SetPropertyInt(playerData, playerID-offset, player);
 		}
 	}
 
 	int ceasefire = 0;
 	if (args.Has("autostart-ceasefire"))
 		ceasefire = args.Get("autostart-ceasefire").ToInt();
 	scriptInterface.SetProperty(settings, "Ceasefire", ceasefire);
 
 	if (args.Has("autostart-ai"))
 	{
 		std::vector<CStr> aiArgs = args.GetMultiple("autostart-ai");
 		for (size_t i = 0; i < aiArgs.size(); ++i)
 		{
 			int playerID = aiArgs[i].BeforeFirst(":").ToInt();
 
 			// Instead of overwriting existing player data, modify the array
 			JS::RootedValue player(cx);
 			if (!scriptInterface.GetPropertyInt(playerData, playerID-offset, &player) || player.isUndefined())
 			{
 				if (mapDirectory == L"scenarios" || mapDirectory == L"skirmishes")
 				{
 					// playerID is certainly bigger than this map player number
 					LOGWARNING("Autostart: Invalid player %d in autostart-ai option", playerID);
 					continue;
 				}
 				ScriptInterface::CreateObject(cx, &player);
 			}
 
 			scriptInterface.SetProperty(player, "AI", aiArgs[i].AfterFirst(":"));
 			scriptInterface.SetProperty(player, "AIDiff", 3);
 			scriptInterface.SetProperty(player, "AIBehavior", "balanced");
 			scriptInterface.SetPropertyInt(playerData, playerID-offset, player);
 		}
 	}
 	// Set AI difficulty
 	if (args.Has("autostart-aidiff"))
 	{
 		std::vector<CStr> civArgs = args.GetMultiple("autostart-aidiff");
 		for (size_t i = 0; i < civArgs.size(); ++i)
 		{
 			int playerID = civArgs[i].BeforeFirst(":").ToInt();
 
 			// Instead of overwriting existing player data, modify the array
 			JS::RootedValue player(cx);
 			if (!scriptInterface.GetPropertyInt(playerData, playerID-offset, &player) || player.isUndefined())
 			{
 				if (mapDirectory == L"scenarios" || mapDirectory == L"skirmishes")
 				{
 					// playerID is certainly bigger than this map player number
 					LOGWARNING("Autostart: Invalid player %d in autostart-aidiff option", playerID);
 					continue;
 				}
 				ScriptInterface::CreateObject(cx, &player);
 			}
 
 			scriptInterface.SetProperty(player, "AIDiff", civArgs[i].AfterFirst(":").ToInt());
 			scriptInterface.SetPropertyInt(playerData, playerID-offset, player);
 		}
 	}
 	// Set player data for Civs
 	if (args.Has("autostart-civ"))
 	{
 		if (mapDirectory != L"scenarios")
 		{
 			std::vector<CStr> civArgs = args.GetMultiple("autostart-civ");
 			for (size_t i = 0; i < civArgs.size(); ++i)
 			{
 				int playerID = civArgs[i].BeforeFirst(":").ToInt();
 
 				// Instead of overwriting existing player data, modify the array
 				JS::RootedValue player(cx);
 				if (!scriptInterface.GetPropertyInt(playerData, playerID-offset, &player) || player.isUndefined())
 				{
 					if (mapDirectory == L"skirmishes")
 					{
 						// playerID is certainly bigger than this map player number
 						LOGWARNING("Autostart: Invalid player %d in autostart-civ option", playerID);
 						continue;
 					}
 					ScriptInterface::CreateObject(cx, &player);
 				}
 
 				scriptInterface.SetProperty(player, "Civ", civArgs[i].AfterFirst(":"));
 				scriptInterface.SetPropertyInt(playerData, playerID-offset, player);
 			}
 		}
 		else
 			LOGWARNING("Autostart: Option 'autostart-civ' is invalid for scenarios");
 	}
 
 	// Add player data to map settings
 	scriptInterface.SetProperty(settings, "PlayerData", playerData);
 
 	// Add map settings to game attributes
 	scriptInterface.SetProperty(attrs, "settings", settings);
 
 	// Get optional playername
 	CStrW userName = L"anonymous";
 	if (args.Has("autostart-playername"))
 		userName = args.Get("autostart-playername").FromUTF8();
 
 	// Add additional scripts to the TriggerScripts property
 	std::vector<CStrW> triggerScriptsVector;
 	JS::RootedValue triggerScripts(cx);
 
 	if (scriptInterface.HasProperty(settings, "TriggerScripts"))
 	{
 		scriptInterface.GetProperty(settings, "TriggerScripts", &triggerScripts);
 		FromJSVal_vector(cx, triggerScripts, triggerScriptsVector);
 	}
 
 	if (!CRenderer::IsInitialised())
 	{
 		CStr nonVisualScript = "scripts/NonVisualTrigger.js";
 		triggerScriptsVector.push_back(nonVisualScript.FromUTF8());
 	}
 
 	std::vector<CStr> victoryConditions(1, "conquest");
 	if (args.Has("autostart-victory"))
 		victoryConditions = args.GetMultiple("autostart-victory");
 
 	if (victoryConditions.size() == 1 && victoryConditions[0] == "endless")
 		victoryConditions.clear();
 
 	scriptInterface.SetProperty(settings, "VictoryConditions", victoryConditions);
 
 	for (const CStr& victory : victoryConditions)
 	{
 		JS::RootedValue scriptData(cx);
 		JS::RootedValue data(cx);
 		JS::RootedValue victoryScripts(cx);
 
 		CStrW scriptPath = L"simulation/data/settings/victory_conditions/" + victory.FromUTF8() + L".json";
 		scriptInterface.ReadJSONFile(scriptPath, &scriptData);
 		if (!scriptData.isUndefined() && scriptInterface.GetProperty(scriptData, "Data", &data) && !data.isUndefined()
 			&& scriptInterface.GetProperty(data, "Scripts", &victoryScripts) && !victoryScripts.isUndefined())
 		{
 			std::vector<CStrW> victoryScriptsVector;
 			FromJSVal_vector(cx, victoryScripts, victoryScriptsVector);
 			triggerScriptsVector.insert(triggerScriptsVector.end(), victoryScriptsVector.begin(), victoryScriptsVector.end());
 		}
 		else
 		{
 			LOGERROR("Autostart: Error reading victory script '%s'", utf8_from_wstring(scriptPath));
 			throw PSERROR_Game_World_MapLoadFailed("Error reading victory script.\nCheck application log for details.");
 		}
 	}
 
 	ToJSVal_vector(cx, &triggerScripts, triggerScriptsVector);
 	scriptInterface.SetProperty(settings, "TriggerScripts", triggerScripts);
 
 	int wonderDuration = 10;
 	if (args.Has("autostart-wonderduration"))
 		wonderDuration = args.Get("autostart-wonderduration").ToInt();
 	scriptInterface.SetProperty(settings, "WonderDuration", wonderDuration);
 
 	int relicDuration = 10;
 	if (args.Has("autostart-relicduration"))
 		relicDuration = args.Get("autostart-relicduration").ToInt();
 	scriptInterface.SetProperty(settings, "RelicDuration", relicDuration);
 
 	int relicCount = 2;
 	if (args.Has("autostart-reliccount"))
 		relicCount = args.Get("autostart-reliccount").ToInt();
 	scriptInterface.SetProperty(settings, "RelicCount", relicCount);
 
 	if (args.Has("autostart-host"))
 	{
 		InitPsAutostart(true, attrs);
 
 		size_t maxPlayers = 2;
 		if (args.Has("autostart-host-players"))
 			maxPlayers = args.Get("autostart-host-players").ToUInt();
 
 		g_NetServer = new CNetServer(false, maxPlayers);
 
 		g_NetServer->UpdateGameAttributes(&attrs, scriptInterface);
 
 		bool ok = g_NetServer->SetupConnection(PS_DEFAULT_PORT);
 		ENSURE(ok);
 
 		g_NetClient = new CNetClient(g_Game, true);
 		g_NetClient->SetUserName(userName);
 		g_NetClient->SetupConnection("127.0.0.1", PS_DEFAULT_PORT, nullptr);
 	}
 	else if (args.Has("autostart-client"))
 	{
 		InitPsAutostart(true, attrs);
 
 		g_NetClient = new CNetClient(g_Game, false);
 		g_NetClient->SetUserName(userName);
 
 		CStr ip = args.Get("autostart-client");
 		if (ip.empty())
 			ip = "127.0.0.1";
 
 		bool ok = g_NetClient->SetupConnection(ip, PS_DEFAULT_PORT, nullptr);
 		ENSURE(ok);
 	}
 	else
 	{
 		g_Game->SetPlayerID(args.Has("autostart-player") ? args.Get("autostart-player").ToInt() : 1);
 
 		g_Game->StartGame(&attrs, "");
 
 		if (CRenderer::IsInitialised())
 		{
 			InitPsAutostart(false, attrs);
 		}
 		else
 		{
 			// TODO: Non progressive load can fail - need a decent way to handle this
 			LDR_NonprogressiveLoad();
 			ENSURE(g_Game->ReallyStartGame() == PSRETURN_OK);
 		}
 	}
 
 	return true;
 }
 
 bool AutostartVisualReplay(const std::string& replayFile)
 {
 	if (!FileExists(OsPath(replayFile)))
 		return false;
 
 	g_Game = new CGame(false);
 	g_Game->SetPlayerID(-1);
 	g_Game->StartVisualReplay(replayFile);
 
 	ScriptInterface& scriptInterface = g_Game->GetSimulation2()->GetScriptInterface();
 	JSContext* cx = scriptInterface.GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedValue attrs(cx, g_Game->GetSimulation2()->GetInitAttributes());
 
 	InitPsAutostart(false, attrs);
 
 	return true;
 }
 
 void CancelLoad(const CStrW& message)
 {
 	shared_ptr<ScriptInterface> pScriptInterface = g_GUI->GetActiveGUI()->GetScriptInterface();
 	JSContext* cx = pScriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedValue global(cx, pScriptInterface->GetGlobalObject());
 
 	LDR_Cancel();
 
 	if (g_GUI &&
 	    g_GUI->GetPageCount() &&
 	    pScriptInterface->HasProperty(global, "cancelOnLoadGameError"))
 		pScriptInterface->CallFunctionVoid(global, "cancelOnLoadGameError", message);
 }
 
 bool InDevelopmentCopy()
 {
 	if (!g_CheckedIfInDevelopmentCopy)
 	{
 		g_InDevelopmentCopy = (g_VFS->GetFileInfo(L"config/dev.cfg", NULL) == INFO::OK);
 		g_CheckedIfInDevelopmentCopy = true;
 	}
 	return g_InDevelopmentCopy;
 }
Index: ps/trunk/source/ps/GameSetup/GameSetup.h
===================================================================
--- ps/trunk/source/ps/GameSetup/GameSetup.h	(revision 22908)
+++ ps/trunk/source/ps/GameSetup/GameSetup.h	(revision 22909)
@@ -1,103 +1,103 @@
 /* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef INCLUDED_GAMESETUP
 #define INCLUDED_GAMESETUP
 
 //
 // GUI integration
 //
 
 // display progress / description in loading screen
 extern void GUI_DisplayLoadProgress(int percent, const wchar_t* pending_task);
 
 extern void Render();
 
 extern bool ShouldRender();
 
 /**
  * initialize global modules that are be needed before Init.
  * must be called from the very beginning of main.
  **/
 extern void EarlyInit();
 
 enum InitFlags
 {
 	// avoid setting a video mode / initializing OpenGL; assume that has
 	// already been done and everything is ready for rendering.
 	// needed by map editor because it creates its own window.
 	INIT_HAVE_VMODE = 1,
 
 	// skip initializing the in-game GUI.
 	// needed by map editor because it uses its own GUI.
 	INIT_NO_GUI = 2,
 
 	// avoid setting display_error app hook
 	// needed by map editor because it has its own wx error display
 	INIT_HAVE_DISPLAY_ERROR = 4,
 
 	// initialize the mod folders from command line parameters
 	INIT_MODS = 8,
 
 	// mount the public mod
 	// needed by the map editor as "mod" does not provide everything it needs
 	INIT_MODS_PUBLIC = 16
 };
 
 enum ShutdownFlags
 {
 	// start shutdown from config down
 	// needed for loading mods as specified in the config
 	// without having to go through a full init-shutdown cycle
 	SHUTDOWN_FROM_CONFIG = 1
 };
 
 /**
  * enable/disable rendering of the GUI (intended mainly for screenshots)
  */
 extern void RenderGui(bool RenderingState);
 extern void RenderLogger(bool RenderingState);
 
 /**
  * enable/disable rendering of the cursor - this does not hide cursor, but reverts to OS style
  */
 extern void RenderCursor(bool RenderingState);
 
 
 class CmdLineArgs;
 class Paths;
 extern const std::vector<CStr>& GetMods(const CmdLineArgs& args, int flags);
 
 /**
  * Mounts all files of the given mods in the global VFS.
  * Make sure to call CacheEnabledModVersions after every call to this.
  */
 extern void MountMods(const Paths& paths, const std::vector<CStr>& mods);
 /**
  * Returns true if successful, false if mods changed and restart_engine was called.
  * In the latter case the caller should call Shutdown() with SHUTDOWN_FROM_CONFIG.
  */
 extern bool Init(const CmdLineArgs& args, int flags);
-extern void InitGraphics(const CmdLineArgs& args, int flags,
-	const std::vector<CStr>& installedMods = std::vector<CStr>());
+extern void InitInput();
+extern void InitGraphics(const CmdLineArgs& args, int flags, const std::vector<CStr>& installedMods = std::vector<CStr>());
 extern void InitNonVisual(const CmdLineArgs& args);
 extern void Shutdown(int flags);
 extern void CancelLoad(const CStrW& message);
 
 extern bool InDevelopmentCopy();
 
 #endif // INCLUDED_GAMESETUP
Index: ps/trunk/source/ps/Hotkey.cpp
===================================================================
--- ps/trunk/source/ps/Hotkey.cpp	(revision 22908)
+++ ps/trunk/source/ps/Hotkey.cpp	(revision 22909)
@@ -1,348 +1,350 @@
-/* Copyright (C) 2017 Wildfire Games.
+/* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 #include "Hotkey.h"
 
 #include <boost/tokenizer.hpp>
 
 #include "ps/CConsole.h"
 #include "ps/CLogger.h"
 #include "ps/CStr.h"
 #include "ps/ConfigDB.h"
 #include "ps/Globals.h"
 #include "ps/KeyName.h"
 
 static bool unified[UNIFIED_LAST - UNIFIED_SHIFT];
 
 struct SKey
 {
 	SDL_Keycode code; // keycode or MOUSE_ or UNIFIED_ value
 	bool negated; // whether the key must be pressed (false) or unpressed (true)
 };
 
 // Hotkey data associated with an externally-specified 'primary' keycode
 struct SHotkeyMapping
 {
 	CStr name; // name of the hotkey
 	bool negated; // whether the primary key must be pressed (false) or unpressed (true)
 	std::vector<SKey> requires; // list of non-primary keys that must also be active
 };
 
 typedef std::vector<SHotkeyMapping> KeyMapping;
 
 // A mapping of keycodes onto the hotkeys that are associated with that key.
 // (A hotkey triggered by a combination of multiple keys will be in this map
 // multiple times.)
 static std::map<int, KeyMapping> g_HotkeyMap;
 
 // The current pressed status of hotkeys
 std::map<std::string, bool> g_HotkeyStatus;
 
 // Look up each key binding in the config file and set the mappings for
 // all key combinations that trigger it.
 static void LoadConfigBindings()
 {
 	for (const std::pair<CStr, CConfigValueSet>& configPair : g_ConfigDB.GetValuesWithPrefix(CFG_COMMAND, "hotkey."))
 	{
 		std::string hotkeyName = configPair.first.substr(7); // strip the "hotkey." prefix
 		for (const CStr& hotkey : configPair.second)
 		{
 			if (hotkey.LowerCase() == "unused")
 				continue;
 
 			std::vector<SKey> keyCombination;
 
 			// Iterate through multiple-key bindings (e.g. Ctrl+I)
 			boost::char_separator<char> sep("+");
 			typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
 			tokenizer tok(hotkey, sep);
 			for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it)
 			{
 				// Attempt decode as key name
 				int mapping = FindKeyCode(*it);
 				if (!mapping)
 					mapping = SDL_GetKeyFromName(it->c_str());
 				if (!mapping)
 				{
 					LOGWARNING("Hotkey mapping used invalid key '%s'", hotkey.c_str());
 					continue;
 				}
 
 				SKey key = { (SDL_Keycode)mapping, false };
 				keyCombination.push_back(key);
 			}
 
 			std::vector<SKey>::iterator itKey, itKey2;
 			for (itKey = keyCombination.begin(); itKey != keyCombination.end(); ++itKey)
 			{
 				SHotkeyMapping bindCode;
 
 				bindCode.name = hotkeyName;
 				bindCode.negated = itKey->negated;
 
 				for (itKey2 = keyCombination.begin(); itKey2 != keyCombination.end(); ++itKey2)
 					if (itKey != itKey2) // Push any auxiliary keys
 						bindCode.requires.push_back(*itKey2);
 
 				g_HotkeyMap[itKey->code].push_back(bindCode);
 			}
 		}
 	}
 }
 
 void LoadHotkeys()
 {
 	InitKeyNameMap();
 
 	LoadConfigBindings();
 
 	// Set up the state of the hotkeys given no key is down.
 	// i.e. find those hotkeys triggered by all negations.
 
 	for (const std::pair<int, KeyMapping>& p : g_HotkeyMap)
 		for (const SHotkeyMapping& hotkey : p.second)
 		{
 			if (!hotkey.negated)
 				continue;
 
 			bool allNegated = true;
 
 			for (const SKey& k : hotkey.requires)
 				if (!k.negated)
 					allNegated = false;
 
 			if (allNegated)
 				g_HotkeyStatus[hotkey.name] = true;
 		}
 }
 
 void UnloadHotkeys()
 {
 	g_HotkeyMap.clear();
 	g_HotkeyStatus.clear();
 }
 
 bool isNegated(const SKey& key)
 {
 	// Normal keycodes are below EXTRA_KEYS_BASE
 	if ((int)key.code < EXTRA_KEYS_BASE && g_keys[key.code] == key.negated)
 		return false;
 	// Mouse 'keycodes' are after the modifier keys
 	else if ((int)key.code < MOUSE_LAST && (int)key.code > MOUSE_BASE && g_mouse_buttons[key.code - MOUSE_BASE] == key.negated)
 		return false;
 	// Modifier keycodes are between the normal keys and the mouse 'keys'
 	else if ((int)key.code < UNIFIED_LAST && (int)key.code > SDL_SCANCODE_TO_KEYCODE(SDL_NUM_SCANCODES) && unified[key.code - UNIFIED_SHIFT] == key.negated)
 		return false;
 	else
 		return true;
 }
 
+InReaction HotkeyStateChange(const SDL_Event_* ev)
+{
+	if (ev->ev.type == SDL_HOTKEYDOWN)
+		g_HotkeyStatus[static_cast<const char*>(ev->ev.user.data1)] = true;
+	else if (ev->ev.type == SDL_HOTKEYUP)
+		g_HotkeyStatus[static_cast<const char*>(ev->ev.user.data1)] = false;
+	return IN_PASS;
+}
+
 InReaction HotkeyInputHandler(const SDL_Event_* ev)
 {
 	int keycode = 0;
 
 	switch(ev->ev.type)
 	{
 	case SDL_KEYDOWN:
 	case SDL_KEYUP:
 		keycode = (int)ev->ev.key.keysym.sym;
 		break;
 
 	case SDL_MOUSEBUTTONDOWN:
 	case SDL_MOUSEBUTTONUP:
 		// Mousewheel events are no longer buttons, but we want to maintain the order
 		// expected by g_mouse_buttons for compatibility
 		if (ev->ev.button.button >= SDL_BUTTON_X1)
 			keycode = MOUSE_BASE + (int)ev->ev.button.button + 2;
 		else
 		keycode = MOUSE_BASE + (int)ev->ev.button.button;
 		break;
 
 	case SDL_MOUSEWHEEL:
 		if (ev->ev.wheel.y > 0)
 		{
 			keycode = MOUSE_WHEELUP;
 			break;
 		}
 		else if (ev->ev.wheel.y < 0)
 		{
 			keycode = MOUSE_WHEELDOWN;
 			break;
 		}
 		else if (ev->ev.wheel.x > 0)
 		{
 			keycode = MOUSE_X2;
 			break;
 		}
 		else if (ev->ev.wheel.x < 0)
 		{
 			keycode = MOUSE_X1;
 			break;
 		}
 		return IN_PASS;
 
-	case SDL_HOTKEYDOWN:
-		g_HotkeyStatus[static_cast<const char*>(ev->ev.user.data1)] = true;
-		return IN_PASS;
-
-	case SDL_HOTKEYUP:
-		g_HotkeyStatus[static_cast<const char*>(ev->ev.user.data1)] = false;
-		return IN_PASS;
 
 	default:
 		return IN_PASS;
 	}
 
 	// Somewhat hackish:
 	// Create phantom 'unified-modifier' events when left- or right- modifier keys are pressed
 	// Just send them to this handler; don't let the imaginary event codes leak back to real SDL.
 
 	SDL_Event_ phantom;
 	phantom.ev.type = ((ev->ev.type == SDL_KEYDOWN) || (ev->ev.type == SDL_MOUSEBUTTONDOWN)) ? SDL_KEYDOWN : SDL_KEYUP;
 	if ((keycode == SDLK_LSHIFT) || (keycode == SDLK_RSHIFT))
 	{
 		phantom.ev.key.keysym.sym = (SDL_Keycode)UNIFIED_SHIFT;
 		unified[0] = (phantom.ev.type == SDL_KEYDOWN);
 		HotkeyInputHandler(&phantom);
 	}
 	else if ((keycode == SDLK_LCTRL) || (keycode == SDLK_RCTRL))
 	{
 		phantom.ev.key.keysym.sym = (SDL_Keycode)UNIFIED_CTRL;
 		unified[1] = (phantom.ev.type == SDL_KEYDOWN);
 		HotkeyInputHandler(&phantom);
 	}
 	else if ((keycode == SDLK_LALT) || (keycode == SDLK_RALT))
 	{
 		phantom.ev.key.keysym.sym = (SDL_Keycode)UNIFIED_ALT;
 		unified[2] = (phantom.ev.type == SDL_KEYDOWN);
 		HotkeyInputHandler(&phantom);
 	}
 	else if ((keycode == SDLK_LGUI) || (keycode == SDLK_RGUI))
 	{
 		phantom.ev.key.keysym.sym = (SDL_Keycode)UNIFIED_SUPER;
 		unified[3] = (phantom.ev.type == SDL_KEYDOWN);
 		HotkeyInputHandler(&phantom);
 	}
 
 	// Check whether we have any hotkeys registered for this particular keycode
 	if (g_HotkeyMap.find(keycode) == g_HotkeyMap.end())
 		return (IN_PASS);
 
 	// Inhibit the dispatch of hotkey events caused by real keys (not fake mouse button
 	// events) while the console is up.
 
 	bool consoleCapture = false;
 
-	if (g_Console->IsActive() && keycode < SDL_SCANCODE_TO_KEYCODE(SDL_NUM_SCANCODES))
+	if (g_Console && g_Console->IsActive() && keycode < SDL_SCANCODE_TO_KEYCODE(SDL_NUM_SCANCODES))
 		consoleCapture = true;
 
 	// Here's an interesting bit:
 	// If you have an event bound to, say, 'F', and another to, say, 'Ctrl+F', pressing
 	// 'F' while control is down would normally fire off both.
 
 	// To avoid this, set the modifier keys for /all/ events this key would trigger
 	// (Ctrl, for example, is both group-save and bookmark-save)
 	// but only send a HotkeyDown event for the event with bindings most precisely
 	// matching the conditions (i.e. the event with the highest number of auxiliary
 	// keys, providing they're all down)
 
 	bool typeKeyDown = ( ev->ev.type == SDL_KEYDOWN ) || ( ev->ev.type == SDL_MOUSEBUTTONDOWN ) || (ev->ev.type == SDL_MOUSEWHEEL);
 
 	// -- KEYDOWN SECTION --
 
 	std::vector<const char*> closestMapNames;
 	size_t closestMapMatch = 0;
 
 	for (const SHotkeyMapping& hotkey : g_HotkeyMap[keycode])
 	{
 		// If a key has been pressed, and this event triggers on its release, skip it.
 		// Similarly, if the key's been released and the event triggers on a keypress, skip it.
 		if (hotkey.negated == typeKeyDown)
 			continue;
 
 		// Check for no unpermitted keys
 		bool accept = true;
 		for (const SKey& k : hotkey.requires)
 		{
 			accept = isNegated(k);
 			if (!accept)
 				break;
 		}
 
 		if (accept && !(consoleCapture && hotkey.name != "console.toggle"))
 		{
 			// Check if this is an equally precise or more precise match
 			if (hotkey.requires.size() + 1 >= closestMapMatch)
 			{
 				// Check if more precise
 				if (hotkey.requires.size() + 1 > closestMapMatch)
 				{
 					// Throw away the old less-precise matches
 					closestMapNames.clear();
 					closestMapMatch = hotkey.requires.size() + 1;
 				}
 
 				closestMapNames.push_back(hotkey.name.c_str());
 			}
 		}
 	}
 
 	for (size_t i = 0; i < closestMapNames.size(); ++i)
 	{
 		SDL_Event_ hotkeyNotification;
 		hotkeyNotification.ev.type = SDL_HOTKEYDOWN;
 		hotkeyNotification.ev.user.data1 = const_cast<char*>(closestMapNames[i]);
 		in_push_priority_event(&hotkeyNotification);
 	}
 
 	// -- KEYUP SECTION --
 
 	for (const SHotkeyMapping& hotkey : g_HotkeyMap[keycode])
 	{
 		// If it's a keydown event, won't cause HotKeyUps in anything that doesn't
 		// use this key negated => skip them
 		// If it's a keyup event, won't cause HotKeyUps in anything that does use
 		// this key negated => skip them too.
 		if (hotkey.negated != typeKeyDown)
 			continue;
 
 		// Check for no unpermitted keys
 		bool accept = true;
 		for (const SKey& k : hotkey.requires)
 		{
 			accept = isNegated(k);
 			if (!accept)
 				break;
 		}
 
 		if (accept)
 		{
 			SDL_Event_ hotkeyNotification;
 			hotkeyNotification.ev.type = SDL_HOTKEYUP;
 			hotkeyNotification.ev.user.data1 = const_cast<char*>(hotkey.name.c_str());
 			in_push_priority_event(&hotkeyNotification);
 		}
 	}
 
 	return IN_PASS;
 }
 
 bool HotkeyIsPressed(const CStr& keyname)
 {
 	return g_HotkeyStatus[keyname];
 }
Index: ps/trunk/source/ps/Hotkey.h
===================================================================
--- ps/trunk/source/ps/Hotkey.h	(revision 22908)
+++ ps/trunk/source/ps/Hotkey.h	(revision 22909)
@@ -1,50 +1,52 @@
-/* Copyright (C) 2014 Wildfire Games.
+/* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef INCLUDED_HOTKEY
 #define INCLUDED_HOTKEY
 
 /**
  * @file
  * Hotkey system.
  *
  * Hotkeys consist of a name (an arbitrary string), and a key mapping.
  * The names and mappings are loaded from the config system (any
  * config setting with the name prefix "hotkey.").
  * When a hotkey is pressed or released, SDL_HOTKEYDOWN and SDL_HOTKEYUP
  * events are triggered, with the hotkey name stored in ev.user.data1
  * as a const char*.
  */
 
 #include "CStr.h"
 #include "lib/input.h"
 #include "lib/external_libraries/libsdl.h"	// see note below
 
 // note: we need the real SDL header - it defines SDL_USEREVENT, which is
 // required for our HOTKEY event type definition. this is OK since
 // hotkey.h is not included from any headers.
 
 const int SDL_HOTKEYDOWN = SDL_USEREVENT;
 const int SDL_HOTKEYUP = SDL_USEREVENT + 1;
 
 extern void LoadHotkeys();
 extern void UnloadHotkeys();
+
+extern InReaction HotkeyStateChange(const SDL_Event_* ev);
 extern InReaction HotkeyInputHandler(const SDL_Event_* ev);
 
 extern bool HotkeyIsPressed(const CStr& keyname);
 
 #endif // INCLUDED_HOTKEY