dom2_events.cpp
#include "dom/dom2_views.h"
#include "dom/dom_exception.h"
#include "xml/dom2_eventsimpl.h"
using namespace DOM;
EventListener::EventListener()
{
}
EventListener::~EventListener()
{
}
void EventListener::handleEvent(Event &/*evt*/)
{
}
DOMString EventListener::eventListenerType()
{
return "";
}
// -----------------------------------------------------------------------------
Event::Event()
{
impl = 0;
}
Event::Event(const Event &other)
{
impl = other.impl;
if (impl) impl->ref();
}
Event::Event(EventImpl *i)
{
impl = i;
if (impl) impl->ref();
}
Event::~Event()
{
if (impl) impl->deref();
}
Event &Event::operator = (const Event &other)
{
if ( impl != other.impl ) {
if(impl) impl->deref();
impl = other.impl;
if(impl) impl->ref();
}
return *this;
}
DOMString Event::type() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return impl->type();
}
Node Event::target() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return impl->target();
}
Node Event::currentTarget() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return impl->currentTarget();
}
unsigned short Event::eventPhase() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return impl->eventPhase();
}
bool Event::bubbles() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return impl->bubbles();
}
bool Event::cancelable() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return impl->cancelable();
}
DOMTimeStamp Event::timeStamp() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return impl->timeStamp();
}
void Event::stopPropagation()
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
impl->stopPropagation(true);
}
void Event::preventDefault()
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
impl->preventDefault(true);
}
void Event::initEvent(const DOMString &eventTypeArg, bool canBubbleArg, bool cancelableArg)
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
impl->initEvent(eventTypeArg,canBubbleArg,cancelableArg);
}
EventImpl *Event::handle() const
{
return impl;
}
bool Event::isNull() const
{
return (impl == 0);
}
// -----------------------------------------------------------------------------
#ifndef SAVE_SPACE
EventException::EventException(unsigned short _code)
{
code = _code;
}
EventException::EventException(const EventException &other)
{
code = other.code;
}
EventException & EventException::operator = (const EventException &other)
{
code = other.code;
return *this;
}
#endif
// -----------------------------------------------------------------------------
UIEvent::UIEvent() : Event()
{
}
UIEvent::UIEvent(const UIEvent &other) : Event(other)
{
}
UIEvent::UIEvent(const Event &other) : Event()
{
(*this)=other;
}
UIEvent::UIEvent(UIEventImpl *impl) : Event(impl)
{
}
UIEvent &UIEvent::operator = (const UIEvent &other)
{
Event::operator = (other);
return *this;
}
UIEvent &UIEvent::operator = (const Event &other)
{
Event e;
e = other;
if (!e.isNull() && !e.handle()->isUIEvent()) {
if ( impl ) impl->deref();
impl = 0;
} else
Event::operator = (other);
return *this;
}
UIEvent::~UIEvent()
{
}
AbstractView UIEvent::view() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<UIEventImpl*>(impl)->view();
}
long UIEvent::detail() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<UIEventImpl*>(impl)->detail();
}
int UIEvent::keyCode() const
{
if ( !impl ) throw DOMException( DOMException::INVALID_STATE_ERR );
if( impl->isTextInputEvent() || impl->isKeyboardEvent() )
return static_cast<KeyEventBaseImpl*>( impl )->keyCode();
return 0;
}
int UIEvent::charCode() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
if( impl->isTextInputEvent() || impl->isKeyboardEvent() )
return static_cast<KeyEventBaseImpl*>( impl )->charCode();
return 0;
}
int UIEvent::pageX() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
if (impl->isMouseEvent() )
return static_cast<MouseEventImpl*>( impl )->pageX();
else
return 0;
}
int UIEvent::pageY() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
if ( impl->isMouseEvent() )
return static_cast<MouseEventImpl*>( impl )->pageY();
else
return 0;
}
int UIEvent::layerX() const
{
if( !impl )
throw DOMException( DOMException::INVALID_STATE_ERR );
if( impl->isMouseEvent() )
return static_cast<MouseEventImpl*>( impl )->layerX();
return 0;
}
int UIEvent::layerY() const
{
if( !impl )
throw DOMException( DOMException::INVALID_STATE_ERR );
if( impl->isMouseEvent() )
return static_cast<MouseEventImpl*>( impl )->layerY();
return 0;
}
int UIEvent::which() const
{
if( !impl ) throw DOMException( DOMException::INVALID_STATE_ERR );
if( impl->isMouseEvent() )
return static_cast<MouseEventImpl*>( impl )->button() + 1;
else if( impl->isTextInputEvent() || impl->isKeyboardEvent() )
{
// return 0 unless the key has an ascii value
if ( static_cast<KeyEventBaseImpl*>( impl )->keyVal() )
return static_cast<KeyEventBaseImpl*>( impl )->keyCode();
}
return 0;
}
void UIEvent::initUIEvent(const DOMString &typeArg,
bool canBubbleArg,
bool cancelableArg,
const AbstractView &viewArg,
long detailArg)
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
static_cast<UIEventImpl*>(impl)->initUIEvent(typeArg,canBubbleArg,cancelableArg,
viewArg,detailArg);
}
// -----------------------------------------------------------------------------
MouseEvent::MouseEvent() : UIEvent()
{
}
MouseEvent::MouseEvent(const MouseEvent &other) : UIEvent(other)
{
}
MouseEvent::MouseEvent(const Event &other) : UIEvent()
{
(*this)=other;
}
MouseEvent::MouseEvent(MouseEventImpl *impl) : UIEvent(impl)
{
}
MouseEvent &MouseEvent::operator = (const MouseEvent &other)
{
UIEvent::operator = (other);
return *this;
}
MouseEvent &MouseEvent::operator = (const Event &other)
{
Event e;
e = other;
if (!e.isNull() && !e.handle()->isMouseEvent()) {
if ( impl ) impl->deref();
impl = 0;
} else
UIEvent::operator = (other);
return *this;
}
MouseEvent::~MouseEvent()
{
}
long MouseEvent::screenX() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<MouseEventImpl*>(impl)->screenX();
}
long MouseEvent::screenY() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<MouseEventImpl*>(impl)->screenY();
}
long MouseEvent::clientX() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<MouseEventImpl*>(impl)->clientX();
}
long MouseEvent::clientY() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<MouseEventImpl*>(impl)->clientY();
}
bool MouseEvent::ctrlKey() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<MouseEventImpl*>(impl)->ctrlKey();
}
bool MouseEvent::shiftKey() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<MouseEventImpl*>(impl)->shiftKey();
}
bool MouseEvent::altKey() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<MouseEventImpl*>(impl)->altKey();
}
bool MouseEvent::metaKey() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<MouseEventImpl*>(impl)->metaKey();
}
unsigned short MouseEvent::button() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<MouseEventImpl*>(impl)->button();
}
Node MouseEvent::relatedTarget() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<MouseEventImpl*>(impl)->relatedTarget();
}
void MouseEvent::initMouseEvent(const DOMString &typeArg,
bool canBubbleArg,
bool cancelableArg,
const AbstractView &viewArg,
long detailArg,
long screenXArg,
long screenYArg,
long clientXArg,
long clientYArg,
bool ctrlKeyArg,
bool altKeyArg,
bool shiftKeyArg,
bool metaKeyArg,
unsigned short buttonArg,
const Node &relatedTargetArg)
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
static_cast<MouseEventImpl*>(impl)->initMouseEvent(typeArg,canBubbleArg,
cancelableArg,viewArg,detailArg,screenXArg,screenYArg,clientXArg,
clientYArg,ctrlKeyArg,altKeyArg,shiftKeyArg,metaKeyArg,buttonArg,
relatedTargetArg);
}
// -----------------------------------------------------------------------------
TextEvent::TextEvent() : UIEvent()
{
}
TextEvent::TextEvent(const TextEvent &other) : UIEvent(other)
{
}
TextEvent::TextEvent(const Event &other) : UIEvent()
{
(*this)=other;
}
TextEvent::TextEvent(KeyEventBaseImpl *impl) : UIEvent(impl)
{
}
TextEvent &TextEvent::operator = (const TextEvent &other)
{
UIEvent::operator = (other);
return *this;
}
TextEvent &TextEvent::operator = (const Event &other)
{
Event e;
e = other;
if (!e.isNull() && !(e.handle()->isTextInputEvent() || e.handle()->isKeyboardEvent())) {
if ( impl ) impl->deref();
impl = 0;
} else
UIEvent::operator = (other);
return *this;
}
TextEvent::~TextEvent()
{
}
void TextEvent::initTextEvent(const DOMString &typeArg,
bool canBubbleArg,
bool cancelableArg,
const AbstractView &viewArg,
long /*detailArg*/,
const DOMString &outputStringArg,
unsigned long keyValArg,
unsigned long virtKeyValArg,
bool /*inputGeneratedArg*/,
bool numPadArg)
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
if (impl->isTextInputEvent()) {
//Initialize based on the outputStringArg or virtKeyValArg.
QString text = outputStringArg.string();
if (outputStringArg.length() == 0 && virtKeyValArg) {
text += QChar((unsigned short)virtKeyValArg);
}
TextEventImpl* tImpl = static_cast<TextEventImpl*>(impl);
tImpl->initTextEvent(typeArg, canBubbleArg, cancelableArg, viewArg, text);
} else {
KeyboardEventImpl* kbImpl = static_cast<KeyboardEventImpl*>(impl);
kbImpl->initKeyboardEvent(typeArg, canBubbleArg, cancelableArg, viewArg,
keyValArg, virtKeyValArg, 0, numPadArg ?
KeyboardEventImpl::DOM_KEY_LOCATION_NUMPAD : KeyboardEventImpl::DOM_KEY_LOCATION_STANDARD);
}
}
unsigned long TextEvent::keyVal() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<KeyEventBaseImpl*>(impl)->keyVal();
}
DOMString TextEvent::outputString() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
KeyEventBaseImpl* ke = static_cast<KeyEventBaseImpl*>(impl);
if (ke->isTextInputEvent())
return static_cast<TextEventImpl*>(ke)->data();
else {
if (ke->keyVal())
return QString(QChar((ushort)ke->keyVal()));
else
return DOMString();
}
}
unsigned long TextEvent::virtKeyVal() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<KeyEventBaseImpl*>(impl)->virtKeyVal();
}
void TextEvent::initModifier(unsigned long modifierArg, bool valueArg)
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<KeyEventBaseImpl*>(impl)->initModifier(modifierArg,valueArg);
}
bool TextEvent::checkModifier(unsigned long modifierArg)
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<KeyEventBaseImpl*>(impl)->checkModifier(modifierArg);
}
bool TextEvent::inputGenerated() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<KeyEventBaseImpl*>(impl)->inputGenerated();
}
bool TextEvent::numPad() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
KeyEventBaseImpl* ke = static_cast<KeyEventBaseImpl*>(impl);
if (ke->isKeyboardEvent())
return static_cast<KeyboardEventImpl*>(ke)->keyLocation() ==
KeyboardEventImpl::DOM_KEY_LOCATION_NUMPAD;
else return false;
}
// -----------------------------------------------------------------------------
MutationEvent::MutationEvent() : Event()
{
}
MutationEvent::MutationEvent(const MutationEvent &other) : Event(other)
{
}
MutationEvent::MutationEvent(const Event &other) : Event()
{
(*this)=other;
}
MutationEvent::MutationEvent(MutationEventImpl *impl) : Event(impl)
{
}
MutationEvent &MutationEvent::operator = (const MutationEvent &other)
{
Event::operator = (other);
return *this;
}
MutationEvent &MutationEvent::operator = (const Event &other)
{
Event e;
e = other;
if (!e.isNull() && !e.handle()->isMutationEvent()) {
if ( impl ) impl->deref();
impl = 0;
} else
Event::operator = (other);
return *this;
}
MutationEvent::~MutationEvent()
{
}
Node MutationEvent::relatedNode() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<MutationEventImpl*>(impl)->relatedNode();
}
DOMString MutationEvent::prevValue() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<MutationEventImpl*>(impl)->prevValue();
}
DOMString MutationEvent::newValue() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<MutationEventImpl*>(impl)->newValue();
}
DOMString MutationEvent::attrName() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<MutationEventImpl*>(impl)->attrName();
}
unsigned short MutationEvent::attrChange() const
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
return static_cast<MutationEventImpl*>(impl)->attrChange();
}
void MutationEvent::initMutationEvent(const DOMString &typeArg,
bool canBubbleArg,
bool cancelableArg,
const Node &relatedNodeArg,
const DOMString &prevValueArg,
const DOMString &newValueArg,
const DOMString &attrNameArg,
unsigned short attrChangeArg)
{
if (!impl)
throw DOMException(DOMException::INVALID_STATE_ERR);
static_cast<MutationEventImpl*>(impl)->initMutationEvent(typeArg,
canBubbleArg,cancelableArg,relatedNodeArg,prevValueArg,
newValueArg,attrNameArg,attrChangeArg);
}
DOM::EventListener::handleEvent
virtual void handleEvent(Event &evt)
This method is called whenever an event occurs of the type for which the EventListener interface was ...
Definition: dom2_events.cpp:37
DOM::UIEvent::layerX
int layerX() const
Non-standard extensions to support Netscape-style layerX and layerY event properties.
Definition: dom2_events.cpp:293
DOM::Event::type
DOMString type() const
The name of the event (case-insensitive).
Definition: dom2_events.cpp:81
DOM::TextEvent::inputGenerated
bool inputGenerated() const
inputGenerated of type boolean
Definition: dom2_events.cpp:608
DOM::Node
The Node interface is the primary datatype for the entire Document Object Model.
Definition: dom_node.h:274
DOM::UIEvent::detail
long detail() const
Specifies some detail information about the Event, depending on the type of event.
Definition: dom2_events.cpp:242
DOM::Event::target
Node target() const
Used to indicate the EventTarget to which the event was originally dispatched.
Definition: dom2_events.cpp:89
DOM::TextEvent::keyVal
unsigned long keyVal() const
keyVal of type unsigned long
Definition: dom2_events.cpp:560
DOM::MouseEvent::clientY
long clientY() const
The vertical coordinate at which the event occurred relative to the DOM implementation's client area...
Definition: dom2_events.cpp:407
DOM::TextEvent::outputString
DOMString outputString() const
outputString of type DOMString
Definition: dom2_events.cpp:568
DOM::Event::bubbles
bool bubbles() const
Used to indicate whether or not an event is a bubbling event.
Definition: dom2_events.cpp:113
DOM::AbstractView
Introduced in DOM Level 2.
Definition: dom2_views.h:41
DOM::UIEvent
Introduced in DOM Level 2.
Definition: dom2_events.h:294
DOM::TextEvent::virtKeyVal
unsigned long virtKeyVal() const
virtKeyVal of type unsigned long
Definition: dom2_events.cpp:584
DOM::MutationEvent::relatedNode
Node relatedNode() const
relatedNode is used to identify a secondary node related to a mutation event.
Definition: dom2_events.cpp:668
DOM::MouseEvent
Introduced in DOM Level 2.
Definition: dom2_events.h:399
DOM::UIEvent::view
AbstractView view() const
The view attribute identifies the AbstractView from which the event was generated.
Definition: dom2_events.cpp:234
DOM::TextEvent::initTextEvent
void initTextEvent(const DOMString &typeArg, bool canBubbleArg, bool cancelableArg, const AbstractView &viewArg, long detailArg, const DOMString &outputStringArg, unsigned long keyValArg, unsigned long virtKeyValArg, bool inputGeneratedArg, bool numPadArg)
initTextEvent
Definition: dom2_events.cpp:529
DOM::UIEvent::charCode
int charCode() const
Non-standard extension to support IE-style charCode event property.
Definition: dom2_events.cpp:260
DOM::TextEvent::checkModifier
bool checkModifier(unsigned long modifierArg)
checkModifier
Definition: dom2_events.cpp:600
DOM::Event::timeStamp
DOMTimeStamp timeStamp() const
Used to specify the time (in milliseconds relative to the epoch) at which the event was created...
Definition: dom2_events.cpp:129
DOM::DOMException
DOM operations only raise exceptions in "exceptional" circumstances, i.e., when an operation is impos...
Definition: dom_exception.h:57
DOM::MouseEvent::ctrlKey
bool ctrlKey() const
Used to indicate whether the 'ctrl' key was depressed during the firing of the event.
Definition: dom2_events.cpp:415
DOM::Event::cancelable
bool cancelable() const
Used to indicate whether or not an event can have its default action prevented.
Definition: dom2_events.cpp:121
DOM::EventException
Introduced in DOM Level 2:
Definition: dom2_events.h:262
DOM::MouseEvent::relatedTarget
Node relatedTarget() const
Used to identify a secondary EventTarget related to a UI event.
Definition: dom2_events.cpp:455
DOM::MouseEvent::shiftKey
bool shiftKey() const
Used to indicate whether the 'shift' key was depressed during the firing of the event.
Definition: dom2_events.cpp:423
DOM::Event::preventDefault
void preventDefault()
If an event is cancelable, the preventDefault method is used to signify that the event is to be cance...
Definition: dom2_events.cpp:145
DOM::UIEvent::initUIEvent
void initUIEvent(const DOMString &typeArg, bool canBubbleArg, bool cancelableArg, const AbstractView &viewArg, long detailArg)
The initUIEvent method is used to initialize the value of a UIEvent created through the DocumentEvent...
Definition: dom2_events.cpp:329
DOM::UIEvent::keyCode
int keyCode() const
Non-standard extension to support IE-style keyCode event property.
Definition: dom2_events.cpp:250
DOM::TextEvent
DOM::TextEvent The detail attribute inherited from UIEvent is used to indicate the number of keypress...
Definition: dom2_events.h:555
DOM::Event::eventPhase
unsigned short eventPhase() const
Used to indicate which phase of event flow is currently being evaluated.
Definition: dom2_events.cpp:105
DOM::MouseEvent::altKey
bool altKey() const
Used to indicate whether the 'alt' key was depressed during the firing of the event.
Definition: dom2_events.cpp:431
DOM::DOMString
This class implements the basic string we use in the DOM.
Definition: dom_string.h:43
DOM::MutationEvent::initMutationEvent
void initMutationEvent(const DOMString &typeArg, bool canBubbleArg, bool cancelableArg, const Node &relatedNodeArg, const DOMString &prevValueArg, const DOMString &newValueArg, const DOMString &attrNameArg, unsigned short attrChangeArg)
The initMutationEvent method is used to initialize the value of a MutationEvent created through the D...
Definition: dom2_events.cpp:708
DOM::MutationEvent
Introduced in DOM Level 2.
Definition: dom2_events.h:738
DOM::MouseEvent::button
unsigned short button() const
During mouse events caused by the depression or release of a mouse button, button is used to indicate...
Definition: dom2_events.cpp:447
DOM::MutationEvent::attrChange
unsigned short attrChange() const
attrChange indicates the type of change which triggered the DOMAttrModified event.
Definition: dom2_events.cpp:700
DOM::Event::initEvent
void initEvent(const DOMString &eventTypeArg, bool canBubbleArg, bool cancelableArg)
The initEvent method is used to initialize the value of an Event created through the DocumentEvent in...
Definition: dom2_events.cpp:153
DOM::MutationEvent::prevValue
DOMString prevValue() const
prevValue indicates the previous value of the Attr node in DOMAttrModified events, and of the CharacterData node in DOMCharDataModified events.
Definition: dom2_events.cpp:676
DOM::MouseEvent::metaKey
bool metaKey() const
Used to indicate whether the 'meta' key was depressed during the firing of the event.
Definition: dom2_events.cpp:439
DOM::MutationEvent::newValue
DOMString newValue() const
newValue indicates the new value of the Attr node in DOMAttrModified events, and of the CharacterData...
Definition: dom2_events.cpp:684
DOM::Event
Introduced in DOM Level 2.
Definition: dom2_events.h:111
DOM::MouseEvent::screenX
long screenX() const
The horizontal coordinate at which the event occurred relative to the origin of the screen coordinate...
Definition: dom2_events.cpp:383
DOM::UIEvent::which
int which() const
Non-standard extension to support Netscape-style "which" event property.
Definition: dom2_events.cpp:313
DOM::MutationEvent::attrName
DOMString attrName() const
attrName indicates the name of the changed Attr node in a DOMAttrModified event.
Definition: dom2_events.cpp:692
DOM::MouseEvent::initMouseEvent
void initMouseEvent(const DOMString &typeArg, bool canBubbleArg, bool cancelableArg, const AbstractView &viewArg, long detailArg, long screenXArg, long screenYArg, long clientXArg, long clientYArg, bool ctrlKeyArg, bool altKeyArg, bool shiftKeyArg, bool metaKeyArg, unsigned short buttonArg, const Node &relatedTargetArg)
The initMouseEvent method is used to initialize the value of a MouseEvent created through the Documen...
Definition: dom2_events.cpp:463
DOM::DOMTimeStamp
unsigned long long DOMTimeStamp
A DOMTimeStamp represents a number of milliseconds.
Definition: dom_node.h:987
DOM::Event::currentTarget
Node currentTarget() const
Used to indicate the EventTarget whose EventListeners are currently being processed.
Definition: dom2_events.cpp:97
DOM::TextEvent::numPad
bool numPad() const
numPad of type boolean
Definition: dom2_events.cpp:616
DOM::MouseEvent::clientX
long clientX() const
The horizontal coordinate at which the event occurred relative to the DOM implementation's client are...
Definition: dom2_events.cpp:399
DOM::TextEvent::initModifier
void initModifier(unsigned long modifierArg, bool valueArg)
initModifier
Definition: dom2_events.cpp:592
DOM::MouseEvent::screenY
long screenY() const
The vertical coordinate at which the event occurred relative to the origin of the screen coordinate s...
Definition: dom2_events.cpp:391
DOM::UIEvent::pageX
int pageX() const
Non-standard extensions to support Netscape-style pageX and pageY event properties.
Definition: dom2_events.cpp:271
DOM::Event::stopPropagation
void stopPropagation()
The stopPropagation method is used prevent further propagation of an event during event flow...
Definition: dom2_events.cpp:137

KDE Home | KDE Accessibility Home | Description of Access Keys