Initial Import

1 files changed, 1811 insertions, 0 deletions

diff --git a/src/xmlcomposer.cpp b/src/xmlcomposer.cpp
new file mode 100644
index 0000000..1bfeb30
--- /dev/null
+++ b/src/xmlcomposer.cpp
@@ -0,0 +1,1811 @@
+// RtfParser.cpp: implementation of the RtfParser class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "stdafx.h"
+#include "RtfAnalyser.h"
+
+const char* kElDest = "i_dest";
+const char* kElBlock = "i_block";
+const char* kAtFix = "i_fix";
+const char* kAtCell = "i_cell";
+const char* kElListtable = "i_listtable";
+const char* kElListdef = "i_listdef";
+
+const char* kElPara = "para";
+const char* kElDoc = "document";
+const char* kElTab = "tab";
+const char* kElSect = "sect";
+const char* kElPage = "page";
+const char* kElStyle = "style";
+const char* kElLine = "line";
+const char* kElList = "list";
+const char* kElStylesheet = "stylesheet";
+const char* kElInfo = "info";
+const char* kElTitle = "title";
+const char* kElAuthor = "author";
+const char* kElOperator = "operator";
+const char* kElB = "b";
+const char* kElHide = "hide";
+const char* kElI = "i";
+const char* kElStrike = "strike";
+const char* kElU = "u";
+const char* kElColor = "color";
+const char* kElCell = "cell";
+const char* kElRow = "row";
+const char* kElTable = "table";
+
+const char* kAtList = "list";
+const char* kAtName = "name";
+const char* kAtBold = "bold";
+const char* kAtHidden = "hide";
+const char* kAtItalic = "italic";
+const char* kAtStrike = "strike";
+const char* kAtUnderline = "underline";
+const char* kAtColor = "color";
+const char* kAtType = "type";
+const char* kAtOrdered = "ordered";
+const char* kAtStart = "start";
+const char* kAtId = "id";
+const char* kAtIndex = "id";
+
+const wchar_t* kValDisc = L"disc";
+const wchar_t* kValLowerAlpha = L"lower-alpha";
+const wchar_t* kValUpperAlpha = L"upper-alpha";
+const wchar_t* kValLowerRoman = L"lower-roman";
+const wchar_t* kValUpperRoman = L"upper-roman";
+const wchar_t* kValArabic = L"arabic";
+const wchar_t* kValNull = L"";
+
+const wchar_t* kValList = L"list";
+const wchar_t* kValPara = L"para";
+const wchar_t* kValTable = L"table";
+
+const char* kNoDuplicates[] =
+	{ kElB, kElU, kElI, kElColor, kElHide, kElColor, NULL };
+
+const char* kRemoveTags[] =
+	{ kElDest, kElListdef, kElListtable, NULL };
+
+const char* kBlockTags[] =
+	{ kElTable, kElPara, NULL };
+
+const char* kHideList[] =
+	{ kAtId, kAtList, NULL };
+
+const char* kNSPrefix = "xmlns";
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+RtfParser::RtfParser(const RtfParserOptions& options)
+{
+	m_document = NULL;
+	memcpy(&m_options, &options, sizeof(options));
+}
+
+RtfParser::~RtfParser()
+{
+	clear();
+
+	if(m_impl != NULL)
+		m_impl.release();
+}
+
+void RtfParser::clear()
+{
+	if(m_document != NULL)
+	{
+		try
+		{
+			m_document.release();
+		}
+		catch(...) { }
+
+		m_document = NULL;
+	}
+	LevelHandler::clear();
+}
+
+void RtfParser::startDocument(RtfReader* reader)
+{
+	LevelHandler::startDocument(reader);
+
+	// Create a new document
+	m_document = m_impl.createDocument("", kElDoc, DOM::DocumentType());
+
+	// TODO: Throw error if document is null
+	ASSERT(m_document != NULL);
+
+	ASSERT(m_curLevel != NULL);
+	m_curLevel->setElement(m_document.getDocumentElement(), true);
+
+	// Set the attributes on the top level
+	setAnalyser(AnalyserPtr(new Root));
+	setDestination(DestinationPtr(new Content));
+	getTextFormatting().resetPara();
+	getTextFormatting().resetText();
+}
+
+void RtfParser::endDocument()
+{
+	LevelHandler::endDocument();
+
+	// Cleanup the tree
+	removeDuplicates(m_document);
+	breakTables(m_document);
+	breakTags(m_document, kElTable, kElRow);
+	breakTags(m_document, kElRow, kElCell);
+	wrapTags(m_document, kElCell, kElDest);
+	breakBlocks(m_document);
+	breakLists(m_document);
+	fixLists(m_document);
+	fixStyles(m_document);
+	fixBlocks(m_document);
+	removeTags(m_document);
+	breakBreak(m_document, kElDoc, kElPage);
+	breakBreak(m_document, kElDoc, kElSect);
+	return;
+}
+
+
+
+
+
+// -----------------------------------------------------------------------
+//  Helper functions
+
+DOM::Element RtfParser::createElement(const string& name)
+{
+	ASSERT(name.length() > 0);
+	return m_document.createElement(name);
+
+	// TODO: Throw exception here if necessary
+}
+
+void RtfParser::replaceElement(const DOM::Element& element)
+{
+	ASSERT(m_curLevel != NULL);
+	m_curLevel->setElement(element, true);
+}
+
+void RtfParser::pushElement(const DOM::Element& element)
+{
+	ASSERT(m_curLevel != NULL);
+	getElement().appendChild(element);
+	m_curLevel->setElement(element);
+}
+
+DOM::Element RtfParser::popElement()
+{
+	DOM::Element element = getElement();
+	ASSERT(m_curLevel != NULL);
+
+	DOM::Node parent = element.getParentNode();
+	ASSERT(parent.getNodeType() == DOM::Node::ELEMENT_NODE);
+
+	// Set it deep so it replaces the current element
+	m_curLevel->setElement((DOM::Element&)parent, true);
+	return element;
+}
+
+void RtfParser::setAttribute(const string& name, const wstring& value, DOM::Element el)
+{
+	ASSERT(name.length() > 0);
+	if(el == NULL)
+		el = getElement();
+	el.setAttribute(name, value);
+}
+
+void RtfParser::setDestination(DestinationPtr dest)
+{
+	ASSERT(m_curLevel);
+
+	m_curLevel->setDestination(dest);
+	dest->m_parser = this;
+	dest->initialize();
+}
+
+DestinationPtr RtfParser::replaceDestination(DestinationPtr dest)
+{
+	ASSERT(m_curLevel);
+
+	DestinationPtr old = m_curLevel->getDestination();
+	m_curLevel->setDestination(dest, true);
+	dest->m_parser = this;
+	dest->initialize();
+
+	return old;
+}
+
+
+void RtfParser::setAnalyser(AnalyserPtr analy)
+{
+	ASSERT(m_curLevel);
+	ASSERT(analy != NULL);
+
+	analy->m_parser = this;
+	m_curLevel->setAnalyser(analy);
+	analy->initialize();
+}
+
+AnalyserPtr RtfParser::getAnalyser()
+{
+	ASSERT(m_curLevel);
+	return m_curLevel->getAnalyser();
+}
+
+DestinationPtr RtfParser::getDestination()
+{
+	ASSERT(m_curLevel);
+	return m_curLevel->getDestination();
+}
+
+RtfFormatting& RtfParser::getTextFormatting()
+{
+	ASSERT(m_curLevel);
+	return m_curLevel->getFormatting();
+}
+
+
+// ---------------------------------------------------------------------------------
+//  Pass this stuff on through to the appropriate analysers etc...
+
+void RtfParser::charData(wstring data)
+{
+	ASSERT(m_curLevel != NULL);
+	DestinationPtr destination = m_curLevel->getDestination();
+	if(destination)
+	{
+		destination->charData(data);
+	}
+	else
+	{
+		destination = DestinationPtr(new Content);
+		setDestination(destination);
+	}
+
+}
+
+void RtfParser::controlWord(const string& cw, int flags, int param)
+{
+	ASSERT(m_curLevel != NULL);
+	AnalyserPtr analyser = m_curLevel->getAnalyser();
+	if(analyser)
+		analyser->controlWord(cw, flags, param);
+}
+
+void RtfParser::groupStart()
+{
+	LevelHandler::groupStart();
+
+	ASSERT(m_curLevel != NULL);
+	AnalyserPtr analyser = m_curLevel->getAnalyser();
+	if(analyser)
+		analyser->groupStart();
+}
+
+void RtfParser::groupEnd()
+{
+	ASSERT(m_curLevel != NULL);
+	AnalyserPtr analyser = m_curLevel->getAnalyser();
+	if(analyser)
+		analyser->groupEnd();
+
+	LevelHandler::groupEnd();
+}
+
+#define ON_INITIALIZE(cls) \
+	void RtfParser::cls::initialize()
+#define ON_CONTROLWORD(cls) \
+	void RtfParser::cls::controlWord(const string& cw, int flags, int param)
+#define ON_CHARDATA(cls) \
+	void RtfParser::cls::charData(wstring data)
+#define ON_GROUPSTART(cls) \
+	void RtfParser::cls::groupStart()
+#define ON_GROUPEND(cls) \
+	void RtfParser::cls::groupEnd()
+#define ON_DONE(cls) \
+	void RtfParser::cls::done()
+#define AN_ELEMENT(name) \
+	m_parser->pushElement(m_parser->createElement(name))
+#define AN_POP_ELEMENT() \
+	m_parser->popElement()
+#define AN_ATTRIBUTE(name, value) \
+	m_parser->setAttribute(name, value)
+#define AN_DESTINATION_ATTR(name) \
+	m_parser->setDestination(new Attribute(name))
+#define AN_DESTINATION(cls) \
+	m_parser->setDestination(new cls)
+#define AN_ANALYSER(cls) \
+	m_parser->setAnalyser(AnalyserPtr(new cls))
+#define AN_SET_ANALYSER(cls) \
+	m_parser->setAnalyser(AnalyserPtr(cls))
+#define HAS_PARAM (flags & kHasParam)
+#define DEFAULT_CONTROLWORD processDefault(cw, flags, param)
+#define DUMMY	1 == 1
+#define NUM_ATTR(n) m_parser->formatInt(n)
+
+bool RtfParser::ParseAnalyser::processDefault(const string& cw, int flags, int param)
+{
+	if(cw == "upr")
+	{
+		AnalyserPtr analy = m_parser->getAnalyser();
+		ASSERT(analy != NULL);
+		AN_SET_ANALYSER(new Upr(analy));
+		return true;
+	}
+
+	return false;
+}
+
+void RtfParser::ParseAnalyser::applyParaFormatting(RtfFormatting* format,
+												   DOM::Element& el)
+{
+	if(format == NULL)
+		format = &(m_parser->getTextFormatting());
+
+	wstring fix = kValPara;
+
+	int list = format->paraList();
+	if(list != -1)
+	{
+		el.setAttribute(kAtList, NUM_ATTR(list));
+	}
+	else
+	{
+		el.removeAttribute(kAtList);
+	}
+
+	if(format->paraInTable())
+		el.setAttribute(kAtCell, L"1");
+	else
+		el.removeAttribute(kAtCell);
+
+	int style = format->paraStyle();
+	if(style != -1)
+		el.setAttribute(kElStyle, NUM_ATTR(style));
+	else
+		el.removeAttribute(kElStyle);
+
+	el.setAttribute(kAtFix, fix);
+}
+
+DOM::Element RtfParser::ParseAnalyser::getCurrentBlock()
+{
+	DOM::Node node = m_parser->getElement();
+
+	if(node.hasChildNodes())
+		node = node.getLastChild();
+
+	return m_parser->getPriorElement(node, kElBlock);
+
+}
+
+bool RtfParser::ParseAnalyser::processTextContent(const string& cw, int flags, int param)
+{
+	DOM::Element el;
+	bool process = false;
+
+	RtfFormatting& format = m_parser->getTextFormatting();
+
+	if(cw == "par")
+	{
+		el = getCurrentBlock();
+		if(el != NULL)
+			applyParaFormatting(&format, el);
+
+		el = m_parser->createElement(kElBlock);
+		applyParaFormatting(&format, el);
+	}
+
+	else if(cw == "intbl")
+		format.paraSetTable(true);
+
+	else if(cw == "cell")
+	{
+		el = getCurrentBlock();
+		if(el != NULL)
+			applyParaFormatting(&format, el);
+
+		el = m_parser->createElement(kElCell);
+		m_parser->pushElement(el);
+		m_parser->popElement();
+		el = m_parser->createElement(kElBlock);
+		applyParaFormatting(&format, el);
+	}
+
+	else if(cw == "trowd")
+		el = m_parser->createElement(kElRow);
+
+	else if(cw == "tab")
+		el = m_parser->createElement(kElTab);
+
+	else if(cw == "sect")
+		el = m_parser->createElement(kElSect);
+
+	else if(cw == "page")
+		el = m_parser->createElement(kElPage);
+
+	else if(cw == "s" && HAS_PARAM)
+		format.paraSetStyle(param);
+
+	else if(cw == "line")
+		el = m_parser->createElement(kElLine);
+
+	else if(cw == "header")
+		AN_ANALYSER(Skip);
+	else if(cw == "footer")
+		AN_ANALYSER(Skip);
+	else if(cw == "bkmkstart")
+		AN_ANALYSER(Skip);
+	else if(cw == "listtext")
+		AN_ANALYSER(Skip);
+
+	else if(cw == "ls" && HAS_PARAM)
+		format.paraSetList(param);
+
+	if(el != NULL)
+	{
+		// This ensures that our content destination is open and ready
+		DestinationPtr dest = m_parser->getDestination();
+		ASSERT(dest != NULL);
+		dest->charData(kValNull);
+
+		m_parser->pushElement(el);
+		m_parser->popElement();
+	}
+
+	return (el != NULL) || process;
+
+	/* TODO: cell, row, intbl, cellx, trowd*/
+}
+
+bool RtfParser::ParseAnalyser::processTextFormatting(const string& cw, int flags,
+												  int param, RtfFormatting& format)
+{
+	bool on = true;
+	if(flags & HAS_PARAM && param == 0)
+		on = false;
+
+	if(cw == "pard")
+	{
+		format.resetPara();
+//		applyParaFormatting();
+	}
+	else if(cw == "plain")
+		format.resetText();
+	else if(cw == "b")
+		format.textSetBold(on);
+	else if(cw == "i")
+		format.textSetItalic(on);
+	else if(cw == "v")
+		format.textSetHidden(on);
+	else if(cw == "ul")
+		format.textSetUnderline(on);
+	else if(cw == "cf" && HAS_PARAM)
+		format.textSetColor(param);
+	else
+		return false;
+
+	return true;
+}
+
+bool RtfParser::ParseAnalyser::processTextFormatting(const string& cw, int flags, int param)
+{
+	return processTextFormatting(cw, flags, param, m_parser->getTextFormatting());
+}
+
+
+ON_INITIALIZE(Skip)
+	{ AN_DESTINATION(Null); }
+ON_GROUPSTART(Skip)
+	{ AN_ANALYSER(Skip); }
+
+
+RtfParser::Upr::Upr(AnalyserPtr prv)
+{
+	ASSERT(prv);
+	prev = prv;
+}
+ON_GROUPSTART(Upr)
+	{ AN_ANALYSER(Skip); }
+ON_GROUPEND(Upr)
+{
+	ASSERT(prev);
+	m_parser->setAnalyser(prev);
+	prev = NULL;
+}
+
+
+ON_INITIALIZE(Stylesheet)
+{
+	AN_ELEMENT(kElStylesheet);
+}
+ON_GROUPSTART(Stylesheet)
+{
+	AN_ANALYSER(Style);
+	AN_DESTINATION(Null);
+}
+
+
+
+ON_INITIALIZE(Style)
+{
+	// Were not sure if this element is really something
+	// so we can't always create
+	haveStyle = false;
+}
+ON_CONTROLWORD(Style)
+{
+	// Get the style id
+	if(flags & kAsterisk)
+	{
+		AN_ANALYSER(Skip);
+		return;
+	}
+
+	if(!haveStyle)
+	{
+		AN_ELEMENT(kElStyle);
+		AN_DESTINATION_ATTR(kAtName);
+		haveStyle = true;
+	}
+
+	if(cw == "s" && flags & kHasParam)
+	{
+		AN_ATTRIBUTE(kAtId, NUM_ATTR(param));
+	}
+
+	// Otherwise get as much formatting out of the tag as possible
+	else if(processTextFormatting(cw, flags, param))
+		DUMMY;
+
+	else
+		DEFAULT_CONTROLWORD;
+}
+ON_GROUPSTART(Style)
+{
+	AN_ANALYSER(Skip);
+}
+ON_GROUPEND(Style)
+{
+	RtfFormatting& props = m_parser->getTextFormatting();
+	if(props.textIsBold())
+		AN_ATTRIBUTE(kAtBold, L"1");
+	if(props.textIsHidden())
+		AN_ATTRIBUTE(kAtHidden, L"1");
+	if(props.textIsItalic())
+		AN_ATTRIBUTE(kAtItalic, L"1");
+	if(props.textIsStrike())
+		AN_ATTRIBUTE(kAtStrike, L"1");
+	if(props.textIsUnderline())
+		AN_ATTRIBUTE(kAtUnderline, L"1");
+	if(props.textColor() != -1 && m_parser->getOptions().doColors)
+		AN_ATTRIBUTE(kAtColor, NUM_ATTR(props.textColor()));
+}
+
+
+
+ON_INITIALIZE(ListTable)
+{
+	AN_ELEMENT(kElListtable);
+}
+ON_GROUPSTART(ListTable)
+{
+	AN_ANALYSER(List);
+	AN_DESTINATION(Null);
+}
+
+
+
+ON_INITIALIZE(List)
+{
+	AN_ELEMENT(kElListdef);
+	AN_ATTRIBUTE(kAtType, kValDisc);
+	AN_ATTRIBUTE(kAtOrdered, L"0");
+	levelsSeen = 0;
+}
+ON_CONTROLWORD(List)
+{
+	if(cw == "listname")
+		AN_DESTINATION_ATTR(kAtName);
+	else if(cw == "listid" && HAS_PARAM)
+		AN_ATTRIBUTE(kAtId, NUM_ATTR(param));
+
+	// We let listlevel in here too
+	else if(cw == "levelstartat" && HAS_PARAM)
+		AN_ATTRIBUTE(kAtStart, NUM_ATTR(param));
+
+	else if(cw == "levelnfc" && HAS_PARAM)
+	{
+		switch(param)
+		{
+        case 0: // 1, 2, 3
+        case 5: // 1st, 2nd, 3rd
+        case 6: // One, Two, Three
+        case 7: // First, Second, Third
+        case 22: // 01, 02, 03
+			AN_ATTRIBUTE(kAtType, kValArabic);
+            break;
+        case 1: // I, II, III
+			AN_ATTRIBUTE(kAtType, kValUpperRoman);
+            break;
+        case 2: // i, ii, iii
+			AN_ATTRIBUTE(kAtType, kValLowerRoman);
+            break;
+        case 3: // A, B, C
+			AN_ATTRIBUTE(kAtType, kValUpperAlpha);
+            break;
+        case 4: // a, b, c
+			AN_ATTRIBUTE(kAtType, kValLowerAlpha);
+            break;
+        default:
+			AN_ATTRIBUTE(kAtType, kValDisc);
+			break;
+        }
+
+		switch(param)
+		{
+        case 0: case 5: case 6: case 7: case 22:
+        case 1: case 2: case 3: case 4:
+			AN_ATTRIBUTE(kAtOrdered, L"1");
+			break;
+		default:
+			AN_ATTRIBUTE(kAtOrdered, L"0");
+		}
+	}
+
+	else
+		DEFAULT_CONTROLWORD;
+}
+ON_GROUPSTART(List)
+{
+	if(levelsSeen > 0)
+		AN_ANALYSER(Skip);
+	levelsSeen++;
+}
+
+
+
+
+ON_INITIALIZE(ListOverrideTable)
+{
+	DOM::Document document = m_parser->getDocument();
+	lists = document.getElementsByTagName(kElListdef);
+	curList = NULL;
+	lsId = -1;
+}
+ON_GROUPSTART(ListOverrideTable)
+{
+	AN_DESTINATION(Null);
+}
+ON_CONTROLWORD(ListOverrideTable)
+{
+	// New list override clear
+	if(cw == "listoverride")
+		curList = NULL;
+
+	// List id for current listoverride
+	else if(cw == "listid" && HAS_PARAM)
+	{
+		wstring id = NUM_ATTR(param);
+
+		if(lists != NULL)
+		{
+			for(int i = 0; i < lists->getLength(); i++)
+			{
+				DOM::Node node = lists->item(i);
+				if(node != NULL && node.getNodeType() == DOM::Node::ELEMENT_NODE)
+				{
+					DOM::Element element = (DOM::Element&)node;
+					if(element.getAttribute(kAtId) == id)
+					{
+						curList = element;
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	// The actual list code
+	else if(cw == "ls" && HAS_PARAM)
+		lsId = param;
+
+	// Override the starting level for the node
+	else if(cw == "levelstartat" && HAS_PARAM)
+	{
+		if(curList != NULL)
+			curList.setAttribute(kAtStart, NUM_ATTR(param));
+	}
+
+	else
+		DEFAULT_CONTROLWORD;
+
+
+	// Okay before any overrides take effect we need to duplicate
+	// the list node for overriding, using the 'listid' and 'ls' we gathered
+	if(curList != NULL && lsId != -1)
+	{
+		DOM::Element parent = (DOM::Element&)curList.getParentNode();
+		if(parent != NULL)
+		{
+			curList = (DOM::Element&)curList.cloneNode(true);
+			if(curList != NULL)
+			{
+				parent.appendChild(curList);
+				curList.setAttribute(kAtList, NUM_ATTR(lsId));
+			}
+		}
+
+		lsId = -1;
+	}
+
+}
+ON_GROUPEND(ListOverrideTable)
+{
+
+}
+
+
+
+
+ON_INITIALIZE(Info)
+{
+	// Create a new element
+	AN_ELEMENT(kElInfo);
+	AN_DESTINATION(Null);
+}
+ON_CONTROLWORD(Info)
+{
+	// The title
+	if(cw == "title")
+	{
+		AN_ELEMENT(kElTitle);
+		AN_DESTINATION(Raw);
+	}
+	else if(cw == "author")
+	{
+		AN_ELEMENT(kElAuthor);
+		AN_DESTINATION(Raw);
+	}
+	else if(cw == "operator")
+	{
+		AN_ELEMENT(kElOperator);
+		AN_DESTINATION(Raw);
+	}
+	else if(flags & kAsterisk)
+		AN_ANALYSER(Skip);
+	else
+		DEFAULT_CONTROLWORD;
+}
+
+
+
+
+ON_INITIALIZE(Root)
+{
+
+}
+ON_CONTROLWORD(Root)
+{
+	if(cw == "stylesheet")
+		AN_ANALYSER(Stylesheet);
+	else if(cw == "listtable")
+		AN_ANALYSER(ListTable);
+	else if(cw == "listoverridetable")
+		AN_ANALYSER(ListOverrideTable);
+	else if(cw == "info")
+		AN_ANALYSER(Info);
+	else if(cw == "fonttbl")
+		AN_ANALYSER(Skip);
+	else if(cw == "colortbl")
+		AN_ANALYSER(Skip);
+	else if(cw == "pict")
+	{
+		AN_ANALYSER(Skip);
+		AN_DESTINATION(Null);
+	}
+	else if(flags & kAsterisk)
+		AN_ANALYSER(Skip);
+	else if(processTextContent(cw, flags, param))
+		DUMMY;
+	else if(processTextFormatting(cw, flags, param))
+		DUMMY;
+	else
+		DEFAULT_CONTROLWORD;
+}
+
+
+ON_INITIALIZE(Content)
+{
+	parent = m_parser->getElement();
+	created = false;
+}
+ON_CHARDATA(Content)
+{
+	// Create the first time we get content
+	if(!created)
+	{
+		DOM::Element dest = m_parser->createElement(kElDest);
+		parent.appendChild(dest);
+		m_parser->replaceElement(dest);
+
+		DOM::Element el = m_parser->createElement(kElBlock);
+		m_parser->pushElement(el);
+		m_parser->popElement();
+
+		created = true;
+	}
+
+	if(data.length() == 0)
+		return;
+
+	int elements = 0;
+	RtfFormatting& format = m_parser->getTextFormatting();
+
+	// Now do text Properties if necessary
+	if(format.textIsBold())
+	{
+		AN_ELEMENT(kElB);
+		elements++;
+	}
+	if(format.textIsHidden())
+	{
+		AN_ELEMENT(kElHide);
+		elements++;
+	}
+	if(format.textIsItalic())
+	{
+		AN_ELEMENT(kElI);
+		elements++;
+	}
+	if(format.textIsStrike())
+	{
+		AN_ELEMENT(kElStrike);
+		elements++;
+	}
+	if(format.textIsUnderline())
+	{
+		AN_ELEMENT(kElU);
+		elements++;
+	}
+	if(format.textColor() != -1 && m_parser->getOptions().doColors)
+	{
+		AN_ELEMENT(kElColor);
+		AN_ATTRIBUTE(kAtIndex, NUM_ATTR(format.textColor()));
+		elements++;
+	}
+
+	// Write the data to the element
+	m_parser->getElement().appendChild(
+		m_parser->getDocument().createTextNode(data));
+
+	// Now drop out of all the above formatting
+	while(elements-- > 0)
+		AN_POP_ELEMENT();
+}
+
+#if 0
+ON_INITIALIZE(Table)
+{
+	stack = 0;
+	level = m_parser->getLevel();
+	AN_ELEMENT(kElTable);
+	AN_DESTINATION(Content);
+}
+
+ON_CONTROLWORD(Table)
+{
+	ASSERT(stack >= 0);
+	ASSERT(level != NULL);
+
+	if(cw == "trowd")
+	{
+		stack++;
+	}
+	else if(cw == "row")
+	{
+		stack--;
+		if(stack <= 0)
+			m_parser->rewindLevel(level);
+	}
+
+	else if(processTextContent(cw, flags, param))
+		DUMMY;
+	else if(processTextFormatting(cw, flags, param))
+		DUMMY;
+	else
+		DEFAULT_CONTROLWORD;
+
+	if(!m_parser->getTextFormatting().paraInTable())
+	{
+		m_parser->rewindLevel(level);
+	}
+
+}
+#endif
+
+
+
+
+ON_CHARDATA(Raw)
+{
+	// Write the data to the element
+	m_parser->getElement().appendChild(
+		m_parser->getDocument().createTextNode(data));
+}
+
+
+
+
+ON_INITIALIZE(Attribute)
+{
+	element = m_parser->getElement();
+	ASSERT(element != NULL);
+}
+
+ON_CHARDATA(Attribute)
+{
+	// Get the current value
+	wstring cur = element.getAttribute(name);
+
+	if(data.at(data.size() - 1) == L';')
+		data.resize(data.size() - 1);
+
+	// Append data
+	cur.append(data);
+
+	// Write it back
+	element.setAttribute(name, cur);
+}
+
+
+
+
+
+/**
+ * A quick check to see if a node is an element of a certain
+ * name
+ */
+bool RtfParser::isElement(const DOM::Node& node, const string& name)
+{
+	return node != NULL && node.getNodeType() == DOM::Node::ELEMENT_NODE &&
+				node.getNodeName() == name;
+}
+
+bool RtfParser::isEqualElement(const DOM::Element& el1, const DOM::Element& el2)
+{
+	if(el1.getNodeName() == el2.getNodeName())
+		return false;
+
+	DOM::NamedNodeMap at1 = el1.getAttributes();
+	DOM::NamedNodeMap at2 = el2.getAttributes();
+
+	if(at1 == NULL && at2 == NULL)
+		return true;
+
+	if(at1 == NULL || at2 == NULL ||
+	   at1->getLength() != at2->getLength())
+		return false;
+
+	for(int i = 0; i < at1->getLength(); i++)
+	{
+		DOM::Attr attr1 = (DOM::Attr&)at1->item(0);
+		if(attr1 != NULL)
+			return false;
+
+		DOM::Attr attr2 = (DOM::Attr&)at2->getNamedItem(attr1.getNodeName());
+		if(attr2 != NULL)
+			return false;
+
+		if(attr1.getNodeValue() == attr2.getNodeValue())
+			return false;
+	}
+
+	return true;
+}
+
+wstring RtfParser::formatInt(int num)
+{
+	wstring n;
+	n.format(L"%d", num);
+	return n;
+}
+
+/**
+ * Gets the pertinent ancestor of this node, or returns null
+ * if not found.
+ */
+DOM::Element RtfParser::getContainingElement(const DOM::Node& node, const string& name)
+{
+	DOM::Node n = node;
+
+	while(true)
+	{
+		n = n.getParentNode();
+		if(n == NULL)
+			break;
+
+		if(isElement(n, name))
+			return (DOM::Element&)n;
+	}
+
+	return DOM::Element();
+}
+
+DOM::Element RtfParser::getPriorElement(const DOM::Node& node, const string& name)
+{
+	DOM::Node n = node;
+
+	while(n != NULL)
+	{
+		if(isElement(n, name))
+			return (DOM::Element&)n;
+
+		n = n.getPreviousSibling();
+	}
+
+	DOM::Node parent = node.getParentNode();
+
+	if(parent == NULL)
+		return DOM::Element();
+	else
+		return getPriorElement(parent, name);
+}
+
+bool isNsAttr(const string& name)
+{
+	return strncmp(name.c_str(), kNSPrefix, strlen(kNSPrefix)) ? false : true;
+}
+
+void RtfParser::copyAttributes(const DOM::Element& src, DOM::Element& dest,
+							   const char** hideList)
+{
+	// Now get both sets of attributes
+	DOM::NamedNodeMap srcMap = src.getAttributes();
+	DOM::NamedNodeMap destMap = dest.getAttributes();
+
+	if(srcMap == NULL || destMap == NULL)
+		return;
+
+	// And copy them  from one to the other
+	for(int j = 0; j < srcMap->getLength(); j++)
+	{
+		DOM::Node attr = srcMap->item(j);
+		if(attr != NULL)
+		{
+			// BUG: Sablotron seems to have a bug in it's
+			// setAttributeNode implementation. It always
+			// adds a blank namespace
+			// attr = attr.cloneNode(false);
+			// if(attr != NULL)
+			//	 destMap.setNamedItem(attr);
+
+			string name = attr.getNodeName();
+
+			if(hideList)
+			{
+
+				for(const char** t = hideList; *t != NULL; t++)
+				{
+					if(name == *t)
+						name.clear();
+				}
+			}
+
+			if(name.length() > 0 && !isNsAttr(name))
+				dest.setAttribute(attr.getNodeName(), attr.getNodeValue());
+		}
+	}
+}
+
+
+void RtfParser::breakBreak(DOM::Document& doc, const string& contain,
+							  const string& tag)
+{
+	DOM::NodeList els = doc.getElementsByTagName(tag);
+	if(els != NULL)
+	{
+		for(int i = 0; i < els->getLength(); i++)
+		{
+			DOM::Element el = (DOM::Element&)els->item(i);
+#if 0
+			// See if parent node only has this break tag
+			// in it. If so then replace parent with this
+
+			DOM::Node parent = el.getParentNode();
+
+			if(parent != NULL)
+			{
+				DOM::Node grandparent = parent.getParentNode();
+
+				if(grandparent != NULL &&
+				   el.getPreviousSibling() == NULL &&
+				   el.getNextSibling() == NULL)
+				{
+					grandparent.replaceChild(parent.removeChild(el), parent);
+				}
+			}
+#endif
+
+			breakElement(el, contain);
+		}
+	}
+}
+
+/**
+ * Breaks a paragraph up through a previous level. Calls itself
+ * recursively to break paragraphs totally free up to containing
+ * destination.
+ *
+ * For example:
+ *
+ * <dest>
+ *	 This is <b> a <block fix="para"/>
+ *	 test of </b> your concentration.
+ *  </dest>
+ *
+ * Becomes:
+ *
+ * <dest>
+ *	 This is <b> a </b><block fix="para"/>
+ *   <b>test of </b> your concentration.
+ * </dest>
+ */
+bool RtfParser::breakElement(DOM::Element& el, const string& contain)
+{
+	ASSERT(el != NULL);
+
+	DOM::Element parent = (DOM::Element&)el.getParentNode();
+	DOM::Element grandparent;
+
+	string s = el.getNodeName();
+	s = parent.getNodeName();
+
+	// Get the parent node
+	if(parent != NULL)
+		grandparent = (DOM::Element&)parent.getParentNode();
+
+	// Make sure we have something to work with before continuing
+	if(grandparent == NULL || parent == NULL ||
+	   isElement(parent, contain))
+		return true;
+
+	DOM::Node e;
+
+	// Check to see if this is the first node in the parent.
+	// If so then just move out to before
+	if(el.getPreviousSibling() == NULL)
+	{
+		e = grandparent.insertBefore(parent.removeChild(el), parent);
+	}
+
+
+	// Check to see if this is the last node in the parent.
+	// If so then just move out to after the parent
+	else if(el.getNextSibling() == NULL)
+	{
+		DOM::Node next = parent.getNextSibling();
+		if(next == NULL)
+			e = grandparent.appendChild(parent.removeChild(el));
+		else
+			e = grandparent.insertBefore(parent.removeChild(el), next);
+	}
+
+
+	// Otherwise it's in the middle so split the parent
+	// element etc...
+	else
+	{
+		// Clone it but not deep
+		DOM::Element parent2 = (DOM::Element&)parent.cloneNode(false);
+
+		if(parent2 == NULL)
+			return false;
+
+		// Flag that tells us whether we moved anything up to parent
+		bool moved = false;
+
+		// Now move all nodes after this one to the second parent.
+		while((e = el.getNextSibling()) != NULL)
+		{
+			parent2.appendChild(parent.removeChild(e));
+			moved = true;
+		}
+
+		// Remove the element from it's parent
+		e = parent.removeChild(el);
+
+		// Okay now we move the paragraph up to the parent
+		insertAfter(grandparent, e, parent);
+		if(moved)
+			insertAfter(grandparent, parent2, e);
+	}
+
+	// Now call it again with the paragraph in the new position
+	// untill everything's cut through!
+	return breakElement((DOM::Element&)e, contain);
+}
+
+/**
+ * Changes from a marker based paragraph system to a contained
+ * paragraph system. Also applies paragraph attributes to the
+ * appropriate paragraph.
+ *
+ * For example:
+ *
+ * <dest>
+ *	 This <blockattr style="10"> is <b> a <block fix="para"/>
+ *	 test of </b> your concentration.
+ *  </dest>
+ *
+ * Becomes:
+ *
+ * <para style="10"> This is <b> a </b></para>
+ * <para><b>test of </b> your concentration.</para>
+ */
+void RtfParser::breakBlocks(DOM::Document& document)
+{
+	// First break out all the paragraphs to the destination level
+	DOM::NodeList blocks = document.getElementsByTagName(kElBlock);
+	if(blocks != NULL)
+	{
+		for(int i = 0; i < blocks->getLength(); i++)
+		{
+			DOM::Element block = (DOM::Element&)blocks->item(i);
+
+			// If it's the single closed style para then break it
+			if(block != NULL && !block.hasChildNodes())
+				breakElement(block, kElDest);
+		}
+	}
+
+
+	// Now group stuff in destinations into paras or other blocks
+	DOM::NodeList destinations = document.getElementsByTagName(kElDest);
+	if(destinations != NULL)
+	{
+		for(int i = 0; i < destinations->getLength(); i++)
+		{
+			DOM::Element dest = (DOM::Element&)destinations->item(i);
+
+			// Sanity Check
+			if(dest == NULL || !dest.hasChildNodes())
+				continue;
+
+			// Go through the children of this destination
+			DOM::Node child = dest.getFirstChild();
+
+			DOM::Element block;
+
+			while(child != NULL)
+			{
+				// If it's a block
+				if(isElement(child, kElBlock))
+				{
+					block = (DOM::Element&)child;
+					child = child.getNextSibling();
+					continue;
+				}
+
+				// If it's already a real block element
+				for(const char** t = kBlockTags; *t != NULL; t++)
+				{
+					if(isElement(child, *t))
+					{
+						block = NULL;
+						break;
+					}
+				}
+
+				// If there's a block then add to it
+				if(block != NULL)
+				{
+					block.appendChild(dest.removeChild(child));
+					child = block;
+				}
+
+				child = child.getNextSibling();
+			}
+		}
+	}
+}
+
+void RtfParser::wrapTags(DOM::Document& doc, const string& tagName,
+						 const string& wrapName)
+{
+	DOM::NodeList tags = doc.getElementsByTagName(tagName);
+	if(tags != NULL)
+	{
+		for(int i = 0; i < tags->getLength(); i++)
+		{
+			DOM::Element tag = (DOM::Element&)tags->item(i);
+
+			DOM::Element wrap = doc.createElement(wrapName);
+			while(tag.hasChildNodes())
+				wrap.appendChild(tag.removeChild(tag.getFirstChild()));
+
+			tag.appendChild(wrap);
+		}
+	}
+}
+
+void RtfParser::breakTags(DOM::Document& doc, const string& parentName,
+						  const string& tagName)
+{
+	DOM::NodeList parents = doc.getElementsByTagName(parentName);
+	if(parents != NULL)
+	{
+		for(int i = 0; i < parents->getLength(); i++)
+		{
+			DOM::Element parent = (DOM::Element&)parents->item(i);
+
+			if(!parent.hasChildNodes())
+				continue;
+
+			DOM::NodeList tags = parent.getElementsByTagName(tagName);
+			if(tags != NULL)
+			{
+				for(int i = 0; i < tags->getLength(); i++)
+					breakElement((DOM::Element&)tags->item(i), parentName);
+			}
+
+			DOM::Node tag = doc.createElement(tagName);
+			parent.insertBefore(tag, parent.getFirstChild());
+
+			DOM::Node child = tag;
+
+			while(child != NULL && (child = child.getNextSibling()) != NULL)
+			{
+				if(isElement(child, kElBlock))
+				{
+					DOM::Node next = child.getNextSibling();
+					if(next == NULL)
+					{
+						parent.removeChild(child);
+						continue;
+					}
+
+					if(isElement(next, tagName))
+					{
+						DOM::Node twodown = next.getNextSibling();
+						if(!isElement(twodown, kElBlock))
+						{
+							child = parent.insertBefore(parent.removeChild(next), child);
+						}
+						else
+						{
+							parent.removeChild(child);
+							child = next;
+						}
+					}
+				}
+
+				if(isElement(child, tagName))
+				{
+					if(!tag.hasChildNodes())
+						parent.removeChild(tag);
+					tag = child;
+				}
+				else
+				{
+					tag.appendChild(parent.removeChild(child));
+					child = tag;
+				}
+			}
+
+			if(!tag.hasChildNodes())
+				parent.removeChild(tag);
+		}
+	}
+
+	DOM::NodeList tags = doc.getElementsByTagName(tagName);
+	if(tags != NULL)
+	{
+		for(int i = 0; i < tags->getLength(); i++)
+		{
+			DOM::Element tag = (DOM::Element&)tags->item(i);
+			DOM::Node parent = tag.getParentNode();
+
+			if(parent != NULL && !isElement(parent, parentName))
+				parent.removeChild(tag);
+
+#if 0
+			else if(tag.hasChildNodes())
+			{
+				DOM::NodeList children = tag.getChildNodes();
+				if(children != NULL && children->getLength() == 1)
+				{
+					DOM::Node child = children->item(0);
+					if(child != NULL && !child.hasChildNodes() &&
+					   isElement(child, kElBlock))
+					    parent.removeChild(tag);
+				}
+			}
+#endif
+
+		}
+	}
+}
+
+void RtfParser::breakLists(DOM::Document& doc)
+{
+	// Now group stuff in destinations into tables
+	DOM::NodeList destinations = doc.getElementsByTagName(kElDest);
+	if(destinations != NULL)
+	{
+		for(int i = 0; i < destinations->getLength(); i++)
+		{
+			DOM::Element dest = (DOM::Element&)destinations->item(i);
+
+			// Sanity Check
+			if(dest == NULL)
+				continue;
+
+			// Go through the children of this destination
+			DOM::Node child = dest.getFirstChild();
+
+			DOM::Element list;
+			DOM::Element e;
+
+			wstring previd;
+
+			while(child != NULL)
+			{
+				// If it's a block and has a cell attribute
+				if(isElement(child, kElBlock))
+				{
+					e = (DOM::Element&)child;
+
+					// if it has a cell attribute
+					wstring listid = e.getAttribute(kAtList);
+					if(listid.length() > 0)
+					{
+						e.removeAttribute(kAtList);
+
+						if(list == NULL || previd != listid)
+						{
+							list = doc.createElement(kElList);
+							list.setAttribute(kAtList, listid);
+							dest.insertBefore(list, child);
+							previd = listid;
+						}
+					}
+					else
+					{
+						list = NULL;
+						previd.clear();
+					}
+				}
+
+				// It's not a block
+				if(list != NULL)
+				{
+					list.appendChild(dest.removeChild(child));
+					child = list;
+				}
+
+				child = child.getNextSibling();
+			}
+		}
+	}
+}
+
+void RtfParser::fixStyles(const DOM::Document doc)
+{
+	DOM::NodeList styles = doc.getElementsByTagName(kElStyle);
+	if(styles != NULL)
+	{
+		DOM::NodeList blocks = doc.getElementsByTagName(kElBlock);
+		if(blocks != NULL)
+		{
+			for(int i = 0; i < blocks->getLength(); i++)
+			{
+				DOM::Element block = (DOM::Element&)blocks->item(i);
+
+				if(block == NULL || !block.hasAttribute(kElStyle))
+					continue;
+
+				for(int j = 0; j < styles->getLength(); j++)
+				{
+					DOM::Element style = (DOM::Element&)styles->item(j);
+					if(style != NULL)
+					{
+						if(style.getAttribute(kAtId) == block.getAttribute(kElStyle))
+						{
+							wstring name = style.getAttribute(kAtName);
+							if(name.length() > 0)
+								block.setAttribute(kElStyle, name);
+						}
+					}
+				}
+			}
+		}
+
+		for(int i = 0; i < styles->getLength(); i++)
+		{
+			DOM::Element style = (DOM::Element&)styles->item(i);
+			if(style != NULL)
+				style.removeAttribute(kAtId);
+		}
+	}
+
+
+}
+
+
+void RtfParser::breakTables(DOM::Document& doc)
+{
+	DOM::NodeList rows = doc.getElementsByTagName(kElRow);
+	if(rows != NULL)
+	{
+		for(int i = 0; i < rows->getLength(); i++)
+		{
+			DOM::Element row = (DOM::Element&)rows->item(i);
+			DOM::Node parent = row.getParentNode();
+
+			if(parent == NULL)
+				continue;
+
+			if(isElement(parent, kElBlock))
+			{
+				DOM::Node grandparent = parent.getParentNode();
+
+				if(grandparent != NULL && !row.hasChildNodes())
+				{
+					if(row.getPreviousSibling() == NULL)
+						grandparent.insertBefore(parent.removeChild(row), parent);
+					else if(row.getNextSibling() == NULL)
+						insertAfter(grandparent, parent.removeChild(row), parent);
+				}
+			}
+
+			breakElement(row, kElDest);
+		}
+	}
+
+
+
+	// Now group stuff in destinations into tables
+	DOM::NodeList destinations = doc.getElementsByTagName(kElDest);
+	if(destinations != NULL)
+	{
+		for(int i = 0; i < destinations->getLength(); i++)
+		{
+			DOM::Element dest = (DOM::Element&)destinations->item(i);
+
+			// Sanity Check
+			if(dest == NULL)
+				continue;
+
+			// Go through the children of this destination
+			DOM::Node child = dest.getFirstChild();
+
+			DOM::Element table;
+			DOM::Element e;
+
+			while(child != NULL)
+			{
+				// If it's a block and has a cell attribute
+				if(isElement(child, kElBlock))
+				{
+					e = (DOM::Element&)child;
+
+					// if it has a cell attribute
+					if(e.getAttribute(kAtCell).length() > 0)
+					{
+						e.removeAttribute(kAtCell);
+
+						if(table == NULL)
+						{
+							table = doc.createElement(kElTable);
+							dest.insertBefore(table, child);
+						}
+					}
+					else
+					{
+						table = NULL;
+					}
+				}
+
+				// It's not a block
+				if(table != NULL)
+				{
+					table.appendChild(dest.removeChild(child));
+					child = table;
+				}
+
+				child = child.getNextSibling();
+			}
+		}
+	}
+}
+
+void RtfParser::insertAfter(DOM::Node& parent, const DOM::Node& node,
+							const DOM::Node& ref)
+{
+	DOM::Node sibling = ref.getNextSibling();
+	if(sibling == NULL)
+		parent.appendChild(node);
+	else
+		parent.insertBefore(node, sibling);
+}
+
+void RtfParser::removeTags(const DOM::Document& doc)
+{
+	// Go through the list of nodes
+	for(const char** t = kRemoveTags; *t != NULL; t++)
+	{
+		DOM::NodeList elements = doc.getElementsByTagName(*t);
+		if(elements != NULL)
+		{
+			for(int j = 0; j < elements->getLength(); j++)
+			{
+				DOM::Element el = (DOM::Element&)elements->item(j);
+				DOM::Node parent = el->getParentNode();
+
+				if(parent == NULL)
+					continue;
+
+				while(el.hasChildNodes())
+					parent.insertBefore(el.removeChild(el.getFirstChild()), el);
+
+				parent.removeChild(el);
+			}
+		}
+	}
+}
+
+void RtfParser::fixLists(const DOM::Document doc)
+{
+	DOM::NodeList lists = doc.getElementsByTagName(kElList);
+	if(lists != NULL)
+	{
+		DOM::NodeList listdefs = doc.getElementsByTagName(kElListdef);
+		if(listdefs != NULL)
+		{
+			for(int i = 0; i < listdefs->getLength(); i++)
+			{
+				DOM::Element listdef = (DOM::Element&)listdefs->item(i);
+
+				if(listdef == NULL || !listdef.hasAttribute(kAtList))
+					continue;
+
+				for(int j = 0; j < lists->getLength(); j++)
+				{
+					DOM::Element list = (DOM::Element&)lists->item(j);
+					if(list != NULL)
+					{
+						if(list.getAttribute(kAtList) == listdef.getAttribute(kAtList))
+						{
+							copyAttributes(listdef, list, kHideList);
+							list.removeAttribute(kAtList);
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+void RtfParser::fixBlocks(const DOM::Document doc)
+{
+	// First break out all the paragraphs to the destination level
+	DOM::NodeList blocks = doc.getElementsByTagName(kElBlock);
+	if(blocks != NULL)
+	{
+		string fix;
+		wstring val;
+
+		for(int i = 0; i < blocks->getLength(); i++)
+		{
+			DOM::Element block = (DOM::Element&)blocks->item(i);
+			DOM::Node parent = block.getParentNode();
+
+			if(parent == NULL)
+				continue;
+
+			fix.resize(0);
+			val.resize(0);
+
+			val = block.getAttribute(kAtFix);
+			if(val.length() > 0)
+				block.removeAttribute(kAtFix);
+
+
+			if(val.length() > 0)
+			{
+				val = block.getAttributeNS("", kAtFix);
+				if(val.length() > 0)
+					block.removeAttributeNS("", kAtFix);
+			}
+
+			if(val.length() > 0)
+				DOM::transcode16to8(val, fix);
+
+			if(fix.length() == 0)
+				fix = kElPara;
+
+			DOM::Element el = doc.createElement(fix);
+			copyAttributes(block, el, NULL);
+
+			while(block.hasChildNodes())
+				el.appendChild(block.removeChild(block.getFirstChild()));
+
+			parent.replaceChild(el, block);
+		}
+	}
+}
+
+
+/**
+ * Removes adjacent duplicate nodes of certain names
+ */
+void RtfParser::removeDuplicates(const DOM::Document& doc)
+{
+	// Go through the list of nodes
+	for(const char** t = kNoDuplicates; *t = NULL; t++)
+	{
+		DOM::NodeList elements = doc.getElementsByTagName(*t);
+		if(elements != NULL)
+		{
+			int x = elements->getLength();
+			for(int j = 0; j < elements->getLength(); j++)
+			{
+
+				// Make sure it's a valid element
+				DOM::Element element = (DOM::Element&)elements->item(j);
+				if(element == NULL)
+					continue;
+
+				// Get neighbors
+				DOM::Node previous = element.getPreviousSibling();
+				DOM::Node next = element.getNextSibling();
+
+				// Make sure it's still in the document, as we may have
+				// removed it on a previous loop
+				DOM::Node parent = element.getParentNode();
+				if(parent == NULL)
+					continue;
+
+				// Combine previous if valid
+				if(previous != NULL && previous.getNodeType() == DOM::Node::ELEMENT_NODE &&
+					isEqualElement((DOM::Element&)previous, element))
+				{
+					while(previous.hasChildNodes())
+					{
+						DOM::Node child = previous.removeChild(previous.getLastChild());
+						if(child != NULL)
+						{
+							if(element.hasChildNodes())
+								element.insertBefore(child, element.getFirstChild());
+							else
+								element.appendChild(child);
+						}
+					}
+
+					// Remove duplicate node
+					parent.removeChild(previous);
+				}
+
+				// Combine next if valid
+				if(next != NULL && next.getNodeType() == DOM::Node::ELEMENT_NODE &&
+					isEqualElement((DOM::Element&)next, element))
+				{
+					while(next.hasChildNodes())
+					{
+						DOM::Node child = next.removeChild(next.getFirstChild());
+						if(child != NULL)
+							element.appendChild(child);
+					}
+
+					// Remove duplicate node
+					parent.removeChild(next);
+				}
+			}
+		}
+	}
+}
\ No newline at end of file