khtml Library API Documentation

kjs_events.cpp

00001 // -*- c-basic-offset: 2 -*-
00002 /*
00003  *  This file is part of the KDE libraries
00004  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
00005  *
00006  *  This library is free software; you can redistribute it and/or
00007  *  modify it under the terms of the GNU Library General Public
00008  *  License as published by the Free Software Foundation; either
00009  *  version 2 of the License, or (at your option) any later version.
00010  *
00011  *  This library is distributed in the hope that it will be useful,
00012  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014  *  Library General Public License for more details.
00015  *
00016  *  You should have received a copy of the GNU Library General Public
00017  *  License along with this library; if not, write to the Free Software
00018  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00019  */
00020 
00021 #include "kjs_window.h"
00022 #include "kjs_events.h"
00023 #include "kjs_events.lut.h"
00024 #include "kjs_views.h"
00025 #include "kjs_proxy.h"
00026 #include "xml/dom_nodeimpl.h"
00027 #include "xml/dom_docimpl.h"
00028 #include "xml/dom2_eventsimpl.h"
00029 #include "rendering/render_object.h"
00030 
00031 #include <kdebug.h>
00032 
00033 using namespace KJS;
00034 
00035 // -------------------------------------------------------------------------
00036 
00037 JSEventListener::JSEventListener(Object _listener, const Object &_win, bool _html)
00038   : listener( _listener ), html( _html ), win( _win )
00039 {
00040     //fprintf(stderr,"JSEventListener::JSEventListener this=%p listener=%p\n",this,listener.imp());
00041     static_cast<Window*>(win.imp())->jsEventListeners.append(this);
00042 }
00043 
00044 JSEventListener::~JSEventListener()
00045 {
00046     static_cast<Window*>(win.imp())->jsEventListeners.removeRef(this);
00047     //fprintf(stderr,"JSEventListener::~JSEventListener this=%p listener=%p\n",this,listener.imp());
00048 }
00049 
00050 void JSEventListener::handleEvent(DOM::Event &evt)
00051 {
00052 #ifdef KJS_DEBUGGER
00053   if (KJSDebugWin::instance() && KJSDebugWin::instance()->inSession())
00054     return;
00055 #endif
00056   KHTMLPart *part = static_cast<Window*>(win.imp())->part();
00057   KJSProxy *proxy = 0L;
00058   if (part)
00059       proxy = KJSProxy::proxy( part );
00060 
00061   if (proxy && listener.implementsCall()) {
00062     ref();
00063 
00064     KJS::ScriptInterpreter *interpreter = static_cast<KJS::ScriptInterpreter *>(proxy->interpreter());
00065     ExecState *exec = interpreter->globalExec();
00066 
00067     List args;
00068     args.append(getDOMEvent(exec,evt));
00069 
00070     // Add the event's target element to the scope
00071     // (and the document, and the form - see KJS::HTMLElement::eventHandlerScope)
00072     Object thisObj = Object::dynamicCast(getDOMNode(exec,evt.currentTarget()));
00073     List scope;
00074     List oldScope = listener.scope();
00075     if ( thisObj.isValid() ) {
00076       scope = static_cast<DOMNode*>(thisObj.imp())->eventHandlerScope(exec);
00077       if ( !scope.isEmpty() ) {
00078         List curScope = oldScope.copy();
00079         curScope.prependList( scope );
00080         listener.setScope( curScope );
00081       }
00082     }
00083     else {
00084       if ( m_hackThisObj.isValid() )
00085         thisObj = m_hackThisObj;
00086       else
00087         kdWarning() << "Null 'this' object! evt=" << evt.type().string() << " currentTarget==" << evt.currentTarget().handle() << endl;
00088     }
00089 
00090     Window *window = static_cast<Window*>(win.imp());
00091     // Set the event we're handling in the Window object
00092     window->setCurrentEvent( &evt );
00093     // ... and in the interpreter
00094     interpreter->setCurrentEvent( &evt );
00095 
00096     KJSCPUGuard guard;
00097     guard.start();
00098     Value retval = listener.call(exec, thisObj, args);
00099     guard.stop();
00100 
00101     if ( !scope.isEmpty() ) {
00102       listener.setScope( oldScope );
00103     }
00104 
00105     window->setCurrentEvent( 0 );
00106     interpreter->setCurrentEvent( 0 );
00107     if ( exec->hadException() )
00108         exec->clearException();
00109     else
00110     {
00111         QVariant ret = ValueToVariant(exec, retval);
00112         if (ret.type() == QVariant::Bool && ret.toBool() == false)
00113             evt.preventDefault();
00114     }
00115     window->afterScriptExecution();
00116     deref();
00117   }
00118 }
00119 
00120 DOM::DOMString JSEventListener::eventListenerType()
00121 {
00122     if (html)
00123     return "_khtml_HTMLEventListener";
00124     else
00125     return "_khtml_JSEventListener";
00126 }
00127 
00128 Value KJS::getNodeEventListener(DOM::Node n, int eventId)
00129 {
00130     DOM::EventListener *listener = n.handle()->getHTMLEventListener(eventId);
00131     if (listener)
00132     return static_cast<JSEventListener*>(listener)->listenerObj();
00133     else
00134     return Null();
00135 }
00136 
00137 // -------------------------------------------------------------------------
00138 
00139 const ClassInfo EventConstructor::info = { "EventConstructor", 0, &EventConstructorTable, 0 };
00140 /*
00141 @begin EventConstructorTable 3
00142   CAPTURING_PHASE   DOM::Event::CAPTURING_PHASE DontDelete|ReadOnly
00143   AT_TARGET     DOM::Event::AT_TARGET       DontDelete|ReadOnly
00144   BUBBLING_PHASE    DOM::Event::BUBBLING_PHASE  DontDelete|ReadOnly
00145 # Reverse-engineered from Netscape
00146   MOUSEDOWN     1               DontDelete|ReadOnly
00147   MOUSEUP       2               DontDelete|ReadOnly
00148   MOUSEOVER     4               DontDelete|ReadOnly
00149   MOUSEOUT      8               DontDelete|ReadOnly
00150   MOUSEMOVE     16              DontDelete|ReadOnly
00151   MOUSEDRAG     32              DontDelete|ReadOnly
00152   CLICK         64              DontDelete|ReadOnly
00153   DBLCLICK      128             DontDelete|ReadOnly
00154   KEYDOWN       256             DontDelete|ReadOnly
00155   KEYUP         512             DontDelete|ReadOnly
00156   KEYPRESS      1024                DontDelete|ReadOnly
00157   DRAGDROP      2048                DontDelete|ReadOnly
00158   FOCUS         4096                DontDelete|ReadOnly
00159   BLUR          8192                DontDelete|ReadOnly
00160   SELECT        16384               DontDelete|ReadOnly
00161   CHANGE        32768               DontDelete|ReadOnly
00162 @end
00163 */
00164 
00165 EventConstructor::EventConstructor(ExecState *exec)
00166   : DOMObject(exec->interpreter()->builtinObjectPrototype())
00167 {
00168 }
00169 
00170 Value EventConstructor::tryGet(ExecState *exec, const UString &p) const
00171 {
00172   return DOMObjectLookupGetValue<EventConstructor, DOMObject>(exec,p,&EventConstructorTable,this);
00173 }
00174 
00175 Value EventConstructor::getValueProperty(ExecState *, int token) const
00176 {
00177   // We use the token as the value to return directly
00178   return Number(token);
00179 }
00180 
00181 Value KJS::getEventConstructor(ExecState *exec)
00182 {
00183   return cacheGlobalObject<EventConstructor>(exec, "[[event.constructor]]");
00184 }
00185 
00186 // -------------------------------------------------------------------------
00187 
00188 const ClassInfo DOMEvent::info = { "Event", 0, &DOMEventTable, 0 };
00189 /*
00190 @begin DOMEventTable 7
00191   type      DOMEvent::Type      DontDelete|ReadOnly
00192   target    DOMEvent::Target    DontDelete|ReadOnly
00193   currentTarget DOMEvent::CurrentTarget DontDelete|ReadOnly
00194   srcElement    DOMEvent::SrcElement    DontDelete|ReadOnly
00195   eventPhase    DOMEvent::EventPhase    DontDelete|ReadOnly
00196   bubbles   DOMEvent::Bubbles   DontDelete|ReadOnly
00197   cancelable    DOMEvent::Cancelable    DontDelete|ReadOnly
00198   timeStamp DOMEvent::TimeStamp DontDelete|ReadOnly
00199   returnValue   DOMEvent::ReturnValue   DontDelete
00200   cancelBubble  DOMEvent::CancelBubble  DontDelete
00201 @end
00202 @begin DOMEventProtoTable 3
00203   stopPropagation   DOMEvent::StopPropagation   DontDelete|Function 0
00204   preventDefault    DOMEvent::PreventDefault    DontDelete|Function 0
00205   initEvent     DOMEvent::InitEvent     DontDelete|Function 3
00206 @end
00207 */
00208 DEFINE_PROTOTYPE("DOMEvent", DOMEventProto)
00209 IMPLEMENT_PROTOFUNC_DOM(DOMEventProtoFunc)
00210 IMPLEMENT_PROTOTYPE(DOMEventProto, DOMEventProtoFunc)
00211 
00212 DOMEvent::DOMEvent(ExecState *exec, DOM::Event e)
00213   : DOMObject(DOMEventProto::self(exec)), event(e) { }
00214 
00215 DOMEvent::~DOMEvent()
00216 {
00217   ScriptInterpreter::forgetDOMObject(event.handle());
00218 }
00219 
00220 Value DOMEvent::tryGet(ExecState *exec, const UString &p) const
00221 {
00222 #ifdef KJS_VERBOSE
00223   kdDebug() << "KJS::DOMEvent::tryGet " << p.qstring() << endl;
00224 #endif
00225   return DOMObjectLookupGetValue<DOMEvent,DOMObject>(exec, p, &DOMEventTable, this );
00226 }
00227 
00228 Value DOMEvent::getValueProperty(ExecState *exec, int token) const
00229 {
00230   switch (token) {
00231   case Type:
00232     return String(event.type());
00233   case Target:
00234   case SrcElement: /*MSIE extension - "the object that fired the event"*/
00235     return getDOMNode(exec,event.target());
00236   case CurrentTarget:
00237     return getDOMNode(exec,event.currentTarget());
00238   case EventPhase:
00239     return Number((unsigned int)event.eventPhase());
00240   case Bubbles:
00241     return Boolean(event.bubbles());
00242   case Cancelable:
00243     return Boolean(event.cancelable());
00244   case TimeStamp:
00245     return Number((long unsigned int)event.timeStamp()); // ### long long ?
00246   case ReturnValue: // MSIE extension
00247     return Boolean(event.handle()->defaultPrevented());
00248   case CancelBubble: // MSIE extension
00249     return Boolean(event.handle()->propagationStopped());
00250   default:
00251     kdWarning() << "Unhandled token in DOMEvent::getValueProperty : " << token << endl;
00252     return Value();
00253   }
00254 }
00255 
00256 void DOMEvent::tryPut(ExecState *exec, const UString &propertyName,
00257                       const Value& value, int attr)
00258 {
00259   DOMObjectLookupPut<DOMEvent, DOMObject>(exec, propertyName, value, attr,
00260                                           &DOMEventTable, this);
00261 }
00262 
00263 void DOMEvent::putValueProperty(ExecState *exec, int token, const Value& value, int)
00264 {
00265   switch (token) {
00266   case ReturnValue: // MSIE equivalent for "preventDefault" (but with a way to reset it)
00267     // returnValue=false means "default action of the event on the source object is canceled",
00268     // which means preventDefault(true). Hence the '!'.
00269     event.handle()->preventDefault(!value.toBoolean(exec));
00270     break;
00271   case CancelBubble: // MSIE equivalent for "stopPropagation" (but with a way to reset it)
00272     event.handle()->stopPropagation(value.toBoolean(exec));
00273     break;
00274   default:
00275     break;
00276   }
00277 }
00278 
00279 Value DOMEventProtoFunc::tryCall(ExecState *exec, Object & thisObj, const List &args)
00280 {
00281   KJS_CHECK_THIS( KJS::DOMEvent, thisObj );
00282   DOM::Event event = static_cast<DOMEvent *>( thisObj.imp() )->toEvent();
00283   switch (id) {
00284     case DOMEvent::StopPropagation:
00285       event.stopPropagation();
00286     case DOMEvent::PreventDefault:
00287       event.preventDefault();
00288       return Undefined();
00289     case DOMEvent::InitEvent:
00290       event.initEvent(args[0].toString(exec).string(),args[1].toBoolean(exec),args[2].toBoolean(exec));
00291       return Undefined();
00292   };
00293   return Undefined();
00294 }
00295 
00296 Value KJS::getDOMEvent(ExecState *exec, DOM::Event e)
00297 {
00298   DOMObject *ret;
00299   if (e.isNull())
00300     return Null();
00301   ScriptInterpreter* interp = static_cast<ScriptInterpreter *>(exec->interpreter());
00302   if ((ret = interp->getDOMObject(e.handle())))
00303     return Value(ret);
00304 
00305   DOM::DOMString module = e.eventModuleName();
00306   if (module == "UIEvents")
00307     ret = new DOMUIEvent(exec, static_cast<DOM::UIEvent>(e));
00308   else if (module == "MouseEvents")
00309     ret = new DOMMouseEvent(exec, static_cast<DOM::MouseEvent>(e));
00310   else if (module == "TextEvents")
00311     ret = new DOMTextEvent(exec, static_cast<DOM::TextEvent>(e));
00312   else if (module == "MutationEvents")
00313     ret = new DOMMutationEvent(exec, static_cast<DOM::MutationEvent>(e));
00314   else
00315     ret = new DOMEvent(exec, e);
00316 
00317   interp->putDOMObject(e.handle(),ret);
00318   return Value(ret);
00319 }
00320 
00321 DOM::Event KJS::toEvent(const Value& val)
00322 {
00323   Object obj = Object::dynamicCast(val);
00324   if (obj.isNull() || !obj.inherits(&DOMEvent::info))
00325     return DOM::Event();
00326 
00327   const DOMEvent *dobj = static_cast<const DOMEvent*>(obj.imp());
00328   return dobj->toEvent();
00329 }
00330 
00331 // -------------------------------------------------------------------------
00332 
00333 
00334 const ClassInfo EventExceptionConstructor::info = { "EventExceptionConstructor", 0, &EventExceptionConstructorTable, 0 };
00335 /*
00336 @begin EventExceptionConstructorTable 1
00337   UNSPECIFIED_EVENT_TYPE_ERR    DOM::EventException::UNSPECIFIED_EVENT_TYPE_ERR DontDelete|ReadOnly
00338 @end
00339 */
00340 EventExceptionConstructor::EventExceptionConstructor(ExecState *exec)
00341   : DOMObject(exec->interpreter()->builtinObjectPrototype())
00342 {
00343 }
00344 
00345 Value EventExceptionConstructor::tryGet(ExecState *exec, const UString &p) const
00346 {
00347   return DOMObjectLookupGetValue<EventExceptionConstructor, DOMObject>(exec,p,&EventExceptionConstructorTable,this);
00348 }
00349 
00350 Value EventExceptionConstructor::getValueProperty(ExecState *, int token) const
00351 {
00352   // We use the token as the value to return directly
00353   return Number(token);
00354 }
00355 
00356 Value KJS::getEventExceptionConstructor(ExecState *exec)
00357 {
00358   return cacheGlobalObject<EventExceptionConstructor>(exec, "[[eventException.constructor]]");
00359 }
00360 
00361 // -------------------------------------------------------------------------
00362 
00363 const ClassInfo DOMUIEvent::info = { "UIEvent", &DOMEvent::info, &DOMUIEventTable, 0 };
00364 /*
00365 @begin DOMUIEventTable 2
00366   view      DOMUIEvent::View    DontDelete|ReadOnly
00367   detail    DOMUIEvent::Detail  DontDelete|ReadOnly
00368 @end
00369 @begin DOMUIEventProtoTable 1
00370   initUIEvent   DOMUIEvent::InitUIEvent DontDelete|Function 5
00371 @end
00372 */
00373 DEFINE_PROTOTYPE("DOMUIEvent",DOMUIEventProto)
00374 IMPLEMENT_PROTOFUNC_DOM(DOMUIEventProtoFunc)
00375 IMPLEMENT_PROTOTYPE_WITH_PARENT(DOMUIEventProto,DOMUIEventProtoFunc,DOMEventProto)
00376 
00377 DOMUIEvent::~DOMUIEvent()
00378 {
00379 }
00380 
00381 Value DOMUIEvent::tryGet(ExecState *exec, const UString &p) const
00382 {
00383   return DOMObjectLookupGetValue<DOMUIEvent,DOMEvent>(exec,p,&DOMUIEventTable,this);
00384 }
00385 
00386 Value DOMUIEvent::getValueProperty(ExecState *exec, int token) const
00387 {
00388   switch (token) {
00389   case View:
00390     return getDOMAbstractView(exec,static_cast<DOM::UIEvent>(event).view());
00391   case Detail:
00392     return Number(static_cast<DOM::UIEvent>(event).detail());
00393   default:
00394     kdWarning() << "Unhandled token in DOMUIEvent::getValueProperty : " << token << endl;
00395     return Value();
00396   }
00397 }
00398 
00399 Value DOMUIEventProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00400 {
00401   KJS_CHECK_THIS( KJS::DOMUIEvent, thisObj );
00402   DOM::UIEvent uiEvent = static_cast<DOMUIEvent *>(thisObj.imp())->toUIEvent();
00403   switch (id) {
00404     case DOMUIEvent::InitUIEvent: {
00405       DOM::AbstractView v = toAbstractView(args[3]);
00406       static_cast<DOM::UIEvent>(uiEvent).initUIEvent(args[0].toString(exec).string(),
00407                                                      args[1].toBoolean(exec),
00408                                                      args[2].toBoolean(exec),
00409                                                      v,
00410                                                      args[4].toInteger(exec));
00411       }
00412       return Undefined();
00413   }
00414   return Undefined();
00415 }
00416 
00417 // -------------------------------------------------------------------------
00418 
00419 const ClassInfo DOMMouseEvent::info = { "MouseEvent", &DOMUIEvent::info, &DOMMouseEventTable, 0 };
00420 
00421 /*
00422 @begin DOMMouseEventTable 2
00423   screenX   DOMMouseEvent::ScreenX  DontDelete|ReadOnly
00424   screenY   DOMMouseEvent::ScreenY  DontDelete|ReadOnly
00425   clientX   DOMMouseEvent::ClientX  DontDelete|ReadOnly
00426   x     DOMMouseEvent::X    DontDelete|ReadOnly
00427   clientY   DOMMouseEvent::ClientY  DontDelete|ReadOnly
00428   y     DOMMouseEvent::Y    DontDelete|ReadOnly
00429   offsetX   DOMMouseEvent::OffsetX  DontDelete|ReadOnly
00430   offsetY   DOMMouseEvent::OffsetY  DontDelete|ReadOnly
00431   ctrlKey   DOMMouseEvent::CtrlKey  DontDelete|ReadOnly
00432   shiftKey  DOMMouseEvent::ShiftKey DontDelete|ReadOnly
00433   altKey    DOMMouseEvent::AltKey   DontDelete|ReadOnly
00434   metaKey   DOMMouseEvent::MetaKey  DontDelete|ReadOnly
00435   button    DOMMouseEvent::Button   DontDelete|ReadOnly
00436   relatedTarget DOMMouseEvent::RelatedTarget DontDelete|ReadOnly
00437   fromElement   DOMMouseEvent::FromElement DontDelete|ReadOnly
00438   toElement DOMMouseEvent::ToElement    DontDelete|ReadOnly
00439 @end
00440 @begin DOMMouseEventProtoTable 1
00441   initMouseEvent    DOMMouseEvent::InitMouseEvent   DontDelete|Function 15
00442 @end
00443 */
00444 DEFINE_PROTOTYPE("DOMMouseEvent",DOMMouseEventProto)
00445 IMPLEMENT_PROTOFUNC_DOM(DOMMouseEventProtoFunc)
00446 IMPLEMENT_PROTOTYPE_WITH_PARENT(DOMMouseEventProto,DOMMouseEventProtoFunc,DOMUIEventProto)
00447 
00448 DOMMouseEvent::~DOMMouseEvent()
00449 {
00450 }
00451 
00452 Value DOMMouseEvent::tryGet(ExecState *exec, const UString &p) const
00453 {
00454 #ifdef KJS_VERBOSE
00455   kdDebug(6070) << "DOMMouseEvent::tryGet " << p.qstring() << endl;
00456 #endif
00457   return DOMObjectLookupGetValue<DOMMouseEvent,DOMUIEvent>(exec,p,&DOMMouseEventTable,this);
00458 }
00459 
00460 Value DOMMouseEvent::getValueProperty(ExecState *exec, int token) const
00461 {
00462   switch (token) {
00463   case ScreenX:
00464     return Number(static_cast<DOM::MouseEvent>(event).screenX());
00465   case ScreenY:
00466     return Number(static_cast<DOM::MouseEvent>(event).screenY());
00467   case ClientX:
00468   case X:
00469     return Number(static_cast<DOM::MouseEvent>(event).clientX());
00470   case ClientY:
00471   case Y:
00472     return Number(static_cast<DOM::MouseEvent>(event).clientY());
00473   case OffsetX:
00474   case OffsetY: // MSIE extension
00475   {
00476     DOM::Node node = event.target();
00477     node.handle()->getDocument()->updateRendering();
00478     khtml::RenderObject *rend = node.handle() ? node.handle()->renderer() : 0L;
00479     int x = static_cast<DOM::MouseEvent>(event).clientX();
00480     int y = static_cast<DOM::MouseEvent>(event).clientY();
00481     if ( rend ) {
00482       int xPos, yPos;
00483       if ( rend->absolutePosition( xPos, yPos ) ) {
00484         kdDebug() << "DOMMouseEvent::getValueProperty rend=" << rend << "  xPos=" << xPos << "  yPos=" << yPos << endl;
00485         x -= xPos;
00486         y -= yPos;
00487       }
00488     }
00489     return Number( token == OffsetX ? x : y );
00490   }
00491   case CtrlKey:
00492     return Boolean(static_cast<DOM::MouseEvent>(event).ctrlKey());
00493   case ShiftKey:
00494     return Boolean(static_cast<DOM::MouseEvent>(event).shiftKey());
00495   case AltKey:
00496     return Boolean(static_cast<DOM::MouseEvent>(event).altKey());
00497   case MetaKey:
00498     return Boolean(static_cast<DOM::MouseEvent>(event).metaKey());
00499   case Button:
00500   {
00501     // Tricky. The DOM (and khtml) use 0 for LMB, 1 for MMB and 2 for RMB
00502     // but MSIE uses 1=LMB, 2=RMB, 4=MMB, as a bitfield
00503     int domButton = static_cast<DOM::MouseEvent>(event).button();
00504     int button = domButton==0 ? 1 : domButton==1 ? 4 : domButton==2 ? 2 : 0;
00505     return Number( (unsigned int)button );
00506   }
00507   case ToElement:
00508     // MSIE extension - "the object toward which the user is moving the mouse pointer"
00509     if (event.handle()->id() == DOM::EventImpl::MOUSEOUT_EVENT)
00510       return getDOMNode(exec,static_cast<DOM::MouseEvent>(event).relatedTarget());
00511     return getDOMNode(exec,static_cast<DOM::MouseEvent>(event).target());
00512   case FromElement:
00513     // MSIE extension - "object from which activation
00514     // or the mouse pointer is exiting during the event" (huh?)
00515     if (event.handle()->id() == DOM::EventImpl::MOUSEOUT_EVENT)
00516       return getDOMNode(exec,static_cast<DOM::MouseEvent>(event).target());
00517     /* fall through */
00518   case RelatedTarget:
00519     return getDOMNode(exec,static_cast<DOM::MouseEvent>(event).relatedTarget());
00520   default:
00521     kdWarning() << "Unhandled token in DOMMouseEvent::getValueProperty : " << token << endl;
00522     return Value();
00523   }
00524 }
00525 
00526 Value DOMMouseEventProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00527 {
00528   KJS_CHECK_THIS( KJS::DOMMouseEvent, thisObj );
00529   DOM::MouseEvent mouseEvent = static_cast<DOMMouseEvent *>(thisObj.imp())->toMouseEvent();
00530   switch (id) {
00531     case DOMMouseEvent::InitMouseEvent:
00532       mouseEvent.initMouseEvent(args[0].toString(exec).string(), // typeArg
00533                                 args[1].toBoolean(exec), // canBubbleArg
00534                                 args[2].toBoolean(exec), // cancelableArg
00535                                 toAbstractView(args[3]), // viewArg
00536                                 args[4].toInteger(exec), // detailArg
00537                                 args[5].toInteger(exec), // screenXArg
00538                                 args[6].toInteger(exec), // screenYArg
00539                                 args[7].toInteger(exec), // clientXArg
00540                                 args[8].toInteger(exec), // clientYArg
00541                                 args[9].toBoolean(exec), // ctrlKeyArg
00542                                 args[10].toBoolean(exec), // altKeyArg
00543                                 args[11].toBoolean(exec), // shiftKeyArg
00544                                 args[12].toBoolean(exec), // metaKeyArg
00545                                 args[13].toInteger(exec), // buttonArg
00546                                 toNode(args[14])); // relatedTargetArg
00547       return Undefined();
00548   }
00549   return Undefined();
00550 }
00551 
00552 // -------------------------------------------------------------------------
00553 
00554 const ClassInfo DOMTextEvent::info = { "TextEvent", &DOMUIEvent::info, &DOMTextEventTable, 0 };
00555 
00556 /*
00557 @begin DOMTextEventTable 2
00558   keyVal     DOMTextEvent::Key       DontDelete|ReadOnly
00559 # IE's name for it
00560   keyCode        DOMTextEvent::Key       DontDelete|ReadOnly
00561   virtKeyVal     DOMTextEvent::VirtKey        DontDelete|ReadOnly
00562   outputString   DOMTextEvent::OutputString   DontDelete|ReadOnly
00563   inputGenerated DOMTextEvent::InputGenerated DontDelete|ReadOnly
00564   numPad         DOMTextEvent::NumPad         DontDelete|ReadOnly
00565 @end
00566 @begin DOMTextEventProtoTable 1
00567   initTextEvent DOMTextEvent::InitTextEvent DontDelete|Function 10
00568   # Missing: initTextEventNS, initModifier
00569 @end
00570 */
00571 DEFINE_PROTOTYPE("DOMTextEvent",DOMTextEventProto)
00572 IMPLEMENT_PROTOFUNC_DOM(DOMTextEventProtoFunc)
00573 IMPLEMENT_PROTOTYPE_WITH_PARENT(DOMTextEventProto,DOMTextEventProtoFunc,DOMUIEventProto)
00574 
00575 DOMTextEvent::~DOMTextEvent()
00576 {
00577 }
00578 
00579 Value DOMTextEvent::tryGet(ExecState *exec, const UString &p) const
00580 {
00581 #ifdef KJS_VERBOSE
00582   kdDebug(6070) << "DOMTextEvent::tryGet " << p.qstring() << endl;
00583 #endif
00584   return DOMObjectLookupGetValue<DOMTextEvent,DOMUIEvent>(exec,p,&DOMTextEventTable,this);
00585 }
00586 
00587 Value DOMTextEvent::getValueProperty(ExecState *, int token) const
00588 {
00589   switch (token) {
00590   case Key:
00591     return Number(static_cast<DOM::TextEvent>(event).keyVal());
00592   case VirtKey:
00593     return Number(static_cast<DOM::TextEvent>(event).virtKeyVal());
00594   case OutputString:
00595     return String(static_cast<DOM::TextEvent>(event).outputString());
00596   case InputGenerated:
00597     return Boolean(static_cast<DOM::TextEvent>(event).inputGenerated());
00598   case NumPad:
00599     return Boolean(static_cast<DOM::TextEvent>(event).numPad());
00600   default:
00601     kdWarning() << "Unhandled token in DOMTextEvent::getValueProperty : " << token << endl;
00602     return Value();
00603   }
00604 }
00605 
00606 Value DOMTextEventProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00607 {
00608   KJS_CHECK_THIS( KJS::DOMTextEvent, thisObj );
00609   DOM::TextEvent keyEvent = static_cast<DOMTextEvent *>(thisObj.imp())->toTextEvent();
00610   switch (id) {
00611     case DOMTextEvent::InitTextEvent:
00612       keyEvent.initTextEvent(args[0].toString(exec).string(), // typeArg
00613                             args[1].toBoolean(exec), // canBubbleArg
00614                             args[2].toBoolean(exec), // cancelableArg
00615                             toAbstractView(args[3]), // viewArg
00616                             args[4].toInteger(exec), // detailArg
00617                             args[5].toString(exec).string(),  // outputStringArg
00618                             args[6].toInteger(exec), // keyValArg
00619                             args[7].toInteger(exec), // virtKeyValArg
00620                             args[8].toBoolean(exec), // inputGeneratedArg
00621                             args[9].toBoolean(exec));// numPadArg
00622 
00623       return Undefined();
00624   }
00625   return Undefined();
00626 }
00627 
00628 // -------------------------------------------------------------------------
00629 
00630 const ClassInfo MutationEventConstructor::info = { "MutationEventConstructor", 0, &MutationEventConstructorTable, 0 };
00631 /*
00632 @begin MutationEventConstructorTable 3
00633   MODIFICATION  DOM::MutationEvent::MODIFICATION    DontDelete|ReadOnly
00634   ADDITION  DOM::MutationEvent::ADDITION        DontDelete|ReadOnly
00635   REMOVAL   DOM::MutationEvent::REMOVAL     DontDelete|ReadOnly
00636 @end
00637 */
00638 MutationEventConstructor::MutationEventConstructor(ExecState* exec)
00639   : DOMObject(exec->interpreter()->builtinObjectPrototype())
00640 {
00641 }
00642 
00643 Value MutationEventConstructor::tryGet(ExecState *exec, const UString &p) const
00644 {
00645   return DOMObjectLookupGetValue<MutationEventConstructor,DOMObject>(exec,p,&MutationEventConstructorTable,this);
00646 }
00647 
00648 Value MutationEventConstructor::getValueProperty(ExecState *, int token) const
00649 {
00650   // We use the token as the value to return directly
00651   return Number(token);
00652 }
00653 
00654 Value KJS::getMutationEventConstructor(ExecState *exec)
00655 {
00656   return cacheGlobalObject<MutationEventConstructor>(exec, "[[mutationEvent.constructor]]");
00657 }
00658 
00659 // -------------------------------------------------------------------------
00660 
00661 const ClassInfo DOMMutationEvent::info = { "MutationEvent", &DOMEvent::info, &DOMMutationEventTable, 0 };
00662 /*
00663 @begin DOMMutationEventTable 5
00664   relatedNode   DOMMutationEvent::RelatedNode   DontDelete|ReadOnly
00665   prevValue DOMMutationEvent::PrevValue DontDelete|ReadOnly
00666   newValue  DOMMutationEvent::NewValue  DontDelete|ReadOnly
00667   attrName  DOMMutationEvent::AttrName  DontDelete|ReadOnly
00668   attrChange    DOMMutationEvent::AttrChange    DontDelete|ReadOnly
00669 @end
00670 @begin DOMMutationEventProtoTable 1
00671   initMutationEvent DOMMutationEvent::InitMutationEvent DontDelete|Function 8
00672 @end
00673 */
00674 DEFINE_PROTOTYPE("DOMMutationEvent",DOMMutationEventProto)
00675 IMPLEMENT_PROTOFUNC_DOM(DOMMutationEventProtoFunc)
00676 IMPLEMENT_PROTOTYPE_WITH_PARENT(DOMMutationEventProto,DOMMutationEventProtoFunc,DOMEventProto)
00677 
00678 DOMMutationEvent::~DOMMutationEvent()
00679 {
00680 }
00681 
00682 Value DOMMutationEvent::tryGet(ExecState *exec, const UString &p) const
00683 {
00684   return DOMObjectLookupGetValue<DOMMutationEvent,DOMEvent>(exec,p,&DOMMutationEventTable,this);
00685 }
00686 
00687 Value DOMMutationEvent::getValueProperty(ExecState *exec, int token) const
00688 {
00689   switch (token) {
00690   case RelatedNode:
00691     return getDOMNode(exec,static_cast<DOM::MutationEvent>(event).relatedNode());
00692   case PrevValue:
00693     return String(static_cast<DOM::MutationEvent>(event).prevValue());
00694   case NewValue:
00695     return String(static_cast<DOM::MutationEvent>(event).newValue());
00696   case AttrName:
00697     return String(static_cast<DOM::MutationEvent>(event).attrName());
00698   case AttrChange:
00699     return Number((unsigned int)static_cast<DOM::MutationEvent>(event).attrChange());
00700   default:
00701     kdWarning() << "Unhandled token in DOMMutationEvent::getValueProperty : " << token << endl;
00702     return Value();
00703   }
00704 }
00705 
00706 Value DOMMutationEventProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00707 {
00708   KJS_CHECK_THIS( KJS::DOMMutationEvent, thisObj );
00709   DOM::MutationEvent mutationEvent = static_cast<DOMMutationEvent *>(thisObj.imp())->toMutationEvent();
00710   switch (id) {
00711     case DOMMutationEvent::InitMutationEvent:
00712       mutationEvent.initMutationEvent(args[0].toString(exec).string(), // typeArg,
00713                                       args[1].toBoolean(exec), // canBubbleArg
00714                                       args[2].toBoolean(exec), // cancelableArg
00715                                       toNode(args[3]), // relatedNodeArg
00716                                       args[4].toString(exec).string(), // prevValueArg
00717                                       args[5].toString(exec).string(), // newValueArg
00718                                       args[6].toString(exec).string(), // attrNameArg
00719                                       args[7].toInteger(exec)); // attrChangeArg
00720       return Undefined();
00721   }
00722   return Undefined();
00723 }
KDE Logo
This file is part of the documentation for kdelibs Version 3.1.4.
Documentation copyright © 1996-2002 the KDE developers.
Generated on Sun Feb 27 22:16:38 2005 by doxygen 1.3.4 written by Dimitri van Heesch, © 1997-2001