khtml Library API Documentation

dom_node.cpp

00001 
00024 #include "dom/dom_doc.h"
00025 #include "dom/dom_exception.h"
00026 #include "dom/dom2_events.h"
00027 #include "xml/dom_docimpl.h"
00028 #include "xml/dom_elementimpl.h"
00029 #include "xml/dom2_eventsimpl.h"
00030 
00031 #include <qrect.h>
00032 
00033 using namespace DOM;
00034 
00035 NamedNodeMap::NamedNodeMap()
00036 {
00037     impl = 0;
00038 }
00039 
00040 NamedNodeMap::NamedNodeMap(const NamedNodeMap &other)
00041 {
00042     impl = other.impl;
00043     if (impl) impl->ref();
00044 }
00045 
00046 NamedNodeMap::NamedNodeMap(NamedNodeMapImpl *i)
00047 {
00048     impl = i;
00049     if (impl) impl->ref();
00050 }
00051 
00052 NamedNodeMap &NamedNodeMap::operator = (const NamedNodeMap &other)
00053 {
00054     if ( impl != other.impl ) {
00055         if(impl) impl->deref();
00056         impl = other.impl;
00057         if(impl) impl->ref();
00058     }
00059     return *this;
00060 }
00061 
00062 NamedNodeMap::~NamedNodeMap()
00063 {
00064     if(impl) impl->deref();
00065 }
00066 
00067 Node NamedNodeMap::getNamedItem( const DOMString &name ) const
00068 {
00069     return getNamedItemNS(DOMString(), name);
00070 }
00071 
00072 Node NamedNodeMap::setNamedItem( const Node &arg )
00073 {
00074     return setNamedItemNS(arg);
00075 }
00076 
00077 Node NamedNodeMap::removeNamedItem( const DOMString &name )
00078 {
00079     return removeNamedItemNS(DOMString(), name);
00080 }
00081 
00082 Node NamedNodeMap::item( unsigned long index ) const
00083 {
00084     if (!impl) return 0;
00085     return impl->item(index);
00086 }
00087 
00088 Node NamedNodeMap::getNamedItemNS( const DOMString &namespaceURI, const DOMString &localName ) const
00089 {
00090     if (!impl) return 0;
00091     return impl->getNamedItem(impl->mapId(namespaceURI, localName, true));
00092 }
00093 
00094 Node NamedNodeMap::setNamedItemNS( const Node &arg )
00095 {
00096     if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
00097     int exceptioncode = 0;
00098     Node r = impl->setNamedItem(arg.impl, exceptioncode);
00099     if (exceptioncode)
00100         throw DOMException(exceptioncode);
00101     return r;
00102 }
00103 
00104 Node NamedNodeMap::removeNamedItemNS( const DOMString &namespaceURI, const DOMString &localName )
00105 {
00106     if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
00107     int exceptioncode = 0;
00108     NodeImpl::Id id = impl->mapId(namespaceURI, localName, true);
00109     NodeImpl* oldItem = impl->getNamedItem(id);
00110     if (!oldItem) throw DOMException(DOMException::NOT_FOUND_ERR);
00111 
00112     Node r(oldItem->cloneNode(true));
00113     impl->removeNamedItem(id, exceptioncode);
00114     if (exceptioncode)
00115         throw DOMException(exceptioncode);
00116     return r;
00117 }
00118 
00119 unsigned long NamedNodeMap::length() const
00120 {
00121     if (!impl) return 0;
00122     return impl->length();
00123 }
00124 
00125 NamedNodeMapImpl *NamedNodeMap::handle() const throw()
00126 {
00127     return impl;
00128 }
00129 
00130 bool NamedNodeMap::isNull() const throw()
00131 {
00132     return (impl == 0);
00133 }
00134 
00135 // ---------------------------------------------------------------------------
00136 
00137 Node::Node()
00138 {
00139     impl = 0;
00140 }
00141 
00142 Node::Node(const Node &other)
00143 {
00144     impl = other.impl;
00145     if(impl) impl->ref();
00146 }
00147 
00148 Node::Node( NodeImpl *i )
00149 {
00150     impl = i;
00151     if(impl) impl->ref();
00152 }
00153 
00154 Node &Node::operator = (const Node &other)
00155 {
00156     if(impl != other.impl) {
00157         if(impl) impl->deref();
00158         impl = other.impl;
00159         if(impl) impl->ref();
00160     }
00161     return *this;
00162 }
00163 
00164 bool Node::operator == (const Node &other)
00165 {
00166     return (impl == other.impl);
00167 }
00168 
00169 bool Node::operator != (const Node &other)
00170 {
00171     return !(impl == other.impl);
00172 }
00173 
00174 Node::~Node()
00175 {
00176     if(impl) impl->deref();
00177 }
00178 
00179 DOMString Node::nodeName() const
00180 {
00181     if(impl) return impl->nodeName();
00182     return DOMString();
00183 }
00184 
00185 DOMString Node::nodeValue() const
00186 {
00187     // ### should throw exception on plain node ?
00188     if(impl) return impl->nodeValue();
00189     return DOMString();
00190 }
00191 
00192 void Node::setNodeValue( const DOMString &_str )
00193 {
00194     if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
00195 
00196     int exceptioncode = 0;
00197     if(impl) impl->setNodeValue( _str,exceptioncode );
00198     if (exceptioncode)
00199         throw DOMException(exceptioncode);
00200 }
00201 
00202 unsigned short Node::nodeType() const
00203 {
00204     if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
00205     return impl->nodeType();
00206 }
00207 
00208 Node Node::parentNode() const
00209 {
00210     if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
00211     return impl->parentNode();
00212 }
00213 
00214 NodeList Node::childNodes() const
00215 {
00216     if (!impl) return 0;
00217     return impl->childNodes();
00218 }
00219 
00220 Node Node::firstChild() const
00221 {
00222     if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
00223     return impl->firstChild();
00224 }
00225 
00226 Node Node::lastChild() const
00227 {
00228     if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
00229     return impl->lastChild();
00230 }
00231 
00232 Node Node::previousSibling() const
00233 {
00234     if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
00235     return impl->previousSibling();
00236 }
00237 
00238 Node Node::nextSibling() const
00239 {
00240     if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
00241     return impl->nextSibling();
00242 }
00243 
00244 NamedNodeMap Node::attributes() const
00245 {
00246     if (!impl || !impl->isElementNode()) return 0;
00247     return static_cast<ElementImpl*>(impl)->attributes();
00248 }
00249 
00250 Document Node::ownerDocument() const
00251 {
00252     // braindead DOM spec says that ownerDocument
00253     // should return null if called on the document node
00254     // we don't do that in the *impl tree to avoid excessive if()'s
00255     // so we simply hack it here in one central place.
00256     if (!impl || impl->getDocument() == impl) return Document(false);
00257 
00258     return impl->getDocument();
00259 }
00260 
00261 Node Node::insertBefore( const Node &newChild, const Node &refChild )
00262 {
00263     if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
00264     int exceptioncode = 0;
00265     NodeImpl *r = impl->insertBefore( newChild.impl, refChild.impl, exceptioncode );
00266     if (exceptioncode)
00267         throw DOMException(exceptioncode);
00268     return r;
00269 }
00270 
00271 Node Node::replaceChild( const Node &newChild, const Node &oldChild )
00272 {
00273     if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
00274     int exceptioncode = 0;
00275     NodeImpl *r = impl->replaceChild( newChild.impl, oldChild.impl, exceptioncode );
00276     if (exceptioncode)
00277         throw DOMException(exceptioncode);
00278     return r;
00279 }
00280 
00281 Node Node::removeChild( const Node &oldChild )
00282 {
00283     if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
00284     int exceptioncode = 0;
00285     NodeImpl *r = impl->removeChild( oldChild.impl, exceptioncode );
00286     if (exceptioncode)
00287         throw DOMException(exceptioncode);
00288     return r;
00289 }
00290 
00291 Node Node::appendChild( const Node &newChild )
00292 {
00293     if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
00294     int exceptioncode = 0;
00295     NodeImpl *r = impl->appendChild( newChild.impl, exceptioncode );
00296     if (exceptioncode)
00297         throw DOMException(exceptioncode);
00298     return r;
00299 }
00300 
00301 bool Node::hasAttributes()
00302 {
00303     if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
00304     if (!impl->isElementNode()) return false;
00305     ElementImpl* e = static_cast<ElementImpl*>(impl);
00306     return e->attributes(true) && e->attributes(true)->length();
00307 }
00308 
00309 bool Node::hasChildNodes(  )
00310 {
00311     if (!impl) return false;
00312     return impl->hasChildNodes();
00313 }
00314 
00315 Node Node::cloneNode( bool deep )
00316 {
00317     if (!impl) return 0;
00318     return impl->cloneNode( deep  );
00319 }
00320 
00321 void Node::normalize (  )
00322 {
00323     if (!impl) return;
00324     impl->normalize();
00325 }
00326 
00327 bool Node::isSupported( const DOMString &feature,
00328                         const DOMString & /*version*/ ) const
00329 {
00330     DOMString upFeature = feature.upper();
00331     return (upFeature == "HTML" ||
00332             upFeature == "XML" ||
00333             upFeature == "CORE");
00334 }
00335 
00336 DOMString Node::namespaceURI(  ) const
00337 {
00338     if (!impl) return DOMString();
00339     return impl->getDocument()->namespaceURI(impl->id());
00340 }
00341 
00342 DOMString Node::prefix(  ) const
00343 {
00344     if (!impl) return DOMString();
00345     return impl->prefix();
00346 }
00347 
00348 void Node::setPrefix(const DOMString &prefix )
00349 {
00350     if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
00351     int exceptioncode = 0;
00352     impl->setPrefix(prefix,exceptioncode);
00353     if (exceptioncode)
00354         throw DOMException(exceptioncode);
00355 }
00356 
00357 DOMString Node::localName(  ) const
00358 {
00359     if (!impl) return DOMString();
00360     return impl->localName();
00361 }
00362 
00363 void Node::addEventListener(const DOMString &type,
00364                           EventListener *listener,
00365                           const bool useCapture)
00366 {
00367     if (!impl) return;
00368     if (listener)
00369         impl->addEventListener(EventImpl::typeToId(type),listener,useCapture);
00370 }
00371 
00372 void Node::removeEventListener(const DOMString &type,
00373                              EventListener *listener,
00374                              bool useCapture)
00375 {
00376     if (!impl) return;
00377     impl->removeEventListener(EventImpl::typeToId(type),listener,useCapture);
00378 }
00379 
00380 bool Node::dispatchEvent(const Event &evt)
00381 {
00382     if (!impl)
00383         throw DOMException(DOMException::INVALID_STATE_ERR);
00384 
00385     int exceptioncode = 0;
00386     bool r = impl->dispatchEvent(evt.handle(),exceptioncode);
00387     if (exceptioncode)
00388         throw DOMException(exceptioncode);
00389     return r;
00390 }
00391 
00392 
00393 unsigned int Node::elementId() const
00394 {
00395     if (!impl) return 0;
00396     return impl->id();
00397 }
00398 
00399 unsigned long Node::index() const
00400 {
00401     if (!impl) return 0;
00402     return impl->nodeIndex();
00403 }
00404 
00405 QString Node::toHTML()
00406 {
00407     if (!impl) return QString::null;
00408     return impl->toHTML();
00409 }
00410 
00411 void Node::applyChanges()
00412 {
00413     if (!impl) return;
00414     impl->recalcStyle( NodeImpl::Inherit );
00415 }
00416 
00417 void Node::getCursor(int offset, int &_x, int &_y, int &height)
00418 {
00419     if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
00420     impl->getCursor(offset, _x, _y, height);
00421 }
00422 
00423 QRect Node::getRect()
00424 {
00425     if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
00426     return impl->getRect();
00427 }
00428 
00429 bool Node::isNull() const
00430 {
00431     return (impl == 0);
00432 }
00433 
00434 NodeImpl *Node::handle() const
00435 {
00436     return impl;
00437 }
00438 
00439 //-----------------------------------------------------------------------------
00440 
00441 NodeList::NodeList()
00442 {
00443     impl = 0;
00444 }
00445 
00446 NodeList::NodeList(const NodeList &other)
00447 {
00448     impl = other.impl;
00449     if(impl) impl->ref();
00450 }
00451 
00452 NodeList::NodeList(const NodeListImpl *i)
00453 {
00454     impl = const_cast<NodeListImpl *>(i);
00455     if(impl) impl->ref();
00456 }
00457 
00458 NodeList &NodeList::operator = (const NodeList &other)
00459 {
00460     if ( impl != other.impl ) {
00461         if(impl) impl->deref();
00462         impl = other.impl;
00463         if(impl) impl->ref();
00464     }
00465     return *this;
00466 }
00467 
00468 NodeList::~NodeList()
00469 {
00470     if(impl) impl->deref();
00471 }
00472 
00473 Node NodeList::item( unsigned long index ) const
00474 {
00475     if (!impl) return 0;
00476     return impl->item(index);
00477 }
00478 
00479 unsigned long NodeList::length() const
00480 {
00481     if (!impl) return 0;
00482     return impl->length();
00483 }
00484 
00485 NodeListImpl *NodeList::handle() const
00486 {
00487     return impl;
00488 }
00489 
00490 bool NodeList::isNull() const
00491 {
00492     return (impl == 0);
00493 }
00494 
KDE Logo
This file is part of the documentation for kdelibs Version 3.1.5.
Documentation copyright © 1996-2002 the KDE developers.
Generated on Wed Jan 28 13:33:44 2004 by doxygen 1.3.4 written by Dimitri van Heesch, © 1997-2001