File indexing completed on 2024-04-28 15:22:56

 /*
  * This file is part of the DOM implementation for KDE.
  *
  * Copyright 1999 Lars Knoll (knoll@kde.org)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "dom/dom_exception.h"
 #include "dom/dom_xml.h"
 #include "dom/dom2_range.h"
 #include "dom/dom2_events.h"
 #include "dom/dom2_views.h"
 #include "dom/dom2_traversal.h"
 #include "dom/html_document.h"
 #include "html/html_documentimpl.h"
 
 #include "xml/dom_docimpl.h"
 #include "xml/dom_elementimpl.h"
 
 #include "khtml_debug.h"
 
 namespace DOM
 {
 
 DOMImplementation::DOMImplementation()
 {
     impl = nullptr;
 }
 
 DOMImplementation::DOMImplementation(const DOMImplementation &other)
 {
     impl = other.impl;
     if (impl) {
         impl->ref();
     }
 }
 
 DOMImplementation::DOMImplementation(DOMImplementationImpl *i)
 {
     impl = i;
     if (impl) {
         impl->ref();
     }
 }
 
 DOMImplementation &DOMImplementation::operator = (const DOMImplementation &other)
 {
     if (impl != other.impl) {
         if (impl) {
             impl->deref();
         }
         impl = other.impl;
         if (impl) {
             impl->ref();
         }
     }
     return *this;
 }
 
 DOMImplementation::~DOMImplementation()
 {
     if (impl) {
         impl->deref();
     }
 }
 
 bool DOMImplementation::hasFeature(const DOMString &feature, const DOMString &version)
 {
     if (!impl) {
         return false;    // ### enable throw DOMException(DOMException::NOT_FOUND_ERR);
     }
 
     return impl->hasFeature(feature, version);
 }
 
 DocumentType DOMImplementation::createDocumentType(const DOMString &qualifiedName,
         const DOMString &publicId,
         const DOMString &systemId)
 {
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
 
     int exceptioncode = 0;
     DocumentTypeImpl *r = impl->createDocumentType(qualifiedName, publicId, systemId, exceptioncode);
     if (exceptioncode) {
         throw DOMException(exceptioncode);
     }
     return r;
 }
 
 Document DOMImplementation::createDocument(const DOMString &namespaceURI,
         const DOMString &qualifiedName,
         const DocumentType &doctype)
 {
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
 
     int exceptioncode = 0;
     DocumentImpl *r = impl->createDocument(namespaceURI, qualifiedName,
                                            (DocumentTypeImpl *)doctype.handle(),
                                            nullptr, exceptioncode);
     if (exceptioncode) {
         throw DOMException(exceptioncode);
     }
     return r;
 }
 
 HTMLDocument DOMImplementation::createHTMLDocument(const DOMString &title)
 {
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
     return static_cast<DOMImplementationImpl *>(impl)->createHTMLDocument(title);
 }
 
 DOMImplementation DOMImplementation::getInterface(const DOMString &/*feature*/) const
 {
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
 
     // This method is a no-op for us.
     return impl;
 }
 
 CSSStyleSheet DOMImplementation::createCSSStyleSheet(const DOMString &title, const DOMString &media)
 {
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
 
     int exceptioncode = 0;
     CSSStyleSheetImpl *r = impl->createCSSStyleSheet(title.implementation(), media.implementation(),
                            exceptioncode);
     if (exceptioncode) {
         throw DOMException(exceptioncode);
     }
     return r;
 }
 
 DOMImplementationImpl *DOMImplementation::handle() const
 {
     return impl;
 }
 
 bool DOMImplementation::isNull() const
 {
     return (impl == nullptr);
 }
 
 // ----------------------------------------------------------------------------
 
 Document::Document()
     : Node()
 {
     // we always want an implementation
     impl = DOMImplementationImpl::createDocument();
     impl->ref();
 }
 
 Document::Document(bool create)
     : Node()
 {
     if (create) {
         impl = DOMImplementationImpl::createDocument();
         impl->ref();
     } else {
         impl = nullptr;
     }
 //    qCDebug(KHTML_LOG) << "Document::Document(bool)";
 }
 
 Document::Document(const Document &other) : Node(other)
 {
 //    qCDebug(KHTML_LOG) << "Document::Document(Document &)";
 }
 
 Document::Document(DocumentImpl *i) : Node(i)
 {
 //    qCDebug(KHTML_LOG) << "Document::Document(DocumentImpl)";
 }
 
 Document &Document::operator = (const Node &other)
 {
     NodeImpl *ohandle = other.handle();
     if (impl != ohandle) {
         if (!ohandle || ohandle->nodeType() != DOCUMENT_NODE) {
             if (impl) {
                 impl->deref();
             }
             impl = nullptr;
         } else {
             Node::operator =(other);
         }
     }
     return *this;
 }
 
 Document &Document::operator = (const Document &other)
 {
     Node::operator =(other);
     return *this;
 }
 
 Document::~Document()
 {
 //    qCDebug(KHTML_LOG) << "Document::~Document\n";
 }
 
 DocumentType Document::doctype() const
 {
     if (impl) {
         return ((DocumentImpl *)impl)->doctype();
     }
     return nullptr;
 }
 
 DOMImplementation Document::implementation() const
 {
     if (impl) {
         return ((DocumentImpl *)impl)->implementation();
     }
     return nullptr;
 }
 
 Element Document::documentElement() const
 {
     if (impl) {
         return ((DocumentImpl *)impl)->documentElement();
     }
     return nullptr;
 }
 
 Element Document::createElement(const DOMString &tagName)
 {
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
 
     int exceptioncode = 0;
     ElementImpl *r = ((DocumentImpl *)impl)->createElement(tagName, &exceptioncode);
     if (exceptioncode) {
         throw DOMException(exceptioncode);
     }
     return r;
 }
 
 Element Document::createElementNS(const DOMString &namespaceURI, const DOMString &qualifiedName)
 {
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
 
     int exceptioncode = 0;
     ElementImpl *r = ((DocumentImpl *)impl)->createElementNS(namespaceURI, qualifiedName, &exceptioncode);
     if (exceptioncode) {
         throw DOMException(exceptioncode);
     }
     return r;
 }
 
 DocumentFragment Document::createDocumentFragment()
 {
     if (impl) {
         return ((DocumentImpl *)impl)->createDocumentFragment();
     }
     return nullptr;
 }
 
 Text Document::createTextNode(const DOMString &data)
 {
     if (impl) {
         return ((DocumentImpl *)impl)->createTextNode(data.implementation());
     }
     return nullptr;
 }
 
 Comment Document::createComment(const DOMString &data)
 {
     if (impl) {
         return ((DocumentImpl *)impl)->createComment(data.implementation());
     }
     return nullptr;
 }
 
 CDATASection Document::createCDATASection(const DOMString &data)
 {
     if (!impl) {
         return nullptr;
     }
     int exceptioncode = 0;
     CDATASectionImpl *d = ((DocumentImpl *)impl)->createCDATASection(data.implementation(), exceptioncode);
     if (exceptioncode) {
         throw DOMException(exceptioncode);
     }
     return d;
 }
 
 ProcessingInstruction Document::createProcessingInstruction(const DOMString &target, const DOMString &data)
 {
     if (impl) {
         return ((DocumentImpl *)impl)->createProcessingInstruction(target, data.implementation());
     }
     return nullptr;
 }
 
 Attr Document::createAttribute(const DOMString &name)
 {
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
     if (name.isNull()) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
     int exceptioncode = 0;
     AttrImpl *a = impl->document()->createAttribute(name, &exceptioncode);
     if (exceptioncode) {
         throw DOMException(exceptioncode);
     }
     return a;
 }
 
 Attr Document::createAttributeNS(const DOMString &namespaceURI, const DOMString &qualifiedName)
 {
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
     if (qualifiedName.isNull()) {
         throw DOMException(DOMException::NAMESPACE_ERR);
     }
     int exceptioncode = 0;
     AttrImpl *a = impl->document()->createAttributeNS(namespaceURI, qualifiedName, &exceptioncode);
     if (exceptioncode) {
         throw DOMException(exceptioncode);
     }
     return a;
 }
 
 EntityReference Document::createEntityReference(const DOMString &name)
 {
     if (!impl) {
         return nullptr;
     }
     int exceptioncode = 0;
     EntityReferenceImpl *er = ((DocumentImpl *)impl)->createEntityReference(name, exceptioncode);
     if (exceptioncode) {
         throw DOMException(exceptioncode);
     }
     return er;
 }
 
 Element Document::getElementById(const DOMString &elementId) const
 {
     if (impl) {
         return ((DocumentImpl *)impl)->getElementById(elementId);
     }
     return nullptr;
 }
 
 NodeList Document::getElementsByTagName(const DOMString &tagName)
 {
     if (!impl) {
         return nullptr;
     }
     return impl->getElementsByTagName(tagName);
 }
 
 NodeList Document::getElementsByTagNameNS(const DOMString &namespaceURI, const DOMString &localName)
 {
     if (!impl) {
         return nullptr;
     }
     return impl->getElementsByTagNameNS(namespaceURI, localName);
 }
 
 NodeList Document::getElementsByClassName(const DOMString &className)
 {
     if (!impl) {
         return nullptr;
     }
     return impl->getElementsByClassName(className);
 }
 
 Node Document::importNode(const Node &importedNode, bool deep)
 {
     if (!impl) {
         throw DOMException(DOMException::INVALID_STATE_ERR);
     }
 
     int exceptioncode = 0;
     NodeImpl *r = static_cast<DocumentImpl *>(impl)->importNode(importedNode.handle(), deep, exceptioncode);
     if (exceptioncode) {
         throw DOMException(exceptioncode);
     }
     return r;
 }
 
 bool Document::isHTMLDocument() const
 {
     if (impl) {
         return ((DocumentImpl *)impl)->isHTMLDocument();
     }
     return 0;
 }
 
 Range Document::createRange()
 {
     if (impl) {
         return ((DocumentImpl *)impl)->createRange();
     }
     return nullptr;
 }
 
 NodeIterator Document::createNodeIterator(Node root, unsigned long whatToShow,
         NodeFilter filter, bool entityReferenceExpansion)
 {
     if (!impl) {
         throw DOMException(DOMException::INVALID_STATE_ERR);
     }
 
     int exceptioncode = 0;
     NodeIteratorImpl *r = static_cast<DocumentImpl *>(impl)->createNodeIterator(root.handle(),
                           whatToShow, filter.handle(), entityReferenceExpansion, exceptioncode);
     if (exceptioncode) {
         throw DOMException(exceptioncode);
     }
     return r;
 }
 
 TreeWalker Document::createTreeWalker(Node root, unsigned long whatToShow, NodeFilter filter,
                                       bool entityReferenceExpansion)
 {
     if (!impl) {
         throw DOMException(DOMException::INVALID_STATE_ERR);
     }
 
     int exceptioncode = 0;
 
     TreeWalkerImpl *tw = static_cast<DocumentImpl *>(impl)->createTreeWalker(
                              root.handle(), whatToShow, filter.handle(), entityReferenceExpansion, exceptioncode);
     if (exceptioncode) {
         throw DOMException(exceptioncode);
     }
 
     return tw;
 }
 
 Event Document::createEvent(const DOMString &eventType)
 {
     if (!impl) {
         throw DOMException(DOMException::INVALID_STATE_ERR);
     }
 
     int exceptioncode = 0;
     EventImpl *r = ((DocumentImpl *)impl)->createEvent(eventType, exceptioncode);
     if (exceptioncode) {
         throw DOMException(exceptioncode);
     }
     return r;
 }
 
 AbstractView Document::defaultView() const
 {
     if (!impl) {
         throw DOMException(DOMException::INVALID_STATE_ERR);
     }
 
     return static_cast<DocumentImpl *>(impl)->defaultView();
 }
 
 StyleSheetList Document::styleSheets() const
 {
     if (!impl) {
         throw DOMException(DOMException::INVALID_STATE_ERR);
     }
 
     return static_cast<DocumentImpl *>(impl)->styleSheets();
 }
 
 DOMString Document::preferredStylesheetSet()
 {
     if (!impl) {
         throw DOMException(DOMException::INVALID_STATE_ERR);
     }
 
     return static_cast<DocumentImpl *>(impl)->preferredStylesheetSet();
 }
 
 DOMString Document::selectedStylesheetSet()
 {
     if (!impl) {
         throw DOMException(DOMException::INVALID_STATE_ERR);
     }
 
     return static_cast<DocumentImpl *>(impl)->selectedStylesheetSet();
 }
 
 void Document::setSelectedStylesheetSet(const DOMString &s)
 {
     if (!impl) {
         throw DOMException(DOMException::INVALID_STATE_ERR);
     }
 
     static_cast<DocumentImpl *>(impl)->setSelectedStylesheetSet(s);
 }
 
 KHTMLView *Document::view() const
 {
     if (!impl) {
         return nullptr;
     }
 
     return static_cast<DocumentImpl *>(impl)->view();
 }
 
 CSSStyleDeclaration Document::getOverrideStyle(const Element &elt, const DOMString &pseudoElt)
 {
     if (!impl) {
         throw DOMException(DOMException::INVALID_STATE_ERR);
     }
 
     CSSStyleDeclarationImpl *r = ((DocumentImpl *)impl)->getOverrideStyle(static_cast<ElementImpl *>(elt.handle()), pseudoElt.implementation());
     return r;
 }
 
 bool Document::execCommand(const DOMString &command, bool userInterface, const DOMString &value)
 {
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
 
     return static_cast<DocumentImpl *>(impl)->execCommand(command, userInterface, value);
 }
 
 bool Document::queryCommandEnabled(const DOMString &command)
 {
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
 
     return static_cast<DocumentImpl *>(impl)->queryCommandEnabled(command);
 }
 
 bool Document::queryCommandIndeterm(const DOMString &command)
 {
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
 
     return static_cast<DocumentImpl *>(impl)->queryCommandIndeterm(command);
 }
 
 bool Document::queryCommandState(const DOMString &command)
 {
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
 
     return static_cast<DocumentImpl *>(impl)->queryCommandState(command);
 }
 
 bool Document::queryCommandSupported(const DOMString &command)
 {
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
 
     return static_cast<DocumentImpl *>(impl)->queryCommandSupported(command);
 }
 
 DOMString Document::queryCommandValue(const DOMString &command)
 {
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
 
     return static_cast<DocumentImpl *>(impl)->queryCommandValue(command);
 }
 
 bool Document::async() const
 {
     if (!impl) {
         throw DOMException(DOMException::INVALID_STATE_ERR);
     }
 
     return static_cast<DocumentImpl *>(impl)->async();
 }
 
 void Document::setAsync(bool b)
 {
     if (!impl) {
         throw DOMException(DOMException::INVALID_STATE_ERR);
     }
 
     static_cast<DocumentImpl *>(impl)->setAsync(b);
 }
 
 void Document::abort()
 {
     if (!impl) {
         throw DOMException(DOMException::INVALID_STATE_ERR);
     }
 
     static_cast<DocumentImpl *>(impl)->abort();
 }
 
 void Document::load(const DOMString &uri)
 {
     if (!impl) {
         throw DOMException(DOMException::INVALID_STATE_ERR);
     }
 
     static_cast<DocumentImpl *>(impl)->load(uri);
 }
 
 void Document::loadXML(const DOMString &source)
 {
     if (!impl) {
         throw DOMException(DOMException::INVALID_STATE_ERR);
     }
 
     static_cast<DocumentImpl *>(impl)->loadXML(source);
 }
 
 Element Document::querySelector(const DOMString &query) const
 {
     int ec = 0;
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
     Element res = impl->querySelector(query, ec).get();
     if (ec) {
         throw DOMException(ec);
     }
     return res;
 }
 
 NodeList Document::querySelectorAll(const DOMString &query) const
 {
     int ec = 0;
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
     NodeList res = impl->querySelectorAll(query, ec).get();
     if (ec) {
         throw DOMException(ec);
     }
     return res;
 }
 
 bool Document::designMode() const
 {
     if (!impl) {
         throw DOMException(DOMException::INVALID_STATE_ERR);
     }
 
     return static_cast<DocumentImpl *>(impl)->designMode();
 }
 
 void Document::setDesignMode(bool enable)
 {
     if (!impl) {
         throw DOMException(DOMException::INVALID_STATE_ERR);
     }
 
     static_cast<DocumentImpl *>(impl)->setDesignMode(enable);
 }
 
 DOMString Document::completeURL(const DOMString &url)
 {
     if (!impl) {
         return url;
     }
     return static_cast<DocumentImpl *>(impl)->completeURL(url.string());
 }
 
 DOMString Document::toString() const
 {
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
 
     return static_cast<DocumentImpl *>(impl)->toString();
 }
 
 void Document::updateRendering()
 {
     if (!impl) {
         return;
     }
     static_cast<DocumentImpl *>(impl)->updateRendering();
 }
 
 void Document::addStyleSheet(const StyleSheet &sheet)
 {
     if (!impl || sheet.isNull()) {
         throw DOMException(DOMException::INVALID_STATE_ERR);
     }
 
     int exceptioncode;
     static_cast<DocumentImpl *>(impl)->addStyleSheet(sheet.handle(), &exceptioncode);
     if (exceptioncode) {
         throw DOMException(exceptioncode);
     }
 }
 
 void Document::removeStyleSheet(const StyleSheet &sheet)
 {
     if (!impl || sheet.isNull()) {
         throw DOMException(DOMException::INVALID_STATE_ERR);
     }
 
     int exceptioncode;
     static_cast<DocumentImpl *>(impl)->removeStyleSheet(sheet.handle(), &exceptioncode);
     if (exceptioncode) {
         throw DOMException(exceptioncode);
     }
 }
 
 // ----------------------------------------------------------------------------
 
 DocumentFragment::DocumentFragment() : Node()
 {
 }
 
 DocumentFragment::DocumentFragment(const DocumentFragment &other) : Node(other)
 {
 }
 
 DocumentFragment &DocumentFragment::operator = (const Node &other)
 {
     NodeImpl *ohandle = other.handle();
     if (impl != ohandle) {
         if (!ohandle || ohandle->nodeType() != DOCUMENT_FRAGMENT_NODE) {
             if (impl) {
                 impl->deref();
             }
             impl = nullptr;
         } else {
             Node::operator =(other);
         }
     }
     return *this;
 }
 
 DocumentFragment &DocumentFragment::operator = (const DocumentFragment &other)
 {
     Node::operator =(other);
     return *this;
 }
 
 DocumentFragment::~DocumentFragment()
 {
 }
 
 Element DocumentFragment::querySelector(const DOMString &query) const
 {
     int ec = 0;
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
     Element res = impl->querySelector(query, ec).get();
     if (ec) {
         throw DOMException(ec);
     }
     return res;
 }
 
 NodeList DocumentFragment::querySelectorAll(const DOMString &query) const
 {
     int ec = 0;
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
     NodeList res = impl->querySelectorAll(query, ec).get();
     if (ec) {
         throw DOMException(ec);
     }
     return res;
 }
 
 DocumentFragment::DocumentFragment(DocumentFragmentImpl *i) : Node(i)
 {
 }
 
 // ----------------------------------------------------------------------------
 
 DocumentType::DocumentType()
     : Node()
 {
 }
 
 DocumentType::DocumentType(const DocumentType &other)
     : Node(other)
 {
 }
 
 DocumentType::DocumentType(DocumentTypeImpl *impl) : Node(impl)
 {
 }
 
 DocumentType &DocumentType::operator = (const Node &other)
 {
     NodeImpl *ohandle = other.handle();
     if (impl != ohandle) {
         if (!ohandle || ohandle->nodeType() != DOCUMENT_TYPE_NODE) {
             if (impl) {
                 impl->deref();
             }
             impl = nullptr;
         } else {
             Node::operator =(other);
         }
     }
     return *this;
 }
 
 DocumentType &DocumentType::operator = (const DocumentType &other)
 {
     Node::operator =(other);
     return *this;
 }
 
 DocumentType::~DocumentType()
 {
 }
 
 DOMString DocumentType::name() const
 {
     if (!impl) {
         return DOMString();    // ### enable throw DOMException(DOMException::NOT_FOUND_ERR);
     }
 
     return static_cast<DocumentTypeImpl *>(impl)->name();
 }
 
 NamedNodeMap DocumentType::entities() const
 {
     if (!impl) {
         return nullptr;    // ### enable throw DOMException(DOMException::NOT_FOUND_ERR);
     }
 
     return static_cast<DocumentTypeImpl *>(impl)->entities();
 }
 
 NamedNodeMap DocumentType::notations() const
 {
     if (!impl) {
         return nullptr;    // ### enable throw DOMException(DOMException::NOT_FOUND_ERR);
     }
 
     return static_cast<DocumentTypeImpl *>(impl)->notations();
 }
 
 DOMString DocumentType::publicId() const
 {
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
 
     return static_cast<DocumentTypeImpl *>(impl)->publicId();
 }
 
 DOMString DocumentType::systemId() const
 {
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
 
     return static_cast<DocumentTypeImpl *>(impl)->systemId();
 }
 
 DOMString DocumentType::internalSubset() const
 {
     if (!impl) {
         throw DOMException(DOMException::NOT_FOUND_ERR);
     }
 
     return static_cast<DocumentTypeImpl *>(impl)->internalSubset();
 }
 
 } // namespace