00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include <khtmlview.h>
00023 #include "xml/dom2_eventsimpl.h"
00024 #include "rendering/render_canvas.h"
00025 #include "rendering/render_layer.h"
00026 #include "xml/dom_nodeimpl.h"
00027 #include "xml/dom_docimpl.h"
00028 #include "misc/htmltags.h"
00029 #include "misc/htmlattrs.h"
00030 #include "html/html_baseimpl.h"
00031 #include <kdebug.h>
00032 #include <khtml_part.h>
00033
00034 #include "kjs_dom.h"
00035 #include "kjs_html.h"
00036 #include "kjs_css.h"
00037 #include "kjs_range.h"
00038 #include "kjs_traversal.h"
00039 #include "kjs_events.h"
00040 #include "kjs_views.h"
00041 #include "kjs_window.h"
00042 #include "dom/dom_exception.h"
00043 #include "kjs_dom.lut.h"
00044 #include "khtmlpart_p.h"
00045
00046 using namespace KJS;
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071 DEFINE_PROTOTYPE("DOMNode",DOMNodeProto)
00072 IMPLEMENT_PROTOFUNC_DOM(DOMNodeProtoFunc)
00073 IMPLEMENT_PROTOTYPE(DOMNodeProto,DOMNodeProtoFunc)
00074
00075 const ClassInfo DOMNode::info = { "Node", 0, &DOMNodeTable, 0 };
00076
00077 DOMNode::DOMNode(ExecState *exec, const DOM::Node& n)
00078 : DOMObject(DOMNodeProto::self(exec)), node(n)
00079 {
00080 }
00081
00082 DOMNode::DOMNode(const Object& proto, const DOM::Node& n)
00083 : DOMObject(proto), node(n)
00084 {
00085 }
00086
00087 DOMNode::~DOMNode()
00088 {
00089 ScriptInterpreter::forgetDOMObject(node.handle());
00090 }
00091
00092 bool DOMNode::toBoolean(ExecState *) const
00093 {
00094 return !node.isNull();
00095 }
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158 Value DOMNode::tryGet(ExecState *exec, const Identifier &propertyName) const
00159 {
00160 #ifdef KJS_VERBOSE
00161 kdDebug(6070) << "DOMNode::tryGet " << propertyName.qstring() << endl;
00162 #endif
00163 return DOMObjectLookupGetValue<DOMNode, DOMObject>(exec, propertyName, &DOMNodeTable, this);
00164 }
00165
00166 Value DOMNode::getValueProperty(ExecState *exec, int token) const
00167 {
00168 khtml::RenderObject *rend = node.handle() ? node.handle()->renderer() : 0L;
00169
00170 switch (token) {
00171 case NodeName:
00172 return getString(node.nodeName());
00173 case NodeValue:
00174 return getString(node.nodeValue());
00175 case NodeType:
00176 return Number((unsigned int)node.nodeType());
00177 case ParentNode:
00178 return getDOMNode(exec,node.parentNode());
00179 case ParentElement:
00180 return getDOMNode(exec,node.parentNode());
00181 case ChildNodes:
00182 return getDOMNodeList(exec,node.childNodes());
00183 case FirstChild:
00184 return getDOMNode(exec,node.firstChild());
00185 case LastChild:
00186 return getDOMNode(exec,node.lastChild());
00187 case PreviousSibling:
00188 return getDOMNode(exec,node.previousSibling());
00189 case NextSibling:
00190 return getDOMNode(exec,node.nextSibling());
00191 case Attributes:
00192 return getDOMNamedNodeMap(exec,node.attributes());
00193 case NamespaceURI:
00194 return getString(node.namespaceURI());
00195 case Prefix:
00196 return getString(node.prefix());
00197 case LocalName:
00198 return getString(node.localName());
00199 case OwnerDocument:
00200 return getDOMNode(exec,node.ownerDocument());
00201 case OnAbort:
00202 return getListener(DOM::EventImpl::ABORT_EVENT);
00203 case OnBlur:
00204 return getListener(DOM::EventImpl::BLUR_EVENT);
00205 case OnChange:
00206 return getListener(DOM::EventImpl::CHANGE_EVENT);
00207 case OnClick:
00208 return getListener(DOM::EventImpl::KHTML_ECMA_CLICK_EVENT);
00209 case OnDblClick:
00210 return getListener(DOM::EventImpl::KHTML_ECMA_DBLCLICK_EVENT);
00211 case OnDragDrop:
00212 return getListener(DOM::EventImpl::KHTML_DRAGDROP_EVENT);
00213 case OnError:
00214 return getListener(DOM::EventImpl::KHTML_ERROR_EVENT);
00215 case OnFocus:
00216 return getListener(DOM::EventImpl::FOCUS_EVENT);
00217 case OnKeyDown:
00218 return getListener(DOM::EventImpl::KHTML_KEYDOWN_EVENT);
00219 case OnKeyPress:
00220 return getListener(DOM::EventImpl::KHTML_KEYPRESS_EVENT);
00221 case OnKeyUp:
00222 return getListener(DOM::EventImpl::KHTML_KEYUP_EVENT);
00223 case OnLoad:
00224 return getListener(DOM::EventImpl::LOAD_EVENT);
00225 case OnMouseDown:
00226 return getListener(DOM::EventImpl::MOUSEDOWN_EVENT);
00227 case OnMouseMove:
00228 return getListener(DOM::EventImpl::MOUSEMOVE_EVENT);
00229 case OnMouseOut:
00230 return getListener(DOM::EventImpl::MOUSEOUT_EVENT);
00231 case OnMouseOver:
00232 return getListener(DOM::EventImpl::MOUSEOVER_EVENT);
00233 case OnMouseUp:
00234 return getListener(DOM::EventImpl::MOUSEUP_EVENT);
00235 case OnMove:
00236 return getListener(DOM::EventImpl::KHTML_MOVE_EVENT);
00237 case OnReset:
00238 return getListener(DOM::EventImpl::RESET_EVENT);
00239 case OnResize:
00240 return getListener(DOM::EventImpl::RESIZE_EVENT);
00241 case OnSelect:
00242 return getListener(DOM::EventImpl::SELECT_EVENT);
00243 case OnSubmit:
00244 return getListener(DOM::EventImpl::SUBMIT_EVENT);
00245 case OnUnload:
00246 return getListener(DOM::EventImpl::UNLOAD_EVENT);
00247 case OffsetLeft:
00248 case OffsetTop:
00249 case OffsetWidth:
00250 case OffsetHeight:
00251 case OffsetParent:
00252 case ClientWidth:
00253 case ClientHeight:
00254 case ScrollWidth:
00255 case ScrollHeight:
00256 case ScrollLeft:
00257 case ScrollTop:
00258 {
00259
00260
00261
00262
00263 DOM::DocumentImpl* docimpl = node.handle()->getDocument();
00264 KHTMLView* v = 0;
00265 if ( docimpl ) {
00266 v = docimpl->view();
00267
00268 if ( v && docimpl->renderer() && !docimpl->renderer()->layouted() )
00269 {
00270 docimpl->updateRendering();
00271 docimpl->view()->layout();
00272 }
00273
00274
00275 rend = node.handle() ? node.handle()->renderer() : 0L;
00276 }
00277
00278 switch (token) {
00279 case OffsetLeft:
00280 return rend ? static_cast<Value>( Number( rend->offsetLeft() ) ) : Undefined();
00281 case OffsetTop:
00282 return rend ? static_cast<Value>( Number( rend->offsetTop() ) ) : Undefined();
00283 case OffsetWidth:
00284 return rend ? static_cast<Value>( Number( rend->offsetWidth() ) ) : Undefined();
00285 case OffsetHeight:
00286 return rend ? static_cast<Value>( Number( rend->offsetHeight() ) ) : Undefined();
00287 case OffsetParent:
00288 {
00289 khtml::RenderObject* par = rend ? rend->offsetParent() : 0;
00290 return getDOMNode( exec, par ? par->element() : 0 );
00291 }
00292 case ClientWidth:
00293 return rend ? static_cast<Value>( Number( rend->clientWidth() ) ) : Undefined();
00294 case ClientHeight:
00295 return rend ? static_cast<Value>( Number( rend->clientHeight() ) ) : Undefined();
00296 case ScrollWidth:
00297 return rend ? static_cast<Value>( Number(rend->scrollWidth()) ) : Undefined();
00298 case ScrollHeight:
00299 return rend ? static_cast<Value>( Number(rend->scrollHeight()) ) : Undefined();
00300 case ScrollLeft:
00301 return Number( rend && rend->layer() ? rend->layer()->scrollXOffset() : 0 );
00302 case ScrollTop:
00303 return Number( rend && rend->layer() ? rend->layer()->scrollYOffset() : 0 );
00304 }
00305 }
00306 case SourceIndex: {
00307
00308
00309
00310 DOM::Document doc = node.ownerDocument();
00311 if (doc.isHTMLDocument()) {
00312 DOM::HTMLCollection all = static_cast<DOM::HTMLDocument>(doc).all();
00313 unsigned long i = 0;
00314 DOM::Node n = all.firstItem();
00315 for ( ; !n.isNull() && n != node; n = all.nextItem() )
00316 ++i;
00317 Q_ASSERT( !n.isNull() );
00318 return Number(i);
00319 }
00320 }
00321 default:
00322 kdDebug(6070) << "WARNING: Unhandled token in DOMNode::getValueProperty : " << token << endl;
00323 break;
00324 }
00325
00326 return Undefined();
00327 }
00328
00329
00330 void DOMNode::tryPut(ExecState *exec, const Identifier& propertyName, const Value& value, int attr)
00331 {
00332 #ifdef KJS_VERBOSE
00333 kdDebug(6070) << "DOMNode::tryPut " << propertyName.qstring() << endl;
00334 #endif
00335 DOMObjectLookupPut<DOMNode,DOMObject>(exec, propertyName, value, attr,
00336 &DOMNodeTable, this );
00337 }
00338
00339 void DOMNode::putValueProperty(ExecState *exec, int token, const Value& value, int )
00340 {
00341 switch (token) {
00342 case NodeValue:
00343 node.setNodeValue(value.toString(exec).string());
00344 break;
00345 case Prefix:
00346 node.setPrefix(value.toString(exec).string());
00347 break;
00348 case OnAbort:
00349 setListener(exec,DOM::EventImpl::ABORT_EVENT,value);
00350 break;
00351 case OnBlur:
00352 setListener(exec,DOM::EventImpl::BLUR_EVENT,value);
00353 break;
00354 case OnChange:
00355 setListener(exec,DOM::EventImpl::CHANGE_EVENT,value);
00356 break;
00357 case OnClick:
00358 setListener(exec,DOM::EventImpl::KHTML_ECMA_CLICK_EVENT,value);
00359 break;
00360 case OnDblClick:
00361 setListener(exec,DOM::EventImpl::KHTML_ECMA_DBLCLICK_EVENT,value);
00362 break;
00363 case OnDragDrop:
00364 setListener(exec,DOM::EventImpl::KHTML_DRAGDROP_EVENT,value);
00365 break;
00366 case OnError:
00367 setListener(exec,DOM::EventImpl::KHTML_ERROR_EVENT,value);
00368 break;
00369 case OnFocus:
00370 setListener(exec,DOM::EventImpl::FOCUS_EVENT,value);
00371 break;
00372 case OnKeyDown:
00373 setListener(exec,DOM::EventImpl::KHTML_KEYDOWN_EVENT,value);
00374 break;
00375 case OnKeyPress:
00376 setListener(exec,DOM::EventImpl::KHTML_KEYPRESS_EVENT,value);
00377 break;
00378 case OnKeyUp:
00379 setListener(exec,DOM::EventImpl::KHTML_KEYUP_EVENT,value);
00380 break;
00381 case OnLoad:
00382 setListener(exec,DOM::EventImpl::LOAD_EVENT,value);
00383 break;
00384 case OnMouseDown:
00385 setListener(exec,DOM::EventImpl::MOUSEDOWN_EVENT,value);
00386 break;
00387 case OnMouseMove:
00388 setListener(exec,DOM::EventImpl::MOUSEMOVE_EVENT,value);
00389 break;
00390 case OnMouseOut:
00391 setListener(exec,DOM::EventImpl::MOUSEOUT_EVENT,value);
00392 break;
00393 case OnMouseOver:
00394 setListener(exec,DOM::EventImpl::MOUSEOVER_EVENT,value);
00395 break;
00396 case OnMouseUp:
00397 setListener(exec,DOM::EventImpl::MOUSEUP_EVENT,value);
00398 break;
00399 case OnMove:
00400 setListener(exec,DOM::EventImpl::KHTML_MOVE_EVENT,value);
00401 break;
00402 case OnReset:
00403 setListener(exec,DOM::EventImpl::RESET_EVENT,value);
00404 break;
00405 case OnResize:
00406 setListener(exec,DOM::EventImpl::RESIZE_EVENT,value);
00407 break;
00408 case OnSelect:
00409 setListener(exec,DOM::EventImpl::SELECT_EVENT,value);
00410 break;
00411 case OnSubmit:
00412 setListener(exec,DOM::EventImpl::SUBMIT_EVENT,value);
00413 break;
00414 case OnUnload:
00415 setListener(exec,DOM::EventImpl::UNLOAD_EVENT,value);
00416 break;
00417 case ScrollTop: {
00418 khtml::RenderObject *rend = node.handle() ? node.handle()->renderer() : 0L;
00419 if (rend && rend->layer() && rend->style()->hidesOverflow())
00420 rend->layer()->scrollToYOffset(value.toInt32(exec));
00421 break;
00422 }
00423 case ScrollLeft: {
00424 khtml::RenderObject *rend = node.handle() ? node.handle()->renderer() : 0L;
00425 if (rend && rend->layer() && rend->style()->hidesOverflow())
00426 rend->layer()->scrollToXOffset(value.toInt32(exec));
00427 break;
00428 }
00429 default:
00430 kdDebug(6070) << "WARNING: DOMNode::putValueProperty unhandled token " << token << endl;
00431 }
00432 }
00433
00434 Value DOMNode::toPrimitive(ExecState *exec, Type ) const
00435 {
00436 if (node.isNull())
00437 return Null();
00438
00439 return String(toString(exec));
00440 }
00441
00442 UString DOMNode::toString(ExecState *) const
00443 {
00444 if (node.isNull())
00445 return "null";
00446 UString s;
00447
00448 DOM::Element e = node;
00449 if ( !e.isNull() ) {
00450 s = e.nodeName().string();
00451 } else
00452 s = className();
00453
00454 return "[object " + s + "]";
00455 }
00456
00457 void DOMNode::setListener(ExecState *exec, int eventId, const Value& func) const
00458 {
00459 node.handle()->setHTMLEventListener(eventId,Window::retrieveActive(exec)->getJSEventListener(func,true));
00460 }
00461
00462 Value DOMNode::getListener(int eventId) const
00463 {
00464 DOM::EventListener *listener = node.handle()->getHTMLEventListener(eventId);
00465 if (listener)
00466 return static_cast<JSEventListener*>(listener)->listenerObj();
00467 else
00468 return Null();
00469 }
00470
00471 void DOMNode::pushEventHandlerScope(ExecState *, ScopeChain &) const
00472 {
00473 }
00474
00475 Value DOMNodeProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00476 {
00477 KJS_CHECK_THIS( DOMNode, thisObj );
00478 DOM::Node node = static_cast<DOMNode *>( thisObj.imp() )->toNode();
00479 switch (id) {
00480 case DOMNode::HasAttributes:
00481 return Boolean(node.hasAttributes());
00482 case DOMNode::HasChildNodes:
00483 return Boolean(node.hasChildNodes());
00484 case DOMNode::CloneNode:
00485 return getDOMNode(exec,node.cloneNode(args[0].toBoolean(exec)));
00486 case DOMNode::Normalize:
00487 node.normalize();
00488 return Undefined();
00489 case DOMNode::IsSupported:
00490 return Boolean(node.isSupported(args[0].toString(exec).string(),args[1].toString(exec).string()));
00491 case DOMNode::AddEventListener: {
00492 JSEventListener *listener = Window::retrieveActive(exec)->getJSEventListener(args[1]);
00493 node.addEventListener(args[0].toString(exec).string(),listener,args[2].toBoolean(exec));
00494 return Undefined();
00495 }
00496 case DOMNode::RemoveEventListener: {
00497 JSEventListener *listener = Window::retrieveActive(exec)->getJSEventListener(args[1]);
00498 node.removeEventListener(args[0].toString(exec).string(),listener,args[2].toBoolean(exec));
00499 return Undefined();
00500 }
00501 case DOMNode::DispatchEvent:
00502 return Boolean(node.dispatchEvent(toEvent(args[0])));
00503 case DOMNode::AppendChild:
00504 return getDOMNode(exec,node.appendChild(toNode(args[0])));
00505 case DOMNode::RemoveChild:
00506 return getDOMNode(exec,node.removeChild(toNode(args[0])));
00507 case DOMNode::InsertBefore:
00508 return getDOMNode(exec,node.insertBefore(toNode(args[0]), toNode(args[1])));
00509 case DOMNode::ReplaceChild:
00510 return getDOMNode(exec,node.replaceChild(toNode(args[0]), toNode(args[1])));
00511 case DOMNode::Contains:
00512 {
00513 DOM::Node other = toNode(args[0]);
00514 if (!other.isNull() && node.nodeType()==DOM::Node::ELEMENT_NODE)
00515 {
00516 DOM::NodeBaseImpl *impl = static_cast<DOM::NodeBaseImpl *>(node.handle());
00517 bool retval = other.handle()->isAncestor(impl);
00518 return Boolean(retval);
00519 }
00520 return Undefined();
00521 }
00522 case DOMNode::Item:
00523 return getDOMNode(exec, node.childNodes().item(static_cast<unsigned long>(args[0].toNumber(exec))));
00524 }
00525
00526 return Undefined();
00527 }
00528
00529
00530
00531
00532
00533
00534
00535
00536
00537
00538 DEFINE_PROTOTYPE("DOMNodeList", DOMNodeListProto)
00539 IMPLEMENT_PROTOFUNC_DOM(DOMNodeListProtoFunc)
00540 IMPLEMENT_PROTOTYPE(DOMNodeListProto,DOMNodeListProtoFunc)
00541
00542 const ClassInfo DOMNodeList::info = { "NodeList", 0, 0, 0 };
00543
00544 DOMNodeList::DOMNodeList(ExecState *exec, const DOM::NodeList& l)
00545 : DOMObject(DOMNodeListProto::self(exec)), list(l) { }
00546
00547 DOMNodeList::~DOMNodeList()
00548 {
00549 ScriptInterpreter::forgetDOMObject(list.handle());
00550 }
00551
00552
00553
00554 bool DOMNodeList::hasProperty(ExecState *exec, const Identifier &p) const
00555 {
00556 if (p == lengthPropertyName)
00557 return true;
00558
00559 return ObjectImp::hasProperty(exec, p);
00560 }
00561
00562 Value DOMNodeList::tryGet(ExecState *exec, const Identifier &p) const
00563 {
00564 #ifdef KJS_VERBOSE
00565 kdDebug(6070) << "DOMNodeList::tryGet " << p.ascii() << endl;
00566 #endif
00567 if (p == lengthPropertyName)
00568 return Number(list.length());
00569
00570
00571 Object proto = Object::dynamicCast(prototype());
00572 if (!proto.isNull() && proto.hasProperty(exec,p))
00573 return proto.get(exec,p);
00574
00575 Value result;
00576
00577
00578 bool ok;
00579 long unsigned int idx = p.toULong(&ok);
00580 if (ok)
00581 result = getDOMNode(exec,list.item(idx));
00582 else {
00583
00584 DOM::HTMLElement e;
00585 unsigned long l = list.length();
00586 bool found = false;
00587
00588 for ( unsigned long i = 0; i < l; i++ )
00589 if ( ( e = list.item( i ) ).id() == p.string() ) {
00590 result = getDOMNode(exec, list.item( i ) );
00591 found = true;
00592 break;
00593 }
00594
00595 if ( !found )
00596 result = ObjectImp::get(exec, p);
00597 }
00598
00599 return result;
00600 }
00601
00602
00603 Value DOMNodeList::call(ExecState *exec, Object &thisObj, const List &args)
00604 {
00605
00606 Value val;
00607 try {
00608 val = tryCall(exec, thisObj, args);
00609 }
00610
00611 catch (...) {
00612 Object err = Error::create(exec, GeneralError, "Exception from DOMNodeList");
00613 exec->setException(err);
00614 }
00615 return val;
00616 }
00617
00618 Value DOMNodeList::tryCall(ExecState *exec, Object &, const List &args)
00619 {
00620
00621 UString s = args[0].toString(exec);
00622 bool ok;
00623 unsigned int u = s.toULong(&ok);
00624 if (ok)
00625 return getDOMNode(exec,list.item(u));
00626
00627 kdDebug(6070) << "WARNING: KJS::DOMNodeList::tryCall " << s.qstring() << " not implemented" << endl;
00628 return Undefined();
00629 }
00630
00631
00632 Value DOMNodeListProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00633 {
00634 KJS_CHECK_THIS( KJS::DOMNodeList, thisObj );
00635 DOM::NodeList list = static_cast<DOMNodeList *>(thisObj.imp())->nodeList();
00636 switch (id) {
00637 case KJS::DOMNodeList::Item:
00638 return getDOMNode(exec, list.item(args[0].toInt32(exec)));
00639 case KJS::DOMNodeList::NamedItem:
00640 {
00641
00642
00643 DOM::HTMLElement e;
00644 unsigned long len = list.length();
00645 DOM::DOMString s = args[0].toString(exec).string();
00646
00647 for ( unsigned long i = 0; i < len; i++ )
00648 {
00649 e = list.item( i );
00650 if ( !e.isNull() && (
00651 e.id() == s || static_cast<ElementImpl *>(e.handle())->getAttribute(ATTR_NAME) == s )
00652 )
00653 {
00654 return getDOMNode(exec, e );
00655 }
00656 }
00657 return Null();
00658 }
00659 default:
00660 return Undefined();
00661 }
00662 }
00663
00664
00665
00666 const ClassInfo DOMAttr::info = { "Attr", &DOMNode::info, &DOMAttrTable, 0 };
00667
00668
00669
00670
00671
00672
00673
00674
00675
00676 Value DOMAttr::tryGet(ExecState *exec, const Identifier &propertyName) const
00677 {
00678 #ifdef KJS_VERBOSE
00679 kdDebug(6070) << "DOMAttr::tryPut " << propertyName.qstring() << endl;
00680 #endif
00681 return DOMObjectLookupGetValue<DOMAttr,DOMNode>(exec, propertyName,
00682 &DOMAttrTable, this );
00683 }
00684
00685 Value DOMAttr::getValueProperty(ExecState *exec, int token) const
00686 {
00687 switch (token) {
00688 case Name:
00689 return getString(static_cast<DOM::Attr>(node).name());
00690 case Specified:
00691 return Boolean(static_cast<DOM::Attr>(node).specified());
00692 case ValueProperty:
00693 return getString(static_cast<DOM::Attr>(node).value());
00694 case OwnerElement:
00695 return getDOMNode(exec,static_cast<DOM::Attr>(node).ownerElement());
00696 }
00697 return Value();
00698 }
00699
00700 void DOMAttr::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr)
00701 {
00702 #ifdef KJS_VERBOSE
00703 kdDebug(6070) << "DOMAttr::tryPut " << propertyName.qstring() << endl;
00704 #endif
00705 DOMObjectLookupPut<DOMAttr,DOMNode>(exec, propertyName, value, attr,
00706 &DOMAttrTable, this );
00707 }
00708
00709 void DOMAttr::putValueProperty(ExecState *exec, int token, const Value& value, int )
00710 {
00711 switch (token) {
00712 case ValueProperty:
00713 static_cast<DOM::Attr>(node).setValue(value.toString(exec).string());
00714 return;
00715 default:
00716 kdDebug(6070) << "WARNING: DOMAttr::putValueProperty unhandled token " << token << endl;
00717 }
00718 }
00719
00720
00721
00722
00723
00724
00725
00726
00727
00728
00729
00730
00731
00732
00733
00734
00735
00736
00737
00738
00739
00740
00741
00742
00743
00744
00745
00746
00747
00748 DEFINE_PROTOTYPE("DOMDocument", DOMDocumentProto)
00749 IMPLEMENT_PROTOFUNC_DOM(DOMDocumentProtoFunc)
00750 IMPLEMENT_PROTOTYPE_WITH_PARENT(DOMDocumentProto, DOMDocumentProtoFunc, DOMNodeProto)
00751
00752 const ClassInfo DOMDocument::info = { "Document", &DOMNode::info, &DOMDocumentTable, 0 };
00753
00754
00755
00756
00757
00758
00759
00760
00761
00762
00763
00764
00765
00766
00767
00768 DOMDocument::DOMDocument(ExecState *exec, const DOM::Document& d)
00769 : DOMNode(DOMDocumentProto::self(exec), d) { }
00770
00771 DOMDocument::DOMDocument(const Object& proto, const DOM::Document& d)
00772 : DOMNode(proto, d) { }
00773
00774 DOMDocument::~DOMDocument()
00775 {
00776 ScriptInterpreter::forgetDOMObject(node.handle());
00777 }
00778
00779 Value DOMDocument::tryGet(ExecState *exec, const Identifier &propertyName) const
00780 {
00781 #ifdef KJS_VERBOSE
00782 kdDebug(6070) << "DOMDocument::tryGet " << propertyName.qstring() << endl;
00783 #endif
00784 return DOMObjectLookupGetValue<DOMDocument, DOMNode>(
00785 exec, propertyName, &DOMDocumentTable, this);
00786 }
00787
00788 Value DOMDocument::getValueProperty(ExecState *exec, int token) const
00789 {
00790 DOM::Document doc = static_cast<DOM::Document>(node);
00791
00792 switch(token) {
00793 case DocType:
00794 return getDOMNode(exec,doc.doctype());
00795 case Implementation:
00796 return getDOMDOMImplementation(exec,doc.implementation());
00797 case DocumentElement:
00798 return getDOMNode(exec,doc.documentElement());
00799 case StyleSheets:
00800
00801 return getDOMStyleSheetList(exec, doc.styleSheets(), doc);
00802 case DOMDocument::DefaultView:
00803 return getDOMAbstractView(exec, doc.defaultView());
00804 case PreferredStylesheetSet:
00805 return getString(doc.preferredStylesheetSet());
00806 case SelectedStylesheetSet:
00807 return getString(doc.selectedStylesheetSet());
00808 case ReadyState:
00809 {
00810 DOM::DocumentImpl* docimpl = node.handle()->getDocument();
00811 if ( docimpl && docimpl->view() )
00812 {
00813 KHTMLPart* part = docimpl->view()->part();
00814 if ( part ) {
00815 if (part->d->m_bComplete) return String("complete");
00816 if (docimpl->parsing()) return String("loading");
00817 return String("loaded");
00818
00819
00820 }
00821 }
00822 return Undefined();
00823 }
00824 case Async:
00825 return Boolean(doc.async());
00826 default:
00827 kdDebug(6070) << "WARNING: DOMDocument::getValueProperty unhandled token " << token << endl;
00828 return Value();
00829 }
00830 }
00831
00832 void DOMDocument::tryPut(ExecState *exec, const Identifier& propertyName, const Value& value, int attr)
00833 {
00834 #ifdef KJS_VERBOSE
00835 kdDebug(6070) << "DOMDocument::tryPut " << propertyName.qstring() << endl;
00836 #endif
00837 DOMObjectLookupPut<DOMDocument,DOMNode>(exec, propertyName, value, attr, &DOMDocumentTable, this );
00838 }
00839
00840 void DOMDocument::putValueProperty(ExecState *exec, int token, const Value& value, int )
00841 {
00842 DOM::Document doc = static_cast<DOM::Document>(node);
00843 switch (token) {
00844 case SelectedStylesheetSet: {
00845 doc.setSelectedStylesheetSet(value.toString(exec).string());
00846 break;
00847 }
00848 case Async: {
00849 doc.setAsync(value.toBoolean(exec));
00850 break;
00851 }
00852 }
00853 }
00854
00855 Value DOMDocumentProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00856 {
00857 KJS_CHECK_THIS( KJS::DOMDocument, thisObj );
00858 DOM::Node node = static_cast<DOMNode *>( thisObj.imp() )->toNode();
00859 DOM::Document doc = static_cast<DOM::Document>(node);
00860 String str = args[0].toString(exec);
00861 DOM::DOMString s = str.value().string();
00862
00863 switch(id) {
00864 case DOMDocument::CreateElement:
00865 return getDOMNode(exec,doc.createElement(s));
00866 case DOMDocument::CreateDocumentFragment:
00867 return getDOMNode(exec,doc.createDocumentFragment());
00868 case DOMDocument::CreateTextNode:
00869 return getDOMNode(exec,doc.createTextNode(s));
00870 case DOMDocument::CreateComment:
00871 return getDOMNode(exec,doc.createComment(s));
00872 case DOMDocument::CreateCDATASection:
00873 return getDOMNode(exec,doc.createCDATASection(s));
00874 case DOMDocument::CreateProcessingInstruction:
00875 return getDOMNode(exec,doc.createProcessingInstruction(args[0].toString(exec).string(),
00876 args[1].toString(exec).string()));
00877 case DOMDocument::CreateAttribute:
00878 return getDOMNode(exec,doc.createAttribute(s));
00879 case DOMDocument::CreateEntityReference:
00880 return getDOMNode(exec,doc.createEntityReference(args[0].toString(exec).string()));
00881 case DOMDocument::GetElementsByTagName:
00882 return getDOMNodeList(exec,doc.getElementsByTagName(s));
00883 case DOMDocument::ImportNode:
00884 return getDOMNode(exec,doc.importNode(toNode(args[0]), args[1].toBoolean(exec)));
00885 case DOMDocument::CreateElementNS:
00886 return getDOMNode(exec,doc.createElementNS(args[0].toString(exec).string(), args[1].toString(exec).string()));
00887 case DOMDocument::CreateAttributeNS:
00888 return getDOMNode(exec,doc.createAttributeNS(args[0].toString(exec).string(),args[1].toString(exec).string()));
00889 case DOMDocument::GetElementsByTagNameNS:
00890 return getDOMNodeList(exec,doc.getElementsByTagNameNS(args[0].toString(exec).string(),
00891 args[1].toString(exec).string()));
00892 case DOMDocument::GetElementById:
00893 #ifdef KJS_VERBOSE
00894 kdDebug(6070) << "DOMDocument::GetElementById looking for " << args[0].toString(exec).string() << endl;
00895 #endif
00896 return getDOMNode(exec,doc.getElementById(args[0].toString(exec).string()));
00897 case DOMDocument::CreateRange:
00898 return getDOMRange(exec,doc.createRange());
00899 case DOMDocument::CreateNodeIterator:
00900 if (args[2].isA(NullType)) {
00901 DOM::NodeFilter filter;
00902 return getDOMNodeIterator(exec,
00903 doc.createNodeIterator(toNode(args[0]),
00904 (long unsigned int)(args[1].toNumber(exec)),
00905 filter,args[3].toBoolean(exec)));
00906 }
00907 else {
00908 Object obj = Object::dynamicCast(args[2]);
00909 if (!obj.isNull())
00910 {
00911 DOM::CustomNodeFilter *customFilter = new JSNodeFilter(obj);
00912 DOM::NodeFilter filter = DOM::NodeFilter::createCustom(customFilter);
00913 return getDOMNodeIterator(exec,
00914 doc.createNodeIterator(
00915 toNode(args[0]),(long unsigned int)(args[1].toNumber(exec)),
00916 filter,args[3].toBoolean(exec)));
00917 }
00918 }
00919 case DOMDocument::CreateTreeWalker:
00920 return getDOMTreeWalker(exec,doc.createTreeWalker(toNode(args[0]),(long unsigned int)(args[1].toNumber(exec)),
00921 toNodeFilter(args[2]),args[3].toBoolean(exec)));
00922 case DOMDocument::CreateEvent:
00923 return getDOMEvent(exec,doc.createEvent(s));
00924 case DOMDocument::GetOverrideStyle: {
00925 DOM::Node arg0 = toNode(args[0]);
00926 if (arg0.nodeType() != DOM::Node::ELEMENT_NODE)
00927 return Undefined();
00928 else
00929 return getDOMCSSStyleDeclaration(exec,doc.getOverrideStyle(static_cast<DOM::Element>(arg0),args[1].toString(exec).string()));
00930 }
00931 case DOMDocument::Abort:
00932 doc.abort();
00933 break;
00934 case DOMDocument::Load: {
00935 Window* active = Window::retrieveActive(exec);
00936
00937
00938 if (active->part()) {
00939
00940 QString dstUrl = active->part()->htmlDocument().completeURL(s).string();
00941 KHTMLPart *part = static_cast<KJS::ScriptInterpreter*>(exec->interpreter())->part();
00942 if (part->url().host() == KURL(dstUrl).host()) {
00943 kdDebug(6070) << "JavaScript: access granted for document.load() of " << dstUrl << endl;
00944 doc.load(dstUrl);
00945 }
00946 else {
00947 kdDebug(6070) << "JavaScript: access denied for document.load() of " << dstUrl << endl;
00948 }
00949 }
00950 break;
00951 }
00952 case DOMDocument::LoadXML:
00953 doc.loadXML(s);
00954 break;
00955 default:
00956 break;
00957 }
00958
00959 return Undefined();
00960 }
00961
00962
00963
00964
00965
00966
00967
00968
00969
00970
00971
00972
00973
00974
00975
00976
00977
00978
00979
00980
00981
00982
00983 DEFINE_PROTOTYPE("DOMElement",DOMElementProto)
00984 IMPLEMENT_PROTOFUNC_DOM(DOMElementProtoFunc)
00985 IMPLEMENT_PROTOTYPE_WITH_PARENT(DOMElementProto,DOMElementProtoFunc,DOMNodeProto)
00986
00987 const ClassInfo DOMElement::info = { "Element", &DOMNode::info, &DOMElementTable, 0 };
00988
00989
00990
00991
00992
00993
00994 DOMElement::DOMElement(ExecState *exec, const DOM::Element& e)
00995 : DOMNode(DOMElementProto::self(exec), e) { }
00996
00997 DOMElement::DOMElement(const Object& proto, const DOM::Element& e)
00998 : DOMNode(proto, e) { }
00999
01000 Value DOMElement::tryGet(ExecState *exec, const Identifier &propertyName) const
01001 {
01002 #ifdef KJS_VERBOSE
01003 kdDebug(6070) << "DOMElement::tryGet " << propertyName.qstring() << endl;
01004 #endif
01005 DOM::Element element = static_cast<DOM::Element>(node);
01006
01007 const HashEntry* entry = Lookup::findEntry(&DOMElementTable, propertyName);
01008 if (entry)
01009 {
01010 switch( entry->value ) {
01011 case TagName:
01012 return getString(element.tagName());
01013 case Style:
01014 return getDOMCSSStyleDeclaration(exec,element.style());
01015 default:
01016 kdDebug(6070) << "WARNING: Unhandled token in DOMElement::tryGet : " << entry->value << endl;
01017 break;
01018 }
01019 }
01020
01021
01022
01023 if (DOMNode::hasProperty(exec, propertyName))
01024 return DOMNode::tryGet(exec, propertyName);
01025
01026 DOM::DOMString attr = element.getAttribute( propertyName.string() );
01027
01028 if ( !attr.isNull() )
01029 return getString( attr );
01030
01031 return Undefined();
01032 }
01033
01034 Value DOMElementProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
01035 {
01036 KJS_CHECK_THIS( KJS::DOMNode, thisObj );
01037 DOM::Node node = static_cast<DOMNode *>( thisObj.imp() )->toNode();
01038 DOM::Element element = static_cast<DOM::Element>(node);
01039
01040 switch(id) {
01041 case DOMElement::GetAttribute:
01042 return String(element.getAttribute(args[0].toString(exec).string()));
01043 case DOMElement::SetAttribute:
01044 element.setAttribute(args[0].toString(exec).string(),args[1].toString(exec).string());
01045 return Undefined();
01046 case DOMElement::RemoveAttribute:
01047 element.removeAttribute(args[0].toString(exec).string());
01048 return Undefined();
01049 case DOMElement::GetAttributeNode:
01050 return getDOMNode(exec,element.getAttributeNode(args[0].toString(exec).string()));
01051 case DOMElement::SetAttributeNode:
01052 return getDOMNode(exec,element.setAttributeNode((new DOMNode(exec,KJS::toNode(args[0])))->toNode()));
01053 case DOMElement::RemoveAttributeNode:
01054 return getDOMNode(exec,element.removeAttributeNode((new DOMNode(exec,KJS::toNode(args[0])))->toNode()));
01055 case DOMElement::GetElementsByTagName:
01056 return getDOMNodeList(exec,element.getElementsByTagName(args[0].toString(exec).string()));
01057 case DOMElement::HasAttribute:
01058 return Boolean(element.hasAttribute(args[0].toString(exec).string()));
01059 case DOMElement::GetAttributeNS:
01060 return String(element.getAttributeNS(args[0].toString(exec).string(),args[1].toString(exec).string()));
01061 case DOMElement::SetAttributeNS:
01062 element.setAttributeNS(args[0].toString(exec).string(),args[1].toString(exec).string(),args[2].toString(exec).string());
01063 return Undefined();
01064 case DOMElement::RemoveAttributeNS:
01065 element.removeAttributeNS(args[0].toString(exec).string(),args[1].toString(exec).string());
01066 return Undefined();
01067 case DOMElement::GetAttributeNodeNS:
01068 return getDOMNode(exec,element.getAttributeNodeNS(args[0].toString(exec).string(),args[1].toString(exec).string()));
01069 case DOMElement::SetAttributeNodeNS:
01070 return getDOMNode(exec,element.setAttributeNodeNS((new DOMNode(exec,KJS::toNode(args[0])))->toNode()));
01071 case DOMElement::GetElementsByTagNameNS:
01072 return getDOMNodeList(exec,element.getElementsByTagNameNS(args[0].toString(exec).string(),args[1].toString(exec).string()));
01073 case DOMElement::HasAttributeNS:
01074 return Boolean(element.hasAttributeNS(args[0].toString(exec).string(),args[1].toString(exec).string()));
01075 default:
01076 return Undefined();
01077 }
01078 }
01079
01080
01081
01082
01083
01084
01085
01086
01087
01088
01089
01090
01091
01092 DEFINE_PROTOTYPE("DOMImplementation",DOMDOMImplementationProto)
01093 IMPLEMENT_PROTOFUNC_DOM(DOMDOMImplementationProtoFunc)
01094 IMPLEMENT_PROTOTYPE(DOMDOMImplementationProto,DOMDOMImplementationProtoFunc)
01095
01096 const ClassInfo DOMDOMImplementation::info = { "DOMImplementation", 0, 0, 0 };
01097
01098 DOMDOMImplementation::DOMDOMImplementation(ExecState *exec, const DOM::DOMImplementation& i)
01099 : DOMObject(DOMDOMImplementationProto::self(exec)), implementation(i) { }
01100
01101 DOMDOMImplementation::~DOMDOMImplementation()
01102 {
01103 ScriptInterpreter::forgetDOMObject(implementation.handle());
01104 }
01105
01106 Value DOMDOMImplementationProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
01107 {
01108 KJS_CHECK_THIS( KJS::DOMDOMImplementation, thisObj );
01109 DOM::DOMImplementation implementation = static_cast<DOMDOMImplementation *>( thisObj.imp() )->toImplementation();
01110
01111 switch(id) {
01112 case DOMDOMImplementation::HasFeature:
01113 return Boolean(implementation.hasFeature(args[0].toString(exec).string(),args[1].toString(exec).string()));
01114 case DOMDOMImplementation::CreateDocumentType:
01115 return getDOMNode(exec,implementation.createDocumentType(args[0].toString(exec).string(),args[1].toString(exec).string(),args[2].toString(exec).string()));
01116 case DOMDOMImplementation::CreateDocument: {
01117
01118
01119 Document doc = implementation.createDocument(args[0].toString(exec).string(),args[1].toString(exec).string(),toNode(args[2]));
01120 KHTMLPart *part = static_cast<KJS::ScriptInterpreter*>(exec->interpreter())->part();
01121 KURL url = static_cast<DocumentImpl*>(part->document().handle())->URL();
01122 static_cast<DocumentImpl*>(doc.handle())->setURL(url.url());
01123 return getDOMNode(exec,doc);
01124 }
01125 case DOMDOMImplementation::CreateCSSStyleSheet:
01126 return getDOMStyleSheet(exec,implementation.createCSSStyleSheet(args[0].toString(exec).string(),args[1].toString(exec).string()));
01127 case DOMDOMImplementation::CreateHTMLDocument:
01128 return getDOMNode(exec, implementation.createHTMLDocument(args[0].toString(exec).string()));
01129 default:
01130 break;
01131 }
01132 return Undefined();
01133 }
01134
01135
01136
01137 const ClassInfo DOMDocumentType::info = { "DocumentType", &DOMNode::info, &DOMDocumentTypeTable, 0 };
01138
01139
01140
01141
01142
01143
01144
01145
01146
01147
01148
01149
01150 DOMDocumentType::DOMDocumentType(ExecState *exec, const DOM::DocumentType& dt)
01151 : DOMNode( exec, dt ) { }
01152
01153 Value DOMDocumentType::tryGet(ExecState *exec, const Identifier &propertyName) const
01154 {
01155 return DOMObjectLookupGetValue<DOMDocumentType, DOMNode>(exec, propertyName, &DOMDocumentTypeTable, this);
01156 }
01157
01158 Value DOMDocumentType::getValueProperty(ExecState *exec, int token) const
01159 {
01160 DOM::DocumentType type = static_cast<DOM::DocumentType>(node);
01161 switch (token) {
01162 case Name:
01163 return String(type.name());
01164 case Entities:
01165 return getDOMNamedNodeMap(exec,type.entities());
01166 case Notations:
01167 return getDOMNamedNodeMap(exec,type.notations());
01168 case PublicId:
01169 return getString(type.publicId());
01170 case SystemId:
01171 return getString(type.systemId());
01172 case InternalSubset:
01173 return getString(type.internalSubset());
01174 default:
01175 kdDebug(6070) << "WARNING: DOMDocumentType::getValueProperty unhandled token " << token << endl;
01176 return Value();
01177 }
01178 }
01179
01180
01181
01182
01183
01184
01185
01186
01187
01188
01189
01190
01191
01192
01193
01194 DEFINE_PROTOTYPE("NamedNodeMap", DOMNamedNodeMapProto)
01195 IMPLEMENT_PROTOFUNC_DOM(DOMNamedNodeMapProtoFunc)
01196 IMPLEMENT_PROTOTYPE(DOMNamedNodeMapProto,DOMNamedNodeMapProtoFunc)
01197
01198 const ClassInfo DOMNamedNodeMap::info = { "NamedNodeMap", 0, 0, 0 };
01199
01200 DOMNamedNodeMap::DOMNamedNodeMap(ExecState *exec, const DOM::NamedNodeMap& m)
01201 : DOMObject(DOMNamedNodeMapProto::self(exec)), map(m) { }
01202
01203 DOMNamedNodeMap::~DOMNamedNodeMap()
01204 {
01205 ScriptInterpreter::forgetDOMObject(map.handle());
01206 }
01207
01208
01209
01210 bool DOMNamedNodeMap::hasProperty(ExecState *exec, const Identifier &p) const
01211 {
01212 if (p == lengthPropertyName)
01213 return true;
01214
01215 return DOMObject::hasProperty(exec, p);
01216 }
01217
01218 Value DOMNamedNodeMap::tryGet(ExecState* exec, const Identifier &p) const
01219 {
01220 if (p == lengthPropertyName)
01221 return Number(map.length());
01222
01223
01224 bool ok;
01225 long unsigned int idx = p.toULong(&ok);
01226 if (ok)
01227 return getDOMNode(exec,map.item(idx));
01228
01229
01230 return DOMObject::tryGet(exec, p);
01231 }
01232
01233 Value DOMNamedNodeMapProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
01234 {
01235 KJS_CHECK_THIS( KJS::DOMNamedNodeMap, thisObj );
01236 DOM::NamedNodeMap map = static_cast<DOMNamedNodeMap *>(thisObj.imp())->toMap();
01237
01238 switch(id) {
01239 case DOMNamedNodeMap::GetNamedItem:
01240 return getDOMNode(exec, map.getNamedItem(args[0].toString(exec).string()));
01241 case DOMNamedNodeMap::SetNamedItem:
01242 return getDOMNode(exec, map.setNamedItem((new DOMNode(exec,KJS::toNode(args[0])))->toNode()));
01243 case DOMNamedNodeMap::RemoveNamedItem:
01244 return getDOMNode(exec, map.removeNamedItem(args[0].toString(exec).string()));
01245 case DOMNamedNodeMap::Item:
01246 return getDOMNode(exec, map.item(args[0].toInt32(exec)));
01247 case DOMNamedNodeMap::GetNamedItemNS:
01248 return getDOMNode(exec, map.getNamedItemNS(args[0].toString(exec).string(),args[1].toString(exec).string()));
01249 case DOMNamedNodeMap::SetNamedItemNS:
01250 return getDOMNode(exec, map.setNamedItemNS(toNode(args[0])));
01251 case DOMNamedNodeMap::RemoveNamedItemNS:
01252 return getDOMNode(exec, map.removeNamedItemNS(args[0].toString(exec).string(),args[1].toString(exec).string()));
01253 default:
01254 break;
01255 }
01256
01257 return Undefined();
01258 }
01259
01260
01261
01262 const ClassInfo DOMProcessingInstruction::info = { "ProcessingInstruction", &DOMNode::info, &DOMProcessingInstructionTable, 0 };
01263
01264
01265
01266
01267
01268
01269
01270
01271 Value DOMProcessingInstruction::tryGet(ExecState *exec, const Identifier &propertyName) const
01272 {
01273 return DOMObjectLookupGetValue<DOMProcessingInstruction, DOMNode>(exec, propertyName, &DOMProcessingInstructionTable, this);
01274 }
01275
01276 Value DOMProcessingInstruction::getValueProperty(ExecState *exec, int token) const
01277 {
01278 switch (token) {
01279 case Target:
01280 return getString(static_cast<DOM::ProcessingInstruction>(node).target());
01281 case Data:
01282 return getString(static_cast<DOM::ProcessingInstruction>(node).data());
01283 case Sheet:
01284 return getDOMStyleSheet(exec,static_cast<DOM::ProcessingInstruction>(node).sheet());
01285 default:
01286 kdDebug(6070) << "WARNING: DOMProcessingInstruction::getValueProperty unhandled token " << token << endl;
01287 return Value();
01288 }
01289 }
01290
01291 void DOMProcessingInstruction::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr)
01292 {
01293
01294 if (propertyName == "data")
01295 static_cast<DOM::ProcessingInstruction>(node).setData(value.toString(exec).string());
01296 else
01297 DOMNode::tryPut(exec, propertyName,value,attr);
01298 }
01299
01300
01301
01302 const ClassInfo DOMNotation::info = { "Notation", &DOMNode::info, &DOMNotationTable, 0 };
01303
01304
01305
01306
01307
01308
01309
01310 Value DOMNotation::tryGet(ExecState *exec, const Identifier &propertyName) const
01311 {
01312 return DOMObjectLookupGetValue<DOMNotation, DOMNode>(exec, propertyName, &DOMNotationTable, this);
01313 }
01314
01315 Value DOMNotation::getValueProperty(ExecState *, int token) const
01316 {
01317 switch (token) {
01318 case PublicId:
01319 return getString(static_cast<DOM::Notation>(node).publicId());
01320 case SystemId:
01321 return getString(static_cast<DOM::Notation>(node).systemId());
01322 default:
01323 kdDebug(6070) << "WARNING: DOMNotation::getValueProperty unhandled token " << token << endl;
01324 return Value();
01325 }
01326 }
01327
01328
01329
01330 const ClassInfo DOMEntity::info = { "Entity", &DOMNode::info, 0, 0 };
01331
01332
01333
01334
01335
01336
01337
01338
01339 Value DOMEntity::tryGet(ExecState *exec, const Identifier &propertyName) const
01340 {
01341 return DOMObjectLookupGetValue<DOMEntity, DOMNode>(exec, propertyName, &DOMEntityTable, this);
01342 }
01343
01344 Value DOMEntity::getValueProperty(ExecState *, int token) const
01345 {
01346 switch (token) {
01347 case PublicId:
01348 return getString(static_cast<DOM::Entity>(node).publicId());
01349 case SystemId:
01350 return getString(static_cast<DOM::Entity>(node).systemId());
01351 case NotationName:
01352 return getString(static_cast<DOM::Entity>(node).notationName());
01353 default:
01354 kdDebug(6070) << "WARNING: DOMEntity::getValueProperty unhandled token " << token << endl;
01355 return Value();
01356 }
01357 }
01358
01359
01360
01361 bool KJS::checkNodeSecurity(ExecState *exec, const DOM::Node& n)
01362 {
01363
01364 if (n.isNull())
01365 return true;
01366 KHTMLView *view = n.handle()->getDocument()->view();
01367 Window* win = view && view->part() ? Window::retrieveWindow(view->part()) : 0L;
01368 if ( !win || !win->isSafeScript(exec) )
01369 return false;
01370 return true;
01371 }
01372
01373 Value KJS::getDOMNode(ExecState *exec, const DOM::Node& n)
01374 {
01375 DOMObject *ret = 0;
01376 if (n.isNull())
01377 return Null();
01378 ScriptInterpreter* interp = static_cast<ScriptInterpreter *>(exec->interpreter());
01379 if ((ret = interp->getDOMObject(n.handle())))
01380 return Value(ret);
01381
01382 switch (n.nodeType()) {
01383 case DOM::Node::ELEMENT_NODE:
01384 if (static_cast<DOM::Element>(n).isHTMLElement())
01385 ret = new HTMLElement(exec, static_cast<DOM::HTMLElement>(n));
01386 else
01387 ret = new DOMElement(exec, static_cast<DOM::Element>(n));
01388 break;
01389 case DOM::Node::ATTRIBUTE_NODE:
01390 ret = new DOMAttr(exec, static_cast<DOM::Attr>(n));
01391 break;
01392 case DOM::Node::TEXT_NODE:
01393 case DOM::Node::CDATA_SECTION_NODE:
01394 ret = new DOMText(exec, static_cast<DOM::Text>(n));
01395 break;
01396 case DOM::Node::ENTITY_REFERENCE_NODE:
01397 ret = new DOMNode(exec, n);
01398 break;
01399 case DOM::Node::ENTITY_NODE:
01400 ret = new DOMEntity(exec, static_cast<DOM::Entity>(n));
01401 break;
01402 case DOM::Node::PROCESSING_INSTRUCTION_NODE:
01403 ret = new DOMProcessingInstruction(exec, static_cast<DOM::ProcessingInstruction>(n));
01404 break;
01405 case DOM::Node::COMMENT_NODE:
01406 ret = new DOMCharacterData(exec, static_cast<DOM::CharacterData>(n));
01407 break;
01408 case DOM::Node::DOCUMENT_NODE:
01409 if (static_cast<DOM::Document>(n).isHTMLDocument())
01410 ret = new HTMLDocument(exec, static_cast<DOM::HTMLDocument>(n));
01411 else
01412 ret = new DOMDocument(exec, static_cast<DOM::Document>(n));
01413 break;
01414 case DOM::Node::DOCUMENT_TYPE_NODE:
01415 ret = new DOMDocumentType(exec, static_cast<DOM::DocumentType>(n));
01416 break;
01417 case DOM::Node::DOCUMENT_FRAGMENT_NODE:
01418 ret = new DOMNode(exec, n);
01419 break;
01420 case DOM::Node::NOTATION_NODE:
01421 ret = new DOMNotation(exec, static_cast<DOM::Notation>(n));
01422 break;
01423 default:
01424 ret = new DOMNode(exec, n);
01425 }
01426 interp->putDOMObject(n.handle(),ret);
01427
01428 return Value(ret);
01429 }
01430
01431 Value KJS::getDOMNamedNodeMap(ExecState *exec, const DOM::NamedNodeMap& m)
01432 {
01433 return Value(cacheDOMObject<DOM::NamedNodeMap, KJS::DOMNamedNodeMap>(exec, m));
01434 }
01435
01436 Value KJS::getDOMNodeList(ExecState *exec, const DOM::NodeList& l)
01437 {
01438 return Value(cacheDOMObject<DOM::NodeList, KJS::DOMNodeList>(exec, l));
01439 }
01440
01441 Value KJS::getDOMDOMImplementation(ExecState *exec, const DOM::DOMImplementation& i)
01442 {
01443 return Value(cacheDOMObject<DOM::DOMImplementation, KJS::DOMDOMImplementation>(exec, i));
01444 }
01445
01446
01447
01448 const ClassInfo NodeConstructor::info = { "NodeConstructor", 0, &NodeConstructorTable, 0 };
01449
01450
01451
01452
01453
01454
01455
01456
01457
01458
01459
01460
01461
01462
01463
01464
01465
01466 NodeConstructor::NodeConstructor(ExecState *exec)
01467 : DOMObject(exec->interpreter()->builtinObjectPrototype())
01468 {
01469 }
01470
01471 Value NodeConstructor::tryGet(ExecState *exec, const Identifier &propertyName) const
01472 {
01473 return DOMObjectLookupGetValue<NodeConstructor, DOMObject>(exec, propertyName, &NodeConstructorTable, this);
01474 }
01475
01476 Value NodeConstructor::getValueProperty(ExecState *, int token) const
01477 {
01478
01479 return Number((unsigned int)token);
01480 #if 0
01481 switch (token) {
01482 case ELEMENT_NODE:
01483 return Number((unsigned int)DOM::Node::ELEMENT_NODE);
01484 case ATTRIBUTE_NODE:
01485 return Number((unsigned int)DOM::Node::ATTRIBUTE_NODE);
01486 case TEXT_NODE:
01487 return Number((unsigned int)DOM::Node::TEXT_NODE);
01488 case CDATA_SECTION_NODE:
01489 return Number((unsigned int)DOM::Node::CDATA_SECTION_NODE);
01490 case ENTITY_REFERENCE_NODE:
01491 return Number((unsigned int)DOM::Node::ENTITY_REFERENCE_NODE);
01492 case ENTITY_NODE:
01493 return Number((unsigned int)DOM::Node::ENTITY_NODE);
01494 case PROCESSING_INSTRUCTION_NODE:
01495 return Number((unsigned int)DOM::Node::PROCESSING_INSTRUCTION_NODE);
01496 case COMMENT_NODE:
01497 return Number((unsigned int)DOM::Node::COMMENT_NODE);
01498 case DOCUMENT_NODE:
01499 return Number((unsigned int)DOM::Node::DOCUMENT_NODE);
01500 case DOCUMENT_TYPE_NODE:
01501 return Number((unsigned int)DOM::Node::DOCUMENT_TYPE_NODE);
01502 case DOCUMENT_FRAGMENT_NODE:
01503 return Number((unsigned int)DOM::Node::DOCUMENT_FRAGMENT_NODE);
01504 case NOTATION_NODE:
01505 return Number((unsigned int)DOM::Node::NOTATION_NODE);
01506 default:
01507 kdDebug(6070) << "WARNING: NodeConstructor::getValueProperty unhandled token " << token << endl;
01508 return Value();
01509 }
01510 #endif
01511 }
01512
01513 Object KJS::getNodeConstructor(ExecState *exec)
01514 {
01515 return Object(cacheGlobalObject<NodeConstructor>(exec, "[[node.constructor]]"));
01516 }
01517
01518
01519
01520 const ClassInfo DOMExceptionConstructor::info = { "DOMExceptionConstructor", 0, 0, 0 };
01521
01522
01523
01524
01525
01526
01527
01528
01529
01530
01531
01532
01533
01534
01535
01536
01537
01538
01539
01540
01541
01542 DOMExceptionConstructor::DOMExceptionConstructor(ExecState* exec)
01543 : DOMObject(exec->interpreter()->builtinObjectPrototype())
01544 {
01545 }
01546
01547 Value DOMExceptionConstructor::tryGet(ExecState *exec, const Identifier &propertyName) const
01548 {
01549 return DOMObjectLookupGetValue<DOMExceptionConstructor, DOMObject>(exec, propertyName, &DOMExceptionConstructorTable, this);
01550 }
01551
01552 Value DOMExceptionConstructor::getValueProperty(ExecState *, int token) const
01553 {
01554
01555 return Number((unsigned int)token);
01556 #if 0
01557 switch (token) {
01558 case INDEX_SIZE_ERR:
01559 return Number((unsigned int)DOM::DOMException::INDEX_SIZE_ERR);
01560 case DOMSTRING_SIZE_ERR:
01561 return Number((unsigned int)DOM::DOMException::DOMSTRING_SIZE_ERR);
01562 case HIERARCHY_REQUEST_ERR:
01563 return Number((unsigned int)DOM::DOMException::HIERARCHY_REQUEST_ERR);
01564 case WRONG_DOCUMENT_ERR:
01565 return Number((unsigned int)DOM::DOMException::WRONG_DOCUMENT_ERR);
01566 case INVALID_CHARACTER_ERR:
01567 return Number((unsigned int)DOM::DOMException::INVALID_CHARACTER_ERR);
01568 case NO_DATA_ALLOWED_ERR:
01569 return Number((unsigned int)DOM::DOMException::NO_DATA_ALLOWED_ERR);
01570 case NO_MODIFICATION_ALLOWED_ERR:
01571 return Number((unsigned int)DOM::DOMException::NO_MODIFICATION_ALLOWED_ERR);
01572 case NOT_FOUND_ERR:
01573 return Number((unsigned int)DOM::DOMException::NOT_FOUND_ERR);
01574 case NOT_SUPPORTED_ERR:
01575 return Number((unsigned int)DOM::DOMException::NOT_SUPPORTED_ERR);
01576 case INUSE_ATTRIBUTE_ERR:
01577 return Number((unsigned int)DOM::DOMException::INUSE_ATTRIBUTE_ERR);
01578 case INVALID_STATE_ERR:
01579 return Number((unsigned int)DOM::DOMException::INVALID_STATE_ERR);
01580 case SYNTAX_ERR:
01581 return Number((unsigned int)DOM::DOMException::SYNTAX_ERR);
01582 case INVALID_MODIFICATION_ERR:
01583 return Number((unsigned int)DOM::DOMException::INVALID_MODIFICATION_ERR);
01584 case NAMESPACE_ERR:
01585 return Number((unsigned int)DOM::DOMException::NAMESPACE_ERR);
01586 case INVALID_ACCESS_ERR:
01587 return Number((unsigned int)DOM::DOMException::INVALID_ACCESS_ERR);
01588 default:
01589 kdDebug(6070) << "WARNING: DOMExceptionConstructor::getValueProperty unhandled token " << token << endl;
01590 return Value();
01591 }
01592 #endif
01593 }
01594
01595 Object KJS::getDOMExceptionConstructor(ExecState *exec)
01596 {
01597 return cacheGlobalObject<DOMExceptionConstructor>(exec, "[[DOMException.constructor]]");
01598 }
01599
01600
01601
01602 const ClassInfo KJS::DOMNamedNodesCollection::info = { "DOMNamedNodesCollection", 0, 0, 0 };
01603
01604
01605
01606
01607 DOMNamedNodesCollection::DOMNamedNodesCollection(ExecState *exec, const QValueList<DOM::Node>& nodes )
01608 : DOMObject(exec->interpreter()->builtinObjectPrototype()),
01609 m_nodes(nodes)
01610 {
01611
01612 }
01613
01614 Value DOMNamedNodesCollection::tryGet(ExecState *exec, const Identifier &propertyName) const
01615 {
01616 kdDebug(6070) << k_funcinfo << propertyName.ascii() << endl;
01617 if (propertyName == lengthPropertyName)
01618 return Number(m_nodes.count());
01619
01620 bool ok;
01621 unsigned int u = propertyName.toULong(&ok);
01622 if (ok && u < m_nodes.count()) {
01623 DOM::Node node = m_nodes[u];
01624 return getDOMNode(exec,node);
01625 }
01626 return DOMObject::tryGet(exec,propertyName);
01627 }
01628
01629
01630
01631 const ClassInfo DOMCharacterData::info = { "CharacterImp",
01632 &DOMNode::info, &DOMCharacterDataTable, 0 };
01633
01634
01635
01636
01637
01638
01639
01640
01641
01642
01643
01644
01645
01646 DEFINE_PROTOTYPE("DOMCharacterData",DOMCharacterDataProto)
01647 IMPLEMENT_PROTOFUNC_DOM(DOMCharacterDataProtoFunc)
01648 IMPLEMENT_PROTOTYPE_WITH_PARENT(DOMCharacterDataProto,DOMCharacterDataProtoFunc, DOMNodeProto)
01649
01650 DOMCharacterData::DOMCharacterData(ExecState *exec, const DOM::CharacterData& d)
01651 : DOMNode(DOMCharacterDataProto::self(exec), d) {}
01652
01653 DOMCharacterData::DOMCharacterData(const Object& proto, const DOM::CharacterData& d)
01654 : DOMNode(proto, d) {}
01655
01656 Value DOMCharacterData::tryGet(ExecState *exec, const Identifier &p) const
01657 {
01658 #ifdef KJS_VERBOSE
01659 kdDebug(6070)<<"DOMCharacterData::tryGet "<<p.string().string()<<endl;
01660 #endif
01661 return DOMObjectLookupGetValue<DOMCharacterData,DOMNode>(exec,p,&DOMCharacterDataTable,this);
01662 }
01663
01664 Value DOMCharacterData::getValueProperty(ExecState *, int token) const
01665 {
01666 DOM::CharacterData data = static_cast<DOM::CharacterData>(node);
01667 switch (token) {
01668 case Data:
01669 return String(data.data());
01670 case Length:
01671 return Number(data.length());
01672 default:
01673 kdDebug(6070) << "WARNING: Unhandled token in DOMCharacterData::getValueProperty : " << token << endl;
01674 return Value();
01675 }
01676 }
01677
01678 void DOMCharacterData::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr)
01679 {
01680 if (propertyName == "data")
01681 static_cast<DOM::CharacterData>(node).setData(value.toString(exec).string());
01682 else
01683 DOMNode::tryPut(exec, propertyName,value,attr);
01684 }
01685
01686 Value DOMCharacterDataProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
01687 {
01688 KJS_CHECK_THIS( KJS::DOMCharacterData, thisObj );
01689 DOM::CharacterData data = static_cast<DOMCharacterData *>(thisObj.imp())->toData();
01690 switch(id) {
01691 case DOMCharacterData::SubstringData:
01692 return getString(data.substringData(args[0].toInteger(exec),args[1].toInteger(exec)));
01693 case DOMCharacterData::AppendData:
01694 data.appendData(args[0].toString(exec).string());
01695 return Undefined();
01696 break;
01697 case DOMCharacterData::InsertData:
01698 data.insertData(args[0].toInteger(exec),args[1].toString(exec).string());
01699 return Undefined();
01700 break;
01701 case DOMCharacterData::DeleteData:
01702 data.deleteData(args[0].toInteger(exec),args[1].toInteger(exec));
01703 return Undefined();
01704 break;
01705 case DOMCharacterData::ReplaceData:
01706 data.replaceData(args[0].toInteger(exec),args[1].toInteger(exec),args[2].toString(exec).string());
01707 return Undefined();
01708 break;
01709 default:
01710 return Undefined();
01711 }
01712 }
01713
01714
01715
01716 const ClassInfo DOMText::info = { "Text",
01717 &DOMCharacterData::info, 0, 0 };
01718
01719
01720
01721
01722
01723 DEFINE_PROTOTYPE("DOMText",DOMTextProto)
01724 IMPLEMENT_PROTOFUNC_DOM(DOMTextProtoFunc)
01725 IMPLEMENT_PROTOTYPE_WITH_PARENT(DOMTextProto,DOMTextProtoFunc,DOMCharacterDataProto)
01726
01727 DOMText::DOMText(ExecState *exec, const DOM::Text& t)
01728 : DOMCharacterData(DOMTextProto::self(exec), t) { }
01729
01730 Value DOMText::tryGet(ExecState *exec, const Identifier &p) const
01731 {
01732 if (p.isEmpty())
01733 return Undefined();
01734 else
01735 return DOMCharacterData::tryGet(exec, p);
01736 }
01737
01738 Value DOMTextProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
01739 {
01740 KJS_CHECK_THIS( KJS::DOMText, thisObj );
01741 DOM::Text text = static_cast<DOMText *>(thisObj.imp())->toText();
01742 switch(id) {
01743 case DOMText::SplitText:
01744 return getDOMNode(exec,text.splitText(args[0].toInteger(exec)));
01745 break;
01746 default:
01747 return Undefined();
01748 }
01749 }
01750