Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731

7 files changed, 17676 insertions, 0 deletions

diff --git a/src/xml/qdom.cpp b/src/xml/qdom.cpp
new file mode 100644
index 000000000..00d2ce7eb
--- /dev/null
+++ b/src/xml/qdom.cpp
@@ -0,0 +1,7092 @@
+/****************************************************************************
+**
+** Implementation of TQDomDocument and related classes.
+**
+** Created : 000518
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the xml module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing retquirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qdom.h"
+
+#ifndef QT_NO_DOM
+
+#include "qxml.h"
+#include "qptrlist.h"
+#include "qdict.h"
+#include "qtextstream.h"
+#include "qtextcodec.h"
+#include "qiodevice.h"
+#include "qregexp.h"
+#include "qbuffer.h"
+
+/*
+  ### old todo comments -- I don't know if they still apply...
+
+  If the document dies, remove all pointers to it from children
+  which can not be deleted at this time.
+
+  If a node dies and has direct children which can not be deleted,
+  then remove the pointer to the parent.
+
+  createElement and friends create double reference counts.
+*/
+
+/*
+  Reference counting:
+
+  Some simple rules:
+  1) If an intern object returns a pointer to another intern object
+     then the reference count of the returned object is not increased.
+  2) If an extern object is created and gets a pointer to some intern
+     object, then the extern object increases the intern objects reference count.
+  3) If an extern object is deleted, then it decreases the reference count
+     on its associated intern object and deletes it if nobody else hold references
+     on the intern object.
+*/
+
+
+/*
+  Helper to split a qualified name in the prefix and local name.
+*/
+static void qt_split_namespace( TQString& prefix, TQString& name, const TQString& qName, bool hasURI )
+{
+    int i = qName.find( ':' );
+    if ( i == -1 ) {
+	if ( hasURI )
+	    prefix = "";
+	else
+	    prefix = TQString::null;
+	name = qName;
+    } else {
+	prefix = qName.left( i );
+	name = qName.mid( i + 1 );
+    }
+}
+
+/*
+  Counter for the TQDomNodeListPrivate timestamps.
+*/
+static volatile long qt_nodeListTime = 0;
+
+/**************************************************************
+ *
+ * Private class declerations
+ *
+ **************************************************************/
+
+class TQDomImplementationPrivate : public TQShared
+{
+public:
+    TQDomImplementationPrivate();
+    ~TQDomImplementationPrivate();
+
+    TQDomImplementationPrivate* clone();
+
+};
+
+class TQDomNodePrivate : public TQShared
+{
+public:
+    TQDomNodePrivate( TQDomDocumentPrivate*, TQDomNodePrivate* parent = 0 );
+    TQDomNodePrivate( TQDomNodePrivate* n, bool deep );
+    virtual ~TQDomNodePrivate();
+
+    TQString nodeName() const { return name; }
+    TQString nodeValue() const { return value; }
+    virtual void setNodeValue( const TQString& v ) { value = v; }
+
+    TQDomDocumentPrivate* ownerDocument();
+    void setOwnerDocument( TQDomDocumentPrivate* doc );
+
+    virtual TQDomNamedNodeMapPrivate* attributes();
+    virtual bool hasAttributes() { return FALSE; }
+    virtual TQDomNodePrivate* insertBefore( TQDomNodePrivate* newChild, TQDomNodePrivate* refChild );
+    virtual TQDomNodePrivate* insertAfter( TQDomNodePrivate* newChild, TQDomNodePrivate* refChild );
+    virtual TQDomNodePrivate* replaceChild( TQDomNodePrivate* newChild, TQDomNodePrivate* oldChild );
+    virtual TQDomNodePrivate* removeChild( TQDomNodePrivate* oldChild );
+    virtual TQDomNodePrivate* appendChild( TQDomNodePrivate* newChild );
+
+    TQDomNodePrivate* namedItem( const TQString& name );
+
+    virtual TQDomNodePrivate* cloneNode( bool deep = TRUE );
+    virtual void normalize();
+    virtual void clear();
+
+    TQDomNodePrivate* parent() { return hasParent ? ownerNode : 0; }
+    void setParent( TQDomNodePrivate *p ) { ownerNode = p; hasParent = TRUE; }
+    void setNoParent() {
+	ownerNode = hasParent ? (TQDomNodePrivate*)ownerDocument() : 0;
+	hasParent = FALSE;
+    }
+
+    // Dynamic cast
+    virtual bool isAttr() { return FALSE; }
+    virtual bool isCDATASection() { return FALSE; }
+    virtual bool isDocumentFragment() { return FALSE; }
+    virtual bool isDocument() { return FALSE; }
+    virtual bool isDocumentType() { return FALSE; }
+    virtual bool isElement() { return FALSE; }
+    virtual bool isEntityReference() { return FALSE; }
+    virtual bool isText() { return FALSE; }
+    virtual bool isEntity() { return FALSE; }
+    virtual bool isNotation() { return FALSE; }
+    virtual bool isProcessingInstruction() { return FALSE; }
+    virtual bool isCharacterData() { return FALSE; }
+    virtual bool isComment() { return FALSE; }
+    virtual TQDomNode::NodeType nodeType() const { return TQDomNode::BaseNode; }
+
+    virtual void save( TQTextStream&, int, int ) const;
+
+    // Variables
+    TQDomNodePrivate* prev;
+    TQDomNodePrivate* next;
+    TQDomNodePrivate* ownerNode; // either the node's parent or the node's owner document
+    TQDomNodePrivate* first;
+    TQDomNodePrivate* last;
+
+    TQString name; // this is the local name if prefix != null
+    TQString value;
+    TQString prefix; // set this only for ElementNode and AttributeNode
+    TQString namespaceURI; // set this only for ElementNode and AttributeNode
+    bool createdWithDom1Interface;
+    bool hasParent;
+};
+
+class TQDomNodeListPrivate : public TQShared
+{
+public:
+    TQDomNodeListPrivate( TQDomNodePrivate* );
+    TQDomNodeListPrivate( TQDomNodePrivate*, const TQString&  );
+    TQDomNodeListPrivate( TQDomNodePrivate*, const TQString&, const TQString&  );
+    virtual ~TQDomNodeListPrivate();
+
+    virtual bool operator== ( const TQDomNodeListPrivate& ) const;
+    virtual bool operator!= ( const TQDomNodeListPrivate& ) const;
+
+    void createList();
+    virtual TQDomNodePrivate* item( int index );
+    virtual uint length() const;
+
+    TQDomNodePrivate* node_impl;
+    TQString tagname;
+    TQString nsURI;
+    TQPtrList<TQDomNodePrivate> list;
+    long timestamp;
+};
+
+class TQDomNamedNodeMapPrivate : public TQShared
+{
+public:
+    TQDomNamedNodeMapPrivate( TQDomNodePrivate* );
+    ~TQDomNamedNodeMapPrivate();
+
+    TQDomNodePrivate* namedItem( const TQString& name ) const;
+    TQDomNodePrivate* namedItemNS( const TQString& nsURI, const TQString& localName ) const;
+    TQDomNodePrivate* setNamedItem( TQDomNodePrivate* arg );
+    TQDomNodePrivate* setNamedItemNS( TQDomNodePrivate* arg );
+    TQDomNodePrivate* removeNamedItem( const TQString& name );
+    TQDomNodePrivate* item( int index ) const;
+    uint length() const;
+    bool contains( const TQString& name ) const;
+    bool containsNS( const TQString& nsURI, const TQString & localName ) const;
+
+    /**
+     * Remove all children from the map.
+     */
+    void clearMap();
+    bool isReadOnly() { return readonly; }
+    void setReadOnly( bool r ) { readonly = r; }
+    bool isAppendToParent() { return appendToParent; }
+    /**
+     * If TRUE, then the node will redirect insert/remove calls
+     * to its parent by calling TQDomNodePrivate::appendChild or removeChild.
+     * In addition the map wont increase or decrease the reference count
+     * of the nodes it contains.
+     *
+     * By default this value is FALSE and the map will handle reference counting
+     * by itself.
+     */
+    void setAppendToParent( bool b ) { appendToParent = b; }
+
+    /**
+     * Creates a copy of the map. It is a deep copy
+     * that means that all children are cloned.
+     */
+    TQDomNamedNodeMapPrivate* clone( TQDomNodePrivate* parent );
+
+    // Variables
+    TQDict<TQDomNodePrivate> map;
+    TQDomNodePrivate* parent;
+    bool readonly;
+    bool appendToParent;
+};
+
+class TQDomDocumentTypePrivate : public TQDomNodePrivate
+{
+public:
+    TQDomDocumentTypePrivate( TQDomDocumentPrivate*, TQDomNodePrivate* parent = 0 );
+    TQDomDocumentTypePrivate( TQDomDocumentTypePrivate* n, bool deep );
+    ~TQDomDocumentTypePrivate();
+    void init();
+
+    // Reimplemented from TQDomNodePrivate
+    TQDomNodePrivate* cloneNode( bool deep = TRUE );
+    TQDomNodePrivate* insertBefore( TQDomNodePrivate* newChild, TQDomNodePrivate* refChild );
+    TQDomNodePrivate* insertAfter( TQDomNodePrivate* newChild, TQDomNodePrivate* refChild );
+    TQDomNodePrivate* replaceChild( TQDomNodePrivate* newChild, TQDomNodePrivate* oldChild );
+    TQDomNodePrivate* removeChild( TQDomNodePrivate* oldChild );
+    TQDomNodePrivate* appendChild( TQDomNodePrivate* newChild );
+
+    bool isDocumentType() { return TRUE; }
+    TQDomNode::NodeType nodeType() const { return TQDomNode::DocumentTypeNode; }
+
+    void save( TQTextStream& s, int, int ) const;
+
+    // Variables
+    TQDomNamedNodeMapPrivate* entities;
+    TQDomNamedNodeMapPrivate* notations;
+    TQString publicId;
+    TQString systemId;
+    TQString internalSubset;
+};
+
+class TQDomDocumentFragmentPrivate : public TQDomNodePrivate
+{
+public:
+    TQDomDocumentFragmentPrivate( TQDomDocumentPrivate*, TQDomNodePrivate* parent = 0 );
+    TQDomDocumentFragmentPrivate( TQDomNodePrivate* n, bool deep );
+    ~TQDomDocumentFragmentPrivate();
+
+    // Reimplemented from TQDomNodePrivate
+    TQDomNodePrivate* cloneNode( bool deep = TRUE );
+    bool isDocumentFragment() { return TRUE; }
+    TQDomNode::NodeType nodeType() const { return TQDomNode::DocumentFragmentNode; }
+};
+
+class TQDomCharacterDataPrivate : public TQDomNodePrivate
+{
+public:
+    TQDomCharacterDataPrivate( TQDomDocumentPrivate*, TQDomNodePrivate* parent, const TQString& data );
+    TQDomCharacterDataPrivate( TQDomCharacterDataPrivate* n, bool deep );
+    ~TQDomCharacterDataPrivate();
+
+    uint dataLength() const;
+    TQString substringData( unsigned long offset, unsigned long count ) const;
+    void appendData( const TQString& arg );
+    void insertData( unsigned long offset, const TQString& arg );
+    void deleteData( unsigned long offset, unsigned long count );
+    void replaceData( unsigned long offset, unsigned long count, const TQString& arg );
+
+    // Reimplemented from TQDomNodePrivate
+    bool isCharacterData() { return TRUE; }
+    TQDomNode::NodeType nodeType() const { return TQDomNode::CharacterDataNode; }
+    TQDomNodePrivate* cloneNode( bool deep = TRUE );
+
+};
+
+class TQDomTextPrivate : public TQDomCharacterDataPrivate
+{
+public:
+    TQDomTextPrivate( TQDomDocumentPrivate*, TQDomNodePrivate* parent, const TQString& value );
+    TQDomTextPrivate( TQDomTextPrivate* n, bool deep );
+    ~TQDomTextPrivate();
+
+    TQDomTextPrivate* splitText( int offset );
+
+    // Reimplemented from TQDomNodePrivate
+    TQDomNodePrivate* cloneNode( bool deep = TRUE );
+    bool isText() { return TRUE; }
+    TQDomNode::NodeType nodeType() const { return TQDomNode::TextNode; }
+    void save( TQTextStream& s, int, int ) const;
+
+};
+
+class TQDomAttrPrivate : public TQDomNodePrivate
+{
+public:
+    TQDomAttrPrivate( TQDomDocumentPrivate*, TQDomNodePrivate*, const TQString& name );
+    TQDomAttrPrivate( TQDomDocumentPrivate*, TQDomNodePrivate*, const TQString& nsURI, const TQString& qName );
+    TQDomAttrPrivate( TQDomAttrPrivate* n, bool deep );
+    ~TQDomAttrPrivate();
+
+    bool specified() const;
+
+    // Reimplemented from TQDomNodePrivate
+    void setNodeValue( const TQString& v );
+    TQDomNodePrivate* cloneNode( bool deep = TRUE );
+    bool isAttr() { return TRUE; }
+    TQDomNode::NodeType nodeType() const { return TQDomNode::AttributeNode; }
+    void save( TQTextStream& s, int, int ) const;
+
+    // Variables
+    bool m_specified;
+};
+
+class TQDomElementPrivate : public TQDomNodePrivate
+{
+public:
+    TQDomElementPrivate( TQDomDocumentPrivate*, TQDomNodePrivate* parent, const TQString& name );
+    TQDomElementPrivate( TQDomDocumentPrivate*, TQDomNodePrivate* parent, const TQString& nsURI, const TQString& qName );
+    TQDomElementPrivate( TQDomElementPrivate* n, bool deep );
+    ~TQDomElementPrivate();
+
+    TQString attribute( const TQString& name,  const TQString& defValue ) const;
+    TQString attributeNS( const TQString& nsURI, const TQString& localName, const TQString& defValue ) const;
+    void setAttribute( const TQString& name, const TQString& value );
+    void setAttributeNS( const TQString& nsURI, const TQString& qName, const TQString& newValue );
+    void removeAttribute( const TQString& name );
+    TQDomAttrPrivate* attributeNode( const TQString& name);
+    TQDomAttrPrivate* attributeNodeNS( const TQString& nsURI, const TQString& localName );
+    TQDomAttrPrivate* setAttributeNode( TQDomAttrPrivate* newAttr );
+    TQDomAttrPrivate* setAttributeNodeNS( TQDomAttrPrivate* newAttr );
+    TQDomAttrPrivate* removeAttributeNode( TQDomAttrPrivate* oldAttr );
+    bool hasAttribute( const TQString& name );
+    bool hasAttributeNS( const TQString& nsURI, const TQString& localName );
+
+    TQString text();
+
+    // Reimplemented from TQDomNodePrivate
+    TQDomNamedNodeMapPrivate* attributes() { return m_attr; }
+    bool hasAttributes() { return ( m_attr->length() > 0 ); }
+    bool isElement() { return TRUE; }
+    TQDomNode::NodeType nodeType() const { return TQDomNode::ElementNode; }
+    TQDomNodePrivate* cloneNode( bool deep = TRUE );
+    void save( TQTextStream& s, int, int ) const;
+
+    // Variables
+    TQDomNamedNodeMapPrivate* m_attr;
+};
+
+
+class TQDomCommentPrivate : public TQDomCharacterDataPrivate
+{
+public:
+    TQDomCommentPrivate( TQDomDocumentPrivate*, TQDomNodePrivate* parent, const TQString& value );
+    TQDomCommentPrivate( TQDomCommentPrivate* n, bool deep );
+    ~TQDomCommentPrivate();
+
+    // Reimplemented from TQDomNodePrivate
+    TQDomNodePrivate* cloneNode( bool deep = TRUE );
+    bool isComment() { return TRUE; }
+    TQDomNode::NodeType nodeType() const { return TQDomNode::CommentNode; }
+    void save( TQTextStream& s, int, int ) const;
+
+};
+
+class TQDomCDATASectionPrivate : public TQDomTextPrivate
+{
+public:
+    TQDomCDATASectionPrivate( TQDomDocumentPrivate*, TQDomNodePrivate* parent, const TQString& value );
+    TQDomCDATASectionPrivate( TQDomCDATASectionPrivate* n, bool deep );
+    ~TQDomCDATASectionPrivate();
+
+    // Reimplemented from TQDomNodePrivate
+    TQDomNodePrivate* cloneNode( bool deep = TRUE );
+    bool isCDATASection() { return TRUE; }
+    TQDomNode::NodeType nodeType() const { return TQDomNode::CDATASectionNode; }
+    void save( TQTextStream& s, int, int ) const;
+
+};
+
+class TQDomNotationPrivate : public TQDomNodePrivate
+{
+public:
+    TQDomNotationPrivate( TQDomDocumentPrivate*, TQDomNodePrivate* parent, const TQString& name,
+			  const TQString& pub, const TQString& sys );
+    TQDomNotationPrivate( TQDomNotationPrivate* n, bool deep );
+    ~TQDomNotationPrivate();
+
+    // Reimplemented from TQDomNodePrivate
+    TQDomNodePrivate* cloneNode( bool deep = TRUE );
+    bool isNotation() { return TRUE; }
+    TQDomNode::NodeType nodeType() const { return TQDomNode::NotationNode; }
+    void save( TQTextStream& s, int, int ) const;
+
+    // Variables
+    TQString m_sys;
+    TQString m_pub;
+};
+
+class TQDomEntityPrivate : public TQDomNodePrivate
+{
+public:
+    TQDomEntityPrivate( TQDomDocumentPrivate*, TQDomNodePrivate* parent, const TQString& name,
+			const TQString& pub, const TQString& sys, const TQString& notation );
+    TQDomEntityPrivate( TQDomEntityPrivate* n, bool deep );
+    ~TQDomEntityPrivate();
+
+    // Reimplemented from TQDomNodePrivate
+    TQDomNodePrivate* cloneNode( bool deep = TRUE );
+    bool isEntity() { return TRUE; }
+    TQDomNode::NodeType nodeType() const { return TQDomNode::EntityNode; }
+    void save( TQTextStream& s, int, int ) const;
+
+    // Variables
+    TQString m_sys;
+    TQString m_pub;
+    TQString m_notationName;
+};
+
+class TQDomEntityReferencePrivate : public TQDomNodePrivate
+{
+public:
+    TQDomEntityReferencePrivate( TQDomDocumentPrivate*, TQDomNodePrivate* parent, const TQString& name );
+    TQDomEntityReferencePrivate( TQDomNodePrivate* n, bool deep );
+    ~TQDomEntityReferencePrivate();
+
+    // Reimplemented from TQDomNodePrivate
+    TQDomNodePrivate* cloneNode( bool deep = TRUE );
+    bool isEntityReference() { return TRUE; }
+    TQDomNode::NodeType nodeType() const { return TQDomNode::EntityReferenceNode; }
+    void save( TQTextStream& s, int, int ) const;
+};
+
+class TQDomProcessingInstructionPrivate : public TQDomNodePrivate
+{
+public:
+    TQDomProcessingInstructionPrivate( TQDomDocumentPrivate*, TQDomNodePrivate* parent, const TQString& target,
+				       const TQString& data);
+    TQDomProcessingInstructionPrivate( TQDomProcessingInstructionPrivate* n, bool deep );
+    ~TQDomProcessingInstructionPrivate();
+
+    // Reimplemented from TQDomNodePrivate
+    TQDomNodePrivate* cloneNode( bool deep = TRUE );
+    bool isProcessingInstruction() { return TRUE; }
+    TQDomNode::NodeType nodeType() const { return TQDomNode::ProcessingInstructionNode; }
+    void save( TQTextStream& s, int, int ) const;
+};
+
+class TQDomDocumentPrivate : public TQDomNodePrivate
+{
+public:
+    TQDomDocumentPrivate();
+    TQDomDocumentPrivate( const TQString& name );
+    TQDomDocumentPrivate( TQDomDocumentTypePrivate* dt );
+    TQDomDocumentPrivate( TQDomDocumentPrivate* n, bool deep );
+    ~TQDomDocumentPrivate();
+
+    bool setContent( TQXmlInputSource *source, bool namespaceProcessing, TQString *errorMsg, int *errorLine, int *errorColumn );
+    bool setContent( TQXmlInputSource *source, TQXmlReader *reader, TQString *errorMsg, int *errorLine, int *errorColumn );
+
+    // Attributes
+    TQDomDocumentTypePrivate* doctype() { return type; };
+    TQDomImplementationPrivate* implementation() { return impl; };
+    TQDomElementPrivate* documentElement();
+
+    // Factories
+    TQDomElementPrivate* createElement( const TQString& tagName );
+    TQDomElementPrivate*	createElementNS( const TQString& nsURI, const TQString& qName );
+    TQDomDocumentFragmentPrivate* createDocumentFragment();
+    TQDomTextPrivate* createTextNode( const TQString& data );
+    TQDomCommentPrivate* createComment( const TQString& data );
+    TQDomCDATASectionPrivate* createCDATASection( const TQString& data );
+    TQDomProcessingInstructionPrivate* createProcessingInstruction( const TQString& target, const TQString& data );
+    TQDomAttrPrivate* createAttribute( const TQString& name );
+    TQDomAttrPrivate* createAttributeNS( const TQString& nsURI, const TQString& qName );
+    TQDomEntityReferencePrivate* createEntityReference( const TQString& name );
+
+    TQDomNodePrivate* importNode( const TQDomNodePrivate* importedNode, bool deep );
+
+    // Reimplemented from TQDomNodePrivate
+    TQDomNodePrivate* cloneNode( bool deep = TRUE );
+    bool isDocument() { return TRUE; }
+    TQDomNode::NodeType nodeType() const { return TQDomNode::DocumentNode; }
+    void clear();
+    void save( TQTextStream&, int, int ) const;
+
+    // Variables
+    TQDomImplementationPrivate* impl;
+    TQDomDocumentTypePrivate* type;
+};
+
+/**************************************************************
+ *
+ * TQDomHandler
+ *
+ **************************************************************/
+
+class TQDomHandler : public TQXmlDefaultHandler
+{
+public:
+    TQDomHandler( TQDomDocumentPrivate* d, bool namespaceProcessing );
+    ~TQDomHandler();
+
+    // content handler
+    bool endDocument();
+    bool startElement( const TQString& nsURI, const TQString& localName, const TQString& qName, const TQXmlAttributes& atts );
+    bool endElement( const TQString& nsURI, const TQString& localName, const TQString& qName );
+    bool characters( const TQString& ch );
+    bool processingInstruction( const TQString& target, const TQString& data );
+    bool skippedEntity( const TQString& name );
+
+    // error handler
+    bool fatalError( const TQXmlParseException& exception );
+
+    // lexical handler
+    bool startCDATA();
+    bool endCDATA();
+    bool startEntity( const TQString & );
+    bool endEntity( const TQString & );
+    bool startDTD( const TQString& name, const TQString& publicId, const TQString& systemId );
+    bool comment( const TQString& ch );
+
+    // decl handler
+    bool externalEntityDecl( const TQString &name, const TQString &publicId, const TQString &systemId ) ;
+
+    // DTD handler
+    bool notationDecl( const TQString & name, const TQString & publicId, const TQString & systemId );
+    bool unparsedEntityDecl( const TQString &name, const TQString &publicId, const TQString &systemId, const TQString &notationName ) ;
+
+    TQString errorMsg;
+    int errorLine;
+    int errorColumn;
+
+private:
+    TQDomDocumentPrivate *doc;
+    TQDomNodePrivate *node;
+    TQString entityName;
+    bool cdata;
+    bool nsProcessing;
+};
+
+/**************************************************************
+ *
+ * TQDomImplementationPrivate
+ *
+ **************************************************************/
+
+TQDomImplementationPrivate::TQDomImplementationPrivate()
+{
+}
+
+TQDomImplementationPrivate::~TQDomImplementationPrivate()
+{
+}
+
+TQDomImplementationPrivate* TQDomImplementationPrivate::clone()
+{
+    TQDomImplementationPrivate* p = new TQDomImplementationPrivate;
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+/**************************************************************
+ *
+ * TQDomImplementation
+ *
+ **************************************************************/
+
+/*!
+    \class TQDomImplementation qdom.h
+    \reentrant
+    \brief The TQDomImplementation class provides information about the
+    features of the DOM implementation.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    This class describes the features that are supported by the DOM
+    implementation. Currently the XML subset of DOM Level 1 and DOM
+    Level 2 Core are supported.
+
+    Normally you will use the function TQDomDocument::implementation()
+    to get the implementation object.
+
+    You can create a new document type with createDocumentType() and a
+    new document with createDocument().
+
+    For further information about the Document Object Model see \link
+    http://www.w3.org/TR/REC-DOM-Level-1/\endlink and \link
+    http://www.w3.org/TR/DOM-Level-2-Core/\endlink. For a more general
+    introduction of the DOM implementation see the TQDomDocument
+    documentation.
+
+    \sa hasFeature()
+*/
+
+/*!
+    Constructs a TQDomImplementation object.
+*/
+TQDomImplementation::TQDomImplementation()
+{
+    impl = 0;
+}
+
+/*!
+    Constructs a copy of \a x.
+*/
+TQDomImplementation::TQDomImplementation( const TQDomImplementation& x )
+{
+    impl = x.impl;
+    if ( impl )
+	impl->ref();
+}
+
+TQDomImplementation::TQDomImplementation( TQDomImplementationPrivate* p )
+{
+    // We want to be co-owners, so increase the reference count
+    impl = p;
+    if (impl)
+    	impl->ref();
+}
+
+/*!
+    Assigns \a x to this DOM implementation.
+*/
+TQDomImplementation& TQDomImplementation::operator= ( const TQDomImplementation& x )
+{
+    if ( x.impl )
+	x.impl->ref(); // avoid x=x
+    if ( impl && impl->deref() )
+	delete impl;
+    impl = x.impl;
+
+    return *this;
+}
+
+/*!
+    Returns TRUE if \a x and this DOM implementation object were
+    created from the same TQDomDocument; otherwise returns FALSE.
+*/
+bool TQDomImplementation::operator==( const TQDomImplementation& x ) const
+{
+    return ( impl == x.impl );
+}
+
+/*!
+    Returns TRUE if \a x and this DOM implementation object were
+    created from different TQDomDocuments; otherwise returns FALSE.
+*/
+bool TQDomImplementation::operator!=( const TQDomImplementation& x ) const
+{
+    return ( impl != x.impl );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+TQDomImplementation::~TQDomImplementation()
+{
+    if ( impl && impl->deref() )
+	delete impl;
+}
+
+/*!
+    The function returns TRUE if TQDom implements the requested \a
+    version of a \a feature; otherwise returns FALSE.
+
+    The currently supported features and their versions:
+    \table
+    \header \i Feature \i Version
+    \row \i XML \i 1.0
+    \endtable
+*/
+bool TQDomImplementation::hasFeature( const TQString& feature, const TQString& version )
+{
+    if ( feature == "XML" ) {
+	if ( version.isEmpty() || version == "1.0" ) {
+	    return TRUE;
+	}
+    }
+    // ### add DOM level 2 features
+    return FALSE;
+}
+
+/*!
+    Creates a document type node for the name \a qName.
+
+    \a publicId specifies the public identifier of the external
+    subset. If you specify TQString::null as the \a publicId, this
+    means that the document type has no public identifier.
+
+    \a systemId specifies the system identifier of the external
+    subset. If you specify TQString::null as the \a systemId, this
+    means that the document type has no system identifier.
+
+    Since you cannot have a public identifier without a system
+    identifier, the public identifier is set to TQString::null if there
+    is no system identifier.
+
+    DOM level 2 does not support any other document type declaration
+    features.
+
+    The only way you can use a document type that was created this
+    way, is in combination with the createDocument() function to
+    create a TQDomDocument with this document type.
+
+    \sa createDocument();
+*/
+TQDomDocumentType TQDomImplementation::createDocumentType( const TQString& qName, const TQString& publicId, const TQString& systemId )
+{
+    TQDomDocumentTypePrivate *dt = new TQDomDocumentTypePrivate( 0 );
+    dt->name = qName;
+    if ( systemId.isNull() ) {
+	dt->publicId = TQString::null;
+	dt->systemId = TQString::null;
+    } else {
+	dt->publicId = publicId;
+	dt->systemId = systemId;
+    }
+    return TQDomDocumentType( dt );
+}
+
+/*!
+    Creates a DOM document with the document type \a doctype. This
+    function also adds a root element node with the qualified name \a
+    qName and the namespace URI \a nsURI.
+*/
+TQDomDocument TQDomImplementation::createDocument( const TQString& nsURI, const TQString& qName, const TQDomDocumentType& doctype )
+{
+    TQDomDocument doc( doctype );
+    TQDomElement root = doc.createElementNS( nsURI, qName );
+    doc.appendChild( root );
+    return doc;
+}
+
+/*!
+    Returns FALSE if the object was created by
+    TQDomDocument::implementation(); otherwise returns TRUE.
+*/
+bool TQDomImplementation::isNull()
+{
+    return ( impl == 0 );
+}
+
+/**************************************************************
+ *
+ * TQDomNodeListPrivate
+ *
+ **************************************************************/
+
+TQDomNodeListPrivate::TQDomNodeListPrivate( TQDomNodePrivate* n_impl )
+{
+    node_impl = n_impl;
+    if ( node_impl )
+	node_impl->ref();
+    timestamp = -1;
+}
+
+TQDomNodeListPrivate::TQDomNodeListPrivate( TQDomNodePrivate* n_impl, const TQString& name )
+{
+    node_impl = n_impl;
+    if ( node_impl )
+	node_impl->ref();
+    tagname = name;
+    timestamp = -1;
+}
+
+TQDomNodeListPrivate::TQDomNodeListPrivate( TQDomNodePrivate* n_impl, const TQString& _nsURI, const TQString& localName )
+{
+    node_impl = n_impl;
+    if ( node_impl )
+	node_impl->ref();
+    tagname = localName;
+    nsURI = _nsURI;
+    timestamp = -1;
+}
+
+TQDomNodeListPrivate::~TQDomNodeListPrivate()
+{
+    if ( node_impl && node_impl->deref() )
+	delete node_impl;
+}
+
+bool TQDomNodeListPrivate::operator== ( const TQDomNodeListPrivate& other ) const
+{
+    return ( node_impl == other.node_impl ) && ( tagname == other.tagname ) ;
+}
+
+bool TQDomNodeListPrivate::operator!= ( const TQDomNodeListPrivate& other ) const
+{
+    return ( node_impl != other.node_impl ) || ( tagname != other.tagname ) ;
+}
+
+void TQDomNodeListPrivate::createList()
+{
+    if ( !node_impl )
+	return;
+    timestamp = qt_nodeListTime;
+    TQDomNodePrivate* p = node_impl->first;
+
+    list.clear();
+    if ( tagname.isNull() ) {
+	while ( p ) {
+	    list.append( p );
+	    p = p->next;
+	}
+    } else if ( nsURI.isNull() ) {
+	while ( p && p != node_impl ) {
+	    if ( p->isElement() && p->nodeName() == tagname ) {
+		list.append( p );
+	    }
+	    if ( p->first )
+		p = p->first;
+	    else if ( p->next )
+		p = p->next;
+	    else {
+		p = p->parent();
+		while ( p && p != node_impl && !p->next )
+		    p = p->parent();
+		if ( p && p != node_impl )
+		    p = p->next;
+	    }
+	}
+    } else {
+	while ( p && p != node_impl ) {
+	    if ( p->isElement() && p->name==tagname && p->namespaceURI==nsURI ) {
+		list.append( p );
+	    }
+	    if ( p->first )
+		p = p->first;
+	    else if ( p->next )
+		p = p->next;
+	    else {
+		p = p->parent();
+		while ( p && p != node_impl && !p->next )
+		    p = p->parent();
+		if ( p && p != node_impl )
+		    p = p->next;
+	    }
+	}
+    }
+}
+
+TQDomNodePrivate* TQDomNodeListPrivate::item( int index )
+{
+    if ( !node_impl )
+	return 0;
+    if ( timestamp < qt_nodeListTime )
+	createList();
+    return list.at( index );
+}
+
+uint TQDomNodeListPrivate::length() const
+{
+    if ( !node_impl )
+	return 0;
+    if ( timestamp < qt_nodeListTime ) {
+	TQDomNodeListPrivate *that = (TQDomNodeListPrivate*)this;
+	that->createList();
+    }
+    return list.count();
+}
+
+/**************************************************************
+ *
+ * TQDomNodeList
+ *
+ **************************************************************/
+
+/*!
+    \class TQDomNodeList qdom.h
+    \reentrant
+    \brief The TQDomNodeList class is a list of TQDomNode objects.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    Lists can be obtained by TQDomDocument::elementsByTagName() and
+    TQDomNode::childNodes(). The Document Object Model (DOM) retquires
+    these lists to be "live": whenever you change the underlying
+    document, the contents of the list will get updated.
+
+    You can get a particular node from the list with item(). The
+    number of items in the list is returned by count() (and by
+    length()).
+
+    For further information about the Document Object Model see \link
+    http://www.w3.org/TR/REC-DOM-Level-1/\endlink and \link
+    http://www.w3.org/TR/DOM-Level-2-Core/\endlink. For a more general
+    introduction of the DOM implementation see the TQDomDocument
+    documentation.
+
+    \sa TQDomNode::childNodes() TQDomDocument::elementsByTagName()
+*/
+
+/*!
+    Creates an empty node list.
+*/
+TQDomNodeList::TQDomNodeList()
+{
+    impl = 0;
+}
+
+TQDomNodeList::TQDomNodeList( TQDomNodeListPrivate* p )
+{
+    impl = p;
+}
+
+/*!
+    Constructs a copy of \a n.
+*/
+TQDomNodeList::TQDomNodeList( const TQDomNodeList& n )
+{
+    impl = n.impl;
+    if ( impl )
+	impl->ref();
+}
+
+/*!
+    Assigns \a n to this node list.
+*/
+TQDomNodeList& TQDomNodeList::operator= ( const TQDomNodeList& n )
+{
+    if ( n.impl )
+	n.impl->ref();
+    if ( impl && impl->deref() )
+	delete impl;
+    impl = n.impl;
+
+    return *this;
+}
+
+/*!
+    Returns TRUE if the node list \a n and this node list are equal;
+    otherwise returns FALSE.
+*/
+bool TQDomNodeList::operator== ( const TQDomNodeList& n ) const
+{
+    if ( impl == n.impl )
+	return TRUE;
+    if ( !impl || !n.impl )
+	return FALSE;
+    return (*impl == *n.impl);
+}
+
+/*!
+    Returns TRUE the node list \a n and this node list are not equal;
+    otherwise returns FALSE.
+*/
+bool TQDomNodeList::operator!= ( const TQDomNodeList& n ) const
+{
+    return !operator==(n);
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+TQDomNodeList::~TQDomNodeList()
+{
+    if ( impl && impl->deref() )
+	delete impl;
+}
+
+/*!
+    Returns the node at position \a index.
+
+    If \a index is negative or if \a index >= length() then a null
+    node is returned (i.e. a node for which TQDomNode::isNull() returns
+    TRUE).
+
+    \sa count()
+*/
+TQDomNode TQDomNodeList::item( int index ) const
+{
+    if ( !impl )
+	return TQDomNode();
+
+    return TQDomNode( impl->item( index ) );
+}
+
+/*!
+    Returns the number of nodes in the list.
+
+    This function is the same as count().
+*/
+uint TQDomNodeList::length() const
+{
+    if ( !impl )
+	return 0;
+    return impl->length();
+}
+
+/*!
+    \fn uint TQDomNodeList::count() const
+
+    Returns the number of nodes in the list.
+
+    This function is the same as length().
+*/
+
+
+/**************************************************************
+ *
+ * TQDomNodePrivate
+ *
+ **************************************************************/
+
+inline void TQDomNodePrivate::setOwnerDocument( TQDomDocumentPrivate* doc )
+{
+    ownerNode = doc;
+    hasParent = FALSE;
+}
+
+TQDomNodePrivate::TQDomNodePrivate( TQDomDocumentPrivate* doc, TQDomNodePrivate *par )
+{
+    if ( par )
+	setParent( par );
+    else
+	setOwnerDocument( doc );
+    prev = 0;
+    next = 0;
+    first = 0;
+    last = 0;
+    createdWithDom1Interface = TRUE;
+}
+
+TQDomNodePrivate::TQDomNodePrivate( TQDomNodePrivate* n, bool deep )
+{
+    setOwnerDocument( n->ownerDocument() );
+    prev = 0;
+    next = 0;
+    first = 0;
+    last = 0;
+
+    name = n->name;
+    value = n->value;
+    prefix = n->prefix;
+    namespaceURI = n->namespaceURI;
+    createdWithDom1Interface = n->createdWithDom1Interface;
+
+    if ( !deep )
+	return;
+
+    for ( TQDomNodePrivate* x = n->first; x; x = x->next )
+	appendChild( x->cloneNode( TRUE ) );
+}
+
+TQDomNodePrivate::~TQDomNodePrivate()
+{
+    TQDomNodePrivate* p = first;
+    TQDomNodePrivate* n;
+
+    while ( p ) {
+	n = p->next;
+	if ( p->deref() )
+	    delete p;
+	else
+	    p->setNoParent();
+	p = n;
+    }
+
+    first = 0;
+    last = 0;
+}
+
+void TQDomNodePrivate::clear()
+{
+    TQDomNodePrivate* p = first;
+    TQDomNodePrivate* n;
+
+    while ( p ) {
+	n = p->next;
+	if ( p->deref() )
+	    delete p;
+	p = n;
+    }
+
+    first = 0;
+    last = 0;
+}
+
+TQDomNodePrivate* TQDomNodePrivate::namedItem( const TQString& n )
+{
+    TQDomNodePrivate* p = first;
+    while ( p ) {
+	if ( p->nodeName() == n )
+	    return p;
+	p = p->next;
+    }
+
+    return 0;
+}
+
+TQDomNamedNodeMapPrivate* TQDomNodePrivate::attributes()
+{
+    return 0;
+}
+
+TQDomNodePrivate* TQDomNodePrivate::insertBefore( TQDomNodePrivate* newChild, TQDomNodePrivate* refChild )
+{
+    // Error check
+    if ( !newChild )
+	return 0;
+
+    // Error check
+    if ( newChild == refChild )
+	return 0;
+
+    // Error check
+    if ( refChild && refChild->parent() != this )
+	return 0;
+
+    // "mark lists as dirty"
+    qt_nodeListTime++;
+
+    // Special handling for inserting a fragment. We just insert
+    // all elements of the fragment instead of the fragment itself.
+    if ( newChild->isDocumentFragment() ) {
+	// Fragment is empty ?
+	if ( newChild->first == 0 )
+	    return newChild;
+
+	// New parent
+	TQDomNodePrivate* n = newChild->first;
+	while ( n )  {
+	    n->setParent( this );
+	    n = n->next;
+	}
+
+	// Insert at the beginning ?
+	if ( !refChild || refChild->prev == 0 ) {
+	    if ( first )
+		first->prev = newChild->last;
+	    newChild->last->next = first;
+	    if ( !last )
+		last = newChild->last;
+	    first = newChild->first;
+	} else {
+	    // Insert in the middle
+	    newChild->last->next = refChild;
+	    newChild->first->prev = refChild->prev;
+	    refChild->prev->next = newChild->first;
+	    refChild->prev = newChild->last;
+	}
+
+	// No need to increase the reference since TQDomDocumentFragment
+	// does not decrease the reference.
+
+	// Remove the nodes from the fragment
+	newChild->first = 0;
+	newChild->last = 0;
+	return newChild;
+    }
+
+    // No more errors can occur now, so we take
+    // ownership of the node.
+    newChild->ref();
+
+    if ( newChild->parent() )
+	newChild->parent()->removeChild( newChild );
+
+    newChild->setParent( this );
+
+    if ( !refChild ) {
+	if ( first )
+	    first->prev = newChild;
+	newChild->next = first;
+	if ( !last )
+	    last = newChild;
+	first = newChild;
+	return newChild;
+    }
+
+    if ( refChild->prev == 0 ) {
+	if ( first )
+	    first->prev = newChild;
+	newChild->next = first;
+	if ( !last )
+	    last = newChild;
+	first = newChild;
+	return newChild;
+    }
+
+    newChild->next = refChild;
+    newChild->prev = refChild->prev;
+    refChild->prev->next = newChild;
+    refChild->prev = newChild;
+
+    return newChild;
+}
+
+TQDomNodePrivate* TQDomNodePrivate::insertAfter( TQDomNodePrivate* newChild, TQDomNodePrivate* refChild )
+{
+    // Error check
+    if ( !newChild )
+	return 0;
+
+    // Error check
+    if ( newChild == refChild )
+	return 0;
+
+    // Error check
+    if ( refChild && refChild->parent() != this )
+	return 0;
+
+    // "mark lists as dirty"
+    qt_nodeListTime++;
+
+    // Special handling for inserting a fragment. We just insert
+    // all elements of the fragment instead of the fragment itself.
+    if ( newChild->isDocumentFragment() ) {
+	// Fragment is empty ?
+	if ( newChild->first == 0 )
+	    return newChild;
+
+	// New parent
+	TQDomNodePrivate* n = newChild->first;
+	while ( n ) {
+	    n->setParent( this );
+	    n = n->next;
+	}
+
+	// Insert at the end
+	if ( !refChild || refChild->next == 0 ) {
+	    if ( last )
+		last->next = newChild->first;
+	    newChild->first->prev = last;
+	    if ( !first )
+		first = newChild->first;
+	    last = newChild->last;
+	} else { // Insert in the middle
+	    newChild->first->prev = refChild;
+	    newChild->last->next = refChild->next;
+	    refChild->next->prev = newChild->last;
+	    refChild->next = newChild->first;
+	}
+
+	// No need to increase the reference since TQDomDocumentFragment
+	// does not decrease the reference.
+
+	// Remove the nodes from the fragment
+	newChild->first = 0;
+	newChild->last = 0;
+	return newChild;
+    }
+
+    // Release new node from its current parent
+    if ( newChild->parent() )
+	newChild->parent()->removeChild( newChild );
+
+    // No more errors can occur now, so we take
+    // ownership of the node
+    newChild->ref();
+
+    newChild->setParent( this );
+
+    // Insert at the end
+    if ( !refChild ) {
+	if ( last )
+	    last->next = newChild;
+	newChild->prev = last;
+	if ( !first )
+	    first = newChild;
+	last = newChild;
+	return newChild;
+    }
+
+    if ( refChild->next == 0 ) {
+	if ( last )
+	    last->next = newChild;
+	newChild->prev = last;
+	if ( !first )
+	    first = newChild;
+	last = newChild;
+	return newChild;
+    }
+
+    newChild->prev = refChild;
+    newChild->next = refChild->next;
+    refChild->next->prev = newChild;
+    refChild->next = newChild;
+
+    return newChild;
+}
+
+TQDomNodePrivate* TQDomNodePrivate::replaceChild( TQDomNodePrivate* newChild, TQDomNodePrivate* oldChild )
+{
+    if ( oldChild->parent() != this )
+	return 0;
+    if ( !newChild || !oldChild )
+	return 0;
+    if ( newChild == oldChild )
+	return 0;
+
+    // mark lists as dirty
+    qt_nodeListTime++;
+
+    // Special handling for inserting a fragment. We just insert
+    // all elements of the fragment instead of the fragment itself.
+    if ( newChild->isDocumentFragment() ) {
+	// Fragment is empty ?
+	if ( newChild->first == 0 )
+	    return newChild;
+
+	// New parent
+	TQDomNodePrivate* n = newChild->first;
+	while ( n ) {
+	    n->setParent( this );
+	    n = n->next;
+	}
+
+
+	if ( oldChild->next )
+	    oldChild->next->prev = newChild->last;
+	if ( oldChild->prev )
+	    oldChild->prev->next = newChild->first;
+
+	newChild->last->next = oldChild->next;
+	newChild->first->prev = oldChild->prev;
+
+	if ( first == oldChild )
+	    first = newChild->first;
+	if ( last == oldChild )
+	    last = newChild->last;
+
+	oldChild->setNoParent();
+	oldChild->next = 0;
+	oldChild->prev = 0;
+
+	// No need to increase the reference since TQDomDocumentFragment
+	// does not decrease the reference.
+
+	// Remove the nodes from the fragment
+	newChild->first = 0;
+	newChild->last = 0;
+
+	// We are no longer interested in the old node
+	if ( oldChild ) oldChild->deref();
+
+	return oldChild;
+    }
+
+    // No more errors can occur now, so we take
+    // ownership of the node
+    newChild->ref();
+
+    // Release new node from its current parent
+    if ( newChild->parent() )
+	newChild->parent()->removeChild( newChild );
+
+    newChild->setParent( this );
+
+    if ( oldChild->next )
+	oldChild->next->prev = newChild;
+    if ( oldChild->prev )
+	oldChild->prev->next = newChild;
+
+    newChild->next = oldChild->next;
+    newChild->prev = oldChild->prev;
+
+    if ( first == oldChild )
+	first = newChild;
+    if ( last == oldChild )
+	last = newChild;
+
+    oldChild->setNoParent();
+    oldChild->next = 0;
+    oldChild->prev = 0;
+
+    // We are no longer interested in the old node
+    if ( oldChild ) oldChild->deref();
+
+    return oldChild;
+}
+
+TQDomNodePrivate* TQDomNodePrivate::removeChild( TQDomNodePrivate* oldChild )
+{
+    // Error check
+    if ( oldChild->parent() != this )
+	return 0;
+
+    // "mark lists as dirty"
+    qt_nodeListTime++;
+
+    // Perhaps oldChild was just created with "createElement" or that. In this case
+    // its parent is TQDomDocument but it is not part of the documents child list.
+    if ( oldChild->next == 0 && oldChild->prev == 0 && first != oldChild )
+	return 0;
+
+    if ( oldChild->next )
+	oldChild->next->prev = oldChild->prev;
+    if ( oldChild->prev )
+	oldChild->prev->next = oldChild->next;
+
+    if ( last == oldChild )
+	last = oldChild->prev;
+    if ( first == oldChild )
+	first = oldChild->next;
+
+    oldChild->setNoParent();
+    oldChild->next = 0;
+    oldChild->prev = 0;
+
+    // We are no longer interested in the old node
+    if ( oldChild ) oldChild->deref();
+
+    return oldChild;
+}
+
+TQDomNodePrivate* TQDomNodePrivate::appendChild( TQDomNodePrivate* newChild )
+{
+    // No reference manipulation needed. Done in insertAfter.
+    return insertAfter( newChild, 0 );
+}
+
+TQDomDocumentPrivate* TQDomNodePrivate::ownerDocument()
+{
+    TQDomNodePrivate* p = this;
+    while ( p && !p->isDocument() ) {
+	if ( !p->hasParent )
+	    return (TQDomDocumentPrivate*)p->ownerNode;
+	p = p->parent();
+    }
+
+    return (TQDomDocumentPrivate*)p;
+}
+
+TQDomNodePrivate* TQDomNodePrivate::cloneNode( bool deep )
+{
+    TQDomNodePrivate* p = new TQDomNodePrivate( this, deep );
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+static void qNormalizeNode( TQDomNodePrivate* n )
+{
+    TQDomNodePrivate* p = n->first;
+    TQDomTextPrivate* t = 0;
+
+    while ( p ) {
+	if ( p->isText() ) {
+	    if ( t ) {
+		TQDomNodePrivate* tmp = p->next;
+		t->appendData( p->nodeValue() );
+		n->removeChild( p );
+		p = tmp;
+	    } else {
+		t = (TQDomTextPrivate*)p;
+		p = p->next;
+	    }
+	} else {
+	    p = p->next;
+	    t = 0;
+	}
+    }
+}
+void TQDomNodePrivate::normalize()
+{
+    // ### This one has moved from TQDomElementPrivate to this position. It is
+    // not tested.
+    qNormalizeNode( this );
+}
+
+void TQDomNodePrivate::save( TQTextStream& s, int depth, int indent ) const
+{
+    const TQDomNodePrivate* n = first;
+    while ( n ) {
+	n->save( s, depth, indent );
+	n = n->next;
+    }
+}
+
+/**************************************************************
+ *
+ * TQDomNode
+ *
+ **************************************************************/
+
+#define IMPL ((TQDomNodePrivate*)impl)
+
+/*!
+    \class TQDomNode qdom.h
+    \reentrant
+    \brief The TQDomNode class is the base class for all the nodes in a DOM tree.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    Many functions in the DOM return a TQDomNode.
+
+    You can find out the type of a node using isAttr(),
+    isCDATASection(), isDocumentFragment(), isDocument(),
+    isDocumentType(), isElement(), isEntityReference(), isText(),
+    isEntity(), isNotation(), isProcessingInstruction(),
+    isCharacterData() and isComment().
+
+    A TQDomNode can be converted into one of its subclasses using
+    toAttr(), toCDATASection(), toDocumentFragment(), toDocument(),
+    toDocumentType(), toElement(), toEntityReference(), toText(),
+    toEntity(), toNotation(), toProcessingInstruction(),
+    toCharacterData() or toComment(). You can convert a node to a null
+    node with clear().
+
+    Copies of the TQDomNode class share their data using explicit
+    sharing. This means that modifying one node will change all
+    copies. This is especially useful in combination with functions
+    which return a TQDomNode, e.g. firstChild(). You can make an
+    independent (deep) copy of the node with cloneNode().
+
+    Nodes are inserted with insertBefore(), insertAfter() or
+    appendChild(). You can replace one node with another using
+    replaceChild() and remove a node with removeChild().
+
+    To traverse nodes use firstChild() to get a node's first child (if
+    any), and nextSibling() to traverse. TQDomNode also provides
+    lastChild(), previousSibling() and parentNode(). To find the first
+    child node with a particular node name use namedItem().
+
+    To find out if a node has children use hasChildNodes() and to get
+    a list of all of a node's children use childNodes().
+
+    The node's name and value (the meaning of which varies depending
+    on its type) is returned by nodeName() and nodeValue()
+    respectively. The node's type is returned by nodeType(). The
+    node's value can be set with setNodeValue().
+
+    The document to which the node belongs is returned by
+    ownerDocument().
+
+    Adjacent TQDomText nodes can be merged into a single node with
+    normalize().
+
+    \l TQDomElement nodes have attributes which can be retrieved with
+    attributes().
+
+    TQDomElement and TQDomAttr nodes can have namespaces which can be
+    retrieved with namespaceURI(). Their local name is retrieved with
+    localName(), and their prefix with prefix(). The prefix can be set
+    with setPrefix().
+
+    You can write the XML representation of the node to a text stream
+    with save().
+
+    The following example looks for the first element in an XML document and
+    prints the names of all the elements that are its direct children.
+    \code
+    TQDomDocument d;
+    d.setContent( someXML );
+    TQDomNode n = d.firstChild();
+    while ( !n.isNull() ) {
+	if ( n.isElement() ) {
+	    TQDomElement e = n.toElement();
+	    cout << "Element name: " << e.tagName() << endl;
+	    break;
+	}
+	n = n.nextSibling();
+    }
+    \endcode
+
+    For further information about the Document Object Model see \link
+    http://www.w3.org/TR/REC-DOM-Level-1/\endlink and \link
+    http://www.w3.org/TR/DOM-Level-2-Core/\endlink. For a more general
+    introduction of the DOM implementation see the TQDomDocument
+    documentation.
+*/
+
+/*!
+    Constructs a \link isNull() null\endlink node.
+*/
+TQDomNode::TQDomNode()
+{
+    impl = 0;
+}
+
+/*!
+    Constructs a copy of \a n.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomNode::TQDomNode( const TQDomNode& n )
+{
+    impl = n.impl;
+    if ( impl ) impl->ref();
+}
+
+/*!  \internal
+  Constructs a new node for the data \a n.
+*/
+TQDomNode::TQDomNode( TQDomNodePrivate* n )
+{
+    impl = n;
+    if ( impl ) impl->ref();
+}
+
+/*!
+    Assigns a copy of \a n to this DOM node.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomNode& TQDomNode::operator= ( const TQDomNode& n )
+{
+    if ( n.impl ) n.impl->ref();
+    if ( impl && impl->deref() ) delete impl;
+    impl = n.impl;
+
+    return *this;
+}
+
+/*!
+    Returns TRUE if \a n and this DOM node are equal; otherwise
+    returns FALSE.
+*/
+bool TQDomNode::operator== ( const TQDomNode& n ) const
+{
+    return ( impl == n.impl );
+}
+
+/*!
+    Returns TRUE if \a n and this DOM node are not equal; otherwise
+    returns FALSE.
+*/
+bool TQDomNode::operator!= ( const TQDomNode& n ) const
+{
+    return ( impl != n.impl );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+TQDomNode::~TQDomNode()
+{
+    if ( impl && impl->deref() ) delete impl;
+}
+
+/*!
+    Returns the name of the node.
+
+    The meaning of the name depends on the subclass:
+    \table
+    \header \i Name \i Meaning
+    \row \i TQDomAttr \i The name of the attribute
+    \row \i TQDomCDATASection \i The string "#cdata-section"
+    \row \i TQDomComment \i The string "#comment"
+    \row \i TQDomDocument \i The string "#document"
+    \row \i TQDomDocumentFragment \i The string "#document-fragment"
+    \row \i TQDomDocumentType \i The name of the document type
+    \row \i TQDomElement \i The tag name
+    \row \i TQDomEntity \i The name of the entity
+    \row \i TQDomEntityReference \i The name of the referenced entity
+    \row \i TQDomNotation \i The name of the notation
+    \row \i TQDomProcessingInstruction \i The target of the processing instruction
+    \row \i TQDomText \i The string "#text"
+    \endtable
+
+    \sa nodeValue()
+*/
+TQString TQDomNode::nodeName() const
+{
+    if ( !impl )
+	return TQString::null;
+
+    if ( !IMPL->prefix.isEmpty() )
+	return IMPL->prefix + ":" + IMPL->name;
+    return IMPL->name;
+}
+
+/*!
+    Returns the value of the node.
+
+    The meaning of the value depends on the subclass:
+    \table
+    \header \i Name \i Meaning
+    \row \i TQDomAttr \i The attribute value
+    \row \i TQDomCDATASection \i The content of the CDATA section
+    \row \i TQDomComment \i The comment
+    \row \i TQDomProcessingInstruction \i The data of the processing intruction
+    \row \i TQDomText \i The text
+    \endtable
+
+    All the other subclasses do not have a node value and will return
+    TQString::null.
+
+    \sa setNodeValue() nodeName()
+*/
+TQString TQDomNode::nodeValue() const
+{
+    if ( !impl )
+	return TQString::null;
+    return IMPL->value;
+}
+
+/*!
+    Sets the node's value to \a v.
+
+    \sa nodeValue()
+*/
+void TQDomNode::setNodeValue( const TQString& v )
+{
+    if ( !impl )
+	return;
+    IMPL->setNodeValue( v );
+}
+
+/*!
+    \enum TQDomNode::NodeType
+
+    This enum defines the type of the node:
+    \value ElementNode
+    \value AttributeNode
+    \value TextNode
+    \value CDATASectionNode
+    \value EntityReferenceNode
+    \value EntityNode
+    \value ProcessingInstructionNode
+    \value CommentNode
+    \value DocumentNode
+    \value DocumentTypeNode
+    \value DocumentFragmentNode
+    \value NotationNode
+    \value BaseNode  A TQDomNode object, i.e. not a TQDomNode subclass.
+    \value CharacterDataNode
+*/
+
+/*!
+    Returns the type of the node.
+
+    \sa toAttr(), toCDATASection(), toDocumentFragment(),
+    toDocument() toDocumentType(), toElement(), toEntityReference(),
+    toText(), toEntity() toNotation(), toProcessingInstruction(),
+    toCharacterData(), toComment()
+*/
+TQDomNode::NodeType TQDomNode::nodeType() const
+{
+    if ( !impl )
+	return TQDomNode::BaseNode;
+    return IMPL->nodeType();
+}
+
+/*!
+    Returns the parent node. If this node has no parent, a null node
+    is returned (i.e. a node for which isNull() returns TRUE).
+*/
+TQDomNode TQDomNode::parentNode() const
+{
+    if ( !impl )
+	return TQDomNode();
+    return TQDomNode( IMPL->parent() );
+}
+
+/*!
+    Returns a list of all direct child nodes.
+
+    Most often you will call this function on a TQDomElement object.
+
+    For example, if the XML document looks like this:
+    \code
+    <body>
+    <h1>Heading</h1>
+    <p>Hello <b>you</b></p>
+    </body>
+    \endcode
+    Then the list of child nodes for the "body"-element will contain
+    the node created by the &lt;h1&gt; tag and the node created by the
+    &lt;p&gt; tag.
+
+    The nodes in the list are not copied; so changing the nodes in the
+    list will also change the children of this node.
+
+    \sa firstChild() lastChild()
+*/
+TQDomNodeList TQDomNode::childNodes() const
+{
+    if ( !impl )
+	return TQDomNodeList();
+    return TQDomNodeList( new TQDomNodeListPrivate( impl ) );
+}
+
+/*!
+    Returns the first child of the node. If there is no child node, a
+    \link isNull() null node\endlink is returned. Changing the
+    returned node will also change the node in the document tree.
+
+    \sa lastChild() childNodes()
+*/
+TQDomNode TQDomNode::firstChild() const
+{
+    if ( !impl )
+	return TQDomNode();
+    return TQDomNode( IMPL->first );
+}
+
+/*!
+    Returns the last child of the node. If there is no child node, a
+    \link isNull() null node\endlink is returned. Changing the
+    returned node will also change the node in the document tree.
+
+    \sa firstChild() childNodes()
+*/
+TQDomNode TQDomNode::lastChild() const
+{
+    if ( !impl )
+	return TQDomNode();
+    return TQDomNode( IMPL->last );
+}
+
+/*!
+    Returns the previous sibling in the document tree. Changing the
+    returned node will also change the node in the document tree.
+
+    For example, if you have XML like this:
+    \code
+    <h1>Heading</h1>
+    <p>The text...</p>
+    <h2>Next heading</h2>
+    \endcode
+    and this TQDomNode represents the &lt;p&gt; tag, previousSibling()
+    will return the node representing the &lt;h1&gt; tag.
+
+    \sa nextSibling()
+*/
+TQDomNode TQDomNode::previousSibling() const
+{
+    if ( !impl )
+	return TQDomNode();
+    return TQDomNode( IMPL->prev );
+}
+
+/*!
+    Returns the next sibling in the document tree. Changing the
+    returned node will also change the node in the document tree.
+
+    If you have XML like this:
+    \code
+    <h1>Heading</h1>
+    <p>The text...</p>
+    <h2>Next heading</h2>
+    \endcode
+    and this TQDomNode represents the &lt;p&gt; tag, nextSibling() will
+    return the node representing the &lt;h2&gt; tag.
+
+    \sa previousSibling()
+*/
+TQDomNode TQDomNode::nextSibling() const
+{
+    if ( !impl )
+	return TQDomNode();
+    return TQDomNode( IMPL->next );
+}
+
+/*!
+    Returns a named node map of all attributes. Attributes are only
+    provided for \l{TQDomElement}s.
+
+    Changing the attributes in the map will also change the attributes
+    of this TQDomNode.
+*/
+TQDomNamedNodeMap TQDomNode::attributes() const
+{
+    if ( !impl )
+	return TQDomNamedNodeMap();
+
+    return TQDomNamedNodeMap( impl->attributes() );
+}
+
+/*!
+    Returns the document to which this node belongs.
+*/
+TQDomDocument TQDomNode::ownerDocument() const
+{
+    if ( !impl )
+	return TQDomDocument();
+    return TQDomDocument( IMPL->ownerDocument() );
+}
+
+/*!
+    Creates a deep (not shallow) copy of the TQDomNode.
+
+    If \a deep is TRUE, then the cloning is done recursively which
+    means that all the node's children are deep copied too. If \a deep
+    is FALSE only the node itself is copied and the copy will have no
+    child nodes.
+*/
+TQDomNode TQDomNode::cloneNode( bool deep ) const
+{
+    if ( !impl )
+	return TQDomNode();
+    return TQDomNode( IMPL->cloneNode( deep ) );
+}
+
+/*!
+    Calling normalize() on an element converts all its children into a
+    standard form. This means that adjacent TQDomText objects will be
+    merged into a single text object (TQDomCDATASection nodes are not
+    merged).
+*/
+void TQDomNode::normalize()
+{
+    if ( !impl )
+	return;
+    IMPL->normalize();
+}
+
+/*!
+    Returns TRUE if the DOM implementation implements the feature \a
+    feature and this feature is supported by this node in the version
+    \a version; otherwise returns FALSE.
+
+    \sa TQDomImplementation::hasFeature()
+*/
+bool TQDomNode::isSupported( const TQString& feature, const TQString& version ) const
+{
+    TQDomImplementation i;
+    return i.hasFeature( feature, version );
+}
+
+/*!
+    Returns the namespace URI of this node or TQString::null if the
+    node has no namespace URI.
+
+    Only nodes of type \link TQDomNode::NodeType ElementNode\endlink or
+    \link TQDomNode::NodeType AttributeNode\endlink can have
+    namespaces. A namespace URI must be specified at creation time and
+    cannot be changed later.
+
+    \sa prefix() localName() TQDomDocument::createElementNS()
+    TQDomDocument::createAttributeNS()
+*/
+TQString TQDomNode::namespaceURI() const
+{
+    if ( !impl )
+	return TQString::null;
+    return IMPL->namespaceURI;
+}
+
+/*!
+    Returns the namespace prefix of the node or TQString::null if the
+    node has no namespace prefix.
+
+    Only nodes of type \link TQDomNode::NodeType ElementNode\endlink or
+    \link TQDomNode::NodeType AttributeNode\endlink can have
+    namespaces. A namespace prefix must be specified at creation time.
+    If a node was created with a namespace prefix, you can change it
+    later with setPrefix().
+
+    If you create an element or attribute with
+    TQDomDocument::createElement() or TQDomDocument::createAttribute(),
+    the prefix will be TQString::null. If you use
+    TQDomDocument::createElementNS() or
+    TQDomDocument::createAttributeNS() instead, the prefix will not be
+    TQString::null; but it might be an empty string if the name does
+    not have a prefix.
+
+    \sa setPrefix() localName() namespaceURI()
+    TQDomDocument::createElementNS() TQDomDocument::createAttributeNS()
+*/
+TQString TQDomNode::prefix() const
+{
+    if ( !impl )
+	return TQString::null;
+    return IMPL->prefix;
+}
+
+/*!
+    If the node has a namespace prefix, this function changes the
+    namespace prefix of the node to \a pre. Otherwise this function
+    does nothing.
+
+    Only nodes of type \link TQDomNode::NodeType ElementNode\endlink or
+    \link TQDomNode::NodeType AttributeNode\endlink can have
+    namespaces. A namespace prefix must have be specified at creation
+    time; it is not possible to add a namespace prefix afterwards.
+
+    \sa prefix() localName() namespaceURI()
+    TQDomDocument::createElementNS() TQDomDocument::createAttributeNS()
+*/
+void TQDomNode::setPrefix( const TQString& pre )
+{
+    if ( !impl || IMPL->prefix.isNull() )
+	return;
+    if ( isAttr() || isElement() )
+	IMPL->prefix = pre;
+}
+
+/*!
+    If the node uses namespaces, this function returns the local name
+    of the node; otherwise it returns TQString::null.
+
+    Only nodes of type \link TQDomNode::NodeType ElementNode\endlink or
+    \link TQDomNode::NodeType AttributeNode\endlink can have
+    namespaces. A namespace must have been specified at creation time;
+    it is not possible to add a namespace afterwards.
+
+    \sa prefix() namespaceURI() TQDomDocument::createElementNS()
+    TQDomDocument::createAttributeNS()
+*/
+TQString TQDomNode::localName() const
+{
+    if ( !impl || IMPL->createdWithDom1Interface )
+	return TQString::null;
+    return IMPL->name;
+}
+
+/*!
+    Returns TRUE if the node has attributes; otherwise returns FALSE.
+
+    \sa attributes()
+*/
+bool TQDomNode::hasAttributes() const
+{
+    if ( !impl )
+	return FALSE;
+    return IMPL->hasAttributes();
+}
+
+/*!
+    Inserts the node \a newChild before the child node \a refChild.
+    \a refChild must be a direct child of this node. If \a refChild is
+    \link isNull() null\endlink then \a newChild is inserted as the
+    node's first child.
+
+    If \a newChild is the child of another node, it is reparented to
+    this node. If \a newChild is a child of this node, then its
+    position in the list of children is changed.
+
+    If \a newChild is a TQDomDocumentFragment, then the children of the
+    fragment are removed from the fragment and inserted before \a
+    refChild.
+
+    Returns a new reference to \a newChild on success or a \link
+    isNull() null node\endlink on failure.
+
+    \sa insertAfter() replaceChild() removeChild() appendChild()
+*/
+TQDomNode TQDomNode::insertBefore( const TQDomNode& newChild, const TQDomNode& refChild )
+{
+    if ( !impl ) {
+        if (nodeType() == DocumentNode)
+            impl = new TQDomDocumentPrivate;
+        else
+            return TQDomNode();
+    }
+    return TQDomNode( IMPL->insertBefore( newChild.impl, refChild.impl ) );
+}
+
+/*!
+    Inserts the node \a newChild after the child node \a refChild. \a
+    refChild must be a direct child of this node. If \a refChild is
+    \link isNull() null\endlink then \a newChild is appended as this
+    node's last child.
+
+    If \a newChild is the child of another node, it is reparented to
+    this node. If \a newChild is a child of this node, then its
+    position in the list of children is changed.
+
+    If \a newChild is a TQDomDocumentFragment, then the children of the
+    fragment are removed from the fragment and inserted after \a
+    refChild.
+
+    Returns a new reference to \a newChild on success or a \link
+    isNull() null node\endlink on failure.
+
+    \sa insertBefore() replaceChild() removeChild() appendChild()
+*/
+TQDomNode TQDomNode::insertAfter( const TQDomNode& newChild, const TQDomNode& refChild )
+{
+    if ( !impl ) {
+        if (nodeType() == DocumentNode)
+            impl = new TQDomDocumentPrivate;
+        else
+            return TQDomNode();
+    }
+    return TQDomNode( IMPL->insertAfter( newChild.impl, refChild.impl ) );
+}
+
+/*!
+    Replaces \a oldChild with \a newChild. \a oldChild must be a
+    direct child of this node.
+
+    If \a newChild is the child of another node, it is reparented to
+    this node. If \a newChild is a child of this node, then its
+    position in the list of children is changed.
+
+    If \a newChild is a TQDomDocumentFragment, then \a oldChild is
+    replaced by all of the children of the fragment.
+
+    Returns a new reference to \a oldChild on success or a \link
+    isNull() null node\endlink an failure.
+
+    \sa insertBefore() insertAfter() removeChild() appendChild()
+*/
+TQDomNode TQDomNode::replaceChild( const TQDomNode& newChild, const TQDomNode& oldChild )
+{
+    if ( !impl ) {
+        if (nodeType() == DocumentNode)
+            impl = new TQDomDocumentPrivate;
+        else
+            return TQDomNode();
+    }
+    return TQDomNode( IMPL->replaceChild( newChild.impl, oldChild.impl ) );
+}
+
+/*!
+    Removes \a oldChild from the list of children. \a oldChild must be
+    a direct child of this node.
+
+    Returns a new reference to \a oldChild on success or a \link
+    isNull() null node\endlink on failure.
+
+    \sa insertBefore() insertAfter() replaceChild() appendChild()
+*/
+TQDomNode TQDomNode::removeChild( const TQDomNode& oldChild )
+{
+    if ( !impl )
+	return TQDomNode();
+
+    if ( oldChild.isNull() )
+	return TQDomNode();
+
+    return TQDomNode( IMPL->removeChild( oldChild.impl ) );
+}
+
+/*!
+    Appends \a newChild as the node's last child.
+
+    If \a newChild is the child of another node, it is reparented to
+    this node. If \a newChild is a child of this node, then its
+    position in the list of children is changed.
+
+    If \a newChild is a TQDomDocumentFragment, then the children of the
+    fragment are removed from the fragment and appended.
+
+    Returns a new reference to \a newChild.
+
+    \sa insertBefore() insertAfter() replaceChild() removeChild()
+*/
+TQDomNode TQDomNode::appendChild( const TQDomNode& newChild )
+{
+    if ( !impl ) {
+        if (nodeType() == DocumentNode)
+            impl = new TQDomDocumentPrivate;
+        else
+            return TQDomNode();
+    }
+    return TQDomNode( IMPL->appendChild( newChild.impl ) );
+}
+
+/*!
+    Returns TRUE if the node has one or more children; otherwise
+    returns FALSE.
+*/
+bool TQDomNode::hasChildNodes() const
+{
+    if ( !impl )
+	return FALSE;
+    return IMPL->first != 0;
+}
+
+/*!
+    Returns TRUE if this node is null (i.e. if it has no type or
+    contents); otherwise returns FALSE.
+*/
+bool TQDomNode::isNull() const
+{
+    return ( impl == 0 );
+}
+
+/*!
+    Converts the node into a null node; if it was not a null node
+    before, its type and contents are deleted.
+
+    \sa isNull()
+*/
+void TQDomNode::clear()
+{
+    if ( impl && impl->deref() ) delete impl;
+    impl = 0;
+}
+
+/*!
+    Returns the first direct child node for which nodeName() equals \a
+    name.
+
+    If no such direct child exists, a \link isNull() null node\endlink
+    is returned.
+
+    \sa nodeName()
+*/
+TQDomNode TQDomNode::namedItem( const TQString& name ) const
+{
+    if ( !impl )
+	return TQDomNode();
+    return TQDomNode( impl->namedItem( name ) );
+}
+
+/*!
+    Writes the XML representation of the node and all its children to
+    the stream \a str. This function uses \a indent as the amount of
+    space to indent the node.
+*/
+void TQDomNode::save( TQTextStream& str, int indent ) const
+{
+    if ( impl )
+	IMPL->save( str, 1, indent );
+}
+
+/*!
+    \relates TQDomNode
+
+    Writes the XML representation of the node \a node and all its
+    children to the stream \a str.
+*/
+TQTextStream& operator<<( TQTextStream& str, const TQDomNode& node )
+{
+    node.save( str, 1 );
+
+    return str;
+}
+
+/*!
+    Returns TRUE if the node is an attribute; otherwise returns FALSE.
+
+    If this function returns TRUE, it does not imply that this object
+    is a TQDomAttribute; you can get the TQDomAttribute with
+    toAttribute().
+
+    \sa toAttr()
+*/
+bool TQDomNode::isAttr() const
+{
+    if(impl)
+	return impl->isAttr();
+    return FALSE;
+}
+
+/*!
+    Returns TRUE if the node is a CDATA section; otherwise returns
+    FALSE.
+
+    If this function returns TRUE, it does not imply that this object
+    is a TQDomCDATASection; you can get the TQDomCDATASection with
+    toCDATASection().
+
+    \sa toCDATASection()
+*/
+bool TQDomNode::isCDATASection() const
+{
+    if(impl)
+	return impl->isCDATASection();
+    return FALSE;
+}
+
+/*!
+    Returns TRUE if the node is a document fragment; otherwise returns
+    FALSE.
+
+    If this function returns TRUE, it does not imply that this object
+    is a TQDomDocumentFragment; you can get the TQDomDocumentFragment
+    with toDocumentFragment().
+
+    \sa toDocumentFragment()
+*/
+bool TQDomNode::isDocumentFragment() const
+{
+    if(impl)
+	return impl->isDocumentFragment();
+    return FALSE;
+}
+
+/*!
+    Returns TRUE if the node is a document; otherwise returns FALSE.
+
+    If this function returns TRUE, it does not imply that this object
+    is a TQDomDocument; you can get the TQDomDocument with toDocument().
+
+    \sa toDocument()
+*/
+bool TQDomNode::isDocument() const
+{
+    if(impl)
+	return impl->isDocument();
+    return FALSE;
+}
+
+/*!
+    Returns TRUE if the node is a document type; otherwise returns
+    FALSE.
+
+    If this function returns TRUE, it does not imply that this object
+    is a TQDomDocumentType; you can get the TQDomDocumentType with
+    toDocumentType().
+
+    \sa toDocumentType()
+*/
+bool TQDomNode::isDocumentType() const
+{
+    if(impl)
+	return impl->isDocumentType();
+    return FALSE;
+}
+
+/*!
+    Returns TRUE if the node is an element; otherwise returns FALSE.
+
+    If this function returns TRUE, it does not imply that this object
+    is a TQDomElement; you can get the TQDomElement with toElement().
+
+    \sa toElement()
+*/
+bool TQDomNode::isElement() const
+{
+    if(impl)
+	return impl->isElement();
+    return FALSE;
+}
+
+/*!
+    Returns TRUE if the node is an entity reference; otherwise returns
+    FALSE.
+
+    If this function returns TRUE, it does not imply that this object
+    is a TQDomEntityReference; you can get the TQDomEntityReference with
+    toEntityReference().
+
+    \sa toEntityReference()
+*/
+bool TQDomNode::isEntityReference() const
+{
+    if(impl)
+	return impl->isEntityReference();
+    return FALSE;
+}
+
+/*!
+    Returns TRUE if the node is a text node; otherwise returns FALSE.
+
+    If this function returns TRUE, it does not imply that this object
+    is a TQDomText; you can get the TQDomText with toText().
+
+    \sa toText()
+*/
+bool TQDomNode::isText() const
+{
+    if(impl)
+	return impl->isText();
+    return FALSE;
+}
+
+/*!
+    Returns TRUE if the node is an entity; otherwise returns FALSE.
+
+    If this function returns TRUE, it does not imply that this object
+    is a TQDomEntity; you can get the TQDomEntity with toEntity().
+
+    \sa toEntity()
+*/
+bool TQDomNode::isEntity() const
+{
+    if(impl)
+	return impl->isEntity();
+    return FALSE;
+}
+
+/*!
+    Returns TRUE if the node is a notation; otherwise returns FALSE.
+
+    If this function returns TRUE, it does not imply that this object
+    is a TQDomNotation; you can get the TQDomNotation with toNotation().
+
+    \sa toNotation()
+*/
+bool TQDomNode::isNotation() const
+{
+    if(impl)
+	return impl->isNotation();
+    return FALSE;
+}
+
+/*!
+    Returns TRUE if the node is a processing instruction; otherwise
+    returns FALSE.
+
+    If this function returns TRUE, it does not imply that this object
+    is a TQDomProcessingInstruction; you can get the
+    TQProcessingInstruction with toProcessingInstruction().
+
+    \sa toProcessingInstruction()
+*/
+bool TQDomNode::isProcessingInstruction() const
+{
+    if(impl)
+	return impl->isProcessingInstruction();
+    return FALSE;
+}
+
+/*!
+    Returns TRUE if the node is a character data node; otherwise
+    returns FALSE.
+
+    If this function returns TRUE, it does not imply that this object
+    is a TQDomCharacterData; you can get the TQDomCharacterData with
+    toCharacterData().
+
+    \sa toCharacterData()
+*/
+bool TQDomNode::isCharacterData() const
+{
+    if(impl)
+	return impl->isCharacterData();
+    return FALSE;
+}
+
+/*!
+    Returns TRUE if the node is a comment; otherwise returns FALSE.
+
+    If this function returns TRUE, it does not imply that this object
+    is a TQDomComment; you can get the TQDomComment with toComment().
+
+    \sa toComment()
+*/
+bool TQDomNode::isComment() const
+{
+     if(impl)
+	return impl->isComment();
+    return FALSE;
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * TQDomNamedNodeMapPrivate
+ *
+ **************************************************************/
+
+TQDomNamedNodeMapPrivate::TQDomNamedNodeMapPrivate( TQDomNodePrivate* n )
+{
+    readonly = FALSE;
+    parent = n;
+    appendToParent = FALSE;
+}
+
+TQDomNamedNodeMapPrivate::~TQDomNamedNodeMapPrivate()
+{
+    clearMap();
+}
+
+TQDomNamedNodeMapPrivate* TQDomNamedNodeMapPrivate::clone( TQDomNodePrivate* p )
+{
+    TQDomNamedNodeMapPrivate* m = new TQDomNamedNodeMapPrivate( p );
+    m->readonly = readonly;
+    m->appendToParent = appendToParent;
+
+    TQDictIterator<TQDomNodePrivate> it ( map );
+    for ( ; it.current(); ++it )
+	m->setNamedItem( it.current()->cloneNode() );
+
+    // we are no longer interested in ownership
+    m->deref();
+    return m;
+}
+
+void TQDomNamedNodeMapPrivate::clearMap()
+{
+    // Dereference all of our children if we took references
+    if ( !appendToParent ) {
+	TQDictIterator<TQDomNodePrivate> it( map );
+	for ( ; it.current(); ++it )
+	    if ( it.current()->deref() )
+		delete it.current();
+    }
+
+    map.clear();
+}
+
+TQDomNodePrivate* TQDomNamedNodeMapPrivate::namedItem( const TQString& name ) const
+{
+    TQDomNodePrivate* p = map[ name ];
+    return p;
+}
+
+TQDomNodePrivate* TQDomNamedNodeMapPrivate::namedItemNS( const TQString& nsURI, const TQString& localName ) const
+{
+    TQDictIterator<TQDomNodePrivate> it( map );
+    TQDomNodePrivate *n = it.current();
+    while ( n ) {
+	if ( !n->prefix.isNull() ) {
+	    // node has a namespace
+	    if ( n->namespaceURI==nsURI && n->name==localName ) {
+		return n;
+	    }
+	}
+	++it;
+	n = it.current();
+    }
+    return 0;
+}
+
+TQDomNodePrivate* TQDomNamedNodeMapPrivate::setNamedItem( TQDomNodePrivate* arg )
+{
+    if ( readonly || !arg )
+	return 0;
+
+    if ( appendToParent )
+	return parent->appendChild( arg );
+
+    TQDomNodePrivate *n = map[ arg->nodeName() ];
+    // We take a reference
+    arg->ref();
+    map.insert( arg->nodeName(), arg );
+    return n;
+}
+
+TQDomNodePrivate* TQDomNamedNodeMapPrivate::setNamedItemNS( TQDomNodePrivate* arg )
+{
+    if ( readonly || !arg )
+	return 0;
+
+    if ( appendToParent )
+	return parent->appendChild( arg );
+
+    if ( !arg->prefix.isNull() ) {
+	// node has a namespace
+	TQDomNodePrivate *n = namedItemNS( arg->namespaceURI, arg->name );
+	// We take a reference
+	arg->ref();
+	map.insert( arg->nodeName(), arg );
+	return n;
+    } else {
+	// ### check the following code if it is ok
+	return setNamedItem( arg );
+    }
+}
+
+TQDomNodePrivate* TQDomNamedNodeMapPrivate::removeNamedItem( const TQString& name )
+{
+    if ( readonly )
+	return 0;
+
+    TQDomNodePrivate* p = namedItem( name );
+    if ( p == 0 )
+	return 0;
+    if ( appendToParent )
+	return parent->removeChild( p );
+
+    map.remove( p->nodeName() );
+    // We took a reference, so we have to free one here
+    p->deref();
+    return p;
+}
+
+TQDomNodePrivate* TQDomNamedNodeMapPrivate::item( int index ) const
+{
+    if ( (uint)index >= length() )
+	return 0;
+
+    TQDictIterator<TQDomNodePrivate> it( map );
+    for ( int i = 0; i < index; ++i, ++it )
+	;
+    return it.current();
+}
+
+uint TQDomNamedNodeMapPrivate::length() const
+{
+    return map.count();
+}
+
+bool TQDomNamedNodeMapPrivate::contains( const TQString& name ) const
+{
+    return ( map[ name ] != 0 );
+}
+
+bool TQDomNamedNodeMapPrivate::containsNS( const TQString& nsURI, const TQString & localName ) const
+{
+    return ( namedItemNS( nsURI, localName ) != 0 );
+}
+
+/**************************************************************
+ *
+ * TQDomNamedNodeMap
+ *
+ **************************************************************/
+
+#define IMPL ((TQDomNamedNodeMapPrivate*)impl)
+
+/*!
+    \class TQDomNamedNodeMap qdom.h
+    \reentrant
+    \brief The TQDomNamedNodeMap class contains a collection of nodes
+    that can be accessed by name.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    Note that TQDomNamedNodeMap does not inherit from TQDomNodeList.
+    TQDomNamedNodeMaps do not provide any specific node ordering.
+    Although nodes in a TQDomNamedNodeMap may be accessed by an ordinal
+    index, this is simply to allow a convenient enumeration of the
+    contents of a TQDomNamedNodeMap, and does not imply that the DOM
+    specifies an ordering of the nodes.
+
+    The TQDomNamedNodeMap is used in three places:
+    \list 1
+    \i TQDomDocumentType::entities() returns a map of all entities
+	described in the DTD.
+    \i TQDomDocumentType::notations() returns a map of all notations
+	described in the DTD.
+    \i TQDomNode::attributes() returns a map of all attributes of an
+	element.
+    \endlist
+
+    Items in the map are identified by the name which TQDomNode::name()
+    returns. Nodes are retrieved using namedItem(), namedItemNS() or
+    item(). New nodes are inserted with setNamedItem() or
+    setNamedItemNS() and removed with removeNamedItem() or
+    removeNamedItemNS(). Use contains() to see if an item with the
+    given name is in the named node map. The number of items is
+    returned by length().
+
+    Terminology: in this class we use "item" and "node"
+    interchangeably.
+*/
+
+/*!
+    Constructs an empty named node map.
+*/
+TQDomNamedNodeMap::TQDomNamedNodeMap()
+{
+    impl = 0;
+}
+
+/*!
+    Constructs a copy of \a n.
+*/
+TQDomNamedNodeMap::TQDomNamedNodeMap( const TQDomNamedNodeMap& n )
+{
+    impl = n.impl;
+    if ( impl )
+	impl->ref();
+}
+
+TQDomNamedNodeMap::TQDomNamedNodeMap( TQDomNamedNodeMapPrivate* n )
+{
+    impl = n;
+    if ( impl )
+	impl->ref();
+}
+
+/*!
+    Assigns \a n to this named node map.
+*/
+TQDomNamedNodeMap& TQDomNamedNodeMap::operator= ( const TQDomNamedNodeMap& n )
+{
+    if ( impl && impl->deref() )
+	delete impl;
+    impl = n.impl;
+    if ( impl )
+	impl->ref();
+
+    return *this;
+}
+
+/*!
+    Returns TRUE if \a n and this named node map are equal; otherwise
+    returns FALSE.
+*/
+bool TQDomNamedNodeMap::operator== ( const TQDomNamedNodeMap& n ) const
+{
+    return ( impl == n.impl );
+}
+
+/*!
+    Returns TRUE if \a n and this named node map are not equal;
+    otherwise returns FALSE.
+*/
+bool TQDomNamedNodeMap::operator!= ( const TQDomNamedNodeMap& n ) const
+{
+    return ( impl != n.impl );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+TQDomNamedNodeMap::~TQDomNamedNodeMap()
+{
+    if ( impl && impl->deref() )
+	delete impl;
+}
+
+/*!
+    Returns the node called \a name.
+
+    If the named node map does not contain such a node, a \link
+    TQDomNode::isNull() null node\endlink is returned. A node's name is
+    the name returned by TQDomNode::nodeName().
+
+    \sa setNamedItem() namedItemNS()
+*/
+TQDomNode TQDomNamedNodeMap::namedItem( const TQString& name ) const
+{
+    if ( !impl )
+	return TQDomNode();
+    return TQDomNode( IMPL->namedItem( name ) );
+}
+
+/*!
+    Inserts the node \a newNode into the named node map. The name used
+    by the map is the node name of \a newNode as returned by
+    TQDomNode::nodeName().
+
+    If the new node replaces an existing node, i.e. the map contains a
+    node with the same name, the replaced node is returned.
+
+    \sa namedItem() removeNamedItem() setNamedItemNS()
+*/
+TQDomNode TQDomNamedNodeMap::setNamedItem( const TQDomNode& newNode )
+{
+    if ( !impl )
+	return TQDomNode();
+    return TQDomNode( IMPL->setNamedItem( (TQDomNodePrivate*)newNode.impl ) );
+}
+
+/*!
+    Removes the node called \a name from the map.
+
+    The function returns the removed node or a \link
+    TQDomNode::isNull() null node\endlink if the map did not contain a
+    node called \a name.
+
+    \sa setNamedItem() namedItem() removeNamedItemNS()
+*/
+TQDomNode TQDomNamedNodeMap::removeNamedItem( const TQString& name )
+{
+    if ( !impl )
+	return TQDomNode();
+    return TQDomNode( IMPL->removeNamedItem( name ) );
+}
+
+/*!
+    Retrieves the node at position \a index.
+
+    This can be used to iterate over the map. Note that the nodes in
+    the map are ordered arbitrarily.
+
+    \sa length()
+*/
+TQDomNode TQDomNamedNodeMap::item( int index ) const
+{
+    if ( !impl )
+	return TQDomNode();
+    return TQDomNode( IMPL->item( index ) );
+}
+
+/*!
+    Returns the node associated with the local name \a localName and
+    the namespace URI \a nsURI.
+
+    If the map does not contain such a node, a \link
+    TQDomNode::isNull() null node\endlink is returned.
+
+    \sa setNamedItemNS() namedItem()
+*/
+TQDomNode TQDomNamedNodeMap::namedItemNS( const TQString& nsURI, const TQString& localName ) const
+{
+    if ( !impl )
+	return TQDomNode();
+    return TQDomNode( IMPL->namedItemNS( nsURI, localName ) );
+}
+
+/*!
+    Inserts the node \a newNode in the map. If a node with the same
+    namespace URI and the same local name already exists in the map,
+    it is replaced by \a newNode. If the new node replaces an existing
+    node, the replaced node is returned.
+
+    \sa namedItemNS() removeNamedItemNS() setNamedItem()
+*/
+TQDomNode TQDomNamedNodeMap::setNamedItemNS( const TQDomNode& newNode )
+{
+    if ( !impl )
+	return TQDomNode();
+    return TQDomNode( IMPL->setNamedItemNS( (TQDomNodePrivate*)newNode.impl ) );
+}
+
+/*!
+    Removes the node with the local name \a localName and the
+    namespace URI \a nsURI from the map.
+
+    The function returns the removed node or a \link
+    TQDomNode::isNull() null node\endlink if the map did not contain a
+    node with the local name \a localName and the namespace URI \a
+    nsURI.
+
+    \sa setNamedItemNS() namedItemNS() removeNamedItem()
+*/
+TQDomNode TQDomNamedNodeMap::removeNamedItemNS( const TQString& nsURI, const TQString& localName )
+{
+    if ( !impl )
+	return TQDomNode();
+    TQDomNodePrivate *n = IMPL->namedItemNS( nsURI, localName );
+    if ( !n )
+	return TQDomNode();
+    return TQDomNode( IMPL->removeNamedItem( n->name ) );
+}
+
+/*!
+    Returns the number of nodes in the map.
+
+    \sa item()
+*/
+uint TQDomNamedNodeMap::length() const
+{
+    if ( !impl )
+	return 0;
+    return IMPL->length();
+}
+
+/*!
+    \fn uint TQDomNamedNodeMap::count() const
+
+    Returns the number of nodes in the map.
+
+    This function is the same as length().
+*/
+
+/*!
+    Returns TRUE if the map contains a node called \a name; otherwise
+    returns FALSE.
+*/
+bool TQDomNamedNodeMap::contains( const TQString& name ) const
+{
+    if ( !impl )
+	return FALSE;
+    return IMPL->contains( name );
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * TQDomDocumentTypePrivate
+ *
+ **************************************************************/
+
+TQDomDocumentTypePrivate::TQDomDocumentTypePrivate( TQDomDocumentPrivate* doc, TQDomNodePrivate* parent )
+    : TQDomNodePrivate( doc, parent )
+{
+    init();
+}
+
+TQDomDocumentTypePrivate::TQDomDocumentTypePrivate( TQDomDocumentTypePrivate* n, bool deep )
+    : TQDomNodePrivate( n, deep )
+{
+    init();
+    // Refill the maps with our new children
+    TQDomNodePrivate* p = first;
+    while ( p ) {
+	if ( p->isEntity() )
+	    // Dont use normal insert function since we would create infinite recursion
+	    entities->map.insert( p->nodeName(), p );
+	if ( p->isNotation() )
+	    // Dont use normal insert function since we would create infinite recursion
+	    notations->map.insert( p->nodeName(), p );
+    }
+}
+
+TQDomDocumentTypePrivate::~TQDomDocumentTypePrivate()
+{
+    if ( entities->deref() )
+	delete entities;
+    if ( notations->deref() )
+	delete notations;
+}
+
+void TQDomDocumentTypePrivate::init()
+{
+    entities = new TQDomNamedNodeMapPrivate( this );
+    notations = new TQDomNamedNodeMapPrivate( this );
+    publicId = TQString::null;
+    systemId = TQString::null;
+    internalSubset = TQString::null;
+
+    entities->setAppendToParent( TRUE );
+    notations->setAppendToParent( TRUE );
+}
+
+TQDomNodePrivate* TQDomDocumentTypePrivate::cloneNode( bool deep)
+{
+    TQDomNodePrivate* p = new TQDomDocumentTypePrivate( this, deep );
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+TQDomNodePrivate* TQDomDocumentTypePrivate::insertBefore( TQDomNodePrivate* newChild, TQDomNodePrivate* refChild )
+{
+    // Call the origianl implementation
+    TQDomNodePrivate* p = TQDomNodePrivate::insertBefore( newChild, refChild );
+    // Update the maps
+    if ( p && p->isEntity() )
+	entities->map.insert( p->nodeName(), p );
+    else if ( p && p->isNotation() )
+	notations->map.insert( p->nodeName(), p );
+
+    return p;
+}
+
+TQDomNodePrivate* TQDomDocumentTypePrivate::insertAfter( TQDomNodePrivate* newChild, TQDomNodePrivate* refChild )
+{
+    // Call the origianl implementation
+    TQDomNodePrivate* p = TQDomNodePrivate::insertAfter( newChild, refChild );
+    // Update the maps
+    if ( p && p->isEntity() )
+	entities->map.insert( p->nodeName(), p );
+    else if ( p && p->isNotation() )
+	notations->map.insert( p->nodeName(), p );
+
+    return p;
+}
+
+TQDomNodePrivate* TQDomDocumentTypePrivate::replaceChild( TQDomNodePrivate* newChild, TQDomNodePrivate* oldChild )
+{
+    // Call the origianl implementation
+    TQDomNodePrivate* p = TQDomNodePrivate::replaceChild( newChild, oldChild );
+    // Update the maps
+    if ( p ) {
+	if ( oldChild && oldChild->isEntity() )
+	    entities->map.remove( oldChild->nodeName() );
+	else if ( oldChild && oldChild->isNotation() )
+	    notations->map.remove( oldChild->nodeName() );
+
+	if ( p->isEntity() )
+	    entities->map.insert( p->nodeName(), p );
+	else if ( p->isNotation() )
+	    notations->map.insert( p->nodeName(), p );
+    }
+
+    return p;
+}
+
+TQDomNodePrivate* TQDomDocumentTypePrivate::removeChild( TQDomNodePrivate* oldChild )
+{
+    // Call the origianl implementation
+    TQDomNodePrivate* p = TQDomNodePrivate::removeChild(  oldChild );
+    // Update the maps
+    if ( p && p->isEntity() )
+	entities->map.remove( p->nodeName() );
+    else if ( p && p->isNotation() )
+	notations->map.remove( p ->nodeName() );
+
+    return p;
+}
+
+TQDomNodePrivate* TQDomDocumentTypePrivate::appendChild( TQDomNodePrivate* newChild )
+{
+    return insertAfter( newChild, 0 );
+}
+
+void TQDomDocumentTypePrivate::save( TQTextStream& s, int, int indent ) const
+{
+    if ( name.isEmpty() )
+	return;
+
+    s << "<!DOCTYPE " << name;
+
+    if ( !publicId.isNull() ) {
+	s << " PUBLIC \"" << publicId << "\"";
+	if ( !systemId.isNull() )
+	    s << " \"" << systemId << "\"";
+    } else if ( !systemId.isNull() ) {
+	s << " SYSTEM \"" << systemId << "\"";
+    }
+
+    if ( entities->length()>0 || notations->length()>0 ) {
+	s << " [ " << endl;
+
+	TQDictIterator<TQDomNodePrivate> it2( notations->map );
+	for ( ; it2.current(); ++it2 )
+	    it2.current()->save( s, 0, indent );
+
+	TQDictIterator<TQDomNodePrivate> it( entities->map );
+	for ( ; it.current(); ++it )
+	    it.current()->save( s, 0, indent );
+
+	s << " ]";
+    }
+
+    s << ">" << endl;
+}
+
+/**************************************************************
+ *
+ * TQDomDocumentType
+ *
+ **************************************************************/
+
+#define IMPL ((TQDomDocumentTypePrivate*)impl)
+
+/*!
+    \class TQDomDocumentType qdom.h
+    \reentrant
+    \brief The TQDomDocumentType class is the representation of the DTD
+    in the document tree.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    The TQDomDocumentType class allows read-only access to some of the
+    data structures in the DTD: it can return a map of all entities()
+    and notations(). In addition the function name() returns the name
+    of the document type as specified in the &lt;!DOCTYPE name&gt;
+    tag. This class also provides the publicId(), systemId() and
+    internalSubset() functions.
+
+    \sa TQDomDocument
+*/
+
+/*!
+    Creates an empty TQDomDocumentType object.
+*/
+TQDomDocumentType::TQDomDocumentType() : TQDomNode()
+{
+}
+
+/*!
+    Constructs a copy of \a n.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomDocumentType::TQDomDocumentType( const TQDomDocumentType& n )
+    : TQDomNode( n )
+{
+}
+
+TQDomDocumentType::TQDomDocumentType( TQDomDocumentTypePrivate* n )
+    : TQDomNode( n )
+{
+}
+
+/*!
+    Assigns \a n to this document type.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomDocumentType& TQDomDocumentType::operator= ( const TQDomDocumentType& n )
+{
+    return (TQDomDocumentType&) TQDomNode::operator=( n );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+TQDomDocumentType::~TQDomDocumentType()
+{
+}
+
+/*!
+    Returns the name of the document type as specified in the
+    &lt;!DOCTYPE name&gt; tag.
+
+    \sa nodeName()
+*/
+TQString TQDomDocumentType::name() const
+{
+    if ( !impl )
+	return TQString::null;
+
+    return IMPL->nodeName();
+}
+
+/*!
+    Returns a map of all entities described in the DTD.
+*/
+TQDomNamedNodeMap TQDomDocumentType::entities() const
+{
+    if ( !impl )
+	return TQDomNamedNodeMap();
+    return TQDomNamedNodeMap( IMPL->entities );
+}
+
+/*!
+    Returns a map of all notations described in the DTD.
+*/
+TQDomNamedNodeMap TQDomDocumentType::notations() const
+{
+    if ( !impl )
+	return TQDomNamedNodeMap();
+    return TQDomNamedNodeMap( IMPL->notations );
+}
+
+/*!
+    Returns the public identifier of the external DTD subset or
+    TQString::null if there is no public identifier.
+
+    \sa systemId() internalSubset() TQDomImplementation::createDocumentType()
+*/
+TQString TQDomDocumentType::publicId() const
+{
+    if ( !impl )
+	return TQString::null;
+    return IMPL->publicId;
+}
+
+/*!
+    Returns the system identifier of the external DTD subset or
+    TQString::null if there is no system identifier.
+
+    \sa publicId() internalSubset() TQDomImplementation::createDocumentType()
+*/
+TQString TQDomDocumentType::systemId() const
+{
+    if ( !impl )
+	return TQString::null;
+    return IMPL->systemId;
+}
+
+/*!
+    Returns the internal subset of the document type or TQString::null
+    if there is no internal subset.
+
+    \sa publicId() systemId()
+*/
+TQString TQDomDocumentType::internalSubset() const
+{
+    if ( !impl )
+	return TQString::null;
+    return IMPL->internalSubset;
+}
+
+/*!
+    Returns \c DocumentTypeNode.
+
+    \sa isDocumentType() TQDomNode::toDocumentType()
+*/
+TQDomNode::NodeType TQDomDocumentType::nodeType() const
+{
+    return DocumentTypeNode;
+}
+
+/*!
+    This function overloads TQDomNode::isDocumentType().
+
+    \sa nodeType() TQDomNode::toDocumentType()
+*/
+bool TQDomDocumentType::isDocumentType() const
+{
+    return TRUE;
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * TQDomDocumentFragmentPrivate
+ *
+ **************************************************************/
+
+TQDomDocumentFragmentPrivate::TQDomDocumentFragmentPrivate( TQDomDocumentPrivate* doc, TQDomNodePrivate* parent )
+    : TQDomNodePrivate( doc, parent )
+{
+    name = "#document-fragment";
+}
+
+TQDomDocumentFragmentPrivate::TQDomDocumentFragmentPrivate( TQDomNodePrivate* n, bool deep )
+    : TQDomNodePrivate( n, deep )
+{
+}
+
+TQDomDocumentFragmentPrivate::~TQDomDocumentFragmentPrivate()
+{
+}
+
+TQDomNodePrivate* TQDomDocumentFragmentPrivate::cloneNode( bool deep)
+{
+    TQDomNodePrivate* p = new TQDomDocumentFragmentPrivate( this, deep );
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+/**************************************************************
+ *
+ * TQDomDocumentFragment
+ *
+ **************************************************************/
+
+#define IMPL ((TQDomDocumentFragmentPrivate*)impl)
+
+/*!
+    \class TQDomDocumentFragment qdom.h
+    \reentrant
+    \brief The TQDomDocumentFragment class is a tree of TQDomNodes which is not usually a complete TQDomDocument.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    If you want to do complex tree operations it is useful to have a
+    lightweight class to store nodes and their relations.
+    TQDomDocumentFragment stores a subtree of a document which does not
+    necessarily represent a well-formed XML document.
+
+    TQDomDocumentFragment is also useful if you want to group several
+    nodes in a list and insert them all together as children of some
+    node. In these cases TQDomDocumentFragment can be used as a
+    temporary container for this list of children.
+
+    The most important feature of TQDomDocumentFragment is that it is
+    treated in a special way by TQDomNode::insertAfter(),
+    TQDomNode::insertBefore(), TQDomNode::replaceChild() and
+    TQDomNode::appendChild(): instead of inserting the fragment itself, all
+    the fragment's children are inserted.
+*/
+
+/*!
+    Constructs an empty document fragment.
+*/
+TQDomDocumentFragment::TQDomDocumentFragment()
+{
+}
+
+TQDomDocumentFragment::TQDomDocumentFragment( TQDomDocumentFragmentPrivate* n )
+    : TQDomNode( n )
+{
+}
+
+/*!
+    Constructs a copy of \a x.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomDocumentFragment::TQDomDocumentFragment( const TQDomDocumentFragment& x )
+    : TQDomNode( x )
+{
+}
+
+/*!
+    Assigns \a x to this DOM document fragment.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomDocumentFragment& TQDomDocumentFragment::operator= ( const TQDomDocumentFragment& x )
+{
+    return (TQDomDocumentFragment&) TQDomNode::operator=( x );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+TQDomDocumentFragment::~TQDomDocumentFragment()
+{
+}
+
+/*!
+    Returns \c DocumentFragment.
+
+    \sa isDocumentFragment() TQDomNode::toDocumentFragment()
+*/
+TQDomNode::NodeType TQDomDocumentFragment::nodeType() const
+{
+    return TQDomNode::DocumentFragmentNode;
+}
+
+/*!
+    This function reimplements TQDomNode::isDocumentFragment().
+
+    \sa nodeType() TQDomNode::toDocumentFragment()
+*/
+bool TQDomDocumentFragment::isDocumentFragment() const
+{
+    return TRUE;
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * TQDomCharacterDataPrivate
+ *
+ **************************************************************/
+
+TQDomCharacterDataPrivate::TQDomCharacterDataPrivate( TQDomDocumentPrivate* d, TQDomNodePrivate* p,
+						      const TQString& data )
+    : TQDomNodePrivate( d, p )
+{
+    value = data;
+
+    name = "#character-data";
+}
+
+TQDomCharacterDataPrivate::TQDomCharacterDataPrivate( TQDomCharacterDataPrivate* n, bool deep )
+    : TQDomNodePrivate( n, deep )
+{
+}
+
+TQDomCharacterDataPrivate::~TQDomCharacterDataPrivate()
+{
+}
+
+TQDomNodePrivate* TQDomCharacterDataPrivate::cloneNode( bool deep )
+{
+    TQDomNodePrivate* p = new TQDomCharacterDataPrivate( this, deep );
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+uint TQDomCharacterDataPrivate::dataLength() const
+{
+    return value.length();
+}
+
+TQString TQDomCharacterDataPrivate::substringData( unsigned long offset, unsigned long n ) const
+{
+    return value.mid( offset, n );
+}
+
+void TQDomCharacterDataPrivate::insertData( unsigned long offset, const TQString& arg )
+{
+    value.insert( offset, arg );
+}
+
+void TQDomCharacterDataPrivate::deleteData( unsigned long offset, unsigned long n )
+{
+    value.remove( offset, n );
+}
+
+void TQDomCharacterDataPrivate::replaceData( unsigned long offset, unsigned long n, const TQString& arg )
+{
+    value.replace( offset, n, arg );
+}
+
+void TQDomCharacterDataPrivate::appendData( const TQString& arg )
+{
+    value += arg;
+}
+
+/**************************************************************
+ *
+ * TQDomCharacterData
+ *
+ **************************************************************/
+
+#define IMPL ((TQDomCharacterDataPrivate*)impl)
+
+/*!
+    \class TQDomCharacterData qdom.h
+    \reentrant
+    \brief The TQDomCharacterData class represents a generic string in the DOM.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    Character data as used in XML specifies a generic data string.
+    More specialized versions of this class are TQDomText, TQDomComment
+    and TQDomCDATASection.
+
+    The data string is set with setData() and retrieved with data().
+    You can retrieve a portion of the data string using
+    substringData(). Extra data can be appended with appendData(), or
+    inserted with insertData(). Portions of the data string can be
+    deleted with deleteData() or replaced with replaceData(). The
+    length of the data string is returned by length().
+
+    The node type of the node containing this character data is
+    returned by nodeType().
+
+    \sa TQDomText TQDomComment TQDomCDATASection
+*/
+
+/*!
+    Constructs an empty character data object.
+*/
+TQDomCharacterData::TQDomCharacterData()
+{
+}
+
+/*!
+    Constructs a copy of \a x.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomCharacterData::TQDomCharacterData( const TQDomCharacterData& x )
+    : TQDomNode( x )
+{
+}
+
+TQDomCharacterData::TQDomCharacterData( TQDomCharacterDataPrivate* n )
+    : TQDomNode( n )
+{
+}
+
+/*!
+    Assigns \a x to this character data.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomCharacterData& TQDomCharacterData::operator= ( const TQDomCharacterData& x )
+{
+    return (TQDomCharacterData&) TQDomNode::operator=( x );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+TQDomCharacterData::~TQDomCharacterData()
+{
+}
+
+/*!
+    Returns the string stored in this object.
+
+    If the node is a \link isNull() null node\endlink, it will return
+    TQString::null.
+*/
+TQString TQDomCharacterData::data() const
+{
+    if ( !impl )
+	return TQString::null;
+    return impl->nodeValue();
+}
+
+/*!
+    Sets this object's string to \a v.
+*/
+void TQDomCharacterData::setData( const TQString& v )
+{
+    if ( impl )
+	impl->setNodeValue( v );
+}
+
+/*!
+    Returns the length of the stored string.
+*/
+uint TQDomCharacterData::length() const
+{
+    if ( impl )
+	return IMPL->dataLength();
+    return 0;
+}
+
+/*!
+    Returns the substring of length \a count from position \a offset.
+*/
+TQString TQDomCharacterData::substringData( unsigned long offset, unsigned long count )
+{
+    if ( !impl )
+	return TQString::null;
+    return IMPL->substringData( offset, count );
+}
+
+/*!
+    Appends the string \a arg to the stored string.
+*/
+void TQDomCharacterData::appendData( const TQString& arg )
+{
+    if ( impl )
+	IMPL->appendData( arg );
+}
+
+/*!
+    Inserts the string \a arg into the stored string at position \a offset.
+*/
+void TQDomCharacterData::insertData( unsigned long offset, const TQString& arg )
+{
+    if ( impl )
+	IMPL->insertData( offset, arg );
+}
+
+/*!
+    Deletes a substring of length \a count from position \a offset.
+*/
+void TQDomCharacterData::deleteData( unsigned long offset, unsigned long count )
+{
+    if ( impl )
+	IMPL->deleteData( offset, count );
+}
+
+/*!
+    Replaces the substring of length \a count starting at position \a
+    offset with the string \a arg.
+*/
+void TQDomCharacterData::replaceData( unsigned long offset, unsigned long count, const TQString& arg )
+{
+    if ( impl )
+	IMPL->replaceData( offset, count, arg );
+}
+
+/*!
+    Returns the type of node this object refers to (i.e. \c TextNode,
+    \c CDATASectionNode, \c CommentNode or \c CharacterDataNode). For
+    a \link isNull() null node\endlink \c CharacterDataNode is
+    returned.
+*/
+TQDomNode::NodeType TQDomCharacterData::nodeType() const
+{
+    if( !impl )
+	return CharacterDataNode;
+    return TQDomNode::nodeType();
+}
+
+/*!
+    Returns TRUE.
+*/
+bool TQDomCharacterData::isCharacterData() const
+{
+    return TRUE;
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * TQDomAttrPrivate
+ *
+ **************************************************************/
+
+TQDomAttrPrivate::TQDomAttrPrivate( TQDomDocumentPrivate* d, TQDomNodePrivate* parent, const TQString& name_ )
+    : TQDomNodePrivate( d, parent )
+{
+    name = name_;
+    m_specified = FALSE;
+}
+
+TQDomAttrPrivate::TQDomAttrPrivate( TQDomDocumentPrivate* d, TQDomNodePrivate* p, const TQString& nsURI, const TQString& qName )
+    : TQDomNodePrivate( d, p )
+{
+    qt_split_namespace( prefix, name, qName, !nsURI.isNull() );
+    namespaceURI = nsURI;
+    createdWithDom1Interface = FALSE;
+    m_specified = FALSE;
+}
+
+TQDomAttrPrivate::TQDomAttrPrivate( TQDomAttrPrivate* n, bool deep )
+    : TQDomNodePrivate( n, deep )
+{
+    m_specified = n->specified();
+}
+
+TQDomAttrPrivate::~TQDomAttrPrivate()
+{
+}
+
+void TQDomAttrPrivate::setNodeValue( const TQString& v )
+{
+    value = v;
+    TQDomTextPrivate *t = new TQDomTextPrivate( 0, this, v );
+    // keep the refcount balanced: appendChild() does a ref() anyway.
+    t->deref();
+    if ( first ) {
+	delete removeChild( first );
+    }
+    appendChild( t );
+}
+
+TQDomNodePrivate* TQDomAttrPrivate::cloneNode( bool deep )
+{
+    TQDomNodePrivate* p = new TQDomAttrPrivate( this, deep );
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+bool TQDomAttrPrivate::specified() const
+{
+    return m_specified;
+}
+
+static bool isXmlChar(const TQChar &c)
+{
+    // Characters in this range must be accepted by XML parsers.
+    // Consequently characters outside of this range need to be escaped.
+
+    ushort uc = c.unicode();
+
+    return uc == 0x9
+            || uc == 0xA
+            || uc == 0xD
+            || 0x20 <= uc && uc <= 0xD7FF
+            || 0xE000 <= uc && uc <= 0xFFFD;
+}
+
+/*
+  Encode an attribute value upon saving.
+*/
+static TQString encodeAttr( const TQString& str )
+{
+    TQString tmp( str );
+    uint len = tmp.length();
+    uint i = 0;
+    while ( i < len ) {
+	if ( tmp[(int)i] == '<' ) {
+	    tmp.replace( i, 1, "&lt;" );
+	    len += 3;
+	    i += 4;
+	} else if ( tmp[(int)i] == '"' ) {
+	    tmp.replace( i, 1, "&quot;" );
+	    len += 5;
+	    i += 6;
+	} else if ( tmp[(int)i] == '&' ) {
+	    tmp.replace( i, 1, "&amp;" );
+	    len += 4;
+	    i += 5;
+	} else if ( tmp[(int)i] == '>' && i>=2 && tmp[(int)i-1]==']' && tmp[(int)i-2]==']' ) {
+	    tmp.replace( i, 1, "&gt;" );
+	    len += 3;
+	    i += 4;
+        } else if (!isXmlChar(tmp[(int)i])) {
+            TQString repl = "&#x" + TQString::number(tmp[(int)i].unicode(), 16) + ';';
+            qWarning("TQDom: saving invalid character %s, the document will not be well-formed", repl.latin1());
+            tmp.replace(i, 1, repl);
+            len += repl.length() - 1;
+            i += repl.length();
+        } else {
+	    ++i;
+	}
+    }
+
+    return tmp;
+}
+
+void TQDomAttrPrivate::save( TQTextStream& s, int, int ) const
+{
+    if ( namespaceURI.isNull() ) {
+	s << name << "=\"" << encodeAttr( value ) << "\"";
+    } else {
+	// ### optimize this (see comment of TQDomElementPrivate::save()
+	s << prefix << ":" << name << "=\"" << encodeAttr( value ) << "\""
+	    << " xmlns:" << prefix << "=\"" << encodeAttr( namespaceURI ) << "\"";
+    }
+}
+
+/**************************************************************
+ *
+ * TQDomAttr
+ *
+ **************************************************************/
+
+#define IMPL ((TQDomAttrPrivate*)impl)
+
+/*!
+    \class TQDomAttr qdom.h
+    \reentrant
+    \brief The TQDomAttr class represents one attribute of a TQDomElement.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    For example, the following piece of XML produces an element with
+    no children, but two attributes:
+
+    \code
+    <link href="http://www.trolltech.com" color="red" />
+    \endcode
+
+    You can access the attributes of an element with code like this:
+
+    \code
+    TQDomElement e = //...
+    //...
+    TQDomAttr a = e.attributeNode( "href" );
+    cout << a.value() << endl;                // prints "http://www.trolltech.com"
+    a.setValue( "http://doc.trolltech.com" ); // change the node's attribute
+    TQDomAttr a2 = e.attributeNode( "href" );
+    cout << a2.value() << endl;               // prints "http://doc.trolltech.com"
+    \endcode
+
+    This example also shows that changing an attribute received from
+    an element changes the attribute of the element. If you do not
+    want to change the value of the element's attribute you must
+    use cloneNode() to get an independent copy of the attribute.
+
+    TQDomAttr can return the name() and value() of an attribute. An
+    attribute's value is set with setValue(). If specified() returns
+    TRUE the value was either set in the document or set with
+    setValue(); otherwise the value hasn't been set. The node this
+    attribute is attached to (if any) is returned by ownerElement().
+
+    For further information about the Document Object Model see
+    \link http://www.w3.org/TR/REC-DOM-Level-1/\endlink and
+    \link http://www.w3.org/TR/DOM-Level-2-Core/\endlink.
+    For a more general introduction of the DOM implementation see the
+    TQDomDocument documentation.
+*/
+
+
+/*!
+    Constructs an empty attribute.
+*/
+TQDomAttr::TQDomAttr()
+{
+}
+
+/*!
+    Constructs a copy of \a x.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomAttr::TQDomAttr( const TQDomAttr& x )
+    : TQDomNode( x )
+{
+}
+
+TQDomAttr::TQDomAttr( TQDomAttrPrivate* n )
+    : TQDomNode( n )
+{
+}
+
+/*!
+    Assigns \a x to this DOM attribute.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomAttr& TQDomAttr::operator= ( const TQDomAttr& x )
+{
+    return (TQDomAttr&) TQDomNode::operator=( x );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+TQDomAttr::~TQDomAttr()
+{
+}
+
+/*!
+    Returns the attribute's name.
+*/
+TQString TQDomAttr::name() const
+{
+    if ( !impl )
+	return TQString::null;
+    return impl->nodeName();
+}
+
+/*!
+    Returns TRUE if the attribute has either been expicitly specified
+    in the XML document or was set by the user with setValue().
+    Returns FALSE if the value hasn't been specified or set.
+
+    \sa setValue()
+*/
+bool TQDomAttr::specified() const
+{
+    if ( !impl )
+	return FALSE;
+    return IMPL->specified();
+}
+
+/*!
+    Returns the element node this attribute is attached to or a \link
+    TQDomNode::isNull() null node\endlink if this attribute is not
+    attached to any element.
+*/
+TQDomElement TQDomAttr::ownerElement() const
+{
+    if ( !impl && !impl->parent()->isElement() )
+	return TQDomElement();
+    return TQDomElement( (TQDomElementPrivate*)(impl->parent()) );
+}
+
+/*!
+    Returns the value of the attribute or TQString::null if the
+    attribute has not been specified.
+
+    \sa specified() setValue()
+*/
+TQString TQDomAttr::value() const
+{
+    if ( !impl )
+	return TQString::null;
+    return impl->nodeValue();
+}
+
+/*!
+    Sets the attribute's value to \a v.
+
+    \sa value()
+*/
+void TQDomAttr::setValue( const TQString& v )
+{
+    if ( !impl )
+	return;
+    impl->setNodeValue( v );
+    IMPL->m_specified = TRUE;
+}
+
+/*!
+    Returns \link TQDomNode::NodeType AttributeNode\endlink.
+*/
+TQDomNode::NodeType TQDomAttr::nodeType() const
+{
+    return AttributeNode;
+}
+
+/*!
+    Returns TRUE.
+*/
+bool TQDomAttr::isAttr() const
+{
+    return TRUE;
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * TQDomElementPrivate
+ *
+ **************************************************************/
+
+TQDomElementPrivate::TQDomElementPrivate( TQDomDocumentPrivate* d, TQDomNodePrivate* p,
+					  const TQString& tagname )
+    : TQDomNodePrivate( d, p )
+{
+    name = tagname;
+    m_attr = new TQDomNamedNodeMapPrivate( this );
+}
+
+TQDomElementPrivate::TQDomElementPrivate( TQDomDocumentPrivate* d, TQDomNodePrivate* p,
+	const TQString& nsURI, const TQString& qName )
+    : TQDomNodePrivate( d, p )
+{
+    qt_split_namespace( prefix, name, qName, !nsURI.isNull() );
+    namespaceURI = nsURI;
+    createdWithDom1Interface = FALSE;
+    m_attr = new TQDomNamedNodeMapPrivate( this );
+}
+
+TQDomElementPrivate::TQDomElementPrivate( TQDomElementPrivate* n, bool deep ) :
+    TQDomNodePrivate( n, deep )
+{
+    m_attr = n->m_attr->clone( this );
+    // Reference is down to 0, so we set it to 1 here.
+    m_attr->ref();
+}
+
+TQDomElementPrivate::~TQDomElementPrivate()
+{
+    if ( m_attr->deref() )
+	delete m_attr;
+}
+
+TQDomNodePrivate* TQDomElementPrivate::cloneNode( bool deep)
+{
+    TQDomNodePrivate* p = new TQDomElementPrivate( this, deep );
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+TQString TQDomElementPrivate::attribute( const TQString& name_, const TQString& defValue ) const
+{
+    TQDomNodePrivate* n = m_attr->namedItem( name_ );
+    if ( !n )
+	return defValue;
+
+    return n->nodeValue();
+}
+
+TQString TQDomElementPrivate::attributeNS( const TQString& nsURI, const TQString& localName, const TQString& defValue ) const
+{
+    TQDomNodePrivate* n = m_attr->namedItemNS( nsURI, localName );
+    if ( !n )
+	return defValue;
+
+    return n->nodeValue();
+}
+
+void TQDomElementPrivate::setAttribute( const TQString& aname, const TQString& newValue )
+{
+    TQDomNodePrivate* n = m_attr->namedItem( aname );
+    if ( !n ) {
+	n = new TQDomAttrPrivate( ownerDocument(), this, aname );
+	n->setNodeValue( newValue );
+
+	// Referencing is done by the map, so we set the reference counter back
+	// to 0 here. This is ok since we created the TQDomAttrPrivate.
+	n->deref();
+	m_attr->setNamedItem( n );
+    } else {
+	n->setNodeValue( newValue );
+    }
+}
+
+void TQDomElementPrivate::setAttributeNS( const TQString& nsURI, const TQString& qName, const TQString& newValue )
+{
+    TQString prefix, localName;
+    qt_split_namespace( prefix, localName, qName, TRUE );
+    TQDomNodePrivate* n = m_attr->namedItemNS( nsURI, localName );
+    if ( !n ) {
+	n = new TQDomAttrPrivate( ownerDocument(), this, nsURI, qName );
+	n->setNodeValue( newValue );
+
+	// Referencing is done by the map, so we set the reference counter back
+	// to 0 here. This is ok since we created the TQDomAttrPrivate.
+	n->deref();
+	m_attr->setNamedItem( n );
+    } else {
+	n->setNodeValue( newValue );
+	n->prefix = prefix;
+    }
+}
+
+void TQDomElementPrivate::removeAttribute( const TQString& aname )
+{
+    TQDomNodePrivate* p = m_attr->removeNamedItem( aname );
+    if ( p && p->count == 0 )
+	delete p;
+}
+
+TQDomAttrPrivate* TQDomElementPrivate::attributeNode( const TQString& aname )
+{
+    return (TQDomAttrPrivate*)m_attr->namedItem( aname );
+}
+
+TQDomAttrPrivate* TQDomElementPrivate::attributeNodeNS( const TQString& nsURI, const TQString& localName )
+{
+    return (TQDomAttrPrivate*)m_attr->namedItemNS( nsURI, localName );
+}
+
+TQDomAttrPrivate* TQDomElementPrivate::setAttributeNode( TQDomAttrPrivate* newAttr )
+{
+    TQDomNodePrivate* n = m_attr->namedItem( newAttr->nodeName() );
+
+    // Referencing is done by the maps
+    m_attr->setNamedItem( newAttr );
+
+    return (TQDomAttrPrivate*)n;
+}
+
+TQDomAttrPrivate* TQDomElementPrivate::setAttributeNodeNS( TQDomAttrPrivate* newAttr )
+{
+    TQDomNodePrivate* n = 0;
+    if ( !newAttr->prefix.isNull() )
+	n = m_attr->namedItemNS( newAttr->namespaceURI, newAttr->name );
+
+    // Referencing is done by the maps
+    m_attr->setNamedItem( newAttr );
+
+    return (TQDomAttrPrivate*)n;
+}
+
+TQDomAttrPrivate* TQDomElementPrivate::removeAttributeNode( TQDomAttrPrivate* oldAttr )
+{
+    return (TQDomAttrPrivate*)m_attr->removeNamedItem( oldAttr->nodeName() );
+}
+
+bool TQDomElementPrivate::hasAttribute( const TQString& aname )
+{
+    return m_attr->contains( aname );
+}
+
+bool TQDomElementPrivate::hasAttributeNS( const TQString& nsURI, const TQString& localName )
+{
+    return m_attr->containsNS( nsURI, localName );
+}
+
+TQString TQDomElementPrivate::text()
+{
+    TQString t( "" );
+
+    TQDomNodePrivate* p = first;
+    while ( p ) {
+	if ( p->isText() || p->isCDATASection() )
+	    t += p->nodeValue();
+	else if ( p->isElement() )
+	    t += ((TQDomElementPrivate*)p)->text();
+	p = p->next;
+    }
+
+    return t;
+}
+
+void TQDomElementPrivate::save( TQTextStream& s, int depth, int indent ) const
+{
+    if ( !( prev && prev->isText() ) )
+	for ( int i = 0; i < depth*indent; ++i )
+	    s << " ";
+
+    TQString qName( name );
+    TQString nsDecl( "" );
+    if ( !namespaceURI.isNull() ) {
+	// ### optimize this, so that you only declare namespaces that are not
+	// yet declared -- we loose default namespace mappings, so maybe we
+	// should rather store the information that we get from
+	// startPrefixMapping()/endPrefixMapping() and use them (you have to
+	// take care if the DOM tree is modified, though)
+	if ( prefix.isEmpty() ) {
+	    nsDecl = " xmlns";
+	} else {
+	    qName = prefix + ":" + name;
+	    nsDecl = " xmlns:" + prefix;
+	}
+	nsDecl += "=\"" + encodeAttr( namespaceURI ) + "\"";
+    }
+    s << "<" << qName << nsDecl;
+
+    if ( !m_attr->map.isEmpty() ) {
+	s << " ";
+	TQDictIterator<TQDomNodePrivate> it( m_attr->map );
+	for ( ; it.current(); ++it ) {
+	    it.current()->save( s, 0, indent );
+	    s << " ";
+	}
+    }
+
+    if ( last ) {
+	// has child nodes
+	if ( first->isText() )
+	    s << ">";
+	else
+	    s << ">" << endl;
+	TQDomNodePrivate::save( s, depth + 1, indent);
+	if ( !last->isText() )
+	    for( int i = 0; i < depth*indent; ++i )
+		s << " ";
+
+	s << "</" << qName << ">";
+    } else {
+	s << "/>";
+    }
+    if ( !( next && next->isText() ) )
+	s << endl;
+}
+
+/**************************************************************
+ *
+ * TQDomElement
+ *
+ **************************************************************/
+
+#define IMPL ((TQDomElementPrivate*)impl)
+
+/*!
+    \class TQDomElement qdom.h
+    \reentrant
+    \brief The TQDomElement class represents one element in the DOM tree.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    Elements have a tagName() and zero or more attributes associated
+    with them. The tag name can be changed with setTagName().
+
+    Element attributes are represented by TQDomAttr objects that can
+    be queried using the attribute() and attributeNode() functions.
+    You can set attributes with the setAttribute() and
+    setAttributeNode() functions. Attributes can be removed with
+    removeAttribute(). There are namespace-aware equivalents to these
+    functions, i.e. setAttributeNS(), setAttributeNodeNS() and
+    removeAttributeNS().
+
+    If you want to access the text of a node use text(), e.g.
+    \code
+    TQDomElement e = //...
+    //...
+    TQString s = e.text()
+    \endcode
+    The text() function operates recursively to find the text (since
+    not all elements contain text). If you want to find all the text
+    in all of a node's children, iterate over the children looking for
+    TQDomText nodes, e.g.
+    \code
+    TQString text;
+    TQDomElement element = doc.documentElement();
+    for( TQDomNode n = element.firstChild(); !n.isNull(); n = n.nextSibling() )
+    {
+	TQDomText t = n.toText();
+	if ( !t.isNull() )
+	    text += t.data();
+    }
+    \endcode
+    Note that we attempt to convert each node to a text node and use
+    text() rather than using firstChild().toText().data() or
+    n.toText().data() directly on the node, because the node may not
+    be a text element.
+
+    You can get a list of all the decendents of an element which have
+    a specified tag name with elementsByTagName() or
+    elementsByTagNameNS().
+
+    For further information about the Document Object Model see
+    \link http://www.w3.org/TR/REC-DOM-Level-1/\endlink and
+    \link http://www.w3.org/TR/DOM-Level-2-Core/\endlink.
+    For a more general introduction of the DOM implementation see the
+    TQDomDocument documentation.
+*/
+
+/*!
+    Constructs an empty element. Use the TQDomDocument::createElement()
+    function to construct elements with content.
+*/
+TQDomElement::TQDomElement()
+    : TQDomNode()
+{
+}
+
+/*!
+    Constructs a copy of \a x.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomElement::TQDomElement( const TQDomElement& x )
+    : TQDomNode( x )
+{
+}
+
+TQDomElement::TQDomElement( TQDomElementPrivate* n )
+    : TQDomNode( n )
+{
+}
+
+/*!
+    Assigns \a x to this DOM element.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomElement& TQDomElement::operator= ( const TQDomElement& x )
+{
+    return (TQDomElement&) TQDomNode::operator=( x );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+TQDomElement::~TQDomElement()
+{
+}
+
+/*!
+    Returns \c ElementNode.
+*/
+TQDomNode::NodeType TQDomElement::nodeType() const
+{
+    return ElementNode;
+}
+
+/*!
+    Sets this element's tag name to \a name.
+
+    \sa tagName()
+*/
+void TQDomElement::setTagName( const TQString& name )
+{
+    if ( impl )
+	impl->name = name;
+}
+
+/*!
+    Returns the tag name of this element. For an XML element like this:
+    \code
+    <img src="myimg.png">
+    \endcode
+    the tagname would return "img".
+
+    \sa setTagName()
+*/
+TQString TQDomElement::tagName() const
+{
+    if ( !impl )
+	return TQString::null;
+    return impl->nodeName();
+}
+
+/*!
+    Returns the attribute called \a name. If the attribute does not
+    exist \a defValue is returned.
+
+    \sa setAttribute() attributeNode() setAttributeNode() attributeNS()
+*/
+TQString TQDomElement::attribute( const TQString& name,  const TQString& defValue ) const
+{
+    if ( !impl )
+	return defValue;
+    return IMPL->attribute( name, defValue );
+}
+
+/*!
+    Adds an attribute called \a name with value \a value. If an
+    attribute with the same name exists, its value is replaced by \a
+    value.
+
+    \sa attribute() setAttributeNode() setAttributeNS()
+*/
+void TQDomElement::setAttribute( const TQString& name, const TQString& value )
+{
+    if ( !impl )
+	return;
+    IMPL->setAttribute( name, value );
+}
+
+/*!
+    \overload
+*/
+void TQDomElement::setAttribute( const TQString& name, int value )
+{
+    // ### 4.0: inline
+    setAttribute( name, long(value) );
+}
+
+/*!
+    \overload
+*/
+void TQDomElement::setAttribute( const TQString& name, uint value )
+{
+    // ### 4.0: inline
+    setAttribute( name, ulong(value) );
+}
+
+/*!
+    \overload
+*/
+void TQDomElement::setAttribute( const TQString& name, long value )
+{
+    if ( !impl )
+	return;
+    TQString x;
+    x.setNum( value );
+    IMPL->setAttribute( name, x );
+}
+
+/*!
+    \overload
+*/
+void TQDomElement::setAttribute( const TQString& name, ulong value )
+{
+    if ( !impl )
+	return;
+    TQString x;
+    x.setNum( value );
+    IMPL->setAttribute( name, x );
+}
+
+/*!
+    \overload
+*/
+void TQDomElement::setAttribute( const TQString& name, double value )
+{
+    if ( !impl )
+	return;
+    TQString x;
+    x.setNum( value );
+    IMPL->setAttribute( name, x );
+}
+
+/*!
+    Removes the attribute called name \a name from this element.
+
+    \sa setAttribute() attribute() removeAttributeNS()
+*/
+void TQDomElement::removeAttribute( const TQString& name )
+{
+    if ( !impl )
+	return;
+    IMPL->removeAttribute( name );
+}
+
+/*!
+    Returns the TQDomAttr object that corresponds to the attribute
+    called \a name. If no such attribute exists a \link
+    TQDomNode::isNull() null attribute\endlink is returned.
+
+    \sa setAttributeNode() attribute() setAttribute() attributeNodeNS()
+*/
+TQDomAttr TQDomElement::attributeNode( const TQString& name)
+{
+    if ( !impl )
+	return TQDomAttr();
+    return TQDomAttr( IMPL->attributeNode( name ) );
+}
+
+/*!
+    Adds the attribute \a newAttr to this element.
+
+    If the element has another attribute that has the same name as \a
+    newAttr, this function replaces that attribute and returns it;
+    otherwise the function returns a \link TQDomNode::isNull() null
+    attribute\endlink.
+
+    \sa attributeNode() setAttribute() setAttributeNodeNS()
+*/
+TQDomAttr TQDomElement::setAttributeNode( const TQDomAttr& newAttr )
+{
+    if ( !impl )
+	return TQDomAttr();
+    return TQDomAttr( IMPL->setAttributeNode( ((TQDomAttrPrivate*)newAttr.impl) ) );
+}
+
+/*!
+    Removes the attribute \a oldAttr from the element and returns it.
+
+    \sa attributeNode() setAttributeNode()
+*/
+TQDomAttr TQDomElement::removeAttributeNode( const TQDomAttr& oldAttr )
+{
+    if ( !impl )
+	return TQDomAttr(); // ### should this return oldAttr?
+    return TQDomAttr( IMPL->removeAttributeNode( ((TQDomAttrPrivate*)oldAttr.impl) ) );
+}
+
+/*!
+    Returns a TQDomNodeList containing all descendent elements of this
+    element that are called \a tagname. The order they are in the node
+    list is the order they are encountered in a preorder traversal of
+    the element tree.
+
+    \sa elementsByTagNameNS() TQDomDocument::elementsByTagName()
+*/
+TQDomNodeList TQDomElement::elementsByTagName( const TQString& tagname ) const
+{
+    return TQDomNodeList( new TQDomNodeListPrivate( impl, tagname ) );
+}
+
+/*!
+    Returns TRUE.
+*/
+bool TQDomElement::isElement() const
+{
+    return TRUE;
+}
+
+/*!
+    Returns a TQDomNamedNodeMap containing all this element's attributes.
+
+    \sa attribute() setAttribute() attributeNode() setAttributeNode()
+*/
+TQDomNamedNodeMap TQDomElement::attributes() const
+{
+    if ( !impl )
+	return TQDomNamedNodeMap();
+    return TQDomNamedNodeMap( IMPL->attributes() );
+}
+
+/*!
+    Returns TRUE if this element has an attribute called \a name;
+    otherwise returns FALSE.
+*/
+bool TQDomElement::hasAttribute( const TQString& name ) const
+{
+    if ( !impl )
+	return FALSE;
+    return IMPL->hasAttribute( name );
+}
+
+/*!
+    Returns the attribute with the local name \a localName and the
+    namespace URI \a nsURI. If the attribute does not exist \a
+    defValue is returned.
+
+    \sa setAttributeNS() attributeNodeNS() setAttributeNodeNS() attribute()
+*/
+TQString TQDomElement::attributeNS( const TQString nsURI, const TQString& localName, const TQString& defValue ) const
+{
+    if ( !impl )
+	return defValue;
+    return IMPL->attributeNS( nsURI, localName, defValue );
+}
+
+/*!
+    Adds an attribute with the qualified name \a qName and the
+    namespace URI \a nsURI with the value \a value. If an attribute
+    with the same local name and namespace URI exists, its prefix is
+    replaced by the prefix of \a qName and its value is repaced by \a
+    value.
+
+    Although \a qName is the qualified name, the local name is used to
+    decide if an existing attribute's value should be replaced.
+
+    \sa attributeNS() setAttributeNodeNS() setAttribute()
+*/
+void TQDomElement::setAttributeNS( const TQString nsURI, const TQString& qName, const TQString& value )
+{
+    if ( !impl )
+	return;
+    IMPL->setAttributeNS( nsURI, qName, value );
+}
+
+/*!
+    \overload
+*/
+void TQDomElement::setAttributeNS( const TQString nsURI, const TQString& qName, int value )
+{
+    // ### 4.0: inline
+    setAttributeNS( nsURI, qName, long(value) );
+}
+
+/*!
+    \overload
+*/
+void TQDomElement::setAttributeNS( const TQString nsURI, const TQString& qName, uint value )
+{
+    // ### 4.0: inline
+    setAttributeNS( nsURI, qName, ulong(value) );
+}
+
+/*!
+    \overload
+*/
+void TQDomElement::setAttributeNS( const TQString nsURI, const TQString& qName, long value )
+{
+    if ( !impl )
+	return;
+    TQString x;
+    x.setNum( value );
+    IMPL->setAttributeNS( nsURI, qName, x );
+}
+
+/*!
+    \overload
+*/
+void TQDomElement::setAttributeNS( const TQString nsURI, const TQString& qName, ulong value )
+{
+    if ( !impl )
+	return;
+    TQString x;
+    x.setNum( value );
+    IMPL->setAttributeNS( nsURI, qName, x );
+}
+
+/*!
+    \overload
+*/
+void TQDomElement::setAttributeNS( const TQString nsURI, const TQString& qName, double value )
+{
+    if ( !impl )
+	return;
+    TQString x;
+    x.setNum( value );
+    IMPL->setAttributeNS( nsURI, qName, x );
+}
+
+/*!
+    Removes the attribute with the local name \a localName and the
+    namespace URI \a nsURI from this element.
+
+    \sa setAttributeNS() attributeNS() removeAttribute()
+*/
+void TQDomElement::removeAttributeNS( const TQString& nsURI, const TQString& localName )
+{
+    if ( !impl )
+	return;
+    TQDomNodePrivate *n = IMPL->attributeNodeNS( nsURI, localName );
+    if ( !n )
+	return;
+    IMPL->removeAttribute( n->nodeName() );
+}
+
+/*!
+    Returns the TQDomAttr object that corresponds to the attribute with
+    the local name \a localName and the namespace URI \a nsURI. If no
+    such attribute exists a \link TQDomNode::isNull() null
+    attribute\endlink is returned.
+
+    \sa setAttributeNode() attribute() setAttribute() attributeNodeNS()
+*/
+TQDomAttr TQDomElement::attributeNodeNS( const TQString& nsURI, const TQString& localName )
+{
+    if ( !impl )
+	return TQDomAttr();
+    return TQDomAttr( IMPL->attributeNodeNS( nsURI, localName ) );
+}
+
+/*!
+    Adds the attribute \a newAttr to this element.
+
+    If the element has another attribute that has the same local name
+    and namespace URI as \a newAttr, this function replaces that
+    attribute and returns it; otherwise the function returns a \link
+    TQDomNode::isNull() null attribute\endlink.
+
+    \sa attributeNodeNS() setAttributeNS() setAttributeNode()
+*/
+TQDomAttr TQDomElement::setAttributeNodeNS( const TQDomAttr& newAttr )
+{
+    if ( !impl )
+	return TQDomAttr();
+    return TQDomAttr( IMPL->setAttributeNodeNS( ((TQDomAttrPrivate*)newAttr.impl) ) );
+}
+
+/*!
+    Returns a TQDomNodeList containing all the descendent elements of
+    this element with the local name \a localName and the namespace
+    URI \a nsURI. The order they are in the node list is the order
+    they are encountered in a preorder traversal of the element tree.
+
+    \sa elementsByTagName() TQDomDocument::elementsByTagNameNS()
+*/
+TQDomNodeList TQDomElement::elementsByTagNameNS( const TQString& nsURI, const TQString& localName ) const
+{
+    return TQDomNodeList( new TQDomNodeListPrivate( impl, nsURI, localName ) );
+}
+
+/*!
+    Returns TRUE if this element has an attribute with the local name
+    \a localName and the namespace URI \a nsURI; otherwise returns
+    FALSE.
+*/
+bool TQDomElement::hasAttributeNS( const TQString& nsURI, const TQString& localName ) const
+{
+    if ( !impl )
+	return FALSE;
+    return IMPL->hasAttributeNS( nsURI, localName );
+}
+
+/*!
+    Returns the element's text or TQString::null.
+
+    Example:
+    \code
+    <h1>Hello <b>TQt</b> <![CDATA[<xml is cool>]]></h1>
+    \endcode
+
+    The function text() of the TQDomElement for the &lt;h1&gt; tag,
+    will return "Hello TQt &lt;xml is cool&gt;".
+
+    Comments are ignored by this function. It only evaluates TQDomText
+    and TQDomCDATASection objects.
+*/
+TQString TQDomElement::text() const
+{
+    if ( !impl )
+	return TQString::null;
+    return IMPL->text();
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * TQDomTextPrivate
+ *
+ **************************************************************/
+
+TQDomTextPrivate::TQDomTextPrivate( TQDomDocumentPrivate* d, TQDomNodePrivate* parent, const TQString& value )
+    : TQDomCharacterDataPrivate( d, parent, value )
+{
+    name = "#text";
+}
+
+TQDomTextPrivate::TQDomTextPrivate( TQDomTextPrivate* n, bool deep )
+    : TQDomCharacterDataPrivate( n, deep )
+{
+}
+
+TQDomTextPrivate::~TQDomTextPrivate()
+{
+}
+
+TQDomNodePrivate* TQDomTextPrivate::cloneNode( bool deep)
+{
+    TQDomNodePrivate* p = new TQDomTextPrivate( this, deep );
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+TQDomTextPrivate* TQDomTextPrivate::splitText( int offset )
+{
+    if ( !parent() ) {
+	qWarning( "TQDomText::splitText  The node has no parent. So I can not split" );
+	return 0;
+    }
+
+    TQDomTextPrivate* t = new TQDomTextPrivate( ownerDocument(), 0, value.mid( offset ) );
+    value.truncate( offset );
+
+    parent()->insertAfter( t, this );
+
+    return t;
+}
+
+void TQDomTextPrivate::save( TQTextStream& s, int, int ) const
+{
+    s << encodeAttr( value );
+}
+
+/**************************************************************
+ *
+ * TQDomText
+ *
+ **************************************************************/
+
+#define IMPL ((TQDomTextPrivate*)impl)
+
+/*!
+    \class TQDomText qdom.h
+    \reentrant
+    \brief The TQDomText class represents text data in the parsed XML document.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    You can split the text in a TQDomText object over two TQDomText
+    objecs with splitText().
+
+    For further information about the Document Object Model see
+    \link http://www.w3.org/TR/REC-DOM-Level-1/\endlink and
+    \link http://www.w3.org/TR/DOM-Level-2-Core/\endlink.
+    For a more general introduction of the DOM implementation see the
+    TQDomDocument documentation.
+*/
+
+/*!
+    Constructs an empty TQDomText object.
+
+    To construct a TQDomText with content, use TQDomDocument::createTextNode().
+*/
+TQDomText::TQDomText()
+    : TQDomCharacterData()
+{
+}
+
+/*!
+    Constructs a copy of \a x.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomText::TQDomText( const TQDomText& x )
+    : TQDomCharacterData( x )
+{
+}
+
+TQDomText::TQDomText( TQDomTextPrivate* n )
+    : TQDomCharacterData( n )
+{
+}
+
+/*!
+    Assigns \a x to this DOM text.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomText& TQDomText::operator= ( const TQDomText& x )
+{
+    return (TQDomText&) TQDomNode::operator=( x );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+TQDomText::~TQDomText()
+{
+}
+
+/*!
+    Returns \c TextNode.
+*/
+TQDomNode::NodeType TQDomText::nodeType() const
+{
+    return TextNode;
+}
+
+/*!
+    Splits this DOM text object into two TQDomText objects. This object
+    keeps its first \a offset characters and the second (newly
+    created) object is inserted into the document tree after this
+    object with the remaining characters.
+
+    The function returns the newly created object.
+
+    \sa TQDomNode::normalize()
+*/
+TQDomText TQDomText::splitText( int offset )
+{
+    if ( !impl )
+	return TQDomText();
+    return TQDomText( IMPL->splitText( offset ) );
+}
+
+/*!
+    Returns TRUE.
+*/
+bool TQDomText::isText() const
+{
+    return TRUE;
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * TQDomCommentPrivate
+ *
+ **************************************************************/
+
+TQDomCommentPrivate::TQDomCommentPrivate( TQDomDocumentPrivate* d, TQDomNodePrivate* parent, const TQString& value )
+    : TQDomCharacterDataPrivate( d, parent, value )
+{
+    name = "#comment";
+}
+
+TQDomCommentPrivate::TQDomCommentPrivate( TQDomCommentPrivate* n, bool deep )
+    : TQDomCharacterDataPrivate( n, deep )
+{
+}
+
+TQDomCommentPrivate::~TQDomCommentPrivate()
+{
+}
+
+TQDomNodePrivate* TQDomCommentPrivate::cloneNode( bool deep)
+{
+    TQDomNodePrivate* p = new TQDomCommentPrivate( this, deep );
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+void TQDomCommentPrivate::save( TQTextStream& s, int, int ) const
+{
+    s << "<!--" << value << "-->";
+}
+
+/**************************************************************
+ *
+ * TQDomComment
+ *
+ **************************************************************/
+
+#define IMPL ((TQDomCommentPrivate*)impl)
+
+/*!
+    \class TQDomComment qdom.h
+    \reentrant
+    \brief The TQDomComment class represents an XML comment.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    A comment in the parsed XML such as this:
+    \code
+    <!-- this is a comment -->
+    \endcode
+    is represented by TQDomComment objects in the parsed Dom tree.
+
+    For further information about the Document Object Model see
+    \link http://www.w3.org/TR/REC-DOM-Level-1/\endlink and
+    \link http://www.w3.org/TR/DOM-Level-2-Core/\endlink.
+    For a more general introduction of the DOM implementation see the
+    TQDomDocument documentation.
+*/
+
+/*!
+    Constructs an empty comment. To construct a comment with content,
+    use the TQDomDocument::createComment() function.
+*/
+TQDomComment::TQDomComment()
+    : TQDomCharacterData()
+{
+}
+
+/*!
+    Constructs a copy of \a x.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomComment::TQDomComment( const TQDomComment& x )
+    : TQDomCharacterData( x )
+{
+}
+
+TQDomComment::TQDomComment( TQDomCommentPrivate* n )
+    : TQDomCharacterData( n )
+{
+}
+
+/*!
+    Assigns \a x to this DOM comment.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomComment& TQDomComment::operator= ( const TQDomComment& x )
+{
+    return (TQDomComment&) TQDomNode::operator=( x );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+TQDomComment::~TQDomComment()
+{
+}
+
+/*!
+    Returns \c CommentNode.
+*/
+TQDomNode::NodeType TQDomComment::nodeType() const
+{
+    return CommentNode;
+}
+
+/*!
+    Returns TRUE.
+*/
+bool TQDomComment::isComment() const
+{
+    return TRUE;
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * TQDomCDATASectionPrivate
+ *
+ **************************************************************/
+
+TQDomCDATASectionPrivate::TQDomCDATASectionPrivate( TQDomDocumentPrivate* d, TQDomNodePrivate* parent,
+						    const TQString& value )
+    : TQDomTextPrivate( d, parent, value )
+{
+    name = "#cdata-section";
+}
+
+TQDomCDATASectionPrivate::TQDomCDATASectionPrivate( TQDomCDATASectionPrivate* n, bool deep )
+    : TQDomTextPrivate( n, deep )
+{
+}
+
+TQDomCDATASectionPrivate::~TQDomCDATASectionPrivate()
+{
+}
+
+TQDomNodePrivate* TQDomCDATASectionPrivate::cloneNode( bool deep)
+{
+    TQDomNodePrivate* p = new TQDomCDATASectionPrivate( this, deep );
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+void TQDomCDATASectionPrivate::save( TQTextStream& s, int, int ) const
+{
+    // ### How do we escape "]]>" ?
+    // "]]>" is not allowed; so there should be none in value anyway
+    s << "<![CDATA[" << value << "]]>";
+}
+
+/**************************************************************
+ *
+ * TQDomCDATASection
+ *
+ **************************************************************/
+
+#define IMPL ((TQDomCDATASectionPrivate*)impl)
+
+/*!
+    \class TQDomCDATASection qdom.h
+    \reentrant
+    \brief The TQDomCDATASection class represents an XML CDATA section.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    CDATA sections are used to escape blocks of text containing
+    characters that would otherwise be regarded as markup. The only
+    delimiter that is recognized in a CDATA section is the "]]&gt;"
+    string that terminates the CDATA section. CDATA sections cannot be
+    nested. Their primary purpose is for including material such as
+    XML fragments, without needing to escape all the delimiters.
+
+    Adjacent TQDomCDATASection nodes are not merged by the
+    TQDomNode::normalize() function.
+
+    For further information about the Document Object Model see
+    \link http://www.w3.org/TR/REC-DOM-Level-1/\endlink and
+    \link http://www.w3.org/TR/DOM-Level-2-Core/\endlink.
+    For a more general introduction of the DOM implementation see the
+    TQDomDocument documentation.
+*/
+
+/*!
+    Constructs an empty CDATA section. To create a CDATA section with
+    content, use the TQDomDocument::createCDATASection() function.
+*/
+TQDomCDATASection::TQDomCDATASection()
+    : TQDomText()
+{
+}
+
+/*!
+    Constructs a copy of \a x.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomCDATASection::TQDomCDATASection( const TQDomCDATASection& x )
+    : TQDomText( x )
+{
+}
+
+TQDomCDATASection::TQDomCDATASection( TQDomCDATASectionPrivate* n )
+    : TQDomText( n )
+{
+}
+
+/*!
+    Assigns \a x to this CDATA section.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomCDATASection& TQDomCDATASection::operator= ( const TQDomCDATASection& x )
+{
+    return (TQDomCDATASection&) TQDomNode::operator=( x );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+TQDomCDATASection::~TQDomCDATASection()
+{
+}
+
+/*!
+    Returns \c CDATASection.
+*/
+TQDomNode::NodeType TQDomCDATASection::nodeType() const
+{
+    return CDATASectionNode;
+}
+
+/*!
+    Returns TRUE.
+*/
+bool TQDomCDATASection::isCDATASection() const
+{
+    return TRUE;
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * TQDomNotationPrivate
+ *
+ **************************************************************/
+
+TQDomNotationPrivate::TQDomNotationPrivate( TQDomDocumentPrivate* d, TQDomNodePrivate* parent,
+					    const TQString& aname,
+					    const TQString& pub, const TQString& sys )
+    : TQDomNodePrivate( d, parent )
+{
+    name = aname;
+    m_pub = pub;
+    m_sys = sys;
+}
+
+TQDomNotationPrivate::TQDomNotationPrivate( TQDomNotationPrivate* n, bool deep )
+    : TQDomNodePrivate( n, deep )
+{
+    m_sys = n->m_sys;
+    m_pub = n->m_pub;
+}
+
+TQDomNotationPrivate::~TQDomNotationPrivate()
+{
+}
+
+TQDomNodePrivate* TQDomNotationPrivate::cloneNode( bool deep)
+{
+    TQDomNodePrivate* p = new TQDomNotationPrivate( this, deep );
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+void TQDomNotationPrivate::save( TQTextStream& s, int, int ) const
+{
+    s << "<!NOTATION " << name << " ";
+    if ( !m_pub.isNull() )  {
+	s << "PUBLIC \"" << m_pub << "\"";
+	if ( !m_sys.isNull() )
+	    s << " \"" << m_sys << "\"";
+    }  else {
+	s << "SYSTEM \"" << m_sys << "\"";
+    }
+    s << ">" << endl;
+}
+
+/**************************************************************
+ *
+ * TQDomNotation
+ *
+ **************************************************************/
+
+#define IMPL ((TQDomNotationPrivate*)impl)
+
+/*!
+    \class TQDomNotation qdom.h
+    \reentrant
+    \brief The TQDomNotation class represents an XML notation.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    A notation either declares, by name, the format of an unparsed
+    entity (see section 4.7 of the XML 1.0 specification), or is used
+    for formal declaration of processing instruction targets (see
+    section 2.6 of the XML 1.0 specification).
+
+    DOM does not support editing notation nodes; they are therefore
+    read-only.
+
+    A notation node does not have any parent.
+
+    You can retrieve the publicId() and systemId() from a notation
+    node.
+
+    For further information about the Document Object Model see
+    \link http://www.w3.org/TR/REC-DOM-Level-1/\endlink and
+    \link http://www.w3.org/TR/DOM-Level-2-Core/\endlink.
+    For a more general introduction of the DOM implementation see the
+    TQDomDocument documentation.
+*/
+
+
+/*!
+    Constructor.
+*/
+TQDomNotation::TQDomNotation()
+    : TQDomNode()
+{
+}
+
+/*!
+    Constructs a copy of \a x.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomNotation::TQDomNotation( const TQDomNotation& x )
+    : TQDomNode( x )
+{
+}
+
+TQDomNotation::TQDomNotation( TQDomNotationPrivate* n )
+    : TQDomNode( n )
+{
+}
+
+/*!
+    Assigns \a x to this DOM notation.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomNotation& TQDomNotation::operator= ( const TQDomNotation& x )
+{
+    return (TQDomNotation&) TQDomNode::operator=( x );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+TQDomNotation::~TQDomNotation()
+{
+}
+
+/*!
+    Returns \c NotationNode.
+*/
+TQDomNode::NodeType TQDomNotation::nodeType() const
+{
+    return NotationNode;
+}
+
+/*!
+    Returns the public identifier of this notation.
+*/
+TQString TQDomNotation::publicId() const
+{
+    if ( !impl )
+	return TQString::null;
+    return IMPL->m_pub;
+}
+
+/*!
+    Returns the system identifier of this notation.
+*/
+TQString TQDomNotation::systemId() const
+{
+    if ( !impl )
+	return TQString::null;
+    return IMPL->m_sys;
+}
+
+/*!
+    Returns TRUE.
+*/
+bool TQDomNotation::isNotation() const
+{
+    return TRUE;
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * TQDomEntityPrivate
+ *
+ **************************************************************/
+
+TQDomEntityPrivate::TQDomEntityPrivate( TQDomDocumentPrivate* d, TQDomNodePrivate* parent,
+					const TQString& aname,
+					const TQString& pub, const TQString& sys, const TQString& notation )
+    : TQDomNodePrivate( d, parent )
+{
+    name = aname;
+    m_pub = pub;
+    m_sys = sys;
+    m_notationName = notation;
+}
+
+TQDomEntityPrivate::TQDomEntityPrivate( TQDomEntityPrivate* n, bool deep )
+    : TQDomNodePrivate( n, deep )
+{
+    m_sys = n->m_sys;
+    m_pub = n->m_pub;
+    m_notationName = n->m_notationName;
+}
+
+TQDomEntityPrivate::~TQDomEntityPrivate()
+{
+}
+
+TQDomNodePrivate* TQDomEntityPrivate::cloneNode( bool deep)
+{
+    TQDomNodePrivate* p = new TQDomEntityPrivate( this, deep );
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+/*
+  Encode an entity value upon saving.
+*/
+static TQCString encodeEntity( const TQCString& str )
+{
+    TQCString tmp( str );
+    uint len = tmp.length();
+    uint i = 0;
+    const char* d = tmp.data();
+    while ( i < len ) {
+	if ( d[i] == '%' ){
+	    tmp.replace( i, 1, "&#60;" );
+	    d = tmp.data();
+	    len += 4;
+	    i += 5;
+	}
+	else if ( d[i] == '"' ) {
+	    tmp.replace( i, 1, "&#34;" );
+	    d = tmp.data();
+	    len += 4;
+	    i += 5;
+	} else if ( d[i] == '&' && i + 1 < len && d[i+1] == '#' ) {
+	    // Dont encode &lt; or &quot; or &custom;.
+	    // Only encode character references
+	    tmp.replace( i, 1, "&#38;" );
+	    d = tmp.data();
+	    len += 4;
+	    i += 5;
+	} else {
+	    ++i;
+	}
+    }
+
+    return tmp;
+}
+
+void TQDomEntityPrivate::save( TQTextStream& s, int, int ) const
+{
+    if ( m_sys.isNull() && m_pub.isNull() ) {
+	s << "<!ENTITY " << name << " \"" << encodeEntity( value.utf8() ) << "\">" << endl;
+    } else {
+	s << "<!ENTITY " << name << " ";
+	if ( m_pub.isNull() ) {
+	    s << "SYSTEM \"" << m_sys << "\"";
+	} else {
+	    s << "PUBLIC \"" << m_pub << "\" \"" << m_sys << "\"";
+	}
+	if (! m_notationName.isNull() ) {
+	    s << " NDATA " << m_notationName;
+	}
+	s << ">" << endl;
+    }
+}
+
+/**************************************************************
+ *
+ * TQDomEntity
+ *
+ **************************************************************/
+
+#define IMPL ((TQDomEntityPrivate*)impl)
+
+/*!
+    \class TQDomEntity qdom.h
+    \reentrant
+    \brief The TQDomEntity class represents an XML entity.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    This class represents an entity in an XML document, either parsed
+    or unparsed. Note that this models the entity itself not the
+    entity declaration.
+
+    DOM does not support editing entity nodes; if a user wants to make
+    changes to the contents of an entity, every related
+    TQDomEntityReference node must be replaced in the DOM tree by a
+    clone of the entity's contents, and then the desired changes must
+    be made to each of the clones instead. All the descendents of an
+    entity node are read-only.
+
+    An entity node does not have any parent.
+
+    You can access the entity's publicId(), systemId() and
+    notationName() when available.
+
+    For further information about the Document Object Model see
+    \link http://www.w3.org/TR/REC-DOM-Level-1/\endlink and
+    \link http://www.w3.org/TR/DOM-Level-2-Core/\endlink.
+    For a more general introduction of the DOM implementation see the
+    TQDomDocument documentation.
+*/
+
+
+/*!
+    Constructs an empty entity.
+*/
+TQDomEntity::TQDomEntity()
+    : TQDomNode()
+{
+}
+
+
+/*!
+    Constructs a copy of \a x.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomEntity::TQDomEntity( const TQDomEntity& x )
+    : TQDomNode( x )
+{
+}
+
+TQDomEntity::TQDomEntity( TQDomEntityPrivate* n )
+    : TQDomNode( n )
+{
+}
+
+/*!
+    Assigns \a x to this DOM entity.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomEntity& TQDomEntity::operator= ( const TQDomEntity& x )
+{
+    return (TQDomEntity&) TQDomNode::operator=( x );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+TQDomEntity::~TQDomEntity()
+{
+}
+
+/*!
+    Returns \c EntityNode.
+*/
+TQDomNode::NodeType TQDomEntity::nodeType() const
+{
+    return EntityNode;
+}
+
+/*!
+    Returns the public identifier associated with this entity. If the
+    public identifier was not specified TQString::null is returned.
+*/
+TQString TQDomEntity::publicId() const
+{
+    if ( !impl )
+	return TQString::null;
+    return IMPL->m_pub;
+}
+
+/*!
+    Returns the system identifier associated with this entity. If the
+    system identifier was not specified TQString::null is returned.
+*/
+TQString TQDomEntity::systemId() const
+{
+    if ( !impl )
+	return TQString::null;
+    return IMPL->m_sys;
+}
+
+/*!
+    For unparsed entities this function returns the name of the
+    notation for the entity. For parsed entities this function returns
+    TQString::null.
+*/
+TQString TQDomEntity::notationName() const
+{
+    if ( !impl )
+	return TQString::null;
+    return IMPL->m_notationName;
+}
+
+/*!
+    Returns TRUE.
+*/
+bool TQDomEntity::isEntity() const
+{
+    return TRUE;
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * TQDomEntityReferencePrivate
+ *
+ **************************************************************/
+
+TQDomEntityReferencePrivate::TQDomEntityReferencePrivate( TQDomDocumentPrivate* d, TQDomNodePrivate* parent, const TQString& aname )
+    : TQDomNodePrivate( d, parent )
+{
+    name = aname;
+}
+
+TQDomEntityReferencePrivate::TQDomEntityReferencePrivate( TQDomNodePrivate* n, bool deep )
+    : TQDomNodePrivate( n, deep )
+{
+}
+
+TQDomEntityReferencePrivate::~TQDomEntityReferencePrivate()
+{
+}
+
+TQDomNodePrivate* TQDomEntityReferencePrivate::cloneNode( bool deep)
+{
+    TQDomNodePrivate* p = new TQDomEntityReferencePrivate( this, deep );
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+void TQDomEntityReferencePrivate::save( TQTextStream& s, int, int ) const
+{
+    s << "&" << name << ";";
+}
+
+/**************************************************************
+ *
+ * TQDomEntityReference
+ *
+ **************************************************************/
+
+#define IMPL ((TQDomEntityReferencePrivate*)impl)
+
+/*!
+    \class TQDomEntityReference qdom.h
+    \reentrant
+    \brief The TQDomEntityReference class represents an XML entity reference.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    A TQDomEntityReference object may be inserted into the DOM tree
+    when an entity reference is in the source document, or when the
+    user wishes to insert an entity reference.
+
+    Note that character references and references to predefined
+    entities are expanded by the XML processor so that characters are
+    represented by their Unicode equivalent rather than by an entity
+    reference.
+
+    Moreover, the XML processor may completely expand references to
+    entities while building the DOM tree, instead of providing
+    TQDomEntityReference objects.
+
+    If it does provide such objects, then for a given entity reference
+    node, it may be that there is no entity node representing the
+    referenced entity; but if such an entity exists, then the child
+    list of the entity reference node is the same as that of the
+    entity  node. As with the entity node, all descendents of the
+    entity reference are read-only.
+
+    For further information about the Document Object Model see
+    \link http://www.w3.org/TR/REC-DOM-Level-1/\endlink and
+    \link http://www.w3.org/TR/DOM-Level-2-Core/\endlink.
+    For a more general introduction of the DOM implementation see the
+    TQDomDocument documentation.
+*/
+
+/*!
+    Constructs an empty entity reference. Use
+    TQDomDocument::createEntityReference() to create a entity reference
+    with content.
+*/
+TQDomEntityReference::TQDomEntityReference()
+    : TQDomNode()
+{
+}
+
+/*!
+    Constructs a copy of \a x.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomEntityReference::TQDomEntityReference( const TQDomEntityReference& x )
+    : TQDomNode( x )
+{
+}
+
+TQDomEntityReference::TQDomEntityReference( TQDomEntityReferencePrivate* n )
+    : TQDomNode( n )
+{
+}
+
+/*!
+    Assigns \a x to this entity reference.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomEntityReference& TQDomEntityReference::operator= ( const TQDomEntityReference& x )
+{
+    return (TQDomEntityReference&) TQDomNode::operator=( x );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+TQDomEntityReference::~TQDomEntityReference()
+{
+}
+
+/*!
+    Returns \c EntityReference.
+*/
+TQDomNode::NodeType TQDomEntityReference::nodeType() const
+{
+    return EntityReferenceNode;
+}
+
+/*!
+    Returns TRUE.
+*/
+bool TQDomEntityReference::isEntityReference() const
+{
+    return TRUE;
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * TQDomProcessingInstructionPrivate
+ *
+ **************************************************************/
+
+TQDomProcessingInstructionPrivate::TQDomProcessingInstructionPrivate( TQDomDocumentPrivate* d,
+	TQDomNodePrivate* parent, const TQString& target, const TQString& data )
+    : TQDomNodePrivate( d, parent )
+{
+    name = target;
+    value = data;
+}
+
+TQDomProcessingInstructionPrivate::TQDomProcessingInstructionPrivate( TQDomProcessingInstructionPrivate* n, bool deep )
+    : TQDomNodePrivate( n, deep )
+{
+}
+
+TQDomProcessingInstructionPrivate::~TQDomProcessingInstructionPrivate()
+{
+}
+
+TQDomNodePrivate* TQDomProcessingInstructionPrivate::cloneNode( bool deep)
+{
+    TQDomNodePrivate* p = new TQDomProcessingInstructionPrivate( this, deep );
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+void TQDomProcessingInstructionPrivate::save( TQTextStream& s, int, int ) const
+{
+    s << "<?" << name << " " << value << "?>" << endl;
+}
+
+/**************************************************************
+ *
+ * TQDomProcessingInstruction
+ *
+ **************************************************************/
+
+#define IMPL ((TQDomProcessingInstructionPrivate*)impl)
+
+/*!
+    \class TQDomProcessingInstruction qdom.h
+    \reentrant
+    \brief The TQDomProcessingInstruction class represents an XML processing
+    instruction.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    Processing instructions are used in XML to keep processor-specific
+    information in the text of the document.
+
+    The content of the processing instruction is retrieved with data()
+    and set with setData(). The processing instruction's target is
+    retrieved with target().
+
+    For further information about the Document Object Model see
+    \link http://www.w3.org/TR/REC-DOM-Level-1/\endlink and
+    \link http://www.w3.org/TR/DOM-Level-2-Core/\endlink.
+    For a more general introduction of the DOM implementation see the
+    TQDomDocument documentation.
+*/
+
+/*!
+    Constructs an empty processing instruction. Use
+    TQDomDocument::createProcessingInstruction() to create a processing
+    instruction with content.
+*/
+TQDomProcessingInstruction::TQDomProcessingInstruction()
+    : TQDomNode()
+{
+}
+
+/*!
+    Constructs a copy of \a x.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomProcessingInstruction::TQDomProcessingInstruction( const TQDomProcessingInstruction& x )
+    : TQDomNode( x )
+{
+}
+
+TQDomProcessingInstruction::TQDomProcessingInstruction( TQDomProcessingInstructionPrivate* n )
+    : TQDomNode( n )
+{
+}
+
+/*!
+    Assigns \a x to this processing instruction.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomProcessingInstruction& TQDomProcessingInstruction::operator= ( const TQDomProcessingInstruction& x )
+{
+    return (TQDomProcessingInstruction&) TQDomNode::operator=( x );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+TQDomProcessingInstruction::~TQDomProcessingInstruction()
+{
+}
+
+/*!
+    Returns \c ProcessingInstructionNode.
+*/
+TQDomNode::NodeType TQDomProcessingInstruction::nodeType() const
+{
+    return ProcessingInstructionNode;
+}
+
+/*!
+    Returns the target of this processing instruction.
+
+    \sa data()
+*/
+TQString TQDomProcessingInstruction::target() const
+{
+    if ( !impl )
+	return TQString::null;
+    return impl->nodeName();
+}
+
+/*!
+    Returns the content of this processing instruction.
+
+    \sa setData() target()
+*/
+TQString TQDomProcessingInstruction::data() const
+{
+    if ( !impl )
+	return TQString::null;
+    return impl->nodeValue();
+}
+
+/*!
+    Sets the data contained in the processing instruction to \a d.
+
+    \sa data()
+*/
+void TQDomProcessingInstruction::setData( const TQString& d )
+{
+    if ( !impl )
+	return;
+    impl->setNodeValue( d );
+}
+
+/*!
+    Returns TRUE.
+*/
+bool TQDomProcessingInstruction::isProcessingInstruction() const
+{
+    return TRUE;
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * TQDomDocumentPrivate
+ *
+ **************************************************************/
+
+TQDomDocumentPrivate::TQDomDocumentPrivate()
+    : TQDomNodePrivate( 0 )
+{
+    impl = new TQDomImplementationPrivate();
+    type = new TQDomDocumentTypePrivate( this, this );
+
+    name = "#document";
+}
+
+TQDomDocumentPrivate::TQDomDocumentPrivate( const TQString& aname )
+    : TQDomNodePrivate( 0 )
+{
+    impl = new TQDomImplementationPrivate();
+    type = new TQDomDocumentTypePrivate( this, this );
+    type->name = aname;
+
+    name = "#document";
+}
+
+TQDomDocumentPrivate::TQDomDocumentPrivate( TQDomDocumentTypePrivate* dt )
+    : TQDomNodePrivate( 0 )
+{
+    impl = new TQDomImplementationPrivate();
+    if ( dt != 0 ) {
+	type = dt;
+	type->ref();
+    } else {
+	type = new TQDomDocumentTypePrivate( this, this );
+    }
+
+    name = "#document";
+}
+
+TQDomDocumentPrivate::TQDomDocumentPrivate( TQDomDocumentPrivate* n, bool deep )
+    : TQDomNodePrivate( n, deep )
+{
+    impl = n->impl->clone();
+    // Reference count is down to 0, so we set it to 1 here.
+    impl->ref();
+    type = (TQDomDocumentTypePrivate*)n->type->cloneNode();
+    type->setParent( this );
+    // Reference count is down to 0, so we set it to 1 here.
+    type->ref();
+}
+
+TQDomDocumentPrivate::~TQDomDocumentPrivate()
+{
+    if ( impl->deref() ) delete impl;
+    if ( type->deref() ) delete type;
+}
+
+void TQDomDocumentPrivate::clear()
+{
+    if ( impl->deref() ) delete impl;
+    if ( type->deref() ) delete type;
+    impl = 0;
+    type = 0;
+    TQDomNodePrivate::clear();
+}
+
+bool TQDomDocumentPrivate::setContent( TQXmlInputSource *source, bool namespaceProcessing, TQString *errorMsg, int *errorLine, int *errorColumn )
+{
+    TQXmlSimpleReader reader;
+    if ( namespaceProcessing ) {
+	reader.setFeature( "http://xml.org/sax/features/namespaces", TRUE );
+	reader.setFeature( "http://xml.org/sax/features/namespace-prefixes", FALSE );
+    } else {
+	reader.setFeature( "http://xml.org/sax/features/namespaces", FALSE );
+	reader.setFeature( "http://xml.org/sax/features/namespace-prefixes", TRUE );
+    }
+    reader.setFeature( "http://trolltech.com/xml/features/report-whitespace-only-CharData", FALSE );
+    reader.setUndefEntityInAttrHack( TRUE );
+
+    return setContent( source, &reader, errorMsg, errorLine, errorColumn );
+}
+
+bool TQDomDocumentPrivate::setContent( TQXmlInputSource *source, TQXmlReader *reader, TQString *errorMsg, int *errorLine, int *errorColumn )
+{
+    clear();
+    impl = new TQDomImplementationPrivate;
+    type = new TQDomDocumentTypePrivate( this, this );
+
+    bool namespaceProcessing = reader->feature( "http://xml.org/sax/features/namespaces" )
+	&& !reader->feature( "http://xml.org/sax/features/namespace-prefixes" );
+
+    TQDomHandler hnd( this, namespaceProcessing );
+    reader->setContentHandler( &hnd );
+    reader->setErrorHandler( &hnd );
+    reader->setLexicalHandler( &hnd );
+    reader->setDeclHandler( &hnd );
+    reader->setDTDHandler( &hnd );
+
+    if ( !reader->parse( source ) ) {
+	if ( errorMsg )
+	    *errorMsg = hnd.errorMsg;
+	if ( errorLine )
+	    *errorLine = hnd.errorLine;
+	if ( errorColumn )
+	    *errorColumn = hnd.errorColumn;
+	return FALSE;
+    }
+
+    return TRUE;
+}
+
+TQDomNodePrivate* TQDomDocumentPrivate::cloneNode( bool deep)
+{
+    TQDomNodePrivate* p = new TQDomDocumentPrivate( this, deep );
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+TQDomElementPrivate* TQDomDocumentPrivate::documentElement()
+{
+    TQDomNodePrivate* p = first;
+    while ( p && !p->isElement() )
+	p = p->next;
+
+    return (TQDomElementPrivate*)p;
+}
+
+TQDomElementPrivate* TQDomDocumentPrivate::createElement( const TQString& tagName )
+{
+    TQDomElementPrivate* e = new TQDomElementPrivate( this, 0, tagName );
+    e->deref();
+    return e;
+}
+
+TQDomElementPrivate* TQDomDocumentPrivate::createElementNS( const TQString& nsURI, const TQString& qName )
+{
+    TQDomElementPrivate* e = new TQDomElementPrivate( this, 0, nsURI, qName );
+    e->deref();
+    return e;
+}
+
+TQDomDocumentFragmentPrivate* TQDomDocumentPrivate::createDocumentFragment()
+{
+    TQDomDocumentFragmentPrivate* f = new TQDomDocumentFragmentPrivate( this, (TQDomNodePrivate*)0 );
+    f->deref();
+    return f;
+}
+
+TQDomTextPrivate* TQDomDocumentPrivate::createTextNode( const TQString& data )
+{
+    TQDomTextPrivate* t = new TQDomTextPrivate( this, 0, data );
+    t->deref();
+    return t;
+}
+
+TQDomCommentPrivate* TQDomDocumentPrivate::createComment( const TQString& data )
+{
+    TQDomCommentPrivate* c = new TQDomCommentPrivate( this, 0, data );
+    c->deref();
+    return c;
+}
+
+TQDomCDATASectionPrivate* TQDomDocumentPrivate::createCDATASection( const TQString& data )
+{
+    TQDomCDATASectionPrivate* c = new TQDomCDATASectionPrivate( this, 0, data );
+    c->deref();
+    return c;
+}
+
+TQDomProcessingInstructionPrivate* TQDomDocumentPrivate::createProcessingInstruction( const TQString& target, const TQString& data )
+{
+    TQDomProcessingInstructionPrivate* p = new TQDomProcessingInstructionPrivate( this, 0, target, data );
+    p->deref();
+    return p;
+}
+
+TQDomAttrPrivate* TQDomDocumentPrivate::createAttribute( const TQString& aname )
+{
+    TQDomAttrPrivate* a = new TQDomAttrPrivate( this, 0, aname );
+    a->deref();
+    return a;
+}
+
+TQDomAttrPrivate* TQDomDocumentPrivate::createAttributeNS( const TQString& nsURI, const TQString& qName )
+{
+    TQDomAttrPrivate* a = new TQDomAttrPrivate( this, 0, nsURI, qName );
+    a->deref();
+    return a;
+}
+
+TQDomEntityReferencePrivate* TQDomDocumentPrivate::createEntityReference( const TQString& aname )
+{
+    TQDomEntityReferencePrivate* e = new TQDomEntityReferencePrivate( this, 0, aname );
+    e->deref();
+    return e;
+}
+
+TQDomNodePrivate* TQDomDocumentPrivate::importNode( const TQDomNodePrivate* importedNode, bool deep )
+{
+    TQDomNodePrivate *node = 0;
+    switch ( importedNode->nodeType() ) {
+	case TQDomNode::AttributeNode:
+	    node = new TQDomAttrPrivate( (TQDomAttrPrivate*)importedNode, TRUE );
+	    break;
+	case TQDomNode::DocumentFragmentNode:
+	    node = new TQDomDocumentFragmentPrivate( (TQDomDocumentFragmentPrivate*)importedNode, deep );
+	    break;
+	case TQDomNode::ElementNode:
+	    node = new TQDomElementPrivate( (TQDomElementPrivate*)importedNode, deep );
+	    break;
+	case TQDomNode::EntityNode:
+	    node = new TQDomEntityPrivate( (TQDomEntityPrivate*)importedNode, deep );
+	    break;
+	case TQDomNode::EntityReferenceNode:
+	    node = new TQDomEntityReferencePrivate( (TQDomEntityReferencePrivate*)importedNode, FALSE );
+	    break;
+	case TQDomNode::NotationNode:
+	    node = new TQDomNotationPrivate( (TQDomNotationPrivate*)importedNode, deep );
+	    break;
+	case TQDomNode::ProcessingInstructionNode:
+	    node = new TQDomProcessingInstructionPrivate( (TQDomProcessingInstructionPrivate*)importedNode, deep );
+	    break;
+	case TQDomNode::TextNode:
+	    node = new TQDomTextPrivate( (TQDomTextPrivate*)importedNode, deep );
+	    break;
+	case TQDomNode::CDATASectionNode:
+	    node = new TQDomCDATASectionPrivate( (TQDomCDATASectionPrivate*)importedNode, deep );
+	    break;
+	case TQDomNode::CommentNode:
+	    node = new TQDomCommentPrivate( (TQDomCommentPrivate*)importedNode, deep );
+	    break;
+	default:
+	    break;
+    }
+    if ( node ) {
+	node->setOwnerDocument( this );
+	// The TQDomNode constructor increases the refcount, so deref() first to
+	// keep refcount balanced.
+	node->deref();
+    }
+    return node;
+}
+
+void TQDomDocumentPrivate::save( TQTextStream& s, int, int indent ) const
+{
+    bool doc = FALSE;
+
+    TQDomNodePrivate* n = first;
+    if ( n && n->isProcessingInstruction() && n->nodeName()=="xml" ) {
+	// we have an XML declaration
+	TQString data = n->nodeValue();
+	TQRegExp encoding( TQString::fromLatin1("encoding\\s*=\\s*((\"([^\"]*)\")|('([^']*)'))") );
+	encoding.search( data );
+	TQString enc = encoding.cap(3);
+	if ( enc.isEmpty() ) {
+	    enc = encoding.cap(5);
+	}
+	if ( enc.isEmpty() ) {
+	    s.setEncoding( TQTextStream::UnicodeUTF8 );
+	} else {
+	    s.setCodec( TQTextCodec::codecForName( enc ) );
+	}
+    } else {
+	s.setEncoding( TQTextStream::UnicodeUTF8 );
+    }
+    while ( n ) {
+	if ( !doc && !(n->isProcessingInstruction()&&n->nodeName()=="xml") ) {
+	    // save doctype after XML declaration
+	    type->save( s, 0, indent );
+	    doc = TRUE;
+	}
+	n->save( s, 0, indent );
+	n = n->next;
+    }
+}
+
+/**************************************************************
+ *
+ * TQDomDocument
+ *
+ **************************************************************/
+
+#define IMPL ((TQDomDocumentPrivate*)impl)
+
+/*!
+    \class TQDomDocument qdom.h
+    \reentrant
+    \brief The TQDomDocument class represents an XML document.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    The TQDomDocument class represents the entire XML document.
+    Conceptually, it is the root of the document tree, and provides
+    the primary access to the document's data.
+
+    Since elements, text nodes, comments, processing instructions,
+    etc., cannot exist outside the context of a document, the document
+    class also contains the factory functions needed to create these
+    objects. The node objects created have an ownerDocument() function
+    which associates them with the document within whose context they
+    were created. The DOM classes that will be used most often are
+    TQDomNode, TQDomDocument, TQDomElement and TQDomText.
+
+    The parsed XML is represented internally by a tree of objects that
+    can be accessed using the various TQDom classes. All TQDom classes
+    only \e reference objects in the internal tree. The internal
+    objects in the DOM tree will get deleted once the last TQDom
+    object referencing them and the TQDomDocument itself are deleted.
+
+    Creation of elements, text nodes, etc. is done using the various
+    factory functions provided in this class. Using the default
+    constructors of the TQDom classes will only result in empty
+    objects that cannot be manipulated or inserted into the Document.
+
+    The TQDomDocument class has several functions for creating document
+    data, for example, createElement(), createTextNode(),
+    createComment(), createCDATASection(),
+    createProcessingInstruction(), createAttribute() and
+    createEntityReference(). Some of these functions have versions
+    that support namespaces, i.e. createElementNS() and
+    createAttributeNS(). The createDocumentFragment() function is used
+    to hold parts of the document; this is useful for manipulating for
+    complex documents.
+
+    The entire content of the document is set with setContent(). This
+    function parses the string it is passed as an XML document and
+    creates the DOM tree that represents the document. The root
+    element is available using documentElement(). The textual
+    representation of the document can be obtained using toString().
+
+    It is possible to insert a node from another document into the
+    document using importNode().
+
+    You can obtain a list of all the elements that have a particular
+    tag with elementsByTagName() or with elementsByTagNameNS().
+
+    The TQDom classes are typically used as follows:
+    \code
+    TQDomDocument doc( "mydocument" );
+    TQFile file( "mydocument.xml" );
+    if ( !file.open( IO_ReadOnly ) )
+	return;
+    if ( !doc.setContent( &file ) ) {
+	file.close();
+	return;
+    }
+    file.close();
+
+    // print out the element names of all elements that are direct children
+    // of the outermost element.
+    TQDomElement docElem = doc.documentElement();
+
+    TQDomNode n = docElem.firstChild();
+    while( !n.isNull() ) {
+	TQDomElement e = n.toElement(); // try to convert the node to an element.
+	if( !e.isNull() ) {
+	    cout << e.tagName() << endl; // the node really is an element.
+	}
+	n = n.nextSibling();
+    }
+
+    // Here we append a new element to the end of the document
+    TQDomElement elem = doc.createElement( "img" );
+    elem.setAttribute( "src", "myimage.png" );
+    docElem.appendChild( elem );
+    \endcode
+
+    Once \c doc and \c elem go out of scope, the whole internal tree
+    representing the XML document is deleted.
+
+    To create a document using DOM use code like this:
+    \code
+    TQDomDocument doc( "MyML" );
+    TQDomElement root = doc.createElement( "MyML" );
+    doc.appendChild( root );
+
+    TQDomElement tag = doc.createElement( "Greeting" );
+    root.appendChild( tag );
+
+    TQDomText t = doc.createTextNode( "Hello World" );
+    tag.appendChild( t );
+
+    TQString xml = doc.toString();
+    \endcode
+
+    For further information about the Document Object Model see
+    \link http://www.w3.org/TR/REC-DOM-Level-1/\endlink and
+    \link http://www.w3.org/TR/DOM-Level-2-Core/\endlink.
+    For a more general introduction of the DOM implementation see the
+    TQDomDocument documentation.
+*/
+
+
+/*!
+    Constructs an empty document.
+*/
+TQDomDocument::TQDomDocument()
+{
+    impl = 0;
+}
+
+/*!
+    Creates a document and sets the name of the document type to \a
+    name.
+*/
+TQDomDocument::TQDomDocument( const TQString& name )
+{
+    // We take over ownership
+    impl = new TQDomDocumentPrivate( name );
+}
+
+/*!
+    Creates a document with the document type \a doctype.
+
+    \sa TQDomImplementation::createDocumentType()
+*/
+TQDomDocument::TQDomDocument( const TQDomDocumentType& doctype )
+{
+    impl = new TQDomDocumentPrivate( (TQDomDocumentTypePrivate*)(doctype.impl) );
+}
+
+/*!
+    Constructs a copy of \a x.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomDocument::TQDomDocument( const TQDomDocument& x )
+    : TQDomNode( x )
+{
+}
+
+TQDomDocument::TQDomDocument( TQDomDocumentPrivate* x )
+    : TQDomNode( x )
+{
+}
+
+/*!
+    Assigns \a x to this DOM document.
+
+    The data of the copy is shared (shallow copy): modifying one node
+    will also change the other. If you want to make a deep copy, use
+    cloneNode().
+*/
+TQDomDocument& TQDomDocument::operator= ( const TQDomDocument& x )
+{
+    return (TQDomDocument&) TQDomNode::operator=( x );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+TQDomDocument::~TQDomDocument()
+{
+}
+
+/*!
+    \overload
+
+    This function reads the XML document from the string \a text.
+    Since \a text is already a Unicode string, no encoding detection
+    is done.
+*/
+bool TQDomDocument::setContent( const TQString& text, bool namespaceProcessing, TQString *errorMsg, int *errorLine, int *errorColumn )
+{
+    if ( !impl )
+	impl = new TQDomDocumentPrivate;
+    TQXmlInputSource source;
+    source.setData( text );
+    return IMPL->setContent( &source, namespaceProcessing, errorMsg, errorLine, errorColumn );
+}
+
+/*!
+    This function parses the XML document from the byte array \a
+    buffer and sets it as the content of the document. It tries to
+    detect the encoding of the document as retquired by the XML
+    specification.
+
+    If \a namespaceProcessing is TRUE, the parser recognizes
+    namespaces in the XML file and sets the prefix name, local name
+    and namespace URI to appropriate values. If \a namespaceProcessing
+    is FALSE, the parser does no namespace processing when it reads
+    the XML file.
+
+    If a parse error occurs, the function returns FALSE; otherwise it
+    returns TRUE. If a parse error occurs and \a errorMsg, \a
+    errorLine and \a errorColumn are not 0, the error message is
+    placed in \a *errorMsg, the line number \a *errorLine and the
+    column number in \a *errorColumn.
+
+    If \a namespaceProcessing is TRUE, the function TQDomNode::prefix()
+    returns a string for all elements and attributes. It returns an
+    empty string if the element or attribute has no prefix.
+
+    If \a namespaceProcessing is FALSE, the functions
+    TQDomNode::prefix(), TQDomNode::localName() and
+    TQDomNode::namespaceURI() return TQString::null.
+
+    \sa TQDomNode::namespaceURI() TQDomNode::localName()
+    TQDomNode::prefix() TQString::isNull() TQString::isEmpty()
+*/
+bool TQDomDocument::setContent( const TQByteArray& buffer, bool namespaceProcessing, TQString *errorMsg, int *errorLine, int *errorColumn )
+{
+    if ( !impl )
+	impl = new TQDomDocumentPrivate;
+    TQBuffer buf( buffer );
+    TQXmlInputSource source( &buf );
+    return IMPL->setContent( &source, namespaceProcessing, errorMsg, errorLine, errorColumn );
+}
+
+/*!
+    \overload
+
+    This function reads the XML document from the C string \a buffer.
+
+    \warning This function does not try to detect the encoding:
+    instead it assumes that the C string is UTF-8 encoded.
+*/
+bool TQDomDocument::setContent( const TQCString& buffer, bool namespaceProcessing, TQString *errorMsg, int *errorLine, int *errorColumn )
+{
+    return setContent( TQString::fromUtf8( buffer, buffer.length() ), namespaceProcessing, errorMsg, errorLine, errorColumn );
+}
+
+/*!
+    \overload
+
+    This function reads the XML document from the IO device \a dev.
+*/
+bool TQDomDocument::setContent( TQIODevice* dev, bool namespaceProcessing, TQString *errorMsg, int *errorLine, int *errorColumn )
+{
+    if ( !impl )
+	impl = new TQDomDocumentPrivate;
+    TQXmlInputSource source( dev );
+    return IMPL->setContent( &source, namespaceProcessing, errorMsg, errorLine, errorColumn );
+}
+
+/*!
+    \overload
+
+    This function reads the XML document from the string \a text.
+    Since \a text is already a Unicode string, no encoding detection
+    is performed.
+
+    No namespace processing is performed either.
+*/
+bool TQDomDocument::setContent( const TQString& text, TQString *errorMsg, int *errorLine, int *errorColumn )
+{
+    return setContent( text, FALSE, errorMsg, errorLine, errorColumn );
+}
+
+/*!
+    \overload
+
+    This function reads the XML document from the byte array \a
+    buffer.
+
+    No namespace processing is performed.
+*/
+bool TQDomDocument::setContent( const TQByteArray& buffer, TQString *errorMsg, int *errorLine, int *errorColumn  )
+{
+    return setContent( buffer, FALSE, errorMsg, errorLine, errorColumn );
+}
+
+/*!
+    \overload
+
+    This function reads the XML document from the C string \a buffer.
+
+    No namespace processing is performed.
+
+    \warning This function does not try to detect the encoding:
+    instead it assumes that the C string is UTF-8 encoded.
+*/
+bool TQDomDocument::setContent( const TQCString& buffer, TQString *errorMsg, int *errorLine, int *errorColumn  )
+{
+    return setContent( buffer, FALSE, errorMsg, errorLine, errorColumn );
+}
+
+/*!
+    \overload
+
+    This function reads the XML document from the IO device \a dev.
+
+    No namespace processing is performed.
+*/
+bool TQDomDocument::setContent( TQIODevice* dev, TQString *errorMsg, int *errorLine, int *errorColumn  )
+{
+    return setContent( dev, FALSE, errorMsg, errorLine, errorColumn );
+}
+
+/*!
+    \overload
+
+    This function reads the XML document from the TQXmlInputSource \a source and
+    parses it with the TQXmlReader \a reader.
+
+    This function doesn't change the features of the \a reader. If you want to
+    use certain features for parsing you can use this function to set up the
+    reader appropriate.
+
+    \sa TQXmlSimpleReader
+*/
+bool TQDomDocument::setContent( TQXmlInputSource *source, TQXmlReader *reader, TQString *errorMsg, int *errorLine, int *errorColumn  )
+{
+    if ( !impl )
+	impl = new TQDomDocumentPrivate;
+    return IMPL->setContent( source, reader, errorMsg, errorLine, errorColumn );
+}
+
+/*!
+    Converts the parsed document back to its textual representation.
+
+    \sa toCString()
+*/
+TQString TQDomDocument::toString() const
+{
+    TQString str;
+    TQTextStream s( str, IO_WriteOnly );
+    save( s, 1 );
+
+    return str;
+}
+
+/*!
+    \overload
+
+    This function uses \a indent as the amount of space to indent
+    subelements.
+*/
+TQString TQDomDocument::toString( int indent ) const
+{
+    TQString str;
+    TQTextStream s( str, IO_WriteOnly );
+    save( s, indent );
+
+    return str;
+}
+
+/*!
+    Converts the parsed document back to its textual representation
+    and returns a TQCString for that is encoded in UTF-8.
+
+    \sa toString()
+*/
+TQCString TQDomDocument::toCString() const
+{
+    // ### if there is an encoding specified in the xml declaration, this
+    // encoding declaration should be changed to utf8
+    return toString().utf8();
+}
+
+/*!
+    \overload
+
+    This function uses \a indent as the amount of space to indent
+    subelements.
+*/
+TQCString TQDomDocument::toCString( int indent ) const
+{
+    // ### if there is an encoding specified in the xml declaration, this
+    // encoding declaration should be changed to utf8
+    return toString( indent ).utf8();
+}
+
+
+/*!
+    Returns the document type of this document.
+*/
+TQDomDocumentType TQDomDocument::doctype() const
+{
+    if ( !impl )
+	return TQDomDocumentType();
+    return TQDomDocumentType( IMPL->doctype() );
+}
+
+/*!
+    Returns a TQDomImplementation object.
+*/
+TQDomImplementation TQDomDocument::implementation() const
+{
+    if ( !impl )
+	return TQDomImplementation();
+    return TQDomImplementation( IMPL->implementation() );
+}
+
+/*!
+    Returns the root element of the document.
+*/
+TQDomElement TQDomDocument::documentElement() const
+{
+    if ( !impl )
+	return TQDomElement();
+    return TQDomElement( IMPL->documentElement() );
+}
+
+/*!
+    Creates a new element called \a tagName that can be inserted into
+    the DOM tree, e.g. using TQDomNode::appendChild().
+
+    \sa createElementNS() TQDomNode::appendChild() TQDomNode::insertBefore()
+    TQDomNode::insertAfter()
+*/
+TQDomElement TQDomDocument::createElement( const TQString& tagName )
+{
+    if ( !impl )
+        impl = new TQDomDocumentPrivate;
+    return TQDomElement( IMPL->createElement( tagName ) );
+}
+
+/*!
+    Creates a new document fragment, that can be used to hold parts of
+    the document, e.g. when doing complex manipulations of the
+    document tree.
+*/
+TQDomDocumentFragment TQDomDocument::createDocumentFragment()
+{
+    if ( !impl )
+        impl = new TQDomDocumentPrivate;
+    return TQDomDocumentFragment( IMPL->createDocumentFragment() );
+}
+
+/*!
+    Creates a text node for the string \a value that can be inserted
+    into the document tree, e.g. using TQDomNode::appendChild().
+
+    \warning All characters within an XML document must be in the range:
+
+    #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
+
+    This rule also applies to characters encoded as character entities and
+    characters in CDATA sections. If you use this function to insert
+    characters outside of this range, the document will not be well-formed.
+
+    If you want to store binary data in an XML document you must either use
+    your own scheme to escape illegal characters, or you must store it in
+    an external unparsed entity.
+
+    \sa TQDomNode::appendChild() TQDomNode::insertBefore() TQDomNode::insertAfter()
+*/
+TQDomText TQDomDocument::createTextNode( const TQString& value )
+{
+    if ( !impl )
+        impl = new TQDomDocumentPrivate;
+    return TQDomText( IMPL->createTextNode( value ) );
+}
+
+/*!
+    Creates a new comment for the string \a value that can be inserted
+    into the document, e.g. using TQDomNode::appendChild().
+
+    \sa TQDomNode::appendChild() TQDomNode::insertBefore() TQDomNode::insertAfter()
+*/
+TQDomComment TQDomDocument::createComment( const TQString& value )
+{
+    if ( !impl )
+        impl = new TQDomDocumentPrivate;
+    return TQDomComment( IMPL->createComment( value ) );
+}
+
+/*!
+    Creates a new CDATA section for the string \a value that can be
+    inserted into the document, e.g. using TQDomNode::appendChild().
+
+    \sa TQDomNode::appendChild() TQDomNode::insertBefore() TQDomNode::insertAfter()
+*/
+TQDomCDATASection TQDomDocument::createCDATASection( const TQString& value )
+{
+    if ( !impl )
+        impl = new TQDomDocumentPrivate;
+    return TQDomCDATASection( IMPL->createCDATASection( value ) );
+}
+
+/*!
+    Creates a new processing instruction that can be inserted into the
+    document, e.g. using TQDomNode::appendChild(). This function sets
+    the target for the processing instruction to \a target and the
+    data to \a data.
+
+    \sa TQDomNode::appendChild() TQDomNode::insertBefore() TQDomNode::insertAfter()
+*/
+TQDomProcessingInstruction TQDomDocument::createProcessingInstruction( const TQString& target,
+								     const TQString& data )
+{
+    if ( !impl )
+        impl = new TQDomDocumentPrivate;
+    return TQDomProcessingInstruction( IMPL->createProcessingInstruction( target, data ) );
+}
+
+
+/*!
+    Creates a new attribute called \a name that can be inserted into
+    an element, e.g. using TQDomElement::setAttributeNode().
+
+    \sa createAttributeNS()
+*/
+TQDomAttr TQDomDocument::createAttribute( const TQString& name )
+{
+    if ( !impl )
+        impl = new TQDomDocumentPrivate;
+    return TQDomAttr( IMPL->createAttribute( name ) );
+}
+
+/*!
+    Creates a new entity reference called \a name that can be inserted
+    into the document, e.g. using TQDomNode::appendChild().
+
+    \sa TQDomNode::appendChild() TQDomNode::insertBefore() TQDomNode::insertAfter()
+*/
+TQDomEntityReference TQDomDocument::createEntityReference( const TQString& name )
+{
+    if ( !impl )
+        impl = new TQDomDocumentPrivate;
+    return TQDomEntityReference( IMPL->createEntityReference( name ) );
+}
+
+/*!
+    Returns a TQDomNodeList, that contains all the elements in the
+    document with the name \a tagname. The order of the node list is
+    the order they are encountered in a preorder traversal of the
+    element tree.
+
+    \sa elementsByTagNameNS() TQDomElement::elementsByTagName()
+*/
+TQDomNodeList TQDomDocument::elementsByTagName( const TQString& tagname ) const
+{
+    return TQDomNodeList( new TQDomNodeListPrivate( impl, tagname ) );
+}
+
+/*!
+    Imports the node \a importedNode from another document to this
+    document. \a importedNode remains in the original document; this
+    function creates a copy that can be used within this document.
+
+    This function returns the imported node that belongs to this
+    document. The returned node has no parent. It is not possible to
+    import TQDomDocument and TQDomDocumentType nodes. In those cases
+    this function returns a \link TQDomNode::isNull() null node\endlink.
+
+    If \a deep is TRUE, this function imports not only the node \a
+    importedNode but its whole subtree; if it is FALSE, only the \a
+    importedNode is imported. The argument \a deep has no effect on
+    TQDomAttr and TQDomEntityReference nodes, since the descendents of
+    TQDomAttr nodes are always imported and those of
+    TQDomEntityReference nodes are never imported.
+
+    The behavior of this function is slightly different depending on
+    the node types:
+    \table
+    \header \i Node Type \i Behaviour
+    \row \i TQDomAttr
+	 \i The owner element is set to 0 and the specified flag is
+	    set to TRUE in the generated attribute. The whole subtree
+	    of \a importedNode is always imported for attribute nodes:
+	    \a deep has no effect.
+    \row \i TQDomDocument
+	 \i Document nodes cannot be imported.
+    \row \i TQDomDocumentFragment
+	 \i If \a deep is TRUE, this function imports the whole
+	    document fragment; otherwise it only generates an empty
+	    document fragment.
+    \row \i TQDomDocumentType
+	 \i Document type nodes cannot be imported.
+    \row \i TQDomElement
+	 \i Attributes for which TQDomAttr::specified() is TRUE are
+	    also imported, other attributes are not imported. If \a
+	    deep is TRUE, this function also imports the subtree of \a
+	    importedNode; otherwise it imports only the element node
+	    (and some attributes, see above).
+    \row \i TQDomEntity
+	 \i Entity nodes can be imported, but at the moment there is
+	    no way to use them since the document type is read-only in
+	    DOM level 2.
+    \row \i TQDomEntityReference
+	 \i Descendents of entity reference nodes are never imported:
+	    \a deep has no effect.
+    \row \i TQDomNotation
+	 \i Notation nodes can be imported, but at the moment there is
+	    no way to use them since the document type is read-only in
+	    DOM level 2.
+    \row \i TQDomProcessingInstruction
+	 \i The target and value of the processing instruction is
+	    copied to the new node.
+    \row \i TQDomText
+	 \i The text is copied to the new node.
+    \row \i TQDomCDATASection
+	 \i The text is copied to the new node.
+    \row \i TQDomComment
+	 \i The text is copied to the new node.
+    \endtable
+
+    \sa TQDomElement::setAttribute() TQDomNode::insertBefore()
+	TQDomNode::insertAfter() TQDomNode::replaceChild() TQDomNode::removeChild()
+	TQDomNode::appendChild()
+*/
+TQDomNode TQDomDocument::importNode( const TQDomNode& importedNode, bool deep )
+{
+    if ( !impl )
+        impl = new TQDomDocumentPrivate;
+    return TQDomNode( IMPL->importNode( importedNode.impl, deep ) );
+}
+
+/*!
+    Creates a new element with namespace support that can be inserted
+    into the DOM tree. The name of the element is \a qName and the
+    namespace URI is \a nsURI. This function also sets
+    TQDomNode::prefix() and TQDomNode::localName() to appropriate values
+    (depending on \a qName).
+
+    \sa createElement()
+*/
+TQDomElement TQDomDocument::createElementNS( const TQString& nsURI, const TQString& qName )
+{
+    if ( !impl )
+        impl = new TQDomDocumentPrivate;
+    return TQDomElement( IMPL->createElementNS( nsURI, qName ) );
+}
+
+/*!
+    Creates a new attribute with namespace support that can be
+    inserted into an element. The name of the attribute is \a qName
+    and the namespace URI is \a nsURI. This function also sets
+    TQDomNode::prefix() and TQDomNode::localName() to appropriate values
+    (depending on \a qName).
+
+    \sa createAttribute()
+*/
+TQDomAttr TQDomDocument::createAttributeNS( const TQString& nsURI, const TQString& qName )
+{
+    if ( !impl )
+        impl = new TQDomDocumentPrivate;
+    return TQDomAttr( IMPL->createAttributeNS( nsURI, qName ) );
+}
+
+/*!
+    Returns a TQDomNodeList that contains all the elements in the
+    document with the local name \a localName and a namespace URI of
+    \a nsURI. The order of the node list is the order they are
+    encountered in a preorder traversal of the element tree.
+
+    \sa elementsByTagName() TQDomElement::elementsByTagNameNS()
+*/
+TQDomNodeList TQDomDocument::elementsByTagNameNS( const TQString& nsURI, const TQString& localName )
+{
+    return TQDomNodeList( new TQDomNodeListPrivate( impl, nsURI, localName ) );
+}
+
+/*!
+    Returns the element whose ID is equal to \a elementId. If no
+    element with the ID was found, this function returns a \link
+    TQDomNode::isNull() null element\endlink.
+
+    Since the TQDomClasses do not know which attributes are element
+    IDs, this function returns always a \link TQDomNode::isNull() null
+    element\endlink. This may change in a future version.
+*/
+TQDomElement TQDomDocument::elementById( const TQString& /*elementId*/ )
+{
+    return TQDomElement();
+}
+
+/*!
+    Returns \c DocumentNode.
+*/
+TQDomNode::NodeType TQDomDocument::nodeType() const
+{
+    return DocumentNode;
+}
+
+/*!
+    Returns TRUE.
+*/
+bool TQDomDocument::isDocument() const
+{
+    return TRUE;
+}
+
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * Node casting functions
+ *
+ **************************************************************/
+
+/*!
+    Converts a TQDomNode into a TQDomAttr. If the node is not an
+    attribute, the returned object will be \link TQDomNode::isNull()
+    null\endlink.
+
+    \sa isAttr()
+*/
+TQDomAttr TQDomNode::toAttr()
+{
+    if ( impl && impl->isAttr() )
+	return TQDomAttr( ((TQDomAttrPrivate*)impl) );
+    return TQDomAttr();
+}
+
+/*!
+    Converts a TQDomNode into a TQDomCDATASection. If the node is not a
+    CDATA section, the returned object will be \link
+    TQDomNode::isNull() null\endlink.
+
+    \sa isCDATASection()
+*/
+TQDomCDATASection TQDomNode::toCDATASection()
+{
+    if ( impl && impl->isCDATASection() )
+	return TQDomCDATASection( ((TQDomCDATASectionPrivate*)impl) );
+    return TQDomCDATASection();
+}
+
+/*!
+    Converts a TQDomNode into a TQDomDocumentFragment. If the node is
+    not a document fragment the returned object will be \link
+    TQDomNode::isNull() null\endlink.
+
+    \sa isDocumentFragment()
+*/
+TQDomDocumentFragment TQDomNode::toDocumentFragment()
+{
+    if ( impl && impl->isDocumentFragment() )
+	return TQDomDocumentFragment( ((TQDomDocumentFragmentPrivate*)impl) );
+    return TQDomDocumentFragment();
+}
+
+/*!
+    Converts a TQDomNode into a TQDomDocument. If the node is not a
+    document the returned object will be \link TQDomNode::isNull()
+    null\endlink.
+
+    \sa isDocument()
+*/
+TQDomDocument TQDomNode::toDocument()
+{
+    if ( impl && impl->isDocument() )
+	return TQDomDocument( ((TQDomDocumentPrivate*)impl) );
+    return TQDomDocument();
+}
+
+/*!
+    Converts a TQDomNode into a TQDomDocumentType. If the node is not a
+    document type the returned object will be \link TQDomNode::isNull()
+    null\endlink.
+
+    \sa isDocumentType()
+*/
+TQDomDocumentType TQDomNode::toDocumentType()
+{
+    if ( impl && impl->isDocumentType() )
+	return TQDomDocumentType( ((TQDomDocumentTypePrivate*)impl) );
+    return TQDomDocumentType();
+}
+
+/*!
+    Converts a TQDomNode into a TQDomElement. If the node is not an
+    element the returned object will be \link TQDomNode::isNull()
+    null\endlink.
+
+    \sa isElement()
+*/
+TQDomElement TQDomNode::toElement()
+{
+    if ( impl && impl->isElement() )
+	return TQDomElement( ((TQDomElementPrivate*)impl) );
+    return TQDomElement();
+}
+
+/*!
+    Converts a TQDomNode into a TQDomEntityReference. If the node is not
+    an entity reference, the returned object will be \link
+    TQDomNode::isNull() null\endlink.
+
+    \sa isEntityReference()
+*/
+TQDomEntityReference TQDomNode::toEntityReference()
+{
+    if ( impl && impl->isEntityReference() )
+	return TQDomEntityReference( ((TQDomEntityReferencePrivate*)impl) );
+    return TQDomEntityReference();
+}
+
+/*!
+    Converts a TQDomNode into a TQDomText. If the node is not a text,
+    the returned object will be \link TQDomNode::isNull() null\endlink.
+
+    \sa isText()
+*/
+TQDomText TQDomNode::toText()
+{
+    if ( impl && impl->isText() )
+	return TQDomText( ((TQDomTextPrivate*)impl) );
+    return TQDomText();
+}
+
+/*!
+    Converts a TQDomNode into a TQDomEntity. If the node is not an
+    entity the returned object will be \link TQDomNode::isNull()
+    null\endlink.
+
+    \sa isEntity()
+*/
+TQDomEntity TQDomNode::toEntity()
+{
+    if ( impl && impl->isEntity() )
+	return TQDomEntity( ((TQDomEntityPrivate*)impl) );
+    return TQDomEntity();
+}
+
+/*!
+    Converts a TQDomNode into a TQDomNotation. If the node is not a
+    notation the returned object will be \link TQDomNode::isNull()
+    null\endlink.
+
+    \sa isNotation()
+*/
+TQDomNotation TQDomNode::toNotation()
+{
+    if ( impl && impl->isNotation() )
+	return TQDomNotation( ((TQDomNotationPrivate*)impl) );
+    return TQDomNotation();
+}
+
+/*!
+    Converts a TQDomNode into a TQDomProcessingInstruction. If the node
+    is not a processing instruction the returned object will be \link
+    TQDomNode::isNull() null\endlink.
+
+    \sa isProcessingInstruction()
+*/
+TQDomProcessingInstruction TQDomNode::toProcessingInstruction()
+{
+    if ( impl && impl->isProcessingInstruction() )
+	return TQDomProcessingInstruction( ((TQDomProcessingInstructionPrivate*)impl) );
+    return TQDomProcessingInstruction();
+}
+
+/*!
+    Converts a TQDomNode into a TQDomCharacterData. If the node is not a
+    character data node the returned object will be \link
+    TQDomNode::isNull() null\endlink.
+
+    \sa isCharacterData()
+*/
+TQDomCharacterData TQDomNode::toCharacterData()
+{
+    if ( impl && impl->isCharacterData() )
+	return TQDomCharacterData( ((TQDomCharacterDataPrivate*)impl) );
+    return TQDomCharacterData();
+}
+
+/*!
+    Converts a TQDomNode into a TQDomComment. If the node is not a
+    comment the returned object will be \link TQDomNode::isNull()
+    null\endlink.
+
+    \sa isComment()
+*/
+TQDomComment TQDomNode::toComment()
+{
+    if ( impl && impl->isComment() )
+	return TQDomComment( ((TQDomCommentPrivate*)impl) );
+    return TQDomComment();
+}
+
+/**************************************************************
+ *
+ * TQDomHandler
+ *
+ **************************************************************/
+
+TQDomHandler::TQDomHandler( TQDomDocumentPrivate* adoc, bool namespaceProcessing )
+{
+    doc = adoc;
+    node = doc;
+    cdata = FALSE;
+    nsProcessing = namespaceProcessing;
+}
+
+TQDomHandler::~TQDomHandler()
+{
+}
+
+bool TQDomHandler::endDocument()
+{
+    // ### is this really necessary? (rms)
+    if ( node != doc )
+	return FALSE;
+    return TRUE;
+}
+
+bool TQDomHandler::startDTD( const TQString& name, const TQString& publicId, const TQString& systemId )
+{
+    doc->doctype()->name = name;
+    doc->doctype()->publicId = publicId;
+    doc->doctype()->systemId = systemId;
+    return TRUE;
+}
+
+bool TQDomHandler::startElement( const TQString& nsURI, const TQString&, const TQString& qName, const TQXmlAttributes& atts )
+{
+    // tag name
+    TQDomNodePrivate* n;
+    if ( nsProcessing ) {
+	n = doc->createElementNS( nsURI, qName );
+    } else {
+	n = doc->createElement( qName );
+    }
+    node->appendChild( n );
+    node = n;
+
+    // attributes
+    for ( int i=0; i<atts.length(); i++ )
+    {
+	if ( nsProcessing ) {
+	    ((TQDomElementPrivate*)node)->setAttributeNS( atts.uri(i), atts.qName(i), atts.value(i) );
+	} else {
+	    ((TQDomElementPrivate*)node)->setAttribute( atts.qName(i), atts.value(i) );
+	}
+    }
+
+    return TRUE;
+}
+
+bool TQDomHandler::endElement( const TQString&, const TQString&, const TQString& )
+{
+    if ( node == doc )
+	return FALSE;
+    node = node->parent();
+
+    return TRUE;
+}
+
+bool TQDomHandler::characters( const TQString&  ch )
+{
+    // No text as child of some document
+    if ( node == doc )
+	return FALSE;
+
+    if ( cdata ) {
+	node->appendChild( doc->createCDATASection( ch ) );
+    } else if ( !entityName.isEmpty() ) {
+	TQDomEntityPrivate* e = new TQDomEntityPrivate( doc, 0, entityName,
+		TQString::null, TQString::null, TQString::null );
+	e->value = ch;
+	doc->doctype()->appendChild( e );
+	node->appendChild( doc->createEntityReference( entityName ) );
+    } else {
+	node->appendChild( doc->createTextNode( ch ) );
+    }
+
+    return TRUE;
+}
+
+bool TQDomHandler::processingInstruction( const TQString& target, const TQString& data )
+{
+    node->appendChild( doc->createProcessingInstruction( target, data ) );
+    return TRUE;
+}
+
+bool TQDomHandler::skippedEntity( const TQString& name )
+{
+    node->appendChild( doc->createEntityReference( name ) );
+    return TRUE;
+}
+
+bool TQDomHandler::fatalError( const TQXmlParseException& exception )
+{
+    errorMsg = exception.message();
+    errorLine =  exception.lineNumber();
+    errorColumn =  exception.columnNumber();
+    return TQXmlDefaultHandler::fatalError( exception );
+}
+
+bool TQDomHandler::startCDATA()
+{
+    cdata = TRUE;
+    return TRUE;
+}
+
+bool TQDomHandler::endCDATA()
+{
+    cdata = FALSE;
+    return TRUE;
+}
+
+bool TQDomHandler::startEntity( const TQString &name )
+{
+    entityName = name;
+    return TRUE;
+}
+
+bool TQDomHandler::endEntity( const TQString & )
+{
+    entityName = TQString::null;
+    return TRUE;
+}
+
+bool TQDomHandler::comment( const TQString& ch )
+{
+    node->appendChild( doc->createComment( ch ) );
+    return TRUE;
+}
+
+bool TQDomHandler::unparsedEntityDecl( const TQString &name, const TQString &publicId, const TQString &systemId, const TQString &notationName )
+{
+    TQDomEntityPrivate* e = new TQDomEntityPrivate( doc, 0, name,
+	    publicId, systemId, notationName );
+    doc->doctype()->appendChild( e );
+    return TRUE;
+}
+
+bool TQDomHandler::externalEntityDecl( const TQString &name, const TQString &publicId, const TQString &systemId )
+{
+    return unparsedEntityDecl( name, publicId, systemId, TQString::null );
+}
+
+bool TQDomHandler::notationDecl( const TQString & name, const TQString & publicId, const TQString & systemId )
+{
+    TQDomNotationPrivate* n = new TQDomNotationPrivate( doc, 0, name, publicId, systemId );
+    doc->doctype()->appendChild( n );
+    return TRUE;
+}
+
+#endif //QT_NO_DOM
diff --git a/src/xml/qdom.h b/src/xml/qdom.h
new file mode 100644
index 000000000..804e8dd97
--- /dev/null
+++ b/src/xml/qdom.h
@@ -0,0 +1,677 @@
+/****************************************************************************
+**
+** Definition of TQDomDocument and related classes.
+**
+** Created : 000518
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the xml module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing retquirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQDOM_H
+#define TQDOM_H
+
+#ifndef QT_H
+#include "qstring.h"
+#endif // QT_H
+
+#if !defined(QT_MODULE_XML) || defined( QT_LICENSE_PROFESSIONAL ) || defined( QT_INTERNAL_XML )
+#define TQM_EXPORT_DOM
+#else
+#define TQM_EXPORT_DOM Q_EXPORT
+#endif
+
+#ifndef QT_NO_DOM
+
+class TQIODevice;
+class TQTextStream;
+
+class TQXmlInputSource;
+class TQXmlReader;
+
+class TQDomDocumentPrivate;
+class TQDomDocumentTypePrivate;
+class TQDomDocumentFragmentPrivate;
+class TQDomNodePrivate;
+class TQDomNodeListPrivate;
+class TQDomImplementationPrivate;
+class TQDomElementPrivate;
+class TQDomNotationPrivate;
+class TQDomEntityPrivate;
+class TQDomEntityReferencePrivate;
+class TQDomProcessingInstructionPrivate;
+class TQDomAttrPrivate;
+class TQDomCharacterDataPrivate;
+class TQDomTextPrivate;
+class TQDomCommentPrivate;
+class TQDomCDATASectionPrivate;
+class TQDomNamedNodeMapPrivate;
+class TQDomImplementationPrivate;
+
+class TQDomNodeList;
+class TQDomElement;
+class TQDomText;
+class TQDomComment;
+class TQDomCDATASection;
+class TQDomProcessingInstruction;
+class TQDomAttr;
+class TQDomEntityReference;
+class TQDomDocument;
+class TQDomNamedNodeMap;
+class TQDomDocument;
+class TQDomDocumentFragment;
+class TQDomDocumentType;
+class TQDomImplementation;
+class TQDomNode;
+class TQDomEntity;
+class TQDomNotation;
+class TQDomCharacterData;
+
+class TQM_EXPORT_DOM TQDomImplementation
+{
+public:
+    TQDomImplementation();
+    TQDomImplementation( const TQDomImplementation& );
+    virtual ~TQDomImplementation();
+    TQDomImplementation& operator= ( const TQDomImplementation& );
+    bool operator== ( const TQDomImplementation& ) const;
+    bool operator!= ( const TQDomImplementation& ) const;
+
+    // functions
+    virtual bool hasFeature( const TQString& feature, const TQString& version );
+    virtual TQDomDocumentType createDocumentType( const TQString& qName, const TQString& publicId, const TQString& systemId );
+    virtual TQDomDocument createDocument( const TQString& nsURI, const TQString& qName, const TQDomDocumentType& doctype );
+
+    // TQt extension
+    bool isNull();
+
+private:
+    TQDomImplementationPrivate* impl;
+    TQDomImplementation( TQDomImplementationPrivate* );
+
+    friend class TQDomDocument;
+};
+
+class TQM_EXPORT_DOM TQDomNode
+{
+public:
+    enum NodeType {
+	ElementNode               = 1,
+	AttributeNode             = 2,
+	TextNode                  = 3,
+	CDATASectionNode          = 4,
+	EntityReferenceNode       = 5,
+	EntityNode                = 6,
+	ProcessingInstructionNode = 7,
+	CommentNode               = 8,
+	DocumentNode              = 9,
+	DocumentTypeNode          = 10,
+	DocumentFragmentNode      = 11,
+	NotationNode              = 12,
+	BaseNode                  = 21,// this is not in the standard
+	CharacterDataNode         = 22 // this is not in the standard
+    };
+
+    TQDomNode();
+    TQDomNode( const TQDomNode& );
+    TQDomNode& operator= ( const TQDomNode& );
+    bool operator== ( const TQDomNode& ) const;
+    bool operator!= ( const TQDomNode& ) const;
+    virtual ~TQDomNode();
+
+    // DOM functions
+    virtual TQDomNode insertBefore( const TQDomNode& newChild, const TQDomNode& refChild );
+    virtual TQDomNode insertAfter( const TQDomNode& newChild, const TQDomNode& refChild );
+    virtual TQDomNode replaceChild( const TQDomNode& newChild, const TQDomNode& oldChild );
+    virtual TQDomNode removeChild( const TQDomNode& oldChild );
+    virtual TQDomNode appendChild( const TQDomNode& newChild );
+    virtual bool hasChildNodes() const;
+    virtual TQDomNode cloneNode( bool deep = TRUE ) const;
+    virtual void normalize();
+    virtual bool isSupported( const TQString& feature, const TQString& version ) const;
+
+    // DOM read only attributes
+    virtual TQString nodeName() const;
+    virtual TQDomNode::NodeType nodeType() const;
+    virtual TQDomNode         parentNode() const;
+    virtual TQDomNodeList     childNodes() const;
+    virtual TQDomNode         firstChild() const;
+    virtual TQDomNode         lastChild() const;
+    virtual TQDomNode         previousSibling() const;
+    virtual TQDomNode         nextSibling() const;
+    virtual TQDomNamedNodeMap attributes() const;
+    virtual TQDomDocument     ownerDocument() const;
+    virtual TQString namespaceURI() const;
+    virtual TQString localName() const;
+    virtual bool hasAttributes() const;
+
+    // DOM attributes
+    virtual TQString nodeValue() const;
+    virtual void setNodeValue( const TQString& );
+    virtual TQString prefix() const;
+    virtual void setPrefix( const TQString& pre );
+
+    // TQt extensions
+    virtual bool isAttr() const;
+    virtual bool isCDATASection() const;
+    virtual bool isDocumentFragment() const;
+    virtual bool isDocument() const;
+    virtual bool isDocumentType() const;
+    virtual bool isElement() const;
+    virtual bool isEntityReference() const;
+    virtual bool isText() const;
+    virtual bool isEntity() const;
+    virtual bool isNotation() const;
+    virtual bool isProcessingInstruction() const;
+    virtual bool isCharacterData() const;
+    virtual bool isComment() const;
+
+    /**
+     * Shortcut to avoid dealing with TQDomNodeList
+     * all the time.
+     */
+    TQDomNode namedItem( const TQString& name ) const;
+
+    bool isNull() const;
+    void clear();
+
+    TQDomAttr toAttr();
+    TQDomCDATASection toCDATASection();
+    TQDomDocumentFragment toDocumentFragment();
+    TQDomDocument toDocument();
+    TQDomDocumentType toDocumentType();
+    TQDomElement toElement();
+    TQDomEntityReference toEntityReference();
+    TQDomText toText();
+    TQDomEntity toEntity();
+    TQDomNotation toNotation();
+    TQDomProcessingInstruction toProcessingInstruction();
+    TQDomCharacterData toCharacterData();
+    TQDomComment toComment();
+
+    void save( TQTextStream&, int ) const;
+
+protected:
+    TQDomNodePrivate* impl;
+    TQDomNode( TQDomNodePrivate* );
+
+private:
+    friend class TQDomDocument;
+    friend class TQDomDocumentType;
+    friend class TQDomNodeList;
+    friend class TQDomNamedNodeMap;
+};
+
+class TQM_EXPORT_DOM TQDomNodeList
+{
+public:
+    TQDomNodeList();
+    TQDomNodeList( const TQDomNodeList& );
+    TQDomNodeList& operator= ( const TQDomNodeList& );
+    bool operator== ( const TQDomNodeList& ) const;
+    bool operator!= ( const TQDomNodeList& ) const;
+    virtual ~TQDomNodeList();
+
+    // DOM functions
+    virtual TQDomNode item( int index ) const;
+
+    // DOM read only attributes
+    virtual uint length() const;
+    uint count() const { return length(); } // TQt API consitancy
+
+private:
+    TQDomNodeListPrivate* impl;
+    TQDomNodeList( TQDomNodeListPrivate* );
+
+    friend class TQDomNode;
+    friend class TQDomElement;
+    friend class TQDomDocument;
+};
+
+class TQM_EXPORT_DOM TQDomDocumentType : public TQDomNode
+{
+public:
+    TQDomDocumentType();
+    TQDomDocumentType( const TQDomDocumentType& x );
+    TQDomDocumentType& operator= ( const TQDomDocumentType& );
+    ~TQDomDocumentType();
+
+    // DOM read only attributes
+    virtual TQString name() const;
+    virtual TQDomNamedNodeMap entities() const;
+    virtual TQDomNamedNodeMap notations() const;
+    virtual TQString publicId() const;
+    virtual TQString systemId() const;
+    virtual TQString internalSubset() const;
+
+    // Reimplemented from TQDomNode
+    TQDomNode::NodeType nodeType() const;
+    bool isDocumentType() const;
+
+private:
+    TQDomDocumentType( TQDomDocumentTypePrivate* );
+
+    friend class TQDomImplementation;
+    friend class TQDomDocument;
+    friend class TQDomNode;
+};
+
+class TQM_EXPORT_DOM TQDomDocument : public TQDomNode
+{
+public:
+    TQDomDocument();
+    Q_EXPLICIT TQDomDocument( const TQString& name );
+    Q_EXPLICIT TQDomDocument( const TQDomDocumentType& doctype );
+    TQDomDocument( const TQDomDocument& x );
+    TQDomDocument& operator= ( const TQDomDocument& );
+    ~TQDomDocument();
+
+    // DOM functions
+    TQDomElement createElement( const TQString& tagName );
+    TQDomDocumentFragment createDocumentFragment();
+    TQDomText createTextNode( const TQString& data );
+    TQDomComment createComment( const TQString& data );
+    TQDomCDATASection createCDATASection( const TQString& data );
+    TQDomProcessingInstruction createProcessingInstruction( const TQString& target, const TQString& data );
+    TQDomAttr createAttribute( const TQString& name );
+    TQDomEntityReference createEntityReference( const TQString& name );
+    TQDomNodeList elementsByTagName( const TQString& tagname ) const;
+    TQDomNode importNode( const TQDomNode& importedNode, bool deep );
+    TQDomElement createElementNS( const TQString& nsURI, const TQString& qName );
+    TQDomAttr createAttributeNS( const TQString& nsURI, const TQString& qName );
+    TQDomNodeList elementsByTagNameNS( const TQString& nsURI, const TQString& localName );
+    TQDomElement elementById( const TQString& elementId );
+
+    // DOM read only attributes
+    TQDomDocumentType doctype() const;
+    TQDomImplementation implementation() const;
+    TQDomElement documentElement() const;
+
+    // TQt extensions
+    bool setContent( const TQCString& text, bool namespaceProcessing, TQString *errorMsg=0, int *errorLine=0, int *errorColumn=0  );
+    bool setContent( const TQByteArray& text, bool namespaceProcessing, TQString *errorMsg=0, int *errorLine=0, int *errorColumn=0  );
+    bool setContent( const TQString& text, bool namespaceProcessing, TQString *errorMsg=0, int *errorLine=0, int *errorColumn=0  );
+    bool setContent( TQIODevice* dev, bool namespaceProcessing, TQString *errorMsg=0, int *errorLine=0, int *errorColumn=0  );
+    bool setContent( const TQCString& text, TQString *errorMsg=0, int *errorLine=0, int *errorColumn=0 );
+    bool setContent( const TQByteArray& text, TQString *errorMsg=0, int *errorLine=0, int *errorColumn=0  );
+    bool setContent( const TQString& text, TQString *errorMsg=0, int *errorLine=0, int *errorColumn=0  );
+    bool setContent( TQIODevice* dev, TQString *errorMsg=0, int *errorLine=0, int *errorColumn=0  );
+
+    bool setContent( TQXmlInputSource *source, TQXmlReader *reader, TQString *errorMsg=0, int *errorLine=0, int *errorColumn=0  );
+
+    // Reimplemented from TQDomNode
+    TQDomNode::NodeType nodeType() const;
+    bool isDocument() const;
+
+    // TQt extensions
+    TQString toString() const; // ### TQt 4: merge the two overloads
+    TQString toString( int ) const;
+    TQCString toCString() const; // ### TQt 4: merge the two overloads
+    TQCString toCString( int ) const;
+
+private:
+    TQDomDocument( TQDomDocumentPrivate* );
+
+    friend class TQDomNode;
+};
+
+class TQM_EXPORT_DOM TQDomNamedNodeMap
+{
+public:
+    TQDomNamedNodeMap();
+    TQDomNamedNodeMap( const TQDomNamedNodeMap& );
+    TQDomNamedNodeMap& operator= ( const TQDomNamedNodeMap& );
+    bool operator== ( const TQDomNamedNodeMap& ) const;
+    bool operator!= ( const TQDomNamedNodeMap& ) const;
+    ~TQDomNamedNodeMap();
+
+    // DOM functions
+    TQDomNode namedItem( const TQString& name ) const;
+    TQDomNode setNamedItem( const TQDomNode& newNode );
+    TQDomNode removeNamedItem( const TQString& name );
+    TQDomNode item( int index ) const;
+    TQDomNode namedItemNS( const TQString& nsURI, const TQString& localName ) const;
+    TQDomNode setNamedItemNS( const TQDomNode& newNode );
+    TQDomNode removeNamedItemNS( const TQString& nsURI, const TQString& localName );
+
+    // DOM read only attributes
+    uint length() const;
+    uint count() const { return length(); } // TQt API consitancy
+
+    // TQt extension
+    bool contains( const TQString& name ) const;
+
+private:
+    TQDomNamedNodeMapPrivate* impl;
+    TQDomNamedNodeMap( TQDomNamedNodeMapPrivate* );
+
+    friend class TQDomNode;
+    friend class TQDomDocumentType;
+    friend class TQDomElement;
+};
+
+class TQM_EXPORT_DOM TQDomDocumentFragment : public TQDomNode
+{
+public:
+    TQDomDocumentFragment();
+    TQDomDocumentFragment( const TQDomDocumentFragment& x );
+    TQDomDocumentFragment& operator= ( const TQDomDocumentFragment& );
+    ~TQDomDocumentFragment();
+
+    // Reimplemented from TQDomNode
+    TQDomNode::NodeType nodeType() const;
+    bool isDocumentFragment() const;
+
+private:
+    TQDomDocumentFragment( TQDomDocumentFragmentPrivate* );
+
+    friend class TQDomDocument;
+    friend class TQDomNode;
+};
+
+class TQM_EXPORT_DOM TQDomCharacterData : public TQDomNode
+{
+public:
+    TQDomCharacterData();
+    TQDomCharacterData( const TQDomCharacterData& x );
+    TQDomCharacterData& operator= ( const TQDomCharacterData& );
+    ~TQDomCharacterData();
+
+    // DOM functions
+    virtual TQString substringData( unsigned long offset, unsigned long count );
+    virtual void appendData( const TQString& arg );
+    virtual void insertData( unsigned long offset, const TQString& arg );
+    virtual void deleteData( unsigned long offset, unsigned long count );
+    virtual void replaceData( unsigned long offset, unsigned long count, const TQString& arg );
+
+    // DOM read only attributes
+    virtual uint length() const;
+
+    // DOM attributes
+    virtual TQString data() const;
+    virtual void setData( const TQString& );
+
+    // Reimplemented from TQDomNode
+    TQDomNode::NodeType nodeType() const;
+    bool isCharacterData() const;
+
+private:
+    TQDomCharacterData( TQDomCharacterDataPrivate* );
+
+    friend class TQDomDocument;
+    friend class TQDomText;
+    friend class TQDomComment;
+    friend class TQDomNode;
+};
+
+class TQM_EXPORT_DOM TQDomAttr : public TQDomNode
+{
+public:
+    TQDomAttr();
+    TQDomAttr( const TQDomAttr& x );
+    TQDomAttr& operator= ( const TQDomAttr& );
+    ~TQDomAttr();
+
+    // DOM read only attributes
+    virtual TQString name() const;
+    virtual bool specified() const;
+    virtual TQDomElement ownerElement() const;
+
+    // DOM attributes
+    virtual TQString value() const;
+    virtual void setValue( const TQString& );
+
+    // Reimplemented from TQDomNode
+    TQDomNode::NodeType nodeType() const;
+    bool isAttr() const;
+
+private:
+    TQDomAttr( TQDomAttrPrivate* );
+
+    friend class TQDomDocument;
+    friend class TQDomElement;
+    friend class TQDomNode;
+};
+
+class TQM_EXPORT_DOM TQDomElement : public TQDomNode
+{
+public:
+    TQDomElement();
+    TQDomElement( const TQDomElement& x );
+    TQDomElement& operator= ( const TQDomElement& );
+    ~TQDomElement();
+
+    // DOM functions
+    TQString attribute( const TQString& name, const TQString& defValue = TQString::null ) const;
+    void setAttribute( const TQString& name, const TQString& value );
+    void setAttribute( const TQString& name, int value );
+    void setAttribute( const TQString& name, uint value );
+    void setAttribute( const TQString& name, long value );
+    void setAttribute( const TQString& name, ulong value );
+    void setAttribute( const TQString& name, double value );
+    void removeAttribute( const TQString& name );
+    TQDomAttr attributeNode( const TQString& name);
+    TQDomAttr setAttributeNode( const TQDomAttr& newAttr );
+    TQDomAttr removeAttributeNode( const TQDomAttr& oldAttr );
+    virtual TQDomNodeList elementsByTagName( const TQString& tagname ) const;
+    bool hasAttribute( const TQString& name ) const;
+
+    TQString attributeNS( const TQString nsURI, const TQString& localName, const TQString& defValue ) const;
+    void setAttributeNS( const TQString nsURI, const TQString& qName, const TQString& value );
+    void setAttributeNS( const TQString nsURI, const TQString& qName, int value );
+    void setAttributeNS( const TQString nsURI, const TQString& qName, uint value );
+    void setAttributeNS( const TQString nsURI, const TQString& qName, long value );
+    void setAttributeNS( const TQString nsURI, const TQString& qName, ulong value );
+    void setAttributeNS( const TQString nsURI, const TQString& qName, double value );
+    void removeAttributeNS( const TQString& nsURI, const TQString& localName );
+    TQDomAttr attributeNodeNS( const TQString& nsURI, const TQString& localName );
+    TQDomAttr setAttributeNodeNS( const TQDomAttr& newAttr );
+    virtual TQDomNodeList elementsByTagNameNS( const TQString& nsURI, const TQString& localName ) const;
+    bool hasAttributeNS( const TQString& nsURI, const TQString& localName ) const;
+
+    // DOM read only attributes
+    TQString tagName() const;
+    void setTagName( const TQString& name ); // TQt extension
+
+    // Reimplemented from TQDomNode
+    TQDomNamedNodeMap attributes() const;
+    TQDomNode::NodeType nodeType() const;
+    bool isElement() const;
+
+    TQString text() const;
+
+private:
+    TQDomElement( TQDomElementPrivate* );
+
+    friend class TQDomDocument;
+    friend class TQDomNode;
+    friend class TQDomAttr;
+};
+
+class TQM_EXPORT_DOM TQDomText : public TQDomCharacterData
+{
+public:
+    TQDomText();
+    TQDomText( const TQDomText& x );
+    TQDomText& operator= ( const TQDomText& );
+    ~TQDomText();
+
+    // DOM functions
+    TQDomText splitText( int offset );
+
+    // Reimplemented from TQDomNode
+    TQDomNode::NodeType nodeType() const;
+    bool isText() const;
+
+private:
+    TQDomText( TQDomTextPrivate* );
+
+    friend class TQDomCDATASection;
+    friend class TQDomDocument;
+    friend class TQDomNode;
+};
+
+class TQM_EXPORT_DOM TQDomComment : public TQDomCharacterData
+{
+public:
+    TQDomComment();
+    TQDomComment( const TQDomComment& x );
+    TQDomComment& operator= ( const TQDomComment& );
+    ~TQDomComment();
+
+    // Reimplemented from TQDomNode
+    TQDomNode::NodeType nodeType() const;
+    bool isComment() const;
+
+private:
+    TQDomComment( TQDomCommentPrivate* );
+
+    friend class TQDomDocument;
+    friend class TQDomNode;
+};
+
+class TQM_EXPORT_DOM TQDomCDATASection : public TQDomText
+{
+public:
+    TQDomCDATASection();
+    TQDomCDATASection( const TQDomCDATASection& x );
+    TQDomCDATASection& operator= ( const TQDomCDATASection& );
+    ~TQDomCDATASection();
+
+    // Reimplemented from TQDomNode
+    TQDomNode::NodeType nodeType() const;
+    bool isCDATASection() const;
+
+private:
+    TQDomCDATASection( TQDomCDATASectionPrivate* );
+
+    friend class TQDomDocument;
+    friend class TQDomNode;
+};
+
+class TQM_EXPORT_DOM TQDomNotation : public TQDomNode
+{
+public:
+    TQDomNotation();
+    TQDomNotation( const TQDomNotation& x );
+    TQDomNotation& operator= ( const TQDomNotation& );
+    ~TQDomNotation();
+
+    // DOM read only attributes
+    TQString publicId() const;
+    TQString systemId() const;
+
+    // Reimplemented from TQDomNode
+    TQDomNode::NodeType nodeType() const;
+    bool isNotation() const;
+
+private:
+    TQDomNotation( TQDomNotationPrivate* );
+
+    friend class TQDomDocument;
+    friend class TQDomNode;
+};
+
+class TQM_EXPORT_DOM TQDomEntity : public TQDomNode
+{
+public:
+    TQDomEntity();
+    TQDomEntity( const TQDomEntity& x );
+    TQDomEntity& operator= ( const TQDomEntity& );
+    ~TQDomEntity();
+
+    // DOM read only attributes
+    virtual TQString publicId() const;
+    virtual TQString systemId() const;
+    virtual TQString notationName() const;
+
+    // Reimplemented from TQDomNode
+    TQDomNode::NodeType nodeType() const;
+    bool isEntity() const;
+
+private:
+    TQDomEntity( TQDomEntityPrivate* );
+
+    friend class TQDomNode;
+};
+
+class TQM_EXPORT_DOM TQDomEntityReference : public TQDomNode
+{
+public:
+    TQDomEntityReference();
+    TQDomEntityReference( const TQDomEntityReference& x );
+    TQDomEntityReference& operator= ( const TQDomEntityReference& );
+    ~TQDomEntityReference();
+
+    // Reimplemented from TQDomNode
+    TQDomNode::NodeType nodeType() const;
+    bool isEntityReference() const;
+
+private:
+    TQDomEntityReference( TQDomEntityReferencePrivate* );
+
+    friend class TQDomDocument;
+    friend class TQDomNode;
+};
+
+class TQM_EXPORT_DOM TQDomProcessingInstruction : public TQDomNode
+{
+public:
+    TQDomProcessingInstruction();
+    TQDomProcessingInstruction( const TQDomProcessingInstruction& x );
+    TQDomProcessingInstruction& operator= ( const TQDomProcessingInstruction& );
+    ~TQDomProcessingInstruction();
+
+    // DOM read only attributes
+    virtual TQString target() const;
+
+    // DOM attributes
+    virtual TQString data() const;
+    virtual void setData( const TQString& d );
+
+    // Reimplemented from TQDomNode
+    TQDomNode::NodeType nodeType() const;
+    bool isProcessingInstruction() const;
+
+private:
+    TQDomProcessingInstruction( TQDomProcessingInstructionPrivate* );
+
+    friend class TQDomDocument;
+    friend class TQDomNode;
+};
+
+
+TQM_EXPORT_DOM TQTextStream& operator<<( TQTextStream&, const TQDomNode& );
+
+#endif //QT_NO_DOM
+#endif // TQDOM_H
diff --git a/src/xml/qsvgdevice.cpp b/src/xml/qsvgdevice.cpp
new file mode 100644
index 000000000..7c0699d52
--- /dev/null
+++ b/src/xml/qsvgdevice.cpp
@@ -0,0 +1,1591 @@
+/****************************************************************************
+**
+** Implementation of the TQSvgDevice class
+**
+** Copyright (C) 2000-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the xml module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing retquirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+*****************************************************************************/
+
+#include <private/qsvgdevice_p.h>
+
+#ifndef QT_NO_SVG
+
+#include "qpainter.h"
+#include "qpaintdevicemetrics.h"
+#include "qfile.h"
+#include "qmap.h"
+#include "qregexp.h"
+#include "qvaluelist.h"
+#include "qtextstream.h"
+#include "qimage.h"
+#include "qpixmap.h"
+
+#include <math.h>
+
+const double deg2rad = 0.017453292519943295769;	// pi/180
+const char piData[] = "version=\"1.0\" standalone=\"no\"";
+const char publicId[] = "-//W3C//DTD SVG 20001102//EN";
+const char systemId[] = "http://www.w3.org/TR/2000/CR-SVG-20001102/DTD/svg-20001102.dtd";
+
+struct TQM_EXPORT_SVG ImgElement {
+    TQDomElement element;
+    TQImage image;
+    Q_DUMMY_COMPARISON_OPERATOR( ImgElement )
+};
+
+struct TQM_EXPORT_SVG PixElement {
+    TQDomElement element;
+    TQPixmap pixmap;
+    Q_DUMMY_COMPARISON_OPERATOR( PixElement )
+};
+
+struct TQSvgDeviceState {
+    int textx, texty;			// current text position
+    int textalign;			// text alignment
+    Q_DUMMY_COMPARISON_OPERATOR( TQSvgDeviceState )
+};
+
+typedef TQValueList<ImgElement> ImageList;
+typedef TQValueList<PixElement> PixmapList;
+typedef TQValueList<TQSvgDeviceState> StateList;
+
+class TQSvgDevicePrivate {
+public:
+    ImageList images;
+    PixmapList pixmaps;
+    StateList stack;
+    int currentClip;
+
+    uint justRestored : 1;
+
+    TQMap<TQString, TQRegion> clipPathTable;
+};
+
+enum ElementType {
+    InvalidElement = 0,
+    AnchorElement,
+    CircleElement,
+    ClipElement,
+    CommentElement,
+    DescElement,
+    EllipseElement,
+    GroupElement,
+    ImageElement,
+    LineElement,
+    PolylineElement,
+    PolygonElement,
+    PathElement,
+    RectElement,
+    SvgElement,
+    TextElement,
+    TitleElement,
+    TSpanElement
+};
+
+typedef TQMap<TQString,ElementType> TQSvgTypeMap;
+static TQSvgTypeMap *qSvgTypeMap=0; // element types
+static TQMap<TQString,TQString> *qSvgColMap=0; // recognized color keyword names
+
+/*!
+    \class TQSvgDevice qsvgdevice.h
+    \brief The TQSvgDevice class provides a paint device for SVG vector graphics.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \ingroup xml-tools
+    \module XML
+    \internal
+
+    SVG is an XML vector graphics format. This class supports the
+    loading and saving of SVG files with load() and save(), and the
+    rendering of an SVG onto a TQPainter using play(). Use toString()
+    to put the SVG into a string.
+
+    \sa TQPaintDevice TQPainter
+*/
+
+/*!
+    Creates a TQSvgDevice object.
+*/
+
+TQSvgDevice::TQSvgDevice()
+    : TQPaintDevice( TQInternal::ExternalDevice ),
+      pt( 0 )
+{
+    d = new TQSvgDevicePrivate;
+    d->currentClip = 0;
+    d->justRestored = FALSE;
+}
+
+/*!
+    Destroys the TQSvgDevice object and frees the resources it used.
+*/
+
+TQSvgDevice::~TQSvgDevice()
+{
+    delete qSvgTypeMap; qSvgTypeMap = 0;	// static
+    delete qSvgColMap; qSvgColMap = 0;
+    delete d;
+}
+
+/*!
+    Loads and parses a SVG from \a dev into the device. Returns TRUE
+    on success (i.e. loaded and parsed without error); otherwise
+    returns FALSE.
+*/
+
+bool TQSvgDevice::load( TQIODevice *dev )
+{
+    return doc.setContent( dev );
+}
+
+/*!
+    Renders (replays) the SVG on the \a painter and returns TRUE if
+    successful (i.e. it is a valid SVG); otherwise returns FALSE.
+*/
+
+bool TQSvgDevice::play( TQPainter *painter )
+{
+    if ( !painter ) {
+#if defined(QT_CHECK_RANGE)
+	Q_ASSERT( painter );
+#endif
+	return FALSE;
+    }
+    pt = painter;
+    pt->setPen( TQt::NoPen ); // SVG default pen and brush
+    pt->setBrush( TQt::black );
+    if ( doc.isNull() ) {
+	qWarning( "TQSvgDevice::play: No SVG data set." );
+	return FALSE;
+    }
+
+    TQDomNode svg = doc.namedItem( "svg" );
+    if ( svg.isNull() || !svg.isElement() ) {
+	qWarning( "TQSvgDevice::play: Couldn't find any svg element." );
+	return FALSE;
+    }
+
+    // force transform to be activated in case our sequences
+    // are replayed later with a transformed painter
+    painter->setWorldXForm( TRUE );
+
+    TQDomNamedNodeMap attr = svg.attributes();
+    int x = lenToInt( attr, "x" );
+    int y = lenToInt( attr, "y" );
+    brect.setX( x );
+    brect.setY( y );
+    TQString wstr = attr.contains( "width" )
+		   ? attr.namedItem( "width" ).nodeValue() : TQString( "100%" );
+    TQString hstr = attr.contains( "height" )
+		   ? attr.namedItem( "height" ).nodeValue() : TQString( "100%" );
+    double width = parseLen( wstr, 0, TRUE );
+    double height = parseLen( hstr, 0, FALSE );
+    // SVG doesn't respect x and y. But we want a proper bounding rect.
+    brect.setWidth( int(width) - x );
+    brect.setHeight( int(height) - y );
+    painter->setClipRect( brect, TQPainter::CoordPainter );
+
+    if ( attr.contains( "viewBox" ) ) {
+	TQRegExp re( TQString::fromLatin1("\\s*(\\S+)\\s*,?\\s*(\\S+)\\s*,?"
+					"\\s*(\\S+)\\s*,?\\s*(\\S+)\\s*") );
+	if ( re.search( attr.namedItem( "viewBox" ).nodeValue() ) < 0 ) {
+	    qWarning( "TQSvgDevice::play: Invalid viewBox attribute.");
+	    return FALSE;
+	} else {
+	    double x = re.cap( 1 ).toDouble();
+	    double y = re.cap( 2 ).toDouble();
+	    double w = re.cap( 3 ).toDouble();
+	    double h = re.cap( 4 ).toDouble();
+	    if ( w < 0 || h < 0 ) {
+		qWarning( "TQSvgDevice::play: Invalid viewBox dimension.");
+		return FALSE;
+	    } else if ( w == 0 || h == 0 ) {
+		return TRUE;
+	    }
+	    painter->scale( width/w, height/h );
+	    painter->translate( -x, -y );
+	}
+    }
+
+    const struct ElementTable {
+	const char *name;
+	ElementType type;
+    } etab[] = {
+	{ "a",        AnchorElement   },
+	{ "#comment", CommentElement  },
+        { "circle",   CircleElement   },
+	{ "clipPath", ClipElement     },
+	{ "desc",     DescElement     },
+        { "ellipse",  EllipseElement  },
+	{ "g",        GroupElement    },
+        { "image",    ImageElement    },
+        { "line",     LineElement     },
+        { "polyline", PolylineElement },
+        { "polygon",  PolygonElement  },
+        { "path",     PathElement     },
+        { "rect",     RectElement     },
+        { "svg",      SvgElement      },
+        { "text",     TextElement     },
+        { "tspan",    TSpanElement    },
+	{ "title",    TitleElement    },
+	{ 0,          InvalidElement  }
+    };
+    // initialize only once
+    if ( !qSvgTypeMap ) {
+	qSvgTypeMap = new TQSvgTypeMap;
+	const ElementTable *t = etab;
+	while ( t->name ) {
+	    qSvgTypeMap->insert( t->name, t->type );
+	    t++;
+	}
+    }
+
+    // initial state
+    TQSvgDeviceState st;
+    st.textx = st.texty = 0;
+    st.textalign = TQt::AlignLeft;
+    d->stack.append(st);
+    curr = &d->stack.last();
+    // 'play' all elements recursively starting with 'svg' as root
+    bool b = play( svg );
+    d->stack.remove( d->stack.begin() );
+    return b;
+}
+
+/*!
+    Returns the SVG as a single string of XML.
+*/
+TQString TQSvgDevice::toString() const
+{
+    if ( doc.isNull() )
+	return TQString();
+
+    return doc.toString();
+}
+
+/*!
+    Saves the SVG to \a fileName.
+*/
+
+bool TQSvgDevice::save( const TQString &fileName )
+{
+    // guess svg id from fileName
+    TQString svgName = fileName.endsWith( ".svg" ) ?
+		      fileName.left( fileName.length()-4 ) : fileName;
+
+    // now we have the info about name and dimensions available
+    TQDomElement root = doc.documentElement();
+    root.setAttribute( "id", svgName );
+    // the standard doesn't take respect x and y. But we want a
+    // proper bounding rect. We make width and height bigger when
+    // writing out and subtract x and y when reading in.
+    root.setAttribute( "x", brect.x() );
+    root.setAttribute( "y", brect.y() );
+    root.setAttribute( "width", brect.width() + brect.x() );
+    root.setAttribute( "height", brect.height() + brect.y() );
+
+    // ... and know how to name any image files to be written out
+    int icount = 0;
+    ImageList::Iterator iit = d->images.begin();
+    for ( ; iit != d->images.end(); ++iit ) {
+	TQString href = TQString( "%1_%2.png" ).arg( svgName ).arg( icount );
+	(*iit).image.save( href, "PNG" );
+	(*iit).element.setAttribute( "xlink:href", href );
+	icount++;
+    }
+    PixmapList::Iterator pit = d->pixmaps.begin();
+    for ( ; pit != d->pixmaps.end(); ++pit ) {
+	TQString href = TQString( "%1_%2.png" ).arg( svgName ).arg( icount );
+	(*pit).pixmap.save( href, "PNG" );
+	(*pit).element.setAttribute( "xlink:href", href );
+	icount++;
+    }
+
+    TQFile f( fileName );
+    if ( !f.open ( IO_WriteOnly ) )
+	return FALSE;
+    TQTextStream s( &f );
+    s.setEncoding( TQTextStream::UnicodeUTF8 );
+    s << doc;
+
+    return TRUE;
+}
+
+/*!
+    \overload
+
+    \a dev is the device to use for saving.
+*/
+
+bool TQSvgDevice::save( TQIODevice *dev )
+{
+#if defined(CHECK_RANGE)
+    if ( !d->images.isEmpty() || !d->pixmaps.isEmpty() )
+	qWarning( "TQSvgDevice::save: skipping external images" );
+#endif
+
+    TQTextStream s( dev );
+    s.setEncoding( TQTextStream::UnicodeUTF8 );
+    s << doc;
+
+    return TRUE;
+}
+
+/*!
+    \fn TQRect TQSvgDevice::boundingRect() const
+
+    Returns the bounding rectangle of the SVG.
+*/
+
+/*!
+    Sets the bounding rectangle of the SVG to rectangle \a r.
+*/
+
+void TQSvgDevice::setBoundingRect( const TQRect &r )
+{
+    brect = r;
+}
+
+/*!
+    Internal implementation of the virtual TQPaintDevice::metric()
+    function.
+
+    \warning Use the TQPaintDeviceMetrics class instead.
+
+    A TQSvgDevice has the following hard coded values: dpi=72,
+    numcolors=16777216 and depth=24. \a m is the metric to get.
+*/
+
+int TQSvgDevice::metric( int m ) const
+{
+    int val;
+    switch ( m ) {
+    case TQPaintDeviceMetrics::PdmWidth:
+	val = brect.width();
+	break;
+    case TQPaintDeviceMetrics::PdmHeight:
+	val = brect.height();
+	break;
+    case TQPaintDeviceMetrics::PdmWidthMM:
+	val = int(25.4/72.0*brect.width());
+	break;
+    case TQPaintDeviceMetrics::PdmHeightMM:
+	val = int(25.4/72.0*brect.height());
+	break;
+    case TQPaintDeviceMetrics::PdmDpiX:
+	val = 72;
+	break;
+    case TQPaintDeviceMetrics::PdmDpiY:
+	val = 72;
+	break;
+    case TQPaintDeviceMetrics::PdmNumColors:
+	val = 16777216;
+	break;
+    case TQPaintDeviceMetrics::PdmDepth:
+	val = 24;
+	break;
+    default:
+	val = 0;
+#if defined(QT_CHECK_RANGE)
+	qWarning( "TQSvgDevice::metric: Invalid metric command" );
+#endif
+    }
+    return val;
+}
+
+/*!
+    \internal
+
+    Records painter commands and stores them in the TQDomDocument doc.
+*/
+
+bool TQSvgDevice::cmd ( int c, TQPainter *painter, TQPDevCmdParam *p )
+{
+    pt = painter;
+
+    if ( c == PdcBegin ) {
+	TQDomImplementation domImpl;
+	TQDomDocumentType docType = domImpl.createDocumentType( "svg",
+							       publicId,
+							       systemId );
+	doc = domImpl.createDocument( "http://www.w3.org/2000/svg",
+				      "svg", docType );
+	doc.insertBefore( doc.createProcessingInstruction( "xml", piData ),
+			  doc.firstChild() );
+	current = doc.documentElement();
+	d->images.clear();
+	d->pixmaps.clear();
+	dirtyTransform = dirtyStyle = FALSE; // ###
+	return TRUE;
+    } else if ( c == PdcEnd ) {
+	return TRUE;
+    }
+
+    TQDomElement e;
+    TQString str;
+    TQRect rect;
+    TQPointArray a;
+    int i, width, height, x, y;
+    switch ( c ) {
+    case PdcNOP:
+	break;
+    case PdcMoveTo:
+	curPt = *p[0].point;
+	break;
+    case PdcLineTo:
+	e = doc.createElement( "line" );
+	e.setAttribute( "x1", curPt.x() );
+	e.setAttribute( "y1", curPt.y() );
+	e.setAttribute( "x2", p[0].point->x() );
+	e.setAttribute( "y2", p[0].point->y() );
+	break;
+    case PdcDrawPoint:
+    case PdcDrawLine:
+	e = doc.createElement( "line" );
+	e.setAttribute( "x1", p[0].point->x() );
+	e.setAttribute( "y1", p[0].point->y() );
+	i = ( c == PdcDrawLine ) ? 1 : 0;
+	e.setAttribute( "x2", p[i].point->x() );
+	e.setAttribute( "y2", p[i].point->y() );
+	break;
+    case PdcDrawRect:
+    case PdcDrawRoundRect:
+	e = doc.createElement( "rect" );
+	x = p[0].rect->x();
+	y = p[0].rect->y();
+	width = p[0].rect->width();
+	height = p[0].rect->height();
+	if ( width < 0 ) {
+	    width = -width;
+	    x -= width - 1;
+	}
+	if ( height < 0 ) {
+	    height = -height;
+	    y -= height - 1;
+	}
+	e.setAttribute( "x", x );
+	e.setAttribute( "y", y );
+	e.setAttribute( "width", width );
+	e.setAttribute( "height", height );
+	if ( c == PdcDrawRoundRect ) {
+	    e.setAttribute( "rx", (p[1].ival*p[0].rect->width())/200 );
+	    e.setAttribute( "ry", (p[2].ival*p[0].rect->height())/200 );
+	}
+	break;
+    case PdcDrawEllipse:
+	rect = *p[0].rect;
+	if ( rect.width() == rect.height() ) {
+	    e = doc.createElement( "circle" );
+	    double cx = rect.x() + (rect.width() / 2.0);
+	    double cy = rect.y() + (rect.height() / 2.0);
+	    e.setAttribute( "cx", cx );
+	    e.setAttribute( "cy", cy );
+	    e.setAttribute( "r", cx - rect.x() );
+	} else {
+	    e = doc.createElement( "ellipse" );
+    	    double cx = rect.x() + (rect.width() / 2.0);
+	    double cy = rect.y() + (rect.height() / 2.0);
+	    e.setAttribute( "cx", cx );
+	    e.setAttribute( "cy", cy );
+	    e.setAttribute( "rx", cx - rect.x() );
+	    e.setAttribute( "ry", cy - rect.y() );
+	}
+	break;
+    case PdcDrawArc:
+    case PdcDrawPie:
+    case PdcDrawChord: {
+	rect = *p[0].rect;
+	double a = (double)p[1].ival / 16.0 * deg2rad;
+	double al = (double)p[2].ival / 16.0 * deg2rad;
+	double rx = rect.width() / 2.0;
+	double ry = rect.height() / 2.0;
+	double x0 = (double)rect.x() + rx;
+	double y0 = (double)rect.y() + ry;
+	double x1 = x0 + rx*cos(a);
+	double y1 = y0 - ry*sin(a);
+	double x2 = x0 + rx*cos(a+al);
+	double y2 = y0 - ry*sin(a+al);
+	int large = TQABS( al ) > ( 180.0 * deg2rad ) ? 1 : 0;
+	int sweep = al < 0.0 ? 1 : 0;
+	if ( c == PdcDrawPie )
+	    str = TQString( "M %1 %2 L %3 %4 " ).arg( x0 ).arg( y0 )
+		  .arg( x1 ).arg( y1 );
+	else
+	    str = TQString( "M %1 %2 " ).arg( x1 ).arg( y1 );
+	str += TQString( "A %1 %2 %3 %4 %5 %6 %7" )
+	       .arg( rx ).arg( ry ).arg( a/deg2rad ). arg( large ).arg( sweep )
+	       .arg( x2 ).arg( y2 );
+	if ( c != PdcDrawArc )
+	    str += "z";
+	e = doc.createElement( "path" );
+	e.setAttribute( "d", str );
+    }
+	break;
+    case PdcDrawLineSegments:
+	{
+	    a = *p[0].ptarr;
+	    uint end = a.size() / 2;
+	    for (uint i = 0; i < end; i++) {
+		e = doc.createElement( "line" );
+		e.setAttribute( "x1", a[int(2*i)].x() );
+		e.setAttribute( "y1", a[int(2*i)].y() );
+		e.setAttribute( "x2", a[int(2*i+1)].x() );
+		e.setAttribute( "y2", a[int(2*i+1)].y() );
+		if ( i < end - 1 ) // The last one will be done at the end
+		    appendChild( e, c );
+	    }
+	}
+	break;
+    case PdcDrawPolyline:
+    case PdcDrawPolygon:
+	{
+	    a = *p[0].ptarr;
+	    e = doc.createElement( ( c == PdcDrawPolyline ) ?
+				   "polyline" : "polygon" );
+	    for (uint i = 0; i < a.size(); i++) {
+		TQString tmp;
+		tmp.sprintf( "%d %d ", a[ (int)i ].x(), a[ (int)i ].y() );
+		str += tmp;
+	    }
+	    e.setAttribute( "points", str.stripWhiteSpace() );
+	}
+	break;
+#ifndef QT_NO_BEZIER
+    case PdcDrawCubicBezier:
+	a = *p[0].ptarr;
+	e = doc.createElement( "path" );
+	str.sprintf( "M %d %d C %d %d %d %d %d %d", a[0].x(), a[0].y(),
+		     a[1].x(), a[1].y(), a[2].x(), a[2].y(),
+		     a[3].x(), a[3].y() );
+	e.setAttribute( "d", str );
+	break;
+#endif
+    case PdcDrawText2:
+	e = doc.createElement( "text" );
+	if ( p[0].point->x() )
+	    e.setAttribute( "x", p[0].point->x() );
+	if ( p[0].point->y() )
+	    e.setAttribute( "y", p[0].point->y() );
+	e.appendChild( doc.createTextNode( *p[1].str ) );
+	break;
+    case PdcDrawText2Formatted: {
+	e = doc.createElement( "text" );
+	const TQRect *r = p[0].rect;
+	int tf = p[1].ival;
+	int x, y;
+	// horizontal text alignment
+	if ( ( tf & TQt::AlignHCenter ) != 0 ) {
+	    x = r->x() + r->width() / 2;
+	    e.setAttribute( "text-anchor", "middle" );
+	} else if ( ( tf & TQt::AlignRight ) != 0 ) {
+	    x = r->right();
+	    e.setAttribute( "text-anchor", "end" );
+	} else {
+	    x = r->x();
+	}
+	// vertical text alignment
+	if ( ( tf & TQt::AlignVCenter ) != 0 )
+	    y = r->y() + ( r->height() + painter->fontMetrics().ascent() ) / 2;
+	else if ( ( tf & TQt::AlignBottom ) != 0 )
+	    y = r->bottom();
+	else
+	    y = r->y() + painter->fontMetrics().ascent();
+	if ( x )
+	    e.setAttribute( "x", x );
+	if ( y )
+	    e.setAttribute( "y", y );
+	e.appendChild( doc.createTextNode( *p[2].str ) );
+    }
+	break;
+    case PdcDrawPixmap:
+    case PdcDrawImage:
+	e = doc.createElement( "image" );
+	e.setAttribute( "x", p[0].rect->x() );
+	e.setAttribute( "y", p[0].rect->y() );
+	e.setAttribute( "width", p[0].rect->width() );
+	e.setAttribute( "height", p[0].rect->height() );
+	if ( c == PdcDrawImage ) {
+	    ImgElement ie;
+	    ie.element = e;
+	    ie.image = *p[1].image;
+	    d->images.append( ie );
+	} else {
+	    PixElement pe;
+	    pe.element = e;
+	    pe.pixmap = *p[1].pixmap;
+	    d->pixmaps.append( pe );
+	}
+	// saving to disk and setting the xlink:href attribute will be
+	// done later in save() once we now the svg document name.
+	break;
+    case PdcSave:
+	e = doc.createElement( "g" );
+	break;
+    case PdcRestore:
+	current = current.parentNode();
+	dirtyTransform = !pt->worldMatrix().isIdentity();
+        d->justRestored = TRUE;
+	// ### reset dirty flags
+	break;
+    case PdcSetBkColor:
+    case PdcSetBkMode:
+    case PdcSetROP:
+    case PdcSetBrushOrigin:
+    case PdcSetFont:
+    case PdcSetPen:
+    case PdcSetBrush:
+	dirtyStyle = TRUE;
+	break;
+    case PdcSetTabStops:
+	// ###
+	break;
+    case PdcSetTabArray:
+	// ###
+	break;
+    case PdcSetVXform:
+    case PdcSetWindow:
+    case PdcSetViewport:
+    case PdcSetWXform:
+    case PdcSetWMatrix:
+    case PdcSaveWMatrix:
+    case PdcRestoreWMatrix:
+	dirtyTransform = TRUE;
+	break;
+    case PdcSetClip:
+	// ###
+	break;
+    case PdcSetClipRegion:
+	{
+            // We skip the clip after restore, since restoring the clip is done automatically by
+            // the viewer as part of the tree structure. It doesn't hurt to write the region
+            // out, but it doubles the number of clipregions defined in the final svg.
+            if (d->justRestored) {
+                d->justRestored = FALSE;
+                return TRUE;
+            }
+
+            TQMemArray<TQRect> rects = p[0].rgn->rects();
+            if (rects.count() == 0)
+                return TRUE;
+	    d->currentClip++;
+	    e = doc.createElement( "clipPath" );
+	    e.setAttribute( "id", TQString("clip%1").arg(d->currentClip) );
+            for (int i=0; i<(int)rects.count(); ++i) {
+                TQDomElement ce = doc.createElement("rect");
+                ce.setAttribute( "x", rects.at(i).x() );
+                ce.setAttribute( "y", rects.at(i).y() );
+                ce.setAttribute( "width", rects.at(i).width() );
+                ce.setAttribute( "height", rects.at(i).height() );
+                e.appendChild(ce);
+	    }
+	    break;
+	}
+    default:
+#if defined(CHECK_RANGE)
+	qWarning( "TQSVGDevice::cmd: Invalid command %d", c );
+#endif
+	break;
+    }
+
+    appendChild( e, c );
+
+    return TRUE;
+}
+
+/*!
+    \internal
+
+    Appends the child and applys any style and transformation.
+
+*/
+
+void TQSvgDevice::appendChild( TQDomElement &e, int c )
+{
+    if ( !e.isNull() ) {
+	current.appendChild( e );
+	if ( c == PdcSave )
+	    current = e;
+	// ### optimize application of attributes utilizing <g>
+	if ( c == PdcSetClipRegion ) {
+	    TQDomElement ne;
+	    ne = doc.createElement( "g" );
+	    ne.setAttribute( "style", TQString("clip-path:url(#clip%1)").arg(d->currentClip) );
+	    current.appendChild( ne );
+	    current = ne;
+	} else {
+	    if ( dirtyStyle )		// only reset when entering
+		applyStyle( &e, c );	// or leaving a <g> tag
+	    if ( dirtyTransform && e.tagName() != "g" ) {
+		// same as above but not for <g> tags
+		applyTransform( &e );
+		if ( c == PdcSave )
+		    dirtyTransform = FALSE;
+	    }
+	}
+    }
+}
+
+
+/*!
+    \internal
+
+    Push the current drawing attributes on a stack.
+
+    \sa restoreAttributes()
+*/
+
+void TQSvgDevice::saveAttributes()
+{
+    pt->save();
+    // copy old state
+    TQSvgDeviceState st( *curr );
+    d->stack.append( st );
+    curr = &d->stack.last();
+}
+
+/*!
+    \internal
+
+    Pop the current drawing attributes off the stack.
+
+    \sa saveAttributes()
+*/
+
+void TQSvgDevice::restoreAttributes()
+{
+    pt->restore();
+    Q_ASSERT( d->stack.count() > 1 );
+    d->stack.remove( d->stack.fromLast() );
+    curr = &d->stack.last();
+}
+
+/*!
+    \internal
+
+    Evaluate \a node, drawing on \a p. Allows recursive calls.
+*/
+
+bool TQSvgDevice::play( const TQDomNode &node )
+{
+    saveAttributes();
+
+	ElementType t = (*qSvgTypeMap)[ node.nodeName() ];
+
+	if ( t == LineElement && pt->pen().style() == TQt::NoPen ) {
+	    TQPen p = pt->pen();
+	    p.setStyle( TQt::SolidLine );
+	    pt->setPen( p );
+	}
+	TQDomNamedNodeMap attr = node.attributes();
+	if ( attr.contains( "style" ) )
+	    setStyle( attr.namedItem( "style" ).nodeValue() );
+	// ### might have to exclude more elements from transform
+	if ( t != SvgElement && attr.contains( "transform" ) )
+	    setTransform( attr.namedItem( "transform" ).nodeValue() );
+	uint i = attr.length();
+	if ( i > 0 ) {
+	    TQPen pen = pt->pen();
+	    TQFont font = pt->font();
+	    while ( i-- ) {
+		TQDomNode n = attr.item( i );
+		TQString a = n.nodeName();
+		TQString val = n.nodeValue().lower().stripWhiteSpace();
+		setStyleProperty( a, val, &pen, &font, &curr->textalign );
+	    }
+	    pt->setPen( pen );
+	    pt->setFont( font );
+	}
+
+	int x1, y1, x2, y2, rx, ry, w, h;
+	double cx1, cy1, crx, cry;
+	switch ( t ) {
+	case CommentElement:
+	    // ignore
+	    break;
+	case RectElement:
+	    rx = ry = 0;
+	    x1 = lenToInt( attr, "x" );
+	    y1 = lenToInt( attr, "y" );
+	    w = lenToInt( attr, "width" );
+	    h = lenToInt( attr, "height" );
+	    if ( w == 0 || h == 0 )	// prevent div by zero below
+		break;
+	    x2 = (int)attr.contains( "rx" ); // tiny abuse of x2 and y2
+	    y2 = (int)attr.contains( "ry" );
+	    if ( x2 )
+		rx = lenToInt( attr, "rx" );
+	    if ( y2 )
+		ry = lenToInt( attr, "ry" );
+	    if ( x2 && !y2 )
+		ry = rx;
+	    else if ( !x2 && y2 )
+		rx = ry;
+	    rx = int(200.0*double(rx)/double(w));
+	    ry = int(200.0*double(ry)/double(h));
+	    pt->drawRoundRect( x1, y1, w, h, rx, ry );
+	    break;
+	case CircleElement:
+	    cx1 = lenToDouble( attr, "cx" ) + 0.5;
+	    cy1 = lenToDouble( attr, "cy" ) + 0.5;
+	    crx = lenToDouble( attr, "r" );
+	    pt->drawEllipse( (int)(cx1-crx), (int)(cy1-crx), (int)(2*crx), (int)(2*crx) );
+	    break;
+	case EllipseElement:
+	    cx1 = lenToDouble( attr, "cx" ) + 0.5;
+	    cy1 = lenToDouble( attr, "cy" ) + 0.5;
+	    crx = lenToDouble( attr, "rx" );
+	    cry = lenToDouble( attr, "ry" );
+	    pt->drawEllipse( (int)(cx1-crx), (int)(cy1-cry), (int)(2*crx), (int)(2*cry) );
+	    break;
+	case LineElement:
+	    {
+		x1 = lenToInt( attr, "x1" );
+		x2 = lenToInt( attr, "x2" );
+		y1 = lenToInt( attr, "y1" );
+		y2 = lenToInt( attr, "y2" );
+		TQPen p = pt->pen();
+		w = p.width();
+		p.setWidth( (unsigned int)(w * (TQABS(pt->worldMatrix().m11()) + TQABS(pt->worldMatrix().m22())) / 2) );
+		pt->setPen( p );
+		pt->drawLine( x1, y1, x2, y2 );
+		p.setWidth( w );
+		pt->setPen( p );
+	    }
+	    break;
+	case PolylineElement:
+	case PolygonElement:
+	    {
+		TQString pts = attr.namedItem( "points" ).nodeValue();
+		pts = pts.simplifyWhiteSpace();
+		TQStringList sl = TQStringList::split( TQRegExp( TQString::fromLatin1("[ ,]") ), pts );
+		TQPointArray ptarr( (uint)sl.count() / 2);
+		for ( int i = 0; i < (int)sl.count() / 2; i++ ) {
+		    double dx = sl[2*i].toDouble();
+		    double dy = sl[2*i+1].toDouble();
+		    ptarr.setPoint( i, int(dx), int(dy) );
+		}
+  		if ( t == PolylineElement ) {
+		    if ( pt->brush().style() != TQt::NoBrush ) {
+			TQPen pn = pt->pen();
+			pt->setPen( TQt::NoPen );
+			pt->drawPolygon( ptarr );
+			pt->setPen( pn );
+		    }
+		    pt->drawPolyline( ptarr ); // ### closes when filled. bug ?
+  		} else {
+		    pt->drawPolygon( ptarr );
+		}
+	    }
+	    break;
+	case SvgElement:
+	case GroupElement:
+	case AnchorElement:
+	    {
+		TQDomNode child = node.firstChild();
+		while ( !child.isNull() ) {
+		    play( child );
+		    child = child.nextSibling();
+		}
+	    }
+	    break;
+	case PathElement:
+	    drawPath( attr.namedItem( "d" ).nodeValue() );
+	    break;
+	case TSpanElement:
+	case TextElement:
+	    {
+		if ( attr.contains( "x" ) )
+		     curr->textx = lenToInt( attr, "x" );
+		if ( attr.contains( "y" ) )
+		     curr->texty = lenToInt( attr, "y" );
+		if ( t == TSpanElement ) {
+		    curr->textx += lenToInt( attr, "dx" );
+		    curr->texty += lenToInt( attr, "dy" );
+		}
+		// backup old colors
+		TQPen pn = pt->pen();
+		TQColor pcolor = pn.color();
+		TQColor bcolor = pt->brush().color();
+		TQDomNode c = node.firstChild();
+		while ( !c.isNull() ) {
+		    if ( c.isText() ) {
+			// we have pen and brush reversed for text drawing
+			pn.setColor( bcolor );
+			pt->setPen( pn );
+			TQString text = c.toText().nodeValue();
+			text = text.simplifyWhiteSpace(); // ### 'preserve'
+			w = pt->fontMetrics().width( text );
+			if ( curr->textalign == TQt::AlignHCenter )
+			    curr->textx -= w / 2;
+			else if ( curr->textalign == TQt::AlignRight )
+			    curr->textx -= w;
+			pt->drawText( curr->textx, curr->texty, text );
+			// restore pen
+			pn.setColor( pcolor );
+			pt->setPen( pn );
+			curr->textx += w;
+		    } else if ( c.isElement() &&
+				c.toElement().tagName() == "tspan" ) {
+			play( c );
+
+		    }
+		    c = c.nextSibling();
+		}
+		if ( t == TSpanElement ) {
+		    // move current text position in parent text element
+		    StateList::Iterator it = --d->stack.fromLast();
+		    (*it).textx = curr->textx;
+		    (*it).texty = curr->texty;
+		}
+	    }
+	    break;
+	case ImageElement:
+	    {
+		x1 = lenToInt( attr, "x" );
+		y1 = lenToInt( attr, "y" );
+		w = lenToInt( attr, "width" );
+		h = lenToInt( attr, "height" );
+		TQString href = attr.namedItem( "xlink:href" ).nodeValue();
+		// ### catch references to embedded .svg files
+		TQPixmap pix;
+		if ( !pix.load( href ) ) {
+		    qWarning( "TQSvgDevice::play: Couldn't load image %s", href.latin1() );
+		    break;
+		}
+		pt->drawPixmap( TQRect( x1, y1, w, h ), pix );
+	    }
+	    break;
+	case DescElement:
+	case TitleElement:
+	    // ignored for now
+	    break;
+	case ClipElement:
+	    {
+		TQDomNode child = node.firstChild();
+                TQRegion region;
+                while (!child.isNull()) {
+                    TQDomNamedNodeMap childAttr = child.attributes();
+                    if ( child.nodeName() == "rect" ) {
+                        TQRect r;
+                        r.setX(lenToInt( childAttr, "x" ));
+                        r.setY(lenToInt( childAttr, "y" ));
+                        r.setWidth(lenToInt( childAttr, "width" ));
+                        r.setHeight(lenToInt( childAttr, "height" ));
+                        region |= r;
+                    } else if ( child.nodeName() == "ellipse" ) {
+                        TQRect r;
+                        int x = lenToInt( childAttr, "cx" );
+                        int y = lenToInt( childAttr, "cy" );
+                        int width = lenToInt( childAttr, "rx" );
+                        int height = lenToInt( childAttr, "ry" );
+                        r.setX( x - width );
+                        r.setY( y - height );
+                        r.setWidth( width * 2 );
+                        r.setHeight( height * 2 );
+                        TQRegion rgn( r, TQRegion::Ellipse );
+                        region |= rgn;
+                    }
+                    child = child.nextSibling();
+                }
+                // Store the region in a named map so that it can be used when the
+                // group node is entered.
+                TQString idString = attr.namedItem("id").nodeValue();
+                if (!idString.isEmpty())
+                    d->clipPathTable[idString] = region;
+                break;
+	    }
+	case InvalidElement:
+	    qWarning( "TQSvgDevice::play: unknown element type %s",
+		      node.nodeName().latin1() );
+	    break;
+	};
+
+	restoreAttributes();
+
+    return TRUE;
+}
+
+/*!
+    \internal
+
+    Parses a CSS2-compatible color specification. Either a keyword or
+    a numerical RGB specification like #ff00ff or rgb(255,0,50%).
+*/
+
+TQColor TQSvgDevice::parseColor( const TQString &col )
+{
+    static const struct ColorTable {
+	const char *name;
+	const char *rgb;
+    } coltab[] = {
+	{ "black",   "#000000" },
+	{ "silver",  "#c0c0c0" },
+	{ "gray",    "#808080" },
+	{ "white",   "#ffffff" },
+	{ "maroon",  "#800000" },
+	{ "red",     "#ff0000" },
+	{ "purple",  "#800080" },
+	{ "fuchsia", "#ff00ff" },
+	{ "green",   "#008000" },
+	{ "lime",    "#00ff00" },
+	{ "olive",   "#808000" },
+	{ "yellow",  "#ffff00" },
+	{ "navy",    "#000080" },
+	{ "blue",    "#0000ff" },
+	{ "teal",    "#008080" },
+	{ "aqua",    "#00ffff" },
+	// ### the latest spec has more
+	{ 0,         0         }
+    };
+
+    // initialize color map on first use
+    if ( !qSvgColMap ) {
+	qSvgColMap = new TQMap<TQString, TQString>;
+	const struct ColorTable *t = coltab;
+	while ( t->name ) {
+	    qSvgColMap->insert( t->name, t->rgb );
+	    t++;
+	}
+    }
+
+    // a keyword ?
+    if ( qSvgColMap->contains ( col ) )
+	return TQColor( (*qSvgColMap)[ col ] );
+    // in rgb(r,g,b) form ?
+    TQString c = col;
+    c.replace( TQRegExp( TQString::fromLatin1("\\s*") ), "" );
+    TQRegExp reg( TQString::fromLatin1("^rgb\\((\\d+)(%?),(\\d+)(%?),(\\d+)(%?)\\)$") );
+    if ( reg.search( c ) >= 0 ) {
+	int comp[3];
+	for ( int i = 0; i < 3; i++ ) {
+	    comp[ i ] = reg.cap( 2*i+1 ).toInt();
+	    if ( !reg.cap( 2*i+2 ).isEmpty() )		// percentage ?
+		comp[ i ] = int((double(255*comp[ i ])/100.0));
+	}
+	return TQColor( comp[ 0 ], comp[ 1 ], comp[ 2 ] );
+    }
+
+    // check for predefined TQt color objects, #RRGGBB and #RGB
+    return TQColor( col );
+}
+
+/*!
+    \internal
+
+    Parse a <length> datatype consisting of a number followed by an
+    optional unit specifier. Can be used for type <coordinate> as
+    well. For relative units the value of \a horiz will determine
+    whether the horizontal or vertical dimension will be used.
+*/
+
+double TQSvgDevice::parseLen( const TQString &str, bool *ok, bool horiz ) const
+{
+    TQRegExp reg( TQString::fromLatin1("([+-]?\\d*\\.*\\d*[Ee]?[+-]?\\d*)(em|ex|px|%|pt|pc|cm|mm|in|)$") );
+    if ( reg.search( str ) == -1 ) {
+	qWarning( "TQSvgDevice::parseLen: couldn't parse %s ", str.latin1() );
+	if ( ok )
+	    *ok = FALSE;
+	return 0.0;
+    }
+
+    double dbl = reg.cap( 1 ).toDouble();
+    TQString u = reg.cap( 2 );
+    if ( !u.isEmpty() && u != "px" ) {
+	TQPaintDeviceMetrics m( pt->device() );
+	if ( u == "em" ) {
+	    TQFontInfo fi( pt->font() );
+	    dbl *= fi.pixelSize();
+	} else if ( u == "ex" ) {
+	    TQFontInfo fi( pt->font() );
+	    dbl *= 0.5 * fi.pixelSize();
+	} else if ( u == "%" )
+	    dbl *= (horiz ? pt->window().width() : pt->window().height())/100.0;
+	else if ( u == "cm" )
+	    dbl *= m.logicalDpiX() / 2.54;
+	else if ( u == "mm" )
+	    dbl *= m.logicalDpiX() / 25.4;
+	else if ( u == "in" )
+	    dbl *= m.logicalDpiX();
+	else if ( u == "pt" )
+	    dbl *= m.logicalDpiX() / 72.0;
+	else if ( u == "pc" )
+	    dbl *= m.logicalDpiX() / 6.0;
+	else
+	    qWarning( "TQSvgDevice::parseLen: Unknown unit %s",  u.latin1() );
+    }
+    if ( ok )
+	*ok = TRUE;
+    return dbl;
+}
+
+/*!
+    \internal
+
+    Returns the length specified in attribute \a attr in \a map. If
+    the specified attribute doesn't exist or can't be parsed \a def is
+    returned.
+*/
+
+int TQSvgDevice::lenToInt( const TQDomNamedNodeMap &map, const TQString &attr,
+			  int def ) const
+{
+    if ( map.contains( attr ) ) {
+	bool ok;
+	double dbl = parseLen( map.namedItem( attr ).nodeValue(), &ok );
+	if ( ok )
+	    return qRound( dbl );
+    }
+    return def;
+}
+
+double TQSvgDevice::lenToDouble( const TQDomNamedNodeMap &map, const TQString &attr,
+				int def ) const
+{
+    if ( map.contains( attr ) ) {
+	bool ok;
+	double d = parseLen( map.namedItem( attr ).nodeValue(), &ok );
+	if ( ok )
+	    return d;
+    }
+    return def;
+}
+
+void TQSvgDevice::setStyleProperty( const TQString &prop, const TQString &val,
+				   TQPen *pen, TQFont *font, int *talign )
+{
+    if ( prop == "stroke" ) {
+	if ( val == "none" ) {
+	    pen->setStyle( TQt::NoPen );
+	} else {
+	    pen->setColor( parseColor( val ));
+	    if ( pen->style() == TQt::NoPen )
+		pen->setStyle( TQt::SolidLine );
+	    if ( pen->width() == 0 )
+		pen->setWidth( 1 );
+	}
+    } else if ( prop == "stroke-width" ) {
+	double w = parseLen( val );
+	if ( w > 0.0001 )
+	    pen->setWidth( int(w) );
+	else
+	    pen->setStyle( TQt::NoPen );
+    } else if ( prop == "stroke-linecap" ) {
+	if ( val == "butt" )
+	    pen->setCapStyle( TQt::FlatCap );
+	else if ( val == "round" )
+	    pen->setCapStyle( TQt::RoundCap );
+	else if ( val == "square" )
+	    pen->setCapStyle( TQt::SquareCap );
+    } else if ( prop == "stroke-linejoin" ) {
+	if ( val == "miter" )
+	    pen->setJoinStyle( TQt::MiterJoin );
+	else if ( val == "round" )
+	    pen->setJoinStyle( TQt::RoundJoin );
+	else if ( val == "bevel" )
+	    pen->setJoinStyle( TQt::BevelJoin );
+    } else if ( prop == "stroke-dasharray" ) {
+        if ( val == "18,6" )
+	    pen->setStyle( TQt::DashLine );
+	else if ( val == "3" )
+	    pen->setStyle( TQt::DotLine );
+	else if ( val == "9,6,3,6" )
+	    pen->setStyle( TQt::DashDotLine );
+	else if ( val == "9,3,3" )
+	    pen->setStyle( TQt::DashDotDotLine );
+        else
+            pen->setStyle( TQt::DotLine );
+    } else if ( prop == "fill" ) {
+	if ( val == "none" )
+	    pt->setBrush( TQt::NoBrush );
+	else
+	    pt->setBrush( parseColor( val ) );
+    } else if ( prop == "font-size" ) {
+	font->setPointSizeFloat( float(parseLen( val )) );
+    } else if ( prop == "font-family" ) {
+	font->setFamily( val );
+    } else if ( prop == "font-style" ) {
+	if ( val == "normal" )
+	    font->setItalic( FALSE );
+	else if ( val == "italic" )
+	    font->setItalic( TRUE );
+	else
+	    qWarning( "TQSvgDevice::setStyleProperty: unhandled "
+		      "font-style: %s", val.latin1() );
+    } else if ( prop == "font-weight" ) {
+	int w = font->weight();
+	// no exact equivalents so we have to "round" a little bit
+	if ( val == "100" || val == "200" )
+	    w = TQFont::Light;
+	if ( val == "300" || val == "400" || val == "normal" )
+	    w = TQFont::Normal;
+	else if ( val == "500" || val == "600" )
+	    w = TQFont::DemiBold;
+	else if ( val == "700" || val == "bold" || val == "800" )
+	    w = TQFont::Bold;
+	else if ( val == "900" )
+	    w = TQFont::Black;
+	font->setWeight( w );
+    } else if ( prop == "text-anchor" ) {
+	if ( val == "middle" )
+	    *talign = TQt::AlignHCenter;
+	else if ( val == "end" )
+	    *talign = TQt::AlignRight;
+	else
+	    *talign = TQt::AlignLeft;
+    } else if ( prop == "clip-path" ) {
+        if (val.startsWith("url(#")) {
+            TQString clipName = val.mid(5, val.length() - 6);
+            if (!clipName.isEmpty()) {
+                TQRegion clipRegion = d->clipPathTable[clipName];
+                if (!clipRegion.isEmpty())
+                    pt->setClipRegion(pt->clipRegion() & clipRegion, TQPainter::CoordPainter);
+            }
+        }
+    }
+}
+
+void TQSvgDevice::setStyle( const TQString &s )
+{
+    TQStringList rules = TQStringList::split( TQChar(';'), s );
+
+    TQPen pen = pt->pen();
+    TQFont font = pt->font();
+
+    TQStringList::ConstIterator it = rules.begin();
+    for ( ; it != rules.end(); it++ ) {
+	int col = (*it).find( ':' );
+	if ( col > 0 ) {
+	    TQString prop = (*it).left( col ).simplifyWhiteSpace();
+	    TQString val = (*it).right( (*it).length() - col - 1 );
+	    val = val.lower().stripWhiteSpace();
+	    setStyleProperty( prop, val, &pen, &font, &curr->textalign );
+	}
+    }
+
+    pt->setPen( pen );
+    pt->setFont( font );
+}
+
+void TQSvgDevice::setTransform( const TQString &tr )
+{
+    TQString t = tr.simplifyWhiteSpace();
+
+    TQRegExp reg( TQString::fromLatin1("\\s*([\\w]+)\\s*\\(([^\\(]*)\\)") );
+    int index = 0;
+    while ( (index = reg.search(t, index)) >= 0 ) {
+	TQString command = reg.cap( 1 );
+	TQString params = reg.cap( 2 );
+	TQStringList plist = TQStringList::split( TQRegExp(TQString::fromLatin1("[,\\s]")), params );
+	if ( command == "translate" ) {
+	    double tx = 0, ty = 0;
+	    tx = plist[0].toDouble();
+	    if ( plist.count() >= 2 )
+		ty = plist[1].toDouble();
+	    pt->translate( tx, ty );
+	} else if ( command == "rotate" ) {
+	    pt->rotate( plist[0].toDouble() );
+	} else if ( command == "scale" ) {
+	    double sx, sy;
+	    sx = sy = plist[0].toDouble();
+	    if ( plist.count() >= 2 )
+		sy = plist[1].toDouble();
+	    pt->scale( sx, sy );
+	} else if ( command == "matrix" && plist.count() >= 6 ) {
+	    double m[ 6 ];
+	    for (int i = 0; i < 6; i++)
+		m[ i ] = plist[ i ].toDouble();
+	    TQWMatrix wm( m[ 0 ], m[ 1 ], m[ 2 ],
+			 m[ 3 ], m[ 4 ], m[ 5 ] );
+	    pt->setWorldMatrix( wm, TRUE );
+	} else if ( command == "skewX" ) {
+	    pt->shear( 0.0, tan( plist[0].toDouble() * deg2rad ) );
+	} else if ( command == "skewY" ) {
+	    pt->shear( tan( plist[0].toDouble() * deg2rad ), 0.0 );
+	}
+
+	// move on to next command
+	index += reg.matchedLength();
+    }
+}
+
+void TQSvgDevice::drawPath( const TQString &data )
+{
+    double x0 = 0, y0 = 0;		// starting point
+    double x = 0, y = 0;		// current point
+    double controlX = 0, controlY = 0;	// last control point for curves
+    TQPointArray path( 500 );		// resulting path
+    TQValueList<int> subIndex;		// start indices for subpaths
+    TQPointArray quad( 4 ), bezier;	// for curve calculations
+    int pcount = 0;			// current point array index
+    uint idx = 0;			// current data position
+    int mode = 0, lastMode = 0;		// parser state
+    bool relative = FALSE;		// e.g. 'h' vs. 'H'
+    TQString commands( "MZLHVCSTQTA" );	// recognized commands
+    int cmdArgs[] = { 2, 0, 2, 1, 1, 6, 4, 4, 2, 7 };	// no of arguments
+    TQRegExp reg( TQString::fromLatin1("\\s*,?\\s*([+-]?\\d*\\.?\\d*)") );	// floating point
+
+    subIndex.append( 0 );
+    // detect next command
+    while ( idx < data.length() ) {
+	TQChar ch = data[ (int)idx++ ];
+	if ( ch.isSpace() )
+	    continue;
+	TQChar chUp = ch.upper();
+	int cmd = commands.find( chUp );
+	if ( cmd >= 0 ) {
+	    // switch to new command mode
+	    mode = cmd;
+	    relative = ( ch != chUp );		// e.g. 'm' instead of 'M'
+	} else {
+	    if ( mode && !ch.isLetter() ) {
+		cmd = mode;			// continue in previous mode
+		idx--;
+	    } else {
+		qWarning( "TQSvgDevice::drawPath: Unknown command" );
+		return;
+	    }
+	}
+
+	// read in the retquired number of arguments
+	const int maxArgs = 7;
+	double arg[ maxArgs ];
+	int numArgs = cmdArgs[ cmd ];
+	for ( int i = 0; i < numArgs; i++ ) {
+	    int pos = reg.search( data, idx );
+	    if ( pos == -1 ) {
+		qWarning( "TQSvgDevice::drawPath: Error parsing arguments" );
+		return;
+	    }
+	    arg[ i ] = reg.cap( 1 ).toDouble();
+	    idx = pos + reg.matchedLength();
+	};
+
+	// process command
+	double offsetX = relative ? x : 0;	// correction offsets
+	double offsetY = relative ? y : 0;	// for relative commands
+	switch ( mode ) {
+	case 0:					// 'M' move to
+	    if ( x != x0 || y != y0 )
+		path.setPoint( pcount++, int(x0), int(y0) );
+	    x = x0 = arg[ 0 ] + offsetX;
+	    y = y0 = arg[ 1 ] + offsetY;
+	    subIndex.append( pcount );
+	    path.setPoint( pcount++, int(x0), int(y0) );
+	    mode = 2;				// -> 'L'
+	    break;
+	case 1:					// 'Z' close path
+	    path.setPoint( pcount++, int(x0), int(y0) );
+	    x = x0;
+	    y = y0;
+	    mode = 0;
+	    break;
+	case 2:					// 'L' line to
+	    x = arg[ 0 ] + offsetX;
+	    y = arg[ 1 ] + offsetY;
+	    path.setPoint( pcount++, int(x), int(y) );
+	    break;
+	case 3:					// 'H' horizontal line
+	    x = arg[ 0 ] + offsetX;
+	    path.setPoint( pcount++, int(x), int(y) );
+	    break;
+	case 4:					// 'V' vertical line
+	    y = arg[ 0 ] + offsetY;
+	    path.setPoint( pcount++, int(x), int(y) );
+	    break;
+#ifndef QT_NO_BEZIER
+	case 5:					// 'C' cubic bezier curveto
+	case 6:					// 'S' smooth shorthand
+	case 7:					// 'Q' quadratic bezier curves
+	case 8: {				// 'T' smooth shorthand
+	    quad.setPoint( 0, int(x), int(y) );
+	    // if possible, reflect last control point if smooth shorthand
+	    if ( mode == 6 || mode == 8 ) { 	// smooth 'S' and 'T'
+		bool cont = mode == lastMode ||
+		     mode == 6 && lastMode == 5 || 	// 'S' and 'C'
+		     mode == 8 && lastMode == 7;	// 'T' and 'Q'
+		x = cont ? 2*x-controlX : x;
+		y = cont ? 2*y-controlY : y;
+		quad.setPoint( 1, int(x), int(y) );
+		quad.setPoint( 2, int(x), int(y) );
+	    }
+	    for ( int j = 0; j < numArgs/2; j++ ) {
+		x = arg[ 2*j   ] + offsetX;
+		y = arg[ 2*j+1 ] + offsetY;
+		quad.setPoint( j+4-numArgs/2, int(x), int(y) );
+	    }
+	    // remember last control point for next shorthand
+	    controlX = quad[ 2 ].x();
+	    controlY = quad[ 2 ].y();
+	    // transform quadratic into cubic Bezier
+	    if ( mode == 7 || mode == 8 ) {	// cubic 'Q' and 'T'
+		int x31 = quad[0].x()+int(2.0*(quad[2].x()-quad[0].x())/3.0);
+		int y31 = quad[0].y()+int(2.0*(quad[2].y()-quad[0].y())/3.0);
+		int x32 = quad[2].x()+int(2.0*(quad[3].x()-quad[2].x())/3.0);
+		int y32 = quad[2].y()+int(2.0*(quad[3].y()-quad[2].y())/3.0);
+		quad.setPoint( 1, x31, y31 );
+		quad.setPoint( 2, x32, y32 );
+	    }
+	    // calculate points on curve
+	    bezier = quad.cubicBezier();
+	    // reserve more space if needed
+	    if ( bezier.size() > path.size() - pcount )
+		path.resize( path.size() - pcount + bezier.size() );
+	    // copy
+	    for ( int k = 0; k < (int)bezier.size(); k ++ )
+		path.setPoint( pcount++, bezier[ k ] );
+	    break;
+	}
+#endif // QT_NO_BEZIER
+	case 9:					// 'A' elliptical arc curve
+	    // ### just a straight line
+	    x = arg[ 5 ] + offsetX;
+	    y = arg[ 6 ] + offsetY;
+	    path.setPoint( pcount++, int(x), int(y) );
+	    break;
+	};
+	lastMode = mode;
+	// array almost full ? expand for next loop
+	if ( pcount >= (int)path.size() - 4 )
+	    path.resize( 2 * path.size() );
+    }
+
+    subIndex.append( pcount );			// dummy marking the end
+    if ( pt->brush().style() != TQt::NoBrush ) {
+	// fill the area without stroke first
+	if ( x != x0 || y != y0 )
+	    path.setPoint( pcount++, int(x0), int(y0) );
+	TQPen pen = pt->pen();
+	pt->setPen( TQt::NoPen );
+	pt->drawPolygon( path, FALSE, 0, pcount );
+	pt->setPen( pen );
+    }
+    // draw each subpath stroke seperately
+    TQValueListConstIterator<int> it = subIndex.begin();
+    int start = 0;
+    while ( it != subIndex.fromLast() ) {
+	int next = *++it;
+	// ### always joins ends if first and last point coincide.
+	// ### 'Z' can't have the desired effect
+	pt->drawPolyline( path, start, next-start );
+	start = next;
+    }
+}
+
+void TQSvgDevice::applyStyle( TQDomElement *e, int c ) const
+{
+    // ### do not write every attribute each time
+    TQColor pcol = pt->pen().color();
+    TQColor bcol = pt->brush().color();
+    TQString s;
+    if ( c == PdcDrawText2 || c == PdcDrawText2Formatted ) {
+	// TQPainter has a reversed understanding of pen/stroke vs.
+	// brush/fill for text
+	s += TQString( "fill:rgb(%1,%2,%3);" )
+	     .arg( pcol.red() ).arg( pcol.green() ).arg( pcol.blue() );
+	s += TQString( "stroke-width:0;" );
+	TQFont f = pt->font();
+	TQFontInfo fi( f );
+	s += TQString( "font-size:%1;" ).arg( fi.pointSize() );
+	s += TQString( "font-style:%1;" )
+	     .arg( f.italic() ? "italic" : "normal" );
+	// not a very scientific distribution
+	TQString fw;
+	if ( f.weight() <= TQFont::Light )
+	    fw = "100";
+	else if ( f.weight() <= TQFont::Normal )
+	    fw = "400";
+	else if ( f.weight() <= TQFont::DemiBold )
+	    fw = "600";
+	else if ( f.weight() <= TQFont::Bold )
+	    fw = "700";
+	else if ( f.weight() <= TQFont::Black )
+	    fw = "800";
+	else
+	    fw = "900";
+	s += TQString( "font-weight:%1;" ).arg( fw );
+	s += TQString( "font-family:%1;" ).arg( f.family() );
+    } else {
+	s += TQString( "stroke:rgb(%1,%2,%3);" )
+	     .arg( pcol.red() ).arg( pcol.green() ).arg( pcol.blue() );
+	double pw = pt->pen().width();
+	if ( pw == 0 && pt->pen().style() != TQt::NoPen )
+	    pw = 0.9;
+	if ( c == PdcDrawLine )
+	    pw /= (TQABS(pt->worldMatrix().m11()) + TQABS(pt->worldMatrix().m22())) / 2.0;
+	s += TQString( "stroke-width:%1;" ).arg( pw );
+	if ( pt->pen().style() == TQt::DashLine )
+	    s+= TQString( "stroke-dasharray:18,6;" );
+	else if ( pt->pen().style() == TQt::DotLine )
+	    s+= TQString( "stroke-dasharray:3;" );
+	else if ( pt->pen().style() == TQt::DashDotLine )
+	    s+= TQString( "stroke-dasharray:9,6,3,6;" );
+	else if ( pt->pen().style() == TQt::DashDotDotLine )
+	    s+= TQString( "stroke-dasharray:9,3,3;" );
+	if ( pt->brush().style() == TQt::NoBrush || c == PdcDrawPolyline ||
+	     c == PdcDrawCubicBezier )
+	    s += "fill:none;"; // TQt polylines use no brush, neither do Beziers
+	else
+	    s += TQString( "fill:rgb(%1,%2,%3);" )
+		 .arg( bcol.red() ).arg( bcol.green() ).arg( bcol.blue() );
+    }
+    e->setAttribute( "style", s );
+}
+
+void TQSvgDevice::applyTransform( TQDomElement *e ) const
+{
+    TQWMatrix m = pt->worldMatrix();
+
+    TQString s;
+    bool rot = ( m.m11() != 1.0 || m.m12() != 0.0 ||
+		 m.m21() != 0.0 || m.m22() != 1.0 );
+    if ( !rot && ( m.dx() != 0.0 || m.dy() != 0.0 ) )
+	s = TQString( "translate(%1,%2)" ).arg( m.dx() ).arg( m.dy() );
+    else if ( rot ) {
+	if ( m.m12() == 0.0 && m.m21() == 0.0 &&
+	     m.dx() == 0.0 && m.dy() == 0.0 )
+	    s = TQString( "scale(%1,%2)" ).arg( m.m11() ).arg( m.m22() );
+	else
+	    s = TQString( "matrix(%1,%2,%3,%4,%5,%6)" )
+		.arg( m.m11() ).arg( m.m12() )
+		.arg( m.m21() ).arg( m.m22() )
+		.arg( m.dx() ).arg( m.dy() );
+    }
+    else
+	return;
+
+    e->setAttribute( "transform", s );
+}
+
+#endif // QT_NO_SVG
diff --git a/src/xml/qsvgdevice_p.h b/src/xml/qsvgdevice_p.h
new file mode 100644
index 000000000..67bd86179
--- /dev/null
+++ b/src/xml/qsvgdevice_p.h
@@ -0,0 +1,140 @@
+/****************************************************************************
+**
+** Definition of the TQSvgDevice class
+**
+** Created : 001024
+**
+** Copyright (C) 2000-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the xml module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing retquirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+*****************************************************************************/
+
+#ifndef TQSVGDEVICE_P_H
+#define TQSVGDEVICE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the TQt API.  It exists for the convenience
+// of the TQPicture class. This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+//
+
+#ifndef QT_H
+#include "qpaintdevice.h"
+#include "qrect.h"
+#include "qdom.h"
+#endif // QT_H
+
+#if !defined(QT_MODULE_XML) || defined( QT_LICENSE_PROFESSIONAL ) || defined( QT_INTERNAL_XML )
+#define TQM_EXPORT_SVG
+#else
+#define TQM_EXPORT_SVG Q_EXPORT
+#endif
+
+#ifndef QT_NO_SVG
+
+class TQPainter;
+class TQDomNode;
+class TQDomNamedNodeMap;
+struct TQSvgDeviceState;
+class TQSvgDevicePrivate;
+
+class TQM_EXPORT_SVG TQSvgDevice : public TQPaintDevice
+{
+public:
+    TQSvgDevice();
+    ~TQSvgDevice();
+
+    bool play( TQPainter *p );
+
+    TQString toString() const;
+
+    bool load( TQIODevice *dev );
+    bool save( TQIODevice *dev );
+    bool save( const TQString &fileName );
+
+    TQRect boundingRect() const;
+    void setBoundingRect( const TQRect &r );
+
+protected:
+    virtual bool cmd ( int, TQPainter*, TQPDevCmdParam* );
+    virtual int	 metric( int ) const;
+
+private:
+    // reading
+    bool play( const TQDomNode &node );
+    void saveAttributes();
+    void restoreAttributes();
+    TQColor parseColor( const TQString &col );
+    double parseLen( const TQString &str, bool *ok=0, bool horiz=TRUE ) const;
+    int lenToInt( const TQDomNamedNodeMap &map, const TQString &attr,
+		  int def=0 ) const;
+    double lenToDouble( const TQDomNamedNodeMap &map, const TQString &attr,
+		  int def=0 ) const;
+    void setStyleProperty( const TQString &prop, const TQString &val,
+			   TQPen *pen, TQFont *font, int *talign );
+    void setStyle( const TQString &s );
+    void setTransform( const TQString &tr );
+    void drawPath( const TQString &data );
+
+    // writing
+    void appendChild( TQDomElement &e, int c );
+    void applyStyle( TQDomElement *e, int c ) const;
+    void applyTransform( TQDomElement *e ) const;
+
+    // reading
+    TQRect brect;			// bounding rectangle
+    TQDomDocument doc;			// document tree
+    TQDomNode current;
+    TQPoint curPt;
+    TQSvgDeviceState *curr;
+    TQPainter *pt;			// used by play() et al
+
+    // writing
+    bool dirtyTransform, dirtyStyle;
+
+    TQSvgDevicePrivate *d;
+};
+
+inline TQRect TQSvgDevice::boundingRect() const
+{
+    return brect;
+}
+
+#endif // QT_NO_SVG
+
+#endif // TQSVGDEVICE_P_H
diff --git a/src/xml/qt_xml.pri b/src/xml/qt_xml.pri
new file mode 100644
index 000000000..4edd51e30
--- /dev/null
+++ b/src/xml/qt_xml.pri
@@ -0,0 +1,10 @@
+# Qt xml module
+
+xml {
+	HEADERS += $$XML_H/qxml.h $$XML_H/qdom.h $$XML_CPP/qsvgdevice_p.h
+	SOURCES += $$XML_CPP/qxml.cpp $$XML_CPP/qdom.cpp $$XML_CPP/qsvgdevice.cpp
+	win32-borland {
+		QMAKE_CFLAGS_WARN_ON	+= -w-use
+		QMAKE_CXXFLAGS_WARN_ON	+= -w-use
+	}
+}
diff --git a/src/xml/qxml.cpp b/src/xml/qxml.cpp
new file mode 100644
index 000000000..8de32e51b
--- /dev/null
+++ b/src/xml/qxml.cpp
@@ -0,0 +1,7635 @@
+/****************************************************************************
+**
+** Implementation of TQXmlSimpleReader and related classes.
+**
+** Created : 000518
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the xml module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing retquirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qxml.h"
+#include "qtextcodec.h"
+#include "qbuffer.h"
+#include "qregexp.h"
+#include "qptrstack.h"
+#include "qmap.h"
+#include "qvaluestack.h"
+
+// needed for QT_TRANSLATE_NOOP:
+#include "qobject.h"
+
+#ifndef QT_NO_XML
+
+//#define QT_QXML_DEBUG
+
+// Error strings for the XML reader
+#define XMLERR_OK                         QT_TRANSLATE_NOOP( "TQXml", "no error occurred" )
+#define XMLERR_ERRORBYCONSUMER            QT_TRANSLATE_NOOP( "TQXml", "error triggered by consumer" )
+#define XMLERR_UNEXPECTEDEOF              QT_TRANSLATE_NOOP( "TQXml", "unexpected end of file" )
+#define XMLERR_MORETHANONEDOCTYPE         QT_TRANSLATE_NOOP( "TQXml", "more than one document type definition" )
+#define XMLERR_ERRORPARSINGELEMENT        QT_TRANSLATE_NOOP( "TQXml", "error occurred while parsing element" )
+#define XMLERR_TAGMISMATCH                QT_TRANSLATE_NOOP( "TQXml", "tag mismatch" )
+#define XMLERR_ERRORPARSINGCONTENT        QT_TRANSLATE_NOOP( "TQXml", "error occurred while parsing content" )
+#define XMLERR_UNEXPECTEDCHARACTER        QT_TRANSLATE_NOOP( "TQXml", "unexpected character" )
+#define XMLERR_INVALIDNAMEFORPI           QT_TRANSLATE_NOOP( "TQXml", "invalid name for processing instruction" )
+#define XMLERR_VERSIONEXPECTED            QT_TRANSLATE_NOOP( "TQXml", "version expected while reading the XML declaration" )
+#define XMLERR_WRONGVALUEFORSDECL         QT_TRANSLATE_NOOP( "TQXml", "wrong value for standalone declaration" )
+#define XMLERR_EDECLORSDDECLEXPECTED      QT_TRANSLATE_NOOP( "TQXml", "encoding declaration or standalone declaration expected while reading the XML declaration" )
+#define XMLERR_SDDECLEXPECTED             QT_TRANSLATE_NOOP( "TQXml", "standalone declaration expected while reading the XML declaration" )
+#define XMLERR_ERRORPARSINGDOCTYPE        QT_TRANSLATE_NOOP( "TQXml", "error occurred while parsing document type definition" )
+#define XMLERR_LETTEREXPECTED             QT_TRANSLATE_NOOP( "TQXml", "letter is expected" )
+#define XMLERR_ERRORPARSINGCOMMENT        QT_TRANSLATE_NOOP( "TQXml", "error occurred while parsing comment" )
+#define XMLERR_ERRORPARSINGREFERENCE      QT_TRANSLATE_NOOP( "TQXml", "error occurred while parsing reference" )
+#define XMLERR_INTERNALGENERALENTITYINDTD QT_TRANSLATE_NOOP( "TQXml", "internal general entity reference not allowed in DTD" )
+#define XMLERR_EXTERNALGENERALENTITYINAV  QT_TRANSLATE_NOOP( "TQXml", "external parsed general entity reference not allowed in attribute value" )
+#define XMLERR_EXTERNALGENERALENTITYINDTD QT_TRANSLATE_NOOP( "TQXml", "external parsed general entity reference not allowed in DTD" )
+#define XMLERR_UNPARSEDENTITYREFERENCE    QT_TRANSLATE_NOOP( "TQXml", "unparsed entity reference in wrong context" )
+#define XMLERR_RECURSIVEENTITIES          QT_TRANSLATE_NOOP( "TQXml", "recursive entities" )
+#define XMLERR_ERRORINTEXTDECL            QT_TRANSLATE_NOOP( "TQXml", "error in the text declaration of an external entity" )
+
+// the constants for the lookup table
+static const signed char cltWS      =  0; // white space
+static const signed char cltPer     =  1; // %
+static const signed char cltAmp     =  2; // &
+static const signed char cltGt      =  3; // >
+static const signed char cltLt      =  4; // <
+static const signed char cltSlash   =  5; // /
+static const signed char cltQm      =  6; // ?
+static const signed char cltEm      =  7; // !
+static const signed char cltDash    =  8; // -
+static const signed char cltCB      =  9; // ]
+static const signed char cltOB      = 10; // [
+static const signed char cltEq      = 11; // =
+static const signed char cltDq      = 12; // "
+static const signed char cltSq      = 13; // '
+static const signed char cltUnknown = 14;
+
+// character lookup table
+static const signed char charLookupTable[256]={
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x00 - 0x07
+    cltUnknown, // 0x08
+    cltWS,      // 0x09 \t
+    cltWS,      // 0x0A \n
+    cltUnknown, // 0x0B
+    cltUnknown, // 0x0C
+    cltWS,      // 0x0D \r
+    cltUnknown, // 0x0E
+    cltUnknown, // 0x0F
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x17 - 0x16
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x18 - 0x1F
+    cltWS,      // 0x20 Space
+    cltEm,      // 0x21 !
+    cltDq,      // 0x22 "
+    cltUnknown, // 0x23
+    cltUnknown, // 0x24
+    cltPer,     // 0x25 %
+    cltAmp,     // 0x26 &
+    cltSq,      // 0x27 '
+    cltUnknown, // 0x28
+    cltUnknown, // 0x29
+    cltUnknown, // 0x2A
+    cltUnknown, // 0x2B
+    cltUnknown, // 0x2C
+    cltDash,    // 0x2D -
+    cltUnknown, // 0x2E
+    cltSlash,   // 0x2F /
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x30 - 0x37
+    cltUnknown, // 0x38
+    cltUnknown, // 0x39
+    cltUnknown, // 0x3A
+    cltUnknown, // 0x3B
+    cltLt,      // 0x3C <
+    cltEq,      // 0x3D =
+    cltGt,      // 0x3E >
+    cltQm,      // 0x3F ?
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x40 - 0x47
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x48 - 0x4F
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x50 - 0x57
+    cltUnknown, // 0x58
+    cltUnknown, // 0x59
+    cltUnknown, // 0x5A
+    cltOB,      // 0x5B [
+    cltUnknown, // 0x5C
+    cltCB,      // 0x5D ]
+    cltUnknown, // 0x5E
+    cltUnknown, // 0x5F
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x60 - 0x67
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x68 - 0x6F
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x70 - 0x77
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x78 - 0x7F
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x80 - 0x87
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x88 - 0x8F
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x90 - 0x97
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x98 - 0x9F
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xA0 - 0xA7
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xA8 - 0xAF
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xB0 - 0xB7
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xB8 - 0xBF
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xC0 - 0xC7
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xC8 - 0xCF
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xD0 - 0xD7
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xD8 - 0xDF
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xE0 - 0xE7
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xE8 - 0xEF
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xF0 - 0xF7
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown  // 0xF8 - 0xFF
+};
+
+
+//
+// local helper functions
+//
+
+/*
+  This function strips the TextDecl [77] ("<?xml ...?>") from the string \a
+  str. The stripped version is stored in \a str. If this function finds an
+  invalid TextDecl, it returns FALSE, otherwise TRUE.
+
+  This function is used for external entities since those can include an
+  TextDecl that must be stripped before inserting the entity.
+*/
+static bool stripTextDecl( TQString& str )
+{
+    TQString textDeclStart( "<?xml" );
+    if ( str.startsWith( textDeclStart ) ) {
+	TQRegExp textDecl(TQString::fromLatin1(
+	    "^<\\?xml\\s+"
+	    "(version\\s*=\\s*((['\"])[-a-zA-Z0-9_.:]+\\3))?"
+	    "\\s*"
+	    "(encoding\\s*=\\s*((['\"])[A-Za-z][-a-zA-Z0-9_.]*\\6))?"
+	    "\\s*\\?>"
+	));
+	TQString strTmp = str.replace( textDecl, "" );
+	if ( strTmp.length() != str.length() )
+	    return FALSE; // external entity has wrong TextDecl
+	str = strTmp;
+    }
+    return TRUE;
+}
+
+
+class TQXmlAttributesPrivate
+{
+};
+class TQXmlInputSourcePrivate
+{
+};
+class TQXmlParseExceptionPrivate
+{
+};
+class TQXmlLocatorPrivate
+{
+};
+class TQXmlDefaultHandlerPrivate
+{
+};
+
+/*!
+    \class TQXmlParseException qxml.h
+    \reentrant
+    \brief The TQXmlParseException class is used to report errors with
+    the TQXmlErrorHandler interface.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    The XML subsystem constructs an instance of this class when it
+    detects an error. You can retrieve the place where the error
+    occurred using systemId(), publicId(), lineNumber() and
+    columnNumber(), along with the error message().
+
+    \sa TQXmlErrorHandler TQXmlReader
+*/
+
+/*!
+    \fn TQXmlParseException::TQXmlParseException( const TQString& name, int c, int l, const TQString& p, const TQString& s )
+
+    Constructs a parse exception with the error string \a name for
+    column \a c and line \a l for the public identifier \a p and the
+    system identifier \a s.
+*/
+
+/*!
+    Returns the error message.
+*/
+TQString TQXmlParseException::message() const
+{
+    return msg;
+}
+/*!
+    Returns the column number where the error occurred.
+*/
+int TQXmlParseException::columnNumber() const
+{
+    return column;
+}
+/*!
+    Returns the line number where the error occurred.
+*/
+int TQXmlParseException::lineNumber() const
+{
+    return line;
+}
+/*!
+    Returns the public identifier where the error occurred.
+*/
+TQString TQXmlParseException::publicId() const
+{
+    return pub;
+}
+/*!
+    Returns the system identifier where the error occurred.
+*/
+TQString TQXmlParseException::systemId() const
+{
+    return sys;
+}
+
+
+/*!
+    \class TQXmlLocator qxml.h
+    \reentrant
+    \brief The TQXmlLocator class provides the XML handler classes with
+    information about the parsing position within a file.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    The reader reports a TQXmlLocator to the content handler before it
+    starts to parse the document. This is done with the
+    TQXmlContentHandler::setDocumentLocator() function. The handler
+    classes can now use this locator to get the position (lineNumber()
+    and columnNumber()) that the reader has reached.
+*/
+
+/*!
+    Constructor.
+*/
+TQXmlLocator::TQXmlLocator()
+{
+}
+
+/*!
+    Destructor.
+*/
+TQXmlLocator::~TQXmlLocator()
+{
+}
+
+/*!
+    \fn int TQXmlLocator::columnNumber()
+
+    Returns the column number (starting at 1) or -1 if there is no
+    column number available.
+*/
+
+/*!
+    \fn int TQXmlLocator::lineNumber()
+
+    Returns the line number (starting at 1) or -1 if there is no line
+    number available.
+*/
+
+class TQXmlSimpleReaderLocator : public TQXmlLocator
+{
+public:
+    TQXmlSimpleReaderLocator( TQXmlSimpleReader* parent )
+    {
+	reader = parent;
+    }
+    ~TQXmlSimpleReaderLocator()
+    {
+    }
+
+    int columnNumber()
+    {
+	return ( reader->columnNr == -1 ? -1 : reader->columnNr + 1 );
+    }
+    int lineNumber()
+    {
+	return ( reader->lineNr == -1 ? -1 : reader->lineNr + 1 );
+    }
+//    TQString getPublicId()
+//    TQString getSystemId()
+
+private:
+    TQXmlSimpleReader *reader;
+};
+
+/*********************************************
+ *
+ * TQXmlNamespaceSupport
+ *
+ *********************************************/
+
+typedef TQMap<TQString, TQString> NamespaceMap;
+
+class TQXmlNamespaceSupportPrivate
+{
+public:
+    TQXmlNamespaceSupportPrivate()
+    {
+	ns.insert( "xml", "http://www.w3.org/XML/1998/namespace" ); // the XML namespace
+    }
+
+    ~TQXmlNamespaceSupportPrivate()
+    {
+    }
+
+    TQValueStack<NamespaceMap> nsStack;
+    NamespaceMap ns;
+};
+
+/*!
+    \class TQXmlNamespaceSupport qxml.h
+    \reentrant
+    \brief The TQXmlNamespaceSupport class is a helper class for XML
+    readers which want to include namespace support.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    You can set the prefix for the current namespace with setPrefix(),
+    and get the list of current prefixes (or those for a given URI)
+    with prefixes(). The namespace URI is available from uri(). Use
+    pushContext() to start a new namespace context, and popContext()
+    to return to the previous namespace context. Use splitName() or
+    processName() to split a name into its prefix and local name.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+*/
+
+/*!
+    Constructs a TQXmlNamespaceSupport.
+*/
+TQXmlNamespaceSupport::TQXmlNamespaceSupport()
+{
+    d = new TQXmlNamespaceSupportPrivate;
+}
+
+/*!
+    Destroys a TQXmlNamespaceSupport.
+*/
+TQXmlNamespaceSupport::~TQXmlNamespaceSupport()
+{
+    delete d;
+}
+
+/*!
+    This function declares a prefix \a pre in the current namespace
+    context to be the namespace URI \a uri. The prefix remains in
+    force until this context is popped, unless it is shadowed in a
+    descendant context.
+
+    Note that there is an asymmetry in this library. prefix() does not
+    return the default "" prefix, even if you have declared one; to
+    check for a default prefix, you must look it up explicitly using
+    uri(). This asymmetry exists to make it easier to look up prefixes
+    for attribute names, where the default prefix is not allowed.
+*/
+void TQXmlNamespaceSupport::setPrefix( const TQString& pre, const TQString& uri )
+{
+    if( pre.isNull() ) {
+	d->ns.insert( "", uri );
+    } else {
+	d->ns.insert( pre, uri );
+    }
+}
+
+/*!
+    Returns one of the prefixes mapped to the namespace URI \a uri.
+
+    If more than one prefix is currently mapped to the same URI, this
+    function makes an arbitrary selection; if you want all of the
+    prefixes, use prefixes() instead.
+
+    Note: to check for a default prefix, use the uri() function with
+    an argument of "".
+*/
+TQString TQXmlNamespaceSupport::prefix( const TQString& uri ) const
+{
+    NamespaceMap::const_iterator itc, it = d->ns.constBegin();
+    while ( (itc=it) != d->ns.constEnd() ) {
+	++it;
+	if ( itc.data() == uri && !itc.key().isEmpty() )
+	    return itc.key();
+    }
+    return "";
+}
+
+/*!
+    Looks up the prefix \a prefix in the current context and returns
+    the currently-mapped namespace URI. Use the empty string ("") for
+    the default namespace.
+*/
+TQString TQXmlNamespaceSupport::uri( const TQString& prefix ) const
+{
+    return d->ns[prefix];
+}
+
+/*!
+    Splits the name \a qname at the ':' and returns the prefix in \a
+    prefix and the local name in \a localname.
+
+    \sa processName()
+*/
+void TQXmlNamespaceSupport::splitName( const TQString& qname,
+	TQString& prefix, TQString& localname ) const
+{
+    int pos = qname.find(':');
+    if (pos == -1)
+        pos = qname.length();
+
+    prefix = qname.left( pos );
+    localname = qname.mid( pos+1 );
+}
+
+/*!
+    Processes a raw XML 1.0 name in the current context by removing
+    the prefix and looking it up among the prefixes currently
+    declared.
+
+    \a qname is the raw XML 1.0 name to be processed. \a isAttribute
+    is TRUE if the name is an attribute name.
+
+    This function stores the namespace URI in \a nsuri (which will be
+    set to TQString::null if the raw name has an undeclared prefix),
+    and stores the local name (without prefix) in \a localname (which
+    will be set to TQString::null if no namespace is in use).
+
+    Note that attribute names are processed differently than element
+    names: an unprefixed element name gets the default namespace (if
+    any), while an unprefixed element name does not.
+*/
+void TQXmlNamespaceSupport::processName( const TQString& qname,
+	bool isAttribute,
+	TQString& nsuri, TQString& localname ) const
+{
+    int len = qname.length();
+    const TQChar *data = qname.unicode();
+    for (int pos = 0; pos < len; ++pos) {
+        if (data[pos].unicode() == ':') {
+            nsuri = uri(qname.left(pos));
+            localname = qname.mid(pos + 1);
+            return;
+	}
+    }
+    // there was no ':'
+    nsuri = TQString::null;
+    // attributes don't take default namespace
+    if (!isAttribute && !d->ns.isEmpty()) {
+        /*
+            We want to access d->ns.value(""), but as an optimization
+            we use the fact that "" compares less than any other
+            string, so it's either first in the map or not there.
+        */
+        NamespaceMap::const_iterator first = d->ns.constBegin();
+        if (first.key().isEmpty())
+            nsuri = first.data(); // get default namespace
+    }
+    localname = qname;
+}
+
+/*!
+    Returns a list of all the prefixes currently declared.
+
+    If there is a default prefix, this function does not return it in
+    the list; check for the default prefix using uri() with an
+    argument of "".
+
+    Note that if you want to iterate over the list, you should iterate
+    over a copy, e.g.
+    \code
+    TQStringList list = myXmlNamespaceSupport.prefixes();
+    TQStringList::iterator it = list.begin();
+    while ( it != list.end() ) {
+	myProcessing( *it );
+	++it;
+    }
+    \endcode
+*/
+TQStringList TQXmlNamespaceSupport::prefixes() const
+{
+    TQStringList list;
+
+    NamespaceMap::const_iterator itc, it = d->ns.constBegin();
+    while ( (itc=it) != d->ns.constEnd() ) {
+	++it;
+	if ( !itc.key().isEmpty() )
+	    list.append( itc.key() );
+    }
+    return list;
+}
+
+/*!
+    \overload
+
+    Returns a list of all prefixes currently declared for the
+    namespace URI \a uri.
+
+    The "xml:" prefix is included. If you only want one prefix that is
+    mapped to the namespace URI, and you don't care which one you get,
+    use the prefix() function instead.
+
+    Note: the empty (default) prefix is never included in this list;
+    to check for the presence of a default namespace, use uri() with
+    an argument of "".
+
+    Note that if you want to iterate over the list, you should iterate
+    over a copy, e.g.
+    \code
+    TQStringList list = myXmlNamespaceSupport.prefixes( "" );
+    TQStringList::Iterator it = list.begin();
+    while( it != list.end() ) {
+	myProcessing( *it );
+	++it;
+    }
+    \endcode
+*/
+TQStringList TQXmlNamespaceSupport::prefixes( const TQString& uri ) const
+{
+    TQStringList list;
+
+    NamespaceMap::const_iterator itc, it = d->ns.constBegin();
+    while ( (itc=it) != d->ns.constEnd() ) {
+	++it;
+	if ( itc.data() == uri && !itc.key().isEmpty() )
+	    list.append( itc.key() );
+    }
+    return list;
+}
+
+/*!
+    Starts a new namespace context.
+
+    Normally, you should push a new context at the beginning of each
+    XML element: the new context automatically inherits the
+    declarations of its parent context, and it also keeps track of
+    which declarations were made within this context.
+
+    \sa popContext()
+*/
+void TQXmlNamespaceSupport::pushContext()
+{
+    d->nsStack.push(d->ns);
+}
+
+/*!
+    Reverts to the previous namespace context.
+
+    Normally, you should pop the context at the end of each XML
+    element. After popping the context, all namespace prefix mappings
+    that were previously in force are restored.
+
+    \sa pushContext()
+*/
+void TQXmlNamespaceSupport::popContext()
+{
+    d->ns.clear();
+    if( !d->nsStack.isEmpty() )
+	d->ns = d->nsStack.pop();
+}
+
+/*!
+    Resets this namespace support object ready for reuse.
+*/
+void TQXmlNamespaceSupport::reset()
+{
+    delete d;
+    d = new TQXmlNamespaceSupportPrivate;
+}
+
+
+
+/*********************************************
+ *
+ * TQXmlAttributes
+ *
+ *********************************************/
+
+/*!
+    \class TQXmlAttributes qxml.h
+    \reentrant
+    \brief The TQXmlAttributes class provides XML attributes.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    If attributes are reported by TQXmlContentHandler::startElement()
+    this class is used to pass the attribute values.
+
+    Use index() to locate the position of an attribute in the list,
+    count() to retrieve the number of attributes, and clear() to
+    remove the attributes. New attributes can be added with append().
+    Use type() to get an attribute's type and value() to get its
+    value. The attribute's name is available from localName() or
+    qName(), and its namespace URI from uri().
+
+*/
+
+/*!
+    \fn TQXmlAttributes::TQXmlAttributes()
+
+    Constructs an empty attribute list.
+*/
+
+/*!
+    \fn TQXmlAttributes::~TQXmlAttributes()
+
+    Destroys the attributes object.
+*/
+
+/*!
+    Looks up the index of an attribute by the qualified name \a qName.
+
+    Returns the index of the attribute or -1 if it wasn't found.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+*/
+int TQXmlAttributes::index( const TQString& qName ) const
+{
+    return qnameList.findIndex( qName );
+}
+
+/*!
+    \overload
+
+    Looks up the index of an attribute by a namespace name.
+
+    \a uri specifies the namespace URI, or an empty string if the name
+    has no namespace URI. \a localPart specifies the attribute's local
+    name.
+
+    Returns the index of the attribute, or -1 if it wasn't found.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+*/
+int TQXmlAttributes::index( const TQString& uri, const TQString& localPart ) const
+{
+    TQString uriTmp;
+    if ( uri.isEmpty() )
+       uriTmp = TQString::null;
+    else
+       uriTmp = uri;
+    uint count = (uint)uriList.count(); // ### size_t/int cast
+    for ( uint i=0; i<count; i++ ) {
+       if ( uriList[i] == uriTmp && localnameList[i] == localPart )
+           return i;
+    }
+    return -1;
+}
+
+/*!
+    Returns the number of attributes in the list.
+
+    \sa count()
+*/
+int TQXmlAttributes::length() const
+{
+    return (int)valueList.count();
+}
+
+/*!
+    \fn int TQXmlAttributes::count() const
+
+    Returns the number of attributes in the list. This function is
+    equivalent to length().
+*/
+
+/*!
+    Looks up an attribute's local name for the attribute at position
+    \a index. If no namespace processing is done, the local name is
+    TQString::null.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+*/
+TQString TQXmlAttributes::localName( int index ) const
+{
+    return localnameList[index];
+}
+
+/*!
+    Looks up an attribute's XML 1.0 qualified name for the attribute
+    at position \a index.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+*/
+TQString TQXmlAttributes::qName( int index ) const
+{
+    return qnameList[index];
+}
+
+/*!
+    Looks up an attribute's namespace URI for the attribute at
+    position \a index. If no namespace processing is done or if the
+    attribute has no namespace, the namespace URI is TQString::null.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+*/
+TQString TQXmlAttributes::uri( int index ) const
+{
+    return uriList[index];
+}
+
+/*!
+    Looks up an attribute's type for the attribute at position \a
+    index.
+
+    Currently only "CDATA" is returned.
+*/
+TQString TQXmlAttributes::type( int ) const
+{
+    return "CDATA";
+}
+
+/*!
+    \overload
+
+    Looks up an attribute's type for the qualified name \a qName.
+
+    Currently only "CDATA" is returned.
+*/
+TQString TQXmlAttributes::type( const TQString& ) const
+{
+    return "CDATA";
+}
+
+/*!
+    \overload
+
+    Looks up an attribute's type by namespace name.
+
+    \a uri specifies the namespace URI and \a localName specifies the
+    local name. If the name has no namespace URI, use an empty string
+    for \a uri.
+
+    Currently only "CDATA" is returned.
+*/
+TQString TQXmlAttributes::type( const TQString&, const TQString& ) const
+{
+    return "CDATA";
+}
+
+/*!
+    Looks up an attribute's value for the attribute at position \a
+    index.
+*/
+TQString TQXmlAttributes::value( int index ) const
+{
+    return valueList[index];
+}
+
+/*!
+    \overload
+
+    Looks up an attribute's value for the qualified name \a qName.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+*/
+TQString TQXmlAttributes::value( const TQString& qName ) const
+{
+    int i = index( qName );
+    if ( i == -1 )
+	return TQString::null;
+    return valueList[ i ];
+}
+
+/*!
+    \overload
+
+    Looks up an attribute's value by namespace name.
+
+    \a uri specifies the namespace URI, or an empty string if the name
+    has no namespace URI. \a localName specifies the attribute's local
+    name.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+*/
+TQString TQXmlAttributes::value( const TQString& uri, const TQString& localName ) const
+{
+    int i = index( uri, localName );
+    if ( i == -1 )
+	return TQString::null;
+    return valueList[ i ];
+}
+
+/*!
+    Clears the list of attributes.
+
+    \sa append()
+*/
+void TQXmlAttributes::clear()
+{
+    qnameList.clear();
+    uriList.clear();
+    localnameList.clear();
+    valueList.clear();
+}
+
+/*!
+    Appends a new attribute entry to the list of attributes. The
+    qualified name of the attribute is \a qName, the namespace URI is
+    \a uri and the local name is \a localPart. The value of the
+    attribute is \a value.
+
+    \sa qName() uri() localName() value()
+*/
+void TQXmlAttributes::append( const TQString &qName, const TQString &uri, const TQString &localPart, const TQString &value )
+{
+    qnameList.append( qName );
+    uriList.append( uri );
+    localnameList.append( localPart);
+    valueList.append( value );
+}
+
+
+/*********************************************
+ *
+ * TQXmlInputSource
+ *
+ *********************************************/
+
+/*!
+    \class TQXmlInputSource qxml.h
+    \reentrant
+    \brief The TQXmlInputSource class provides the input data for the
+    TQXmlReader subclasses.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    All subclasses of TQXmlReader read the input XML document from this
+    class.
+
+    This class recognizes the encoding of the data by reading the
+    encoding declaration in the XML file if it finds one, and reading
+    the data using the corresponding encoding. If it does not find an
+    encoding declaration, then it assumes that the data is either in
+    UTF-8 or UTF-16, depending on whether it can find a byte-order
+    mark.
+
+    There are two ways to populate the input source with data: you can
+    construct it with a TQIODevice* so that the input source reads the
+    data from that device. Or you can set the data explicitly with one
+    of the setData() functions.
+
+    Usually you either construct a TQXmlInputSource that works on a
+    TQIODevice* or you construct an empty TQXmlInputSource and set the
+    data with setData(). There are only rare occasions where you would
+    want to mix both methods.
+
+    The TQXmlReader subclasses use the next() function to read the
+    input character by character. If you want to start from the
+    beginning again, use reset().
+
+    The functions data() and fetchData() are useful if you want to do
+    something with the data other than parsing, e.g. displaying the
+    raw XML file. The benefit of using the TQXmlInputClass in such
+    cases is that it tries to use the correct encoding.
+
+    \sa TQXmlReader TQXmlSimpleReader
+*/
+
+// the following two are guaranteed not to be a character
+const TQChar TQXmlInputSource::EndOfData = TQChar((ushort)0xfffe);
+const TQChar TQXmlInputSource::EndOfDocument = TQChar((ushort)0xffff);
+
+/*
+    Common part of the constructors.
+*/
+void TQXmlInputSource::init()
+{
+    inputDevice = 0;
+    inputStream = 0;
+
+    setData( TQString::null );
+    encMapper = 0;
+}
+
+/*!
+    Constructs an input source which contains no data.
+
+    \sa setData()
+*/
+TQXmlInputSource::TQXmlInputSource()
+{
+    init();
+}
+
+/*!
+    Constructs an input source and gets the data from device \a dev.
+    If \a dev is not open, it is opened in read-only mode. If \a dev
+    is 0 or it is not possible to read from the device, the input
+    source will contain no data.
+
+    \sa setData() fetchData() TQIODevice
+*/
+TQXmlInputSource::TQXmlInputSource( TQIODevice *dev )
+{
+    init();
+    inputDevice = dev;
+    fetchData();
+}
+
+/*! \obsolete
+  Constructs an input source and gets the data from the text stream \a stream.
+*/
+TQXmlInputSource::TQXmlInputSource( TQTextStream& stream )
+{
+    init();
+    inputStream = &stream;
+    fetchData();
+}
+
+/*! \obsolete
+  Constructs an input source and gets the data from the file \a file. If the
+  file cannot be read the input source is empty.
+*/
+TQXmlInputSource::TQXmlInputSource( TQFile& file )
+{
+    init();
+    inputDevice = &file;
+    fetchData();
+}
+
+/*!
+    Destructor.
+*/
+TQXmlInputSource::~TQXmlInputSource()
+{
+    delete encMapper;
+}
+
+/*!
+    Returns the next character of the input source. If this function
+    reaches the end of available data, it returns
+    TQXmlInputSource::EndOfData. If you call next() after that, it
+    tries to fetch more data by calling fetchData(). If the
+    fetchData() call results in new data, this function returns the
+    first character of that data; otherwise it returns
+    TQXmlInputSource::EndOfDocument.
+
+    \sa reset() fetchData() TQXmlSimpleReader::parse() TQXmlSimpleReader::parseContinue()
+*/
+TQChar TQXmlInputSource::next()
+{
+    if ( pos >= length ) {
+	if ( nextReturnedEndOfData ) {
+	    nextReturnedEndOfData = FALSE;
+	    fetchData();
+	    if ( pos >= length ) {
+		return EndOfDocument;
+	    }
+	    return next();
+	}
+	nextReturnedEndOfData = TRUE;
+	return EndOfData;
+    }
+    return unicode[pos++];
+}
+
+/*!
+    This function sets the position used by next() to the beginning of
+    the data returned by data(). This is useful if you want to use the
+    input source for more than one parse.
+
+    \sa next()
+*/
+void TQXmlInputSource::reset()
+{
+    nextReturnedEndOfData = FALSE;
+    pos = 0;
+}
+
+/*!
+    Returns the data the input source contains or TQString::null if the
+    input source does not contain any data.
+
+    \sa setData() TQXmlInputSource() fetchData()
+*/
+TQString TQXmlInputSource::data()
+{
+    return str;
+}
+
+/*!
+    Sets the data of the input source to \a dat.
+
+    If the input source already contains data, this function deletes
+    that data first.
+
+    \sa data()
+*/
+void TQXmlInputSource::setData( const TQString& dat )
+{
+    str = dat;
+    unicode = str.unicode();
+    pos = 0;
+    length = str.length();
+    nextReturnedEndOfData = FALSE;
+}
+
+/*!
+    \overload
+
+    The data \a dat is passed through the correct text-codec, before
+    it is set.
+*/
+void TQXmlInputSource::setData( const TQByteArray& dat )
+{
+    setData( fromRawData( dat ) );
+}
+
+/*!
+    This function reads more data from the device that was set during
+    construction. If the input source already contained data, this
+    function deletes that data first.
+
+    This object contains no data after a call to this function if the
+    object was constructed without a device to read data from or if
+    this function was not able to get more data from the device.
+
+    There are two occasions where a fetch is done implicitly by
+    another function call: during construction (so that the object
+    starts out with some initial data where available), and during a
+    call to next() (if the data had run out).
+
+    You don't normally need to use this function if you use next().
+
+    \sa data() next() TQXmlInputSource()
+*/
+void TQXmlInputSource::fetchData()
+{
+    TQByteArray rawData;
+
+    if ( inputDevice != 0 ) {
+	if ( inputDevice->isOpen() || inputDevice->open( IO_ReadOnly )  )
+	    rawData = inputDevice->readAll();
+    } else if ( inputStream != 0 ) {
+	if ( inputStream->device()->isDirectAccess() ) {
+	    rawData = inputStream->device()->readAll();
+	} else {
+	    int nread = 0;
+	    const int bufsize = 512;
+	    while ( !inputStream->device()->atEnd() ) {
+		rawData.resize( nread + bufsize );
+		nread += inputStream->device()->readBlock( rawData.data()+nread, bufsize );
+	    }
+	    rawData.resize( nread );
+	}
+    }
+    setData( fromRawData( rawData ) );
+}
+
+/*!
+    This function reads the XML file from \a data and tries to
+    recognize the encoding. It converts the raw data \a data into a
+    TQString and returns it. It tries its best to get the correct
+    encoding for the XML file.
+
+    If \a beginning is TRUE, this function assumes that the data
+    starts at the beginning of a new XML document and looks for an
+    encoding declaration. If \a beginning is FALSE, it converts the
+    raw data using the encoding determined from prior calls.
+*/
+TQString TQXmlInputSource::fromRawData( const TQByteArray &data, bool beginning )
+{
+    if ( data.size() == 0 )
+	return TQString::null;
+    if ( beginning ) {
+	delete encMapper;
+	encMapper = 0;
+    }
+    if ( encMapper == 0 ) {
+	TQTextCodec *codec = 0;
+	// look for byte order mark and read the first 5 characters
+	if ( data.size() >= 2 &&
+		( ((uchar)data.at(0)==(uchar)0xfe &&
+		   (uchar)data.at(1)==(uchar)0xff ) ||
+		  ((uchar)data.at(0)==(uchar)0xff &&
+		   (uchar)data.at(1)==(uchar)0xfe ) )) {
+	    codec = TQTextCodec::codecForMib( 1000 ); // UTF-16
+	} else {
+	    codec = TQTextCodec::codecForMib( 106 ); // UTF-8
+	}
+	if ( !codec )
+	    return TQString::null;
+
+	encMapper = codec->makeDecoder();
+	TQString input = encMapper->toUnicode( data.data(), data.size() );
+	// ### unexpected EOF? (for incremental parsing)
+	// starts the document with an XML declaration?
+	if ( input.find("<?xml") == 0 ) {
+	    // try to find out if there is an encoding
+	    int endPos = input.find( ">" );
+	    int pos = input.find( "encoding" );
+	    if ( pos < endPos && pos != -1 ) {
+		TQString encoding;
+		do {
+		    pos++;
+		    if ( pos > endPos ) {
+			return input;
+		    }
+		} while( input[pos] != '"' && input[pos] != '\'' );
+		pos++;
+		while( input[pos] != '"' && input[pos] != '\'' ) {
+		    encoding += input[pos];
+		    pos++;
+		    if ( pos > endPos ) {
+			return input;
+		    }
+		}
+
+		codec = TQTextCodec::codecForName( encoding );
+		if ( codec == 0 ) {
+		    return input;
+		}
+		delete encMapper;
+		encMapper = codec->makeDecoder();
+		return encMapper->toUnicode( data.data(), data.size() );
+	    }
+	}
+	return input;
+    }
+    return encMapper->toUnicode( data.data(), data.size() );
+}
+
+
+/*********************************************
+ *
+ * TQXmlDefaultHandler
+ *
+ *********************************************/
+
+/*!
+    \class TQXmlContentHandler qxml.h
+    \reentrant
+    \brief The TQXmlContentHandler class provides an interface to
+    report the logical content of XML data.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    If the application needs to be informed of basic parsing events,
+    it can implement this interface and activate it using
+    TQXmlReader::setContentHandler(). The reader can then report basic
+    document-related events like the start and end of elements and
+    character data through this interface.
+
+    The order of events in this interface is very important, and
+    mirrors the order of information in the document itself. For
+    example, all of an element's content (character data, processing
+    instructions, and sub-elements) appears, in order, between the
+    startElement() event and the corresponding endElement() event.
+
+    The class TQXmlDefaultHandler provides a default implementation for
+    this interface; subclassing from the TQXmlDefaultHandler class is
+    very convenient if you only want to be informed of some parsing
+    events.
+
+    The startDocument() function is called at the start of the
+    document, and endDocument() is called at the end. Before parsing
+    begins setDocumentLocator() is called. For each element
+    startElement() is called, with endElement() being called at the
+    end of each element. The characters() function is called with
+    chunks of character data; ignorableWhitespace() is called with
+    chunks of whitespace and processingInstruction() is called with
+    processing instructions. If an entity is skipped skippedEntity()
+    is called. At the beginning of prefix-URI scopes
+    startPrefixMapping() is called.
+
+    See also the \link xml.html#sax2Intro Introduction to SAX2\endlink.
+
+    \sa TQXmlDTDHandler TQXmlDeclHandler TQXmlEntityResolver TQXmlErrorHandler
+    TQXmlLexicalHandler
+*/
+
+/*!
+    \fn void TQXmlContentHandler::setDocumentLocator( TQXmlLocator* locator )
+
+    The reader calls this function before it starts parsing the
+    document. The argument \a locator is a pointer to a TQXmlLocator
+    which allows the application to get the parsing position within
+    the document.
+
+    Do not destroy the \a locator; it is destroyed when the reader is
+    destroyed. (Do not use the \a locator after the reader is
+    destroyed).
+*/
+
+/*!
+    \fn bool TQXmlContentHandler::startDocument()
+
+    The reader calls this function when it starts parsing the
+    document. The reader calls this function just once, after the call
+    to setDocumentLocator(), and before any other functions in this
+    class or in the TQXmlDTDHandler class are called.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    \sa endDocument()
+*/
+
+/*!
+    \fn bool TQXmlContentHandler::endDocument()
+
+    The reader calls this function after it has finished parsing. It
+    is called just once, and is the last handler function called. It
+    is called after the reader has read all input or has abandoned
+    parsing because of a fatal error.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    \sa startDocument()
+*/
+
+/*!
+    \fn bool TQXmlContentHandler::startPrefixMapping( const TQString& prefix, const TQString& uri )
+
+    The reader calls this function to signal the begin of a prefix-URI
+    namespace mapping scope. This information is not necessary for
+    normal namespace processing since the reader automatically
+    replaces prefixes for element and attribute names.
+
+    Note that startPrefixMapping() and endPrefixMapping() calls are
+    not guaranteed to be properly nested relative to each other: all
+    startPrefixMapping() events occur before the corresponding
+    startElement() event, and all endPrefixMapping() events occur
+    after the corresponding endElement() event, but their order is not
+    otherwise guaranteed.
+
+    The argument \a prefix is the namespace prefix being declared and
+    the argument \a uri is the namespace URI the prefix is mapped to.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+
+    \sa endPrefixMapping()
+*/
+
+/*!
+    \fn bool TQXmlContentHandler::endPrefixMapping( const TQString& prefix )
+
+    The reader calls this function to signal the end of a prefix
+    mapping for the prefix \a prefix.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+
+    \sa startPrefixMapping()
+*/
+
+/*!
+    \fn bool TQXmlContentHandler::startElement( const TQString& namespaceURI, const TQString& localName, const TQString& qName, const TQXmlAttributes& atts )
+
+    The reader calls this function when it has parsed a start element
+    tag.
+
+    There is a corresponding endElement() call when the corresponding
+    end element tag is read. The startElement() and endElement() calls
+    are always nested correctly. Empty element tags (e.g. \c{<x/>})
+    cause a startElement() call to be immediately followed by an
+    endElement() call.
+
+    The attribute list provided only contains attributes with explicit
+    values. The attribute list contains attributes used for namespace
+    declaration (i.e. attributes starting with xmlns) only if the
+    namespace-prefix property of the reader is TRUE.
+
+    The argument \a namespaceURI is the namespace URI, or
+    TQString::null if the element has no namespace URI or if no
+    namespace processing is done. \a localName is the local name
+    (without prefix), or TQString::null if no namespace processing is
+    done, \a qName is the qualified name (with prefix) and \a atts are
+    the attributes attached to the element. If there are no
+    attributes, \a atts is an empty attributes object.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+
+    \sa endElement()
+*/
+
+/*!
+    \fn bool TQXmlContentHandler::endElement( const TQString& namespaceURI, const TQString& localName, const TQString& qName )
+
+    The reader calls this function when it has parsed an end element
+    tag with the qualified name \a qName, the local name \a localName
+    and the namespace URI \a namespaceURI.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+
+    \sa startElement()
+*/
+
+/*!
+    \fn bool TQXmlContentHandler::characters( const TQString& ch )
+
+    The reader calls this function when it has parsed a chunk of
+    character data (either normal character data or character data
+    inside a CDATA section; if you need to distinguish between those
+    two types you must use TQXmlLexicalHandler::startCDATA() and
+    TQXmlLexicalHandler::endCDATA()). The character data is reported in
+    \a ch.
+
+    Some readers report whitespace in element content using the
+    ignorableWhitespace() function rather than using this one.
+
+    A reader may report the character data of an element in more than
+    one chunk; e.g. a reader might want to report "a\<b" in three
+    characters() events ("a ", "\<" and " b").
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn bool TQXmlContentHandler::ignorableWhitespace( const TQString& ch )
+
+    Some readers may use this function to report each chunk of
+    whitespace in element content. The whitespace is reported in \a ch.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn bool TQXmlContentHandler::processingInstruction( const TQString& target, const TQString& data )
+
+    The reader calls this function when it has parsed a processing
+    instruction.
+
+    \a target is the target name of the processing instruction and \a
+    data is the data in the processing instruction.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn bool TQXmlContentHandler::skippedEntity( const TQString& name )
+
+    Some readers may skip entities if they have not seen the
+    declarations (e.g. because they are in an external DTD). If they
+    do so they report that they skipped the entity called \a name by
+    calling this function.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn TQString TQXmlContentHandler::errorString()
+
+    The reader calls this function to get an error string, e.g. if any
+    of the handler functions returns FALSE.
+*/
+
+
+/*!
+    \class TQXmlErrorHandler qxml.h
+    \reentrant
+    \brief The TQXmlErrorHandler class provides an interface to report
+    errors in XML data.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    If you want your application to report errors to the user or to
+    perform customized error handling, you should subclass this class.
+
+    You can set the error handler with TQXmlReader::setErrorHandler().
+
+    Errors can be reported using warning(), error() and fatalError(),
+    with the error text being reported with errorString().
+
+    See also the \link xml.html#sax2Intro Introduction to SAX2\endlink.
+
+    \sa TQXmlDTDHandler TQXmlDeclHandler TQXmlContentHandler TQXmlEntityResolver
+    TQXmlLexicalHandler
+*/
+
+/*!
+    \fn bool TQXmlErrorHandler::warning( const TQXmlParseException& exception )
+
+    A reader might use this function to report a warning. Warnings are
+    conditions that are not errors or fatal errors as defined by the
+    XML 1.0 specification. Details of the warning are stored in \a
+    exception.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn bool TQXmlErrorHandler::error( const TQXmlParseException& exception )
+
+    A reader might use this function to report a recoverable error. A
+    recoverable error corresponds to the definiton of "error" in
+    section 1.2 of the XML 1.0 specification. Details of the error are
+    stored in \a exception.
+
+    The reader must continue to provide normal parsing events after
+    invoking this function.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn bool TQXmlErrorHandler::fatalError( const TQXmlParseException& exception )
+
+    A reader must use this function to report a non-recoverable error.
+    Details of the error are stored in \a exception.
+
+    If this function returns TRUE the reader might try to go on
+    parsing and reporting further errors; but no regular parsing
+    events are reported.
+*/
+
+/*!
+    \fn TQString TQXmlErrorHandler::errorString()
+
+    The reader calls this function to get an error string if any of
+    the handler functions returns FALSE.
+*/
+
+
+/*!
+    \class TQXmlDTDHandler qxml.h
+    \reentrant
+    \brief The TQXmlDTDHandler class provides an interface to report
+    DTD content of XML data.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    If an application needs information about notations and unparsed
+    entities, it can implement this interface and register an instance
+    with TQXmlReader::setDTDHandler().
+
+    Note that this interface includes only those DTD events that the
+    XML recommendation retquires processors to report, i.e. notation
+    and unparsed entity declarations using notationDecl() and
+    unparsedEntityDecl() respectively.
+
+    See also the \link xml.html#sax2Intro Introduction to SAX2\endlink.
+
+    \sa TQXmlDeclHandler TQXmlContentHandler TQXmlEntityResolver TQXmlErrorHandler
+    TQXmlLexicalHandler
+*/
+
+/*!
+    \fn bool TQXmlDTDHandler::notationDecl( const TQString& name, const TQString& publicId, const TQString& systemId )
+
+    The reader calls this function when it has parsed a notation
+    declaration.
+
+    The argument \a name is the notation name, \a publicId is the
+    notation's public identifier and \a systemId is the notation's
+    system identifier.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn bool TQXmlDTDHandler::unparsedEntityDecl( const TQString& name, const TQString& publicId, const TQString& systemId, const TQString& notationName )
+
+    The reader calls this function when it finds an unparsed entity
+    declaration.
+
+    The argument \a name is the unparsed entity's name, \a publicId is
+    the entity's public identifier, \a systemId is the entity's system
+    identifier and \a notationName is the name of the associated
+    notation.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn TQString TQXmlDTDHandler::errorString()
+
+    The reader calls this function to get an error string if any of
+    the handler functions returns FALSE.
+*/
+
+
+/*!
+    \class TQXmlEntityResolver qxml.h
+    \reentrant
+    \brief The TQXmlEntityResolver class provides an interface to
+    resolve external entities contained in XML data.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    If an application needs to implement customized handling for
+    external entities, it must implement this interface, i.e.
+    resolveEntity(), and register it with
+    TQXmlReader::setEntityResolver().
+
+    See also the \link xml.html#sax2Intro Introduction to SAX2\endlink.
+
+    \sa TQXmlDTDHandler TQXmlDeclHandler TQXmlContentHandler TQXmlErrorHandler
+    TQXmlLexicalHandler
+*/
+
+/*!
+    \fn bool TQXmlEntityResolver::resolveEntity( const TQString& publicId, const TQString& systemId, TQXmlInputSource*& ret )
+
+    The reader calls this function before it opens any external
+    entity, except the top-level document entity. The application may
+    request the reader to resolve the entity itself (\a ret is 0) or
+    to use an entirely different input source (\a ret points to the
+    input source).
+
+    The reader deletes the input source \a ret when it no longer needs
+    it, so you should allocate it on the heap with \c new.
+
+    The argument \a publicId is the public identifier of the external
+    entity, \a systemId is the system identifier of the external
+    entity and \a ret is the return value of this function. If \a ret
+    is 0 the reader should resolve the entity itself, if it is
+    non-zero it must point to an input source which the reader uses
+    instead.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn TQString TQXmlEntityResolver::errorString()
+
+    The reader calls this function to get an error string if any of
+    the handler functions returns FALSE.
+*/
+
+
+/*!
+    \class TQXmlLexicalHandler qxml.h
+    \reentrant
+    \brief The TQXmlLexicalHandler class provides an interface to
+    report the lexical content of XML data.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    The events in the lexical handler apply to the entire document,
+    not just to the document element, and all lexical handler events
+    appear between the content handler's startDocument and endDocument
+    events.
+
+    You can set the lexical handler with
+    TQXmlReader::setLexicalHandler().
+
+    This interface's design is based on the the SAX2 extension
+    LexicalHandler.
+
+    The interface provides the startDTD(), endDTD(), startEntity(),
+    endEntity(), startCDATA(), endCDATA() and comment() functions.
+
+    See also the \link xml.html#sax2Intro Introduction to SAX2\endlink.
+
+    \sa TQXmlDTDHandler TQXmlDeclHandler TQXmlContentHandler TQXmlEntityResolver
+    TQXmlErrorHandler
+*/
+
+/*!
+    \fn bool TQXmlLexicalHandler::startDTD( const TQString& name, const TQString& publicId, const TQString& systemId )
+
+    The reader calls this function to report the start of a DTD
+    declaration, if any. It reports the name of the document type in
+    \a name, the public identifier in \a publicId and the system
+    identifier in \a systemId.
+
+    If the public identifier is missing, \a publicId is set to
+    TQString::null. If the system identifier is missing, \a systemId is
+    set to TQString::null. Note that it is not valid XML to have a
+    public identifier but no system identifier; in such cases a parse
+    error will occur.
+
+    All declarations reported through TQXmlDTDHandler or
+    TQXmlDeclHandler appear between the startDTD() and endDTD() calls.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    \sa endDTD()
+*/
+
+/*!
+    \fn bool TQXmlLexicalHandler::endDTD()
+
+    The reader calls this function to report the end of a DTD
+    declaration, if any.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    \sa startDTD()
+*/
+
+/*!
+    \fn bool TQXmlLexicalHandler::startEntity( const TQString& name )
+
+    The reader calls this function to report the start of an entity
+    called \a name.
+
+    Note that if the entity is unknown, the reader reports it through
+    TQXmlContentHandler::skippedEntity() and not through this
+    function.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    \sa endEntity() TQXmlSimpleReader::setFeature()
+*/
+
+/*!
+    \fn bool TQXmlLexicalHandler::endEntity( const TQString& name )
+
+    The reader calls this function to report the end of an entity
+    called \a name.
+
+    For every startEntity() call, there is a corresponding endEntity()
+    call. The calls to startEntity() and endEntity() are properly
+    nested.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    \sa startEntity() TQXmlContentHandler::skippedEntity() TQXmlSimpleReader::setFeature()
+*/
+
+/*!
+    \fn bool TQXmlLexicalHandler::startCDATA()
+
+    The reader calls this function to report the start of a CDATA
+    section. The content of the CDATA section is reported through the
+    TQXmlContentHandler::characters() function. This function is
+    intended only to report the boundary.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    \sa endCDATA()
+*/
+
+/*!
+    \fn bool TQXmlLexicalHandler::endCDATA()
+
+    The reader calls this function to report the end of a CDATA
+    section.
+
+    If this function returns FALSE the reader stops parsing and reports
+    an error. The reader uses the function errorString() to get the error
+    message.
+
+    \sa startCDATA() TQXmlContentHandler::characters()
+*/
+
+/*!
+    \fn bool TQXmlLexicalHandler::comment( const TQString& ch )
+
+    The reader calls this function to report an XML comment anywhere
+    in the document. It reports the text of the comment in \a ch.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn TQString TQXmlLexicalHandler::errorString()
+
+    The reader calls this function to get an error string if any of
+    the handler functions returns FALSE.
+*/
+
+
+/*!
+    \class TQXmlDeclHandler qxml.h
+    \reentrant
+    \brief The TQXmlDeclHandler class provides an interface to report declaration
+    content of XML data.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    You can set the declaration handler with
+    TQXmlReader::setDeclHandler().
+
+    This interface is based on the SAX2 extension DeclHandler.
+
+    The interface provides attributeDecl(), internalEntityDecl() and
+    externalEntityDecl() functions.
+
+    See also the \link xml.html#sax2Intro Introduction to SAX2\endlink.
+
+    \sa TQXmlDTDHandler TQXmlContentHandler TQXmlEntityResolver TQXmlErrorHandler
+    TQXmlLexicalHandler
+*/
+
+/*!
+    \fn bool TQXmlDeclHandler::attributeDecl( const TQString& eName, const TQString& aName, const TQString& type, const TQString& valueDefault, const TQString& value )
+
+    The reader calls this function to report an attribute type
+    declaration. Only the effective (first) declaration for an
+    attribute is reported.
+
+    The reader passes the name of the associated element in \a eName
+    and the name of the attribute in \a aName. It passes a string that
+    represents the attribute type in \a type and a string that
+    represents the attribute default in \a valueDefault. This string
+    is one of "#IMPLIED", "#RETQUIRED", "#FIXED" or TQString::null (if
+    none of the others applies). The reader passes the attribute's
+    default value in \a value. If no default value is specified in the
+    XML file, \a value is TQString::null.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn bool TQXmlDeclHandler::internalEntityDecl( const TQString& name, const TQString& value )
+
+    The reader calls this function to report an internal entity
+    declaration. Only the effective (first) declaration is reported.
+
+    The reader passes the name of the entity in \a name and the value
+    of the entity in \a value.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn bool TQXmlDeclHandler::externalEntityDecl( const TQString& name, const TQString& publicId, const TQString& systemId )
+
+    The reader calls this function to report a parsed external entity
+    declaration. Only the effective (first) declaration for each
+    entity is reported.
+
+    The reader passes the name of the entity in \a name, the public
+    identifier in \a publicId and the system identifier in \a
+    systemId. If there is no public identifier specified, it passes
+    TQString::null in \a publicId.
+
+    If this function returns FALSE the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn TQString TQXmlDeclHandler::errorString()
+
+    The reader calls this function to get an error string if any of
+    the handler functions returns FALSE.
+*/
+
+
+/*!
+    \class TQXmlDefaultHandler qxml.h
+    \reentrant
+    \brief The TQXmlDefaultHandler class provides a default implementation of all
+    the XML handler classes.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    Very often we are only interested in parts of the things that the
+    reader reports. This class implements a default behaviour for the
+    handler classes (i.e. most of the time do nothing). Usually this
+    is the class you subclass for implementing your own customized
+    handler.
+
+    See also the \link xml.html#sax2Intro Introduction to SAX2\endlink.
+
+    \sa TQXmlDTDHandler TQXmlDeclHandler TQXmlContentHandler TQXmlEntityResolver
+    TQXmlErrorHandler TQXmlLexicalHandler
+*/
+
+/*!
+    \fn TQXmlDefaultHandler::TQXmlDefaultHandler()
+
+    Constructor.
+*/
+/*!
+    \fn TQXmlDefaultHandler::~TQXmlDefaultHandler()
+
+    Destructor.
+*/
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+void TQXmlDefaultHandler::setDocumentLocator( TQXmlLocator* )
+{
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::startDocument()
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::endDocument()
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::startPrefixMapping( const TQString&, const TQString& )
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::endPrefixMapping( const TQString& )
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::startElement( const TQString&, const TQString&,
+	const TQString&, const TQXmlAttributes& )
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::endElement( const TQString&, const TQString&,
+	const TQString& )
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::characters( const TQString& )
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::ignorableWhitespace( const TQString& )
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::processingInstruction( const TQString&,
+	const TQString& )
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::skippedEntity( const TQString& )
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::warning( const TQXmlParseException& )
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::error( const TQXmlParseException& )
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::fatalError( const TQXmlParseException& )
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::notationDecl( const TQString&, const TQString&,
+	const TQString& )
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::unparsedEntityDecl( const TQString&, const TQString&,
+	const TQString&, const TQString& )
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Sets \a ret to 0, so that the reader uses the system identifier
+    provided in the XML document.
+*/
+bool TQXmlDefaultHandler::resolveEntity( const TQString&, const TQString&,
+	TQXmlInputSource*& ret )
+{
+    ret = 0;
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Returns the default error string.
+*/
+TQString TQXmlDefaultHandler::errorString()
+{
+    return TQString( XMLERR_ERRORBYCONSUMER );
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::startDTD( const TQString&, const TQString&, const TQString& )
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::endDTD()
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::startEntity( const TQString& )
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::endEntity( const TQString& )
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::startCDATA()
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::endCDATA()
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::comment( const TQString& )
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::attributeDecl( const TQString&, const TQString&, const TQString&, const TQString&, const TQString& )
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::internalEntityDecl( const TQString&, const TQString& )
+{
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Does nothing.
+*/
+bool TQXmlDefaultHandler::externalEntityDecl( const TQString&, const TQString&, const TQString& )
+{
+    return TRUE;
+}
+
+
+/*********************************************
+ *
+ * TQXmlSimpleReaderPrivate
+ *
+ *********************************************/
+
+class TQXmlSimpleReaderPrivate
+{
+private:
+    // functions
+    inline TQXmlSimpleReaderPrivate()
+    {
+	parseStack = 0;
+        undefEntityInAttrHack = FALSE;
+    }
+
+    inline ~TQXmlSimpleReaderPrivate()
+    {
+	delete parseStack;
+    }
+
+    inline void initIncrementalParsing()
+    {
+	delete parseStack;
+	parseStack = new TQValueStack<ParseState>;
+    }
+
+    // used to determine if elements are correctly nested
+    TQValueStack<TQString> tags;
+
+    // used for entity declarations
+    struct ExternParameterEntity
+    {
+	ExternParameterEntity( ) {}
+	ExternParameterEntity( const TQString &p, const TQString &s )
+	    : publicId(p), systemId(s) {}
+	TQString publicId;
+	TQString systemId;
+
+	Q_DUMMY_COMPARISON_OPERATOR(ExternParameterEntity)
+    };
+    struct ExternEntity
+    {
+	ExternEntity( ) {}
+	ExternEntity( const TQString &p, const TQString &s, const TQString &n )
+	    : publicId(p), systemId(s), notation(n) {}
+	TQString publicId;
+	TQString systemId;
+	TQString notation;
+	Q_DUMMY_COMPARISON_OPERATOR(ExternEntity)
+    };
+    TQMap<TQString,ExternParameterEntity> externParameterEntities;
+    TQMap<TQString,TQString> parameterEntities;
+    TQMap<TQString,ExternEntity> externEntities;
+    TQMap<TQString,TQString> entities;
+
+    // used for parsing of entity references
+    TQValueStack<TQString> xmlRef;
+    TQValueStack<TQString> xmlRefName;
+
+    // used for standalone declaration
+    enum Standalone { Yes, No, Unknown };
+
+    TQString doctype; // only used for the doctype
+    TQString xmlVersion; // only used to store the version information
+    TQString encoding; // only used to store the encoding
+    Standalone standalone; // used to store the value of the standalone declaration
+
+    TQString publicId; // used by parseExternalID() to store the public ID
+    TQString systemId; // used by parseExternalID() to store the system ID
+    TQString attDeclEName; // use by parseAttlistDecl()
+    TQString attDeclAName; // use by parseAttlistDecl()
+
+    // flags for some features support
+    bool useNamespaces;
+    bool useNamespacePrefixes;
+    bool reportWhitespaceCharData;
+    bool reportEntities;
+
+    // used to build the attribute list
+    TQXmlAttributes attList;
+
+    // used in TQXmlSimpleReader::parseContent() to decide whether character
+    // data was read
+    bool contentCharDataRead;
+
+    // helper classes
+    TQXmlLocator *locator;
+    TQXmlNamespaceSupport namespaceSupport;
+
+    // error string
+    TQString error;
+
+    // arguments for parse functions (this is needed to allow incremental
+    // parsing)
+    bool parsePI_xmldecl;
+    bool parseName_useRef;
+    bool parseReference_charDataRead;
+    TQXmlSimpleReader::EntityRecognitionContext parseReference_context;
+    bool parseExternalID_allowPublicID;
+    TQXmlSimpleReader::EntityRecognitionContext parsePEReference_context;
+    TQString parseString_s;
+
+    // for incremental parsing
+    struct ParseState {
+	typedef bool (TQXmlSimpleReader::*ParseFunction) ();
+	ParseFunction function;
+	int state;
+    };
+    TQValueStack<ParseState> *parseStack;
+
+    // used in parseProlog()
+    bool xmldecl_possible;
+    bool doctype_read;
+
+    // used in parseDoctype()
+    bool startDTDwasReported;
+
+    // used in parseString()
+    signed char Done;
+
+    bool undefEntityInAttrHack;
+
+    int nameValueLen;
+    int refValueLen;
+    int stringValueLen;
+
+    // friend declarations
+    friend class TQXmlSimpleReader;
+};
+
+
+/*********************************************
+ *
+ * TQXmlSimpleReader
+ *
+ *********************************************/
+
+/*!
+    \class TQXmlReader qxml.h
+    \reentrant
+    \brief The TQXmlReader class provides an interface for XML readers (i.e.
+    parsers).
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    This abstract class provides an interface for all of TQt's XML
+    readers. Currently there is only one implementation of a reader
+    included in TQt's XML module: TQXmlSimpleReader. In future releases
+    there might be more readers with different properties available
+    (e.g. a validating parser).
+
+    The design of the XML classes follows the \link
+    http://www.saxproject.org/ SAX2 Java interface\endlink, with
+    the names adapted to fit TQt naming conventions. It should be very
+    easy for anybody who has worked with SAX2 to get started with the
+    TQt XML classes.
+
+    All readers use the class TQXmlInputSource to read the input
+    document. Since you are normally interested in particular content
+    in the XML document, the reader reports the content through
+    special handler classes (TQXmlDTDHandler, TQXmlDeclHandler,
+    TQXmlContentHandler, TQXmlEntityResolver, TQXmlErrorHandler and
+    TQXmlLexicalHandler), which you must subclass, if you want to
+    process the contents.
+
+    Since the handler classes only describe interfaces you must
+    implement all the functions. We provide the TQXmlDefaultHandler
+    class to make this easier: it implements a default behaviour (do
+    nothing) for all functions, so you can subclass it and just
+    implement the functions you are interested in.
+
+    Features and properties of the reader can be set with setFeature()
+    and setProperty() respectively. You can set the reader to use your
+    own subclasses with setEntityResolver(), setDTDHandler(),
+    setContentHandler(), setErrorHandler(), setLexicalHandler() and
+    setDeclHandler(). The parse itself is started with a call to
+    parse().
+
+    \sa TQXmlSimpleReader
+*/
+
+/*!
+    \fn bool TQXmlReader::feature( const TQString& name, bool *ok ) const
+
+    If the reader has the feature called \a name, the feature's value
+    is returned. If no such feature exists the return value is
+    undefined.
+
+    If \a ok is not 0: \a *ok  is set to TRUE if the reader has the
+    feature called \a name; otherwise \a *ok is set to FALSE.
+
+    \sa setFeature() hasFeature()
+*/
+
+/*!
+    \fn void TQXmlReader::setFeature( const TQString& name, bool value )
+
+    Sets the feature called \a name to the given \a value. If the
+    reader doesn't have the feature nothing happens.
+
+    \sa feature() hasFeature()
+*/
+
+/*!
+    \fn bool TQXmlReader::hasFeature( const TQString& name ) const
+
+    Returns \c TRUE if the reader has the feature called \a name;
+    otherwise returns FALSE.
+
+    \sa feature() setFeature()
+*/
+
+/*!
+    \fn void* TQXmlReader::property( const TQString& name, bool *ok ) const
+
+    If the reader has the property \a name, this function returns the
+    value of the property; otherwise the return value is undefined.
+
+    If \a ok is not 0: if the reader has the \a name property \a *ok
+    is set to TRUE; otherwise \a *ok is set to FALSE.
+
+    \sa setProperty() hasProperty()
+*/
+
+/*!
+    \fn void TQXmlReader::setProperty( const TQString& name, void* value )
+
+    Sets the property \a name to \a value. If the reader doesn't have
+    the property nothing happens.
+
+    \sa property() hasProperty()
+*/
+
+/*!
+    \fn bool TQXmlReader::hasProperty( const TQString& name ) const
+
+    Returns TRUE if the reader has the property \a name; otherwise
+    returns FALSE.
+
+    \sa property() setProperty()
+*/
+
+/*!
+    \fn void TQXmlReader::setEntityResolver( TQXmlEntityResolver* handler )
+
+    Sets the entity resolver to \a handler.
+
+    \sa entityResolver()
+*/
+
+/*!
+    \fn TQXmlEntityResolver* TQXmlReader::entityResolver() const
+
+    Returns the entity resolver or 0 if none was set.
+
+    \sa setEntityResolver()
+*/
+
+/*!
+    \fn void TQXmlReader::setDTDHandler( TQXmlDTDHandler* handler )
+
+    Sets the DTD handler to \a handler.
+
+    \sa DTDHandler()
+*/
+
+/*!
+    \fn TQXmlDTDHandler* TQXmlReader::DTDHandler() const
+
+    Returns the DTD handler or 0 if none was set.
+
+    \sa setDTDHandler()
+*/
+
+/*!
+    \fn void TQXmlReader::setContentHandler( TQXmlContentHandler* handler )
+
+    Sets the content handler to \a handler.
+
+    \sa contentHandler()
+*/
+
+/*!
+    \fn TQXmlContentHandler* TQXmlReader::contentHandler() const
+
+    Returns the content handler or 0 if none was set.
+
+    \sa setContentHandler()
+*/
+
+/*!
+    \fn void TQXmlReader::setErrorHandler( TQXmlErrorHandler* handler )
+
+    Sets the error handler to \a handler. Clears the error handler if
+    \a handler is 0.
+
+    \sa errorHandler()
+*/
+
+/*!
+    \fn TQXmlErrorHandler* TQXmlReader::errorHandler() const
+
+    Returns the error handler or 0 if none is set.
+
+    \sa setErrorHandler()
+*/
+
+/*!
+    \fn void TQXmlReader::setLexicalHandler( TQXmlLexicalHandler* handler )
+
+    Sets the lexical handler to \a handler.
+
+    \sa lexicalHandler()
+*/
+
+/*!
+    \fn TQXmlLexicalHandler* TQXmlReader::lexicalHandler() const
+
+    Returns the lexical handler or 0 if none was set.
+
+    \sa setLexicalHandler()
+*/
+
+/*!
+    \fn void TQXmlReader::setDeclHandler( TQXmlDeclHandler* handler )
+
+    Sets the declaration handler to \a handler.
+
+    \sa declHandler()
+*/
+
+/*!
+    \fn TQXmlDeclHandler* TQXmlReader::declHandler() const
+
+    Returns the declaration handler or 0 if none was set.
+
+    \sa setDeclHandler()
+*/
+
+/*!
+  \fn bool TQXmlReader::parse( const TQXmlInputSource& input )
+
+  \obsolete
+*/
+
+/*!
+    \fn bool TQXmlReader::parse( const TQXmlInputSource* input )
+
+    Reads an XML document from \a input and parses it. Returns TRUE if
+    the parsing was successful; otherwise returns FALSE.
+*/
+
+
+/*!
+    \class TQXmlSimpleReader qxml.h
+    \reentrant
+    \brief The TQXmlSimpleReader class provides an implementation of a
+    simple XML reader (parser).
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+    \mainclass
+
+    This XML reader is sufficient for simple parsing tasks. The reader:
+    \list
+    \i provides a well-formed parser;
+    \i does not parse any external entities;
+    \i can do namespace processing.
+    \endlist
+
+    Documents are parsed with a call to parse().
+
+*/
+
+static inline bool is_S(TQChar ch)
+{
+    ushort uc = ch.unicode();
+    return (uc == ' ' || uc == '\t' || uc == '\n' || uc == '\r');
+}
+
+enum NameChar { NameBeginning, NameNotBeginning, NotName };
+
+static const char Begi = (char)NameBeginning;
+static const char NtBg = (char)NameNotBeginning;
+static const char NotN = (char)NotName;
+
+static const char nameCharTable[128] =
+{
+// 0x00
+    NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN,
+    NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN,
+// 0x10
+    NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN,
+    NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN,
+// 0x20 (0x2D is '-', 0x2E is '.')
+    NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN,
+    NotN, NotN, NotN, NotN, NotN, NtBg, NtBg, NotN,
+// 0x30 (0x30..0x39 are '0'..'9', 0x3A is ':')
+    NtBg, NtBg, NtBg, NtBg, NtBg, NtBg, NtBg, NtBg,
+    NtBg, NtBg, Begi, NotN, NotN, NotN, NotN, NotN,
+// 0x40 (0x41..0x5A are 'A'..'Z')
+    NotN, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
+    Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
+// 0x50 (0x5F is '_')
+    Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
+    Begi, Begi, Begi, NotN, NotN, NotN, NotN, Begi,
+// 0x60 (0x61..0x7A are 'a'..'z')
+    NotN, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
+    Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
+// 0x70
+    Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
+    Begi, Begi, Begi, NotN, NotN, NotN, NotN, NotN
+};
+
+static inline NameChar fastDetermineNameChar(TQChar ch)
+{
+    ushort uc = ch.unicode();
+    if (!(uc & ~0x7f)) // uc < 128
+        return (NameChar)nameCharTable[uc];
+
+    TQChar::Category cat = ch.category();
+    // ### some these categories might be slightly wrong
+    if ((cat >= TQChar::Letter_Uppercase && cat <= TQChar::Letter_Other)
+        || cat == TQChar::Number_Letter)
+        return NameBeginning;
+    if ((cat >= TQChar::Number_DecimalDigit && cat <= TQChar::Number_Other)
+                || (cat >= TQChar::Mark_NonSpacing && cat <= TQChar::Mark_Enclosing))
+        return NameNotBeginning;
+    return NotName;
+}
+
+static NameChar determineNameChar(TQChar ch)
+{
+    return fastDetermineNameChar(ch);
+}
+
+inline void TQXmlSimpleReader::nameClear()
+{
+    d->nameValueLen = 0; nameArrayPos = 0;
+}
+
+inline void TQXmlSimpleReader::refClear()
+{
+    d->refValueLen = 0; refArrayPos = 0;
+}
+
+/*!
+    Constructs a simple XML reader with the following feature settings:
+    \table
+    \header \i Feature \i Setting
+    \row \i \e http://xml.org/sax/features/namespaces \i TRUE
+    \row \i \e http://xml.org/sax/features/namespace-prefixes \i FALSE
+    \row \i \e http://trolltech.com/xml/features/report-whitespace-only-CharData
+	 \i TRUE
+    \row \i \e http://trolltech.com/xml/features/report-start-end-entity \i FALSE
+    \endtable
+
+    More information about features can be found in the \link
+    xml.html#sax2Features TQt SAX2 overview. \endlink
+
+    \sa setFeature()
+*/
+
+TQXmlSimpleReader::TQXmlSimpleReader()
+{
+    d = new TQXmlSimpleReaderPrivate();
+    d->locator = new TQXmlSimpleReaderLocator( this );
+
+    entityRes  = 0;
+    dtdHnd     = 0;
+    contentHnd = 0;
+    errorHnd   = 0;
+    lexicalHnd = 0;
+    declHnd    = 0;
+
+    // default feature settings
+    d->useNamespaces = TRUE;
+    d->useNamespacePrefixes = FALSE;
+    d->reportWhitespaceCharData = TRUE;
+    d->reportEntities = FALSE;
+}
+
+/*!
+    Destroys the simple XML reader.
+*/
+TQXmlSimpleReader::~TQXmlSimpleReader()
+{
+    delete d->locator;
+    delete d;
+}
+
+/*!
+    \reimp
+*/
+bool TQXmlSimpleReader::feature( const TQString& name, bool *ok ) const
+{
+    if ( ok != 0 )
+	*ok = TRUE;
+    if        ( name == "http://xml.org/sax/features/namespaces" ) {
+	return d->useNamespaces;
+    } else if ( name == "http://xml.org/sax/features/namespace-prefixes" ) {
+	return d->useNamespacePrefixes;
+    } else if ( name == "http://trolltech.com/xml/features/report-whitespace-only-CharData" ) {
+	return d->reportWhitespaceCharData;
+    } else if ( name == "http://trolltech.com/xml/features/report-start-end-entity" ) {
+	return d->reportEntities;
+    } else {
+	qWarning( "Unknown feature %s", name.latin1() );
+	if ( ok != 0 )
+	    *ok = FALSE;
+    }
+    return FALSE;
+}
+
+/*!
+    Sets the state of the feature \a name to \a value:
+
+    If the feature is not recognized, it is ignored.
+
+    The following features are supported:
+    \table
+    \header \i Feature \i Notes
+    \row \i \e http://xml.org/sax/features/namespaces
+         \i If this feature is TRUE, namespace processing is
+     performed.
+    \row \i \e http://xml.org/sax/features/namespace-prefixes
+         \i If this feature is TRUE, the the original prefixed names
+            and attributes used for namespace declarations are
+            reported.
+    \row \i \e http://trolltech.com/xml/features/report-whitespace-only-CharData
+         \i If this feature is TRUE, CharData that only contain
+            whitespace are not ignored, but are reported via
+            TQXmlContentHandler::characters().
+    \row \i \e http://trolltech.com/xml/features/report-start-end-entity
+         \i If this feature is TRUE, the parser reports
+            TQXmlContentHandler::startEntity() and
+            TQXmlContentHandler::endEntity() events. So character data
+            might be reported in chunks. If this feature is FALSE, the
+            parser does not report those events, but rather silently
+            substitutes the entities and reports the character data in
+            one chunk.
+    \endtable
+
+    \quotefile xml/tagreader-with-features/tagreader.cpp
+    \skipto reader
+    \printline reader
+    \skipto setFeature
+    \printline setFeature
+    \printline TRUE
+
+    (Code taken from xml/tagreader-with-features/tagreader.cpp)
+
+    \sa feature() hasFeature()
+*/
+void TQXmlSimpleReader::setFeature( const TQString& name, bool value )
+{
+    if        ( name == "http://xml.org/sax/features/namespaces" ) {
+	d->useNamespaces = value;
+    } else if ( name == "http://xml.org/sax/features/namespace-prefixes" ) {
+	d->useNamespacePrefixes = value;
+    } else if ( name == "http://trolltech.com/xml/features/report-whitespace-only-CharData" ) {
+	d->reportWhitespaceCharData = value;
+    } else if ( name == "http://trolltech.com/xml/features/report-start-end-entity" ) {
+	d->reportEntities = value;
+    } else {
+	qWarning( "Unknown feature %s", name.latin1() );
+    }
+}
+
+/*! \reimp
+*/
+bool TQXmlSimpleReader::hasFeature( const TQString& name ) const
+{
+    if ( name == "http://xml.org/sax/features/namespaces"
+	    || name == "http://xml.org/sax/features/namespace-prefixes"
+	    || name == "http://trolltech.com/xml/features/report-whitespace-only-CharData"
+	    || name == "http://trolltech.com/xml/features/report-start-end-entity" ) {
+	return TRUE;
+    } else {
+	return FALSE;
+    }
+}
+
+/*! \reimp
+*/
+void* TQXmlSimpleReader::property( const TQString&, bool *ok ) const
+{
+    if ( ok != 0 )
+	*ok = FALSE;
+    return 0;
+}
+
+/*! \reimp
+*/
+void TQXmlSimpleReader::setProperty( const TQString&, void* )
+{
+}
+
+/*!
+    \reimp
+*/
+bool TQXmlSimpleReader::hasProperty( const TQString& ) const
+{
+    return FALSE;
+}
+
+/*!
+    \reimp
+*/
+void TQXmlSimpleReader::setEntityResolver( TQXmlEntityResolver* handler )
+{ entityRes = handler; }
+
+/*!
+    \reimp
+*/
+TQXmlEntityResolver* TQXmlSimpleReader::entityResolver() const
+{ return entityRes; }
+
+/*!
+    \reimp
+*/
+void TQXmlSimpleReader::setDTDHandler( TQXmlDTDHandler* handler )
+{ dtdHnd = handler; }
+
+/*!
+    \reimp
+*/
+TQXmlDTDHandler* TQXmlSimpleReader::DTDHandler() const
+{ return dtdHnd; }
+
+/*!
+    \reimp
+*/
+void TQXmlSimpleReader::setContentHandler( TQXmlContentHandler* handler )
+{ contentHnd = handler; }
+
+/*!
+    \reimp
+*/
+TQXmlContentHandler* TQXmlSimpleReader::contentHandler() const
+{ return contentHnd; }
+
+/*!
+    \reimp
+*/
+void TQXmlSimpleReader::setErrorHandler( TQXmlErrorHandler* handler )
+{ errorHnd = handler; }
+
+/*!
+    \reimp
+*/
+TQXmlErrorHandler* TQXmlSimpleReader::errorHandler() const
+{ return errorHnd; }
+
+/*!
+    \reimp
+*/
+void TQXmlSimpleReader::setLexicalHandler( TQXmlLexicalHandler* handler )
+{ lexicalHnd = handler; }
+
+/*!
+    \reimp
+*/
+TQXmlLexicalHandler* TQXmlSimpleReader::lexicalHandler() const
+{ return lexicalHnd; }
+
+/*!
+    \reimp
+*/
+void TQXmlSimpleReader::setDeclHandler( TQXmlDeclHandler* handler )
+{ declHnd = handler; }
+
+/*!
+    \reimp
+*/
+TQXmlDeclHandler* TQXmlSimpleReader::declHandler() const
+{ return declHnd; }
+
+
+
+/*!
+    \reimp
+*/
+bool TQXmlSimpleReader::parse( const TQXmlInputSource& input )
+{
+    return parse( &input, FALSE );
+}
+
+/*!
+    \reimp
+*/
+bool TQXmlSimpleReader::parse( const TQXmlInputSource* input )
+{
+    return parse( input, FALSE );
+}
+
+/*!
+    Reads an XML document from \a input and parses it. Returns FALSE
+    if the parsing detects an error; otherwise returns TRUE.
+
+    If \a incremental is TRUE, the parser does not return FALSE when
+    it reaches the end of the \a input without reaching the end of the
+    XML file. Instead it stores the state of the parser so that
+    parsing can be continued at a later stage when more data is
+    available. You can use the function parseContinue() to continue
+    with parsing. This class stores a pointer to the input source \a
+    input and the parseContinue() function tries to read from that
+    input souce. This means that you should not delete the input
+    source \a input until you've finished your calls to
+    parseContinue(). If you call this function with \a incremental
+    TRUE whilst an incremental parse is in progress a new parsing
+    session will be started and the previous session lost.
+
+    If \a incremental is FALSE, this function behaves like the normal
+    parse function, i.e. it returns FALSE when the end of input is
+    reached without reaching the end of the XML file and the parsing
+    cannot be continued.
+
+    \sa parseContinue() TQSocket
+*/
+bool TQXmlSimpleReader::parse( const TQXmlInputSource *input, bool incremental )
+{
+    init( input );
+    if ( incremental ) {
+	d->initIncrementalParsing();
+    } else {
+	delete d->parseStack;
+	d->parseStack = 0;
+    }
+    // call the handler
+    if ( contentHnd ) {
+	contentHnd->setDocumentLocator( d->locator );
+	if ( !contentHnd->startDocument() ) {
+	    reportParseError( contentHnd->errorString() );
+	    d->tags.clear();
+	    return FALSE;
+	}
+    }
+    return parseBeginOrContinue( 0, incremental );
+}
+
+/*!
+    Continues incremental parsing; this function reads the input from
+    the TQXmlInputSource that was specified with the last parse()
+    command. To use this function, you \e must have called parse()
+    with the incremental argument set to TRUE.
+
+    Returns FALSE if a parsing error occurs; otherwise returns TRUE.
+
+    If the input source returns an empty string for the function
+    TQXmlInputSource::data(), then this means that the end of the XML
+    file has been reached; this is tquite important, especially if you
+    want to use the reader to parse more than one XML file.
+
+    The case of the end of the XML file being reached without having
+    finished parsing is not considered to be an error: you can
+    continue parsing at a later stage by calling this function again
+    when there is more data available to parse.
+
+    This function assumes that the end of the XML document is reached
+    if the TQXmlInputSource::next() function returns
+    TQXmlInputSource::EndOfDocument. If the parser has not finished
+    parsing when it encounters this symbol, it is an error and FALSE
+    is returned.
+
+    \sa parse() TQXmlInputSource::next()
+*/
+bool TQXmlSimpleReader::parseContinue()
+{
+    if ( d->parseStack == 0 || d->parseStack->isEmpty() )
+	return FALSE;
+    initData();
+    int state = d->parseStack->pop().state;
+    return parseBeginOrContinue( state, TRUE );
+}
+
+/*
+  Common part of parse() and parseContinue()
+*/
+bool TQXmlSimpleReader::parseBeginOrContinue( int state, bool incremental )
+{
+    bool atEndOrig = atEnd();
+
+    if ( state==0 ) {
+	if ( !parseProlog() ) {
+	    if ( incremental && d->error.isNull() ) {
+		pushParseState( 0, 0 );
+		return TRUE;
+	    } else {
+		d->tags.clear();
+		return FALSE;
+	    }
+	}
+	state = 1;
+    }
+    if ( state==1 ) {
+	if ( !parseElement() ) {
+	    if ( incremental && d->error.isNull() ) {
+		pushParseState( 0, 1 );
+		return TRUE;
+	    } else {
+		d->tags.clear();
+		return FALSE;
+	    }
+	}
+	state = 2;
+    }
+    // parse Misc*
+    while ( !atEnd() ) {
+	if ( !parseMisc() ) {
+	    if ( incremental && d->error.isNull() ) {
+		pushParseState( 0, 2 );
+		return TRUE;
+	    } else {
+		d->tags.clear();
+		return FALSE;
+	    }
+	}
+    }
+    if ( !atEndOrig && incremental ) {
+	// we parsed something at all, so be prepared to come back later
+	pushParseState( 0, 2 );
+	return TRUE;
+    }
+    // is stack empty?
+    if ( !d->tags.isEmpty() && !d->error.isNull() ) {
+	reportParseError( XMLERR_UNEXPECTEDEOF );
+	d->tags.clear();
+	return FALSE;
+    }
+    // call the handler
+    if ( contentHnd ) {
+	delete d->parseStack;
+	d->parseStack = 0;
+	if ( !contentHnd->endDocument() ) {
+	    reportParseError( contentHnd->errorString() );
+	    return FALSE;
+	}
+    }
+    return TRUE;
+}
+
+//
+// The following private parse functions have another semantics for the return
+// value: They return TRUE iff parsing has finished successfully (i.e. the end
+// of the XML file must be reached!). If one of these functions return FALSE,
+// there is only an error when d->error.isNULL() is also FALSE.
+//
+
+/*
+  For the incremental parsing, it is very important that the parse...()
+  functions have a certain structure. Since it might be hard to understand how
+  they work, here is a description of the layout of these functions:
+
+    bool TQXmlSimpleReader::parse...()
+    {
+(1)	const signed char Init             = 0;
+	...
+
+(2)	const signed char Inp...           = 0;
+	...
+
+(3)	static signed char table[3][2] = {
+	...
+	};
+	signed char state;
+	signed char input;
+
+(4)        if (d->parseStack == 0 || d->parseStack->isEmpty()) {
+(4a)	...
+	} else {
+(4b)	...
+	}
+
+	for ( ; ; ) {
+(5)	    switch ( state ) {
+	    ...
+	    }
+
+(6)
+(6a)	    if ( atEnd() ) {
+		unexpectedEof( &TQXmlSimpleReader::parseNmtoken, state );
+		return FALSE;
+	    }
+(6b)        if (determineNameChar(c) != NotName) {
+	    ...
+	    }
+(7)	    state = table[state][input];
+
+(8)	    switch ( state ) {
+	    ...
+	    }
+	}
+    }
+
+  Explanation:
+  ad 1: constants for the states (used in the transition table)
+  ad 2: constants for the input (used in the transition table)
+  ad 3: the transition table for the state machine
+  ad 4: test if we are in a parseContinue() step
+	a) if no, do inititalizations
+	b) if yes, restore the state and call parse functions recursively
+  ad 5: Do some actions according to the state; from the logical execution
+	order, this code belongs after 8 (see there for an explanation)
+  ad 6: Check the character that is at the actual "cursor" position:
+	a) If we reached the EOF, report either error or push the state (in the
+	   case of incremental parsing).
+	b) Otherwise, set the input character constant for the transition
+	   table.
+  ad 7: Get the new state according to the input that was read.
+  ad 8: Do some actions according to the state. The last line in every case
+	statement reads new data (i.e. it move the cursor). This can also be
+	done by calling another parse...() funtion. If you need processing for
+	this state after that, you have to put it into the switch statement 5.
+	This ensures that you have a well defined re-entry point, when you ran
+	out of data.
+*/
+
+/*
+  Parses the prolog [22].
+*/
+bool TQXmlSimpleReader::parseProlog()
+{
+    const signed char Init             = 0;
+    const signed char EatWS            = 1; // eat white spaces
+    const signed char Lt               = 2; // '<' read
+    const signed char Em               = 3; // '!' read
+    const signed char DocType          = 4; // read doctype
+    const signed char Comment          = 5; // read comment
+    const signed char CommentR         = 6; // same as Comment, but already reported
+    const signed char PInstr           = 7; // read PI
+    const signed char PInstrR          = 8; // same as PInstr, but already reported
+    const signed char Done             = 9;
+
+    const signed char InpWs            = 0;
+    const signed char InpLt            = 1; // <
+    const signed char InpQm            = 2; // ?
+    const signed char InpEm            = 3; // !
+    const signed char InpD             = 4; // D
+    const signed char InpDash          = 5; // -
+    const signed char InpUnknown       = 6;
+
+    static const signed char table[9][7] = {
+     /*  InpWs   InpLt  InpQm  InpEm  InpD      InpDash  InpUnknown */
+	{ EatWS,  Lt,    -1,    -1,    -1,       -1,       -1      }, // Init
+	{ -1,     Lt,    -1,    -1,    -1,       -1,       -1      }, // EatWS
+	{ -1,     -1,    PInstr,Em,    Done,     -1,       Done    }, // Lt
+	{ -1,     -1,    -1,    -1,    DocType,  Comment,  -1      }, // Em
+	{ EatWS,  Lt,    -1,    -1,    -1,       -1,       -1      }, // DocType
+	{ EatWS,  Lt,    -1,    -1,    -1,       -1,       -1      }, // Comment
+	{ EatWS,  Lt,    -1,    -1,    -1,       -1,       -1      }, // CommentR
+	{ EatWS,  Lt,    -1,    -1,    -1,       -1,       -1      }, // PInstr
+	{ EatWS,  Lt,    -1,    -1,    -1,       -1,       -1      }  // PInstrR
+    };
+    signed char state;
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	d->xmldecl_possible = TRUE;
+	d->doctype_read = FALSE;
+	state = Init;
+    } else {
+        state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseProlog (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+            ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseProlog, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case DocType:
+		if ( d->doctype_read ) {
+		    reportParseError( XMLERR_MORETHANONEDOCTYPE );
+		    return FALSE;
+		} else {
+		    d->doctype_read = FALSE;
+		}
+		break;
+	    case Comment:
+		if ( lexicalHnd ) {
+		    if ( !lexicalHnd->comment( string() ) ) {
+			reportParseError( lexicalHnd->errorString() );
+			return FALSE;
+		    }
+		}
+		state = CommentR;
+		break;
+	    case PInstr:
+		// call the handler
+		if ( contentHnd ) {
+		    if ( d->xmldecl_possible && !d->xmlVersion.isEmpty() ) {
+			TQString value( "version = '" );
+			value += d->xmlVersion;
+			value += "'";
+			if ( !d->encoding.isEmpty() ) {
+			    value += " encoding = '";
+			    value += d->encoding;
+			    value += "'";
+			}
+			if ( d->standalone == TQXmlSimpleReaderPrivate::Yes ) {
+			    value += " standalone = 'yes'";
+			} else if ( d->standalone == TQXmlSimpleReaderPrivate::No ) {
+			    value += " standalone = 'no'";
+			}
+			if ( !contentHnd->processingInstruction( "xml", value ) ) {
+			    reportParseError( contentHnd->errorString() );
+			    return FALSE;
+			}
+		    } else {
+			if ( !contentHnd->processingInstruction( name(), string() ) ) {
+			    reportParseError( contentHnd->errorString() );
+			    return FALSE;
+			}
+		    }
+		}
+		// XML declaration only on first position possible
+		d->xmldecl_possible = FALSE;
+		state = PInstrR;
+		break;
+	    case Done:
+		return TRUE;
+	    case -1:
+		reportParseError( XMLERR_ERRORPARSINGELEMENT );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseProlog, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if ( c.unicode() == '<' ) {
+	    input = InpLt;
+	} else if ( c.unicode() == '?' ) {
+	    input = InpQm;
+	} else if ( c.unicode() == '!' ) {
+	    input = InpEm;
+	} else if ( c.unicode() == 'D' ) {
+	    input = InpD;
+	} else if ( c.unicode() == '-' ) {
+	    input = InpDash;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case EatWS:
+		// XML declaration only on first position possible
+		d->xmldecl_possible = FALSE;
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseProlog, state );
+		    return FALSE;
+		}
+		break;
+	    case Lt:
+		next();
+		break;
+	    case Em:
+		// XML declaration only on first position possible
+		d->xmldecl_possible = FALSE;
+		next();
+		break;
+	    case DocType:
+		if ( !parseDoctype() ) {
+		    parseFailed( &TQXmlSimpleReader::parseProlog, state );
+		    return FALSE;
+		}
+		break;
+	    case Comment:
+	    case CommentR:
+		if ( !parseComment() ) {
+		    parseFailed( &TQXmlSimpleReader::parseProlog, state );
+		    return FALSE;
+		}
+		break;
+	    case PInstr:
+	    case PInstrR:
+		d->parsePI_xmldecl = d->xmldecl_possible;
+		if ( !parsePI() ) {
+		    parseFailed( &TQXmlSimpleReader::parseProlog, state );
+		    return FALSE;
+		}
+		break;
+	}
+    }
+}
+
+/*
+  Parse an element [39].
+
+  Precondition: the opening '<' is already read.
+*/
+bool TQXmlSimpleReader::parseElement()
+{
+    const int Init             =  0;
+    const int ReadName         =  1;
+    const int Ws1              =  2;
+    const int STagEnd          =  3;
+    const int STagEnd2         =  4;
+    const int ETagBegin        =  5;
+    const int ETagBegin2       =  6;
+    const int Ws2              =  7;
+    const int EmptyTag         =  8;
+    const int Attrib           =  9;
+    const int AttribPro        = 10; // like Attrib, but processAttribute was already called
+    const int Ws3              = 11;
+    const int Done             = 12;
+
+    const int InpWs            = 0; // whitespace
+    const int InpNameBe        = 1; // is_NameBeginning()
+    const int InpGt            = 2; // >
+    const int InpSlash         = 3; // /
+    const int InpUnknown       = 4;
+
+    static const int table[12][5] = {
+     /*  InpWs      InpNameBe    InpGt        InpSlash     InpUnknown */
+	{ -1,        ReadName,    -1,          -1,          -1        }, // Init
+	{ Ws1,       Attrib,      STagEnd,     EmptyTag,    -1        }, // ReadName
+	{ -1,        Attrib,      STagEnd,     EmptyTag,    -1        }, // Ws1
+	{ STagEnd2,  STagEnd2,    STagEnd2,    STagEnd2,    STagEnd2  }, // STagEnd
+	{ -1,        -1,          -1,          ETagBegin,   -1        }, // STagEnd2
+	{ -1,        ETagBegin2,  -1,          -1,          -1        }, // ETagBegin
+	{ Ws2,       -1,          Done,        -1,          -1        }, // ETagBegin2
+	{ -1,        -1,          Done,        -1,          -1        }, // Ws2
+	{ -1,        -1,          Done,        -1,          -1        }, // EmptyTag
+	{ Ws3,       Attrib,      STagEnd,     EmptyTag,    -1        }, // Attrib
+	{ Ws3,       Attrib,      STagEnd,     EmptyTag,    -1        }, // AttribPro
+	{ -1,        Attrib,      STagEnd,     EmptyTag,    -1        }  // Ws3
+    };
+    int state;
+    int input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseElement (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseElement, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case ReadName:
+		// store it on the stack
+		d->tags.push( name() );
+		// empty the attributes
+		d->attList.clear();
+		if ( d->useNamespaces )
+		    d->namespaceSupport.pushContext();
+		break;
+	    case ETagBegin2:
+		if ( !processElementETagBegin2() )
+		    return FALSE;
+		break;
+	    case Attrib:
+		if ( !processElementAttribute() )
+		    return FALSE;
+		state = AttribPro;
+		break;
+	    case Done:
+		return TRUE;
+	    case -1:
+		reportParseError( XMLERR_ERRORPARSINGELEMENT );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseElement, state );
+	    return FALSE;
+	}
+
+        if (fastDetermineNameChar(c) == NameBeginning) {
+	    input = InpNameBe;
+	} else if ( c.unicode() == '>' ) {
+	    input = InpGt;
+	} else if (is_S(c)) {
+            input = InpWs;
+        } else if (c.unicode() == '/') {
+	    input = InpSlash;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case ReadName:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &TQXmlSimpleReader::parseElement, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws1:
+	    case Ws2:
+	    case Ws3:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseElement, state );
+		    return FALSE;
+		}
+		break;
+	    case STagEnd:
+		// call the handler
+		if ( contentHnd ) {
+                    const TQString &tagsTop = d->tags.top();
+		    if ( d->useNamespaces ) {
+			TQString uri, lname;
+                        d->namespaceSupport.processName(tagsTop, FALSE, uri, lname);
+                        if (!contentHnd->startElement(uri, lname, tagsTop, d->attList)) {
+			    reportParseError( contentHnd->errorString() );
+			    return FALSE;
+			}
+		    } else {
+                        if (!contentHnd->startElement(TQString::null, TQString::null, tagsTop, d->attList)) {
+			    reportParseError( contentHnd->errorString() );
+			    return FALSE;
+			}
+		    }
+		}
+		next();
+		break;
+	    case STagEnd2:
+		if ( !parseContent() ) {
+		    parseFailed( &TQXmlSimpleReader::parseElement, state );
+		    return FALSE;
+		}
+		break;
+	    case ETagBegin:
+		next();
+		break;
+	    case ETagBegin2:
+		// get the name of the tag
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &TQXmlSimpleReader::parseElement, state );
+		    return FALSE;
+		}
+		break;
+	    case EmptyTag:
+		if  ( d->tags.isEmpty() ) {
+		    reportParseError( XMLERR_TAGMISMATCH );
+		    return FALSE;
+		}
+		if ( !processElementEmptyTag() )
+		    return FALSE;
+		next();
+		break;
+	    case Attrib:
+	    case AttribPro:
+		// get name and value of attribute
+		if ( !parseAttribute() ) {
+		    parseFailed( &TQXmlSimpleReader::parseElement, state );
+		    return FALSE;
+		}
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+/*
+  Helper to break down the size of the code in the case statement.
+  Return FALSE on error, otherwise TRUE.
+*/
+bool TQXmlSimpleReader::processElementEmptyTag()
+{
+    TQString uri, lname;
+    // pop the stack and call the handler
+    if ( contentHnd ) {
+	if ( d->useNamespaces ) {
+	    // report startElement first...
+	    d->namespaceSupport.processName( d->tags.top(), FALSE, uri, lname );
+	    if ( !contentHnd->startElement( uri, lname, d->tags.top(), d->attList ) ) {
+		reportParseError( contentHnd->errorString() );
+		return FALSE;
+	    }
+	    // ... followed by endElement...
+	    if ( !contentHnd->endElement( uri, lname, d->tags.pop() ) ) {
+		reportParseError( contentHnd->errorString() );
+		return FALSE;
+	    }
+	    // ... followed by endPrefixMapping
+	    TQStringList prefixesBefore, prefixesAfter;
+	    if ( contentHnd ) {
+		prefixesBefore = d->namespaceSupport.prefixes();
+	    }
+	    d->namespaceSupport.popContext();
+	    // call the handler for prefix mapping
+	    prefixesAfter = d->namespaceSupport.prefixes();
+	    for ( TQStringList::Iterator it = prefixesBefore.begin(); it != prefixesBefore.end(); ++it ) {
+		if ( prefixesAfter.contains(*it) == 0 ) {
+		    if ( !contentHnd->endPrefixMapping( *it ) ) {
+			reportParseError( contentHnd->errorString() );
+			return FALSE;
+		    }
+		}
+	    }
+	} else {
+	    // report startElement first...
+	    if ( !contentHnd->startElement( TQString::null, TQString::null, d->tags.top(), d->attList ) ) {
+		reportParseError( contentHnd->errorString() );
+		return FALSE;
+	    }
+	    // ... followed by endElement
+	    if ( !contentHnd->endElement( TQString::null, TQString::null, d->tags.pop() ) ) {
+		reportParseError( contentHnd->errorString() );
+		return FALSE;
+	    }
+	}
+    } else {
+	d->tags.pop_back();
+	d->namespaceSupport.popContext();
+    }
+    return TRUE;
+}
+/*
+  Helper to break down the size of the code in the case statement.
+  Return FALSE on error, otherwise TRUE.
+*/
+bool TQXmlSimpleReader::processElementETagBegin2()
+{
+    const TQString &name = TQXmlSimpleReader::name();
+
+    // pop the stack and compare it with the name
+    if ( d->tags.pop() != name ) {
+	reportParseError( XMLERR_TAGMISMATCH );
+	return FALSE;
+    }
+    // call the handler
+    if ( contentHnd ) {
+        TQString uri, lname;
+
+        if (d->useNamespaces)
+            d->namespaceSupport.processName(name, FALSE, uri, lname);
+        if (!contentHnd->endElement(uri, lname, name)) {
+            reportParseError(contentHnd->errorString());
+            return FALSE;
+	}
+    }
+    if ( d->useNamespaces ) {
+        NamespaceMap prefixesBefore, prefixesAfter;
+        if (contentHnd)
+            prefixesBefore = d->namespaceSupport.d->ns;
+
+	d->namespaceSupport.popContext();
+	// call the handler for prefix mapping
+	if ( contentHnd ) {
+            prefixesAfter = d->namespaceSupport.d->ns;
+            if (prefixesBefore.size() != prefixesAfter.size()) {
+                for (NamespaceMap::const_iterator it = prefixesBefore.constBegin(); it != prefixesBefore.constEnd(); ++it) {
+                    if (!it.key().isEmpty() && !prefixesAfter.contains(it.key())) {
+                        if (!contentHnd->endPrefixMapping(it.key())) {
+                            reportParseError(contentHnd->errorString());
+                            return FALSE;
+                        }
+		    }
+		}
+	    }
+	}
+    }
+    return TRUE;
+}
+/*
+  Helper to break down the size of the code in the case statement.
+  Return FALSE on error, otherwise TRUE.
+*/
+bool TQXmlSimpleReader::processElementAttribute()
+{
+    TQString uri, lname, prefix;
+    const TQString &name = TQXmlSimpleReader::name();
+    const TQString &string = TQXmlSimpleReader::string();
+
+    // add the attribute to the list
+    if ( d->useNamespaces ) {
+	// is it a namespace declaration?
+        d->namespaceSupport.splitName(name, prefix, lname);
+        if (prefix == "xmlns") {
+	    // namespace declaration
+	    d->namespaceSupport.setPrefix( lname, string );
+	    if ( d->useNamespacePrefixes ) {
+		// according to http://www.w3.org/2000/xmlns/, the "prefix"
+		// xmlns maps to the namespace name
+		// http://www.w3.org/2000/xmlns/
+		d->attList.append( name, "http://www.w3.org/2000/xmlns/", lname, string );
+	    }
+	    // call the handler for prefix mapping
+	    if ( contentHnd ) {
+		if ( !contentHnd->startPrefixMapping( lname, string ) ) {
+		    reportParseError( contentHnd->errorString() );
+		    return FALSE;
+		}
+	    }
+	} else {
+	    // no namespace delcaration
+	    d->namespaceSupport.processName( name, TRUE, uri, lname );
+	    d->attList.append( name, uri, lname, string );
+	}
+    } else {
+	// no namespace support
+	d->attList.append( name, TQString::null, TQString::null, string );
+    }
+    return TRUE;
+}
+
+/*
+  Parse a content [43].
+
+  A content is only used between tags. If a end tag is found the < is already
+  read and the head stand on the '/' of the end tag '</name>'.
+*/
+bool TQXmlSimpleReader::parseContent()
+{
+    const signed char Init             =  0;
+    const signed char ChD              =  1; // CharData
+    const signed char ChD1             =  2; // CharData help state
+    const signed char ChD2             =  3; // CharData help state
+    const signed char Ref              =  4; // Reference
+    const signed char Lt               =  5; // '<' read
+    const signed char PInstr           =  6; // PI
+    const signed char PInstrR          =  7; // same as PInstr, but already reported
+    const signed char Elem             =  8; // Element
+    const signed char Em               =  9; // '!' read
+    const signed char Com              = 10; // Comment
+    const signed char ComR             = 11; // same as Com, but already reported
+    const signed char CDS              = 12; // CDSect
+    const signed char CDS1             = 13; // read a CDSect
+    const signed char CDS2             = 14; // read a CDSect (help state)
+    const signed char CDS3             = 15; // read a CDSect (help state)
+    const signed char Done             = 16; // finished reading content
+
+    const signed char InpLt            = 0; // <
+    const signed char InpGt            = 1; // >
+    const signed char InpSlash         = 2; // /
+    const signed char InpTQMark         = 3; // ?
+    const signed char InpEMark         = 4; // !
+    const signed char InpAmp           = 5; // &
+    const signed char InpDash          = 6; // -
+    const signed char InpOpenB         = 7; // [
+    const signed char InpCloseB        = 8; // ]
+    const signed char InpUnknown       = 9;
+
+    static const signed char mapCLT2FSMChar[] = {
+	InpUnknown, // white space
+	InpUnknown, // %
+	InpAmp,     // &
+	InpGt,      // >
+	InpLt,      // <
+	InpSlash,   // /
+	InpTQMark,   // ?
+	InpEMark,   // !
+	InpDash,    // -
+	InpCloseB,  // ]
+	InpOpenB,   // [
+	InpUnknown, // =
+	InpUnknown, // "
+	InpUnknown, // '
+	InpUnknown  // unknown
+    };
+
+    static const signed char table[16][10] = {
+     /*  InpLt  InpGt  InpSlash  InpTQMark  InpEMark  InpAmp  InpDash  InpOpenB  InpCloseB  InpUnknown */
+	{ Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD1,      ChD  }, // Init
+	{ Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD1,      ChD  }, // ChD
+	{ Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD2,      ChD  }, // ChD1
+	{ Lt,    -1,    ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD2,      ChD  }, // ChD2
+	{ Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD,       ChD  }, // Ref (same as Init)
+	{ -1,    -1,    Done,     PInstr,   Em,       -1,     -1,      -1,       -1,        Elem }, // Lt
+	{ Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD,       ChD  }, // PInstr (same as Init)
+	{ Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD,       ChD  }, // PInstrR
+	{ Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD,       ChD  }, // Elem (same as Init)
+	{ -1,    -1,    -1,       -1,       -1,       -1,     Com,     CDS,      -1,        -1   }, // Em
+	{ Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD,       ChD  }, // Com (same as Init)
+	{ Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD,       ChD  }, // ComR
+	{ CDS1,  CDS1,  CDS1,     CDS1,     CDS1,     CDS1,   CDS1,    CDS1,     CDS2,      CDS1 }, // CDS
+	{ CDS1,  CDS1,  CDS1,     CDS1,     CDS1,     CDS1,   CDS1,    CDS1,     CDS2,      CDS1 }, // CDS1
+	{ CDS1,  CDS1,  CDS1,     CDS1,     CDS1,     CDS1,   CDS1,    CDS1,     CDS3,      CDS1 }, // CDS2
+	{ CDS1,  Init,  CDS1,     CDS1,     CDS1,     CDS1,   CDS1,    CDS1,     CDS3,      CDS1 }  // CDS3
+    };
+    signed char state;
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	d->contentCharDataRead = FALSE;
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseContent (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseContent, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Ref:
+		if ( !d->contentCharDataRead)
+		    d->contentCharDataRead = d->parseReference_charDataRead;
+		break;
+	    case PInstr:
+		if ( contentHnd ) {
+		    if ( !contentHnd->processingInstruction(name(),string()) ) {
+			reportParseError( contentHnd->errorString() );
+			return FALSE;
+		    }
+		}
+		state = PInstrR;
+		break;
+	    case Com:
+		if ( lexicalHnd ) {
+		    if ( !lexicalHnd->comment( string() ) ) {
+			reportParseError( lexicalHnd->errorString() );
+			return FALSE;
+		    }
+		}
+		state = ComR;
+		break;
+	    case CDS:
+		stringClear();
+		break;
+	    case CDS2:
+		if ( !atEnd() && c.unicode() != ']' )
+		    stringAddC( ']' );
+		break;
+	    case CDS3:
+		// test if this skipping was legal
+		if ( !atEnd() ) {
+		    if ( c.unicode() == '>' ) {
+			// the end of the CDSect
+			if ( lexicalHnd ) {
+			    if ( !lexicalHnd->startCDATA() ) {
+				reportParseError( lexicalHnd->errorString() );
+				return FALSE;
+			    }
+			}
+			if ( contentHnd ) {
+			    if ( !contentHnd->characters( string() ) ) {
+				reportParseError( contentHnd->errorString() );
+				return FALSE;
+			    }
+			}
+			if ( lexicalHnd ) {
+			    if ( !lexicalHnd->endCDATA() ) {
+				reportParseError( lexicalHnd->errorString() );
+				return FALSE;
+			    }
+			}
+		    } else if (c.unicode() == ']') {
+			// three or more ']'
+			stringAddC( ']' );
+		    } else {
+			// after ']]' comes another character
+			stringAddC( ']' );
+			stringAddC( ']' );
+		    }
+		}
+		break;
+	    case Done:
+		// call the handler for CharData
+		if ( contentHnd ) {
+		    if ( d->contentCharDataRead ) {
+			if ( d->reportWhitespaceCharData || !string().simplifyWhiteSpace().isEmpty() ) {
+			    if ( !contentHnd->characters( string() ) ) {
+				reportParseError( contentHnd->errorString() );
+				return FALSE;
+			    }
+			}
+		    }
+		}
+		// Done
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_ERRORPARSINGCONTENT );
+		return FALSE;
+	}
+
+	// get input (use lookup-table instead of nested ifs for performance
+	// reasons)
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseContent, state );
+	    return FALSE;
+	}
+	if ( c.row() ) {
+	    input = InpUnknown;
+	} else {
+	    input = mapCLT2FSMChar[ charLookupTable[ c.cell() ] ];
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Init:
+		// skip the ending '>' of a CDATASection
+		next();
+		break;
+	    case ChD:
+		// on first call: clear string
+		if ( !d->contentCharDataRead ) {
+		    d->contentCharDataRead = TRUE;
+		    stringClear();
+		}
+		stringAddC();
+		if ( d->reportEntities ) {
+		    if ( !reportEndEntities() )
+			return FALSE;
+		}
+		next();
+		break;
+	    case ChD1:
+		// on first call: clear string
+		if ( !d->contentCharDataRead ) {
+		    d->contentCharDataRead = TRUE;
+		    stringClear();
+		}
+		stringAddC();
+		if ( d->reportEntities ) {
+		    if ( !reportEndEntities() )
+			return FALSE;
+		}
+		next();
+		break;
+	    case ChD2:
+		stringAddC();
+		if ( d->reportEntities ) {
+		    if ( !reportEndEntities() )
+			return FALSE;
+		}
+		next();
+		break;
+	    case Ref:
+		if ( !d->contentCharDataRead) {
+		    // reference may be CharData; so clear string to be safe
+		    stringClear();
+		    d->parseReference_context = InContent;
+		    if ( !parseReference() ) {
+			parseFailed( &TQXmlSimpleReader::parseContent, state );
+			return FALSE;
+		    }
+		} else {
+		    if ( d->reportEntities ) {
+			// report character data in chunks
+			if ( contentHnd ) {
+			    if ( d->reportWhitespaceCharData || !string().simplifyWhiteSpace().isEmpty() ) {
+				if ( !contentHnd->characters( string() ) ) {
+				    reportParseError( contentHnd->errorString() );
+				    return FALSE;
+				}
+			    }
+			}
+			stringClear();
+		    }
+		    d->parseReference_context = InContent;
+		    if ( !parseReference() ) {
+			parseFailed( &TQXmlSimpleReader::parseContent, state );
+			return FALSE;
+		    }
+		}
+		break;
+	    case Lt:
+		// call the handler for CharData
+		if ( contentHnd ) {
+		    if ( d->contentCharDataRead ) {
+			if ( d->reportWhitespaceCharData || !string().simplifyWhiteSpace().isEmpty() ) {
+			    if ( !contentHnd->characters( string() ) ) {
+				reportParseError( contentHnd->errorString() );
+				return FALSE;
+			    }
+			}
+		    }
+		}
+		d->contentCharDataRead = FALSE;
+		next();
+		break;
+	    case PInstr:
+	    case PInstrR:
+		d->parsePI_xmldecl = FALSE;
+		if ( !parsePI() ) {
+		    parseFailed( &TQXmlSimpleReader::parseContent, state );
+		    return FALSE;
+		}
+		break;
+	    case Elem:
+		if ( !parseElement() ) {
+		    parseFailed( &TQXmlSimpleReader::parseContent, state );
+		    return FALSE;
+		}
+		break;
+	    case Em:
+		next();
+		break;
+	    case Com:
+	    case ComR:
+		if ( !parseComment() ) {
+		    parseFailed( &TQXmlSimpleReader::parseContent, state );
+		    return FALSE;
+		}
+		break;
+	    case CDS:
+		d->parseString_s = "[CDATA[";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseContent, state );
+		    return FALSE;
+		}
+		break;
+	    case CDS1:
+		stringAddC();
+		next();
+		break;
+	    case CDS2:
+		// skip ']'
+		next();
+		break;
+	    case CDS3:
+		// skip ']'...
+		next();
+		break;
+	}
+    }
+}
+bool TQXmlSimpleReader::reportEndEntities()
+{
+    int count = (int)d->xmlRef.count();
+    while ( count != 0 && d->xmlRef.top().isEmpty() ) {
+	if ( contentHnd ) {
+	    if ( d->reportWhitespaceCharData || !string().simplifyWhiteSpace().isEmpty() ) {
+		if ( !contentHnd->characters( string() ) ) {
+		    reportParseError( contentHnd->errorString() );
+		    return FALSE;
+		}
+	    }
+	}
+	stringClear();
+	if ( lexicalHnd ) {
+	    if ( !lexicalHnd->endEntity(d->xmlRefName.top()) ) {
+		reportParseError( lexicalHnd->errorString() );
+		return FALSE;
+	    }
+	}
+	d->xmlRef.pop_back();
+	d->xmlRefName.pop_back();
+	count--;
+    }
+    return TRUE;
+}
+
+/*
+  Parse Misc [27].
+*/
+bool TQXmlSimpleReader::parseMisc()
+{
+    const signed char Init             = 0;
+    const signed char Lt               = 1; // '<' was read
+    const signed char Comment          = 2; // read comment
+    const signed char eatWS            = 3; // eat whitespaces
+    const signed char PInstr           = 4; // read PI
+    const signed char Comment2         = 5; // read comment
+
+    const signed char InpWs            = 0; // S
+    const signed char InpLt            = 1; // <
+    const signed char InpQm            = 2; // ?
+    const signed char InpEm            = 3; // !
+    const signed char InpUnknown       = 4;
+
+    static const signed char table[3][5] = {
+     /*  InpWs   InpLt  InpQm  InpEm     InpUnknown */
+	{ eatWS,  Lt,    -1,    -1,       -1        }, // Init
+	{ -1,     -1,    PInstr,Comment,  -1        }, // Lt
+	{ -1,     -1,    -1,    -1,       Comment2  }  // Comment
+    };
+    signed char state;
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseMisc (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseMisc, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case eatWS:
+		return TRUE;
+	    case PInstr:
+		if ( contentHnd ) {
+		    if ( !contentHnd->processingInstruction(name(),string()) ) {
+			reportParseError( contentHnd->errorString() );
+			return FALSE;
+		    }
+		}
+		return TRUE;
+	    case Comment2:
+		if ( lexicalHnd ) {
+		    if ( !lexicalHnd->comment( string() ) ) {
+			reportParseError( lexicalHnd->errorString() );
+			return FALSE;
+		    }
+		}
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseMisc, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if ( c.unicode() == '<' ) {
+	    input = InpLt;
+	} else if ( c.unicode() == '?' ) {
+	    input = InpQm;
+	} else if ( c.unicode() == '!' ) {
+	    input = InpEm;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case eatWS:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseMisc, state );
+		    return FALSE;
+		}
+		break;
+	    case Lt:
+		next();
+		break;
+	    case PInstr:
+		d->parsePI_xmldecl = FALSE;
+		if ( !parsePI() ) {
+		    parseFailed( &TQXmlSimpleReader::parseMisc, state );
+		    return FALSE;
+		}
+		break;
+	    case Comment:
+		next();
+		break;
+	    case Comment2:
+		if ( !parseComment() ) {
+		    parseFailed( &TQXmlSimpleReader::parseMisc, state );
+		    return FALSE;
+		}
+		break;
+	}
+    }
+}
+
+/*
+  Parse a processing instruction [16].
+
+  If xmldec is TRUE, it tries to parse a PI or a XML declaration [23].
+
+  Precondition: the beginning '<' of the PI is already read and the head stand
+  on the '?' of '<?'.
+
+  If this funktion was successful, the head-position is on the first
+  character after the PI.
+*/
+bool TQXmlSimpleReader::parsePI()
+{
+    const signed char Init             =  0;
+    const signed char QmI              =  1; // ? was read
+    const signed char Name             =  2; // read Name
+    const signed char XMLDecl          =  3; // read XMLDecl
+    const signed char Ws1              =  4; // eat ws after "xml" of XMLDecl
+    const signed char PInstr           =  5; // read PI
+    const signed char Ws2              =  6; // eat ws after Name of PI
+    const signed char Version          =  7; // read versionInfo
+    const signed char Ws3              =  8; // eat ws after versionInfo
+    const signed char EorSD            =  9; // read EDecl or SDDecl
+    const signed char Ws4              = 10; // eat ws after EDecl or SDDecl
+    const signed char SD               = 11; // read SDDecl
+    const signed char Ws5              = 12; // eat ws after SDDecl
+    const signed char ADone            = 13; // almost done
+    const signed char Char             = 14; // Char was read
+    const signed char Qm               = 15; // Qm was read
+    const signed char Done             = 16; // finished reading content
+
+    const signed char InpWs            = 0; // whitespace
+    const signed char InpNameBe        = 1; // NameBeginning()
+    const signed char InpGt            = 2; // >
+    const signed char InpQm            = 3; // ?
+    const signed char InpUnknown       = 4;
+
+    static const signed char table[16][5] = {
+     /*  InpWs,  InpNameBe  InpGt  InpQm   InpUnknown  */
+	{ -1,     -1,        -1,    QmI,    -1     }, // Init
+	{ -1,     Name,      -1,    -1,     -1     }, // QmI
+	{ -1,     -1,        -1,    -1,     -1     }, // Name (this state is left not through input)
+	{ Ws1,    -1,        -1,    -1,     -1     }, // XMLDecl
+	{ -1,     Version,   -1,    -1,     -1     }, // Ws1
+	{ Ws2,    -1,        -1,    Qm,     -1     }, // PInstr
+	{ Char,   Char,      Char,  Qm,     Char   }, // Ws2
+	{ Ws3,    -1,        -1,    ADone,  -1     }, // Version
+	{ -1,     EorSD,     -1,    ADone,  -1     }, // Ws3
+	{ Ws4,    -1,        -1,    ADone,  -1     }, // EorSD
+	{ -1,     SD,        -1,    ADone,  -1     }, // Ws4
+	{ Ws5,    -1,        -1,    ADone,  -1     }, // SD
+	{ -1,     -1,        -1,    ADone,  -1     }, // Ws5
+	{ -1,     -1,        Done,  -1,     -1     }, // ADone
+	{ Char,   Char,      Char,  Qm,     Char   }, // Char
+	{ Char,   Char,      Done,  Qm,     Char   }, // Qm
+    };
+    signed char state;
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parsePI (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parsePI, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Name:
+		// test what name was read and determine the next state
+		// (not very beautiful, I admit)
+		if ( name().lower() == "xml" ) {
+		    if ( d->parsePI_xmldecl && name()=="xml" ) {
+			state = XMLDecl;
+		    } else {
+			reportParseError( XMLERR_INVALIDNAMEFORPI );
+			return FALSE;
+		    }
+		} else {
+		    state = PInstr;
+		    stringClear();
+		}
+		break;
+	    case Version:
+		// get version (syntax like an attribute)
+		if ( name() != "version" ) {
+		    reportParseError( XMLERR_VERSIONEXPECTED );
+		    return FALSE;
+		}
+		d->xmlVersion = string();
+		break;
+	    case EorSD:
+		// get the EDecl or SDDecl (syntax like an attribute)
+		if        ( name() == "standalone" ) {
+		    if ( string()=="yes" ) {
+			d->standalone = TQXmlSimpleReaderPrivate::Yes;
+		    } else if ( string()=="no" ) {
+			d->standalone = TQXmlSimpleReaderPrivate::No;
+		    } else {
+			reportParseError( XMLERR_WRONGVALUEFORSDECL );
+			return FALSE;
+		    }
+		} else if ( name() == "encoding" ) {
+		    d->encoding = string();
+		} else {
+		    reportParseError( XMLERR_EDECLORSDDECLEXPECTED );
+		    return FALSE;
+		}
+		break;
+	    case SD:
+		if ( name() != "standalone" ) {
+		    reportParseError( XMLERR_SDDECLEXPECTED );
+		    return FALSE;
+		}
+		if ( string()=="yes" ) {
+		    d->standalone = TQXmlSimpleReaderPrivate::Yes;
+		} else if ( string()=="no" ) {
+		    d->standalone = TQXmlSimpleReaderPrivate::No;
+		} else {
+		    reportParseError( XMLERR_WRONGVALUEFORSDECL );
+		    return FALSE;
+		}
+		break;
+	    case Qm:
+		// test if the skipping was legal
+		if ( !atEnd() && c.unicode() != '>' )
+		    stringAddC( '?' );
+		break;
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parsePI, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if (determineNameChar(c) == NameBeginning) {
+	    input = InpNameBe;
+	} else if ( c.unicode() == '>' ) {
+	    input = InpGt;
+	} else if ( c.unicode() == '?' ) {
+	    input = InpQm;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case QmI:
+		next();
+		break;
+	    case Name:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &TQXmlSimpleReader::parsePI, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws1:
+	    case Ws2:
+	    case Ws3:
+	    case Ws4:
+	    case Ws5:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parsePI, state );
+		    return FALSE;
+		}
+		break;
+	    case Version:
+		if ( !parseAttribute() ) {
+		    parseFailed( &TQXmlSimpleReader::parsePI, state );
+		    return FALSE;
+		}
+		break;
+	    case EorSD:
+		if ( !parseAttribute() ) {
+		    parseFailed( &TQXmlSimpleReader::parsePI, state );
+		    return FALSE;
+		}
+		break;
+	    case SD:
+		// get the SDDecl (syntax like an attribute)
+		if ( d->standalone != TQXmlSimpleReaderPrivate::Unknown ) {
+		    // already parsed the standalone declaration
+		    reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+		    return FALSE;
+		}
+		if ( !parseAttribute() ) {
+		    parseFailed( &TQXmlSimpleReader::parsePI, state );
+		    return FALSE;
+		}
+		break;
+	    case ADone:
+		next();
+		break;
+	    case Char:
+		stringAddC();
+		next();
+		break;
+	    case Qm:
+		// skip the '?'
+		next();
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a document type definition (doctypedecl [28]).
+
+  Precondition: the beginning '<!' of the doctype is already read the head
+  stands on the 'D' of '<!DOCTYPE'.
+
+  If this funktion was successful, the head-position is on the first
+  character after the document type definition.
+*/
+bool TQXmlSimpleReader::parseDoctype()
+{
+    const signed char Init             =  0;
+    const signed char Doctype          =  1; // read the doctype
+    const signed char Ws1              =  2; // eat_ws
+    const signed char Doctype2         =  3; // read the doctype, part 2
+    const signed char Ws2              =  4; // eat_ws
+    const signed char Sys              =  5; // read SYSTEM or PUBLIC
+    const signed char Ws3              =  6; // eat_ws
+    const signed char MP               =  7; // markupdecl or PEReference
+    const signed char MPR              =  8; // same as MP, but already reported
+    const signed char PER              =  9; // PERReference
+    const signed char Mup              = 10; // markupdecl
+    const signed char Ws4              = 11; // eat_ws
+    const signed char MPE              = 12; // end of markupdecl or PEReference
+    const signed char Done             = 13;
+
+    const signed char InpWs            = 0;
+    const signed char InpD             = 1; // 'D'
+    const signed char InpS             = 2; // 'S' or 'P'
+    const signed char InpOB            = 3; // [
+    const signed char InpCB            = 4; // ]
+    const signed char InpPer           = 5; // %
+    const signed char InpGt            = 6; // >
+    const signed char InpUnknown       = 7;
+
+    static const signed char table[13][8] = {
+     /*  InpWs,  InpD       InpS       InpOB  InpCB  InpPer InpGt  InpUnknown */
+	{ -1,     Doctype,   -1,        -1,    -1,    -1,    -1,    -1        }, // Init
+	{ Ws1,    -1,        -1,        -1,    -1,    -1,    -1,    -1        }, // Doctype
+	{ -1,     Doctype2,  Doctype2,  -1,    -1,    -1,    -1,    Doctype2  }, // Ws1
+	{ Ws2,    -1,        Sys,       MP,    -1,    -1,    Done,  -1        }, // Doctype2
+	{ -1,     -1,        Sys,       MP,    -1,    -1,    Done,  -1        }, // Ws2
+	{ Ws3,    -1,        -1,        MP,    -1,    -1,    Done,  -1        }, // Sys
+	{ -1,     -1,        -1,        MP,    -1,    -1,    Done,  -1        }, // Ws3
+	{ -1,     -1,        -1,        -1,    MPE,   PER,   -1,    Mup       }, // MP
+	{ -1,     -1,        -1,        -1,    MPE,   PER,   -1,    Mup       }, // MPR
+	{ Ws4,    -1,        -1,        -1,    MPE,   PER,   -1,    Mup       }, // PER
+	{ Ws4,    -1,        -1,        -1,    MPE,   PER,   -1,    Mup       }, // Mup
+	{ -1,     -1,        -1,        -1,    MPE,   PER,   -1,    Mup       }, // Ws4
+	{ -1,     -1,        -1,        -1,    -1,    -1,    Done,  -1        }  // MPE
+    };
+    signed char state;
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	d->startDTDwasReported = FALSE;
+	d->systemId = TQString::null;
+	d->publicId = TQString::null;
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseDoctype (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseDoctype, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Doctype2:
+		d->doctype = name();
+		break;
+	    case MP:
+		if ( !d->startDTDwasReported && lexicalHnd  ) {
+		    d->startDTDwasReported = TRUE;
+		    if ( !lexicalHnd->startDTD( d->doctype, d->publicId, d->systemId ) ) {
+			reportParseError( lexicalHnd->errorString() );
+			return FALSE;
+		    }
+		}
+		state = MPR;
+		break;
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_ERRORPARSINGDOCTYPE );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseDoctype, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if ( c.unicode() == 'D' ) {
+	    input = InpD;
+	} else if ( c.unicode() == 'S' ) {
+	    input = InpS;
+	} else if ( c.unicode() == 'P' ) {
+	    input = InpS;
+	} else if ( c.unicode() == '[' ) {
+	    input = InpOB;
+	} else if ( c.unicode() == ']' ) {
+	    input = InpCB;
+	} else if ( c.unicode() == '%' ) {
+	    input = InpPer;
+	} else if ( c.unicode() == '>' ) {
+	    input = InpGt;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Doctype:
+		d->parseString_s = "DOCTYPE";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseDoctype, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws1:
+	    case Ws2:
+	    case Ws3:
+	    case Ws4:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseDoctype, state );
+		    return FALSE;
+		}
+		break;
+	    case Doctype2:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &TQXmlSimpleReader::parseDoctype, state );
+		    return FALSE;
+		}
+		break;
+	    case Sys:
+		d->parseExternalID_allowPublicID = FALSE;
+		if ( !parseExternalID() ) {
+		    parseFailed( &TQXmlSimpleReader::parseDoctype, state );
+		    return FALSE;
+		}
+		break;
+	    case MP:
+	    case MPR:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseDoctype, state );
+		    return FALSE;
+		}
+		break;
+	    case PER:
+		d->parsePEReference_context = InDTD;
+		if ( !parsePEReference() ) {
+		    parseFailed( &TQXmlSimpleReader::parseDoctype, state );
+		    return FALSE;
+		}
+		break;
+	    case Mup:
+		if ( !parseMarkupdecl() ) {
+		    parseFailed( &TQXmlSimpleReader::parseDoctype, state );
+		    return FALSE;
+		}
+		break;
+	    case MPE:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseDoctype, state );
+		    return FALSE;
+		}
+		break;
+	    case Done:
+		if ( lexicalHnd ) {
+		    if ( !d->startDTDwasReported ) {
+			d->startDTDwasReported = TRUE;
+			if ( !lexicalHnd->startDTD( d->doctype, d->publicId, d->systemId ) ) {
+			    reportParseError( lexicalHnd->errorString() );
+			    return FALSE;
+			}
+		    }
+		    if ( !lexicalHnd->endDTD() ) {
+			reportParseError( lexicalHnd->errorString() );
+			return FALSE;
+		    }
+		}
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a ExternalID [75].
+
+  If allowPublicID is TRUE parse ExternalID [75] or PublicID [83].
+*/
+bool TQXmlSimpleReader::parseExternalID()
+{
+    const signed char Init             =  0;
+    const signed char Sys              =  1; // parse 'SYSTEM'
+    const signed char SysWS            =  2; // parse the whitespace after 'SYSTEM'
+    const signed char SysSQ            =  3; // parse SystemLiteral with '
+    const signed char SysSQ2           =  4; // parse SystemLiteral with '
+    const signed char SysDQ            =  5; // parse SystemLiteral with "
+    const signed char SysDQ2           =  6; // parse SystemLiteral with "
+    const signed char Pub              =  7; // parse 'PUBLIC'
+    const signed char PubWS            =  8; // parse the whitespace after 'PUBLIC'
+    const signed char PubSQ            =  9; // parse PubidLiteral with '
+    const signed char PubSQ2           = 10; // parse PubidLiteral with '
+    const signed char PubDQ            = 11; // parse PubidLiteral with "
+    const signed char PubDQ2           = 12; // parse PubidLiteral with "
+    const signed char PubE             = 13; // finished parsing the PubidLiteral
+    const signed char PubWS2           = 14; // parse the whitespace after the PubidLiteral
+    const signed char PDone            = 15; // done if allowPublicID is TRUE
+    const signed char Done             = 16;
+
+    const signed char InpSQ            = 0; // '
+    const signed char InpDQ            = 1; // "
+    const signed char InpS             = 2; // S
+    const signed char InpP             = 3; // P
+    const signed char InpWs            = 4; // white space
+    const signed char InpUnknown       = 5;
+
+    static const signed char table[15][6] = {
+     /*  InpSQ    InpDQ    InpS     InpP     InpWs     InpUnknown */
+	{ -1,      -1,      Sys,     Pub,     -1,       -1      }, // Init
+	{ -1,      -1,      -1,      -1,      SysWS,    -1      }, // Sys
+	{ SysSQ,   SysDQ,   -1,      -1,      -1,       -1      }, // SysWS
+	{ Done,    SysSQ2,  SysSQ2,  SysSQ2,  SysSQ2,   SysSQ2  }, // SysSQ
+	{ Done,    SysSQ2,  SysSQ2,  SysSQ2,  SysSQ2,   SysSQ2  }, // SysSQ2
+	{ SysDQ2,  Done,    SysDQ2,  SysDQ2,  SysDQ2,   SysDQ2  }, // SysDQ
+	{ SysDQ2,  Done,    SysDQ2,  SysDQ2,  SysDQ2,   SysDQ2  }, // SysDQ2
+	{ -1,      -1,      -1,      -1,      PubWS,    -1      }, // Pub
+	{ PubSQ,   PubDQ,   -1,      -1,      -1,       -1      }, // PubWS
+	{ PubE,    -1,      PubSQ2,  PubSQ2,  PubSQ2,   PubSQ2  }, // PubSQ
+	{ PubE,    -1,      PubSQ2,  PubSQ2,  PubSQ2,   PubSQ2  }, // PubSQ2
+	{ -1,      PubE,    PubDQ2,  PubDQ2,  PubDQ2,   PubDQ2  }, // PubDQ
+	{ -1,      PubE,    PubDQ2,  PubDQ2,  PubDQ2,   PubDQ2  }, // PubDQ2
+	{ PDone,   PDone,   PDone,   PDone,   PubWS2,   PDone   }, // PubE
+	{ SysSQ,   SysDQ,   PDone,   PDone,   PDone,    PDone   }  // PubWS2
+    };
+    signed char state;
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	d->systemId = TQString::null;
+	d->publicId = TQString::null;
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseExternalID (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseExternalID, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case PDone:
+		if ( d->parseExternalID_allowPublicID ) {
+		    d->publicId = string();
+		    return TRUE;
+		} else {
+		    reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+		    return FALSE;
+		}
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseExternalID, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if ( c.unicode() == '\'' ) {
+	    input = InpSQ;
+	} else if ( c.unicode() == '"' ) {
+	    input = InpDQ;
+	} else if ( c.unicode() == 'S' ) {
+	    input = InpS;
+	} else if ( c.unicode() == 'P' ) {
+	    input = InpP;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Sys:
+		d->parseString_s = "SYSTEM";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseExternalID, state );
+		    return FALSE;
+		}
+		break;
+	    case SysWS:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseExternalID, state );
+		    return FALSE;
+		}
+		break;
+	    case SysSQ:
+	    case SysDQ:
+		stringClear();
+		next();
+		break;
+	    case SysSQ2:
+	    case SysDQ2:
+		stringAddC();
+		next();
+		break;
+	    case Pub:
+		d->parseString_s = "PUBLIC";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseExternalID, state );
+		    return FALSE;
+		}
+		break;
+	    case PubWS:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseExternalID, state );
+		    return FALSE;
+		}
+		break;
+	    case PubSQ:
+	    case PubDQ:
+		stringClear();
+		next();
+		break;
+	    case PubSQ2:
+	    case PubDQ2:
+		stringAddC();
+		next();
+		break;
+	    case PubE:
+		next();
+		break;
+	    case PubWS2:
+		d->publicId = string();
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseExternalID, state );
+		    return FALSE;
+		}
+		break;
+	    case Done:
+		d->systemId = string();
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a markupdecl [29].
+*/
+bool TQXmlSimpleReader::parseMarkupdecl()
+{
+    const signed char Init             = 0;
+    const signed char Lt               = 1; // < was read
+    const signed char Em               = 2; // ! was read
+    const signed char CE               = 3; // E was read
+    const signed char Qm               = 4; // ? was read
+    const signed char Dash             = 5; // - was read
+    const signed char CA               = 6; // A was read
+    const signed char CEL              = 7; // EL was read
+    const signed char CEN              = 8; // EN was read
+    const signed char CN               = 9; // N was read
+    const signed char Done             = 10;
+
+    const signed char InpLt            = 0; // <
+    const signed char InpQm            = 1; // ?
+    const signed char InpEm            = 2; // !
+    const signed char InpDash          = 3; // -
+    const signed char InpA             = 4; // A
+    const signed char InpE             = 5; // E
+    const signed char InpL             = 6; // L
+    const signed char InpN             = 7; // N
+    const signed char InpUnknown       = 8;
+
+    static const signed char table[4][9] = {
+     /*  InpLt  InpQm  InpEm  InpDash  InpA   InpE   InpL   InpN   InpUnknown */
+	{ Lt,    -1,    -1,    -1,      -1,    -1,    -1,    -1,    -1     }, // Init
+	{ -1,    Qm,    Em,    -1,      -1,    -1,    -1,    -1,    -1     }, // Lt
+	{ -1,    -1,    -1,    Dash,    CA,    CE,    -1,    CN,    -1     }, // Em
+	{ -1,    -1,    -1,    -1,      -1,    -1,    CEL,   CEN,   -1     }  // CE
+    };
+    signed char state;
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseMarkupdecl (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseMarkupdecl, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Qm:
+		if ( contentHnd ) {
+		    if ( !contentHnd->processingInstruction(name(),string()) ) {
+			reportParseError( contentHnd->errorString() );
+			return FALSE;
+		    }
+		}
+		return TRUE;
+	    case Dash:
+		if ( lexicalHnd ) {
+		    if ( !lexicalHnd->comment( string() ) ) {
+			reportParseError( lexicalHnd->errorString() );
+			return FALSE;
+		    }
+		}
+		return TRUE;
+	    case CA:
+		return TRUE;
+	    case CEL:
+		return TRUE;
+	    case CEN:
+		return TRUE;
+	    case CN:
+		return TRUE;
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_LETTEREXPECTED );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseMarkupdecl, state );
+	    return FALSE;
+	}
+	if        ( c.unicode() == '<' ) {
+	    input = InpLt;
+	} else if ( c.unicode() == '?' ) {
+	    input = InpQm;
+	} else if ( c.unicode() == '!' ) {
+	    input = InpEm;
+	} else if ( c.unicode() == '-' ) {
+	    input = InpDash;
+	} else if ( c.unicode() == 'A' ) {
+	    input = InpA;
+	} else if ( c.unicode() == 'E' ) {
+	    input = InpE;
+	} else if ( c.unicode() == 'L' ) {
+	    input = InpL;
+	} else if ( c.unicode() == 'N' ) {
+	    input = InpN;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Lt:
+		next();
+		break;
+	    case Em:
+		next();
+		break;
+	    case CE:
+		next();
+		break;
+	    case Qm:
+		d->parsePI_xmldecl = FALSE;
+		if ( !parsePI() ) {
+		    parseFailed( &TQXmlSimpleReader::parseMarkupdecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Dash:
+		if ( !parseComment() ) {
+		    parseFailed( &TQXmlSimpleReader::parseMarkupdecl, state );
+		    return FALSE;
+		}
+		break;
+	    case CA:
+		if ( !parseAttlistDecl() ) {
+		    parseFailed( &TQXmlSimpleReader::parseMarkupdecl, state );
+		    return FALSE;
+		}
+		break;
+	    case CEL:
+		if ( !parseElementDecl() ) {
+		    parseFailed( &TQXmlSimpleReader::parseMarkupdecl, state );
+		    return FALSE;
+		}
+		break;
+	    case CEN:
+		if ( !parseEntityDecl() ) {
+		    parseFailed( &TQXmlSimpleReader::parseMarkupdecl, state );
+		    return FALSE;
+		}
+		break;
+	    case CN:
+		if ( !parseNotationDecl() ) {
+		    parseFailed( &TQXmlSimpleReader::parseMarkupdecl, state );
+		    return FALSE;
+		}
+		break;
+	}
+    }
+}
+
+/*
+  Parse a PEReference [69]
+*/
+bool TQXmlSimpleReader::parsePEReference()
+{
+    const signed char Init             = 0;
+    const signed char Next             = 1;
+    const signed char Name             = 2;
+    const signed char NameR            = 3; // same as Name, but already reported
+    const signed char Done             = 4;
+
+    const signed char InpSemi          = 0; // ;
+    const signed char InpPer           = 1; // %
+    const signed char InpUnknown       = 2;
+
+    static const signed char table[4][3] = {
+     /*  InpSemi  InpPer  InpUnknown */
+	{ -1,      Next,   -1    }, // Init
+	{ -1,      -1,     Name  }, // Next
+	{ Done,    -1,     -1    }, // Name
+	{ Done,    -1,     -1    }  // NameR
+    };
+    signed char state;
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parsePEReference (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parsePEReference, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Name:
+		{
+		    bool skipIt = TRUE;
+		    TQString xmlRefString;
+
+		    TQMap<TQString,TQString>::Iterator it;
+		    it = d->parameterEntities.find( ref() );
+		    if ( it != d->parameterEntities.end() ) {
+			skipIt = FALSE;
+			xmlRefString = it.data();
+		    } else if ( entityRes ) {
+			TQMap<TQString,TQXmlSimpleReaderPrivate::ExternParameterEntity>::Iterator it2;
+			it2 = d->externParameterEntities.find( ref() );
+			TQXmlInputSource *ret = 0;
+			if ( it2 != d->externParameterEntities.end() ) {
+			    if ( !entityRes->resolveEntity( it2.data().publicId, it2.data().systemId, ret ) ) {
+				delete ret;
+				reportParseError( entityRes->errorString() );
+				return FALSE;
+			    }
+			    if ( ret ) {
+				xmlRefString = ret->data();
+				delete ret;
+				if ( !stripTextDecl( xmlRefString ) ) {
+				    reportParseError( XMLERR_ERRORINTEXTDECL );
+				    return FALSE;
+				}
+				skipIt = FALSE;
+			    }
+			}
+		    }
+
+		    if ( skipIt ) {
+			if ( contentHnd ) {
+			    if ( !contentHnd->skippedEntity( TQString("%") + ref() ) ) {
+				reportParseError( contentHnd->errorString() );
+				return FALSE;
+			    }
+			}
+		    } else {
+			if ( d->parsePEReference_context == InEntityValue ) {
+			    // Included in literal
+			    if ( !insertXmlRef( xmlRefString, ref(), TRUE ) )
+				return FALSE;
+			} else if ( d->parsePEReference_context == InDTD ) {
+			    // Included as PE
+			    if ( !insertXmlRef( TQString(" ")+xmlRefString+TQString(" "), ref(), FALSE ) )
+				return FALSE;
+			}
+		    }
+		}
+		state = NameR;
+		break;
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_LETTEREXPECTED );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parsePEReference, state );
+	    return FALSE;
+	}
+	if        ( c.unicode() == ';' ) {
+	    input = InpSemi;
+	} else if ( c.unicode() == '%' ) {
+	    input = InpPer;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Next:
+		next();
+		break;
+	    case Name:
+	    case NameR:
+		d->parseName_useRef = TRUE;
+		if ( !parseName() ) {
+		    parseFailed( &TQXmlSimpleReader::parsePEReference, state );
+		    return FALSE;
+		}
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a AttlistDecl [52].
+
+  Precondition: the beginning '<!' is already read and the head
+  stands on the 'A' of '<!ATTLIST'
+*/
+bool TQXmlSimpleReader::parseAttlistDecl()
+{
+    const signed char Init             =  0;
+    const signed char Attlist          =  1; // parse the string "ATTLIST"
+    const signed char Ws               =  2; // whitespace read
+    const signed char Name             =  3; // parse name
+    const signed char Ws1              =  4; // whitespace read
+    const signed char Attdef           =  5; // parse the AttDef
+    const signed char Ws2              =  6; // whitespace read
+    const signed char Atttype          =  7; // parse the AttType
+    const signed char Ws3              =  8; // whitespace read
+    const signed char DDecH            =  9; // DefaultDecl with #
+    const signed char DefReq           = 10; // parse the string "RETQUIRED"
+    const signed char DefImp           = 11; // parse the string "IMPLIED"
+    const signed char DefFix           = 12; // parse the string "FIXED"
+    const signed char Attval           = 13; // parse the AttValue
+    const signed char Ws4              = 14; // whitespace read
+    const signed char Done             = 15;
+
+    const signed char InpWs            = 0; // white space
+    const signed char InpGt            = 1; // >
+    const signed char InpHash          = 2; // #
+    const signed char InpA             = 3; // A
+    const signed char InpI             = 4; // I
+    const signed char InpF             = 5; // F
+    const signed char InpR             = 6; // R
+    const signed char InpUnknown       = 7;
+
+    static const signed char table[15][8] = {
+     /*  InpWs    InpGt    InpHash  InpA      InpI     InpF     InpR     InpUnknown */
+	{ -1,      -1,      -1,      Attlist,  -1,      -1,      -1,      -1      }, // Init
+	{ Ws,      -1,      -1,      -1,       -1,      -1,      -1,      -1      }, // Attlist
+	{ -1,      -1,      -1,      Name,     Name,    Name,    Name,    Name    }, // Ws
+	{ Ws1,     Done,    Attdef,  Attdef,   Attdef,  Attdef,  Attdef,  Attdef  }, // Name
+	{ -1,      Done,    Attdef,  Attdef,   Attdef,  Attdef,  Attdef,  Attdef  }, // Ws1
+	{ Ws2,     -1,      -1,      -1,       -1,      -1,      -1,      -1      }, // Attdef
+	{ -1,      Atttype, Atttype, Atttype,  Atttype, Atttype, Atttype, Atttype }, // Ws2
+	{ Ws3,     -1,      -1,      -1,       -1,      -1,      -1,      -1      }, // Attype
+	{ -1,      Attval,  DDecH,   Attval,   Attval,  Attval,  Attval,  Attval  }, // Ws3
+	{ -1,      -1,      -1,      -1,       DefImp,  DefFix,  DefReq,  -1      }, // DDecH
+	{ Ws4,     Ws4,     -1,      -1,       -1,      -1,      -1,      -1      }, // DefReq
+	{ Ws4,     Ws4,     -1,      -1,       -1,      -1,      -1,      -1      }, // DefImp
+	{ Ws3,     -1,      -1,      -1,       -1,      -1,      -1,      -1      }, // DefFix
+	{ Ws4,     Ws4,     -1,      -1,       -1,      -1,      -1,      -1      }, // Attval
+	{ -1,      Done,    Attdef,  Attdef,   Attdef,  Attdef,  Attdef,  Attdef  }  // Ws4
+    };
+    signed char state;
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseAttlistDecl (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Name:
+		d->attDeclEName = name();
+		break;
+	    case Attdef:
+		d->attDeclAName = name();
+		break;
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_LETTEREXPECTED );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseAttlistDecl, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if ( c.unicode() == '>' ) {
+	    input = InpGt;
+	} else if ( c.unicode() == '#' ) {
+	    input = InpHash;
+	} else if ( c.unicode() == 'A' ) {
+	    input = InpA;
+	} else if ( c.unicode() == 'I' ) {
+	    input = InpI;
+	} else if ( c.unicode() == 'F' ) {
+	    input = InpF;
+	} else if ( c.unicode() == 'R' ) {
+	    input = InpR;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Attlist:
+		d->parseString_s = "ATTLIST";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws:
+	    case Ws1:
+	    case Ws2:
+	    case Ws3:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Name:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Attdef:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Atttype:
+		if ( !parseAttType() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case DDecH:
+		next();
+		break;
+	    case DefReq:
+		d->parseString_s = "RETQUIRED";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case DefImp:
+		d->parseString_s = "IMPLIED";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case DefFix:
+		d->parseString_s = "FIXED";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Attval:
+		if ( !parseAttValue() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws4:
+		if ( declHnd ) {
+		    // ### not all values are computed yet...
+		    if ( !declHnd->attributeDecl( d->attDeclEName, d->attDeclAName, "", "", "" ) ) {
+			reportParseError( declHnd->errorString() );
+			return FALSE;
+		    }
+		}
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a AttType [54]
+*/
+bool TQXmlSimpleReader::parseAttType()
+{
+    const signed char Init             =  0;
+    const signed char ST               =  1; // StringType
+    const signed char TTI              =  2; // TokenizedType starting with 'I'
+    const signed char TTI2             =  3; // TokenizedType helpstate
+    const signed char TTI3             =  4; // TokenizedType helpstate
+    const signed char TTE              =  5; // TokenizedType starting with 'E'
+    const signed char TTEY             =  6; // TokenizedType starting with 'ENTITY'
+    const signed char TTEI             =  7; // TokenizedType starting with 'ENTITI'
+    const signed char N                =  8; // N read (TokenizedType or Notation)
+    const signed char TTNM             =  9; // TokenizedType starting with 'NM'
+    const signed char TTNM2            = 10; // TokenizedType helpstate
+    const signed char NO               = 11; // Notation
+    const signed char NO2              = 12; // Notation helpstate
+    const signed char NO3              = 13; // Notation helpstate
+    const signed char NOName           = 14; // Notation, read name
+    const signed char NO4              = 15; // Notation helpstate
+    const signed char EN               = 16; // Enumeration
+    const signed char ENNmt            = 17; // Enumeration, read Nmtoken
+    const signed char EN2              = 18; // Enumeration helpstate
+    const signed char ADone            = 19; // almost done (make next and accept)
+    const signed char Done             = 20;
+
+    const signed char InpWs            =  0; // whitespace
+    const signed char InpOp            =  1; // (
+    const signed char InpCp            =  2; // )
+    const signed char InpPipe          =  3; // |
+    const signed char InpC             =  4; // C
+    const signed char InpE             =  5; // E
+    const signed char InpI             =  6; // I
+    const signed char InpM             =  7; // M
+    const signed char InpN             =  8; // N
+    const signed char InpO             =  9; // O
+    const signed char InpR             = 10; // R
+    const signed char InpS             = 11; // S
+    const signed char InpY             = 12; // Y
+    const signed char InpUnknown       = 13;
+
+    static const signed char table[19][14] = {
+     /*  InpWs    InpOp    InpCp    InpPipe  InpC     InpE     InpI     InpM     InpN     InpO     InpR     InpS     InpY     InpUnknown */
+	{ -1,      EN,      -1,      -1,      ST,      TTE,     TTI,     -1,      N,       -1,      -1,      -1,      -1,      -1     }, // Init
+	{ Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done   }, // ST
+	{ Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    TTI2,    Done,    Done,    Done   }, // TTI
+	{ Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    TTI3,    Done,    Done   }, // TTI2
+	{ Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done   }, // TTI3
+	{ -1,      -1,      -1,      -1,      -1,      -1,      TTEI,    -1,      -1,      -1,      -1,      -1,      TTEY,    -1     }, // TTE
+	{ Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done   }, // TTEY
+	{ Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done   }, // TTEI
+	{ -1,      -1,      -1,      -1,      -1,      -1,      -1,      TTNM,    -1,      NO,      -1,      -1,      -1,      -1     }, // N
+	{ Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    TTNM2,   Done,    Done   }, // TTNM
+	{ Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done   }, // TTNM2
+	{ NO2,     -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1     }, // NO
+	{ -1,      NO3,     -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1     }, // NO2
+	{ NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName }, // NO3
+	{ NO4,     -1,      ADone,   NO3,     -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1     }, // NOName
+	{ -1,      -1,      ADone,   NO3,     -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1     }, // NO4
+	{ -1,      -1,      ENNmt,   -1,      ENNmt,   ENNmt,   ENNmt,   ENNmt,   ENNmt,   ENNmt,   ENNmt,   ENNmt,   ENNmt,   ENNmt  }, // EN
+	{ EN2,     -1,      ADone,   EN,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1     }, // ENNmt
+	{ -1,      -1,      ADone,   EN,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1     }  // EN2
+    };
+    signed char state;
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseAttType (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseAttType, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case ADone:
+		return TRUE;
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_LETTEREXPECTED );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseAttType, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if ( c.unicode() == '(' ) {
+	    input = InpOp;
+	} else if ( c.unicode() == ')' ) {
+	    input = InpCp;
+	} else if ( c.unicode() == '|' ) {
+	    input = InpPipe;
+	} else if ( c.unicode() == 'C' ) {
+	    input = InpC;
+	} else if ( c.unicode() == 'E' ) {
+	    input = InpE;
+	} else if ( c.unicode() == 'I' ) {
+	    input = InpI;
+	} else if ( c.unicode() == 'M' ) {
+	    input = InpM;
+	} else if ( c.unicode() == 'N' ) {
+	    input = InpN;
+	} else if ( c.unicode() == 'O' ) {
+	    input = InpO;
+	} else if ( c.unicode() == 'R' ) {
+	    input = InpR;
+	} else if ( c.unicode() == 'S' ) {
+	    input = InpS;
+	} else if ( c.unicode() == 'Y' ) {
+	    input = InpY;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case ST:
+		d->parseString_s = "CDATA";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case TTI:
+		d->parseString_s = "ID";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case TTI2:
+		d->parseString_s = "REF";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case TTI3:
+		next(); // S
+		break;
+	    case TTE:
+		d->parseString_s = "ENTIT";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case TTEY:
+		next(); // Y
+		break;
+	    case TTEI:
+		d->parseString_s = "IES";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case N:
+		next(); // N
+		break;
+	    case TTNM:
+		d->parseString_s = "MTOKEN";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case TTNM2:
+		next(); // S
+		break;
+	    case NO:
+		d->parseString_s = "OTATION";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case NO2:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case NO3:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case NOName:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case NO4:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case EN:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case ENNmt:
+		if ( !parseNmtoken() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case EN2:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case ADone:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a AttValue [10]
+
+  Precondition: the head stands on the beginning " or '
+
+  If this function was successful, the head stands on the first
+  character after the closing " or ' and the value of the attribute
+  is in string().
+*/
+bool TQXmlSimpleReader::parseAttValue()
+{
+    const signed char Init             = 0;
+    const signed char Dq               = 1; // double quotes were read
+    const signed char DqRef            = 2; // read references in double quotes
+    const signed char DqC              = 3; // signed character read in double quotes
+    const signed char Sq               = 4; // single quotes were read
+    const signed char SqRef            = 5; // read references in single quotes
+    const signed char SqC              = 6; // signed character read in single quotes
+    const signed char Done             = 7;
+
+    const signed char InpDq            = 0; // "
+    const signed char InpSq            = 1; // '
+    const signed char InpAmp           = 2; // &
+    const signed char InpLt            = 3; // <
+    const signed char InpUnknown       = 4;
+
+    static const signed char table[7][5] = {
+     /*  InpDq  InpSq  InpAmp  InpLt InpUnknown */
+	{ Dq,    Sq,    -1,     -1,   -1    }, // Init
+	{ Done,  DqC,   DqRef,  -1,   DqC   }, // Dq
+	{ Done,  DqC,   DqRef,  -1,   DqC   }, // DqRef
+	{ Done,  DqC,   DqRef,  -1,   DqC   }, // DqC
+	{ SqC,   Done,  SqRef,  -1,   SqC   }, // Sq
+	{ SqC,   Done,  SqRef,  -1,   SqC   }, // SqRef
+	{ SqC,   Done,  SqRef,  -1,   SqC   }  // SqRef
+    };
+    signed char state;
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseAttValue (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseAttValue, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseAttValue, state );
+	    return FALSE;
+	}
+	if        ( c.unicode() == '"' ) {
+	    input = InpDq;
+	} else if ( c.unicode() == '\'' ) {
+	    input = InpSq;
+	} else if ( c.unicode() == '&' ) {
+	    input = InpAmp;
+	} else if ( c.unicode() == '<' ) {
+	    input = InpLt;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Dq:
+	    case Sq:
+		stringClear();
+		next();
+		break;
+	    case DqRef:
+	    case SqRef:
+		d->parseReference_context = InAttributeValue;
+		if ( !parseReference() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttValue, state );
+		    return FALSE;
+		}
+		break;
+	    case DqC:
+	    case SqC:
+		stringAddC();
+		next();
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a elementdecl [45].
+
+  Precondition: the beginning '<!E' is already read and the head
+  stands on the 'L' of '<!ELEMENT'
+*/
+bool TQXmlSimpleReader::parseElementDecl()
+{
+    const signed char Init             =  0;
+    const signed char Elem             =  1; // parse the beginning string
+    const signed char Ws1              =  2; // whitespace retquired
+    const signed char Nam              =  3; // parse Name
+    const signed char Ws2              =  4; // whitespace retquired
+    const signed char Empty            =  5; // read EMPTY
+    const signed char Any              =  6; // read ANY
+    const signed char Cont             =  7; // read contentspec (except ANY or EMPTY)
+    const signed char Mix              =  8; // read Mixed
+    const signed char Mix2             =  9; //
+    const signed char Mix3             = 10; //
+    const signed char MixN1            = 11; //
+    const signed char MixN2            = 12; //
+    const signed char MixN3            = 13; //
+    const signed char MixN4            = 14; //
+    const signed char Cp               = 15; // parse cp
+    const signed char Cp2              = 16; //
+    const signed char WsD              = 17; // eat whitespace before Done
+    const signed char Done             = 18;
+
+    const signed char InpWs            =  0;
+    const signed char InpGt            =  1; // >
+    const signed char InpPipe          =  2; // |
+    const signed char InpOp            =  3; // (
+    const signed char InpCp            =  4; // )
+    const signed char InpHash          =  5; // #
+    const signed char InpQm            =  6; // ?
+    const signed char InpAst           =  7; // *
+    const signed char InpPlus          =  8; // +
+    const signed char InpA             =  9; // A
+    const signed char InpE             = 10; // E
+    const signed char InpL             = 11; // L
+    const signed char InpUnknown       = 12;
+
+    static const signed char table[18][13] = {
+     /*  InpWs   InpGt  InpPipe  InpOp  InpCp   InpHash  InpQm  InpAst  InpPlus  InpA    InpE    InpL    InpUnknown */
+	{ -1,     -1,    -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     Elem,   -1     }, // Init
+	{ Ws1,    -1,    -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Elem
+	{ -1,     -1,    -1,      -1,    -1,     -1,      -1,    -1,     -1,      Nam,    Nam,    Nam,    Nam    }, // Ws1
+	{ Ws2,    -1,    -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Nam
+	{ -1,     -1,    -1,      Cont,  -1,     -1,      -1,    -1,     -1,      Any,    Empty,  -1,     -1     }, // Ws2
+	{ WsD,    Done,  -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Empty
+	{ WsD,    Done,  -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Any
+	{ -1,     -1,    -1,      Cp,    Cp,     Mix,     -1,    -1,     -1,      Cp,     Cp,     Cp,     Cp     }, // Cont
+	{ Mix2,   -1,    MixN1,   -1,    Mix3,   -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Mix
+	{ -1,     -1,    MixN1,   -1,    Mix3,   -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Mix2
+	{ WsD,    Done,  -1,      -1,    -1,     -1,      -1,    WsD,    -1,      -1,     -1,     -1,     -1     }, // Mix3
+	{ -1,     -1,    -1,      -1,    -1,     -1,      -1,    -1,     -1,      MixN2,  MixN2,  MixN2,  MixN2  }, // MixN1
+	{ MixN3,  -1,    MixN1,   -1,    MixN4,  -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // MixN2
+	{ -1,     -1,    MixN1,   -1,    MixN4,  -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // MixN3
+	{ -1,     -1,    -1,      -1,    -1,     -1,      -1,    WsD,    -1,      -1,     -1,     -1,     -1     }, // MixN4
+	{ WsD,    Done,  -1,      -1,    -1,     -1,      Cp2,   Cp2,    Cp2,     -1,     -1,     -1,     -1     }, // Cp
+	{ WsD,    Done,  -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Cp2
+	{ -1,     Done,  -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }  // WsD
+    };
+    signed char state;
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseElementDecl (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseElementDecl, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Done:
+		return TRUE;
+	    case -1:
+		reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseElementDecl, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if ( c.unicode() == '>' ) {
+	    input = InpGt;
+	} else if ( c.unicode() == '|' ) {
+	    input = InpPipe;
+	} else if ( c.unicode() == '(' ) {
+	    input = InpOp;
+	} else if ( c.unicode() == ')' ) {
+	    input = InpCp;
+	} else if ( c.unicode() == '#' ) {
+	    input = InpHash;
+	} else if ( c.unicode() == '?' ) {
+	    input = InpQm;
+	} else if ( c.unicode() == '*' ) {
+	    input = InpAst;
+	} else if ( c.unicode() == '+' ) {
+	    input = InpPlus;
+	} else if ( c.unicode() == 'A' ) {
+	    input = InpA;
+	} else if ( c.unicode() == 'E' ) {
+	    input = InpE;
+	} else if ( c.unicode() == 'L' ) {
+	    input = InpL;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Elem:
+		d->parseString_s = "LEMENT";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws1:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Nam:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &TQXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws2:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Empty:
+		d->parseString_s = "EMPTY";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Any:
+		d->parseString_s = "ANY";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Cont:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Mix:
+		d->parseString_s = "#PCDATA";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Mix2:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Mix3:
+		next();
+		break;
+	    case MixN1:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case MixN2:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &TQXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case MixN3:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case MixN4:
+		next();
+		break;
+	    case Cp:
+		if ( !parseChoiceSeq() ) {
+		    parseFailed( &TQXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Cp2:
+		next();
+		break;
+	    case WsD:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a NotationDecl [82].
+
+  Precondition: the beginning '<!' is already read and the head
+  stands on the 'N' of '<!NOTATION'
+*/
+bool TQXmlSimpleReader::parseNotationDecl()
+{
+    const signed char Init             = 0;
+    const signed char Not              = 1; // read NOTATION
+    const signed char Ws1              = 2; // eat whitespaces
+    const signed char Nam              = 3; // read Name
+    const signed char Ws2              = 4; // eat whitespaces
+    const signed char ExtID            = 5; // parse ExternalID
+    const signed char ExtIDR           = 6; // same as ExtID, but already reported
+    const signed char Ws3              = 7; // eat whitespaces
+    const signed char Done             = 8;
+
+    const signed char InpWs            = 0;
+    const signed char InpGt            = 1; // >
+    const signed char InpN             = 2; // N
+    const signed char InpUnknown       = 3;
+
+    static const signed char table[8][4] = {
+     /*  InpWs   InpGt  InpN    InpUnknown */
+	{ -1,     -1,    Not,    -1     }, // Init
+	{ Ws1,    -1,    -1,     -1     }, // Not
+	{ -1,     -1,    Nam,    Nam    }, // Ws1
+	{ Ws2,    Done,  -1,     -1     }, // Nam
+	{ -1,     Done,  ExtID,  ExtID  }, // Ws2
+	{ Ws3,    Done,  -1,     -1     }, // ExtID
+	{ Ws3,    Done,  -1,     -1     }, // ExtIDR
+	{ -1,     Done,  -1,     -1     }  // Ws3
+    };
+    signed char state;
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseNotationDecl (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseNotationDecl, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case ExtID:
+		// call the handler
+		if ( dtdHnd ) {
+		    if ( !dtdHnd->notationDecl( name(), d->publicId, d->systemId ) ) {
+			reportParseError( dtdHnd->errorString() );
+			return FALSE;
+		    }
+		}
+		state = ExtIDR;
+		break;
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseNotationDecl, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if ( c.unicode() == '>' ) {
+	    input = InpGt;
+	} else if ( c.unicode() == 'N' ) {
+	    input = InpN;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Not:
+		d->parseString_s = "NOTATION";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseNotationDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws1:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseNotationDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Nam:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &TQXmlSimpleReader::parseNotationDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws2:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseNotationDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case ExtID:
+	    case ExtIDR:
+		d->parseExternalID_allowPublicID = TRUE;
+		if ( !parseExternalID() ) {
+		    parseFailed( &TQXmlSimpleReader::parseNotationDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws3:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseNotationDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse choice [49] or seq [50].
+
+  Precondition: the beginning '('S? is already read and the head
+  stands on the first non-whitespace character after it.
+*/
+bool TQXmlSimpleReader::parseChoiceSeq()
+{
+    const signed char Init             = 0;
+    const signed char Ws1              = 1; // eat whitespace
+    const signed char CorS             = 2; // choice or set
+    const signed char Ws2              = 3; // eat whitespace
+    const signed char More             = 4; // more cp to read
+    const signed char Name             = 5; // read name
+    const signed char Done             = 6; //
+
+    const signed char InpWs            = 0; // S
+    const signed char InpOp            = 1; // (
+    const signed char InpCp            = 2; // )
+    const signed char InpQm            = 3; // ?
+    const signed char InpAst           = 4; // *
+    const signed char InpPlus          = 5; // +
+    const signed char InpPipe          = 6; // |
+    const signed char InpComm          = 7; // ,
+    const signed char InpUnknown       = 8;
+
+    static const signed char table[6][9] = {
+     /*  InpWs   InpOp  InpCp  InpQm  InpAst  InpPlus  InpPipe  InpComm  InpUnknown */
+	{ -1,     Ws1,   -1,    -1,    -1,     -1,      -1,      -1,      Name  }, // Init
+	{ -1,     CorS,  -1,    -1,    -1,     -1,      -1,      -1,      CorS  }, // Ws1
+	{ Ws2,    -1,    Done,  Ws2,   Ws2,    Ws2,     More,    More,    -1    }, // CorS
+	{ -1,     -1,    Done,  -1,    -1,     -1,      More,    More,    -1    }, // Ws2
+	{ -1,     Ws1,   -1,    -1,    -1,     -1,      -1,      -1,      Name  }, // More (same as Init)
+	{ Ws2,    -1,    Done,  Ws2,   Ws2,    Ws2,     More,    More,    -1    }  // Name (same as CorS)
+    };
+    signed char state;
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseChoiceSeq (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseChoiceSeq, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseChoiceSeq, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if ( c.unicode() == '(' ) {
+	    input = InpOp;
+	} else if ( c.unicode() == ')' ) {
+	    input = InpCp;
+	} else if ( c.unicode() == '?' ) {
+	    input = InpQm;
+	} else if ( c.unicode() == '*' ) {
+	    input = InpAst;
+	} else if ( c.unicode() == '+' ) {
+	    input = InpPlus;
+	} else if ( c.unicode() == '|' ) {
+	    input = InpPipe;
+	} else if ( c.unicode() == ',' ) {
+	    input = InpComm;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Ws1:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseChoiceSeq, state );
+		    return FALSE;
+		}
+		break;
+	    case CorS:
+		if ( !parseChoiceSeq() ) {
+		    parseFailed( &TQXmlSimpleReader::parseChoiceSeq, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws2:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseChoiceSeq, state );
+		    return FALSE;
+		}
+		break;
+	    case More:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseChoiceSeq, state );
+		    return FALSE;
+		}
+		break;
+	    case Name:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &TQXmlSimpleReader::parseChoiceSeq, state );
+		    return FALSE;
+		}
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a EntityDecl [70].
+
+  Precondition: the beginning '<!E' is already read and the head
+  stand on the 'N' of '<!ENTITY'
+*/
+bool TQXmlSimpleReader::parseEntityDecl()
+{
+    const signed char Init             =  0;
+    const signed char Ent              =  1; // parse "ENTITY"
+    const signed char Ws1              =  2; // white space read
+    const signed char Name             =  3; // parse name
+    const signed char Ws2              =  4; // white space read
+    const signed char EValue           =  5; // parse entity value
+    const signed char EValueR          =  6; // same as EValue, but already reported
+    const signed char ExtID            =  7; // parse ExternalID
+    const signed char Ws3              =  8; // white space read
+    const signed char Ndata            =  9; // parse "NDATA"
+    const signed char Ws4              = 10; // white space read
+    const signed char NNam             = 11; // parse name
+    const signed char NNamR            = 12; // same as NNam, but already reported
+    const signed char PEDec            = 13; // parse PEDecl
+    const signed char Ws6              = 14; // white space read
+    const signed char PENam            = 15; // parse name
+    const signed char Ws7              = 16; // white space read
+    const signed char PEVal            = 17; // parse entity value
+    const signed char PEValR           = 18; // same as PEVal, but already reported
+    const signed char PEEID            = 19; // parse ExternalID
+    const signed char PEEIDR           = 20; // same as PEEID, but already reported
+    const signed char WsE              = 21; // white space read
+    const signed char Done             = 22;
+    const signed char EDDone           = 23; // done, but also report an external, unparsed entity decl
+
+    const signed char InpWs            = 0; // white space
+    const signed char InpPer           = 1; // %
+    const signed char InpQuot          = 2; // " or '
+    const signed char InpGt            = 3; // >
+    const signed char InpN             = 4; // N
+    const signed char InpUnknown       = 5;
+
+    static const signed char table[22][6] = {
+     /*  InpWs  InpPer  InpQuot  InpGt  InpN    InpUnknown */
+	{ -1,    -1,     -1,      -1,    Ent,    -1      }, // Init
+	{ Ws1,   -1,     -1,      -1,    -1,     -1      }, // Ent
+	{ -1,    PEDec,  -1,      -1,    Name,   Name    }, // Ws1
+	{ Ws2,   -1,     -1,      -1,    -1,     -1      }, // Name
+	{ -1,    -1,     EValue,  -1,    -1,     ExtID   }, // Ws2
+	{ WsE,   -1,     -1,      Done,  -1,     -1      }, // EValue
+	{ WsE,   -1,     -1,      Done,  -1,     -1      }, // EValueR
+	{ Ws3,   -1,     -1,      EDDone,-1,     -1      }, // ExtID
+	{ -1,    -1,     -1,      EDDone,Ndata,  -1      }, // Ws3
+	{ Ws4,   -1,     -1,      -1,    -1,     -1      }, // Ndata
+	{ -1,    -1,     -1,      -1,    NNam,   NNam    }, // Ws4
+	{ WsE,   -1,     -1,      Done,  -1,     -1      }, // NNam
+	{ WsE,   -1,     -1,      Done,  -1,     -1      }, // NNamR
+	{ Ws6,   -1,     -1,      -1,    -1,     -1      }, // PEDec
+	{ -1,    -1,     -1,      -1,    PENam,  PENam   }, // Ws6
+	{ Ws7,   -1,     -1,      -1,    -1,     -1      }, // PENam
+	{ -1,    -1,     PEVal,   -1,    -1,     PEEID   }, // Ws7
+	{ WsE,   -1,     -1,      Done,  -1,     -1      }, // PEVal
+	{ WsE,   -1,     -1,      Done,  -1,     -1      }, // PEValR
+	{ WsE,   -1,     -1,      Done,  -1,     -1      }, // PEEID
+	{ WsE,   -1,     -1,      Done,  -1,     -1      }, // PEEIDR
+	{ -1,    -1,     -1,      Done,  -1,     -1      }  // WsE
+    };
+    signed char state;
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseEntityDecl (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseEntityDecl, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case EValue:
+		if (  !entityExist( name() ) ) {
+		    d->entities.insert( name(), string() );
+		    if ( declHnd ) {
+			if ( !declHnd->internalEntityDecl( name(), string() ) ) {
+			    reportParseError( declHnd->errorString() );
+			    return FALSE;
+			}
+		    }
+		}
+		state = EValueR;
+		break;
+	    case NNam:
+		if (  !entityExist( name() ) ) {
+		    d->externEntities.insert( name(), TQXmlSimpleReaderPrivate::ExternEntity( d->publicId, d->systemId, ref() ) );
+		    if ( dtdHnd ) {
+			if ( !dtdHnd->unparsedEntityDecl( name(), d->publicId, d->systemId, ref() ) ) {
+			    reportParseError( declHnd->errorString() );
+			    return FALSE;
+			}
+		    }
+		}
+		state = NNamR;
+		break;
+	    case PEVal:
+		if (  !entityExist( name() ) ) {
+		    d->parameterEntities.insert( name(), string() );
+		    if ( declHnd ) {
+			if ( !declHnd->internalEntityDecl( TQString("%")+name(), string() ) ) {
+			    reportParseError( declHnd->errorString() );
+			    return FALSE;
+			}
+		    }
+		}
+		state = PEValR;
+		break;
+	    case PEEID:
+		if (  !entityExist( name() ) ) {
+		    d->externParameterEntities.insert( name(), TQXmlSimpleReaderPrivate::ExternParameterEntity( d->publicId, d->systemId ) );
+		    if ( declHnd ) {
+			if ( !declHnd->externalEntityDecl( TQString("%")+name(), d->publicId, d->systemId ) ) {
+			    reportParseError( declHnd->errorString() );
+			    return FALSE;
+			}
+		    }
+		}
+		state = PEEIDR;
+		break;
+	    case EDDone:
+		if (  !entityExist( name() ) ) {
+		    d->externEntities.insert( name(), TQXmlSimpleReaderPrivate::ExternEntity( d->publicId, d->systemId, TQString::null ) );
+		    if ( declHnd ) {
+			if ( !declHnd->externalEntityDecl( name(), d->publicId, d->systemId ) ) {
+			    reportParseError( declHnd->errorString() );
+			    return FALSE;
+			}
+		    }
+		}
+		return TRUE;
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_LETTEREXPECTED );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseEntityDecl, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if ( c.unicode() == '%' ) {
+	    input = InpPer;
+	} else if ( c.unicode() == '"' || c.unicode() == '\'' ) {
+	    input = InpQuot;
+	} else if ( c.unicode() == '>' ) {
+	    input = InpGt;
+	} else if ( c.unicode() == 'N' ) {
+	    input = InpN;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Ent:
+		d->parseString_s = "NTITY";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws1:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Name:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &TQXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws2:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case EValue:
+	    case EValueR:
+		if ( !parseEntityValue() ) {
+		    parseFailed( &TQXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case ExtID:
+		d->parseExternalID_allowPublicID = FALSE;
+		if ( !parseExternalID() ) {
+		    parseFailed( &TQXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws3:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ndata:
+		d->parseString_s = "NDATA";
+		if ( !parseString() ) {
+		    parseFailed( &TQXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws4:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case NNam:
+	    case NNamR:
+		d->parseName_useRef = TRUE;
+		if ( !parseName() ) {
+		    parseFailed( &TQXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case PEDec:
+		next();
+		break;
+	    case Ws6:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case PENam:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &TQXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws7:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case PEVal:
+	    case PEValR:
+		if ( !parseEntityValue() ) {
+		    parseFailed( &TQXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case PEEID:
+	    case PEEIDR:
+		d->parseExternalID_allowPublicID = FALSE;
+		if ( !parseExternalID() ) {
+		    parseFailed( &TQXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case WsE:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case EDDone:
+		next();
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a EntityValue [9]
+*/
+bool TQXmlSimpleReader::parseEntityValue()
+{
+    const signed char Init             = 0;
+    const signed char Dq               = 1; // EntityValue is double quoted
+    const signed char DqC              = 2; // signed character
+    const signed char DqPER            = 3; // PERefence
+    const signed char DqRef            = 4; // Reference
+    const signed char Sq               = 5; // EntityValue is double quoted
+    const signed char SqC              = 6; // signed character
+    const signed char SqPER            = 7; // PERefence
+    const signed char SqRef            = 8; // Reference
+    const signed char Done             = 9;
+
+    const signed char InpDq            = 0; // "
+    const signed char InpSq            = 1; // '
+    const signed char InpAmp           = 2; // &
+    const signed char InpPer           = 3; // %
+    const signed char InpUnknown       = 4;
+
+    static const signed char table[9][5] = {
+     /*  InpDq  InpSq  InpAmp  InpPer  InpUnknown */
+	{ Dq,    Sq,    -1,     -1,     -1    }, // Init
+	{ Done,  DqC,   DqRef,  DqPER,  DqC   }, // Dq
+	{ Done,  DqC,   DqRef,  DqPER,  DqC   }, // DqC
+	{ Done,  DqC,   DqRef,  DqPER,  DqC   }, // DqPER
+	{ Done,  DqC,   DqRef,  DqPER,  DqC   }, // DqRef
+	{ SqC,   Done,  SqRef,  SqPER,  SqC   }, // Sq
+	{ SqC,   Done,  SqRef,  SqPER,  SqC   }, // SqC
+	{ SqC,   Done,  SqRef,  SqPER,  SqC   }, // SqPER
+	{ SqC,   Done,  SqRef,  SqPER,  SqC   }  // SqRef
+    };
+    signed char state;
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseEntityValue (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseEntityValue, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_LETTEREXPECTED );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseEntityValue, state );
+	    return FALSE;
+	}
+	if        ( c.unicode() == '"' ) {
+	    input = InpDq;
+	} else if ( c.unicode() == '\'' ) {
+	    input = InpSq;
+	} else if ( c.unicode() == '&' ) {
+	    input = InpAmp;
+	} else if ( c.unicode() == '%' ) {
+	    input = InpPer;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Dq:
+	    case Sq:
+		stringClear();
+		next();
+		break;
+	    case DqC:
+	    case SqC:
+		stringAddC();
+		next();
+		break;
+	    case DqPER:
+	    case SqPER:
+		d->parsePEReference_context = InEntityValue;
+		if ( !parsePEReference() ) {
+		    parseFailed( &TQXmlSimpleReader::parseEntityValue, state );
+		    return FALSE;
+		}
+		break;
+	    case DqRef:
+	    case SqRef:
+		d->parseReference_context = InEntityValue;
+		if ( !parseReference() ) {
+		    parseFailed( &TQXmlSimpleReader::parseEntityValue, state );
+		    return FALSE;
+		}
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a comment [15].
+
+  Precondition: the beginning '<!' of the comment is already read and the head
+  stands on the first '-' of '<!--'.
+
+  If this funktion was successful, the head-position is on the first
+  character after the comment.
+*/
+bool TQXmlSimpleReader::parseComment()
+{
+    const signed char Init             = 0;
+    const signed char Dash1            = 1; // the first dash was read
+    const signed char Dash2            = 2; // the second dash was read
+    const signed char Com              = 3; // read comment
+    const signed char Com2             = 4; // read comment (help state)
+    const signed char ComE             = 5; // finished reading comment
+    const signed char Done             = 6;
+
+    const signed char InpDash          = 0; // -
+    const signed char InpGt            = 1; // >
+    const signed char InpUnknown       = 2;
+
+    static const signed char table[6][3] = {
+     /*  InpDash  InpGt  InpUnknown */
+	{ Dash1,   -1,    -1  }, // Init
+	{ Dash2,   -1,    -1  }, // Dash1
+	{ Com2,    Com,   Com }, // Dash2
+	{ Com2,    Com,   Com }, // Com
+	{ ComE,    Com,   Com }, // Com2
+	{ -1,      Done,  -1  }  // ComE
+    };
+    signed char state;
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseComment (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseComment, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Dash2:
+		stringClear();
+		break;
+	    case Com2:
+		// if next character is not a dash than don't skip it
+		if ( !atEnd() && c.unicode() != '-' )
+		    stringAddC( '-' );
+		break;
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_ERRORPARSINGCOMMENT );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseComment, state );
+	    return FALSE;
+	}
+	if        ( c.unicode() == '-' ) {
+	    input = InpDash;
+	} else if ( c.unicode() == '>' ) {
+	    input = InpGt;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Dash1:
+		next();
+		break;
+	    case Dash2:
+		next();
+		break;
+	    case Com:
+		stringAddC();
+		next();
+		break;
+	    case Com2:
+		next();
+		break;
+	    case ComE:
+		next();
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+    Parse an Attribute [41].
+
+    Precondition: the head stands on the first character of the name
+    of the attribute (i.e. all whitespaces are already parsed).
+
+    The head stand on the next character after the end quotes. The
+    variable name contains the name of the attribute and the variable
+    string contains the value of the attribute.
+*/
+bool TQXmlSimpleReader::parseAttribute()
+{
+    const int Init             = 0;
+    const int PName            = 1; // parse name
+    const int Ws               = 2; // eat ws
+    const int Eq               = 3; // the '=' was read
+    const int Quotes           = 4; // " or ' were read
+
+    const int InpNameBe        = 0;
+    const int InpEq            = 1; // =
+    const int InpDq            = 2; // "
+    const int InpSq            = 3; // '
+    const int InpUnknown       = 4;
+
+    static const int table[4][5] = {
+     /*  InpNameBe  InpEq  InpDq    InpSq    InpUnknown */
+	{ PName,     -1,    -1,      -1,      -1    }, // Init
+	{ -1,        Eq,    -1,      -1,      Ws    }, // PName
+	{ -1,        Eq,    -1,      -1,      -1    }, // Ws
+	{ -1,        -1,    Quotes,  Quotes,  -1    }  // Eq
+    };
+    int state;
+    int input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseAttribute (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseAttribute, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Quotes:
+		// Done
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseAttribute, state );
+	    return FALSE;
+	}
+	if        ( determineNameChar(c) == NameBeginning ) {
+	    input = InpNameBe;
+	} else if ( c.unicode() == '=' ) {
+	    input = InpEq;
+	} else if ( c.unicode() == '"' ) {
+	    input = InpDq;
+	} else if ( c.unicode() == '\'' ) {
+	    input = InpSq;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case PName:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttribute, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws:
+		if ( !eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttribute, state );
+		    return FALSE;
+		}
+		break;
+	    case Eq:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttribute, state );
+		    return FALSE;
+		}
+		break;
+	    case Quotes:
+		if ( !parseAttValue() ) {
+		    parseFailed( &TQXmlSimpleReader::parseAttribute, state );
+		    return FALSE;
+		}
+		break;
+	}
+    }
+}
+
+/*
+  Parse a Name [5] and store the name in name or ref (if useRef is TRUE).
+*/
+bool TQXmlSimpleReader::parseName()
+{
+    const int Init             = 0;
+    const int Name1            = 1; // parse first signed character of the name
+    const int Name             = 2; // parse name
+    const int Done             = 3;
+
+    const int InpNameBe        = 0; // name beginning signed characters
+    const int InpNameCh        = 1; // NameChar without InpNameBe
+    const int InpUnknown       = 2;
+
+    Q_ASSERT(InpNameBe == (int)NameBeginning);
+    Q_ASSERT(InpNameCh == (int)NameNotBeginning);
+    Q_ASSERT(InpUnknown == (int)NotName);
+
+    static const int table[3][3] = {
+     /*  InpNameBe  InpNameCh  InpUnknown */
+	{ Name1,     -1,        -1    }, // Init
+	{ Name,      Name,      Done  }, // Name1
+	{ Name,      Name,      Done  }  // Name
+    };
+    int state;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseName (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseName, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_LETTEREXPECTED );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseName, state );
+	    return FALSE;
+	}
+
+        // we can safely do the (int) cast thanks to the Q_ASSERTs earlier in this function
+        state = table[state][(int)fastDetermineNameChar(c)];
+
+	switch ( state ) {
+	    case Name1:
+		if ( d->parseName_useRef ) {
+		    refClear();
+		    refAddC();
+		} else {
+		    nameClear();
+		    nameAddC();
+		}
+		next();
+		break;
+	    case Name:
+		if ( d->parseName_useRef ) {
+		    refAddC();
+		} else {
+		    nameAddC();
+		}
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a Nmtoken [7] and store the name in name.
+*/
+bool TQXmlSimpleReader::parseNmtoken()
+{
+    const signed char Init             = 0;
+    const signed char NameF            = 1;
+    const signed char Name             = 2;
+    const signed char Done             = 3;
+
+    const signed char InpNameCh        = 0; // NameChar without InpNameBe
+    const signed char InpUnknown       = 1;
+
+    static const signed char table[3][2] = {
+     /*  InpNameCh  InpUnknown */
+	{ NameF,     -1    }, // Init
+	{ Name,      Done  }, // NameF
+	{ Name,      Done  }  // Name
+    };
+    signed char state;
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseNmtoken (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseNmtoken, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_LETTEREXPECTED );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseNmtoken, state );
+	    return FALSE;
+	}
+        if (determineNameChar(c) == NotName) {
+            input = InpUnknown;
+        } else {
+	    input = InpNameCh;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case NameF:
+		nameClear();
+		nameAddC();
+		next();
+		break;
+	    case Name:
+		nameAddC();
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a Reference [67].
+
+  parseReference_charDataRead is set to TRUE if the reference must not be
+  parsed. The character(s) which the reference mapped to are appended to
+  string. The head stands on the first character after the reference.
+
+  parseReference_charDataRead is set to FALSE if the reference must be parsed.
+  The charachter(s) which the reference mapped to are inserted at the reference
+  position. The head stands on the first character of the replacement).
+*/
+bool TQXmlSimpleReader::parseReference()
+{
+    // temporary variables (only used in very local context, so they don't
+    // interfere with incremental parsing)
+    uint tmp;
+    bool ok;
+
+    const signed char Init             =  0;
+    const signed char SRef             =  1; // start of a reference
+    const signed char ChRef            =  2; // parse CharRef
+    const signed char ChDec            =  3; // parse CharRef decimal
+    const signed char ChHexS           =  4; // start CharRef hexadecimal
+    const signed char ChHex            =  5; // parse CharRef hexadecimal
+    const signed char Name             =  6; // parse name
+    const signed char DoneD            =  7; // done CharRef decimal
+    const signed char DoneH            =  8; // done CharRef hexadecimal
+    const signed char DoneN            =  9; // done EntityRef
+
+    const signed char InpAmp           = 0; // &
+    const signed char InpSemi          = 1; // ;
+    const signed char InpHash          = 2; // #
+    const signed char InpX             = 3; // x
+    const signed char InpNum           = 4; // 0-9
+    const signed char InpHex           = 5; // a-f A-F
+    const signed char InpUnknown       = 6;
+
+    static const signed char table[8][7] = {
+     /*  InpAmp  InpSemi  InpHash  InpX     InpNum  InpHex  InpUnknown */
+	{ SRef,   -1,      -1,      -1,      -1,     -1,     -1    }, // Init
+	{ -1,     -1,      ChRef,   Name,    Name,   Name,   Name  }, // SRef
+	{ -1,     -1,      -1,      ChHexS,  ChDec,  -1,     -1    }, // ChRef
+	{ -1,     DoneD,   -1,      -1,      ChDec,  -1,     -1    }, // ChDec
+	{ -1,     -1,      -1,      -1,      ChHex,  ChHex,  -1    }, // ChHexS
+	{ -1,     DoneH,   -1,      -1,      ChHex,  ChHex,  -1    }, // ChHex
+	{ -1,     DoneN,   -1,      -1,      -1,     -1,     -1    }  // Name
+    };
+    signed char state;
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	d->parseReference_charDataRead = FALSE;
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseReference (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseReference, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case DoneD:
+		return TRUE;
+	    case DoneH:
+		return TRUE;
+	    case DoneN:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_ERRORPARSINGREFERENCE );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseReference, state );
+	    return FALSE;
+	}
+	if        ( c.row() ) {
+	    input = InpUnknown;
+	} else if ( c.cell() == '&' ) {
+	    input = InpAmp;
+	} else if ( c.cell() == ';' ) {
+	    input = InpSemi;
+	} else if ( c.cell() == '#' ) {
+	    input = InpHash;
+	} else if ( c.cell() == 'x' ) {
+	    input = InpX;
+	} else if ( '0' <= c.cell() && c.cell() <= '9' ) {
+	    input = InpNum;
+	} else if ( 'a' <= c.cell() && c.cell() <= 'f' ) {
+	    input = InpHex;
+	} else if ( 'A' <= c.cell() && c.cell() <= 'F' ) {
+	    input = InpHex;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case SRef:
+		refClear();
+		next();
+		break;
+	    case ChRef:
+		next();
+		break;
+	    case ChDec:
+		refAddC();
+		next();
+		break;
+	    case ChHexS:
+		next();
+		break;
+	    case ChHex:
+		refAddC();
+		next();
+		break;
+	    case Name:
+		// read the name into the ref
+		d->parseName_useRef = TRUE;
+		if ( !parseName() ) {
+		    parseFailed( &TQXmlSimpleReader::parseReference, state );
+		    return FALSE;
+		}
+		break;
+	    case DoneD:
+		tmp = ref().toUInt( &ok, 10 );
+		if ( ok ) {
+		    stringAddC( TQChar(tmp) );
+		} else {
+		    reportParseError( XMLERR_ERRORPARSINGREFERENCE );
+		    return FALSE;
+		}
+		d->parseReference_charDataRead = TRUE;
+		next();
+		break;
+	    case DoneH:
+		tmp = ref().toUInt( &ok, 16 );
+		if ( ok ) {
+		    stringAddC( TQChar(tmp) );
+		} else {
+		    reportParseError( XMLERR_ERRORPARSINGREFERENCE );
+		    return FALSE;
+		}
+		d->parseReference_charDataRead = TRUE;
+		next();
+		break;
+	    case DoneN:
+		if ( !processReference() )
+		    return FALSE;
+		next();
+		break;
+	}
+    }
+}
+
+/* This private function is only called by TQDom. It avoids a data corruption bug
+   whereby undefined entities in attribute values would be appended after the
+   element that contained them.
+
+   The solution is not perfect - the undefined entity reference is replaced by
+   an empty string. The propper fix will come in TQt4, when SAX will be extended
+   so that attribute values can be made up of multiple children, rather than just
+   a single string value.
+*/
+void TQXmlSimpleReader::setUndefEntityInAttrHack(bool b)
+{
+    d->undefEntityInAttrHack = b;
+}
+
+/*
+  Helper function for parseReference()
+*/
+bool TQXmlSimpleReader::processReference()
+{
+    TQString reference = ref();
+    if ( reference == "amp" ) {
+	if ( d->parseReference_context == InEntityValue ) {
+	    // Bypassed
+	    stringAddC( '&' ); stringAddC( 'a' ); stringAddC( 'm' ); stringAddC( 'p' ); stringAddC( ';' );
+	} else {
+	    // Included or Included in literal
+	    stringAddC( '&' );
+	}
+	d->parseReference_charDataRead = TRUE;
+    } else if ( reference == "lt" ) {
+	if ( d->parseReference_context == InEntityValue ) {
+	    // Bypassed
+	    stringAddC( '&' ); stringAddC( 'l' ); stringAddC( 't' ); stringAddC( ';' );
+	} else {
+	    // Included or Included in literal
+	    stringAddC( '<' );
+	}
+	d->parseReference_charDataRead = TRUE;
+    } else if ( reference == "gt" ) {
+	if ( d->parseReference_context == InEntityValue ) {
+	    // Bypassed
+	    stringAddC( '&' ); stringAddC( 'g' ); stringAddC( 't' ); stringAddC( ';' );
+	} else {
+	    // Included or Included in literal
+	    stringAddC( '>' );
+	}
+	d->parseReference_charDataRead = TRUE;
+    } else if ( reference == "apos" ) {
+	if ( d->parseReference_context == InEntityValue ) {
+	    // Bypassed
+	    stringAddC( '&' ); stringAddC( 'a' ); stringAddC( 'p' ); stringAddC( 'o' ); stringAddC( 's' ); stringAddC( ';' );
+	} else {
+	    // Included or Included in literal
+	    stringAddC( '\'' );
+	}
+	d->parseReference_charDataRead = TRUE;
+    } else if ( reference == "quot" ) {
+	if ( d->parseReference_context == InEntityValue ) {
+	    // Bypassed
+	    stringAddC( '&' ); stringAddC( 'q' ); stringAddC( 'u' ); stringAddC( 'o' ); stringAddC( 't' ); stringAddC( ';' );
+	} else {
+	    // Included or Included in literal
+	    stringAddC( '"' );
+	}
+	d->parseReference_charDataRead = TRUE;
+    } else {
+	TQMap<TQString,TQString>::Iterator it;
+	it = d->entities.find( reference );
+	if ( it != d->entities.end() ) {
+	    // "Internal General"
+	    switch ( d->parseReference_context ) {
+		case InContent:
+		    // Included
+		    if ( !insertXmlRef( it.data(), reference, FALSE ) )
+			return FALSE;
+		    d->parseReference_charDataRead = FALSE;
+		    break;
+		case InAttributeValue:
+		    // Included in literal
+		    if ( !insertXmlRef( it.data(), reference, TRUE ) )
+			return FALSE;
+		    d->parseReference_charDataRead = FALSE;
+		    break;
+		case InEntityValue:
+		    {
+			// Bypassed
+			stringAddC( '&' );
+			for ( int i=0; i<(int)reference.length(); i++ ) {
+			    stringAddC( reference[i] );
+			}
+			stringAddC( ';');
+			d->parseReference_charDataRead = TRUE;
+		    }
+		    break;
+		case InDTD:
+		    // Forbidden
+		    d->parseReference_charDataRead = FALSE;
+		    reportParseError( XMLERR_INTERNALGENERALENTITYINDTD );
+		    return FALSE;
+	    }
+	} else {
+	    TQMap<TQString,TQXmlSimpleReaderPrivate::ExternEntity>::Iterator itExtern;
+	    itExtern = d->externEntities.find( reference );
+	    if ( itExtern == d->externEntities.end() ) {
+		// entity not declared
+		// ### check this case for conformance
+		if ( d->parseReference_context == InEntityValue ) {
+		    // Bypassed
+		    stringAddC( '&' );
+		    for ( int i=0; i<(int)reference.length(); i++ ) {
+			stringAddC( reference[i] );
+		    }
+		    stringAddC( ';');
+		    d->parseReference_charDataRead = TRUE;
+		} else {
+		    if ( contentHnd && !(d->parseReference_context == InAttributeValue
+                             && d->undefEntityInAttrHack)) {
+			if ( !contentHnd->skippedEntity( reference ) ) {
+			    reportParseError( contentHnd->errorString() );
+			    return FALSE; // error
+			}
+		    }
+		}
+	    } else if ( (*itExtern).notation.isNull() ) {
+		// "External Parsed General"
+		switch ( d->parseReference_context ) {
+		    case InContent:
+			{
+			    // Included if validating
+			    bool skipIt = TRUE;
+			    if ( entityRes ) {
+				TQXmlInputSource *ret = 0;
+				if ( !entityRes->resolveEntity( itExtern.data().publicId, itExtern.data().systemId, ret ) ) {
+				    delete ret;
+				    reportParseError( entityRes->errorString() );
+				    return FALSE;
+				}
+				if ( ret ) {
+				    TQString xmlRefString = ret->data();
+				    delete ret;
+				    if ( !stripTextDecl( xmlRefString ) ) {
+					reportParseError( XMLERR_ERRORINTEXTDECL );
+					return FALSE;
+				    }
+				    if ( !insertXmlRef( xmlRefString, reference, FALSE ) )
+					return FALSE;
+				    skipIt = FALSE;
+				}
+			    }
+			    if ( skipIt && contentHnd ) {
+				if ( !contentHnd->skippedEntity( reference ) ) {
+				    reportParseError( contentHnd->errorString() );
+				    return FALSE; // error
+				}
+			    }
+			    d->parseReference_charDataRead = FALSE;
+			} break;
+		    case InAttributeValue:
+			// Forbidden
+			d->parseReference_charDataRead = FALSE;
+			reportParseError( XMLERR_EXTERNALGENERALENTITYINAV );
+			return FALSE;
+		    case InEntityValue:
+			{
+			    // Bypassed
+			    stringAddC( '&' );
+			    for ( int i=0; i<(int)reference.length(); i++ ) {
+				stringAddC( reference[i] );
+			    }
+			    stringAddC( ';');
+			    d->parseReference_charDataRead = TRUE;
+			}
+			break;
+		    case InDTD:
+			// Forbidden
+			d->parseReference_charDataRead = FALSE;
+			reportParseError( XMLERR_EXTERNALGENERALENTITYINDTD );
+			return FALSE;
+		}
+	    } else {
+		// "Unparsed"
+		// ### notify for "Occurs as Attribute Value" missing (but this is no refence, anyway)
+		// Forbidden
+		d->parseReference_charDataRead = FALSE;
+		reportParseError( XMLERR_UNPARSEDENTITYREFERENCE );
+		return FALSE; // error
+	    }
+	}
+    }
+    return TRUE; // no error
+}
+
+
+/*
+  Parses over a simple string.
+
+  After the string was successfully parsed, the head is on the first
+  character after the string.
+*/
+bool TQXmlSimpleReader::parseString()
+{
+    const signed char InpCharExpected  = 0; // the character that was expected
+    const signed char InpUnknown       = 1;
+
+    signed char state; // state in this function is the position in the string s
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	d->Done = d->parseString_s.length();
+	state = 0;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "TQXmlSimpleReader: parseString (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &TQXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "TQXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &TQXmlSimpleReader::parseString, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	if ( state == d->Done ) {
+	    return TRUE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &TQXmlSimpleReader::parseString, state );
+	    return FALSE;
+	}
+	if ( c == d->parseString_s[(int)state] ) {
+	    input = InpCharExpected;
+	} else {
+	    input = InpUnknown;
+	}
+	if ( input == InpCharExpected ) {
+	    state++;
+	} else {
+	    // Error
+	    reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+	    return FALSE;
+	}
+
+	next();
+    }
+}
+
+/*
+  This private function inserts and reports an entity substitution. The
+  substituted string is \a data and the name of the entity reference is \a
+  name. If \a inLiteral is TRUE, the entity is IncludedInLiteral (i.e., " and '
+  must be quoted. Otherwise they are not quoted.
+
+  This function returns FALSE on error.
+*/
+bool TQXmlSimpleReader::insertXmlRef( const TQString &data, const TQString &name, bool inLiteral )
+{
+    if ( inLiteral ) {
+	TQString tmp = data;
+	d->xmlRef.push( tmp.replace( "\"", "&quot;" ).replace( "'", "&apos;" ) );
+    } else {
+	d->xmlRef.push( data );
+    }
+    d->xmlRefName.push( name );
+    uint n = (uint)TQMAX( d->parameterEntities.count(), d->entities.count() );
+    if ( d->xmlRefName.count() > n+1 ) {
+	// recursive entities
+	reportParseError( XMLERR_RECURSIVEENTITIES );
+	return FALSE;
+    }
+    if ( d->reportEntities && lexicalHnd ) {
+	if ( !lexicalHnd->startEntity( name ) ) {
+	    reportParseError( lexicalHnd->errorString() );
+	    return FALSE;
+	}
+    }
+    return TRUE;
+}
+
+/*
+  This private function moves the cursor to the next character.
+*/
+void TQXmlSimpleReader::next()
+{
+    int count = (int)d->xmlRef.count();
+    while ( count != 0 ) {
+	if ( d->xmlRef.top().isEmpty() ) {
+	    d->xmlRef.pop_back();
+	    d->xmlRefName.pop_back();
+	    count--;
+	} else {
+	    c = d->xmlRef.top().constref( 0 );
+	    d->xmlRef.top().remove( (uint)0, 1 );
+	    return;
+	}
+    }
+    // the following could be written nicer, but since it is a time-critical
+    // function, rather optimize for speed
+    ushort uc = c.unicode();
+    if (uc == '\n') {
+	c = inputSource->next();
+	lineNr++;
+	columnNr = -1;
+    } else if ( uc == '\r' ) {
+	c = inputSource->next();
+	if ( c.unicode() != '\n' ) {
+	    lineNr++;
+	    columnNr = -1;
+	}
+    } else {
+	c = inputSource->next();
+    }
+    ++columnNr;
+}
+
+/*
+  This private function moves the cursor to the next non-whitespace character.
+  This function does not move the cursor if the actual cursor position is a
+  non-whitespace charcter.
+
+  Returns FALSE when you use incremental parsing and this function reaches EOF
+  with reading only whitespace characters. In this case it also poplulates the
+  parseStack with useful information. In all other cases, this function returns
+  TRUE.
+*/
+bool TQXmlSimpleReader::eat_ws()
+{
+    while ( !atEnd() ) {
+	if ( !is_S(c) ) {
+	    return TRUE;
+	}
+	next();
+    }
+    if ( d->parseStack != 0 ) {
+	unexpectedEof( &TQXmlSimpleReader::eat_ws, 0 );
+	return FALSE;
+    }
+    return TRUE;
+}
+
+bool TQXmlSimpleReader::next_eat_ws()
+{
+    next();
+    return eat_ws();
+}
+
+
+/*
+  This private function initializes the reader. \a i is the input source to
+  read the data from.
+*/
+void TQXmlSimpleReader::init( const TQXmlInputSource *i )
+{
+    lineNr = 0;
+    columnNr = -1;
+    inputSource = (TQXmlInputSource *)i;
+    initData();
+
+    d->externParameterEntities.clear();
+    d->parameterEntities.clear();
+    d->externEntities.clear();
+    d->entities.clear();
+
+    d->tags.clear();
+
+    d->doctype = "";
+    d->xmlVersion = "";
+    d->encoding = "";
+    d->standalone = TQXmlSimpleReaderPrivate::Unknown;
+    d->error = TQString::null;
+}
+
+/*
+  This private function initializes the XML data related variables. Especially,
+  it reads the data from the input source.
+*/
+void TQXmlSimpleReader::initData()
+{
+    c = TQXmlInputSource::EndOfData;
+    d->xmlRef.clear();
+    next();
+}
+
+/*
+  Returns TRUE if a entity with the name \a e exists,
+  otherwise returns FALSE.
+*/
+bool TQXmlSimpleReader::entityExist( const TQString& e ) const
+{
+    if (  d->parameterEntities.find(e) == d->parameterEntities.end() &&
+	  d->externParameterEntities.find(e) == d->externParameterEntities.end() &&
+	  d->externEntities.find(e) == d->externEntities.end() &&
+	  d->entities.find(e) == d->entities.end() ) {
+	return FALSE;
+    } else {
+	return TRUE;
+    }
+}
+
+void TQXmlSimpleReader::reportParseError( const TQString& error )
+{
+    d->error = error;
+    if ( errorHnd ) {
+	if ( d->error.isNull() ) {
+	    errorHnd->fatalError( TQXmlParseException( XMLERR_OK, columnNr+1, lineNr+1 ) );
+	} else {
+	    errorHnd->fatalError( TQXmlParseException( d->error, columnNr+1, lineNr+1 ) );
+	}
+    }
+}
+
+/*
+  This private function is called when a parsing function encounters an
+  unexpected EOF. It decides what to do (depending on incremental parsing or
+  not). \a where is a pointer to the function where the error occurred and \a
+  state is the parsing state in this function.
+*/
+void TQXmlSimpleReader::unexpectedEof( ParseFunction where, int state )
+{
+    if ( d->parseStack == 0 ) {
+	reportParseError( XMLERR_UNEXPECTEDEOF );
+    } else {
+	if ( c == TQXmlInputSource::EndOfDocument ) {
+	    reportParseError( XMLERR_UNEXPECTEDEOF );
+	} else {
+	    pushParseState( where, state );
+	}
+    }
+}
+
+/*
+  This private function is called when a parse...() function returned FALSE. It
+  determines if there was an error or if incremental parsing simply went out of
+  data and does the right thing for the case. \a where is a pointer to the
+  function where the error occurred and \a state is the parsing state in this
+  function.
+*/
+void TQXmlSimpleReader::parseFailed( ParseFunction where, int state )
+{
+    if ( d->parseStack!=0 && d->error.isNull() ) {
+	pushParseState( where, state );
+    }
+}
+
+/*
+  This private function pushes the function pointer \a function and state \a
+  state to the parse stack. This is used when you are doing an incremental
+  parsing and reach the end of file too early.
+
+  Only call this function when d->parseStack!=0.
+*/
+void TQXmlSimpleReader::pushParseState( ParseFunction function, int state )
+{
+    TQXmlSimpleReaderPrivate::ParseState ps;
+    ps.function = function;
+    ps.state = state;
+    d->parseStack->push( ps );
+}
+
+inline static void updateValue(TQString &value, const TQChar *array, int &arrayPos, int &valueLen)
+{
+    value.setLength(valueLen + arrayPos);
+    memcpy(const_cast<TQChar*>(value.unicode()) + valueLen, array, arrayPos * sizeof(TQChar));
+    valueLen += arrayPos;
+    arrayPos = 0;
+}
+
+// use buffers instead of TQString::operator+= when single characters are read
+const TQString& TQXmlSimpleReader::string()
+{
+    updateValue(stringValue, stringArray, stringArrayPos, d->stringValueLen);
+    return stringValue;
+}
+
+const TQString& TQXmlSimpleReader::name()
+{
+    updateValue(nameValue, nameArray, nameArrayPos, d->nameValueLen);
+    return nameValue;
+}
+
+const TQString& TQXmlSimpleReader::ref()
+{
+    updateValue(refValue, refArray, refArrayPos, d->refValueLen);
+    return refValue;
+}
+
+void TQXmlSimpleReader::stringAddC(const TQChar &ch)
+{
+    if (stringArrayPos == 256)
+        updateValue(stringValue, stringArray, stringArrayPos, d->stringValueLen);
+    stringArray[stringArrayPos++] = ch;
+}
+void TQXmlSimpleReader::nameAddC(const TQChar &ch)
+{
+    if (nameArrayPos == 256)
+        updateValue(nameValue, nameArray, nameArrayPos, d->nameValueLen);
+    nameArray[nameArrayPos++] = ch;
+}
+
+void TQXmlSimpleReader::refAddC(const TQChar &ch)
+{
+    if (refArrayPos == 256)
+        updateValue(refValue, refArray, refArrayPos, d->refValueLen);
+    refArray[refArrayPos++] = ch;
+}
+
+void TQXmlSimpleReader::stringClear()
+{
+    d->stringValueLen = 0; stringArrayPos = 0;
+}
+
+
+#endif //QT_NO_XML
diff --git a/src/xml/qxml.h b/src/xml/qxml.h
new file mode 100644
index 000000000..4cb0b921f
--- /dev/null
+++ b/src/xml/qxml.h
@@ -0,0 +1,531 @@
+/****************************************************************************
+**
+** Definition of TQXmlSimpleReader and related classes.
+**
+** Created : 000518
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the xml module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing retquirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQXML_H
+#define TQXML_H
+
+#ifndef QT_H
+#include "qtextstream.h"
+#include "qfile.h"
+#include "qstring.h"
+#include "qstringlist.h"
+#include "qvaluevector.h"
+#endif // QT_H
+
+#if !defined(QT_MODULE_XML) || defined( QT_LICENSE_PROFESSIONAL ) || defined( QT_INTERNAL_XML )
+#define TQM_EXPORT_XML
+#else
+#define TQM_EXPORT_XML Q_EXPORT
+#endif
+
+#ifndef QT_NO_XML
+
+class TQXmlNamespaceSupport;
+class TQXmlAttributes;
+class TQXmlContentHandler;
+class TQXmlDefaultHandler;
+class TQXmlDTDHandler;
+class TQXmlEntityResolver;
+class TQXmlErrorHandler;
+class TQXmlLexicalHandler;
+class TQXmlDeclHandler;
+class TQXmlInputSource;
+class TQXmlLocator;
+class TQXmlNamespaceSupport;
+class TQXmlParseException;
+
+class TQXmlReader;
+class TQXmlSimpleReader;
+
+class TQXmlSimpleReaderPrivate;
+class TQXmlNamespaceSupportPrivate;
+class TQXmlAttributesPrivate;
+class TQXmlInputSourcePrivate;
+class TQXmlParseExceptionPrivate;
+class TQXmlLocatorPrivate;
+class TQXmlDefaultHandlerPrivate;
+
+
+//
+// SAX Namespace Support
+//
+
+class TQM_EXPORT_XML TQXmlNamespaceSupport
+{
+public:
+    TQXmlNamespaceSupport();
+    ~TQXmlNamespaceSupport();
+
+    void setPrefix( const TQString&, const TQString& );
+
+    TQString prefix( const TQString& ) const;
+    TQString uri( const TQString& ) const;
+    void splitName( const TQString&, TQString&, TQString& ) const;
+    void processName( const TQString&, bool, TQString&, TQString& ) const;
+    TQStringList prefixes() const;
+    TQStringList prefixes( const TQString& ) const;
+
+    void pushContext();
+    void popContext();
+    void reset();
+
+private:
+    TQXmlNamespaceSupportPrivate *d;
+
+    friend class TQXmlSimpleReader;
+};
+
+
+//
+// SAX Attributes
+//
+
+class TQM_EXPORT_XML TQXmlAttributes
+{
+public:
+    TQXmlAttributes() {}
+    virtual ~TQXmlAttributes() {}
+
+    int index( const TQString& qName ) const;
+    int index( const TQString& uri, const TQString& localPart ) const;
+    int length() const;
+    int count() const;
+    TQString localName( int index ) const;
+    TQString qName( int index ) const;
+    TQString uri( int index ) const;
+    TQString type( int index ) const;
+    TQString type( const TQString& qName ) const;
+    TQString type( const TQString& uri, const TQString& localName ) const;
+    TQString value( int index ) const;
+    TQString value( const TQString& qName ) const;
+    TQString value( const TQString& uri, const TQString& localName ) const;
+
+    void clear();
+    void append( const TQString &qName, const TQString &uri, const TQString &localPart, const TQString &value );
+
+private:
+    TQStringList qnameList;
+    TQStringList uriList;
+    TQStringList localnameList;
+    TQStringList valueList;
+
+    TQXmlAttributesPrivate *d;
+};
+
+//
+// SAX Input Source
+//
+
+class TQM_EXPORT_XML TQXmlInputSource
+{
+public:
+    TQXmlInputSource();
+    TQXmlInputSource( TQIODevice *dev );
+    TQXmlInputSource( TQFile& file ); // obsolete
+    TQXmlInputSource( TQTextStream& stream ); // obsolete
+    virtual ~TQXmlInputSource();
+
+    virtual void setData( const TQString& dat );
+    virtual void setData( const TQByteArray& dat );
+    virtual void fetchData();
+    virtual TQString data();
+    virtual TQChar next();
+    virtual void reset();
+
+    static const TQChar EndOfData;
+    static const TQChar EndOfDocument;
+
+protected:
+    virtual TQString fromRawData( const TQByteArray &data, bool beginning = FALSE );
+
+private:
+    void init();
+
+    TQIODevice *inputDevice;
+    TQTextStream *inputStream;
+
+    TQString str;
+    const TQChar *unicode;
+    int pos;
+    int length;
+    bool nextReturnedEndOfData;
+    TQTextDecoder *encMapper;
+
+    TQXmlInputSourcePrivate *d;
+};
+
+//
+// SAX Exception Classes
+//
+
+class TQM_EXPORT_XML TQXmlParseException
+{
+public:
+    TQXmlParseException( const TQString& name="", int c=-1, int l=-1, const TQString& p="", const TQString& s="" )
+	: msg( name ), column( c ), line( l ), pub( p ), sys( s )
+    { }
+
+    int columnNumber() const;
+    int lineNumber() const;
+    TQString publicId() const;
+    TQString systemId() const;
+    TQString message() const;
+
+private:
+    TQString msg;
+    int column;
+    int line;
+    TQString pub;
+    TQString sys;
+
+    TQXmlParseExceptionPrivate *d;
+};
+
+
+//
+// XML Reader
+//
+
+class TQM_EXPORT_XML TQXmlReader
+{
+public:
+    virtual bool feature( const TQString& name, bool *ok = 0 ) const = 0;
+    virtual void setFeature( const TQString& name, bool value ) = 0;
+    virtual bool hasFeature( const TQString& name ) const = 0;
+    virtual void* property( const TQString& name, bool *ok = 0 ) const = 0;
+    virtual void setProperty( const TQString& name, void* value ) = 0;
+    virtual bool hasProperty( const TQString& name ) const = 0;
+    virtual void setEntityResolver( TQXmlEntityResolver* handler ) = 0;
+    virtual TQXmlEntityResolver* entityResolver() const = 0;
+    virtual void setDTDHandler( TQXmlDTDHandler* handler ) = 0;
+    virtual TQXmlDTDHandler* DTDHandler() const = 0;
+    virtual void setContentHandler( TQXmlContentHandler* handler ) = 0;
+    virtual TQXmlContentHandler* contentHandler() const = 0;
+    virtual void setErrorHandler( TQXmlErrorHandler* handler ) = 0;
+    virtual TQXmlErrorHandler* errorHandler() const = 0;
+    virtual void setLexicalHandler( TQXmlLexicalHandler* handler ) = 0;
+    virtual TQXmlLexicalHandler* lexicalHandler() const = 0;
+    virtual void setDeclHandler( TQXmlDeclHandler* handler ) = 0;
+    virtual TQXmlDeclHandler* declHandler() const = 0;
+    virtual bool parse( const TQXmlInputSource& input ) = 0;
+    virtual bool parse( const TQXmlInputSource* input ) = 0;
+};
+
+class TQM_EXPORT_XML TQXmlSimpleReader : public TQXmlReader
+{
+public:
+    TQXmlSimpleReader();
+    virtual ~TQXmlSimpleReader();
+
+    bool feature( const TQString& name, bool *ok = 0 ) const;
+    void setFeature( const TQString& name, bool value );
+    bool hasFeature( const TQString& name ) const;
+
+    void* property( const TQString& name, bool *ok = 0 ) const;
+    void setProperty( const TQString& name, void* value );
+    bool hasProperty( const TQString& name ) const;
+
+    void setEntityResolver( TQXmlEntityResolver* handler );
+    TQXmlEntityResolver* entityResolver() const;
+    void setDTDHandler( TQXmlDTDHandler* handler );
+    TQXmlDTDHandler* DTDHandler() const;
+    void setContentHandler( TQXmlContentHandler* handler );
+    TQXmlContentHandler* contentHandler() const;
+    void setErrorHandler( TQXmlErrorHandler* handler );
+    TQXmlErrorHandler* errorHandler() const;
+    void setLexicalHandler( TQXmlLexicalHandler* handler );
+    TQXmlLexicalHandler* lexicalHandler() const;
+    void setDeclHandler( TQXmlDeclHandler* handler );
+    TQXmlDeclHandler* declHandler() const;
+
+    bool parse( const TQXmlInputSource& input );
+    bool parse( const TQXmlInputSource* input );
+    virtual bool parse( const TQXmlInputSource* input, bool incremental );
+    virtual bool parseContinue();
+
+private:
+    // variables
+    TQXmlContentHandler *contentHnd;
+    TQXmlErrorHandler   *errorHnd;
+    TQXmlDTDHandler     *dtdHnd;
+    TQXmlEntityResolver *entityRes;
+    TQXmlLexicalHandler *lexicalHnd;
+    TQXmlDeclHandler    *declHnd;
+
+    TQXmlInputSource *inputSource;
+
+    TQChar c; // the character at reading position
+    int   lineNr; // number of line
+    int   columnNr; // position in line
+
+    int     nameArrayPos;
+    TQChar   nameArray[256]; // only used for names
+    TQString nameValue; // only used for names
+    int     refArrayPos;
+    TQChar   refArray[256]; // only used for references
+    TQString refValue; // only used for references
+    int     stringArrayPos;
+    TQChar   stringArray[256]; // used for any other strings that are parsed
+    TQString stringValue; // used for any other strings that are parsed
+
+    TQXmlSimpleReaderPrivate* d;
+
+    const TQString &string();
+    void stringClear();
+    inline void stringAddC() { stringAddC(c); }
+    void stringAddC(const TQChar&);
+    const TQString& name();
+    void nameClear();
+    inline void nameAddC() { nameAddC(c); }
+    void nameAddC(const TQChar&);
+    const TQString& ref();
+    void refClear();
+    inline void refAddC() { refAddC(c); }
+    void refAddC(const TQChar&);
+
+    // used by parseReference() and parsePEReference()
+    enum EntityRecognitionContext { InContent, InAttributeValue, InEntityValue, InDTD };
+
+    // private functions
+    bool eat_ws();
+    bool next_eat_ws();
+
+    void next();
+    bool atEnd();
+
+    void init( const TQXmlInputSource* i );
+    void initData();
+
+    bool entityExist( const TQString& ) const;
+
+    bool parseBeginOrContinue( int state, bool incremental );
+
+    bool parseProlog();
+    bool parseElement();
+    bool processElementEmptyTag();
+    bool processElementETagBegin2();
+    bool processElementAttribute();
+    bool parseMisc();
+    bool parseContent();
+
+    bool parsePI();
+    bool parseDoctype();
+    bool parseComment();
+
+    bool parseName();
+    bool parseNmtoken();
+    bool parseAttribute();
+    bool parseReference();
+    bool processReference();
+
+    bool parseExternalID();
+    bool parsePEReference();
+    bool parseMarkupdecl();
+    bool parseAttlistDecl();
+    bool parseAttType();
+    bool parseAttValue();
+    bool parseElementDecl();
+    bool parseNotationDecl();
+    bool parseChoiceSeq();
+    bool parseEntityDecl();
+    bool parseEntityValue();
+
+    bool parseString();
+
+    bool insertXmlRef( const TQString&, const TQString&, bool );
+
+    bool reportEndEntities();
+    void reportParseError( const TQString& error );
+
+    typedef bool (TQXmlSimpleReader::*ParseFunction) ();
+    void unexpectedEof( ParseFunction where, int state );
+    void parseFailed( ParseFunction where, int state );
+    void pushParseState( ParseFunction function, int state );
+
+    void setUndefEntityInAttrHack(bool b);
+
+    friend class TQXmlSimpleReaderPrivate;
+    friend class TQXmlSimpleReaderLocator;
+    friend class TQDomDocumentPrivate;
+};
+
+//
+// SAX Locator
+//
+
+class TQM_EXPORT_XML TQXmlLocator
+{
+public:
+    TQXmlLocator();
+    virtual ~TQXmlLocator();
+
+    virtual int columnNumber() = 0;
+    virtual int lineNumber() = 0;
+//    TQString getPublicId()
+//    TQString getSystemId()
+};
+
+//
+// SAX handler classes
+//
+
+class TQM_EXPORT_XML TQXmlContentHandler
+{
+public:
+    virtual void setDocumentLocator( TQXmlLocator* locator ) = 0;
+    virtual bool startDocument() = 0;
+    virtual bool endDocument() = 0;
+    virtual bool startPrefixMapping( const TQString& prefix, const TQString& uri ) = 0;
+    virtual bool endPrefixMapping( const TQString& prefix ) = 0;
+    virtual bool startElement( const TQString& namespaceURI, const TQString& localName, const TQString& qName, const TQXmlAttributes& atts ) = 0;
+    virtual bool endElement( const TQString& namespaceURI, const TQString& localName, const TQString& qName ) = 0;
+    virtual bool characters( const TQString& ch ) = 0;
+    virtual bool ignorableWhitespace( const TQString& ch ) = 0;
+    virtual bool processingInstruction( const TQString& target, const TQString& data ) = 0;
+    virtual bool skippedEntity( const TQString& name ) = 0;
+    virtual TQString errorString() = 0;
+};
+
+class TQM_EXPORT_XML TQXmlErrorHandler
+{
+public:
+    virtual bool warning( const TQXmlParseException& exception ) = 0;
+    virtual bool error( const TQXmlParseException& exception ) = 0;
+    virtual bool fatalError( const TQXmlParseException& exception ) = 0;
+    virtual TQString errorString() = 0;
+};
+
+class TQM_EXPORT_XML TQXmlDTDHandler
+{
+public:
+    virtual bool notationDecl( const TQString& name, const TQString& publicId, const TQString& systemId ) = 0;
+    virtual bool unparsedEntityDecl( const TQString& name, const TQString& publicId, const TQString& systemId, const TQString& notationName ) = 0;
+    virtual TQString errorString() = 0;
+};
+
+class TQM_EXPORT_XML TQXmlEntityResolver
+{
+public:
+    virtual bool resolveEntity( const TQString& publicId, const TQString& systemId, TQXmlInputSource*& ret ) = 0;
+    virtual TQString errorString() = 0;
+};
+
+class TQM_EXPORT_XML TQXmlLexicalHandler
+{
+public:
+    virtual bool startDTD( const TQString& name, const TQString& publicId, const TQString& systemId ) = 0;
+    virtual bool endDTD() = 0;
+    virtual bool startEntity( const TQString& name ) = 0;
+    virtual bool endEntity( const TQString& name ) = 0;
+    virtual bool startCDATA() = 0;
+    virtual bool endCDATA() = 0;
+    virtual bool comment( const TQString& ch ) = 0;
+    virtual TQString errorString() = 0;
+};
+
+class TQM_EXPORT_XML TQXmlDeclHandler
+{
+public:
+    virtual bool attributeDecl( const TQString& eName, const TQString& aName, const TQString& type, const TQString& valueDefault, const TQString& value ) = 0;
+    virtual bool internalEntityDecl( const TQString& name, const TQString& value ) = 0;
+    virtual bool externalEntityDecl( const TQString& name, const TQString& publicId, const TQString& systemId ) = 0;
+    virtual TQString errorString() = 0;
+};
+
+
+class TQM_EXPORT_XML TQXmlDefaultHandler : public TQXmlContentHandler, public TQXmlErrorHandler, public TQXmlDTDHandler, public TQXmlEntityResolver, public TQXmlLexicalHandler, public TQXmlDeclHandler
+{
+public:
+    TQXmlDefaultHandler() { }
+    virtual ~TQXmlDefaultHandler() { }
+
+    void setDocumentLocator( TQXmlLocator* locator );
+    bool startDocument();
+    bool endDocument();
+    bool startPrefixMapping( const TQString& prefix, const TQString& uri );
+    bool endPrefixMapping( const TQString& prefix );
+    bool startElement( const TQString& namespaceURI, const TQString& localName, const TQString& qName, const TQXmlAttributes& atts );
+    bool endElement( const TQString& namespaceURI, const TQString& localName, const TQString& qName );
+    bool characters( const TQString& ch );
+    bool ignorableWhitespace( const TQString& ch );
+    bool processingInstruction( const TQString& target, const TQString& data );
+    bool skippedEntity( const TQString& name );
+
+    bool warning( const TQXmlParseException& exception );
+    bool error( const TQXmlParseException& exception );
+    bool fatalError( const TQXmlParseException& exception );
+
+    bool notationDecl( const TQString& name, const TQString& publicId, const TQString& systemId );
+    bool unparsedEntityDecl( const TQString& name, const TQString& publicId, const TQString& systemId, const TQString& notationName );
+
+    bool resolveEntity( const TQString& publicId, const TQString& systemId, TQXmlInputSource*& ret );
+
+    bool startDTD( const TQString& name, const TQString& publicId, const TQString& systemId );
+    bool endDTD();
+    bool startEntity( const TQString& name );
+    bool endEntity( const TQString& name );
+    bool startCDATA();
+    bool endCDATA();
+    bool comment( const TQString& ch );
+
+    bool attributeDecl( const TQString& eName, const TQString& aName, const TQString& type, const TQString& valueDefault, const TQString& value );
+    bool internalEntityDecl( const TQString& name, const TQString& value );
+    bool externalEntityDecl( const TQString& name, const TQString& publicId, const TQString& systemId );
+
+    TQString errorString();
+
+private:
+    TQXmlDefaultHandlerPrivate *d;
+};
+
+
+//
+// inlines
+//
+
+inline bool TQXmlSimpleReader::atEnd()
+{ return (c.unicode()|0x0001) == 0xffff; }
+inline int TQXmlAttributes::count() const
+{ return length(); }
+
+
+#endif //QT_NO_XML
+
+#endif