![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
diff --git a/src/dom/domimpl.h b/src/dom/domimpl.h
--- a/src/dom/domimpl.h
+++ b/src/dom/domimpl.h
class DOMImplementationSourceImpl;
class DOMImplementationImpl;
class NodeImpl;
+typedef Ptr<NodeImpl> NodeImplPtr;
class CharacterDataImpl;
class AttrImpl;
+typedef Ptr<AttrImpl> AttrImplPtr;
class ElementImpl;
+typedef Ptr<ElementImpl> ElementImplPtr;
class TextImpl;
class CommentImpl;
class TypeInfoImpl;
class DOMConfigurationImpl;
class CDATASectionImpl;
class DocumentTypeImpl;
+typedef Ptr<DocumentTypeImpl> DocumentTypeImplPtr;
class NotationImpl;
class EntityImpl;
class EntityReferenceImpl;
class ProcessingInstructionImpl;
class DocumentFragmentImpl;
class DocumentImpl;
+typedef Ptr<DocumentImpl> DocumentImplPtr;
/**
*
*/
- virtual DocumentType *createDocumentType(const DOMString& qualifiedName,
+ virtual DocumentTypePtr createDocumentType(const DOMString& qualifiedName,
const DOMString& publicId,
const DOMString& systemId)
throw(DOMException);
/**
*
*/
- virtual Document *createDocument(const DOMString& namespaceURI,
+ virtual DocumentPtr createDocument(const DOMString& namespaceURI,
const DOMString& qualifiedName,
- DocumentType *doctype)
+ DocumentTypePtr doctype)
throw(DOMException);
/**
*
/**
*
*/
- virtual Node *getParentNode();
+ virtual NodePtr getParentNode();
/**
*
/**
*
*/
- virtual Node *getFirstChild();
+ virtual NodePtr getFirstChild();
/**
*
*/
- virtual Node *getLastChild();
+ virtual NodePtr getLastChild();
/**
*
*/
- virtual Node *getPreviousSibling();
+ virtual NodePtr getPreviousSibling();
/**
*
*/
- virtual Node *getNextSibling();
+ virtual NodePtr getNextSibling();
/**
*
/**
*
*/
- virtual Document *getOwnerDocument();
+ virtual DocumentPtr getOwnerDocument();
/**
*
*/
- virtual Node *insertBefore(const Node *newChild,
- const Node *refChild)
+ virtual NodePtr insertBefore(const NodePtr newChild,
+ const NodePtr refChild)
throw(DOMException);
/**
*
*/
- virtual Node *replaceChild(const Node *newChild,
- const Node *oldChild)
+ virtual NodePtr replaceChild(const NodePtr newChild,
+ const NodePtr oldChild)
throw(DOMException);
/**
*
*/
- virtual Node *removeChild(const Node *oldChild)
+ virtual NodePtr removeChild(const NodePtr oldChild)
throw(DOMException);
/**
*
*/
- virtual Node *appendChild(const Node *newChild)
+ virtual NodePtr appendChild(const NodePtr newChild)
throw(DOMException);
/**
/**
*
*/
- virtual Node *cloneNode(bool deep);
+ virtual NodePtr cloneNode(bool deep);
/**
*
/**
*
*/
- virtual unsigned short compareDocumentPosition(const Node *other);
+ virtual unsigned short compareDocumentPosition(const NodePtr other);
/**
*
*/
- virtual DOMString getTextContext() throw(DOMException);
+ virtual DOMString getTextContent() throw(DOMException);
/**
*
*/
- virtual void setTextContext(const DOMString &val) throw(DOMException);
+ virtual void setTextContent(const DOMString &val) throw(DOMException);
/**
/**
*
*/
- virtual bool isEqualNode(const Node *node);
+ virtual bool isEqualNode(const NodePtr node);
/**
*
*/
- virtual DOMUserData *getUserData(const DOMString &namespaceURI);
+ virtual DOMUserData *getUserData(const DOMString &key);
//##################
DOMString ret = iter->second;
return ret;
}
- if (parent)
+ if (parent.get())
{
DOMString ret = parent->bindingsFind(prefix);
if (ret.size() > 0)
*
*/
DOMString lookupNamespacePrefix(const DOMString &namespaceURI,
- Node *originalElement);
+ NodePtr originalElement);
/**
*
*/
/**
*
*/
- NodeImpl(DocumentImpl *owner);
+ NodeImpl(const NodeImpl &other);
/**
*
*/
- NodeImpl(DocumentImpl *owner, const DOMString &nodeName);
+ NodeImpl &operator=(const NodeImpl &other);
/**
*
*/
- NodeImpl(DocumentImpl *owner, const DOMString &namespaceURI, const DOMString &nodeName);
+ NodeImpl(DocumentImplPtr owner);
+
+ /**
+ *
+ */
+ NodeImpl(DocumentImplPtr owner, const DOMString &nodeName);
+
+ /**
+ *
+ */
+ NodeImpl(DocumentImplPtr owner, const DOMString &namespaceURI,
+ const DOMString &nodeName);
/**
*
unsigned short nodeType;
- NodeImpl *parent;
+ NodeImplPtr parent;
- NodeImpl *prev;
+ NodeImplPtr prev;
- NodeImpl *next;
+ NodeImplPtr next;
DOMUserData *userData;
DOMString nodeValue;
- NodeImpl *firstChild;
- NodeImpl *lastChild;
+ NodeImplPtr firstChild;
+ NodeImplPtr lastChild;
- DocumentImpl *ownerDocument;
+ DocumentImplPtr ownerDocument;
NamedNodeMap attributes;
UserDataEntry(const DOMString &theKey,
const DOMUserData *theData,
const UserDataHandler *theHandler)
- {
+ {
next = NULL;
key = theKey;
data = (DOMUserData *)theData;
handler = (UserDataHandler *)theHandler;
- }
- ~UserDataEntry()
- {
+ }
+
+ virtual ~UserDataEntry()
+ {
//delete anything after me, too
if (next)
delete next;
- }
+ }
UserDataEntry *next;
DOMString key;
};
UserDataEntry *userDataEntries;
+
+ TypeInfo typeInfo;
//### Our prefix->namespaceURI bindings
/**
*
*/
- CharacterDataImpl(DocumentImpl *owner, const DOMString &value);
+ CharacterDataImpl(DocumentImplPtr owner, const DOMString &value);
/**
*
/**
*
*/
- virtual Element *getOwnerElement();
+ virtual ElementPtr getOwnerElement();
/**
*
*/
- virtual TypeInfo *getSchemaTypeInfo();
+ virtual TypeInfo &getSchemaTypeInfo();
/**
/**
*
*/
- virtual void setOwnerElement(const Element *elem);
+ virtual void setOwnerElement(const ElementPtr elem);
/**
*
*/
- AttrImpl(DocumentImpl *owner, const DOMString &name);
+ AttrImpl(DocumentImplPtr owner, const DOMString &name);
/**
*
*/
- AttrImpl(DocumentImpl *owner, const DOMString &namespaceURI, const DOMString &name);
+ AttrImpl(DocumentImplPtr owner, const DOMString &namespaceURI,
+ const DOMString &name);
/**
*
protected:
- Element *ownerElement;
+ ElementPtr ownerElement;
};
/**
*
*/
- virtual Attr *getAttributeNode(const DOMString& name);
+ virtual AttrPtr getAttributeNode(const DOMString& name);
/**
*
*/
- virtual Attr *setAttributeNode(Attr *newAttr)
+ virtual AttrPtr setAttributeNode(AttrPtr newAttr)
throw(DOMException);
/**
*
*/
- virtual Attr *removeAttributeNode(Attr *oldAttr)
+ virtual AttrPtr removeAttributeNode(AttrPtr oldAttr)
throw(DOMException);
/**
/**
*
*/
- virtual Attr *getAttributeNodeNS(const DOMString& namespaceURI,
+ virtual AttrPtr getAttributeNodeNS(const DOMString& namespaceURI,
const DOMString& localName);
/**
*
*/
- virtual Attr *setAttributeNodeNS(Attr *newAttr)
+ virtual AttrPtr setAttributeNodeNS(AttrPtr newAttr)
throw(DOMException);
/**
/**
*
*/
- virtual TypeInfo *getSchemaTypeInto();
+ virtual TypeInfo &getSchemaTypeInfo();
/**
/**
*
*/
- virtual void setIdAttributeNode(const Attr *idAttr,
+ virtual void setIdAttributeNode(const AttrPtr idAttr,
bool isId) throw (DOMException);
/**
*
*/
- ElementImpl(DocumentImpl *owner, const DOMString &tagName);
+ ElementImpl(DocumentImplPtr owner, const DOMString &tagName);
/**
*
*/
- ElementImpl(DocumentImpl *owner, const DOMString &namespaceURI, const DOMString &tagName);
+ ElementImpl(DocumentImplPtr owner, const DOMString &namespaceURI,
+ const DOMString &tagName);
/**
*
friend class DocumentImpl;
static void getElementsByTagNameRecursive(NodeList &list,
- const DOMString& name, Element *elem);
+ const DOMString& name, ElementPtr elem);
static void getElementsByTagNameNSRecursive(NodeList &list,
- const DOMString& namespaceURI, const DOMString& tagName, Element *elem);
+ const DOMString& namespaceURI, const DOMString& tagName,
+ ElementPtr elem);
};
/**
*
*/
- virtual Text *splitText(unsigned long offset)
+ virtual TextPtr splitText(unsigned long offset)
throw(DOMException);
/**
/**
*
*/
- virtual Text *replaceWholeText(const DOMString &content)
+ virtual TextPtr replaceWholeText(const DOMString &content)
throw(DOMException);
//##################
/**
*
*/
- TextImpl(DocumentImpl *owner, const DOMString &val);
+ TextImpl(DocumentImplPtr owner, const DOMString &val);
/**
*
/**
*
*/
- CommentImpl(DocumentImpl *owner, const DOMString &theValue);
+ CommentImpl(DocumentImplPtr owner, const DOMString &theValue);
/**
*
virtual void handle(unsigned short operation,
const DOMString &key,
const DOMUserData *data,
- const Node *src,
- const Node *dst);
+ const NodePtr src,
+ const NodePtr dst);
//##################
//# Non-API methods
/**
*
*/
- virtual Node *getRelatedNode();
+ virtual NodePtr getRelatedNode();
/**
long utf16Offset;
- Node *relatedNode;
+ NodePtr relatedNode;
DOMString uri;
};
/**
*
*/
- CDATASectionImpl(DocumentImpl *owner, const DOMString &value);
+ CDATASectionImpl(DocumentImplPtr owner, const DOMString &value);
/**
*
/**
*
*/
- NotationImpl(DocumentImpl *owner);
+ NotationImpl(DocumentImplPtr owner);
/**
*
/**
*
*/
- EntityImpl(DocumentImpl *owner);
+ EntityImpl(DocumentImplPtr owner);
/**
*
/**
*
*/
- EntityReferenceImpl(DocumentImpl *owner, const DOMString &theName);
+ EntityReferenceImpl(DocumentImplPtr owner, const DOMString &theName);
/**
*
/**
*
*/
-class ProcessingInstructionImpl : public ProcessingInstruction, public NodeImpl
+class ProcessingInstructionImpl :
+ public ProcessingInstruction,
+ public NodeImpl
{
public:
/**
*
*/
- ProcessingInstructionImpl(DocumentImpl *owner,
+ ProcessingInstructionImpl(DocumentImplPtr owner,
const DOMString &target,
const DOMString &data);
/**
*
*/
- DocumentFragmentImpl(DocumentImpl *owner);
+ DocumentFragmentImpl(DocumentImplPtr owner);
/**
*
/**
*
*/
- virtual DocumentType *getDoctype();
+ virtual DocumentTypePtr getDoctype();
/**
*
/**
*
*/
- virtual Element *getDocumentElement();
+ virtual ElementPtr getDocumentElement();
/**
*
*/
- virtual Element *createElement(const DOMString& tagName)
+ virtual ElementPtr createElement(const DOMString& tagName)
throw(DOMException);
/**
*
*/
- virtual DocumentFragment *createDocumentFragment();
+ virtual DocumentFragmentPtr createDocumentFragment();
/**
*
*/
- virtual Text *createTextNode(const DOMString& data);
+ virtual TextPtr createTextNode(const DOMString& data);
/**
*
*/
- virtual Comment *createComment(const DOMString& data);
+ virtual CommentPtr createComment(const DOMString& data);
/**
*
*/
- virtual CDATASection *createCDATASection(const DOMString& data)
+ virtual CDATASectionPtr createCDATASection(const DOMString& data)
throw(DOMException);
/**
*
*/
- virtual ProcessingInstruction *createProcessingInstruction(const DOMString& target,
- const DOMString& data)
- throw(DOMException);
+ virtual ProcessingInstructionPtr createProcessingInstruction(
+ const DOMString& target,
+ const DOMString& data)
+ throw(DOMException);
/**
*
*/
- virtual Attr *createAttribute(const DOMString& name)
+ virtual AttrPtr createAttribute(const DOMString& name)
throw(DOMException);
/**
*
*/
- virtual EntityReference *createEntityReference(const DOMString& name)
+ virtual EntityReferencePtr createEntityReference(const DOMString& name)
throw(DOMException);
/**
/**
*
*/
- virtual Node *importNode(const Node *importedNode,
+ virtual NodePtr importNode(const NodePtr importedNode,
bool deep)
throw(DOMException);
/**
*
*/
- virtual Element *createElementNS(const DOMString& namespaceURI,
+ virtual ElementPtr createElementNS(const DOMString& namespaceURI,
const DOMString& qualifiedName)
throw(DOMException);
/**
*
*/
- virtual Attr *createAttributeNS(const DOMString& namespaceURI,
+ virtual AttrPtr createAttributeNS(const DOMString& namespaceURI,
const DOMString& qualifiedName)
throw(DOMException);
/**
*
*/
- virtual Element *getElementById(const DOMString& elementId);
+ virtual ElementPtr getElementById(const DOMString& elementId);
/**
/**
*
*/
- virtual Node *adoptNode(const Node *source) throw (DOMException);
+ virtual NodePtr adoptNode(const NodePtr source) throw (DOMException);
/**
*
/**
*
*/
- virtual Node *renameNode(const Node *n,
+ virtual NodePtr renameNode(const NodePtr n,
const DOMString &name,
const DOMString &qualifiedName)
throw (DOMException);
//##################
DocumentImpl(const DOMImplementation *domImpl,
- const DOMString &namespaceURI,
- const DOMString &qualifiedName,
- const DocumentType *doctype);
+ const DOMString &namespaceURI,
+ const DOMString &qualifiedName,
+ const DocumentTypePtr doctype);
virtual ~DocumentImpl();
DOMImplementation *parent;
- DOMString *documentURI;
+ DOMString documentURI;
DOMString qualifiedName;
- DocumentType *doctype;
+ DocumentTypePtr doctype;
- ElementImpl *documentElement;
+ ElementImplPtr documentElement;
class NamedElementItem
{
{
next = NULL;
}
- NamedElementItem(const DOMString &nameArg, Element *elemArg)
+ NamedElementItem(const DOMString &nameArg, ElementPtr elemArg)
{
next = NULL;
name = nameArg;
}
NamedElementItem *next;
DOMString name;
- Element *elem;
+ ElementPtr elem;
};
NamedElementItem elementsById;