DOM Events is designed with two main goals. The first goal is the
design of an
The second goal of the DOM Events is to provide a common subset of
the current event systems used in
The following sections of the specification define both the specification for the DOM Event Model and a number of conformant event modules designed for use within the model. The DOM Event Model consists of:
The
A set of interfaces to access contextual information on events and to register event listeners.
This document specifies an event flow for tree-based structures:
An implementation is DOM Level 3 Events conformant if it supports
the Core module defined in UIEvent interface, and
conforms to the DOM Level 2 Core module.
An implementation which does not conform to an event module can
still implement the DOM interfaces associated with it. The DOM
application can then create an event object using the
DocumentEvent.createEvent() method and dispatch an
event type associated with this interface using the
EventTarget.dispatchEvent() method.
A DOM application may use the hasFeature(feature,
version) method of the DOMImplementation
interface with parameter values "Events" and
"3.0" (respectively) to determine whether or not DOM
Level 3 Events is supported by the implementation. In order to
fully support DOM Level 3 Events, an implementation must also
support the "Core" feature defined in the DOM Level 2 Core
specification hasFeature("Events", "3.0") returns true
must also return true when the version
number is "2.0", "" or,
null.
Each event module describes its own feature string in the event module listing.
This specification is to be understood in the context of the DOM
Level 3 Core specification null argument is passed when
null was not expected) is discussed under
The event is dispatched following a path from the root of the tree
to this
The
The
The
The target's ancestors are determined before the initial dispatch of the event. If the target node is removed during the dispatching, or a target's ancestor is added or removed, the event propagation will always be based on the target node and the target's ancestors determined before the dispatch.
Some events may not necessarily accomplish the three phases of the
DOM event flow, e.g. the event could only be defined for one or
two phases. As an example, events defined in this specification
will always accomplish the capture and target phases but some will
not accomplish the bubbling phase ("bubbling events" versus
"non-bubbling events", see also the Event.bubbles
attribute).
Each node encountered during the dispatch of the event may contain event listeners.
Event listeners can be registered on all nodes in the tree for a
specific type of event (
If the event listener is being registered on a node while an
event gets processed on this node, the event listener will not be
triggered during the current phase but may be triggered during a
later phase in the event flow, i.e. the
An event listener is always part of a group. It is either explicitly in a group if a group has been specified at the registration or implicitly in the default group if no group has been specified. Within a group, event listeners are ordered in their order of registration. If two event listeners {A1, A2}, which are part of the same group, are registered one after the other (A1, then A2) for the same phase, the DOM event flow guarantees their triggering order (A1, then A2). If the two listeners are not part of the same group, no specification is made as to the order in which they will be triggered.
In general, a DOM application does not need to define and use a separate group unless other event listeners, external to the DOM application, may change the event propagation (e.g. from a concurrent DOM application, from imported functionalities that rely on the event system, etc.).
While this specification does not specify a full ordering (i.e. groups are still unordered), it does specify ordering within a group. This implies that if the event listeners {A1, A2, B1, B2}, with A and B being two different groups, are registered for the same phase in the order A1, A2, B1, and B2, the following triggering orders are possible and conform to the DOM event flow:
{A1, A2, B1, B2}
{A1, B1, A2, B2}
{B1, A1, A2, B2}
{A1, B1, B2, A2}
{B1, A1, B2, A2}
{B1, B2, A1, A2}
DOM Events implementations may impose priorities on groups but
DOM applications must not rely on it. Unlike this specification,
When the event is dispatched through the tree, from node to node, event listeners registered on the node are triggered if the following three conditions are all met:
they were registered for the same type of event, or the same category.
they were registered for the same phase;
the event propagation has not been stopped for the group.
If an event listener is removed from a node while an event is being processed on the node, it will not be triggered by the current actions. Once removed, the event listener is never invoked again (unless registered again for future processing).
It is expected that actions taken by an event listener may cause
additional events to be dispatched. Additional events should be
handled in a synchronous manner and may cause reentrance into the
event model. If an event listener fires a new event using
EventTarget.dispatchEvent(), the event propagation
that causes the event listener to be triggered will resume only
after the event propagation of the new event is completed.
Since implementations may have restrictions such as stack-usage or other memory requirements, applications should not depend on how many synchronous events may be triggered.
All event listeners are part of a group (see
immediate: no more event listeners from the same group will be
triggered by the event object (see
Event.stopImmediatePropagation());
deferred until all event listeners from the same group have
been triggered on the current node, i.e. the event listeners of
the same group attached on other nodes will not be triggered
(see Event.stopPropagation()).
If two event listeners are registered for two different groups, one cannot prevent the other from being triggered.
Implementations may have a default action associated with an event
type. An example is the
The default actions are not part of the DOM Event flow. Before
invoking a default action, the implementation must first dispatch
the event as described in the
Different implementations will specify their own default actions, if any, associated with each event. The DOM Events specification does not attempt to specify these actions.
This specification does not provide mechanisms for accessing default actions or adding new ones.
Implementations could react to an event before dispatching it and
do changes on the display and the DOM tree. In such case, if a DOM
attribute is changed before the event is fired, cancelling the
device event type will also reverse the change. A good example is
the attribute HTMLInputElement.checked: as described
in HTMLInputElement.checked is changed as well, and then
the device event type HTMLInputElement.checked
will need to be changed back to its original value.
Event targets may have associated
In terms of this specification, the activation behavior of the
event target is the default action of the event type
Implementations dispatch the DOMActivate event as
default action of a click event is implementation
dependent.
When implementations dispatch a synthesized click
event, the expectation is that they do so as default action of
another event type. For example, when a user activates a hyperlink
using a keyboard, the click event would be dispatched
as default action of respective keyboard event.
Implementations are, however, required to dispatch the synthesized
click event as described above even if they do not
dispatch such an event (e.g., when activation is requested by a
voice command since this specification does not address event types
for voice input).
The activation of an event target is device dependent but is also application dependent, e.g. a link in a document can be activated using a mouse click or a mouse double click.
Each event is associated with a type, called
An event type could be part of one or more categories. A category
is represented using a
Depending on the level of DOM support, or the devices used for
display (e.g. screen) or interaction (e.g., mouse, keyboard, touch
screen, and voice), these event types can be generated by the
implementation. When used with an
The following table provides a non-normative summary of the event
types defined in this specification. All event types are in no
namespace and this specification refers to them by their local
name only. All events will accomplish the capture and target
phases, but not all of them will accomplish the bubbling phase
(see also
| type | Bubbling phase | Cancelable | Target node types | DOM interface |
|---|---|---|---|---|
|
|
Yes | Yes |
Element
|
UIEvent
|
|
|
Yes | No |
Element
|
UIEvent
|
|
|
Yes | No |
Element
|
UIEvent
|
|
|
No | No |
Element
|
UIEvent
|
|
|
No | No |
Element
|
UIEvent
|
|
|
Yes | Yes |
Element
|
TextEvent
|
|
|
Yes | Yes |
Element
|
MouseEvent
|
|
|
Yes | Yes |
Element
|
MouseEvent
|
|
|
Yes | Yes |
Element
|
MouseEvent
|
|
|
Yes | Yes |
Element
|
MouseEvent
|
|
|
Yes | Yes |
Element
|
MouseEvent
|
|
|
Yes | Yes |
Element
|
MouseEvent
|
|
|
Yes | Yes |
Element
|
KeyboardEvent
|
|
|
Yes | Yes |
Element
|
KeyboardEvent
|
|
|
Yes | No |
Document, DocumentFragment,
Element, Attr
|
MutationEvent
|
|
|
Yes | No |
Element, Attr, Text,
Comment, CDATASection,
DocumentType, EntityReference,
ProcessingInstruction
|
MutationEvent
|
|
|
Yes | No |
Element, Attr, Text,
Comment, CDATASection,
DocumentType, EntityReference,
ProcessingInstruction
|
MutationEvent
|
|
|
No | No |
Element, Attr, Text,
Comment, CDATASection,
DocumentType, EntityReference,
ProcessingInstruction
|
MutationEvent
|
|
|
No | No |
Element, Attr, Text,
Comment, CDATASection,
DocumentType, EntityReference,
ProcessingInstruction
|
MutationEvent
|
|
|
Yes | No |
Element
|
MutationEvent
|
|
|
Yes | No |
Text, Comment,
CDATASection, ProcessingInstruction
|
MutationEvent
|
|
|
Yes | No |
Element
|
MutationNameEvent
|
|
|
Yes | No |
Element
|
MutationNameEvent
|
|
|
No | No |
Document, Element
|
Event
|
|
|
No | No |
Document, Element
|
Event
|
|
|
Yes | No |
Element
|
Event
|
|
|
Yes | No |
Element
|
Event
|
|
|
Yes | No |
Element
|
Event
|
|
|
Yes | No |
Element
|
Event
|
|
|
Yes | Yes |
Element
|
Event
|
|
|
Yes | Yes |
Element
|
Event
|
|
|
Yes | No |
Document, Element
|
UIEvent
|
|
|
Yes | No |
Document, Element
|
UIEvent
|
As an example, the event Element
nodes for that event and on the capture and target phases. This
event cannot be cancelled. If an event listener for the
Document or Element
nodes, or if it is attached to the bubbling phase only, this event
listener cannot be triggered.
The event objects associated with the event types described above may contain context information. Refer to the description of the DOM interfaces for further information.
DOM Level 3 Events considers the Event.type attribute
to be case-sensitive, while DOM Level 2 Events considers
Event.type to be case-insensitive.
This section is non-normative.
There are mainly two ways to associate an event listener to a node in the tree:
at the programming level using the EventTarget
methods.
at the document level using
EventTarget methods
The user can attach an event listener using the methods on the
EventTarget interface:
The methods do not provide the ability to register the same event listener more than once for the same event type and the same phase. It is not possible to register an event listener:
for only one of the
for a specific event category.
To register an event listener, DOM applications use the methods
EventTarget.addEventListener() and
EventTarget.addEventListenerNS().
An EventListener being registered on an
EventTarget may choose to have that
EventListener triggered during the capture phase by
specifying the useCapture parameter of the
EventTarget.addEventListener() or
EventTarget.addEventListenerNS() methods to be
true. If false, the
EventListener will be triggered during the target and
bubbling phases.
In
Event listeners can only be registered on Element
nodes, other Node types are not addressable, and
cannot be registered for a specific group either, they are always
attached to the default group. The
In
Event listeners can only be registered on Element
nodes, other Node types are not addressable, and
cannot be registered for a specific group either, they are always
attached to the default group. The
"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"}.
In languages such as
Since only one attribute with the same name can appear on an
element, it is 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
Node types and the
The interfaces described in this section are fundamental to DOM Level 3 Events and must always be supported by the implementation.
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.
To create an instance of the Event interface, use
the DocumentEvent.createEvent("Event") method call.
An integer indicating which phase of the event flow is being
processed as defined in
The current event phase is the
The current event is in the
The current event phase is the
The
Used to indicate the
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
Used to indicate which phase of event flow is currently being accomplished.
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.
Used to indicate whether or not an event can have its default
action prevented (see also
true,
otherwise the value is false.
Used to specify the time at which the event was created in
milliseconds relative to 1970-01-01T00:00:00Z. 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, the value is 0.
This method is used to prevent event listeners of the same
group to be triggered but its effect is deferred until all
event listeners attached on the
Event.currentTarget have been triggered (see
This method does not prevent the default action from being
invoked; use Event.preventDefault() for that
effect.
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
This method does not stop the event propagation; use
Event.stopPropagation() or
Event.stopImmediatePropagation() for that effect.
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. This method has no effect if
called after the event has been dispatched. If called from a
subclass of the 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.namespaceURI
to null. To initialize an event with a namespace
URI, use the Event.initEventNS() method.
Specifies Event.type, the
Specifies Event.bubbles. This parameter
overrides the intrinsic bubbling behavior of the event.
Specifies Event.cancelable. This parameter
overrides the intrinsic cancelable behavior of the event.
The null if it is unspecified.
For events initialized with a DOM Level 2 Events method, such
as Event.initEvent(), this is always
null.
This method is used to prevent event listeners of the same
group to be triggered and, unlike
Event.stopPropagation() its effect is immediate
(see
This method does not prevent the default action from being
invoked; use Event.preventDefault() for that
effect.
Used to indicate whether Event.preventDefault()
has been called for this event.
The initEventNS method is used to initialize the
value of an Event object and has the same behavior
as Event.initEvent().
Specifies Event.namespaceURI, the
null if no
namespace.
Refer to the Event.initEvent() method for a
description of this parameter.
Refer to the Event.initEvent() method for a
description of this parameter.
Refer to the Event.initEvent() method for a
description of this parameter.
The CustomEvent interface is the recommended interface for
application-specific event types. Unlike the Event
interface, it allows applications to provide contextual
information about the event type. Application-specific event
types should have an associated namespace to avoid clashes with
future general-purpose event types.
To create an instance of the CustomEvent interface,
use the DocumentEvent.createEvent("CustomEvent")
method call.
Specifies some detail information about the Event.
The initCustomEventNS method is used to initialize
the value of a CustomEvent object and has the same
behavior as Event.initEventNS().
Refer to the Event.initEventNS() method for a
description of this parameter.
Refer to the Event.initEventNS() method for a
description of this parameter.
Refer to the Event.initEventNS() method for a
description of this parameter.
Refer to the Event.initEventNS() method for a
description of this parameter.
Specifies CustomEvent.detail. This value may be
null.
The EventTarget interface is implemented by all the
objects which could be
When used with 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 addEventListener or
addEventListenerNS repeatedly on the same
EventTarget with the same values for the parameters
namespaceURI, type,
listener, and useCapture has no
effect. Doing so does not cause the EventListener
to be called more than once and does not cause a change in the
triggering order. In order to register a listener for a
different event group (
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. Invoking this method is equivalent
to invoking addEventListenerNS with the same
values for the parameters type,
listener, and useCapture, and the
value null for the parameters
namespaceURI and evtGroup.
Specifies the Event.type associated with the
event for which the user is registering.
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.
If true, useCapture indicates that the user
wishes to add the event listener for the
false, the event listener will only be
triggered during the target and bubbling phases.
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. The Event.namespaceURI for which the
user registered the event listener is implied and is
null.
Event listeners registered for other event groups than the
default group cannot be removed using this method; see
EventTarget.removeEventListenerNS() for that
effect.
Specifies the Event.type for which the user
registered the event listener.
The EventListener to be removed.
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.
This method allows the dispatch of events into the
implementation's event model. The
EventTarget object on which
dispatchEvent is called.
The event to be dispatched.
Indicates whether any of the listeners which handled the event
called Event.preventDefault(). If
Event.preventDefault() was called the returned
value is false, else it is true.
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.
NOT_SUPPORTED_ERR: Raised if the Event object
has not been created using
DocumentEvent.createEvent().
INVALID_CHARACTER_ERR: Raised if Event.type is
not an
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.
Specifies the Event.namespaceURI associated with
the event for which the user is registering.
Refer to the EventTarget.addEventListener()
method for a description of this parameter.
Refer to the EventTarget.addEventListener()
method for a description of this parameter.
Refer to the EventTarget.addEventListener()
method for a description of this parameter.
The object that represents the event group to associate with
the EventListener (see also
null to attach the event listener to the default
group.
This method allows the removal of an event listener,
independently of the associated event group. Calling
removeEventListenerNS with arguments which do not
identify any currently registered EventListener on
the EventTarget has no effect.
Specifies the Event.namespaceURI associated with
the event for which the user registered the event listener.
Refer to the EventTarget.removeEventListener()
method for a description of this parameter.
Refer to the EventTarget.removeEventListener()
method for a description of this parameter.
Refer to the EventTarget.removeEventListener()
method for a description of this parameter.
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, with methods such as
Node.cloneNode or Range.cloneContents,
does not copy the event listeners attached to it. Event
listeners must be attached to the newly created
Node afterwards if so desired.
Moving a Node, with methods
Document.adoptNode, Node.appendChild,
or Range.extractContents, does not affect the event
listeners attached to it.
This method is called whenever an event occurs of the event
type for which the EventListener interface was
registered.
The Event contains contextual information about
the
Event operations may throw an EventException as
specified in their method descriptions.
An integer indicating the type of error generated.
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.
If the Event object is already dispatched in the
tree.
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.
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 DocumentEvent interface provides a mechanism
by which the user can create an Event object of a
type supported by the implementation. If the feature "Events"
is supported by the Document object, the
DocumentEvent interface must be implemented on the
same object. If the feature "+Events" is supported by the
Document object, an object that supports the
DocumentEvent interface must be returned by
invoking the method Node.getFeature("+Events",
"3.0") on the Document object.
The eventType parameter specifies the name of
the DOM Events interface to be supported by the created
event object, e.g. "Event",
"MouseEvent", "MutationEvent" and
so on. 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 invoke
DocumentEvent.createEvent("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,
UIEvent.detail in this example.
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".
The newly created event object.
NOT_SUPPORTED_ERR: Raised if the implementation does not
support the Event interface requested.
Test if the implementation can generate events of a specified type.
Specifies the Event.namespaceURI of the event.
Specifies the Event.type of the event.
true if the implementation can generate and
dispatch this event type, false otherwise.
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 if required. The DOM will not attempt to define all possible events. For purposes of interoperability, the DOM defines a module of user interface events including lower level device dependent events and a module of document mutation events.
The User Interface event module contains basic event types associated with user interfaces.
The UIEvent interface provides specific contextual
information associated with User Interface events.
To create an instance of the UIEvent interface,
use the DocumentEvent.createEvent("UIEvent")
method call.
The view attribute identifies the
AbstractView from which the event was generated.
Specifies some detail information about the
Event, depending on the type of event.
The initUIEvent method is used to initialize the
value of a UIEvent object and has the same
behavior as Event.initEvent().
Refer to the Event.initEvent() method for a
description of this parameter.
Refer to the Event.initEvent() method for a
description of this parameter.
Refer to the Event.initEvent() method for a
description of this parameter.
Specifies UIEvent.view. This value may be
null.
Specifies UIEvent.detail.
The initUIEventNS method is used to initialize
the value of a UIEvent object and has the same
behavior as Event.initEventNS().
Refer to the Event.initEventNS() method for a
description of this parameter.
Refer to the Event.initEventNS() method for a
description of this parameter.
Refer to the Event.initEventNS() method for a
description of this parameter.
Refer to the Event.initEventNS() method for a
description of this parameter.
Refer to the UIEvent.initUIEvent() method for a
description of this parameter.
Refer to the UIEvent.initUIEvent() method for a
description of this parameter.
The User Interface event types are listed below. 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
module 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 hasFeature("UIEvents", "3.0") returns
true must also return true when the
version number is "2.0", ""
or, null.
| Type |
DOMActivate
|
|---|---|
| Namespace |
None
|
| Interface |
UIEvent
|
| Cancelable | Yes |
| Bubbles | Yes |
| Target |
Element
|
| Context info |
UIEvent.view is in use.
|
Refer to
| Type |
DOMFocusIn
|
|---|---|
| Namespace |
http://www.w3.org/2001/xml-events
|
| Interface |
UIEvent
|
| Cancelable | No |
| Bubbles | Yes |
| Target |
Element
|
| Context info |
UIEvent.view is in use.
|
An
| Type |
DOMFocusOut
|
|---|---|
| Namespace |
http://www.w3.org/2001/xml-events
|
| Interface |
UIEvent
|
| Cancelable | No |
| Bubbles | Yes |
| Target | Element |
| Context info |
UIEvent.view is in use.
|
An
| Type |
focus
|
|---|---|
| Namespace |
None
|
| Interface |
UIEvent
|
| Cancelable | No |
| Bubbles | No |
| Target |
Element
|
| Context info |
UIEvent.view is in use.
|
An
| Type |
blur
|
|---|---|
| Namespace |
None
|
| Interface |
UIEvent
|
| Cancelable | No |
| Bubbles | No |
| Target |
Element
|
| Context info |
UIEvent.view is in use.
|
An
The text event module originates from the
onkeypress attribute. Unlike this attribute, the
event type
The TextEvent interface provides specific
contextual information associated with Text Events.
To create an instance of the TextEvent interface,
use the DocumentEvent.createEvent("TextEvent")
method call.
data holds the value of the characters generated
by the character device. This may be a single Unicode
character or a non-empty sequence of Unicode characters
The initTextEvent method is used to initialize
the value of a TextEvent object and has the same
behavior as UIEvent.initUIEvent(). The value of
UIEvent.detail remains undefined.
Refer to the UIEvent.initUIEvent() method for a
description of this parameter.
Refer to the UIEvent.initUIEvent() method for a
description of this parameter.
Refer to the UIEvent.initUIEvent() method for a
description of this parameter.
Refer to the UIEvent.initUIEvent() method for a
description of this parameter.
Specifies TextEvent.data.
The initTextEventNS method is used to initialize
the value of a TextEvent object and has the same
behavior as UIEvent.initUIEventNS(). The value of
UIEvent.detail remains undefined.
Refer to the UIEvent.initUIEventNS() method for
a description of this parameter.
Refer to the UIEvent.initUIEventNS() method for
a description of this parameter.
Refer to the UIEvent.initUIEventNS() method for
a description of this parameter.
Refer to the UIEvent.initUIEventNS() method for
a description of this parameter.
Refer to the UIEvent.initUIEventNS() method for
a description of this parameter.
Refer to the TextEvent.initTextEvent() method
for a description of this parameter.
The text event type is listed below. 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
| Type |
textInput
|
|---|---|
| Namespace |
None
|
| Interface |
TextEvent
|
| Cancelable | Yes |
| Bubbles | Yes |
| Target |
Element
|
| Context info |
UIEvent.view and TextEvent.data
are in use.
|
One or more characters have been entered. The characters can
originate from a variety of sources. For example, it could be
characters resulting from a key being pressed or released on a
keyboard device, characters resulting from the processing of an
The Mouse event module originates from the
onclick, ondblclick,
onmousedown, onmouseup,
onmouseover, onmousemove, and
onmouseout attributes. This event module is
specifically designed for use with pointing input devices, such as
a mouse or a trackball.
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 theirs descendent elements.
To create an instance of the MouseEvent interface,
use the DocumentEvent.createEvent("MouseEvent")
method call.
When initializing MouseEvent objects using
initMouseEvent or initMouseEventNS,
implementations should use the client coordinates
clientX and clientY for calculation
of other coordinates (such as target coordinates exposed by
The horizontal coordinate at which the event occurred relative to the origin of the screen coordinate system.
The vertical coordinate at which the event occurred relative to the origin of the screen coordinate system.
The horizontal coordinate at which the event occurred relative to the DOM implementation's client area.
The vertical coordinate at which the event occurred relative to the DOM implementation's client area.
true if the control (Ctrl) key modifier is
activated.
true if the shift (Shift) key modifier is
activated.
true if the alt (alternative) key modifier is
activated.
The Option key modifier on Macintosh systems must be represented using this key modifier.
true if the meta (Meta) key modifier is
activated.
The Command key modifier on Macintosh system must be represented using this meta key.
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 button of the mouse (in general on the left or the one
button on Macintosh mice, used to activate a button or select
text). 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 can be used to represent
such buttons.
Used to identify a secondary EventTarget related
to a UI event, depending on the type of event.
The initMouseEvent method is used to initialize
the value of a MouseEvent object and has the same
behavior as UIEvent.initUIEvent().
Refer to the UIEvent.initUIEvent() method for a
description of this parameter.
Refer to the UIEvent.initUIEvent() method for a
description of this parameter.
Refer to the UIEvent.initUIEvent() method for a
description of this parameter.
Refer to the UIEvent.initUIEvent() method for a
description of this parameter.
Refer to the UIEvent.initUIEvent() method for a
description of this parameter.
Specifies MouseEvent.screenX.
Specifies MouseEvent.screenY.
Specifies MouseEvent.clientX.
Specifies MouseEvent.clientY.
Specifies MouseEvent.ctrlKey.
Specifies MouseEvent.altKey.
Specifies MouseEvent.shiftKey.
Specifies MouseEvent.metaKey.
Specifies MouseEvent.button.
Specifies MouseEvent.relatedTarget. This value
may be null.
This methods queries the state of a modifier using a key
identifier. See also
A modifier key identifier, as defined by the
KeyboardEvent.keyIdentifier attribute. Common
modifier keys are "Alt",
"AltGraph", "CapsLock",
"Control", "Meta",
"NumLock", "Scroll", or
"Shift".
If an application wishes to distinguish between right and
left modifiers, this information could be deduced using
keyboard events and KeyboardEvent.keyLocation.
true if it is modifier key and the modifier is
activated, false otherwise.
The initMouseEventNS method is used to initialize
the value of a MouseEvent object and has the same
behavior as UIEvent.initUIEventNS().
Refer to the UIEvent.initUIEventNS() method for
a description of this parameter.
Refer to the UIEvent.initUIEventNS() method for
a description of this parameter.
Refer to the UIEvent.initUIEventNS() method for
a description of this parameter.
Refer to the UIEvent.initUIEventNS() method for
a description of this parameter.
Refer to the UIEvent.initUIEventNS() method for
a description of this parameter.
Refer to the UIEvent.initUIEventNS() method for
a description of this parameter.
Refer to the MouseEvent.initMouseEvent() method
for a description of this parameter.
Refer to the MouseEvent.initMouseEvent() method
for a description of this parameter.
Refer to the MouseEvent.initMouseEvent() method
for a description of this parameter.
Refer to the MouseEvent.initMouseEvent() method
for a description of this parameter.
Refer to the MouseEvent.initMouseEvent() method
for a description of this parameter.
Refer to the MouseEvent.initMouseEvent() method
for a description of this parameter.
A
"Control Alt" will activated the control and
alt modifiers.
The Mouse event types are listed below. 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
hasFeature("MouseEvents", "3.0") returns
true must also return true when the
version number is "2.0", ""
or, null.
| Type |
click
|
|---|---|
| Namespace |
None
|
| Interface |
MouseEvent
|
| Cancelable | Yes |
| Bubbles | Yes |
| Target |
Element
|
| Context info |
MouseEvent.screenX,
MouseEvent.screenY,
MouseEvent.clientX,
MouseEvent.clientY,
MouseEvent.altKey,
MouseEvent.ctrlKey,
MouseEvent.shiftKey,
MouseEvent.metaKey,
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.
|
A pointing device button is clicked over an element. The
definition of a click depends on the environment configuration;
i.e. may depend on the screen location or the delay between the
press and release of the pointing device button. In any case,
the target node must be the same between the
| Type |
mousedown
|
|---|---|
| Namespace |
None
|
| Interface |
MouseEvent
|
| Cancelable | Yes |
| Bubbles | Yes |
| Target |
Element
|
| Context info |
MouseEvent.screenX,
MouseEvent.screenY,
MouseEvent.clientX,
MouseEvent.clientY,
MouseEvent.altKey,
MouseEvent.ctrlKey,
MouseEvent.shiftKey,
MouseEvent.metaKey,
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.
|
A pointing device button is pressed over an element. In the case of nested elements, this event type is always targeted at the most deeply nested element.
| Type |
mouseup
|
|---|---|
| Namespace |
None
|
| Interface |
MouseEvent
|
| Cancelable | Yes |
| Bubbles | Yes |
| Target |
Element
|
| Context info |
MouseEvent.screenX,
MouseEvent.screenY,
MouseEvent.clientX,
MouseEvent.clientY,
MouseEvent.altKey,
MouseEvent.ctrlKey,
MouseEvent.shiftKey,
MouseEvent.metaKey,
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.
|
A pointing device button is released over an element. In the case of nested elements, this event type is always targeted at the most deeply nested element.
| Type |
mouseover
|
|---|---|
| Namespace |
None
|
| Interface |
MouseEvent
|
| Cancelable | Yes |
| Bubbles | Yes |
| Target |
Element
|
| Context info |
MouseEvent.screenX,
MouseEvent.screenY,
MouseEvent.clientX,
MouseEvent.clientY,
MouseEvent.altKey,
MouseEvent.ctrlKey,
MouseEvent.shiftKey,
MouseEvent.metaKey, and
UIEvent.view are in use.
MouseEvent.relatedTarget indicates the
|
A pointing device is moved onto an element. In the case of nested elements, this event type is always targeted at the most deeply nested element.
| Type |
mousemove
|
|---|---|
| Namespace |
None
|
| Interface |
MouseEvent
|
| Cancelable | Yes |
| Bubbles | Yes |
| Target |
Element
|
| Context info |
MouseEvent.screenX,
MouseEvent.screenY,
MouseEvent.clientX,
MouseEvent.clientY,
MouseEvent.altKey,
MouseEvent.ctrlKey,
MouseEvent.shiftKey,
MouseEvent.metaKey, and
UIEvent.view are in use.
|
A pointing device is moved while it is over an element. In the case of nested elements, this event type is always targeted at the most deeply nested element.
| Type |
mouseout
|
|---|---|
| Namespace |
None
|
| Interface |
MouseEvent
|
| Cancelable | Yes |
| Bubbles | Yes |
| Target |
Element
|
| Context info |
MouseEvent.screenX,
MouseEvent.screenY,
MouseEvent.clientX,
MouseEvent.clientY,
MouseEvent.altKey,
MouseEvent.ctrlKey,
MouseEvent.shiftKey,
MouseEvent.metaKey, and
UIEvent.view are in use.
MouseEvent.relatedTarget indicates the
|
A pointing device is moved away from an element. In the case of nested elements, this event type is always targeted at the most deeply nested element.
As an example, a "double click" on a mouse device will produce the
following events (the value of UIEvent.detail is
indicated in parenthesis):
"mousedown" (1)
"mouseup" (1)
"click" (1)
"mousedown" (2)
"mouseup" (2)
"click" (2)
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
The KeyboardEvent interface provides specific
contextual information associated with keyboard devices. Each
keyboard event references a key using an identifier. Keyboard
events are commonly directed at the element that has the focus.
The KeyboardEvent interface provides convenient
attributes for some common modifiers keys:
KeyboardEvent.ctrlKey,
KeyboardEvent.shiftKey,
KeyboardEvent.altKey,
KeyboardEvent.metaKey. These attributes are
equivalent to use the method
KeyboardEvent.getModifierState(keyIdentifierArg)
with "Control", "Shift", "Alt", or "Meta" respectively.
To create an instance of the KeyboardEvent
interface, use the
DocumentEvent.createEvent("KeyboardEvent") method
call.
This set of constants is used to indicate the location of a key on the device. In case a DOM implementation wishes to provide a new location information, a value different from the following constant values must be used.
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 keyboard.
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 keyboard.
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 keyboard.
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 keyboard located on the numeric pad.
keyIdentifier holds the identifier of the key.
The key identifiers are defined in Appendix A.2
""Unidentified".
The keyLocation attribute contains an indication
of the location of they key on the device, as described in
true if the control (Ctrl) key modifier is
activated.
true if the shift (Shift) key modifier is
activated.
true if the alternative (Alt) key modifier is
activated.
The Option key modifier on Macintosh systems must be represented using this key modifier.
true if the meta (Meta) key modifier is
activated.
The Command key modifier on Macintosh systems must be represented using this key modifier.
This methods queries the state of a modifier using a key
identifier. See also
A modifier key identifier. Common modifier keys are
"Alt", "AltGraph",
"CapsLock", "Control",
"Meta", "NumLock",
"Scroll", or "Shift".
If an application wishes to distinguish between right and
left modifiers, this information could be deduced using
keyboard events and KeyboardEvent.keyLocation.
true if it is modifier key and the modifier is
activated, false otherwise.
The initKeyboardEvent method is used to
initialize the value of a KeyboardEvent object
and has the same behavior as
UIEvent.initUIEvent(). The value of
UIEvent.detail remains undefined.
Refer to the UIEvent.initUIEvent() method for a
description of this parameter.
Refer to the UIEvent.initUIEvent() method for a
description of this parameter.
Refer to the UIEvent.initUIEvent() method for a
description of this parameter.
Refer to the UIEvent.initUIEvent() method for a
description of this parameter.
Specifies KeyboardEvent.keyIdentifier.
Specifies KeyboardEvent.keyLocation.
A
The initKeyboardEventNS method is used to
initialize the value of a KeyboardEvent object
and has the same behavior as
UIEvent.initUIEventNS(). The value of
UIEvent.detail remains undefined.
Refer to the UIEvent.initUIEventNS() method for
a description of this parameter.
Refer to the UIEvent.initUIEventNS() method for
a description of this parameter.
Refer to the UIEvent.initUIEventNS() method for
a description of this parameter.
Refer to the UIEvent.initUIEventNS() method for
a description of this parameter.
Refer to the UIEvent.initUIEventNS() method for
a description of this parameter.
Refer to the KeyboardEvent.initKeyboardEvent()
method for a description of this parameter.
Refer to the KeyboardEvent.initKeyboardEvent()
method for a description of this parameter.
A
"Control Alt" will activated the control and
alt modifiers.
Depending on the character generation device, keyboard events may or may not be generated.
The keyboard event types are listed below. 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
| Type |
keydown
|
|---|---|
| Namespace |
None
|
| Interface |
KeyboardEvent
|
| Cancelable | Yes |
| Bubbles | Yes |
| Target |
Element
|
| Context info |
UIEvent.view,
KeyboardEvent.keyIdentifier,
KeyboardEvent.keyLocation,
KeyboardEvent.altKey,
KeyboardEvent.shiftKey,
KeyboardEvent.ctrlKey, and
KeyboardEvent.metaKey are in use.
|
A key is pressed down. This event type is device dependent and
relies on the capabilities of the input devices and how they
are mapped in the operating system. This event type is
generated after the keyboard mapping but before the processing
of an
| Type |
keyup
|
|---|---|
| Namespace |
None
|
| Interface |
KeyboardEvent
|
| Cancelable | Yes |
| Bubbles | Yes |
| Target |
Element
|
| Context info |
UIEvent.view,
KeyboardEvent.keyIdentifier, and
KeyboardEvent.keyLocation are in use.
KeyboardEvent.altKey,
KeyboardEvent.shiftKey,
KeyboardEvent.ctrlKey, and
KeyboardEvent.metaKey are in use unless the
KeyboardEvent.keyIdentifier corresponds to the
key modifier itself.
|
A key is released. This event type is device dependent and
relies on the capabilities of the input devices and how they
are mapped in the operating system. This event type is
generated after the keyboard mapping but before the processing
of an
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 resulting 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.
The MutationEvent interface provides specific
contextual information associated with Mutation events.
To create an instance of the MutationEvent
interface, use the
DocumentEvent.createEvent("MutationEvent") method
call.
An integer indicating in which way the Attr was
changed.
The Attr was modified in place.
The Attr was just added.
The Attr was just removed.
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
Attr node which was
modified, added, or removed.
prevValue indicates the previous value of the
Attr node in
CharacterData node in
newValue indicates the new value of the
Attr node in
CharacterData node in
attrName indicates the name of the changed
Attr node in a
attrChange indicates the type of change which
triggered the
MODIFICATION,
ADDITION, or REMOVAL.
The initMutationEvent method is used to
initialize the value of a MutationEvent object
and has the same behavior as Event.initEvent().
Refer to the Event.initEvent() method for a
description of this parameter.
Refer to the Event.initEvent() method for a
description of this parameter.
Refer to the Event.initEvent() method for a
description of this parameter.
Specifies MutationEvent.relatedNode.
Specifies MutationEvent.prevValue. This value
may be null.
Specifies MutationEvent.newValue. This value
may be null.
Specifies MutationEvent.attrname. This value
may be null.
Specifies MutationEvent.attrChange. This value
may be null.
The initMutationEventNS method is used to
initialize the value of a MutationEvent object
and has the same behavior as Event.initEventNS().
Refer to the Event.initEventNS() method for a
description of this parameter.
Refer to the Event.initEventNS() method for a
description of this parameter.
Refer to the Event.initEventNS() method for a
description of this parameter.
Refer to the Event.initEventNS() method for a
description of this parameter.
Refer to the MutationEvent.initMutationEvent()
method for a description of this parameter.
Refer to the MutationEvent.initMutationEvent()
method for a description of this parameter.
Refer to the MutationEvent.initMutationEvent()
method for a description of this parameter.
Refer to the MutationEvent.initMutationEvent()
method for a description of this parameter.
Refer to the MutationEvent.initMutationEvent()
method for a description of this parameter.
The mutation event types are listed below. 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 Mutation 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
MutationEvent interface is built on top of the DOM
Level 2 Mutation Events MutationEvent interface
implementation where
hasFeature("MutationEvents","3.0") returns
true must also return true when the
version number is "2.0", ""
or, null.
| Type |
DOMSubtreeModified
|
|---|---|
| Namespace |
None
|
| Interface |
MutationEvent
|
| Cancelable | No |
| Bubbles | Yes |
| Target |
Document, DocumentFragment,
Element, Attr
|
| Context info | None |
This is a general event for notification of all changes to the document. It can be used instead of the more specific mutation and mutation name events listed below. It may be dispatched after a single modification to the document or, at the implementation's discretion, after multiple changes have occurred. The latter use should generally be used to accommodate multiple changes which occur either simultaneously or in rapid succession. The target of this event is the lowest common parent of the changes which have taken place. This event is dispatched after any other events caused by the mutation(s) have occurred.
| Type |
DOMNodeInserted
|
|---|---|
| Namespace |
None
|
| Interface |
MutationEvent
|
| Cancelable | No |
| Bubbles | Yes |
| Target |
Element, Attr, Text,
Comment, CDATASection,
DocumentType, EntityReference,
ProcessingInstruction
|
| Context info |
MutationEvent.relatedNode holds the parent node
of the node that has been inserted or, in case of
Attr nodes, the ownerElement of
the Attr node.
|
A node has been added as a
Attr nodes, has been added to an
Element. This event is dispatched after the
insertion has taken place. The
| Type |
DOMNodeRemoved
|
|---|---|
| Namespace |
None
|
| Interface |
MutationEvent
|
| Cancelable | No |
| Bubbles | Yes |
| Target |
Element, Attr, Text,
Comment, CDATASection,
DocumentType, EntityReference,
ProcessingInstruction
|
| Context info |
MutationEvent.relatedNode holds the parent node
of the node being removed or, in case of Attr
nodes, the ownerElement of the
Attr node.
|
A node is being removed from its parent node or, in case of
Attr nodes, removed from its
ownerElement. This event is dispatched before the
removal takes place. The
| Type |
DOMNodeRemovedFromDocument
|
|---|---|
| Namespace |
None
|
| Interface |
MutationEvent
|
| Cancelable | No |
| Bubbles | Yes |
| Target |
Element, Attr, Text,
Comment, CDATASection,
DocumentType, EntityReference,
ProcessingInstruction
|
| Context info | None |
A node is being removed from a document, either through direct
removal of the node or removal of a subtree in which it is
contained; Attr nodes are considered part of an
Element's subtree. This event is dispatched before
the removal takes place. The
| Type |
DOMNodeInsertedIntoDocument
|
|---|---|
| Namespace |
None
|
| Interface |
MutationEvent
|
| Cancelable | No |
| Bubbles | Yes |
| Target |
Element, Attr, Text,
Comment, CDATASection,
DocumentType, EntityReference,
ProcessingInstruction
|
| Context info | None |
A node has been inserted into a document, either through direct
insertion of the node or insertion of a subtree in which it is
contained; Attr nodes are considered part of an
Element's subtree. This event is dispatched after
the insertion has taken place. The
| Type |
DOMAttrModified
|
|---|---|
| Namespace |
None
|
| Interface |
MutationEvent
|
| Cancelable | No |
| Bubbles | Yes |
| Target |
Element
|
| Context info |
MutationEvent.attrName and
MutationEvent.attrChange are in use. The value
of MutationEvent.relatedNode indicates the
Attr node that has been modified, added, or
removed. If the Attr node has been added,
MutationEvent.newValue is in use. If the
Attr node has been removed,
MutationEvent.prevValue is in use. If the
Attr node has been modified,
MutationEvent.newValue and
MutationEvent.prevValue are in use.
|
Occurs after Attr.value has been modified and
after an Attr node has been added to or removed
from an Element. The
Element node where the change
occured. It is implementation dependent whether this event type
occurs when the children of the Attr node are
changed in ways that do not affect the value of
Attr.value.
| Type |
DOMCharacterDataModified
|
|---|---|
| Namespace |
None
|
| Interface |
MutationEvent
|
| Cancelable | No |
| Bubbles | Yes |
| Target |
Text, Comment,
CDATASection,
ProcessingInstruction
|
| Context info |
MutationEvent.prevValue, and
MutationEvent.newValue are in use.
|
Occurs after CharacterData.data or
ProcessingInstruction.data have been modified but
the node itself has not been inserted or deleted. The
CharacterData node or the
ProcessingInstruction node.
The MutationNameEvent interface provides specific
contextual information associated with Mutation name event
types.
To create an instance of the MutationNameEvent
interface, use the
Document.createEvent("MutationNameEvent") method
call.
The previous value of the relatedNode's
namespaceURI.
The previous value of the relatedNode's
nodeName.
The initMutationNameEvent method is used to
initialize the value of a MutationNameEvent
object and has the same behavior as
MutationEvent.initMutationEvent().
Refer to the MutationEvent.initMutationEvent()
method for a description of this parameter.
Refer to the MutationEvent.initMutationEvent()
method for a description of this parameter.
Refer to the MutationEvent.initMutationEvent()
method for a description of this parameter.
Refer to the MutationEvent.initMutationEvent()
method for a description of this parameter.
Specifies MutationNameEvent.prevNamespaceURI.
This value may be null.
Specifies MutationNameEvent.prevNodeName.
The initMutationNameEventNS method is used to
initialize the value of a MutationNameEvent
object and has the same behavior as
MutationEvent.initMutationEventNS().
Refer to the
MutationEvent.initMutationEventNS() method for
a description of this parameter.
Refer to the
MutationEvent.initMutationEventNS() method for
a description of this parameter.
Refer to the
MutationEvent.initMutationEventNS() method for
a description of this parameter.
Refer to the
MutationEvent.initMutationEventNS() method for
a description of this parameter.
Refer to the
MutationEvent.initMutationEventNS() method for
a description of this parameter.
Refer to the MutationEvent.initMutationEvent()
method for a description of this parameter.
Refer to the MutationEvent.initMutationEvent()
method for a description of this parameter.
The mutation name event types are listed below. 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 Mutation Name event module 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
| Type |
DOMElementNameChanged
|
|---|---|
| Namespace |
None
|
| Interface |
MutationNameEvent
|
| Cancelable | No |
| Bubbles | Yes |
| Target |
Element
|
| Context info |
MutationNameEvent.prevNamespaceURI, and
MutationNameEvent.prevNodeName are in use.
|
Occurs after the namespaceURI and/or the
nodeName of an Element node have been
modified (e.g., the element was renamed using
Document.renameNode()). The
Element node.
| Type |
DOMAttributeNameChanged
|
|---|---|
| Namespace |
None
|
| Interface |
MutationNameEvent
|
| Cancelable | No |
| Bubbles | Yes |
| Target |
Element
|
| Context info |
MutationNameEvent.prevNamespaceURI, and
MutationNameEvent.prevNodeName are in use. The
value of MutationEvent.relatedNode contains the
renamed Attr node.
|
Occurs after the namespaceURI and/or the
nodeName of a Attr node have been
modified (e.g., the attribute was renamed using
Document.renameNode()). The
Element node whose Attr
has been renamed.
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
The basic event types are listed below.
The event types UIEvent interface. All other basic 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.
| Type |
load
|
|---|---|
| Namespace |
None
|
| Interface |
Event
|
| Cancelable | No |
| Bubbles | No |
| Target |
Document, Element
|
| Context info |
UIEvent.view may be in use.
|
The DOM Implementation finishes loading the resource (such as
the document) and any dependent resources (such as images,
style sheets, or scripts). Dependent resources that fail to
load will not prevent this event from firing if the resource
that loaded them is still accessible via the DOM. If this event
type is dispatched, implementations are required to dispatch
this event at least on the Document node.
| Type |
unload
|
|---|---|
| Namespace |
None
|
| Interface |
Event
|
| Cancelable | No |
| Bubbles | No |
| Target |
Document, Element
|
| Context info |
UIEvent.view may be in use.
|
The DOM implementation removes from the environment the
resource (such as the document) or any dependent resources
(such as images, style sheets, scripts). The document is
unloaded after the dispatch of this event type. If this event
type is dispatched, implementations are required to dispatch
this event at least on the Document node.
| Type |
abort
|
|---|---|
| Namespace |
None
|
| Interface |
Event
|
| Cancelable | No |
| Bubbles | Yes |
| Target |
Element
|
| Context info |
UIEvent.view may be in use.
|
The loading of the document, or a resource linked from it, is stopped before being entirely loaded.
| Type |
error
|
|---|---|
| Namespace |
None
|
| Interface |
Event
|
| Cancelable | No |
| Bubbles | Yes |
| Target |
Element
|
| Context info |
UIEvent.view may be in use.
|
A resource failed to load, or has been loaded but cannot be interpreted according to its semantics such as an invalid image, a script execution error, or non-well-formed XML.
| Type |
select
|
|---|---|
| Namespace |
None
|
| Interface |
Event
|
| Cancelable | No |
| Bubbles | Yes |
| Target |
Element
|
| Context info |
UIEvent.view may be in use.
|
A user selects some text. DOM Level 3 Events does not provide contextual information to access the selected text. The selection occured before the dispatch of this event type.
| Type |
change
|
|---|---|
| Namespace |
None
|
| Interface |
Event
|
| Cancelable | No |
| Bubbles | Yes |
| Target |
Element
|
| Context info |
UIEvent.view may be in use.
|
A control loses the input focus and its value has been modified
since gaining focus. This event type is dispatched before the
event type
| Type |
submit
|
|---|---|
| Namespace |
None
|
| Interface |
Event
|
| Cancelable | Yes |
| Bubbles | Yes |
| Target |
Element
|
| Context info |
UIEvent.view may be in use.
|
A form, such as
| Type |
reset
|
|---|---|
| Namespace |
None
|
| Interface |
Event
|
| Cancelable | Yes |
| Bubbles | Yes |
| Target |
Element
|
| Context info |
UIEvent.view may be in use.
|
A form, such as
| Type |
resize
|
|---|---|
| Namespace |
None
|
| Interface |
UIEvent
|
| Cancelable | No |
| Bubbles | Yes |
| Target |
Document, Element
|
| Context info |
UIEvent.view is in use.
|
A document view or an element has been resized. The resize occured before the dispatch of this event type.
| Type |
scroll
|
|---|---|
| Namespace |
None
|
| Interface |
UIEvent
|
| Cancelable | No |
| Bubbles | Yes |
| Target |
Document, Element
|
| Context info |
UIEvent.view is in use.
|
A document view or an element has been scrolled. The scroll occured before the dispatch of this event type.