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