diff options
Diffstat (limited to 'src/xml')
| -rw-r--r-- | src/xml/qdom.cpp | 7092 | ||||
| -rw-r--r-- | src/xml/qdom.h | 677 | ||||
| -rw-r--r-- | src/xml/qsvgdevice.cpp | 1591 | ||||
| -rw-r--r-- | src/xml/qsvgdevice_p.h | 140 | ||||
| -rw-r--r-- | src/xml/qt_xml.pri | 10 | ||||
| -rw-r--r-- | src/xml/qxml.cpp | 7635 | ||||
| -rw-r--r-- | src/xml/qxml.h | 531 |
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 ¬ationName ) ; + + 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 <h1> tag and the node created by the + <p> 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 <p> tag, previousSibling() + will return the node representing the <h1> 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 <p> tag, nextSibling() will + return the node representing the <h2> 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 <!DOCTYPE name> + 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 + <!DOCTYPE name> 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, "<" ); + len += 3; + i += 4; + } else if ( tmp[(int)i] == '"' ) { + tmp.replace( i, 1, """ ); + len += 5; + i += 6; + } else if ( tmp[(int)i] == '&' ) { + tmp.replace( i, 1, "&" ); + len += 4; + i += 5; + } else if ( tmp[(int)i] == '>' && i>=2 && tmp[(int)i-1]==']' && tmp[(int)i-2]==']' ) { + tmp.replace( i, 1, ">" ); + 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 <h1> tag, + will return "Hello TQt <xml is cool>". + + 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 "]]>" + 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, "<" ); + d = tmp.data(); + len += 4; + i += 5; + } + else if ( d[i] == '"' ) { + tmp.replace( i, 1, """ ); + d = tmp.data(); + len += 4; + i += 5; + } else if ( d[i] == '&' && i + 1 < len && d[i+1] == '#' ) { + // Dont encode < or " or &custom;. + // Only encode character references + tmp.replace( i, 1, "&" ); + 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 ¬ationName ) +{ + 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( "\"", """ ).replace( "'", "'" ) ); + } 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 |