#include "kjs_traversal.h"
#include "kjs_traversal.lut.h"
#include "kjs_proxy.h"
#include <dom/dom_node.h>
#include <xml/dom_nodeimpl.h>
#include <xml/dom_docimpl.h>
#include <khtmlview.h>
#include <kdebug.h>
using namespace KJS;
const ClassInfo DOMNodeIterator::info = { "NodeIterator", 0, &DOMNodeIteratorTable, 0 };
DEFINE_PROTOTYPE("DOMNodeIterator",DOMNodeIteratorProto)
IMPLEMENT_PROTOFUNC(DOMNodeIteratorProtoFunc)
IMPLEMENT_PROTOTYPE(DOMNodeIteratorProto,DOMNodeIteratorProtoFunc)
DOMNodeIterator::DOMNodeIterator(ExecState *exec, DOM::NodeIterator ni)
: DOMObject(DOMNodeIteratorProto::self(exec)), nodeIterator(ni) {}
DOMNodeIterator::~DOMNodeIterator()
{
ScriptInterpreter::forgetDOMObject(nodeIterator.handle());
}
Value DOMNodeIterator::tryGet(ExecState *exec, const Identifier &p) const
{
return DOMObjectLookupGetValue<DOMNodeIterator,DOMObject>(exec,p,&DOMNodeIteratorTable,this);
}
Value DOMNodeIterator::getValueProperty(ExecState *exec, int token) const
{
DOM::NodeIterator ni(nodeIterator);
switch (token) {
case Root:
return getDOMNode(exec,ni.root());
case WhatToShow:
return Number(ni.whatToShow());
case Filter:
return getDOMNodeFilter(exec,ni.filter());
case ExpandEntityReferences:
return Boolean(ni.expandEntityReferences());
case ReferenceNode:
return getDOMNode(exec,ni.referenceNode());
case PointerBeforeReferenceNode:
return Boolean(ni.pointerBeforeReferenceNode());
default:
kdWarning() << "Unhandled token in DOMNodeIterator::getValueProperty : " << token << endl;
return Value();
}
}
Value DOMNodeIteratorProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &)
{
if (!thisObj.inherits(&KJS::DOMNodeIterator::info)) {
Object err = Error::create(exec,TypeError);
exec->setException(err);
return err;
}
DOM::NodeIterator nodeIterator = static_cast<DOMNodeIterator *>(thisObj.imp())->toNodeIterator();
switch (id) {
case DOMNodeIterator::PreviousNode:
return getDOMNode(exec,nodeIterator.previousNode());
case DOMNodeIterator::NextNode:
return getDOMNode(exec,nodeIterator.nextNode());
case DOMNodeIterator::Detach:
nodeIterator.detach();
return Undefined();
}
return Undefined();
}
Value KJS::getDOMNodeIterator(ExecState *exec, DOM::NodeIterator ni)
{
return cacheDOMObject<DOM::NodeIterator, DOMNodeIterator>(exec, ni);
}
const ClassInfo NodeFilterConstructor::info = { "NodeFilterConstructor", 0, &NodeFilterConstructorTable, 0 };
Value NodeFilterConstructor::tryGet(ExecState *exec, const Identifier &p) const
{
return DOMObjectLookupGetValue<NodeFilterConstructor,DOMObject>(exec,p,&NodeFilterConstructorTable,this);
}
Value NodeFilterConstructor::getValueProperty(ExecState *, int token) const
{
return Number(token);
}
Value KJS::getNodeFilterConstructor(ExecState *exec)
{
return cacheGlobalObject<NodeFilterConstructor>(exec, "[[nodeFilter.constructor]]");
}
const ClassInfo DOMNodeFilter::info = { "NodeFilter", 0, 0, 0 };
DEFINE_PROTOTYPE("DOMNodeFilter",DOMNodeFilterProto)
IMPLEMENT_PROTOFUNC(DOMNodeFilterProtoFunc)
IMPLEMENT_PROTOTYPE(DOMNodeFilterProto,DOMNodeFilterProtoFunc)
DOMNodeFilter::DOMNodeFilter(ExecState *exec, DOM::NodeFilter nf)
: DOMObject(DOMNodeFilterProto::self(exec)), nodeFilter(nf) {}
DOMNodeFilter::~DOMNodeFilter()
{
ScriptInterpreter::forgetDOMObject(nodeFilter.handle());
}
Value DOMNodeFilterProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
{
if (!thisObj.inherits(&KJS::DOMNodeFilter::info)) {
Object err = Error::create(exec,TypeError);
exec->setException(err);
return err;
}
DOM::NodeFilter nodeFilter = static_cast<DOMNodeFilter *>(thisObj.imp())->toNodeFilter();
switch (id) {
case DOMNodeFilter::AcceptNode:
return Number(nodeFilter.acceptNode(toNode(args[0])));
}
return Undefined();
}
Value KJS::getDOMNodeFilter(ExecState *exec, DOM::NodeFilter nf)
{
return cacheDOMObject<DOM::NodeFilter, DOMNodeFilter>(exec, nf);
}
const ClassInfo DOMTreeWalker::info = { "TreeWalker", 0, &DOMTreeWalkerTable, 0 };
DEFINE_PROTOTYPE("DOMTreeWalker",DOMTreeWalkerProto)
IMPLEMENT_PROTOFUNC(DOMTreeWalkerProtoFunc)
IMPLEMENT_PROTOTYPE(DOMTreeWalkerProto,DOMTreeWalkerProtoFunc)
DOMTreeWalker::DOMTreeWalker(ExecState *exec, DOM::TreeWalker tw)
: DOMObject(DOMTreeWalkerProto::self(exec)), treeWalker(tw) {}
DOMTreeWalker::~DOMTreeWalker()
{
ScriptInterpreter::forgetDOMObject(treeWalker.handle());
}
Value DOMTreeWalker::tryGet(ExecState *exec, const Identifier &p) const
{
return DOMObjectLookupGetValue<DOMTreeWalker,DOMObject>(exec,p,&DOMTreeWalkerTable,this);
}
Value DOMTreeWalker::getValueProperty(ExecState *exec, int token) const
{
DOM::TreeWalker tw(treeWalker);
switch (token) {
case Root:
return getDOMNode(exec,tw.root());
case WhatToShow:
return Number(tw.whatToShow());
case Filter:
return getDOMNodeFilter(exec,tw.filter());
case ExpandEntityReferences:
return Boolean(tw.expandEntityReferences());
case CurrentNode:
return getDOMNode(exec,tw.currentNode());
default:
kdWarning() << "Unhandled token in DOMTreeWalker::getValueProperty : " << token << endl;
return Value();
}
}
void DOMTreeWalker::tryPut(ExecState *exec, const Identifier &propertyName,
const Value& value, int attr)
{
if (propertyName == "currentNode") {
treeWalker.setCurrentNode(toNode(value));
}
else
ObjectImp::put(exec, propertyName, value, attr);
}
Value DOMTreeWalkerProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &)
{
if (!thisObj.inherits(&KJS::DOMTreeWalker::info)) {
Object err = Error::create(exec,TypeError);
exec->setException(err);
return err;
}
DOM::TreeWalker treeWalker = static_cast<DOMTreeWalker *>(thisObj.imp())->toTreeWalker();
switch (id) {
case DOMTreeWalker::ParentNode:
return getDOMNode(exec,treeWalker.parentNode());
case DOMTreeWalker::FirstChild:
return getDOMNode(exec,treeWalker.firstChild());
case DOMTreeWalker::LastChild:
return getDOMNode(exec,treeWalker.lastChild());
case DOMTreeWalker::PreviousSibling:
return getDOMNode(exec,treeWalker.previousSibling());
case DOMTreeWalker::NextSibling:
return getDOMNode(exec,treeWalker.nextSibling());
case DOMTreeWalker::PreviousNode:
return getDOMNode(exec,treeWalker.previousNode());
case DOMTreeWalker::NextNode:
return getDOMNode(exec,treeWalker.nextNode());
}
return Undefined();
}
Value KJS::getDOMTreeWalker(ExecState *exec, DOM::TreeWalker tw)
{
return cacheDOMObject<DOM::TreeWalker, DOMTreeWalker>(exec, tw);
}
DOM::NodeFilter KJS::toNodeFilter(const Value& val)
{
Object obj = Object::dynamicCast(val);
if (obj.isNull() || !obj.inherits(&DOMNodeFilter::info))
return DOM::NodeFilter();
const DOMNodeFilter *dobj = static_cast<const DOMNodeFilter*>(obj.imp());
return dobj->toNodeFilter();
}
JSNodeFilterCondition::JSNodeFilterCondition(Object & _filter) : filter( _filter )
{
}
short JSNodeFilterCondition::acceptNode(const DOM::Node &node) const
{
KHTMLPart *part = static_cast<DOM::DocumentImpl *>(node.handle()->docPtr()->document())->part();
KJSProxy *proxy = KJSProxy::proxy(part);
if (proxy && filter.implementsCall()) {
ExecState *exec = proxy->interpreter()->globalExec();
List args;
args.append(getDOMNode(exec,node));
Object obj = const_cast<ProtectedObject &>(filter);
Value result = obj.call(exec, obj, args);
return result.toInt32(exec);
}
return DOM::NodeFilter::FILTER_REJECT;
}