dom_node.cpp
#include "dom/dom_doc.h"
#include "dom/dom_exception.h"
#include "dom/dom2_events.h"
#include "xml/dom_docimpl.h"
#include "xml/dom_elementimpl.h"
#include "xml/dom2_eventsimpl.h"
#include <qrect.h>
using namespace DOM;
NamedNodeMap::NamedNodeMap()
{
impl = 0;
}
NamedNodeMap::NamedNodeMap(const NamedNodeMap &other)
{
impl = other.impl;
if (impl) impl->ref();
}
NamedNodeMap::NamedNodeMap(NamedNodeMapImpl *i)
{
impl = i;
if (impl) impl->ref();
}
NamedNodeMap &NamedNodeMap::operator = (const NamedNodeMap &other)
{
if ( impl != other.impl ) {
if(impl) impl->deref();
impl = other.impl;
if(impl) impl->ref();
}
return *this;
}
NamedNodeMap::~NamedNodeMap()
{
if(impl) impl->deref();
}
Node NamedNodeMap::getNamedItem( const DOMString &name ) const
{
if (!impl) return 0;
NodeImpl::Id nid = impl->mapId(0, name.implementation(), true);
if (!nid) return 0;
return impl->getNamedItem(nid, false, name.implementation());
}
Node NamedNodeMap::setNamedItem( const Node &arg )
{
if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
if (!arg.impl) throw DOMException(DOMException::NOT_FOUND_ERR);
int exceptioncode = 0;
Node r = impl->setNamedItem(arg.impl, false,
arg.impl->nodeName().implementation(), exceptioncode);
if (exceptioncode)
throw DOMException(exceptioncode);
return r;
}
Node NamedNodeMap::removeNamedItem( const DOMString &name )
{
if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
int exceptioncode = 0;
Node r = impl->removeNamedItem(impl->mapId(0, name.implementation(), false),
false, name.implementation(), exceptioncode);
if (exceptioncode)
throw DOMException(exceptioncode);
return r;
}
Node NamedNodeMap::item( unsigned long index ) const
{
if (!impl) return 0;
return impl->item(index);
}
Node NamedNodeMap::getNamedItemNS( const DOMString &namespaceURI, const DOMString &localName ) const
{
if (!impl) return 0;
NodeImpl::Id nid = impl->mapId( namespaceURI.implementation(), localName.implementation(), true );
return impl->getNamedItem(nid, true);
}
Node NamedNodeMap::setNamedItemNS( const Node &arg )
{
if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
int exceptioncode = 0;
Node r = impl->setNamedItem(arg.impl, true, 0, exceptioncode);
if (exceptioncode)
throw DOMException(exceptioncode);
return r;
}
Node NamedNodeMap::removeNamedItemNS( const DOMString &namespaceURI, const DOMString &localName )
{
if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
int exceptioncode = 0;
NodeImpl::Id nid = impl->mapId( namespaceURI.implementation(), localName.implementation(), false );
Node r = impl->removeNamedItem(nid, true, 0, exceptioncode);
if (exceptioncode)
throw DOMException(exceptioncode);
return r;
}
unsigned long NamedNodeMap::length() const
{
if (!impl) return 0;
return impl->length();
}
// ---------------------------------------------------------------------------
Node::Node(const Node &other)
{
impl = other.impl;
if(impl) impl->ref();
}
Node::Node( NodeImpl *i )
{
impl = i;
if(impl) impl->ref();
}
Node &Node::operator = (const Node &other)
{
if(impl != other.impl) {
if(impl) impl->deref();
impl = other.impl;
if(impl) impl->ref();
}
return *this;
}
bool Node::operator == (const Node &other) const
{
return (impl == other.impl);
}
bool Node::operator != (const Node &other) const
{
return !(impl == other.impl);
}
Node::~Node()
{
if(impl) impl->deref();
}
DOMString Node::nodeName() const
{
if(impl) return impl->nodeName();
return DOMString();
}
DOMString Node::nodeValue() const
{
// ### should throw exception on plain node ?
if(impl) return impl->nodeValue();
return DOMString();
}
void Node::setNodeValue( const DOMString &_str )
{
if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
int exceptioncode = 0;
if(impl) impl->setNodeValue( _str,exceptioncode );
if (exceptioncode)
throw DOMException(exceptioncode);
}
unsigned short Node::nodeType() const
{
if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
return impl->nodeType();
}
Node Node::parentNode() const
{
if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
return impl->parentNode();
}
NodeList Node::childNodes() const
{
if (!impl) return 0;
return impl->childNodes();
}
Node Node::firstChild() const
{
if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
return impl->firstChild();
}
Node Node::lastChild() const
{
if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
return impl->lastChild();
}
Node Node::previousSibling() const
{
if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
return impl->previousSibling();
}
Node Node::nextSibling() const
{
if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
return impl->nextSibling();
}
NamedNodeMap Node::attributes() const
{
if (!impl || !impl->isElementNode()) return 0;
return static_cast<ElementImpl*>(impl)->attributes();
}
Document Node::ownerDocument() const
{
// braindead DOM spec says that ownerDocument
// should return null if called on the document node
// we don't do that in the *impl tree to avoid excessive if()'s
// so we simply hack it here in one central place.
if (!impl || impl->getDocument() == impl) return Document(false);
return impl->getDocument();
}
Node Node::insertBefore( const Node &newChild, const Node &refChild )
{
if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
int exceptioncode = 0;
NodeImpl *r = impl->insertBefore( newChild.impl, refChild.impl, exceptioncode );
if (exceptioncode)
throw DOMException(exceptioncode);
if (!newChild.impl->closed()) newChild.impl->close();
return r;
}
Node Node::replaceChild( const Node &newChild, const Node &oldChild )
{
if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
int exceptioncode = 0;
impl->replaceChild( newChild.impl, oldChild.impl, exceptioncode );
if (exceptioncode)
throw DOMException(exceptioncode);
if (newChild.impl && !newChild.impl->closed()) newChild.impl->close();
return oldChild;
}
Node Node::removeChild( const Node &oldChild )
{
if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
int exceptioncode = 0;
impl->removeChild( oldChild.impl, exceptioncode );
if (exceptioncode)
throw DOMException(exceptioncode);
return oldChild;
}
Node Node::appendChild( const Node &newChild )
{
if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
int exceptioncode = 0;
NodeImpl *r = impl->appendChild( newChild.impl, exceptioncode );
if (exceptioncode)
throw DOMException(exceptioncode);
if (!newChild.impl->closed()) newChild.impl->close();
return r;
}
bool Node::hasAttributes()
{
if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
if (!impl->isElementNode()) return false;
ElementImpl* e = static_cast<ElementImpl*>(impl);
return e->attributes(true) && e->attributes(true)->length();
}
bool Node::hasChildNodes( )
{
if (!impl) return false;
return impl->hasChildNodes();
}
Node Node::cloneNode( bool deep )
{
if (!impl) return 0;
return impl->cloneNode( deep );
}
void Node::normalize ( )
{
if (!impl) return;
impl->normalize();
}
bool Node::isSupported( const DOMString &feature,
const DOMString & /*version*/ ) const
{
DOMString upFeature = feature.upper();
return (upFeature == "HTML" ||
upFeature == "XML" ||
upFeature == "CORE");
}
DOMString Node::namespaceURI( ) const
{
if (!impl) return DOMString();
return impl->namespaceURI();
}
DOMString Node::prefix( ) const
{
if (!impl) return DOMString();
return impl->prefix();
}
void Node::setPrefix(const DOMString &prefix )
{
if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
int exceptioncode = 0;
impl->setPrefix(prefix,exceptioncode);
if (exceptioncode)
throw DOMException(exceptioncode);
}
DOMString Node::localName( ) const
{
if (!impl) return DOMString();
return impl->localName();
}
void Node::addEventListener(const DOMString &type,
EventListener *listener,
const bool useCapture)
{
if (!impl) return;
if (listener)
impl->addEventListener(EventImpl::typeToId(type),listener,useCapture);
}
void Node::removeEventListener(const DOMString &type,
EventListener *listener,
bool useCapture)
{
if (!impl) return;
impl->removeEventListener(EventImpl::typeToId(type),listener,useCapture);
}
bool Node::dispatchEvent(const Event &evt)
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
if (!evt.handle())
throw DOMException(DOMException::NOT_FOUND_ERR);
int exceptioncode = 0;
impl->dispatchEvent(evt.handle(),exceptioncode);
if (exceptioncode)
throw DOMException(exceptioncode);
return !evt.handle()->defaultPrevented();
}
unsigned int Node::elementId() const
{
if (!impl) return 0;
return impl->id();
}
unsigned long Node::index() const
{
if (!impl) return 0;
return impl->nodeIndex();
}
QString Node::toHTML()
{
if (!impl) return QString::null;
return impl->toString().string();
}
void Node::applyChanges()
{
if (!impl) return;
impl->recalcStyle( NodeImpl::Inherit );
}
void Node::getCursor(int offset, int &_x, int &_y, int &height)
{
if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
int dummy;
impl->getCaret(offset, false, _x, _y, dummy, height);
}
QRect Node::getRect()
{
if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
return impl->getRect();
}
DOMString Node::textContent( ) const
{
if(impl) return impl->textContent();
return DOMString();
}
void Node::setTextContent(const DOMString &content) const
{
if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
int exceptioncode = 0;
impl->setTextContent( content, exceptioncode );
if (exceptioncode)
throw DOMException(exceptioncode);
}
//-----------------------------------------------------------------------------
NodeList::NodeList()
{
impl = 0;
}
NodeList::NodeList(const NodeList &other)
{
impl = other.impl;
if(impl) impl->ref();
}
NodeList::NodeList(const NodeListImpl *i)
{
impl = const_cast<NodeListImpl *>(i);
if(impl) impl->ref();
}
NodeList &NodeList::operator = (const NodeList &other)
{
if ( impl != other.impl ) {
if(impl) impl->deref();
impl = other.impl;
if(impl) impl->ref();
}
return *this;
}
NodeList::~NodeList()
{
if(impl) impl->deref();
}
Node NodeList::item( unsigned long index ) const
{
if (!impl) return 0;
return impl->item(index);
}
unsigned long NodeList::length() const
{
if (!impl) return 0;
return impl->length();
}
DOM::NamedNodeMap::getNamedItemNS
Node getNamedItemNS(const DOMString &namespaceURI, const DOMString &localName) const
Introduced in DOM Level 2.
Definition: dom_node.cpp:103
DOM::Node::lastChild
Node lastChild() const
The last child of this node.
Definition: dom_node.cpp:223
DOM::Node::textContent
DOMString textContent() const
Introduced in DOM Level 3.
Definition: dom_node.cpp:435
DOM::Node::insertBefore
Node insertBefore(const Node &newChild, const Node &refChild)
Inserts the node newChild before the existing child node refChild .
Definition: dom_node.cpp:258
DOM::Node
The Node interface is the primary datatype for the entire Document Object Model.
Definition: dom_node.h:274
DOM::Node::dispatchEvent
bool dispatchEvent(const Event &evt)
Introduced in DOM Level 2 This method is from the EventTarget interface.
Definition: dom_node.cpp:382
DOM::Node::nodeName
DOMString nodeName() const
The name of this node, depending on its type; see the table above.
Definition: dom_node.cpp:176
DOM::NamedNodeMap::removeNamedItem
Node removeNamedItem(const DOMString &name)
Removes a node specified by name.
Definition: dom_node.cpp:86
DOM::Node::prefix
DOMString prefix() const
Introduced in DOM Level 2.
Definition: dom_node.cpp:344
DOM::Node::previousSibling
Node previousSibling() const
The node immediately preceding this node.
Definition: dom_node.cpp:229
DOM::Node::setNodeValue
void setNodeValue(const DOMString &)
see nodeValue NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
Definition: dom_node.cpp:189
DOM::Node::appendChild
Node appendChild(const Node &newChild)
Adds the node newChild to the end of the list of children of this node.
Definition: dom_node.cpp:292
DOM::Node::removeEventListener
void removeEventListener(const DOMString &type, EventListener *listener, bool useCapture)
Introduced in DOM Level 2 This method is from the EventTarget interface.
Definition: dom_node.cpp:374
DOM::Node::getRect
QRect getRect()
not part of the DOM.
Definition: dom_node.cpp:429
DOM::Node::attributes
NamedNodeMap attributes() const
A NamedNodeMap containing the attributes of this node (if it is an Element ) or null otherwise...
Definition: dom_node.cpp:241
DOM::Node::hasChildNodes
bool hasChildNodes()
This is a convenience method to allow easy determination of whether a node has any children...
Definition: dom_node.cpp:311
DOM::DOMException
DOM operations only raise exceptions in "exceptional" circumstances, i.e., when an operation is impos...
Definition: dom_exception.h:57
DOM::Node::replaceChild
Node replaceChild(const Node &newChild, const Node &oldChild)
Replaces the child node oldChild with newChild in the list of children, and returns the oldChild node...
Definition: dom_node.cpp:269
DOM::Node::childNodes
NodeList childNodes() const
A NodeList that contains all children of this node.
Definition: dom_node.cpp:211
DOM::NamedNodeMap
Objects implementing the NamedNodeMap interface are used to represent collections of nodes that can b...
Definition: dom_node.h:66
DOM::Node::isSupported
bool isSupported(const DOMString &feature, const DOMString &version) const
Introduced in DOM Level 2.
Definition: dom_node.cpp:329
DOM::Node::parentNode
Node parentNode() const
The parent of this node.
Definition: dom_node.cpp:205
DOM::NodeList::item
Node item(unsigned long index) const
Returns the index th item in the collection.
Definition: dom_node.cpp:485
DOM::Node::localName
DOMString localName() const
Introduced in DOM Level 2.
Definition: dom_node.cpp:359
DOM::DOMString
This class implements the basic string we use in the DOM.
Definition: dom_string.h:43
DOM::Node::nodeValue
DOMString nodeValue() const
The value of this node, depending on its type; see the table above.
Definition: dom_node.cpp:182
DOM::Node::removeChild
Node removeChild(const Node &oldChild)
Removes the child node indicated by oldChild from the list of children, and returns it...
Definition: dom_node.cpp:281
DOM::Document
The Document interface represents the entire HTML or XML document.
Definition: dom_doc.h:245
DOM::Node::ownerDocument
Document ownerDocument() const
The Document object associated with this node.
Definition: dom_node.cpp:247
DOM::Node::addEventListener
void addEventListener(const DOMString &type, EventListener *listener, const bool useCapture)
Introduced in DOM Level 2 This method is from the EventTarget interface.
Definition: dom_node.cpp:365
DOM::NamedNodeMap::setNamedItemNS
Node setNamedItemNS(const Node &arg)
Introduced in DOM Level 2.
Definition: dom_node.cpp:110
DOM::Node::cloneNode
Node cloneNode(bool deep)
Returns a duplicate of this node, i.e., serves as a generic copy constructor for nodes.
Definition: dom_node.cpp:317
DOM::NamedNodeMap::item
Node item(unsigned long index) const
Returns the index th item in the map.
Definition: dom_node.cpp:97
DOM::Node::normalize
void normalize()
Modified in DOM Level 2.
Definition: dom_node.cpp:323
DOM::Node::firstChild
Node firstChild() const
The first child of this node.
Definition: dom_node.cpp:217
DOM::NodeList
The NodeList interface provides the abstraction of an ordered collection of nodes, without defining or constraining how this collection is implemented.
Definition: dom_node.h:931
DOM::EventListener
Introduced in DOM Level 2.
Definition: dom2_events.h:64
DOM::Event
Introduced in DOM Level 2.
Definition: dom2_events.h:111
DOM::Node::getCursor
void getCursor(int offset, int &_x, int &_y, int &height) KDE_DEPRECATED
Definition: dom_node.cpp:422
DOM::NamedNodeMap::getNamedItem
Node getNamedItem(const DOMString &name) const
Retrieves a node specified by name.
Definition: dom_node.cpp:66
DOM::NamedNodeMap::length
unsigned long length() const
The number of nodes in the map.
Definition: dom_node.cpp:131
DOM::Node::namespaceURI
DOMString namespaceURI() const
Introduced in DOM Level 2.
Definition: dom_node.cpp:338
DOM::Node::hasAttributes
bool hasAttributes()
Returns whether this node (if it is an element) has any attributes.
Definition: dom_node.cpp:303
DOM::Node::setTextContent
void setTextContent(const DOMString &content) const
Introduced in DOM Level 3.
Definition: dom_node.cpp:441
DOM::Node::setPrefix
void setPrefix(const DOMString &prefix)
see prefix
Definition: dom_node.cpp:350
DOM::NamedNodeMap::removeNamedItemNS
Node removeNamedItemNS(const DOMString &namespaceURI, const DOMString &localName)
Introduced in DOM Level 2.
Definition: dom_node.cpp:120
DOM::Node::nextSibling
Node nextSibling() const
The node immediately following this node.
Definition: dom_node.cpp:235
DOM::NamedNodeMap::setNamedItem
Node setNamedItem(const Node &arg)
Adds a node using its nodeName attribute.
Definition: dom_node.cpp:74
DOM::NodeList::length
unsigned long length() const
The number of nodes in the list.
Definition: dom_node.cpp:491
DOM::DOMString::upper
DOMString upper() const
Returns an uppercase version of the string.
Definition: dom_string.cpp:179
DOM::Node::nodeType
unsigned short nodeType() const
A code representing the type of the underlying object, as defined above.
Definition: dom_node.cpp:199

KDE Home | KDE Accessibility Home | Description of Access Keys