00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
#include "kjs_traversal.h"
00022
#include "kjs_traversal.lut.h"
00023
#include "kjs_proxy.h"
00024
#include <dom/dom_node.h>
00025
#include <xml/dom_nodeimpl.h>
00026
#include <xml/dom_docimpl.h>
00027
#include <khtmlview.h>
00028
#include <khtml_part.h>
00029
#include <kdebug.h>
00030
00031
using namespace KJS;
00032
00033
00034
00035
const ClassInfo DOMNodeIterator::info = {
"NodeIterator", 0, &DOMNodeIteratorTable, 0 };
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049 DEFINE_PROTOTYPE(
"DOMNodeIterator",DOMNodeIteratorProto)
00050 IMPLEMENT_PROTOFUNC_DOM(DOMNodeIteratorProtoFunc)
00051 IMPLEMENT_PROTOTYPE(DOMNodeIteratorProto,DOMNodeIteratorProtoFunc)
00052
00053 DOMNodeIterator::DOMNodeIterator(ExecState *exec, DOM::
NodeIterator ni)
00054 :
DOMObject(DOMNodeIteratorProto::self(exec)), nodeIterator(ni) {}
00055
00056 DOMNodeIterator::~DOMNodeIterator()
00057 {
00058
ScriptInterpreter::forgetDOMObject(nodeIterator.handle());
00059 }
00060
00061 Value DOMNodeIterator::tryGet(ExecState *exec,
const Identifier &p)
const
00062
{
00063
return DOMObjectLookupGetValue<DOMNodeIterator,DOMObject>(exec,p,&DOMNodeIteratorTable,
this);
00064 }
00065
00066 Value DOMNodeIterator::getValueProperty(ExecState *exec,
int token)
const
00067
{
00068
DOM::NodeIterator ni(nodeIterator);
00069
switch (token) {
00070
case Root:
00071
return getDOMNode(exec,ni.root());
00072
case WhatToShow:
00073
return Number(ni.whatToShow());
00074
case Filter:
00075
return getDOMNodeFilter(exec,ni.filter());
00076
case ExpandEntityReferences:
00077
return Boolean(ni.expandEntityReferences());
00078
default:
00079
kdDebug(6070) <<
"WARNING: Unhandled token in DOMNodeIterator::getValueProperty : " << token <<
endl;
00080
return Value();
00081 }
00082 }
00083
00084 Value DOMNodeIteratorProtoFunc::tryCall(ExecState *exec, Object &thisObj,
const List &)
00085 {
00086 KJS_CHECK_THIS( KJS::DOMNodeIterator, thisObj );
00087
DOM::NodeIterator nodeIterator = static_cast<DOMNodeIterator *>(thisObj.imp())->toNodeIterator();
00088
switch (
id) {
00089
case DOMNodeIterator::PreviousNode:
00090
return getDOMNode(exec,nodeIterator.
previousNode());
00091
case DOMNodeIterator::NextNode:
00092
return getDOMNode(exec,nodeIterator.
nextNode());
00093
case DOMNodeIterator::Detach:
00094 nodeIterator.
detach();
00095
return Undefined();
00096 }
00097
return Undefined();
00098 }
00099
00100 Value KJS::getDOMNodeIterator(ExecState *exec,
DOM::NodeIterator ni)
00101 {
00102
return cacheDOMObject<DOM::NodeIterator, DOMNodeIterator>(exec, ni);
00103 }
00104
00105
00106
00107
00108
const ClassInfo NodeFilterConstructor::info = {
"NodeFilterConstructor", 0, &NodeFilterConstructorTable, 0 };
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130 NodeFilterConstructor::NodeFilterConstructor(ExecState* exec)
00131 :
DOMObject(exec->interpreter()->builtinObjectPrototype())
00132 {
00133 }
00134
00135 Value NodeFilterConstructor::tryGet(ExecState *exec,
const Identifier &p)
const
00136
{
00137
return DOMObjectLookupGetValue<NodeFilterConstructor,DOMObject>(exec,p,&NodeFilterConstructorTable,
this);
00138 }
00139
00140 Value NodeFilterConstructor::getValueProperty(ExecState *,
int token)
const
00141
{
00142
00143
return Number(token);
00144 }
00145
00146 Value KJS::getNodeFilterConstructor(ExecState *exec)
00147 {
00148
return cacheGlobalObject<NodeFilterConstructor>(exec,
"[[nodeFilter.constructor]]");
00149 }
00150
00151
00152
00153
const ClassInfo DOMNodeFilter::info = {
"NodeFilter", 0, 0, 0 };
00154
00155
00156
00157
00158
00159 DEFINE_PROTOTYPE(
"DOMNodeFilter",DOMNodeFilterProto)
00160 IMPLEMENT_PROTOFUNC_DOM(DOMNodeFilterProtoFunc)
00161 IMPLEMENT_PROTOTYPE(DOMNodeFilterProto,DOMNodeFilterProtoFunc)
00162
00163 DOMNodeFilter::DOMNodeFilter(ExecState *exec, DOM::
NodeFilter nf)
00164 :
DOMObject(DOMNodeFilterProto::self(exec)), nodeFilter(nf) {}
00165
00166 DOMNodeFilter::~DOMNodeFilter()
00167 {
00168
ScriptInterpreter::forgetDOMObject(nodeFilter.handle());
00169 }
00170
00171 Value DOMNodeFilterProtoFunc::tryCall(ExecState *exec, Object &thisObj,
const List &args)
00172 {
00173 KJS_CHECK_THIS( KJS::DOMNodeFilter, thisObj );
00174
DOM::NodeFilter nodeFilter = static_cast<DOMNodeFilter *>(thisObj.imp())->toNodeFilter();
00175
switch (
id) {
00176
case DOMNodeFilter::AcceptNode:
00177
return Number(nodeFilter.
acceptNode(toNode(args[0])));
00178 }
00179
return Undefined();
00180 }
00181
00182 Value KJS::getDOMNodeFilter(ExecState *exec,
DOM::NodeFilter nf)
00183 {
00184
return cacheDOMObject<DOM::NodeFilter, DOMNodeFilter>(exec, nf);
00185 }
00186
00187
00188
00189
const ClassInfo DOMTreeWalker::info = {
"TreeWalker", 0, &DOMTreeWalkerTable, 0 };
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208 DEFINE_PROTOTYPE(
"DOMTreeWalker",DOMTreeWalkerProto)
00209 IMPLEMENT_PROTOFUNC_DOM(DOMTreeWalkerProtoFunc)
00210 IMPLEMENT_PROTOTYPE(DOMTreeWalkerProto,DOMTreeWalkerProtoFunc)
00211
00212 DOMTreeWalker::DOMTreeWalker(ExecState *exec, DOM::
TreeWalker tw)
00213 :
DOMObject(DOMTreeWalkerProto::self(exec)), treeWalker(tw) {}
00214
00215 DOMTreeWalker::~DOMTreeWalker()
00216 {
00217
ScriptInterpreter::forgetDOMObject(treeWalker.handle());
00218 }
00219
00220 Value DOMTreeWalker::tryGet(ExecState *exec,
const Identifier &p)
const
00221
{
00222
return DOMObjectLookupGetValue<DOMTreeWalker,DOMObject>(exec,p,&DOMTreeWalkerTable,
this);
00223 }
00224
00225 Value DOMTreeWalker::getValueProperty(ExecState *exec,
int token)
const
00226
{
00227
DOM::TreeWalker tw(treeWalker);
00228
switch (token) {
00229
case Root:
00230
return getDOMNode(exec,tw.root());
00231
case WhatToShow:
00232
return Number(tw.whatToShow());
00233
case Filter:
00234
return getDOMNodeFilter(exec,tw.filter());
00235
case ExpandEntityReferences:
00236
return Boolean(tw.expandEntityReferences());
00237
case CurrentNode:
00238
return getDOMNode(exec,tw.currentNode());
00239
default:
00240
kdDebug(6070) <<
"WARNING: Unhandled token in DOMTreeWalker::getValueProperty : " << token <<
endl;
00241
return Value();
00242 }
00243 }
00244
00245
void DOMTreeWalker::tryPut(ExecState *exec,
const Identifier &propertyName,
00246
const Value& value,
int attr)
00247 {
00248
if (propertyName ==
"currentNode") {
00249 treeWalker.setCurrentNode(toNode(value));
00250 }
00251
else
00252 ObjectImp::put(exec, propertyName, value, attr);
00253 }
00254
00255 Value DOMTreeWalkerProtoFunc::tryCall(ExecState *exec, Object &thisObj,
const List &)
00256 {
00257 KJS_CHECK_THIS( KJS::DOMTreeWalker, thisObj );
00258
DOM::TreeWalker treeWalker = static_cast<DOMTreeWalker *>(thisObj.imp())->toTreeWalker();
00259
switch (
id) {
00260
case DOMTreeWalker::ParentNode:
00261
return getDOMNode(exec,treeWalker.
parentNode());
00262
case DOMTreeWalker::FirstChild:
00263
return getDOMNode(exec,treeWalker.
firstChild());
00264
case DOMTreeWalker::LastChild:
00265
return getDOMNode(exec,treeWalker.
lastChild());
00266
case DOMTreeWalker::PreviousSibling:
00267
return getDOMNode(exec,treeWalker.
previousSibling());
00268
case DOMTreeWalker::NextSibling:
00269
return getDOMNode(exec,treeWalker.
nextSibling());
00270
case DOMTreeWalker::PreviousNode:
00271
return getDOMNode(exec,treeWalker.
previousSibling());
00272
case DOMTreeWalker::NextNode:
00273
return getDOMNode(exec,treeWalker.
nextNode());
00274 }
00275
return Undefined();
00276 }
00277
00278 Value KJS::getDOMTreeWalker(ExecState *exec,
DOM::TreeWalker tw)
00279 {
00280
return cacheDOMObject<DOM::TreeWalker, DOMTreeWalker>(exec, tw);
00281 }
00282
00283
DOM::NodeFilter KJS::toNodeFilter(
const Value& val)
00284 {
00285 Object obj = Object::dynamicCast(val);
00286
if (obj.isNull() || !obj.inherits(&DOMNodeFilter::info))
00287
return DOM::NodeFilter();
00288
00289
const DOMNodeFilter *dobj = static_cast<const DOMNodeFilter*>(obj.imp());
00290
return dobj->toNodeFilter();
00291 }
00292
00293
00294
00295 JSNodeFilter::JSNodeFilter(Object & _filter) : DOM::
CustomNodeFilter(), filter( _filter )
00296 {
00297 }
00298
00299 JSNodeFilter::~JSNodeFilter()
00300 {
00301 }
00302
00303
short JSNodeFilter::acceptNode(
const DOM::Node &n)
00304 {
00305
KHTMLView *view = static_cast<DOM::DocumentImpl *>( n.
handle()->docPtr()->document() )->view();
00306
if (!view)
00307
return DOM::NodeFilter::FILTER_REJECT;
00308
00309
KHTMLPart *part = view->
part();
00310 KJSProxy *proxy = part->
jScript();
00311
if (proxy) {
00312 ExecState *exec = proxy->interpreter()->globalExec();
00313 Object acceptNodeFunc = Object::dynamicCast( filter.get(exec,
"acceptNode") );
00314
if (acceptNodeFunc.implementsCall()) {
00315 List args;
00316 args.append(getDOMNode(exec,n));
00317 Value result = acceptNodeFunc.call(exec,filter,args);
00318
if (exec->hadException())
00319 exec->clearException();
00320
return result.toInteger(exec);
00321 }
00322 }
00323
00324
return DOM::NodeFilter::FILTER_REJECT;
00325 }