Index: ps/trunk/source/ps/Profile.cpp
===================================================================
--- ps/trunk/source/ps/Profile.cpp	(revision 5179)
+++ ps/trunk/source/ps/Profile.cpp	(revision 5180)
@@ -1,511 +1,554 @@
 /**
  * =========================================================================
  * File        : Profile.cpp
  * Project     : Pyrogeneses
  * Description : GPG3-style hierarchical profiler
  * =========================================================================
  */
 
 #include "precompiled.h"
 
 #include "Profile.h"
 #include "ProfileViewer.h"
 #include "lib/timer.h"
 
+#if GCC_VERSION && !defined(NDEBUG)
+# define GLIBC_MALLOC_HOOK
+# include <malloc.h>
+# include "ThreadUtil.h"
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////////////////////
 // CProfileNodeTable
 
 
 
 /**
  * Class CProfileNodeTable: Implement ProfileViewer's AbstractProfileTable
  * interface in order to display profiling data in-game.
  */
 class CProfileNodeTable : public AbstractProfileTable
 {
 public:
 	CProfileNodeTable(CProfileNode* n);
 	virtual ~CProfileNodeTable();
 
 	// Implementation of AbstractProfileTable interface
 	virtual CStr GetName();
 	virtual CStr GetTitle();
 	virtual size_t GetNumberRows();
 	virtual const std::vector<ProfileColumn>& GetColumns();
 	
 	virtual CStr GetCellText(size_t row, size_t col);
 	virtual AbstractProfileTable* GetChild(size_t row);
 	virtual bool IsHighlightRow(size_t row);
 	
 private:
 	/**
 	 * struct ColumnDescription: The only purpose of this helper structure
 	 * is to provide the global constructor that sets up the column
 	 * description.
 	 */
 	struct ColumnDescription
 	{
 		std::vector<ProfileColumn> columns;
 		
 		ColumnDescription()
 		{
 			columns.push_back(ProfileColumn("Name", 230));
 			columns.push_back(ProfileColumn("calls/frame", 100));
 			columns.push_back(ProfileColumn("msec/frame", 100));
 			columns.push_back(ProfileColumn("%/frame", 100));
 			columns.push_back(ProfileColumn("%/parent", 100));
 			columns.push_back(ProfileColumn("mem allocs", 100));
 		}
 	};
 	
 	/// The node represented by this table
 	CProfileNode* node;
 	
 	/// Columns description (shared by all instances)
 	static ColumnDescription columnDescription;
 };
 
 CProfileNodeTable::ColumnDescription CProfileNodeTable::columnDescription;
 
 
 // Constructor/Destructor
 CProfileNodeTable::CProfileNodeTable(CProfileNode* n)
 {
 	node = n;
 }
 
 CProfileNodeTable::~CProfileNodeTable()
 {
 }
 
 // Short name (= name of profile node)
 CStr CProfileNodeTable::GetName()
 {
 	return node->GetName();
 }
 
 // Title (= explanatory text plus time totals)
 CStr CProfileNodeTable::GetTitle()
 {
 	char buf[512];
 	
 	snprintf(buf, sizeof(buf), "Profiling Information for: %s (Time in node: %.3f msec/frame)", node->GetName(), node->GetFrameTime() * 1000.0f );
 	buf[sizeof(buf)-1] = '\0';
 	
 	return buf;
 }
 
 // Total number of children
 size_t CProfileNodeTable::GetNumberRows()
 {
 	return node->GetChildren()->size() + node->GetScriptChildren()->size() + 1;
 }
 
 // Column description
 const std::vector<ProfileColumn>& CProfileNodeTable::GetColumns()
 {
 	return columnDescription.columns;
 }
 
 // Retrieve cell text
 CStr CProfileNodeTable::GetCellText(size_t row, size_t col)
 {
 	CProfileNode* child;
 	size_t nrchildren = node->GetChildren()->size();
 	size_t nrscriptchildren = node->GetScriptChildren()->size();
 	char buf[256] = "?";
 	
 	if (row < nrchildren)
 		child = (*node->GetChildren())[row];
 	else if (row < nrchildren + nrscriptchildren)
 		child = (*node->GetScriptChildren())[row - nrchildren];
 	else if (row > nrchildren + nrscriptchildren)
 		return "!bad row!";
 	else
 	{
 		// "unlogged" row
 		if (col == 0)
 			return "unlogged";
 		else if (col == 1)
 			return "";
 		
 		float unlogged = node->GetFrameTime();
 		long unlogged_mallocs = node->GetFrameMallocs();
 		CProfileNode::const_profile_iterator it;
 
 		for (it = node->GetChildren()->begin(); it != node->GetChildren()->end(); ++it)
 		{
 			unlogged -= (*it)->GetFrameTime();
 			unlogged_mallocs -= (*it)->GetFrameMallocs();
 		}
 		for (it = node->GetScriptChildren()->begin(); it != node->GetScriptChildren()->end(); ++it)
 		{
 			unlogged -= (*it)->GetFrameTime();
 			unlogged_mallocs -= (*it)->GetFrameMallocs();
 		}
 		
 		if (col == 2)
 			snprintf(buf, sizeof(buf), "%.3f", unlogged * 1000.0f);
 		else if (col == 3)
 			snprintf(buf, sizeof(buf), "%.1f", unlogged / g_Profiler.GetRoot()->GetFrameTime());
 		else if (col == 4)
 			snprintf(buf, sizeof(buf), "%.1f", unlogged * 100.0f / g_Profiler.GetRoot()->GetFrameTime());
 		else if (col == 5)
 			snprintf(buf, sizeof(buf), "%ld", unlogged_mallocs);
 		buf[sizeof(buf)-1] = '\0';
 		
 		return CStr(buf);
 	}
 	
 	switch(col)
 	{
 	default:
 	case 0:
 		return child->GetName();
 		
 	case 1:
 #ifdef PROFILE_AMORTIZE
 		snprintf(buf, sizeof(buf), "%.3f", child->GetFrameCalls());
 #else
 		snprintf(buf, sizeof(buf), "%d", child->GetFrameCalls());
 #endif
 		break;
 	case 2:
 		snprintf(buf, sizeof(buf), "%.3f", child->GetFrameTime() * 1000.0f);
 		break;
 	case 3:
 		snprintf(buf, sizeof(buf), "%.1f", child->GetFrameTime() * 100.0 / g_Profiler.GetRoot()->GetFrameTime());
 		break;
 	case 4:
 		snprintf(buf, sizeof(buf), "%.1f", child->GetFrameTime() * 100.0 / node->GetFrameTime());
 		break;
 	case 5:
 		snprintf(buf, sizeof(buf), "%ld", child->GetFrameMallocs());
 		break;
 	}
 	buf[sizeof(buf)-1] = '\0';
 	return CStr(buf);
 }
 
 // Return a pointer to the child table if the child node is expandable
 AbstractProfileTable* CProfileNodeTable::GetChild(size_t row)
 {
 	CProfileNode* child;
 	size_t nrchildren = node->GetChildren()->size();
 	size_t nrscriptchildren = node->GetScriptChildren()->size();
 	
 	if (row < nrchildren)
 		child = (*node->GetChildren())[row];
 	else if (row < nrchildren + nrscriptchildren)
 		child = (*node->GetScriptChildren())[row - nrchildren];
 	else
 		return 0;
 	
 	if (child->CanExpand())
 		return child->display_table;
 	
 	return 0;
 }
 
 // Highlight all script nodes
 bool CProfileNodeTable::IsHighlightRow(size_t row)
 {
 	size_t nrchildren = node->GetChildren()->size();
 	size_t nrscriptchildren = node->GetScriptChildren()->size();
 	
 	return (row >= nrchildren && row < (nrchildren + nrscriptchildren));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 // CProfileNode implementation
 
 
 // Note: As with the GPG profiler, name is assumed to be a pointer to a constant string; only pointer equality is checked.
 CProfileNode::CProfileNode( const char* _name, CProfileNode* _parent )
 {
 	name = _name;
 	recursion = 0;
 
 	Reset();
 
 	parent = _parent;
 
 	display_table = new CProfileNodeTable(this);
 
 	Reset();
 }
 
 CProfileNode::~CProfileNode()
 {
 	profile_iterator it;
 	for( it = children.begin(); it != children.end(); it++ )
 		delete( *it );	
 	for( it = script_children.begin(); it != script_children.end(); it++ )
 		delete( *it );
 	
 	delete display_table;
 }
 
 const CProfileNode* CProfileNode::GetChild( const char* childName ) const
 {
 	const_profile_iterator it;
 	for( it = children.begin(); it != children.end(); it++ )
 		if( (*it)->name == childName )
 			return( *it );
 
 	return( NULL );
 }
 
 const CProfileNode* CProfileNode::GetScriptChild( const char* childName ) const
 {
 	const_profile_iterator it;
 	for( it = script_children.begin(); it != script_children.end(); it++ )
 		if( (*it)->name == childName )
 			return( *it );
 
 	return( NULL );
 }
 
 CProfileNode* CProfileNode::GetChild( const char* childName )
 {
 	profile_iterator it;
 	for( it = children.begin(); it != children.end(); it++ )
 		if( (*it)->name == childName )
 			return( *it );
 	
 	CProfileNode* newNode = new CProfileNode( childName, this );
 	children.push_back( newNode );
 	return( newNode );
 }
 
 CProfileNode* CProfileNode::GetScriptChild( const char* childName )
 {
 	profile_iterator it;
 	for( it = script_children.begin(); it != script_children.end(); it++ )
 		if( (*it)->name == childName )
 			return( *it );
 	
 	CProfileNode* newNode = new CProfileNode( childName, this );
 	script_children.push_back( newNode );
 	return( newNode );
 }
 
 bool CProfileNode::CanExpand()
 {
 	return( !( children.empty() && script_children.empty() ) );
 }
 
 void CProfileNode::Reset()
 {
 	calls_total = 0;
 	calls_frame_current = 0;
 #ifdef PROFILE_AMORTIZE
 	int i;
 	for( i = 0; i < PROFILE_AMORTIZE_FRAMES; i++ )
 	{
 		calls_frame_buffer[i] = 0;
 		time_frame_buffer[i] = 0.0;
 	}
 	calls_frame_last = calls_frame_buffer;
 	calls_frame_amortized = 0.0f;
 #else
 	calls_frame_last = 0;
 #endif
 
 	time_total = 0.0;
 	time_frame_current = 0.0;
 #ifdef PROFILE_AMORTIZE
 	time_frame_last = time_frame_buffer;
 	time_frame_amortized = 0.0;
 #else
 	time_frame_last = 0.0;
 #endif
 
 	mallocs_total = 0;
 	mallocs_frame_current = 0;
 	mallocs_frame_last = 0;
 
 	profile_iterator it;
 	for( it = children.begin(); it != children.end(); it++ )
 		(*it)->Reset();
 	for( it = script_children.begin(); it != script_children.end(); it++ )
 		(*it)->Reset();
 }
 
 void CProfileNode::Frame()
 {
 	calls_total += calls_frame_current;
 	time_total += time_frame_current;
 	mallocs_total += mallocs_frame_current;
 
 #ifdef PROFILE_AMORTIZE
 	calls_frame_amortized -= *calls_frame_last;
 	*calls_frame_last = calls_frame_current;
 	calls_frame_amortized += calls_frame_current;
 	time_frame_amortized -= *time_frame_last;
 	*time_frame_last = time_frame_current;
 	time_frame_amortized += time_frame_current;
 	if( ++calls_frame_last == ( calls_frame_buffer + PROFILE_AMORTIZE_FRAMES ) )
 		calls_frame_last = calls_frame_buffer;
 	if( ++time_frame_last == ( time_frame_buffer + PROFILE_AMORTIZE_FRAMES ) )
 		time_frame_last = time_frame_buffer;
 #else
 	calls_frame_last = calls_frame_current;
 	time_frame_last = time_frame_current;
 #endif
 	mallocs_frame_last = mallocs_frame_current;
 
 	calls_frame_current = 0;
 	time_frame_current = 0.0;
 	mallocs_frame_current = 0;
 	
 	profile_iterator it;
 	for( it = children.begin(); it != children.end(); it++ )
 		(*it)->Frame();
 	for( it = script_children.begin(); it != script_children.end(); it++ )
 		(*it)->Frame();
 }
 
+// TODO: these should probably only count allocations that occur in the thread being profiled
+#if HAVE_VC_DEBUG_ALLOC
+static long memory_alloc_bias = 0; // so we can subtract the allocations caused by this function
 static long get_memory_alloc_count()
 {
-#if HAVE_VC_DEBUG_ALLOC
 	// TODO: it's probably better to use _CrtSetAllocHook to increment a
 	// user-visible counter. (I didn't know that existed when I wrote this.)
 
 	// Find the number of allocations that have ever occurred, by doing a dummy
 	// allocation and checking its request number
-	static long bias = 0; // so we can subtract the allocations caused by this function
 	void* p = malloc(1);
 	long requestNumber = 0;
 	int ok = _CrtIsMemoryBlock(p, 1, &requestNumber, NULL, NULL);
 	UNUSED2(ok);
 	free(p);
-	++bias;
-	return requestNumber - bias;
+	cpu_AtomicAdd(&memory_alloc_bias, 1);
+	return requestNumber - memory_alloc_bias;
+}
+#elif defined(GLIBC_MALLOC_HOOK)
+// Set up malloc hooks to count allocations - see
+// http://www.gnu.org/software/libc/manual/html_node/Hooks-for-Malloc.html
+static int malloc_count = 0;
+static void *(*old_malloc_hook) (size_t, const void*);
+static CMutex malloc_mutex;
+static void *malloc_hook(size_t size, const void* caller)
+{
+	// TODO: this is totally not nicely thread-safe - glibc's hook system seems to
+	// not make threading easy, and I don't want to think too hard, so this is
+	// just all put inside a lock.
+	CScopeLock lock(malloc_mutex);
+	
+	++malloc_count;
+	__malloc_hook = old_malloc_hook;
+	void* result = malloc(size);
+	old_malloc_hook = __malloc_hook;
+	__malloc_hook = malloc_hook;
+	return result;
+}
+static void malloc_initialize_hook()
+{
+	CScopeLock lock(malloc_mutex);
+	
+	old_malloc_hook = __malloc_hook;
+	__malloc_hook = malloc_hook;
+}
+/*
+It would be nice to do:
+    __attribute__ ((visibility ("default"))) void (*__malloc_initialize_hook)() = malloc_initialize_hook;
+except that doesn't seem to work in practice, since something (?) resets the
+hook to NULL some time while loading the game, after we've set it here - so
+we just call malloc_initialize_hook once inside CProfileManager::Frame instead
+and hope nobody deletes our hook after that.
+*/
+static long get_memory_alloc_count()
+{
+	return malloc_count;
+}
 #else
-	// TODO: support other compilers if it's easy.
+static long get_memory_alloc_count()
+{
 	// TODO: don't show this column of data when we don't have sensible values
 	// to display.
 	return 0;
-#endif
 }
+#endif
 
 void CProfileNode::Call()
 {
 	calls_frame_current++;
 	if( recursion++ == 0 )
 	{
 		start = get_time();
 		start_mallocs = get_memory_alloc_count();
 	}
 }
 
 bool CProfileNode::Return()
 {
 	if( !parent ) return( false );
 
 	if( ( --recursion == 0 ) && ( calls_frame_current != 0 ) )
 	{
 		time_frame_current += ( get_time() - start );
 		mallocs_frame_current += ( get_memory_alloc_count() - start_mallocs );
 	}
 	return( recursion == 0 );
 }
 
 void CProfileNode::ScriptingInit()
 {
 	AddProperty( L"name", (IJSObject::GetFn)&CProfileNode::JS_GetName );
 	/*
 	AddReadOnlyClassProperty( L"callsTotal", &CProfileNode::calls_total );
 	AddReadOnlyClassProperty( L"callsPerFrame", &CProfileNode::calls_frame_last );
 	AddReadOnlyClassProperty( L"timeTotal", &CProfileNode::time_total );
 	AddReadOnlyClassProperty( L"timePerFrame", &CProfileNode::time_frame_last );
 	*/
 	CJSObject<CProfileNode, true>::ScriptingInit( "ProfilerNode" );
 }
 
 CProfileManager::CProfileManager()
 {
 	root = new CProfileNode( "root", NULL );
 	current = root;
 	frame_start = 0.0;
+	frame_start_mallocs = 0;
 	g_ProfileViewer.AddRootTable(root->display_table);
 }
 
 CProfileManager::~CProfileManager()
 {
 	std::map<CStr8, const char*>::iterator it;
 	for( it = m_internedStrings.begin(); it != m_internedStrings.end(); it++ )
 		delete[]( it->second );
 
 	delete( root );
 }
 
 void CProfileManager::Start( const char* name )
 {
 	if( name != current->GetName() )
 		current = current->GetChild( name );
 	current->Call();
 }
 
 void CProfileManager::StartScript( const char* name )
 {
 	if( name != current->GetName() )
 		current = current->GetScriptChild( name );
 	current->Call();
 }
 
 const char* CProfileManager::InternString( const CStr8& intern )
 {
 	std::map<CStr8, const char*>::iterator it = m_internedStrings.find( intern );
 	if( it != m_internedStrings.end() )
 		return( it->second );
 	
 	size_t length = intern.length();
 	char* data = new char[length + 1];
 	strcpy( data, intern.c_str() );
 	data[length] = 0;
 	m_internedStrings.insert( std::pair<CStr8, const char*>( intern, data ) );	
 	return( data );
 }
 
 void CProfileManager::Stop()
 {
 	if( current->Return() )
 		current = current->GetParent();
 }
 
 void CProfileManager::Reset()
 {
 	root->Reset();
-	start = get_time();
-	frame_start = get_time();
+	start = frame_start = get_time();
+	start_mallocs = frame_start_mallocs = get_memory_alloc_count();
 }
 
 void CProfileManager::Frame()
 {
+#ifdef GLIBC_MALLOC_HOOK
+	ONCE(malloc_initialize_hook());
+#endif
+	
 	root->time_frame_current = ( get_time() - frame_start );
+	root->mallocs_frame_current = ( get_memory_alloc_count() - frame_start_mallocs );
 	root->Frame();
 	
 	frame_start = get_time();
+	frame_start_mallocs = get_memory_alloc_count();
 }
 
 void CProfileManager::StructuralReset()
 {
 	delete( root );
 	root = new CProfileNode( "root", NULL );
 	current = root;
 	g_ProfileViewer.AddRootTable(root->display_table);
 }
-
-double CProfileManager::GetTime()
-{
-	return( get_time() - start );
-}
-
-double CProfileManager::GetFrameTime()
-{
-	return( get_time() - frame_start );
-}
-
-
Index: ps/trunk/source/ps/Profile.h
===================================================================
--- ps/trunk/source/ps/Profile.h	(revision 5179)
+++ ps/trunk/source/ps/Profile.h	(revision 5180)
@@ -1,168 +1,168 @@
 /**
  * =========================================================================
  * File        : Profile.h
  * Project     : Pyrogenesis
  * Description : GPG3-style hierarchical profiler
  * =========================================================================
  */
 
 #ifndef INCLUDED_PROFILE
 #define INCLUDED_PROFILE
 
 #include <vector>
 #include "Singleton.h"
 #include "scripting/ScriptableObject.h"
 
 
 #define PROFILE_AMORTIZE
 #define PROFILE_AMORTIZE_FRAMES 50
 
 class CProfileManager;
 class CProfileNodeTable;
 
 class CProfileNode : public CJSObject<CProfileNode, true>
 {
 	friend class CProfileManager;
 	friend class CProfileNodeTable;
 	
 	const char* name;
 
 	int calls_total;
 	int calls_frame_current;
 #ifdef PROFILE_AMORTIZE
 	int calls_frame_buffer[PROFILE_AMORTIZE_FRAMES];
 	int* calls_frame_last;
 	float calls_frame_amortized;
 #else
 	int calls_frame_last;
 #endif
 
 	double time_total;
 	double time_frame_current;
 #ifdef PROFILE_AMORTIZE
 	double time_frame_buffer[PROFILE_AMORTIZE_FRAMES];
 	double* time_frame_last;
 	double time_frame_amortized;
 #else
 	double time_frame_last;
 #endif
 
 	long mallocs_total;
 	long mallocs_frame_current;
 	long mallocs_frame_last;
 
 	double start;
 	long start_mallocs;
 	int recursion;
 
 	CProfileNode* parent;
 	std::vector<CProfileNode*> children;
 	std::vector<CProfileNode*> script_children;
 	CProfileNodeTable* display_table;
 	
 public:
 	typedef std::vector<CProfileNode*>::iterator profile_iterator;
 	typedef std::vector<CProfileNode*>::const_iterator const_profile_iterator;
 
 	CProfileNode( const char* name, CProfileNode* parent );
 	~CProfileNode();
 
 	const char* GetName() const { return( name ); }
 	int GetCalls() const { return( calls_total ); }
 	double GetTime() const { return( time_total ); }
 
 #ifdef PROFILE_AMORTIZE
 	float GetFrameCalls() const { return( calls_frame_amortized / PROFILE_AMORTIZE_FRAMES ); }
 	double GetFrameTime() const { return( time_frame_amortized / PROFILE_AMORTIZE_FRAMES ); }
 #else
 	int GetFrameCalls() const { return( calls_frame_last ); }
 	double GetFrameTime() const { return( time_frame_last ); }
 #endif
 	long GetFrameMallocs() const { return( mallocs_frame_last ); }
 
 	const CProfileNode* GetChild( const char* name ) const;
 	const CProfileNode* GetScriptChild( const char* name ) const;
 	const std::vector<CProfileNode*>* GetChildren() const { return( &children ); }
 	const std::vector<CProfileNode*>* GetScriptChildren() const { return( &script_children ); }
 
 	bool CanExpand();
 
 	CProfileNode* GetChild( const char* name );
 	CProfileNode* GetScriptChild( const char* name );
 	CProfileNode* GetParent() const { return( parent ); }
 
 	// Resets timing information for this node and all its children
 	void Reset();
 	// Resets frame timings for this node and all its children
 	void Frame();
 	// Enters the node
 	void Call();
 	// Leaves the node. Returns true if the node has actually been left
 	bool Return();
 
 // Javascript stuff...
 
 	static void ScriptingInit();
 	jsval JS_GetName(JSContext*) { return( ToJSVal( CStrW( name ) ) ); }
 };
 
 class CProfileManager : public Singleton<CProfileManager>
 {
 	CProfileNode* root;
 	CProfileNode* current;
 	double start;
 	double frame_start;
+	long start_mallocs;
+	long frame_start_mallocs;
 	std::map<CStr8, const char*> m_internedStrings;
 
 public:
 	CProfileManager();
 	~CProfileManager();
 
 	// Begins timing for a named subsection
 	void Start( const char* name );
 	void StartScript( const char* name );
 
 	// Ends timing for the current subsection
 	void Stop();
 
 	// Resets all timing information
 	void Reset();
 	// Resets frame timing information
 	void Frame();
 	// Resets absolutely everything
 	void StructuralReset();
 
 	const char* InternString( const CStr8& intern );
 
 	inline const CProfileNode* GetCurrent() { return( current ); }
 	inline const CProfileNode* GetRoot() { return( root ); }
-	double GetTime();
-	double GetFrameTime();
 };
 
 #define g_Profiler CProfileManager::GetSingleton()
 
 class CProfileSample
 {
 	static std::map<CStrW, char*> evMap;
 public:
 	CProfileSample( const char* name )
 	{
 		if (CProfileManager::IsInitialised())
 			g_Profiler.Start( name );
 	}
 	~CProfileSample()
 	{
 		if (CProfileManager::IsInitialised())
 			g_Profiler.Stop();
 	}
 };
 
 // Put a PROFILE( xyz ) block at the start of all code to be profiled.
 // Profile blocks last until the end of the containing scope.
 #define PROFILE( name ) CProfileSample __profile( name )
 // Cheat a bit to make things slightly easier on the user
 #define PROFILE_START( name ) { CProfileSample __profile( name )
 #define PROFILE_END( name ) }
 
 #endif // INCLUDED_PROFILE
Index: ps/trunk/source/gui/CGUI.cpp
===================================================================
--- ps/trunk/source/gui/CGUI.cpp	(revision 5179)
+++ ps/trunk/source/gui/CGUI.cpp	(revision 5180)
@@ -1,1894 +1,1897 @@
 /*
 CGUI
 */
 
 #include "precompiled.h"
 
 #include <string>
 
 #include <stdarg.h>
 
 #include "lib/res/graphics/unifont.h"
 
 #include "GUI.h"
 
 // Types - when including them into the engine.
 #include "CButton.h"
 #include "CImage.h"
 #include "CText.h"
 #include "CCheckBox.h"
 #include "CRadioButton.h"
 #include "CInput.h"
 #include "CList.h"
 #include "CDropDown.h"
 #include "CProgressBar.h"
 #include "CTooltip.h"
 #include "MiniMap.h"
 
 #include "ps/XML/Xeromyces.h"
 #include "ps/Font.h"
 
 #include "ps/Pyrogenesis.h"
 #include "lib/input.h"
 #include "lib/bits.h"
 // TODO Gee: Whatever include CRect/CPos/CSize
 #include "ps/Overlay.h"
+#include "ps/Profile.h"
 
 #include "scripting/ScriptingHost.h"
 #include "ps/Hotkey.h"
 #include "ps/Globals.h"
 #include "lib/timer.h"
 #include "lib/sysdep/sysdep.h"
 
 // namespaces used
 using namespace std;
 const double SELECT_DBLCLICK_RATE = 0.5;
 #include "ps/CLogger.h"
 #define LOG_CATEGORY "gui"
 
 
 // Class for global JavaScript object
 JSClass GUIClass = {
 	"GUIClass", 0,
 	JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,
 	JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, JS_FinalizeStub,
 };
 
 
 //-------------------------------------------------------------------
 //	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 implementation (in CGUI) static
 //-------------------------------------------------------------------
 InReaction gui_handler(const SDL_Event_* ev)
 {
+	PROFILE(" GUI event handler ");
 	return g_GUI.HandleEvent(ev);
 }
 
 
 InReaction CGUI::HandleEvent(const SDL_Event_* ev)
 {
 	InReaction ret = IN_PASS;
 
 	if (ev->ev.type == SDL_GUIHOTKEYPRESS)
 	{
 		const CStr& objectName = *(CStr*) ev->ev.user.data1;
 		IGUIObject* object = FindObjectByName(objectName);
 		if (! object)
 		{
 			LOG(ERROR, LOG_CATEGORY, "Cannot find hotkeyed object '%s'", objectName.c_str());
 		}
 		else
 		{
 			object->HandleMessage( SGUIMessage( GUIM_PRESSED ) );
 			object->ScriptEvent("press");
 		}
 	}
 
 	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, (float)ev->ev.motion.y);
 
 		GUI<SGUIMessage>::RecurseObject(GUIRR_HIDDEN | GUIRR_GHOST, m_BaseObject, 
 										&IGUIObject::HandleMessage, 
 										SGUIMessage(GUIM_MOUSE_MOTION));
 	}
 
 	// 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(ev->ev.button.button);
 			break;
 		default:
 			break;
 		}
 	}
 
 // JW: (pre|post)process omitted; what're they for? why would we need any special button_released handling?
 
 	// 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
 		GUI<IGUIObject*>::RecurseObject(GUIRR_HIDDEN | GUIRR_GHOST, m_BaseObject, 
 										&IGUIObject::ChooseMouseOverAndClosest, 
 										pNearest);
 
 		// Is placed in the UpdateMouseOver function
 		//if (ev->ev.type == SDL_MOUSEMOTION && pNearest)
 		//	pNearest->ScriptEvent("mousemove");
 
 		// Now we'll call UpdateMouseOver on *all* objects,
 		//  we'll input the one hovered, and they will each
 		//  update their own data and send messages accordingly
 		
 		GUI<IGUIObject*>::RecurseObject(GUIRR_HIDDEN | GUIRR_GHOST, m_BaseObject, 
 										&IGUIObject::UpdateMouseOver, 
 										pNearest);
 
 		if (ev->ev.type == SDL_MOUSEBUTTONDOWN)
 		{
 			switch (ev->ev.button.button)
 			{
 			case SDL_BUTTON_LEFT:
 				if (pNearest)
 				{
 					if (pNearest != m_FocusedObject)
 					{
 						// Update focused object
 						if (m_FocusedObject)
 							m_FocusedObject->HandleMessage(SGUIMessage(GUIM_LOST_FOCUS));
 						m_FocusedObject = pNearest;
 						m_FocusedObject->HandleMessage(SGUIMessage(GUIM_GOT_FOCUS));
 					}
 
 					pNearest->HandleMessage(SGUIMessage(GUIM_MOUSE_PRESS_LEFT));
 					pNearest->ScriptEvent("mouseleftpress");
 
 					// Block event, so things on the map (behind the GUI) won't be pressed
 					ret = IN_HANDLED;
 				}
 				else if (m_FocusedObject)
 				{
 					m_FocusedObject->HandleMessage(SGUIMessage(GUIM_LOST_FOCUS));
 					//if (m_FocusedObject-> TODO SelfishFocus?
 					m_FocusedObject = 0;
 				}
 				break;
 
 			case SDL_BUTTON_WHEELDOWN: // wheel down
 				if (pNearest)
 				{
 					pNearest->HandleMessage(SGUIMessage(GUIM_MOUSE_WHEEL_DOWN));
 					pNearest->ScriptEvent("mousewheeldown");
 
 					ret = IN_HANDLED;
 				}
 				break;
 
 			case SDL_BUTTON_WHEELUP: // wheel up
 				if (pNearest)
 				{
 					pNearest->HandleMessage(SGUIMessage(GUIM_MOUSE_WHEEL_UP));
 					pNearest->ScriptEvent("mousewheelup"); 
 
 					ret = IN_HANDLED;
 				}
 				break;
 
 			default:
 				break;
 			}
 		}
 		else 
 		if (ev->ev.type == SDL_MOUSEBUTTONUP)
 		{
 			switch (ev->ev.button.button)
 			{
 			case SDL_BUTTON_LEFT:
 				if (pNearest)
 				{
 					double timeElapsed = get_time() - pNearest->m_LastClickTime[SDL_BUTTON_LEFT];
 					pNearest->m_LastClickTime[SDL_BUTTON_LEFT] = get_time();
 					
 					//Double click?
 					if (timeElapsed < SELECT_DBLCLICK_RATE)
 					{
 						pNearest->HandleMessage(SGUIMessage(GUIM_MOUSE_DBLCLICK_LEFT));
 						pNearest->ScriptEvent("mouseleftdoubleclick");
 					}
 					else
 					{
 						pNearest->HandleMessage(SGUIMessage(GUIM_MOUSE_RELEASE_LEFT));
 						pNearest->ScriptEvent("mouseleftrelease");
 					}
 
 					ret = IN_HANDLED;
 				}
 				break;
 			case SDL_BUTTON_RIGHT:
 				if (pNearest)
 				{
 					double timeElapsed = get_time() - pNearest->m_LastClickTime[SDL_BUTTON_RIGHT];
 					pNearest->m_LastClickTime[SDL_BUTTON_RIGHT] = get_time();
 					
 					//Double click?
 					if (timeElapsed < SELECT_DBLCLICK_RATE)
 					{
 						pNearest->HandleMessage(SGUIMessage(GUIM_MOUSE_DBLCLICK_RIGHT));
 						//pNearest->ScriptEvent("mouserightdoubleclick");
 					}
 					else
 					{
 						pNearest->HandleMessage(SGUIMessage(GUIM_MOUSE_RELEASE_RIGHT));
 						//pNearest->ScriptEvent("mouserightrelease");
 					}
 
 					ret = IN_HANDLED;
 				}
 				break;
 			}
 
 			// Reset all states on all visible objects
 			GUI<>::RecurseObject(GUIRR_HIDDEN, m_BaseObject, 
 									&IGUIObject::ResetStates);
 
 			// It will have reset the mouse over of the current hovered, so we'll
 			//  have to restore that
 			if (pNearest)
 				pNearest->m_MouseHovering = true;
 		}
 	}
 	catch (PS_RESULT e)
 	{
 		UNUSED2(e);
 		debug_warn("CGUI::HandleEvent error");
 		// TODO Gee: Handle
 	}
 // JW: what's the difference between mPress and mDown? what's the code below responsible for?
 /*
 	// Generally if just mouse is clicked
 	if (m_pInput->mDown(NEMM_BUTTON1) && pNearest)
 	{
 		pNearest->HandleMessage(GUIM_MOUSE_DOWN_LEFT);
 	}
 */
 
 	// 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(ev->ev.button.button);
 			break;
 		default:
 			break;
 		}
 	}
 
 	// 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
 			)
 		{
 			ret = GetFocusedObject()->ManuallyHandleEvent(ev);
 		}
 		// else will return IN_PASS because we never used the button.
 	}
 
 	return ret;
 }
 
 void CGUI::TickObjects()
 {
 	CStr action = "tick";
 	GUI<CStr>::RecurseObject(0, m_BaseObject, 
 							&IGUIObject::ScriptEvent, action);
 
 	// Also update tooltips:
 
 	// TODO: Efficiency
 	IGUIObject* pNearest = NULL;
 	GUI<IGUIObject*>::RecurseObject(GUIRR_HIDDEN | GUIRR_GHOST, m_BaseObject, 
 		&IGUIObject::ChooseMouseOverAndClosest, 
 		pNearest);
 
 	m_Tooltip.Update(pNearest, m_MousePos, this);
 }
 
 void CGUI::SendEventToAll(const CStr& EventName)
 {
 	// janwas 2006-03-03: spoke with Ykkrosh about EventName case.
 	// when registering, case is converted to lower - this avoids surprise
 	// if someone were to get the case wrong and then not notice their
 	// handler is never called. however, until now, the other end
 	// (sending events here) wasn't converting to lower case,
 	// leading to a similar problem.
 	// now fixed; case is irrelevant since all are converted to lower.
 	GUI<CStr>::RecurseObject(0, m_BaseObject, 
 		&IGUIObject::ScriptEvent, EventName.LowerCase());
 }
 
 //-------------------------------------------------------------------
 //  Constructor / Destructor
 //-------------------------------------------------------------------
 CGUI::CGUI() : m_MouseButtons(0), m_FocusedObject(NULL), m_InternalNameNumber(0)
 {
 	m_BaseObject = new CGUIDummyObject;
 	m_BaseObject->SetGUI(this);
 
 	// Construct the parent object for all GUI JavaScript things
 	m_ScriptObject = JS_NewObject(g_ScriptingHost.getContext(), &GUIClass, NULL, NULL);
 	debug_assert(m_ScriptObject != NULL); // How should it handle errors?
 	JS_AddRoot(g_ScriptingHost.getContext(), &m_ScriptObject);
 
 	// This will make this invisible, not add
 	//m_BaseObject->SetName(BASE_OBJECT_NAME);
 }
 
 CGUI::~CGUI()
 {
 	if (m_BaseObject)
 		delete m_BaseObject;
 
 	if (m_ScriptObject)
 		// Let it be garbage-collected
 		JS_RemoveRoot(g_ScriptingHost.getContext(), &m_ScriptObject);
 }
 
 //-------------------------------------------------------------------
 //  Functions
 //-------------------------------------------------------------------
 IGUIObject *CGUI::ConstructObject(const CStr& str)
 {
 	if (m_ObjectTypes.count(str) > 0)
 		return (*m_ObjectTypes[str])();
 	else
 	{
 		// Error reporting will be handled with the NULL return.
 		return NULL;
 	}
 }
 
 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);
 
 	// The following line was commented out, I don't know if that's me or not, or
 	//  for what reason, but I'm gonna uncomment, if anything breaks, just let me
 	//  know, or if it wasn't I that commented it out, do let me know why.
 	//  -- Gee 20-07-2005
 	AddObjectType("list",			&CList::ConstructObject);
 	//
 
 	AddObjectType("dropdown",		&CDropDown::ConstructObject);
 }
 
 void CGUI::Process()
 {
 /*
 
 	// TODO Gee: check if m_pInput is valid, otherwise return
 ///	debug_assert(m_pInput);
 
 	// Pre-process all objects
 	try
 	{
 		GUI<EGUIMessage>::RecurseObject(0, m_BaseObject, &IGUIObject::HandleMessage, GUIM_PREPROCESS);
 	}
 	catch (PS_RESULT e)
 	{
 		return;
 	}
 
 	// Check mouse over
 	try
 	{
 		// Only one object can be hovered
 		//  check which one it is, if any !
 		IGUIObject *pNearest = NULL;
 
 		GUI<IGUIObject*>::RecurseObject(GUIRR_HIDDEN, m_BaseObject, &IGUIObject::ChooseMouseOverAndClosest, pNearest);
 		
 		// Now we'll call UpdateMouseOver on *all* objects,
 		//  we'll input the one hovered, and they will each
 		//  update their own data and send messages accordingly
 		GUI<IGUIObject*>::RecurseObject(GUIRR_HIDDEN, m_BaseObject, &IGUIObject::UpdateMouseOver, pNearest);
 
 		// If pressed
 		if (m_pInput->mPress(NEMM_BUTTON1) && pNearest)
 		{
 			pNearest->HandleMessage(GUIM_MOUSE_PRESS_LEFT);
 		}
 		else
 		// If released
 		if (m_pInput->mRelease(NEMM_BUTTON1) && pNearest)
 		{
 			pNearest->HandleMessage(GUIM_MOUSE_RELEASE_LEFT);
 		}
 
 		// Generally if just mouse is clicked
 		if (m_pInput->mDown(NEMM_BUTTON1) && pNearest)
 		{
 			pNearest->HandleMessage(GUIM_MOUSE_DOWN_LEFT);
 		}
 
 	}
 	catch (PS_RESULT e)
 	{
 		return;
 	}
 
 	// Post-process all objects
 	try
 	{
 		GUI<EGUIMessage>::RecurseObject(0, m_BaseObject, &IGUIObject::HandleMessage, GUIM_POSTPROCESS);
 	}
 	catch (PS_RESULT e)
 	{
 		return;
 	}
 */
 }
 
 void CGUI::Draw()
 {
 	// Clear the depth buffer, so the GUI is
 	// drawn on top of everything else
 	glClear(GL_DEPTH_BUFFER_BIT);
 	glPushMatrix();
 
 	guiLoadIdentity();
 
 	try
 	{
 		// Recurse IGUIObject::Draw() with restriction: hidden
 		//  meaning all hidden objects won't call Draw (nor will it recurse its children)
 		GUI<>::RecurseObject(GUIRR_HIDDEN, m_BaseObject, &IGUIObject::Draw);
 	}
 	catch (PS_RESULT e)
 	{
 		UNUSED2(e);
 		glPopMatrix();
 
 		// TODO Gee: Report error.
 		debug_warn("CGUI::Draw error");
 		return;
 	}
 	glPopMatrix();
 }
 
 void CGUI::DrawSprite(CGUISpriteInstance& Sprite,
 					  int CellID,
 					  const float& Z,
 					  const CRect& Rect,
 					  const CRect& UNUSED(Clipping))
 {
 	// If the sprite doesn't exist (name == ""), don't bother drawing anything
 	if (Sprite.IsEmpty())
 		return;
 
 	// TODO: Clipping?
 
 	glPushMatrix();
 	glTranslatef(0.0f, 0.0f, Z);
 
 	Sprite.Draw(Rect, CellID, m_Sprites);
 
 	glPopMatrix();
 
 }
 
 void CGUI::Destroy()
 {
 	// We can use the map to delete all
 	//  now we don't want to cancel all if one Destroy fails
 	map_pObjects::iterator it;
 	for (it = m_pAllObjects.begin(); it != m_pAllObjects.end(); ++it)
 	{
 		try
 		{
 			it->second->Destroy();
 		}
 		catch (PS_RESULT e)
 		{
 			UNUSED2(e);
 			debug_warn("CGUI::Destroy error");
 			// TODO Gee: Handle
 		}
 		
 		delete it->second;
 	}
 
 	for (std::map<CStr, CGUISprite>::iterator it2 = m_Sprites.begin(); it2 != m_Sprites.end(); ++it2)
 		for (std::vector<SGUIImage>::iterator it3 = it2->second.m_Images.begin(); it3 != it2->second.m_Images.end(); ++it3)
 			delete it3->m_Effects;
 
 	// Clear all
 	m_pAllObjects.clear();
 	m_Sprites.clear();
 	m_Icons.clear();
 }
 
 void CGUI::UpdateResolution()
 {
 	// Update ALL cached
 	GUI<>::RecurseObject(0, m_BaseObject, &IGUIObject::UpdateCachedSize );
 }
 
 void CGUI::AddObject(IGUIObject* pObject)
 {
 	try
 	{
 		// Add CGUI pointer
 		GUI<CGUI*>::RecurseObject(0, pObject, &IGUIObject::SetGUI, this);
 
 		// Add child to base object
 		m_BaseObject->AddChild(pObject); // can throw
 
 		// Cache tree
 		GUI<>::RecurseObject(0, pObject, &IGUIObject::UpdateCachedSize);
 
 		// Loaded
 		GUI<SGUIMessage>::RecurseObject(0, pObject, &IGUIObject::HandleMessage, SGUIMessage(GUIM_LOAD));
 	}
 	catch (PS_RESULT e)
 	{
 		throw e;
 	}
 }
 
 void CGUI::UpdateObjects()
 {
 	// We'll fill a temporary map until we know everything
 	//  succeeded
 	map_pObjects AllObjects;
 
 	try
 	{
 		// Fill freshly
 		GUI< map_pObjects >::RecurseObject(0, m_BaseObject, &IGUIObject::AddToPointersMap, AllObjects );
 	}
 	catch (PS_RESULT e)
 	{
 		// Throw the same error
 		throw e;
 	}
 
 	// 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;
 }
 
 
 // private struct used only in GenerateText(...)
 struct SGenerateTextImage
 {
 	float m_YFrom,			// The image's starting location in Y
 		  m_YTo,			// The image's end location in Y
 		  m_Indentation;	// The image width in other words
 
 	// Some help functions
 	// TODO Gee: CRect => CPoint ?
 	void SetupSpriteCall(const bool Left, SGUIText::SSpriteCall &SpriteCall, 
 						 const float width, const float y,
 						 const CSize &Size, const CStr& TextureName, 
 						 const float BufferZone, const int CellID)
 	{
 		// TODO Gee: Temp hardcoded values
 		SpriteCall.m_Area.top = y+BufferZone;
 		SpriteCall.m_Area.bottom = y+BufferZone + Size.cy;
 		
 		if (Left)
 		{
 			SpriteCall.m_Area.left = BufferZone;
 			SpriteCall.m_Area.right = Size.cx+BufferZone;
 		}
 		else
 		{
 			SpriteCall.m_Area.left = width-BufferZone - Size.cx;
 			SpriteCall.m_Area.right = width-BufferZone;
 		}
 
 		SpriteCall.m_CellID = CellID;
 		SpriteCall.m_Sprite = TextureName;
 
 		m_YFrom = SpriteCall.m_Area.top-BufferZone;
 		m_YTo = SpriteCall.m_Area.bottom+BufferZone;
 		m_Indentation = Size.cx+BufferZone*2;
 	}
 };
 
 SGUIText CGUI::GenerateText(const CGUIString &string,
 							const CStr& Font, const float &Width, const float &BufferZone, 
 							const IGUIObject *pObject)
 {
 	SGUIText Text; // object we're generating
 	
 	if (string.m_Words.size() == 0)
 		return Text;
 
 	float x=BufferZone, y=BufferZone; // drawing pointer
 	int from=0;
 	bool done=false;
 
 	bool FirstLine = true;	// Necessary because text in the first line is shorter
 							// (it doesn't count the line spacing)
 
 	// Images on the left or the right side.
 	vector<SGenerateTextImage> Images[2];
 	int pos_last_img=-1;	// Position in the string where last img (either left or right) were encountered.
 							//  in order to avoid duplicate processing.
 
 	// Easier to read.
 	bool WordWrapping = (Width != 0);
 
 	// Go through string word by word
 	for (int i=0; i<(int)string.m_Words.size()-1 && !done; ++i)
 	{
 		// Pre-process each line one time, so we know which floating images
 		//  will be added for that line.
 
 		// Generated stuff is stored in Feedback.
 		CGUIString::SFeedback Feedback;
 
 		// Preliminary line_height, used for word-wrapping with floating images.
 		float prelim_line_height=0.f;
 
 		// Width and height of all text calls generated.
 		string.GenerateTextCall(Feedback, Font,
 								string.m_Words[i], string.m_Words[i+1],
 								FirstLine);
 
 		// Loop through our images queues, to see if images has been added.
 		
 		// Check if this has already been processed.
 		//  Also, floating images are only applicable if Word-Wrapping is on
 		if (WordWrapping && i > pos_last_img)
 		{
 			// Loop left/right
 			for (int j=0; j<2; ++j)
 			{
 				for (vector<CStr>::const_iterator it = Feedback.m_Images[j].begin(); 
 					it != Feedback.m_Images[j].end();
 					++it)
 				{
 					SGUIText::SSpriteCall SpriteCall;
 					SGenerateTextImage Image;
 
 					// Y is if no other floating images is above, y. Else it is placed
 					//  after the last image, like a stack downwards.
 					float _y;
 					if (Images[j].size() > 0)
 						_y = std::max(y, Images[j].back().m_YTo);
 					else
 						_y = y; 
 
 					// Get Size from Icon database
 					SGUIIcon icon = GetIcon(*it);
 
 					CSize size = icon.m_Size;
 					Image.SetupSpriteCall((j==CGUIString::SFeedback::Left), SpriteCall, Width, _y, size, icon.m_SpriteName, BufferZone, icon.m_CellID);
 
 					// Check if image is the lowest thing.
 					Text.m_Size.cy = std::max(Text.m_Size.cy, Image.m_YTo);
 
 					Images[j].push_back(Image);
 					Text.m_SpriteCalls.push_back(SpriteCall);
 				}
 			}
 		}
 
 		pos_last_img = std::max(pos_last_img, i);
 
 		x += Feedback.m_Size.cx;
 		prelim_line_height = std::max(prelim_line_height, Feedback.m_Size.cy);
 
 		// If Width is 0, then there's no word-wrapping, disable NewLine.
 		if ((WordWrapping && (x > Width-BufferZone || Feedback.m_NewLine)) || i == (int)string.m_Words.size()-2)
 		{
 			// Change 'from' to 'i', but first keep a copy of its value.
 			int temp_from = from;
 			from = i;
 
 			static const int From=0, To=1;
 			//int width_from=0, width_to=width;
 			float width_range[2];
 			width_range[From] = BufferZone;
 			width_range[To] = Width - BufferZone;
 
 			// Floating images are only applicable if word-wrapping is enabled.
 			if (WordWrapping)
 			{
 				// Decide width of the line. We need to iterate our floating images.
 				//  this won't be exact because we're assuming the line_height
 				//  will be as our preliminary calculation said. But that may change,
 				//  although we'd have to add a couple of more loops to try straightening
 				//  this problem out, and it is very unlikely to happen noticeably if one
 				//  structures his text in a stylistically pure fashion. Even if not, it
 				//  is still quite unlikely it will happen.
 				// Loop through left and right side, from and to.
 				for (int j=0; j<2; ++j)
 				{
 					for (vector<SGenerateTextImage>::const_iterator it = Images[j].begin(); 
 						it != Images[j].end(); 
 						++it)
 					{
 						// We're working with two intervals here, the image's and the line height's.
 						//  let's find the union of these two.
 						float union_from, union_to;
 
 						union_from = std::max(y, it->m_YFrom);
 						union_to = std::min(y+prelim_line_height, it->m_YTo);
 						
 						// The union is not empty
 						if (union_to > union_from)
 						{
 							if (j == From)
 								width_range[From] = std::max(width_range[From], it->m_Indentation);
 							else
 								width_range[To] = std::min(width_range[To], Width - it->m_Indentation);
 						}
 					}
 				}
 			}
 
 			// Reset X for the next loop
 			x = width_range[From];
 
 			// Now we'll do another loop to figure out the height of
 			//  the line (the height of the largest character). This
 			//  couldn't be determined in the first loop (main loop)
 			//  because it didn't regard images, so we don't know
 			//  if all characters processed, will actually be involved
 			//  in that line.
 			float line_height=0.f;
 			for (int j=temp_from; j<=i; ++j)
 			{
 				// We don't want to use Feedback now, so we'll have to use
 				//  another.
 				CGUIString::SFeedback Feedback2;
 
 				// Don't attach object, it'll suppress the errors
 				//  we want them to be reported in the final GenerateTextCall()
 				//  so that we don't get duplicates.
 				string.GenerateTextCall(Feedback2, Font,
 										string.m_Words[j], string.m_Words[j+1],
 										FirstLine);
 
 				// Append X value.
 				x += Feedback2.m_Size.cx;
 
 				if (WordWrapping && x > width_range[To] && j!=temp_from && !Feedback2.m_NewLine)
 					break;
 
 				// Let line_height be the maximum m_Height we encounter.
 				line_height = std::max(line_height, Feedback2.m_Size.cy);
 
 				if (WordWrapping && Feedback2.m_NewLine)
 					break;
 			}
 
 			// Reset x once more
 			x = width_range[From];
 			// Move down, because font drawing starts from the baseline
 			y += line_height;
 
 			// Do the real processing now
 			for (int j=temp_from; j<=i; ++j)
 			{
 				// We don't want to use Feedback now, so we'll have to use
 				//  another one.
 				CGUIString::SFeedback Feedback2;
 
 				// Defaults
 				string.GenerateTextCall(Feedback2, Font,
 										string.m_Words[j], string.m_Words[j+1], 
 										FirstLine, pObject);
 
 				// Iterate all and set X/Y values
 				// Since X values are not set, we need to make an internal
 				//  iteration with an increment that will append the internal
 				//  x, that is what x_pointer is for.
 				float x_pointer=0.f;
 
 				vector<SGUIText::STextCall>::iterator it;
 				for (it = Feedback2.m_TextCalls.begin(); it != Feedback2.m_TextCalls.end(); ++it)
 				{
 					it->m_Pos = CPos(x + x_pointer, y);
 
 					x_pointer += it->m_Size.cx;
 
 					if (it->m_pSpriteCall)
 					{
 						it->m_pSpriteCall->m_Area += it->m_Pos - CSize(0,it->m_pSpriteCall->m_Area.GetHeight());
 					}
 				}
 
 				// Append X value.
 				x += Feedback2.m_Size.cx;
 
 				Text.m_Size.cx = std::max(Text.m_Size.cx, x+BufferZone);
 
 				// The first word overrides the width limit, what we
 				//  do, in those cases, are just drawing that word even
 				//  though it'll extend the object.
 				if (WordWrapping) // only if word-wrapping is applicable
 				{
 					if (Feedback2.m_NewLine)
 					{
 						from = j+1;
 
 						// Sprite call can exist within only a newline segment,
 						//  therefore we need this.
 						Text.m_SpriteCalls.insert(Text.m_SpriteCalls.end(), Feedback2.m_SpriteCalls.begin(), Feedback2.m_SpriteCalls.end());
 						break;
 					}
 					else
 					if (x > width_range[To] && j==temp_from)
 					{
 						from = j+1;
 						// do not break, since we want it to be added to m_TextCalls
 					}
 					else
 					if (x > width_range[To])
 					{
 						from = j;
 						break;
 					}
 				}
 
 				// Add the whole Feedback2.m_TextCalls to our m_TextCalls.
 				Text.m_TextCalls.insert(Text.m_TextCalls.end(), Feedback2.m_TextCalls.begin(), Feedback2.m_TextCalls.end());
 				Text.m_SpriteCalls.insert(Text.m_SpriteCalls.end(), Feedback2.m_SpriteCalls.begin(), Feedback2.m_SpriteCalls.end());
 
 				if (j == (int)string.m_Words.size()-2)
 					done = true;
 			}
 
 			// Reset X
 			x = 0.f;
 
 			// Update height of all
 			Text.m_Size.cy = std::max(Text.m_Size.cy, y+BufferZone);
 
 			FirstLine = false;
 
 			// Now if we entered as from = i, then we want
 			//  i being one minus that, so that it will become
 			//  the same i in the next loop. The difference is that
 			//  we're on a new line now.
 			i = from-1;
 		}
 	}
 
 	return Text;
 }
 
 void CGUI::DrawText(SGUIText &Text, const CColor &DefaultColor, 
 					const CPos &pos, const float &z, const CRect &clipping)
 {
 	// TODO Gee: All these really necessary? Some
 	//  are defaults and if you changed them
 	//  the opposite value at the end of the functions,
 	//  some things won't be drawn correctly. 
 	glEnable(GL_TEXTURE_2D);
 	glDisable(GL_CULL_FACE);
 
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	glEnable(GL_BLEND);
 	glDisable(GL_ALPHA_TEST);
 
 	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 
 	if (clipping != CRect())
 	{
 		double eq[4][4] = 
 		{ 
 			{  0.0,  1.0, 0.0, -clipping.top },
 			{  1.0,  0.0, 0.0, -clipping.left },
 			{  0.0, -1.0, 0.0, clipping.bottom },
 			{ -1.0,  0.0, 0.0, clipping.right }
 		};
 
 		for (int i=0; i<4; ++i)
 		{
 			glClipPlane(GL_CLIP_PLANE0+i, eq[i]);
 			glEnable(GL_CLIP_PLANE0+i);
 		}
 	}
 
 	CFont* font = NULL;
 	CStr LastFontName;
 
 	for (vector<SGUIText::STextCall>::const_iterator it = Text.m_TextCalls.begin(); 
 		 it != Text.m_TextCalls.end(); 
 		 ++it)
 	{
 		// If this is just a placeholder for a sprite call, continue
 		if (it->m_pSpriteCall)
 			continue;
 
 		// Switch fonts when necessary, but remember the last one used
 		if (it->m_Font != LastFontName)
 		{
 			delete font;
 			font = new CFont(it->m_Font);
 			font->Bind();
 			LastFontName = it->m_Font;
 		}
 
 		CColor color = it->m_UseCustomColor ? it->m_Color : DefaultColor;
 
 		glPushMatrix();
 
 		// TODO Gee: (2004-09-04) Why are font corrupted if inputted float value?
 		glTranslatef((GLfloat)int(pos.x+it->m_Pos.x), (GLfloat)int(pos.y+it->m_Pos.y), z);
 		glColor4fv(color.FloatArray());
 		glwprintf(L"%ls", it->m_String.c_str()); // "%ls" is necessary in case m_String contains % symbols
 
 		glPopMatrix();
 
 	}
 
 	if (font)
 		delete font;
 
 	for (list<SGUIText::SSpriteCall>::iterator it=Text.m_SpriteCalls.begin(); 
 		 it!=Text.m_SpriteCalls.end(); 
 		 ++it)
 	{
 		DrawSprite(it->m_Sprite, it->m_CellID, z, it->m_Area + pos);
 	}
 
 	// TODO To whom it may concern: Thing were not reset, so
 	//  I added this line, modify if incorrect --
 	if (clipping != CRect())
 	{
 		for (int i=0; i<4; ++i)
 			glDisable(GL_CLIP_PLANE0+i);
 	}	
 	glDisable(GL_TEXTURE_2D);
 	// -- GL
 }
 
 bool CGUI::GetPreDefinedColor(const CStr& name, CColor &Output)
 {
 	if (m_PreDefinedColors.count(name) == 0)
 	{
 		return false;
 	}
 	else
 	{
 		Output = m_PreDefinedColors[name];
 		return true;
 	}
 }
 
 void CGUI::ReportParseError(const char *str, ...)
 {
 	va_list argp;
 	char buffer[512];
 	memset(buffer,0,sizeof(buffer));
 	
 	va_start(argp, str);
 	sys_vsnprintf(buffer, sizeof(buffer), str, argp);
 	va_end(argp);
 
 	// Print header
 	if (m_Errors==0)
 	{
 		LOG(ERROR, LOG_CATEGORY, "*** GUI Tree Creation Errors:");
 	}
 
 	// Important, set ParseError to true
 	++m_Errors;
 
 	LOG(ERROR, LOG_CATEGORY, buffer);
 }
 
 /**
  * @callgraph
  */
 void CGUI::LoadXmlFile(const string &Filename)
 {
 	// Reset parse error
 	//  we can later check if this has increased
 	m_Errors = 0;
 
 	CXeromyces XeroFile;
 	if (XeroFile.Load(Filename.c_str()) != PSRETURN_OK)
 		// Fail silently
 		return;
 
 	XMBElement node = XeroFile.GetRoot();
 
 	// Check root element's (node) name so we know what kind of
 	//  data we'll be expecting
 	CStr root_name (XeroFile.GetElementString(node.GetNodeName()));
 
 	try
 	{
 
 		if (root_name == "objects")
 		{
 			Xeromyces_ReadRootObjects(node, &XeroFile);
 
 			// 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("CGUI::LoadXmlFile error");
 			// TODO Gee: Output in log
 		}
 	}
 	catch (PSERROR_GUI& e)
 	{
 		LOG(ERROR, LOG_CATEGORY, "Errors loading GUI file %s (%s)", Filename.c_str(), e.getCode());
 		return;
 	}
 
 	// Now report if any other errors occured
 	if (m_Errors > 0)
 	{
 ///		g_console.submit("echo GUI Tree Creation Reports %d errors", m_Errors);
 	}
 
 }
 
 //===================================================================
 //	XML Reading Xeromyces Specific Sub-Routines
 //===================================================================
 
 void CGUI::Xeromyces_ReadRootObjects(XMBElement Element, CXeromyces* pFile)
 {
 	int el_script = pFile->GetElementID("script");
 
 	// Iterate main children
 	//  they should all be <object> or <script> elements
 	XMBElementList children = Element.GetChildNodes();
 	for (int i=0; i<children.Count; ++i)
 	{
 		//debug_printf("Object %d\n", i);
 		XMBElement child = children.Item(i);
 
 		if (child.GetNodeName() == el_script)
 			// Execute the inline script
 			Xeromyces_ReadScript(child, pFile);
 		else
 			// Read in this whole object into the GUI
 			Xeromyces_ReadObject(child, pFile, m_BaseObject);
 	}
 }
 
 void CGUI::Xeromyces_ReadRootSprites(XMBElement Element, CXeromyces* pFile)
 {
 	// Iterate main children
 	//  they should all be <sprite> elements
 	XMBElementList children = Element.GetChildNodes();
 	for (int i=0; i<children.Count; ++i)
 	{
 		XMBElement child = children.Item(i);
 
 		// Read in this whole object into the GUI
 		Xeromyces_ReadSprite(child, pFile);
 	}
 }
 
 void CGUI::Xeromyces_ReadRootStyles(XMBElement Element, CXeromyces* pFile)
 {
 	// Iterate main children
 	//  they should all be <styles> elements
 	XMBElementList children = Element.GetChildNodes();
 	for (int i=0; i<children.Count; ++i)
 	{
 		XMBElement child = children.Item(i);
 
 		// Read in this whole object into the GUI
 		Xeromyces_ReadStyle(child, pFile);
 	}
 }
 
 void CGUI::Xeromyces_ReadRootSetup(XMBElement Element, CXeromyces* pFile)
 {
 	// Iterate main children
 	//  they should all be <icon>, <scrollbar> or <tooltip>.
 	XMBElementList children = Element.GetChildNodes();
 	for (int i=0; i<children.Count; ++i)
 	{
 		XMBElement child = children.Item(i);
 
 		// Read in this whole object into the GUI
 
 		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("Invalid data - DTD shouldn't allow this");
 		}
 	}
 }
 
 void CGUI::Xeromyces_ReadObject(XMBElement Element, CXeromyces* pFile, IGUIObject *pParent)
 {
 	debug_assert(pParent);
 	int i;
 
 	// Our object we are going to create
 	IGUIObject *object = NULL;
 
 	XMBAttributeList attributes = Element.GetAttributes();
 
 	// Well first of all we need to determine the type
 	CStr type (attributes.GetNamedItem(pFile->GetAttributeID("type")));
 
 	// Construct object from specified type
 	//  henceforth, we need to do a rollback before aborting.
 	//  i.e. releasing this object
 	object = ConstructObject(type);
 
 	if (!object)
 	{
 		// Report error that object was unsuccessfully loaded
 		ReportParseError("Unrecognized 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);
 	ATTR(style);
 	ATTR(type);
 	ATTR(name);
 	ATTR(hotkey);
 	ATTR(z);
 	ATTR(on);
 	ATTR(file);
 
 	//
 	//	Read Style and set defaults
 	//
 	//	If the setting "style" is set, try loading that setting.
 	//
 	//	Always load default (if it's available) first!
 	//
 	CStr argStyle (attributes.GetNamedItem(attr_style));
 
 	if (m_Styles.count("default") == 1)
 		object->LoadStyle(*this, "default");
 
 	if (! argStyle.empty())
 	{
 		// additional check
 		if (m_Styles.count(argStyle) == 0)
 		{
 			ReportParseError("Trying to use style '%s' that doesn't exist.", argStyle.c_str());
 		}
 		else object->LoadStyle(*this, argStyle);
 	}
 	
 
 	//
 	//	Read Attributes
 	//
 
 	bool NameSet = false;
 	bool ManuallySetZ = false; // if z has been manually set, this turn true
 
 	CStr hotkeyTag;
 
 	// Now we can iterate all attributes and store
 	for (i=0; i<attributes.Count; ++i)
 	{
 		XMBAttribute attr = attributes.Item(i);
 
 		// 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;
 
 		// Also the name needs some special attention
 		if (attr.Name == attr_name)
 		{
 			object->SetName((CStr)attr.Value);
 			NameSet = true;
 			continue;
 		}
 
 		// Wire up the hotkey tag, if it has one
 		if (attr.Name == attr_hotkey)
 			hotkeyTag = attr.Value;
 
 		if (attr.Name == attr_z)
 			ManuallySetZ = true;
 
 		// Try setting the value
 		if (object->SetSetting(pFile->GetAttributeString(attr.Name), (CStr)attr.Value, true) != PS_OK)
 		{
 			ReportParseError("(object: %s) Can't set \"%s\" to \"%s\"", object->GetPresentableName().c_str(), pFile->GetAttributeString(attr.Name).c_str(), CStr(attr.Value).c_str());
 
 			// This is not a fatal error
 		}
 	}
 
 	// Check if name isn't set, generate an internal name in that case.
 	if (!NameSet)
 	{
 		object->SetName(CStr("__internal(") + CStr(m_InternalNameNumber) + CStr(")"));
 		++m_InternalNameNumber;
 	}
 
 	// Attempt to register the hotkey tag, if one was provided
 	if (! hotkeyTag.empty())
 		HotkeyRegisterGuiObject(object->GetName(), hotkeyTag);
 
 	CStrW caption (Element.GetText());
 	if (! caption.empty())
 	{
 		// Set the setting caption to this
 		object->SetSetting("caption", caption, true);
 
 		// There is no harm if the object didn't have a "caption"
 	}
 
 
 	//
 	//	Read Children
 	//
 
 	// Iterate children
 	XMBElementList children = Element.GetChildNodes();
 
 	for (i=0; i<children.Count; ++i)
 	{
 		// Get node
 		XMBElement child = children.Item(i);
 
 		// 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);
 		}
 		else if (element_name == elmt_action)
 		{
 			// Scripted <action> element
 
 			// Check for a 'file' parameter
 			CStr file (child.GetAttributes().GetNamedItem(attr_file));
 
 			CStr code;
 
 			// If there is a file, open it and use it as the code
 			if (! file.empty())
 			{
 				CVFSFile scriptfile;
 				if (scriptfile.Load(file) != PSRETURN_OK)
 				{
 					LOG(ERROR, LOG_CATEGORY, "Error opening action file '%s'", file.c_str());
 					throw PSERROR_GUI_JSOpenFailed();
 				}
 
 				code = scriptfile.GetAsString();
 			}
 
 			// 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
 		{
 			// Try making the object read the tag.
 			if (!object->HandleAdditionalChildren(child, pFile))
 			{
 				LOG(ERROR, LOG_CATEGORY, "(object: %s) Reading unknown children for its type");
 			}
 		}
 	} 
 
 	//
 	//	Check if Z wasn't manually set
 	//
 	if (!ManuallySetZ)
 	{
 		// Set it automatically to 10 plus its parents
 		if (pParent==NULL)
 		{
 			debug_warn("CGUI::Xeromyces_ReadObject error");
 			// TODO Gee: Report error
 		}
 		else
 		{
 			bool absolute;
 			GUI<bool>::GetSetting(object, "absolute", absolute);
 
 			// If the object is absolute, we'll have to get the parent's Z buffered,
 			//  and add to that!
 			if (absolute)
 			{
 				GUI<float>::SetSetting(object, "z", pParent->GetBufferedZ() + 10.f, true);
 			}
 			else
 			// If the object is relative, then we'll just store Z as "10"
 			{
 				GUI<float>::SetSetting(object, "z", 10.f, true);
 			}
 		}
 	}
 
 
 	//
 	//	Input Child
 	//
 
 	try
 	{
 		if (pParent == m_BaseObject)
 			AddObject(object);
 		else
 			pParent->AddChild(object);
 	}
 	catch (PS_RESULT e)
 	{ 
 		ReportParseError(e);
 	}
 }
 
 void CGUI::Xeromyces_ReadScript(XMBElement Element, CXeromyces* pFile)
 {
 
 	// Check for a 'file' parameter
 	CStr file (Element.GetAttributes().GetNamedItem( pFile->GetAttributeID("file") ));
 
 	// If there is a file specified, open and execute it
 	if (! file.empty())
 		g_ScriptingHost.RunScript(file, m_ScriptObject);
 
 	// Execute inline scripts
 	CStr code (Element.GetText());
 	if (! code.empty())
 		g_ScriptingHost.RunMemScript(code.c_str(), code.length(), "Some XML file", Element.GetLineNumber(), m_ScriptObject);
 }
 
 void CGUI::Xeromyces_ReadSprite(XMBElement Element, CXeromyces* pFile)
 {
 	// Sprite object we're adding
 	CGUISprite sprite;
 	
 	// and what will be its reference name
 	CStr name;
 
 	//
 	//	Read Attributes
 	//
 
 	// Get name, we know it exists because of DTD requirements
 	name = Element.GetAttributes().GetNamedItem( pFile->GetAttributeID("name") );
 
 	if (m_Sprites.find(name) != m_Sprites.end())
 		LOG(WARNING, LOG_CATEGORY, "Sprite name '%s' used more than once; first definition will be discarded", (const char*)name);
 
 	//
 	//	Read Children (the images)
 	//
 
 	SGUIImageEffects* effects = NULL;
 
 	// Iterate children
 	XMBElementList children = Element.GetChildNodes();
 
 	for (int i=0; i<children.Count; ++i)
 	{
 		// Get node
 		XMBElement child = children.Item(i);
 
 		CStr ElementName (pFile->GetElementString(child.GetNodeName()));
 
 		if (ElementName == "image")
 		{
 			Xeromyces_ReadImage(child, pFile, sprite);
 		}
 		else if (ElementName == "effect")
 		{
 			debug_assert(! effects); // DTD should only allow one effect per sprite
 			effects = new SGUIImageEffects;
 			Xeromyces_ReadEffects(child, pFile, *effects);
 		}
 		else
 		{
 			debug_warn("Invalid data - DTD shouldn't allow this");
 		}
 	}
 
 	// Apply the effects to every image (unless the image overrides it with
 	// different effects)
 	if (effects)
 		for (std::vector<SGUIImage>::iterator it = sprite.m_Images.begin(); it != sprite.m_Images.end(); ++it)
 			if (! it->m_Effects)
 				it->m_Effects = new SGUIImageEffects(*effects); // do a copy just so it can be deleted correctly later
 
 	delete effects;
 
 	//
 	//	Add Sprite
 	//
 
 	m_Sprites[name] = sprite;
 }
 
 void CGUI::Xeromyces_ReadImage(XMBElement Element, CXeromyces* pFile, CGUISprite &parent)
 {
 
 	// Image object we're adding
 	SGUIImage image;
 	
 	// Set defaults (or maybe do that in DTD?)
 	image.m_TextureSize = CClientArea("0 0 100% 100%");
 	image.m_Size = CClientArea("0 0 100% 100%");
 	
 	// TODO Gee: Setup defaults here (or maybe they are in the SGUIImage ctor)
 
 	//
 	//	Read Attributes
 	//
 
 	// Now we can iterate all attributes and store
 	XMBAttributeList attributes = Element.GetAttributes();
 	for (int i=0; i<attributes.Count; ++i)
 	{
 		XMBAttribute attr = attributes.Item(i);
 		CStr attr_name (pFile->GetAttributeString(attr.Name));
 		CStr attr_value (attr.Value);
 
 		if (attr_name == "texture")
 		{
 			CStr TexFilename ("art/textures/ui/");
 			TexFilename += attr_value;
 
 			image.m_TextureName = TexFilename;
 		}
 		else
 		if (attr_name == "size")
 		{
 			CClientArea ca;
 			if (!GUI<CClientArea>::ParseString(attr_value, ca))
 				ReportParseError("Error parsing '%s' (\"%s\")", attr_name.c_str(), attr_value.c_str());
 			else image.m_Size = ca;
 		}
 		else
 		if (attr_name == "texture_size")
 		{
 			CClientArea ca;
 			if (!GUI<CClientArea>::ParseString(attr_value, ca))
 				ReportParseError("Error parsing '%s' (\"%s\")", attr_name.c_str(), attr_value.c_str());
 			else image.m_TextureSize = ca;
 		}
 		else
 		if (attr_name == "real_texture_placement")
 		{
 			CRect rect;
 			if (!GUI<CRect>::ParseString(attr_value, rect))
 				ReportParseError("Error parsing '%s' (\"%s\")", attr_name.c_str(), attr_value.c_str());
 			else image.m_TexturePlacementInFile = rect;
 		}
 		else
 		if (attr_name == "cell_size")
 		{
 			CSize size;
 			if (!GUI<CSize>::ParseString(attr_value, size))
 				ReportParseError("Error parsing '%s' (\"%s\")", attr_name.c_str(), attr_value.c_str());
 			else image.m_CellSize = size;
 		}
 		else
 		if (attr_name == "z_level")
 		{
 			float z_level;
 			if (!GUI<float>::ParseString(attr_value, z_level))
 				ReportParseError("Error parsing '%s' (\"%s\")", attr_name.c_str(), attr_value.c_str());
 			else image.m_DeltaZ = z_level/100.f;
 		}
 		else
 		if (attr_name == "backcolor")
 		{
 			CColor color;
 			if (!GUI<CColor>::ParseString(attr_value, color))
 				ReportParseError("Error parsing '%s' (\"%s\")", attr_name.c_str(), attr_value.c_str());
 			else image.m_BackColor = color;
 		}
 		else
 		if (attr_name == "bordercolor")
 		{
 			CColor color;
 			if (!GUI<CColor>::ParseString(attr_value, color))
 				ReportParseError("Error parsing '%s' (\"%s\")", attr_name.c_str(), attr_value.c_str());
 			else image.m_BorderColor = color;
 		}
 		else
 		if (attr_name == "border")
 		{
 			bool b;
 			if (!GUI<bool>::ParseString(attr_value, b))
 				ReportParseError("Error parsing '%s' (\"%s\")", attr_name.c_str(), attr_value.c_str());
 			else image.m_Border = b;
 		}
 		else
 		{
 			debug_warn("Invalid data - DTD shouldn't allow this");
 		}
 	}
 
 	// Look for effects
 	XMBElementList children = Element.GetChildNodes();
 	for (int i=0; i<children.Count; ++i)
 	{
 		XMBElement child = children.Item(i);
 		CStr ElementName (pFile->GetElementString(child.GetNodeName()));
 		if (ElementName == "effect")
 		{
 			debug_assert(! image.m_Effects); // DTD should only allow one effect per sprite
 			image.m_Effects = new SGUIImageEffects;
 			Xeromyces_ReadEffects(child, pFile, *image.m_Effects);
 		}
 		else
 		{
 			debug_warn("Invalid data - DTD shouldn't allow this");
 		}
 	}
 
 	//
 	//	Input
 	//
 
 	parent.AddImage(image);	
 }
 
 void CGUI::Xeromyces_ReadEffects(XMBElement Element, CXeromyces* pFile, SGUIImageEffects &effects)
 {
 	XMBAttributeList attributes = Element.GetAttributes();
 	for (int i=0; i<attributes.Count; ++i)
 	{
 		XMBAttribute attr = attributes.Item(i);
 		CStr attr_name (pFile->GetAttributeString(attr.Name));
 		CStr attr_value (attr.Value);
 
 #define COLOR(xml, mem, alpha) \
 		if (attr_name == xml) \
 		{ \
 			CColor color; \
 			if (!GUI<int>::ParseColor(attr_value, color, alpha)) \
 				ReportParseError("Error parsing '%s' (\"%s\")", attr_name.c_str(), attr_value.c_str()); \
 			else effects.m_##mem = color; \
 		} \
 		else
 
 
 #define BOOL(xml, mem) \
 		if (attr_name == xml) \
 		{ \
 			effects.m_##mem = true; \
 		} \
 		else
 
 		COLOR("add_color", AddColor, 0.f)
 		COLOR("multiply_color", MultiplyColor, 255.f)
 		BOOL("grayscale", Greyscale)
 
 		{
 			debug_warn("Invalid data - DTD shouldn't allow this");
 		}
 	}
 }
 
 void CGUI::Xeromyces_ReadStyle(XMBElement Element, CXeromyces* pFile)
 {
 	// style object we're adding
 	SGUIStyle style;
 	CStr name;
 	
 	//
 	//	Read Attributes
 	//
 
 	// Now we can iterate all attributes and store
 	XMBAttributeList attributes = Element.GetAttributes();
 	for (int i=0; i<attributes.Count; ++i)
 	{
 		XMBAttribute attr = attributes.Item(i);
 		CStr attr_name (pFile->GetAttributeString(attr.Name));
 		CStr attr_value (attr.Value);
 
 		// 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[attr_name] = attr_value;
 	}
 
 	//
 	//	Add to CGUI
 	//
 
 	m_Styles[name] = style;
 }
 
 void CGUI::Xeromyces_ReadScrollBarStyle(XMBElement Element, CXeromyces* pFile)
 {
 	// style object we're adding
 	SGUIScrollBarStyle scrollbar;
 	CStr name;
 	
 	//
 	//	Read Attributes
 	//
 
 	// Now we can iterate all attributes and store
 	XMBAttributeList attributes = Element.GetAttributes();
 	for (int i=0; i<attributes.Count; ++i)
 	{
 		XMBAttribute attr = attributes.Item(i);
 		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 == "width")
 		{
 			float f;
 			if (!GUI<float>::ParseString(attr_value, f))
 			{
 				ReportParseError("Error parsing '%s' (\"%s\")", attr_name.c_str(), attr_value.c_str());
 			}
 			scrollbar.m_Width = f;
 		}
 		else
 		if (attr_name == "minimum_bar_size")
 		{
 			float f;
 			if (!GUI<float>::ParseString(attr_value, f))
 			{
 				ReportParseError("Error parsing '%s' (\"%s\")", attr_name.c_str(), attr_value.c_str());
 			}
 			scrollbar.m_MinimumBarSize = 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;
 	}
 
 	//
 	//	Add to CGUI 
 	//
 
 	m_ScrollBarStyles[name] = scrollbar;
 }
 
 void CGUI::Xeromyces_ReadIcon(XMBElement Element, CXeromyces* pFile)
 {
 	// Icon we're adding
 	SGUIIcon icon;
 	CStr name;
 
 	XMBAttributeList attributes = Element.GetAttributes();
 	for (int i=0; i<attributes.Count; ++i)
 	{
 		XMBAttribute attr = attributes.Item(i);
 		CStr attr_name (pFile->GetAttributeString(attr.Name));
 		CStr attr_value (attr.Value);
 
 		if (attr_value == "null")
 			continue;
 
 		if (attr_name == "name")
 			name = attr_value;
 		else
 		if (attr_name == "sprite")
 			icon.m_SpriteName = attr_value;
 		else
 		if (attr_name == "size")
 		{
 			CSize size;
 			if (!GUI<CSize>::ParseString(attr_value, size))
 				ReportParseError("Error parsing '%s' (\"%s\") inside <icon>.", attr_name.c_str(), attr_value.c_str());
 			icon.m_Size = size;
 		}
 		else
 		if (attr_name == "cell_id")
 		{
 			int cell_id;
 			if (!GUI<int>::ParseString(attr_value, cell_id))
 				ReportParseError("Error parsing '%s' (\"%s\") inside <icon>.", attr_name.c_str(), attr_value.c_str());
 			icon.m_CellID = cell_id;
 		}
 		else
 		{
 			debug_warn("Invalid data - DTD shouldn't allow this");
 		}
 	}
 
 	m_Icons[name] = icon;
 }
 
 void CGUI::Xeromyces_ReadTooltip(XMBElement Element, CXeromyces* pFile)
 {
 	// Read the tooltip, and store it as a specially-named object
 
 	IGUIObject* object = new CTooltip;
 
 	XMBAttributeList attributes = Element.GetAttributes();
 	for (int i=0; i<attributes.Count; ++i)
 	{
 		XMBAttribute attr = attributes.Item(i);
 		CStr attr_name (pFile->GetAttributeString(attr.Name));
 		CStr attr_value (attr.Value);
 
 		if (attr_name == "name")
 		{
 			object->SetName("__tooltip_" + attr_value);
 		}
 		else
 		{
 			object->SetSetting(attr_name, attr_value);
 		}
 	}
 
 	AddObject(object);
 }
 
 // Reads Custom Color
 void CGUI::Xeromyces_ReadColor(XMBElement Element, CXeromyces* pFile)
 {
 	// Read the color and stor in m_PreDefinedColors
 
 	XMBAttributeList attributes = Element.GetAttributes();
 
 	//IGUIObject* object = new CTooltip;
 	CColor color;
 	CStr name = attributes.GetNamedItem(pFile->GetAttributeID("name"));
 
 	// Try parsing value 
 	CStr value (Element.GetText());
 	if (! value.empty())
 	{
 		// Try setting color to value
 		if (!color.ParseString(value, 255.f))
 		{
 			ReportParseError("Unable to create custom color '%s'. Invalid color syntax.", name.c_str());
 		}
 		else
 		{
 			// input color
 			m_PreDefinedColors[name] = color;
 		}
 	}
 }
Index: ps/trunk/source/gui/GUIutil.h
===================================================================
--- ps/trunk/source/gui/GUIutil.h	(revision 5179)
+++ ps/trunk/source/gui/GUIutil.h	(revision 5180)
@@ -1,382 +1,382 @@
 /*
 GUI util
 
 --Overview--
 
 	Contains help class GUI<>, which gives us templated
 	 parameter to all functions within GUI.
 
 --More info--
 
 	Check GUI.h
 
 */
 
 #ifndef INCLUDED_GUIUTIL
 #define INCLUDED_GUIUTIL
 
 
 //--------------------------------------------------------
 //  Includes / Compiler directives
 //--------------------------------------------------------
 #include "GUIbase.h"
 #include "ps/Parser.h"
 // TODO Gee: New
 #include "ps/Overlay.h"
 #include "CGUI.h"
 #include "CGUISprite.h"
 #include "IGUIObject.h"
 
 //--------------------------------------------------------
 //  Help Classes/Structs for the GUI
 //--------------------------------------------------------
 
 class CClientArea;
 class CGUIString;
 
 template <typename T>
 bool __ParseString(const CStr& Value, T &tOutput);
 
 // Load Identity matrix and
 //  adapt (origio) to being in top left corner and down
 //  just like the mouse position
 void guiLoadIdentity();
 
 //--------------------------------------------------------
 //  Forward declarations
 //--------------------------------------------------------
 struct SGUIMessage;
 
 /**
  * Base class to only the class GUI. This superclass is 
  * kind of a templateless extention of the class GUI.
  * Used for other functions to friend with, because it
  * can't friend with GUI since it's templated (at least
  * not on all compilers we're using).
  */
 class CInternalCGUIAccessorBase
 {
 protected:
 	/// Get object pointer
 	static IGUIObject * GetObjectPointer(CGUI &GUIinstance, const CStr& Object);
 	
 	/// const version
 	static const IGUIObject * GetObjectPointer(const CGUI &GUIinstance, const CStr& Object);
 
 	/// Wrapper for ResetStates
 	static void QueryResetting(IGUIObject *pObject);
 
 	static void HandleMessage(IGUIObject *pObject, const SGUIMessage &message);
 };
 
 
 #ifndef NDEBUG
 // Used to ensure type-safety, sort of 
 template<typename T> void CheckType(const IGUIObject* obj, const CStr& setting);
 #endif
 
 
 /**
  * Includes static functions that needs one template
  * argument.
  *
  * int is only to please functions that doesn't even use T
  * and are only within this class because it's convenient
  */
 template <typename T=int>
 class GUI : public CInternalCGUIAccessorBase
 {
 	// Private functions further ahead
 	friend class CGUI;
 	friend class IGUIObject;
 	friend class CInternalCGUIAccessorBase;
 
 public:
 
 	// Like GetSetting (below), but doesn't make a copy of the value
 	// (so it can be modified later)
 	static PS_RESULT GetSettingPointer(const IGUIObject *pObject, const CStr& Setting, T* &Value);
 
 	/**
 	 * Retrieves a setting by name from object pointer
 	 *
 	 * @param pObject Object pointer
 	 * @param Setting Setting by name
 	 * @param Value Stores value here, note type T!
 	 */
 	static PS_RESULT GetSetting(const IGUIObject *pObject, const CStr& Setting, T &Value);
 
 	/**
 	 * Sets a value by name using a real datatype as input.
 	 *
 	 * This is the official way of setting a setting, no other
 	 *  way should only cautiously be used!
 	 *
 	 * @param pObject Object pointer
 	 * @param Setting Setting by name
 	 * @param Value Sets value to this, note type T!
 	 * @param SkipMessage Does not send a GUIM_SETTINGS_UPDATED if true
 	 */
 	static PS_RESULT SetSetting(IGUIObject *pObject, const CStr& Setting, 
 								const T &Value, const bool &SkipMessage=false);
 
 #ifdef g_GUI
 	/**
 	 * Adapter that uses the singleton g_GUI
 	 * Can safely be removed.
 	 */
 	static PS_RESULT GetSetting(
 		const CStr& Object, 
 		const CStr& Setting, T &Value)
 	{
 		return GetSetting(g_GUI, Object, Setting, Value);
 	}
 #endif // g_GUI
 
 	/**
 	 * Retrieves a setting by settings name and object name
 	 *
 	 * @param GUI GUI Object const ref
 	 * @param Object Object name
 	 * @param Setting Setting by name
 	 * @param Value Stores value here, note type T!
 	 */
 	static PS_RESULT GetSetting(
 		const CGUI &GUIinstance, const CStr& Object, 
 		const CStr& Setting, T &Value)
 	{
 		if (!GUIinstance.ObjectExists(Object))
 			return PS_OBJECT_FAIL;
 
 		// Retrieve pointer and call sibling function
 		const IGUIObject *pObject = GetObjectPointer(GUIinstance, Object);
 
 		return GetSetting(pObject, Setting, Value);
 	}
 
 #ifdef g_GUI
 	/**
 	 * Adapter that uses the singleton g_GUI
 	 * Can safely be removed.
 	 */
 	static PS_RESULT SetSetting(
 		const CStr& Object, const CStr& Setting, const T &Value, const bool& SkipMessage=false)
 	{
 		return SetSetting(g_GUI, Object, Setting, Value, SkipMessage);		
 	}
 #endif // g_GUI
 
 	/**
 	 * Sets a value by setting and object name using a real 
 	 * datatype as input
 	 *
 	 * This is just a wrapper so that we can type the object name
 	 *  and not input the actual pointer.
 	 *
 	 * @param GUI GUI Object, reference since we'll be changing values
 	 * @param Object Object name
 	 * @param Setting Setting by name
 	 * @param Value Sets value to this, note type T!
 	 */
 	static PS_RESULT SetSetting(
 		CGUI &GUIinstance, const CStr& Object, 
 		const CStr& Setting, const T &Value,
 		const bool& SkipMessage=false)
 	{
 		if (!GUIinstance.ObjectExists(Object))
 			return PS_OBJECT_FAIL;
 
 		// Retrieve pointer and call sibling function
 
 		// Important, we don't want to use this T, we want
 		//  to use the standard T, since that will be the
 		//  one with the friend relationship
 		IGUIObject *pObject = GetObjectPointer(GUIinstance, Object);
 
 		return SetSetting(pObject, Setting, Value, SkipMessage);
 	}
 	
 	/**
 	 * This will return the value of the first sprite if it's not null,
 	 * if it is null, it will return the value of the second sprite, if
 	 * that one is null, then null it is.
 	 *
 	 * @param prim Primary sprite that should be used
 	 * @param sec Secondary sprite if Primary should fail
 	 * @return Resulting string
 	 */
 	static CGUISpriteInstance& FallBackSprite(
 									CGUISpriteInstance& prim,
 									CGUISpriteInstance& sec)
 	{
 		// CStr() == empty string, null
 		return (prim.IsEmpty() ? sec : prim);
 	}
 
 	/**
 	 * Same principle as FallBackSprite
 	 *
 	 * @param prim Primary color that should be used
 	 * @param sec Secondary color if Primary should fail
 	 * @return Resulting color
 	 * @see FallBackSprite
 	 */
 	static CColor FallBackColor(const CColor &prim, const CColor &sec)
 	{
 		// CColor() == null.
 		return ((prim!=CColor())?(prim):(sec));
 	}
 
 	/**
 	 * Sets a value by setting and object name using a real 
 	 * datatype as input.
 	 *
 	 * This is just a wrapper for _mem_ParseString() which really
 	 * works the magic.
 	 *
 	 * @param Value The value in string form, like "0 0 100% 100%"
 	 * @param tOutput Parsed value of type T
 	 * @return True at success.
 	 *
 	 * @see _mem_ParseString()
 	 */
 	static bool ParseString(const CStr& Value, T &tOutput)
 	{
 		return __ParseString<T>(Value, tOutput);
 	}
 
 	static bool ParseColor(const CStr& Value, CColor &tOutput, float DefaultAlpha);
 
 private:
 
 	// templated typedef of function pointer
 	typedef void (IGUIObject::*void_Object_pFunction_argT)(const T &arg);
 	typedef void (IGUIObject::*void_Object_pFunction_argRefT)(T &arg);
 	typedef void (IGUIObject::*void_Object_pFunction)();
 
 	/**
 	 * If you want to call a IGUIObject-function
 	 * on not just an object, but also on ALL of their children
 	 * you want to use this recursion system.
 	 * It recurses an object calling a function on itself
 	 * and all children (and so forth).
 	 *
 	 * <b>Restrictions:</b>\n
 	 * You can also set restrictions, so that if the recursion
 	 * reaches an objects with certain setup, it just doesn't
 	 * call the function on the object, nor it's children for
 	 * that matter. i.e. it cuts that object off from the
 	 * recursion tree. What setups that can cause restrictions
 	 * are hardcoded and specific. Check out the defines
 	 * GUIRR_* for all different setups.
 	 *
 	 * Error reports are either logged or thrown out of RecurseObject.
 	 * Always use it with try/catch!
 	 *
 	 * @param RR Recurse Restrictions, set to 0 if no restrictions
 	 * @param pObject Top object, this is where the iteration starts
 	 * @param pFunc Function to recurse
 	 * @param Argument Argument for pFunc of type T
 	 * @throws PS_RESULT Depends on what pFunc might throw. PS_RESULT is standard.
 	 *			Itself doesn't throw anything.
 	*/
-	static void RecurseObject(const int &RR, IGUIObject *pObject, void_Object_pFunction_argT pFunc, const T &Argument)
+	static void RecurseObject(const int RR, IGUIObject *pObject, void_Object_pFunction_argT pFunc, const T &Argument)
 	{
 		// TODO Gee: Don't run this for the base object.
 		if (CheckIfRestricted(RR, pObject))
 			return;
 
 		(pObject->*pFunc)(Argument);
 		
 		// Iterate children
 		vector_pObjects::iterator it;
 		for (it = pObject->ChildrenItBegin(); it != pObject->ChildrenItEnd(); ++it)
 		{
 			RecurseObject(RR, *it, pFunc, Argument);
 		}
 	}
 
 	/**
 	 * Argument is reference.
 	 *
 	 * @see RecurseObject()
 	 */
-	static void RecurseObject(const int &RR, IGUIObject *pObject, void_Object_pFunction_argRefT pFunc, T &Argument)
+	static void RecurseObject(const int RR, IGUIObject *pObject, void_Object_pFunction_argRefT pFunc, T &Argument)
 	{
 		if (CheckIfRestricted(RR, pObject))
 			return;
 
 		(pObject->*pFunc)(Argument);
 		
 		// Iterate children
 		vector_pObjects::iterator it;
 		for (it = pObject->ChildrenItBegin(); it != pObject->ChildrenItEnd(); ++it)
 		{
 			RecurseObject(RR, *it, pFunc, Argument);
 		}
 	}
 
 	/**
 	 * With no argument.
 	 *
 	 * @see RecurseObject()
 	 */
-	static void RecurseObject(const int &RR, IGUIObject *pObject, void_Object_pFunction pFunc)
+	static void RecurseObject(const int RR, IGUIObject *pObject, void_Object_pFunction pFunc)
 	{
 		if (CheckIfRestricted(RR, pObject))
 			return;
 
 		(pObject->*pFunc)();
 
 		// Iterate children
 		vector_pObjects::iterator it;
 		for (it = pObject->ChildrenItBegin(); it != pObject->ChildrenItEnd(); ++it)
 		{
 			RecurseObject(RR, *it, pFunc);
 		}
 	}
 
 private:
 	/**
 	 * Checks restrictions for the iteration, for instance if
 	 * you tell the recursor to avoid all hidden objects, it
 	 * will, and this function checks a certain object's
 	 * restriction values.
 	 *
 	 * @param RR What kind of restriction, for instance hidden or disabled
 	 * @param pObject Object
 	 * @return true if restricted
 	 */
-	static bool CheckIfRestricted(const int &RR, IGUIObject *pObject)
+	static bool CheckIfRestricted(const int RR, IGUIObject *pObject)
 	{
 		if (RR & GUIRR_HIDDEN)
 		{
 			bool hidden;
 			GUI<bool>::GetSetting(pObject, "hidden", hidden);
 
 			if (hidden)
 				return true;
 		}
 		if (RR & GUIRR_DISABLED)
 		{
 			bool enabled;
 			GUI<bool>::GetSetting(pObject, "enabled", enabled);
 
 			if (!enabled)
 				return true;
 		}
 		if (RR & GUIRR_GHOST)
 		{
 			bool ghost;
 			GUI<bool>::GetSetting(pObject, "ghost", ghost);
 
 			if (ghost)
 				return true;
 		}
 
 		// false means not restricted
 		return false;
 	}
 };
 
 #endif
Index: ps/trunk/source/gui/GUIutil.cpp
===================================================================
--- ps/trunk/source/gui/GUIutil.cpp	(revision 5179)
+++ ps/trunk/source/gui/GUIutil.cpp	(revision 5180)
@@ -1,378 +1,378 @@
 /*
 GUI utilities
 */
 
 #include "precompiled.h"
 #include "GUI.h"
 #include "ps/Parser.h"
 #include "ps/i18n.h"
 
 extern int g_yres;
 
 using namespace std;
 
 template <>
 bool __ParseString<bool>(const CStr& Value, bool &Output)
 {
 	if (Value == "true")
 		Output = true;
 	else
 	if (Value == "false")
 		Output = false;
 	else 
 		return false;
 
 	return true;
 }
 
 template <>
 bool __ParseString<int>(const CStr& Value, int &Output)
 {
 	Output = Value.ToInt();
 	return true;
 }
 
 template <>
 bool __ParseString<float>(const CStr& Value, float &Output)
 {
 	Output = Value.ToFloat();
 	return true;
 }
 
 template <>
 bool __ParseString<CRect>(const CStr& Value, CRect &Output)
 {
 	// Use the parser to parse the values
 	CParser& parser (CParserCache::Get("_$value_$value_$value_$value_"));
 
 	string str = Value;
 
 	CParserLine line;
 	line.ParseString(parser, str);
 	if (!line.m_ParseOK)
 	{
 		// Parsing failed
 		return false;
 	}
 	float values[4];
 	for (int i=0; i<4; ++i)
 	{
 		if (!line.GetArgFloat(i, values[i]))
 		{
 			// Parsing failed
 			return false;
 		}
 	}
 
 	// Finally the rectangle values
 	Output = CRect(values[0], values[1], values[2], values[3]);
 	return true;
 }
 
 template <>
 bool __ParseString<CClientArea>(const CStr& Value, CClientArea &Output)
 {
 	return Output.SetClientArea(Value);
 }
 
 template <>
 bool GUI<int>::ParseColor(const CStr& Value, CColor &Output, float DefaultAlpha)
 {
 	// First, check our database in g_GUI for pre-defined colors
 	//  If we find anything, we'll ignore DefaultAlpha
 #ifdef g_GUI
 	// If it fails, it won't do anything with Output
 	if (g_GUI.GetPreDefinedColor(Value, Output))
 		return true;
 
 #endif // g_GUI
 
 	return Output.ParseString(Value, DefaultAlpha);
 }
 
 
 template <>
 bool __ParseString<CColor>(const CStr& Value, CColor &Output)
 {
 	// First, check our database in g_GUI for pre-defined colors
 #ifdef g_GUI
 	// If it fails, it won't do anything with Output
 	if (g_GUI.GetPreDefinedColor(Value, Output))
 		return true;
 
 #endif // g_GUI
 
 	return Output.ParseString(Value, 255.f);
 }
 
 template <>
 bool __ParseString<CSize>(const CStr& Value, CSize &Output)
 {
 	// Use the parser to parse the values
 	CParser& parser (CParserCache::Get("_$value_$value_"));
 
 	string str = Value;
 
 	CParserLine line;
 	line.ParseString(parser, str);
 	if (!line.m_ParseOK)
 	{
 		// Parsing failed
 		return false;
 	}
 
 	float x, y;
 
 	// x
 	if (!line.GetArgFloat(0, x))
 	{
 		// TODO Gee: Parsing failed
 		return false;
 	}
 
 	// y
 	if (!line.GetArgFloat(1, y))
 	{
 		// TODO Gee: Parsing failed
 		return false;
 	}
 
 	Output.cx = x;
 	Output.cy = y;
 	
 	return true;
 }
 
 template <>
 bool __ParseString<CPos>(const CStr& Value, CPos &Output)
 {
 	CSize temp;
 	if (__ParseString<CSize>(Value, temp))
 	{
 		Output = CPos(temp);
 		return true;
 	}
 	else
 		return false;
 }
 
 template <>
 bool __ParseString<EAlign>(const CStr& Value, EAlign &Output)
 {
 	if (Value == "left")
 		Output = EAlign_Left;
 	else
 	if (Value == "center")
 		Output = EAlign_Center;
 	else
 	if (Value == "right")
 		Output = EAlign_Right;
 	else
 		return false;
 
 	return true;
 }
 
 template <>
 bool __ParseString<EVAlign>(const CStr& Value, EVAlign &Output)
 {
 	if (Value == "top")
 		Output = EVAlign_Top;
 	else
 	if (Value == "center")
 		Output = EVAlign_Center;
 	else
 	if (Value == "bottom")
 		Output = EVAlign_Bottom;
 	else
 		return false;
 
 	return true;
 }
 
 template <>
 bool __ParseString<CGUIString>(const CStr& Value, CGUIString &Output)
 {
 	// Translate the Value and retrieve the localised string in
 	//  Unicode.
 
 	Output.SetValue(I18n::translate((CStrW)Value));
 	return true;
 }
 
 template <>
 bool __ParseString<CStr>(const CStr& Value, CStr&Output)
 {
 	// Do very little.
 	Output = Value;
 	return true;
 }
 
 template <>
 bool __ParseString<CStrW>(const CStr& Value, CStrW& Output)
 {
 	// Translate the Value and retrieve the localised string in
 	//  Unicode.
 
 	Output = I18n::translate((CStrW)Value);
 	return true;
 }
 
 template <>
 bool __ParseString<CGUISpriteInstance>(const CStr& Value, CGUISpriteInstance &Output)
 {
 	Output = Value;
 	return true;
 }
 
 template <>
 bool __ParseString<CGUIList>(const CStr& UNUSED(Value), CGUIList& UNUSED(Output))
 {
-	//LOG(WARNING, LOG_CATEGORY, "Cannot set a 'list' from a string.");
 	return false;
 }
 
 
 //--------------------------------------------------------
 
 void guiLoadIdentity()
 {
 	glLoadIdentity();
 	glTranslatef(0.0f, (GLfloat)g_yres, -1000.0f);
 	glScalef(1.0f, -1.f, 1.0f);
 }
 
 //--------------------------------------------------------
 //  Utilities implementation
 //--------------------------------------------------------
 IGUIObject * CInternalCGUIAccessorBase::GetObjectPointer(CGUI &GUIinstance, const CStr& Object)
 {
 //	if (!GUIinstance.ObjectExists(Object))
 //		return NULL;
 
 	return GUIinstance.m_pAllObjects.find(Object)->second;
 }
 
 const IGUIObject * CInternalCGUIAccessorBase::GetObjectPointer(const CGUI &GUIinstance, const CStr& Object)
 {
 //	if (!GUIinstance.ObjectExists(Object))
 //		return NULL;
 
 	return GUIinstance.m_pAllObjects.find(Object)->second;
 }
 
 void CInternalCGUIAccessorBase::QueryResetting(IGUIObject *pObject)
 {
 	GUI<>::RecurseObject(0, pObject, &IGUIObject::ResetStates);
 }
 
 void CInternalCGUIAccessorBase::HandleMessage(IGUIObject *pObject, const SGUIMessage &message)
 {
 	pObject->HandleMessage(message);		
 }
 
 
 
 #ifndef NDEBUG
 	#define TYPE(T) \
 		template<> void CheckType<T>(const IGUIObject* obj, const CStr& setting) {	\
 			if (((IGUIObject*)obj)->m_Settings[setting].m_Type != GUIST_##T)	\
 			{	\
 				/* Abort now, to avoid corrupting everything by invalidly \
 					casting pointers */ \
 				DISPLAY_ERROR(L"FATAL ERROR: Inconsistent types in GUI");	\
 			}	\
 		}
 	#include "GUItypes.h"
 	#undef TYPE
 #endif
 
 
 //--------------------------------------------------------------------
-#include "ps/CLogger.h"
+
 template <typename T>
 PS_RESULT GUI<T>::GetSettingPointer(const IGUIObject *pObject, const CStr& Setting, T* &Value)
 {
 	if (pObject == NULL)
 		return PS_OBJECT_FAIL;
 
-	if (!pObject->SettingExists(Setting))
+	std::map<CStr, SGUISetting>::const_iterator it = pObject->m_Settings.find(Setting);
+	if (it == pObject->m_Settings.end())
 		return PS_SETTING_FAIL;
 
-	if (!pObject->m_Settings.find(Setting)->second.m_pSetting)
+	if (it->second.m_pSetting == NULL)
 		return PS_FAIL;
 
 #ifndef NDEBUG
 	CheckType<T>(pObject, Setting);
 #endif
 
 	// Get value
-	Value = (T*)pObject->m_Settings.find(Setting)->second.m_pSetting;
+	Value = (T*)(it->second.m_pSetting);
 
 	return PS_OK;
 }
 
 template <typename T>
 PS_RESULT GUI<T>::GetSetting(const IGUIObject *pObject, const CStr& Setting, T &Value)
 {
 	T* v;
 	PS_RESULT ret = GetSettingPointer(pObject, Setting, v);
 	if (ret == PS_OK)
 		Value = *v;
 	return ret;
 }
 
 template <typename T>
 PS_RESULT GUI<T>::SetSetting(IGUIObject *pObject, const CStr& Setting, 
 							 const T &Value, const bool& SkipMessage)
 {
 	if (pObject == NULL)
 		return PS_OBJECT_FAIL;
 
 	if (!pObject->SettingExists(Setting))
 		return PS_SETTING_FAIL;
 
 #ifndef NDEBUG
 	CheckType<T>(pObject, Setting);
 #endif
 
 	// Set value
 	*(T*)pObject->m_Settings[Setting].m_pSetting = Value;
 
 	//
 	//	Some settings needs special attention at change
 	//
 
 	// If setting was "size", we need to re-cache itself and all children
 	if (Setting == "size")
 	{
 		RecurseObject(0, pObject, &IGUIObject::UpdateCachedSize);
 	}
 	else
 	if (Setting == "hidden")
 	{
 		// Hiding an object requires us to reset it and all children
 		QueryResetting(pObject);
 		//RecurseObject(0, pObject, IGUIObject::ResetStates);
 	}
 
 	if (!SkipMessage)
 		HandleMessage(pObject, SGUIMessage(GUIM_SETTINGS_UPDATED, Setting));
 
 	return PS_OK;
 }
 
 // Instantiate templated functions:
 #define TYPE(T) \
 	template PS_RESULT GUI<T>::GetSettingPointer(const IGUIObject *pObject, const CStr& Setting, T* &Value); \
 	template PS_RESULT GUI<T>::GetSetting(const IGUIObject *pObject, const CStr& Setting, T &Value); \
 	template PS_RESULT GUI<T>::SetSetting(IGUIObject *pObject, const CStr& Setting, const T &Value, const bool& SkipMessage);
 #define GUITYPE_IGNORE_CGUISpriteInstance
 #include "GUItypes.h"
 
 // Don't instantiate GetSetting<CGUISpriteInstance> - this will cause linker errors if
 // you attempt to retrieve a sprite using GetSetting, since that copies the sprite
 // and will mess up the caching performed by DrawSprite. You have to use GetSettingPointer
 // instead. (This is mainly useful to stop me accidentally using the wrong function.)
 template PS_RESULT GUI<CGUISpriteInstance>::GetSettingPointer(const IGUIObject *pObject, const CStr& Setting, CGUISpriteInstance* &Value);
 template PS_RESULT GUI<CGUISpriteInstance>::SetSetting(IGUIObject *pObject, const CStr& Setting, const CGUISpriteInstance &Value, const bool& SkipMessage);
Index: ps/trunk/source/main.cpp
===================================================================
--- ps/trunk/source/main.cpp	(revision 5179)
+++ ps/trunk/source/main.cpp	(revision 5180)
@@ -1,376 +1,377 @@
 /*
 
 This module drives the game when running without Atlas (our integrated
 map editor). It receives input and OS messages via SDL and feeds them
 into the input dispatcher, where they are passed on to the game GUI and
 simulation.
 It also contains main(), which either runs the above controller or
 that of Atlas depending on commandline parameters.
 
 */
 
 // not for any PCH effort, but instead for the (common) definitions
 // included there.
 #include "lib/precompiled.h"
 
 #include "lib/input.h"
 #include "lib/timer.h"
 #include "lib/external_libraries/sdl.h"
 #include "lib/res/file/vfs.h"
 #include "lib/res/sound/snd_mgr.h"
 #include "lib/res/file/vfs_optimizer.h"
 
 #include "ps/GameSetup/GameSetup.h"
 #include "ps/GameSetup/Atlas.h"
 #include "ps/GameSetup/Config.h"
 #include "ps/GameSetup/CmdLineArgs.h"
 #include "ps/Loader.h"
 #include "ps/CConsole.h"
 #include "ps/Profile.h"
 #include "ps/Util.h"
 #include "ps/Game.h"
 #include "ps/Hotkey.h"
 #include "ps/Globals.h"
 #include "ps/Interact.h"
 #include "network/Client.h"
 #include "network/Server.h"
 #include "network/SessionManager.h"
 #include "graphics/Camera.h"
 #include "graphics/GameView.h"
 #include "simulation/Scheduler.h"
 #include "sound/CMusicPlayer.h"
 #include "gui/GUI.h"
 
 #define LOG_CATEGORY "main"
 
 extern bool g_TerrainModified;
 extern bool g_GameRestarted;
 
 void kill_mainloop();
 
 
 // main app message handler
 static InReaction MainInputHandler(const SDL_Event_* ev)
 {
 	switch(ev->ev.type)
 	{
 	case SDL_QUIT:
 		kill_mainloop();
 		break;
 
 	case SDL_HOTKEYDOWN:
 		switch(ev->ev.user.code)
 		{
 		case HOTKEY_EXIT:
 			kill_mainloop();
 			return IN_HANDLED;
 
 		case HOTKEY_SCREENSHOT:
 			WriteScreenshot("png");
 			return IN_HANDLED;
 
 		case HOTKEY_BIGSCREENSHOT:
 			WriteBigScreenshot("bmp", 10);
 			return IN_HANDLED;
 
 		default:
 			break;
 		}
 		break;
 	}
 
 	return IN_PASS;
 }
 
 
 // dispatch all pending events to the various receivers.
 static void PumpEvents()
 {
+	PROFILE( "dispatch events" );
 	in_dispatch_recorded_events();
 
 	SDL_Event_ ev;
 	while(SDL_PollEvent(&ev.ev))
 		in_dispatch_event(&ev);
 }
 
 
 // return indication of whether archive is currently being built; this is
 // used to prevent reloading during that time (see call site).
 static bool ProgressiveBuildArchive()
 {
 	int ret = vfs_opt_auto_build("../logs/trace.txt", "mods/official/official%02d.zip", "mods/official/mini%02d.zip");
 	if(ret == INFO::ALL_COMPLETE)
 	{
 		// nothing to do; will return false below
 	}
 	else if(ret < 0)
 		DISPLAY_ERROR(L"Archive build failed");
 	else if(ret == INFO::OK)
 		g_GUI.SendEventToAll("archivebuildercomplete");
 	// in progress
 	else
 	{
 		int percent = (int)ret;
 		g_ScriptingHost.SetGlobal("g_ArchiveBuilderProgress", INT_TO_JSVAL(percent));
 		g_GUI.SendEventToAll("archivebuilderprogress");
 		return true;
 	}
 
 	return false;
 }
 
 
 static int ProgressiveLoad()
 {
 	wchar_t description[100];
 	int progress_percent;
 	LibError ret = LDR_ProgressiveLoad(10e-3, description, ARRAY_SIZE(description), &progress_percent);
 	switch(ret)
 	{
 		// no load active => no-op (skip code below)
 	case INFO::OK:
 		return 0;
 		// current task didn't complete. we only care about this insofar as the
 		// load process is therefore not yet finished.
 	case ERR::TIMED_OUT:
 		break;
 		// just finished loading
 	case INFO::ALL_COMPLETE:
 		g_Game->ReallyStartGame();
 		wcscpy_s(description, ARRAY_SIZE(description), L"Game is starting..");
 		// LDR_ProgressiveLoad returns L""; set to valid text to
 		// avoid problems in converting to JSString
 		break;
 		// error!
 	default:
 		CHECK_ERR(ret);
 		// can't do this above due to legit ERR::TIMED_OUT
 		break;
 	}
 
 	GUI_DisplayLoadProgress(progress_percent, description);
 	return 0;
 }
 
 
 CMusicPlayer music_player;
 
 static void Frame()
 {
 	MICROLOG(L"Frame");
 	ogl_WarnIfError();
 
 	// get elapsed time
 	calc_fps();
 	// .. old method - "exact" but contains jumps
 #if 0
 	static double last_time;
 	const double time = get_time();
 	const float TimeSinceLastFrame = (float)(time-last_time);
 	last_time = time;
 	ONCE(return);	// first call: set last_time and return
 
 	// .. new method - filtered and more smooth, but errors may accumulate
 #else
 	const float TimeSinceLastFrame = spf;
 #endif
 	debug_assert(TimeSinceLastFrame >= 0.0f);
 
 	// decide if update/render is necessary
 	bool need_render = !g_app_minimized;
 	bool need_update = true;
 
 	// If we are not running a multiplayer game, disable updates when the game is
 	// minimized or out of focus and relinquish the CPU a bit, in order to make 
 	// debugging easier.
 	if( !g_NetClient && !g_NetServer && !g_app_has_focus )
 	{
 		need_update = false;
 		// don't use SDL_WaitEvent: don't want the main loop to freeze until app focus is restored
 		SDL_Delay(10);
 	}
 
 	// TODO: throttling: limit update and render frequency to the minimum.
 	// this is mostly relevant for "inactive" state, so that other windows
 	// get enough CPU time, but it's always nice for power+thermal management.
 
 
 	PROFILE_START( "update music" );
 	music_player.Update();
 	PROFILE_END( "update music" );
 
 	bool is_building_archive;	// must come before PROFILE_START's {
 	PROFILE_START("build archive");
 	MICROLOG(L"build archive");
 	is_building_archive = ProgressiveBuildArchive();
 	PROFILE_END( "build archive");
 
 	// this scans for changed files/directories and reloads them, thus
 	// allowing hotloading (changes are immediately assimilated in-game).
 	// must not be done during archive building because it changes the
 	// archive file each iteration, but keeps it locked; reloading
 	// would trigger a warning because the file can't be opened.
 	if(!is_building_archive)
 	{
 		PROFILE_START("reload changed files");
 		MICROLOG(L"reload changed files");
 		vfs_reload_changed_files(); 
 		PROFILE_END( "reload changed files");
 	}
 
 	PROFILE_START("progressive load");
 	MICROLOG(L"progressive load");
 	ProgressiveLoad();
 	PROFILE_END( "progressive load");
 
 	PROFILE_START("input");
 	MICROLOG(L"input");
 	PumpEvents();
 	g_SessionManager.Poll();
 	PROFILE_END("input");
 
 	ogl_WarnIfError();
 
 	PROFILE_START("gui tick");
 	MICROLOG(L"gui tick");
 #ifndef NO_GUI
 	g_GUI.TickObjects();
 #endif
 	PROFILE_END("gui tick");
 
 	ogl_WarnIfError();
 
 	PROFILE_START( "game logic" );
 	if (g_Game && g_Game->IsGameStarted() && need_update)
 	{
 		PROFILE_START( "simulation update" );
 		g_Game->Update(TimeSinceLastFrame);
 		PROFILE_END( "simulation update" );
 
 		if (!g_FixedFrameTiming)
 		{
 			PROFILE( "camera update" );
 			g_Game->GetView()->Update(float(TimeSinceLastFrame));
 		}
 
 		PROFILE_START( "selection and interaction ui" );
 		// TODO Where does GameView end and other things begin?
 		g_Mouseover.Update( TimeSinceLastFrame );
 		g_Selection.Update();
 		g_BuildingPlacer.Update( TimeSinceLastFrame );
 		PROFILE_END( "selection and interaction ui" );
 
 		PROFILE_START( "sound update" );
 		CCamera* camera = g_Game->GetView()->GetCamera();
 		CMatrix3D& orientation = camera->m_Orientation;
 
 		float* pos = &orientation._data[12];
 		float* dir = &orientation._data[8];
 		float* up  = &orientation._data[4];
 		if(snd_update(pos, dir, up) < 0)
 			debug_printf("snd_update failed\n");
 		PROFILE_END( "sound update" );
 	}
 	else
 	{
 		// CSimulation would do this with the proper turn length if we were in
 		// a game. This is basically just to keep script timers running.
 		uint ms_elapsed = (uint)(TimeSinceLastFrame*1000);
 		g_Scheduler.Update(ms_elapsed);
 		if(snd_update(0, 0, 0) < 0)
 			debug_printf("snd_update (pos=0 version) failed\n");
 	}
 	PROFILE_END( "game logic" );
 
 	PROFILE_START( "update console" );
 	g_Console->Update(TimeSinceLastFrame);
 	PROFILE_END( "update console" );
 
 	PROFILE_START("render");
 	ogl_WarnIfError();
 	if(need_render)
 	{
 		MICROLOG(L"render");
 		Render();
 		MICROLOG(L"finished render");
 		PROFILE_START( "swap buffers" );
 		SDL_GL_SwapBuffers();
 		PROFILE_END( "swap buffers" );
 	}
 	ogl_WarnIfError();
 	PROFILE_END("render");
 
 	g_Profiler.Frame();
 
 	if(g_FixedFrameTiming && frameCount==100)
 		kill_mainloop();
 
 	g_TerrainModified = false;
 	g_GameRestarted = false;
 }
 
 
 static void MainControllerInit()
 {
 	// add additional input handlers only needed by this controller:
 
 	// 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.
 #ifndef NO_GUI
 	in_add_handler(gui_handler);
 #endif
 
 	// must be registered after gui_handler. Should mayhap even be last.
 	in_add_handler(MainInputHandler);
 }
 
 
 
 static void MainControllerShutdown()
 {
 	music_player.Release();
 }
 
 
 static bool quit = false;	// break out of main loop
 
 // stop the main loop and trigger orderly shutdown. called from several
 // places: the event handler (SDL_QUIT and hotkey) and JS exitProgram.
 void kill_mainloop()
 {
 	quit = true;
 }
 
 
 // moved into a helper function to ensure args is destroyed before
 // exit(), which may result in a memory leak.
 static void RunGameOrAtlas(int argc, char* argv[])
 {
 	CmdLineArgs args(argc, argv);
 
 	// run Atlas (if requested via args)
 	bool ran_atlas = ATLAS_RunIfOnCmdLine(args);
 	// Atlas handles the whole init/shutdown/etc sequence by itself;
 	// when we get here, it has exited and we're done.
 	if(ran_atlas)
 		return;
 
 	// run the game
 	Init(args, 0);
 	MainControllerInit();
 	while(!quit)
 		Frame();
 	Shutdown(0);
 	ScriptingHost::FinalShutdown(); // this can't go in Shutdown() because that could be called multiple times per process, so stick it here instead
 	MainControllerShutdown();
 }
 
 int main(int argc, char* argv[])
 {
 	EarlyInit();	// must come at beginning of main
 
 	RunGameOrAtlas(argc, argv);
 
 	exit(EXIT_SUCCESS);
 }
Index: ps/trunk/binaries/data/tools/atlas/scripts/main.js
===================================================================
--- ps/trunk/binaries/data/tools/atlas/scripts/main.js	(revision 5179)
+++ ps/trunk/binaries/data/tools/atlas/scripts/main.js	(revision 5180)
@@ -1,98 +1,98 @@
 function getScriptFilename(name)
 {
 	var relativePath = 'tools/atlas/scripts/' + name + '.js';
 	var filename = new wxFileName(relativePath, wxPathFormat.UNIX);
 	filename.normalize(wxPathNormalize.DOTS | wxPathNormalize.ABSOLUTE | wxPathNormalize.TILDE,
 		Atlas.GetDataDirectory()); // equivalent to MakeAbsolute(dir);
 	return filename;
 }
 
 /**
  * Loads and executes a script from disk. The script runs in a separate scope,
  * so variables and functions declared in it will not be visible outside that file.
  */
 function loadScript(name /*, ...*/)
 {
 	var filename = getScriptFilename(name);
 	var file = new wxFFile(filename.fullPath);
 	var script = file.readAll(); // TODO: handle errors
 	file.close();
 
 	var args = [];
 	for (var i = 1; i < arguments.length; ++i)
 	args.push(arguments[i])
 	
 	var script = Atlas.LoadScript(name+'.js', script);
 	scriptReloader.add(name, args, filename);
 	
 	script.init.apply(null, args);
 	
 	return script;
 }
 
 function loadXML(name)
 {
 	var relativePath = 'tools/atlas/' + name + '.xml';
 	var filename = new wxFileName(relativePath, wxPathFormat.UNIX);
 	filename.normalize(wxPathNormalize.DOTS | wxPathNormalize.ABSOLUTE | wxPathNormalize.TILDE,
 	Atlas.GetDataDirectory()); // equivalent to MakeAbsolute(dir);
 
 	var file = new wxFFile(filename.fullPath);
 	var xml = file.readAll(); // TODO: handle errors
 	// TODO: complain (or work) nicely if the XML file starts with
 	// "<?xml ...?>" (which E4X doesn't like parsing)
 	file.close();
 
-	return eval(xml);
+	return new XML(xml);
 }
 
 function init() { /* dummy function to make the script reloader happy */ }
 
 var scriptReloader = {
 	timer: new wxTimer(),
 	scripts: [], // [ [filename,window], ... ]
 	notify: function ()
 	{
 		for each (var script in scriptReloader.scripts)
 		{
 			var mtime = script.filename.modificationTime;
 			if (mtime - script.mtime != 0)
 			{
 				print('*** Modifications detected - reloading "' + script.name + '"...\n');
 				script.mtime = mtime;
 				if (script.name == 'main')
 				{
 					// Special case for this file to reload itself
 					var obj = loadScript(script.name, null);
 					// Copy the important state into the new version of this file
 					obj.scriptReloader.scripts = scriptReloader.scripts;
 					// Stop this one
 					scriptReloader.timer.stop();
 				}
 				else
 				{
 					// TODO: know which arguments are really windows that should be regenerated
 					for each (var window in script.args)
 						window.destroyChildren();
 					loadScript.apply(null, [script.name].concat(script.args));
 					for each (var window in script.args)
 						window.layout();
 				}
 			}
 		}
 	},
 	add: function (name, args, filename)
 	{
 		for each (var script in this.scripts)
 			if (script.name == name)
 				return; // stop if this is already loaded
 		this.scripts.push({ name:name, args:args, filename:filename, mtime:filename.modificationTime });
 	}
 };
 scriptReloader.timer.onNotify = scriptReloader.notify;
 scriptReloader.timer.start(1000);
 scriptReloader.add('main', null, getScriptFilename('main'));
 
 // Export global functions:
 global.loadScript = loadScript;
 global.loadXML = loadXML;