dom_doc.cpp Source File

tdehtml

/*
 * This file is part of the DOM implementation for KDE.
 *
 * (C) 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 <kdebug.h>
 
namespace DOM {
 
DOMImplementation::DOMImplementation()
{
    impl = 0;
}
 
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, doctype, exceptioncode );
    if ( exceptioncode )
        throw DOMException( exceptioncode );
    return r;
}
 
HTMLDocument DOMImplementation::createHTMLDocument( const DOMString& title )
{
    if (!impl) throw DOMException(DOMException::NOT_FOUND_ERR);
 
    HTMLDocumentImpl* r = impl->createHTMLDocument( 0 /* ### create a view otherwise it doesn't work */);
 
    r->open();
 
    r->write(TQString::fromLatin1("<HTML><HEAD><TITLE>") + title.string() +
             TQString::fromLatin1("</TITLE></HEAD>"));
 
    return r;
}
 
DOMImplementation DOMImplementation::getInterface(const DOMString &feature) const
{
    if (!impl)
        throw DOMException(DOMException::NOT_FOUND_ERR);
 
    return impl->getInterface(feature);
}
 
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 == 0);
}
 
// ----------------------------------------------------------------------------
 
Document::Document()
    : Node()
{
    // we always want an implementation
    impl = DOMImplementationImpl::instance()->createDocument();
    impl->ref();
}
 
Document::Document(bool create)
    : Node()
{
    if(create)
    {
    impl = DOMImplementationImpl::instance()->createDocument();
    impl->ref();
    }
    else
    impl = 0;
//    kdDebug(6090) << "Document::Document(bool)" << endl;
}
 
Document::Document(const Document &other) : Node(other)
{
//    kdDebug(6090) << "Document::Document(Document &)" << endl;
}
 
Document::Document(DocumentImpl *i) : Node(i)
{
//    kdDebug(6090) << "Document::Document(DocumentImpl)" << endl;
}
 
Document &Document::operator = (const Node &other)
{
    NodeImpl* ohandle = other.handle();
    if ( impl != ohandle ) {
        if (!ohandle || ohandle->nodeType() != DOCUMENT_NODE) {
        if ( impl ) impl->deref();
            impl = 0;
    } else {
            Node::operator =(other);
    }
    }
    return *this;
}
 
Document &Document::operator = (const Document &other)
{
    Node::operator =(other);
    return *this;
}
 
Document::~Document()
{
//    kdDebug(6090) << "Document::~Document\n" << endl;
}
 
DocumentType Document::doctype() const
{
    if (impl) return ((DocumentImpl *)impl)->doctype();
    return 0;
}
 
DOMImplementation Document::implementation() const
{
    if (impl) return ((DocumentImpl *)impl)->implementation();
    return 0;
}
 
Element Document::documentElement() const
{
    if (impl) return ((DocumentImpl *)impl)->documentElement();
    return 0;
}
 
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 0;
}
 
Text Document::createTextNode( const DOMString &data )
{
    if (impl) return ((DocumentImpl *)impl)->createTextNode( data.implementation() );
    return 0;
}
 
Comment Document::createComment( const DOMString &data )
{
    if (impl) return ((DocumentImpl *)impl)->createComment( data.implementation() );
    return 0;
}
 
CDATASection Document::createCDATASection( const DOMString &data )
{
    // ### DOM1 spec says raise exception if html documents - what about XHTML documents?
    if (impl) return ((DocumentImpl *)impl)->createCDATASection( data.implementation() );
    return 0;
}
 
ProcessingInstruction Document::createProcessingInstruction( const DOMString &target, const DOMString &data )
{
    if (impl) return ((DocumentImpl *)impl)->createProcessingInstruction( target, data.implementation() );
    return 0;
}
 
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->getDocument()->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->getDocument()->createAttributeNS(namespaceURI, qualifiedName, &exceptioncode);
    if ( exceptioncode )
        throw DOMException( exceptioncode );
    return a;
}
 
EntityReference Document::createEntityReference( const DOMString &name )
{
    if (impl) return ((DocumentImpl *)impl)->createEntityReference( name );
    return 0;
}
 
Element Document::getElementById( const DOMString &elementId ) const
{
    if(impl) return ((DocumentImpl *)impl)->getElementById( elementId );
    return 0;
}
 
NodeList Document::getElementsByTagName( const DOMString &tagName )
{
    if (!impl) return 0;
    NodeImpl::Id id;
    if ( tagName == "*" )
        id = 0;
    else
        id = impl->getDocument()->getId(NodeImpl::ElementId, tagName.implementation(), false, true);
    return new TagNodeListImpl( impl, id );
}
 
NodeList Document::getElementsByTagNameNS( const DOMString &namespaceURI, const DOMString &localName )
{
    if (!impl) return 0;
    return new TagNodeListImpl( impl, namespaceURI, localName );
}
 
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 0;
}
 
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,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);
}
 
 
TDEHTMLView *Document::view() const
{
    if (!impl) return 0;
 
    return static_cast<DocumentImpl*>(impl)->view();
}
 
CSSStyleDeclaration Document::getOverrideStyle(const Element &elt, const DOMString &pseudoElt)
{
    if (!impl)
    throw DOMException(DOMException::INVALID_STATE_ERR);
 
    int exceptioncode = 0;
    CSSStyleDeclarationImpl *r = ((DocumentImpl *)impl)->getOverrideStyle(static_cast<ElementImpl*>(elt.handle()),pseudoElt.implementation());
    if (exceptioncode)
    throw DOMException(exceptioncode);
    return r;
}
 
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 );
}
 
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 = 0;
        } else {
            Node::operator =(other);
        }
    }
    return *this;
}
 
DocumentFragment &DocumentFragment::operator = (const DocumentFragment &other)
{
    Node::operator =(other);
    return *this;
}
 
DocumentFragment::~DocumentFragment()
{
}
 
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 = 0;
    } 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 0; // ### enable throw DOMException(DOMException::NOT_FOUND_ERR);
 
    return static_cast<DocumentTypeImpl*>(impl)->entities();
}
 
NamedNodeMap DocumentType::notations() const
{
    if (!impl)
    return 0; // ### 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