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