int GUIManager::NewPage( const char* xml_file )
	{
		int ret = 1; // non-zero is failure
		Page* page;

		SyncPageCache();

		if( NULL != ( page = GetExistingCacheObject( xml_file ) ) )
		{
			SyncPageCache();
			page->m_topMost = true;
			ret = 0;
		}
		else
		{
			TiXmlDocument xmldoc;
			char* absPath = MakePathAbsolute( xml_file );

			if( absPath != NULL )
			{
				if( xmldoc.LoadFile( absPath ) )
				{
					XUTIL::xVector< int > tvec;

					tvec.Push( 1 );
					tvec.Pop();
					int cap = tvec.Capacity();
					int tsize = tvec.Size();
					tvec.Erase( 1, 2 );
					tvec.Front();
					tvec.Back();
					tvec.Empty();

	int GUIManager::NewPage( const char* xml_file )
	{
		int ret = 1; // non-zero is failure
		Page* page;

		SyncPageCache();

		if( NULL != ( page = GetExistingCacheObject( xml_file ) ) )
		{
			SyncPageCache();
			page->m_topMost = true;
			ret = 0;
		}
		else
		{
			TiXmlDocument xmldoc;
			char* absPath = MakePathAbsolute( xml_file );

			if( absPath != NULL )
			{
				if( xmldoc.LoadFile( absPath ) )
				{
					XUTIL::xVector< int > tvec;

					tvec.Push( 1 );
					tvec.Pop();
					int cap = tvec.Capacity();
					int tsize = tvec.Size();
					tvec.Erase( 1, 2 );
					tvec.Front();
					tvec.Back();
					tvec.Empty();

					// Create the new frame. There is always a single root frame of type "Frame".
					// This frame represents, in essence, the "screen", and can contain many child
					// frames which compose of a full menu.
					TiXmlElement* root = xmldoc.RootElement();
					if( root && strcmp( root->Value(), "GUI" ) == 0 )
					{
						Frame* newFrame = NULL;

						Page* page = new Page;
						if( page != NULL )
						{
							// Store the name of the XML File
							page->m_xmlFile = new char[ strlen( xml_file ) + 1 ];
							strcpy( page->m_xmlFile, xml_file );

							// ---------------------------------------------------------------------------------
							// TEMPLATE CREATION
							// ---------------------------------------------------------------------------------
							const TiXmlElement* templateIter = root->FirstChildElement( "Template" );
							while( templateIter != NULL )
							{
								m_templates.Push( templateIter );
								templateIter = templateIter->NextSiblingElement( "Template" );
							}

							// ---------------------------------------------------------------------------------


							// ---------------------------------------------------------------------------------
							// VARIABLE CREATION
							// ---------------------------------------------------------------------------------
							const TiXmlElement* variableIter = root->FirstChildElement( "Variable" );
							while( variableIter != NULL )
							{
								m_variables.Push( variableIter );
								variableIter = variableIter->NextSiblingElement( "Variable" );
							}

							// ---------------------------------------------------------------------------------


							// Create a temporary vector to store pointers to
							// dispatchable entities that need to have dependencies
							// resolved.
							XUTIL::xVector< Dispatchable* > dispatchables;

							// ---------------------------------------------------------------------------------
							// FRAME CREATION
							// ---------------------------------------------------------------------------------
							const TiXmlElement* rootFrame = root->FirstChildElement( "Frame" );
							if( rootFrame != NULL )
							{
								// Check the type of the root frame. It must be of type "Root" (RootFrame class)
								const char* rootType = rootFrame->Attribute( "type" );
								if( rootType != NULL && strcmp( rootType, "Root" ) == 0 )
								{
									newFrame = FrameFactory::Create( rootType, NULL, NULL, NULL, page );
									if( newFrame != NULL )
									{
										ParseFrame( rootFrame, newFrame, page );

										dispatchables.Push( newFrame );
									}
								}
							}

							// ---------------------------------------------------------------------------------



							// ---------------------------------------------------------------------------------
							// SETTER CREATION
							// ---------------------------------------------------------------------------------
							const TiXmlElement* setterElement = root->FirstChildElement( "Setter" );
							while( setterElement != NULL )
							{
								const char* type = setterElement->Attribute( "type" );
								if( type != NULL )
								{
									const char* id = setterElement->Attribute( "id" );

									Setter* newSetter = SetterFactory::Create( type, id, page );
									if( newSetter != NULL )
									{
										ParseSetter( setterElement, newSetter, page );
										page->m_setters.Push( newSetter );

										dispatchables.Push( newSetter );
									}
								}

								setterElement = setterElement->NextSiblingElement( "Setter" );
							}

							// ---------------------------------------------------------------------------------

							// Add the GUIManager *and* GameScript to the dependencies list,
							// since both of these are capable of receiving dispatches.
							dispatchables.Push( this );
							dispatchables.Push( GameScript::Instance() );


							// Resolve dependencies *AFTER* all frames and setters
							// have been created. Resolving dependencies
							// means that actions (which currently only have
							// string ID's to the frames they will be dispatched
							// to) are converted to pointers, for faster dispatching
							// during "runtime".
							page->m_eventCache.ResolveDependencies( dispatchables );

							// Finally, the cache is completely created
							if( newFrame != NULL )
							{
								page->m_topMost = true;
								page->m_rootFrame = newFrame;

								m_pages.PushBack( page );
								ret = 0;
							}

							// Delete all of the templates & variables. They are not needed outside of the parser.
							m_templates.Clear( true );
							m_variables.Clear( true );
						}
					}
				}

				delete[] absPath;
			}
		}

		return ret;
	}