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