From e97ec6788ec4354a168404e45f8850130118510b Mon Sep 17 00:00:00 2001
From: dfighter1985 <devnull@localhost>
Date: Mon, 9 Jul 2012 03:45:00 +0200
Subject: [PATCH] CHANGED: #1471 CInterfaceParser is now part of the Nel GUI
 library and is under the NLGUI namespace.

---
 code/nel/include/nel/gui/interface_parser.h   |  355 ++
 code/nel/src/gui/interface_parser.cpp         | 2885 ++++++++++++++++
 code/ryzom/client/src/actions.h               |    2 -
 .../src/interface_v3/interface_manager.h      |    4 +-
 .../src/interface_v3/interface_parser.cpp     | 2919 -----------------
 .../src/interface_v3/interface_parser.h       |  356 --
 .../client/src/interface_v3/parser_modules.h  |    4 +-
 7 files changed, 3245 insertions(+), 3280 deletions(-)
 create mode 100644 code/nel/include/nel/gui/interface_parser.h
 create mode 100644 code/nel/src/gui/interface_parser.cpp
 delete mode 100644 code/ryzom/client/src/interface_v3/interface_parser.cpp
 delete mode 100644 code/ryzom/client/src/interface_v3/interface_parser.h

diff --git a/code/nel/include/nel/gui/interface_parser.h b/code/nel/include/nel/gui/interface_parser.h
new file mode 100644
index 000000000..2ddc359cd
--- /dev/null
+++ b/code/nel/include/nel/gui/interface_parser.h
@@ -0,0 +1,355 @@
+// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
+// Copyright (C) 2010  Winch Gate Property Limited
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+#ifndef RZ_INTERFACE_PARSER_H
+#define RZ_INTERFACE_PARSER_H
+
+#include "nel/misc/types_nl.h"
+#include "nel/3d/u_texture.h"
+#include "nel/gui/ctrl_sheet_selection.h"
+#include "nel/gui/interface_link.h"
+#include "nel/misc/smart_ptr.h"
+#include "nel/gui/lua_helper.h"
+#include "nel/gui/widget_manager.h"
+
+namespace NLGUI
+{
+	class CInterfaceElement;
+	class CInterfaceGroup;
+	class CInterfaceOptions;
+	class CInterfaceLink;
+	class CCtrlBase;
+	class CGroupList;
+	class CGroupContainer;
+	class CInterfaceAnim;
+	class CViewPointer;
+
+	// ***************************************************************************
+	/**
+	 * class managing the interface parsing
+	 * \author Matthieu 'TrapII' Besson
+	 * \author Nevrax France
+	 * \date 2002
+	 */
+
+	// this is the base class for CInterfaceManager
+	class CInterfaceParser : public IParser
+	{
+
+	public:
+		
+		class IParserModule
+		{
+		public:
+			enum ParsingStage
+			{
+				None			= 0,
+				Unresolved		= 1,
+				Resolved		= 2,
+				GroupChildren	= 4
+			};
+
+			IParserModule(){
+				parser = NULL;
+				parsingStage = None;
+			}
+			virtual ~IParserModule(){}
+
+			bool canParseInStage( ParsingStage stage )
+			{
+				if( ( parsingStage & static_cast< uint >( stage ) ) != 0 )
+					return true;
+				else
+					return false;
+			}
+
+			virtual bool parse( xmlNodePtr cur, CInterfaceGroup *parentGroup ) = 0;
+			void setParser( CInterfaceParser *p ){ parser = p; }
+		
+		protected:
+			CInterfaceParser *parser;
+			uint parsingStage;
+		};
+
+		CInterfaceParser();
+		virtual ~CInterfaceParser();
+
+	public:
+
+		/**
+		 * Parsing methods
+		 */
+
+		/** Load a set of xml files
+		  * \param isFilename true if xmlFileNames array contains the names of the xml file, false, if each
+		  *                   array is a script itself
+		  */
+		bool parseInterface (const std::vector<std::string> &xmlFileNames, bool reload, bool isFilename = true, bool checkInData = false);
+
+		bool parseXMLDocument (xmlNodePtr root, bool reload);
+		bool parseTemplateNode (xmlNodePtr node,xmlNodePtr instance,xmlNodePtr templ);
+		bool parseInstance(xmlNodePtr cur);
+		bool parseVector (xmlNodePtr cur);
+		bool parseVariable (xmlNodePtr cur, CInterfaceGroup * parentGroup);
+		bool parseOptions (xmlNodePtr cur, CInterfaceGroup * parentGroup);
+		bool parseGroup (xmlNodePtr cur, CInterfaceGroup * parentGroup, bool reload);
+		bool parseGroupChildren(xmlNodePtr cur, CInterfaceGroup * parentGroup, bool reload);
+		bool parseControl (xmlNodePtr cur, CInterfaceGroup * parentGroup, bool reload);
+		bool parseLink (xmlNodePtr cur, CInterfaceGroup * parentGroup);
+		bool parseView (xmlNodePtr cur, CInterfaceGroup * parentGroup, bool reload);
+		bool parseTreeNode (xmlNodePtr cur, CGroupContainer *parentGroup);
+		bool parseTree (xmlNodePtr cur, CWidgetManager::SMasterGroup *parentGroup);
+		bool parseDefine(xmlNodePtr cur);
+		bool parseProcedure(xmlNodePtr cur, bool reload);
+		bool parseSheetSelection(xmlNodePtr cur);
+		bool parseAnim(xmlNodePtr cur, CInterfaceGroup * parentGroup);
+		bool parseStyle(xmlNodePtr cur);
+		bool parseLUAScript (xmlNodePtr cur);
+		bool setupTree (xmlNodePtr cur, CWidgetManager::SMasterGroup *parentGroup);
+		bool setupTreeNode (xmlNodePtr cur, CGroupContainer *parentGroup);
+		
+		void addModule( std::string name, IParserModule *module );
+		IParserModule* getModuleFor( std::string name ) const;
+		void removeAllModules();
+
+		// Called by each parse in parseXMLDocument
+		bool solveDefine(xmlNodePtr cur);
+		bool solveStyle(xmlNodePtr cur);
+
+		// Solve All define in a string. return false if some define not founs (defError contains this define)
+		bool solveDefine(const std::string &propVal, std::string &newPropVal, std::string &defError);
+
+		// Called after template & options parsing
+		virtual void setupOptions() { }
+
+		/**
+		 * Initializer
+		 */
+
+		bool initCoordsAndLuaScript ();
+
+		/// Association builders : associate an element of the interface with the string ID of
+		/// another element used as reference for position values
+		void addParentPositionAssociation (CInterfaceElement *element, const std::string &parentID);
+		void addParentSizeAssociation (CInterfaceElement *element, const std::string &parentID);
+		void addParentSizeMaxAssociation (CInterfaceElement *element, const std::string &parentID);
+
+		/// LUA Class Association builder :  associate a lua script to a group (called for each group after every document parsed)
+		void addLuaClassAssociation(CInterfaceGroup *group, const std::string &luaScript);
+
+		/**
+		 * Accessors
+		 */
+		// access to control sheet selection
+		CCtrlSheetSelection	&getCtrlSheetSelection() { return _CtrlSheetSelection; }
+
+		/// \name Parameter variable
+		// @{
+		const std::string	&getDefine(const std::string &id) const;
+		bool				isDefineExist(const std::string &id) const;
+		void				setDefine(const std::string &id, const std::string &value);
+		// @}
+
+		/// \name Dynamic links mgt
+		// @{
+			/** Associate the given dynamic link with an ID
+			  * \return true if succesful
+			  */
+			bool addLink(CInterfaceLink *link, const std::string &id);
+			/** remove the given link from its ID
+			  * \return true if succesful
+			  */
+			bool removeLink(const std::string &id);
+		// @}
+
+		/** create a template from an instance consisting of a single group
+		  * \param templateName name of the template in the xml
+		  * \param templateParams array containing each template parameter and its name
+		  * \param number of template parameters in the array
+		  */
+		CInterfaceGroup *createGroupInstance(const std::string &templateName, const std::string &parentID, const std::pair<std::string, std::string> *templateParams, uint numParams, bool updateLinks = true);
+		CInterfaceGroup *createGroupInstance(const std::string &templateName, const std::string &parentID, std::vector<std::pair<std::string, std::string> > &templateParams, bool updateLinks = true)
+		{
+			if (templateParams.size() > 0)
+				return createGroupInstance(templateName, parentID, &templateParams[0], (uint)templateParams.size(), updateLinks);
+			else
+				return createGroupInstance(templateName, parentID, NULL, 0, updateLinks);
+		}
+
+		/** create a template from an instance consisting of a single control or group
+		  * \param templateName name of the template in the xml
+		  * \param templateParams array containing each template parameter and its name
+		  * \param number of template parameters in the array
+		  */
+		CInterfaceElement *createUIElement(const std::string &templateName, const std::string &parentID, const std::pair<std::string,std::string> *templateParams, uint numParams, bool updateLinks /* = true */);
+		CInterfaceElement *createUIElement(const std::string &templateName, const std::string &parentID, std::vector<std::pair<std::string, std::string> > &templateParams, bool updateLinks = true)
+		{
+			if (templateParams.size() > 0)
+				return createUIElement(templateName, parentID, &templateParams[0], (uint)templateParams.size(), updateLinks);
+			else
+				return createUIElement(templateName, parentID, NULL, 0, updateLinks);
+		}
+
+		static void freeXMLNodeAndSibblings(xmlNodePtr node);
+
+		// search a "tree" node in the hierarchy that match node. may return root! NULL if not found
+		static xmlNodePtr searchTreeNodeInHierarchy(xmlNodePtr root, const char *node);
+
+		/// \name Clearing mgt
+		// @{
+			void removeAllLinks();
+			void removeAllProcedures();
+			void removeAllDefines();
+			void removeAllTemplates();
+			void removeAllAnims();
+			void removeAll();
+		// @}
+
+		// get info on procedure. return 0 if procedure not found
+		uint getProcedureNumActions( const std::string &procName ) const;
+
+		// return false if procedure not found, or if bad action index. return false if has some param variable (@0...)
+		bool getProcedureAction( const std::string &procName, uint actionIndex, std::string &ah, std::string &params ) const;
+
+		void setCacheUIParsing( bool b ){ cacheUIParsing = b; }
+
+	protected:
+
+		/**
+		 * Temporary data for init
+		 */
+
+		/// vector storing parsed templates during init. At the end of init, only used template are kept
+		std::vector<xmlNodePtr> _Templates;
+
+
+		// map linking an element to its parent position used during init only
+		std::map<CInterfaceElement*,std::string> _ParentPositionsMap;
+		std::map<CInterfaceElement*,std::string> _ParentSizesMap;
+		std::map<CInterfaceElement*,std::string> _ParentSizesMaxMap;
+
+		// map linking a group to its lua script. used during init only
+		std::map<CInterfaceGroup*,std::string> _LuaClassAssociation;
+
+		/**
+		 * Data of initialized interface
+		 */
+
+		/// Define Variable list
+		typedef	std::map<std::string, std::string>		TVarMap;
+		typedef	TVarMap::iterator			ItVarMap;
+		typedef	TVarMap::const_iterator		CstItVarMap;
+		TVarMap								_DefineMap;
+
+		bool	validDefineChar(char c) const;
+
+		/// Procedure def
+		class	CParamBlock
+		{
+		public:
+			// -1 if not a param id, but a string
+			sint32		NumParam;
+			std::string		String;
+
+			CParamBlock()
+			{
+				NumParam= -1;
+			}
+		};
+		class	CAction
+		{
+		public:
+			// a condition to launch this action handler (is an expression)
+			std::vector<CParamBlock>	CondBlocks;
+
+			// the action handler (may be proc!!)
+			std::string					Action;
+			// A list of string/or param number => to build the final params at execution
+			std::vector<CParamBlock>	ParamBlocks;
+
+			// build a paramBlock from a string
+			void		buildParamBlock (const std::string &params);
+			// from ParamBlock, and a paramList (skip the 0th), build params.
+			void		buildParams (const std::vector<std::string> &paramList, std::string &params) const;
+
+			void		buildCondBlock (const std::string &params);
+
+			void		buildCond (const std::vector<std::string> &paramList, std::string &cond) const;
+
+			static void buildBlocks (const std::string &in, std::vector<CParamBlock> &out);
+			static void eval (const std::vector<std::string> &inArgs, const std::vector<CParamBlock> &inBlocks, std::string &out);
+
+		};
+		class	CProcedure
+		{
+		public:
+			// List of the actions
+			std::vector<CAction>	Actions;
+		};
+		class	CStyleProperty
+		{
+		public:
+			std::string				Name;
+			std::string				Value;
+		};
+		class	CStyle
+		{
+		public:
+			std::vector<CStyleProperty>		Properties;
+		};
+
+
+		/// Procedure list
+		typedef	std::map<std::string,CProcedure>		TProcedureMap;
+		typedef	TProcedureMap::iterator			ItProcedureMap;
+		typedef	TProcedureMap::const_iterator	CstItProcedureMap;
+		TProcedureMap							_ProcedureMap;
+
+		// mgt of sheet selections (inventory, buy, sell..)
+		CCtrlSheetSelection		  _CtrlSheetSelection;
+
+		// Map of dynamic links
+		typedef std::map<std::string, NLMISC::CSmartPtr<CInterfaceLink> > TLinkMap;
+		TLinkMap _LinkMap;
+
+		// Map of anims
+		typedef std::map<std::string, CInterfaceAnim *> TAnimMap;
+		TAnimMap _AnimMap;
+
+		// Map of styles.
+		typedef	std::map<std::string, CStyle>			TStyleMap;
+		TStyleMap										_StyleMap;
+
+	protected:
+		std::map< std::string, IParserModule* > moduleMap;
+		// LUA
+		// ----------------------------------------------------------------------------------
+		// LUA Interface State. NB: The LUA environnement is not shared between Login/OutGame/InGame
+		NLMISC::CSmartPtr<CLuaState> _LuaState;
+		virtual void initLUA();
+		void uninitLUA();
+		// List of script loaded (for reloadLua command)
+		std::set<std::string>	_LuaFileScripts;
+		// Load A .lua. false if parse error. string 'error' contains the eventual error desc (but warning still displayed)
+		bool				loadLUA(const std::string &luaFile, std::string &error);
+		bool cacheUIParsing;
+	};
+
+}
+
+#endif // RZ_INTERFACE_PARSER_H
diff --git a/code/nel/src/gui/interface_parser.cpp b/code/nel/src/gui/interface_parser.cpp
new file mode 100644
index 000000000..22705fd64
--- /dev/null
+++ b/code/nel/src/gui/interface_parser.cpp
@@ -0,0 +1,2885 @@
+// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
+// Copyright (C) 2010  Winch Gate Property Limited
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include <map>
+#include "nel/misc/rgba.h"
+#include "nel/gui/interface_parser.h"
+#include "nel/misc/i_xml.h"
+#include "nel/misc/file.h"
+#include "nel/misc/algo.h"
+#include "nel/misc/mem_stream.h"
+#include "nel/misc/factory.h"
+#include "nel/misc/big_file.h"
+#include "nel/misc/xml_auto_ptr.h"
+#include "nel/gui/interface_options.h"
+#include "nel/gui/interface_anim.h"
+#include "nel/gui/interface_expr.h"
+#include "nel/gui/view_pointer.h"
+#include "nel/gui/group_modal.h"
+#include "nel/gui/group_list.h"
+#include "nel/gui/group_container.h"
+#include "nel/gui/interface_link.h"
+#include "nel/gui/lua_helper.h"
+#include "nel/gui/lua_ihm.h"
+#include "nel/gui/lua_manager.h"
+
+#ifdef LUA_NEVRAX_VERSION
+	#include "lua_ide_dll_nevrax/include/lua_ide_dll/ide_interface.h" // external debugger
+#endif
+const uint32 UI_CACHE_SERIAL_CHECK = (uint32) 'IUG_';
+
+using namespace NLMISC;
+using namespace std;
+
+namespace NLGUI
+{
+
+	void saveXMLTree(COFile &f, xmlNodePtr node)
+	{
+		// save node name
+		std::string name = (const char *) node->name;
+		f.serial(name);
+		// save properties
+		uint32 numProp = 0;
+		xmlAttrPtr currProp = node->properties;
+		while (currProp)
+		{
+			++ numProp;
+			currProp = currProp->next;
+		}
+		f.serial(numProp);
+		currProp = node->properties;
+		while (currProp)
+		{
+			std::string name = (const char *) currProp->name;
+			f.serial(name);
+			CXMLAutoPtr ptr(xmlGetProp(node, currProp->name));
+			std::string value = (const char *) ptr;
+			f.serial(value);
+			currProp = currProp->next;
+		}
+		uint32 numChildren = 0;
+		xmlNodePtr currChild = node->children;
+		while (currChild)
+		{
+			++ numChildren;
+			currChild = currChild->next;
+		}
+		f.serial(numChildren);
+		currChild = node->children;
+		while (currChild)
+		{
+			saveXMLTree(f, currChild);
+			currChild = currChild->next;
+		}
+	}
+
+	xmlNodePtr buildTree(CIFile &f)
+	{
+		// load node name
+		std::string name;
+		f.serial(name);
+		xmlNodePtr node = xmlNewNode(NULL, (const xmlChar *) name.c_str());
+		// slod properties
+		uint32 numProp;
+		f.serial(numProp);
+		for(uint k = 0; k < numProp; ++k)
+		{
+			std::string name, value;
+			f.serial(name, value);
+			xmlSetProp(node, (const xmlChar *) name.c_str(), (const xmlChar *) value.c_str());
+		}
+		uint32 numChildren;
+		f.serial(numChildren);
+		for(uint k = 0; k < numChildren; ++k)
+		{
+			xmlAddChild(node, buildTree(f));
+		}
+		return node;
+	}
+
+
+
+	// ----------------------------------------------------------------------------
+	// CRootGroup
+	// ----------------------------------------------------------------------------
+
+	class CRootGroup : public CInterfaceGroup
+	{
+	public:
+		CRootGroup(const TCtorParam &param)
+			: CInterfaceGroup(param)
+		{ }
+
+		/// Destructor
+		virtual ~CRootGroup() { }
+
+		virtual CInterfaceElement* getElement (const std::string &id)
+		{
+			if (_Id == id)
+			return this;
+
+			if (id.substr(0, _Id.size()) != _Id)
+				return NULL;
+
+			vector<CViewBase*>::const_iterator itv;
+			for (itv = _Views.begin(); itv != _Views.end(); itv++)
+			{
+				CViewBase *pVB = *itv;
+				if (pVB->getId() == id)
+					return pVB;
+			}
+
+			vector<CCtrlBase*>::const_iterator itc;
+			for (itc = _Controls.begin(); itc != _Controls.end(); itc++)
+			{
+				CCtrlBase* ctrl = *itc;
+				if (ctrl->getId() == id)
+					return ctrl;
+			}
+
+			// Accelerate
+			string sTmp = id;
+			sTmp = sTmp.substr(_Id.size()+1,sTmp.size());
+			string::size_type pos = sTmp.find(':');
+			if (pos != string::npos)
+				sTmp = sTmp.substr(0,pos);
+
+			map<string,CInterfaceGroup*>::iterator it = _Accel.find(sTmp);
+			if (it != _Accel.end())
+			{
+				CInterfaceGroup *pIG = it->second;
+				return pIG->getElement(id);
+			}
+			return NULL;
+		}
+
+		virtual void addGroup (CInterfaceGroup *child, sint eltOrder = -1)
+		{
+			string sTmp = child->getId();
+			sTmp = sTmp.substr(_Id.size()+1,sTmp.size());
+			_Accel.insert(pair<string,CInterfaceGroup*>(sTmp, child));
+			CInterfaceGroup::addGroup(child,eltOrder);
+		}
+
+		virtual bool delGroup (CInterfaceGroup *child, bool dontDelete = false)
+		{
+			string sTmp = child->getId();
+			sTmp = sTmp.substr(_Id.size()+1,sTmp.size());
+			map<string,CInterfaceGroup*>::iterator it = _Accel.find(sTmp);
+			if (it != _Accel.end())
+			{
+				_Accel.erase(it);
+			}
+			return CInterfaceGroup::delGroup(child,dontDelete);
+		}
+
+	private:
+		map<string,CInterfaceGroup*> _Accel;
+	};
+
+	// ----------------------------------------------------------------------------
+	// CInterfaceParser
+	// ----------------------------------------------------------------------------
+
+	// ----------------------------------------------------------------------------
+	CInterfaceParser::CInterfaceParser()
+	{
+		// LUA
+		_LuaState= NULL;
+		cacheUIParsing = false;
+	}
+
+	CInterfaceParser::~CInterfaceParser()
+	{
+		_LuaState = NULL;
+		removeAllModules();
+	}
+	/** Convert a string into a memstream
+	  */
+	static void interfaceScriptAsMemStream(const std::string &script, CMemStream &destStream)
+	{
+		NLMISC::contReset(destStream);
+		if (destStream.isReading()) // we must be sure that we are reading the stream
+		{
+			destStream.invert();
+		}
+		destStream.seek(0, NLMISC::IStream::begin);
+		if (script.empty()) return;
+		destStream.serialBuffer(const_cast<uint8 *>((const uint8 *) &script[0]), (uint)script.size());
+		destStream.invert();
+		destStream.seek(0, NLMISC::IStream::begin);
+	}
+
+	// ----------------------------------------------------------------------------
+	bool CInterfaceParser::parseInterface (const std::vector<std::string> & strings, bool reload, bool isFilename, bool checkInData)
+	{
+		bool	ok;
+
+		bool needCheck = false;
+
+	#if !FINAL_VERSION
+		needCheck = false;
+	#endif
+
+		// TestYoyo. UnHide For Parsing Profile
+		/*
+		NLMISC::CHTimer::startBench();
+		{
+
+		H_AUTO(parseInterface);
+		*/
+
+		//ignore the content of tags containing only white space
+		xmlKeepBlanksDefault(0);
+		//parse all interface files and build a single xml document
+		xmlNodePtr globalEnclosing;
+		nlassert (strings.size());
+		CIXml read;
+		string nextFileName;
+		static const char *SCRIPT_AS_STRING = "<script as string>";
+		try
+		{
+			CIFile file;
+			CMemStream scriptStream;
+			string firstFileName;
+			vector<string>::const_iterator it = strings.begin();
+			if (isFilename)
+			{
+				//get the first file document pointer
+				firstFileName = *it;
+				string filename = CPath::lookup(firstFileName);
+				bool isInData = false;
+				string::size_type pos = filename.find ("@");
+				if (pos != string::npos)
+				{
+					vector<string> bigFilePaths;
+					CBigFile::getInstance().getBigFilePaths(bigFilePaths);
+					if (CBigFile::getInstance().getBigFileName(filename.substr(0, pos)) != "data/"+filename.substr(0, pos))
+						isInData = false;
+					else
+						isInData = true;
+				}
+
+				if ((needCheck && !isInData) || !file.open (CPath::lookup(firstFileName)))
+				{
+					// todo hulud interface syntax error
+					nlwarning ("could not open file %s, skipping xml parsing",firstFileName.c_str());
+					return false;
+				}
+				read.init (file);
+			}
+			else
+			{
+				firstFileName = SCRIPT_AS_STRING; // for error msg
+				interfaceScriptAsMemStream(*it, scriptStream);
+				read.init(scriptStream);
+			}
+			//get the enclosing element (<interface config>)
+			globalEnclosing = read.getRootNode();
+			if (!globalEnclosing)
+			{
+				// todo hulud interface syntax error
+				nlwarning ("no root element in xml file %s, skipping xml parsing",firstFileName.c_str());
+				return false;
+			}
+			if (strcmp( (char*)globalEnclosing->name,"interface_config") )
+			{
+				// todo hulud interface syntax error
+				nlwarning ("wrong root element in xml file %s, skipping xml parsing",firstFileName.c_str());
+				return false;
+			}
+			if (isFilename)
+			{
+				file.close();
+			}
+
+			// Get all other xml files, and add their nodes to the first xml document
+			it++;
+			uint32 i = 0;
+			for (; it != strings.end(); it++)
+			{
+				//nlwarning("Parsing interface file : %s", it->c_str());
+				nextFileName = *it;
+				CIXml nextRead;
+				xmlNodePtr cur = NULL;
+				bool saveParseResult = false;
+				bool readFromUncompressedXML = true;
+				if( isFilename && cacheUIParsing )
+				{
+					saveParseResult = true;
+					std::string archive = CPath::lookup(nextFileName + "_compressed", false, false);
+					std::string current = CPath::lookup(nextFileName, false, false);
+					if (!archive.empty() && !current.empty())
+					{
+						if (CFile::getFileModificationDate(current) <= CFile::getFileModificationDate(archive))
+						{
+							CIFile input;
+							input.open(archive);
+							input.serialCheck(UI_CACHE_SERIAL_CHECK);
+							input.serialVersion(0);
+							cur = buildTree(input);
+							input.serialCheck(UI_CACHE_SERIAL_CHECK);
+							readFromUncompressedXML = false;
+							saveParseResult = false;
+						}
+					}
+				}
+				if (!cur)
+				{
+					if (isFilename)
+					{
+						if (!file.open(CPath::lookup(nextFileName, false, false)))
+						{
+							// todo hulud interface syntax error
+							nlwarning ("could not open file %s, skipping xml parsing",nextFileName.c_str());
+							return false;
+						}
+						nextRead.init (file);
+					}
+					else
+					{
+						interfaceScriptAsMemStream(nextFileName, scriptStream);
+						nextFileName = SCRIPT_AS_STRING; // for error MSG
+						read.init(scriptStream);
+					}
+					cur = nextRead.getRootNode();
+					if (!cur)
+					{
+						// todo hulud interface syntax error
+						nlwarning ("no root element in  xml file %s, skipping xml parsing", it->c_str() );
+						return false;
+					}
+				}
+				if (saveParseResult)
+				{
+					nlassert(isFilename);
+					std::string outputFilename = CPath::standardizePath("data") + CFile::getFilename(nextFileName) + std::string("_compressed");
+					COFile f;
+					f.open(outputFilename);
+					f.serialCheck(UI_CACHE_SERIAL_CHECK);
+					f.serialVersion(0);
+					saveXMLTree(f, cur);
+					f.serialCheck(UI_CACHE_SERIAL_CHECK);
+				}
+				if (strcmp( (char*)cur->name,"interface_config") )
+				{
+					// todo hulud interface syntax error
+					nlwarning ("wrong root element in xml file %s. should be interface config, skipping xml parsing", nextFileName.c_str());
+					return false;
+				}
+				xmlNodePtr curSon = cur->children;
+				while (curSon)
+				{
+					xmlNodePtr bufNode = xmlCopyNode (curSon, 1);
+					xmlAddChild (globalEnclosing,bufNode);
+					curSon = curSon->next;
+				}
+				if (!readFromUncompressedXML)
+				{
+					freeXMLNodeAndSibblings(cur);
+				}
+				if (isFilename)
+				{
+					file.close();
+				}
+				i++;
+			}
+		}
+		catch (const Exception &e)
+		{
+			// Output error
+			// todo hulud interface syntax error
+			nlwarning ("CInterfaceParser: Error while loading the xml interface file %s, skipping xml parsing : %s", nextFileName.c_str(), e.what());
+			if (testWildCard(nextFileName, "save/keys_?*.xml"))
+			{
+				// if file matches 'save/keys_?*.xml', move this file as a backup
+				string	backup = nextFileName+".backup";
+				if (CFile::fileExists(backup))
+					CFile::deleteFile(backup);
+				CFile::moveFile(backup.c_str(), nextFileName.c_str());
+			}
+			return false;
+		}
+		//parse the built doc
+		ok = parseXMLDocument(globalEnclosing, reload);
+	//	freeXMLNodeAndSibblings(globalEnclosing); // Done by the ~CIXml
+
+
+		// TestYoyo. UnHide for Parsing Profile
+		/*
+		}
+		NLMISC::CHTimer::endBench();
+		// Display and save profile to a File.
+		CLog	log;
+		CFileDisplayer	fileDisplayer(NLMISC::CFile::findNewFile(getLogDirectory() + "profile_parseInterface.log"));
+		log.addDisplayer(&fileDisplayer);
+		// diplay
+		NLMISC::CHTimer::displayHierarchicalByExecutionPathSorted(&log, CHTimer::TotalTime, true, 48, 2);
+		NLMISC::CHTimer::display(&log, CHTimer::TotalTime);
+		*/
+
+
+		return ok;
+	}
+
+
+	// ----------------------------------------------------------------------------
+	bool CInterfaceParser::parseXMLDocument(xmlNodePtr root, bool reload)
+	{
+
+		CWidgetManager::SMasterGroup *curRoot = NULL;
+		CInterfaceGroup *rootGroup = NULL;
+		//parse templates
+		xmlNodePtr curNode = root->children;
+
+		std::vector< CWidgetManager::SMasterGroup > &_MasterGroups = CWidgetManager::getInstance()->getAllMasterGroup();
+
+		while (curNode)
+		{
+			// first solve define for the xml node and his sons
+			if(!solveDefine(curNode))
+			{
+				// todo hulud interface syntax error
+				nlwarning ("could not read all define");
+			}
+			// then try to solve Style for the xml node and his sons
+			else if (!solveStyle(curNode))
+			{
+				// todo hulud interface syntax error
+				nlwarning ("could not read all styles");
+			}
+			// If define and style oks, try to parse "1st pass" objets (define, options....).
+			else if ( !strcmp((char*)curNode->name,"template") )
+			{
+				// Check there is a valid name for this template
+				CXMLAutoPtr ptr((const char*) xmlGetProp( curNode, (xmlChar*)"name" ));
+				if (ptr)
+				{
+					// remove any template with the same name in the list (useful when using 'loadui' command)
+					for(uint k = 0; k < _Templates.size(); ++k)
+					{
+						CXMLAutoPtr otherTemplName((const char*) xmlGetProp( _Templates[k], (xmlChar*)"name" ));
+						if (strcmp((const char *) otherTemplName, (const char *) ptr) == 0)
+						{
+							nlwarning("Replacing template %s with new version", (const char *) ptr);
+							xmlFreeNode(_Templates[k]);
+							_Templates[k] = NULL;
+						}
+					}
+					_Templates.erase(std::remove(_Templates.begin(), _Templates.end(), (xmlNodePtr) NULL), _Templates.end());
+					_Templates.push_back(curNode);
+				}
+				else
+					// todo hulud interface syntax error
+					nlwarning ("no name in a template node");
+			}
+			else if ( !strcmp((char*)curNode->name,"options") )
+			{
+				if (!parseOptions(curNode,rootGroup))
+					// todo hulud interface syntax error
+					nlwarning ("could not parse options");
+			}
+			else if ( !strcmp((char*)curNode->name,"define") )
+			{
+				if (!parseDefine(curNode))
+					// todo hulud interface syntax error
+					nlwarning ("could not parse define");
+			}
+			else if ( !strcmp((char*)curNode->name,"style") )
+			{
+				if (!parseStyle(curNode))
+					// todo hulud interface syntax error
+					nlwarning ("could not parse 'style'");
+			}
+			else
+			{
+				IParserModule *module = getModuleFor( (char*)( curNode->name ) );
+				if( module != NULL ){
+					if( module->canParseInStage( IParserModule::Unresolved ) )
+						module->parse( curNode, rootGroup );
+				}
+			}
+
+			curNode = curNode->next;
+		}
+
+
+		if (!reload) // TMP : crahs when doing the setup twice (old pointer on the text manager ...)
+		{
+			setupOptions();
+		}
+
+
+		//parse filters , groups and eventually instances
+		// vector that are on top of the xml hierarchy
+		root = root->children;
+		while (root)
+		{
+			if ( !strcmp((char*)root->name,"root") )
+			{
+				CXMLAutoPtr ptr((const char*)xmlGetProp (root, (xmlChar*)"id"));
+				if (ptr)
+				{
+					rootGroup = CWidgetManager::getInstance()->getMasterGroupFromId (string("ui:") + (const char*)ptr);
+					if (rootGroup == NULL)
+					{
+						rootGroup = (CInterfaceGroup*)(new CRootGroup(CViewBase::TCtorParam()));
+						rootGroup->parse (root, NULL);
+						CWidgetManager::SMasterGroup mg;
+						mg.Group = rootGroup;
+						_MasterGroups.push_back (mg);
+					}
+					for (uint32 i = 0; i < _MasterGroups.size(); ++i)
+						if (_MasterGroups[i].Group == rootGroup)
+							curRoot = &_MasterGroups[i];
+				}
+				else
+				{
+					// todo hulud interface syntax error
+					nlwarning ("could not parse root");
+				}
+			}
+			else if (!strcmp((char*)root->name,"group"))
+			{
+				if (!parseGroup(root,rootGroup, reload))
+					// todo hulud interface syntax error
+					nlwarning ("could not parse group");
+			}
+			else if (!strcmp((char*)root->name,"instance"))
+			{
+				if (!parseInstance(root))
+					// todo hulud interface syntax error
+					nlwarning ("could not parse instance");
+			}
+			else if (!strcmp((char*)root->name,"view"))
+			{
+				if (!parseView(root,rootGroup, reload))
+					// todo hulud interface syntax error
+					nlwarning ("could not parse view");
+			}
+			else if (!strcmp((char*)root->name,"ctrl"))
+			{
+				if (!parseControl(root,rootGroup, reload))
+					// todo hulud interface syntax error
+					nlwarning ("could not parse control");
+			}
+			else if ( !strcmp((char*)root->name,"vector") )
+			{
+				if (!parseVector(root))
+					// todo hulud interface syntax error
+					nlwarning ("could not parse vector");
+			}
+			else if ( !strcmp((char*)root->name,"link") )
+			{
+				if (!parseLink(root,rootGroup))
+					// todo hulud interface syntax error
+					nlwarning ("could not parse link");
+			}
+			else if ( !strcmp((char*)root->name,"variable") )
+			{
+				if (!parseVariable(root,rootGroup))
+					// todo hulud interface syntax error
+					nlwarning ("could not parse variable");
+			}
+			else if ( !strcmp((char*)root->name,"tree") )
+			{
+				if (!parseTree(root,curRoot))
+					// todo hulud interface syntax error
+					nlwarning ("could not parse tree");
+				/* if (!setupTree(root,curRoot))
+					nlwarning ("could not setup tree"); */
+			}
+			else if ( !strcmp((char*)root->name,"proc") )
+			{
+				if (!parseProcedure(root, reload))
+					// todo hulud interface syntax error
+					nlwarning ("could not parse procedure");
+			}
+			else if ( !strcmp((char*)root->name,"sheet_selection") )
+			{
+				if (!parseSheetSelection(root))
+					// todo hulud interface syntax error
+					nlwarning ("could not parse sheet selection");
+			}
+			else if ( !strcmp((char*)root->name,"anim") )
+			{
+				if (!parseAnim(root,rootGroup))
+					// todo hulud interface syntax error
+					nlwarning ("could not parse 'anim'");
+			}
+			else if ( !strcmp((char*)root->name,"lua") )
+			{
+				if(!parseLUAScript(root))
+				{
+					nlwarning ("could not parse 'lua'");
+					exit( EXIT_FAILURE );
+				}
+			}
+			else
+			{
+				IParserModule *module = getModuleFor( (char*)( root->name ) );
+				if( module != NULL )
+				{
+					if( module->canParseInStage( IParserModule::Resolved ) )
+						module->parse( root, rootGroup );
+				}
+			}
+
+			root = root->next;
+		}
+
+		// add all modals group to the window list
+		for (uint32 i = 0; i < _MasterGroups.size(); ++i)
+		{
+
+			CWidgetManager::SMasterGroup &rMG = _MasterGroups[i];
+			// insert all modals
+			for (uint32 j = 0; j < rMG.Group->getGroups().size(); ++j)
+			{
+				CGroupModal *pIG = dynamic_cast<CGroupModal*>(rMG.Group->getGroups()[j]);
+				// if it is a modal group
+				if(pIG)
+				{
+					// add to the window list
+					CWidgetManager::getInstance()->addWindowToMasterGroup(rMG.Group->getId(), pIG);
+				}
+			}
+		}
+
+		// init all the elements coords, and Lua Script
+		if (!initCoordsAndLuaScript())
+			return false;
+
+		std::vector<xmlNodePtr> keptTemplates;
+
+		// keep template that have the "keep" flag if we are not reloading
+		// if reloading, always keep the template
+		{
+			CXMLAutoPtr ptr;
+			for(uint k = 0; k < _Templates.size(); ++k)
+			{
+				CXMLAutoPtr ptr(xmlGetProp(_Templates[k], (const xmlChar *) "keep"));
+				if (reload || (ptr && nlstricmp((const char *) ptr, "true") == 0))
+				{
+					// xmlUnsetProp(_Templates[k], (const xmlChar *) "keep");
+					xmlNodePtr	copy = xmlCopyNode(_Templates[k], 1);
+					if (copy)
+						keptTemplates.push_back(copy);
+				}
+
+				// free the original node, whether we kept a copy or not
+				xmlUnlinkNode( _Templates[k] );
+				xmlFreeNode( _Templates[k] );
+				_Templates[k] = NULL;
+			}
+			// keep new list
+			_Templates.swap(keptTemplates);
+		}
+		return true;
+	}
+
+	// ----------------------------------------------------------------------------
+	bool CInterfaceParser::parseTemplateNode(xmlNodePtr node,xmlNodePtr instance,xmlNodePtr templ)
+	{
+		CXMLAutoPtr ptr;
+		//get the node properties
+		xmlAttrPtr props = node->properties;
+		while (props)
+		{
+			//get the property value
+			ptr = (char*)xmlGetProp( node, props->name);
+			nlassert(ptr);
+			//if it begins with a #, it is a reference in the instance attribute
+			if (strchr(ptr, '#') != NULL)
+			{
+				string LastProp = ptr;
+				string NewProp ="";
+				string RepProp;
+
+				while (LastProp.size() > 0)
+				{
+					string::size_type diesPos = LastProp.find("#");
+					if (diesPos != string::npos)
+					{
+						if (diesPos > 0)
+						{
+							NewProp += LastProp.substr(0, LastProp.find("#"));
+							LastProp = LastProp.substr(LastProp.find("#"),LastProp.size());
+						}
+
+						CXMLAutoPtr instanceProp;
+						for (uint32 i = 0; i < LastProp.size(); ++i)
+						{
+							RepProp = LastProp.substr(0, LastProp.size()-i);
+							instanceProp = xmlGetProp (instance , (const xmlChar*)(RepProp.c_str() + 1));
+							if (instanceProp)
+								break;
+							instanceProp = xmlGetProp (templ , (const xmlChar*)(RepProp.c_str() + 1));
+							if (instanceProp)
+								break;
+						}
+						if (!instanceProp)
+						{
+							CXMLAutoPtr ptr2((const char*)xmlGetProp( instance, (xmlChar*)"id"));
+							string sTmp;
+							if (ptr2.getDatas() != NULL)
+								sTmp = string("cannot parse template node property: ") + ((const char *) ptr + 1) + string(" in instance : ") + string((const char*)ptr2);
+							else
+								sTmp = string("cannot parse template node property: ") + ((const char *) ptr + 1) + string(" in instance : NULL");
+							// todo hulud interface syntax error
+							nlinfo(sTmp.c_str());
+
+							return false;
+						}
+						NewProp += string((const char*)instanceProp);
+						LastProp = LastProp.substr (RepProp.size(), LastProp.size());
+					}
+					else
+					{
+						NewProp += LastProp;
+						LastProp = "";
+					}
+				}
+				xmlSetProp(node,props->name, (const xmlChar*)NewProp.c_str());
+			}
+			props = props->next;
+		}
+		//parse the node children
+		node = node->children;
+		while (node)
+		{
+			if (!parseTemplateNode(node,instance,templ))
+				return false;
+			node = node->next;
+		}
+		return true;
+	}
+
+	// ----------------------------------------------------------------------------
+	bool CInterfaceParser::parseInstance(xmlNodePtr cur)
+	{
+		CXMLAutoPtr ptr;
+
+		//try to find the instance template in our template vector. If the template doesn't exist, return false
+		CXMLAutoPtr templ((const char*) xmlGetProp( cur, (xmlChar*)"template" ));
+		if (!templ)
+		{
+			// todo hulud interface syntax error
+			nlinfo("parse error : no referenced template in an instance");
+			return false;
+		}
+		vector<xmlNodePtr>::const_iterator it;
+		for (it = _Templates.begin(); it != _Templates.end();it++)
+		{
+			ptr = (char*) xmlGetProp( *it, (xmlChar*)"name" );
+			if (!ptr)
+			{
+				// todo hulud interface syntax error
+				nlinfo("no name in a template node");
+				return false;
+			}
+			if ( !strcmp(templ,ptr) )
+			{
+				break;
+			}
+		}
+		if ( it == _Templates.end() )
+		{
+			// todo hulud interface syntax error
+			nlinfo("the template %s was not found", (const char*)templ);
+			return false;
+		}
+
+		xmlNodePtr templNode = *it;
+		//for each child of the template, create the appropriate node
+		xmlNodePtr child = (*it)->children;
+		xmlNodePtr nextSibling=cur;
+		while (child)
+		{
+			//copy the template child node
+			xmlNodePtr node = xmlCopyNode (child, 1);
+
+			//add it to our tree
+			//node = xmlAddChild(cur->parent,node);
+			node = xmlAddNextSibling (nextSibling, node);
+			nextSibling = nextSibling->next;
+
+			//parse the child
+			if (!parseTemplateNode(node, cur, templNode))
+				return false;
+			child = child->next;
+		}
+		return true;
+	}
+
+	// ----------------------------------------------------------------------------
+	bool CInterfaceParser::parseVector(xmlNodePtr cur)
+	{
+		//get the number of elements
+		CXMLAutoPtr cSize((const char*) xmlGetProp( cur, (xmlChar*)"_size" ));
+		if (!cSize)
+		{
+			// todo hulud interface syntax error
+			nlinfo("no _size in a vector");
+			return false;
+		}
+		sint32 size;
+		fromString(cSize, size);
+		if (size <= 0)
+		{
+			// todo hulud interface syntax error
+			nlinfo("size<0");
+			return false;
+		}
+
+		// Vector of groups
+		bool bGroupVector = true;
+
+		//get the first position reference
+		CXMLAutoPtr firstpos((const char*) xmlGetProp( cur, (xmlChar*)"_firstpos" ));
+		if (!firstpos)
+		{
+			bGroupVector = false;
+		}
+		//get the next position reference
+		CXMLAutoPtr nextpos((const char*) xmlGetProp( cur, (xmlChar*)"_nextpos" ));
+		if (!nextpos)
+		{
+			bGroupVector = false;
+		}
+
+		sint32 index = 0;
+		//get the first index value
+		CXMLAutoPtr indexChar((const char*) xmlGetProp( cur, (xmlChar*)"_firstindex" ));
+		if (indexChar)
+		{
+			fromString((const char*)indexChar, index);
+		}
+
+		sint32 step = 1;
+		//get the step for the indices
+		CXMLAutoPtr stepChar((const char*) xmlGetProp( cur, (xmlChar*)"_step" ));
+		if (stepChar)
+		{
+			fromString((const char*)stepChar, step);
+		}
+
+
+		//get the x and y of the first element
+		CXMLAutoPtr xfirst((const char*) xmlGetProp( cur, (xmlChar*)"_xfirst" ));
+		CXMLAutoPtr yfirst((const char*) xmlGetProp( cur, (xmlChar*)"_yfirst" ));
+
+		xmlNodePtr node;
+		CXMLAutoPtr id;
+		xmlNodePtr nextSibling= cur;
+		//now we can add all the following elements
+		sint32 i;
+		for (i = index;; i += step)
+		{
+			if (step > 0)
+			{
+				if (i >= index + size) break;
+			}
+			else
+			{
+				if (i <= index - size) break;
+			}
+			//copy the node
+			node = xmlCopyNode(cur,1);
+			//set the name and posref
+
+			if (bGroupVector)
+			{
+				if (i==index)
+				{
+					xmlSetProp(node,(xmlChar*)"posref",(const xmlChar*)firstpos);
+					if (xfirst)
+					{
+						xmlSetProp(node,(xmlChar*)"x",(const xmlChar*)xfirst);
+					}
+					if (yfirst)
+					{
+						xmlSetProp(node,(xmlChar*)"y",(const xmlChar*)yfirst);
+					}
+				}
+				else
+				{
+					xmlSetProp(node,(xmlChar*)"posref",(const xmlChar*)nextpos);
+					xmlSetProp(node,(xmlChar*)"posparent",(const xmlChar*)id);
+				}
+			}
+
+			xmlNodeSetName(node,(xmlChar*)"instance");
+
+			//replace all the $i
+			xmlAttrPtr attr = node->properties;
+			while(attr)
+			{
+				CXMLAutoPtr prop((const char*) xmlGetProp( node, attr->name ));
+				string str((const char*)prop);
+				string::size_type pos = str.find("$i");
+				while (pos != string::npos)
+				{
+					str.replace(pos,2,toString(i));
+					pos = str.find("$i",pos);
+				}
+				xmlSetProp(node,attr->name,(xmlChar*)str.c_str());
+				attr = attr->next;
+
+			}
+			//add the new instance to our tree, just near us.
+			xmlAddNextSibling (nextSibling, node);
+			nextSibling= node;
+
+			//get the node id, used in the next iteration
+			if (bGroupVector)
+			{
+				id = (char*) xmlGetProp( node, (xmlChar*)"id" );
+				if (!id)
+				{
+					// todo hulud interface syntax error
+					nlinfo("no id in a vector");
+					break;
+				}
+			}
+		}
+
+		return step > 0 ? (i == index + size) : (i == index - size);
+	}
+
+	// ----------------------------------------------------------------------------
+	bool CInterfaceParser::parseLink(xmlNodePtr cur, CInterfaceGroup * parentGroup)
+	{
+		CXMLAutoPtr ptr((const char*) xmlGetProp (cur, (xmlChar*)"expr"));
+		if (!ptr)
+		{
+			// todo hulud interface syntax error
+			nlwarning("<CInterfaceParser::parseLink> Can't read  the expression for a link node");
+			return false;
+		}
+		std::string expr = ptr;
+
+
+		std::vector<CInterfaceLink::CTargetInfo> targets;
+
+		ptr = (char*) xmlGetProp (cur, (xmlChar*)"target");
+		if (ptr)
+		{
+			CInterfaceLink::splitLinkTargets(std::string((const char*)ptr), parentGroup, targets);
+		}
+		// optional action handler
+		std::string action;
+		std::string params;
+		std::string cond;
+		ptr = (char*) xmlGetProp (cur, (xmlChar*)"action");
+		if (ptr) action = (const char *) ptr;
+		ptr = (char*) xmlGetProp (cur, (xmlChar*)"params");
+		if (ptr) params = (const char *) ptr;
+		ptr = (char*) xmlGetProp (cur, (xmlChar*)"cond");
+		if (ptr) cond = (const char *) ptr;
+
+		// create the link
+		CInterfaceLink *il = new CInterfaceLink;
+		il->init(targets, expr, action, params, cond, parentGroup); // init will add 'il' in the list of link present in 'elm'
+		return true;
+	}
+
+	// ----------------------------------------------------------------------------
+	bool CInterfaceParser::parseVariable (xmlNodePtr cur, CInterfaceGroup * /* parentGroup */)
+	{
+		//get the args
+		CXMLAutoPtr ptr((const char*) xmlGetProp (cur, (xmlChar*)"entry"));
+		if (!ptr)
+		{
+			// todo hulud interface syntax error
+			nlinfo ("no entry in a variable tag");
+			return false;
+		}
+		string entry((const char*)ptr);
+
+		ptr = (char*) xmlGetProp (cur, (xmlChar*)"type");
+		if (!ptr)
+		{
+			// todo hulud interface syntax error
+			nlinfo ("no type in a variable tag");
+			return false;
+		}
+		string type((const char*)ptr);
+
+		string value;
+		ptr = (char*) xmlGetProp (cur, (xmlChar*)"value");
+		if (!ptr)
+		{
+			//if no value is specified, try to get the db entry directly
+			value = entry;
+		}
+		else
+			value = string((const char*)ptr);
+
+		// Array definition
+		sint	size= 1;
+		bool	ArrayMode= false;
+		string	entryPrefix;
+		string	entrySuffix;
+		ptr = (char*) xmlGetProp (cur, (xmlChar*)"size");
+		if (ptr)
+		{
+			ArrayMode= true;
+			fromString((const char*)ptr, size);
+			string::size_type pos= entry.find("$i");
+			if( pos==string::npos )
+			{
+				// todo hulud interface syntax error
+				nlinfo ("no $i found in a 'variable' tag with 'size' defined ");
+				return false;
+			}
+			else
+			{
+				entryPrefix= entry.substr(0, pos);
+				entrySuffix= entry.substr(pos+2);
+			}
+		}
+
+		// loop all variables
+		for(sint index= 0;index<size;index++)
+		{
+			// If array variable, build the variable name
+			if(ArrayMode)
+			{
+				entry= entryPrefix + toString(index) + entrySuffix;
+			}
+
+			// access the database
+			CInterfaceProperty prop;
+
+			if (type == "sint64")
+				prop.readSInt64(value.c_str(),entry);
+			else if (type == "sint32")
+				prop.readSInt32(value.c_str(),entry);
+			else if (type == "float" || type == "double")
+				prop.readDouble(value.c_str(),entry);
+			else if (type == "bool")
+				prop.readBool(value.c_str(),entry);
+			else if (type == "rgba")
+				prop.readRGBA(value.c_str(),entry);
+			else if (type == "hotspot")
+				prop.readHotSpot(value.c_str(),entry);
+			else if (type == "text")
+			{
+				/*uint textId = addText(value);
+				prop.readSInt32(toString(textId),entry);*/
+			}
+		}
+
+		return true;
+	}
+
+	// ----------------------------------------------------------------------------
+	bool CInterfaceParser::parseOptions (xmlNodePtr cur, CInterfaceGroup * /* parentGroup */)
+	{
+		// build the options from type
+		CInterfaceOptions *options = NULL;
+		CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"type" ));
+		if (ptr)
+		{
+			options = NLMISC_GET_FACTORY( CInterfaceOptions, std::string ).createObject( std::string( (const char*)ptr ), CInterfaceOptions::TCtorParam() );
+
+			if( options == NULL )
+				options = new CInterfaceOptions( CInterfaceOptions::TCtorParam() );
+		}
+		else
+		{
+			options = new CInterfaceOptions( CInterfaceOptions::TCtorParam() );
+		}
+
+		CWidgetManager *wm = CWidgetManager::getInstance();
+
+		// get the name
+		ptr = (char*) xmlGetProp( cur, (xmlChar*)"name" );
+		if (!ptr)
+		{
+			// todo hulud interface syntax error
+			nlinfo ("options has no name");
+			return false;
+		}
+		string optionsName = ptr;
+
+		// herit if possible
+		ptr = (char*) xmlGetProp( cur, (xmlChar*)"herit" );
+		if (ptr)
+		{
+			string optionsParentName = ptr;
+			CInterfaceOptions *io = wm->getOptions( optionsParentName );
+			if( io != NULL )
+				options->copyBasicMap( *io );
+		}
+
+		// parse parameters
+		if (options->parse (cur))
+		{
+			// Remove old one
+			wm->removeOptions( optionsName );
+			wm->addOptions( optionsName, options );
+		}
+		else
+		{
+			delete options;
+			return false;
+		}
+		return true;
+	}
+
+	// ----------------------------------------------------------------------------
+	bool CInterfaceParser::parseGroup (xmlNodePtr cur, CInterfaceGroup * parentGroup, bool reload)
+	{
+		CInterfaceGroup * group;
+		CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"type" ));
+		if (ptr)
+		{
+			group = dynamic_cast<CInterfaceGroup*>( NLMISC_GET_FACTORY(CViewBase, std::string).createObject(string((const char*)ptr), CViewBase::TCtorParam()) );
+			if (group == NULL)
+			{
+				group = dynamic_cast<CInterfaceGroup*>(NLMISC_GET_FACTORY(CViewBase, std::string).createObject("interface_group", CViewBase::TCtorParam()));
+			}
+
+		}
+		else
+			group = dynamic_cast<CInterfaceGroup*>(NLMISC_GET_FACTORY(CViewBase, std::string).createObject("interface_group", CViewBase::TCtorParam()));
+
+		// parse the group attributes
+		if (!group->parse(cur,parentGroup))
+		{
+			delete group;
+			// todo hulud interface syntax error
+			nlwarning ("cannot parse group attributes");
+			return false;
+		}
+
+		if (parentGroup)
+		{
+			CGroupList *pList = dynamic_cast<CGroupList*>(parentGroup);
+			if (parentGroup->getElement(group->getId()) != NULL)
+			{
+				// Remove old groupe and replace
+				if (reload)
+				{
+					// Remove from the parent
+					parentGroup->delElement (group->getId(), true);
+				}
+				else
+				{
+					// todo hulud interface syntax error
+					nlwarning ("id already exists for %s in %s", group->getId().c_str(), parentGroup->getId().c_str());
+					delete group;
+					return false;
+				}
+			}
+
+			if (pList != NULL)
+				pList->addChild (group);
+			else
+				parentGroup->addGroup (group);
+		}
+		else
+		{
+			// todo hulud interface syntax error
+			nlinfo ("no parent for %s", group->getId().c_str());
+			delete group;
+			return false;
+		}
+
+		//parse the children
+		bool ok = parseGroupChildren(cur, group, reload);
+
+		if (!ok)
+		{
+			string tmp = "cannot parse group "+group->getId();
+			// todo hulud interface syntax error
+			nlinfo (tmp.c_str());
+		}
+		return ok;
+	}
+
+	// ----------------------------------------------------------------------------
+	bool CInterfaceParser::parseGroupChildren(xmlNodePtr cur, CInterfaceGroup * parentGroup, bool reload)
+	{
+		cur = cur->children;
+		bool ok = true;
+		while (cur)
+		{
+			if ( !strcmp((char*)cur->name,"view") )
+				ok = ok && parseView(cur,parentGroup, reload);
+			else if ( !strcmp((char*)cur->name,"ctrl") )
+				ok = ok && parseControl(cur,parentGroup, reload);
+			else if ( !strcmp((char*)cur->name,"group") )
+				ok = ok && parseGroup(cur,parentGroup, reload);
+			else if ( !strcmp((char*)cur->name,"instance") )
+				ok = ok && parseInstance(cur);
+			else if ( !strcmp((char*)cur->name,"vector") )
+				ok = ok && parseVector(cur);
+			else if ( !strcmp((char*)cur->name,"link") )
+				ok = ok && parseLink(cur,parentGroup);
+			else
+			{
+				IParserModule *module = getModuleFor( (char*)( cur->name ) );
+				if( module != NULL )
+				{
+					if( module->canParseInStage( IParserModule::GroupChildren ) )
+						ok = ok && module->parse( cur, parentGroup );
+				}
+			}
+
+
+			cur = cur->next;
+		}
+		return ok;
+	}
+
+	// ----------------------------------------------------------------------------
+	bool CInterfaceParser::parseControl (xmlNodePtr cur, CInterfaceGroup * parentGroup, bool reload)
+	{
+		CCtrlBase* ctrl = NULL;
+		CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"type" ));
+		if (!ptr)
+		{
+			// todo hulud interface syntax error
+			nlinfo ("no type in a control tag");
+			return false;
+		}
+
+		ctrl = dynamic_cast<CCtrlBase*>(NLMISC_GET_FACTORY(CViewBase, std::string).createObject(string((const char*)ptr), CViewBase::TCtorParam()));
+
+		if (ctrl)
+		{
+			if (!ctrl->parse(cur,parentGroup))
+			{
+				delete ctrl;
+				return false;
+			}
+			if (parentGroup->getElement(ctrl->getId()) != NULL)
+			{
+				// Remove old groupe and replace
+				if (reload)
+					parentGroup->delElement (ctrl->getId());
+				else
+				{
+					// todo hulud interface syntax error
+					nlwarning ("id already exists for %s in %s", ctrl->getId().c_str(), parentGroup->getId().c_str());
+					delete ctrl;
+					return false;
+				}
+			}
+			// Add the ctrl to the parent group
+			parentGroup->addCtrl(ctrl);
+			return true;
+		}
+		return false;
+	}
+
+	// ----------------------------------------------------------------------------
+	bool CInterfaceParser::parseView(xmlNodePtr cur, CInterfaceGroup * parentGroup, bool reload)
+	{
+		CViewBase * view=NULL;
+		CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"type" ));
+		if (!ptr)
+		{
+			// todo hulud interface syntax error
+			nlinfo("no type in a view");
+			return false;
+		}
+
+		view = NLMISC_GET_FACTORY(CViewBase, std::string).createObject(string((const char*)ptr), CViewBase::TCtorParam());
+
+		if ( !strcmp(ptr,"pointer"))
+		{
+			CWidgetManager::getInstance()->setPointer( dynamic_cast<CViewPointer*>(view) );
+		}
+
+		//nlinfo("view type %s mem : %d",ptr,view->getMemory());
+		if (view)
+		{
+			if (!view->parse(cur,parentGroup))
+			{
+				delete view;
+				return false;
+			}
+			if (parentGroup->getElement(view->getId()) != NULL)
+			{
+				// Remove old groupe and replace
+				if (reload)
+					parentGroup->delElement (view->getId());
+				else
+				{
+					// todo hulud interface syntax error
+					nlwarning ("id already exists for %s in %s", view->getId().c_str(), parentGroup->getId().c_str());
+					delete view;
+					return false;
+				}
+			}
+
+			//add the view to the parent group
+			CGroupList *pList = dynamic_cast<CGroupList*>(parentGroup);
+			if (pList != NULL)
+			{
+				pList->addChild (view);
+			}
+			else
+			{
+				parentGroup->addView(view);
+			}
+			return true;
+		}
+		// todo hulud interface syntax error
+		nlinfo("unknown view type %s", (const char*)ptr);
+		return false;
+	}
+
+	// ----------------------------------------------------------------------------
+	bool CInterfaceParser::parseTreeNode (xmlNodePtr cur, CGroupContainer *parentGroup)
+	{
+		CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"node" ));
+		if (!ptr) return false;
+		CInterfaceElement *pEltFound = NULL;
+		std::vector< CWidgetManager::SMasterGroup > &_MasterGroups = CWidgetManager::getInstance()->getAllMasterGroup();
+		for (uint32 i = 0; i < _MasterGroups.size(); ++i)
+		{
+			CWidgetManager::SMasterGroup &rMG = _MasterGroups[i];
+			for (uint32 j = 0; j < rMG.Group->getGroups().size(); ++j)
+			{
+				CInterfaceGroup *pIG = rMG.Group->getGroups()[j];
+				string stmp = strlwr(pIG->getId().substr(pIG->getId().rfind(':')+1,pIG->getId().size()));
+				string stmp2 = strlwr(string((const char*)ptr));
+				if (stmp == stmp2)
+				{
+					pEltFound = pIG;
+					break;
+				}
+			}
+			if (pEltFound != NULL)
+				break;
+		}
+		if (pEltFound == NULL)
+		{
+			string stmp = string("element not found for tree : ") + string((const char*)ptr);
+			// todo hulud interface syntax error
+			nlinfo(stmp.c_str());
+			return false;
+		}
+		CGroupContainer *pIC = dynamic_cast<CGroupContainer*>(pEltFound);
+		if (pIC == NULL)
+		{
+			string stmp = string("not a container : ") + pEltFound->getId();
+			// todo hulud interface syntax error
+			nlinfo(stmp.c_str());
+			return false;
+		}
+		parentGroup->attachContainer (pIC);
+		cur = cur->children;
+		while (cur)
+		{
+			parseTreeNode(cur, pIC);
+			cur = cur->next;
+		}
+		return true;
+	}
+
+	// ----------------------------------------------------------------------------
+	bool CInterfaceParser::setupTreeNode (xmlNodePtr cur, CGroupContainer * /* parentGroup */)
+	{
+		CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"node" ));
+		if (!ptr) return false;
+		std::vector< CWidgetManager::SMasterGroup > &_MasterGroups = CWidgetManager::getInstance()->getAllMasterGroup();
+		CInterfaceElement *pEltFound = NULL;
+		for (uint32 i = 0; i < _MasterGroups.size(); ++i)
+		{
+			CWidgetManager::SMasterGroup &rMG = _MasterGroups[i];
+			for (uint32 j = 0; j < rMG.Group->getGroups().size(); ++j)
+			{
+				CInterfaceGroup *pIG = rMG.Group->getGroups()[j];
+				string stmp = strlwr(pIG->getId().substr(pIG->getId().rfind(':')+1,pIG->getId().size()));
+				string stmp2 = strlwr(string((const char*)ptr));
+				if (stmp == stmp2)
+				{
+					pEltFound = pIG;
+					break;
+				}
+			}
+			if (pEltFound != NULL)
+				break;
+		}
+		if (pEltFound == NULL)
+		{
+			string stmp = string("element not found for tree : ") + string((const char*)ptr);
+			// todo hulud interface syntax error
+			nlinfo(stmp.c_str());
+			return false;
+		}
+		CGroupContainer *pIC = dynamic_cast<CGroupContainer*>(pEltFound);
+		if (pIC == NULL)
+		{
+			string stmp = string("not a container : ") + pEltFound->getId();
+			// todo hulud interface syntax error
+			nlinfo(stmp.c_str());
+			return false;
+		}
+		// See if the group should be docked.
+		ptr = (char*) xmlGetProp( cur, (xmlChar*)"docked" );
+		if (nlstricmp((const char *) ptr, "true") == 0)
+		{
+			// dock the container
+			pIC->popupCurrentPos();
+			// compute position on screen
+			sint32 x = 0, y = 0, w = 200, h = 100;
+			ptr = (char*) xmlGetProp( cur, (xmlChar*)"x" );
+			if (ptr)
+			{
+				sint32 value;
+				if (fromString((const char*)ptr, value))
+				{
+					x = value;
+				}
+			}
+			ptr = (char*) xmlGetProp( cur, (xmlChar*)"y" );
+			if (ptr)
+			{
+				sint32 value;
+				if (fromString((const char*)ptr, value))
+				{
+					y = value;
+				}
+			}
+			ptr = (char*) xmlGetProp( cur, (xmlChar*)"w" );
+			if (ptr)
+			{
+				sint32 value;
+				if (fromString((const char*)ptr, value))
+				{
+					w = value;
+				}
+			}
+			ptr = (char*) xmlGetProp( cur, (xmlChar*)"h" );
+			if (ptr)
+			{
+				sint32 value;
+				if (fromString((const char*)ptr, value))
+				{
+					h = value;
+				}
+			}
+			pIC->setX(x);
+			pIC->setY(y);
+			pIC->setW(w);
+			pIC->setH(h);
+			pIC->invalidateCoords();
+		}
+		//
+		while (cur)
+		{
+			setupTreeNode(cur, pIC);
+			cur = cur->next;
+		}
+		return true;
+	}
+
+	void CInterfaceParser::addModule( std::string name, IParserModule *module )
+	{
+		std::map< std::string, IParserModule* >::iterator itr =
+			moduleMap.find( name );
+
+		if( itr != moduleMap.end() )
+		{
+			nlwarning( "Tried to add parser module %s, which already exists.",name.c_str() );
+			delete module;
+			return;
+		}
+
+		module->setParser( this );
+		moduleMap[ name ] = module;
+	}
+
+	CInterfaceParser::IParserModule* CInterfaceParser::getModuleFor( std::string name ) const
+	{
+		std::map< std::string, IParserModule* >::const_iterator itr =
+			moduleMap.find( name );
+		if( itr == moduleMap.end() )
+			return NULL;
+		else
+			return itr->second;
+	}
+
+	void CInterfaceParser::removeAllModules()
+	{
+		std::map< std::string, IParserModule* >::iterator itr;
+		for( itr = moduleMap.begin(); itr != moduleMap.end(); ++itr )
+		{
+			delete itr->second;
+		}
+		moduleMap.clear();
+	}
+
+	// ----------------------------------------------------------------------------
+	bool CInterfaceParser::setupTree (xmlNodePtr cur, CWidgetManager::SMasterGroup * /* parentGroup */)
+	{
+		CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"node" ));
+		if (!ptr) return false;
+		std::vector< CWidgetManager::SMasterGroup > &_MasterGroups = CWidgetManager::getInstance()->getAllMasterGroup();
+		CInterfaceElement *pEltFound = NULL;
+		for (uint32 i = 0; i < _MasterGroups.size(); ++i)
+		{
+			CWidgetManager::SMasterGroup &rMG = _MasterGroups[i];
+			for (uint32 j = 0; j < rMG.Group->getGroups().size(); ++j)
+			{
+				CInterfaceGroup *pIG = rMG.Group->getGroups()[j];
+				string stmp = strlwr(pIG->getId().substr(pIG->getId().rfind(':')+1,pIG->getId().size()));
+				string stmp2 = strlwr(string((const char*)ptr));
+				if (stmp == stmp2)
+				{
+					pEltFound = pIG;
+					break;
+				}
+			}
+			if (pEltFound != NULL)
+				break;
+		}
+
+		if (pEltFound == NULL)
+		{
+			string stmp = string("no group found for ") + string((const char*)ptr);
+			// todo hulud interface syntax error
+			nlinfo(stmp.c_str());
+			return false;
+		}
+
+		// the element must be a group
+		CInterfaceGroup *pIG = dynamic_cast<CInterfaceGroup*>(pEltFound);
+		if (pIG == NULL)
+		{
+			string stmp = string("not a group !") + pEltFound->getId();
+			// todo hulud interface syntax error
+			nlinfo(stmp.c_str());
+			return false;
+		}
+
+		// but must not be a group modal
+		if (dynamic_cast<CGroupModal*>(pIG))
+		{
+			string stmp = string("tree can't have modal group !") + pEltFound->getId();
+			// todo hulud interface syntax error
+			nlinfo(stmp.c_str());
+			return false;
+		}
+
+
+		CGroupContainer *pIC = dynamic_cast<CGroupContainer*>(pEltFound);
+		if (pIC != NULL)
+		{
+			cur = cur->children;
+			while (cur)
+			{
+				setupTreeNode(cur, pIC);
+				cur = cur->next;
+			}
+		}
+		return true;
+	}
+
+
+
+	// ----------------------------------------------------------------------------
+	bool CInterfaceParser::parseTree (xmlNodePtr cur, CWidgetManager::SMasterGroup *parentGroup)
+	{
+		CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"node" ));
+		if (!ptr) return false;
+		std::vector< CWidgetManager::SMasterGroup > &_MasterGroups = CWidgetManager::getInstance()->getAllMasterGroup();
+		CInterfaceElement *pEltFound = NULL;
+		for (uint32 i = 0; i < _MasterGroups.size(); ++i)
+		{
+			CWidgetManager::SMasterGroup &rMG = _MasterGroups[i];
+			for (uint32 j = 0; j < rMG.Group->getGroups().size(); ++j)
+			{
+				CInterfaceGroup *pIG = rMG.Group->getGroups()[j];
+				string stmp = NLMISC::toLower(pIG->getId().substr(pIG->getId().rfind(':')+1,pIG->getId().size()));
+				string stmp2 = NLMISC::toLower(string((const char*)ptr));
+				if (stmp == stmp2)
+				{
+					pEltFound = pIG;
+					break;
+				}
+			}
+			if (pEltFound != NULL)
+				break;
+		}
+
+		if (pEltFound == NULL)
+		{
+			string stmp = string("no group found for ") + string((const char*)ptr);
+			// todo hulud interface syntax error
+			nlinfo(stmp.c_str());
+			return false;
+		}
+
+		// the element must be a group
+		CInterfaceGroup *pIG = dynamic_cast<CInterfaceGroup*>(pEltFound);
+		if (pIG == NULL)
+		{
+			string stmp = string("not a group !") + pEltFound->getId();
+			// todo hulud interface syntax error
+			nlinfo(stmp.c_str());
+			return false;
+		}
+
+		// but must not be a group modal
+		if (dynamic_cast<CGroupModal*>(pIG))
+		{
+			string stmp = string("tree can't have modal group !") + pEltFound->getId();
+			// todo hulud interface syntax error
+			nlinfo(stmp.c_str());
+			return false;
+		}
+
+		// Ok add it.
+		CWidgetManager::getInstance()->addWindowToMasterGroup(parentGroup->Group->getId(), pIG);
+
+		CGroupContainer *pIC = dynamic_cast<CGroupContainer*>(pEltFound);
+		if (pIC != NULL)
+		{
+			cur = cur->children;
+			while (cur)
+			{
+				parseTreeNode(cur, pIC);
+				cur = cur->next;
+			}
+		}
+		return true;
+	}
+
+	// ----------------------------------------------------------------------------
+	bool CInterfaceParser::parseDefine(xmlNodePtr cur)
+	{
+		CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"id" ));
+		if (!ptr || *ptr==0)
+		{
+			// todo hulud interface syntax error
+			nlinfo ("no id in a define");
+			return false;
+		}
+		CXMLAutoPtr ptrVal2;
+		CXMLAutoPtr ptrVal((const char*) xmlGetProp( cur, (xmlChar*)"value" ));
+		if (!ptrVal)
+		{
+			ptrVal2 = (char*) xmlGetProp( cur, (xmlChar*)"value_from_code" );
+			if (!ptrVal2)
+			{
+				// todo hulud interface syntax error
+				nlwarning ("<parseDefine> : no value nor value_from_code in a define");
+				return false;
+			}
+		}
+
+		// verify id.
+		string	id= (const char*)ptr;
+		for(uint i=0;i<id.size();i++)
+		{
+			if(!validDefineChar(id[i]))
+			{
+				// todo hulud interface syntax error
+				nlwarning ("<parseDefine> : bad id in a define. Bad char found: %c", id[i]);
+				return false;
+			}
+		}
+
+		// Check if we have to execute some code
+		if (ptrVal2)
+		{
+			CInterfaceExprValue res;
+
+			if (CInterfaceExpr::eval(ptrVal2, res))
+			{
+				if (!res.toString())
+				{
+					// todo hulud interface syntax error
+					nlwarning ("<parseDefine> : cant eval to string value_from_code : %s", (const char*)ptrVal2);
+					return false;
+				}
+				setDefine(id, res.getString().c_str());
+			}
+			else
+			{
+				// todo hulud interface syntax error
+				nlwarning ("<parseDefine> : cant eval value_from_code : %s", (const char*)ptrVal2);
+				return false;
+			}
+		}
+		else
+		{
+			// Assign var
+			setDefine (id, (const char*)ptrVal);
+		}
+
+		return true;
+	}
+
+	// ----------------------------------------------------------------------------
+	bool CInterfaceParser::parseProcedure(xmlNodePtr cur, bool reload)
+	{
+		CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"id" ));
+		if (!ptr || *ptr==0)
+		{
+			// todo hulud interface syntax error
+			nlwarning ("no id in a procedure");
+			return false;
+		}
+		string	procId= ptr;
+
+		if (_ProcedureMap.find(procId) != _ProcedureMap.end())
+		{
+			// If reloading the interface, remove the old proc
+			if (reload)
+			{
+				_ProcedureMap.erase (procId);
+			}
+			else
+			{
+				// todo hulud interface syntax error
+				nlwarning ("id already exists for procedure %s", procId.c_str());
+				return false;
+			}
+		}
+
+		// build the procedure
+		CProcedure	newProc;
+
+		// Look for sons.
+		cur = cur->children;
+		while (cur)
+		{
+			if (stricmp((char*)cur->name,"action") == 0)
+			{
+				CXMLAutoPtr name((const char*) xmlGetProp (cur, (xmlChar*)"handler"));
+				CXMLAutoPtr params((const char*) xmlGetProp (cur, (xmlChar*)"params"));
+				CXMLAutoPtr cond((const char*) xmlGetProp (cur, (xmlChar*)"cond"));
+				CAction	action;
+				if(!name)
+				{
+					// todo hulud interface syntax error
+					nlinfo("no action name in a action of procedure %s", procId.c_str());
+					return false;
+				}
+				else
+					action.Action= (const char*)name;
+				if(params)
+					action.buildParamBlock((const char*)params);
+				if(cond)
+					action.buildCondBlock ((const char*)cond);
+				newProc.Actions.push_back(action);
+			}
+			else if (!strcmp((char*)cur->name,"instance"))
+			{
+				if (!parseInstance(cur))
+					// todo hulud interface syntax error
+					nlwarning ("could not parse instance");
+			}
+			else if (!strcmp((char*)cur->name,"vector"))
+			{
+				if (!parseVector(cur))
+					// todo hulud interface syntax error
+					nlwarning ("could not parse vector");
+			}
+			cur = cur->next;
+		}
+
+		// add/replace the procedure
+		_ProcedureMap[procId]= newProc;
+
+		return true;
+	}
+
+	// ----------------------------------------------------------------------------
+	bool CInterfaceParser::initCoordsAndLuaScript()
+	{
+		// set all position associations
+		for (map<CInterfaceElement*,string>::const_iterator it = _ParentPositionsMap.begin(); it != _ParentPositionsMap.end();it++)
+		{
+			CInterfaceElement *pIEL = it->first;
+			string EltName = it->second;
+
+			CInterfaceGroup *parent = pIEL->getParent();
+			CInterfaceElement *parentpos;
+			//if the element has a parent check the parent's children
+			if (parent)
+				parentpos = parent->getElement(EltName);
+			//if the element has no parent, check the windows
+			else
+				parentpos = CWidgetManager::getInstance()->getWindowFromId(EltName);
+
+			if (parentpos == NULL)
+			{
+				// todo hulud interface syntax error
+				nlinfo(" the element %s was not found as %s position reference ", EltName.c_str(), pIEL->getId().c_str());
+			}
+			else
+			{
+				pIEL->setParentPos (parentpos);
+			}
+		}
+		// Same for size
+		for (map<CInterfaceElement*,string>::const_iterator it2 = _ParentSizesMap.begin(); it2 != _ParentSizesMap.end(); it2++)
+		{
+			CInterfaceElement *pIEL = it2->first;
+			string EltName = it2->second;
+
+			CInterfaceGroup *parent = pIEL->getParent();
+			CInterfaceElement *parentsize;
+			if (EltName == "parent")
+			{
+				parentsize = pIEL->getParent();
+			}
+			else
+			{
+				//if the element has a parent check the parent's children
+				if (parent)
+					parentsize = parent->getElement(EltName);
+				//if the element has no parent, check the windows
+				else
+					parentsize = CWidgetManager::getInstance()->getWindowFromId(EltName);
+			}
+
+			if (parentsize == NULL)
+			{
+				// todo hulud interface syntax error
+				nlinfo(" the element %s was not found as %s size reference ", EltName.c_str(), pIEL->getId().c_str());
+			}
+			else
+			{
+				pIEL->setParentSize (parentsize);
+			}
+		}
+		// Same for size max
+		for (map<CInterfaceElement*,string>::const_iterator it3 = _ParentSizesMaxMap.begin(); it3 != _ParentSizesMaxMap.end(); it3++)
+		{
+			CInterfaceGroup *pIEL = dynamic_cast<CInterfaceGroup*>(it3->first);
+			if (pIEL == NULL) continue;
+			string EltName = it3->second;
+
+			CInterfaceGroup *parent = pIEL->getParent();
+			CInterfaceElement *parentsizemax;
+			if (EltName == "parent")
+			{
+				parentsizemax = parent;
+			}
+			else
+			{
+				//if the element has a parent check the parent's children
+				if (parent)
+					parentsizemax = parent->getElement(EltName);
+				//if the element has no parent, check the windows
+				else
+					parentsizemax = CWidgetManager::getInstance()->getWindowFromId(EltName);
+			}
+
+			if (parentsizemax == NULL)
+			{
+				// todo hulud interface syntax error
+				nlinfo(" the element %s was not found as %s sizemax reference ", EltName.c_str(), pIEL->getId().c_str());
+			}
+			else
+			{
+				pIEL->setParentSizeMax (parentsizemax);
+			}
+		}
+
+		// Same For LUA Class association
+		for (map<CInterfaceGroup*,string>::const_iterator itLua = _LuaClassAssociation.begin(); itLua != _LuaClassAssociation.end(); itLua++)
+		{
+			// execute the script on this group
+			CAHManager::getInstance()->runActionHandler("lua", itLua->first, itLua->second);
+		}
+
+
+		// Clear all structures used only for init
+		NLMISC::contReset (_ParentPositionsMap);
+		NLMISC::contReset (_ParentSizesMap);
+		NLMISC::contReset (_ParentSizesMaxMap);
+		NLMISC::contReset (_LuaClassAssociation);
+		return true;
+	}
+
+	// ----------------------------------------------------------------------------
+	void CInterfaceParser::addParentPositionAssociation(CInterfaceElement* element, const std::string& parent)
+	{
+		_ParentPositionsMap.insert (std::map<CInterfaceElement*,std::string>::value_type(element, parent));
+	}
+
+	// ----------------------------------------------------------------------------
+	void CInterfaceParser::addParentSizeAssociation(CInterfaceElement* element, const std::string& parent)
+	{
+		_ParentSizesMap.insert (std::map<CInterfaceElement*,std::string>::value_type(element, parent));
+	}
+
+	// ----------------------------------------------------------------------------
+	void CInterfaceParser::addParentSizeMaxAssociation (CInterfaceElement *element, const std::string &parent)
+	{
+		_ParentSizesMaxMap.insert (std::map<CInterfaceElement*,std::string>::value_type(element, parent));
+	}
+
+	// ----------------------------------------------------------------------------
+	void CInterfaceParser::addLuaClassAssociation (CInterfaceGroup *group, const std::string &luaScript)
+	{
+		_LuaClassAssociation.insert (std::map<CInterfaceGroup*,std::string>::value_type(group, luaScript));
+	}
+
+	// ***************************************************************************
+	const std::string	&CInterfaceParser::getDefine(const std::string &id) const
+	{
+		static	string NullStr;
+		CstItVarMap	it= _DefineMap.find(id);
+		if(it==_DefineMap.end())
+			return NullStr;
+		else
+			return it->second;
+	}
+
+	// ***************************************************************************
+	bool				CInterfaceParser::isDefineExist(const std::string &id) const
+	{
+		CstItVarMap	it= _DefineMap.find(id);
+		return it!=_DefineMap.end();
+	}
+
+
+	// ***************************************************************************
+	void				CInterfaceParser::setDefine(const std::string &id, const std::string &value)
+	{
+		_DefineMap[id]= value;
+	}
+
+
+	// ***************************************************************************
+	bool				CInterfaceParser::validDefineChar(char c) const
+	{
+		if(c>='A' && c<='Z')
+			return true;
+		if(c>='a' && c<='z')
+			return true;
+		if(c>='0' && c<='9')
+			return true;
+		if(c=='_')
+			return true;
+
+		return false;
+	}
+
+	#define	DEFINE_IDENT	'%'
+
+	// ***************************************************************************
+	bool				CInterfaceParser::solveDefine(const std::string &propVal, std::string &newPropVal, std::string &defError)
+	{
+		string::size_type	curPos= 0;
+		string::size_type	lastPos= 0;
+
+		//if it has some % then solve define value
+		while( (curPos=propVal.find(DEFINE_IDENT, curPos)) != string::npos)
+		{
+			// If it is end of line
+			if(curPos==propVal.size()-1)
+			{
+				// then skip
+				curPos= propVal.size();
+			}
+			// If it is a double %%
+			else if(propVal[curPos+1]==DEFINE_IDENT)
+			{
+				// copy from last to cur included
+				curPos++;
+				newPropVal+= propVal.substr(lastPos, curPos-lastPos);
+				// both % are skipped
+				curPos++;
+				lastPos= curPos;
+			}
+			// else parse define value
+			else
+			{
+				// copy the last not define sub string.
+				newPropVal+= propVal.substr(lastPos, curPos-lastPos);
+
+				// skip the %
+				curPos++;
+
+				// get the id pos
+				uint	startIdPos= (uint)curPos;
+				while( curPos<propVal.size() && validDefineChar(propVal[curPos]) )
+					curPos++;
+				// get the id
+				string	defineId= propVal.substr(startIdPos, curPos-startIdPos);
+				if(!isDefineExist(defineId))
+				{
+					defError= defineId;
+					return false;
+				}
+				// Add the define value to the string
+				newPropVal+= getDefine(defineId);
+
+				// valid pos is current pos
+				lastPos= curPos;
+			}
+		}
+		// concat last part
+		newPropVal+= propVal.substr(lastPos, propVal.size()-lastPos);
+
+		return true;
+	}
+
+	// ***************************************************************************
+	bool				CInterfaceParser::solveDefine(xmlNodePtr cur)
+	{
+		CXMLAutoPtr ptr;
+
+		//get the node properties
+		xmlAttrPtr props = cur->properties;
+		while (props)
+		{
+			//get the property value
+			ptr = (char*)xmlGetProp( cur, props->name);
+			nlassert(ptr);
+			string	propVal= ptr;
+			string	newPropVal;
+
+			// solve define of this prop
+			string	defError;
+			if(!solveDefine(propVal, newPropVal, defError))
+			{
+				// todo hulud interface syntax error
+				nlinfo("can't find define: %s", defError.c_str());
+				return false;
+			}
+
+			// change value
+			xmlSetProp(cur, props->name, (const xmlChar*)newPropVal.c_str());
+
+			// next property
+			props = props->next;
+		}
+
+		// recurs to node children
+		cur= cur->children;
+		while(cur)
+		{
+			if(!solveDefine(cur))
+				return false;
+			cur= cur->next;
+		}
+
+		return true;
+	}
+
+
+	// ***************************************************************************
+	// CInterfaceParser::CAction
+	// ***************************************************************************
+
+	#define	PROC_PARAM_IDENT	'@'
+
+	// ***************************************************************************
+	void CInterfaceParser::CAction::buildParamBlock(const std::string &params)
+	{
+		buildBlocks (params, ParamBlocks);
+	}
+
+	void CInterfaceParser::CAction::buildParams(const std::vector<string> &paramList, std::string &params) const
+	{
+		eval (paramList, ParamBlocks, params);
+	}
+
+	void CInterfaceParser::CAction::buildCondBlock(const std::string &params)
+	{
+		buildBlocks (params, CondBlocks);
+	}
+
+	void CInterfaceParser::CAction::buildCond(const std::vector<string> &paramList, std::string &params) const
+	{
+		eval (paramList, CondBlocks, params);
+	}
+
+	// ***************************************************************************
+	void		CInterfaceParser::CAction::buildBlocks (const std::string &in, std::vector<CParamBlock> &out)
+	{
+		out.clear();
+
+		if(in.empty())
+			return;
+
+		string	lastString;
+		string::size_type	curPos= 0;
+		string::size_type	lastPos= 0;
+
+		//if it has some @ then solve proc value
+		while( (curPos=in.find(PROC_PARAM_IDENT, curPos)) != string::npos)
+		{
+			// If it is end of line
+			if(curPos==in.size()-1)
+			{
+				// then skip
+				curPos= in.size();
+			}
+			else
+			{
+				// Skip all @
+				uint countNbIdent = 0;
+				while (curPos<in.size() && in[curPos]==PROC_PARAM_IDENT)
+				{
+					curPos++;
+					countNbIdent++;
+				}
+
+				// get the id pos
+				uint countNbDigit = 0;
+				uint startIdPos= (uint)curPos;
+				while (curPos<in.size() && in[curPos]>='0' && in[curPos]<='9')
+				{
+					curPos++;
+					countNbDigit++;
+				}
+
+				if (curPos == startIdPos)
+				{
+					// No digit so it is a normal db entry
+					lastString+= in.substr (lastPos, curPos-(countNbIdent-1)-lastPos);
+					// all @ are skipped
+				}
+				else
+				{
+					// There is some digit it is an argument
+
+					// copy the last not param sub string.
+					sint nbToCopy = (sint)(curPos-countNbIdent-countNbDigit-lastPos);
+					if (nbToCopy > 0)
+						lastString += in.substr(lastPos, nbToCopy);
+
+					// if not empty, add to the param block
+					if (!lastString.empty())
+					{
+						CParamBlock pb;
+						pb.String = lastString;
+						out.push_back(pb);
+						// clear it
+						lastString.clear();
+					}
+
+					// get the param id
+					sint paramId;
+					fromString(in.substr(startIdPos, curPos-startIdPos), paramId);
+					// Add it to the param block
+					CParamBlock	 pb;
+					pb.NumParam = paramId;
+					out.push_back(pb);
+				}
+
+				// valid pos is current pos
+				lastPos= curPos;
+			}
+		}
+		// concat last part
+		lastString+= in.substr(lastPos, in.size()-lastPos);
+		if(!lastString.empty())
+		{
+			CParamBlock pb;
+			pb.String = lastString;
+			out.push_back(pb);
+		}
+	}
+
+	// ***************************************************************************
+	//void		CInterfaceParser::CAction::buildParams(const std::vector<string> &paramList, std::string &params) const
+	void CInterfaceParser::CAction::eval (const std::vector<string> &inArgs, const std::vector<CParamBlock> &inBlocks, std::string &out)
+	{
+		// clear the ret string
+		out.clear();
+
+		// for all block
+		for (uint i=0; i < inBlocks.size(); i++)
+		{
+			const CParamBlock &pb = inBlocks[i];
+			// if the block is a raw string
+			if (pb.NumParam < 0)
+			{
+				// concat with the block
+				out += pb.String;
+			}
+			// else get from paramList
+			else
+			{
+				// add 1, because paramList[0] is the name of the procedure
+				sint idInList = pb.NumParam+1;
+				// if param exist
+				if (idInList < (sint)inArgs.size())
+					// concat with the params
+					out += inArgs[idInList];
+				// else skip (should fail)
+			}
+		}
+	}
+
+	// ***************************************************************************
+	bool CInterfaceParser::parseSheetSelection(xmlNodePtr cur)
+	{
+		CXMLAutoPtr prop;
+		prop = (char*) xmlGetProp( cur, (xmlChar*)"name" );
+		if (!prop)
+		{
+			// todo hulud interface syntax error
+			nlwarning("<CInterfaceParser::parseSheetSelection> can't get name of a selection");
+			return false;
+		}
+		std::string groupName = (const char *) prop;
+		prop = (char*) xmlGetProp( cur, (xmlChar*)"texture" );
+		if (!prop)
+		{
+			// todo hulud interface syntax error
+			nlwarning("<CInterfaceParser::parseSheetSelection> can't get texture name for selection %s", groupName.c_str());
+			return false;
+		}
+		std::string texName = (const char *) prop;
+		prop = (char*) xmlGetProp( cur, (xmlChar*)"color" );
+		CRGBA color = CRGBA::White;
+		if (prop)
+		{
+			color = CInterfaceElement::convertColor(prop);
+		}
+		bool globalColor = true;
+		prop = (char*) xmlGetProp( cur, (xmlChar*)"global_color" );
+		if (prop) globalColor = CInterfaceElement::convertBool(prop);
+		sint groupIndex = _CtrlSheetSelection.addGroup(groupName);
+		if (groupIndex != -1)
+		{
+			CSheetSelectionGroup *csg = _CtrlSheetSelection.getGroup(groupIndex);
+			csg->setTexture(texName);
+			csg->setColor(color);
+			csg->enableGlobalColor(globalColor);
+		}
+		return true;
+	}
+
+	// ***************************************************************************
+	bool CInterfaceParser::addLink(CInterfaceLink *link, const std::string &id)
+	{
+		if (!link)
+		{
+			// todo hulud interface syntax error
+			nlwarning("link empty");
+			return false;
+		}
+		TLinkMap::const_iterator it = _LinkMap.find(id);
+		if (it != _LinkMap.end())
+		{
+			// todo hulud interface syntax error
+			nlwarning("<CInterfaceParser::addLink> link %s added twice", id.c_str());
+			return false;
+		}
+		#ifdef NL_DEBUG
+			link->LinkName = id;
+		#endif
+		_LinkMap[id] = link;
+		return false;
+	}
+
+	// ***************************************************************************
+	bool CInterfaceParser::removeLink(const std::string &id)
+	{
+		TLinkMap::iterator it = _LinkMap.find(id);
+		if (it == _LinkMap.end())
+		{
+			// todo hulud interface syntax error
+			nlwarning("<CInterfaceParser::removeLink> unknown link %s", id.c_str());
+			return false;
+		}
+		CSmartPtr<CInterfaceLink> &link = it->second; // dont need to copy a smart ptr on link since still in map
+		for (uint k = 0; k < link->getNumTargets(); ++k)
+		{
+			link->getTarget(k)->removeLink(link); // remove the link from the list & delete it
+		}
+		it->second->uninit();
+		_LinkMap.erase(it); // NB : the link is holded by a smart ptr, to do this decrease the ref count
+		return true;
+	}
+
+
+	// ***************************************************************************
+	xmlNodePtr CInterfaceParser::searchTreeNodeInHierarchy(xmlNodePtr root, const char *node)
+	{
+		// if I match...
+		CXMLAutoPtr prop((const char*) xmlGetProp( root, (xmlChar*)"node" ));
+		// not a valide tree node? abort.
+		if (!prop) return NULL;
+		// match?
+		if ( !strcmp((const char*)prop, node ) )
+			return root;
+
+		// No, try with sons.
+		xmlNodePtr cur= root->children;
+		while(cur)
+		{
+			xmlNodePtr candidate= searchTreeNodeInHierarchy(cur, node);
+			// if found in this branch.
+			if(candidate)
+				return candidate;
+
+			// try next
+			cur= cur->next;
+		}
+
+		// not found
+		return NULL;
+	}
+
+	//==================================================================
+	bool CInterfaceParser::parseAnim(xmlNodePtr cur, CInterfaceGroup * parentGroup)
+	{
+		CInterfaceAnim *pAnim;
+
+		CXMLAutoPtr ptr;
+
+		ptr = (char*) xmlGetProp( cur, (xmlChar*)"id" );
+		if (!ptr)
+		{
+			// todo hulud interface syntax error
+			nlinfo ("anim has no id");
+			return false;
+		}
+		string animId = ptr;
+		pAnim = new CInterfaceAnim;
+
+		if (pAnim->parse (cur, parentGroup))
+		{
+			if (_AnimMap.count(animId))
+			{
+				nlwarning("Anim %s already exists, replacing with new one", animId.c_str());
+			}
+			_AnimMap[animId] = pAnim;
+		}
+		else
+		{
+			delete pAnim;
+			return false;
+		}
+		return true;
+	}
+
+	//==================================================================
+	void CInterfaceParser::freeXMLNodeAndSibblings(xmlNodePtr node)
+	{
+		if (!node) return;
+		 while (node)
+		 {
+			 xmlNodePtr currNode = node;
+			 node = node->next;
+			 xmlFreeNode(currNode);
+		 }
+	}
+
+
+	// ***************************************************************************
+	CInterfaceGroup *CInterfaceParser::createGroupInstance(const std::string &templateName, const std::string &parentID, const std::pair<std::string,std::string> *templateParams, uint numParams, bool updateLinks /* = true */)
+	{
+		// create basic xml node that contains infos for the template
+		xmlNodePtr instance = xmlNewNode(NULL, (const xmlChar *) "instance");
+		if (!instance)
+		{
+			// todo hulud interface syntax error
+			nlwarning("<CInterfaceParser::createGroupInstance> Can't create xml node ");
+			return NULL;
+		}
+		for(uint k = 0; k < numParams; ++k)
+		{
+			xmlSetProp(instance, (const xmlChar *) templateParams[k].first.c_str(), (const xmlChar *) templateParams[k].second.c_str());
+		}
+		xmlSetProp(instance, (const xmlChar *) "template", (const xmlChar *) templateName.c_str());
+		if (!parseInstance(instance))
+		{
+			// todo hulud interface syntax error
+			nlwarning("<CInterfaceParser::createGroupInstance> cannot create instance from template %s", templateName.c_str());
+			freeXMLNodeAndSibblings(instance);
+			return NULL;
+		}
+
+		// result should contain a group
+		xmlNodePtr currNode = instance->next;
+		while (currNode)
+		{
+			if (strcmp((const char *) currNode->name, "group") == 0 && currNode->type == XML_ELEMENT_NODE)
+			{
+				// TODO nico : build a struct from that mess
+				std::map<CInterfaceElement*,std::string> localParentPositionsMap;
+				std::map<CInterfaceElement*,std::string> localParentSizesMap;
+				std::map<CInterfaceElement*,std::string> localParentSizesMaxMap;
+				std::map<CInterfaceGroup*,std::string>	 localLuaClassAssociation;
+
+				localParentPositionsMap.swap(_ParentPositionsMap);
+				localParentSizesMap.swap(_ParentSizesMap);
+				localParentSizesMaxMap.swap(_ParentSizesMaxMap);
+				localLuaClassAssociation.swap(_LuaClassAssociation);
+
+				CViewBase::TCtorParam params;
+				CInterfaceGroup dummyGroup(params);
+				dummyGroup.setId(parentID);
+				if (!parseGroup(currNode, &dummyGroup, false))
+				{
+					localParentPositionsMap.swap(_ParentPositionsMap);
+					localParentSizesMap.swap(_ParentSizesMap);
+					localParentSizesMaxMap.swap(_ParentSizesMaxMap);
+					localLuaClassAssociation.swap(_LuaClassAssociation);
+					freeXMLNodeAndSibblings(instance);
+					return NULL;
+				}
+				freeXMLNodeAndSibblings(instance);
+				CInterfaceGroup *group = dummyGroup.getGroup((uint) 0);
+				dummyGroup.delGroup(group, true);
+				group->setParent(NULL);
+				group->setParentPos(NULL);
+				initCoordsAndLuaScript();
+				localParentPositionsMap.swap(_ParentPositionsMap);
+				localParentSizesMap.swap(_ParentSizesMap);
+				localParentSizesMaxMap.swap(_ParentSizesMaxMap);
+				localLuaClassAssociation.swap(_LuaClassAssociation);
+				if ((group != NULL) && updateLinks)
+				{
+					group->updateAllLinks();
+				}
+				CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(group);
+				if (pGC != NULL)
+					pGC->setup();
+				return group;
+			}
+			currNode = currNode->next;
+		}
+		// todo hulud interface syntax error
+		CXMLAutoPtr ptr(xmlGetProp(instance, (const xmlChar *) templateName.c_str()));
+		nlwarning("<CInterfaceParser::createGroupInstance> no group found in template %s", (const char*)ptr);
+		freeXMLNodeAndSibblings(instance);
+		return NULL;
+	}
+
+	// ***************************************************************************
+	CInterfaceElement *CInterfaceParser::createUIElement(const std::string &templateName, const std::string &parentID, const std::pair<std::string,std::string> *templateParams, uint numParams, bool updateLinks /* = true */)
+	{
+		std::string elementId;
+
+		// create basic xml node that contains infos for the template
+		xmlNodePtr instance = xmlNewNode(NULL, (const xmlChar *) "instance");
+		if (!instance)
+		{
+			// todo hulud interface syntax error
+			nlwarning("<CInterfaceParser::addUIElement> Can't create xml node ");
+			return NULL;
+		}
+		for(uint k = 0; k < numParams; ++k)
+		{
+			xmlSetProp(instance, (const xmlChar *) templateParams[k].first.c_str(), (const xmlChar *) templateParams[k].second.c_str());
+			if (!strcmp(templateParams[k].first.c_str(), "id"))
+			{
+				elementId = templateParams[k].second;
+			}
+		}
+		xmlSetProp(instance, (const xmlChar *) "template", (const xmlChar *) templateName.c_str());
+		if (!parseInstance(instance))
+		{
+			// todo hulud interface syntax error
+			nlwarning("<CInterfaceParser::addUIElement> cannot create instance from template %s", templateName.c_str());
+			freeXMLNodeAndSibblings(instance);
+			return NULL;
+		}
+
+		CInterfaceElement	*pIE= CWidgetManager::getInstance()->getElementFromId(parentID);
+		CInterfaceGroup * parentGroup = dynamic_cast<CInterfaceGroup*>(pIE);
+
+		if(!parentGroup)
+		{
+			nlwarning("<CInterfaceParser::addUIElement> no parent group %s found ", parentID.c_str());
+			freeXMLNodeAndSibblings(instance);
+			return NULL;
+		}
+
+		// result should contain a group
+		xmlNodePtr currNode = instance->next;
+		CInterfaceElement * newElement = NULL;
+		while (currNode)
+		{
+			if (strcmp((const char *) currNode->name, "group") == 0 && currNode->type == XML_ELEMENT_NODE)
+			{
+				if (!parseGroup(currNode, parentGroup, false))
+				{
+					freeXMLNodeAndSibblings(instance);
+					return NULL;
+				}
+				freeXMLNodeAndSibblings(instance);
+				newElement = parentGroup->getGroup(elementId);
+				parentGroup->delGroup((CInterfaceGroup*)newElement, true);
+			}
+			else if (strcmp((const char *) currNode->name, "ctrl") == 0 && currNode->type == XML_ELEMENT_NODE)
+			{
+				if (!parseControl(currNode, parentGroup, false))
+				{
+					freeXMLNodeAndSibblings(instance);
+					return NULL;
+				}
+				freeXMLNodeAndSibblings(instance);
+				newElement = parentGroup->getCtrl(elementId);
+				parentGroup->delCtrl((CCtrlBase*)newElement, true);
+			}
+
+			if(newElement != NULL)
+			{
+				initCoordsAndLuaScript();
+				if (updateLinks)
+				{
+					newElement->updateAllLinks();
+				}
+				return newElement;
+			}
+
+			currNode = currNode->next;
+		}
+		// todo hulud interface syntax error
+		CXMLAutoPtr ptr(xmlGetProp(instance, (const xmlChar *) templateName.c_str()));
+		nlwarning("<CInterfaceParser::addUIElement> no group found in template %s", (const char *)ptr);
+		freeXMLNodeAndSibblings(instance);
+		return NULL;
+	}
+
+	// ***************************************************************************
+	void CInterfaceParser::removeAllLinks()
+	{
+		_LinkMap.clear();
+	}
+
+	// ***************************************************************************
+	void CInterfaceParser::removeAllProcedures()
+	{
+		_ProcedureMap.clear();
+	}
+
+	// ***************************************************************************
+	void CInterfaceParser::removeAllDefines()
+	{
+		_DefineMap.clear();
+	}
+
+	// ***************************************************************************
+	void CInterfaceParser::removeAllTemplates()
+	{
+		for (uint i = 0; i < _Templates.size(); ++i)
+			xmlFreeNode(_Templates[i]);
+		_Templates.clear();
+	}
+
+	// ***************************************************************************
+	void CInterfaceParser::removeAllAnims()
+	{
+		TAnimMap::iterator it = _AnimMap.begin();
+		while (it != _AnimMap.end())
+		{
+			CInterfaceAnim *pAnim = it->second;
+			delete pAnim;
+			it++;
+		}
+		_AnimMap.clear();
+	}
+
+	// ***************************************************************************
+
+
+	// ***************************************************************************
+	void CInterfaceParser::removeAll()
+	{
+		removeAllLinks();
+		CWidgetManager::getInstance()->removeAllOptions();
+		removeAllProcedures();
+		removeAllDefines();
+		removeAllTemplates();
+		removeAllAnims();
+		CWidgetManager::getInstance()->removeAllMasterGroups();
+		_StyleMap.clear();
+		_CtrlSheetSelection.deleteGroups();
+	}
+
+
+	// ------------------------------------------------------------------------------------------------
+	uint CInterfaceParser::getProcedureNumActions(const std::string &procName) const
+	{
+		CstItProcedureMap	it= _ProcedureMap.find(procName);
+		if(it!=_ProcedureMap.end())
+		{
+			const CProcedure	&proc= it->second;
+			return (uint)proc.Actions.size();
+		}
+		else
+			return 0;
+	}
+
+	// ------------------------------------------------------------------------------------------------
+	bool CInterfaceParser::getProcedureAction(const std::string &procName, uint actionIndex, std::string &ah, std::string &params) const
+	{
+		CstItProcedureMap	it= _ProcedureMap.find(procName);
+		if(it!=_ProcedureMap.end())
+		{
+			const CProcedure	&proc= it->second;
+			if(actionIndex<proc.Actions.size())
+			{
+				const CAction		&action= proc.Actions[actionIndex];
+				// if not a variable parametrized Params
+				if(action.ParamBlocks.size()==1 && action.ParamBlocks[0].NumParam==-1)
+				{
+					ah= action.Action;
+					params= action.ParamBlocks[0].String;
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+
+	// ***************************************************************************
+	bool CInterfaceParser::parseStyle(xmlNodePtr cur)
+	{
+		string		styleId;
+		CXMLAutoPtr prop;
+
+		prop = xmlGetProp (cur, (xmlChar*)"style");
+		if(prop)
+			styleId= (const char*)prop;
+		else
+		{
+			// todo hulud interface syntax error
+			nlwarning("'style' not found in 'style'");
+			return false;
+		}
+
+		// create or replace style
+		CStyle	newStyle;
+
+		//get the node properties
+		xmlAttrPtr props = cur->properties;
+		while (props)
+		{
+			// if not the "style" property
+			if( nlstricmp((const char*)props->name, "style") != 0 )
+			{
+				// Append it.
+				newStyle.Properties.push_back(CStyleProperty());
+				newStyle.Properties.back().Name= (const char*)props->name;
+
+				CXMLAutoPtr ptr(xmlGetProp( cur, props->name ));
+				newStyle.Properties.back().Value = (const char*)ptr;
+			}
+
+			props= props->next;
+		}
+
+		// associate.
+		_StyleMap[styleId]= newStyle;
+
+		return true;
+	}
+
+	// ***************************************************************************
+	bool CInterfaceParser::parseLUAScript (xmlNodePtr cur)
+	{
+		// read fileName
+		CXMLAutoPtr prop;
+		string	fileName;
+		prop = xmlGetProp (cur, (xmlChar*)"file");
+		if(prop)
+			fileName= (const char*)prop;
+		else
+		{
+			nlwarning("'file' not found in 'lua'");
+			return false;
+		}
+
+		// Append to set of reloadable FileScripts
+		_LuaFileScripts.insert(fileName);
+
+		// just display warning here.
+		string	dummyError;
+		return loadLUA(fileName, dummyError);
+	}
+
+	// ***************************************************************************
+	bool				CInterfaceParser::solveStyle(xmlNodePtr cur)
+	{
+		CXMLAutoPtr ptr;
+
+		// if the node is a style, abort (not recrusive because use "style" as param name)
+		if ( !strcmp((char*)cur->name,"style") )
+			return true;
+
+		// try to read a "style" param.
+		ptr= (char*)xmlGetProp( cur, (xmlChar*)"style");
+		if(ptr)
+		{
+			// get the style
+			TStyleMap::iterator	it= _StyleMap.find((const char*)ptr);
+			if( it==_StyleMap.end() )
+			{
+				// todo hulud interface syntax error
+				nlwarning("style '%s' not found", (const char*)ptr);
+				return false;
+			}
+
+			// the style
+			CStyle	&style= it->second;
+
+			// for all properties of the style, set them in the node
+			for(uint i=0;i<style.Properties.size();i++)
+			{
+				const char *propName= style.Properties[i].Name.c_str();
+				const char *propValue= style.Properties[i].Value.c_str();
+
+				// replace it only if the property is not already defined, (=> user can overide style properties)
+				CXMLAutoPtr ptr2(xmlGetProp( cur, (xmlChar*)propName));
+				if( !ptr2 )
+				{
+					xmlSetProp(cur, (xmlChar*)propName, (xmlChar*)propValue);
+				}
+			}
+		}
+
+		// recurs to node children
+		cur= cur->children;
+		while(cur)
+		{
+			if(!solveStyle(cur))
+				return false;
+			cur= cur->next;
+		}
+
+		return true;
+	}
+
+	// ***************************************************************************
+
+	#ifdef LUA_NEVRAX_VERSION
+
+	class CLuaDebugBreakScreen : public IDebuggedAppMainLoop
+	{
+	public:
+		// called by external lua debugger when application is breaked
+		virtual void breakEventLoop()
+		{
+			Driver->clearBuffers(CRGBA(90, 90, 90));
+			TextContext->setShaded(true);
+			TextContext->setFontSize(40);
+			TextContext->setColor(CRGBA::White);
+
+			// TOP LEFT //
+			//----------//
+			TextContext->setHotSpot(NL3D::UTextContext::MiddleMiddle);
+			TextContext->printfAt(0.5f, 0.5f, "Break in LUA code");
+			Driver->swapBuffers();
+		}
+	};
+	static CLuaDebugBreakScreen LuaDebugBreakScreen;
+
+	#endif
+
+
+	// ***************************************************************************
+	void	CInterfaceParser::initLUA()
+	{
+		// do nothing if LUA environment already exists
+		if( _LuaState != NULL )
+			return;
+
+		// create a new LUA environnement
+		nlassert(_LuaState==NULL);
+		CLuaManager::enableLuaDebugging();
+		CLuaManager::getInstance();
+		_LuaState= CLuaManager::getInstance().getLuaState();
+
+	#ifdef LUA_NEVRAX_VERSION
+		extern ILuaIDEInterface *LuaDebuggerIDE;
+		if (LuaDebuggerIDE) LuaDebuggerIDE->setDebuggedAppMainLoop(&LuaDebugBreakScreen);
+	#endif
+
+		// register LUA methods
+		CLuaIHM::registerAll(*_LuaState);
+	}
+
+	// ***************************************************************************
+	void	CInterfaceParser::uninitLUA()
+	{
+		// Delete all LUA environnement (and hence variables)
+		// delete _LuaState;
+		// _LuaState= NULL;
+
+		// delete all .lua file loaded
+		_LuaFileScripts.clear();
+	}
+
+	// ***************************************************************************
+	bool	CInterfaceParser::loadLUA(const std::string &fileName, std::string &error)
+	{
+		// get file
+
+		bool needCheck = false;
+
+		#if !FINAL_VERSION
+			needCheck = false;
+		#endif
+
+		string	pathName= CPath::lookup(fileName, false);
+		if(pathName.empty())
+		{
+			nlwarning("LUA Script '%s' not found", fileName.c_str());
+			return false;
+		}
+
+		bool isInData = false;
+		std::string::size_type pos = pathName.find("@");
+		if (pos != string::npos)
+		{
+			if (CBigFile::getInstance().getBigFileName(pathName.substr(0, pos)) != "data/"+pathName.substr(0, pos))
+				isInData = false;
+			else
+				isInData = true;
+		}
+
+		if (needCheck && !isInData)
+		{
+			nlwarning("You are not allowed to modify the lua files");
+			// return true so it'll not generate a message box, we just ignore the file
+			return true;
+		}
+
+		// Parse script
+		nlassert(_LuaState);
+		try
+		{
+			_LuaState->executeFile(pathName);
+		}
+		catch(const ELuaError &e)
+		{
+			nlwarning(e.luaWhat().c_str());
+			error= e.luaWhat();
+			return false;
+		}
+
+		return true;
+	}
+
+}
+
diff --git a/code/ryzom/client/src/actions.h b/code/ryzom/client/src/actions.h
index 57f52d8f7..cdc3f200a 100644
--- a/code/ryzom/client/src/actions.h
+++ b/code/ryzom/client/src/actions.h
@@ -308,8 +308,6 @@ struct CTKeyHashMapTraits
  */
 class CActionsManager
 {
-	friend class CInterfaceParser;
-
 public:
 
 	/// Typedef to use the map easily.
diff --git a/code/ryzom/client/src/interface_v3/interface_manager.h b/code/ryzom/client/src/interface_v3/interface_manager.h
index 55c8d3f4a..f0eecf342 100644
--- a/code/ryzom/client/src/interface_v3/interface_manager.h
+++ b/code/ryzom/client/src/interface_v3/interface_manager.h
@@ -35,7 +35,7 @@
 #include "nel/gui/view_renderer.h"
 
 // InterfaceV3
-#include "interface_parser.h"
+#include "nel/gui/interface_parser.h"
 #include "nel/gui/ctrl_sheet_selection.h"
 #include "nel/gui/interface_options.h"
 #include "interface_config.h"
@@ -80,7 +80,7 @@ namespace NLGUI
  * \author Nevrax France
  * \date 2002
  */
-class CInterfaceManager : public CInterfaceParser, public NLGUI::IInputEventListener
+class CInterfaceManager : public NLGUI::CInterfaceParser, public NLGUI::IInputEventListener
 {
 public:
 
diff --git a/code/ryzom/client/src/interface_v3/interface_parser.cpp b/code/ryzom/client/src/interface_v3/interface_parser.cpp
deleted file mode 100644
index 8d66ae077..000000000
--- a/code/ryzom/client/src/interface_v3/interface_parser.cpp
+++ /dev/null
@@ -1,2919 +0,0 @@
-// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
-// Copyright (C) 2010  Winch Gate Property Limited
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#include "interface_parser.h"
-#include "nel/misc/i_xml.h"
-#include "nel/misc/file.h"
-#include "nel/misc/algo.h"
-#include "nel/misc/mem_stream.h"
-#include "nel/misc/factory.h"
-#include "nel/misc/big_file.h"
-#include "nel/misc/xml_auto_ptr.h"
-#include "nel/gui/interface_options.h"
-#include "nel/gui/interface_anim.h"
-#include "nel/gui/interface_expr.h"
-#include "nel/gui/view_pointer.h"
-#include "nel/gui/group_modal.h"
-#include "nel/gui/group_list.h"
-#include "nel/gui/group_container.h"
-#include "nel/gui/interface_link.h"
-#include "nel/gui/lua_helper.h"
-#include "nel/gui/lua_ihm.h"
-#include "nel/gui/lua_manager.h"
-
-#ifdef LUA_NEVRAX_VERSION
-	#include "lua_ide_dll_nevrax/include/lua_ide_dll/ide_interface.h" // external debugger
-#endif
-const uint32 UI_CACHE_SERIAL_CHECK = (uint32) 'IUG_';
-
-using namespace NLMISC;
-using namespace NLGUI;
-using namespace std;
-
-void saveXMLTree(COFile &f, xmlNodePtr node)
-{
-	// save node name
-	std::string name = (const char *) node->name;
-	f.serial(name);
-	// save properties
-	uint32 numProp = 0;
-	xmlAttrPtr currProp = node->properties;
-	while (currProp)
-	{
-		++ numProp;
-		currProp = currProp->next;
-	}
-	f.serial(numProp);
-	currProp = node->properties;
-	while (currProp)
-	{
-		std::string name = (const char *) currProp->name;
-		f.serial(name);
-		CXMLAutoPtr ptr(xmlGetProp(node, currProp->name));
-		std::string value = (const char *) ptr;
-		f.serial(value);
-		currProp = currProp->next;
-	}
-	uint32 numChildren = 0;
-	xmlNodePtr currChild = node->children;
-	while (currChild)
-	{
-		++ numChildren;
-		currChild = currChild->next;
-	}
-	f.serial(numChildren);
-	currChild = node->children;
-	while (currChild)
-	{
-		saveXMLTree(f, currChild);
-		currChild = currChild->next;
-	}
-}
-
-xmlNodePtr buildTree(CIFile &f)
-{
-	// load node name
-	std::string name;
-	f.serial(name);
-	xmlNodePtr node = xmlNewNode(NULL, (const xmlChar *) name.c_str());
-	// slod properties
-	uint32 numProp;
-	f.serial(numProp);
-	for(uint k = 0; k < numProp; ++k)
-	{
-		std::string name, value;
-		f.serial(name, value);
-		xmlSetProp(node, (const xmlChar *) name.c_str(), (const xmlChar *) value.c_str());
-	}
-	uint32 numChildren;
-	f.serial(numChildren);
-	for(uint k = 0; k < numChildren; ++k)
-	{
-		xmlAddChild(node, buildTree(f));
-	}
-	return node;
-}
-
-
-
-// ----------------------------------------------------------------------------
-// CRootGroup
-// ----------------------------------------------------------------------------
-
-class CRootGroup : public CInterfaceGroup
-{
-public:
-	CRootGroup(const TCtorParam &param)
-		: CInterfaceGroup(param)
-	{ }
-
-	/// Destructor
-	virtual ~CRootGroup() { }
-
-	virtual CInterfaceElement* getElement (const std::string &id)
-	{
-		if (_Id == id)
-		return this;
-
-		if (id.substr(0, _Id.size()) != _Id)
-			return NULL;
-
-		vector<CViewBase*>::const_iterator itv;
-		for (itv = _Views.begin(); itv != _Views.end(); itv++)
-		{
-			CViewBase *pVB = *itv;
-			if (pVB->getId() == id)
-				return pVB;
-		}
-
-		vector<CCtrlBase*>::const_iterator itc;
-		for (itc = _Controls.begin(); itc != _Controls.end(); itc++)
-		{
-			CCtrlBase* ctrl = *itc;
-			if (ctrl->getId() == id)
-				return ctrl;
-		}
-
-		// Accelerate
-		string sTmp = id;
-		sTmp = sTmp.substr(_Id.size()+1,sTmp.size());
-		string::size_type pos = sTmp.find(':');
-		if (pos != string::npos)
-			sTmp = sTmp.substr(0,pos);
-
-		map<string,CInterfaceGroup*>::iterator it = _Accel.find(sTmp);
-		if (it != _Accel.end())
-		{
-			CInterfaceGroup *pIG = it->second;
-			return pIG->getElement(id);
-		}
-		return NULL;
-	}
-
-	virtual void addGroup (CInterfaceGroup *child, sint eltOrder = -1)
-	{
-		string sTmp = child->getId();
-		sTmp = sTmp.substr(_Id.size()+1,sTmp.size());
-		_Accel.insert(pair<string,CInterfaceGroup*>(sTmp, child));
-		CInterfaceGroup::addGroup(child,eltOrder);
-	}
-
-	virtual bool delGroup (CInterfaceGroup *child, bool dontDelete = false)
-	{
-		string sTmp = child->getId();
-		sTmp = sTmp.substr(_Id.size()+1,sTmp.size());
-		map<string,CInterfaceGroup*>::iterator it = _Accel.find(sTmp);
-		if (it != _Accel.end())
-		{
-			_Accel.erase(it);
-		}
-		return CInterfaceGroup::delGroup(child,dontDelete);
-	}
-
-private:
-	map<string,CInterfaceGroup*> _Accel;
-};
-
-// ----------------------------------------------------------------------------
-// CInterfaceParser
-// ----------------------------------------------------------------------------
-
-// ----------------------------------------------------------------------------
-CInterfaceParser::CInterfaceParser()
-{
-	// LUA
-	_LuaState= NULL;
-	cacheUIParsing = false;
-}
-
-CInterfaceParser::~CInterfaceParser()
-{
-	_LuaState = NULL;
-	removeAllModules();
-}
-/** Convert a string into a memstream
-  */
-static void interfaceScriptAsMemStream(const std::string &script, CMemStream &destStream)
-{
-	NLMISC::contReset(destStream);
-	if (destStream.isReading()) // we must be sure that we are reading the stream
-	{
-		destStream.invert();
-	}
-	destStream.seek(0, NLMISC::IStream::begin);
-	if (script.empty()) return;
-	destStream.serialBuffer(const_cast<uint8 *>((const uint8 *) &script[0]), (uint)script.size());
-	destStream.invert();
-	destStream.seek(0, NLMISC::IStream::begin);
-}
-
-// ----------------------------------------------------------------------------
-bool CInterfaceParser::parseInterface (const std::vector<std::string> & strings, bool reload, bool isFilename, bool checkInData)
-{
-	bool	ok;
-
-	bool needCheck = false;
-
-#if !FINAL_VERSION
-	needCheck = false;
-#endif
-
-	// TestYoyo. UnHide For Parsing Profile
-	/*
-	NLMISC::CHTimer::startBench();
-	{
-
-	H_AUTO(parseInterface);
-	*/
-
-	//ignore the content of tags containing only white space
-	xmlKeepBlanksDefault(0);
-	//parse all interface files and build a single xml document
-	xmlNodePtr globalEnclosing;
-	nlassert (strings.size());
-	CIXml read;
-	string nextFileName;
-	static const char *SCRIPT_AS_STRING = "<script as string>";
-	try
-	{
-		CIFile file;
-		CMemStream scriptStream;
-		string firstFileName;
-		vector<string>::const_iterator it = strings.begin();
-		if (isFilename)
-		{
-			//get the first file document pointer
-			firstFileName = *it;
-			string filename = CPath::lookup(firstFileName);
-			bool isInData = false;
-			string::size_type pos = filename.find ("@");
-			if (pos != string::npos)
-			{
-				vector<string> bigFilePaths;
-				CBigFile::getInstance().getBigFilePaths(bigFilePaths);
-				if (CBigFile::getInstance().getBigFileName(filename.substr(0, pos)) != "data/"+filename.substr(0, pos))
-					isInData = false;
-				else
-					isInData = true;
-			}
-
-			if ((needCheck && !isInData) || !file.open (CPath::lookup(firstFileName)))
-			{
-				// todo hulud interface syntax error
-				nlwarning ("could not open file %s, skipping xml parsing",firstFileName.c_str());
-				return false;
-			}
-			read.init (file);
-		}
-		else
-		{
-			firstFileName = SCRIPT_AS_STRING; // for error msg
-			interfaceScriptAsMemStream(*it, scriptStream);
-			read.init(scriptStream);
-		}
-		//get the enclosing element (<interface config>)
-		globalEnclosing = read.getRootNode();
-		if (!globalEnclosing)
-		{
-			// todo hulud interface syntax error
-			nlwarning ("no root element in xml file %s, skipping xml parsing",firstFileName.c_str());
-			return false;
-		}
-		if (strcmp( (char*)globalEnclosing->name,"interface_config") )
-		{
-			// todo hulud interface syntax error
-			nlwarning ("wrong root element in xml file %s, skipping xml parsing",firstFileName.c_str());
-			return false;
-		}
-		if (isFilename)
-		{
-			file.close();
-		}
-
-		// Get all other xml files, and add their nodes to the first xml document
-		it++;
-		uint32 i = 0;
-		for (; it != strings.end(); it++)
-		{
-			//nlwarning("Parsing interface file : %s", it->c_str());
-			nextFileName = *it;
-			CIXml nextRead;
-			xmlNodePtr cur = NULL;
-			bool saveParseResult = false;
-			bool readFromUncompressedXML = true;
-			if( isFilename && cacheUIParsing )
-			{
-				saveParseResult = true;
-				std::string archive = CPath::lookup(nextFileName + "_compressed", false, false);
-				std::string current = CPath::lookup(nextFileName, false, false);
-				if (!archive.empty() && !current.empty())
-				{
-					if (CFile::getFileModificationDate(current) <= CFile::getFileModificationDate(archive))
-					{
-						CIFile input;
-						input.open(archive);
-						input.serialCheck(UI_CACHE_SERIAL_CHECK);
-						input.serialVersion(0);
-						cur = buildTree(input);
-						input.serialCheck(UI_CACHE_SERIAL_CHECK);
-						readFromUncompressedXML = false;
-						saveParseResult = false;
-					}
-				}
-			}
-			if (!cur)
-			{
-				if (isFilename)
-				{
-					if (!file.open(CPath::lookup(nextFileName, false, false)))
-					{
-						// todo hulud interface syntax error
-						nlwarning ("could not open file %s, skipping xml parsing",nextFileName.c_str());
-						return false;
-					}
-					nextRead.init (file);
-				}
-				else
-				{
-					interfaceScriptAsMemStream(nextFileName, scriptStream);
-					nextFileName = SCRIPT_AS_STRING; // for error MSG
-					read.init(scriptStream);
-				}
-				cur = nextRead.getRootNode();
-				if (!cur)
-				{
-					// todo hulud interface syntax error
-					nlwarning ("no root element in  xml file %s, skipping xml parsing", it->c_str() );
-					return false;
-				}
-			}
-			if (saveParseResult)
-			{
-				nlassert(isFilename);
-				std::string outputFilename = CPath::standardizePath("data") + CFile::getFilename(nextFileName) + std::string("_compressed");
-				COFile f;
-				f.open(outputFilename);
-				f.serialCheck(UI_CACHE_SERIAL_CHECK);
-				f.serialVersion(0);
-				saveXMLTree(f, cur);
-				f.serialCheck(UI_CACHE_SERIAL_CHECK);
-			}
-			if (strcmp( (char*)cur->name,"interface_config") )
-			{
-				// todo hulud interface syntax error
-				nlwarning ("wrong root element in xml file %s. should be interface config, skipping xml parsing", nextFileName.c_str());
-				return false;
-			}
-			xmlNodePtr curSon = cur->children;
-			while (curSon)
-			{
-				xmlNodePtr bufNode = xmlCopyNode (curSon, 1);
-				xmlAddChild (globalEnclosing,bufNode);
-				curSon = curSon->next;
-			}
-			if (!readFromUncompressedXML)
-			{
-				freeXMLNodeAndSibblings(cur);
-			}
-			if (isFilename)
-			{
-				file.close();
-			}
-			i++;
-		}
-	}
-	catch (const Exception &e)
-	{
-		// Output error
-		// todo hulud interface syntax error
-		nlwarning ("CInterfaceParser: Error while loading the xml interface file %s, skipping xml parsing : %s", nextFileName.c_str(), e.what());
-		if (testWildCard(nextFileName, "save/keys_?*.xml"))
-		{
-			// if file matches 'save/keys_?*.xml', move this file as a backup
-			string	backup = nextFileName+".backup";
-			if (CFile::fileExists(backup))
-				CFile::deleteFile(backup);
-			CFile::moveFile(backup.c_str(), nextFileName.c_str());
-		}
-		return false;
-	}
-	//parse the built doc
-	ok = parseXMLDocument(globalEnclosing, reload);
-//	freeXMLNodeAndSibblings(globalEnclosing); // Done by the ~CIXml
-
-
-	// TestYoyo. UnHide for Parsing Profile
-	/*
-	}
-	NLMISC::CHTimer::endBench();
-	// Display and save profile to a File.
-	CLog	log;
-	CFileDisplayer	fileDisplayer(NLMISC::CFile::findNewFile(getLogDirectory() + "profile_parseInterface.log"));
-	log.addDisplayer(&fileDisplayer);
-	// diplay
-	NLMISC::CHTimer::displayHierarchicalByExecutionPathSorted(&log, CHTimer::TotalTime, true, 48, 2);
-	NLMISC::CHTimer::display(&log, CHTimer::TotalTime);
-	*/
-
-
-	return ok;
-}
-
-
-// ----------------------------------------------------------------------------
-bool CInterfaceParser::parseXMLDocument(xmlNodePtr root, bool reload)
-{
-	H_AUTO(parseXMLDocument);
-
-	CWidgetManager::SMasterGroup *curRoot = NULL;
-	CInterfaceGroup *rootGroup = NULL;
-	//parse templates
-	xmlNodePtr curNode = root->children;
-
-	std::vector< CWidgetManager::SMasterGroup > &_MasterGroups = CWidgetManager::getInstance()->getAllMasterGroup();
-
-	while (curNode)
-	{
-		// first solve define for the xml node and his sons
-		if(!solveDefine(curNode))
-		{
-			// todo hulud interface syntax error
-			nlwarning ("could not read all define");
-		}
-		// then try to solve Style for the xml node and his sons
-		else if (!solveStyle(curNode))
-		{
-			// todo hulud interface syntax error
-			nlwarning ("could not read all styles");
-		}
-		// If define and style oks, try to parse "1st pass" objets (define, options....).
-		else if ( !strcmp((char*)curNode->name,"template") )
-		{
-			// Check there is a valid name for this template
-			CXMLAutoPtr ptr((const char*) xmlGetProp( curNode, (xmlChar*)"name" ));
-			if (ptr)
-			{
-				// remove any template with the same name in the list (useful when using 'loadui' command)
-				for(uint k = 0; k < _Templates.size(); ++k)
-				{
-					CXMLAutoPtr otherTemplName((const char*) xmlGetProp( _Templates[k], (xmlChar*)"name" ));
-					if (strcmp((const char *) otherTemplName, (const char *) ptr) == 0)
-					{
-						nlwarning("Replacing template %s with new version", (const char *) ptr);
-						xmlFreeNode(_Templates[k]);
-						_Templates[k] = NULL;
-					}
-				}
-				_Templates.erase(std::remove(_Templates.begin(), _Templates.end(), (xmlNodePtr) NULL), _Templates.end());
-				_Templates.push_back(curNode);
-			}
-			else
-				// todo hulud interface syntax error
-				nlwarning ("no name in a template node");
-		}
-		else if ( !strcmp((char*)curNode->name,"options") )
-		{
-			if (!parseOptions(curNode,rootGroup))
-				// todo hulud interface syntax error
-				nlwarning ("could not parse options");
-		}
-		else if ( !strcmp((char*)curNode->name,"define") )
-		{
-			if (!parseDefine(curNode))
-				// todo hulud interface syntax error
-				nlwarning ("could not parse define");
-		}
-		else if ( !strcmp((char*)curNode->name,"style") )
-		{
-			if (!parseStyle(curNode))
-				// todo hulud interface syntax error
-				nlwarning ("could not parse 'style'");
-		}
-		else
-		{
-			IParserModule *module = getModuleFor( (char*)( curNode->name ) );
-			if( module != NULL ){
-				if( module->canParseInStage( IParserModule::Unresolved ) )
-					module->parse( curNode, rootGroup );
-			}
-		}
-
-		curNode = curNode->next;
-	}
-
-
-	if (!reload) // TMP : crahs when doing the setup twice (old pointer on the text manager ...)
-	{
-		setupOptions();
-	}
-
-
-	//parse filters , groups and eventually instances
-	// vector that are on top of the xml hierarchy
-	root = root->children;
-	while (root)
-	{
-		if ( !strcmp((char*)root->name,"root") )
-		{
-			CXMLAutoPtr ptr((const char*)xmlGetProp (root, (xmlChar*)"id"));
-			if (ptr)
-			{
-				rootGroup = CWidgetManager::getInstance()->getMasterGroupFromId (string("ui:") + (const char*)ptr);
-				if (rootGroup == NULL)
-				{
-					rootGroup = (CInterfaceGroup*)(new CRootGroup(CViewBase::TCtorParam()));
-					rootGroup->parse (root, NULL);
-					CWidgetManager::SMasterGroup mg;
-					mg.Group = rootGroup;
-					_MasterGroups.push_back (mg);
-				}
-				for (uint32 i = 0; i < _MasterGroups.size(); ++i)
-					if (_MasterGroups[i].Group == rootGroup)
-						curRoot = &_MasterGroups[i];
-			}
-			else
-			{
-				// todo hulud interface syntax error
-				nlwarning ("could not parse root");
-			}
-		}
-		else if (!strcmp((char*)root->name,"group"))
-		{
-			if (!parseGroup(root,rootGroup, reload))
-				// todo hulud interface syntax error
-				nlwarning ("could not parse group");
-		}
-		else if (!strcmp((char*)root->name,"instance"))
-		{
-			if (!parseInstance(root))
-				// todo hulud interface syntax error
-				nlwarning ("could not parse instance");
-		}
-		else if (!strcmp((char*)root->name,"view"))
-		{
-			if (!parseView(root,rootGroup, reload))
-				// todo hulud interface syntax error
-				nlwarning ("could not parse view");
-		}
-		else if (!strcmp((char*)root->name,"ctrl"))
-		{
-			if (!parseControl(root,rootGroup, reload))
-				// todo hulud interface syntax error
-				nlwarning ("could not parse control");
-		}
-		else if ( !strcmp((char*)root->name,"vector") )
-		{
-			if (!parseVector(root))
-				// todo hulud interface syntax error
-				nlwarning ("could not parse vector");
-		}
-		else if ( !strcmp((char*)root->name,"link") )
-		{
-			if (!parseLink(root,rootGroup))
-				// todo hulud interface syntax error
-				nlwarning ("could not parse link");
-		}
-		else if ( !strcmp((char*)root->name,"variable") )
-		{
-			if (!parseVariable(root,rootGroup))
-				// todo hulud interface syntax error
-				nlwarning ("could not parse variable");
-		}
-		else if ( !strcmp((char*)root->name,"tree") )
-		{
-			if (!parseTree(root,curRoot))
-				// todo hulud interface syntax error
-				nlwarning ("could not parse tree");
-			/* if (!setupTree(root,curRoot))
-				nlwarning ("could not setup tree"); */
-		}
-		else if ( !strcmp((char*)root->name,"proc") )
-		{
-			if (!parseProcedure(root, reload))
-				// todo hulud interface syntax error
-				nlwarning ("could not parse procedure");
-		}
-		else if ( !strcmp((char*)root->name,"sheet_selection") )
-		{
-			if (!parseSheetSelection(root))
-				// todo hulud interface syntax error
-				nlwarning ("could not parse sheet selection");
-		}
-		else if ( !strcmp((char*)root->name,"anim") )
-		{
-			if (!parseAnim(root,rootGroup))
-				// todo hulud interface syntax error
-				nlwarning ("could not parse 'anim'");
-		}
-		else if ( !strcmp((char*)root->name,"lua") )
-		{
-			if(!parseLUAScript(root))
-			{
-				nlwarning ("could not parse 'lua'");
-				exit( EXIT_FAILURE );
-			}
-		}
-		else
-		{
-			IParserModule *module = getModuleFor( (char*)( root->name ) );
-			if( module != NULL )
-			{
-				if( module->canParseInStage( IParserModule::Resolved ) )
-					module->parse( root, rootGroup );
-			}
-		}
-
-		root = root->next;
-	}
-
-	// add all modals group to the window list
-	for (uint32 i = 0; i < _MasterGroups.size(); ++i)
-	{
-		H_AUTO(addWindowToMasterGroup)
-
-		CWidgetManager::SMasterGroup &rMG = _MasterGroups[i];
-		// insert all modals
-		for (uint32 j = 0; j < rMG.Group->getGroups().size(); ++j)
-		{
-			CGroupModal *pIG = dynamic_cast<CGroupModal*>(rMG.Group->getGroups()[j]);
-			// if it is a modal group
-			if(pIG)
-			{
-				// add to the window list
-				CWidgetManager::getInstance()->addWindowToMasterGroup(rMG.Group->getId(), pIG);
-			}
-		}
-	}
-
-	// init all the elements coords, and Lua Script
-	if (!initCoordsAndLuaScript())
-		return false;
-
-	std::vector<xmlNodePtr> keptTemplates;
-
-	// keep template that have the "keep" flag if we are not reloading
-	// if reloading, always keep the template
-	{
-		H_AUTO(keep_template)
-
-			CXMLAutoPtr ptr;
-		for(uint k = 0; k < _Templates.size(); ++k)
-		{
-			CXMLAutoPtr ptr(xmlGetProp(_Templates[k], (const xmlChar *) "keep"));
-			if (reload || (ptr && nlstricmp((const char *) ptr, "true") == 0))
-			{
-				// xmlUnsetProp(_Templates[k], (const xmlChar *) "keep");
-				xmlNodePtr	copy = xmlCopyNode(_Templates[k], 1);
-				if (copy)
-					keptTemplates.push_back(copy);
-			}
-
-			// free the original node, whether we kept a copy or not
-			xmlUnlinkNode( _Templates[k] );
-			xmlFreeNode( _Templates[k] );
-			_Templates[k] = NULL;
-		}
-		// keep new list
-		_Templates.swap(keptTemplates);
-	}
-	return true;
-}
-
-// ----------------------------------------------------------------------------
-bool CInterfaceParser::parseTemplateNode(xmlNodePtr node,xmlNodePtr instance,xmlNodePtr templ)
-{
-	CXMLAutoPtr ptr;
-	//get the node properties
-	xmlAttrPtr props = node->properties;
-	while (props)
-	{
-		//get the property value
-		ptr = (char*)xmlGetProp( node, props->name);
-		nlassert(ptr);
-		//if it begins with a #, it is a reference in the instance attribute
-		if (strchr(ptr, '#') != NULL)
-		{
-			string LastProp = ptr;
-			string NewProp ="";
-			string RepProp;
-
-			while (LastProp.size() > 0)
-			{
-				string::size_type diesPos = LastProp.find("#");
-				if (diesPos != string::npos)
-				{
-					if (diesPos > 0)
-					{
-						NewProp += LastProp.substr(0, LastProp.find("#"));
-						LastProp = LastProp.substr(LastProp.find("#"),LastProp.size());
-					}
-
-					CXMLAutoPtr instanceProp;
-					for (uint32 i = 0; i < LastProp.size(); ++i)
-					{
-						RepProp = LastProp.substr(0, LastProp.size()-i);
-						instanceProp = xmlGetProp (instance , (const xmlChar*)(RepProp.c_str() + 1));
-						if (instanceProp)
-							break;
-						instanceProp = xmlGetProp (templ , (const xmlChar*)(RepProp.c_str() + 1));
-						if (instanceProp)
-							break;
-					}
-					if (!instanceProp)
-					{
-						CXMLAutoPtr ptr2((const char*)xmlGetProp( instance, (xmlChar*)"id"));
-						string sTmp;
-						if (ptr2.getDatas() != NULL)
-							sTmp = string("cannot parse template node property: ") + ((const char *) ptr + 1) + string(" in instance : ") + string((const char*)ptr2);
-						else
-							sTmp = string("cannot parse template node property: ") + ((const char *) ptr + 1) + string(" in instance : NULL");
-						// todo hulud interface syntax error
-						nlinfo(sTmp.c_str());
-
-						return false;
-					}
-					NewProp += string((const char*)instanceProp);
-					LastProp = LastProp.substr (RepProp.size(), LastProp.size());
-				}
-				else
-				{
-					NewProp += LastProp;
-					LastProp = "";
-				}
-			}
-			xmlSetProp(node,props->name, (const xmlChar*)NewProp.c_str());
-		}
-		props = props->next;
-	}
-	//parse the node children
-	node = node->children;
-	while (node)
-	{
-		if (!parseTemplateNode(node,instance,templ))
-			return false;
-		node = node->next;
-	}
-	return true;
-}
-
-// ----------------------------------------------------------------------------
-bool CInterfaceParser::parseInstance(xmlNodePtr cur)
-{
-	H_AUTO(parseInstance)
-
-	CXMLAutoPtr ptr;
-
-	//try to find the instance template in our template vector. If the template doesn't exist, return false
-	CXMLAutoPtr templ((const char*) xmlGetProp( cur, (xmlChar*)"template" ));
-	if (!templ)
-	{
-		// todo hulud interface syntax error
-		nlinfo("parse error : no referenced template in an instance");
-		return false;
-	}
-	vector<xmlNodePtr>::const_iterator it;
-	for (it = _Templates.begin(); it != _Templates.end();it++)
-	{
-		ptr = (char*) xmlGetProp( *it, (xmlChar*)"name" );
-		if (!ptr)
-		{
-			// todo hulud interface syntax error
-			nlinfo("no name in a template node");
-			return false;
-		}
-		if ( !strcmp(templ,ptr) )
-		{
-			break;
-		}
-	}
-	if ( it == _Templates.end() )
-	{
-		// todo hulud interface syntax error
-		nlinfo("the template %s was not found", (const char*)templ);
-		return false;
-	}
-
-	xmlNodePtr templNode = *it;
-	//for each child of the template, create the appropriate node
-	xmlNodePtr child = (*it)->children;
-	xmlNodePtr nextSibling=cur;
-	while (child)
-	{
-		//copy the template child node
-		xmlNodePtr node = xmlCopyNode (child, 1);
-
-		//add it to our tree
-		//node = xmlAddChild(cur->parent,node);
-		node = xmlAddNextSibling (nextSibling, node);
-		nextSibling = nextSibling->next;
-
-		//parse the child
-		if (!parseTemplateNode(node, cur, templNode))
-			return false;
-		child = child->next;
-	}
-	return true;
-}
-
-// ----------------------------------------------------------------------------
-bool CInterfaceParser::parseVector(xmlNodePtr cur)
-{
-	H_AUTO(parseVector)
-
-	//get the number of elements
-	CXMLAutoPtr cSize((const char*) xmlGetProp( cur, (xmlChar*)"_size" ));
-	if (!cSize)
-	{
-		// todo hulud interface syntax error
-		nlinfo("no _size in a vector");
-		return false;
-	}
-	sint32 size;
-	fromString(cSize, size);
-	if (size <= 0)
-	{
-		// todo hulud interface syntax error
-		nlinfo("size<0");
-		return false;
-	}
-
-	// Vector of groups
-	bool bGroupVector = true;
-
-	//get the first position reference
-	CXMLAutoPtr firstpos((const char*) xmlGetProp( cur, (xmlChar*)"_firstpos" ));
-	if (!firstpos)
-	{
-		bGroupVector = false;
-	}
-	//get the next position reference
-	CXMLAutoPtr nextpos((const char*) xmlGetProp( cur, (xmlChar*)"_nextpos" ));
-	if (!nextpos)
-	{
-		bGroupVector = false;
-	}
-
-	sint32 index = 0;
-	//get the first index value
-	CXMLAutoPtr indexChar((const char*) xmlGetProp( cur, (xmlChar*)"_firstindex" ));
-	if (indexChar)
-	{
-		fromString((const char*)indexChar, index);
-	}
-
-	sint32 step = 1;
-	//get the step for the indices
-	CXMLAutoPtr stepChar((const char*) xmlGetProp( cur, (xmlChar*)"_step" ));
-	if (stepChar)
-	{
-		fromString((const char*)stepChar, step);
-	}
-
-
-	//get the x and y of the first element
-	CXMLAutoPtr xfirst((const char*) xmlGetProp( cur, (xmlChar*)"_xfirst" ));
-	CXMLAutoPtr yfirst((const char*) xmlGetProp( cur, (xmlChar*)"_yfirst" ));
-
-	xmlNodePtr node;
-	CXMLAutoPtr id;
-	xmlNodePtr nextSibling= cur;
-	//now we can add all the following elements
-	sint32 i;
-	for (i = index;; i += step)
-	{
-		if (step > 0)
-		{
-			if (i >= index + size) break;
-		}
-		else
-		{
-			if (i <= index - size) break;
-		}
-		//copy the node
-		node = xmlCopyNode(cur,1);
-		//set the name and posref
-
-		if (bGroupVector)
-		{
-			if (i==index)
-			{
-				xmlSetProp(node,(xmlChar*)"posref",(const xmlChar*)firstpos);
-				if (xfirst)
-				{
-					xmlSetProp(node,(xmlChar*)"x",(const xmlChar*)xfirst);
-				}
-				if (yfirst)
-				{
-					xmlSetProp(node,(xmlChar*)"y",(const xmlChar*)yfirst);
-				}
-			}
-			else
-			{
-				xmlSetProp(node,(xmlChar*)"posref",(const xmlChar*)nextpos);
-				xmlSetProp(node,(xmlChar*)"posparent",(const xmlChar*)id);
-			}
-		}
-
-		xmlNodeSetName(node,(xmlChar*)"instance");
-
-		//replace all the $i
-		xmlAttrPtr attr = node->properties;
-		while(attr)
-		{
-			CXMLAutoPtr prop((const char*) xmlGetProp( node, attr->name ));
-			string str((const char*)prop);
-			string::size_type pos = str.find("$i");
-			while (pos != string::npos)
-			{
-				str.replace(pos,2,toString(i));
-				pos = str.find("$i",pos);
-			}
-			xmlSetProp(node,attr->name,(xmlChar*)str.c_str());
-			attr = attr->next;
-
-		}
-		//add the new instance to our tree, just near us.
-		xmlAddNextSibling (nextSibling, node);
-		nextSibling= node;
-
-		//get the node id, used in the next iteration
-		if (bGroupVector)
-		{
-			id = (char*) xmlGetProp( node, (xmlChar*)"id" );
-			if (!id)
-			{
-				// todo hulud interface syntax error
-				nlinfo("no id in a vector");
-				break;
-			}
-		}
-	}
-
-	return step > 0 ? (i == index + size) : (i == index - size);
-}
-
-// ----------------------------------------------------------------------------
-bool CInterfaceParser::parseLink(xmlNodePtr cur, CInterfaceGroup * parentGroup)
-{
-	H_AUTO(parseLink)
-
-	CXMLAutoPtr ptr((const char*) xmlGetProp (cur, (xmlChar*)"expr"));
-	if (!ptr)
-	{
-		// todo hulud interface syntax error
-		nlwarning("<CInterfaceParser::parseLink> Can't read  the expression for a link node");
-		return false;
-	}
-	std::string expr = ptr;
-
-
-	std::vector<CInterfaceLink::CTargetInfo> targets;
-
-	ptr = (char*) xmlGetProp (cur, (xmlChar*)"target");
-	if (ptr)
-	{
-		CInterfaceLink::splitLinkTargets(std::string((const char*)ptr), parentGroup, targets);
-	}
-	// optional action handler
-	std::string action;
-	std::string params;
-	std::string cond;
-	ptr = (char*) xmlGetProp (cur, (xmlChar*)"action");
-	if (ptr) action = (const char *) ptr;
-	ptr = (char*) xmlGetProp (cur, (xmlChar*)"params");
-	if (ptr) params = (const char *) ptr;
-	ptr = (char*) xmlGetProp (cur, (xmlChar*)"cond");
-	if (ptr) cond = (const char *) ptr;
-
-	// create the link
-	CInterfaceLink *il = new CInterfaceLink;
-	il->init(targets, expr, action, params, cond, parentGroup); // init will add 'il' in the list of link present in 'elm'
-	return true;
-}
-
-// ----------------------------------------------------------------------------
-bool CInterfaceParser::parseVariable (xmlNodePtr cur, CInterfaceGroup * /* parentGroup */)
-{
-	H_AUTO(parseVariable )
-
-	//get the args
-	CXMLAutoPtr ptr((const char*) xmlGetProp (cur, (xmlChar*)"entry"));
-	if (!ptr)
-	{
-		// todo hulud interface syntax error
-		nlinfo ("no entry in a variable tag");
-		return false;
-	}
-	string entry((const char*)ptr);
-
-	ptr = (char*) xmlGetProp (cur, (xmlChar*)"type");
-	if (!ptr)
-	{
-		// todo hulud interface syntax error
-		nlinfo ("no type in a variable tag");
-		return false;
-	}
-	string type((const char*)ptr);
-
-	string value;
-	ptr = (char*) xmlGetProp (cur, (xmlChar*)"value");
-	if (!ptr)
-	{
-		//if no value is specified, try to get the db entry directly
-		value = entry;
-	}
-	else
-		value = string((const char*)ptr);
-
-	// Array definition
-	sint	size= 1;
-	bool	ArrayMode= false;
-	string	entryPrefix;
-	string	entrySuffix;
-	ptr = (char*) xmlGetProp (cur, (xmlChar*)"size");
-	if (ptr)
-	{
-		ArrayMode= true;
-		fromString((const char*)ptr, size);
-		string::size_type pos= entry.find("$i");
-		if( pos==string::npos )
-		{
-			// todo hulud interface syntax error
-			nlinfo ("no $i found in a 'variable' tag with 'size' defined ");
-			return false;
-		}
-		else
-		{
-			entryPrefix= entry.substr(0, pos);
-			entrySuffix= entry.substr(pos+2);
-		}
-	}
-
-	// loop all variables
-	for(sint index= 0;index<size;index++)
-	{
-		// If array variable, build the variable name
-		if(ArrayMode)
-		{
-			entry= entryPrefix + toString(index) + entrySuffix;
-		}
-
-		// access the database
-		CInterfaceProperty prop;
-
-		if (type == "sint64")
-			prop.readSInt64(value.c_str(),entry);
-		else if (type == "sint32")
-			prop.readSInt32(value.c_str(),entry);
-		else if (type == "float" || type == "double")
-			prop.readDouble(value.c_str(),entry);
-		else if (type == "bool")
-			prop.readBool(value.c_str(),entry);
-		else if (type == "rgba")
-			prop.readRGBA(value.c_str(),entry);
-		else if (type == "hotspot")
-			prop.readHotSpot(value.c_str(),entry);
-		else if (type == "text")
-		{
-			/*uint textId = addText(value);
-			prop.readSInt32(toString(textId),entry);*/
-		}
-	}
-
-	return true;
-}
-
-// ----------------------------------------------------------------------------
-bool CInterfaceParser::parseOptions (xmlNodePtr cur, CInterfaceGroup * /* parentGroup */)
-{
-	H_AUTO(parseOptions )
-
-	// build the options from type
-	CInterfaceOptions *options = NULL;
-	CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"type" ));
-	if (ptr)
-	{
-		options = NLMISC_GET_FACTORY( CInterfaceOptions, std::string ).createObject( std::string( (const char*)ptr ), CInterfaceOptions::TCtorParam() );
-
-		if( options == NULL )
-			options = new CInterfaceOptions( CInterfaceOptions::TCtorParam() );
-	}
-	else
-	{
-		options = new CInterfaceOptions( CInterfaceOptions::TCtorParam() );
-	}
-
-	CWidgetManager *wm = CWidgetManager::getInstance();
-
-	// get the name
-	ptr = (char*) xmlGetProp( cur, (xmlChar*)"name" );
-	if (!ptr)
-	{
-		// todo hulud interface syntax error
-		nlinfo ("options has no name");
-		return false;
-	}
-	string optionsName = ptr;
-
-	// herit if possible
-	ptr = (char*) xmlGetProp( cur, (xmlChar*)"herit" );
-	if (ptr)
-	{
-		string optionsParentName = ptr;
-		CInterfaceOptions *io = wm->getOptions( optionsParentName );
-		if( io != NULL )
-			options->copyBasicMap( *io );
-	}
-
-	// parse parameters
-	if (options->parse (cur))
-	{
-		// Remove old one
-		wm->removeOptions( optionsName );
-		wm->addOptions( optionsName, options );
-	}
-	else
-	{
-		delete options;
-		return false;
-	}
-	return true;
-}
-
-// ----------------------------------------------------------------------------
-bool CInterfaceParser::parseGroup (xmlNodePtr cur, CInterfaceGroup * parentGroup, bool reload)
-{
-	H_AUTO(parseGroup )
-
-	CInterfaceGroup * group;
-	CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"type" ));
-	if (ptr)
-	{
-		group = dynamic_cast<CInterfaceGroup*>( NLMISC_GET_FACTORY(CViewBase, std::string).createObject(string((const char*)ptr), CViewBase::TCtorParam()) );
-		if (group == NULL)
-		{
-			group = dynamic_cast<CInterfaceGroup*>(NLMISC_GET_FACTORY(CViewBase, std::string).createObject("interface_group", CViewBase::TCtorParam()));
-		}
-
-	}
-	else
-		group = dynamic_cast<CInterfaceGroup*>(NLMISC_GET_FACTORY(CViewBase, std::string).createObject("interface_group", CViewBase::TCtorParam()));
-
-	// parse the group attributes
-	if (!group->parse(cur,parentGroup))
-	{
-		delete group;
-		// todo hulud interface syntax error
-		nlwarning ("cannot parse group attributes");
-		return false;
-	}
-
-	if (parentGroup)
-	{
-		CGroupList *pList = dynamic_cast<CGroupList*>(parentGroup);
-		if (parentGroup->getElement(group->getId()) != NULL)
-		{
-			// Remove old groupe and replace
-			if (reload)
-			{
-				// Remove from the parent
-				parentGroup->delElement (group->getId(), true);
-			}
-			else
-			{
-				// todo hulud interface syntax error
-				nlwarning ("id already exists for %s in %s", group->getId().c_str(), parentGroup->getId().c_str());
-				delete group;
-				return false;
-			}
-		}
-
-		if (pList != NULL)
-			pList->addChild (group);
-		else
-			parentGroup->addGroup (group);
-	}
-	else
-	{
-		// todo hulud interface syntax error
-		nlinfo ("no parent for %s", group->getId().c_str());
-		delete group;
-		return false;
-	}
-
-	//parse the children
-	bool ok = parseGroupChildren(cur, group, reload);
-
-	if (!ok)
-	{
-		string tmp = "cannot parse group "+group->getId();
-		// todo hulud interface syntax error
-		nlinfo (tmp.c_str());
-	}
-	return ok;
-}
-
-// ----------------------------------------------------------------------------
-bool CInterfaceParser::parseGroupChildren(xmlNodePtr cur, CInterfaceGroup * parentGroup, bool reload)
-{
-	cur = cur->children;
-	bool ok = true;
-	while (cur)
-	{
-		if ( !strcmp((char*)cur->name,"view") )
-			ok = ok && parseView(cur,parentGroup, reload);
-		else if ( !strcmp((char*)cur->name,"ctrl") )
-			ok = ok && parseControl(cur,parentGroup, reload);
-		else if ( !strcmp((char*)cur->name,"group") )
-			ok = ok && parseGroup(cur,parentGroup, reload);
-		else if ( !strcmp((char*)cur->name,"instance") )
-			ok = ok && parseInstance(cur);
-		else if ( !strcmp((char*)cur->name,"vector") )
-			ok = ok && parseVector(cur);
-		else if ( !strcmp((char*)cur->name,"link") )
-			ok = ok && parseLink(cur,parentGroup);
-		else
-		{
-			IParserModule *module = getModuleFor( (char*)( cur->name ) );
-			if( module != NULL )
-			{
-				if( module->canParseInStage( IParserModule::GroupChildren ) )
-					ok = ok && module->parse( cur, parentGroup );
-			}
-		}
-
-
-		cur = cur->next;
-	}
-	return ok;
-}
-
-// ----------------------------------------------------------------------------
-bool CInterfaceParser::parseControl (xmlNodePtr cur, CInterfaceGroup * parentGroup, bool reload)
-{
-	H_AUTO(parseControl )
-
-	CCtrlBase* ctrl = NULL;
-	CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"type" ));
-	if (!ptr)
-	{
-		// todo hulud interface syntax error
-		nlinfo ("no type in a control tag");
-		return false;
-	}
-
-	ctrl = dynamic_cast<CCtrlBase*>(NLMISC_GET_FACTORY(CViewBase, std::string).createObject(string((const char*)ptr), CViewBase::TCtorParam()));
-
-	if (ctrl)
-	{
-		if (!ctrl->parse(cur,parentGroup))
-		{
-			delete ctrl;
-			return false;
-		}
-		if (parentGroup->getElement(ctrl->getId()) != NULL)
-		{
-			// Remove old groupe and replace
-			if (reload)
-				parentGroup->delElement (ctrl->getId());
-			else
-			{
-				// todo hulud interface syntax error
-				nlwarning ("id already exists for %s in %s", ctrl->getId().c_str(), parentGroup->getId().c_str());
-				delete ctrl;
-				return false;
-			}
-		}
-		// Add the ctrl to the parent group
-		parentGroup->addCtrl(ctrl);
-		return true;
-	}
-	return false;
-}
-
-// ----------------------------------------------------------------------------
-bool CInterfaceParser::parseView(xmlNodePtr cur, CInterfaceGroup * parentGroup, bool reload)
-{
-	H_AUTO(parseView)
-
-	CViewBase * view=NULL;
-	CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"type" ));
-	if (!ptr)
-	{
-		// todo hulud interface syntax error
-		nlinfo("no type in a view");
-		return false;
-	}
-
-	view = NLMISC_GET_FACTORY(CViewBase, std::string).createObject(string((const char*)ptr), CViewBase::TCtorParam());
-
-	if ( !strcmp(ptr,"pointer"))
-	{
-		CWidgetManager::getInstance()->setPointer( dynamic_cast<CViewPointer*>(view) );
-	}
-
-	//nlinfo("view type %s mem : %d",ptr,view->getMemory());
-	if (view)
-	{
-		if (!view->parse(cur,parentGroup))
-		{
-			delete view;
-			return false;
-		}
-		if (parentGroup->getElement(view->getId()) != NULL)
-		{
-			// Remove old groupe and replace
-			if (reload)
-				parentGroup->delElement (view->getId());
-			else
-			{
-				// todo hulud interface syntax error
-				nlwarning ("id already exists for %s in %s", view->getId().c_str(), parentGroup->getId().c_str());
-				delete view;
-				return false;
-			}
-		}
-
-		//add the view to the parent group
-		CGroupList *pList = dynamic_cast<CGroupList*>(parentGroup);
-		if (pList != NULL)
-		{
-			pList->addChild (view);
-		}
-		else
-		{
-			parentGroup->addView(view);
-		}
-		return true;
-	}
-	// todo hulud interface syntax error
-	nlinfo("unknown view type %s", (const char*)ptr);
-	return false;
-}
-
-// ----------------------------------------------------------------------------
-bool CInterfaceParser::parseTreeNode (xmlNodePtr cur, CGroupContainer *parentGroup)
-{
-	CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"node" ));
-	if (!ptr) return false;
-	CInterfaceElement *pEltFound = NULL;
-	std::vector< CWidgetManager::SMasterGroup > &_MasterGroups = CWidgetManager::getInstance()->getAllMasterGroup();
-	for (uint32 i = 0; i < _MasterGroups.size(); ++i)
-	{
-		CWidgetManager::SMasterGroup &rMG = _MasterGroups[i];
-		for (uint32 j = 0; j < rMG.Group->getGroups().size(); ++j)
-		{
-			CInterfaceGroup *pIG = rMG.Group->getGroups()[j];
-			string stmp = strlwr(pIG->getId().substr(pIG->getId().rfind(':')+1,pIG->getId().size()));
-			string stmp2 = strlwr(string((const char*)ptr));
-			if (stmp == stmp2)
-			{
-				pEltFound = pIG;
-				break;
-			}
-		}
-		if (pEltFound != NULL)
-			break;
-	}
-	if (pEltFound == NULL)
-	{
-		string stmp = string("element not found for tree : ") + string((const char*)ptr);
-		// todo hulud interface syntax error
-		nlinfo(stmp.c_str());
-		return false;
-	}
-	CGroupContainer *pIC = dynamic_cast<CGroupContainer*>(pEltFound);
-	if (pIC == NULL)
-	{
-		string stmp = string("not a container : ") + pEltFound->getId();
-		// todo hulud interface syntax error
-		nlinfo(stmp.c_str());
-		return false;
-	}
-	parentGroup->attachContainer (pIC);
-	cur = cur->children;
-	while (cur)
-	{
-		parseTreeNode(cur, pIC);
-		cur = cur->next;
-	}
-	return true;
-}
-
-// ----------------------------------------------------------------------------
-bool CInterfaceParser::setupTreeNode (xmlNodePtr cur, CGroupContainer * /* parentGroup */)
-{
-	CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"node" ));
-	if (!ptr) return false;
-	std::vector< CWidgetManager::SMasterGroup > &_MasterGroups = CWidgetManager::getInstance()->getAllMasterGroup();
-	CInterfaceElement *pEltFound = NULL;
-	for (uint32 i = 0; i < _MasterGroups.size(); ++i)
-	{
-		CWidgetManager::SMasterGroup &rMG = _MasterGroups[i];
-		for (uint32 j = 0; j < rMG.Group->getGroups().size(); ++j)
-		{
-			CInterfaceGroup *pIG = rMG.Group->getGroups()[j];
-			string stmp = strlwr(pIG->getId().substr(pIG->getId().rfind(':')+1,pIG->getId().size()));
-			string stmp2 = strlwr(string((const char*)ptr));
-			if (stmp == stmp2)
-			{
-				pEltFound = pIG;
-				break;
-			}
-		}
-		if (pEltFound != NULL)
-			break;
-	}
-	if (pEltFound == NULL)
-	{
-		string stmp = string("element not found for tree : ") + string((const char*)ptr);
-		// todo hulud interface syntax error
-		nlinfo(stmp.c_str());
-		return false;
-	}
-	CGroupContainer *pIC = dynamic_cast<CGroupContainer*>(pEltFound);
-	if (pIC == NULL)
-	{
-		string stmp = string("not a container : ") + pEltFound->getId();
-		// todo hulud interface syntax error
-		nlinfo(stmp.c_str());
-		return false;
-	}
-	// See if the group should be docked.
-	ptr = (char*) xmlGetProp( cur, (xmlChar*)"docked" );
-	if (nlstricmp((const char *) ptr, "true") == 0)
-	{
-		// dock the container
-		pIC->popupCurrentPos();
-		// compute position on screen
-		sint32 x = 0, y = 0, w = 200, h = 100;
-		ptr = (char*) xmlGetProp( cur, (xmlChar*)"x" );
-		if (ptr)
-		{
-			sint32 value;
-			if (fromString((const char*)ptr, value))
-			{
-				x = value;
-			}
-		}
-		ptr = (char*) xmlGetProp( cur, (xmlChar*)"y" );
-		if (ptr)
-		{
-			sint32 value;
-			if (fromString((const char*)ptr, value))
-			{
-				y = value;
-			}
-		}
-		ptr = (char*) xmlGetProp( cur, (xmlChar*)"w" );
-		if (ptr)
-		{
-			sint32 value;
-			if (fromString((const char*)ptr, value))
-			{
-				w = value;
-			}
-		}
-		ptr = (char*) xmlGetProp( cur, (xmlChar*)"h" );
-		if (ptr)
-		{
-			sint32 value;
-			if (fromString((const char*)ptr, value))
-			{
-				h = value;
-			}
-		}
-		pIC->setX(x);
-		pIC->setY(y);
-		pIC->setW(w);
-		pIC->setH(h);
-		pIC->invalidateCoords();
-	}
-	//
-	while (cur)
-	{
-		setupTreeNode(cur, pIC);
-		cur = cur->next;
-	}
-	return true;
-}
-
-void CInterfaceParser::addModule( std::string name, IParserModule *module )
-{
-	std::map< std::string, IParserModule* >::iterator itr =
-		moduleMap.find( name );
-
-	if( itr != moduleMap.end() )
-	{
-		nlwarning( "Tried to add parser module %s, which already exists.",name.c_str() );
-		delete module;
-		return;
-	}
-
-	module->setParser( this );
-	moduleMap[ name ] = module;
-}
-
-CInterfaceParser::IParserModule* CInterfaceParser::getModuleFor( std::string name ) const
-{
-	std::map< std::string, IParserModule* >::const_iterator itr =
-		moduleMap.find( name );
-	if( itr == moduleMap.end() )
-		return NULL;
-	else
-		return itr->second;
-}
-
-void CInterfaceParser::removeAllModules()
-{
-	std::map< std::string, IParserModule* >::iterator itr;
-	for( itr = moduleMap.begin(); itr != moduleMap.end(); ++itr )
-	{
-		delete itr->second;
-	}
-	moduleMap.clear();
-}
-
-// ----------------------------------------------------------------------------
-bool CInterfaceParser::setupTree (xmlNodePtr cur, CWidgetManager::SMasterGroup * /* parentGroup */)
-{
-	CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"node" ));
-	if (!ptr) return false;
-	std::vector< CWidgetManager::SMasterGroup > &_MasterGroups = CWidgetManager::getInstance()->getAllMasterGroup();
-	CInterfaceElement *pEltFound = NULL;
-	for (uint32 i = 0; i < _MasterGroups.size(); ++i)
-	{
-		CWidgetManager::SMasterGroup &rMG = _MasterGroups[i];
-		for (uint32 j = 0; j < rMG.Group->getGroups().size(); ++j)
-		{
-			CInterfaceGroup *pIG = rMG.Group->getGroups()[j];
-			string stmp = strlwr(pIG->getId().substr(pIG->getId().rfind(':')+1,pIG->getId().size()));
-			string stmp2 = strlwr(string((const char*)ptr));
-			if (stmp == stmp2)
-			{
-				pEltFound = pIG;
-				break;
-			}
-		}
-		if (pEltFound != NULL)
-			break;
-	}
-
-	if (pEltFound == NULL)
-	{
-		string stmp = string("no group found for ") + string((const char*)ptr);
-		// todo hulud interface syntax error
-		nlinfo(stmp.c_str());
-		return false;
-	}
-
-	// the element must be a group
-	CInterfaceGroup *pIG = dynamic_cast<CInterfaceGroup*>(pEltFound);
-	if (pIG == NULL)
-	{
-		string stmp = string("not a group !") + pEltFound->getId();
-		// todo hulud interface syntax error
-		nlinfo(stmp.c_str());
-		return false;
-	}
-
-	// but must not be a group modal
-	if (dynamic_cast<CGroupModal*>(pIG))
-	{
-		string stmp = string("tree can't have modal group !") + pEltFound->getId();
-		// todo hulud interface syntax error
-		nlinfo(stmp.c_str());
-		return false;
-	}
-
-
-	CGroupContainer *pIC = dynamic_cast<CGroupContainer*>(pEltFound);
-	if (pIC != NULL)
-	{
-		cur = cur->children;
-		while (cur)
-		{
-			setupTreeNode(cur, pIC);
-			cur = cur->next;
-		}
-	}
-	return true;
-}
-
-
-
-// ----------------------------------------------------------------------------
-bool CInterfaceParser::parseTree (xmlNodePtr cur, CWidgetManager::SMasterGroup *parentGroup)
-{
-	H_AUTO(parseTree )
-
-	CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"node" ));
-	if (!ptr) return false;
-	std::vector< CWidgetManager::SMasterGroup > &_MasterGroups = CWidgetManager::getInstance()->getAllMasterGroup();
-	CInterfaceElement *pEltFound = NULL;
-	for (uint32 i = 0; i < _MasterGroups.size(); ++i)
-	{
-		CWidgetManager::SMasterGroup &rMG = _MasterGroups[i];
-		for (uint32 j = 0; j < rMG.Group->getGroups().size(); ++j)
-		{
-			CInterfaceGroup *pIG = rMG.Group->getGroups()[j];
-			string stmp = NLMISC::toLower(pIG->getId().substr(pIG->getId().rfind(':')+1,pIG->getId().size()));
-			string stmp2 = NLMISC::toLower(string((const char*)ptr));
-			if (stmp == stmp2)
-			{
-				pEltFound = pIG;
-				break;
-			}
-		}
-		if (pEltFound != NULL)
-			break;
-	}
-
-	if (pEltFound == NULL)
-	{
-		string stmp = string("no group found for ") + string((const char*)ptr);
-		// todo hulud interface syntax error
-		nlinfo(stmp.c_str());
-		return false;
-	}
-
-	// the element must be a group
-	CInterfaceGroup *pIG = dynamic_cast<CInterfaceGroup*>(pEltFound);
-	if (pIG == NULL)
-	{
-		string stmp = string("not a group !") + pEltFound->getId();
-		// todo hulud interface syntax error
-		nlinfo(stmp.c_str());
-		return false;
-	}
-
-	// but must not be a group modal
-	if (dynamic_cast<CGroupModal*>(pIG))
-	{
-		string stmp = string("tree can't have modal group !") + pEltFound->getId();
-		// todo hulud interface syntax error
-		nlinfo(stmp.c_str());
-		return false;
-	}
-
-	// Ok add it.
-	CWidgetManager::getInstance()->addWindowToMasterGroup(parentGroup->Group->getId(), pIG);
-
-	CGroupContainer *pIC = dynamic_cast<CGroupContainer*>(pEltFound);
-	if (pIC != NULL)
-	{
-		cur = cur->children;
-		while (cur)
-		{
-			parseTreeNode(cur, pIC);
-			cur = cur->next;
-		}
-	}
-	return true;
-}
-
-// ----------------------------------------------------------------------------
-bool CInterfaceParser::parseDefine(xmlNodePtr cur)
-{
-	H_AUTO(parseDefine)
-
-	CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"id" ));
-	if (!ptr || *ptr==0)
-	{
-		// todo hulud interface syntax error
-		nlinfo ("no id in a define");
-		return false;
-	}
-	CXMLAutoPtr ptrVal2;
-	CXMLAutoPtr ptrVal((const char*) xmlGetProp( cur, (xmlChar*)"value" ));
-	if (!ptrVal)
-	{
-		ptrVal2 = (char*) xmlGetProp( cur, (xmlChar*)"value_from_code" );
-		if (!ptrVal2)
-		{
-			// todo hulud interface syntax error
-			nlwarning ("<parseDefine> : no value nor value_from_code in a define");
-			return false;
-		}
-	}
-
-	// verify id.
-	string	id= (const char*)ptr;
-	for(uint i=0;i<id.size();i++)
-	{
-		if(!validDefineChar(id[i]))
-		{
-			// todo hulud interface syntax error
-			nlwarning ("<parseDefine> : bad id in a define. Bad char found: %c", id[i]);
-			return false;
-		}
-	}
-
-	// Check if we have to execute some code
-	if (ptrVal2)
-	{
-		CInterfaceExprValue res;
-
-		if (CInterfaceExpr::eval(ptrVal2, res))
-		{
-			if (!res.toString())
-			{
-				// todo hulud interface syntax error
-				nlwarning ("<parseDefine> : cant eval to string value_from_code : %s", (const char*)ptrVal2);
-				return false;
-			}
-			setDefine(id, res.getString().c_str());
-		}
-		else
-		{
-			// todo hulud interface syntax error
-			nlwarning ("<parseDefine> : cant eval value_from_code : %s", (const char*)ptrVal2);
-			return false;
-		}
-	}
-	else
-	{
-		// Assign var
-		setDefine (id, (const char*)ptrVal);
-	}
-
-	return true;
-}
-
-// ----------------------------------------------------------------------------
-bool CInterfaceParser::parseProcedure(xmlNodePtr cur, bool reload)
-{
-	H_AUTO(parseProcedure)
-
-	CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"id" ));
-	if (!ptr || *ptr==0)
-	{
-		// todo hulud interface syntax error
-		nlwarning ("no id in a procedure");
-		return false;
-	}
-	string	procId= ptr;
-
-	if (_ProcedureMap.find(procId) != _ProcedureMap.end())
-	{
-		// If reloading the interface, remove the old proc
-		if (reload)
-		{
-			_ProcedureMap.erase (procId);
-		}
-		else
-		{
-			// todo hulud interface syntax error
-			nlwarning ("id already exists for procedure %s", procId.c_str());
-			return false;
-		}
-	}
-
-	// build the procedure
-	CProcedure	newProc;
-
-	// Look for sons.
-	cur = cur->children;
-	while (cur)
-	{
-		if (stricmp((char*)cur->name,"action") == 0)
-		{
-			CXMLAutoPtr name((const char*) xmlGetProp (cur, (xmlChar*)"handler"));
-			CXMLAutoPtr params((const char*) xmlGetProp (cur, (xmlChar*)"params"));
-			CXMLAutoPtr cond((const char*) xmlGetProp (cur, (xmlChar*)"cond"));
-			CAction	action;
-			if(!name)
-			{
-				// todo hulud interface syntax error
-				nlinfo("no action name in a action of procedure %s", procId.c_str());
-				return false;
-			}
-			else
-				action.Action= (const char*)name;
-			if(params)
-				action.buildParamBlock((const char*)params);
-			if(cond)
-				action.buildCondBlock ((const char*)cond);
-			newProc.Actions.push_back(action);
-		}
-		else if (!strcmp((char*)cur->name,"instance"))
-		{
-			if (!parseInstance(cur))
-				// todo hulud interface syntax error
-				nlwarning ("could not parse instance");
-		}
-		else if (!strcmp((char*)cur->name,"vector"))
-		{
-			if (!parseVector(cur))
-				// todo hulud interface syntax error
-				nlwarning ("could not parse vector");
-		}
-		cur = cur->next;
-	}
-
-	// add/replace the procedure
-	_ProcedureMap[procId]= newProc;
-
-	return true;
-}
-
-// ----------------------------------------------------------------------------
-bool CInterfaceParser::initCoordsAndLuaScript()
-{
-	H_AUTO(initCoordsAndLuaScript)
-
-	// set all position associations
-	for (map<CInterfaceElement*,string>::const_iterator it = _ParentPositionsMap.begin(); it != _ParentPositionsMap.end();it++)
-	{
-		CInterfaceElement *pIEL = it->first;
-		string EltName = it->second;
-
-		CInterfaceGroup *parent = pIEL->getParent();
-		CInterfaceElement *parentpos;
-		//if the element has a parent check the parent's children
-		if (parent)
-			parentpos = parent->getElement(EltName);
-		//if the element has no parent, check the windows
-		else
-			parentpos = CWidgetManager::getInstance()->getWindowFromId(EltName);
-
-		if (parentpos == NULL)
-		{
-			// todo hulud interface syntax error
-			nlinfo(" the element %s was not found as %s position reference ", EltName.c_str(), pIEL->getId().c_str());
-		}
-		else
-		{
-			pIEL->setParentPos (parentpos);
-		}
-	}
-	// Same for size
-	for (map<CInterfaceElement*,string>::const_iterator it2 = _ParentSizesMap.begin(); it2 != _ParentSizesMap.end(); it2++)
-	{
-		CInterfaceElement *pIEL = it2->first;
-		string EltName = it2->second;
-
-		CInterfaceGroup *parent = pIEL->getParent();
-		CInterfaceElement *parentsize;
-		if (EltName == "parent")
-		{
-			parentsize = pIEL->getParent();
-		}
-		else
-		{
-			//if the element has a parent check the parent's children
-			if (parent)
-				parentsize = parent->getElement(EltName);
-			//if the element has no parent, check the windows
-			else
-				parentsize = CWidgetManager::getInstance()->getWindowFromId(EltName);
-		}
-
-		if (parentsize == NULL)
-		{
-			// todo hulud interface syntax error
-			nlinfo(" the element %s was not found as %s size reference ", EltName.c_str(), pIEL->getId().c_str());
-		}
-		else
-		{
-			pIEL->setParentSize (parentsize);
-		}
-	}
-	// Same for size max
-	for (map<CInterfaceElement*,string>::const_iterator it3 = _ParentSizesMaxMap.begin(); it3 != _ParentSizesMaxMap.end(); it3++)
-	{
-		CInterfaceGroup *pIEL = dynamic_cast<CInterfaceGroup*>(it3->first);
-		if (pIEL == NULL) continue;
-		string EltName = it3->second;
-
-		CInterfaceGroup *parent = pIEL->getParent();
-		CInterfaceElement *parentsizemax;
-		if (EltName == "parent")
-		{
-			parentsizemax = parent;
-		}
-		else
-		{
-			//if the element has a parent check the parent's children
-			if (parent)
-				parentsizemax = parent->getElement(EltName);
-			//if the element has no parent, check the windows
-			else
-				parentsizemax = CWidgetManager::getInstance()->getWindowFromId(EltName);
-		}
-
-		if (parentsizemax == NULL)
-		{
-			// todo hulud interface syntax error
-			nlinfo(" the element %s was not found as %s sizemax reference ", EltName.c_str(), pIEL->getId().c_str());
-		}
-		else
-		{
-			pIEL->setParentSizeMax (parentsizemax);
-		}
-	}
-
-	// Same For LUA Class association
-	for (map<CInterfaceGroup*,string>::const_iterator itLua = _LuaClassAssociation.begin(); itLua != _LuaClassAssociation.end(); itLua++)
-	{
-		// execute the script on this group
-		CAHManager::getInstance()->runActionHandler("lua", itLua->first, itLua->second);
-	}
-
-
-	// Clear all structures used only for init
-	NLMISC::contReset (_ParentPositionsMap);
-	NLMISC::contReset (_ParentSizesMap);
-	NLMISC::contReset (_ParentSizesMaxMap);
-	NLMISC::contReset (_LuaClassAssociation);
-	return true;
-}
-
-// ----------------------------------------------------------------------------
-void CInterfaceParser::addParentPositionAssociation(CInterfaceElement* element, const std::string& parent)
-{
-	_ParentPositionsMap.insert (std::map<CInterfaceElement*,std::string>::value_type(element, parent));
-}
-
-// ----------------------------------------------------------------------------
-void CInterfaceParser::addParentSizeAssociation(CInterfaceElement* element, const std::string& parent)
-{
-	_ParentSizesMap.insert (std::map<CInterfaceElement*,std::string>::value_type(element, parent));
-}
-
-// ----------------------------------------------------------------------------
-void CInterfaceParser::addParentSizeMaxAssociation (CInterfaceElement *element, const std::string &parent)
-{
-	_ParentSizesMaxMap.insert (std::map<CInterfaceElement*,std::string>::value_type(element, parent));
-}
-
-// ----------------------------------------------------------------------------
-void CInterfaceParser::addLuaClassAssociation (CInterfaceGroup *group, const std::string &luaScript)
-{
-	_LuaClassAssociation.insert (std::map<CInterfaceGroup*,std::string>::value_type(group, luaScript));
-}
-
-// ***************************************************************************
-const std::string	&CInterfaceParser::getDefine(const std::string &id) const
-{
-	static	string NullStr;
-	CstItVarMap	it= _DefineMap.find(id);
-	if(it==_DefineMap.end())
-		return NullStr;
-	else
-		return it->second;
-}
-
-// ***************************************************************************
-bool				CInterfaceParser::isDefineExist(const std::string &id) const
-{
-	CstItVarMap	it= _DefineMap.find(id);
-	return it!=_DefineMap.end();
-}
-
-
-// ***************************************************************************
-void				CInterfaceParser::setDefine(const std::string &id, const std::string &value)
-{
-	_DefineMap[id]= value;
-}
-
-
-// ***************************************************************************
-bool				CInterfaceParser::validDefineChar(char c) const
-{
-	if(c>='A' && c<='Z')
-		return true;
-	if(c>='a' && c<='z')
-		return true;
-	if(c>='0' && c<='9')
-		return true;
-	if(c=='_')
-		return true;
-
-	return false;
-}
-
-#define	DEFINE_IDENT	'%'
-
-// ***************************************************************************
-bool				CInterfaceParser::solveDefine(const std::string &propVal, std::string &newPropVal, std::string &defError)
-{
-	string::size_type	curPos= 0;
-	string::size_type	lastPos= 0;
-
-	//if it has some % then solve define value
-	while( (curPos=propVal.find(DEFINE_IDENT, curPos)) != string::npos)
-	{
-		// If it is end of line
-		if(curPos==propVal.size()-1)
-		{
-			// then skip
-			curPos= propVal.size();
-		}
-		// If it is a double %%
-		else if(propVal[curPos+1]==DEFINE_IDENT)
-		{
-			// copy from last to cur included
-			curPos++;
-			newPropVal+= propVal.substr(lastPos, curPos-lastPos);
-			// both % are skipped
-			curPos++;
-			lastPos= curPos;
-		}
-		// else parse define value
-		else
-		{
-			// copy the last not define sub string.
-			newPropVal+= propVal.substr(lastPos, curPos-lastPos);
-
-			// skip the %
-			curPos++;
-
-			// get the id pos
-			uint	startIdPos= (uint)curPos;
-			while( curPos<propVal.size() && validDefineChar(propVal[curPos]) )
-				curPos++;
-			// get the id
-			string	defineId= propVal.substr(startIdPos, curPos-startIdPos);
-			if(!isDefineExist(defineId))
-			{
-				defError= defineId;
-				return false;
-			}
-			// Add the define value to the string
-			newPropVal+= getDefine(defineId);
-
-			// valid pos is current pos
-			lastPos= curPos;
-		}
-	}
-	// concat last part
-	newPropVal+= propVal.substr(lastPos, propVal.size()-lastPos);
-
-	return true;
-}
-
-// ***************************************************************************
-bool				CInterfaceParser::solveDefine(xmlNodePtr cur)
-{
-	H_AUTO(solveDefine)
-
-	CXMLAutoPtr ptr;
-
-	//get the node properties
-	xmlAttrPtr props = cur->properties;
-	while (props)
-	{
-		//get the property value
-		ptr = (char*)xmlGetProp( cur, props->name);
-		nlassert(ptr);
-		string	propVal= ptr;
-		string	newPropVal;
-
-		// solve define of this prop
-		string	defError;
-		if(!solveDefine(propVal, newPropVal, defError))
-		{
-			// todo hulud interface syntax error
-			nlinfo("can't find define: %s", defError.c_str());
-			return false;
-		}
-
-		// change value
-		xmlSetProp(cur, props->name, (const xmlChar*)newPropVal.c_str());
-
-		// next property
-		props = props->next;
-	}
-
-	// recurs to node children
-	cur= cur->children;
-	while(cur)
-	{
-		if(!solveDefine(cur))
-			return false;
-		cur= cur->next;
-	}
-
-	return true;
-}
-
-
-// ***************************************************************************
-// CInterfaceParser::CAction
-// ***************************************************************************
-
-#define	PROC_PARAM_IDENT	'@'
-
-// ***************************************************************************
-void CInterfaceParser::CAction::buildParamBlock(const std::string &params)
-{
-	buildBlocks (params, ParamBlocks);
-}
-
-void CInterfaceParser::CAction::buildParams(const std::vector<string> &paramList, std::string &params) const
-{
-	eval (paramList, ParamBlocks, params);
-}
-
-void CInterfaceParser::CAction::buildCondBlock(const std::string &params)
-{
-	buildBlocks (params, CondBlocks);
-}
-
-void CInterfaceParser::CAction::buildCond(const std::vector<string> &paramList, std::string &params) const
-{
-	eval (paramList, CondBlocks, params);
-}
-
-// ***************************************************************************
-void		CInterfaceParser::CAction::buildBlocks (const std::string &in, std::vector<CParamBlock> &out)
-{
-	out.clear();
-
-	if(in.empty())
-		return;
-
-	string	lastString;
-	string::size_type	curPos= 0;
-	string::size_type	lastPos= 0;
-
-	//if it has some @ then solve proc value
-	while( (curPos=in.find(PROC_PARAM_IDENT, curPos)) != string::npos)
-	{
-		// If it is end of line
-		if(curPos==in.size()-1)
-		{
-			// then skip
-			curPos= in.size();
-		}
-		else
-		{
-			// Skip all @
-			uint countNbIdent = 0;
-			while (curPos<in.size() && in[curPos]==PROC_PARAM_IDENT)
-			{
-				curPos++;
-				countNbIdent++;
-			}
-
-			// get the id pos
-			uint countNbDigit = 0;
-			uint startIdPos= (uint)curPos;
-			while (curPos<in.size() && in[curPos]>='0' && in[curPos]<='9')
-			{
-				curPos++;
-				countNbDigit++;
-			}
-
-			if (curPos == startIdPos)
-			{
-				// No digit so it is a normal db entry
-				lastString+= in.substr (lastPos, curPos-(countNbIdent-1)-lastPos);
-				// all @ are skipped
-			}
-			else
-			{
-				// There is some digit it is an argument
-
-				// copy the last not param sub string.
-				sint nbToCopy = (sint)(curPos-countNbIdent-countNbDigit-lastPos);
-				if (nbToCopy > 0)
-					lastString += in.substr(lastPos, nbToCopy);
-
-				// if not empty, add to the param block
-				if (!lastString.empty())
-				{
-					CParamBlock pb;
-					pb.String = lastString;
-					out.push_back(pb);
-					// clear it
-					lastString.clear();
-				}
-
-				// get the param id
-				sint paramId;
-				fromString(in.substr(startIdPos, curPos-startIdPos), paramId);
-				// Add it to the param block
-				CParamBlock	 pb;
-				pb.NumParam = paramId;
-				out.push_back(pb);
-			}
-
-			// valid pos is current pos
-			lastPos= curPos;
-		}
-	}
-	// concat last part
-	lastString+= in.substr(lastPos, in.size()-lastPos);
-	if(!lastString.empty())
-	{
-		CParamBlock pb;
-		pb.String = lastString;
-		out.push_back(pb);
-	}
-}
-
-// ***************************************************************************
-//void		CInterfaceParser::CAction::buildParams(const std::vector<string> &paramList, std::string &params) const
-void CInterfaceParser::CAction::eval (const std::vector<string> &inArgs, const std::vector<CParamBlock> &inBlocks, std::string &out)
-{
-	// clear the ret string
-	out.clear();
-
-	// for all block
-	for (uint i=0; i < inBlocks.size(); i++)
-	{
-		const CParamBlock &pb = inBlocks[i];
-		// if the block is a raw string
-		if (pb.NumParam < 0)
-		{
-			// concat with the block
-			out += pb.String;
-		}
-		// else get from paramList
-		else
-		{
-			// add 1, because paramList[0] is the name of the procedure
-			sint idInList = pb.NumParam+1;
-			// if param exist
-			if (idInList < (sint)inArgs.size())
-				// concat with the params
-				out += inArgs[idInList];
-			// else skip (should fail)
-		}
-	}
-}
-
-// ***************************************************************************
-bool CInterfaceParser::parseSheetSelection(xmlNodePtr cur)
-{
-	H_AUTO(parseSheetSelection)
-
-	CXMLAutoPtr prop;
-	prop = (char*) xmlGetProp( cur, (xmlChar*)"name" );
-	if (!prop)
-	{
-		// todo hulud interface syntax error
-		nlwarning("<CInterfaceParser::parseSheetSelection> can't get name of a selection");
-		return false;
-	}
-	std::string groupName = (const char *) prop;
-	prop = (char*) xmlGetProp( cur, (xmlChar*)"texture" );
-	if (!prop)
-	{
-		// todo hulud interface syntax error
-		nlwarning("<CInterfaceParser::parseSheetSelection> can't get texture name for selection %s", groupName.c_str());
-		return false;
-	}
-	std::string texName = (const char *) prop;
-	prop = (char*) xmlGetProp( cur, (xmlChar*)"color" );
-	CRGBA color = CRGBA::White;
-	if (prop)
-	{
-		color = CInterfaceElement::convertColor(prop);
-	}
-	bool globalColor = true;
-	prop = (char*) xmlGetProp( cur, (xmlChar*)"global_color" );
-	if (prop) globalColor = CInterfaceElement::convertBool(prop);
-	sint groupIndex = _CtrlSheetSelection.addGroup(groupName);
-	if (groupIndex != -1)
-	{
-		CSheetSelectionGroup *csg = _CtrlSheetSelection.getGroup(groupIndex);
-		csg->setTexture(texName);
-		csg->setColor(color);
-		csg->enableGlobalColor(globalColor);
-	}
-	return true;
-}
-
-// ***************************************************************************
-bool CInterfaceParser::addLink(CInterfaceLink *link, const std::string &id)
-{
-	if (!link)
-	{
-		// todo hulud interface syntax error
-		nlwarning("link empty");
-		return false;
-	}
-	TLinkMap::const_iterator it = _LinkMap.find(id);
-	if (it != _LinkMap.end())
-	{
-		// todo hulud interface syntax error
-		nlwarning("<CInterfaceParser::addLink> link %s added twice", id.c_str());
-		return false;
-	}
-	#ifdef NL_DEBUG
-		link->LinkName = id;
-	#endif
-	_LinkMap[id] = link;
-	return false;
-}
-
-// ***************************************************************************
-bool CInterfaceParser::removeLink(const std::string &id)
-{
-	TLinkMap::iterator it = _LinkMap.find(id);
-	if (it == _LinkMap.end())
-	{
-		// todo hulud interface syntax error
-		nlwarning("<CInterfaceParser::removeLink> unknown link %s", id.c_str());
-		return false;
-	}
-	CSmartPtr<CInterfaceLink> &link = it->second; // dont need to copy a smart ptr on link since still in map
-	for (uint k = 0; k < link->getNumTargets(); ++k)
-	{
-		link->getTarget(k)->removeLink(link); // remove the link from the list & delete it
-	}
-	it->second->uninit();
-	_LinkMap.erase(it); // NB : the link is holded by a smart ptr, to do this decrease the ref count
-	return true;
-}
-
-
-// ***************************************************************************
-xmlNodePtr CInterfaceParser::searchTreeNodeInHierarchy(xmlNodePtr root, const char *node)
-{
-	// if I match...
-	CXMLAutoPtr prop((const char*) xmlGetProp( root, (xmlChar*)"node" ));
-	// not a valide tree node? abort.
-	if (!prop) return NULL;
-	// match?
-	if ( !strcmp((const char*)prop, node ) )
-		return root;
-
-	// No, try with sons.
-	xmlNodePtr cur= root->children;
-	while(cur)
-	{
-		xmlNodePtr candidate= searchTreeNodeInHierarchy(cur, node);
-		// if found in this branch.
-		if(candidate)
-			return candidate;
-
-		// try next
-		cur= cur->next;
-	}
-
-	// not found
-	return NULL;
-}
-
-//==================================================================
-bool CInterfaceParser::parseAnim(xmlNodePtr cur, CInterfaceGroup * parentGroup)
-{
-	H_AUTO(parseAnim)
-
-	CInterfaceAnim *pAnim;
-
-	CXMLAutoPtr ptr;
-
-	ptr = (char*) xmlGetProp( cur, (xmlChar*)"id" );
-	if (!ptr)
-	{
-		// todo hulud interface syntax error
-		nlinfo ("anim has no id");
-		return false;
-	}
-	string animId = ptr;
-	pAnim = new CInterfaceAnim;
-
-	if (pAnim->parse (cur, parentGroup))
-	{
-		if (_AnimMap.count(animId))
-		{
-			nlwarning("Anim %s already exists, replacing with new one", animId.c_str());
-		}
-		_AnimMap[animId] = pAnim;
-	}
-	else
-	{
-		delete pAnim;
-		return false;
-	}
-	return true;
-}
-
-//==================================================================
-void CInterfaceParser::freeXMLNodeAndSibblings(xmlNodePtr node)
-{
-	if (!node) return;
-	 while (node)
-	 {
-		 xmlNodePtr currNode = node;
-		 node = node->next;
-		 xmlFreeNode(currNode);
-	 }
-}
-
-
-// ***************************************************************************
-CInterfaceGroup *CInterfaceParser::createGroupInstance(const std::string &templateName, const std::string &parentID, const std::pair<std::string,std::string> *templateParams, uint numParams, bool updateLinks /* = true */)
-{
-	// create basic xml node that contains infos for the template
-	xmlNodePtr instance = xmlNewNode(NULL, (const xmlChar *) "instance");
-	if (!instance)
-	{
-		// todo hulud interface syntax error
-		nlwarning("<CInterfaceParser::createGroupInstance> Can't create xml node ");
-		return NULL;
-	}
-	for(uint k = 0; k < numParams; ++k)
-	{
-		xmlSetProp(instance, (const xmlChar *) templateParams[k].first.c_str(), (const xmlChar *) templateParams[k].second.c_str());
-	}
-	xmlSetProp(instance, (const xmlChar *) "template", (const xmlChar *) templateName.c_str());
-	if (!parseInstance(instance))
-	{
-		// todo hulud interface syntax error
-		nlwarning("<CInterfaceParser::createGroupInstance> cannot create instance from template %s", templateName.c_str());
-		freeXMLNodeAndSibblings(instance);
-		return NULL;
-	}
-
-	// result should contain a group
-	xmlNodePtr currNode = instance->next;
-	while (currNode)
-	{
-		if (strcmp((const char *) currNode->name, "group") == 0 && currNode->type == XML_ELEMENT_NODE)
-		{
-			// TODO nico : build a struct from that mess
-			std::map<CInterfaceElement*,std::string> localParentPositionsMap;
-			std::map<CInterfaceElement*,std::string> localParentSizesMap;
-			std::map<CInterfaceElement*,std::string> localParentSizesMaxMap;
-			std::map<CInterfaceGroup*,std::string>	 localLuaClassAssociation;
-
-			localParentPositionsMap.swap(_ParentPositionsMap);
-			localParentSizesMap.swap(_ParentSizesMap);
-			localParentSizesMaxMap.swap(_ParentSizesMaxMap);
-			localLuaClassAssociation.swap(_LuaClassAssociation);
-
-			CViewBase::TCtorParam params;
-			CInterfaceGroup dummyGroup(params);
-			dummyGroup.setId(parentID);
-			if (!parseGroup(currNode, &dummyGroup, false))
-			{
-				localParentPositionsMap.swap(_ParentPositionsMap);
-				localParentSizesMap.swap(_ParentSizesMap);
-				localParentSizesMaxMap.swap(_ParentSizesMaxMap);
-				localLuaClassAssociation.swap(_LuaClassAssociation);
-				freeXMLNodeAndSibblings(instance);
-				return NULL;
-			}
-			freeXMLNodeAndSibblings(instance);
-			CInterfaceGroup *group = dummyGroup.getGroup((uint) 0);
-			dummyGroup.delGroup(group, true);
-			group->setParent(NULL);
-			group->setParentPos(NULL);
-			initCoordsAndLuaScript();
-			localParentPositionsMap.swap(_ParentPositionsMap);
-			localParentSizesMap.swap(_ParentSizesMap);
-			localParentSizesMaxMap.swap(_ParentSizesMaxMap);
-			localLuaClassAssociation.swap(_LuaClassAssociation);
-			if ((group != NULL) && updateLinks)
-			{
-				group->updateAllLinks();
-			}
-			CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(group);
-			if (pGC != NULL)
-				pGC->setup();
-			return group;
-		}
-		currNode = currNode->next;
-	}
-	// todo hulud interface syntax error
-	CXMLAutoPtr ptr(xmlGetProp(instance, (const xmlChar *) templateName.c_str()));
-	nlwarning("<CInterfaceParser::createGroupInstance> no group found in template %s", (const char*)ptr);
-	freeXMLNodeAndSibblings(instance);
-	return NULL;
-}
-
-// ***************************************************************************
-CInterfaceElement *CInterfaceParser::createUIElement(const std::string &templateName, const std::string &parentID, const std::pair<std::string,std::string> *templateParams, uint numParams, bool updateLinks /* = true */)
-{
-	std::string elementId;
-
-	// create basic xml node that contains infos for the template
-	xmlNodePtr instance = xmlNewNode(NULL, (const xmlChar *) "instance");
-	if (!instance)
-	{
-		// todo hulud interface syntax error
-		nlwarning("<CInterfaceParser::addUIElement> Can't create xml node ");
-		return NULL;
-	}
-	for(uint k = 0; k < numParams; ++k)
-	{
-		xmlSetProp(instance, (const xmlChar *) templateParams[k].first.c_str(), (const xmlChar *) templateParams[k].second.c_str());
-		if (!strcmp(templateParams[k].first.c_str(), "id"))
-		{
-			elementId = templateParams[k].second;
-		}
-	}
-	xmlSetProp(instance, (const xmlChar *) "template", (const xmlChar *) templateName.c_str());
-	if (!parseInstance(instance))
-	{
-		// todo hulud interface syntax error
-		nlwarning("<CInterfaceParser::addUIElement> cannot create instance from template %s", templateName.c_str());
-		freeXMLNodeAndSibblings(instance);
-		return NULL;
-	}
-
-	CInterfaceElement	*pIE= CWidgetManager::getInstance()->getElementFromId(parentID);
-	CInterfaceGroup * parentGroup = dynamic_cast<CInterfaceGroup*>(pIE);
-
-	if(!parentGroup)
-	{
-		nlwarning("<CInterfaceParser::addUIElement> no parent group %s found ", parentID.c_str());
-		freeXMLNodeAndSibblings(instance);
-		return NULL;
-	}
-
-	// result should contain a group
-	xmlNodePtr currNode = instance->next;
-	CInterfaceElement * newElement = NULL;
-	while (currNode)
-	{
-		if (strcmp((const char *) currNode->name, "group") == 0 && currNode->type == XML_ELEMENT_NODE)
-		{
-			if (!parseGroup(currNode, parentGroup, false))
-			{
-				freeXMLNodeAndSibblings(instance);
-				return NULL;
-			}
-			freeXMLNodeAndSibblings(instance);
-			newElement = parentGroup->getGroup(elementId);
-			parentGroup->delGroup((CInterfaceGroup*)newElement, true);
-		}
-		else if (strcmp((const char *) currNode->name, "ctrl") == 0 && currNode->type == XML_ELEMENT_NODE)
-		{
-			if (!parseControl(currNode, parentGroup, false))
-			{
-				freeXMLNodeAndSibblings(instance);
-				return NULL;
-			}
-			freeXMLNodeAndSibblings(instance);
-			newElement = parentGroup->getCtrl(elementId);
-			parentGroup->delCtrl((CCtrlBase*)newElement, true);
-		}
-
-		if(newElement != NULL)
-		{
-			initCoordsAndLuaScript();
-			if (updateLinks)
-			{
-				newElement->updateAllLinks();
-			}
-			return newElement;
-		}
-
-		currNode = currNode->next;
-	}
-	// todo hulud interface syntax error
-	CXMLAutoPtr ptr(xmlGetProp(instance, (const xmlChar *) templateName.c_str()));
-	nlwarning("<CInterfaceParser::addUIElement> no group found in template %s", (const char *)ptr);
-	freeXMLNodeAndSibblings(instance);
-	return NULL;
-}
-
-// ***************************************************************************
-void CInterfaceParser::removeAllLinks()
-{
-	_LinkMap.clear();
-}
-
-// ***************************************************************************
-void CInterfaceParser::removeAllProcedures()
-{
-	_ProcedureMap.clear();
-}
-
-// ***************************************************************************
-void CInterfaceParser::removeAllDefines()
-{
-	_DefineMap.clear();
-}
-
-// ***************************************************************************
-void CInterfaceParser::removeAllTemplates()
-{
-	for (uint i = 0; i < _Templates.size(); ++i)
-		xmlFreeNode(_Templates[i]);
-	_Templates.clear();
-}
-
-// ***************************************************************************
-void CInterfaceParser::removeAllAnims()
-{
-	TAnimMap::iterator it = _AnimMap.begin();
-	while (it != _AnimMap.end())
-	{
-		CInterfaceAnim *pAnim = it->second;
-		delete pAnim;
-		it++;
-	}
-	_AnimMap.clear();
-}
-
-// ***************************************************************************
-
-
-// ***************************************************************************
-void CInterfaceParser::removeAll()
-{
-	removeAllLinks();
-	CWidgetManager::getInstance()->removeAllOptions();
-	removeAllProcedures();
-	removeAllDefines();
-	removeAllTemplates();
-	removeAllAnims();
-	CWidgetManager::getInstance()->removeAllMasterGroups();
-	_StyleMap.clear();
-	_CtrlSheetSelection.deleteGroups();
-}
-
-
-// ------------------------------------------------------------------------------------------------
-uint CInterfaceParser::getProcedureNumActions(const std::string &procName) const
-{
-	CstItProcedureMap	it= _ProcedureMap.find(procName);
-	if(it!=_ProcedureMap.end())
-	{
-		const CProcedure	&proc= it->second;
-		return (uint)proc.Actions.size();
-	}
-	else
-		return 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool CInterfaceParser::getProcedureAction(const std::string &procName, uint actionIndex, std::string &ah, std::string &params) const
-{
-	CstItProcedureMap	it= _ProcedureMap.find(procName);
-	if(it!=_ProcedureMap.end())
-	{
-		const CProcedure	&proc= it->second;
-		if(actionIndex<proc.Actions.size())
-		{
-			const CAction		&action= proc.Actions[actionIndex];
-			// if not a variable parametrized Params
-			if(action.ParamBlocks.size()==1 && action.ParamBlocks[0].NumParam==-1)
-			{
-				ah= action.Action;
-				params= action.ParamBlocks[0].String;
-				return true;
-			}
-		}
-	}
-
-	return false;
-}
-
-// ***************************************************************************
-bool CInterfaceParser::parseStyle(xmlNodePtr cur)
-{
-	H_AUTO(parseStyle)
-
-	string		styleId;
-	CXMLAutoPtr prop;
-
-	prop = xmlGetProp (cur, (xmlChar*)"style");
-	if(prop)
-		styleId= (const char*)prop;
-	else
-	{
-		// todo hulud interface syntax error
-		nlwarning("'style' not found in 'style'");
-		return false;
-	}
-
-	// create or replace style
-	CStyle	newStyle;
-
-	//get the node properties
-	xmlAttrPtr props = cur->properties;
-	while (props)
-	{
-		// if not the "style" property
-		if( nlstricmp((const char*)props->name, "style") != 0 )
-		{
-			// Append it.
-			newStyle.Properties.push_back(CStyleProperty());
-			newStyle.Properties.back().Name= (const char*)props->name;
-
-			CXMLAutoPtr ptr(xmlGetProp( cur, props->name ));
-			newStyle.Properties.back().Value = (const char*)ptr;
-		}
-
-		props= props->next;
-	}
-
-	// associate.
-	_StyleMap[styleId]= newStyle;
-
-	return true;
-}
-
-// ***************************************************************************
-bool CInterfaceParser::parseLUAScript (xmlNodePtr cur)
-{
-	H_AUTO(parseLUA)
-
-	// read fileName
-	CXMLAutoPtr prop;
-	string	fileName;
-	prop = xmlGetProp (cur, (xmlChar*)"file");
-	if(prop)
-		fileName= (const char*)prop;
-	else
-	{
-		nlwarning("'file' not found in 'lua'");
-		return false;
-	}
-
-	// Append to set of reloadable FileScripts
-	_LuaFileScripts.insert(fileName);
-
-	// just display warning here.
-	string	dummyError;
-	return loadLUA(fileName, dummyError);
-}
-
-// ***************************************************************************
-bool				CInterfaceParser::solveStyle(xmlNodePtr cur)
-{
-	H_AUTO(solveStyle)
-
-	CXMLAutoPtr ptr;
-
-	// if the node is a style, abort (not recrusive because use "style" as param name)
-	if ( !strcmp((char*)cur->name,"style") )
-		return true;
-
-	// try to read a "style" param.
-	ptr= (char*)xmlGetProp( cur, (xmlChar*)"style");
-	if(ptr)
-	{
-		// get the style
-		TStyleMap::iterator	it= _StyleMap.find((const char*)ptr);
-		if( it==_StyleMap.end() )
-		{
-			// todo hulud interface syntax error
-			nlwarning("style '%s' not found", (const char*)ptr);
-			return false;
-		}
-
-		// the style
-		CStyle	&style= it->second;
-
-		// for all properties of the style, set them in the node
-		for(uint i=0;i<style.Properties.size();i++)
-		{
-			const char *propName= style.Properties[i].Name.c_str();
-			const char *propValue= style.Properties[i].Value.c_str();
-
-			// replace it only if the property is not already defined, (=> user can overide style properties)
-			CXMLAutoPtr ptr2(xmlGetProp( cur, (xmlChar*)propName));
-			if( !ptr2 )
-			{
-				xmlSetProp(cur, (xmlChar*)propName, (xmlChar*)propValue);
-			}
-		}
-	}
-
-	// recurs to node children
-	cur= cur->children;
-	while(cur)
-	{
-		if(!solveStyle(cur))
-			return false;
-		cur= cur->next;
-	}
-
-	return true;
-}
-
-// ***************************************************************************
-
-#ifdef LUA_NEVRAX_VERSION
-
-class CLuaDebugBreakScreen : public IDebuggedAppMainLoop
-{
-public:
-	// called by external lua debugger when application is breaked
-	virtual void breakEventLoop()
-	{
-		Driver->clearBuffers(CRGBA(90, 90, 90));
-		TextContext->setShaded(true);
-		TextContext->setFontSize(40);
-		TextContext->setColor(CRGBA::White);
-
-		// TOP LEFT //
-		//----------//
-		TextContext->setHotSpot(NL3D::UTextContext::MiddleMiddle);
-		TextContext->printfAt(0.5f, 0.5f, "Break in LUA code");
-		Driver->swapBuffers();
-	}
-};
-static CLuaDebugBreakScreen LuaDebugBreakScreen;
-
-#endif
-
-
-// ***************************************************************************
-void	CInterfaceParser::initLUA()
-{
-	// do nothing if LUA environment already exists
-	if( _LuaState != NULL )
-		return;
-
-	// create a new LUA environnement
-	nlassert(_LuaState==NULL);
-	CLuaManager::enableLuaDebugging();
-	CLuaManager::getInstance();
-	_LuaState= CLuaManager::getInstance().getLuaState();
-
-#ifdef LUA_NEVRAX_VERSION
-	extern ILuaIDEInterface *LuaDebuggerIDE;
-	if (LuaDebuggerIDE) LuaDebuggerIDE->setDebuggedAppMainLoop(&LuaDebugBreakScreen);
-#endif
-
-	// register LUA methods
-	CLuaIHM::registerAll(*_LuaState);
-}
-
-// ***************************************************************************
-void	CInterfaceParser::uninitLUA()
-{
-	// Delete all LUA environnement (and hence variables)
-    // delete _LuaState;
-	// _LuaState= NULL;
-
-	// delete all .lua file loaded
-	_LuaFileScripts.clear();
-}
-
-// ***************************************************************************
-bool	CInterfaceParser::loadLUA(const std::string &fileName, std::string &error)
-{
-	// get file
-
-	bool needCheck = false;
-
-	#if !FINAL_VERSION
-		needCheck = false;
-	#endif
-
-	string	pathName= CPath::lookup(fileName, false);
-	if(pathName.empty())
-	{
-		nlwarning("LUA Script '%s' not found", fileName.c_str());
-		return false;
-	}
-
-	bool isInData = false;
-	std::string::size_type pos = pathName.find("@");
-	if (pos != string::npos)
-	{
-		if (CBigFile::getInstance().getBigFileName(pathName.substr(0, pos)) != "data/"+pathName.substr(0, pos))
-			isInData = false;
-		else
-			isInData = true;
-	}
-
-	if (needCheck && !isInData)
-	{
-		nlwarning("You are not allowed to modify the lua files");
-		// return true so it'll not generate a message box, we just ignore the file
-		return true;
-	}
-
-	// Parse script
-	nlassert(_LuaState);
-	try
-	{
-		_LuaState->executeFile(pathName);
-	}
-	catch(const ELuaError &e)
-	{
-		nlwarning(e.luaWhat().c_str());
-		error= e.luaWhat();
-		return false;
-	}
-
-	return true;
-}
-
diff --git a/code/ryzom/client/src/interface_v3/interface_parser.h b/code/ryzom/client/src/interface_v3/interface_parser.h
deleted file mode 100644
index b28a2ab9e..000000000
--- a/code/ryzom/client/src/interface_v3/interface_parser.h
+++ /dev/null
@@ -1,356 +0,0 @@
-// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
-// Copyright (C) 2010  Winch Gate Property Limited
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-
-
-#ifndef RZ_INTERFACE_PARSER_H
-#define RZ_INTERFACE_PARSER_H
-
-#include "nel/misc/types_nl.h"
-#include "nel/3d/u_texture.h"
-#include "nel/gui/ctrl_sheet_selection.h"
-#include "nel/gui/interface_link.h"
-#include "nel/misc/smart_ptr.h"
-#include "nel/gui/lua_helper.h"
-#include "nel/gui/widget_manager.h"
-
-namespace NLGUI
-{
-	class CInterfaceElement;
-	class CInterfaceGroup;
-	class CInterfaceOptions;
-	class CInterfaceLink;
-	class CCtrlBase;
-	class CGroupList;
-	class CGroupContainer;
-	class CInterfaceAnim;
-	class CViewPointer;
-}
-
-using namespace NLGUI;
-
-// ***************************************************************************
-/**
- * class managing the interface parsing
- * \author Matthieu 'TrapII' Besson
- * \author Nevrax France
- * \date 2002
- */
-
-// this is the base class for CInterfaceManager
-class CInterfaceParser : public IParser
-{
-
-public:
-	
-	class IParserModule
-	{
-	public:
-		enum ParsingStage
-		{
-			None			= 0,
-			Unresolved		= 1,
-			Resolved		= 2,
-			GroupChildren	= 4
-		};
-
-		IParserModule(){
-			parser = NULL;
-			parsingStage = None;
-		}
-		virtual ~IParserModule(){}
-
-		bool canParseInStage( ParsingStage stage )
-		{
-			if( ( parsingStage & static_cast< uint >( stage ) ) != 0 )
-				return true;
-			else
-				return false;
-		}
-
-		virtual bool parse( xmlNodePtr cur, CInterfaceGroup *parentGroup ) = 0;
-		void setParser( CInterfaceParser *p ){ parser = p; }
-	
-	protected:
-		CInterfaceParser *parser;
-		uint parsingStage;
-	};
-
-	CInterfaceParser();
-	virtual ~CInterfaceParser();
-
-public:
-
-	/**
-	 * Parsing methods
-	 */
-
-	/** Load a set of xml files
-      * \param isFilename true if xmlFileNames array contains the names of the xml file, false, if each
-	  *                   array is a script itself
-	  */
-	bool parseInterface (const std::vector<std::string> &xmlFileNames, bool reload, bool isFilename = true, bool checkInData = false);
-
-	bool parseXMLDocument (xmlNodePtr root, bool reload);
-	bool parseTemplateNode (xmlNodePtr node,xmlNodePtr instance,xmlNodePtr templ);
-	bool parseInstance(xmlNodePtr cur);
-	bool parseVector (xmlNodePtr cur);
-	bool parseVariable (xmlNodePtr cur, CInterfaceGroup * parentGroup);
-	bool parseOptions (xmlNodePtr cur, CInterfaceGroup * parentGroup);
-	bool parseGroup (xmlNodePtr cur, CInterfaceGroup * parentGroup, bool reload);
-	bool parseGroupChildren(xmlNodePtr cur, CInterfaceGroup * parentGroup, bool reload);
-	bool parseControl (xmlNodePtr cur, CInterfaceGroup * parentGroup, bool reload);
-	bool parseLink (xmlNodePtr cur, CInterfaceGroup * parentGroup);
-	bool parseView (xmlNodePtr cur, CInterfaceGroup * parentGroup, bool reload);
-	bool parseTreeNode (xmlNodePtr cur, CGroupContainer *parentGroup);
-	bool parseTree (xmlNodePtr cur, CWidgetManager::SMasterGroup *parentGroup);
-	bool parseDefine(xmlNodePtr cur);
-	bool parseProcedure(xmlNodePtr cur, bool reload);
-	bool parseSheetSelection(xmlNodePtr cur);
-	bool parseAnim(xmlNodePtr cur, CInterfaceGroup * parentGroup);
-	bool parseStyle(xmlNodePtr cur);
-	bool parseLUAScript (xmlNodePtr cur);
-	bool setupTree (xmlNodePtr cur, CWidgetManager::SMasterGroup *parentGroup);
-	bool setupTreeNode (xmlNodePtr cur, CGroupContainer *parentGroup);
-	
-	void addModule( std::string name, IParserModule *module );
-	IParserModule* getModuleFor( std::string name ) const;
-	void removeAllModules();
-
-	// Called by each parse in parseXMLDocument
-	bool solveDefine(xmlNodePtr cur);
-	bool solveStyle(xmlNodePtr cur);
-
-	// Solve All define in a string. return false if some define not founs (defError contains this define)
-	bool solveDefine(const std::string &propVal, std::string &newPropVal, std::string &defError);
-
-	// Called after template & options parsing
-	virtual void setupOptions() { }
-
-	/**
-	 * Initializer
-	 */
-
-	bool initCoordsAndLuaScript ();
-
-	/// Association builders : associate an element of the interface with the string ID of
-	/// another element used as reference for position values
-	void addParentPositionAssociation (CInterfaceElement *element, const std::string &parentID);
-	void addParentSizeAssociation (CInterfaceElement *element, const std::string &parentID);
-	void addParentSizeMaxAssociation (CInterfaceElement *element, const std::string &parentID);
-
-	/// LUA Class Association builder :  associate a lua script to a group (called for each group after every document parsed)
-	void addLuaClassAssociation(CInterfaceGroup *group, const std::string &luaScript);
-
-	/**
-	 * Accessors
-	 */
-	// access to control sheet selection
-	CCtrlSheetSelection	&getCtrlSheetSelection() { return _CtrlSheetSelection; }
-
-	/// \name Parameter variable
-	// @{
-	const std::string	&getDefine(const std::string &id) const;
-	bool				isDefineExist(const std::string &id) const;
-	void				setDefine(const std::string &id, const std::string &value);
-	// @}
-
-	/// \name Dynamic links mgt
-	// @{
-		/** Associate the given dynamic link with an ID
-		  * \return true if succesful
-		  */
-		bool addLink(CInterfaceLink *link, const std::string &id);
-		/** remove the given link from its ID
-		  * \return true if succesful
-		  */
-		bool removeLink(const std::string &id);
-	// @}
-
-	/** create a template from an instance consisting of a single group
-	  * \param templateName name of the template in the xml
-	  * \param templateParams array containing each template parameter and its name
-	  * \param number of template parameters in the array
-	  */
-	CInterfaceGroup *createGroupInstance(const std::string &templateName, const std::string &parentID, const std::pair<std::string, std::string> *templateParams, uint numParams, bool updateLinks = true);
-	CInterfaceGroup *createGroupInstance(const std::string &templateName, const std::string &parentID, std::vector<std::pair<std::string, std::string> > &templateParams, bool updateLinks = true)
-	{
-		if (templateParams.size() > 0)
-			return createGroupInstance(templateName, parentID, &templateParams[0], (uint)templateParams.size(), updateLinks);
-		else
-			return createGroupInstance(templateName, parentID, NULL, 0, updateLinks);
-	}
-
-	/** create a template from an instance consisting of a single control or group
-	  * \param templateName name of the template in the xml
-	  * \param templateParams array containing each template parameter and its name
-	  * \param number of template parameters in the array
-	  */
-	CInterfaceElement *createUIElement(const std::string &templateName, const std::string &parentID, const std::pair<std::string,std::string> *templateParams, uint numParams, bool updateLinks /* = true */);
-	CInterfaceElement *createUIElement(const std::string &templateName, const std::string &parentID, std::vector<std::pair<std::string, std::string> > &templateParams, bool updateLinks = true)
-	{
-		if (templateParams.size() > 0)
-			return createUIElement(templateName, parentID, &templateParams[0], (uint)templateParams.size(), updateLinks);
-		else
-			return createUIElement(templateName, parentID, NULL, 0, updateLinks);
-	}
-
-	static void freeXMLNodeAndSibblings(xmlNodePtr node);
-
-	// search a "tree" node in the hierarchy that match node. may return root! NULL if not found
-	static xmlNodePtr searchTreeNodeInHierarchy(xmlNodePtr root, const char *node);
-
-	/// \name Clearing mgt
-	// @{
-		void removeAllLinks();
-		void removeAllProcedures();
-		void removeAllDefines();
-		void removeAllTemplates();
-		void removeAllAnims();
-		void removeAll();
-	// @}
-
-	// get info on procedure. return 0 if procedure not found
-	uint getProcedureNumActions( const std::string &procName ) const;
-
-	// return false if procedure not found, or if bad action index. return false if has some param variable (@0...)
-	bool getProcedureAction( const std::string &procName, uint actionIndex, std::string &ah, std::string &params ) const;
-
-	void setCacheUIParsing( bool b ){ cacheUIParsing = b; }
-
-protected:
-
-	/**
-	 * Temporary data for init
-	 */
-
-	/// vector storing parsed templates during init. At the end of init, only used template are kept
-	std::vector<xmlNodePtr> _Templates;
-
-
-	// map linking an element to its parent position used during init only
-	std::map<CInterfaceElement*,std::string> _ParentPositionsMap;
-	std::map<CInterfaceElement*,std::string> _ParentSizesMap;
-	std::map<CInterfaceElement*,std::string> _ParentSizesMaxMap;
-
-	// map linking a group to its lua script. used during init only
-	std::map<CInterfaceGroup*,std::string> _LuaClassAssociation;
-
-	/**
-	 * Data of initialized interface
-	 */
-
-	/// Define Variable list
-	typedef	std::map<std::string, std::string>		TVarMap;
-	typedef	TVarMap::iterator			ItVarMap;
-	typedef	TVarMap::const_iterator		CstItVarMap;
-	TVarMap								_DefineMap;
-
-	bool	validDefineChar(char c) const;
-
-	/// Procedure def
-	class	CParamBlock
-	{
-	public:
-		// -1 if not a param id, but a string
-		sint32		NumParam;
-		std::string		String;
-
-		CParamBlock()
-		{
-			NumParam= -1;
-		}
-	};
-	class	CAction
-	{
-	public:
-		// a condition to launch this action handler (is an expression)
-		std::vector<CParamBlock>	CondBlocks;
-
-		// the action handler (may be proc!!)
-		std::string					Action;
-		// A list of string/or param number => to build the final params at execution
-		std::vector<CParamBlock>	ParamBlocks;
-
-		// build a paramBlock from a string
-		void		buildParamBlock (const std::string &params);
-		// from ParamBlock, and a paramList (skip the 0th), build params.
-		void		buildParams (const std::vector<std::string> &paramList, std::string &params) const;
-
-		void		buildCondBlock (const std::string &params);
-
-		void		buildCond (const std::vector<std::string> &paramList, std::string &cond) const;
-
-		static void buildBlocks (const std::string &in, std::vector<CParamBlock> &out);
-		static void eval (const std::vector<std::string> &inArgs, const std::vector<CParamBlock> &inBlocks, std::string &out);
-
-	};
-	class	CProcedure
-	{
-	public:
-		// List of the actions
-		std::vector<CAction>	Actions;
-	};
-	class	CStyleProperty
-	{
-	public:
-		std::string				Name;
-		std::string				Value;
-	};
-	class	CStyle
-	{
-	public:
-		std::vector<CStyleProperty>		Properties;
-	};
-
-
-	/// Procedure list
-	typedef	std::map<std::string,CProcedure>		TProcedureMap;
-	typedef	TProcedureMap::iterator			ItProcedureMap;
-	typedef	TProcedureMap::const_iterator	CstItProcedureMap;
-	TProcedureMap							_ProcedureMap;
-
-	// mgt of sheet selections (inventory, buy, sell..)
-	CCtrlSheetSelection		  _CtrlSheetSelection;
-
-	// Map of dynamic links
-	typedef std::map<std::string, NLMISC::CSmartPtr<CInterfaceLink> > TLinkMap;
-	TLinkMap _LinkMap;
-
-	// Map of anims
-	typedef std::map<std::string, CInterfaceAnim *> TAnimMap;
-	TAnimMap _AnimMap;
-
-	// Map of styles.
-	typedef	std::map<std::string, CStyle>			TStyleMap;
-	TStyleMap										_StyleMap;
-
-protected:
-	std::map< std::string, IParserModule* > moduleMap;
-	// LUA
-	// ----------------------------------------------------------------------------------
-	// LUA Interface State. NB: The LUA environnement is not shared between Login/OutGame/InGame
-	NLMISC::CSmartPtr<CLuaState> _LuaState;
-	virtual void initLUA();
-	void uninitLUA();
-	// List of script loaded (for reloadLua command)
-	std::set<std::string>	_LuaFileScripts;
-	// Load A .lua. false if parse error. string 'error' contains the eventual error desc (but warning still displayed)
-	bool				loadLUA(const std::string &luaFile, std::string &error);
-	bool cacheUIParsing;
-};
-
-#endif // RZ_INTERFACE_PARSER_H
diff --git a/code/ryzom/client/src/interface_v3/parser_modules.h b/code/ryzom/client/src/interface_v3/parser_modules.h
index 375fccb9d..4b9647beb 100644
--- a/code/ryzom/client/src/interface_v3/parser_modules.h
+++ b/code/ryzom/client/src/interface_v3/parser_modules.h
@@ -18,7 +18,9 @@
 #ifndef PARSER_MODULES_H
 #define PARSER_MODULES_H
 
-#include "interface_parser.h"
+#include "nel/gui/interface_parser.h"
+
+using namespace NLGUI;
 
 class CIF3DSceneParser : public CInterfaceParser::IParserModule
 {