From 4c3c7eaa2d225ecc0c16644f1a23e848bf539164 Mon Sep 17 00:00:00 2001 From: tpearson Date: Mon, 2 Aug 2010 19:12:15 +0000 Subject: Starting work on Qt4 interface... git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/dependencies/tqtinterface@1158413 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- qtinterface/qt4/Qt/qdom.h | 681 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 681 insertions(+) create mode 100644 qtinterface/qt4/Qt/qdom.h (limited to 'qtinterface/qt4/Qt/qdom.h') diff --git a/qtinterface/qt4/Qt/qdom.h b/qtinterface/qt4/Qt/qdom.h new file mode 100644 index 0000000..32567f0 --- /dev/null +++ b/qtinterface/qt4/Qt/qdom.h @@ -0,0 +1,681 @@ +/**************************************************************************** +** +** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtXml module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial Usage +** Licensees holding valid Qt Commercial licenses may use this file in +** accordance with the Qt Commercial License Agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Nokia. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDOM_H +#define QDOM_H + +#include + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Xml) + +#ifndef QT_NO_DOM + +class QIODevice; +class QTextStream; + +class QXmlInputSource; +class QXmlReader; + +class QDomDocumentPrivate; +class QDomDocumentTypePrivate; +class QDomDocumentFragmentPrivate; +class QDomNodePrivate; +class QDomNodeListPrivate; +class QDomImplementationPrivate; +class QDomElementPrivate; +class QDomNotationPrivate; +class QDomEntityPrivate; +class QDomEntityReferencePrivate; +class QDomProcessingInstructionPrivate; +class QDomAttrPrivate; +class QDomCharacterDataPrivate; +class QDomTextPrivate; +class QDomCommentPrivate; +class QDomCDATASectionPrivate; +class QDomNamedNodeMapPrivate; +class QDomImplementationPrivate; + +class QDomNodeList; +class QDomElement; +class QDomText; +class QDomComment; +class QDomCDATASection; +class QDomProcessingInstruction; +class QDomAttr; +class QDomEntityReference; +class QDomDocument; +class QDomNamedNodeMap; +class QDomDocument; +class QDomDocumentFragment; +class QDomDocumentType; +class QDomImplementation; +class QDomNode; +class QDomEntity; +class QDomNotation; +class QDomCharacterData; + +class Q_XML_EXPORT QDomImplementation +{ +public: + QDomImplementation(); + QDomImplementation(const QDomImplementation&); + ~QDomImplementation(); + QDomImplementation& operator= (const QDomImplementation&); + bool operator== (const QDomImplementation&) const; + bool operator!= (const QDomImplementation&) const; + + // functions + bool hasFeature(const QString& feature, const QString& version) const; + QDomDocumentType createDocumentType(const QString& qName, const QString& publicId, const QString& systemId); + QDomDocument createDocument(const QString& nsURI, const QString& qName, const QDomDocumentType& doctype); + + enum InvalidDataPolicy { AcceptInvalidChars = 0, DropInvalidChars, ReturnNullNode }; + static InvalidDataPolicy invalidDataPolicy(); + static void setInvalidDataPolicy(InvalidDataPolicy policy); + + // Qt extension + bool isNull(); + +private: + QDomImplementationPrivate* impl; + QDomImplementation(QDomImplementationPrivate*); + + friend class QDomDocument; +}; + +class Q_XML_EXPORT QDomNode +{ +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 + }; + + enum EncodingPolicy + { + EncodingFromDocument = 1, + EncodingFromTextStream = 2 + }; + + QDomNode(); + QDomNode(const QDomNode&); + QDomNode& operator= (const QDomNode&); + bool operator== (const QDomNode&) const; + bool operator!= (const QDomNode&) const; + ~QDomNode(); + + // DOM functions + QDomNode insertBefore(const QDomNode& newChild, const QDomNode& refChild); + QDomNode insertAfter(const QDomNode& newChild, const QDomNode& refChild); + QDomNode replaceChild(const QDomNode& newChild, const QDomNode& oldChild); + QDomNode removeChild(const QDomNode& oldChild); + QDomNode appendChild(const QDomNode& newChild); + bool hasChildNodes() const; + QDomNode cloneNode(bool deep = true) const; + void normalize(); + bool isSupported(const QString& feature, const QString& version) const; + + // DOM read-only attributes + QString nodeName() const; + NodeType nodeType() const; + QDomNode parentNode() const; + QDomNodeList childNodes() const; + QDomNode firstChild() const; + QDomNode lastChild() const; + QDomNode previousSibling() const; + QDomNode nextSibling() const; + QDomNamedNodeMap attributes() const; + QDomDocument ownerDocument() const; + QString namespaceURI() const; + QString localName() const; + bool hasAttributes() const; + + // DOM attributes + QString nodeValue() const; + void setNodeValue(const QString&); + QString prefix() const; + void setPrefix(const QString& pre); + + // Qt extensions + bool isAttr() const; + bool isCDATASection() const; + bool isDocumentFragment() const; + bool isDocument() const; + bool isDocumentType() const; + bool isElement() const; + bool isEntityReference() const; + bool isText() const; + bool isEntity() const; + bool isNotation() const; + bool isProcessingInstruction() const; + bool isCharacterData() const; + bool isComment() const; + + /** + * Shortcut to avoid dealing with QDomNodeList + * all the time. + */ + QDomNode namedItem(const QString& name) const; + + bool isNull() const; + void clear(); + + QDomAttr toAttr() const; + QDomCDATASection toCDATASection() const; + QDomDocumentFragment toDocumentFragment() const; + QDomDocument toDocument() const; + QDomDocumentType toDocumentType() const; + QDomElement toElement() const; + QDomEntityReference toEntityReference() const; + QDomText toText() const; + QDomEntity toEntity() const; + QDomNotation toNotation() const; + QDomProcessingInstruction toProcessingInstruction() const; + QDomCharacterData toCharacterData() const; + QDomComment toComment() const; + + void save(QTextStream&, int) const; + void save(QTextStream&, int, EncodingPolicy) const; // ### Qt 5: Merge overload(if we at all keep this) + + QDomElement firstChildElement(const QString &tagName = QString()) const; + QDomElement lastChildElement(const QString &tagName = QString()) const; + QDomElement previousSiblingElement(const QString &tagName = QString()) const; + QDomElement nextSiblingElement(const QString &taName = QString()) const; + + int lineNumber() const; + int columnNumber() const; + +protected: + QDomNodePrivate* impl; + QDomNode(QDomNodePrivate*); + +private: + friend class QDomDocument; + friend class QDomDocumentType; + friend class QDomNodeList; + friend class QDomNamedNodeMap; +}; + +class Q_XML_EXPORT QDomNodeList +{ +public: + QDomNodeList(); + QDomNodeList(const QDomNodeList&); + QDomNodeList& operator= (const QDomNodeList&); + bool operator== (const QDomNodeList&) const; + bool operator!= (const QDomNodeList&) const; + ~QDomNodeList(); + + // DOM functions + QDomNode item(int index) const; + inline QDomNode at(int index) const { return item(index); } // Qt API consistency + + // DOM read only attributes + uint length() const; + inline int count() const { return length(); } // Qt API consitancy + inline int size() const { return length(); } // Qt API consistency + inline bool isEmpty() const { return length() == 0; } // Qt API consistency + +private: + QDomNodeListPrivate* impl; + QDomNodeList(QDomNodeListPrivate*); + + friend class QDomNode; + friend class QDomElement; + friend class QDomDocument; +}; + +class Q_XML_EXPORT QDomDocumentType : public QDomNode +{ +public: + QDomDocumentType(); + QDomDocumentType(const QDomDocumentType& x); + QDomDocumentType& operator= (const QDomDocumentType&); + + // DOM read only attributes + QString name() const; + QDomNamedNodeMap entities() const; + QDomNamedNodeMap notations() const; + QString publicId() const; + QString systemId() const; + QString internalSubset() const; + + // Overridden from QDomNode + inline QDomNode::NodeType nodeType() const { return DocumentTypeNode; } + +private: + QDomDocumentType(QDomDocumentTypePrivate*); + + friend class QDomImplementation; + friend class QDomDocument; + friend class QDomNode; +}; + +class Q_XML_EXPORT QDomDocument : public QDomNode +{ +public: + QDomDocument(); + explicit QDomDocument(const QString& name); + explicit QDomDocument(const QDomDocumentType& doctype); + QDomDocument(const QDomDocument& x); + QDomDocument& operator= (const QDomDocument&); + ~QDomDocument(); + + // DOM functions + QDomElement createElement(const QString& tagName); + QDomDocumentFragment createDocumentFragment(); + QDomText createTextNode(const QString& data); + QDomComment createComment(const QString& data); + QDomCDATASection createCDATASection(const QString& data); + QDomProcessingInstruction createProcessingInstruction(const QString& target, const QString& data); + QDomAttr createAttribute(const QString& name); + QDomEntityReference createEntityReference(const QString& name); + QDomNodeList elementsByTagName(const QString& tagname) const; + QDomNode importNode(const QDomNode& importedNode, bool deep); + QDomElement createElementNS(const QString& nsURI, const QString& qName); + QDomAttr createAttributeNS(const QString& nsURI, const QString& qName); + QDomNodeList elementsByTagNameNS(const QString& nsURI, const QString& localName); + QDomElement elementById(const QString& elementId); + + // DOM read only attributes + QDomDocumentType doctype() const; + QDomImplementation implementation() const; + QDomElement documentElement() const; + + // Overridden from QDomNode + inline QDomNode::NodeType nodeType() const { return DocumentNode; } + + // Qt extensions + bool setContent(const QByteArray& text, bool namespaceProcessing, QString *errorMsg=0, int *errorLine=0, int *errorColumn=0 ); + bool setContent(const QString& text, bool namespaceProcessing, QString *errorMsg=0, int *errorLine=0, int *errorColumn=0 ); + bool setContent(QIODevice* dev, bool namespaceProcessing, QString *errorMsg=0, int *errorLine=0, int *errorColumn=0 ); + bool setContent(QXmlInputSource *source, bool namespaceProcessing, QString *errorMsg=0, int *errorLine=0, int *errorColumn=0 ); + bool setContent(const QByteArray& text, QString *errorMsg=0, int *errorLine=0, int *errorColumn=0 ); + bool setContent(const QString& text, QString *errorMsg=0, int *errorLine=0, int *errorColumn=0 ); + bool setContent(QIODevice* dev, QString *errorMsg=0, int *errorLine=0, int *errorColumn=0 ); + bool setContent(QXmlInputSource *source, QXmlReader *reader, QString *errorMsg=0, int *errorLine=0, int *errorColumn=0 ); + + // Qt extensions + QString toString(int = 1) const; + QByteArray toByteArray(int = 1) const; + +private: + QDomDocument(QDomDocumentPrivate*); + + friend class QDomNode; +}; + +class Q_XML_EXPORT QDomNamedNodeMap +{ +public: + QDomNamedNodeMap(); + QDomNamedNodeMap(const QDomNamedNodeMap&); + QDomNamedNodeMap& operator= (const QDomNamedNodeMap&); + bool operator== (const QDomNamedNodeMap&) const; + bool operator!= (const QDomNamedNodeMap&) const; + ~QDomNamedNodeMap(); + + // DOM functions + QDomNode namedItem(const QString& name) const; + QDomNode setNamedItem(const QDomNode& newNode); + QDomNode removeNamedItem(const QString& name); + QDomNode item(int index) const; + QDomNode namedItemNS(const QString& nsURI, const QString& localName) const; + QDomNode setNamedItemNS(const QDomNode& newNode); + QDomNode removeNamedItemNS(const QString& nsURI, const QString& localName); + + // DOM read only attributes + uint length() const; + int count() const { return length(); } // Qt API consitancy + inline int size() const { return length(); } // Qt API consistency + inline bool isEmpty() const { return length() == 0; } // Qt API consistency + + // Qt extension + bool contains(const QString& name) const; + +private: + QDomNamedNodeMapPrivate* impl; + QDomNamedNodeMap(QDomNamedNodeMapPrivate*); + + friend class QDomNode; + friend class QDomDocumentType; + friend class QDomElement; +}; + +class Q_XML_EXPORT QDomDocumentFragment : public QDomNode +{ +public: + QDomDocumentFragment(); + QDomDocumentFragment(const QDomDocumentFragment& x); + QDomDocumentFragment& operator= (const QDomDocumentFragment&); + + // Overridden from QDomNode + inline QDomNode::NodeType nodeType() const { return DocumentFragmentNode; } + +private: + QDomDocumentFragment(QDomDocumentFragmentPrivate*); + + friend class QDomDocument; + friend class QDomNode; +}; + +class Q_XML_EXPORT QDomCharacterData : public QDomNode +{ +public: + QDomCharacterData(); + QDomCharacterData(const QDomCharacterData& x); + QDomCharacterData& operator= (const QDomCharacterData&); + + // DOM functions + QString substringData(unsigned long offset, unsigned long count); + void appendData(const QString& arg); + void insertData(unsigned long offset, const QString& arg); + void deleteData(unsigned long offset, unsigned long count); + void replaceData(unsigned long offset, unsigned long count, const QString& arg); + + // DOM read only attributes + uint length() const; + + // DOM attributes + QString data() const; + void setData(const QString&); + + // Overridden from QDomNode + QDomNode::NodeType nodeType() const; + +private: + QDomCharacterData(QDomCharacterDataPrivate*); + + friend class QDomDocument; + friend class QDomText; + friend class QDomComment; + friend class QDomNode; +}; + +class Q_XML_EXPORT QDomAttr : public QDomNode +{ +public: + QDomAttr(); + QDomAttr(const QDomAttr& x); + QDomAttr& operator= (const QDomAttr&); + + // DOM read only attributes + QString name() const; + bool specified() const; + QDomElement ownerElement() const; + + // DOM attributes + QString value() const; + void setValue(const QString&); + + // Overridden from QDomNode + inline QDomNode::NodeType nodeType() const { return AttributeNode; } + +private: + QDomAttr(QDomAttrPrivate*); + + friend class QDomDocument; + friend class QDomElement; + friend class QDomNode; +}; + +class Q_XML_EXPORT QDomElement : public QDomNode +{ +public: + QDomElement(); + QDomElement(const QDomElement& x); + QDomElement& operator= (const QDomElement&); + + // DOM functions + QString attribute(const QString& name, const QString& defValue = QString() ) const; + void setAttribute(const QString& name, const QString& value); + void setAttribute(const QString& name, qlonglong value); + void setAttribute(const QString& name, qulonglong value); + inline void setAttribute(const QString& name, int value) + { setAttribute(name, qlonglong(value)); } + inline void setAttribute(const QString& name, uint value) + { setAttribute(name, qulonglong(value)); } + void setAttribute(const QString& name, float value); + void setAttribute(const QString& name, double value); + void removeAttribute(const QString& name); + QDomAttr attributeNode(const QString& name); + QDomAttr setAttributeNode(const QDomAttr& newAttr); + QDomAttr removeAttributeNode(const QDomAttr& oldAttr); + QDomNodeList elementsByTagName(const QString& tagname) const; + bool hasAttribute(const QString& name) const; + + QString attributeNS(const QString nsURI, const QString& localName, const QString& defValue = QString()) const; + void setAttributeNS(const QString nsURI, const QString& qName, const QString& value); + inline void setAttributeNS(const QString nsURI, const QString& qName, int value) + { setAttributeNS(nsURI, qName, qlonglong(value)); } + inline void setAttributeNS(const QString nsURI, const QString& qName, uint value) + { setAttributeNS(nsURI, qName, qulonglong(value)); } + void setAttributeNS(const QString nsURI, const QString& qName, qlonglong value); + void setAttributeNS(const QString nsURI, const QString& qName, qulonglong value); + void setAttributeNS(const QString nsURI, const QString& qName, double value); + void removeAttributeNS(const QString& nsURI, const QString& localName); + QDomAttr attributeNodeNS(const QString& nsURI, const QString& localName); + QDomAttr setAttributeNodeNS(const QDomAttr& newAttr); + QDomNodeList elementsByTagNameNS(const QString& nsURI, const QString& localName) const; + bool hasAttributeNS(const QString& nsURI, const QString& localName) const; + + // DOM read only attributes + QString tagName() const; + void setTagName(const QString& name); // Qt extension + + // Overridden from QDomNode + QDomNamedNodeMap attributes() const; + inline QDomNode::NodeType nodeType() const { return ElementNode; } + + QString text() const; + +private: + QDomElement(QDomElementPrivate*); + + friend class QDomDocument; + friend class QDomNode; + friend class QDomAttr; +}; + +class Q_XML_EXPORT QDomText : public QDomCharacterData +{ +public: + QDomText(); + QDomText(const QDomText& x); + QDomText& operator= (const QDomText&); + + // DOM functions + QDomText splitText(int offset); + + // Overridden from QDomCharacterData + inline QDomNode::NodeType nodeType() const { return TextNode; } + +private: + QDomText(QDomTextPrivate*); + + friend class QDomCDATASection; + friend class QDomDocument; + friend class QDomNode; +}; + +class Q_XML_EXPORT QDomComment : public QDomCharacterData +{ +public: + QDomComment(); + QDomComment(const QDomComment& x); + QDomComment& operator= (const QDomComment&); + + // Overridden from QDomCharacterData + inline QDomNode::NodeType nodeType() const { return CommentNode; } + +private: + QDomComment(QDomCommentPrivate*); + + friend class QDomDocument; + friend class QDomNode; +}; + +class Q_XML_EXPORT QDomCDATASection : public QDomText +{ +public: + QDomCDATASection(); + QDomCDATASection(const QDomCDATASection& x); + QDomCDATASection& operator= (const QDomCDATASection&); + + // Overridden from QDomText + inline QDomNode::NodeType nodeType() const { return CDATASectionNode; } + +private: + QDomCDATASection(QDomCDATASectionPrivate*); + + friend class QDomDocument; + friend class QDomNode; +}; + +class Q_XML_EXPORT QDomNotation : public QDomNode +{ +public: + QDomNotation(); + QDomNotation(const QDomNotation& x); + QDomNotation& operator= (const QDomNotation&); + + // DOM read only attributes + QString publicId() const; + QString systemId() const; + + // Overridden from QDomNode + inline QDomNode::NodeType nodeType() const { return NotationNode; } + +private: + QDomNotation(QDomNotationPrivate*); + + friend class QDomDocument; + friend class QDomNode; +}; + +class Q_XML_EXPORT QDomEntity : public QDomNode +{ +public: + QDomEntity(); + QDomEntity(const QDomEntity& x); + QDomEntity& operator= (const QDomEntity&); + + // DOM read only attributes + QString publicId() const; + QString systemId() const; + QString notationName() const; + + // Overridden from QDomNode + inline QDomNode::NodeType nodeType() const { return EntityNode; } + +private: + QDomEntity(QDomEntityPrivate*); + + friend class QDomNode; +}; + +class Q_XML_EXPORT QDomEntityReference : public QDomNode +{ +public: + QDomEntityReference(); + QDomEntityReference(const QDomEntityReference& x); + QDomEntityReference& operator= (const QDomEntityReference&); + + // Overridden from QDomNode + inline QDomNode::NodeType nodeType() const { return EntityReferenceNode; } + +private: + QDomEntityReference(QDomEntityReferencePrivate*); + + friend class QDomDocument; + friend class QDomNode; +}; + +class Q_XML_EXPORT QDomProcessingInstruction : public QDomNode +{ +public: + QDomProcessingInstruction(); + QDomProcessingInstruction(const QDomProcessingInstruction& x); + QDomProcessingInstruction& operator= (const QDomProcessingInstruction&); + + // DOM read only attributes + QString target() const; + + // DOM attributes + QString data() const; + void setData(const QString& d); + + // Overridden from QDomNode + inline QDomNode::NodeType nodeType() const { return ProcessingInstructionNode; } + +private: + QDomProcessingInstruction(QDomProcessingInstructionPrivate*); + + friend class QDomDocument; + friend class QDomNode; +}; + + +Q_XML_EXPORT QTextStream& operator<<(QTextStream&, const QDomNode&); + +#endif // QT_NO_DOM + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QDOM_H -- cgit v1.2.1