/*
 *  This file is part of the KDE libraries
 *  Copyright (C) 2000 Harri Porten (porten@kde.org)
 *  Copyright (C) 2003 Apple Computer, Inc.
 *  Copyright (C) 2010 Maksim Orlovich (maksim@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; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "kjs_dom.h"
#include "kjs_dom.lut.h"

#include <khtmlview.h>
#include <xml/dom2_eventsimpl.h>
#include <rendering/render_canvas.h>
#include <rendering/render_layer.h>
#include <xml/dom_nodeimpl.h>
#include <xml/dom_docimpl.h>
#include <xml/dom3_xpathimpl.h>
#include <html/html_baseimpl.h>
#include <html/html_documentimpl.h>
#include <html/html_miscimpl.h>
#include "HTMLAudioElement.h"
#include "HTMLVideoElement.h"
#include "JSHTMLAudioElement.h"
#include "JSHTMLVideoElement.h"
#include "khtml_debug.h"
#include <khtml_part.h>
#include <QList>

#include "kjs_html.h"
#include "kjs_css.h"
#include "kjs_range.h"
#include "kjs_traversal.h"
#include "kjs_events.h"
#include "kjs_views.h"
#include "kjs_window.h"
#include "kjs_xpath.h"
#include "kjs_clientrect.h"
#include "xmlhttprequest.h"
#include <kjs/PropertyNameArray.h>
#include <dom/dom_exception.h>
#include <dom/html_document.h>
#include <khtmlpart_p.h>

// for win32, MinGW
#undef FOCUS_EVENT
#undef CreateEvent

using namespace KJS;
using namespace khtml;
using namespace DOM;

// -------------------------------------------------------------------------
/* Source for DOMNodeConstantsTable.
@begin DOMNodeConstantsTable 21
  ELEMENT_NODE      DOM::Node::ELEMENT_NODE     DontDelete|ReadOnly
  ATTRIBUTE_NODE    DOM::Node::ATTRIBUTE_NODE       DontDelete|ReadOnly
  TEXT_NODE     DOM::Node::TEXT_NODE        DontDelete|ReadOnly
  CDATA_SECTION_NODE    DOM::Node::CDATA_SECTION_NODE   DontDelete|ReadOnly
  ENTITY_REFERENCE_NODE DOM::Node::ENTITY_REFERENCE_NODE    DontDelete|ReadOnly
  ENTITY_NODE       DOM::Node::ENTITY_NODE      DontDelete|ReadOnly
  PROCESSING_INSTRUCTION_NODE DOM::Node::PROCESSING_INSTRUCTION_NODE DontDelete|ReadOnly
  COMMENT_NODE      DOM::Node::COMMENT_NODE     DontDelete|ReadOnly
  DOCUMENT_NODE     DOM::Node::DOCUMENT_NODE        DontDelete|ReadOnly
  DOCUMENT_TYPE_NODE    DOM::Node::DOCUMENT_TYPE_NODE   DontDelete|ReadOnly
  DOCUMENT_FRAGMENT_NODE DOM::Node::DOCUMENT_FRAGMENT_NODE  DontDelete|ReadOnly
  NOTATION_NODE     DOM::Node::NOTATION_NODE        DontDelete|ReadOnly
  XPATH_NAMESPACE_NODE  DOM::Node::XPATH_NAMESPACE_NODE         DontDelete|ReadOnly
  DOCUMENT_POSITION_DISCONNECTED                DOM::Node::DOCUMENT_POSITION_DISCONNECTED  DontDelete|ReadOnly
  DOCUMENT_POSITION_PRECEDING                   DOM::Node::DOCUMENT_POSITION_PRECEDING  DontDelete|ReadOnly
  DOCUMENT_POSITION_FOLLOWING                   DOM::Node::DOCUMENT_POSITION_FOLLOWING   DontDelete|ReadOnly
  DOCUMENT_POSITION_CONTAINS                    DOM::Node::DOCUMENT_POSITION_CONTAINS  DontDelete|ReadOnly
  DOCUMENT_POSITION_CONTAINED_BY                DOM::Node::DOCUMENT_POSITION_CONTAINED_BY  DontDelete|ReadOnly
  DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC     DOM::Node::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC  DontDelete|ReadOnly
@end
*/
IMPLEMENT_CONSTANT_TABLE(DOMNodeConstants, "DOMNodeConstants")

// -------------------------------------------------------------------------
/* Source for DOMNodeProtoTable.
@begin DOMNodeProtoTable 13
  insertBefore  DOMNode::InsertBefore   DontDelete|Function 2
  replaceChild  DOMNode::ReplaceChild   DontDelete|Function 2
  removeChild   DOMNode::RemoveChild    DontDelete|Function 1
  appendChild   DOMNode::AppendChild    DontDelete|Function 1
  hasAttributes DOMNode::HasAttributes  DontDelete|Function 0
  hasChildNodes DOMNode::HasChildNodes  DontDelete|Function 0
  cloneNode DOMNode::CloneNode  DontDelete|Function 1
# DOM2
  normalize DOMNode::Normalize  DontDelete|Function 0
  isSupported   DOMNode::IsSupported    DontDelete|Function 2
# DOM3
  compareDocumentPosition   DOMNode::CompareDocumentPosition    DontDelete|Function 1
# from the EventTarget interface
  addEventListener  DOMNode::AddEventListener   DontDelete|Function 3
  removeEventListener   DOMNode::RemoveEventListener    DontDelete|Function 3
  dispatchEvent     DOMNode::DispatchEvent  DontDelete|Function 1
# IE extensions
  contains  DOMNode::Contains       DontDelete|Function 1
  insertAdjacentHTML    DOMNode::InsertAdjacentHTML DontDelete|Function 2
@end
*/
KJS_IMPLEMENT_PROTOFUNC(DOMNodeProtoFunc)
KJS_IMPLEMENT_PROTOTYPE_IMP("DOMNode", DOMNodeProto, DOMNodeProtoFunc, DOMNodeConstants)
{
    // We need to setup the constructor property to the ctor here, but NodeConstructor::self
    // will try to make us again, since we're in the middle of cacheGlobalObject.
    // To workaround that, register ourselves so the re-entry of cacheGlobalObject
    // will pick us. NodeCtor ctor does the same already, to fix the problem
    // in the other direction.
    exec->lexicalInterpreter()->globalObject()->put(exec, *name(), this, KJS::Internal | KJS::DontEnum);
    putDirect(exec->propertyNames().constructor, NodeConstructor::self(exec), DontEnum);
}

const ClassInfo DOMNode::info = { "Node", nullptr, &DOMNodeTable, nullptr };

DOMNode::DOMNode(ExecState *exec, DOM::NodeImpl *n)
    : DOMObject(DOMNodeProto::self(exec)), m_impl(n)
{}

DOMNode::DOMNode(JSObject *proto, DOM::NodeImpl *n)
    : DOMObject(proto), m_impl(n)
{}

DOMNode::~DOMNode()
{
    ScriptInterpreter::forgetDOMObject(m_impl.get());
}

bool DOMNode::toBoolean(ExecState *) const
{
    return !m_impl.isNull();
}

/* Source for DOMNodeTable.
@begin DOMNodeTable 53
  nodeName  DOMNode::NodeName   DontDelete|ReadOnly
  nodeValue DOMNode::NodeValue  DontDelete
  nodeType  DOMNode::NodeType   DontDelete|ReadOnly
  parentNode    DOMNode::ParentNode DontDelete|ReadOnly
  parentElement DOMNode::ParentElement  DontDelete|ReadOnly
  childNodes    DOMNode::ChildNodes DontDelete|ReadOnly
  firstChild    DOMNode::FirstChild DontDelete|ReadOnly
  lastChild DOMNode::LastChild  DontDelete|ReadOnly
  previousSibling  DOMNode::PreviousSibling DontDelete|ReadOnly
  nextSibling   DOMNode::NextSibling    DontDelete|ReadOnly
  attributes    DOMNode::Attributes DontDelete|ReadOnly
  namespaceURI  DOMNode::NamespaceURI   DontDelete|ReadOnly
# DOM2
  prefix    DOMNode::Prefix     DontDelete
  localName DOMNode::LocalName  DontDelete|ReadOnly
  ownerDocument DOMNode::OwnerDocument  DontDelete|ReadOnly
# DOM3
  textContent   DOMNode::TextContent    DontDelete
# Event handlers
# IE also has: onactivate, onbefore*, oncontextmenu, oncontrolselect, oncut,
# ondeactivate, ondrag*, ondrop, onfocusin, onfocusout, onhelp, onmousewheel,
# onmove*, onpaste, onpropertychange, onreadystatechange, onresizeend/start,
# onselectionchange, onstop
  onabort   DOMNode::OnAbort        DontDelete
  onblur    DOMNode::OnBlur         DontDelete
  onchange  DOMNode::OnChange       DontDelete
  onclick   DOMNode::OnClick        DontDelete
  ondblclick    DOMNode::OnDblClick     DontDelete
  ondragdrop    DOMNode::OnDragDrop     DontDelete
  onerror   DOMNode::OnError        DontDelete
  onfocus   DOMNode::OnFocus            DontDelete
  onkeydown DOMNode::OnKeyDown      DontDelete
  onkeypress    DOMNode::OnKeyPress     DontDelete
  onkeyup   DOMNode::OnKeyUp        DontDelete
  onload    DOMNode::OnLoad         DontDelete
  onmousedown   DOMNode::OnMouseDown        DontDelete
  onmousemove   DOMNode::OnMouseMove        DontDelete
  onmouseout    DOMNode::OnMouseOut     DontDelete
  onmouseover   DOMNode::OnMouseOver        DontDelete
  onmouseup DOMNode::OnMouseUp      DontDelete
  onmove    DOMNode::OnMove         DontDelete
  onreset   DOMNode::OnReset        DontDelete
  onresize  DOMNode::OnResize       DontDelete
  onscroll      DOMNode::OnScroll               DontDelete
  onselect  DOMNode::OnSelect       DontDelete
  onsubmit  DOMNode::OnSubmit       DontDelete
  onunload  DOMNode::OnUnload       DontDelete
# IE extensions
  offsetLeft    DOMNode::OffsetLeft     DontDelete|ReadOnly
  offsetTop DOMNode::OffsetTop      DontDelete|ReadOnly
  offsetWidth   DOMNode::OffsetWidth        DontDelete|ReadOnly
  offsetHeight  DOMNode::OffsetHeight       DontDelete|ReadOnly
  offsetParent  DOMNode::OffsetParent       DontDelete|ReadOnly
  clientWidth   DOMNode::ClientWidth        DontDelete|ReadOnly
  clientHeight  DOMNode::ClientHeight       DontDelete|ReadOnly
  clientLeft    DOMNode::ClientLeft     DontDelete|ReadOnly
  clientTop DOMNode::ClientTop      DontDelete|ReadOnly
  scrollLeft    DOMNode::ScrollLeft     DontDelete
  scrollTop DOMNode::ScrollTop      DontDelete
  scrollWidth   DOMNode::ScrollWidth            DontDelete|ReadOnly
  scrollHeight  DOMNode::ScrollHeight           DontDelete|ReadOnly
  sourceIndex   DOMNode::SourceIndex        DontDelete|ReadOnly
@end
*/

bool DOMNode::getOwnPropertySlot(ExecState *exec, const Identifier &propertyName, PropertySlot &slot)
{
#ifdef KJS_VERBOSE
    qCDebug(KHTML_LOG) << "DOMNode::getOwnPropertySlot " << propertyName.qstring();
#endif
    return getStaticValueSlot<DOMNode, DOMObject>(exec, &DOMNodeTable, this, propertyName, slot);
}

static khtml::RenderObject *handleBodyRootQuirk(const DOM::NodeImpl *node, khtml::RenderObject *rend, int token)
{
    //This emulates the quirks of various height/width properties on the viewport and root. Note that it
    //is (mostly) IE-compatible in quirks, and mozilla-compatible in strict.
    if (!rend) {
        return nullptr;
    }

    bool quirksMode = rend->style() && rend->style()->htmlHacks();

    //There are a couple quirks here. One is that in quirks mode body is always forwarded to root...
    //This is relevant for even the scrollTop/scrollLeft type properties.
    if (quirksMode && node->id() == ID_BODY) {
        while (rend->parent() && !rend->isRoot()) {
            rend = rend->parent();
        }
    }

    //Also, some properties of the root are really done in terms of the viewport.
    //These are  {offset/client}{Height/Width}. The offset versions do it only in
    //quirks mode, the client always.
    if (!rend->isRoot()) {
        return rend;    //Don't care about non-root things here!
    }
    bool needViewport = false;

    switch (token) {
    case DOMNode::OffsetHeight:
    case DOMNode::OffsetWidth:
        needViewport = quirksMode;
        break;
    case DOMNode::ClientHeight:
    case DOMNode::ClientWidth:
    case DOMNode::ClientLeft:
    case DOMNode::ClientTop:
        needViewport = true;
        break;
    }

    if (needViewport) {
        //Scan up to find the new target
        while (rend->parent()) {
            rend = rend->parent();
        }
    }
    return rend;
}

JSValue *DOMNode::getValueProperty(ExecState *exec, int token) const
{
    NodeImpl &node = *impl();
    switch (token) {
    case NodeName:
        return jsString(node.nodeName());
    case NodeValue:
        return ::getStringOrNull(node.nodeValue()); // initially null, per domts/level1/core/hc_documentcreateelement.html
    case NodeType:
        return jsNumber((unsigned int)node.nodeType());
    case ParentNode:
        return getDOMNode(exec, node.parentNode());
    case ParentElement: // IE only apparently
        return getDOMNode(exec, node.parentNode());
    case ChildNodes:
        return getDOMNodeList(exec, node.childNodes().get());
    case FirstChild:
        return getDOMNode(exec, node.firstChild());
    case LastChild:
        return getDOMNode(exec, node.lastChild());
    case PreviousSibling:
        return getDOMNode(exec, node.previousSibling());
    case NextSibling:
        return getDOMNode(exec, node.nextSibling());
    case Attributes: {
        DOM::NamedNodeMapImpl *attrs = nullptr;
        if (node.isElementNode()) {
            DOM::ElementImpl &el = static_cast<DOM::ElementImpl &>(node);
            attrs = el.attributes();
        }
        return getDOMNamedNodeMap(exec, attrs);
    }
    case NamespaceURI:
        return ::getStringOrNull(node.namespaceURI()); // Moz returns null if not set (dom/namespaces.html)
    case Prefix:
        return ::getStringOrNull(node.prefix());  // Moz returns null if not set (dom/namespaces.html)
    case LocalName:
        return ::getStringOrNull(node.localName());  // Moz returns null if not set (dom/namespaces.html)
    case OwnerDocument:
        return getDOMNode(exec, node.ownerDocument());
    case TextContent:
        return ::getStringOrNull(node.textContent());
    case OnAbort:
        return getListener(DOM::EventImpl::ABORT_EVENT);
    case OnBlur:
        return getListener(DOM::EventImpl::BLUR_EVENT);
    case OnChange:
        return getListener(DOM::EventImpl::CHANGE_EVENT);
    case OnClick:
        return getListener(DOM::EventImpl::KHTML_ECMA_CLICK_EVENT);
    case OnDblClick:
        return getListener(DOM::EventImpl::KHTML_ECMA_DBLCLICK_EVENT);
    case OnDragDrop:
        return getListener(DOM::EventImpl::KHTML_DRAGDROP_EVENT);
    case OnError:
        return getListener(DOM::EventImpl::ERROR_EVENT);
    case OnFocus:
        return getListener(DOM::EventImpl::FOCUS_EVENT);
    case OnKeyDown:
        return getListener(DOM::EventImpl::KEYDOWN_EVENT);
    case OnKeyPress:
        return getListener(DOM::EventImpl::KEYPRESS_EVENT);
    case OnKeyUp:
        return getListener(DOM::EventImpl::KEYUP_EVENT);
    case OnLoad:
        return getListener(DOM::EventImpl::LOAD_EVENT);
    case OnMouseDown:
        return getListener(DOM::EventImpl::MOUSEDOWN_EVENT);
    case OnMouseMove:
        return getListener(DOM::EventImpl::MOUSEMOVE_EVENT);
    case OnMouseOut:
        return getListener(DOM::EventImpl::MOUSEOUT_EVENT);
    case OnMouseOver:
        return getListener(DOM::EventImpl::MOUSEOVER_EVENT);
    case OnMouseUp:
        return getListener(DOM::EventImpl::MOUSEUP_EVENT);
    case OnMove:
        return getListener(DOM::EventImpl::KHTML_MOVE_EVENT);
    case OnReset:
        return getListener(DOM::EventImpl::RESET_EVENT);
    case OnResize:
        return getListener(DOM::EventImpl::RESIZE_EVENT);
    case OnScroll:
        return getListener(DOM::EventImpl::SCROLL_EVENT);
    case OnSelect:
        return getListener(DOM::EventImpl::SELECT_EVENT);
    case OnSubmit:
        return getListener(DOM::EventImpl::SUBMIT_EVENT);
    case OnUnload:
        return getListener(DOM::EventImpl::UNLOAD_EVENT);
    case SourceIndex: {
        // Retrieves the ordinal position of the object, in source order, as the object
        // appears in the document's all collection
        // i.e. document.all[n.sourceIndex] == n
        DOM::DocumentImpl *doc = node.document();
        if (doc->isHTMLDocument()) {
            HTMLCollectionImpl all(doc, HTMLCollectionImpl::DOC_ALL);
            unsigned long i = 0;
            for (DOM::NodeImpl *n = all.firstItem(); n; n = all.nextItem()) {
                if (n == impl()) {
                    return jsNumber(i);
                }
                ++i;
            }
        }
        return jsUndefined();
    }
    default:
        // no DOM standard, found in IE only

        // Make sure our layout is up to date before we allow a query on these attributes.
        DOM::DocumentImpl *docimpl = node.document();
        if (docimpl) {
            docimpl->updateLayout();
        }

        khtml::RenderObject *rend = node.renderer();

        //In quirks mode, may need to forward if to body.
        rend = handleBodyRootQuirk(impl(), rend, token);

        switch (token) {
        case OffsetLeft:
            return rend ? jsNumber(rend->offsetLeft()) : jsNumber(0);
        case OffsetTop:
            return rend ? jsNumber(rend->offsetTop()) : jsNumber(0);
        case OffsetWidth:
            return rend ? jsNumber(rend->offsetWidth()) : jsNumber(0);
        case OffsetHeight:
            return rend ? jsNumber(rend->offsetHeight()) : jsNumber(0);
        case OffsetParent: {
            khtml::RenderObject *par = rend ? rend->offsetParent() : nullptr;
            return getDOMNode(exec, par ? par->element() : nullptr);
        }
        case ClientWidth:
            return rend ? jsNumber(rend->clientWidth()) : jsNumber(0);
        case ClientHeight:
            return rend ? jsNumber(rend->clientHeight()) : jsNumber(0);
        case ClientLeft:
            return rend ? jsNumber(rend->clientLeft()) : jsNumber(0);
        case ClientTop:
            return rend ? jsNumber(rend->clientTop()) : jsNumber(0);
        case ScrollWidth:
            return rend ? jsNumber(rend->scrollWidth()) : jsNumber(0);
        case ScrollHeight:
            return rend ? jsNumber(rend->scrollHeight()) : jsNumber(0);
        case ScrollLeft:
            if (rend && rend->layer()) {
                if (rend->isRoot() && !rend->hasOverflowClip()) {
                    return jsNumber(node.document()->view() ? node.document()->view()->contentsX() : 0);
                }
                return jsNumber(rend->hasOverflowClip() ? rend->layer()->scrollXOffset() : 0);
            }
            return jsNumber(0);
        case ScrollTop:
            if (rend && rend->layer()) {
                if (rend->isRoot() && !rend->hasOverflowClip()) {
                    return jsNumber(node.document()->view() ? node.document()->view()->contentsY() : 0);
                }
                return jsNumber(rend->hasOverflowClip() ? rend->layer()->scrollYOffset() : 0);
            }
            return jsNumber(0);
        default:
            // qCDebug(KHTML_LOG) << "WARNING: Unhandled token in DOMNode::getValueProperty : " << token;
            break;
        }
    }
    return jsUndefined();
}

void DOMNode::put(ExecState *exec, const Identifier &propertyName, JSValue *value, int attr)
{
#ifdef KJS_VERBOSE
    qCDebug(KHTML_LOG) << "DOMNode::tryPut " << propertyName.qstring();
#endif
    lookupPut<DOMNode, DOMObject>(exec, propertyName, value, attr,
                                  &DOMNodeTable, this);
}

void DOMNode::putValueProperty(ExecState *exec, int token, JSValue *value, int /*attr*/)
{
    DOMExceptionTranslator exception(exec);
    NodeImpl &node = *impl();

    switch (token) {
    case NodeValue:
        node.setNodeValue(value->toString(exec).domString(), exception);
        break;
    case Prefix:
        node.setPrefix(value->toString(exec).domString(), exception);
        break;
    case TextContent:
        node.setTextContent(valueToStringWithNullCheck(exec, value), exception);
        break;
    case OnAbort:
        setListener(exec, DOM::EventImpl::ABORT_EVENT, value);
        break;
    case OnBlur:
        setListener(exec, DOM::EventImpl::BLUR_EVENT, value);
        break;
    case OnChange:
        setListener(exec, DOM::EventImpl::CHANGE_EVENT, value);
        break;
    case OnClick:
        setListener(exec, DOM::EventImpl::KHTML_ECMA_CLICK_EVENT, value);
        break;
    case OnDblClick:
        setListener(exec, DOM::EventImpl::KHTML_ECMA_DBLCLICK_EVENT, value);
        break;
    case OnDragDrop:
        setListener(exec, DOM::EventImpl::KHTML_DRAGDROP_EVENT, value);
        break;
    case OnError:
        setListener(exec, DOM::EventImpl::ERROR_EVENT, value);
        break;
    case OnFocus:
        setListener(exec, DOM::EventImpl::FOCUS_EVENT, value);
        break;
    case OnKeyDown:
        setListener(exec, DOM::EventImpl::KEYDOWN_EVENT, value);
        break;
    case OnKeyPress:
        setListener(exec, DOM::EventImpl::KEYPRESS_EVENT, value);
        break;
    case OnKeyUp:
        setListener(exec, DOM::EventImpl::KEYUP_EVENT, value);
        break;
    case OnLoad:
        setListener(exec, DOM::EventImpl::LOAD_EVENT, value);
        break;
    case OnMouseDown:
        setListener(exec, DOM::EventImpl::MOUSEDOWN_EVENT, value);
        break;
    case OnMouseMove:
        setListener(exec, DOM::EventImpl::MOUSEMOVE_EVENT, value);
        break;
    case OnMouseOut:
        setListener(exec, DOM::EventImpl::MOUSEOUT_EVENT, value);
        break;
    case OnMouseOver:
        setListener(exec, DOM::EventImpl::MOUSEOVER_EVENT, value);
        break;
    case OnMouseUp:
        setListener(exec, DOM::EventImpl::MOUSEUP_EVENT, value);
        break;
    case OnMove:
        setListener(exec, DOM::EventImpl::KHTML_MOVE_EVENT, value);
        break;
    case OnReset:
        setListener(exec, DOM::EventImpl::RESET_EVENT, value);
        break;
    case OnResize:
        setListener(exec, DOM::EventImpl::RESIZE_EVENT, value);
        break;
    case OnScroll:
        setListener(exec, DOM::EventImpl::SCROLL_EVENT, value);
        break;
    case OnSelect:
        setListener(exec, DOM::EventImpl::SELECT_EVENT, value);
        break;
    case OnSubmit:
        setListener(exec, DOM::EventImpl::SUBMIT_EVENT, value);
        break;
    case OnUnload:
        setListener(exec, DOM::EventImpl::UNLOAD_EVENT, value);
        break;
    default:
        // Make sure our layout is up to date
        DOM::DocumentImpl *docimpl = node.document();
        if (docimpl) {
            docimpl->updateLayout();
        }

        khtml::RenderObject *rend = node.renderer();

        //In quirks mode, may need to forward.
        rend = handleBodyRootQuirk(impl(), rend, token);

        switch (token) {
        case ScrollLeft:
            if (rend && rend->layer()) {
                if (rend->hasOverflowClip()) {
                    rend->layer()->scrollToXOffset(value->toInt32(exec));
                } else if (rend->isRoot()) {
                    KHTMLView *sview = node.document()->view();
                    if (sview) {
                        sview->setContentsPos(value->toInt32(exec), sview->contentsY());
                    }
                }
            }
            break;
        case ScrollTop:
            if (rend && rend->layer()) {
                if (rend->hasOverflowClip()) {
                    rend->layer()->scrollToYOffset(value->toInt32(exec));
                } else if (rend->isRoot()) {
                    KHTMLView *sview = node.document()->view();
                    if (sview) {
                        sview->setContentsPos(sview->contentsX(), value->toInt32(exec));
                    }
                }
            }
            break;
        default:
            // qCDebug(KHTML_LOG) << "WARNING: DOMNode::putValueProperty unhandled token " << token;
            break;
        }
    }
}

JSValue *DOMNode::toPrimitive(ExecState *exec, JSType /*preferred*/) const
{
    if (m_impl.isNull()) {
        return jsNull();
    }

    return jsString(toString(exec));
}

UString DOMNode::toString(ExecState *) const
{
    if (m_impl.isNull()) {
        return "null";
    }
    return "[object " + className() + "]";
}

void DOMNode::setListener(ExecState *exec, int eventId, JSValue *func) const
{
    m_impl->setHTMLEventListener(eventId, Window::retrieveActive(exec)->getJSEventListener(func, true));
}

JSValue *DOMNode::getListener(int eventId) const
{
    DOM::EventListener *listener = m_impl->getHTMLEventListener(eventId);
    JSEventListener *jsListener = static_cast<JSEventListener *>(listener);
    if (jsListener && jsListener->listenerObj()) {
        return jsListener->listenerObj();
    } else {
        return jsNull();
    }
}

void DOMNode::pushEventHandlerScope(ExecState *, ScopeChain &) const
{
}

JSValue *DOMNodeProtoFunc::callAsFunction(ExecState *exec, JSObject *thisObj, const List &args)
{
    KJS_CHECK_THIS(DOMNode, thisObj);
    DOMExceptionTranslator exception(exec);
    DOM::NodeImpl &node = *static_cast<DOMNode *>(thisObj)->impl();
    switch (id) {
    case DOMNode::HasAttributes:
        return jsBoolean(node.hasAttributes());
    case DOMNode::HasChildNodes:
        return jsBoolean(node.hasChildNodes());
    case DOMNode::CloneNode: {
        RefPtr<NodeImpl> clone = node.cloneNode(args[0]->toBoolean(exec));
        return getDOMNode(exec, clone.get());
    }
    case DOMNode::Normalize:
        node.normalize();
        return jsUndefined();
    case DOMNode::IsSupported:
        return jsBoolean(node.isSupported(args[0]->toString(exec).domString(), args[1]->toString(exec).domString()));
    case DOMNode::AddEventListener: {
        JSEventListener *listener = Window::retrieveActive(exec)->getJSEventListener(args[1]);
        EventName id = EventName::fromString(args[0]->toString(exec).domString());
        node.addEventListener(id, listener, args[2]->toBoolean(exec));
        return jsUndefined();
    }
    case DOMNode::RemoveEventListener: {
        JSEventListener *listener = Window::retrieveActive(exec)->getJSEventListener(args[1]);
        EventName id = EventName::fromString(args[0]->toString(exec).domString());
        node.removeEventListener(id, listener, args[2]->toBoolean(exec));
        return jsUndefined();
    }
    case DOMNode::DispatchEvent: {
        SharedPtr<DOM::EventImpl> evt = toEvent(args[0]);
        if (!evt) {
            setDOMException(exec, DOMException::NOT_FOUND_ERR);
            return jsUndefined();
        }
        node.dispatchEvent(evt.get(), exception);
        return jsBoolean(!evt->defaultPrevented());
    }
    case DOMNode::AppendChild:
        return getDOMNode(exec, node.appendChild(toNode(args[0]), exception));
    case DOMNode::RemoveChild: {
        SharedPtr<DOM::NodeImpl> oldKid = toNode(args[0]);
        node.removeChild(oldKid.get(), exception);
        return getDOMNode(exec, oldKid.get());
    }
    case DOMNode::InsertBefore:
        return getDOMNode(exec, node.insertBefore(toNode(args[0]), toNode(args[1]), exception));
    case DOMNode::ReplaceChild: {
        SharedPtr<DOM::NodeImpl> oldKid = toNode(args[1]);
        node.replaceChild(toNode(args[0]), oldKid.get(), exception);
        return getDOMNode(exec, oldKid.get());
    }
    case DOMNode::Contains: {
        DOM::NodeImpl *other = toNode(args[0]);
        if (other && other->isElementNode()) {
            return jsBoolean(other->isAncestor(&node));
        }
        setDOMException(exec, DOMException::TYPE_MISMATCH_ERR); // ### a guess
        return jsUndefined();
    }
    case DOMNode::InsertAdjacentHTML: {
        // see http://www.faqts.com/knowledge_base/view.phtml/aid/5756
        // and http://msdn.microsoft.com/workshop/author/dhtml/reference/methods/insertAdjacentHTML.asp
        SharedPtr<DOM::RangeImpl> range = node.document()->createRange();

        range->setStartBefore(&node, exception);
        if (exception.triggered()) {
            return jsUndefined();
        }

        SharedPtr<DOM::DocumentFragmentImpl> docFrag =
            static_cast<DOM::DocumentFragmentImpl *>(range->createContextualFragment(args[1]->toString(exec).domString(), exception).handle());
        if (exception.triggered()) {
            return jsUndefined();
        }

        DOMString where = args[0]->toString(exec).domString().lower();

        if (where == "beforebegin") {
            node.parentNode()->insertBefore(docFrag.get(), &node, exception);
        } else if (where == "afterbegin") {
            node.insertBefore(docFrag.get(), node.firstChild(), exception);
        } else if (where == "beforeend") {
            return getDOMNode(exec, node.appendChild(docFrag.get(), exception));
        } else if (where == "afterend") {
            if (node.nextSibling()) {
                node.parentNode()->insertBefore(docFrag.get(), node.nextSibling(), exception);
            } else {
                node.parentNode()->appendChild(docFrag.get(), exception);
            }
        }

        return jsUndefined();
    }
    case DOMNode::CompareDocumentPosition: {
        DOM::NodeImpl *other = toNode(args[0]);
        if (!other) {
            setDOMException(exec, DOMException::TYPE_MISMATCH_ERR);
        } else {
            return jsNumber(node.compareDocumentPosition(other));
        }
    }
    }

    return jsUndefined();
}

// -------------------------------------------------------------------------

/*
@begin DOMNodeListProtoTable 2
  item      DOMNodeList::Item       DontDelete|Function 1
# IE extension (IE treats DOMNodeList like an HTMLCollection)
  namedItem DOMNodeList::NamedItem      DontDelete|Function 1
@end
*/
KJS_DEFINE_PROTOTYPE(DOMNodeListProto)
KJS_IMPLEMENT_PROTOFUNC(DOMNodeListProtoFunc)
KJS_IMPLEMENT_PROTOTYPE("DOMNodeList", DOMNodeListProto, DOMNodeListProtoFunc, ObjectPrototype)

IMPLEMENT_PSEUDO_CONSTRUCTOR(NodeListPseudoCtor, "NodeList", DOMNodeListProto)

const ClassInfo DOMNodeList::info = { "NodeList", nullptr, nullptr, nullptr };

DOMNodeList::DOMNodeList(ExecState *exec, DOM::NodeListImpl *l)
    : DOMObject(DOMNodeListProto::self(exec)), m_impl(l) { }

DOMNodeList::~DOMNodeList()
{
    ScriptInterpreter::forgetDOMObject(m_impl.get());
}

JSValue *DOMNodeList::indexGetter(ExecState *exec, unsigned index)
{
    return getDOMNode(exec, m_impl->item(index));
}

JSValue *DOMNodeList::nameGetter(ExecState *exec, JSObject *, const Identifier &name, const PropertySlot &slot)
{
    DOMNodeList *thisObj = static_cast<DOMNodeList *>(slot.slotBase());
    return getDOMNode(exec, thisObj->getByName(name));
}

JSValue *DOMNodeList::lengthGetter(ExecState *, JSObject *, const Identifier &, const PropertySlot &slot)
{
    DOMNodeList *thisObj = static_cast<DOMNodeList *>(slot.slotBase());
    return jsNumber(thisObj->m_impl->length());
}

DOM::NodeImpl *DOMNodeList::getByName(const Identifier &name)
{
    //### M.O.: I bet IE checks name only for some tags.
    DOMString domName = name.domString();
    unsigned long l   = m_impl->length();
    for (unsigned long i = 0; i < l; i++) {
        DOM::NodeImpl *n = m_impl->item(i);
        if (n->isElementNode()) {
            DOM::ElementImpl *e = static_cast<DOM::ElementImpl *>(n);
            if (e->getAttribute(ATTR_ID) == domName || e->getAttribute(ATTR_NAME) == domName) {
                return n;
            }
        }
    }
    return nullptr;
}

bool DOMNodeList::getOwnPropertySlot(ExecState *exec, const Identifier &propertyName, PropertySlot &slot)
{
    if (propertyName == exec->propertyNames().length) {
        slot.setCustom(this, lengthGetter);
        return true;
    }

    //### this could benefit from further nodelist/collection consolidation,
    //including moving nameditem down to nodelists.

    // Look in the prototype (for functions) before assuming it's an item's name
    JSObject *proto = prototype()->getObject();
    if (proto && proto->hasProperty(exec, propertyName)) {
        return false;
    }

    //May be it's an index?
    if (getIndexSlot(this, *m_impl, propertyName, slot)) {
        return true;
    }

    //May be it's a name -- check by ID
    //Check by id
    if (getByName(propertyName)) {
        slot.setCustom(this, nameGetter);
        return true;
    }

    return DOMObject::getOwnPropertySlot(exec, propertyName, slot);
}

void DOMNodeList::getOwnPropertyNames(ExecState *exec, PropertyNameArray &propertyNames, PropertyMap::PropertyMode mode)
{
    for (unsigned i = 0; i < m_impl->length(); ++i) {
        propertyNames.add(Identifier::from(i));
    }

    propertyNames.add(exec->propertyNames().length);

    JSObject::getOwnPropertyNames(exec, propertyNames, mode);
}

// Need to support both get and call, so that list[0] and list(0) work.
JSValue *DOMNodeList::callAsFunction(ExecState *exec, JSObject *, const List &args)
{
    // Do not use thisObj here. See HTMLCollection.
    UString s = args[0]->toString(exec);

    // index-based lookup?
    bool ok;
    unsigned int u = s.qstring().toULong(&ok);
    if (ok) {
        return getDOMNode(exec, m_impl->item(u));
    }

    // try lookup by name
    // ### NodeList::namedItem() would be cool to have
    // ### do we need to support the same two arg overload as in HTMLCollection?
    JSValue *result = get(exec, Identifier(s));

    if (result) {
        return result;
    }

    return jsUndefined();
}

JSValue *DOMNodeListProtoFunc::callAsFunction(ExecState *exec, JSObject *thisObj, const List &args)
{
    KJS_CHECK_THIS(KJS::DOMNodeList, thisObj);
    DOMNodeList *jsList     = static_cast<DOMNodeList *>(thisObj);
    DOM::NodeListImpl &list = *jsList->impl();
    switch (id) {
    case KJS::DOMNodeList::Item:
        return getDOMNode(exec, list.item(args[0]->toInt32(exec)));
    case KJS::DOMNodeList::NamedItem:
        return getDOMNode(exec, jsList->getByName(Identifier(args[0]->toString(exec))));
    default:
        return jsUndefined();
    }
}

// -------------------------------------------------------------------------

//### FIXME: link to the node prototype.
const ClassInfo DOMAttr::info = { "Attr", &DOMNode::info, &DOMAttrTable, nullptr };

/* Source for DOMAttrTable.
@begin DOMAttrTable 5
  name      DOMAttr::Name       DontDelete|ReadOnly
  specified DOMAttr::Specified  DontDelete|ReadOnly
  value     DOMAttr::ValueProperty  DontDelete
  ownerElement  DOMAttr::OwnerElement   DontDelete|ReadOnly
@end
*/
bool DOMAttr::getOwnPropertySlot(ExecState *exec, const Identifier &propertyName, PropertySlot &slot)
{
#ifdef KJS_VERBOSE
    qCDebug(KHTML_LOG) << "DOMAttr::tryGet " << propertyName.qstring();
#endif
    return getStaticValueSlot<DOMAttr, DOMNode>(exec, &DOMAttrTable, this, propertyName, slot);
}

JSValue *DOMAttr::getValueProperty(ExecState *exec, int token) const
{
    AttrImpl *attr = static_cast<AttrImpl *>(impl());
    switch (token) {
    case Name:
        return jsString(attr->name());
    case Specified:
        return jsBoolean(attr->specified());
    case ValueProperty:
        return jsString(attr->nodeValue());
    case OwnerElement: // DOM2
        return getDOMNode(exec, attr->ownerElement());
    }
    return jsNull(); // not reached
}

void DOMAttr::put(ExecState *exec, const Identifier &propertyName, JSValue *value, int attr)
{
#ifdef KJS_VERBOSE
    qCDebug(KHTML_LOG) << "DOMAttr::tryPut " << propertyName.qstring();
#endif
    lookupPut<DOMAttr, DOMNode>(exec, propertyName, value, attr,
                                &DOMAttrTable, this);
}

void DOMAttr::putValueProperty(ExecState *exec, int token, JSValue *value, int /*attr*/)
{
    DOMExceptionTranslator exception(exec);
    switch (token) {
    case ValueProperty:
        static_cast<AttrImpl *>(impl())->setValue(value->toString(exec).domString(), exception);
        return;
    default:
        qCWarning(KHTML_LOG) << "DOMAttr::putValueProperty unhandled token " << token;
    }
}

AttrImpl *toAttr(JSValue *val)
{
    if (!val || !val->isObject(&DOMAttr::info)) {
        return nullptr;
    }
    return static_cast<AttrImpl *>(static_cast<DOMNode *>(val)->impl());
}

// -------------------------------------------------------------------------

/* Source for DOMDocumentProtoTable.
@begin DOMDocumentProtoTable 23
  createElement   DOMDocument::CreateElement                   DontDelete|Function 1
  createDocumentFragment DOMDocument::CreateDocumentFragment   DontDelete|Function 1
  createTextNode  DOMDocument::CreateTextNode                  DontDelete|Function 1
  createComment   DOMDocument::CreateComment                   DontDelete|Function 1
  createCDATASection DOMDocument::CreateCDATASection           DontDelete|Function 1
  createProcessingInstruction DOMDocument::CreateProcessingInstruction DontDelete|Function 1
  createAttribute DOMDocument::CreateAttribute                 DontDelete|Function 1
  createEntityReference DOMDocument::CreateEntityReference     DontDelete|Function 1
  getElementsByTagName  DOMDocument::GetElementsByTagName      DontDelete|Function 1
  importNode           DOMDocument::ImportNode                 DontDelete|Function 2
  createElementNS      DOMDocument::CreateElementNS            DontDelete|Function 2
  createAttributeNS    DOMDocument::CreateAttributeNS          DontDelete|Function 2
  getElementsByTagNameNS  DOMDocument::GetElementsByTagNameNS  DontDelete|Function 2
  getElementById     DOMDocument::GetElementById               DontDelete|Function 1
  createRange        DOMDocument::CreateRange                  DontDelete|Function 0
  createNodeIterator DOMDocument::CreateNodeIterator           DontDelete|Function 3
  createTreeWalker   DOMDocument::CreateTreeWalker             DontDelete|Function 4
  createEvent        DOMDocument::CreateEvent                  DontDelete|Function 1
  getOverrideStyle   DOMDocument::GetOverrideStyle             DontDelete|Function 2
  abort              DOMDocument::Abort                        DontDelete|Function 0
  load               DOMDocument::Load                         DontDelete|Function 1
  loadXML            DOMDocument::LoadXML                      DontDelete|Function 2
  execCommand        DOMDocument::ExecCommand                  DontDelete|Function 3
  queryCommandEnabled DOMDocument::QueryCommandEnabled         DontDelete|Function 1
  queryCommandIndeterm DOMDocument::QueryCommandIndeterm       DontDelete|Function 1
  queryCommandState DOMDocument::QueryCommandState             DontDelete|Function 1
  queryCommandSupported DOMDocument::QueryCommandSupported     DontDelete|Function 1
  queryCommandValue DOMDocument::QueryCommandValue             DontDelete|Function 1
  getElementsByClassName DOMDocument::GetElementsByClassName   DontDelete|Function 1
  querySelector          DOMDocument::QuerySelector            DontDelete|Function 1
  querySelectorAll       DOMDocument::QuerySelectorAll         DontDelete|Function 1
  createExpression       DOMDocument::CreateExpression         DontDelete|Function 2
  createNSResolver       DOMDocument::CreateNSResolver         DontDelete|Function 1
  evaluate               DOMDocument::Evaluate                 DontDelete|Function 4
@end
*/

KJS_IMPLEMENT_PROTOFUNC(DOMDocumentProtoFunc)
KJS_IMPLEMENT_PROTOTYPE("DOMDocument", DOMDocumentProto, DOMDocumentProtoFunc, DOMNodeProto)

IMPLEMENT_PSEUDO_CONSTRUCTOR(DocumentPseudoCtor, "Document", DOMDocumentProto)

const ClassInfo DOMDocument::info = { "Document", &DOMNode::info, &DOMDocumentTable, nullptr };

/* Source for DOMDocumentTable.
@begin DOMDocumentTable 4
  doctype         DOMDocument::DocType                         DontDelete|ReadOnly
  implementation  DOMDocument::Implementation                  DontDelete|ReadOnly
  characterSet    DOMDocument::CharacterSet                    DontDelete|ReadOnly
  documentElement DOMDocument::DocumentElement                 DontDelete|ReadOnly
  styleSheets     DOMDocument::StyleSheets                     DontDelete|ReadOnly
  preferredStylesheetSet  DOMDocument::PreferredStylesheetSet  DontDelete|ReadOnly
  selectedStylesheetSet  DOMDocument::SelectedStylesheetSet    DontDelete
  readyState      DOMDocument::ReadyState                      DontDelete|ReadOnly
  defaultView     DOMDocument::DefaultView                     DontDelete|ReadOnly
  async           DOMDocument::Async                           DontDelete
  title           DOMDocument::Title                           DontDelete
@end
*/

DOMDocument::DOMDocument(ExecState *exec, DOM::DocumentImpl *d)
    : DOMNode(exec, d)
{
    setPrototype(DOMDocumentProto::self(exec));
}

DOMDocument::DOMDocument(JSObject *proto, DOM::DocumentImpl *d)
    : DOMNode(proto, d)
{}

bool DOMDocument::getOwnPropertySlot(ExecState *exec, const Identifier &propertyName, PropertySlot &slot)
{
#ifdef KJS_VERBOSE
    qCDebug(KHTML_LOG) << "DOMDocument::tryGet " << propertyName.qstring();
#endif
    return getStaticValueSlot<DOMDocument, DOMNode>(
               exec, &DOMDocumentTable, this, propertyName, slot);
}

JSValue *DOMDocument::getValueProperty(ExecState *exec, int token) const
{
    DOM::DocumentImpl &doc = *static_cast<DOM::DocumentImpl *>(m_impl.get());

    switch (token) {
    case DocType:
        return getDOMNode(exec, doc.doctype());
    case Implementation:
        return getDOMDOMImplementation(exec, doc.implementation());
    case DocumentElement:
        return getDOMNode(exec, doc.documentElement());
    case CharacterSet: {
        if (doc.part()) {
            return jsString(doc.part()->encoding());
        } else {
            return jsUndefined();
        }
    }
    case StyleSheets:
        //qCDebug(KHTML_LOG) << "DOMDocument::StyleSheets, returning " << doc.styleSheets().length() << " stylesheets";
        return getDOMStyleSheetList(exec, doc.styleSheets(), &doc);
    case DOMDocument::DefaultView: { // DOM2
        KHTMLPart *part = doc.part();
        if (part) {
            return Window::retrieve(part);
        }
        return getDOMAbstractView(exec, doc.defaultView());
    }
    case PreferredStylesheetSet:
        return jsString(doc.preferredStylesheetSet());
    case SelectedStylesheetSet:
        return jsString(doc.selectedStylesheetSet());
    case ReadyState: {
        if (KHTMLPart *part = doc.part()) {
            if (part->d->m_bComplete) {
                return jsString("complete");
            }
            if (doc.parsing()) {
                return jsString("loading");
            }
            return jsString("loaded");
            // What does the interactive value mean ?
            // Missing support for "uninitialized"
        }
        return jsUndefined();
    }
    case Async:
        return jsBoolean(doc.async());
    case Title:
        return jsString(doc.title());
    default:
        // qCDebug(KHTML_LOG) << "WARNING: DOMDocument::getValueProperty unhandled token " << token;
        return jsNull();
    }
}

void DOMDocument::put(ExecState *exec, const Identifier &propertyName, JSValue *value, int attr)
{
#ifdef KJS_VERBOSE
    qCDebug(KHTML_LOG) << "DOMDocument::tryPut " << propertyName.qstring();
#endif
    lookupPut<DOMDocument, DOMNode>(exec, propertyName, value, attr, &DOMDocumentTable, this);
}

void DOMDocument::putValueProperty(ExecState *exec, int token, JSValue *value, int /*attr*/)
{
    DOM::DocumentImpl &doc = *static_cast<DOM::DocumentImpl *>(impl());
    switch (token) {
    case SelectedStylesheetSet: {
        doc.setSelectedStylesheetSet(value->toString(exec).domString());
        break;
    }
    case Async: {
        doc.setAsync(value->toBoolean(exec));
        break;
    }
    case Title: {
        DOM::DOMString val = value->toString(exec).domString();
        if (doc.title() != val) {
            doc.setTitle(val);
        }
        break;
    }
    }
}

JSValue *DOMDocumentProtoFunc::callAsFunction(ExecState *exec, JSObject *thisObj, const List &args)
{
    KJS_CHECK_THIS(KJS::DOMDocument, thisObj);
    DOMExceptionTranslator exception(exec);
    DOM::NodeImpl     &node = *static_cast<DOMNode *>(thisObj)->impl();
    DOM::DocumentImpl &doc  = static_cast<DOM::DocumentImpl &>(node);

    KJS::UString str = args[0]->toString(exec);

    // we can do it fast, without copying the data
    if (id == DOMDocument::GetElementById) {
#ifdef KJS_VERBOSE
        qCDebug(KHTML_LOG) << "DOMDocument::GetElementById looking for " << args[0]->toString(exec).qstring();
#endif
        // create DOMStringImpl without copying
        DOMStringImpl shallowCopy(DOMStringImpl::ShallowCopy, (QChar *)str.data(), str.size());
        return getDOMNode(exec, doc.getElementById(DOMString(&shallowCopy)));
    }

    DOM::DOMString s = str.domString();

    switch (id) {
    case DOMDocument::CreateElement:
        return getDOMNode(exec, doc.createElement(s, exception));
    case DOMDocument::CreateDocumentFragment:
        return getDOMNode(exec, doc.createDocumentFragment());
    case DOMDocument::CreateTextNode:
        return getDOMNode(exec, doc.createTextNode(s.implementation()));
    case DOMDocument::CreateComment:
        return getDOMNode(exec, doc.createComment(s.implementation()));
    case DOMDocument::CreateCDATASection:
        return getDOMNode(exec, doc.createCDATASection(s.implementation(), exception));
    case DOMDocument::CreateProcessingInstruction:
        return getDOMNode(exec, doc.createProcessingInstruction(args[0]->toString(exec).domString(),
                          args[1]->toString(exec).domString().implementation()));
    case DOMDocument::CreateAttribute:
        return getDOMNode(exec, doc.createAttribute(s, exception));
    case DOMDocument::CreateEntityReference:
        return getDOMNode(exec, doc.createEntityReference(args[0]->toString(exec).domString(), exception));
    case DOMDocument::GetElementsByTagName:
        return getDOMNodeList(exec, doc.getElementsByTagName(s));
    case DOMDocument::ImportNode: // DOM2
        return getDOMNode(exec, doc.importNode(toNode(args[0]), args[1]->toBoolean(exec), exception));
    case DOMDocument::CreateElementNS: // DOM2
        return getDOMNode(exec, doc.createElementNS(valueToStringWithNullCheck(exec, args[0]), args[1]->toString(exec).domString(), exception));
    case DOMDocument::CreateAttributeNS: // DOM2
        return getDOMNode(exec, doc.createAttributeNS(valueToStringWithNullCheck(exec, args[0]), args[1]->toString(exec).domString(), exception));
    case DOMDocument::GetElementsByTagNameNS: // DOM2
        return getDOMNodeList(exec, doc.getElementsByTagNameNS(args[0]->toString(exec).domString(),
                              args[1]->toString(exec).domString()));
    case DOMDocument::CreateRange:
        return getDOMRange(exec, doc.createRange());
    case DOMDocument::CreateNodeIterator:
        return getDOMNodeIterator(exec,
                                  doc.createNodeIterator(toNode(args[0]),
                                          (long unsigned int)(args[1]->toNumber(exec)),
                                          toNodeFilter(args[2]), args[3]->toBoolean(exec), exception));
    case DOMDocument::CreateTreeWalker:
        return getDOMTreeWalker(exec, doc.createTreeWalker(toNode(args[0]), (long unsigned int)(args[1]->toNumber(exec)),
                                toNodeFilter(args[2]), args[3]->toBoolean(exec), exception));
    case DOMDocument::CreateEvent:
        return getDOMEvent(exec, doc.createEvent(s, exception));
    case DOMDocument::GetOverrideStyle: {
        DOM::NodeImpl *arg0 = toNode(args[0]);
        if (!arg0 || !arg0->isElementNode()) {
            return jsUndefined();    // throw exception?
        } else {
            return getDOMCSSStyleDeclaration(exec, doc.getOverrideStyle(static_cast<DOM::ElementImpl *>(arg0), args[1]->toString(exec).domString().implementation()));
        }
    }
    case DOMDocument::Abort:
        doc.abort();
        break;
    case DOMDocument::Load: {
        Window *active = Window::retrieveActive(exec);
        // Complete the URL using the "active part" (running interpreter). We do this for the security
        // check and to make sure we load exactly the same url as we have verified to be safe
        KHTMLPart *khtmlpart = qobject_cast<KHTMLPart *>(active->part());
        if (khtmlpart) {
            // Security: only allow documents to be loaded from the same host
            QString dstUrl = khtmlpart->htmlDocument().completeURL(s).string();
            KParts::ReadOnlyPart *part = static_cast<KJS::ScriptInterpreter *>(exec->dynamicInterpreter())->part();
            if (part->url().host() == QUrl(dstUrl).host()) {
                // qCDebug(KHTML_LOG) << "JavaScript: access granted for document.load() of " << dstUrl;
                doc.load(dstUrl);
            } else {
                // qCDebug(KHTML_LOG) << "JavaScript: access denied for document.load() of " << dstUrl;
            }
        }
        break;
    }
    case DOMDocument::LoadXML:
        doc.loadXML(s);
        break;
    case DOMDocument::ExecCommand: {
        return jsBoolean(doc.execCommand(args[0]->toString(exec).domString(), args[1]->toBoolean(exec), args[2]->toString(exec).domString()));
    }
    case DOMDocument::QueryCommandEnabled: {
        return jsBoolean(doc.queryCommandEnabled(args[0]->toString(exec).domString()));
    }
    case DOMDocument::QueryCommandIndeterm: {
        return jsBoolean(doc.queryCommandIndeterm(args[0]->toString(exec).domString()));
    }
    case DOMDocument::QueryCommandState: {
        return jsBoolean(doc.queryCommandState(args[0]->toString(exec).domString()));
    }
    case DOMDocument::QueryCommandSupported: {
        return jsBoolean(doc.queryCommandSupported(args[0]->toString(exec).domString()));
    }
    case DOMDocument::QueryCommandValue: {
        DOM::DOMString commandValue(doc.queryCommandValue(args[0]->toString(exec).domString()));
        // Method returns null DOMString to signal command is unsupported.
        // Microsoft documentation for this method says:
        // "If not supported [for a command identifier], this method returns a Boolean set to false."
        if (commandValue.isNull()) {
            return jsBoolean(false);
        } else {
            return jsString(commandValue);
        }
    }
    case DOMDocument::GetElementsByClassName:
        return getDOMNodeList(exec, doc.getElementsByClassName(s));
    case DOMDocument::QuerySelector: {
        RefPtr<DOM::ElementImpl> e = doc.querySelector(s, exception);
        return getDOMNode(exec, e.get());
    }
    case DOMDocument::QuerySelectorAll: {
        RefPtr<DOM::NodeListImpl> l = doc.querySelectorAll(s, exception);
        return getDOMNodeList(exec, l.get());
    }
    case DOMDocument::CreateExpression: {
        RefPtr<khtml::XPathNSResolverImpl> res = toResolver(exec, args[1]);
        RefPtr<khtml::XPathExpressionImpl> e = doc.createExpression(s, res.get(), exception);
        JSValue *wrapper = getWrapper<KJS::XPathExpression>(exec, e.get());

        // protect the resolver if needed
        if (!wrapper->isNull() && res && res->type() == khtml::XPathNSResolverImpl::JS) {
            static_cast<XPathExpression *>(wrapper)->setAssociatedResolver(static_cast<JSXPathNSResolver *>(res.get())->resolverObject());
        }
        return wrapper;
    }
    case DOMDocument::CreateNSResolver: {
        DOM::NodeImpl *node = toNode(args[0]);
        return getWrapper<KJS::XPathNSResolver>(exec, doc.createNSResolver(node));
    }
    case DOMDocument::Evaluate: {
        return getWrapper<KJS::XPathResult>(exec,
                                            doc.evaluate(s, // expression
                                                    toNode(args[1]), // contextNode,
                                                    toResolver(exec, args[2]), // resolver
                                                    args[3]->toInt32(exec), // type
                                                    nullptr, // result reuse, ignored
                                                    exception));
    }
    default:
        break;
    }

    return jsUndefined();
}

// -------------------------------------------------------------------------

/* Source for DOMElementProtoTable.
@begin DOMElementProtoTable 17
  getAttribute      DOMElement::GetAttribute    DontDelete|Function 1
  setAttribute      DOMElement::SetAttribute    DontDelete|Function 2
  removeAttribute   DOMElement::RemoveAttribute DontDelete|Function 1
  getAttributeNode  DOMElement::GetAttributeNode    DontDelete|Function 1
  setAttributeNode  DOMElement::SetAttributeNode    DontDelete|Function 2
  removeAttributeNode   DOMElement::RemoveAttributeNode DontDelete|Function 1
  getElementsByTagName  DOMElement::GetElementsByTagName    DontDelete|Function 1
  hasAttribute      DOMElement::HasAttribute    DontDelete|Function 1
  getAttributeNS    DOMElement::GetAttributeNS  DontDelete|Function 2
  setAttributeNS    DOMElement::SetAttributeNS  DontDelete|Function 3
  removeAttributeNS DOMElement::RemoveAttributeNS   DontDelete|Function 2
  getAttributeNodeNS    DOMElement::GetAttributeNodeNS  DontDelete|Function 2
  setAttributeNodeNS    DOMElement::SetAttributeNodeNS  DontDelete|Function 1
  getElementsByTagNameNS DOMElement::GetElementsByTagNameNS DontDelete|Function 2
  hasAttributeNS    DOMElement::HasAttributeNS  DontDelete|Function 2
  getElementsByClassName DOMElement::GetElementsByClassName   DontDelete|Function 1
# Extensions
  blur          DOMElement::Blur    DontDelete|Function 0
  focus         DOMElement::Focus   DontDelete|Function 0
  querySelector          DOMElement::QuerySelector            DontDelete|Function 1
  querySelectorAll       DOMElement::QuerySelectorAll         DontDelete|Function 1
  getClientRects         DOMElement::GetClientRects           DontDelete|Function 0
  getBoundingClientRect  DOMElement::GetBoundingClientRect    DontDelete|Function 0
@end
*/
KJS_IMPLEMENT_PROTOFUNC(DOMElementProtoFunc)
KJS_IMPLEMENT_PROTOTYPE("DOMElement", DOMElementProto, DOMElementProtoFunc, DOMNodeProto)

IMPLEMENT_PSEUDO_CONSTRUCTOR(ElementPseudoCtor, "Element", DOMElementProto)

const ClassInfo DOMElement::info = { "Element", &DOMNode::info, &DOMElementTable, nullptr };
/* Source for DOMElementTable.
@begin DOMElementTable 7
  tagName       DOMElement::TagName                 DontDelete|ReadOnly
  style         DOMElement::Style                   DontDelete|ReadOnly
# DOM 3 - ElementTraversal interface
  firstElementChild DOMElement::FirstElementChild       DontDelete|ReadOnly
  lastElementChild  DOMElement::LastElementChild        DontDelete|ReadOnly
  previousElementSibling DOMElement::PreviousElementSibling DontDelete|ReadOnly
  nextElementSibling    DOMElement::NextElementSibling      DontDelete|ReadOnly
  childElementCount DOMElement::ChildElementCount       DontDelete|ReadOnly
@end
*/
DOMElement::DOMElement(ExecState *exec, DOM::ElementImpl *e)
    : DOMNode(exec, e)
{
    setPrototype(DOMElementProto::self(exec));
}

DOMElement::DOMElement(JSObject *proto, DOM::ElementImpl *e)
    : DOMNode(proto, e)
{}

JSValue *DOMElement::getValueProperty(ExecState *exec, int token) const
{
    DOM::ElementImpl &element = static_cast<DOM::ElementImpl &>(*m_impl);
    switch (token) {
    case TagName:
        return jsString(element.tagName());
    case Style:
        return getDOMCSSStyleDeclaration(exec, element.getInlineStyleDecls());
    case FirstElementChild:
        return getDOMNode(exec, element.firstElementChild());
    case LastElementChild:
        return getDOMNode(exec, element.lastElementChild());
    case PreviousElementSibling:
        return getDOMNode(exec, element.previousElementSibling());
    case NextElementSibling:
        return getDOMNode(exec, element.nextElementSibling());
    case ChildElementCount:
        return jsNumber((unsigned int)element.childElementCount());
    default:
        // qCDebug(KHTML_LOG) << "WARNING: Unhandled token in DOMElement::getValueProperty : " << token;
        return jsUndefined();
    }
}

bool DOMElement::getOwnPropertySlot(ExecState *exec, const Identifier &propertyName, PropertySlot &slot)
{
#ifdef KJS_VERBOSE
    qCDebug(KHTML_LOG) << "DOMElement::getOwnPropertySlot " << propertyName.qstring();
#endif

    //DOM::Element element = static_cast<DOM::Element>(node);
    if (getStaticOwnValueSlot(&DOMElementTable, this, propertyName, slot)) {
        return true;
    }

    return DOMNode::getOwnPropertySlot(exec, propertyName, slot);
}

JSValue *DOMElementProtoFunc::callAsFunction(ExecState *exec, JSObject *thisObj, const List &args)
{
    KJS_CHECK_THIS(KJS::DOMNode, thisObj);   // node should be enough here, given the cast
    DOMExceptionTranslator exception(exec);
    DOM::NodeImpl    &node    = *static_cast<DOMNode *>(thisObj)->impl();
    DOM::ElementImpl &element = static_cast<DOM::ElementImpl &>(node);

    switch (id) {
    case DOMElement::GetAttribute:
        /** In theory, we should not return null here, as per DOM. In practice, that
         breaks websites */
        return getStringOrNull(element.getAttribute(args[0]->toString(exec).domString()));
    case DOMElement::SetAttribute:
        element.setAttribute(args[0]->toString(exec).domString(), args[1]->toString(exec).domString(), exception);
        return jsUndefined();
    case DOMElement::RemoveAttribute:
        element.removeAttribute(args[0]->toString(exec).domString(), exception);
        return jsUndefined();
    case DOMElement::GetAttributeNode:
        return getDOMNode(exec, element.getAttributeNode(args[0]->toString(exec).domString()));
    case DOMElement::SetAttributeNode: {
        DOM::Attr ret = element.setAttributeNode(KJS::toAttr(args[0]), exception);
        return getDOMNode(exec, ret.handle());
    }
    case DOMElement::RemoveAttributeNode: {
        DOM::Attr ret = element.removeAttributeNode(KJS::toAttr(args[0]), exception);
        return getDOMNode(exec, ret.handle());
    }
    case DOMElement::GetElementsByTagName:
        return getDOMNodeList(exec, element.getElementsByTagName(args[0]->toString(exec).domString()));
    case DOMElement::HasAttribute: // DOM2
        return jsBoolean(element.hasAttribute(args[0]->toString(exec).domString()));
    case DOMElement::GetAttributeNS: // DOM2
        return jsString(element.getAttributeNS(args[0]->toString(exec).domString(), args[1]->toString(exec).domString(), exception));
    case DOMElement::SetAttributeNS: // DOM2
        element.setAttributeNS(args[0]->toString(exec).domString(), args[1]->toString(exec).domString(), args[2]->toString(exec).domString(), exception);
        return jsUndefined();
    case DOMElement::RemoveAttributeNS: // DOM2
        element.removeAttributeNS(args[0]->toString(exec).domString(), args[1]->toString(exec).domString(), exception);
        return jsUndefined();
    case DOMElement::GetAttributeNodeNS: // DOM2
        return getDOMNode(exec, element.getAttributeNodeNS(args[0]->toString(exec).domString(), args[1]->toString(exec).domString(), exception));
    case DOMElement::SetAttributeNodeNS: {
        DOM::Attr toRet = element.setAttributeNodeNS(KJS::toAttr(args[0]), exception);
        return getDOMNode(exec, toRet.handle());
    }
    case DOMElement::GetElementsByTagNameNS: // DOM2
        return getDOMNodeList(exec, element.getElementsByTagNameNS(args[0]->toString(exec).domString(), args[1]->toString(exec).domString()));
    case DOMElement::HasAttributeNS: // DOM2
        return jsBoolean(element.hasAttributeNS(args[0]->toString(exec).domString(), args[1]->toString(exec).domString()));
    case DOMElement::GetElementsByClassName: // HTML 5
        return getDOMNodeList(exec, element.getElementsByClassName(args[0]->toString(exec).domString()));
    case DOMElement::QuerySelector: { // WA Selectors 1
        RefPtr<DOM::ElementImpl> e = element.querySelector(args[0]->toString(exec).domString(), exception);
        return getDOMNode(exec, e.get());
    }
    case DOMElement::QuerySelectorAll: {  // WA Selectors 1
        RefPtr<DOM::NodeListImpl> l = element.querySelectorAll(args[0]->toString(exec).domString(), exception);
        return getDOMNodeList(exec, l.get());
    }
    case DOMElement::GetClientRects: {
        DOM::DocumentImpl *docimpl = node.document();
        if (docimpl) {
            docimpl->updateLayout();
        }

        khtml::RenderObject *rend = node.renderer();

        if (!rend) {
            return new ClientRectList(exec);
        }

        //In quirks mode, may need to forward it to body.
        rend = handleBodyRootQuirk(static_cast<DOMNode *>(thisObj)->impl(), rend, DOMNode::ClientTop);

        return new ClientRectList(exec, rend->getClientRects());
    }
    case DOMElement::GetBoundingClientRect: {
        DOM::DocumentImpl *docimpl = node.document();
        if (docimpl) {
            docimpl->updateLayout();
        }

        khtml::RenderObject *rend = node.renderer();

        //In quirks mode, may need to forward it to body.
        rend = handleBodyRootQuirk(static_cast<DOMNode *>(thisObj)->impl(), rend, DOMNode::ClientTop);

        if (!rend) {
            return new ClientRect(exec, 0, 0, 0, 0);
        }

        QList<QRectF> list = rend->getClientRects();
        if (list.isEmpty()) {
            return new ClientRect(exec, 0, 0, 0, 0);
        } else {
            QRectF rect = list.first();
            for (int i = 1; i < list.length(); ++i) {
                rect = rect.united(list.at(i));
            }
            return new ClientRect(exec, rect);
        }
    }

    default:

        // Make sure our layout is up to date before we call these
        DOM::DocumentImpl *docimpl = element.document();
        if (docimpl) {
            docimpl->updateLayout();
        }
        switch (id) {
        case DOMElement::Focus:
            element.focus();
            return jsUndefined();
        case DOMElement::Blur:
            element.blur();
            return jsUndefined();
        default:
            return jsUndefined();
        }
    }
}

DOM::ElementImpl *KJS::toElement(JSValue *v)
{
    DOM::NodeImpl *node = toNode(v);
    if (node && node->isElementNode()) {
        return static_cast<DOM::ElementImpl *>(node);
    }
    return nullptr;
}

DOM::AttrImpl *KJS::toAttr(JSValue *v)
{
    DOM::NodeImpl *node = toNode(v);
    if (node && node->isAttributeNode()) {
        return static_cast<DOM::AttrImpl *>(node);
    }
    return nullptr;
}

// -------------------------------------------------------------------------

/* Source for DOMDOMImplementationProtoTable.
@begin DOMDOMImplementationProtoTable 5
  hasFeature        DOMDOMImplementation::HasFeature        DontDelete|Function 2
  createCSSStyleSheet   DOMDOMImplementation::CreateCSSStyleSheet   DontDelete|Function 2
# DOM2
  createDocumentType    DOMDOMImplementation::CreateDocumentType    DontDelete|Function 3
  createDocument    DOMDOMImplementation::CreateDocument        DontDelete|Function 3
  createHTMLDocument    DOMDOMImplementation::CreateHTMLDocument        DontDelete|Function 1
@end
*/
KJS_DEFINE_PROTOTYPE(DOMDOMImplementationProto)
KJS_IMPLEMENT_PROTOFUNC(DOMDOMImplementationProtoFunc)
KJS_IMPLEMENT_PROTOTYPE("DOMImplementation", DOMDOMImplementationProto, DOMDOMImplementationProtoFunc, ObjectPrototype)

const ClassInfo DOMDOMImplementation::info = { "DOMImplementation", nullptr, nullptr, nullptr };

DOMDOMImplementation::DOMDOMImplementation(ExecState *exec, DOM::DOMImplementationImpl *i)
    : DOMObject(DOMDOMImplementationProto::self(exec)), m_impl(i) { }

DOMDOMImplementation::~DOMDOMImplementation()
{
    ScriptInterpreter::forgetDOMObject(m_impl.get());
}

JSValue *DOMDOMImplementationProtoFunc::callAsFunction(ExecState *exec, JSObject *thisObj, const List &args)
{
    KJS_CHECK_THIS(KJS::DOMDOMImplementation, thisObj);
    DOM::DOMImplementationImpl &implementation = *static_cast<DOMDOMImplementation *>(thisObj)->impl();
    DOMExceptionTranslator exception(exec);

    switch (id) {
    case DOMDOMImplementation::HasFeature:
        return jsBoolean(implementation.hasFeature(args[0]->toString(exec).domString(),
                         valueToStringWithNullCheck(exec, args[1])));
    case DOMDOMImplementation::CreateDocumentType: // DOM2
        return getDOMNode(exec, implementation.createDocumentType(args[0]->toString(exec).domString(), args[1]->toString(exec).domString(), args[2]->toString(exec).domString(), exception));
    case DOMDOMImplementation::CreateDocument: { // DOM2
        // Initially set the URL to document of the creator... this is so that it resides in the same
        // host/domain for security checks. The URL will be updated if Document.load() is called.
        KHTMLPart *part = qobject_cast<KHTMLPart *>(static_cast<KJS::ScriptInterpreter *>(exec->dynamicInterpreter())->part());
        if (part) {
            //### this should probably be pushed to the impl
            DOM::NodeImpl *supposedDocType = toNode(args[2]);
            if (supposedDocType && supposedDocType->nodeType() != DOM::Node::DOCUMENT_TYPE_NODE) {
                setDOMException(exec, DOMException::NOT_FOUND_ERR);
                return jsNull();
            }

            DOM::DocumentTypeImpl *docType = static_cast<DOM::DocumentTypeImpl *>(supposedDocType);

            // ### no real leak but lifetime of part is not tied to document
            KHTMLPart *newPart = new KHTMLPart(part->view(), part);
            DOM::DocumentImpl *doc = implementation.createDocument(valueToStringWithNullCheck(exec, args[0]),
                                     valueToStringWithNullCheck(exec, args[1]),
                                     docType,
                                     newPart->view(),
                                     exception);
            if (!doc) {
                return jsNull();
            }
            QUrl url = static_cast<DocumentImpl *>(part->document().handle())->URL();
            doc->setURL(url.url());
            return getDOMNode(exec, doc);
        }
        break;
    }
    case DOMDOMImplementation::CreateCSSStyleSheet: // DOM2
        return getDOMStyleSheet(exec, implementation.createCSSStyleSheet(
                                    args[0]->toString(exec).domString().implementation(),
                                    args[1]->toString(exec).domString().implementation(), exception));
    case DOMDOMImplementation::CreateHTMLDocument: // DOM2-HTML
        return getDOMNode(exec, implementation.createHTMLDocument(args[0]->toString(exec).domString()));
    default:
        break;
    }
    return jsUndefined();
}

// -------------------------------------------------------------------------

const ClassInfo DOMDocumentType::info = { "DocumentType", &DOMNode::info, &DOMDocumentTypeTable, nullptr };

/* Source for DOMDocumentTypeTable.
@begin DOMDocumentTypeTable 6
  name          DOMDocumentType::Name       DontDelete|ReadOnly
  entities      DOMDocumentType::Entities   DontDelete|ReadOnly
  notations     DOMDocumentType::Notations  DontDelete|ReadOnly
# DOM2
  publicId      DOMDocumentType::PublicId   DontDelete|ReadOnly
  systemId      DOMDocumentType::SystemId   DontDelete|ReadOnly
  internalSubset    DOMDocumentType::InternalSubset DontDelete|ReadOnly
@end
*/
DOMDocumentType::DOMDocumentType(ExecState *exec, DOM::DocumentTypeImpl *dt)
    : DOMNode(/*### no proto yet*/exec, dt) { }

bool DOMDocumentType::getOwnPropertySlot(ExecState *exec, const Identifier &propertyName, KJS::PropertySlot &slot)
{
#ifdef KJS_VERBOSE
    qCDebug(KHTML_LOG) << "DOMDocumentType::getOwnPropertySlot " << propertyName.qstring();
#endif
    return getStaticValueSlot<DOMDocumentType, DOMNode>(exec, &DOMDocumentTypeTable, this, propertyName, slot);
}

JSValue *DOMDocumentType::getValueProperty(ExecState *exec, int token) const
{
    DOM::DocumentTypeImpl &type = static_cast<DOM::DocumentTypeImpl &>(*m_impl);
    switch (token) {
    case Name:
        return jsString(type.name());
    case Entities:
        return getDOMNamedNodeMap(exec, type.entities());
    case Notations:
        return getDOMNamedNodeMap(exec, type.notations());
    case PublicId: // DOM2
        return jsString(type.publicId());
    case SystemId: // DOM2
        return jsString(type.systemId());
    case InternalSubset: // DOM2
        return ::getStringOrNull(type.internalSubset()); // can be null, see domts/level2/core/internalSubset01.html
    default:
        // qCDebug(KHTML_LOG) << "WARNING: DOMDocumentType::getValueProperty unhandled token " << token;
        return jsNull();
    }
}

// -------------------------------------------------------------------------

/* Source for DOMNamedNodeMapProtoTable.
@begin DOMNamedNodeMapProtoTable 7
  getNamedItem      DOMNamedNodeMap::GetNamedItem       DontDelete|Function 1
  setNamedItem      DOMNamedNodeMap::SetNamedItem       DontDelete|Function 1
  removeNamedItem   DOMNamedNodeMap::RemoveNamedItem    DontDelete|Function 1
  item          DOMNamedNodeMap::Item           DontDelete|Function 1
# DOM2
  getNamedItemNS    DOMNamedNodeMap::GetNamedItemNS     DontDelete|Function 2
  setNamedItemNS    DOMNamedNodeMap::SetNamedItemNS     DontDelete|Function 1
  removeNamedItemNS DOMNamedNodeMap::RemoveNamedItemNS  DontDelete|Function 2
@end
@begin DOMNamedNodeMapTable 7
  length        DOMNamedNodeMap::Length         DontDelete|Function 1
@end
*/
KJS_DEFINE_PROTOTYPE(DOMNamedNodeMapProto)
KJS_IMPLEMENT_PROTOFUNC(DOMNamedNodeMapProtoFunc)
KJS_IMPLEMENT_PROTOTYPE("NamedNodeMap", DOMNamedNodeMapProto, DOMNamedNodeMapProtoFunc, ObjectPrototype)

const ClassInfo DOMNamedNodeMap::info = { "NamedNodeMap", nullptr, &DOMNamedNodeMapTable, nullptr };

DOMNamedNodeMap::DOMNamedNodeMap(ExecState *exec, DOM::NamedNodeMapImpl *m)
    : DOMObject(DOMNamedNodeMapProto::self(exec)), m_impl(m) { }

DOMNamedNodeMap::~DOMNamedNodeMap()
{
    ScriptInterpreter::forgetDOMObject(m_impl.get());
}

JSValue *DOMNamedNodeMap::indexGetter(ExecState *exec, unsigned index)
{
    return getDOMNode(exec, m_impl->item(index));
}

JSValue *DOMNamedNodeMap::lengthGetter(ExecState *, JSObject *, const Identifier &, const PropertySlot &slot)
{
    DOMNamedNodeMap *thisObj = static_cast<DOMNamedNodeMap *>(slot.slotBase());
    return jsNumber(thisObj->m_impl->length());
}

bool DOMNamedNodeMap::getOwnPropertySlot(ExecState *exec, const Identifier &propertyName, PropertySlot &slot)
{
    if (propertyName == exec->propertyNames().length) {
        slot.setCustom(this, lengthGetter);
        return true;
    }

    // See if it's an item name get
    DOM::NodeImpl *attr = impl()->getNamedItem(propertyName.ustring().domString());
    if (attr) {
        return getImmediateValueSlot(this, getDOMNode(exec, attr), slot);
    }

    //May be it's an index?
    if (getIndexSlot(this, *m_impl, propertyName, slot)) {
        return true;
    }

    return DOMObject::getOwnPropertySlot(exec, propertyName, slot);
}

JSValue *DOMNamedNodeMapProtoFunc::callAsFunction(ExecState *exec, JSObject *thisObj, const List &args)
{
    KJS_CHECK_THIS(KJS::DOMNamedNodeMap, thisObj);
    DOMExceptionTranslator exception(exec);
    DOM::NamedNodeMapImpl &map = *static_cast<DOMNamedNodeMap *>(thisObj)->impl();

    switch (id) {
    case DOMNamedNodeMap::GetNamedItem:
        return getDOMNode(exec, map.getNamedItem(args[0]->toString(exec).domString()));
    case DOMNamedNodeMap::SetNamedItem: {
        DOM::Node old = map.setNamedItem(toNode(args[0]), exception);
        return getDOMNode(exec, old.handle());
    }
    case DOMNamedNodeMap::RemoveNamedItem: {
        DOM::Attr toRet = map.removeNamedItem(args[0]->toString(exec).domString(), exception);
        return getDOMNode(exec, toRet.handle());
    }
    case DOMNamedNodeMap::Item:
        return getDOMNode(exec, map.item(args[0]->toInt32(exec)));
    case DOMNamedNodeMap::GetNamedItemNS: {// DOM2
        DOM::Node old = map.getNamedItemNS(args[0]->toString(exec).domString(), args[1]->toString(exec).domString());
        return getDOMNode(exec, old.handle());
    }
    case DOMNamedNodeMap::SetNamedItemNS: {// DOM2
        DOM::Node old = map.setNamedItemNS(toNode(args[0]), exception);
        return getDOMNode(exec, old.handle());
    }
    case DOMNamedNodeMap::RemoveNamedItemNS: { // DOM2
        DOM::Node old = map.removeNamedItemNS(args[0]->toString(exec).domString(), args[1]->toString(exec).domString(), exception);
        return getDOMNode(exec, old.handle());
    }
    default:
        break;
    }

    return jsUndefined();
}

// -------------------------------------------------------------------------
//### FIXME: proto
const ClassInfo DOMProcessingInstruction::info = { "ProcessingInstruction", &DOMNode::info, &DOMProcessingInstructionTable, nullptr };

/* Source for DOMProcessingInstructionTable.
@begin DOMProcessingInstructionTable 3
  target    DOMProcessingInstruction::Target    DontDelete|ReadOnly
  data      DOMProcessingInstruction::Data      DontDelete
  sheet     DOMProcessingInstruction::Sheet     DontDelete|ReadOnly
@end
*/
bool DOMProcessingInstruction::getOwnPropertySlot(ExecState *exec, const Identifier &propertyName, PropertySlot &slot)
{
    return getStaticValueSlot<DOMProcessingInstruction, DOMNode>(exec, &DOMProcessingInstructionTable, this, propertyName, slot);
}

JSValue *DOMProcessingInstruction::getValueProperty(ExecState *exec, int token) const
{
    DOM::ProcessingInstructionImpl &pi = *static_cast<DOM::ProcessingInstructionImpl *>(m_impl.get());
    switch (token) {
    case Target:
        return jsString(pi.target());
    case Data:
        return jsString(pi.data());
    case Sheet:
        return getDOMStyleSheet(exec, pi.sheet());
    default:
        // qCDebug(KHTML_LOG) << "WARNING: DOMProcessingInstruction::getValueProperty unhandled token " << token;
        return jsNull();
    }
}

void DOMProcessingInstruction::put(ExecState *exec, const Identifier &propertyName, JSValue *value, int attr)
{
    DOM::ProcessingInstructionImpl &pi = *static_cast<DOM::ProcessingInstructionImpl *>(m_impl.get());
    // Not worth using the hashtable for this one ;)
    if (propertyName == "data") {
        DOMExceptionTranslator exception(exec);
        pi.setData(value->toString(exec).domString(), exception);
    } else {
        DOMNode::put(exec, propertyName, value, attr);
    }
}

// -------------------------------------------------------------------------

const ClassInfo DOMNotation::info = { "Notation", &DOMNode::info, &DOMNotationTable, nullptr };

/* Source for DOMNotationTable.
@begin DOMNotationTable 2
  publicId      DOMNotation::PublicId   DontDelete|ReadOnly
  systemId      DOMNotation::SystemId   DontDelete|ReadOnly
@end
*/
bool DOMNotation::getOwnPropertySlot(ExecState *exec, const Identifier &propertyName, PropertySlot &slot)
{
    return getStaticValueSlot<DOMNotation, DOMNode>(exec, &DOMNotationTable, this, propertyName, slot);
}

JSValue *DOMNotation::getValueProperty(ExecState *, int token) const
{
    DOM::NotationImpl &nota = *static_cast<DOM::NotationImpl *>(m_impl.get());
    switch (token) {
    case PublicId:
        return jsString(nota.publicId());
    case SystemId:
        return jsString(nota.systemId());
    default:
        // qCDebug(KHTML_LOG) << "WARNING: DOMNotation::getValueProperty unhandled token " << token;
        return jsNull();
    }
}

// -------------------------------------------------------------------------

const ClassInfo DOMEntity::info = { "Entity", &DOMNode::info, nullptr, nullptr };

/* Source for DOMEntityTable.
@begin DOMEntityTable 2
  publicId      DOMEntity::PublicId     DontDelete|ReadOnly
  systemId      DOMEntity::SystemId     DontDelete|ReadOnly
  notationName      DOMEntity::NotationName DontDelete|ReadOnly
@end
*/
bool DOMEntity::getOwnPropertySlot(ExecState *exec, const Identifier &propertyName, PropertySlot &slot)
{
    return getStaticValueSlot<DOMEntity, DOMNode>(exec, &DOMEntityTable, this, propertyName, slot);
}

JSValue *DOMEntity::getValueProperty(ExecState *, int token) const
{
    DOM::EntityImpl &entity = *static_cast<DOM::EntityImpl *>(m_impl.get());
    switch (token) {
    case PublicId:
        return jsString(entity.publicId());
    case SystemId:
        return jsString(entity.systemId());
    case NotationName:
        return jsString(entity.notationName());
    default:
        // qCDebug(KHTML_LOG) << "WARNING: DOMEntity::getValueProperty unhandled token " << token;
        return jsNull();
    }
}

// -------------------------------------------------------------------------

bool KJS::checkNodeSecurity(ExecState *exec, const DOM::NodeImpl *n)
{
    // Check to see if the currently executing interpreter is allowed to access the specified node
    if (!n) {
        return true;
    }
    KHTMLPart *part = n->document()->part();
    Window *win = part ? Window::retrieveWindow(part) : nullptr;
    if (!win || !win->isSafeScript(exec)) {
        return false;
    }
    return true;
}

// adopted from binding/JSHTMLElementFactory.cpp
#define CREATE_WRAPPER_FUNCTION(name) \
    static DOMObject* create##name##Wrapper(ExecState* exec, DOM::NodeImpl* n) \
    { \
        return new JSHTML##name##Element(exec, static_cast<HTML##name##Element*>(n)); \
    }

CREATE_WRAPPER_FUNCTION(Audio)
CREATE_WRAPPER_FUNCTION(Video)

JSValue *KJS::getEventTarget(ExecState *exec, DOM::EventTargetImpl *t)
{
    if (!t) {
        return jsNull();
    }
    if (t->eventTargetType() == EventTargetImpl::DOM_NODE) {
        return getDOMNode(exec, static_cast<DOM::NodeImpl *>(t));
    } else if (t->eventTargetType() == EventTargetImpl::WINDOW) {
        Window *w = static_cast<WindowEventTargetImpl *>(t)->window();
        return w ? w : jsNull();
    } else {
        return static_cast<XMLHttpRequest *>(t);
    }
}

JSValue *KJS::getDOMNode(ExecState *exec, DOM::NodeImpl *n)
{
    DOMObject *ret = nullptr;
    if (!n) {
        return jsNull();
    }
    ScriptInterpreter *interp = static_cast<ScriptInterpreter *>(exec->dynamicInterpreter());
    if ((ret = interp->getDOMObject(n))) {
        return ret;
    }

    switch (n->nodeType()) {
    case DOM::Node::ELEMENT_NODE:
        switch (n->id()) {
        case ID_AUDIO:
            ret = createAudioWrapper(exec, n);
            break;
        case ID_VIDEO:
            ret = createVideoWrapper(exec, n);
            break;
        default:
            if (static_cast<DOM::ElementImpl *>(n)->isHTMLElement()) {
                ret = new HTMLElement(exec, static_cast<DOM::HTMLElementImpl *>(n));
            } else {
                ret = new DOMElement(exec, static_cast<DOM::ElementImpl *>(n));
            }
            break;
        }
        break;
    case DOM::Node::ATTRIBUTE_NODE:
        ret = new DOMAttr(exec, static_cast<DOM::AttrImpl *>(n));
        break;
    case DOM::Node::TEXT_NODE:
    case DOM::Node::CDATA_SECTION_NODE:
        ret = new DOMText(exec, static_cast<DOM::TextImpl *>(n));
        break;
    case DOM::Node::ENTITY_REFERENCE_NODE:
        ret = new DOMNode(exec, n);
        break;
    case DOM::Node::ENTITY_NODE:
        ret = new DOMEntity(exec, static_cast<DOM::EntityImpl *>(n));
        break;
    case DOM::Node::PROCESSING_INSTRUCTION_NODE:
        ret = new DOMProcessingInstruction(exec, static_cast<DOM::ProcessingInstructionImpl *>(n));
        break;
    case DOM::Node::COMMENT_NODE:
        ret = new DOMComment(exec, static_cast<DOM::CommentImpl *>(n));
        break;
    case DOM::Node::DOCUMENT_NODE:
        if (static_cast<DOM::DocumentImpl *>(n)->isHTMLDocument()) {
            ret = new HTMLDocument(exec, static_cast<DOM::HTMLDocumentImpl *>(n));
        } else {
            ret = new DOMDocument(exec, static_cast<DOM::DocumentImpl *>(n));
        }
        break;
    case DOM::Node::DOCUMENT_TYPE_NODE:
        ret = new DOMDocumentType(exec, static_cast<DOM::DocumentTypeImpl *>(n));
        break;
    case DOM::Node::DOCUMENT_FRAGMENT_NODE:
        ret = new DOMDocumentFragment(exec, static_cast<DOM::DocumentFragmentImpl *>(n));
        break;
    case DOM::Node::NOTATION_NODE:
        ret = new DOMNotation(exec, static_cast<DOM::NotationImpl *>(n));
        break;
    default:
        ret = new DOMNode(exec, n);
    }
    interp->putDOMObject(n, ret);

    return ret;
}

JSValue *KJS::getDOMNamedNodeMap(ExecState *exec, DOM::NamedNodeMapImpl *m)
{
    return cacheDOMObject<DOM::NamedNodeMapImpl, KJS::DOMNamedNodeMap>(exec, m);
}

JSValue *KJS::getDOMNodeList(ExecState *exec, DOM::NodeListImpl *l)
{
    return cacheDOMObject<DOM::NodeListImpl, KJS::DOMNodeList>(exec, l);
}

JSValue *KJS::getDOMDOMImplementation(ExecState *exec, DOM::DOMImplementationImpl *i)
{
    return cacheDOMObject<DOM::DOMImplementationImpl, KJS::DOMDOMImplementation>(exec, i);
}

// -------------------------------------------------------------------------

IMPLEMENT_PSEUDO_CONSTRUCTOR_WITH_PARENT(NodeConstructor, "NodeConstructor", DOMNodeProto, DOMNodeConstants)
// -------------------------------------------------------------------------

/* Source for DOMExceptionProtoTable.
@begin DOMExceptionProtoTable 29
  INDEX_SIZE_ERR        DOM::DOMException::INDEX_SIZE_ERR       DontDelete|ReadOnly
  DOMSTRING_SIZE_ERR        DOM::DOMException::DOMSTRING_SIZE_ERR   DontDelete|ReadOnly
  HIERARCHY_REQUEST_ERR     DOM::DOMException::HIERARCHY_REQUEST_ERR    DontDelete|ReadOnly
  WRONG_DOCUMENT_ERR        DOM::DOMException::WRONG_DOCUMENT_ERR   DontDelete|ReadOnly
  INVALID_CHARACTER_ERR     DOM::DOMException::INVALID_CHARACTER_ERR    DontDelete|ReadOnly
  NO_DATA_ALLOWED_ERR       DOM::DOMException::NO_DATA_ALLOWED_ERR  DontDelete|ReadOnly
  NO_MODIFICATION_ALLOWED_ERR   DOM::DOMException::NO_MODIFICATION_ALLOWED_ERR  DontDelete|ReadOnly
  NOT_FOUND_ERR         DOM::DOMException::NOT_FOUND_ERR        DontDelete|ReadOnly
  NOT_SUPPORTED_ERR     DOM::DOMException::NOT_SUPPORTED_ERR    DontDelete|ReadOnly
  INUSE_ATTRIBUTE_ERR       DOM::DOMException::INUSE_ATTRIBUTE_ERR  DontDelete|ReadOnly
  INVALID_STATE_ERR     DOM::DOMException::INVALID_STATE_ERR    DontDelete|ReadOnly
  SYNTAX_ERR            DOM::DOMException::SYNTAX_ERR       DontDelete|ReadOnly
  INVALID_MODIFICATION_ERR  DOM::DOMException::INVALID_MODIFICATION_ERR DontDelete|ReadOnly
  NAMESPACE_ERR         DOM::DOMException::NAMESPACE_ERR        DontDelete|ReadOnly
  INVALID_ACCESS_ERR        DOM::DOMException::INVALID_ACCESS_ERR   DontDelete|ReadOnly
  VALIDATION_ERR               DOM::DOMException::VALIDATION_ERR      DontDelete|ReadOnly
  TYPE_MISMATCH_ERR            DOM::DOMException::TYPE_MISMATCH_ERR   DontDelete|ReadOnly
  SECURITY_ERR                 DOM::DOMException::SECURITY_ERR        DontDelete|ReadOnly
  NETWORK_ERR                  DOM::DOMException::NETWORK_ERR         DontDelete|ReadOnly
  ABORT_ERR                    DOM::DOMException::ABORT_ERR           DontDelete|ReadOnly
  URL_MISMATCH_ERR             DOM::DOMException::URL_MISMATCH_ERR    DontDelete|ReadOnly
  QUOTA_EXCEEDED_ERR           DOM::DOMException::QUOTA_EXCEEDED_ERR  DontDelete|ReadOnly
  TIMEOUT_ERR                  DOM::DOMException::TIMEOUT_ERR         DontDelete|ReadOnly
  NOT_READABLE_ERR             DOM::DOMException::NOT_READABLE_ERR    DontDelete|ReadOnly
  DATA_CLONE_ERR               DOM::DOMException::DATA_CLONE_ERR      DontDelete|ReadOnly
  ENCODING_ERR                 DOM::DOMException::ENCODING_ERR        DontDelete|ReadOnly
@end
*/

DEFINE_CONSTANT_TABLE(DOMExceptionProto)
IMPLEMENT_CONSTANT_TABLE(DOMExceptionProto, "DOMException")

IMPLEMENT_PSEUDO_CONSTRUCTOR_WITH_PARENT(DOMExceptionPseudoCtor,
        "DOMException",
        DOMExceptionProto, DOMExceptionProto)

JSDOMException::JSDOMException(ExecState *exec)
    : DOMObject(DOMExceptionProto::self(exec))
{
}

const ClassInfo JSDOMException::info = { "DOMException", nullptr, nullptr, nullptr };

JSObject *KJS::getDOMExceptionConstructor(ExecState *exec)
{
    return DOMExceptionPseudoCtor::self(exec);
}

// -------------------------------------------------------------------------

/* Source for DOMNamedNodesCollection.
@begin DOMNamedNodesCollectionTable 1
  length        KJS::DOMNamedNodesCollection::Length        DontDelete|ReadOnly
@end
*/
const ClassInfo KJS::DOMNamedNodesCollection::info = { "DOMNamedNodesCollection", nullptr, &DOMNamedNodesCollectionTable, nullptr };

// Such a collection is usually very short-lived, it only exists
// for constructs like document.forms.<name>[1],
// so it shouldn't be a problem that it's storing all the nodes (with the same name). (David)
DOMNamedNodesCollection::DOMNamedNodesCollection(ExecState *exec, const QList<SharedPtr<DOM::NodeImpl> > &nodes)
    : DOMObject(exec->lexicalInterpreter()->builtinObjectPrototype()),
      m_nodes(nodes)
{
    // Maybe we should ref (and deref in the dtor) the nodes, though ?
}

JSValue *DOMNamedNodesCollection::indexGetter(ExecState *exec, unsigned index)
{
    return getDOMNode(exec, m_nodes[index].get());
}

JSValue *DOMNamedNodesCollection::lengthGetter(ExecState *, JSObject *, const Identifier &, const PropertySlot &slot)
{
    DOMNamedNodesCollection *thisObj = static_cast<DOMNamedNodesCollection *>(slot.slotBase());
    return jsNumber(thisObj->m_nodes.size());
}

bool DOMNamedNodesCollection::getOwnPropertySlot(ExecState *exec, const Identifier &propertyName, PropertySlot &slot)
{
    // qCDebug(KHTML_LOG) << propertyName.ascii();

    if (propertyName == exec->propertyNames().length) {
        slot.setCustom(this, lengthGetter);
        return true;
    }

    //May be it's an index?
    if (getIndexSlot(this, m_nodes.size(), propertyName, slot)) {
        return true;
    }

    return DOMObject::getOwnPropertySlot(exec, propertyName, slot);
}

// -------------------------------------------------------------------------

const ClassInfo DOMCharacterData::info = { "CharacterImp",
                                           &DOMNode::info, &DOMCharacterDataTable, nullptr
                                         };
/*
@begin DOMCharacterDataTable 2
  data      DOMCharacterData::Data      DontDelete
  length    DOMCharacterData::Length    DontDelete|ReadOnly
@end
@begin DOMCharacterDataProtoTable 7
  substringData DOMCharacterData::SubstringData DontDelete|Function 2
  appendData    DOMCharacterData::AppendData    DontDelete|Function 1
  insertData    DOMCharacterData::InsertData    DontDelete|Function 2
  deleteData    DOMCharacterData::DeleteData    DontDelete|Function 2
  replaceData   DOMCharacterData::ReplaceData   DontDelete|Function 2
@end
*/
KJS_DEFINE_PROTOTYPE(DOMCharacterDataProto)
KJS_IMPLEMENT_PROTOFUNC(DOMCharacterDataProtoFunc)
KJS_IMPLEMENT_PROTOTYPE("DOMCharacterData", DOMCharacterDataProto, DOMCharacterDataProtoFunc, DOMNodeProto)

DOMCharacterData::DOMCharacterData(ExecState *exec, DOM::CharacterDataImpl *d)
    : DOMNode(exec, d)
{
    setPrototype(DOMCharacterDataProto::self(exec));
}

bool DOMCharacterData::getOwnPropertySlot(ExecState *exec, const Identifier &propertyName, PropertySlot &slot)
{
#ifdef KJS_VERBOSE
    qCDebug(KHTML_LOG) << "DOMCharacterData::tryGet " << propertyName.qstring();
#endif
    return getStaticValueSlot<DOMCharacterData, DOMNode>(exec, &DOMCharacterDataTable, this, propertyName, slot);
}

JSValue *DOMCharacterData::getValueProperty(ExecState *, int token) const
{
    DOM::CharacterDataImpl &data = *impl();
    switch (token) {
    case Data:
        return jsString(data.data());
    case Length:
        return jsNumber(data.length());
    default:
        // qCDebug(KHTML_LOG) << "WARNING: Unhandled token in DOMCharacterData::getValueProperty : " << token;
        return jsNull();
    }
}

void DOMCharacterData::put(ExecState *exec, const Identifier &propertyName, JSValue *value, int attr)
{
    if (propertyName == "data") {
        DOMExceptionTranslator exception(exec);
        impl()->setData(value->toString(exec).domString(), exception);
    } else {
        DOMNode::put(exec, propertyName, value, attr);
    }
}

JSValue *DOMCharacterDataProtoFunc::callAsFunction(ExecState *exec, JSObject *thisObj, const List &args)
{
    KJS_CHECK_THIS(KJS::DOMCharacterData, thisObj);
    DOM::CharacterDataImpl &data = *static_cast<DOMCharacterData *>(thisObj)->impl();
    DOMExceptionTranslator exception(exec);
    switch (id) {
    case DOMCharacterData::SubstringData:
        return jsString(data.substringData(args[0]->toInteger(exec), args[1]->toInteger(exec), exception));
    case DOMCharacterData::AppendData:
        data.appendData(args[0]->toString(exec).domString(), exception);
        return jsUndefined();
        break;
    case DOMCharacterData::InsertData:
        data.insertData(args[0]->toInteger(exec), args[1]->toString(exec).domString(), exception);
        return  jsUndefined();
        break;
    case DOMCharacterData::DeleteData:
        data.deleteData(args[0]->toInteger(exec), args[1]->toInteger(exec), exception);
        return  jsUndefined();
        break;
    case DOMCharacterData::ReplaceData:
        data.replaceData(args[0]->toInteger(exec), args[1]->toInteger(exec), args[2]->toString(exec).domString(), exception);
        return jsUndefined();
    default:
        break;
    }
    return jsUndefined();
}

// -------------------------------------------------------------------------

const ClassInfo DOMText::info = { "Text", &DOMCharacterData::info,
                                  &DOMTextTable, nullptr
                                };

/*
@begin DOMTextTable 2
  wholeText        DOMText::WholeText        DontDelete|ReadOnly
@end
@begin DOMTextProtoTable 2
  splitText    DOMText::SplitText        DontDelete|Function 1
  replaceWholeText DOMText::ReplaceWholeText DontDelete|Function 1
@end
*/
KJS_DEFINE_PROTOTYPE(DOMTextProto)
KJS_IMPLEMENT_PROTOFUNC(DOMTextProtoFunc)
KJS_IMPLEMENT_PROTOTYPE("DOMText", DOMTextProto, DOMTextProtoFunc, DOMCharacterDataProto)

DOMText::DOMText(ExecState *exec, DOM::TextImpl *t)
    : DOMCharacterData(exec, t)
{
    setPrototype(DOMTextProto::self(exec));
}

bool DOMText::getOwnPropertySlot(ExecState *exec,
                                 const Identifier &propertyName,
                                 PropertySlot &slot)
{
    return getStaticValueSlot<DOMText, DOMCharacterData>(exec, &DOMTextTable, this, propertyName, slot);
}

JSValue *DOMText::getValueProperty(ExecState *, int token) const
{
    TextImpl *text = static_cast<TextImpl *>(impl());
    switch (token) {
    case WholeText:
        return jsString(text->wholeText());
    }
    return jsNull(); // not reached
}

JSValue *DOMTextProtoFunc::callAsFunction(ExecState *exec, JSObject *thisObj, const List &args)
{
    KJS_CHECK_THIS(KJS::DOMText, thisObj);
    DOM::TextImpl &text = *static_cast<DOMText *>(thisObj)->impl();
    DOMExceptionTranslator exception(exec);
    switch (id) {
    case DOMText::SplitText:
        return getDOMNode(exec, text.splitText(args[0]->toInteger(exec), exception));
    case DOMText::ReplaceWholeText:
        return getDOMNode(exec, text.replaceWholeText(args[0]->toString(exec).domString(), exception));
    default:
        break;
    }
    return jsUndefined();
}

// -------------------------------------------------------------------------

const ClassInfo DOMComment::info = { "Comment",
                                     &DOMCharacterData::info, nullptr, nullptr
                                   };
/*
@begin DOMCommentProtoTable 1
@end
*/

KJS_DEFINE_PROTOTYPE(DOMCommentProto)
KJS_IMPLEMENT_PROTOFUNC(DOMCommentProtoFunc)
KJS_IMPLEMENT_PROTOTYPE("DOMComment", DOMCommentProto, DOMCommentProtoFunc, DOMCharacterDataProto)

DOMComment::DOMComment(ExecState *exec, DOM::CommentImpl *d)
    : DOMCharacterData(exec, d)
{
    setPrototype(DOMCommentProto::self(exec));
}

JSValue *DOMCommentProtoFunc::callAsFunction(ExecState *exec, JSObject *thisObj, const List & /*args*/)
{
    KJS_CHECK_THIS(KJS::DOMComment, thisObj);
    return jsUndefined();
}

// -------------------------------------------------------------------------

const ClassInfo DOMDocumentFragment::info = { "DocumentFragment",
                                              &DOMNode::info, nullptr, nullptr
                                            };
/*
@begin DOMDocumentFragmentProtoTable 2
  querySelector          DOMDocumentFragment::QuerySelector            DontDelete|Function 1
  querySelectorAll       DOMDocumentFragment::QuerySelectorAll         DontDelete|Function 1
@end
*/

KJS_DEFINE_PROTOTYPE(DOMDocumentFragmentProto)
KJS_IMPLEMENT_PROTOFUNC(DOMDocumentFragmentProtoFunc)
KJS_IMPLEMENT_PROTOTYPE("DocumentFragment", DOMDocumentFragmentProto,
                        DOMDocumentFragmentProtoFunc, DOMNodeProto)
IMPLEMENT_PSEUDO_CONSTRUCTOR(DocumentFragmentPseudoCtor, "DocumentFragment", DOMDocumentFragmentProto)

DOMDocumentFragment::DOMDocumentFragment(ExecState *exec, DOM::DocumentFragmentImpl *i)
    : DOMNode(exec, i)
{
    setPrototype(DOMDocumentFragmentProto::self(exec));
}

JSValue *DOMDocumentFragmentProtoFunc::callAsFunction(ExecState *exec, JSObject *thisObj, const List &args)
{
    KJS_CHECK_THIS(KJS::DOMDocumentFragment, thisObj);
    DOMExceptionTranslator exception(exec);

    DOM::NodeImpl *n = static_cast<DOMDocumentFragment *>(thisObj)->impl();
    DOM::DOMString s = args[0]->toString(exec).domString();

    switch (id) {
    case DOMDocumentFragment::QuerySelector: {
        RefPtr<DOM::ElementImpl> e = n->querySelector(s, exception);
        return getDOMNode(exec, e.get());
    }
    case DOMDocumentFragment::QuerySelectorAll: {
        RefPtr<DOM::NodeListImpl> l = n->querySelectorAll(s, exception);
        return getDOMNodeList(exec, l.get());
    }
    }
    return jsUndefined();
}

