00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include "kjs_window.h"
00023 #include "kjs_events.h"
00024 #include "kjs_events.lut.h"
00025 #include "kjs_views.h"
00026 #include "kjs_proxy.h"
00027 #include "xml/dom_nodeimpl.h"
00028 #include "xml/dom_docimpl.h"
00029 #include "xml/dom2_eventsimpl.h"
00030 #include "rendering/render_object.h"
00031 #include "xml/dom2_eventsimpl.h"
00032
00033 #include <kdebug.h>
00034
00035 using namespace KJS;
00036 using namespace DOM;
00037
00038
00039
00040 JSEventListener::JSEventListener(Object _listener, const Object &_win, bool _html)
00041 : listener( _listener ), html( _html ), win( _win )
00042 {
00043
00044 static_cast<Window*>(win.imp())->jsEventListeners.insert(this, this);
00045 }
00046
00047 JSEventListener::~JSEventListener()
00048 {
00049 static_cast<Window*>(win.imp())->jsEventListeners.remove(this);
00050
00051 }
00052
00053 void JSEventListener::handleEvent(DOM::Event &evt)
00054 {
00055 #ifdef KJS_DEBUGGER
00056 if (KJSDebugWin::debugWindow() && KJSDebugWin::debugWindow()->inSession())
00057 return;
00058 #endif
00059 KHTMLPart *part = static_cast<Window*>(win.imp())->part();
00060 KJSProxy *proxy = 0L;
00061 if (part)
00062 proxy = KJSProxy::proxy( part );
00063
00064 if (proxy && listener.implementsCall()) {
00065 ref();
00066
00067 KJS::ScriptInterpreter *interpreter = static_cast<KJS::ScriptInterpreter *>(proxy->interpreter());
00068 ExecState *exec = interpreter->globalExec();
00069
00070 List args;
00071 args.append(getDOMEvent(exec,evt));
00072
00073
00074 Object thisObj = Object::dynamicCast(getDOMNode(exec,evt.currentTarget()));
00075 ScopeChain oldScope = listener.scope();
00076 if ( thisObj.isValid() ) {
00077 ScopeChain scope = oldScope;
00078
00079
00080 static_cast<DOMNode*>(thisObj.imp())->pushEventHandlerScope(exec, scope);
00081 listener.setScope( scope );
00082 }
00083 else {
00084 if ( m_hackThisObj.isValid() ) {
00085 thisObj = m_hackThisObj;
00086 }
00087 else
00088 {
00089
00090
00091 thisObj = win;
00092 }
00093 }
00094
00095 Window *window = static_cast<Window*>(win.imp());
00096
00097 window->setCurrentEvent( &evt );
00098
00099 interpreter->setCurrentEvent( &evt );
00100
00101 KJSCPUGuard guard;
00102 guard.start();
00103 Value retval = listener.call(exec, thisObj, args);
00104 guard.stop();
00105
00106 listener.setScope( oldScope );
00107
00108 window->setCurrentEvent( 0 );
00109 interpreter->setCurrentEvent( 0 );
00110 if ( exec->hadException() )
00111 exec->clearException();
00112 else
00113 {
00114 QVariant ret = ValueToVariant(exec, retval);
00115 if (ret.type() == QVariant::Bool && ret.toBool() == false)
00116 evt.preventDefault();
00117 }
00118 window->afterScriptExecution();
00119 deref();
00120 }
00121 }
00122
00123 DOM::DOMString JSEventListener::eventListenerType()
00124 {
00125 if (html)
00126 return "_khtml_HTMLEventListener";
00127 else
00128 return "_khtml_JSEventListener";
00129 }
00130
00131 Value KJS::getNodeEventListener(DOM::Node n, int eventId)
00132 {
00133 DOM::EventListener *listener = n.handle()->getHTMLEventListener(eventId);
00134 if (listener)
00135 return static_cast<JSEventListener*>(listener)->listenerObj();
00136 else
00137 return Null();
00138 }
00139
00140
00141
00142 const ClassInfo EventConstructor::info = { "EventConstructor", 0, &EventConstructorTable, 0 };
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168 EventConstructor::EventConstructor(ExecState *exec)
00169 : DOMObject(exec->interpreter()->builtinObjectPrototype())
00170 {
00171 }
00172
00173 Value EventConstructor::tryGet(ExecState *exec, const Identifier &p) const
00174 {
00175 return DOMObjectLookupGetValue<EventConstructor, DOMObject>(exec,p,&EventConstructorTable,this);
00176 }
00177
00178 Value EventConstructor::getValueProperty(ExecState *, int token) const
00179 {
00180
00181 return Number(token);
00182 }
00183
00184 Value KJS::getEventConstructor(ExecState *exec)
00185 {
00186 return cacheGlobalObject<EventConstructor>(exec, "[[event.constructor]]");
00187 }
00188
00189
00190
00191 const ClassInfo DOMEvent::info = { "Event", 0, &DOMEventTable, 0 };
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211 DEFINE_PROTOTYPE("DOMEvent", DOMEventProto)
00212 IMPLEMENT_PROTOFUNC_DOM(DOMEventProtoFunc)
00213 IMPLEMENT_PROTOTYPE(DOMEventProto, DOMEventProtoFunc)
00214
00215 DOMEvent::DOMEvent(ExecState *exec, DOM::Event e)
00216 : DOMObject(DOMEventProto::self(exec)), event(e) { }
00217
00218 DOMEvent::DOMEvent(const Object &proto, DOM::Event e)
00219 : DOMObject(proto), event(e) { }
00220
00221 DOMEvent::~DOMEvent()
00222 {
00223 ScriptInterpreter::forgetDOMObject(event.handle());
00224 }
00225
00226 Value DOMEvent::tryGet(ExecState *exec, const Identifier &p) const
00227 {
00228 #ifdef KJS_VERBOSE
00229 kdDebug() << "KJS::DOMEvent::tryGet " << p.qstring() << endl;
00230 #endif
00231 return DOMObjectLookupGetValue<DOMEvent,DOMObject>(exec, p, &DOMEventTable, this );
00232 }
00233
00234 Value DOMEvent::getValueProperty(ExecState *exec, int token) const
00235 {
00236 switch (token) {
00237 case Type:
00238 return String(event.type());
00239 case Target:
00240 case SrcElement:
00241 return getDOMNode(exec,event.target());
00242 case CurrentTarget:
00243 return getDOMNode(exec,event.currentTarget());
00244 case EventPhase:
00245 return Number((unsigned int)event.eventPhase());
00246 case Bubbles:
00247 return Boolean(event.bubbles());
00248 case Cancelable:
00249 return Boolean(event.cancelable());
00250 case TimeStamp:
00251 return Number((long unsigned int)event.timeStamp());
00252 case ReturnValue:
00253 return Boolean(event.handle()->defaultPrevented());
00254 case CancelBubble:
00255 return Boolean(event.handle()->propagationStopped());
00256 default:
00257 kdDebug(6070) << "WARNING: Unhandled token in DOMEvent::getValueProperty : " << token << endl;
00258 return Value();
00259 }
00260 }
00261
00262 Value DOMEvent::defaultValue(ExecState *exec, KJS::Type hint) const
00263 {
00264 if (event.handle()->id() == EventImpl::ERROR_EVENT && !event.handle()->message().isNull()) {
00265 return String(event.handle()->message());
00266 }
00267 else
00268 return DOMObject::defaultValue(exec,hint);
00269 }
00270
00271 void DOMEvent::tryPut(ExecState *exec, const Identifier &propertyName,
00272 const Value& value, int attr)
00273 {
00274 DOMObjectLookupPut<DOMEvent, DOMObject>(exec, propertyName, value, attr,
00275 &DOMEventTable, this);
00276 }
00277
00278 void DOMEvent::putValueProperty(ExecState *exec, int token, const Value& value, int)
00279 {
00280 switch (token) {
00281 case ReturnValue:
00282
00283
00284 event.handle()->preventDefault(!value.toBoolean(exec));
00285 break;
00286 case CancelBubble:
00287 event.handle()->stopPropagation(value.toBoolean(exec));
00288 break;
00289 default:
00290 break;
00291 }
00292 }
00293
00294 Value DOMEventProtoFunc::tryCall(ExecState *exec, Object & thisObj, const List &args)
00295 {
00296 KJS_CHECK_THIS( KJS::DOMEvent, thisObj );
00297 DOM::Event event = static_cast<DOMEvent *>( thisObj.imp() )->toEvent();
00298 switch (id) {
00299 case DOMEvent::StopPropagation:
00300 event.stopPropagation();
00301 return Undefined();
00302 case DOMEvent::PreventDefault:
00303 event.preventDefault();
00304 return Undefined();
00305 case DOMEvent::InitEvent:
00306 event.initEvent(args[0].toString(exec).string(),args[1].toBoolean(exec),args[2].toBoolean(exec));
00307 return Undefined();
00308 };
00309 return Undefined();
00310 }
00311
00312 Value KJS::getDOMEvent(ExecState *exec, DOM::Event e)
00313 {
00314 DOMObject *ret;
00315 if (e.isNull())
00316 return Null();
00317 ScriptInterpreter* interp = static_cast<ScriptInterpreter *>(exec->interpreter());
00318 if ((ret = interp->getDOMObject(e.handle())))
00319 return Value(ret);
00320
00321 DOM::DOMString module = e.eventModuleName();
00322 if (module == "UIEvents")
00323 ret = new DOMUIEvent(exec, static_cast<DOM::UIEvent>(e));
00324 else if (module == "MouseEvents")
00325 ret = new DOMMouseEvent(exec, static_cast<DOM::MouseEvent>(e));
00326 else if (module == "TextEvents")
00327 ret = new DOMTextEvent(exec, static_cast<DOM::TextEvent>(e));
00328 else if (module == "MutationEvents")
00329 ret = new DOMMutationEvent(exec, static_cast<DOM::MutationEvent>(e));
00330 else
00331 ret = new DOMEvent(exec, e);
00332
00333 interp->putDOMObject(e.handle(),ret);
00334 return Value(ret);
00335 }
00336
00337 DOM::Event KJS::toEvent(const Value& val)
00338 {
00339 Object obj = Object::dynamicCast(val);
00340 if (obj.isNull() || !obj.inherits(&DOMEvent::info))
00341 return DOM::Event();
00342
00343 const DOMEvent *dobj = static_cast<const DOMEvent*>(obj.imp());
00344 return dobj->toEvent();
00345 }
00346
00347
00348
00349
00350 const ClassInfo EventExceptionConstructor::info = { "EventExceptionConstructor", 0, &EventExceptionConstructorTable, 0 };
00351
00352
00353
00354
00355
00356 EventExceptionConstructor::EventExceptionConstructor(ExecState *exec)
00357 : DOMObject(exec->interpreter()->builtinObjectPrototype())
00358 {
00359 }
00360
00361 Value EventExceptionConstructor::tryGet(ExecState *exec, const Identifier &p) const
00362 {
00363 return DOMObjectLookupGetValue<EventExceptionConstructor, DOMObject>(exec,p,&EventExceptionConstructorTable,this);
00364 }
00365
00366 Value EventExceptionConstructor::getValueProperty(ExecState *, int token) const
00367 {
00368
00369 return Number(token);
00370 }
00371
00372 Value KJS::getEventExceptionConstructor(ExecState *exec)
00373 {
00374 return cacheGlobalObject<EventExceptionConstructor>(exec, "[[eventException.constructor]]");
00375 }
00376
00377
00378
00379 const ClassInfo DOMUIEvent::info = { "UIEvent", &DOMEvent::info, &DOMUIEventTable, 0 };
00380
00381
00382
00383
00384
00385
00386
00387
00388
00389
00390
00391
00392
00393
00394
00395 DEFINE_PROTOTYPE("DOMUIEvent",DOMUIEventProto)
00396 IMPLEMENT_PROTOFUNC_DOM(DOMUIEventProtoFunc)
00397 IMPLEMENT_PROTOTYPE_WITH_PARENT(DOMUIEventProto,DOMUIEventProtoFunc,DOMEventProto)
00398
00399 DOMUIEvent::DOMUIEvent(ExecState *exec, DOM::UIEvent ue) :
00400 DOMEvent(DOMUIEventProto::self(exec), ue) {}
00401
00402 DOMUIEvent::DOMUIEvent(const Object &proto, DOM::UIEvent ue) :
00403 DOMEvent(proto, ue) {}
00404
00405 DOMUIEvent::~DOMUIEvent()
00406 {
00407 }
00408
00409 Value DOMUIEvent::tryGet(ExecState *exec, const Identifier &p) const
00410 {
00411 return DOMObjectLookupGetValue<DOMUIEvent,DOMEvent>(exec,p,&DOMUIEventTable,this);
00412 }
00413
00414 Value DOMUIEvent::getValueProperty(ExecState *exec, int token) const
00415 {
00416 switch (token) {
00417 case View:
00418 return getDOMAbstractView(exec,static_cast<DOM::UIEvent>(event).view());
00419 case Detail:
00420 return Number(static_cast<DOM::UIEvent>(event).detail());
00421 case KeyCode:
00422
00423 return Number(static_cast<DOM::UIEvent>(event).keyCode());
00424 case LayerX:
00425
00426 return Number(static_cast<DOM::UIEvent>(event).layerX());
00427 case LayerY:
00428
00429 return Number(static_cast<DOM::UIEvent>(event).layerY());
00430 case PageX:
00431
00432 if (event.handle() && event.handle()->isMouseEvent())
00433 return Number(static_cast<DOM::MouseEvent>(event).clientX());
00434 return Number(0);
00435 case PageY:
00436
00437 if (event.handle() && event.handle()->isMouseEvent())
00438 return Number(static_cast<DOM::MouseEvent>(event).clientY());
00439 return Number(0);
00440 case Which:
00441
00442 return Number(static_cast<DOM::UIEvent>(event).which());
00443 default:
00444 kdDebug(6070) << "WARNING: Unhandled token in DOMUIEvent::getValueProperty : " << token << endl;
00445 return Undefined();
00446 }
00447 }
00448
00449 Value DOMUIEventProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00450 {
00451 KJS_CHECK_THIS( KJS::DOMUIEvent, thisObj );
00452 DOM::UIEvent uiEvent = static_cast<DOMUIEvent *>(thisObj.imp())->toUIEvent();
00453 switch (id) {
00454 case DOMUIEvent::InitUIEvent: {
00455 DOM::AbstractView v = toAbstractView(args[3]);
00456 static_cast<DOM::UIEvent>(uiEvent).initUIEvent(args[0].toString(exec).string(),
00457 args[1].toBoolean(exec),
00458 args[2].toBoolean(exec),
00459 v,
00460 args[4].toInteger(exec));
00461 }
00462 return Undefined();
00463 }
00464 return Undefined();
00465 }
00466
00467
00468
00469 const ClassInfo DOMMouseEvent::info = { "MouseEvent", &DOMUIEvent::info, &DOMMouseEventTable, 0 };
00470
00471
00472
00473
00474
00475
00476
00477
00478
00479
00480
00481
00482
00483
00484
00485
00486
00487
00488
00489
00490
00491
00492
00493
00494 DEFINE_PROTOTYPE("DOMMouseEvent",DOMMouseEventProto)
00495 IMPLEMENT_PROTOFUNC_DOM(DOMMouseEventProtoFunc)
00496 IMPLEMENT_PROTOTYPE_WITH_PARENT(DOMMouseEventProto,DOMMouseEventProtoFunc,DOMUIEventProto)
00497
00498 DOMMouseEvent::DOMMouseEvent(ExecState *exec, DOM::MouseEvent me) :
00499 DOMUIEvent(DOMMouseEventProto::self(exec), me) {}
00500
00501 DOMMouseEvent::~DOMMouseEvent()
00502 {
00503 }
00504
00505 Value DOMMouseEvent::tryGet(ExecState *exec, const Identifier &p) const
00506 {
00507 #ifdef KJS_VERBOSE
00508 kdDebug(6070) << "DOMMouseEvent::tryGet " << p.qstring() << endl;
00509 #endif
00510 return DOMObjectLookupGetValue<DOMMouseEvent,DOMUIEvent>(exec,p,&DOMMouseEventTable,this);
00511 }
00512
00513 Value DOMMouseEvent::getValueProperty(ExecState *exec, int token) const
00514 {
00515 switch (token) {
00516 case ScreenX:
00517 return Number(static_cast<DOM::MouseEvent>(event).screenX());
00518 case ScreenY:
00519 return Number(static_cast<DOM::MouseEvent>(event).screenY());
00520 case ClientX:
00521 case X:
00522 return Number(static_cast<DOM::MouseEvent>(event).clientX());
00523 case ClientY:
00524 case Y:
00525 return Number(static_cast<DOM::MouseEvent>(event).clientY());
00526 case OffsetX:
00527 case OffsetY:
00528 {
00529 DOM::Node node = event.target();
00530 node.handle()->getDocument()->updateRendering();
00531 khtml::RenderObject *rend = node.handle() ? node.handle()->renderer() : 0L;
00532 int x = static_cast<DOM::MouseEvent>(event).clientX();
00533 int y = static_cast<DOM::MouseEvent>(event).clientY();
00534 if ( rend ) {
00535 int xPos, yPos;
00536 if ( rend->absolutePosition( xPos, yPos ) ) {
00537 kdDebug() << "DOMMouseEvent::getValueProperty rend=" << rend << " xPos=" << xPos << " yPos=" << yPos << endl;
00538 x -= xPos;
00539 y -= yPos;
00540 }
00541 }
00542 return Number( token == OffsetX ? x : y );
00543 }
00544 case CtrlKey:
00545 return Boolean(static_cast<DOM::MouseEvent>(event).ctrlKey());
00546 case ShiftKey:
00547 return Boolean(static_cast<DOM::MouseEvent>(event).shiftKey());
00548 case AltKey:
00549 return Boolean(static_cast<DOM::MouseEvent>(event).altKey());
00550 case MetaKey:
00551 return Boolean(static_cast<DOM::MouseEvent>(event).metaKey());
00552 case Button:
00553 {
00554
00555
00556 int domButton = static_cast<DOM::MouseEvent>(event).button();
00557 int button = domButton==0 ? 1 : domButton==1 ? 4 : domButton==2 ? 2 : 0;
00558 return Number( (unsigned int)button );
00559 }
00560 case ToElement:
00561
00562 if (event.handle()->id() == DOM::EventImpl::MOUSEOUT_EVENT)
00563 return getDOMNode(exec,static_cast<DOM::MouseEvent>(event).relatedTarget());
00564 return getDOMNode(exec,static_cast<DOM::MouseEvent>(event).target());
00565 case FromElement:
00566
00567
00568 if (event.handle()->id() == DOM::EventImpl::MOUSEOUT_EVENT)
00569 return getDOMNode(exec,static_cast<DOM::MouseEvent>(event).target());
00570
00571 case RelatedTarget:
00572 return getDOMNode(exec,static_cast<DOM::MouseEvent>(event).relatedTarget());
00573 default:
00574 kdDebug(6070) << "WARNING: Unhandled token in DOMMouseEvent::getValueProperty : " << token << endl;
00575 return Value();
00576 }
00577 }
00578
00579 Value DOMMouseEventProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00580 {
00581 KJS_CHECK_THIS( KJS::DOMMouseEvent, thisObj );
00582 DOM::MouseEvent mouseEvent = static_cast<DOMMouseEvent *>(thisObj.imp())->toMouseEvent();
00583 switch (id) {
00584 case DOMMouseEvent::InitMouseEvent:
00585 mouseEvent.initMouseEvent(args[0].toString(exec).string(),
00586 args[1].toBoolean(exec),
00587 args[2].toBoolean(exec),
00588 toAbstractView(args[3]),
00589 args[4].toInteger(exec),
00590 args[5].toInteger(exec),
00591 args[6].toInteger(exec),
00592 args[7].toInteger(exec),
00593 args[8].toInteger(exec),
00594 args[9].toBoolean(exec),
00595 args[10].toBoolean(exec),
00596 args[11].toBoolean(exec),
00597 args[12].toBoolean(exec),
00598 args[13].toInteger(exec),
00599 toNode(args[14]));
00600 return Undefined();
00601 }
00602 return Undefined();
00603 }
00604
00605
00606
00607 const ClassInfo DOMTextEvent::info = { "TextEvent", &DOMUIEvent::info, &DOMTextEventTable, 0 };
00608
00609
00610
00611
00612
00613
00614
00615
00616
00617
00618
00619
00620
00621
00622 DEFINE_PROTOTYPE("DOMTextEvent",DOMTextEventProto)
00623 IMPLEMENT_PROTOFUNC_DOM(DOMTextEventProtoFunc)
00624 IMPLEMENT_PROTOTYPE_WITH_PARENT(DOMTextEventProto,DOMTextEventProtoFunc,DOMUIEventProto)
00625
00626 DOMTextEvent::DOMTextEvent(ExecState *exec, DOM::TextEvent ke) :
00627 DOMUIEvent(DOMTextEventProto::self(exec), ke) {}
00628
00629 DOMTextEvent::~DOMTextEvent()
00630 {
00631 }
00632
00633 Value DOMTextEvent::tryGet(ExecState *exec, const Identifier &p) const
00634 {
00635 #ifdef KJS_VERBOSE
00636 kdDebug(6070) << "DOMTextEvent::tryGet " << p.qstring() << endl;
00637 #endif
00638 return DOMObjectLookupGetValue<DOMTextEvent,DOMUIEvent>(exec,p,&DOMTextEventTable,this);
00639 }
00640
00641 Value DOMTextEvent::getValueProperty(ExecState *, int token) const
00642 {
00643 switch (token) {
00644 case Key:
00645 return Number(static_cast<DOM::TextEvent>(event).keyVal());
00646 case VirtKey:
00647 return Number(static_cast<DOM::TextEvent>(event).virtKeyVal());
00648 case OutputString:
00649 return String(static_cast<DOM::TextEvent>(event).outputString());
00650 case InputGenerated:
00651 return Boolean(static_cast<DOM::TextEvent>(event).inputGenerated());
00652 case NumPad:
00653 return Boolean(static_cast<DOM::TextEvent>(event).numPad());
00654 default:
00655 kdDebug(6070) << "WARNING: Unhandled token in DOMTextEvent::getValueProperty : " << token << endl;
00656 return Value();
00657 }
00658 }
00659
00660 Value DOMTextEventProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00661 {
00662 KJS_CHECK_THIS( KJS::DOMTextEvent, thisObj );
00663 DOM::TextEvent keyEvent = static_cast<DOMTextEvent *>(thisObj.imp())->toTextEvent();
00664 switch (id) {
00665 case DOMTextEvent::InitTextEvent:
00666 keyEvent.initTextEvent(args[0].toString(exec).string(),
00667 args[1].toBoolean(exec),
00668 args[2].toBoolean(exec),
00669 toAbstractView(args[3]),
00670 args[4].toInteger(exec),
00671 args[5].toString(exec).string(),
00672 args[6].toInteger(exec),
00673 args[7].toInteger(exec),
00674 args[8].toBoolean(exec),
00675 args[9].toBoolean(exec));
00676
00677 return Undefined();
00678 }
00679 return Undefined();
00680 }
00681
00682
00683
00684 const ClassInfo MutationEventConstructor::info = { "MutationEventConstructor", 0, &MutationEventConstructorTable, 0 };
00685
00686
00687
00688
00689
00690
00691
00692 MutationEventConstructor::MutationEventConstructor(ExecState* exec)
00693 : DOMObject(exec->interpreter()->builtinObjectPrototype())
00694 {
00695 }
00696
00697 Value MutationEventConstructor::tryGet(ExecState *exec, const Identifier &p) const
00698 {
00699 return DOMObjectLookupGetValue<MutationEventConstructor,DOMObject>(exec,p,&MutationEventConstructorTable,this);
00700 }
00701
00702 Value MutationEventConstructor::getValueProperty(ExecState *, int token) const
00703 {
00704
00705 return Number(token);
00706 }
00707
00708 Value KJS::getMutationEventConstructor(ExecState *exec)
00709 {
00710 return cacheGlobalObject<MutationEventConstructor>(exec, "[[mutationEvent.constructor]]");
00711 }
00712
00713
00714
00715 const ClassInfo DOMMutationEvent::info = { "MutationEvent", &DOMEvent::info, &DOMMutationEventTable, 0 };
00716
00717
00718
00719
00720
00721
00722
00723
00724
00725
00726
00727
00728 DEFINE_PROTOTYPE("DOMMutationEvent",DOMMutationEventProto)
00729 IMPLEMENT_PROTOFUNC_DOM(DOMMutationEventProtoFunc)
00730 IMPLEMENT_PROTOTYPE_WITH_PARENT(DOMMutationEventProto,DOMMutationEventProtoFunc,DOMEventProto)
00731
00732 DOMMutationEvent::DOMMutationEvent(ExecState *exec, DOM::MutationEvent me) :
00733 DOMEvent(DOMMutationEventProto::self(exec), me) {}
00734
00735 DOMMutationEvent::~DOMMutationEvent()
00736 {
00737 }
00738
00739 Value DOMMutationEvent::tryGet(ExecState *exec, const Identifier &p) const
00740 {
00741 return DOMObjectLookupGetValue<DOMMutationEvent,DOMEvent>(exec,p,&DOMMutationEventTable,this);
00742 }
00743
00744 Value DOMMutationEvent::getValueProperty(ExecState *exec, int token) const
00745 {
00746 switch (token) {
00747 case RelatedNode:
00748 return getDOMNode(exec,static_cast<DOM::MutationEvent>(event).relatedNode());
00749 case PrevValue:
00750 return String(static_cast<DOM::MutationEvent>(event).prevValue());
00751 case NewValue:
00752 return String(static_cast<DOM::MutationEvent>(event).newValue());
00753 case AttrName:
00754 return String(static_cast<DOM::MutationEvent>(event).attrName());
00755 case AttrChange:
00756 return Number((unsigned int)static_cast<DOM::MutationEvent>(event).attrChange());
00757 default:
00758 kdDebug(6070) << "WARNING: Unhandled token in DOMMutationEvent::getValueProperty : " << token << endl;
00759 return Value();
00760 }
00761 }
00762
00763 Value DOMMutationEventProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00764 {
00765 KJS_CHECK_THIS( KJS::DOMMutationEvent, thisObj );
00766 DOM::MutationEvent mutationEvent = static_cast<DOMMutationEvent *>(thisObj.imp())->toMutationEvent();
00767 switch (id) {
00768 case DOMMutationEvent::InitMutationEvent:
00769 mutationEvent.initMutationEvent(args[0].toString(exec).string(),
00770 args[1].toBoolean(exec),
00771 args[2].toBoolean(exec),
00772 toNode(args[3]),
00773 args[4].toString(exec).string(),
00774 args[5].toString(exec).string(),
00775 args[6].toString(exec).string(),
00776 args[7].toInteger(exec));
00777 return Undefined();
00778 }
00779 return Undefined();
00780 }