khtml Library API Documentation

dom_doc.cpp

00001 /* 00002 * This file is part of the DOM implementation for KDE. 00003 * 00004 * (C) 1999 Lars Knoll (knoll@kde.org) 00005 * 00006 * This library is free software; you can redistribute it and/or 00007 * modify it under the terms of the GNU Library General Public 00008 * License as published by the Free Software Foundation; either 00009 * version 2 of the License, or (at your option) any later version. 00010 * 00011 * This library is distributed in the hope that it will be useful, 00012 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00013 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00014 * Library General Public License for more details. 00015 * 00016 * You should have received a copy of the GNU Library General Public License 00017 * along with this library; see the file COPYING.LIB. If not, write to 00018 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, 00019 * Boston, MA 02111-1307, USA. 00020 * 00021 */ 00022 00023 #include "dom/dom_exception.h" 00024 #include "dom/dom_xml.h" 00025 #include "dom/dom2_range.h" 00026 #include "dom/dom2_events.h" 00027 #include "dom/dom2_views.h" 00028 #include "dom/dom2_traversal.h" 00029 #include "dom/html_document.h" 00030 #include "html/html_documentimpl.h" 00031 00032 #include "xml/dom_docimpl.h" 00033 #include "xml/dom_elementimpl.h" 00034 00035 #include <kdebug.h> 00036 00037 namespace DOM { 00038 00039 DOMImplementation::DOMImplementation() 00040 { 00041 impl = 0; 00042 } 00043 00044 DOMImplementation::DOMImplementation(const DOMImplementation &other) 00045 { 00046 impl = other.impl; 00047 if (impl) impl->ref(); 00048 } 00049 00050 DOMImplementation::DOMImplementation(DOMImplementationImpl *i) 00051 { 00052 impl = i; 00053 if (impl) impl->ref(); 00054 } 00055 00056 DOMImplementation &DOMImplementation::operator = (const DOMImplementation &other) 00057 { 00058 if ( impl != other.impl ) { 00059 if (impl) impl->deref(); 00060 impl = other.impl; 00061 if (impl) impl->ref(); 00062 } 00063 return *this; 00064 } 00065 00066 DOMImplementation::~DOMImplementation() 00067 { 00068 if (impl) impl->deref(); 00069 } 00070 00071 bool DOMImplementation::hasFeature( const DOMString &feature, const DOMString &version ) 00072 { 00073 if (!impl) 00074 return false; // ### enable throw DOMException(DOMException::NOT_FOUND_ERR); 00075 00076 return impl->hasFeature(feature,version); 00077 } 00078 00079 DocumentType DOMImplementation::createDocumentType ( const DOMString &qualifiedName, 00080 const DOMString &publicId, 00081 const DOMString &systemId ) 00082 { 00083 if (!impl) 00084 throw DOMException(DOMException::NOT_FOUND_ERR); 00085 00086 int exceptioncode = 0; 00087 DocumentTypeImpl *r = impl->createDocumentType(qualifiedName, publicId, systemId, exceptioncode); 00088 if ( exceptioncode ) 00089 throw DOMException( exceptioncode ); 00090 return r; 00091 } 00092 00093 Document DOMImplementation::createDocument ( const DOMString &namespaceURI, 00094 const DOMString &qualifiedName, 00095 const DocumentType &doctype ) 00096 { 00097 if (!impl) 00098 throw DOMException(DOMException::NOT_FOUND_ERR); 00099 00100 int exceptioncode = 0; 00101 DocumentImpl *r = impl->createDocument(namespaceURI, qualifiedName, doctype, exceptioncode ); 00102 if ( exceptioncode ) 00103 throw DOMException( exceptioncode ); 00104 return r; 00105 } 00106 00107 HTMLDocument DOMImplementation::createHTMLDocument( const DOMString& title ) 00108 { 00109 if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR); 00110 00111 HTMLDocumentImpl* r = impl->createHTMLDocument( 0 /* ### create a view otherwise it doesn't work */); 00112 00113 r->open(); 00114 00115 r->write(QString::fromLatin1("<HTML><HEAD><TITLE>") + title.string() + 00116 QString::fromLatin1("</TITLE></HEAD>")); 00117 00118 return r; 00119 } 00120 00121 DOMImplementation DOMImplementation::getInterface(const DOMString &feature) const 00122 { 00123 if (!impl) 00124 throw DOMException(DOMException::NOT_FOUND_ERR); 00125 00126 return impl->getInterface(feature); 00127 } 00128 00129 CSSStyleSheet DOMImplementation::createCSSStyleSheet(const DOMString &title, const DOMString &media) 00130 { 00131 if (!impl) 00132 throw DOMException(DOMException::NOT_FOUND_ERR); 00133 00134 int exceptioncode = 0; 00135 CSSStyleSheetImpl *r = impl->createCSSStyleSheet(title.implementation(), media.implementation(), 00136 exceptioncode); 00137 if ( exceptioncode ) 00138 throw DOMException( exceptioncode ); 00139 return r; 00140 } 00141 00142 DOMImplementationImpl *DOMImplementation::handle() const 00143 { 00144 return impl; 00145 } 00146 00147 bool DOMImplementation::isNull() const 00148 { 00149 return (impl == 0); 00150 } 00151 00152 // ---------------------------------------------------------------------------- 00153 00154 Document::Document() 00155 : Node() 00156 { 00157 // we always want an implementation 00158 impl = DOMImplementationImpl::instance()->createDocument(); 00159 impl->ref(); 00160 } 00161 00162 Document::Document(bool create) 00163 : Node() 00164 { 00165 if(create) 00166 { 00167 impl = DOMImplementationImpl::instance()->createDocument(); 00168 impl->ref(); 00169 } 00170 else 00171 impl = 0; 00172 // kdDebug(6090) << "Document::Document(bool)" << endl; 00173 } 00174 00175 Document::Document(const Document &other) : Node(other) 00176 { 00177 // kdDebug(6090) << "Document::Document(Document &)" << endl; 00178 } 00179 00180 Document::Document(DocumentImpl *i) : Node(i) 00181 { 00182 // kdDebug(6090) << "Document::Document(DocumentImpl)" << endl; 00183 } 00184 00185 Document &Document::operator = (const Node &other) 00186 { 00187 NodeImpl* ohandle = other.handle(); 00188 if ( impl != ohandle ) { 00189 if (!ohandle || ohandle->nodeType() != DOCUMENT_NODE) { 00190 if ( impl ) impl->deref(); 00191 impl = 0; 00192 } else { 00193 Node::operator =(other); 00194 } 00195 } 00196 return *this; 00197 } 00198 00199 Document &Document::operator = (const Document &other) 00200 { 00201 Node::operator =(other); 00202 return *this; 00203 } 00204 00205 Document::~Document() 00206 { 00207 // kdDebug(6090) << "Document::~Document\n" << endl; 00208 } 00209 00210 DocumentType Document::doctype() const 00211 { 00212 if (impl) return ((DocumentImpl *)impl)->doctype(); 00213 return 0; 00214 } 00215 00216 DOMImplementation Document::implementation() const 00217 { 00218 if (impl) return ((DocumentImpl *)impl)->implementation(); 00219 return 0; 00220 } 00221 00222 Element Document::documentElement() const 00223 { 00224 if (impl) return ((DocumentImpl *)impl)->documentElement(); 00225 return 0; 00226 } 00227 00228 Element Document::createElement( const DOMString &tagName ) 00229 { 00230 if (!impl) 00231 throw DOMException(DOMException::NOT_FOUND_ERR); 00232 00233 int exceptioncode = 0; 00234 ElementImpl* r = ((DocumentImpl *)impl)->createElement(tagName, &exceptioncode); 00235 if ( exceptioncode ) 00236 throw DOMException( exceptioncode ); 00237 return r; 00238 } 00239 00240 Element Document::createElementNS( const DOMString &namespaceURI, const DOMString &qualifiedName ) 00241 { 00242 if (!impl) 00243 throw DOMException(DOMException::NOT_FOUND_ERR); 00244 00245 int exceptioncode = 0; 00246 ElementImpl* r = ((DocumentImpl *)impl)->createElementNS(namespaceURI,qualifiedName, &exceptioncode); 00247 if ( exceptioncode ) 00248 throw DOMException( exceptioncode ); 00249 return r; 00250 } 00251 00252 DocumentFragment Document::createDocumentFragment( ) 00253 { 00254 if (impl) return ((DocumentImpl *)impl)->createDocumentFragment(); 00255 return 0; 00256 } 00257 00258 Text Document::createTextNode( const DOMString &data ) 00259 { 00260 if (impl) return ((DocumentImpl *)impl)->createTextNode( data.implementation() ); 00261 return 0; 00262 } 00263 00264 Comment Document::createComment( const DOMString &data ) 00265 { 00266 if (impl) return ((DocumentImpl *)impl)->createComment( data.implementation() ); 00267 return 0; 00268 } 00269 00270 CDATASection Document::createCDATASection( const DOMString &data ) 00271 { 00272 // ### DOM1 spec says raise exception if html documents - what about XHTML documents? 00273 if (impl) return ((DocumentImpl *)impl)->createCDATASection( data.implementation() ); 00274 return 0; 00275 } 00276 00277 ProcessingInstruction Document::createProcessingInstruction( const DOMString &target, const DOMString &data ) 00278 { 00279 if (impl) return ((DocumentImpl *)impl)->createProcessingInstruction( target, data.implementation() ); 00280 return 0; 00281 } 00282 00283 Attr Document::createAttribute( const DOMString &name ) 00284 { 00285 if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR); 00286 if (name.isNull()) throw DOMException(DOMException::NOT_FOUND_ERR); 00287 int exceptioncode = 0; 00288 AttrImpl* a = impl->getDocument()->createAttribute(name, &exceptioncode); 00289 if ( exceptioncode ) 00290 throw DOMException( exceptioncode ); 00291 return a; 00292 } 00293 00294 Attr Document::createAttributeNS( const DOMString &namespaceURI, const DOMString &qualifiedName ) 00295 { 00296 if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR); 00297 if (qualifiedName.isNull()) throw DOMException(DOMException::NAMESPACE_ERR); 00298 int exceptioncode = 0; 00299 AttrImpl* a = impl->getDocument()->createAttributeNS(namespaceURI, qualifiedName, &exceptioncode); 00300 if ( exceptioncode ) 00301 throw DOMException( exceptioncode ); 00302 return a; 00303 } 00304 00305 EntityReference Document::createEntityReference( const DOMString &name ) 00306 { 00307 if (impl) return ((DocumentImpl *)impl)->createEntityReference( name ); 00308 return 0; 00309 } 00310 00311 Element Document::getElementById( const DOMString &elementId ) const 00312 { 00313 if(impl) return ((DocumentImpl *)impl)->getElementById( elementId ); 00314 return 0; 00315 } 00316 00317 NodeList Document::getElementsByTagName( const DOMString &tagName ) 00318 { 00319 if (!impl) return 0; 00320 NodeImpl::Id id; 00321 if ( tagName == "*" ) 00322 id = 0; 00323 else 00324 id = impl->getDocument()->getId(NodeImpl::ElementId, tagName.implementation(), false, true); 00325 return new TagNodeListImpl( impl, id ); 00326 } 00327 00328 NodeList Document::getElementsByTagNameNS( const DOMString &namespaceURI, const DOMString &localName ) 00329 { 00330 if (!impl) return 0; 00331 return new TagNodeListImpl( impl, namespaceURI, localName ); 00332 } 00333 00334 Node Document::importNode( const Node & importedNode, bool deep ) 00335 { 00336 if (!impl) 00337 throw DOMException(DOMException::INVALID_STATE_ERR); 00338 00339 int exceptioncode = 0; 00340 NodeImpl *r = static_cast<DocumentImpl*>(impl)->importNode(importedNode.handle(), deep, exceptioncode); 00341 if (exceptioncode) 00342 throw DOMException(exceptioncode); 00343 return r; 00344 } 00345 00346 bool Document::isHTMLDocument() const 00347 { 00348 if (impl) return ((DocumentImpl *)impl)->isHTMLDocument(); 00349 return 0; 00350 } 00351 00352 Range Document::createRange() 00353 { 00354 if (impl) return ((DocumentImpl *)impl)->createRange(); 00355 return 0; 00356 } 00357 00358 NodeIterator Document::createNodeIterator(Node root, unsigned long whatToShow, 00359 NodeFilter filter, bool entityReferenceExpansion) 00360 { 00361 if (!impl) 00362 throw DOMException(DOMException::INVALID_STATE_ERR); 00363 00364 int exceptioncode = 0; 00365 NodeIteratorImpl *r = static_cast<DocumentImpl*>(impl)->createNodeIterator(root.handle(), 00366 whatToShow,filter,entityReferenceExpansion,exceptioncode); 00367 if (exceptioncode) 00368 throw DOMException(exceptioncode); 00369 return r; 00370 } 00371 00372 TreeWalker Document::createTreeWalker(Node root, unsigned long whatToShow, NodeFilter filter, 00373 bool entityReferenceExpansion) 00374 { 00375 if (!impl) 00376 throw DOMException(DOMException::INVALID_STATE_ERR); 00377 00378 int exceptioncode = 0; 00379 00380 TreeWalkerImpl *tw = static_cast<DocumentImpl *>(impl)->createTreeWalker( 00381 root.handle(), whatToShow, filter.handle(), entityReferenceExpansion, exceptioncode); 00382 if (exceptioncode) 00383 throw DOMException(exceptioncode); 00384 00385 return tw; 00386 } 00387 00388 Event Document::createEvent(const DOMString &eventType) 00389 { 00390 if (!impl) 00391 throw DOMException(DOMException::INVALID_STATE_ERR); 00392 00393 int exceptioncode = 0; 00394 EventImpl *r = ((DocumentImpl *)impl)->createEvent(eventType,exceptioncode); 00395 if (exceptioncode) 00396 throw DOMException(exceptioncode); 00397 return r; 00398 } 00399 00400 AbstractView Document::defaultView() const 00401 { 00402 if (!impl) 00403 throw DOMException(DOMException::INVALID_STATE_ERR); 00404 00405 return static_cast<DocumentImpl*>(impl)->defaultView(); 00406 } 00407 00408 StyleSheetList Document::styleSheets() const 00409 { 00410 if (!impl) 00411 throw DOMException(DOMException::INVALID_STATE_ERR); 00412 00413 return static_cast<DocumentImpl*>(impl)->styleSheets(); 00414 } 00415 00416 DOMString Document::preferredStylesheetSet() 00417 { 00418 if (!impl) 00419 throw DOMException(DOMException::INVALID_STATE_ERR); 00420 00421 return static_cast<DocumentImpl*>(impl)->preferredStylesheetSet(); 00422 } 00423 00424 DOMString Document::selectedStylesheetSet() 00425 { 00426 if (!impl) 00427 throw DOMException(DOMException::INVALID_STATE_ERR); 00428 00429 return static_cast<DocumentImpl*>(impl)->selectedStylesheetSet(); 00430 } 00431 00432 void Document::setSelectedStylesheetSet(const DOMString& s) 00433 { 00434 if (!impl) 00435 throw DOMException(DOMException::INVALID_STATE_ERR); 00436 00437 static_cast<DocumentImpl*>(impl)->setSelectedStylesheetSet(s); 00438 } 00439 00440 00441 KHTMLView *Document::view() const 00442 { 00443 if (!impl) return 0; 00444 00445 return static_cast<DocumentImpl*>(impl)->view(); 00446 } 00447 00448 CSSStyleDeclaration Document::getOverrideStyle(const Element &elt, const DOMString &pseudoElt) 00449 { 00450 if (!impl) 00451 throw DOMException(DOMException::INVALID_STATE_ERR); 00452 00453 int exceptioncode = 0; 00454 CSSStyleDeclarationImpl *r = ((DocumentImpl *)impl)->getOverrideStyle(static_cast<ElementImpl*>(elt.handle()),pseudoElt.implementation()); 00455 if (exceptioncode) 00456 throw DOMException(exceptioncode); 00457 return r; 00458 } 00459 00460 bool Document::async() const 00461 { 00462 if (!impl) 00463 throw DOMException(DOMException::INVALID_STATE_ERR); 00464 00465 return static_cast<DocumentImpl*>( impl )->async( ); 00466 } 00467 00468 void Document::setAsync( bool b ) 00469 { 00470 if (!impl) 00471 throw DOMException(DOMException::INVALID_STATE_ERR); 00472 00473 static_cast<DocumentImpl*>( impl )->setAsync( b ); 00474 } 00475 00476 void Document::abort() 00477 { 00478 if (!impl) 00479 throw DOMException(DOMException::INVALID_STATE_ERR); 00480 00481 00482 static_cast<DocumentImpl*>( impl )->abort( ); 00483 } 00484 00485 void Document::load( const DOMString &uri ) 00486 { 00487 if (!impl) 00488 throw DOMException(DOMException::INVALID_STATE_ERR); 00489 00490 static_cast<DocumentImpl*>( impl )->load( uri ); 00491 } 00492 00493 void Document::loadXML( const DOMString &source ) 00494 { 00495 if (!impl) 00496 throw DOMException(DOMException::INVALID_STATE_ERR); 00497 00498 00499 static_cast<DocumentImpl*>( impl )->loadXML( source ); 00500 } 00501 00502 bool Document::designMode() const { 00503 if (!impl) 00504 throw DOMException(DOMException::INVALID_STATE_ERR); 00505 00506 return static_cast<DocumentImpl*>( impl )->designMode(); 00507 } 00508 00509 void Document::setDesignMode(bool enable) { 00510 if (!impl) 00511 throw DOMException(DOMException::INVALID_STATE_ERR); 00512 00513 static_cast<DocumentImpl*>( impl )->setDesignMode( enable ); 00514 } 00515 00516 DOMString Document::completeURL(const DOMString& url) 00517 { 00518 if ( !impl ) return url; 00519 return static_cast<DocumentImpl*>( impl )->completeURL( url.string() ); 00520 } 00521 00522 DOMString Document::toString() const 00523 { 00524 if (!impl) 00525 throw DOMException(DOMException::NOT_FOUND_ERR); 00526 00527 return static_cast<DocumentImpl*>(impl)->toString(); 00528 } 00529 00530 void Document::updateRendering() 00531 { 00532 if ( !impl ) return; 00533 static_cast<DocumentImpl*>( impl )->updateRendering( ); 00534 } 00535 00536 void Document::addStyleSheet(const StyleSheet &sheet) 00537 { 00538 if (!impl || sheet.isNull()) 00539 throw DOMException(DOMException::INVALID_STATE_ERR); 00540 00541 int exceptioncode; 00542 static_cast<DocumentImpl*>( impl )->addStyleSheet( sheet.handle(), &exceptioncode ); 00543 if (exceptioncode) 00544 throw DOMException(exceptioncode); 00545 } 00546 00547 void Document::removeStyleSheet(const StyleSheet &sheet) 00548 { 00549 if (!impl || sheet.isNull()) 00550 throw DOMException(DOMException::INVALID_STATE_ERR); 00551 00552 int exceptioncode; 00553 static_cast<DocumentImpl*>( impl )->removeStyleSheet( sheet.handle(), &exceptioncode ); 00554 if (exceptioncode) 00555 throw DOMException(exceptioncode); 00556 } 00557 00558 // ---------------------------------------------------------------------------- 00559 00560 DocumentFragment::DocumentFragment() : Node() 00561 { 00562 } 00563 00564 DocumentFragment::DocumentFragment(const DocumentFragment &other) : Node(other) 00565 { 00566 } 00567 00568 DocumentFragment &DocumentFragment::operator = (const Node &other) 00569 { 00570 NodeImpl* ohandle = other.handle(); 00571 if ( impl != ohandle ) { 00572 if (!ohandle || ohandle->nodeType() != DOCUMENT_FRAGMENT_NODE) { 00573 if ( impl ) impl->deref(); 00574 impl = 0; 00575 } else { 00576 Node::operator =(other); 00577 } 00578 } 00579 return *this; 00580 } 00581 00582 DocumentFragment &DocumentFragment::operator = (const DocumentFragment &other) 00583 { 00584 Node::operator =(other); 00585 return *this; 00586 } 00587 00588 DocumentFragment::~DocumentFragment() 00589 { 00590 } 00591 00592 DocumentFragment::DocumentFragment(DocumentFragmentImpl *i) : Node(i) 00593 { 00594 } 00595 00596 // ---------------------------------------------------------------------------- 00597 00598 DocumentType::DocumentType() 00599 : Node() 00600 { 00601 } 00602 00603 DocumentType::DocumentType(const DocumentType &other) 00604 : Node(other) 00605 { 00606 } 00607 00608 DocumentType::DocumentType(DocumentTypeImpl *impl) : Node(impl) 00609 { 00610 } 00611 00612 DocumentType &DocumentType::operator = (const Node &other) 00613 { 00614 NodeImpl* ohandle = other.handle(); 00615 if ( impl != ohandle ) { 00616 if (!ohandle || ohandle->nodeType() != DOCUMENT_TYPE_NODE) { 00617 if ( impl ) impl->deref(); 00618 impl = 0; 00619 } else { 00620 Node::operator =(other); 00621 } 00622 } 00623 return *this; 00624 } 00625 00626 DocumentType &DocumentType::operator = (const DocumentType &other) 00627 { 00628 Node::operator =(other); 00629 return *this; 00630 } 00631 00632 DocumentType::~DocumentType() 00633 { 00634 } 00635 00636 DOMString DocumentType::name() const 00637 { 00638 if (!impl) 00639 return DOMString(); // ### enable throw DOMException(DOMException::NOT_FOUND_ERR); 00640 00641 return static_cast<DocumentTypeImpl*>(impl)->name(); 00642 } 00643 00644 NamedNodeMap DocumentType::entities() const 00645 { 00646 if (!impl) 00647 return 0; // ### enable throw DOMException(DOMException::NOT_FOUND_ERR); 00648 00649 return static_cast<DocumentTypeImpl*>(impl)->entities(); 00650 } 00651 00652 NamedNodeMap DocumentType::notations() const 00653 { 00654 if (!impl) 00655 return 0; // ### enable throw DOMException(DOMException::NOT_FOUND_ERR); 00656 00657 return static_cast<DocumentTypeImpl*>(impl)->notations(); 00658 } 00659 00660 DOMString DocumentType::publicId() const 00661 { 00662 if (!impl) 00663 throw DOMException(DOMException::NOT_FOUND_ERR); 00664 00665 return static_cast<DocumentTypeImpl*>(impl)->publicId(); 00666 } 00667 00668 DOMString DocumentType::systemId() const 00669 { 00670 if (!impl) 00671 throw DOMException(DOMException::NOT_FOUND_ERR); 00672 00673 return static_cast<DocumentTypeImpl*>(impl)->systemId(); 00674 } 00675 00676 DOMString DocumentType::internalSubset() const 00677 { 00678 if (!impl) 00679 throw DOMException(DOMException::NOT_FOUND_ERR); 00680 00681 return static_cast<DocumentTypeImpl*>(impl)->internalSubset(); 00682 } 00683 00684 } // namespace
KDE Logo
This file is part of the documentation for khtml Library Version 3.4.0.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Tue Apr 12 23:31:23 2005 by doxygen 1.3.7 written by Dimitri van Heesch, © 1997-2003