Please say somethingYou don't have the authorization!Connection errorConnection errorUnknown error
Event listeners can only be registered on Element nodes, i.e. other Node
types are not addressable, and cannot be registered for a specific group
either, i.e. they are always attached to the default group. The target phase
and the bubbling phase are coupled during the registration. [VoiceXML 2.0]
does not address namespaces in event types but uses the notion of event
categories. The event type "connection.disconnect.hangup" could be
associated to the event categories {"http://www.example.org/2003/voicexml",
"connection"} and {"http://www.example.org/2003/voicexml",
"connection.disconnect"}.
1.5.4. Using XML or HTML attributes
In languages such as [HTML 4.01], [XHTML 1.0], or [SVG 1.0], event listeners
are specified as attributes:
Since only one attribute with the same name can appear on an element, it is
therefore not possible to register more than one event listener on a single
EventTarget for the event type. Also, event listeners can only be registered
on Element nodes for the target phase and bubbling phase, i.e. other Node
types and the capture phase are not addressable with these languages. Event
listeners cannot be registered for a specific group either, i.e. they are
always attached to the default group.
In order to achieve compatibility with those languages, implementors may
view the setting of attributes which represent event handlers as the
creation and registration of an EventListener on the EventTarget. The value
of useCapture defaults to false. This EventListener behaves in the same
manner as any other EventListeners which may be registered on the
EventTarget. If the attribute representing the event listener is changed,
this may be viewed as the removal of the previously registered EventListener
and the registration of a new one. Furthermore, no specification is made as
to the order in which event attributes will receive the event with regards
to the other EventListeners on the EventTarget.
1.6. Basic interfaces
The interfaces described in this section are fundamental to DOM Level 3
Events and must always be supported by the implementation.
Interface Event (introduced in DOM Level 2)
The Event interface is used to provide contextual information about an
event to the listener processing the event. An object which implements
the Event interface is passed as the parameter to an EventListener.
More specific context information is passed to event listeners by
deriving additional interfaces from Event which contain information
directly relating to the type of event they represent. These derived
interfaces are also implemented by the object passed to the event
listener.
IDL Definition
// Introduced in DOM Level 2:
interface Event {
// PhaseType
const unsigned short CAPTURING_PHASE = 1;
const unsigned short AT_TARGET = 2;
const unsigned short BUBBLING_PHASE = 3;
readonly attribute DOMString type;
readonly attribute EventTarget target;
readonly attribute EventTarget currentTarget;
readonly attribute unsigned short eventPhase;
readonly attribute boolean bubbles;
readonly attribute boolean cancelable;
readonly attribute DOMTimeStamp timeStamp;
void stopPropagation();
void preventDefault();
void initEvent(in DOMString eventTypeArg,
in boolean canBubbleArg,
in boolean cancelableArg);
// Introduced in DOM Level 3:
readonly attribute DOMString namespaceURI;
// Introduced in DOM Level 3:
boolean isCustom();
// Introduced in DOM Level 3:
void stopImmediatePropagation();
// Introduced in DOM Level 3:
boolean isDefaultPrevented();
// Introduced in DOM Level 3:
void initEventNS(in DOMString namespaceURIArg,
in DOMString eventTypeArg,
in boolean canBubbleArg,
in boolean cancelableArg);
};
Definition group PhaseType
An integer indicating which phase of the event flow is being
processed as defined in DOM event flow.
Defined Constants
AT_TARGET
The current event is in the target phase, i.e. it is
being evaluated at the event target.
BUBBLING_PHASE
The current event phase is the bubbling phase.
CAPTURING_PHASE
The current event phase is the capture phase.
Attributes
bubbles of type boolean, readonly
Used to indicate whether or not an event is a bubbling event.
If the event can bubble the value is true, otherwise the
value is false.
cancelable of type boolean, readonly
Used to indicate whether or not an event can have its default
action prevented (see also Default actions and cancelable
events). If the default action can be prevented the value is
true, otherwise the value is false.
currentTarget of type EventTarget, readonly
Used to indicate the EventTarget whose EventListeners are
currently being processed. This is particularly useful during
the capture and bubbling phases. This attribute could contain
the target node or a target ancestor when used with the DOM
event flow.
eventPhase of type unsigned short, readonly
Used to indicate which phase of event flow is currently being
accomplished.
namespaceURI of type DOMString, readonly, introduced in DOM Level
3
The namespace URI associated with this event at creation
time, or null if it is unspecified.
For events initialized with a DOM Level 2 Events method, such
as initEvent, this is always null.
target of type EventTarget, readonly
Used to indicate the event target. This attribute contain the
target node when used with the DOM event flow.
timeStamp of type DOMTimeStamp, readonly
Used to specify the time (in milliseconds relative to the
epoch) at which the event was created. Due to the fact that
some systems may not provide this information the value of
timeStamp may be not available for all events. When not
available, a value of 0 will be returned. Examples of epoch
time are the time of the system start or 0:0:0 UTC 1st
January 1970.
type of type DOMString, readonly
The name must be an NCName as defined in [XML Namespaces] and
is case-sensitive. The character ":" (colon) should not be
used in this attribute.
If the attribute Event.namespaceURI is different from null,
this attribute represents a local name.
Methods
initEvent
The initEvent method is used to initialize the value of an
Event created through the DocumentEvent.createEvent method.
This method may only be called before the Event has been
dispatched via the EventTarget.dispatchEvent method. If the
method is called several times before invoking
EventTarget.dispatchEvent, only the final invocation takes
precedence. If called from a subclass of Event interface only
the values specified in this method are modified, all other
attributes are left unchanged.
This method sets the Event.type attribute to eventTypeArg,
and Event.localName and Event.namespaceURI to null. To
initialize an event with a local name and namespace URI, use
the initEventNS method.
Parameters
eventTypeArg of type DOMString
Specifies the event type.
canBubbleArg of type boolean
Specifies whether or not the event can bubble. This
parameter overrides the intrinsic bubbling behavior of
the event.
cancelableArg of type boolean
Specifies whether or not the event's default action can
be prevented. This parameter overrides the intrinsic
cancelable behavior of the event.
No Return Value
No Exceptions
initEventNS introduced in DOM Level 3
The initEventNS method is used to initialize the value of an
Event created through the DocumentEvent interface. This
method may only be called before the Event has been
dispatched via the dispatchEvent method, though it may be
called multiple times the event has been dispatched. If
called multiple times the final invocation takes precedence.
If a call to initEventNS is made after one of the Event
derived interfaces' init methods has been called, only the
values specified in the initEventNS method are modified, all
other attributes are left unchanged.
This method sets the Event.type attribute to eventTypeArg,
and Event.namespaceURI to namespaceURIArg.
Parameters
namespaceURIArg of type DOMString
Specifies the namespace URI associated with this event,
or null if no namespace.
eventTypeArg of type DOMString
Specifies the local name of the event type (see also the
description of Event.type).
canBubbleArg of type boolean
Specifies whether or not the event can bubble.
cancelableArg of type boolean
Specifies whether or not the event's default action can
be prevented.
No Return Value
No Exceptions
isCustom introduced in DOM Level 3
This method will always return false, unless the event
implements the CustomEvent interface.
Return Value
boolean true if preventDefault() has been called for this
event.
No Parameters
No Exceptions
isDefaultPrevented introduced in DOM Level 3
This method will return true if the method preventDefault()
has been called for this event, false otherwise.
Return Value
boolean true if preventDefault() has been called for this
event.
No Parameters
No Exceptions
preventDefault
If an event is cancelable, the preventDefault method is used
to signify that the event is to be canceled, meaning any
default action normally taken by the implementation as a
result of the event will not occur (see also Default actions
and cancelable events), and thus independently of event
groups. Calling this method for a non-cancelable event has no
effect.
Note: This method does not stop the event propagation; use
stopPropagation or stopImmediatePropagation for that effect.
No Parameters
No Return Value
No Exceptions
stopImmediatePropagation introduced in DOM Level 3
This method is used to prevent event listeners of the same
group to be triggered and, unlike stopPropagation its effect
is immediate (see Event propagation and event groups). Once
it has been called, further calls to that method have no
additional effect.
Note: This method does not prevent the default action from
being invoked; use preventDefault for that effect.
No Parameters
No Return Value
No Exceptions
stopPropagation
This method is used to prevent event listeners of the same
group to be triggered but its effect is differed until all
event listeners attached on the currentTarget have been
triggered (see Event propagation and event groups). Once it
has been called, further calls to that method have no
additional effect.
Note: This method does not prevent the default action from
being invoked; use preventDefault for that effect.
No Parameters
No Return Value
No Exceptions
Interface EventTarget (introduced in DOM Level 2)
The EventTarget interface is implemented by all the objects which could
be event targets in an implementation which supports the Event flows.
The interface allows registration, removal or query of event listeners,
and dispatch of events to an event target.
When used with DOM event flow, this interface is implemented by all
target nodes and target ancestors, i.e. all DOM Nodes of the tree
support this interface when the implementation conforms to DOM Level 3
Events and, therefore, this interface can be obtained by using
binding-specific casting methods on an instance of the Node interface.
Invoking multiple times addEventListener or addEventListenerNS on the
same EventTarget with the same parameters (namespaceURI, type,
listener, and useCapture) is considered to be a no-op and thus
independently of the event group. They do not cause the EventListener
to be called more than once and do not cause a change in the triggering
order. In order to guarantee that an event listener will be added to
the event target for the specified event group, one needs to invoke
removeEventListener or removeEventListenerNS first.
IDL Definition
// Introduced in DOM Level 2:
interface EventTarget {
void addEventListener(in DOMString type,
in EventListener listener,
in boolean useCapture);
void removeEventListener(in DOMString type,
in EventListener listener,
in boolean useCapture);
// Modified in DOM Level 3:
boolean dispatchEvent(in Event evt)
raises(EventException);
// Introduced in DOM Level 3:
void addEventListenerNS(in DOMString namespaceURI,
in DOMString type,
in EventListener listener,
in boolean useCapture,
in DOMObject evtGroup);
// Introduced in DOM Level 3:
void removeEventListenerNS(in DOMString namespaceURI,
in DOMString type,
in EventListener listener,
in boolean useCapture);
// Introduced in DOM Level 3:
boolean willTriggerNS(in DOMString namespaceURI,
in DOMString type);
// Introduced in DOM Level 3:
boolean hasEventListenerNS(in DOMString namespaceURI,
in DOMString type);
};
Methods
addEventListener
This method allows the registration of an event listener in
the default group and, depending on the useCapture parameter,
on the capture phase of the DOM event flow or its target and
bubbling phases.
Parameters
type of type DOMString
Specifies the Event.type associated with the event for
which the user is registering.
listener of type EventListener
The listener parameter takes an object implemented by
the user which implements the EventListener interface
and contains the method to be called when the event
occurs.
useCapture of type boolean
If true, useCapture indicates that the user wishes to
add the event listener for the capture phase only, i.e.
this event listener will not be triggered during the
target and bubbling phases. If false, the event listener
will only be triggered during the target and bubbling
phases.
No Return Value
No Exceptions
addEventListenerNS introduced in DOM Level 3
This method allows the registration of an event listener in a
specified group or the default group and, depending on the
useCapture parameter, on the capture phase of the DOM event
flow or its target and bubbling phases.
Parameters
namespaceURI of type DOMString
Specifies the Event.namespaceURI associated with the
event for which the user is registering.
type of type DOMString
Specifies the Event.type associated with the event for
which the user is registering.
listener of type EventListener
The listener parameter takes an object implemented by
the user which implements the EventListener interface
and contains the method to be called when the event
occurs.
useCapture of type boolean
If true, useCapture indicates that the user wishes to
add the event listener for the capture phase only, i.e.
this event listener will not be triggered during the
target and bubbling phases. If false, the event listener
will only be triggered during the target and bubbling
phases.
evtGroup of type DOMObject
The object that represents the event group to associate
with the EventListener (see also Event propagation and
event groups). Use null to attach the event listener to
the default group.
No Return Value
No Exceptions
dispatchEvent modified in DOM Level 3
This method allows the dispatch of events into the
implementation's event model. The event target of the event
is the EventTarget object on which dispatchEvent is called.
Parameters
evt of type Event
The event to be dispatched.
Return Value
boolean Indicates whether any of the listeners which handled
the event called preventDefault. If preventDefault
was called the returned value is false, else it is
true.
Exceptions
EventException UNSPECIFIED_EVENT_TYPE_ERR: Raised if the
Event.type was not specified by initializing
the event before dispatchEvent was called.
Specification of the Event.type as null or an
empty string will also trigger this
exception.
DISPATCH_REQUEST_ERR: Raised if the Event
object is already being dispatched in the
tree.
NOT_SUPPORTED_ERR: Raised if the Event object
has not been created using
DocumentEvent.createEvent or does not support
the interface CustomEvent.
hasEventListenerNS introduced in DOM Level 3
This method allows the DOM application to know if this
EventTarget contains an event listener registered for the
specified event type. This is useful for determining at which
nodes within a hierarchy altered handling of specific event
types has been introduced, but should not be used to
determine whether the specified event type triggers an event
listener (see willTriggerNS).
Issue canTriggerOnTarget-useCapture:
do we need a useCapture parameter?
Resolution: No use case for that.
Parameters
namespaceURI of type DOMString
Specifies the Event.namespaceURI associated with the
event.
type of type DOMString
Specifies the Event.type associated with the event.
Return Value
boolean true if an event listener is registered on this
EventTarget for the specified event type, false
otherwise.
No Exceptions
removeEventListener
This method allows the removal of event listeners from the
default group.
Calling removeEventListener with arguments which do not
identify any currently registered EventListener on the
EventTarget has no effect.
Parameters
type of type DOMString
Specifies the Event.type for which the user registered
the event listener.
listener of type EventListener
The EventListener to be removed.
useCapture of type boolean
Specifies whether the EventListener being removed was
registered for the capture phase or not. If a listener
was registered twice, once for the capture phase and
once for the target and bubbling phases, each must be
removed separately. Removal of an event listener
registered for the capture phase does not affect the
same event listener registered for the target and
bubbling phases, and vice versa.
No Return Value
No Exceptions
removeEventListenerNS introduced in DOM Level 3
This method allows the removal of event listeners from a
specified group or the default group.
Calling removeEventListenerNS with arguments which do not
identify any currently registered EventListener on the
EventTarget has no effect.
Parameters
namespaceURI of type DOMString
Specifies the Event.namespaceURI associated with the
event for which the user registered the event listener.
type of type DOMString
Specifies the Event.type associated with the event for
which the user registered the event listener.
listener of type EventListener
The EventListener parameter indicates the EventListener
to be removed.
useCapture of type boolean
Specifies whether the EventListener being removed was
registered for the capture phase or not. If a listener
was registered twice, once for the capture phase and
once for the target and bubbling phases, each must be
removed separately. Removal of an event listener
registered for the capture phase does not affect the
same event listener registered for the target and
bubbling phases, and vice versa.
No Return Value
No Exceptions
willTriggerNS introduced in DOM Level 3
This method allows the DOM application to know if an event
listener, attached to this EventTarget or one of its
ancestors, will be triggered by the specified event type
during the dispatch of the event to this event target or one
of its descendants.
Parameters
namespaceURI of type DOMString
Specifies the Event.namespaceURI associated with the
event.
type of type DOMString
Specifies the Event.type associated with the event.
Return Value
boolean true if an event listener will be triggered on the
EventTarget with the specified event type, false
otherwise.
No Exceptions
Interface EventListener (introduced in DOM Level 2)
The EventListener interface is the primary way for handling events.
Users implement the EventListener interface and register their event
listener on an EventTarget. The users should also remove their
EventListener from its EventTarget after they have completed using the
listener.
Copying a Node does not copy the event listeners attached to it. Event
listeners must be attached to the newly created Node afterwards if so
desired. Therefore, Nodes are copied using Node.cloneNode or
Range.cloneContents, the EventListeners attached to the source Nodes
are not attached to their copies.
Moving a Node does not affect the event listeners attached to it.
Therefore, when Nodes are moved using Document.adoptNode,
Node.appendChild, or Range.extractContents, the EventListeners attached
to the moved Nodes stay attached to them.
IDL Definition
// Introduced in DOM Level 2:
interface EventListener {
void handleEvent(in Event evt);
};
Methods
handleEvent
This method is called whenever an event occurs of the event
type for which the EventListener interface was registered.
Parameters
evt of type Event
The Event contains contextual information about the
event.
No Return Value
No Exceptions
Exception EventException introduced in DOM Level 2
Event operations may throw an EventException as specified in their
method descriptions.
IDL Definition
// Introduced in DOM Level 2:
exception EventException {
unsigned short code;
};
// EventExceptionCode
const unsigned short UNSPECIFIED_EVENT_TYPE_ERR = 0;
// Introduced in DOM Level 3:
const unsigned short DISPATCH_REQUEST_ERR = 1;
Definition group EventExceptionCode
An integer indicating the type of error generated.
Defined Constants
DISPATCH_REQUEST_ERR, introduced in DOM Level 3.
If the Event object is already dispatched in the tree.
UNSPECIFIED_EVENT_TYPE_ERR
If the Event.type was not specified by initializing the
event before the method was called. Specification of the
Event.type as null or an empty string will also trigger
this exception.
1.6.1. Event creation
In most cases, the events dispatched by the DOM Events implementation are
also created by the implementation. It is however possible to simulate
events such as mouse events by creating the Event objects and dispatch them
using the DOM Events implementation.
DOM Events provides two ways for creating Event objects. An application can
either create Event objects that are known to the implementation, or create
its own objects and have them dispatched by the DOM Events implementation.
Creating Event objects that are known to the DOM Events implementation is
done using DocumentEvent.createEvent. The application must then initialize
the object by calling the appropriate initialization method before invoking
EventTarget.dispatchEvent. The Event objects created must be known by the
DOM Events implementation otherwise an event exception is thrown.
The DOM application might want to create its own Event objects, in order to
change the default Event implementation provided by the DOM Events
implementation or to generate new event types with specific contextual
information. In any case, the application is responsible for creating and
initializing the Event object. The application can then dispatch the event
using the DOM Events implementation by using EventTarget.dispatchEvent.
However, the DOM Events implementation requires to have access to two
attributes in the Event object in order to accomplish the dispatch
appropriately: Event.currentTarget and Event.eventPhase. Those attributes
are defined as readonly in the Event interface since event listeners must
not change them and it is the responsibility of the DOM Events
implementation to update them during the event flow. Therefore, implementing
the Event interface when creating its own events is not enough for an
application since the DOM Events implementation will not be able to update
the current phase and the current node during the dispatch, unless the event
object also implements the CustomEvent interface to give access to the
relevant attributes.
Interface DocumentEvent (introduced in DOM Level 2)
The DocumentEvent interface provides a mechanism by which the user can
create an Event object of a type supported by the implementation. It is
expected that the DocumentEvent interface will be implemented on the
same object which implements the Document interface in an
implementation which supports the Event model.
IDL Definition
// Introduced in DOM Level 2:
interface DocumentEvent {
Event createEvent(in DOMString eventType)
raises(DOMException);
// Introduced in DOM Level 3:
boolean canDispatch(in DOMString namespaceURI,
in DOMString type);
};
Methods
canDispatch introduced in DOM Level 3
Test if the implementation can generate events of a specified
type.
Parameters
namespaceURI of type DOMString
Specifies the Event.namespaceURI of the event.
type of type DOMString
Specifies the Event.type of the event.
Return Value
boolean true if the implementation can generate and dispatch
this event type, false otherwise.
No Exceptions
createEvent
Parameters
eventType of type DOMString
The eventType parameter specifies the name of the DOM
Events interface to be supported by the created event
object, e.g. "Event", "MouseEvent", "MutationEvent" ...
If the Event is to be dispatched via the
EventTarget.dispatchEvent method the appropriate event
init method must be called after creation in order to
initialize the Event's values.
As an example, a user wishing to synthesize some kind of
UIEvent would call DocumentEvent.createEvent with the
parameter "UIEvent". The UIEvent.initUIEventNS method
could then be called on the newly created UIEvent object
to set the specific type of user interface event to be
dispatched, {"http://www.w3.org/2001/xml-events",
"DOMActivate"} for example, and set its context
information, e.g. UIEvent.detail in this example.
The createEvent method is used in creating Events when
it is either inconvenient or unnecessary for the user to
create an Event themselves. In cases where the
implementation provided Event is insufficient, users may
supply their own Event implementations for use with the
EventTarget.dispatchEvent method. However, the DOM
implementation needs access to the attributes
Event.currentTarget and Event.eventPhase to propagate
appropriately the event in the DOM tree. Therefore
users' Event implementations might need to support the
CustomEvent interface for that effect.
Note: For backward compatibility reason, "UIEvents",
"MouseEvents", "MutationEvents", and "HTMLEvents"
feature names are valid values for the parameter
eventType and represent respectively the interfaces
"UIEvent", "MouseEvent", "MutationEvent", and "Event".
Return Value
Event The newly created event object.
Exceptions
DOMException NOT_SUPPORTED_ERR: Raised if the implementation
does not support the Event interface requested.
Interface CustomEvent (introduced in DOM Level 3)
The CustomEvent interface gives access to the attributes
Event.currentTarget and Event.eventPhase. It is intended to be used by
the DOM Events implementation to access the underlying current target
and event phase while dispatching a custom Event in the tree; it is
also intended to be implemented, and not used, by DOM applications.
The methods contained in this interface are not intended to be used by
a DOM application, especially during the dispatch on the Event object.
Changing the current target or the current phase may conduct into
unpredictable results of the event flow. The DOM Events implementation
should ensure that both methods return the appropriate current target
and phase before invoking each event listener on the current target to
protect DOM applications from malicious event listeners.
Note: If this interface is supported by the event object,
Event.isCustom() must return true.
IDL Definition
// Introduced in DOM Level 3:
interface CustomEvent : Event {
void setDispatchState(in EventTarget target,
in unsigned short phase);
boolean isPropagationStopped();
boolean isImmediatePropagationStopped();
};
Methods
isImmediatePropagationStopped
The isImmediatePropagationStopped method is used by the DOM
Events implementation to know if the method
stopImmediatePropagation() has been called for this event. It
returns true if the method has been called, false otherwise.
Return Value
boolean true if the event propagation has been stopped
immediately in the current group.
No Parameters
No Exceptions
isPropagationStopped
This method will return true if the method stopPropagation()
has been called for this event, false in any other cases.
Return Value
boolean true if the event propagation has been stopped in
the current group.
No Parameters
No Exceptions
setDispatchState
The setDispatchState method is used by the DOM Events
implementation to set the values of Event.currentTarget and
Event.eventPhase. It also reset the states of
isPropagationStopped and isImmediatePropagationStopped.
Parameters
target of type EventTarget
Specifies the new value for the Event.currentTarget
attribute.
phase of type unsigned short
Specifies the new value for the Event.eventPhase
attribute.
No Return Value
No Exceptions
1.7. Event module definitions
The DOM Event Model allows a DOM implementation to support multiple modules
of events. The model has been designed to allow addition of new event
modules as is required. The DOM will not attempt to define all possible
events. For purposes of interoperability, the DOM will define a module of
user interface events including lower level device dependent events, a
module of UI logical events, and a module of document mutation events.
1.7.1. User Interface event types
The User Interface event module contains basic event types associated with
user interfaces.
Interface UIEvent (introduced in DOM Level 2)
The UIEvent interface provides specific contextual information
associated with User Interface events.
Note: To create an instance of the UIEvent interface, use the feature
string "UIEvent" as the value of the input parameter used with the
DocumentEvent.createEvent method.
IDL Definition
// Introduced in DOM Level 2:
interface UIEvent : Event {
readonly attribute views::AbstractView view;
readonly attribute long detail;
void initUIEvent(in DOMString typeArg,
in boolean canBubbleArg,
in boolean cancelableArg,
in views::AbstractView viewArg,
in long detailArg);
// Introduced in DOM Level 3:
void initUIEventNS(in DOMString namespaceURI,
in DOMString typeArg,
in boolean canBubbleArg,
in boolean cancelableArg,
in views::AbstractView viewArg,
in long detailArg);
};
Attributes
detail of type long, readonly
Specifies some detail information about the Event, depending
on the type of event.
view of type views::AbstractView, readonly
The view attribute identifies the AbstractView from which the
event was generated.
Methods
initUIEvent
The initUIEvent method is used to initialize the value of a
UIEvent created using the DocumentEvent.createEvent method.
This method may only be called before the UIEvent has been
dispatched via the EventTarget.dispatchEvent method, though
it may be called multiple times during that phase if
necessary. If called multiple times, the final invocation
takes precedence.
Parameters
typeArg of type DOMString
Specifies the event type.
canBubbleArg of type boolean
Specifies whether or not the event can bubble. This
parameter overrides the intrinsic bubbling behavior of
the event.
cancelableArg of type boolean
Specifies whether or not the event's default action can
be prevented. This parameter overrides the intrinsic
cancelable behavior of the event.
viewArg of type views::AbstractView
Specifies the Event's AbstractView.
detailArg of type long
Specifies the Event's detail.
No Return Value
No Exceptions
initUIEventNS introduced in DOM Level 3
The initUIEventNS method is used to initialize the value of a
UIEvent created using the DocumentEvent.createEvent method.
This method may only be called before the UIEvent has been
dispatched via the EventTarget.dispatchEvent method, though
it may be called multiple times during that phase if
necessary. If called multiple times, the final invocation
takes precedence.
Parameters
namespaceURI of type DOMString
Specifies the namespace URI associated with this event,
or null if the application wish not to use namespaces.
typeArg of type DOMString
Specifies the event type (see also the description of
the type attribute in the Event interface).
canBubbleArg of type boolean
Specifies whether or not the event can bubble.
cancelableArg of type boolean
Specifies whether or not the event's default action can
be prevented.
viewArg of type views::AbstractView
Specifies the Event's AbstractView.
detailArg of type long
Specifies the Event's detail.
No Return Value
No Exceptions
The User Interface event types are listed below. For a full description of
the semantics associated with these event types, refer to the Complete list
of event types. A DOM application may use the hasFeature(feature, version)
method of the DOMImplementation interface with parameter values "UIEvents"
and "3.0" (respectively) to determine whether or not the DOM Level 3 User
Interface event types are supported by the implementation. In order to fully
support this module, an implementation must also support the "Events"
feature defined in this specification and the "Views" feature defined in the
DOM Level 2 Views specification [DOM Level 2 Views]. For additional
information about conformance, please see the DOM Level 3 Core specification
[DOM Level 3 Core]. The DOM Level 3 User Interface Events module is built on
top of the DOM Level 2 User Interface Events [DOM Level 2 Events] module,
i.e. a DOM Level 3 User Interface Events implementation where
hasFeature("UIEvents", "3.0") returns true must also return true when the
version number is "2.0", "" or, null.
Event type Context information
"http://www.w3.org/2001/xml-events", "DOMActivate" UIEvent.view is in use.
"http://www.w3.org/2001/xml-events", "DOMFocusIn" (same as above)
"http://www.w3.org/2001/xml-events", "DOMFocusOut" (same as above)
1.7.2. Text events
The text event module originates from the [HTML 4.01] onkeypress attribute.
Unlike this attribute, the event type {"http://www.w3.org/2001/xml-events",
"textInput"} applies only to characters and is specifically designed for use
with text input devices.
Interface TextEvent (introduced in DOM Level 3)
The TextEvent interface provides specific contextual information
associated with Text Events.
Note: To create an instance of the TextEvent interface, use the feature
string "TextEvent" as the value of the input parameter used with the
DocumentEvent.createEvent method.
Issue auto-repeat:
In the past, detail was used to contain the repeat count for the
key. Do we want to keep this notion? How? using an auto-repeat
event instead? Use cases?
Resolution: closed.
Issue visibleOutputGenerated-1:
same question for visibleOutputGenerated: This attribute is device
dependent (display related). What happen on voice system for
example? What are the real use cases for it?
Resolution: closed.
Issue paste-1:
What happens on paste through Ctrl-V? Do you get a textInput event
or not if the selection contains characters?
Resolution: This will be undefined by this specification.
IDL Definition
// Introduced in DOM Level 3:
interface TextEvent : UIEvent {
readonly attribute DOMString data;
void initTextEvent(in DOMString typeArg,
in boolean canBubbleArg,
in boolean cancelableArg,
in views::AbstractView viewArg,
in DOMString dataArg);
void initTextEventNS(in DOMString namespaceURI,
in DOMString type,
in boolean canBubbleArg,
in boolean cancelableArg,
in views::AbstractView viewArg,
in DOMString dataArg);
};
Attributes
data of type DOMString, readonly
data holds the value of the characters generated by the
character device. This may be a single Unicode character or
it may be a string.
Methods
initTextEvent
The initTextEvent method is used to initialize the value of a
TextEvent created using the DocumentEvent.createEvent method.
This method may only be called before the TextEvent has been
dispatched via the EventTarget.dispatchEvent method, though
it may be called multiple times during that phase if
necessary. If called multiple times, the final invocation
takes precedence. This method has no effect if called after
the event has been dispatched.
Parameters
typeArg of type DOMString
Specifies the event type.
canBubbleArg of type boolean
Specifies whether or not the event can bubble. This
parameter overrides the intrinsic bubbling behavior of
the event.
cancelableArg of type boolean
Specifies whether or not the event's default action can
be prevent. This parameter overrides the intrinsic
cancelable behavior of the event.
viewArg of type views::AbstractView
Specifies the TextEvent's view.
dataArg of type DOMString
Specifies the TextEvent's data attribute
No Return Value
No Exceptions
initTextEventNS
The initTextEventNS method is used to initialize the value of
a TextEvent created using the DocumentEvent.createEvent
method. This method may only be called before the TextEvent
has been dispatched via the EventTarget.dispatchEvent method,
though it may be called multiple times during that phase if
necessary. If called multiple times, the final invocation
takes precedence. This method has no effect if called after
the event has been dispatched.
Parameters
namespaceURI of type DOMString
Specifies the namespace URI associated with this event,
or null if the applications wish to have no namespace.
type of type DOMString
Specifies the event type.
canBubbleArg of type boolean
Specifies whether or not the event can bubble.
cancelableArg of type boolean
Specifies whether or not the event's default action can
be prevent.
viewArg of type views::AbstractView
Specifies the TextEvent's view.
dataArg of type DOMString
Specifies the TextEvent's data attribute
No Return Value
No Exceptions
The text event type is listed below. For a full description of the semantics
associated with this event type, refer to the Complete list of event types.
A DOM application may use the hasFeature(feature, version) method of the
DOMImplementation interface with parameter values "TextEvents" and "3.0"
(respectively) to determine whether or not the Text event module is
supported by the implementation. In order to fully support this module, an
implementation must also support the "UIEvents" feature defined in this
specification. For additional information about conformance, please see the
DOM Level 3 Core specification [DOM Level 3 Core].
Event type Context information
"http://www.w3.org/2001/xml-events", "textInput" UIEvent.view and
TextEvent.data are in use.
1.7.3. Mouse event types
The Mouse event module originates from the [HTML 4.01] onclick, ondblclick,
onmousedown, onmouseup, onmouseover, onmousemove, and onmouseout attributes.
This event module is specifically designed for use with pointing input
devices, such a mouse.
Interface MouseEvent (introduced in DOM Level 2)
The MouseEvent interface provides specific contextual information
associated with Mouse events.
In the case of nested elements mouse events are always targeted at the
most deeply nested element. Ancestors of the targeted element may use
bubbling to obtain notification of mouse events which occur within its
descendent elements.
Note: To create an instance of the MouseEvent interface, use the
feature string "MouseEvent" as the value of the input parameter used
with the DocumentEvent.createEvent method.
IDL Definition
// Introduced in DOM Level 2:
interface MouseEvent : UIEvent {
readonly attribute long screenX;
readonly attribute long screenY;
readonly attribute long clientX;
readonly attribute long clientY;
readonly attribute boolean ctrlKey;
readonly attribute boolean shiftKey;
readonly attribute boolean altKey;
readonly attribute boolean metaKey;
readonly attribute unsigned short button;
readonly attribute EventTarget relatedTarget;
void initMouseEvent(in DOMString typeArg,
in boolean canBubbleArg,
in boolean cancelableArg,
in views::AbstractView viewArg,
in long detailArg,
in long screenXArg,
in long screenYArg,
in long clientXArg,
in long clientYArg,
in boolean ctrlKeyArg,
in boolean altKeyArg,
in boolean shiftKeyArg,
in boolean metaKeyArg,
in unsigned short buttonArg,
in EventTarget relatedTargetArg);
// Introduced in DOM Level 3:
void initMouseEventNS(in DOMString namespaceURI,
in DOMString typeArg,
in boolean canBubbleArg,
in boolean cancelableArg,
in views::AbstractView viewArg,
in long detailArg,
in long screenXArg,
in long screenYArg,
in long clientXArg,
in long clientYArg,
in boolean ctrlKeyArg,
in boolean altKeyArg,
in boolean shiftKeyArg,
in boolean metaKeyArg,
in unsigned short buttonArg,
in EventTarget relatedTargetArg,
in boolean altGraphKeyArg);
// Introduced in DOM Level 3:
readonly attribute boolean altGraphKey;
};
Attributes
altGraphKey of type boolean, readonly, introduced in DOM Level 3
true if the alt-graph (Alt Gr) key modifier is activated.
Note: Some operating systems simulate the alt-graph key
modifier with the combinaison of alt and ctrl key modifiers.
Implementations are encouraged to use this modifier instead.
altKey of type boolean, readonly
true if the alt (alternative) key modifier is activated.
button of type unsigned short, readonly
During mouse events caused by the depression or release of a
mouse button, button is used to indicate which mouse button
changed state. 0 indicates the normal (in general on the left
or the one button on Macintosh mice, used to activate a
button or select text) button of the mouse. 2 indicates the
contextual property (in general on the right, used to display
a context menu) button of the mouse if present. 1 indicates
the extra (in general in the middle and often combined with
the mouse wheel) button. Some mice may provide or simulate
more buttons and values higher than 2 could be used to
represent such buttons.
clientX of type long, readonly
The horizontal coordinate at which the event occurred
relative to the DOM implementation's client area.
clientY of type long, readonly
The vertical coordinate at which the event occurred relative
to the DOM implementation's client area.
ctrlKey of type boolean, readonly
true if the control (Ctrl) key modifier is activated.
metaKey of type boolean, readonly
true if the meta (Meta) key modifier is activated.
Note: The Command key modifier on Macintosh system must be
represented using this key modifier.
relatedTarget of type EventTarget, readonly
Used to identify a secondary EventTarget related to a UI
event. Currently this attribute is used with the mouseover
event to indicate the EventTarget which the pointing device
exited and with the mouseout event to indicate the
EventTarget which the pointing device entered.
screenX of type long, readonly
The horizontal coordinate at which the event occurred
relative to the origin of the screen coordinate system.
screenY of type long, readonly
The vertical coordinate at which the event occurred relative
to the origin of the screen coordinate system.
shiftKey of type boolean, readonly
true if the shift (Shift) key modifier is activated.
Methods
initMouseEvent
The initMouseEvent method is used to initialize the value of
a MouseEvent created using the DocumentEvent.createEvent
method. This method may only be called before the MouseEvent
has been dispatched via the EventTarget.dispatchEvent method,
though it may be called multiple times before being
dispatched. If called multiple times, the final invocation
takes precedence.
Parameters
typeArg of type DOMString
Specifies the event type.
canBubbleArg of type boolean
Specifies whether or not the event can bubble.
cancelableArg of type boolean
Specifies whether or not the event's default action can
be prevented.
viewArg of type views::AbstractView
Specifies the Event's view.
detailArg of type long
Specifies the Event's mouse click count.
screenXArg of type long
Specifies the Event's screen x coordinate
screenYArg of type long
Specifies the Event's screen y coordinate
clientXArg of type long
Specifies the Event's client x coordinate
clientYArg of type long
Specifies the Event's client y coordinate
ctrlKeyArg of type boolean
Specifies whether or not control key was depressed
during the Event.
altKeyArg of type boolean
Specifies whether or not alt key was depressed during
the Event.
shiftKeyArg of type boolean
Specifies whether or not shift key was depressed during
the Event.
metaKeyArg of type boolean
Specifies whether or not meta key was depressed during
the Event.
buttonArg of type unsigned short
Specifies the Event's mouse button.
relatedTargetArg of type EventTarget
Specifies the Event's related EventTarget.
No Return Value
No Exceptions
initMouseEventNS introduced in DOM Level 3
The initMouseEventNS method is used to initialize the value
of a MouseEvent created using the DocumentEvent.createEvent
interface. This method may only be called before the
MouseEvent has been dispatched via the
EventTarget.dispatchEvent method, though it may be called
multiple times during that phase if necessary. If called
multiple times, the final invocation takes precedence.
Parameters
namespaceURI of type DOMString
Specifies the namespace URI associated with this event,
or null if the application wish to have no namespace.
typeArg of type DOMString
Specifies the event type.
canBubbleArg of type boolean
Specifies whether or not the event can bubble.
cancelableArg of type boolean
Specifies whether or not the event's default action can
be prevented.
viewArg of type views::AbstractView
Specifies the Event's AbstractView.
detailArg of type long
Specifies the Event's mouse click count.
screenXArg of type long
Specifies the Event's screen x coordinate
screenYArg of type long
Specifies the Event's screen y coordinate
clientXArg of type long
Specifies the Event's client x coordinate
clientYArg of type long
Specifies the Event's client y coordinate
ctrlKeyArg of type boolean
Specifies whether or not control key was depressed
during the Event.
altKeyArg of type boolean
Specifies whether or not alt key was depressed during
the Event.
shiftKeyArg of type boolean
Specifies whether or not shift key was depressed during
the Event.
metaKeyArg of type boolean
Specifies whether or not meta key was depressed during
the Event.
buttonArg of type unsigned short
Specifies the Event's mouse button.
relatedTargetArg of type EventTarget
Specifies the Event's related EventTarget.
altGraphKeyArg of type boolean
Specifies whether or not alt graph key was depressed
during the Event.
No Return Value
No Exceptions
The Mouse event types are listed below. For a full description of the
semantics associated with these event types, refer to the Complete list of
event types. In the case of nested elements, mouse event types are always
targeted at the most deeply nested element. Ancestors of the targeted
element may use bubbling to obtain notification of mouse events which occur
within its descendent elements. A DOM application may use the
hasFeature(feature, version) method of the DOMImplementation interface with
parameter values "MouseEvents" and "3.0" (respectively) to determine whether
or not the Mouse event module is supported by the implementation. In order
to fully support this module, an implementation must also support the
"UIEvents" feature defined in this specification. For additional information
about conformance, please see the DOM Level 3 Core specification [DOM Level
3 Core]. The DOM Level 3 Mouse Events module is built on top of the DOM
Level 2 Mouse Events [DOM Level 2 Events] module, i.e. a DOM Level 3 Mouse
Events implementation where hasFeature("MouseEvents", "3.0") returns true
must also return true when the version number is "2.0", "" or, null.
Event type Context information
"http://www.w3.org/2001/xml-events", MouseEvent.screenX,
"click" MouseEvent.screenY,
MouseEvent.clientX,
MouseEvent.clientY,
MouseEvent.altKey,
MouseEvent.ctrlKey,
MouseEvent.shiftKey,
MouseEvent.metaKey,
MouseEvent.altGraphKey,
MouseEvent.button, and
UIEvent.view are in use. The
UIEvent.detail attribute
indicates the number of
consecutive clicks of a pointing
device button during a user
action. The attribute value is 1
when the user begins this action
and increments by 1 for each
click. The notion of consecutive
clicks depends on the environment
configuration. For example, a
"double click" will not happen if
there is a long delay between the
two clicks, even if the pointing
device did not move.
"http://www.w3.org/2001/xml-events", MouseEvent.screenX,
"mousedown" MouseEvent.screenY,
MouseEvent.clientX,
MouseEvent.clientY,
MouseEvent.altKey,
MouseEvent.ctrlKey,
MouseEvent.shiftKey,
MouseEvent.metaKey,
MouseEvent.altGraphKey,
MouseEvent.button, and
UIEvent.view are in use. The
UIEvent.detail attribute
indicates the number of
consecutive clicks, incremented
by one, of a pointing device
button during a user action. For
example, if no click happened
before the mousedown,
UIEvent.detail will contain the
value 1.
"http://www.w3.org/2001/xml-events", MouseEvent.screenX,
"mouseup" MouseEvent.screenY,
MouseEvent.clientX,
MouseEvent.clientY,
MouseEvent.altKey,
MouseEvent.ctrlKey,
MouseEvent.shiftKey,
MouseEvent.metaKey,
MouseEvent.altGraphKey,
MouseEvent.button, and
UIEvent.view are in use. The
UIEvent.detail attribute
indicates the number of
consecutive clicks, incremented
by one, of a pointing device
button during a user action. For
example, if no click happened
before the mouseup,
UIEvent.detail will contain the
value 1. However, if no click is
generated after the mouseup,
UIEvent.detail contains the value
0, indicating that no click is
occurring.
"http://www.w3.org/2001/xml-events", MouseEvent.screenX,
"mouseover" MouseEvent.screenY,
MouseEvent.clientX,
MouseEvent.clientY,
MouseEvent.altKey,
MouseEvent.ctrlKey,
MouseEvent.shiftKey,
MouseEvent.metaKey,
MouseEvent.altGraphKey, and
UIEvent.view are in use.
MouseEvent.relatedTarget
indicates the event target a
pointing device is exiting.
"http://www.w3.org/2001/xml-events", MouseEvent.screenX,
"mousemove" MouseEvent.screenY,
MouseEvent.clientX,
MouseEvent.clientY,
MouseEvent.altKey,
MouseEvent.ctrlKey,
MouseEvent.shiftKey,
MouseEvent.metaKey,
MouseEvent.altGraphKey, and
UIEvent.view are in use.
"http://www.w3.org/2001/xml-events", MouseEvent.screenX,
"mouseout" MouseEvent.screenY,
MouseEvent.clientX,
MouseEvent.clientY,
MouseEvent.altKey,
MouseEvent.ctrlKey,
MouseEvent.shiftKey,
MouseEvent.metaKey,
MouseEvent.altGraphKey, and
UIEvent.view are in use.
MouseEvent.relatedTarget
indicates the event target a
pointing device is entering.
As an example, a "double-click" on a mouse device will produce the following
events (the value of UIEvent.detail is indicated in parenthesis):
1. {"http://www.w3.org/2001/xml-events", "mousedown"} (1)
2. {"http://www.w3.org/2001/xml-events", "mouseup"} (1)
3. {"http://www.w3.org/2001/xml-events", "click"} (1)
4. {"http://www.w3.org/2001/xml-events", "mousedown"} (2)
5. {"http://www.w3.org/2001/xml-events", "mouseup"} (2)
6. {"http://www.w3.org/2001/xml-events", "click"} (2)
(ED: plh -- I added this example above but didn't check if it is correct or
not yet (do we have the click(1)?). If it is not, let me know in any case.
I'll probably complicate the example a bit (with moves) to show how detail
really works. )
1.7.4. Keyboard event types
Keyboard events are device dependent, i.e. they rely on the capabilities of
the input devices and how they are mapped in the operating systems. It is
therefore highly recommended to rely on Text events when dealing with
characters.
Interface KeyboardEvent (introduced in DOM Level 3)
The KeyboardEvent interface provides specific contextual information
associated with keyboard devices. Each keyboard event reference a key
using an identifier.
Each modifier attribute (ctrlKey, shiftKey, altKey, metaKey, and
altGraphKey) is activated when the key modifier is being pressed down
or maintained pressed, i.e. the modifier attribute is not in use when
the key modifier is being released.
Note: To create an instance of the KeyboardEvent interface, use the
feature string "KeyboardEvent" as the value of the input parameter used
with the DocumentEvent.createEvent method.
IDL Definition
// Introduced in DOM Level 3:
interface KeyboardEvent : UIEvent {
// KeyLocationCode
const unsigned long DOM_KEY_LOCATION_STANDARD = 0x00;
const unsigned long DOM_KEY_LOCATION_LEFT = 0x01;
const unsigned long DOM_KEY_LOCATION_RIGHT = 0x02;
const unsigned long DOM_KEY_LOCATION_NUMPAD = 0x03;
const unsigned long DOM_KEY_LOCATION_UNKNOWN = 0x04;
readonly attribute DOMString keyIdentifier;
readonly attribute unsigned long keyLocation;
readonly attribute boolean ctrlKey;
readonly attribute boolean shiftKey;
readonly attribute boolean altKey;
readonly attribute boolean metaKey;
readonly attribute boolean altGraphKey;
void initKeyboardEvent(in DOMString typeArg,
in boolean canBubbleArg,
in boolean cancelableArg,
in views::AbstractView viewArg,
in DOMString keyIdentifierArg,
in unsigned long keyLocationArg,
in boolean ctrlKeyArg,
in boolean shiftKeyArg,
in boolean altKeyArg,
in boolean metaKeyArg,
in boolean altGraphKeyArg);
void initKeyboardEventNS(in DOMString namespaceURI,
in DOMString type,
in boolean canBubbleArg,
in boolean cancelableArg,
in views::AbstractView viewArg,
in DOMString keyIdentifierArg,
in unsigned long keyLocationArg,
in boolean ctrlKeyArg,
in boolean shiftKeyArg,
in boolean altKeyArg,
in boolean metaKeyArg,
in boolean altGraphKeyArg);
};
Definition group KeyLocationCode
Defined Constants
DOM_KEY_LOCATION_LEFT
The key activated is in the left key location (there is
more than one possible location for this key). Example:
the left Shift key on a PC 101 Key US.
DOM_KEY_LOCATION_NUMPAD
The key activation originated on the numeric keypad or
with a virtual key corresponding to the numeric keypad.
Example: the '1' key on a PC 101 Key US.
DOM_KEY_LOCATION_RIGHT
The key activation is in the right key location (there
is more than one possible location for this key).
Example: the right Shift key on a PC 101 Key US.
DOM_KEY_LOCATION_STANDARD
The key activation is not distinguished as the left or
right version of the key, and did not originate from the
numeric keypad (or did not originate with a virtual key
corresponding to the numeric keypad). Example: the 'Q'
key on a PC 101 Key US.
DOM_KEY_LOCATION_UNKNOWN
Implementations can use this constant to indicate that
the location of the key cannot be determined.
Note: In case a DOM implementation wishes to provide new
location information, all values above the value of this
constant can be used for that effect and generic DOM
applications should consider values above the value of
this constant as being equivalent to
DOM_KEY_LOCATION_UNKNOWN.
Attributes
altGraphKey of type boolean, readonly
true if the alt-graph (Alt Gr) key modifier is activated.
Note: Some operating systems simulate the alt-graph key
modifier with the combinaison of alt and ctrl key modifiers.
Implementations are encouraged to use this modifier instead.
altKey of type boolean, readonly
true if the alt (alternative) key modifier is activated.
ctrlKey of type boolean, readonly
true if the control (Ctrl) key modifier is activated.
keyIdentifier of type DOMString, readonly
keyIdentifier holds the identifier of the key. For a list of
possible values, refer to Key identifiers for keyboard
events..
Note: Implementations that are unable to identify a key must
use the key identifier "Unidentified".
keyLocation of type unsigned long, readonly
The keyLocation attribute contains an indication of the
location of they key on the device.
metaKey of type boolean, readonly
true if the meta (Meta) key modifier is activated.
Note: The Command key modifier on Macintosh system must be
represented using this key modifier.
shiftKey of type boolean, readonly
true if the shift (Shift) key modifier is activated.
Methods
initKeyboardEvent
The initKeyboardEvent method is used to initialize the value
of a KeyboardEvent created using the
DocumentEvent.createEvent method. This method may only be
called before the KeyboardEvent has been dispatched via the
EventTarget.dispatchEvent method, though it may be called
multiple times before being dispatched if necessary. If
called multiple times, the final invocation takes precedence.
This method has no effect if called after the event has been
dispatched.
Parameters
typeArg of type DOMString
Specifies the event type.
canBubbleArg of type boolean
Specifies whether or not the event can bubble. This
parameter overrides the intrinsic bubbling behavior of
the event.
cancelableArg of type boolean
Specifies whether or not the event's default action can
be prevent. This parameter overrides the intrinsic
cancelable behavior of the event.
viewArg of type views::AbstractView
Specifies the KeyboardEvent's AbstractView.
keyIdentifierArg of type DOMString
Specifies the KeyboardEvent's keyIdentifier attribute.
keyLocationArg of type unsigned long
Specifies the KeyboardEvent's keyLocation attribute.
ctrlKeyArg of type boolean
Specifies the KeyboardEvent's ctrlKey attribute.
shiftKeyArg of type boolean
Specifies the KeyboardEvent's shiftKey attribute.
altKeyArg of type boolean
Specifies the KeyboardEvent's altKey attribute.
metaKeyArg of type boolean
Specifies the KeyboardEvent's metaKey attribute.
altGraphKeyArg of type boolean
Specifies the KeyboardEvent's altGraphKey attribute.
No Return Value
No Exceptions
initKeyboardEventNS
The initKeyboardEventNS method is used to initialize the
value of a KeyboardEvent created using the
DocumentEvent.createEvent method. This method may only be
called before the KeyboardEvent has been dispatched via the
EventTarget.dispatchEvent method, though it may be called
multiple times during that phase if necessary. If called
multiple times, the final invocation takes precedence. This
method has no effect if called after the event has been
dispatched.
Parameters
namespaceURI of type DOMString
Specifies the namespace URI associated with this event,
or null if the applications wish to have no namespace.
type of type DOMString
Specifies the event type.
canBubbleArg of type boolean
Specifies whether or not the event can bubble.
cancelableArg of type boolean
Specifies whether or not the event's default action can
be prevent.
viewArg of type views::AbstractView
Specifies the KeyboardEvent's AbstractView.
keyIdentifierArg of type DOMString
Specifies the KeyboardEvent's keyIdentifier attribute
keyLocationArg of type unsigned long
Specifies the KeyboardEvent's keyLocation attribute.
ctrlKeyArg of type boolean
Specifies the KeyboardEvent's ctrlKey attribute.
shiftKeyArg of type boolean
Specifies the KeyboardEvent's shiftKey attribute.
altKeyArg of type boolean
Specifies the KeyboardEvent's altKey attribute.
metaKeyArg of type boolean
Specifies the KeyboardEvent's metaKey attribute.
altGraphKeyArg of type boolean
Specifies the KeyboardEvent's altGraphKey attribute.
No Return Value
No Exceptions
Depending on the character device generation system, keyboard events may or
may not be generated.
The keyboard event types are listed below. For a full description of the
semantics associated with these event types, refer to the Complete list of
event types. A DOM application may use the hasFeature(feature, version)
method of the DOMImplementation interface with parameter values
"KeyboardEvents" and "3.0" (respectively) to determine whether or not the
Keyboard event module is supported by the implementation. In order to fully
support this module, an implementation must also support the "UIEvents"
feature defined in this specification. For additional information about
conformance, please see the DOM Level 3 Core specification [DOM Level 3
Core].
Event type Context information
"http://www.w3.org/2001/xml-events", UIEvent.view,
"keydown" KeyboardEvent.keyIdentifier,
KeyboardEvent.location,
KeyboardEvent.altKey,
KeyboardEvent.altGraphKey,
KeyboardEvent.shiftKey,
KeyboardEvent.ctrlKey, and
KeyboardEvent.metaKey are in use.
"http://www.w3.org/2001/xml-events", UIEvent.view,
"keyup" KeyboardEvent.keyIdentifier, and
KeyboardEvent.location are in use.
KeyboardEvent.altKey,
KeyboardEvent.altGraphKey,
KeyboardEvent.shiftKey,
KeyboardEvent.ctrlKey, and
KeyboardEvent.metaKey are in use
unless the Keyboard.keyIdentifier
corresponds to the key modifier
itself.
Issue keyboard-1:
Should the cancellation of a keydown prevent the textInput/keyup event
types from being dispatched?
1.7.5. Mutation and mutation name event types
The mutation and mutation name event modules are designed to allow
notification of any changes to the structure of a document, including
attribute, text, or name modifications. It may be noted that none of the
event types associated with the modules are designated as cancelable. This
stems from the fact that it is very difficult to make use of existing DOM
interfaces which cause document modifications if any change to the document
might or might not take place due to cancelation of the resulted event.
Although this is still a desired capability, it was decided that it would be
better left until the addition of transactions into the DOM.
Many single modifications of the tree can cause multiple mutation events to
be dispatched. Rather than attempt to specify the ordering of mutation
events due to every possible modification of the tree, the ordering of these
events is left to the implementation.
Interface MutationEvent (introduced in DOM Level 2)
The MutationEvent interface provides specific contextual information
associated with Mutation events.
Note: To create an instance of the MutationEvent interface, use the
feature string "MutationEvent" as the value of the input parameter used
with the DocumentEvent.createEvent method.
IDL Definition
// Introduced in DOM Level 2:
interface MutationEvent : Event {
// attrChangeType
const unsigned short MODIFICATION = 1;
const unsigned short ADDITION = 2;
const unsigned short REMOVAL = 3;
readonly attribute Node relatedNode;
readonly attribute DOMString prevValue;
readonly attribute DOMString newValue;
readonly attribute DOMString attrName;
readonly attribute unsigned short attrChange;
void initMutationEvent(in DOMString typeArg,
in boolean canBubbleArg,
in boolean cancelableArg,
in Node relatedNodeArg,
in DOMString prevValueArg,
in DOMString newValueArg,
in DOMString attrNameArg,
in unsigned short attrChangeArg);
// Introduced in DOM Level 3:
void initMutationEventNS(in DOMString namespaceURI,
in DOMString typeArg,
in boolean canBubbleArg,
in boolean cancelableArg,
in Node relatedNodeArg,
in DOMString prevValueArg,
in DOMString newValueArg,
in DOMString attrNameArg,
in unsigned short attrChangeArg);
};
Definition group attrChangeType
An integer indicating in which way the Attr was changed.
Defined Constants
ADDITION
The Attr was just added.
MODIFICATION
The Attr was modified in place.
REMOVAL
The Attr was just removed.
Attributes
attrChange of type unsigned short, readonly
attrChange indicates the type of change which triggered the
DOMAttrModified event. The values can be MODIFICATION,
ADDITION, or REMOVAL.
attrName of type DOMString, readonly
attrName indicates the name of the changed Attr node in a
DOMAttrModified event.
newValue of type DOMString, readonly
newValue indicates the new value of the Attr node in
DOMAttrModified events, and of the CharacterData node in
DOMCharacterDataModified events.
prevValue of type DOMString, readonly
prevValue indicates the previous value of the Attr node in
DOMAttrModified events, and of the CharacterData node in
DOMCharacterDataModified events.
relatedNode of type Node, readonly
relatedNode is used to identify a secondary node related to a
mutation event. For example, if a mutation event is
dispatched to a node indicating that its parent has changed,
the relatedNode is the changed parent. If an event is instead
dispatched to a subtree indicating a node was changed within
it, the relatedNode is the changed node. In the case of the
DOMAttrModified event it indicates the Attr node which was
modified, added, or removed.
Methods
initMutationEvent
The initMutationEvent method is used to initialize the value
of a MutationEvent created using the
DocumentEvent.createEvent method. This method may only be
called before the MutationEvent has been dispatched via the
EventTarget.dispatchEvent method, though it may be called
multiple times before being dispatched if necessary. If
called multiple times, the final invocation takes precedence.
Parameters
typeArg of type DOMString
Specifies the event type.
canBubbleArg of type boolean
Specifies whether or not the event can bubble. This
parameter overrides the intrinsic bubbling behavior of
the event.
cancelableArg of type boolean
Specifies whether or not the event's default action can
be prevented. This parameter overrides the intrinsic
cancelable behavior of the event.
relatedNodeArg of type Node
Specifies the Event's related Node.
prevValueArg of type DOMString
Specifies the Event's prevValue attribute. This value
may be null.
newValueArg of type DOMString
Specifies the Event's newValue attribute. This value may
be null.
attrNameArg of type DOMString
Specifies the Event's attrName attribute. This value may
be null.
attrChangeArg of type unsigned short
Specifies the Event's attrChange attribute.
No Return Value
No Exceptions
initMutationEventNS introduced in DOM Level 3
The initMutationEventNS method is used to initialize the
value of a MutationEvent created using the
DocumentEvent.createEvent method. This method may only be
called before the MutationEvent has been dispatched via the
EventTarget.dispatchEvent method, though it may be called
multiple times during that phase if necessary. If called
multiple times, the final invocation takes precedence.
Parameters
namespaceURI of type DOMString
Specifies the namespace URI associated with this event,
or null if the application wish to have no namespace.
typeArg of type DOMString
Specifies the event type.
canBubbleArg of type boolean
Specifies whether or not the event can bubble.
cancelableArg of type boolean
Specifies whether or not the event's default action can
be prevented.
relatedNodeArg of type Node
Specifies the Event's related Node.
prevValueArg of type DOMString
Specifies the Event's prevValue attribute. This value
may be null.
newValueArg of type DOMString
Specifies the Event's newValue attribute. This value may
be null.
attrNameArg of type DOMString
Specifies the Event's attrName attribute. This value may
be null.
attrChangeArg of type unsigned short
Specifies the Event's attrChange attribute.
No Return Value
No Exceptions
The mutation event types are listed below. For a full description of the
semantics associated with these event types, refer to the Complete list of
event types. A DOM application may use the hasFeature(feature, version)
method of the DOMImplementation interface with parameter values
"MutationEvents" and "3.0" (respectively) to determine whether or not the
MutationEvent is supported by the implementation. In order to fully support
this module, an implementation must also support the "Events" feature
defined in this specification. For additional information about conformance,
please see the DOM Level 3 Core specification [DOM Level 3 Core]. This
MutationEvent interface is built on top of the DOM Level 2 Mutation Events
[DOM Level 2 Events] module, i.e. a DOM Level 3 MutationEvent interface
implementation where hasFeature("MutationEvents","3.0") returns true must
also return true when the version number is "2.0", "" or, null.
Event type Context information
"http://www.w3.org/2001/xml-events", None
"DOMSubtreeModified"
"http://www.w3.org/2001/xml-events", MutationEvent.relatedNode holds
"DOMNodeInserted" the parent node of the node being
inserted.
"http://www.w3.org/2001/xml-events", MutationEvent.relatedNode holds
"DOMNodeRemoved" the parent node of the node being
removed.
"http://www.w3.org/2001/xml-events", None
"DOMNodeRemovedFromDocument"
"http://www.w3.org/2001/xml-events", None
"DOMNodeInsertedIntoDocument"
"http://www.w3.org/2001/xml-events", MutationEvent.attrName is in use.
"DOMAttrModified" The value of
MutationEvent.relatedNode
indicates the Attr node whose
value has been affected. The
value of MutationEvent.attrChange
indicates whether the Attr was
modified, added, or removed. If
the Attr node is being added,
MutationEvent.newValue is in use.
If the Attr node is being
removed, MutationEvent.prevValue
is in value. If the Attr node is
being modified,
MutationEvent.newValue and
MutationEvent.prevValue are in
use.
"http://www.w3.org/2001/xml-events", MutationEvent.prevValue, and
"DOMCharacterDataModified" MutationEvent.newValue are in
use.
Interface MutationNameEvent (introduced in DOM Level 3)
The MutationNameEvent interface provides specific contextual
information associated with Mutation name event types.
Note: To create an instance of the MutationNameEvent interface, use the
feature string "MutationNameEvent" as the value of the input parameter
used with the createEvent method of the DocumentEvent interface.
IDL Definition
// Introduced in DOM Level 3:
interface MutationNameEvent : MutationEvent {
readonly attribute DOMString prevNamespaceURI;
readonly attribute DOMString prevNodeName;
// Introduced in DOM Level 3:
void initMutationNameEvent(in DOMString typeArg,
in boolean canBubbleArg,
in boolean cancelableArg,
in Node relatedNodeArg,
in DOMString prevNamespaceURI,
in DOMString prevNodeName);
// Introduced in DOM Level 3:
void initMutationNameEventNS(in DOMString namespaceURI,
in DOMString typeArg,
in boolean canBubbleArg,
in boolean cancelableArg,
in Node relatedNodeArg,
in DOMString prevNamespaceURI,
in DOMString prevNodeName);
};
Attributes
prevNamespaceURI of type DOMString, readonly
The previous value of the relatedNode's namespaceURI.
prevNodeName of type DOMString, readonly
The previous value of the relatedNode's nodeName.
Methods
initMutationNameEvent introduced in DOM Level 3
The initMutationNameEvent method is used to initialize the
value of a MutationNameEvent created using the
DocumentEvent.createEvent method. This method may only be
called before the MutationNameEvent has been dispatched via
the EventTarget.dispatchEvent method, though it may be called
multiple times during that phase if necessary. If called
multiple times, the final invocation takes precedence.
Parameters
typeArg of type DOMString
Specifies the event type.
canBubbleArg of type boolean
Specifies whether or not the event can bubble.
cancelableArg of type boolean
Specifies whether or not the event's default action can
be prevented.
relatedNodeArg of type Node
Specifies the Event's related Node.
prevNamespaceURI of type DOMString
Specifies the previous namespaceURI of the related Node.
This value may be null.
prevNodeName of type DOMString
Specifies the previous nodeName of the related Node.
No Return Value
No Exceptions
initMutationNameEventNS introduced in DOM Level 3
The initMutationNameEventNS method is used to initialize the
value of a MutationNameEvent created using the
DocumentEvent.createEvent method. This method may only be
called before the MutationNameEvent has been dispatched via
the EventTarget.dispatchEvent method, though it may be called
multiple times during that phase if necessary. If called
multiple times, the final invocation takes precedence.
Parameters
namespaceURI of type DOMString
Specifies the namespace URI associated with this event,
or null if the application wish to have no namespace.
typeArg of type DOMString
Specifies the event type.
canBubbleArg of type boolean
Specifies whether or not the event can bubble.
cancelableArg of type boolean
Specifies whether or not the event's default action can
be prevented.
relatedNodeArg of type Node
Specifies the Event's related Node.
prevNamespaceURI of type DOMString
Specifies the previous namespaceURI of the related Node.
This value may be null.
prevNodeName of type DOMString
Specifies the previous nodeName of the related Node.
No Return Value
No Exceptions
The mutation name event types are listed below. For a full description of
the semantics associated with these event types, refer to the Complete list
of event types. A DOM application may use the hasFeature(feature, version)
method of the DOMImplementation interface with parameter values
"MutationNameEvents" and "3.0" (respectively) to determine whether or not
the MutationNameEvent is supported by the implementation. In order to fully
support this module, an implementation must also support the
"MutationEvents" feature defined in this specification and the "Core"
feature defined in the DOM Level 3 Core specification [DOM Level 3 Core].
For additional information about conformance, please see the DOM Level 3
Core specification [DOM Level 3 Core].
Event type Context information
"http://www.w3.org/2001/xml-events", MutationNameEvent.prevNamespaceURI,
"DOMElementNameChanged" and MutationNameEvent.prevNodeName
are in use.
"http://www.w3.org/2001/xml-events", MutationNameEvent.prevNamespaceURI,
"DOMAttributeNameChanged" and MutationNameEvent.prevNodeName
are in use. The value of
MutationEvent.relatedNode contains
the renamed Attr node.
1.7.6. Basic event types
This event module contains basic event types associated with document
manipulation.
A DOM application may use the hasFeature(feature, version) method of the
DOMImplementation interface with parameter values "BasicEvents" and "3.0"
(respectively) to determine whether or not the basic event module is
supported by the implementation. In order to fully support this module, an
implementation must also support the "Events" feature defined in this
specification. For additional information about conformance, please see the
DOM Level 3 Core specification [DOM Level 3 Core].
The basic event types are listed below. For a full description of the
semantics associated with these event types, refer to the Complete list of
event types.
The event types {"http://www.w3.org/2001/xml-events", "resize"} and
{"http://www.w3.org/2001/xml-events", "scroll"} implement the UIEvent
interface. All other HTML event types implement at least the basic Event
interface. However, they may be generated from a user interface; in that
case, the event objects also implements the UIEvent interface and
UIEvent.view is in use.
Event type Context information
"http://www.w3.org/2001/xml-events", "load" UIEvent.view may be in use.
"http://www.w3.org/2001/xml-events", "unload" (same as above)
"http://www.w3.org/2001/xml-events", "abort" (same as above)
"http://www.w3.org/2001/xml-events", "error" (same as above)
"http://www.w3.org/2001/xml-events", "select" (same as above)
"http://www.w3.org/2001/xml-events", "change" (same as above)
"http://www.w3.org/2001/xml-events", "submit" (same as above)
"http://www.w3.org/2001/xml-events", "reset" (same as above)
"http://www.w3.org/2001/xml-events", "resize" UIEvent.view is in use.
"http://www.w3.org/2001/xml-events", "scroll" UIEvent.view is in use.
1.7.7. HTML Events
The HTML event module is composed of events listed in [HTML 4.01] and
additional events which are supported in DOM Level 0 browsers. It refines
the semantics and scope of the basic event types and provides two new event
types. This event module is only applicable if the Document supports the
[DOM Level 2 HTML] specification. Use Node.isSupported(feature, version)
with the parameter values "HTML" and "2.0" (respectively) to determine
whether or not the Document node supported the HTML module.
A DOM application may use the hasFeature(feature, version) method of the
DOMImplementation interface with parameter values "HTMLEvents" and "3.0"
(respectively) to determine whether or not the HTML event module is
supported by the implementation. In order to fully support this module, an
implementation must also support the "BasicEvents" feature defined in this
specification and the "HTML" feature defined in [DOM Level 2 HTML]. For
additional information about conformance, please see the DOM Level 3 Core
specification [DOM Level 3 Core]. The DOM Level 3 HTML Events module is
built on top of the DOM Level 2 HTML Events [DOM Level 2 Events] module,
i.e. a DOM Level 3 HTML Events implementation where hasFeature("HTMLEvents",
"3.0") returns true must also return true when the version number is "2.0",
"" or, null.
Event type Description Target node
"http://www.w3.org/2001/xml-events", The DOM implementation HTMLBodyElement,
"load" finishes loading all HTMLFrameSetElement,
content within the BODY HTMLObjectElement,
element, all frames HTMLLinkElement,
within a FRAMESET, or anyHTMLMetaElement,
resource linked from the HTMLScriptElement,
document. HTMLFrameElement,
HTMLIFrameElement,
HTMLImageElement
"http://www.w3.org/2001/xml-events", The DOM implementation HTMLBodyElement,
"unload" removes a document from aHTMLFrameSetElement
window or frame. This
event is valid for BODY
and FRAMESET elements.
"http://www.w3.org/2001/xml-events", The page loading is HTMLObjectElement
"abort" stopped before an image
has been allowed to
completely load. This
event applies to OBJECT
elements.
"http://www.w3.org/2001/xml-events", An image does not load HTMLObjectElement,
"error" properly or when an errorHTMLBodyElement,
occurs during script HTMLFrameSetElement
execution. This event is
valid for OBJECT
elements, BODY elements,
and FRAMESET element.
"http://www.w3.org/2001/xml-events", A user selects some text HTMLInputElement,
"select" in a text field either HTMLTextAreaElement
via the user interface or
via attributes defined in
[DOM Level 2 HTML]. This
event is valid for INPUT
and TEXTAREA elements.
"http://www.w3.org/2001/xml-events", A control loses the inputHTMLInputElement,
"change" focus and its value has HTMLSelectElement,
been modified since HTMLTextAreaElement
gaining focus. This event
can occur either via a
user interface
manipulation or the
focus() methods and the
attributes defined in
[DOM Level 2 HTML]. This
event is valid for INPUT,
SELECT, and TEXTAREA
element.
"http://www.w3.org/2001/xml-events", A form is submitted HTMLFormElement
"submit" either via a button. This
event only applies to the
FORM element. Note that
the
HTMLFormElement.submit()
method defined in [DOM
Level 2 HTML] does not
fire this event type.
"http://www.w3.org/2001/xml-events", A form is reset either HTMLFormElement
"reset" via a button, or the
HTMLFormElement.reset()
method defined in [DOM
Level 2 HTML]. This event
only applies to the FORM
element.
"http://www.w3.org/2001/xml-events", A document view is HTMLDocument
"resize" resized.
"http://www.w3.org/2001/xml-events", A document view is HTMLDocument
"scroll" scrolled.
The following new event types are defined:
Event type Description BubblingCancelable Target node DOM
phase interface
"http://www.w3.org/2001/xml-events", An element receives focus either via No No HTMLAnchorElement, Event
"focus" a pointing device, the focus() HTMLAreaElement,
methods defined in [DOM Level 2 HTMLLabelElement,
HTML], or by tabbing navigation. This HTMLInputElement,
event is only valid for the following HTMLSelectElement,
elements: A, AREA, LABEL, INPUT, HTMLtextAreaElement,
SELECT, TEXTAREA, and BUTTON. This HTMLButtonElement.
event type is dispatched after the
event type
{"http://www.w3.org/2001/xml-events",
"DOMFocusIn"}.
"http://www.w3.org/2001/xml-events", An element loses focus either via a No No HTMLAnchorElement, Event
"blur" pointing device, the blur() methods HTMLAreaElement,
defined in [DOM Level 2 HTML], or by HTMLLabelElement,
tabbing navigation. This event is HTMLInputElement,
only valid for the following HTMLSelectElement,
elements: A, AREA, LABEL, INPUT, HTMLtextAreaElement,
SELECT, TEXTAREA, and BUTTON. This HTMLButtonElement.
event type is dispatched after the
event type
{"http://www.w3.org/2001/xml-events",
"DOMFocusOut"}.
The event types {"http://www.w3.org/2001/xml-events", "focus"} and
{"http://www.w3.org/2001/xml-events", "blur"} may be generated from a user
interface; in that case, the event objects also implements the UIEvent
interface and UIEvent.view is in use.
1.7.7.1. Activation and default actions
The concept of activation ({"http://www.w3.org/2001/xml-events",
"DOMActivate"}) was introduced in [DOM Level 2 Events] to separate generic
actions from the devices used to activate them. For example, an hyperlink
can be activated using a mouse or a keyboard, and the activation will force
the user agent to follow the link. It is expected that the action of
following the link is done using a default action attached to the hyperlink
element. In such case, the default action of the device event type is to
trigger the event type {"http://www.w3.org/2001/xml-events", "DOMActivate"}.
Preventing the default action of a mouse click when the target node is an
hyperlink will prevent the activation. The same approach is made for control
elements.
If a change is made before the activation, cancelling the device event type
will also reverse the change. A good example is the attribute
HTMLInputElement.checked. As described in [DOM Level 2 HTML], the value of
this property may be changed before the dispatch of the event: the user
clicks on the radio button, the radio button is being checked (or unchecked)
on the display, the attribute HTMLInputElement.checked is changed as well,
and then the device event type {"http://www.w3.org/2001/xml-events",
"click"} is being dispatched. If the default action of the device event type
is prevented, or if the default action attached to the
{"http://www.w3.org/2001/xml-events", "DOMActivate"} event type is
prevented, the value of the property will need to be changed back to its
original value.
31 March 2003
Appendix A: Key identifiers for keyboard events.
Editor:
Philippe Le Hégaret, W3C
A.1: Introduction
Each keyboard event references a key using a DOMString key identifier. The
set contained in this appendix is based on the sets of keycodes from:
* the interface java.awt.event.KeyEvent of the Java 2 Platform v1.4
[KeyEvent for Java];
* the enumeration System.Windows.Forms.Keys of the Microsoft .NET
Framework 1.0 [Keys enumeration for .Net].
While implementations are recommended to use the most relevant identifier
for a key independently of the platform or keyboard layout mappings, DOM
applications should not make assumption on the ability of keyboard devices
to generate them. When using keyboard events, "consider using numbers and
function keys (F4, F5, and so on) instead of letters in shortcut-key
combinaisons" ([DWW95]) given that most keyboard layouts will provide keys
for those.
"U+000000", "U+000001", ..., "U+FFFFFF" are Unicode based key identifiers
([Unicode 3.0]). When a key cannot be mapped to Unicode, a specific
identifier is used (see also Guidelines for defining key identifiers). In
any case, no assumption should be made between the sequence of keyboard
events and the text events. The following three examples illustrated the
concept of keyboard layout mappings and its relation with keyboard events.
The keystroke "U+000051" (Latin Capital Letter Q key) will produce (on a
PC/AT US keyboard using a US keyboard layout mapping and without any
modifier activated) the Unicode character q (Latin Small Letter Q):
1. {"http://www.w3.org/2001/xml-events", "keydown"}: "U+000051" (Latin
Capital Letter Q key)
2. {"http://www.w3.org/2001/xml-events", "textInput"}: "q"
3. {"http://www.w3.org/2001/xml-events", "keyup"}: "U+000051" (Latin
Capital Letter Q key)
If the keyboard layout mapping is switched to a french mapping, pressing the
same key will produce:
1. {"http://www.w3.org/2001/xml-events", "keydown"}: "U+000041"
2. {"http://www.w3.org/2001/xml-events", "textInput"}: "a"
3. {"http://www.w3.org/2001/xml-events", "keyup"}: "U+000041"
If the keyboard layout mapping is switched to a serbian (cyrillic) mapping,
pressing the same key will produce:
1. {"http://www.w3.org/2001/xml-events", "keydown"}: "U+000409"
2. {"http://www.w3.org/2001/xml-events", "textInput"}: "?"
3. {"http://www.w3.org/2001/xml-events", "keyup"}: "U+000409"
Note: The order between the text event and keyboard events may differ
depending on the keyboard devices.
A.1.1: Modifier keys
Keyboard input use modifier keys to change the normal behavior of a key. The
KeyboardEvent interface provides specific attributes for them:
KeyboardEvent.ctrlKey, KeyboardEvent.shiftKey, KeyboardEvent.altKey,
KeyboardEvent.metaKey, and KeyboardEvent.altGraphKey.
The following example describes a possible sequence of keys to generate the
Unicode character Q (Latin Capital Letter Q) on a PC/AT US keyboard using a
US mapping:
1. {"http://www.w3.org/2001/xml-events", "keydown"}: "Shift", shiftKey
2. {"http://www.w3.org/2001/xml-events", "keydown"}: "U+000051" (Latin
Capital Letter Q key), shiftKey
3. {"http://www.w3.org/2001/xml-events", "textInput"}: "Q"
4. {"http://www.w3.org/2001/xml-events", "keyup"}: "U+000051" (Latin
Capital Letter Q key), shiftKey
5. {"http://www.w3.org/2001/xml-events", "keyup"}: "Shift"
The following example describes a possible sequence of keys that does not
generate a Unicode character (using the same configuration):
1. {"http://www.w3.org/2001/xml-events", "keydown"}: "Control", ctrlKey
2. {"http://www.w3.org/2001/xml-events", "keydown"}: "U+000056" (Latin
Capital Letter V key), ctrlKey
3. {"http://www.w3.org/2001/xml-events", "keyup"}: "U+000056" (Latin
Capital Letter V key), ctrlKey
4. {"http://www.w3.org/2001/xml-events", "keyup"}: "Control"
A.1.2: Dead keys
Keyboard input use dead keys for the input of composed character sequences.
Unlike the handwriting sequence, in which users type the base character
first, keyboard input require to enter a special state when a dead key is
pressed and emit the character(s) only when one of a limited number of
"legal" base character is entered.
The dead keys are represented in the key identifiers set using combining
diacritical marks. The sequence of keystrokes "U+000302" (Combining
Circumflex Accent key) and "U+000045" (Latin Capital Letter E key) will
likely produce (on a PC/AT french keyboard using a french mapping and
without any modifier activated) the Unicode character é (Latin Small Letter
E With Acute) or the composed Unicode character sequence e (Latin Small
Letter E) and 000302 (Combining Circumflex Accent). In practice, french
keyboard input will generate the Unicode character é instead of the composed
Unicode character sequence, as shown in the following example:
1. {"http://www.w3.org/2001/xml-events", "keydown"}: "U+000302" (Combining
Circumflex Accent key)
2. {"http://www.w3.org/2001/xml-events", "keyup"}: "U+000302" (Combining
Circumflex Accent key)
3. {"http://www.w3.org/2001/xml-events", "keydown"}: "U+000045" (Latin
Capital Letter E key)
4. {"http://www.w3.org/2001/xml-events", "textInput"}: "é"
5. {"http://www.w3.org/2001/xml-events", "keyup"}: "U+000045" (Latin
Capital Letter E key)
A.1.3: Input Method Editors
Also known as front end processor, an input method editor (IME) is an
application that performs the conversion between keystrokes and ideographs
or other characters, usually by user-guided dictionary lookup.
The IMEs function keys are not represented in this set. As an example,
receiving an keydown for the "Accept" key identifier does not necessarily
implies that the text currently selected in the IME is being accepted. It
only indicates that a keystroke happened, disconnected from the IME Accept
functionality. Depending on the device in use, the IME Accept functionality
can be obtain using the Accept key or the Return key. Keyboard events cannot
be used to determine the current state of the input method editor.
Keyboard events correspond to the events generated by the input device after
the keyboard layout mapping but before the processing of the input method
editor.
The following example describes a possible sequence of keys to generate the
Unicode character ? (Hiragana Letter SI) using Japanese input methods. This
assumes that the input method editor is activated and in the Japanese-Romaji
input mode. The keys "Convert" and "Accept" may be replaced by others
depending on the input device in use and the configuration of the IME, e.g.
it could be respectively "U+000020" (Space key) and "Enter".
1. {"http://www.w3.org/2001/xml-events", "keydown"}: "U+000053" (Latin
Capital Letter S key)
2. {"http://www.w3.org/2001/xml-events", "keyup"}: "U+000053" (Latin
Capital Letter S key)
3. {"http://www.w3.org/2001/xml-events", "keydown"}: "U+000049" (Latin
Capital Letter I key)
4. {"http://www.w3.org/2001/xml-events", "keyup"}: "U+000049" (Latin
Capital Letter I key)
5. {"http://www.w3.org/2001/xml-events", "keydown"}: "Convert"
6. {"http://www.w3.org/2001/xml-events", "keyup"}: "Convert"
7. {"http://www.w3.org/2001/xml-events", "keydown"}: "Accept"
8. {"http://www.w3.org/2001/xml-events", "textInput"}: "?"
9. {"http://www.w3.org/2001/xml-events", "keyup"}: "Accept"
Note: This specification does not provide a representation of the input
method editor (IME) events, e.g. representing the input context.
A.1.4: Guidelines for defining key identifiers
Note: This section is informative.
The list of key identifiers contained in this appendix is not exhaustive and
input devices may have to define their own key identifiers. Here is a
algorithm to determine which key identifier to use:
1. Determine a representation for the key by looking at the keyboard
layout mapping in use (and not the keyboard device in use). This
representation should be unique, as human friendly as possible,
platform independent, and consistent. For example, on PC/AT US
keyboards with a US mapping, the 'Q' key is mapped to the key
identifier "U+000051" (Latin Capital Letter Q key), the '1/!' key is
mapped to the key identifier "U+000031" (Digit One key), the key '`/~'
is mapped to the key identifier "U+000060" (Grave Accent key), and the
'Enter' key is mapped to the key identifier "Enter".
2. Find an appropriate mapping in the Unicode character set. There might
not always be an appropriate and obvious mapping: the Unicode set
contains characters and symbols, the key might generate different
characters depending on the operating system, ... In general, unless
the representation of the key can be mapped to a unique Unicode
character, it is better to create a new one.
3. If no appropriate mapping was found, create an key identifier as human
friendly as possible. As an example, the Enter key is mapped to the key
identifier "Enter" and not to "U+00000A" (Line Feed), given that this
key generates the character 00000A on Unix operating systems and the
characters 00000D and 00000A on Windows operating systems.
A.2: Key identifiers set
Note: The keycodes Multiply, Add, Substract, Decimal, Separator, Divide,
NumPad0, NumPad1, NumPad2, NumPad3, NumPad4, NumPad5, NumPad6, NumPad7,
NumPad8, and NumPad9 are not part of this set. Use KeyBoard.keyLocation to
know if a key originated from the numeric keypad.
"Accept"
The Accept (Commit) key.
"Again"
The Again key.
"AllCandidates"
The All Candidates key.
"Alphanumeric"
The Alphanumeric key.
"Alt"
The Alt (Menu) key.
"AltGraph"
The Alt-Graph key.
"Apps"
The Application key.
"Attn"
The ATTN key.
"BrowserBack"
The Browser Back key.
"BrowserFavorites"
The Browser Favorites key.
"BrowserForward"
The Browser Forward key.
"BrowserHome"
The Browser Home key.
"BrowserRefresh"
The Browser Refresh key.
"BrowserSearch"
The Browser Search key.
"BrowserStop"
The Browser Stop key.
"CapsLock"
The Caps Lock (Capital) key.
"Clear"
The Clear key.
"CodeInput"
The Code Input key.
"Compose"
The Compose key.
"Control"
The Control (Ctrl) key.
"Crsel"
The Crsel key.
"Convert"
The Convert key.
"Copy"
The Copy key.
"Cut"
The Cut key.
"Down"
The Down Arrow key.
"End"
The End key.
"Enter"
The Enter key.
Note: This key identifier is also used for the Return (Macintosh
numpad) key.
"EraseEof"
The Erase EOF key.
"Execute"
The Execute key.
"Exsel"
The Exsel key.
"F1"
The F1 key.
"F2"
The F2 key.
"F3"
The F3 key.
"F4"
The F4 key.
"F5"
The F5 key.
"F6"
The F6 key.
"F7"
The F7 key.
"F8"
The F8 key.
"F9"
The F9 key.
"F10"
The F10 key.
"F11"
The F11 key.
"F12"
The F12 key.
"F13"
The F13 key.
"F14"
The F14 key.
"F15"
The F15 key.
"F16"
The F16 key.
"F17"
The F17 key.
"F18"
The F18 key.
"F19"
The F19 key.
"F20"
The F20 key.
"F21"
The F21 key.
"F22"
The F22 key.
"F23"
The F23 key.
"F24"
The F24 key.
"FinalMode"
The Final Mode (Final) key used on some asian keyboards.
"Find"
The Find key.
"FullWidth"
The Full-Width Characters key.
"HalfWidth"
The Half-Width Characters key.
"HangulMode"
The Hangul (Korean characters) Mode key.
"HanjaMode"
The Hanja (Korean characters) Mode key.
"Help"
The Help key.
"Hiragana"
The Hiragana (Japanese Kana characters) key.
"Home"
The Home key.
"Insert"
The Insert (Ins) key.
"JapaneseHiragana"
The Japanese-Hiragana key.
"JapaneseKatakana"
The Japanese-Katakana key.
"JapaneseRomaji"
The Japanese-Romaji key.
"JunjaMode"
The Junja Mode key.
"KanaMode"
The Kana Mode (Kana Lock) key.
"KanjiMode"
The Kanji (Japanese name for ideographic characters of Chinese origin)
Mode key.
"Katakana"
The Katakana (Japanese Kana characters) key.
"LaunchApplication1"
The Start Application One key.
"LaunchApplication2"
The Start Application Two key.
"LaunchMail"
The Start Mail key.
"Left"
The Left Arrow key.
"Meta"
The Meta key.
"MediaNextTrack"
The Media Next Track key.
"MediaPlayPause"
The Media Play Pause key.
"MediaPreviousTrack"
The Media Previous Track key.
"MediaStop"
The Media Stok key.
"ModeChange"
The Mode Change key.
"Nonconvert"
The Nonconvert (Don't Convert) key.
"NumLock"
The Num Lock key.
"PageDown"
The Page Down (Next) key.
"PageUp"
The Page Up key.
"Paste"
The Paste key.
"Pause"
The Pause key.
"Play"
The Play key.
"PreviousCandidate"
The Previous Candidate function key.
"PrintScreen"
The Print Screen (PrintScrn, SnapShot) key.
"Process"
The Process key.
"Props"
The Props key.
"Right"
The Right Arrow key.
"RomanCharacters"
The Roman Characters function key.
"Scroll"
The Scroll Lock key.
"Select"
The Select key.
"SelectMedia"
The Select Media key.
"Shift"
The Shift key.
"Stop"
The Stop key.
"Up"
The Up Arrow key.
"Undo"
The Undo key.
"VolumeDown"
The Volume Down key.
"VolumeMute"
The Volume Mute key.
"VolumeUp"
The Volume Up key.
"Win"
The Windows Logo key.
"Zoom"
The Zoom key.
"U+000008"
The Backspace (Back) key.
"U+000009"
The Horizontal Tabulation (Tab) key.
"U+000018"
The Cancel key.
"U+00001B"
The Escape (Esc) key.
"U+000020"
The Space (Spacebar) key.
"U+000021"
The Exclamation Mark (Factorial, Bang) key (!).
"U+000022"
The Quotation Mark (Quote Double) key (").
"U+000023"
The Number Sign (Pound Sign, Hash, Crosshatch, Octothorpe) key (#).
"U+000024"
The Dollar Sign (milreis, escudo) key ($).
"U+000026"
The Ampersand key (&).
"U+000027"
The Apostrophe (Apostrophe-Quote, APL Quote) key (').
"U+000028"
The Left Parenthesis (Opening Parenthesis) key (().
"U+000029"
The Right Parenthesis (Closing Parenthesis) key ()).
"U+00002A"
The Asterix (Star) key (*).
"U+00002B"
The Plus Sign (Plus) key (+).
"U+00002C"
The Comma (decimal separator) sign key (,).
"U+00002D"
The Hyphen-minus (hyphen or minus sign) key (-).
"U+00002E"
The Full Stop (period, dot, decimal point) key (.).
"U+00002F"
The Solidus (slash, virgule, shilling) key (/).
"U+000030"
The Digit Zero key (0).
"U+000031"
The Digit One key (1).
"U+000032"
The Digit Two key (2).
"U+000033"
The Digit Three key (3).
"U+000034"
The Digit Four key (4).
"U+000035"
The Digit Five key (5).
"U+000036"
The Digit Six key (6).
"U+000037"
The Digit Seven key (7).
"U+000038"
The Digit Eight key (8).
"U+000039"
The Digit Nine key (9).
"U+00003A"
The Colon key (:).
"U+00003B"
The Semicolon key (;).
"U+00003C"
The Less-Than Sign key ().
"U+00003F"
The Question Mark key (?).
"U+000040"
The Commercial At (@) key.
"U+000041"
The Latin Capital Letter A key (A).
"U+000042"
The Latin Capital Letter B key (B).
"U+000043"
The Latin Capital Letter C key (C).
"U+000044"
The Latin Capital Letter D key (D).
"U+000045"
The Latin Capital Letter E key (E).
"U+000046"
The Latin Capital Letter F key (F).
"U+000047"
The Latin Capital Letter G key (G).
"U+000048"
The Latin Capital Letter H key (H).
"U+000049"
The Latin Capital Letter I key (I).
"U+00004A"
The Latin Capital Letter J key (J).
"U+00004B"
The Latin Capital Letter K key (K).
"U+00004C"
The Latin Capital Letter L key (L).
"U+00004D"
The Latin Capital Letter M key (M).
"U+00004E"
The Latin Capital Letter N key (N).
"U+00004F"
The Latin Capital Letter O key (O).
"U+000050"
The Latin Capital Letter P key (P).
"U+000051"
The Latin Capital Letter Q key (Q).
"U+000052"
The Latin Capital Letter R key (R).
"U+000053"
The Latin Capital Letter S key (S).
"U+000054"
The Latin Capital Letter T key (T).
"U+000055"
The Latin Capital Letter U key (U).
"U+000056"
The Latin Capital Letter V key (V).
"U+000057"
The Latin Capital Letter W key (W).
"U+000058"
The Latin Capital Letter X key (X).
"U+000059"
The Latin Capital Letter Y key (Y).
"U+00005A"
The Latin Capital Letter Z key (Z).
"U+00005B"
The Left Square Bracket (Opening Square Bracket) key ([).
"U+00005C"
The Reverse Solidus (Backslash) key (\).
"U+00005D"
The Right Square Bracket (Closing Square Bracket) key (]).
"U+00005E"
The Circumflex Accent key (^).
"U+00005F"
The Low Sign (Spacing Underscore, Underscore) key (_).
"U+000060"
The Grave Accent (Back Quote) key (`).
"U+00007B"
The Left Curly Bracket (Opening Curly Bracket, Opening Brace, Brace
Left) key ({).
"U+00007C"
The Vertical Line (Vertical Bar, Pipe) key (|).
"U+00007D"
The Right Curly Bracket (Closing Curly Bracket, Closing Brace, Brace
Right) key (}).
"U+00007F"
The Delete (Del) Key.
"U+0000A1"
The Inverted Exclamation Mark key (¡).
"U+000300"
The Combining Grave Accent (Greek Varia, Dead Grave) key.
"U+000301"
The Combining Acute Accent (Stress Mark, Greek Oxia, Tonos, Dead
Eacute) key.
"U+000302"
The Combining Circumflex Accent (Hat, Dead Circumflex) key.
"U+000303"
The Combining Tilde (Dead Tilde) key.
"U+000304"
The Combining Macron (Long, Dead Macron) key.
"U+000306"
The Combining Breve (Short, Dead Breve) key.
"U+000307"
The Combining Dot Above (Derivative, Dead Above Dot) key.
"U+000308"
The Combining Diaeresis (Double Dot Abode, Umlaut, Greek Dialytika,
Double Derivative, Dead Diaeresis) key.
"U+00030A"
The Combining Ring Above (Dead Above Ring) key.
"U+00030B"
The Combining Double Acute Accent (Dead Doubleacute) key.
"U+00030C"
The Combining Caron (Hacek, V Above, Dead Caron) key.
"U+000327"
The Combining Cedilla (Dead Cedilla) key.
"U+000328"
The Combining Ogonek (Nasal Hook, Dead Ogonek) key.
"U+000345"
The Combining Greek Ypogegrammeni (Greek Non-Spacing Iota Below, Iota
Subscript, Dead Iota) key.
"U+0020AC"
The Euro Currency Sign key (EUR).
"U+003099"
The Combining Katakana-Hiragana Voiced Sound Mark (Dead Voiced Sound)
key.
"U+00309A"
The Combining Katakana-Hiragana Semi-Voiced Sound Mark (Dead Semivoiced
Sound) key.
31 March 2003
Appendix B: Changes
Editor:
Philippe Le Hégaret, W3C
B.1: Changes between DOM Level 2 Events and DOM Level 3 Events
This new specification provides a better separation between the DOM even
flow, the event types, and the DOM interfaces.
B.1.1: Changes to DOM Level 2 event flow
This new specification introduced two new concepts in the event flow:
* event groups: unlike DOM Level 2 Events, stopPropagation does no longer
stop the event propagation entirely. It only stops it for a given event
group.
* partial ordering of event listeners: within an event group, event
listeners are now ordered while ordering was unspecified in DOM Level 2
Events.
B.1.2: Changes to DOM Level 2 event types
Lots of clarifications have been made on the event types. The conformance is
now explicitly defined against the event types, and not only the interfaces
required by the event types. Support for namespaces and the feature
"BasicEvents" have been introduced.
The DOM Level 2 Event load event type can now be dispatched to more [HTML
4.01] elements. blur and focus have been clarified and restricted to [HTML
4.01] applications only.
B.1.3: Changes to DOM Level 2 Events interfaces
Interface Event
The Event interface has a new attribute namespaceURI, and a four new
methods: isDefaultPrevented, isCustom, stopImmediatePropagation,
isPropagationStopped, initEventNS.
Interface EventTarget
The EventTarget interface has four new methods: addEventListenerNS,
removeEventListenerNS, willTriggerNS, hasEventListenerNS.
Interface DocumentEvent
The Event interface has one new method: canDispatch.
Interface UIEvent
The UIEvent interface has a new method initUIEventNS.
Interface MouseEvent
The MouseEvent interface has a new method initMouseEventNS and a new
attribute altGraphKey.
Interface MutationEvent
The MutationEvent interface has a new method initMutationEventNS.
Exception EventException
The DISPATCH_REQUEST_ERR constant has been added.
B.1.4: New Interfaces
The interfaces CustomEvent, TextEvent, KeyboardEvent, and MutationNameEvent
were added to the Events module.
31 March 2003
Appendix C: IDL Definitions
This appendix contains the complete OMG IDL [OMG IDL] for the Level 3
Document Object Model Events definitions.
The IDL files are also available as:
http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/idl.zip
events.idl:
// File: events.idl
#ifndef _EVENTS_IDL_
#define _EVENTS_IDL_
#include "dom.idl"
#include "views.idl"
#pragma prefix "dom.w3c.org"
module events
{
typedef dom::DOMString DOMString;
typedef dom::DOMTimeStamp DOMTimeStamp;
typedef dom::DOMObject DOMObject;
typedef dom::Node Node;
interface EventTarget;
interface EventListener;
// Introduced in DOM Level 2:
exception EventException {
unsigned short code;
};
// EventExceptionCode
const unsigned short UNSPECIFIED_EVENT_TYPE_ERR = 0;
// Introduced in DOM Level 3:
const unsigned short DISPATCH_REQUEST_ERR = 1;
// Introduced in DOM Level 2:
interface Event {
// PhaseType
const unsigned short CAPTURING_PHASE = 1;
const unsigned short AT_TARGET = 2;
const unsigned short BUBBLING_PHASE = 3;
readonly attribute DOMString type;
readonly attribute EventTarget target;
readonly attribute EventTarget currentTarget;
readonly attribute unsigned short eventPhase;
readonly attribute boolean bubbles;
readonly attribute boolean cancelable;
readonly attribute DOMTimeStamp timeStamp;
void stopPropagation();
void preventDefault();
void initEvent(in DOMString eventTypeArg,
in boolean canBubbleArg,
in boolean cancelableArg);
// Introduced in DOM Level 3:
readonly attribute DOMString namespaceURI;
// Introduced in DOM Level 3:
boolean isCustom();
// Introduced in DOM Level 3:
void stopImmediatePropagation();
// Introduced in DOM Level 3:
boolean isDefaultPrevented();
// Introduced in DOM Level 3:
void initEventNS(in DOMString namespaceURIArg,
in DOMString eventTypeArg,
in boolean canBubbleArg,
in boolean cancelableArg);
};
// Introduced in DOM Level 2:
interface EventTarget {
void addEventListener(in DOMString type,
in EventListener listener,
in boolean useCapture);
void removeEventListener(in DOMString type,
in EventListener listener,
in boolean useCapture);
// Modified in DOM Level 3:
boolean dispatchEvent(in Event evt)
raises(EventException);
// Introduced in DOM Level 3:
void addEventListenerNS(in DOMString namespaceURI,
in DOMString type,
in EventListener listener,
in boolean useCapture,
in DOMObject evtGroup);
// Introduced in DOM Level 3:
void removeEventListenerNS(in DOMString namespaceURI,
in DOMString type,
in EventListener listener,
in boolean useCapture);
// Introduced in DOM Level 3:
boolean willTriggerNS(in DOMString namespaceURI,
in DOMString type);
// Introduced in DOM Level 3:
boolean hasEventListenerNS(in DOMString namespaceURI,
in DOMString type);
};
// Introduced in DOM Level 2:
interface EventListener {
void handleEvent(in Event evt);
};
// Introduced in DOM Level 2:
interface DocumentEvent {
Event createEvent(in DOMString eventType)
raises(dom::DOMException);
// Introduced in DOM Level 3:
boolean canDispatch(in DOMString namespaceURI,
in DOMString type);
};
// Introduced in DOM Level 3:
interface CustomEvent : Event {
void setDispatchState(in EventTarget target,
in unsigned short phase);
boolean isPropagationStopped();
boolean isImmediatePropagationStopped();
};
// Introduced in DOM Level 2:
interface UIEvent : Event {
readonly attribute views::AbstractView view;
readonly attribute long detail;
void initUIEvent(in DOMString typeArg,
in boolean canBubbleArg,
in boolean cancelableArg,
in views::AbstractView viewArg,
in long detailArg);
// Introduced in DOM Level 3:
void initUIEventNS(in DOMString namespaceURI,
in DOMString typeArg,
in boolean canBubbleArg,
in boolean cancelableArg,
in views::AbstractView viewArg,
in long detailArg);
};
// Introduced in DOM Level 3:
interface TextEvent : UIEvent {
readonly attribute DOMString data;
void initTextEvent(in DOMString typeArg,
in boolean canBubbleArg,
in boolean cancelableArg,
in views::AbstractView viewArg,
in DOMString dataArg);
void initTextEventNS(in DOMString namespaceURI,
in DOMString type,
in boolean canBubbleArg,
in boolean cancelableArg,
in views::AbstractView viewArg,
in DOMString dataArg);
};
// Introduced in DOM Level 2:
interface MouseEvent : UIEvent {
readonly attribute long screenX;
readonly attribute long screenY;
readonly attribute long clientX;
readonly attribute long clientY;
readonly attribute boolean ctrlKey;
readonly attribute boolean shiftKey;
readonly attribute boolean altKey;
readonly attribute boolean metaKey;
readonly attribute unsigned short button;
readonly attribute EventTarget relatedTarget;
void initMouseEvent(in DOMString typeArg,
in boolean canBubbleArg,
in boolean cancelableArg,
in views::AbstractView viewArg,
in long detailArg,
in long screenXArg,
in long screenYArg,
in long clientXArg,
in long clientYArg,
in boolean ctrlKeyArg,
in boolean altKeyArg,
in boolean shiftKeyArg,
in boolean metaKeyArg,
in unsigned short buttonArg,
in EventTarget relatedTargetArg);
// Introduced in DOM Level 3:
void initMouseEventNS(in DOMString namespaceURI,
in DOMString typeArg,
in boolean canBubbleArg,
in boolean cancelableArg,
in views::AbstractView viewArg,
in long detailArg,
in long screenXArg,
in long screenYArg,
in long clientXArg,
in long clientYArg,
in boolean ctrlKeyArg,
in boolean altKeyArg,
in boolean shiftKeyArg,
in boolean metaKeyArg,
in unsigned short buttonArg,
in EventTarget relatedTargetArg,
in boolean altGraphKeyArg);
// Introduced in DOM Level 3:
readonly attribute boolean altGraphKey;
};
// Introduced in DOM Level 3:
interface KeyboardEvent : UIEvent {
// KeyLocationCode
const unsigned long DOM_KEY_LOCATION_STANDARD = 0x00;
const unsigned long DOM_KEY_LOCATION_LEFT = 0x01;
const unsigned long DOM_KEY_LOCATION_RIGHT = 0x02;
const unsigned long DOM_KEY_LOCATION_NUMPAD = 0x03;
const unsigned long DOM_KEY_LOCATION_UNKNOWN = 0x04;
readonly attribute DOMString keyIdentifier;
readonly attribute unsigned long keyLocation;
readonly attribute boolean ctrlKey;
readonly attribute boolean shiftKey;
readonly attribute boolean altKey;
readonly attribute boolean metaKey;
readonly attribute boolean altGraphKey;
void initKeyboardEvent(in DOMString typeArg,
in boolean canBubbleArg,
in boolean cancelableArg,
in views::AbstractView viewArg,
in DOMString keyIdentifierArg,
in unsigned long keyLocationArg,
in boolean ctrlKeyArg,
in boolean shiftKeyArg,
in boolean altKeyArg,
in boolean metaKeyArg,
in boolean altGraphKeyArg);
void initKeyboardEventNS(in DOMString namespaceURI,
in DOMString type,
in boolean canBubbleArg,
in boolean cancelableArg,
in views::AbstractView viewArg,
in DOMString keyIdentifierArg,
in unsigned long keyLocationArg,
in boolean ctrlKeyArg,
in boolean shiftKeyArg,
in boolean altKeyArg,
in boolean metaKeyArg,
in boolean altGraphKeyArg);
};
// Introduced in DOM Level 2:
interface MutationEvent : Event {
// attrChangeType
const unsigned short MODIFICATION = 1;
const unsigned short ADDITION = 2;
const unsigned short REMOVAL = 3;
readonly attribute Node relatedNode;
readonly attribute DOMString prevValue;
readonly attribute DOMString newValue;
readonly attribute DOMString attrName;
readonly attribute unsigned short attrChange;
void initMutationEvent(in DOMString typeArg,
in boolean canBubbleArg,
in boolean cancelableArg,
in Node relatedNodeArg,
in DOMString prevValueArg,
in DOMString newValueArg,
in DOMString attrNameArg,
in unsigned short attrChangeArg);
// Introduced in DOM Level 3:
void initMutationEventNS(in DOMString namespaceURI,
in DOMString typeArg,
in boolean canBubbleArg,
in boolean cancelableArg,
in Node relatedNodeArg,
in DOMString prevValueArg,
in DOMString newValueArg,
in DOMString attrNameArg,
in unsigned short attrChangeArg);
};
// Introduced in DOM Level 3:
interface MutationNameEvent : MutationEvent {
readonly attribute DOMString prevNamespaceURI;
readonly attribute DOMString prevNodeName;
// Introduced in DOM Level 3:
void initMutationNameEvent(in DOMString typeArg,
in boolean canBubbleArg,
in boolean cancelableArg,
in Node relatedNodeArg,
in DOMString prevNamespaceURI,
in DOMString prevNodeName);
// Introduced in DOM Level 3:
void initMutationNameEventNS(in DOMString namespaceURI,
in DOMString typeArg,
in boolean canBubbleArg,
in boolean cancelableArg,
in Node relatedNodeArg,
in DOMString prevNamespaceURI,
in DOMString prevNodeName);
};
};
#endif // _EVENTS_IDL_
31 March 2003
Appendix D: Java Language Binding
This appendix contains the complete Java [Java] bindings for the Level 3
Document Object Model Events.
The Java files are also available as
http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/java-binding.zip
org/w3c/dom/events/EventException.java:
package org.w3c.dom.events;
public class EventException extends RuntimeException {
public EventException(short code, String message) {
super(message);
this.code = code;
}
public short code;
// EventExceptionCode
public static final short UNSPECIFIED_EVENT_TYPE_ERR = 0;
public static final short DISPATCH_REQUEST_ERR = 1;
}
org/w3c/dom/events/Event.java:
package org.w3c.dom.events;
public interface Event {
// PhaseType
public static final short CAPTURING_PHASE = 1;
public static final short AT_TARGET = 2;
public static final short BUBBLING_PHASE = 3;
public String getType();
public EventTarget getTarget();
public EventTarget getCurrentTarget();
public short getEventPhase();
public boolean getBubbles();
public boolean getCancelable();
public long getTimeStamp();
public void stopPropagation();
public void preventDefault();
public void initEvent(String eventTypeArg,
boolean canBubbleArg,
boolean cancelableArg);
public String getNamespaceURI();
public boolean isCustom();
public void stopImmediatePropagation();
public boolean isDefaultPrevented();
public void initEventNS(String namespaceURIArg,
String eventTypeArg,
boolean canBubbleArg,
boolean cancelableArg);
}
org/w3c/dom/events/EventTarget.java:
package org.w3c.dom.events;
public interface EventTarget {
public void addEventListener(String type,
EventListener listener,
boolean useCapture);
public void removeEventListener(String type,
EventListener listener,
boolean useCapture);
public boolean dispatchEvent(Event evt)
throws EventException;
public void addEventListenerNS(String namespaceURI,
String type,
EventListener listener,
boolean useCapture,
Object evtGroup);
public void removeEventListenerNS(String namespaceURI,
String type,
EventListener listener,
boolean useCapture);
public boolean willTriggerNS(String namespaceURI,
String type);
public boolean hasEventListenerNS(String namespaceURI,
String type);
}
org/w3c/dom/events/EventListener.java:
package org.w3c.dom.events;
public interface EventListener {
public void handleEvent(Event evt);
}
org/w3c/dom/events/DocumentEvent.java:
package org.w3c.dom.events;
import org.w3c.dom.DOMException;
public interface DocumentEvent {
public Event createEvent(String eventType)
throws DOMException;
public boolean canDispatch(String namespaceURI,
String type);
}
org/w3c/dom/events/CustomEvent.java:
package org.w3c.dom.events;
public interface CustomEvent extends Event {
public void setDispatchState(EventTarget target,
short phase);
public boolean isPropagationStopped();
public boolean isImmediatePropagationStopped();
}
org/w3c/dom/events/UIEvent.java:
package org.w3c.dom.events;
import org.w3c.dom.views.AbstractView;
public interface UIEvent extends Event {
public AbstractView getView();
public int getDetail();
public void initUIEvent(String typeArg,
boolean canBubbleArg,
boolean cancelableArg,
AbstractView viewArg,
int detailArg);
public void initUIEventNS(String namespaceURI,
String typeArg,
boolean canBubbleArg,
boolean cancelableArg,
AbstractView viewArg,
int detailArg);
}
org/w3c/dom/events/TextEvent.java:
package org.w3c.dom.events;
import org.w3c.dom.views.AbstractView;
public interface TextEvent extends UIEvent {
public String getData();
public void initTextEvent(String typeArg,
boolean canBubbleArg,
boolean cancelableArg,
AbstractView viewArg,
String dataArg);
public void initTextEventNS(String namespaceURI,
String type,
boolean canBubbleArg,
boolean cancelableArg,
AbstractView viewArg,
String dataArg);
}
org/w3c/dom/events/MouseEvent.java:
package org.w3c.dom.events;
import org.w3c.dom.views.AbstractView;
public interface MouseEvent extends UIEvent {
public int getScreenX();
public int getScreenY();
public int getClientX();
public int getClientY();
public boolean getCtrlKey();
public boolean getShiftKey();
public boolean getAltKey();
public boolean getMetaKey();
public short getButton();
public EventTarget getRelatedTarget();
public void initMouseEvent(String typeArg,
boolean canBubbleArg,
boolean cancelableArg,
AbstractView viewArg,
int detailArg,
int screenXArg,
int screenYArg,
int clientXArg,
int clientYArg,
boolean ctrlKeyArg,
boolean altKeyArg,
boolean shiftKeyArg,
boolean metaKeyArg,
short buttonArg,
EventTarget relatedTargetArg);
public void initMouseEventNS(String namespaceURI,
String typeArg,
boolean canBubbleArg,
boolean cancelableArg,
AbstractView viewArg,
int detailArg,
int screenXArg,
int screenYArg,
int clientXArg,
int clientYArg,
boolean ctrlKeyArg,
boolean altKeyArg,
boolean shiftKeyArg,
boolean metaKeyArg,
short buttonArg,
EventTarget relatedTargetArg,
boolean altGraphKeyArg);
public boolean getAltGraphKey();
}
org/w3c/dom/events/KeyboardEvent.java:
package org.w3c.dom.events;
import org.w3c.dom.views.AbstractView;
public interface KeyboardEvent extends UIEvent {
// KeyLocationCode
public static final int DOM_KEY_LOCATION_STANDARD = 0x00;
public static final int DOM_KEY_LOCATION_LEFT = 0x01;
public static final int DOM_KEY_LOCATION_RIGHT = 0x02;
public static final int DOM_KEY_LOCATION_NUMPAD = 0x03;
public static final int DOM_KEY_LOCATION_UNKNOWN = 0x04;
public String getKeyIdentifier();
public int getKeyLocation();
public boolean getCtrlKey();
public boolean getShiftKey();
public boolean getAltKey();
public boolean getMetaKey();
public boolean getAltGraphKey();
public void initKeyboardEvent(String typeArg,
boolean canBubbleArg,
boolean cancelableArg,
AbstractView viewArg,
String keyIdentifierArg,
int keyLocationArg,
boolean ctrlKeyArg,
boolean shiftKeyArg,
boolean altKeyArg,
boolean metaKeyArg,
boolean altGraphKeyArg);
public void initKeyboardEventNS(String namespaceURI,
String type,
boolean canBubbleArg,
boolean cancelableArg,
AbstractView viewArg,
String keyIdentifierArg,
int keyLocationArg,
boolean ctrlKeyArg,
boolean shiftKeyArg,
boolean altKeyArg,
boolean metaKeyArg,
boolean altGraphKeyArg);
}
org/w3c/dom/events/MutationEvent.java:
package org.w3c.dom.events;
import org.w3c.dom.Node;
public interface MutationEvent extends Event {
// attrChangeType
public static final short MODIFICATION = 1;
public static final short ADDITION = 2;
public static final short REMOVAL = 3;
public Node getRelatedNode();
public String getPrevValue();
public String getNewValue();
public String getAttrName();
public short getAttrChange();
public void initMutationEvent(String typeArg,
boolean canBubbleArg,
boolean cancelableArg,
Node relatedNodeArg,
String prevValueArg,
String newValueArg,
String attrNameArg,
short attrChangeArg);
public void initMutationEventNS(String namespaceURI,
String typeArg,
boolean canBubbleArg,
boolean cancelableArg,
Node relatedNodeArg,
String prevValueArg,
String newValueArg,
String attrNameArg,
short attrChangeArg);
}
org/w3c/dom/events/MutationNameEvent.java:
package org.w3c.dom.events;
import org.w3c.dom.Node;
public interface MutationNameEvent extends MutationEvent {
public String getPrevNamespaceURI();
public String getPrevNodeName();
public void initMutationNameEvent(String typeArg,
boolean canBubbleArg,
boolean cancelableArg,
Node relatedNodeArg,
String prevNamespaceURI,
String prevNodeName);
public void initMutationNameEventNS(String namespaceURI,
String typeArg,
boolean canBubbleArg,
boolean cancelableArg,
Node relatedNodeArg,
String prevNamespaceURI,
String prevNodeName);
}
31 March 2003
Appendix E: ECMAScript Language Binding
This appendix contains the complete ECMAScript [ECMAScript] binding for the
Level 3 Document Object Model Events definitions.
Properties of the Event Constructor function:
Event.CAPTURING_PHASE
The value of the constant Event.CAPTURING_PHASE is 1.
Event.AT_TARGET
The value of the constant Event.AT_TARGET is 2.
Event.BUBBLING_PHASE
The value of the constant Event.BUBBLING_PHASE is 3.
Objects that implement the Event interface:
Properties of objects that implement the Event interface:
type
This read-only property is a String.
target
This read-only property is an object that implements the
EventTarget interface.
currentTarget
This read-only property is an object that implements the
EventTarget interface.
eventPhase
This read-only property is a Number.
bubbles
This read-only property is a Boolean.
cancelable
This read-only property is a Boolean.
timeStamp
This read-only property is an object that implements the Date
interface.
namespaceURI
This read-only property is a String.
Functions of objects that implement the Event interface:
stopPropagation()
This function has no return value.
preventDefault()
This function has no return value.
initEvent(eventTypeArg, canBubbleArg, cancelableArg)
This function has no return value.
The eventTypeArg parameter is a String.
The canBubbleArg parameter is a Boolean.
The cancelableArg parameter is a Boolean.
isCustom()
This function returns a Boolean.
stopImmediatePropagation()
This function has no return value.
isDefaultPrevented()
This function returns a Boolean.
initEventNS(namespaceURIArg, eventTypeArg, canBubbleArg,
cancelableArg)
This function has no return value.
The namespaceURIArg parameter is a String.
The eventTypeArg parameter is a String.
The canBubbleArg parameter is a Boolean.
The cancelableArg parameter is a Boolean.
Objects that implement the EventTarget interface:
Functions of objects that implement the EventTarget interface:
addEventListener(type, listener, useCapture)
This function has no return value.
The type parameter is a String.
The listener parameter is an object that implements the
EventListener interface.
The useCapture parameter is a Boolean.
removeEventListener(type, listener, useCapture)
This function has no return value.
The type parameter is a String.
The listener parameter is an object that implements the
EventListener interface.
The useCapture parameter is a Boolean.
dispatchEvent(evt)
This function returns a Boolean.
The evt parameter is an object that implements the Event
interface.
This function can raise an object that implements the
EventException interface.
addEventListenerNS(namespaceURI, type, listener, useCapture,
evtGroup)
This function has no return value.
The namespaceURI parameter is a String.
The type parameter is a String.
The listener parameter is an object that implements the
EventListener interface.
The useCapture parameter is a Boolean.
The evtGroup parameter is an object that implements the
Object interface.
removeEventListenerNS(namespaceURI, type, listener, useCapture)
This function has no return value.
The namespaceURI parameter is a String.
The type parameter is a String.
The listener parameter is an object that implements the
EventListener interface.
The useCapture parameter is a Boolean.
willTriggerNS(namespaceURI, type)
This function returns a Boolean.
The namespaceURI parameter is a String.
The type parameter is a String.
hasEventListenerNS(namespaceURI, type)
This function returns a Boolean.
The namespaceURI parameter is a String.
The type parameter is a String.
EventListener function:
This function has no return value. The parameter is an object that
implements the Event interface.
Properties of the EventException Constructor function:
EventException.UNSPECIFIED_EVENT_TYPE_ERR
The value of the constant
EventException.UNSPECIFIED_EVENT_TYPE_ERR is 0.
EventException.DISPATCH_REQUEST_ERR
The value of the constant EventException.DISPATCH_REQUEST_ERR is
1.
Objects that implement the EventException interface:
Properties of objects that implement the EventException interface:
code
This property is a Number.
Objects that implement the DocumentEvent interface:
Functions of objects that implement the DocumentEvent interface:
createEvent(eventType)
This function returns an object that implements the Event
interface.
The eventType parameter is a String.
This function can raise an object that implements the
DOMException interface.
canDispatch(namespaceURI, type)
This function returns a Boolean.
The namespaceURI parameter is a String.
The type parameter is a String.
Objects that implement the CustomEvent interface:
Objects that implement the CustomEvent interface have all properties
and functions of the Event interface as well as the properties and
functions defined below.
Functions of objects that implement the CustomEvent interface:
setDispatchState(target, phase)
This function has no return value.
The target parameter is an object that implements the
EventTarget interface.
The phase parameter is a Number.
isPropagationStopped()
This function returns a Boolean.
isImmediatePropagationStopped()
This function returns a Boolean.
Objects that implement the UIEvent interface:
Objects that implement the UIEvent interface have all properties and
functions of the Event interface as well as the properties and
functions defined below.
Properties of objects that implement the UIEvent interface:
view
This read-only property is an object that implements the
AbstractView interface.
detail
This read-only property is a Number.
Functions of objects that implement the UIEvent interface:
initUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg,
detailArg)
This function has no return value.
The typeArg parameter is a String.
The canBubbleArg parameter is a Boolean.
The cancelableArg parameter is a Boolean.
The viewArg parameter is an object that implements the
AbstractView interface.
The detailArg parameter is a Number.
initUIEventNS(namespaceURI, typeArg, canBubbleArg, cancelableArg,
viewArg, detailArg)
This function has no return value.
The namespaceURI parameter is a String.
The typeArg parameter is a String.
The canBubbleArg parameter is a Boolean.
The cancelableArg parameter is a Boolean.
The viewArg parameter is an object that implements the
AbstractView interface.
The detailArg parameter is a Number.
Objects that implement the TextEvent interface:
Objects that implement the TextEvent interface have all properties and
functions of the UIEvent interface as well as the properties and
functions defined below.
Properties of objects that implement the TextEvent interface:
data
This read-only property is a String.
Functions of objects that implement the TextEvent interface:
initTextEvent(typeArg, canBubbleArg, cancelableArg, viewArg,
dataArg)
This function has no return value.
The typeArg parameter is a String.
The canBubbleArg parameter is a Boolean.
The cancelableArg parameter is a Boolean.
The viewArg parameter is an object that implements the
AbstractView interface.
The dataArg parameter is a String.
initTextEventNS(namespaceURI, type, canBubbleArg, cancelableArg,
viewArg, dataArg)
This function has no return value.
The namespaceURI parameter is a String.
The type parameter is a String.
The canBubbleArg parameter is a Boolean.
The cancelableArg parameter is a Boolean.
The viewArg parameter is an object that implements the
AbstractView interface.
The dataArg parameter is a String.
Objects that implement the MouseEvent interface:
Objects that implement the MouseEvent interface have all properties and
functions of the UIEvent interface as well as the properties and
functions defined below.
Properties of objects that implement the MouseEvent interface:
screenX
This read-only property is a Number.
screenY
This read-only property is a Number.
clientX
This read-only property is a Number.
clientY
This read-only property is a Number.
ctrlKey
This read-only property is a Boolean.
shiftKey
This read-only property is a Boolean.
altKey
This read-only property is a Boolean.
metaKey
This read-only property is a Boolean.
button
This read-only property is a Number.
relatedTarget
This read-only property is an object that implements the
EventTarget interface.
altGraphKey
This read-only property is a Boolean.
Functions of objects that implement the MouseEvent interface:
initMouseEvent(typeArg, canBubbleArg, cancelableArg, viewArg,
detailArg, screenXArg, screenYArg, clientXArg, clientYArg,
ctrlKeyArg, altKeyArg, shiftKeyArg, metaKeyArg, buttonArg,
relatedTargetArg)
This function has no return value.
The typeArg parameter is a String.
The canBubbleArg parameter is a Boolean.
The cancelableArg parameter is a Boolean.
The viewArg parameter is an object that implements the
AbstractView interface.
The detailArg parameter is a Number.
The screenXArg parameter is a Number.
The screenYArg parameter is a Number.
The clientXArg parameter is a Number.
The clientYArg parameter is a Number.
The ctrlKeyArg parameter is a Boolean.
The altKeyArg parameter is a Boolean.
The shiftKeyArg parameter is a Boolean.
The metaKeyArg parameter is a Boolean.
The buttonArg parameter is a Number.
The relatedTargetArg parameter is an object that implements
the EventTarget interface.
initMouseEventNS(namespaceURI, typeArg, canBubbleArg,
cancelableArg, viewArg, detailArg, screenXArg, screenYArg,
clientXArg, clientYArg, ctrlKeyArg, altKeyArg, shiftKeyArg,
metaKeyArg, buttonArg, relatedTargetArg, altGraphKeyArg)
This function has no return value.
The namespaceURI parameter is a String.
The typeArg parameter is a String.
The canBubbleArg parameter is a Boolean.
The cancelableArg parameter is a Boolean.
The viewArg parameter is an object that implements the
AbstractView interface.
The detailArg parameter is a Number.
The screenXArg parameter is a Number.
The screenYArg parameter is a Number.
The clientXArg parameter is a Number.
The clientYArg parameter is a Number.
The ctrlKeyArg parameter is a Boolean.
The altKeyArg parameter is a Boolean.
The shiftKeyArg parameter is a Boolean.
The metaKeyArg parameter is a Boolean.
The buttonArg parameter is a Number.
The relatedTargetArg parameter is an object that implements
the EventTarget interface.
The altGraphKeyArg parameter is a Boolean.
Properties of the KeyboardEvent Constructor function:
KeyboardEvent.DOM_KEY_LOCATION_STANDARD
The value of the constant KeyboardEvent.DOM_KEY_LOCATION_STANDARD
is 0x00.
KeyboardEvent.DOM_KEY_LOCATION_LEFT
The value of the constant KeyboardEvent.DOM_KEY_LOCATION_LEFT is
0x01.
KeyboardEvent.DOM_KEY_LOCATION_RIGHT
The value of the constant KeyboardEvent.DOM_KEY_LOCATION_RIGHT is
0x02.
KeyboardEvent.DOM_KEY_LOCATION_NUMPAD
The value of the constant KeyboardEvent.DOM_KEY_LOCATION_NUMPAD is
0x03.
KeyboardEvent.DOM_KEY_LOCATION_UNKNOWN
The value of the constant KeyboardEvent.DOM_KEY_LOCATION_UNKNOWN
is 0x04.
Objects that implement the KeyboardEvent interface:
Objects that implement the KeyboardEvent interface have all properties
and functions of the UIEvent interface as well as the properties and
functions defined below.
Properties of objects that implement the KeyboardEvent interface:
keyIdentifier
This read-only property is a String.
keyLocation
This read-only property is a Number.
ctrlKey
This read-only property is a Boolean.
shiftKey
This read-only property is a Boolean.
altKey
This read-only property is a Boolean.
metaKey
This read-only property is a Boolean.
altGraphKey
This read-only property is a Boolean.
Functions of objects that implement the KeyboardEvent interface:
initKeyboardEvent(typeArg, canBubbleArg, cancelableArg, viewArg,
keyIdentifierArg, keyLocationArg, ctrlKeyArg, shiftKeyArg,
altKeyArg, metaKeyArg, altGraphKeyArg)
This function has no return value.
The typeArg parameter is a String.
The canBubbleArg parameter is a Boolean.
The cancelableArg parameter is a Boolean.
The viewArg parameter is an object that implements the
AbstractView interface.
The keyIdentifierArg parameter is a String.
The keyLocationArg parameter is a Number.
The ctrlKeyArg parameter is a Boolean.
The shiftKeyArg parameter is a Boolean.
The altKeyArg parameter is a Boolean.
The metaKeyArg parameter is a Boolean.
The altGraphKeyArg parameter is a Boolean.
initKeyboardEventNS(namespaceURI, type, canBubbleArg,
cancelableArg, viewArg, keyIdentifierArg, keyLocationArg,
ctrlKeyArg, shiftKeyArg, altKeyArg, metaKeyArg, altGraphKeyArg)
This function has no return value.
The namespaceURI parameter is a String.
The type parameter is a String.
The canBubbleArg parameter is a Boolean.
The cancelableArg parameter is a Boolean.
The viewArg parameter is an object that implements the
AbstractView interface.
The keyIdentifierArg parameter is a String.
The keyLocationArg parameter is a Number.
The ctrlKeyArg parameter is a Boolean.
The shiftKeyArg parameter is a Boolean.
The altKeyArg parameter is a Boolean.
The metaKeyArg parameter is a Boolean.
The altGraphKeyArg parameter is a Boolean.
Properties of the MutationEvent Constructor function:
MutationEvent.MODIFICATION
The value of the constant MutationEvent.MODIFICATION is 1.
MutationEvent.ADDITION
The value of the constant MutationEvent.ADDITION is 2.
MutationEvent.REMOVAL
The value of the constant MutationEvent.REMOVAL is 3.
Objects that implement the MutationEvent interface:
Objects that implement the MutationEvent interface have all properties
and functions of the Event interface as well as the properties and
functions defined below.
Properties of objects that implement the MutationEvent interface:
relatedNode
This read-only property is an object that implements the Node
interface.
prevValue
This read-only property is a String.
newValue
This read-only property is a String.
attrName
This read-only property is a String.
attrChange
This read-only property is a Number.
Functions of objects that implement the MutationEvent interface:
initMutationEvent(typeArg, canBubbleArg, cancelableArg,
relatedNodeArg, prevValueArg, newValueArg, attrNameArg,
attrChangeArg)
This function has no return value.
The typeArg parameter is a String.
The canBubbleArg parameter is a Boolean.
The cancelableArg parameter is a Boolean.
The relatedNodeArg parameter is an object that implements the
Node interface.
The prevValueArg parameter is a String.
The newValueArg parameter is a String.
The attrNameArg parameter is a String.
The attrChangeArg parameter is a Number.
initMutationEventNS(namespaceURI, typeArg, canBubbleArg,
cancelableArg, relatedNodeArg, prevValueArg, newValueArg,
attrNameArg, attrChangeArg)
This function has no return value.
The namespaceURI parameter is a String.
The typeArg parameter is a String.
The canBubbleArg parameter is a Boolean.
The cancelableArg parameter is a Boolean.
The relatedNodeArg parameter is an object that implements the
Node interface.
The prevValueArg parameter is a String.
The newValueArg parameter is a String.
The attrNameArg parameter is a String.
The attrChangeArg parameter is a Number.
Objects that implement the MutationNameEvent interface:
Objects that implement the MutationNameEvent interface have all
properties and functions of the MutationEvent interface as well as the
properties and functions defined below.
Properties of objects that implement the MutationNameEvent interface:
prevNamespaceURI
This read-only property is a String.
prevNodeName
This read-only property is a String.
Functions of objects that implement the MutationNameEvent interface:
initMutationNameEvent(typeArg, canBubbleArg, cancelableArg,
relatedNodeArg, prevNamespaceURI, prevNodeName)
This function has no return value.
The typeArg parameter is a String.
The canBubbleArg parameter is a Boolean.
The cancelableArg parameter is a Boolean.
The relatedNodeArg parameter is an object that implements the
Node interface.
The prevNamespaceURI parameter is a String.
The prevNodeName parameter is a String.
initMutationNameEventNS(namespaceURI, typeArg, canBubbleArg,
cancelableArg, relatedNodeArg, prevNamespaceURI, prevNodeName)
This function has no return value.
The namespaceURI parameter is a String.
The typeArg parameter is a String.
The canBubbleArg parameter is a Boolean.
The cancelableArg parameter is a Boolean.
The relatedNodeArg parameter is an object that implements the
Node interface.
The prevNamespaceURI parameter is a String.
The prevNodeName parameter is a String.
31 March 2003
Glossary
Editors:
Arnaud Le Hors, W3C
Robert S. Sutor, IBM Research (for DOM Level 1)
Several of the following term definitions have been borrowed or modified
from similar definitions in other W3C or standards documents. See the links
within the definitions for more information.
bubbling phase
The process by which an event can be handled by one of the target
ancestors after being handled by the target node.
capture phase
The process by which an event can be handled by one of the target
ancestors before being handled by the target node.
child
A child is an immediate descendant node of a node.
document element
There is only one document element in a Document. This element node is
a child of the Document node. See Well-Formed XML Documents in XML [XML
1.0].
document order
There is an ordering, document order, defined on all the nodes in the
document corresponding to the order in which the first character of the
XML representation of each node occurs in the XML representation of the
document after expansion of general entities. Thus, the document
element node will be the first node. Element nodes occur before their
children. Thus, document order orders element nodes in order of the
occurrence of their start-tag in the XML (after expansion of entities).
The attribute nodes of an element occur after the element and before
its children. The relative order of attribute nodes is
implementation-dependent.
DOM Level 0
The term "DOM Level 0" refers to a mix (not formally specified) of HTML
document functionalities offered by Netscape Navigator version 3.0 and
Microsoft Internet Explorer version 3.0. In some cases, attributes or
methods have been included for reasons of backward compatibility with
"DOM Level 0".
event
An event is the representation of some asynchronous occurrence (such as
a mouse click on the presentation of the element, or the removal of
child node from an element, or any of unthinkably many other
possibilities) that gets associated with an event target.
event target
The object to which an event is targeted.
local name
A local name is the local part of a qualified name. This is called the
local part in Namespaces in XML [XML Namespaces].
namespace URI
A namespace URI is a URI that identifies an XML namespace. This is
called the namespace name in Namespaces in XML [XML Namespaces].
string comparison
When string matching is required, it is to occur as though the
comparison was between 2 sequences of code points from [Unicode 2.0].
target node
The target node is the node representing the event target to which an
event is targeted using the DOM event flow.
target phase
The process by which an event can be handled by the event target.
tokenized
The description given to various information items (for example,
attribute values of various types, but not including the StringType
CDATA) after having been processed by the XML processor. The process
includes stripping leading and trailing white space, and replacing
multiple space characters by one. See the definition of tokenized type.
well-formed
A node is a well-formed XML node if it matches its respective
production in [XML 1.0], meets all well-formedness constraints related
to the production, if the entities which are referenced within the node
are also well-formed. See also the definition for well-formed XML
documents in [XML 1.0].
XML name
See XML name in the XML specification ([XML 1.0]).
31 March 2003
References
For the latest version of any W3C specification please consult the list of
W3C Technical Reports available at http://www.w3.org/TR.
G.1: Normative references
[DOM Level 2 Core]
Document Object Model Level 2 Core Specification, A. Le Hors, et al.,
Editors. World Wide Web Consortium, 13 November 2000. This version of
the DOM Level 2 Core Recommendation is
http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113. The latest
version of DOM Level 2 Core is available at
http://www.w3.org/TR/DOM-Level-2-Core.
[DOM Level 3 Core]
Document Object Model Level 3 Core Specification, A. Le Hors, et al.,
Editors. World Wide Web Consortium, October 2002. This version of the
Document Object Model Level 3 Core Specification is
http://www.w3.org/TR/2002/WD-DOM-Level-3-Core-20021022. The latest
version of DOM Level 3 Core is available at
http://www.w3.org/TR/DOM-Level-3-Core.
[DOM Level 2 Events]
Document Object Model Level 2 Events Specification, T. Pixley, Editor.
World Wide Web Consortium, 13 November 2000. This version of the
Document Object Model Level 2 Events Recommendation is
http://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113. The latest
version of Document Object Model Level 2 Events is available at
http://www.w3.org/TR/DOM-Level-2-Events.
[DOM Level 2 HTML]
Document Object Model Level 2 HTML Specification, J. Stenback, et al.,
Editors. World Wide Web Consortium, 9 January 2003. This version of the
Document Object Model Level 2 HTML Recommendation is
http://www.w3.org/TR/2003/REC-DOM-Level-2-HTML-20030109. The latest
version of Document Object Model Level 2 HTML is available at
http://www.w3.org/TR/DOM-Level-2-HTML.
[DOM Level 2 Views]
Document Object Model Level 2 Views Specification, A. Le Hors, L.
Cable, Editors. World Wide Web Consortium, 13 November 2000. This
version of the Document Object Model Level 2 Views Recommendation is
http://www.w3.org/TR/2000/REC-DOM-Level-2-Views-20001113. The latest
version of Document Object Model Level 2 Views is available at
http://www.w3.org/TR/DOM-Level-2-Views.
[ECMAScript]
ECMAScript Language Specification, Third Edition. European Computer
Manufacturers Association, Standard ECMA-262, December 1999.
[HTML 4.01]
HTML 4.01 Specification, D. Raggett, A. Le Hors, and I. Jacobs,
Editors. World Wide Web Consortium, 17 December 1997, revised 24 April
1998, revised 24 December 1999. This version of the HTML 4.01
Recommendation is http://www.w3.org/TR/1999/REC-html401-19991224. The
latest version of HTML 4 is available at http://www.w3.org/TR/html4.
[Java]
The Java Language Specification, J. Gosling, B. Joy, and G. Steele,
Authors. Addison-Wesley, September 1996. Available at
http://java.sun.com/docs/books/jls
[OMG IDL]
"OMG IDL Syntax and Semantics" defined in The Common Object Request
Broker: Architecture and Specification, version 2, Object Management
Group. The latest version of CORBA version 2.0 is available at
http://www.omg.org/technology/documents/formal/corba_2.htm.
[Unicode 3.0]
The Unicode Standard, Version 3.0.. The Unicode Consortium, 2000.
Reading, Mass.: Addison-Wesley Developers Press. ISBN 0-201-61633-5.
[XML 1.0]
Extensible Markup Language (XML) 1.0 (Second Edition), T. Bray, J.
Paoli, C. M. Sperberg-McQueen, and E. Maler, Editors. World Wide Web
Consortium, 10 February 1998, revised 6 October 2000. This version of
the XML 1.0 Recommendation is
http://www.w3.org/TR/2000/REC-xml-20001006. The latest version of XML
1.0 is available at http://www.w3.org/TR/REC-xml.
[XML Namespaces]
Namespaces in XML, T. Bray, D. Hollander, and A. Layman, Editors. World
Wide Web Consortium, 14 January 1999. This version of the XML
Information Set Recommendation is
http://www.w3.org/TR/1999/REC-xml-names-19990114. The latest version of
Namespaces in XML is available at http://www.w3.org/TR/REC-xml-names.
G.2: Informative references
[DOM Level 3 Load and Save]
Document Object Model Level 3 Load and Save Specification, J. Stenback,
A. Heninger, Editors. World Wide Web Consortium, July 2002. This
version of the DOM Level 3 Load and Save Specification is
http://www.w3.org/TR/DOM-Level-3-LS. The latest version of DOM Level 3
Load and Save is available at http://www.w3.org/TR/DOM-Level-3-LS.
[DWW95]
Developing International Software for Windows 95 and Windows NT: A
Handbook for International Software Design, N. Kano, Author. Microsoft
Press, 1995. ISBN 1-55615-840-8.
[KeyEvent for Java]
Java 2 SDK, Standard Edition Documentation, Version 1.4.1, Class
java.awt.events.KeyEvent. Sun Microsystems. Available at
http://java.sun.com/j2se/1.4.1/docs/api/java/awt/event/KeyEvent.html.
[Keys enumeration for .Net]
.NET Framework Class Library, Keys Enumeration. Microsoft. Available at
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemWindowsFormsKeysClassTopic.asp.
[SVG 1.0]
Scalable Vector Graphics (SVG) 1.0 Specification, J. Ferraiolo, Editor.
World Wide Web Consortium, 4 September 2001. This version of the SVG
1.0 Recommendation is http://www.w3.org/TR/2001/REC-SVG-20010904. The
latest version of SVG 1.0 is available at http://www.w3.org/TR/SVG.
[Unicode 2.0]
The Unicode Standard, Version 2.0.. The Unicode Consortium, 1996.
Reading, Mass.: Addison-Wesley Developers Press. ISBN 0-201-48345-9.
[VoiceXML 2.0]
Voice Extensible Markup Language (VoiceXML) Version 2.0, S. McGlashan,
et al., Editors. World Wide Web Consortium, February 2003. This version
of the Voice Extensible Markup Language Version 2.0 specification is
http://www.w3.org/TR/2003/CR-voicexml20-20030220. The latest version of
Voice Extensible Markup Language Version 2.0 is available at
http://www.w3.org/TR/voicexml20/.
[XForms 1.0]
XForms 1.0, M. Dubinko, et al., Editors. World Wide Web Consortium,
November 2002. This version of the XForms 1.0 specification is
http://www.w3.org/TR/2002/CR-xforms-20021112/. The latest version of
XForms 1.0 is available at http://www.w3.org/TR/xforms/.
[XHTML 1.0]
XHTML 1.0: The Extensible HyperText Markup Language, S. Pemberton, et
al., Authors. World Wide Web Consortium, 26 January 2000, revised 1
August 2002. This version of the XHTML 1.0 Recommendation is
http://www.w3.org/TR/2002/REC-xhtml1-20020801. The latest version of
XHTML 1.0 is available at http://www.w3.org/TR/xhtml1.
[XML Events]
XML Events, S. McCarron, S. Pemberton, and T.V. Raman, Editors. World
Wide Web Consortium, February 2003. This version of the XML Events
specification is http://www.w3.org/TR/2003/CR-xml-events-20030207. The
latest version of XML Events is available at
http://www.w3.org/TR/xml-events.
[XML Schema Part 2]
XML Schema Part 2: Datatypes, P. Byron and Ashok Malhotra, Editors.
World Wide Web Consortium, 2 May 2001. This version of the XML Part 2
Recommendation is http://www.w3.org/TR/2001/REC-xmlschema-2-20010502.
The latest version of XML Schema Part 2 is available at
http://www.w3.org/TR/xmlschema-2.
31 March 2003
Index
addEventListener addEventListenerNS ADDITION
altGraphKey 1, 2 altKey 1, 2 AT_TARGET
attrChange attrName
bubbles bubbling phase 1, 2, 3, BUBBLING_PHASE
4, 5, 6, 7, 8, 9, 10
button
cancelable cancelable event 1, 2 canDispatch
capture phase 1, 2, 3, 4,
5, 6, 7 CAPTURING_PHASE child 1, 2
clientX clientY createEvent
ctrlKey 1, 2 currentTarget CustomEvent
data detail DISPATCH_REQUEST_ERR
dispatchEvent document element document order
DocumentEvent DOM event flow DOM Level 0 1, 2, 3
DOM Level 2 Core 1, 2 DOM Level 2 Events 1, 2, DOM Level 2 HTML 1, 2, 3
3, 4, 5, 6, 7
DOM Level 2 Views 1, 2 DOM Level 3 Core 1, 2, DOM Level 3 Load and Save 1,
3, 4, 5, 6, 7, 8, 9, 10 2
DOM_KEY_LOCATION_LEFT DOM_KEY_LOCATION_NUMPAD DOM_KEY_LOCATION_RIGHT
DOM_KEY_LOCATION_STANDARD DOM_KEY_LOCATION_UNKNOWN DWW95
ECMAScript Event 1, 2, 3, 4, 5 event target 1, 2, 3, 4, 5,
6, 7, 8
EventException EventListener eventPhase
EventTarget
handleEvent hasEventListenerNS HTML 4.01 1, 2, 3, 4, 5, 6, 7
initEvent initEventNS initKeyboardEvent
initKeyboardEventNS initMouseEvent initMouseEventNS
initMutationEvent initMutationEventNS initMutationNameEvent
initMutationNameEventNS initTextEvent initTextEventNS
initUIEvent initUIEventNS Input Method Editor 1
isCustom isDefaultPrevented isImmediatePropagationStopped
isPropagationStopped
Java
KeyboardEvent KeyEvent for Java keyIdentifier
keyLocation Keys enumeration for
.Net
local name 1, 2, 3, 4, 5
metaKey 1, 2 MODIFICATION MouseEvent
MutationEvent MutationNameEvent
namespace URI 1, 2, 3, 4,
5, 6, 7, 8, 9, 10, 11, 12 namespaceURI newValue
OMG IDL
preventDefault prevNamespaceURI prevNodeName
prevValue
relatedNode relatedTarget REMOVAL
removeEventListener removeEventListenerNS
screenX screenY setDispatchState
shiftKey 1, 2 stopImmediatePropagation stopPropagation
string comparison 1, 2 SVG 1.0 1, 2, 3
target target node 1, 2, 3, 4, target phase 1, 2, 3, 4, 5,
5, 6 6, 7, 8
TextEvent timeStamp tokenized
type
UIEvent Unicode 2.0 1, 2 Unicode 3.0
UNSPECIFIED_EVENT_TYPE_ERR
view VoiceXML 2.0 1, 2
well-formed willTriggerNS
XForms 1.0 1, 2 XHTML 1.0 1, 2, 3, 4 XML 1.0 1, 2, 3, 4, 5
XML Events 1, 2, 3 XML name 1, 2 XML Namespaces 1, 2, 3, 4, 5,
6
XML Schema Part 2 1, 2