You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
991 lines
24 KiB
991 lines
24 KiB
/*
|
|
Copyright (C) 2001-2003 KSVG Team
|
|
This file is part of the KDE project
|
|
|
|
Additional copyright:
|
|
(C) 2001 Peter Kelly <pmk@post.com>
|
|
(C) 2001 Tobias Anton <anton@stud.fbi.fh-darmstadt.de>
|
|
|
|
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 <kdebug.h>
|
|
|
|
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<KSVGBridge<SVGKeyEventImpl> *>(static_cast<ObjectImp *>(thisObj.imp()))->impl())->checkModifier(args[0].toUInt32(exec)));
|
|
case SVGKeyEventImpl::GetKeyVal:
|
|
case SVGKeyEventImpl::GetCharCode:
|
|
return Number((static_cast<KSVGBridge<SVGKeyEventImpl> *>(static_cast<ObjectImp *>(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);
|
|
}
|