// This is the SIP interface definition for the QDom classes.
//
// Copyright (c) 2007
// 	Riverbank Computing Limited <info@riverbankcomputing.co.uk>
// 
// This file is part of PyQt.
// 
// This copy of PyQt is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2, or (at your option) any later
// version.
// 
// PyQt is supplied in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
// details.
// 
// You should have received a copy of the GNU General Public License along with
// PyQt; see the file LICENSE.  If not, write to the Free Software Foundation,
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.


%ExportedDoc
<Sect2><Title>QDomImplementation (Qt v2.2+)</Title>
<Para>
<Literal>QDomImplementation</Literal> is fully implemented.
</Para>
</Sect2>

<Sect2><Title>QDomNode (Qt v2.2+)</Title>
<Para>
<Literal>QDomNode</Literal> is fully implemented, including the Python
<Literal>==</Literal> and <Literal>!=</Literal> operators.
</Para>
</Sect2>

<Sect2><Title>QDomNodeList (Qt v2.2+)</Title>
<Para>
<Literal>QDomNodeList</Literal> is fully implemented.
</Para>
</Sect2>

<Sect2><Title>QDomDocument (Qt v2.2+)</Title>
<FuncSynopsis>
	<FuncDef>bool <Function>setContent</Function></FuncDef>
	<ParamDef>const QCString &amp;<Parameter>buffer</Parameter></ParamDef>
	<ParamDef>bool <Parameter>namespaceProcessing</Parameter></ParamDef>
	<ParamDef>QString *<Parameter>errorMsg</Parameter> = 0</ParamDef>
	<ParamDef>int *<Parameter>errorLine</Parameter> = 0</ParamDef>
	<ParamDef>int *<Parameter>errorColumn</Parameter> = 0</ParamDef>
</FuncSynopsis>
<Para>
This takes the <Literal>buffer</Literal> and
<Literal>namespaceProcessing</Literal> parameters and returns a tuple
containing the <Literal>bool</Literal> result and the
<Literal>errorMsg</Literal>, <Literal>errorLine</Literal> and
<Literal>errorColumn</Literal> values.  (Qt v3+)
</Para>

<FuncSynopsis>
	<FuncDef>bool <Function>setContent</Function></FuncDef>
	<ParamDef>const QByteArray &amp;<Parameter>buffer</Parameter></ParamDef>
	<ParamDef>bool <Parameter>namespaceProcessing</Parameter></ParamDef>
	<ParamDef>QString *<Parameter>errorMsg</Parameter> = 0</ParamDef>
	<ParamDef>int *<Parameter>errorLine</Parameter> = 0</ParamDef>
	<ParamDef>int *<Parameter>errorColumn</Parameter> = 0</ParamDef>
</FuncSynopsis>
<Para>
This takes the <Literal>buffer</Literal> and
<Literal>namespaceProcessing</Literal> parameters and returns a tuple
containing the <Literal>bool</Literal> result and the
<Literal>errorMsg</Literal>, <Literal>errorLine</Literal> and
<Literal>errorColumn</Literal> values.  (Qt v3+)
</Para>

<FuncSynopsis>
	<FuncDef>bool <Function>setContent</Function></FuncDef>
	<ParamDef>const QString &amp;<Parameter>text</Parameter></ParamDef>
	<ParamDef>bool <Parameter>namespaceProcessing</Parameter></ParamDef>
	<ParamDef>QString *<Parameter>errorMsg</Parameter> = 0</ParamDef>
	<ParamDef>int *<Parameter>errorLine</Parameter> = 0</ParamDef>
	<ParamDef>int *<Parameter>errorColumn</Parameter> = 0</ParamDef>
</FuncSynopsis>
<Para>
This takes the <Literal>text</Literal> and
<Literal>namespaceProcessing</Literal> parameters and returns a tuple
containing the <Literal>bool</Literal> result and the
<Literal>errorMsg</Literal>, <Literal>errorLine</Literal> and
<Literal>errorColumn</Literal> values.  (Qt v3+)
</Para>

<FuncSynopsis>
	<FuncDef>bool <Function>setContent</Function></FuncDef>
	<ParamDef>const QIODevice *<Parameter>dev</Parameter></ParamDef>
	<ParamDef>bool <Parameter>namespaceProcessing</Parameter></ParamDef>
	<ParamDef>QString *<Parameter>errorMsg</Parameter> = 0</ParamDef>
	<ParamDef>int *<Parameter>errorLine</Parameter> = 0</ParamDef>
	<ParamDef>int *<Parameter>errorColumn</Parameter> = 0</ParamDef>
</FuncSynopsis>
<Para>
This takes the <Literal>dev</Literal> and
<Literal>namespaceProcessing</Literal> parameters and returns a tuple
containing the <Literal>bool</Literal> result and the
<Literal>errorMsg</Literal>, <Literal>errorLine</Literal> and
<Literal>errorColumn</Literal> values.  (Qt v3+)
</Para>

<FuncSynopsis>
	<FuncDef>bool <Function>setContent</Function></FuncDef>
	<ParamDef>const QCString &amp;<Parameter>buffer</Parameter></ParamDef>
	<ParamDef>QString *<Parameter>errorMsg</Parameter> = 0</ParamDef>
	<ParamDef>int *<Parameter>errorLine</Parameter> = 0</ParamDef>
	<ParamDef>int *<Parameter>errorColumn</Parameter> = 0</ParamDef>
</FuncSynopsis>
<Para>
This takes the <Literal>buffer</Literal> parameter only and returns a tuple
containing the <Literal>bool</Literal> result and the
<Literal>errorMsg</Literal>, <Literal>errorLine</Literal> and
<Literal>errorColumn</Literal> values.  (Qt v3+)
</Para>

<FuncSynopsis>
	<FuncDef>bool <Function>setContent</Function></FuncDef>
	<ParamDef>const QByteArray &amp;<Parameter>buffer</Parameter></ParamDef>
	<ParamDef>QString *<Parameter>errorMsg</Parameter> = 0</ParamDef>
	<ParamDef>int *<Parameter>errorLine</Parameter> = 0</ParamDef>
	<ParamDef>int *<Parameter>errorColumn</Parameter> = 0</ParamDef>
</FuncSynopsis>
<Para>
This takes the <Literal>buffer</Literal> parameter only and returns a tuple
containing the <Literal>bool</Literal> result and the
<Literal>errorMsg</Literal>, <Literal>errorLine</Literal> and
<Literal>errorColumn</Literal> values.  (Qt v3+)
</Para>

<FuncSynopsis>
	<FuncDef>bool <Function>setContent</Function></FuncDef>
	<ParamDef>const QString &amp;<Parameter>text</Parameter></ParamDef>
	<ParamDef>QString *<Parameter>errorMsg</Parameter> = 0</ParamDef>
	<ParamDef>int *<Parameter>errorLine</Parameter> = 0</ParamDef>
	<ParamDef>int *<Parameter>errorColumn</Parameter> = 0</ParamDef>
</FuncSynopsis>
<Para>
This takes the <Literal>text</Literal> parameter only and returns a tuple
containing the <Literal>bool</Literal> result and the
<Literal>errorMsg</Literal>, <Literal>errorLine</Literal> and
<Literal>errorColumn</Literal> values.  (Qt v3+)
</Para>

<FuncSynopsis>
	<FuncDef>bool <Function>setContent</Function></FuncDef>
	<ParamDef>const QIODevice *<Parameter>dev</Parameter></ParamDef>
	<ParamDef>QString *<Parameter>errorMsg</Parameter> = 0</ParamDef>
	<ParamDef>int *<Parameter>errorLine</Parameter> = 0</ParamDef>
	<ParamDef>int *<Parameter>errorColumn</Parameter> = 0</ParamDef>
</FuncSynopsis>
<Para>
This takes the <Literal>dev</Literal> parameter only and returns a tuple
containing the <Literal>bool</Literal> result and the
<Literal>errorMsg</Literal>, <Literal>errorLine</Literal> and
<Literal>errorColumn</Literal> values.  (Qt v3+)
</Para>

<FuncSynopsis>
	<FuncDef>bool <Function>setContent</Function></FuncDef>
	<ParamDef>QXmlInputSource *<Parameter>source</Parameter></ParamDef>
	<ParamDef>QXmlReader *<Parameter>reader</Parameter></ParamDef>
	<ParamDef>QString *<Parameter>errorMsg</Parameter> = 0</ParamDef>
	<ParamDef>int *<Parameter>errorLine</Parameter> = 0</ParamDef>
	<ParamDef>int *<Parameter>errorColumn</Parameter> = 0</ParamDef>
</FuncSynopsis>
<Para>
Not yet implemented.  (Qt v3.2.0+)
</Para>
</Sect2>

<Sect2><Title>QDomDocumentFragment (Qt v2.2+)</Title>
<Para>
<Literal>QDomDocumentFragment</Literal> is fully implemented.
</Para>
</Sect2>

<Sect2><Title>QDomDocumentType (Qt v2.2+)</Title>
<Para>
<Literal>QDomDocumentType</Literal> is fully implemented.
</Para>
</Sect2>

<Sect2><Title>QDomNamedNodeMap (Qt v2.2+)</Title>
<Para>
<Literal>QDomNamedNodeMap</Literal> is fully implemented.
</Para>
</Sect2>

<Sect2><Title>QDomCharacterData (Qt v2.2+)</Title>
<Para>
<Literal>QDomCharacterData</Literal> is fully implemented.
</Para>
</Sect2>

<Sect2><Title>QDomAttr (Qt v2.2+)</Title>
<Para>
<Literal>QDomAttr</Literal> is fully implemented.
</Para>
</Sect2>

<Sect2><Title>QDomElement (Qt v2.2+)</Title>
<Para>
<Literal>QDomElement</Literal> is fully implemented.
</Para>
</Sect2>

<Sect2><Title>QDomText (Qt v2.2+)</Title>
<Para>
<Literal>QDomText</Literal> is fully implemented.
</Para>
</Sect2>

<Sect2><Title>QDomComment (Qt v2.2+)</Title>
<Para>
<Literal>QDomComment</Literal> is fully implemented.
</Para>
</Sect2>

<Sect2><Title>QDomCDATASection (Qt v2.2+)</Title>
<Para>
<Literal>QDomCDATASection</Literal> is fully implemented.
</Para>
</Sect2>

<Sect2><Title>QDomNotation (Qt v2.2+)</Title>
<Para>
<Literal>QDomNotation</Literal> is fully implemented.
</Para>
</Sect2>

<Sect2><Title>QDomEntity (Qt v2.2+)</Title>
<Para>
<Literal>QDomEntity</Literal> is fully implemented.
</Para>
</Sect2>

<Sect2><Title>QDomEntityReference (Qt v2.2+)</Title>
<Para>
<Literal>QDomEntityReference</Literal> is fully implemented.
</Para>
</Sect2>

<Sect2><Title>QDomProcessingInstruction (Qt v2.2+)</Title>
<Para>
<Literal>QDomProcessingInstruction</Literal> is fully implemented.
</Para>
</Sect2>
%End


%If (Qt_DOM)
%If (Qt_2_2_0 -)

class QDomImplementation
{
%TypeHeaderCode
#include <qdom.h>
%End

public:
	QDomImplementation();
	QDomImplementation(const QDomImplementation &);

	virtual bool hasFeature(const QString &,const QString &);
%If (Qt_3_0_0 -)
	virtual QDomDocumentType createDocumentType(const QString &,
						    const QString &,
						    const QString &);
	virtual QDomDocument createDocument(const QString &,const QString &,
					    const QDomDocumentType &);
%End
	bool isNull();
};


class QDomNode
{
%TypeHeaderCode
#include <qdom.h>
%End

public:
	enum NodeType {
		ElementNode,
		AttributeNode,
		TextNode,
		CDATASectionNode,
		EntityReferenceNode,
		EntityNode,
		ProcessingInstructionNode,
		CommentNode,
		DocumentNode,
		DocumentTypeNode,
		DocumentFragmentNode,
		NotationNode,
		BaseNode,
		CharacterDataNode
	};

	QDomNode();
	QDomNode(const QDomNode &);

	bool operator==(const QDomNode &) const;
	bool operator!=(const QDomNode &) const;

	virtual QDomNode insertBefore(const QDomNode &,const QDomNode &);
	virtual QDomNode insertAfter(const QDomNode &,const QDomNode &);
	virtual QDomNode replaceChild(const QDomNode &,const QDomNode &);
	virtual QDomNode removeChild(const QDomNode &);
	virtual QDomNode appendChild(const QDomNode &);
%If (Qt_3_0_0 -)
	virtual bool hasChildNodes() const;
%End
	virtual QDomNode cloneNode(bool = 1) const;
%If (Qt_3_0_0 -)
	virtual void normalize();
	virtual bool isSupported(const QString &,const QString &) const;
%End

	virtual QString nodeName() const;
	virtual NodeType nodeType() const;
	virtual QDomNode parentNode() const;
	virtual QDomNodeList childNodes() const;
	virtual QDomNode firstChild() const;
	virtual QDomNode lastChild() const;
	virtual QDomNode previousSibling() const;
	virtual QDomNode nextSibling() const;
	virtual QDomNamedNodeMap attributes() const;
	virtual QDomDocument ownerDocument() const;
%If (Qt_3_0_0 -)
	virtual QString namespaceURI() const;
	virtual QString localName() const;
	virtual bool hasAttributes() const;
%End

	virtual QString nodeValue() const;
	virtual void setNodeValue(const QString &);
%If (Qt_3_0_0 -)
	virtual QString prefix() const;
	virtual void setPrefix(const QString &);
%End

	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;

	QDomNode namedItem(const QString &) const;

	bool isNull() const;
	void clear();

	QDomAttr toAttr();
	QDomCDATASection toCDATASection();
	QDomDocumentFragment toDocumentFragment();
	QDomDocument toDocument();
	QDomDocumentType toDocumentType();
	QDomElement toElement();
	QDomEntityReference toEntityReference();
	QDomText toText();
	QDomEntity toEntity();
	QDomNotation toNotation();
	QDomProcessingInstruction toProcessingInstruction();
	QDomCharacterData toCharacterData();
	QDomComment toComment();

	void save(QTextStream &,int) const;
};


class QDomNodeList
{
%TypeHeaderCode
#include <qdom.h>
%End

public:
	QDomNodeList();
	QDomNodeList(const QDomNodeList &);

	virtual QDomNode item(int) const;

	virtual uint length() const;
	uint count() const;
};


class QDomDocumentType : QDomNode
{
%TypeHeaderCode
#include <qdom.h>
%End

public:
	QDomDocumentType();
	QDomDocumentType(const QDomDocumentType &);

	virtual QString name() const;
	virtual QDomNamedNodeMap entities() const;
	virtual QDomNamedNodeMap notations() const;
%If (Qt_3_0_0 -)
	virtual QString publicId() const;
	virtual QString systemId() const;
	virtual QString internalSubset() const;
%End

	QDomNode::NodeType nodeType() const;
	bool isDocumentType() const;
};


class QDomDocument : QDomNode
{
%TypeHeaderCode
#include <qdom.h>
%End

public:
	QDomDocument();
	QDomDocument(const QString &);
%If (Qt_3_0_0 -)
	QDomDocument(const QDomDocumentType &);
%End
	QDomDocument(const QDomDocument &);

	QDomElement createElement(const QString &);
	QDomDocumentFragment createDocumentFragment();
	QDomText createTextNode(const QString &);
	QDomComment createComment(const QString &);
	QDomCDATASection createCDATASection(const QString &);
	QDomProcessingInstruction createProcessingInstruction(const QString &,
							      const QString &);
	QDomAttr createAttribute(const QString &);
	QDomEntityReference createEntityReference(const QString &);
	QDomNodeList elementsByTagName(const QString &) const;
%If (Qt_3_0_0 -)
	QDomElement elementById(const QString &);
%End

	QDomDocumentType doctype() const;
	QDomImplementation implementation() const;
	QDomElement documentElement() const;

%If (- Qt_3_0_0)
	bool setContent(const QCString &);
	bool setContent(const QByteArray &);
	bool setContent(const QString &);
	bool setContent(QIODevice *);
%End
%If (Qt_3_0_0 -)
	// Note that we need handwritten code for these because of the need to
	// allocate storage for the error string.
	SIP_PYTUPLE setContent(const QCString &,bool);
%MethodCode
		bool res;
		QString *emsg = new QString();
		int eline, ecol;

		Py_BEGIN_ALLOW_THREADS
		res = sipCpp -> QDomDocument::setContent(*a0,a1,emsg,&eline,&ecol);
		Py_END_ALLOW_THREADS

		sipRes = sipBuildResult(&sipIsErr,"(bNii)",res,emsg,sipClass_QString,eline,ecol);
%End

	SIP_PYTUPLE setContent(const QByteArray &,bool);
%MethodCode
		bool res;
		QString *emsg = new QString();
		int eline, ecol;
 
		Py_BEGIN_ALLOW_THREADS
		res = sipCpp -> QDomDocument::setContent(*a0,a1,emsg,&eline,&ecol);
		Py_END_ALLOW_THREADS

		sipRes = sipBuildResult(&sipIsErr,"(bNii)",res,emsg,sipClass_QString,eline,ecol);
%End

	SIP_PYTUPLE setContent(const QString &,bool);
%MethodCode
		bool res;
		QString *emsg = new QString();
		int eline, ecol;
 
		Py_BEGIN_ALLOW_THREADS
		res = sipCpp -> QDomDocument::setContent(*a0,a1,emsg,&eline,&ecol);
		Py_END_ALLOW_THREADS

		sipRes = sipBuildResult(&sipIsErr,"(bNii)",res,emsg,sipClass_QString,eline,ecol);
%End

	SIP_PYTUPLE setContent(QIODevice *,bool);
%MethodCode
		bool res;
		QString *emsg = new QString();
		int eline, ecol;

		Py_BEGIN_ALLOW_THREADS
		res = sipCpp -> QDomDocument::setContent(a0,a1,emsg,&eline,&ecol);
		Py_END_ALLOW_THREADS

		sipRes = sipBuildResult(&sipIsErr,"(bNii)",res,emsg,sipClass_QString,eline,ecol);
%End

	SIP_PYTUPLE setContent(const QCString &);
%MethodCode
		bool res;
		QString *emsg = new QString();
		int eline, ecol;

		Py_BEGIN_ALLOW_THREADS
		res = sipCpp -> QDomDocument::setContent(*a0,emsg,&eline,&ecol);
		Py_END_ALLOW_THREADS

		sipRes = sipBuildResult(&sipIsErr,"(bNii)",res,emsg,sipClass_QString,eline,ecol);
%End

	SIP_PYTUPLE setContent(const QByteArray &);
%MethodCode
		bool res;
		QString *emsg = new QString();
		int eline, ecol;
 
		Py_BEGIN_ALLOW_THREADS
		res = sipCpp -> QDomDocument::setContent(*a0,emsg,&eline,&ecol);
		Py_END_ALLOW_THREADS

		sipRes = sipBuildResult(&sipIsErr,"(bNii)",res,emsg,sipClass_QString,eline,ecol);
%End

	SIP_PYTUPLE setContent(const QString &);
%MethodCode
		bool res;
		QString *emsg = new QString();
		int eline, ecol;

		Py_BEGIN_ALLOW_THREADS
		res = sipCpp -> QDomDocument::setContent(*a0,emsg,&eline,&ecol);
		Py_END_ALLOW_THREADS

		sipRes = sipBuildResult(&sipIsErr,"(bNii)",res,emsg,sipClass_QString,eline,ecol);
%End

	SIP_PYTUPLE setContent(QIODevice *);
%MethodCode
		bool res;
		QString *emsg = new QString();
		int eline, ecol;

		Py_BEGIN_ALLOW_THREADS
		res = sipCpp -> QDomDocument::setContent(a0,emsg,&eline,&ecol);
		Py_END_ALLOW_THREADS

		sipRes = sipBuildResult(&sipIsErr,"(bNii)",res,emsg,sipClass_QString,eline,ecol);
%End

%End

%If (Qt_3_2_0 -)
//	bool setContent(QXmlInputSource *,QXmlReader *,QString * = 0,int * = 0,
//			int * = 0);
%End

	QDomNode::NodeType nodeType() const;
	bool isDocument() const;

	QString toString() const;
%If (Qt_3_1_0 -)
	QString toString(int) const;
%End
	QCString toCString() const;
%If (Qt_3_1_0 -)
	QCString toCString(int) const;
%End
};


class QDomNamedNodeMap
{
%TypeHeaderCode
#include <qdom.h>
%End

public:
	QDomNamedNodeMap();
	QDomNamedNodeMap(const QDomNamedNodeMap &);

	QDomNode namedItem(const QString &) const;
	QDomNode setNamedItem(const QDomNode &);
	QDomNode removeNamedItem(const QString &);
	QDomNode item(int) const;
%If (Qt_3_0_0 -)
	QDomNode namedItemNS(const QString &,const QString &) const;
	QDomNode setNamedItemNS(const QDomNode &);
	QDomNode removeNamedItemNS(const QString &,const QString &);
%End

	uint length() const;
%If (Qt_3_0_0 -)
	uint count() const;
%End

	bool contains(const QString &) const;
};


class QDomDocumentFragment : QDomNode
{
%TypeHeaderCode
#include <qdom.h>
%End

public:
	QDomDocumentFragment();
	QDomDocumentFragment(const QDomDocumentFragment &);

	QDomNode::NodeType nodeType() const;
	bool isDocumentFragment() const;
};


class QDomCharacterData : QDomNode
{
%TypeHeaderCode
#include <qdom.h>
%End

public:
	QDomCharacterData();
	QDomCharacterData(const QDomCharacterData &);

	virtual QString substringData(unsigned long,unsigned long);
	virtual void appendData(const QString &);
	virtual void insertData(unsigned long,const QString &);
	virtual void deleteData(unsigned long,unsigned long);
	virtual void replaceData(unsigned long,unsigned long,const QString &);

	virtual uint length() const;

	virtual QString data() const;
	virtual void setData(const QString &);

	QDomNode::NodeType nodeType() const;
	bool isCharacterData() const;
};


class QDomAttr : QDomNode
{
%TypeHeaderCode
#include <qdom.h>
%End

public:
	QDomAttr();
	QDomAttr(const QDomAttr&);

	virtual QString name() const;
	virtual bool specified() const;
%If (Qt_3_0_0 -)
	virtual QDomElement ownerElement() const;
%End

	virtual QString value() const;
	virtual void setValue(const QString &);

	QDomNode::NodeType nodeType() const;
	bool isAttr() const;
};


class QDomElement : QDomNode
{
%TypeHeaderCode
#include <qdom.h>
%End

public:
	QDomElement();
	QDomElement(const QDomElement &);

	QString attribute(const QString &,
			  const QString & = QString::null) const;
	void setAttribute(const QString &,const QString &);
	void setAttribute(const QString &,int /Constrained/);
//	void setAttribute(const QString &,uint);
%If (Qt_3_2_0 -)
//	void setAttribute(const QString &,long);
//	void setAttribute(const QString &,ulong);
%End
	void setAttribute(const QString &,double);
	void removeAttribute(const QString &);
	QDomAttr attributeNode(const QString &);
	QDomAttr setAttributeNode(const QDomAttr &);
	QDomAttr removeAttributeNode(const QDomAttr &);
	virtual QDomNodeList elementsByTagName(const QString &) const;
	bool hasAttribute(const QString &) const;
%If (- Qt_3_0_0)
	void normalize();
%End

%If (Qt_3_0_0 -)
	QString attributeNS(const QString,const QString &,
			    const QString &) const;
	void setAttributeNS(const QString,const QString &,const QString &);
	void setAttributeNS(const QString,const QString &,int /Constrained/);
//	void setAttributeNS(const QString,const QString &,uint);
%If (Qt_3_2_0 -)
//	void setAttributeNS(const QString &,const QString &,long);
//	void setAttributeNS(const QString &,const QString &,ulong);
%End
	void setAttributeNS(const QString,const QString &,double);
	void removeAttributeNS(const QString &,const QString &);
	QDomAttr attributeNodeNS(const QString &,const QString &);
	QDomAttr setAttributeNodeNS(const QDomAttr &);
	virtual QDomNodeList elementsByTagNameNS(const QString &,
						 const QString &) const;
	bool hasAttributeNS(const QString &,const QString &) const;
%End

	QString tagName() const;
	void setTagName(const QString &);

	QDomNamedNodeMap attributes() const;
	QDomNode::NodeType nodeType() const;
	bool isElement() const;

	QString text() const;
};


class QDomText : QDomCharacterData
{
%TypeHeaderCode
#include <qdom.h>
%End

public:
	QDomText();
	QDomText(const QDomText &);

	QDomText splitText(int);

	QDomNode::NodeType nodeType() const;
	bool isText() const;
};


class QDomComment : QDomCharacterData
{
%TypeHeaderCode
#include <qdom.h>
%End

public:
	QDomComment();
	QDomComment(const QDomComment &);

	QDomNode::NodeType nodeType() const;
	bool isComment() const;
};


class QDomCDATASection : QDomText
{
%TypeHeaderCode
#include <qdom.h>
%End

public:
	QDomCDATASection();
	QDomCDATASection(const QDomCDATASection&);

	QDomNode::NodeType nodeType() const;
	bool isCDATASection() const;
};


class QDomNotation : QDomNode
{
%TypeHeaderCode
#include <qdom.h>
%End

public:
	QDomNotation();
	QDomNotation(const QDomNotation &);

	QString publicId() const;
	QString systemId() const;

	QDomNode::NodeType nodeType() const;
	bool isNotation() const;
};


class QDomEntity : QDomNode
{
%TypeHeaderCode
#include <qdom.h>
%End

public:
	QDomEntity();
	QDomEntity(const QDomEntity &);

	virtual QString publicId() const;
	virtual QString systemId() const;
	virtual QString notationName() const;

	QDomNode::NodeType nodeType() const;
	bool isEntity() const;
};


class QDomEntityReference : QDomNode
{
%TypeHeaderCode
#include <qdom.h>
%End

public:
	QDomEntityReference();
	QDomEntityReference(const QDomEntityReference &);

	QDomNode::NodeType nodeType() const;
	bool isEntityReference() const;
};


class QDomProcessingInstruction : QDomNode
{
%TypeHeaderCode
#include <qdom.h>
%End

public:
	QDomProcessingInstruction();
	QDomProcessingInstruction(const QDomProcessingInstruction &);

	virtual QString target() const;

	virtual QString data() const;
	virtual void setData(const QString &);

	QDomNode::NodeType nodeType() const;
	bool isProcessingInstruction() const;
};

%End
%End