/* Copyright (C) 2001-2003 KSVG Team This file is part of the KDE project Additional copyright: (C) 2001 Peter Kelly (C) 2001 Tobias Anton This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "SVGDocumentImpl.h" #include "SVGEventImpl.h" #include using namespace KSVG; #include "ksvg_scriptinterpreter.h" #include "SVGEventImpl.lut.h" #include "ksvg_bridge.h" #include "ksvg_ecma.h" SVGEventImpl::SVGEventImpl() { m_canBubble = false; m_cancelable = false; m_propagationStopped = false; m_defaultPrevented = false; m_id = SVGEvent::UNKNOWN_EVENT; m_eventPhase = 0; m_createTime = TQDateTime::currentDateTime(); m_defaultHandled = false; m_target = 0; m_currentTarget = 0; } SVGEventImpl::SVGEventImpl(SVGEvent::EventId _id, bool canBubbleArg, bool cancelableArg) { DOM::DOMString t = SVGEvent::idToType(_id); m_type = t.implementation(); m_canBubble = canBubbleArg; m_cancelable = cancelableArg; m_propagationStopped = false; m_defaultPrevented = false; m_id = _id; m_eventPhase = 0; m_createTime = TQDateTime::currentDateTime(); m_defaultHandled = false; m_target = 0; m_currentTarget = 0; } SVGEventImpl::~SVGEventImpl() { } DOM::DOMString SVGEventImpl::type() const { return m_type; } SVGElementImpl *SVGEventImpl::target() const { return m_target; } void SVGEventImpl::setTarget(SVGElementImpl *_target) { m_target = _target; } SVGElementImpl *SVGEventImpl::currentTarget() const { return m_currentTarget; } void SVGEventImpl::setCurrentTarget(SVGElementImpl *_currentTarget) { m_currentTarget = _currentTarget; } unsigned short SVGEventImpl::eventPhase() const { return m_eventPhase; } void SVGEventImpl::setEventPhase(unsigned short _eventPhase) { m_eventPhase = _eventPhase; } bool SVGEventImpl::bubbles() const { return m_canBubble; } bool SVGEventImpl::cancelable() const { return m_cancelable; } DOM::DOMTimeStamp SVGEventImpl::timeStamp() { TQDateTime epoch(TQDate(1970, 1, 1), TQTime(0, 0)); // ### kjs does not yet support long long (?) so the value wraps around return epoch.secsTo(m_createTime) * 1000 + m_createTime.time().msec(); } void SVGEventImpl::stopPropagation() { m_propagationStopped = true; } void SVGEventImpl::preventDefault() { if(m_cancelable) m_defaultPrevented = true; } void SVGEventImpl::initEvent(const DOM::DOMString &eventTypeArg, bool canBubbleArg, bool cancelableArg) { // ### ensure this is not called after we have been dispatched (also for subclasses) m_type = eventTypeArg.implementation(); m_id = SVGEvent::typeToId(eventTypeArg); m_canBubble = canBubbleArg; m_cancelable = cancelableArg; } void SVGEventImpl::setDefaultHandled() { m_defaultHandled = true; } /* @namespace KSVG @begin SVGEventImpl::s_hashTable 11 type SVGEventImpl::Type DontDelete|ReadOnly target SVGEventImpl::Target DontDelete|ReadOnly currentTarget SVGEventImpl::CurrentTarget DontDelete|ReadOnly eventPhase SVGEventImpl::EventPhase DontDelete|ReadOnly bubbles SVGEventImpl::Bubbles DontDelete|ReadOnly cancelable SVGEventImpl::Cancelable DontDelete|ReadOnly timeStamp SVGEventImpl::TimeStamp DontDelete|ReadOnly @end @namespace KSVG @begin SVGEventImplProto::s_hashTable 13 getType SVGEventImpl::GetType DontDelete|Function 0 getTarget SVGEventImpl::GetTarget DontDelete|Function 0 getCurrentTarget SVGEventImpl::GetCurrentTarget DontDelete|Function 0 getCurrentNode SVGEventImpl::GetCurrentNode DontDelete|Function 0 getEventphase SVGEventImpl::GetEventPhase DontDelete|Function 0 getBubbles SVGEventImpl::GetBubbles DontDelete|Function 0 getCancelable SVGEventImpl::GetCancelable DontDelete|Function 0 getTimeStamp SVGEventImpl::GetTimeStamp DontDelete|Function 0 stopPropagation SVGEventImpl::StopPropagation DontDelete|Function 0 preventDefault SVGEventImpl::PreventDefault DontDelete|Function 0 initEvent SVGEventImpl::InitEvent DontDelete|Function 3 @end */ KSVG_IMPLEMENT_PROTOTYPE("SVGEvent", SVGEventImplProto, SVGEventImplProtoFunc) Value SVGEventImpl::getValueProperty(ExecState *exec, int token) const { switch(token) { case Type: return String(type()); case Target: return getDOMNode(exec, *target()); case CurrentTarget: return getDOMNode(exec, *currentTarget()); case EventPhase: return Number(eventPhase()); case Bubbles: return Boolean(bubbles()); case Cancelable: return Boolean(cancelable()); // case TimeStamp: // TODO default: kdWarning() << "Unhandled token in " << k_funcinfo << " : " << token << endl; return KJS::Undefined(); } } Value SVGEventImplProtoFunc::call(ExecState *exec, Object &thisObj, const List &args) { KSVG_CHECK_THIS(SVGEventImpl) switch(id) { case SVGEventImpl::GetType: return String(obj->type()); case SVGEventImpl::GetTarget: return getDOMNode(exec, *obj->target()); case SVGEventImpl::GetCurrentTarget: case SVGEventImpl::GetCurrentNode: return getDOMNode(exec, *obj->currentTarget()); case SVGEventImpl::GetEventPhase: return Number(obj->eventPhase()); case SVGEventImpl::GetBubbles: return Boolean(obj->bubbles()); case SVGEventImpl::GetCancelable: return Boolean(obj->cancelable()); // case SVGEventImpl::GetTimeStamp: // TODO case SVGEventImpl::StopPropagation: { obj->stopPropagation(); return Undefined(); } case SVGEventImpl::PreventDefault: { obj->preventDefault(); return Undefined(); } case SVGEventImpl::InitEvent: { obj->initEvent(args[0].toString(exec).string(), args[1].toBoolean(exec), args[2].toBoolean(exec)); return Undefined(); } default: kdWarning() << "Unhandled function id in " << k_funcinfo << " : " << id << endl; break; } return Undefined(); } SVGUIEventImpl::SVGUIEventImpl() : SVGEventImpl() { m_detail = 0; } SVGUIEventImpl::SVGUIEventImpl(SVGEvent::EventId _id, bool canBubbleArg, bool cancelableArg, DOM::AbstractView &viewArg, long detailArg) : SVGEventImpl(_id, canBubbleArg, cancelableArg) { m_view = viewArg; m_detail = detailArg; } SVGUIEventImpl::~SVGUIEventImpl() { } DOM::AbstractView SVGUIEventImpl::view() const { return m_view; } long SVGUIEventImpl::detail() const { return m_detail; } void SVGUIEventImpl::initUIEvent(const DOM::DOMString &typeArg, bool canBubbleArg, bool cancelableArg, const DOM::AbstractView &viewArg, long detailArg) { SVGEventImpl::initEvent(typeArg, canBubbleArg, cancelableArg); m_view = viewArg; m_detail = detailArg; } /* @namespace KSVG @begin SVGUIEventImpl::s_hashTable 3 view SVGUIEventImpl::View DontDelete|ReadOnly detail SVGUIEventImpl::Detail DontDelete|ReadOnly @end @namespace KSVG @begin SVGUIEventImplProto::s_hashTable 5 getView SVGUIEventImpl::GetView DontDelete|Function 0 getDetail SVGUIEventImpl::GetDetail DontDelete|Function 0 initUIEvent SVGUIEventImpl::InitUIEvent DontDelete|Function 5 @end */ KSVG_IMPLEMENT_PROTOTYPE("SVGUIEvent", SVGUIEventImplProto, SVGUIEventImplProtoFunc) Value SVGUIEventImpl::getValueProperty(ExecState *, int token) const { switch(token) { // case View: // TODO case Detail: return Number(detail()); default: kdWarning() << "Unhandled token in " << k_funcinfo << " : " << token << endl; return KJS::Undefined(); } } Value SVGUIEventImplProtoFunc::call(ExecState *exec, Object &thisObj, const List &) { KSVG_CHECK_THIS(SVGUIEventImpl) switch(id) { // case SVGUIEventImpl::GetView: // TODO case SVGUIEventImpl::GetDetail: return Number(obj->detail()); // case SVGUIEventImpl::InitUIEvent: // TODO default: kdWarning() << "Unhandled function id in " << k_funcinfo << " : " << id << endl; break; } return Undefined(); } SVGKeyEventImpl::SVGKeyEventImpl() : SVGUIEventImpl() { qKeyEvent = 0; } SVGKeyEventImpl::SVGKeyEventImpl(TQKeyEvent *key, DOM::AbstractView &view, SVGEvent::EventId _id) : SVGUIEventImpl(_id, true, true, view, 0) { qKeyEvent = new TQKeyEvent(key->type(), key->key(), key->ascii(), key->state(), key->text(), key->isAutoRepeat(), key->count()); // Events are supposed to be accepted by default in TQt! // This line made TQLineEdit's keyevents be ignored, so they were sent to the tdehtmlview // (and e.g. space would make it scroll down) //qKeyEvent->ignore(); m_detail = key->count(); m_numPad = false; m_keyVal = 0; m_virtKeyVal = DOM_VK_UNDEFINED; m_inputGenerated = true; switch(key->key()) { case TQt::Key_Enter: m_numPad = true; /* fall through */ case TQt::Key_Return: m_virtKeyVal = DOM_VK_ENTER; break; case TQt::Key_NumLock: m_numPad = true; m_virtKeyVal = DOM_VK_NUM_LOCK; break; case TQt::Key_Alt: m_virtKeyVal = DOM_VK_RIGHT_ALT; // ### DOM_VK_LEFT_ALT; break; case TQt::Key_Control: m_virtKeyVal = DOM_VK_LEFT_CONTROL; // ### DOM_VK_RIGHT_CONTROL break; case TQt::Key_Shift: m_virtKeyVal = DOM_VK_LEFT_SHIFT; // ### DOM_VK_RIGHT_SHIFT break; case TQt::Key_Meta: m_virtKeyVal = DOM_VK_LEFT_META; // ### DOM_VK_RIGHT_META break; case TQt::Key_CapsLock: m_virtKeyVal = DOM_VK_CAPS_LOCK; break; case TQt::Key_Delete: m_virtKeyVal = DOM_VK_DELETE; break; case TQt::Key_End: m_virtKeyVal = DOM_VK_END; break; case TQt::Key_Escape: m_virtKeyVal = DOM_VK_ESCAPE; break; case TQt::Key_Home: m_virtKeyVal = DOM_VK_HOME; break; case TQt::Key_Insert: m_virtKeyVal = DOM_VK_INSERT; break; case TQt::Key_Pause: m_virtKeyVal = DOM_VK_PAUSE; break; case TQt::Key_Print: m_virtKeyVal = DOM_VK_PRINTSCREEN; break; case TQt::Key_ScrollLock: m_virtKeyVal = DOM_VK_SCROLL_LOCK; break; case TQt::Key_Left: m_virtKeyVal = DOM_VK_LEFT; break; case TQt::Key_Right: m_virtKeyVal = DOM_VK_RIGHT; break; case TQt::Key_Up: m_virtKeyVal = DOM_VK_UP; break; case TQt::Key_Down: m_virtKeyVal = DOM_VK_DOWN; break; case TQt::Key_Next: m_virtKeyVal = DOM_VK_PAGE_DOWN; break; case TQt::Key_Prior: m_virtKeyVal = DOM_VK_PAGE_UP; break; case TQt::Key_F1: m_virtKeyVal = DOM_VK_F1; break; case TQt::Key_F2: m_virtKeyVal = DOM_VK_F2; break; case TQt::Key_F3: m_virtKeyVal = DOM_VK_F3; break; case TQt::Key_F4: m_virtKeyVal = DOM_VK_F4; break; case TQt::Key_F5: m_virtKeyVal = DOM_VK_F5; break; case TQt::Key_F6: m_virtKeyVal = DOM_VK_F6; break; case TQt::Key_F7: m_virtKeyVal = DOM_VK_F7; break; case TQt::Key_F8: m_virtKeyVal = DOM_VK_F8; break; case TQt::Key_F9: m_virtKeyVal = DOM_VK_F9; break; case TQt::Key_F10: m_virtKeyVal = DOM_VK_F10; break; case TQt::Key_F11: m_virtKeyVal = DOM_VK_F11; break; case TQt::Key_F12: m_virtKeyVal = DOM_VK_F12; break; case TQt::Key_F13: m_virtKeyVal = DOM_VK_F13; break; case TQt::Key_F14: m_virtKeyVal = DOM_VK_F14; break; case TQt::Key_F15: m_virtKeyVal = DOM_VK_F15; break; case TQt::Key_F16: m_virtKeyVal = DOM_VK_F16; break; case TQt::Key_F17: m_virtKeyVal = DOM_VK_F17; break; case TQt::Key_F18: m_virtKeyVal = DOM_VK_F18; break; case TQt::Key_F19: m_virtKeyVal = DOM_VK_F19; break; case TQt::Key_F20: m_virtKeyVal = DOM_VK_F20; break; case TQt::Key_F21: m_virtKeyVal = DOM_VK_F21; break; case TQt::Key_F22: m_virtKeyVal = DOM_VK_F22; break; case TQt::Key_F23: m_virtKeyVal = DOM_VK_F23; break; case TQt::Key_F24: m_virtKeyVal = DOM_VK_F24; break; default: m_virtKeyVal = DOM_VK_UNDEFINED; break; } // m_keyVal should contain the unicode value // of the pressed key if available. if (!key->text().isNull()) m_keyVal = TQString(key->text()).unicode()[0]; // m_numPad = ??? // key->state returns enum ButtonState, which is ShiftButton, ControlButton and AltButton or'ed together. m_modifier = key->state(); // key->text() returns the unicode sequence as a TQString m_outputString = DOM::DOMString(key->text()); } SVGKeyEventImpl::SVGKeyEventImpl(SVGEvent::EventId _id, bool canBubbleArg, bool cancelableArg, DOM::AbstractView &viewArg, unsigned short detailArg, DOM::DOMString &outputStringArg, unsigned long keyValArg, unsigned long virtKeyValArg, bool inputGeneratedArg, bool numPadArg) : SVGUIEventImpl(_id, canBubbleArg, cancelableArg, viewArg, detailArg) { qKeyEvent = 0; m_keyVal = keyValArg; m_virtKeyVal = virtKeyValArg; m_inputGenerated = inputGeneratedArg; m_outputString = outputStringArg; m_numPad = numPadArg; m_modifier = 0; } SVGKeyEventImpl::~SVGKeyEventImpl() { delete qKeyEvent; } bool SVGKeyEventImpl::checkModifier(unsigned long modifierArg) { return ((m_modifier && modifierArg) == modifierArg); } void SVGKeyEventImpl::initKeyEvent(DOM::DOMString &typeArg, bool canBubbleArg, bool cancelableArg, const DOM::AbstractView &viewArg, long detailArg, DOM::DOMString &outputStringArg, unsigned long keyValArg, unsigned long virtKeyValArg, bool inputGeneratedArg, bool numPadArg) { SVGUIEventImpl::initUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg); m_outputString = outputStringArg; m_keyVal = keyValArg; m_virtKeyVal = virtKeyValArg; m_inputGenerated = inputGeneratedArg; m_numPad = numPadArg; } void SVGKeyEventImpl::initModifier(unsigned long modifierArg, bool valueArg) { if(valueArg) m_modifier |= modifierArg; else m_modifier &= (modifierArg ^ 0xFFFFFFFF); } bool SVGKeyEventImpl::inputGenerated() const { return m_inputGenerated; } unsigned long SVGKeyEventImpl::keyVal() const { return m_keyVal; } DOM::DOMString SVGKeyEventImpl::outputString() const { return m_outputString; } /* @namespace KSVG @begin SVGKeyEventImpl::s_hashTable 7 keyVal SVGKeyEventImpl::KeyVal DontDelete|ReadOnly keyCode SVGKeyEventImpl::KeyVal DontDelete|ReadOnly charCode SVGKeyEventImpl::KeyVal DontDelete|ReadOnly outputString SVGKeyEventImpl::OutputString DontDelete|ReadOnly virtKeyVal SVGKeyEventImpl::VirtKeyVal DontDelete|ReadOnly # todo visibleOutputGenerated numPad @end @namespace KSVG @begin SVGKeyEventImplProto::s_hashTable 7 checkModifier SVGKeyEventImpl::CheckModifier DontDelete|Function 1 getKeyCode SVGKeyEventImpl::GetKeyVal DontDelete|Function 0 getCharCode SVGKeyEventImpl::GetKeyVal DontDelete|Function 0 getKeyVal SVGKeyEventImpl::GetKeyVal DontDelete|Function 0 getCharCode SVGKeyEventImpl::GetCharCode DontDelete|Function 0 # todo initModifier @end */ KSVG_IMPLEMENT_PROTOTYPE("SVGKeyEvent", SVGKeyEventImplProto, SVGKeyEventImplProtoFunc) Value SVGKeyEventImpl::getValueProperty(ExecState *, int token) const { switch(token) { case KeyVal: return Number(keyVal()); case VirtKeyVal: return Number(virtKeyVal()); case OutputString: return String(outputString()); default: kdWarning() << "Unhandled token in " << k_funcinfo << " : " << token << endl; return Undefined(); } } Value SVGKeyEventImplProtoFunc::call(ExecState *exec, Object &thisObj, const List &args) { KSVG_CHECK_THIS(SVGKeyEventImpl) switch(id) { case SVGKeyEventImpl::CheckModifier: return Boolean((static_cast *>(static_cast(thisObj.imp()))->impl())->checkModifier(args[0].toUInt32(exec))); case SVGKeyEventImpl::GetKeyVal: case SVGKeyEventImpl::GetCharCode: return Number((static_cast *>(static_cast(thisObj.imp()))->impl())->keyVal()); default: kdWarning() << "Unhandled function id in " << k_funcinfo << " : " << id << endl; break; } return Undefined(); } // ----------------------------------------------------------------------------- SVGMouseEventImpl::SVGMouseEventImpl() : SVGUIEventImpl() { m_screenX = 0; m_screenY = 0; m_clientX = 0; m_clientY = 0; m_ctrlKey = false; m_altKey = false; m_shiftKey = false; m_metaKey = false; m_button = 0; } SVGMouseEventImpl::SVGMouseEventImpl(SVGEvent::EventId _id, bool canBubbleArg, bool cancelableArg, DOM::AbstractView &viewArg, long detailArg, long screenXArg, long screenYArg, long clientXArg, long clientYArg, bool ctrlKeyArg, bool altKeyArg, bool shiftKeyArg, bool metaKeyArg, unsigned short buttonArg, SVGElementImpl *relatedTargetArg) : SVGUIEventImpl(_id, canBubbleArg, cancelableArg, viewArg, detailArg) { m_screenX = screenXArg; m_screenY = screenYArg; m_clientX = clientXArg; m_clientY = clientYArg; m_ctrlKey = ctrlKeyArg; m_altKey = altKeyArg; m_shiftKey = shiftKeyArg; m_metaKey = metaKeyArg; m_button = buttonArg; m_relatedTarget = relatedTargetArg; } SVGMouseEventImpl::~SVGMouseEventImpl() { } long SVGMouseEventImpl::screenX() const { return m_screenX; } long SVGMouseEventImpl::screenY() const { return m_screenY; } long SVGMouseEventImpl::clientX() const { return m_clientX; } long SVGMouseEventImpl::clientY() const { return m_clientY; } bool SVGMouseEventImpl::ctrlKey() const { return m_ctrlKey; } bool SVGMouseEventImpl::shiftKey() const { return m_shiftKey; } bool SVGMouseEventImpl::altKey() const { return m_altKey; } bool SVGMouseEventImpl::metaKey() const { return m_metaKey; } unsigned short SVGMouseEventImpl::button() const { return m_button; } SVGElementImpl *SVGMouseEventImpl::relatedTarget() const { return m_relatedTarget; } DOM::DOMString SVGMouseEventImpl::url() const { return m_url; } void SVGMouseEventImpl::setURL(DOM::DOMString url) { m_url = url; } void SVGMouseEventImpl::initMouseEvent(const DOM::DOMString &typeArg, bool canBubbleArg, bool cancelableArg, const DOM::AbstractView &viewArg, long detailArg, long screenXArg, long screenYArg, long clientXArg, long clientYArg, bool ctrlKeyArg, bool altKeyArg, bool shiftKeyArg, bool metaKeyArg, unsigned short buttonArg, SVGElementImpl *relatedTargetArg) { SVGUIEventImpl::initUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg); m_screenX = screenXArg; m_screenY = screenYArg; m_clientX = clientXArg; m_clientY = clientYArg; m_ctrlKey = ctrlKeyArg; m_altKey = altKeyArg; m_shiftKey = shiftKeyArg; m_metaKey = metaKeyArg; m_button = buttonArg; m_relatedTarget = relatedTargetArg; } /* @namespace KSVG @begin SVGMouseEventImpl::s_hashTable 11 screenX SVGMouseEventImpl::ScreenX DontDelete|ReadOnly screenY SVGMouseEventImpl::ScreenY DontDelete|ReadOnly clientX SVGMouseEventImpl::ClientX DontDelete|ReadOnly clientY SVGMouseEventImpl::ClientY DontDelete|ReadOnly ctrlKey SVGMouseEventImpl::CtrlKey DontDelete|ReadOnly shiftKey SVGMouseEventImpl::ShiftKey DontDelete|ReadOnly altKey SVGMouseEventImpl::AltKey DontDelete|ReadOnly metaKey SVGMouseEventImpl::MetaKey DontDelete|ReadOnly button SVGMouseEventImpl::Button DontDelete|ReadOnly relatedTarget SVGMouseEventImpl::RelatedTarget DontDelete|ReadOnly @end @namespace KSVG @begin SVGMouseEventImplProto::s_hashTable 13 getScreenX SVGMouseEventImpl::GetScreenX DontDelete|Function 0 getScreenY SVGMouseEventImpl::GetScreenY DontDelete|Function 0 getClientX SVGMouseEventImpl::GetClientX DontDelete|Function 0 getClientY SVGMouseEventImpl::GetClientY DontDelete|Function 0 getCtrlKey SVGMouseEventImpl::GetCtrlKey DontDelete|Function 0 getShiftKey SVGMouseEventImpl::GetShiftKey DontDelete|Function 0 getAltKey SVGMouseEventImpl::GetAltKey DontDelete|Function 0 getMetaKey SVGMouseEventImpl::GetMetaKey DontDelete|Function 0 getButton SVGMouseEventImpl::GetButton DontDelete|Function 0 getRelatedTarget SVGMouseEventImpl::GetRelatedTarget DontDelete|Function 0 initMouseEvent SVGMouseEventImpl::InitMouseEvent DontDelete|Function 15 @end */ KSVG_IMPLEMENT_PROTOTYPE("SVGMouseEvent", SVGMouseEventImplProto, SVGMouseEventImplProtoFunc) Value SVGMouseEventImpl::getValueProperty(ExecState *exec, int token) const { kdDebug(26004) << k_funcinfo << endl; switch(token) { case ScreenX: return Number(screenX()); case ScreenY: return Number(screenY()); case ClientX: return Number(clientX()); case ClientY: return Number(clientY()); case CtrlKey: return Number(ctrlKey()); case ShiftKey: return Number(shiftKey()); case AltKey: return Number(altKey()); case MetaKey: return Number(metaKey()); case Button: return Number(button()); case RelatedTarget: return getDOMNode(exec, *relatedTarget()); default: kdWarning() << "Unhandled token in " << k_funcinfo << " : " << token << endl; return KJS::Undefined(); } } Value SVGMouseEventImplProtoFunc::call(ExecState *exec, Object &thisObj, const List &) { kdDebug(26004) << k_funcinfo << endl; KSVG_CHECK_THIS(SVGMouseEventImpl) switch(id) { case SVGMouseEventImpl::GetScreenX: return Number(obj->screenX()); case SVGMouseEventImpl::GetScreenY: return Number(obj->screenY()); case SVGMouseEventImpl::GetClientX: return Number(obj->clientX()); case SVGMouseEventImpl::GetClientY: return Number(obj->clientY()); case SVGMouseEventImpl::GetCtrlKey: return Number(obj->ctrlKey()); case SVGMouseEventImpl::GetShiftKey: return Number(obj->shiftKey()); case SVGMouseEventImpl::GetAltKey: return Number(obj->altKey()); case SVGMouseEventImpl::GetMetaKey: return Number(obj->metaKey()); case SVGMouseEventImpl::GetButton: return Number(obj->button()); case SVGMouseEventImpl::GetRelatedTarget: return getDOMNode(exec, *obj->relatedTarget()); // case SVGMouseEventImpl::InitMouseEvent: // TODO default: kdWarning() << "Unhandled function id in " << k_funcinfo << " : " << id << endl; break; } return Undefined(); } SVGMutationEventImpl::SVGMutationEventImpl() : SVGEventImpl() { m_attrChange = 0; } SVGMutationEventImpl::SVGMutationEventImpl(SVGEvent::EventId _id, bool canBubbleArg, bool cancelableArg, SVGElementImpl *relatedNodeArg, const DOM::DOMString &prevValueArg, const DOM::DOMString &newValueArg, const DOM::DOMString &attrNameArg, unsigned short attrChangeArg) : SVGEventImpl(_id, canBubbleArg, cancelableArg) { m_relatedNode = relatedNodeArg; m_prevValue = prevValueArg.implementation(); m_newValue = newValueArg.implementation(); m_attrName = attrNameArg.implementation(); m_attrChange = attrChangeArg; } SVGMutationEventImpl::~SVGMutationEventImpl() { } SVGElementImpl *SVGMutationEventImpl::relatedNode() const { return m_relatedNode; } DOM::DOMString SVGMutationEventImpl::prevValue() const { return m_prevValue; } DOM::DOMString SVGMutationEventImpl::newValue() const { return m_newValue; } DOM::DOMString SVGMutationEventImpl::attrName() const { return m_attrName; } unsigned short SVGMutationEventImpl::attrChange() const { return m_attrChange; } void SVGMutationEventImpl::initMutationEvent(const DOM::DOMString &typeArg, bool canBubbleArg, bool cancelableArg, SVGElementImpl *relatedNodeArg, const DOM::DOMString &prevValueArg, const DOM::DOMString &newValueArg, const DOM::DOMString &attrNameArg, unsigned short attrChangeArg) { SVGEventImpl::initEvent(typeArg, canBubbleArg, cancelableArg); m_relatedNode = relatedNodeArg; m_prevValue = prevValueArg.implementation(); m_newValue = newValueArg.implementation(); m_attrName = attrNameArg.implementation(); m_attrChange = attrChangeArg; } SVGRegisteredEventListener::SVGRegisteredEventListener(SVGEvent::EventId _id, SVGEventListener *_listener, bool _useCapture) { id = _id; listener = _listener; useCapture = _useCapture; listener->ref(); } SVGRegisteredEventListener::~SVGRegisteredEventListener() { listener->deref(); } bool SVGRegisteredEventListener::operator==(const SVGRegisteredEventListener &other) { return (id == other.id && listener == other.listener && useCapture == other.useCapture); } // vim:ts=4:noet