Manual merge of the GSoC2008 GUI branch. (71 files)

svn-id: r34757

4 files changed, 837 insertions, 0 deletions

diff --git a/common/module.mk b/common/module.mk
index 599ffcf8a6..e04af5270b 100644
--- a/common/module.mk
+++ b/common/module.mk
@@ -17,6 +17,7 @@ MODULE_OBJS := \
 	system.o \
 	unarj.o \
 	unzip.o \
+	xmlparser.o \
 	zlib.o
 
 # Include common rules
diff --git a/common/rect.h b/common/rect.h
index dcf1c8b421..962069bf48 100644
--- a/common/rect.h
+++ b/common/rect.h
@@ -124,6 +124,16 @@ struct Rect {
 		return contains(p.x, p.y);
 	}
 
+	/*! @brief check if the given rect is _fully_ contained inside this rectangle
+
+		@param r The rectangle to check
+
+		@retur true if the given rect is inside, false otherwise
+	*/
+	bool contains(const Rect &r) const {
+		return (left < r.left) && (right > r.right) && (top < r.top) && (bottom > r.bottom);
+	}
+
 	/*!	@brief check if given rectangle intersects with this rectangle
 
 		@param r the rectangle to check
diff --git a/common/xmlparser.cpp b/common/xmlparser.cpp
new file mode 100644
index 0000000000..44274f7c8d
--- /dev/null
+++ b/common/xmlparser.cpp
@@ -0,0 +1,339 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "common/util.h"
+#include "common/system.h"
+#include "common/events.h"
+#include "common/hashmap.h"
+#include "common/hash-str.h"
+#include "common/xmlparser.h"
+
+namespace Common {
+
+using namespace Graphics;
+
+bool XMLParser::parserError(const char *errorString, ...) {
+	_state = kParserError;
+
+	int original_pos = _stream->pos();
+	int pos = original_pos;
+	int lineCount = 1;
+	int lineStart = 0;
+
+	if (_fileName == "Memory Stream") {
+		lineStart = MAX(0, original_pos - 35);
+		lineCount = 0;
+	} else {
+		do {
+			if (_char == '\n' || _char == '\r') {
+				lineCount++;
+		
+				if (lineStart == 0)
+					lineStart = MAX(pos + 1, original_pos - 60);
+			}
+			
+			_stream->seek(-1, SEEK_CUR);
+
+		} while (_stream->pos() > 0);
+	}
+
+	char lineStr[70];
+	_stream->seek(original_pos - 35, SEEK_SET);
+	_stream->readLine_NEW(lineStr, 70);
+	
+	for (int i = 0; i < 70; ++i)
+		if (lineStr[i] == '\n')
+			lineStr[i] = ' ';
+
+	printf("\n  File <%s>, line %d:\n", _fileName.c_str(), lineCount);
+
+	bool startFull = lineStr[0] == '<';
+	bool endFull = lineStr[strlen(lineStr) - 1] == '>';
+
+	printf("%s%s%s\n", startFull ? "" : "...", lineStr, endFull ? "" : "...");
+
+	int cursor = 35;
+
+	if (!startFull)
+		cursor += 3;
+
+	while (cursor--)
+		printf(" ");
+
+	printf("^\n");
+	printf("Parser error: ");
+
+	va_list args;
+	va_start(args, errorString);
+	vprintf(errorString, args);
+	va_end(args);
+
+	printf("\n\n");
+
+	return false;
+}
+
+bool XMLParser::parseActiveKey(bool closed) {
+	bool ignore = false;
+	assert(_activeKey.empty() == false);
+
+	ParserNode *key = _activeKey.top();
+	XMLKeyLayout *layout = (_activeKey.size() == 1) ? _XMLkeys : getParentNode(key)->layout;
+	
+	if (layout->children.contains(key->name)) {
+		key->layout = layout->children[key->name];
+	
+		Common::StringMap localMap = key->values;
+		int keyCount = localMap.size();
+	
+		for (Common::List<XMLKeyLayout::XMLKeyProperty>::const_iterator i = key->layout->properties.begin(); i != key->layout->properties.end(); ++i) {
+			if (i->required && !localMap.contains(i->name))
+				return parserError("Missing required property '%s' inside key '%s'", i->name.c_str(), key->name.c_str());
+			else if (localMap.contains(i->name))
+				keyCount--;
+		}
+	
+		if (keyCount > 0)
+			return parserError("Unhandled property inside key '%s': '%s'", key->name.c_str(), localMap.begin()->_key.c_str());
+			
+	} else {
+		return parserError("Unexpected key in the active scope: '%s'.", key->name.c_str());
+	}
+
+	// check if any of the parents must be ignored.
+	// if a parent is ignored, all children are too.
+	for (int i = _activeKey.size() - 1; i >= 0; --i) {
+		if (_activeKey[i]->ignore)
+			ignore = true;
+	}
+
+	if (ignore == false && keyCallback(key) == false) {
+		// HACK:  People may be stupid and overlook the fact that
+		// when keyCallback() fails, a parserError() must be set.
+		// We set it manually in that case.
+		if (_state != kParserError)
+			parserError("Unhandled exception when parsing '%s' key.", key->name.c_str());
+			
+		return false;
+	}
+	
+	if (closed)
+		return closeKey();
+
+	return true;
+}
+
+bool XMLParser::parseKeyValue(Common::String keyName) {
+	assert(_activeKey.empty() == false);
+
+	if (_activeKey.top()->values.contains(keyName))
+		return false;
+
+	_token.clear();
+	char stringStart;
+
+	if (_char == '"' || _char == '\'') {
+		stringStart = _char;
+		_char = _stream->readByte();
+
+		while (_char && _char != stringStart) {
+			_token += _char;
+			_char = _stream->readByte();
+		}
+
+		if (_char == 0)
+			return false;
+
+		_char = _stream->readByte();
+
+	} else if (!parseToken()) {
+		return false;
+	}
+
+	_activeKey.top()->values[keyName] = _token;
+	return true;
+}
+
+bool XMLParser::closeKey() {
+	bool ignore = false;
+	bool result = true;
+	
+	for (int i = _activeKey.size() - 1; i >= 0; --i) {
+		if (_activeKey[i]->ignore)
+			ignore = true;
+	}
+	
+	if (ignore == false)
+		result = closedKeyCallback(_activeKey.top());
+		
+	freeNode(_activeKey.pop());
+	
+	return result;
+}
+
+bool XMLParser::parse() {
+
+	if (_stream == 0)
+		return parserError("XML stream not ready for reading.");
+		
+	if (_XMLkeys == 0)
+		buildLayout();
+
+	while (!_activeKey.empty())
+		freeNode(_activeKey.pop());
+
+	cleanup();
+
+	bool activeClosure = false;
+	bool selfClosure = false;
+
+	_state = kParserNeedKey;
+	_activeKey.clear();
+
+	_char = _stream->readByte();
+	
+	while (_char && _state != kParserError) {
+		if (skipSpaces())
+			continue;
+
+		if (skipComments())
+			continue;
+
+		switch (_state) {
+			case kParserNeedKey:
+				if (_char != '<') {
+					parserError("Parser expecting key start.");
+					break;
+				}
+
+				if ((_char = _stream->readByte()) == 0) {
+					parserError("Unexpected end of file.");
+					break;
+				}
+
+				if (_char == '/') { // FIXME: What if it's a comment start
+					_char = _stream->readByte();
+					activeClosure = true;
+				}
+
+				_state = kParserNeedKeyName;
+				break;
+
+			case kParserNeedKeyName:
+				if (!parseToken()) {
+					parserError("Invalid key name.");
+					break;
+				}
+
+				if (activeClosure) {
+					if (_activeKey.empty() || _token != _activeKey.top()->name) {
+						parserError("Unexpected closure.");
+						break;
+					}
+				} else {
+					ParserNode *node = allocNode(); //new ParserNode;
+					node->name = _token;
+					node->ignore = false;
+					node->depth = _activeKey.size();
+					node->layout = 0;
+					_activeKey.push(node);
+				}
+
+				_state = kParserNeedPropertyName;
+				break;
+
+			case kParserNeedPropertyName:
+				if (activeClosure) {
+					if (!closeKey()) {
+						parserError("Missing data when closing key '%s'.", _activeKey.top()->name.c_str()); 
+						break;
+					}
+
+					activeClosure = false;
+
+					if (_char != '>')
+						parserError("Invalid syntax in key closure.");
+					else 
+						_state = kParserNeedKey;
+
+					_char = _stream->readByte();
+					break;
+				}
+
+				selfClosure = false;
+
+				if (_char == '/') { // FIXME: comment start?
+					selfClosure = true;
+					_char = _stream->readByte();
+				}
+
+				if (_char == '>') {
+					if (parseActiveKey(selfClosure)) {
+						_char = _stream->readByte();
+						_state = kParserNeedKey;
+					}
+					break;
+				}
+
+				if (!parseToken()) 
+					parserError("Error when parsing key value.");
+				else 
+					_state = kParserNeedPropertyOperator;
+
+				break;
+
+			case kParserNeedPropertyOperator:
+				if (_char != '=') 
+					parserError("Syntax error after key name.");
+				else  
+					_state = kParserNeedPropertyValue;
+
+				_char = _stream->readByte();
+				break;
+
+			case kParserNeedPropertyValue:
+				if (!parseKeyValue(_token)) 
+					parserError("Invalid key value.");
+				else 
+					_state = kParserNeedPropertyName;
+
+				break;
+
+			default:
+				break;
+		}
+	}
+
+	if (_state == kParserError)
+		return false;
+
+	if (_state != kParserNeedKey || !_activeKey.empty())
+		return parserError("Unexpected end of file.");
+
+	return true;
+}
+
+}
+
diff --git a/common/xmlparser.h b/common/xmlparser.h
new file mode 100644
index 0000000000..5f649f517f
--- /dev/null
+++ b/common/xmlparser.h
@@ -0,0 +1,487 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifndef XML_PARSER_H
+#define XML_PARSER_H
+
+#include "common/scummsys.h"
+#include "graphics/surface.h"
+#include "common/system.h"
+#include "common/xmlparser.h"
+#include "common/stream.h"
+#include "common/file.h"
+#include "common/fs.h"
+
+#include "common/hashmap.h"
+#include "common/hash-str.h"
+#include "common/stack.h"
+
+namespace Common {
+	
+/*
+	XMLParser.cpp/h -- Generic XML Parser
+	=====================================
+
+	External documentation available at:
+		http://www.smartlikearoboc.com/scummvm_doc/xmlparser_doc.html
+*/
+
+#define MAX_XML_DEPTH 8
+			
+#define XML_KEY(keyName) {\
+		lay =  new CustomXMLKeyLayout;\
+		lay->callback = (&kLocalParserName::parserCallback_##keyName);\
+		layout.top()->children[#keyName] = lay;\
+		layout.push(lay); \
+		_layoutList.push_back(lay);\
+		for (Common::List<XMLKeyLayout::XMLKeyProperty>::const_iterator p = globalProps.begin(); p != globalProps.end(); ++p){\
+			layout.top()->properties.push_back(*p);}
+		
+#define XML_KEY_RECURSIVE(keyName) {\
+			layout.top()->children[#keyName] = layout.top();\
+			layout.push(layout.top());\
+		}
+
+#define KEY_END() layout.pop(); }
+
+#define XML_PROP(propName, req) {\
+		prop.name = #propName; \
+		prop.required = req; \
+		layout.top()->properties.push_back(prop); }
+		
+#define XML_GLOBAL_PROP(propName, req) {\
+		prop.name = #propName; \
+		prop.required = req;\
+		globalProps.push_back(prop); }
+		
+	
+#define CUSTOM_XML_PARSER(parserName) \
+	protected: \
+	typedef parserName kLocalParserName; \
+	bool keyCallback(ParserNode *node) {return node->layout->doCallback(this, node); }\
+	struct CustomXMLKeyLayout : public XMLKeyLayout {\
+		typedef bool (parserName::*ParserCallback)(ParserNode *node);\
+		ParserCallback callback;\
+		bool doCallback(XMLParser *parent, ParserNode *node) {return ((kLocalParserName*)parent->*callback)(node);} };\
+	virtual void buildLayout() { \
+		Common::Stack<XMLKeyLayout*> layout; \
+		CustomXMLKeyLayout *lay = 0; \
+		XMLKeyLayout::XMLKeyProperty prop; \
+		Common::List<XMLKeyLayout::XMLKeyProperty> globalProps; \
+		_XMLkeys = new CustomXMLKeyLayout; \
+		layout.push(_XMLkeys);
+	
+#define PARSER_END() layout.clear(); }
+
+/**
+ * The base XMLParser class implements generic functionality for parsing
+ * XML-like files.
+ *
+ * In order to use it, it must be inherited with a child class that implements
+ * the XMLParser::keyCallback() function.
+ *
+ * @see XMLParser::keyCallback()
+ */
+class XMLParser {
+
+public:
+	/**
+	 * Parser constructor.
+	 */
+	XMLParser() : _XMLkeys(0), _stream(0) {}
+
+	virtual ~XMLParser() {
+		while (!_activeKey.empty())
+			freeNode(_activeKey.pop());
+
+		delete _XMLkeys;
+		delete _stream;
+
+		for (Common::List<XMLKeyLayout*>::iterator i = _layoutList.begin();
+			i != _layoutList.end(); ++i)
+			delete *i;
+
+		_layoutList.clear();
+	}
+
+	/** Active state for the parser */
+	enum ParserState {
+		kParserNeedKey,
+		kParserNeedKeyName,
+
+		kParserNeedPropertyName,
+		kParserNeedPropertyOperator,
+		kParserNeedPropertyValue,
+
+		kParserError
+	};
+	
+	struct XMLKeyLayout;
+	struct ParserNode;
+	
+	typedef Common::HashMap<Common::String, XMLParser::XMLKeyLayout*, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> ChildMap;
+	
+	/** nested struct representing the layout of the XML file */
+	struct XMLKeyLayout {
+		struct XMLKeyProperty {
+			Common::String name;
+			bool required;
+		};
+		
+		Common::List<XMLKeyProperty> properties;
+		ChildMap children;
+		
+		virtual bool doCallback(XMLParser *parent, ParserNode *node) = 0;
+		
+		virtual ~XMLKeyLayout() {
+			properties.clear();
+		}
+	} *_XMLkeys;
+
+	/** Struct representing a parsed node */
+	struct ParserNode {
+		Common::String name;
+		Common::StringMap values;
+		bool ignore;
+		int depth;
+		XMLKeyLayout *layout;
+	};
+	
+	FixedSizeMemoryPool<sizeof(ParserNode), MAX_XML_DEPTH> _nodePool;
+
+	ParserNode *allocNode() {
+		void* mem = _nodePool.malloc();
+		return new (mem) ParserNode;
+	} 
+
+	void freeNode(ParserNode *node) {
+		node->~ParserNode();
+		_nodePool.free(node);
+	}
+
+	/**
+	 * Loads a file into the parser.
+	 * Used for the loading of Theme Description files
+	 * straight from the filesystem.
+	 *
+	 * @param filename Name of the file to load.
+	 */
+	bool loadFile(const Common::String &filename) {
+		Common::File *f = new Common::File;
+
+		if (!f->open(filename)) {
+			delete f;
+			return false;
+		}
+
+		_fileName = filename;
+		_stream = f;
+		return true;
+	}
+	
+	bool loadFile(const FSNode &node) {
+		Common::File *f = new Common::File;
+		
+		if (!f->open(node)) {
+			delete f;
+			return false;
+		}
+		
+		_fileName = node.getName();
+		_stream = f;
+		return true;
+	}
+
+	/**
+	 * Loads a memory buffer into the parser.
+	 * Used for loading the default theme fallback directly
+	 * from memory if no themes can be found.
+	 *
+	 * @param buffer Pointer to the buffer.
+	 * @param size Size of the buffer
+	 * @param disposable Sets if the XMLParser owns the buffer,
+	 *                   i.e. if it can be freed safely after it's
+	 *                   no longer needed by the parser.
+	 */
+	bool loadBuffer(const byte *buffer, uint32 size, bool disposable = false) {
+		_stream = new MemoryReadStream(buffer, size, disposable);
+		_fileName = "Memory Stream";
+		return true;
+	}
+	
+	bool loadStream(Common::SeekableReadStream *stream) {
+		_stream = stream;
+		_fileName = "File Stream";
+		return true;
+	}
+	
+	void close() {
+		if (_stream) {
+			delete _stream;
+			_stream = 0;
+		}
+	}
+
+	/**
+	 * The actual parsing function.
+	 * Parses the loaded data stream, returns true if successful.
+	 */
+	bool parse();
+
+	/**
+	 * Returns the active node being parsed (the one on top of
+	 * the node stack).
+	 */
+	ParserNode *getActiveNode() {
+		if (!_activeKey.empty())
+			return _activeKey.top();
+
+		return 0;
+	}
+
+	/**
+	 * Returns the parent of a given node in the stack.
+	 */
+	ParserNode *getParentNode(ParserNode *child) {
+		return child->depth > 0 ? _activeKey[child->depth - 1] : 0;
+	}
+
+protected:
+	
+	/**
+	 * The buildLayout function builds the layout for the parser to use
+	 * based on a series of helper macros. This function is automatically
+	 * generated by the CUSTOM_XML_PARSER() macro on custom parsers.
+	 *
+	 * See the documentation regarding XML layouts.
+	 */
+	virtual void buildLayout() = 0;
+	
+	/**
+	 * The keycallback function is automatically overloaded on custom parsers
+	 * when using the CUSTOM_XML_PARSER() macro. 
+	 *
+	 * Its job is to call the corresponding Callback function for the given node.
+	 * A function for each key type must be declared separately. See the custom
+	 * parser creation instructions.
+	 *
+	 * When parsing a key in such function, one may chose to skip it, e.g. because it's not needed
+	 * on the current configuration. In order to ignore a key, you must set
+	 * the "ignore" field of its KeyNode struct to "true": The key and all its children
+	 * will then be automatically ignored by the parser.
+	 *
+	 * The callback function must return true if the key was properly handled (this includes the case when the
+	 * key is being ignored). False otherwise. The return of keyCallback() is the same as
+	 * the callback function's.
+	 * See the sample implementation in GUI::ThemeParser.
+	 */
+	virtual bool keyCallback(ParserNode *node) = 0;
+
+	/**
+	 * The closed key callback function MAY be overloaded by inheriting classes to
+	 * implement parser-specific functions.
+	 *
+	 * The closedKeyCallback is issued once a key has been finished parsing, to let
+	 * the parser verify that all the required subkeys, etc, were included.
+	 *
+	 * Unlike the keyCallbacks(), there's just a closedKeyCallback() for all keys.
+	 * Use "node->name" to distinguish between each key type.
+	 *
+	 * Returns true if the key was properly closed, false otherwise.
+	 * By default, all keys are properly closed.
+	 */
+	virtual bool closedKeyCallback(ParserNode *node) {
+		return true;
+	}
+	
+	/**
+	 * Called when a node is closed. Manages its cleanup and calls the
+	 * closing callback function if needed.
+	 */
+	bool closeKey();
+
+	/**
+	 * Parses the value of a given key. There's no reason to overload this.
+	 */
+	bool parseKeyValue(Common::String keyName);
+
+	/**
+	 * Called once a key has been parsed. It handles the closing/cleanup of the
+	 * node stack and calls the keyCallback.
+	 */
+	bool parseActiveKey(bool closed);
+
+	/**
+	 * Prints an error message when parsing fails and stops the parser.
+	 * Parser error always returns "false" so we can pass the return value directly
+	 * and break down the parsing.
+	 */
+	bool parserError(const char *errorString, ...) GCC_PRINTF(2, 3);
+
+	/**
+	 * Skips spaces/whitelines etc. Returns true if any spaces were skipped.
+	 */
+	bool skipSpaces() {
+		if (!isspace(_char))
+			return false;
+
+		while (_char && isspace(_char))
+			_char = _stream->readByte();
+
+		return true;
+	}
+
+	/**
+	 * Skips comment blocks and comment lines.
+	 * Returns true if any comments were skipped.
+	 * Overload this if you want to disable comments on your XML syntax
+	 * or to change the commenting syntax.
+	 */
+	virtual bool skipComments() {
+		char endComment1 = 0, endComment2 = 0;
+
+		if (_char == '/') {
+			_char = _stream->readByte();
+
+			if (_char != '*') {
+				_stream->seek(-1, SEEK_CUR);
+				_char = '/';
+				return false;
+			}
+			
+			_char = _stream->readByte();
+
+			while (_char) {
+				endComment1 = endComment2;
+				endComment2 = _char;
+				_char = _stream->readByte();
+
+				if (endComment1 == '*' && endComment2 == '/')
+					break;
+
+				if (_char == 0)
+					return parserError("Comment has no closure.");
+			}
+			_char = _stream->readByte();
+			return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * Check if a given character can be part of a KEY or VALUE name.
+	 * Overload this if you want to support keys with strange characters
+	 * in their name.
+	 */
+	virtual inline bool isValidNameChar(char c) {
+		return isalnum(c) || c == '_';
+	}
+
+	/**
+	 * Parses a the first textual token found.
+	 * There's no reason to overload this.
+	 */
+	bool parseToken() {
+		_token.clear();
+
+		while (isValidNameChar(_char)) {
+			_token += _char;
+			_char = _stream->readByte();
+		}
+
+		return isspace(_char) != 0 || _char == '>' || _char == '=' || _char == '/';
+	}
+
+	/**
+	 * Parses the values inside an integer key.
+	 * The count parameter specifies the number of values inside
+	 * the key, which are expected to be separated with commas.
+	 *
+	 * Sample usage:
+	 * parseIntegerKey("255, 255, 255", 3, &red, &green, &blue);
+	 * [will parse each field into its own integer]
+	 *
+	 * parseIntegerKey("1234", 1, &number);
+	 * [will parse the single number into the variable]
+	 *
+	 * @param key String containing the integers to be parsed.
+	 * @param count Number of comma-separated ints in the string.
+	 * @param ... Integer variables to store the parsed ints, passed
+	 *            by reference.
+	 * @returns True if the parsing succeeded.
+	 */
+	bool parseIntegerKey(const char *key, int count, ...) {
+		char *parseEnd;
+		int *num_ptr;
+
+		va_list args;
+		va_start(args, count);
+
+		while (count--) {
+			while (isspace(*key))
+				key++;
+
+			num_ptr = va_arg(args, int*);
+			*num_ptr = strtol(key, &parseEnd, 10);
+
+			key = parseEnd;
+
+			while (isspace(*key))
+				key++;
+
+			if (count && *key++ != ',')
+				return false;
+		}
+
+		va_end(args);
+		return (*key == 0);
+	}
+
+	/**
+	 * Overload if your parser needs to support parsing the same file
+	 * several times, so you can clean up the internal state of the 
+	 * parser before each parse.
+	 */
+	virtual void cleanup() {}
+
+	Common::List<XMLKeyLayout*> _layoutList;
+
+private:
+	char _char;
+	SeekableReadStream *_stream;
+	Common::String _fileName;
+
+	ParserState _state; /** Internal state of the parser */
+
+	Common::String _error; /** Current error message */
+	Common::String _token; /** Current text token */
+
+	Common::Stack<ParserNode*> _activeKey; /** Node stack of the parsed keys */
+};
+
+}
+
+#endif