The Pointer Events specification defines a unified hardware-agnostic framework for handling input from various devices, including mice, touchscreens, and pens/styluses. By providing a single set of events (e.g., pointerdown, pointermove, pointerup), it allows developers to support diverse input methods without writing device-specific logic for each.
This specification also defines Mouse and Wheel Events, as well as a mapping to fire Mouse Events for other pointer device types.
Status of This Document
This section describes the status of this
document at the time of its publication. A list of current W3C
publications and the latest revision of this technical report can be found
in the
W3C standards and drafts index.
This specification is an update to [PointerEvents3] specification. It also includes the Mouse and Wheel Events, previously in the [UIEVENTS] specification.
This revision includes new features:
persistentDeviceId to provide a stable identifier for input devices across multiple interactions.
Publication as a Working Draft does not
imply endorsement by W3C and its Members.
This is a draft document and may be updated, replaced, or obsoleted by other
documents at any time. It is inappropriate to cite this document as other
than a work in progress.
This document was produced by a group
operating under the
W3C Patent
Policy.
W3C maintains a
public list of any patent disclosures
made in connection with the deliverables of
the group; that page also includes
instructions for disclosing a patent. An individual who has actual
knowledge of a patent that the individual believes contains
Essential Claim(s)
must disclose the information in accordance with
section 6 of the W3C Patent Policy.
Today, most [HTML] content is used with and/or designed for mouse input. Those that handle input in a custom manner typically code to [UIEVENTS] Mouse Events. Newer computing devices today, however, incorporate other forms of input, including touchscreens and pen input. Event types have been proposed for handling each of these forms of input individually. However, that approach often incurs unnecessary duplication of logic and event handling overhead when adding support for a new input type. This often creates a compatibility problem when content is written with only one device type in mind. Additionally, for compatibility with existing mouse-based content, most user agents fire Mouse Events for all input types. This makes it ambiguous whether a Mouse Event represents an actual mouse device or is being produced from another input type for compatibility, which makes it hard to code to both device types simultaneously.
To reduce the cost of coding to multiple input types and also to help with the above described ambiguity with Mouse Events, this specification defines a more abstract form of input, called a pointer. A pointer can be any point of contact on the screen made by a mouse cursor, pen, touch (including multi-touch), or other pointing input device. This model makes it easier to write sites and applications that work well no matter what hardware the user has. For scenarios when device-specific handling is desired, this specification also defines properties for inspecting the device type which produced the event. The primary goal is to provide a single set of events and interfaces that allow for easier authoring for cross-device pointer input while still allowing for device-specific handling only when necessary for an augmented experience.
An additional key goal is to enable multi-threaded user agents to handle direct manipulation actions for panning and zooming (for instance, with a finger or stylus on a touchscreen), without blocking on script execution.
Note
While this specification defines a unified event model for a variety of pointer inputs, this model does not cover other forms of input such as keyboards or keyboard-like interfaces (for instance, a screen reader or similar assistive technology running on a touchscreen-only device, which allows users sequential navigation through focusable controls and elements). While user agents might choose to also generate pointer events in response to these interfaces, this scenario is not covered in this specification.
In the first instance, authors are encouraged to provide equivalent functionality for all forms of input by responding to high-level events such as focus, blur and click. However, when using low-level events (such as Pointer Events), authors are encouraged to ensure that all types of input are supported. In the case of keyboards and keyboard-like interfaces, this might require the addition of explicit keyboard event handling. See Keyboard Accessible [WCAG22] for further details.
Figure 1A pointer is a hardware-agnostic representation of input devices that can target a specific coordinate (or set of coordinates) on a screen.
The events for handling generic pointer input look a lot like those for mouse: pointerdown, pointermove, pointerup, pointerover, pointerout, and so on. This facilitates easy content migration from Mouse Events to Pointer Events.
Pointer Events provide all the usual properties present in Mouse Events (including client coordinates, target element, button states) in addition to new properties for other forms of input, such as pressure, contact geometry, tilt. Authors can easily code to Pointer Events to share logic between different input types where it makes sense, and customize for a particular type of input only where necessary to get the best experience.
While Pointer Events are sourced from a variety of input devices, they are not defined as being generated from some other set of device-specific events. While possible and encouraged for compatibility, this spec does not require other device-specific events be supported (such as mouse events or touch events). A user agent could support pointer events without supporting any other device events. For compatibility with content written to mouse-specific events, this specification does provide an optional section describing how to generate compatibility mouse events based on pointer input from devices other than a mouse.
Note
This specification does not provide any advice on the expected behavior of user agents that support both Touch Events (as defined in [TOUCH-EVENTS]) and Pointer Events. For more information on the relationship between these two specifications, see the Touch Events Community Group.
2. Conformance
As well as sections marked as non-normative, all authoring guidelines, diagrams, examples, and notes in this specification are non-normative. Everything else in this specification is normative.
The key words MAY, MUST, MUST NOT, OPTIONAL, and SHOULD in this document
are to be interpreted as described in
BCP 14
[RFC2119] [RFC8174]
when, and only when, they appear in all
capitals, as shown here.
3. Examples
This section is non-normative.
The following are basic examples that demonstrate how some of the APIs in this specification might be used by authors. Further, more specific examples are provided in the relevant sections of this document.
/* Bind to either Pointer Events or traditional touch/mouse */if (window.PointerEvent) {
// if Pointer Events are supported, only listen to pointer events
target.addEventListener("pointerdown", function(e) {
// if necessary, apply separate logic based on e.pointerType// for different touch/pen/mouse behavior
...
});
...
} else {
// traditional touch/mouse event handlers
target.addEventListener('touchstart', function(e) {
// prevent compatibility mouse events and click
e.preventDefault();
...
});
...
target.addEventListener('mousedown', ...);
...
}
// additional event listeners for keyboard handling
...
Example 2: Detecting the type of input from a user
window.addEventListener("pointerdown", detectInputType);
functiondetectInputType(event) {
switch(event.pointerType) {
case"mouse":
/* mouse input detected */break;
case"pen":
/* pen/stylus input detected */break;
case"touch":
/* touch input detected */break;
default:
/* pointerType is empty (could not be detected)
or UA-specific custom type */
}
}
Example 3: Resizing an element to match the contact geometry
<divstyle="position:absolute; top:0px; left:0px; width:100px;height:100px;"></div><script>window.addEventListener("pointerdown", assignPenColor);
window.addEventListener("pointermove", assignPenColor);
const colorMap = newMap();
functionassignPenColor(event) {
const uniqueId = event.persistentDeviceId;
// Check if a unique Id exists.if (uniqueId == 0) {
return;
}
// Check if a color has been assigned to the device.if (map.has(uniqueId)) {
return;
}
// Assign a color to the device.let newColor = getNewColor();
map.set(uniqueId, newColor);
return newColor;
}
functiongetNewColor() {
/* return some color value */
}
</script>
4. Mouse Events
The mouse event module originates from the [HTML401] 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.
4.1 Interface MouseEvent
Introduced in DOM Level 2, modified in this specification.
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.
Note
Ancestors of the targeted element can use event bubbling to obtain notifications of mouse events which occur within their descendent elements.
When initializing MouseEvent objects using initMouseEvent, implementations can use the client coordinates clientX and clientY for calculation of other coordinates (such as target coordinates exposed by DOM Level 0 implementations or other proprietary attributes, e.g., pageX).
During mouse events caused by the depression or release of a mouse button, buttonMUST be used to indicate which pointer device button changed state.
The value of the button attribute MUST be as follows:
0MUST indicate the primary button of the device (in general, the left button or the only button on single-button devices, used to activate a user interface control or select text) or the un-initialized value.
1MUST indicate the auxiliary button (in general, the middle button, often combined with a mouse wheel).
2MUST indicate the secondary button (in general, the right button, often used to display a context menu).
3MUST indicate the X1 (back) button.
4MUST indicate the X2 (forward) button.
Some pointing devices provide or simulate more button states, and values higher than 2 or lower than 0MAY be used to represent such buttons.
Note
The value of button is not updated for events not caused by the depression/release of a mouse button. In these scenarios, take care not to interpret the value 0 as the left button, but rather as the default value.
During any mouse events, buttonsMUST be used to indicate which combination of mouse buttons are currently being pressed, expressed as a bitmask.
Note
Though similarly named, the values for the buttons attribute and the button attribute are very different. The value of button is assumed to be valid during mousedown / mouseup event handlers, whereas the buttons attribute reflects the state of the mouse's buttons for any trusted MouseEvent object (while it is being dispatched), because it can represent the "no button currently active" state (0).
The value of the buttons attribute MUST be as follows:
0MUST indicate no button is currently active.
1MUST indicate the primary button of the device (in general, the left button or the only button on single-button devices, used to activate a user interface control or select text).
2MUST indicate the secondary button (in general, the right button, often used to display a context menu), if present.
4MUST indicate the auxiliary button (in general, the middle button, often combined with a mouse wheel).
Some pointing devices provide or simulate more buttons. To represent such buttons, the value MUST be doubled for each successive button (in the binary series 8, 16, 32, ... ).
Note
Because the sum of any set of button values is a unique number, a content author can use a bitwise operation to determine how many buttons are currently being pressed and which buttons they are, for an arbitrary number of mouse buttons on a device. For example, the value 3 indicates that the left and right button are currently both pressed, while the value 5 indicates that the left and middle button are currently both pressed.
Initializes the screenX attribute of the MouseEvent object to the desired horizontal relative position of the mouse pointer on the user's screen.
Initializing the event object to the given mouse position must not move the user's mouse pointer to the initialized position.
screenY
Initializes the screenY attribute of the MouseEvent object to the desired vertical relative position of the mouse pointer on the user's screen.
Initializing the event object to the given mouse position must not move the user's mouse pointer to the initialized position.
clientX
Initializes the clientX attribute of the MouseEvent object to the desired horizontal position of the mouse pointer relative to the client window of the user's browser.
Initializing the event object to the given mouse position must not move the user's mouse pointer to the initialized position.
clientY
Initializes the clientY attribute of the MouseEvent object to the desired vertical position of the mouse pointer relative to the client window of the user's browser.
Initializing the event object to the given mouse position must not move the user's mouse pointer to the initialized position.
button
Initializes the button attribute of the MouseEvent object to a number representing the desired state of the button(s) of the mouse.
Note
The value 0 is used to represent the primary mouse button, 1 is used to represent the auxiliary/middle mouse button, and 2 to represent the right mouse button. Numbers greater than 2 are also possible, but are not specified in this document.
buttons
Initializes the buttons attribute of the MouseEvent object to a number representing one or more of the button(s) of the mouse that are to be considered active.
Note
The buttons attribute is a bit-field. If a mask value of 1 is true when applied to the value of the bit field, then the primary mouse button is down. If a mask value of 2 is true when applied to the value of the bit field, then the right mouse button is down. If a mask value of 4 is true when applied to the value of the bit field, then the auxiliary/middle button is down.
In JavaScript, to initialize the buttons attribute as if the right (2) and middlebutton (4) were being pressed simultaneously, the buttons value can be assigned as either:
{ buttons: 2 | 4 }
or:
{ buttons: 6 }
relatedTarget
The relatedTarget should be initialized to the element whose bounds the mouse pointer just left (in the case of a mouseover or mouseenter event) or the element whose bounds the mouse pointer is entering (in the case of a mouseout or mouseleave or focusout event). For other events, this value need not be assigned (and will default to null).
Implementations MUST maintain the current click count when generating mouse events. This MUST be a non-negative integer indicating the number of consecutive clicks of a pointing device button within a specific time. The delay after which the count resets is specific to the environment configuration.
4.2 MouseEvent Algorithms
4.2.1 Native OS Requirements
The algorithms in this section assume that the native platform OS will provide the following:
A way to identify when a mouse button press should be interpreted as a "click" (handled by handle native mouse click)
For example, as a flag or as a separate event
If a separate "click" event is fired, then the native OS will fire it immediately after the corresponding "mouse up" event, with no intervening mouse-related events
For these events, the OS will be able to provide the following info:
The x,y mouse coordinates relative to the native OS desktop
The x,y mouse coordinates relative to the UA's window viewport
Which keyboard modifiers are currently being held
4.2.2 Constructing Mouse Events
Warning
This section needs to be revised.
Generally, when a constructor of an Event interface, or of an interface inherited from the Event interface, is invoked, the steps described in [DOM] should be followed. However the MouseEvent interfaces provide additional dictionary members for initializing the internal state of the Event object's key modifiers: specifically, the internal state queried for using the getModifierState() methods. This section supplements the [DOM] steps for intializing a new MouseEvent object with these optional modifier states.
For the purposes of constructing a MouseEvent, or object derived from these objects using the algorithm below, all MouseEvent, and derived objects have internal key modifier state which can be set and retrieved using the key modifier names described in the Modifier Keys table in [UIEvents-Key].
The following steps supplement the algorithm defined for constructing events in [DOM]:
If the Event being constructed is a MouseEvent object or an object that derives from it, and a EventModifierInit argument was provided to the constructor, then run the following sub-steps:
For each EventModifierInit argument, if the dictionary member begins with the string "modifier", then let the key modifier name be the dictionary member's name excluding the prefix "modifier", and set the Event object's internal key modifier state that matches the key modifier name to the corresponding value.
4.2.3 Global State for MouseEvent
Warning
This section needs to be revised.
4.2.3.1 User Agent-Level State
The UA must maintain the following values that are shared for the entire User Agent.
A mouse button bitmask that tracks the current state of the mouse buttons.
4.2.3.2 Window-Level State
The UA must maintain the following values that are shared for the Window.
A last mouse element value (initially undefined) that keeps track of the last Element that we sent a MouseEvent to.
A last mouse DOM path value (initially empty) that contains a snapshot of the ancestors Elements of the last mouse element when the most recent mouse event was sent.
4.2.4 Internal State for MouseEvent
Warning
This section needs to be revised.
A MouseEvent has the following internal flags that are used to track the state of various modifier keys:
shift flag,
control flag,
alt flag,
altgraph flag,
and meta flag.
These flags are set if the corresponding modifier key was pressed at the time
of the mouse event.
4.2.5 hit test
Warning
This section needs to be revised.
Let pos be the x,y coordinates relative to the viewport
See pointerevents/100
for info about browsers using PointerEvents and rounded coordinates.
Editor's note
Any "default action" is handled during dispatch by triggering the
activation behavior
algorithm for the target. So there is no need for handle that here.
However, need to verify that the existing spec handles disabled/css-pointer-events/inert/...
Note
To handle HTMLelement.click(), call this algorithm with native = null and target = HTMLelement.
Note
To handle keyboard-initiated clicks, call this algorithm with native = null and target = currently focused element.
4.2.16 handle native mouse double click
Warning
This section needs to be revised.
Let native be the native mouse double click
Note
This should be called immediately after handle native mouse click for mouse clicks that generate double clicks.
Let mbutton be an ID from native that identifies which mouse button was pressed
If mbutton is not the primary mouse button, then return
Let target be hit test with viewport-relative coordinates from native
This algorithm makes assumptions about the dispatch of PointerEvents because they are not currently specified explicitly. Once pointerevents/285 is resolved this may need to be updated.
Let target be hit test with viewport-relative coordinates from native
Verify behavior when canceled (appears to have no effect).
Let leaveElements be a copy of last mouse DOM path with all elements common to targetDomPath removed.
For each element in leaveElements, do
Editor's note
Handle case where element has been deleted.
Also case where it has been moved: Should the DOM mutation have triggered
a mouseleave event? Should we sent it now? Should it be dropped?
Need to verify what current browsers do.
To handle a context menu triggered by the keyboard, call this algorithm with native = null and target = currently focused element.
4.3 Mouse Event Order
Certain mouse events defined in this specification MUST occur in a set order relative to one another. The following shows the event sequence that MUST occur when a pointing device's cursor is moved over an element:
When a pointing device is moved into an element A, and then into a nested element B and then back out again, the following sequence of events MUST occur:
Sometimes elements can be visually overlapped using CSS. In the following example, three elements labeled A, B, and C all have the same dimensions and absolute position on a web page. Element C is a child of B, and B is a child of A in the DOM:
Figure 2Graphical representation of three stacked elements all on top of each other, with the pointing device moving over the stack.
When the pointing device is moved from outside the element stack to the element labeled C and then moved out again, the following series of events MUST occur:
The following is the typical sequence of events when a button associated with a pointing device (e.g., a mouse button or trackpad) is pressed and released over an element:
The lag time, degree, distance, and number of mousemove events allowed between the mousedown and mouseup events while still firing a click or dblclick event will be implementation-, device-, and platform-specific. This tolerance can aid users that have physical disabilities like unsteady hands when these users interact with a pointing device.
Each implementation will determine the appropriate hysteresis
tolerance, but in general SHOULD fire click and dblclick
events when the event target of the associated mousedown and
mouseup events is the same element with no mouseout or
mouseleave events intervening, and SHOULD fire click and
dblclick events on the nearest common inclusive ancestor when the
associated mousedown and mouseup event targets are
different.
If the target (e.g. the target element) is removed from the
DOM during the mouse events sequence, the remaining events of the
sequence MUST NOT be fired on that element.
If the target element is removed from the DOM as the result of a
mousedown event, no events for that element will be dispatched
for mouseup, click, or dblclick, nor any default
activation events. However, the mouseup event will still be
dispatched on the element that is exposed to the mouse after the removal
of the initial target element. Similarly, if the target element is
removed from the DOM during the dispatch of a mouseup event, the
click and subsequent events will not be dispatched.
4.4 Mouse Event Types
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.
The auxclick event type MUST be dispatched on the topmost
event target indicated by the pointer, when the user presses
down and releases the non-primary pointer button, or otherwise activates
the pointer in a manner that simulates such an action. The actuation
method of the mouse button depends upon the pointer device and the
environment configuration, e.g., it MAY depend on the screen
location or the delay between the press and release of the pointing
device button.
The auxclick event should only be fired for the non-primary pointer
buttons (i.e., when button value is not 0,
buttons value is greater than 1). The primary button
(like the left button on a standard mouse) MUST NOT fire
auxclick events. See click for a corresponding event that
is associated with the primary button.
The auxclick event MAY be preceded by the mousedown and
mouseup events on the same element, disregarding changes
between other node types (e.g., text nodes). Depending upon the
environment configuration, the auxclick event MAY be dispatched
if one or more of the event types mouseover,
mousemove, and mouseout occur between the press and
release of the pointing device button.
If the target has associated activation behavior,
the default actionMUST be to execute that activation
behavior.
Example 6: Receiving and handling auxclick for the middle
myLink.addEventListener("auxclick", function(e) {
if (e.button === 1) {
// This would prevent the default behavior which is for example// opening a new tab when middle clicking on a link.
e.preventDefault();
// Do something else to handle middle button click like taking// care of opening link or non-link buttons in new tabs in a way// that fits the app. Other actions like closing a tab in a tab-strip// which should be done on the click action can be done here too.
}
});
Note
In the case of right button, the auxclick event is dispatched after
any contextmenu event. Note that some user agents swallow all input
events while a context menu is being displayed, so auxclick may not be
available to applications in such scenarios.
See Example 7 for more clarification.
Example 7: Receiving and handling auxclick for the right button
myDiv.addEventListener("contextmenu", function(e) {
// This call makes sure no context menu is shown// to interfere with page receiving the events.
e.preventDefault();
});
myDiv.addEventListener("auxclick", function(e) {
if (e.button === 2) {
// Do something else to handle right button click like opening a// customized context menu inside the app.
}
});
For PointerEvent specific attributes, see the [PointerEvents] spec.
The click event type MUST be dispatched on the topmost
event target indicated by the pointer, when the user presses
down and releases the primary pointer button, or otherwise activates
the pointer in a manner that simulates such an action. The actuation
method of the mouse button depends upon the pointer device and the
environment configuration, e.g., it MAY depend on the screen
location or the delay between the press and release of the pointing
device button.
The click event should only be fired for the primary pointer
button (i.e., when button value is 0,
buttons value is 1). Secondary buttons
(like the middle or right button on a standard mouse) MUST NOT fire
click events. See auxclick for a corresponding event that
is associated with the non-primary buttons.
The click event MAY be preceded by the mousedown and
mouseup events on the same element, disregarding changes
between other node types (e.g., text nodes). Depending upon the
environment configuration, the click event MAY be dispatched
if one or more of the event types mouseover,
mousemove, and mouseout occur between the press and
release of the pointing device button. The click event MAY
also be followed by the dblclick event.
If a user mouses down on a text node child of a
<p> element which has been styled with a large
line-height, shifts the mouse slightly such that it is no longer
over an area containing text but is still within the containing
block of that <p> element (i.e., the pointer is
between lines of the same text block, but not over the text node per
se), then subsequently mouses up, this will likely still trigger a
click event (if it falls within the normal temporal
hysteresis for a click), since the user has stayed
within the scope of the same element. Note that user-agent-generated
mouse events are not dispatched on text nodes.
In addition to being associated with pointer devices, the
click event type MUST be dispatched as part of an element
activation.
Note
For maximum accessibility, content authors are encouraged to use the
click event type when defining activation behavior for custom
controls, rather than other pointing-device event types such as
mousedown or mouseup, which are more device-specific.
Though the click event type has its origins in pointer
devices (e.g., a mouse), subsequent implementation enhancements have
extended it beyond that association, and it can be considered a
device-independent event type for element activation.
A user agentMUST dispatch this event when the primary button
of a pointing device is clicked twice over an element. The
definition of a double click depends on the environment
configuration, except that the event target MUST be the same between
mousedown, mouseup, and dblclick. This event
type MUST be dispatched after the event type click if a click
and double click occur simultaneously, and after the event type
mouseup otherwise.
As with the click event, the dblclick event should
only be fired for the primary pointer button. Secondary buttons MUST NOT fire dblclick events.
Note
Canceling the click event does not affect the firing of a
dblclick event.
Varies: Start a drag/drop operation; start a text selection; start a scroll/pan
interaction (in combination with the middle mouse button, if supported)
A user agentMUST dispatch this event when a pointing device
button is pressed over an element.
Note
Many implementations use the mousedown event to begin a
variety of contextually dependent default actions. These
default actions can be prevented if this event is canceled. Some of
these default actions could include: beginning a drag/drop
interaction with an image or link, starting text selection, etc.
Additionally, some implementations provide a mouse-driven panning
feature that is activated when the middle mouse button is pressed at
the time the mousedown event is dispatched.
A user agentMUST dispatch this event when a pointing device
is moved onto the boundaries of an element or one of its descendent
elements. A user agentMUST also dispatch this event when the
element or one of its descendants moves to be underneath the primary
pointing device. This event type is similar to mouseover, but
differs in that it does not bubble, and MUST NOT be dispatched when
the pointer device moves from an element onto the boundaries of one
of its descendent elements.
A user agentMUST dispatch this event when a pointing device
is moved off of the boundaries of an element and all of its
descendent elements. A user agentMUST also dispatch this event
when the element or one of its descendants moves to be no longer underneath
the primary pointing device. This event type is similar to mouseout,
but differs in that does not bubble, and that it MUST NOT be
dispatched until the pointing device has left the boundaries of the
element and the boundaries of all of its children.
A user agentMUST dispatch this event when a pointing device
is moved while it is over an element. The frequency rate of events
while the pointing device is moved is implementation-, device-, and
platform-specific, but multiple consecutive mousemove events
SHOULD be fired for sustained pointer-device movement, rather than a
single event for each instance of mouse movement. Implementations
are encouraged to determine the optimal frequency rate to balance
responsiveness with performance.
Note
In some implementation environments, such as a browser,
mousemove events can continue to fire if the user began a
drag operation (e.g., a mouse button is pressed) and the pointing
device has left the boundary of the user agent.
Note
This event was formerly specified to be non-cancelable in DOM Level
2 Events, but was changed to reflect existing interoperability between
user agents.
A user agentMUST dispatch this event when a pointing device
is moved off of the boundaries of an element or when the element is
moved to be no longer underneath the primary pointing device.
This event type is similar to mouseleave, but differs in that
does bubble, and that it MUST be dispatched when the pointer device
moves from an element onto the boundaries of one of its descendent elements.
A user agentMUST dispatch this event when a pointing device
is moved onto the boundaries of an element or when the element is
moved to be underneath the primary pointing device.
This event type is similar to mouseenter, but differs in
that it bubbles, and that it MUST be dispatched when the pointer device moves onto the
boundaries of an element whose ancestor element is the target for the same event listener instance.
A user agentMUST dispatch this event when a pointing device
button is released over an element.
Note
In some implementation environments, such as a browser, a
mouseup event can be dispatched even if the pointing device
has left the boundary of the user agent, e.g., if the user began a
drag operation with a mouse button pressed.
A unique identifier for the pointer causing the event. user agentsMAY reserve a generic pointerId value of 0 or 1 for the primary mouse pointer. The pointerId value of -1MUST be reserved and used to indicate events that were generated by something other than a pointing device. For any other pointers, user agents are free to implement different strategies and approaches in how they assign a pointerId value. However, all active pointers in the top-level browsing context (as defined by [HTML]) must be unique, and the identifier MUST NOT be influenced by any other top-level browsing context (i.e. one top-level browsing context cannot assume that the pointerId of a pointer will be the same when the pointer moves outside of the browsing context and into another top-level browsing context).
The user agentMAY recycle previously retired values for pointerId from previous active pointers, or it MAY always reuse the same pointerId for a particular pointing device (for instance, to uniquely identify particular pen/stylus inputs from a specific user in a multi-user collaborative application). However, in the latter case, to minimize the chance of fingerprinting and tracking across different pages or domains, the pointerIdMUST only be associated explicitly with that particular pointing device for the lifetime of the page / session, and a new randomized pointerIdMUST be chosen the next time that particular pointing device is used again in a new session.
Note
The pointerId selection algorithm is implementation specific. Authors cannot assume values convey any particular meaning other than an identifier for the pointer that is unique from all other active pointers. As an example, user agents may simply assign a number, starting from 0, to any active pointers, in the order that they become active — but these values are not guaranteed to be monotonically increasing. As the reuse of the same pointerId for a particular pointing device is left up to individual implementations, authors are strongly discouraged from relying on it, and to refer to persistentDeviceId instead.
width
The width (magnitude on the X axis), in CSS pixels (see [CSS21]), of the contact geometry of the pointer. This value MAY be updated on each event for a given pointer. For inputs that typically lack contact geometry (such as a traditional mouse), and in cases where the actual geometry of the input is not detected by the hardware, the user agentMUST return a default value of 1.
height
The height (magnitude on the Y axis), in CSS pixels (see [CSS21]), of the contact geometry of the pointer. This value MAY be updated on each event for a given pointer. For inputs that typically lack contact geometry (such as a traditional mouse), and in cases where the actual geometry of the input is not detected by the hardware, the user agentMUST return a default value of 1.
pressure
The normalized pressure of the pointer input in the range of [0,1], where 0 and 1 represent the minimum and maximum pressure the hardware is capable of detecting, respectively. For hardware and platforms that do not support pressure, the value MUST be 0.5 when in the active buttons state and 0 otherwise.
tangentialPressure
The normalized tangential pressure (also known as barrel pressure), typically set by an additional control (e.g. a finger wheel on an airbrush stylus), of the pointer input in the range of [-1,1], where 0 is the neutral position of the control. Note that some hardware may only support positive values in the range of [0,1]. For hardware and platforms that do not support tangential pressure, the value MUST be 0.
Note
Despite the property's name, in practice the hardware controls/sensors that generate the values for this property may not necessarily be pressure sensitive. As an example, in most cases the finger wheel on most airbrush/painting stylus implementations can be freely set, rather than requiring the user to apply a constant pressure on the wheel to prevent it from returning to the zero position.
tiltX
The plane angle (in degrees, in the range of [-90,90]) between the Y-Z plane and the plane containing both the transducer (e.g. pen/stylus) axis and the Y axis. A positive tiltX is to the right, in the direction of increasing X values. tiltX can be used along with tiltY to represent the tilt away from the normal of a transducer with the digitizer. For hardware and platforms that do not report tilt or angle, the value MUST be 0.
The plane angle (in degrees, in the range of [-90,90]) between the X-Z plane and the plane containing both the transducer (e.g. pen/stylus) axis and the X axis. A positive tiltY is towards the user, in the direction of increasing Y values. tiltY can be used along with tiltX to represent the tilt away from the normal of a transducer with the digitizer. For hardware and platforms that do not report tilt or angle, the value MUST be 0.
The clockwise rotation (in degrees, in the range of [0,359]) of a transducer (e.g. pen/stylus) around its own major axis. For hardware and platforms that do not report twist, the value MUST be 0.
altitudeAngle
The altitude (in radians) of the transducer (e.g. pen/stylus), in the range [0,π/2] — where 0 is parallel to the surface (X-Y plane), and π/2 is perpendicular to the surface. For hardware and platforms that do not report tilt or angle, the value MUST be π/2.
Note
The default value defined here for altitudeAngle is π/2,
which positions the transducer as being perpendicular to the surface.
This differs from the Touch Events - Level 2 specification's
definition for the altitudeAngle property, which has a default value of 0.
Figure 5Example altitudeAngle of π/4 (45 degrees from the X-Y plane).
azimuthAngle
The azimuth angle (in radians) of the transducer (e.g. pen/stylus), in the range [0, 2π] — where 0 represents a transducer whose cap is pointing in the direction of increasing X values (point to "3 o'clock" if looking straight down) on the X-Y plane, and the values progressively increase when going clockwise (π/2 at "6 o'clock", π at "9 o'clock", 3π/2 at "12 o'clock"). When the transducer is perfectly perpendicular to the surface (altitudeAngle of π/2), the value MUST be 0. For hardware and platforms that do not report tilt or angle, the value MUST be 0.
Figure 6Example azimuthAngle of π/6 ("4 o'clock").
pointerType
Indicates the device type that caused the event (such as mouse, pen, touch). If the user agent is to fire a pointer event for a mouse, pen/stylus, or touch input device, then the value of pointerTypeMUST be according to the following table:
Pointer Device Type
pointerType Value
Mouse
mouse
Pen / stylus
pen
Touch contact
touch
If the device type cannot be detected by the user agent, then the value MUST be an empty string. If the user agent supports pointer device types other than those listed above, the value of pointerTypeSHOULD be vendor prefixed to avoid conflicting names for different types of devices. Future specifications MAY provide additional normative values for other device types.
Note
See Example 2 for a basic demonstration of how the pointerType can be used. Also note that developers should include some form of default handling to cover user agents that may have implemented their own custom pointerType values and for situations where pointerType is simply an empty string.
isPrimary
Indicates if the pointer represents the primary pointer of this pointer type.
persistentDeviceId
A unique identifier for the pointing device. If the hardware supports multiple pointers, pointer events generated from pointing devices MUST only get a persistentDeviceId if those pointers are uniquely identifiable over the session. If the pointer is uniquely identifiable, the assigned persistentDeviceId to that pointing device will remain constant for the remainder of the session. The persistentDeviceId value of 0MUST be reserved and used to indicate events whose generating device could not be identified. Like pointerId, to minimize the chance of fingerprinting and tracking across different pages or domains, the persistentDeviceIdMUST only be associated explicitly with that particular pointing device for the lifetime of the page / session, and a new randomized persistentDeviceIdMUST be chosen the next time that particular pointing device is used again in a new session.
Note
Due to digitizer and pointing device hardware constraints, a persistentDeviceId is not guaranteed to be available for all pointer events from a pointing device. For example, the device may not report its hardware id to the digitizer in time for pointerdown to have a persistentDeviceId. In such a case, the persistentDeviceId may initially be 0 and change to a valid value.
The PointerEventInit dictionary is used by the PointerEvent interface's constructor to provide a mechanism by which to construct untrusted (synthetic) pointer events. It inherits from the MouseEventInit dictionary defined in [UIEVENTS]. See the examples for sample code demonstrating how to fire an untrusted pointer event.
The PointerEvent interface inherits from MouseEvent, defined in UI Events.
Also note the proposed extension in CSSOM View Module, which changes the various coordinate properties from long
to double to allow for fractional coordinates. For user agents that already implement this proposed extension for
PointerEvent, but not for regular MouseEvent, there are additional requirements when it comes to
the click, auxclick, and contextmenu events.
5.1.1 Button states
5.1.1.1 Chorded button interactions
Some pointer devices, such as mouse or pen, support multiple buttons. In the [UIEVENTS] Mouse Event model, each button press produces a mousedown and mouseup event. To better abstract this hardware difference and simplify cross-device input authoring, Pointer Events do not fire overlapping pointerdown and pointerup events for chorded button presses (depressing an additional button while another button on the pointer device is already depressed).
Instead, chorded button presses can be detected by inspecting changes to the button and buttons properties. The button and buttons properties are inherited from the MouseEvent interface, but with a change in semantics and values, as outlined in the following sections.
The modifications to the button and buttons properties apply only to pointer events. However for click, auxclick and contextmenu the value of button and buttonsMUST follow [UIEVENTS], as is the case for compatibility mouse events .
5.1.1.2 The button property
To identify button state transitions in any pointer event (and not just pointerdown and pointerup), the button property indicates the device button whose state change fired the event.
Device Button Changes
button
Neither buttons nor touch/pen contact changed since last event
-1
Left Mouse, Touch contact, Pen contact
0
Middle Mouse
1
Right Mouse, Pen barrel button
2
X1 (back) Mouse
3
X2 (forward) Mouse
4
Pen eraser button
5
Note
During a mouse drag, the value of the button property in a pointermove event will be different from that in a mousemove event. For example, while moving the mouse with the right button pressed, the pointermove events will have the button value -1, but the mousemove events will have the button value 2.
5.1.1.3 The buttons property
The buttons property gives the current state of the device buttons as a bitmask (same as in MouseEvent, but with an expanded set of possible values).
Current state of device buttons
buttons
Mouse moved with no buttons pressed, Pen moved while hovering with no buttons pressed
0
Left Mouse, Touch contact, Pen contact
1
Middle Mouse
4
Right Mouse, Pen barrel button
2
X1 (back) Mouse
8
X2 (forward) Mouse
16
Pen eraser button
32
5.1.2 The primary pointer
In a multi-pointer (e.g. multi-touch) scenario, the isPrimary property is used to identify a master pointer amongst the set of active pointers for each pointer type.
At any given time, there can only ever be at most one primary pointer for each pointer type.
The first pointer to become active for a particular pointer type (e.g. the first finger to touch the screen in a multi-touch interaction) becomes the primary pointer for that pointer type.
Authors who desire single-pointer interaction can achieve this by ignoring non-primary pointers (however, see the note below on multiple primary pointers).
Note
When two or more pointer device types are being used concurrently, multiple pointers (one for each pointerType) are considered primary. For example, a touch contact and a mouse cursor moved simultaneously will produce pointers that are both considered primary.
Note
Some devices, operating systems and user agents may ignore the concurrent use of more than one type of pointer input to avoid accidental interactions. For instance, devices that support both touch and pen interactions may ignore touch inputs while the pen is actively being used, to allow users to rest their hand on the touchscreen while using the pen (a feature commonly referred to as "palm rejection"). Currently, it is not possible for authors to suppress this behavior.
Note
In some cases, it is possible for the user agent to fire pointer events in which no pointer is marked as a primary pointer. For instance, when there are multiple active pointers of a particular type, like a multi-touch interaction, and the primary pointer is removed (e.g. it leaves the screen), there may end up being no primary pointers. Also on platforms where the primary pointer is determined using all active pointers of the same type on the device (including those targeted at an application other than the user agent), if the first (primary) pointer is outside of the user agent and other (non-primary) pointers targeted inside the user agent, then the user agentMAY fire pointer events for the other pointers with a value of false for isPrimary.
Note
Current operating systems and user agents don't usually have a concept of multiple mouse inputs. When more than one mouse device is present (for instance, on a laptop with both a trackpad and an external mouse), all mouse devices are generally treated as a single device — movements on any of the devices are translated to movement of a single mouse pointer, and there is no distinction between button presses on different mouse devices. For this reason, there will usually only be a single mouse pointer, and that pointer will be primary.
5.1.3 Firing events using the PointerEvent interface
Before firing this event, the user agentSHOULD treat the target as if the pointing device has moved over it from the previousTarget for the purpose of ensuring event ordering [UIEVENTS]. If the needsOverEvent flag is set, a pointerover event is needed even if the target element is the same.
Fire the event to the determined target.
Save the determined target as the previousTarget for the given pointer,
and reset the needsOverEvent flag to false.
If the previousTarget at any point will no longer be connected [DOM],
update the previousTarget to the nearest still connected [DOM] parent
following the event path corresponding to dispatching events to the previousTarget,
and set the needsOverEvent flag to true.
Note
Using the pointer capture target override as the target instead of the normal hit-test result may fire some boundary events, as defined by [UIEVENTS]. This is the same as the pointer leaving its previous target and entering this new capturing target. When the capture is released, the same scenario may happen, as the pointer is leaving the capturing target and entering the hit-test target.
5.1.3.1 Attributes and default actions
The bubbles and cancelable properties and the default actions for the event types defined in this specification appear in the following table. Details of each of these event types are provided in Pointer Event types.
Varies: when the pointer is primary, all default actions of the mousedown event
Canceling this event also prevents subsequent firing of compatibility mouse events.
Viewport manipulations (panning and zooming) — generally, as a result of a direct manipulation interaction — are intentionally NOT a default action of pointer events, meaning that these behaviors (e.g. panning a page as a result of moving a finger on a touchscreen) cannot be suppressed by canceling a pointer event. Authors must instead use touch-action to explicitly declare the direct manipulation behavior for a region of the document. Removing this dependency on the cancelation of events facilitates performance optimizations by the user agent.
For pointerenter and pointerleave events, the composed [DOM] attribute SHOULD be false; for all other pointer events in the table above, the attribute SHOULD be true.
For all pointer events in the table above, the detail [UIEVENTS] attribute SHOULD be 0.
Note
Many user agents expose non-standard attributes fromElement and toElement in MouseEvents to support legacy content. We encourage those user agents to set the values of those (inherited) attributes in PointerEvents to null to transition authors to the use of standardized alternates (target and relatedTarget).
Similar to MouseEventrelatedTarget, the relatedTarget should be initialized to the element whose bounds the pointer just left (in the case of a pointerover or pointerenter event) or the element whose bounds the pointer is entering (in the case of a pointerout or pointerleave). For other pointer events, this value will default to null. Note that when an element receives the pointer capture all the following events for that pointer are considered to be inside the boundary of the capturing element.
As defined in the section for click, auxclick, and contextmenu events, even after the lostpointercapture event has been dispatched,
the corresponding click, auxclick or contextmenu event, if any, would still be dispatched to the capturing target.
5.1.3.3 Suppressing a pointer event stream
The user agentMUST suppress a pointer event stream when it detects that the web page is unlikely to continue to receive pointer events with a specific pointerId. Any of the following scenarios satisfy this condition (there MAY be additional scenarios):
The user agent has opened a modal dialog or menu.
A pointer input device is physically disconnected, or a hoverable pointer input device (e.g. a hoverable pen/stylus) has left the hover range detectable by the digitizer.
The pointer is subsequently used by the user agent to manipulate the page viewport (e.g. panning or zooming). See the section on touch-action CSS property for details.
Note
User agents can trigger panning or zooming through multiple pointer types (such as touch and pen), and therefore the start of a pan or zoom action may result in the suppression of various pointers, including pointers with different pointer types.
As part of the drag operation initiation algorithm as defined in the drag and drop processing model [HTML],
for the pointer that caused the drag operation.
A pointing device that moved relative to the screen surface or underwent some change in any of its properties fires various events as defined in Pointer Event types. For a stationary pointing device (that neither moved relative to the screen surface nor underwent any change in any properties), the user agentMUST fire certain boundary events after a layout change that affected the hit test target for the pointer, see pointerover, pointerenter, pointerout and pointerleave for details. The user agentMAY delay the firing of these boundary events because of performance reasons (e.g. to avoid too many hit-tests or layout changes caused by boundary event listeners).
Note
A stationary pointing device (that neither moved relative to the screen surface nor underwent any change in any properties) never fires a pointermove event.
5.1.5 Converting between tiltX / tiltY and altitudeAngle / azimuthAngle
Pointer Events include two complementary sets of attributes to express the orientation of a transducer relative to the X-Y plane: tiltX / tiltY (introduced in the original Pointer Events specification), and azimuthAngle / altitudeAngle (adopted from the Touch Events - Level 2 specification).
Depending on the specific hardware and platform, user agents will likely only receive one set of values for the transducer orientation relative to the screen plane — either tiltX / tiltY or altitudeAngle / azimuthAngle. User agents MUST use the following algorithm for converting these values.
When the user agent calculates tiltX / tiltY from azimuthAngle / altitudeAngle it SHOULD round the final integer values using Math.round [ECMASCRIPT] rules.
Example 8: Converting between tiltX/tiltY and altitudeAngle/azimuthAngle
/* Converting between tiltX/tiltY and altitudeAngle/azimuthAngle */functionspherical2tilt(altitudeAngle, azimuthAngle) {
const radToDeg = 180/Math.PI;
let tiltXrad = 0;
let tiltYrad = 0;
if (altitudeAngle == 0) {
// the pen is in the X-Y planeif (azimuthAngle == 0 || azimuthAngle == 2*Math.PI) {
// pen is on positive X axis
tiltXrad = Math.PI/2;
}
if (azimuthAngle == Math.PI/2) {
// pen is on positive Y axis
tiltYrad = Math.PI/2;
}
if (azimuthAngle == Math.PI) {
// pen is on negative X axis
tiltXrad = -Math.PI/2;
}
if (azimuthAngle == 3*Math.PI/2) {
// pen is on negative Y axis
tiltYrad = -Math.PI/2;
}
if (azimuthAngle>0 && azimuthAngle<Math.PI/2) {
tiltXrad = Math.PI/2;
tiltYrad = Math.PI/2;
}
if (azimuthAngle>Math.PI/2 && azimuthAngle<Math.PI) {
tiltXrad = -Math.PI/2;
tiltYrad = Math.PI/2;
}
if (azimuthAngle>Math.PI && azimuthAngle<3*Math.PI/2) {
tiltXrad = -Math.PI/2;
tiltYrad = -Math.PI/2;
}
if (azimuthAngle>3*Math.PI/2 && azimuthAngle<2*Math.PI) {
tiltXrad = Math.PI/2;
tiltYrad = -Math.PI/2;
}
}
if (altitudeAngle != 0) {
const tanAlt = Math.tan(altitudeAngle);
tiltXrad = Math.atan(Math.cos(azimuthAngle) / tanAlt);
tiltYrad = Math.atan(Math.sin(azimuthAngle) / tanAlt);
}
return {"tiltX":tiltXrad*radToDeg, "tiltY":tiltYrad*radToDeg};
}
functiontilt2spherical(tiltX, tiltY) {
const tiltXrad = tiltX * Math.PI/180;
const tiltYrad = tiltY * Math.PI/180;
// calculate azimuth anglelet azimuthAngle = 0;
if (tiltX == 0) {
if (tiltY > 0) {
azimuthAngle = Math.PI/2;
}
elseif (tiltY < 0) {
azimuthAngle = 3*Math.PI/2;
}
} elseif (tiltY == 0) {
if (tiltX < 0) {
azimuthAngle = Math.PI;
}
} elseif (Math.abs(tiltX) == 90 || Math.abs(tiltY) == 90) {
// not enough information to calculate azimuth
azimuthAngle = 0;
} else {
// Non-boundary case: neither tiltX nor tiltY is equal to 0 or +-90const tanX = Math.tan(tiltXrad);
const tanY = Math.tan(tiltYrad);
azimuthAngle = Math.atan2(tanY, tanX);
if (azimuthAngle < 0) {
azimuthAngle += 2*Math.PI;
}
}
// calculate altitude anglelet altitudeAngle = 0;
if (Math.abs(tiltX) == 90 || Math.abs(tiltY) == 90) {
altitudeAngle = 0
} elseif (tiltX == 0) {
altitudeAngle = Math.PI/2 - Math.abs(tiltYrad);
} elseif (tiltY == 0) {
altitudeAngle = Math.PI/2 - Math.abs(tiltXrad);
} else {
// Non-boundary case: neither tiltX nor tiltY is equal to 0 or +-90
altitudeAngle = Math.atan(1.0/Math.sqrt(Math.pow(Math.tan(tiltXrad),2) + Math.pow(Math.tan(tiltYrad),2)));
}
return {"altitudeAngle":altitudeAngle, "azimuthAngle":azimuthAngle};
}
Let mouseout be the corresponding mouseout MouseEvent
Note
Unlike mousedown events, pointerdown
events are not nested when multiple buttons are pressed.
The MouseEvent is passed so that the fields can be copied into the PointerEvent.
Let mouseout be the corresponding mouseout MouseEvent
Note
Unlike mouseup events, pointerup events are not nested when multiple buttons are pressed. The MouseEvent is passed so that the fields can be copied into the PointerEvent.
The step to determine the target of a pointer detects that the pointer has moved into an element or one of its descendants.
A layout change causes the hit test boundaries of an element or one of its descendants to move underneath an uncaptured pointer of a stationary pointing device.
This event type is similar to pointerover but with two differences: pointerenter does not bubble, and its dispatch considers the hit test boundaries of even descendant elements.
Note
There are similarities between this event type, the mouseenter event described in [UIEVENTS], and the CSS :hover pseudo-class described in [CSS21]. See also the pointerleave event.
5.3.3 The pointerdown event
The user agentMUSTfire a pointer event named pointerdown when a pointer enters the active buttons state. For mouse, this is when the device transitions from no buttons depressed to at least one button depressed. For touch, this is when physical contact is made with the digitizer. For pen, this is when the pen either makes physical contact with the digitizer without any button depressed, or transitions from no buttons depressed to at least one button depressed while hovering.
Note
For mouse (or other multi-button pointer devices), this means pointerdown and pointerup are not fired for all of the same circumstances as mousedown and mouseup. See chorded buttons for more information.
Authors can prevent the firing of certain compatibility mouse events by canceling the pointerdown event (if the isPrimary property is true). This sets the PREVENT MOUSE EVENT flag on the pointer. Note, however, that this does not prevent the mouseover, mouseenter, mouseout, or mouseleave events from firing.
User agents MAY delay dispatch of the pointermove event (for instance, for performance reasons).
The coalesced events information will be exposed via thegetCoalescedEvents method for the single dispatched pointermove event.
The final coordinates of such events should be used for finding the target of the event.
5.3.5 The pointerrawupdate event
The user agentMUSTfire a pointer event
named pointerrawupdate, and only do so within a secure context, when a pointer changes any properties that don't fire
pointerdown or pointerup events. See pointermove event for a list of such properties.
In contrast with pointermove, user agents SHOULD dispatch pointerrawupdate events as soon as possible
and as frequently as the JavaScript can handle the events.
The target of pointerrawupdate events might be different from the pointermove events
due to the fact that pointermove events might get delayed or coalesced, and the final position of the event
which is used for finding the target could be different from its coalesced events.
Other than the target, the concatenation of coalesced events lists of all dispatched pointerrawupdate events
since the last pointermove event is the same as the coalesced events of the next pointermove event in terms of the other event attributes.
The attributes of pointerrawupdate are mostly the same as pointermove, with the exception of
cancelable which MUST be false for pointerrawupdate.
Adding listeners for the pointerrawupdate event might negatively impact the performance of the web page, depending on the implementation of the user agent.
For most use cases the other pointerevent types should suffice.
A pointerrawupdate listener should only be added if JavaScript needs high frequency events and can handle them just as fast.
In these cases, there is probably no need to listen to other types of pointer events.
5.3.6 The pointerup event
The user agentMUSTfire a pointer event named pointerup when a pointer leaves the active buttons state. For mouse, this is when the device transitions from at least one button depressed to no buttons depressed. For touch, this is when physical contact is removed from the digitizer. For pen, this is when the pen is removed from the physical contact with the digitizer while no button is depressed, or transitions from at least one button depressed to no buttons depressed while hovering.
For mouse (or other multi-button pointer devices), this means pointerdown and pointerup are not fired for all of the same circumstances as mousedown and mouseup. See chorded buttons for more information.
The values of the following properties of the pointercancel event MUST match the values of the last dispatched pointer event with the same pointerId: width, height, pressure, tangentialPressure, tiltX, tiltY, twist, altitudeAngle, azimuthAngle, pointerType, isPrimary, and the coordinates inherited from [UIEVENTS]. The coalescedEvents and predictedEvents lists in the pointercancel event MUST be empty, and the event's cancelable attribute MUST be false.
The step to determine the target of a pointer detects that the pointer has moved out of an element and all of its descendants.
A layout change causes the hit test boundaries of an element and all of its descendants to move away from underneath an uncaptured pointer of a stationary pointing device.
This event type is similar to pointerout but with two differences: pointerleave does not bubble, and its dispatch considers the hit test boundaries of even descendant elements.
Note
There are similarities between this event type, the mouseleave event described in [UIEVENTS], and the CSS :hover pseudo-class described in [CSS21]. See also the pointerenter event.
5.3.12 The click, auxclick, and contextmenu events
This section is an addition to click,
auxclick and contextmenu
events defined in [UIEVENTS]. These events are typically tied to user interface activation, and are fired even from non-pointer input devices, such as keyboards.
These events MUST be of type PointerEvent, and are subject to the additional requirements mentioned in the rest of this section.
5.3.12.1 Event attributes
For these events, all PointerEvent specific attributes (defined in this spec) other than pointerId and pointerTypeMUST have their default values. In addition:
If the events are generated by a pointing device, their pointerId and pointerTypeMUST be the same as the PointerEvents that caused these events.
If the events are generated by a non-pointing device (such as voice recognition software or a keyboard interaction), pointerIdMUST be -1 and pointerTypeMUST be an empty string.
5.3.12.2 Event coordinates
As noted in PointerEvent, CSSOM View Module proposes to redefine the various coordinate properties (screenX, screenY, pageX, pageY, clientX,
clientY, x, y, offsetX, offsetY) as double, to allow for fractional coordinates.
However, this change — when applied only to PointerEvent, but not to regular MouseEvent — has proven to lead to web compatibility issues with legacy code
in the case of click, auxclick, and contextmenu. For this reason, user agents that have implemented the proposed
change in CSSOM View Module only for PointerEventMUST convert the various coordinate properties for the click, auxclick, and contextmenu
to long values (as defined in the original UI Events) using Math.floor [ECMASCRIPT].
5.3.12.3 Event dispatch
A click, auxclick or contextmenu event MUST follow the dispatch process defined in the [UIEVENTS] spec except that the event target is overridden using the algorithm below:
Let event be the click, auxclick or contextmenu event being dispatched, and userEvent be the user interaction event that caused the firing of event.
Note
Event userEvent could be a non-PointerEvent; for example, it is a KeyboardEvent when a click event dispatch is caused by hitting the spacebar on a checkbox element.
When userEvent is a PointerEvent, userEvent is a pointerup for a click or auxclick event, and either a pointerdown or a pointerup event (depending on native platform convention) for a contextmenu event.
If userEvent is not a PointerEvent, dispatch event following the [UIEVENTS] spec without overriding event target and skip the remaining steps below.
Define target as follows:
If event is a contextmenu event, or userEvent was dispatched while the corresponding pointer was captured, then let target be the target of userEvent.
Otherwise (event is a click or auxclick event for which userEvent is a pointerup event that was dispatched uncaptured) let target be the nearest common inclusive ancestor of the corresponding pointerdown and pointerup targets in the DOM at the moment event is being dispatched.
Dispatch event to target following the [UIEVENTS] spec.
Note
If userEvent was captured, event is dispatched to the capturing target of userEvent even though the lostpointercapture event with the same pointerId has been dispatched already.
6. Wheel Events
Wheels are devices that can be rotated in one or more spatial dimensions, and which can be associated with a pointer device. The coordinate system depends on the
environment configuration.
The user's environment might be configured to associate vertical scrolling
with rotation along the y-axis, horizontal scrolling with rotation along the
x-axis, and zooming with rotation along the z-axis.
The deltaX, deltaY, and deltaZ attributes of WheelEvent objects indicate
a measurement along their respective axes in units of pixels, lines, or
pages. The reported measurements are provided after an environment-specific
algorithm translates the actual rotation/movement of the wheel device into
the appropriate values and units.
Note
A user's environment settings can be customized to interpret actual rotation/movement
of a wheel device in different ways.
One movement of a common dented mouse wheel can produce a measurement of 162 pixels
(162 is just an example value, actual values can depend on the current screen
dimensions of the user-agent).
But a user can change their default environment settings to speed-up their mouse wheel,
increasing this number.
Furthermore, some mouse wheel software can support acceleration (the faster the wheel
is rotated/moved, the greater the delta of each measurement) or even sub-pixel rotation
measurements.
Because of this, authors can not assume a given rotation amount in one user agent will
produce the same delta value in all user agents.
The sign (positive or negative) of the values of the deltaX, deltaY, and deltaZ attributes
MUST be consistent between multiple dispatches of the
wheel event while the
motion of the actual wheel device is rotating/moving in the same direction.
If a user agent scrolls as the default action of the
wheel event then the sign
of the deltaSHOULD be given by a right-hand coordinate system where positive X,
Y, and Z axes are directed towards the right-most edge, bottom-most edge, and farthest
depth (away from the user) of the document, respectively.
Note
Individual user agents can (depending on their environment and hardware configuration)
interpret the same physical user interaction on the wheel differently.
For example, a vertical swipe on the edge of a trackpad from top to bottom can be
interpreted as a wheel action intended to either scroll the
page down or to pan the page up (i.e., resulting in either a positive or negative
deltaY value respectively).
A user agentMUST create a wheel event transaction when the first wheel event
is fired, so that all subsequent wheel events within a implementation-specific amount of
time can be targetted at the same element. A wheel event transaction is series of
wheel events that are associated with a single user gesture. The
wheel event transactionMUST have an associated event target that is the
topmost event target at the time the first wheel event occurs in the group.
If a series of wheel events targetted in a scrollable element start above a child element,
later events for the same user gesture may occur over the child element.
6.1 Interface WheelEvent
The WheelEvent interface provides specific contextual information
associated with wheel events.
To create an instance of the WheelEvent interface, use the WheelEvent constructor,
passing an optional WheelEventInit dictionary.
The units of measurement for the deltaMUST be pixels.
This is the most typical case in most operating system and
implementation configurations.
DOM_DELTA_LINE
The units of measurement for the deltaMUST be individual
lines of text. This is the case for many form controls.
DOM_DELTA_PAGE
The units of measurement for the deltaMUST be pages,
either defined as a single screen or as a demarcated page.
deltaX
In user agents where the default action of the wheel
event is to scroll, the value MUST be the measurement along the
x-axis (in pixels, lines, or pages) to be scrolled in the case
where the event is not cancelled. Otherwise, this is an
implementation-specific measurement (in pixels, lines, or pages)
of the movement of a wheel device around the x-axis.
The un-initialized value of this attribute MUST be
0.0.
deltaY
In user agents where the default action of the wheel
event is to scroll, the value MUST be the measurement along the
y-axis (in pixels, lines, or pages) to be scrolled in the case
where the event is not cancelled. Otherwise, this is an
implementation-specific measurement (in pixels, lines, or pages)
of the movement of a wheel device around the y-axis.
The un-initialized value of this attribute MUST be
0.0.
deltaZ
In user agents where the default action of the wheel
event is to scroll, the value MUST be the measurement along the
z-axis (in pixels, lines, or pages) to be scrolled in the case
where the event is not cancelled. Otherwise, this is an
implementation-specific measurement (in pixels, lines, or pages)
of the movement of a wheel device around the z-axis.
The un-initialized value of this attribute MUST be
0.0.
deltaMode
The deltaMode attribute contains an indication of
the units of measurement for the delta values. The
default value is DOM_DELTA_PIXEL (pixels).
This attribute MUST be set to one of the DOM_DELTA constants to
indicate the units of measurement for the delta values.
The precise measurement is specific to device, operating system,
and application configurations.
The un-initialized value of this attribute MUST be
0.
Initializes the deltaZ attribute of the WheelEvent
object. Relative positive values for this attribute (as well as
the deltaX and deltaY attributes) are
given by a right-hand coordinate system where the X, Y, and Z
axes are directed towards the right-most edge, bottom-most edge,
and farthest depth (away from the user) of the document,
respectively. Negative relative values are in the respective
opposite directions.
deltaMode
Initializes the deltaMode attribute on the
WheelEvent object to the enumerated values 0, 1, or 2, which
represent the amount of pixels scrolled
(DOM_DELTA_PIXEL), lines scrolled
(DOM_DELTA_LINE), or pages scrolled
(DOM_DELTA_PAGE) if the rotation of the
wheel would have resulted in scrolling.
WheelEvent.deltaX : expected amount that the page will scroll along the x-axis according to the deltaMode units; or an implementation-specific value of movement of a wheel around the x-axis
WheelEvent.deltaY : expected amount that the page will scroll along the y-axis according to the deltaMode units; or an implementation-specific value of movement of a wheel around the y-axis
WheelEvent.deltaZ : expected amount that the page will scroll along the z-axis according to the deltaMode units; or an implementation-specific value of movement of a wheel around the z-axis
WheelEvent.deltaMode : unit indicator (pixels, lines, or pages) for the deltaX, deltaY, and deltaZ attributes
A user agentMUST dispatch this event when a mouse wheel has
been rotated around any axis, or when an equivalent input device
(such as a mouse-ball, certain tablets or touchpads, etc.) has
emulated such an action. Depending on the platform and input device,
diagonal wheel deltasMAY be delivered either as a single
wheel event with multiple non-zero axes or as separate
wheel events for each non-zero axis.
The typical default action of the wheel event type is
to scroll (or in some cases, zoom) the document by the indicated
amount. If this event is canceled, the implementation MUST NOT
scroll or zoom the document (or perform whatever other
implementation-specific default action is associated with this event
type).
Note
In some user agents, or with some input devices, the speed
that the wheel has been turned can affect the delta values,
with a faster speed producing a higher delta value.
6.2.2 cancelability of wheel events
Calling preventDefault on a wheel event can prevent
or otherwise interrupt scrolling. For maximum scroll performance, a
user agent may not wait for each wheel event associated with the scroll
to be processed to see if it will be canceled. In such cases the user
agent should generate wheel events whose
cancelable property is false, indicating that
preventDefault cannot be used to prevent or interrupt
scrolling. Otherwise cancelable will be true.
Set pointer capture for the pointer identified by the argument pointerId to the element on which this method is invoked. For subsequent events of the pointer, the capturing target will substitute the normal hit testing result as if the pointer is always over the capturing target, and they MUST always be targeted at this element until capture is released. The pointer MUST be in its active buttons state for this method to be effective, otherwise it fails silently. When the provided method's argument does not match any of the active pointers, throw a "NotFoundError" DOMException.
releasePointerCapture()
Release pointer capture for the pointer identified by the argument pointerId from the element on which this method is invoked. Subsequent events for the pointer follow normal hit testing mechanisms (out of scope for this specification) for determining the event target. When the provided method's argument does not match any of the active pointers, throw a "NotFoundError" DOMException.
hasPointerCapture
Indicates whether the element on which this method is invoked has pointer capture for the pointer identified by the argument pointerId. In particular, returns true if the pending pointer capture target override for pointerId is set to the element on which this method is invoked, and false otherwise.
If emulated maxTouchPoints is not null, return
emulated maxTouchPoints.
Return the maximum number of simultaneous touch contacts supported by
the device. In the case of devices with multiple digitizers (e.g.
multiple touchscreens), the value MUST be the maximum of the set of
maximum supported contacts by each individual digitizer.
For example, suppose a device has 3 touchscreens, which support 2, 5,
and 10 simultaneous touch contacts, respectively. The value of
maxTouchPoints should be 10.
Note
While a maxTouchPoints value of greater than 0 indicates the user's device is capable of supporting touch input, it does not necessarily mean the user will use touch input. Authors should be careful to also consider other input modalities that could be present on the system, such as mouse, pen, or screen readers.
Note
maxTouchPoints is often used to ensure that the interaction model of the content can be recognized by the current hardware. UI affordances can be provided to users with less capable hardware. On platforms where the precise number of touch points is not known, the minimum number guaranteed to be recognized is provided. Therefore, it is possible for the number of recognized touch points to exceed the value of maxTouchPoints.
10. Declaring direct manipulation behavior
As noted in Attributes and Default Actions, viewport manipulations (panning and zooming) cannot be suppressed by canceling a pointer event. Instead, authors must declaratively define which of these behaviors they want to allow, and which they want to suppress, using the touch-action CSS property.
Note
While the issue of pointers used to manipulate the viewport is generally limited to touch input (where a user's finger can both interact with content and pan/zoom the page), certain user agents may also allow the same types of (direct or indirect) manipulation for other pointer types. For instance, on mobile/tablet devices, users may also be able to scroll using a stylus. While, for historical reasons, the touch-action CSS property defined in this specification appears to refer only to touch inputs, it does in fact apply to all forms of pointer inputs that allow direct manipulation for panning and zooming.
all elements except: non-replaced inline elements, table rows, row groups, table columns, and column groups
Inherited:
no
Percentages:
N/A
Media:
visual
Computed value:
same as specified value
Canonical order:
per grammar
Animation type:
not animatable
The touch-action CSS property determines whether direct manipulation interactions (which are not limited to touch, despite the property's name) MAY trigger the user agent's panning and zooming behavior. See the section on touch-action values.
The user agent has determined (via methods out of scope for this specification) that a direct manipulation interaction is to be consumed for panning or zooming,
a pointerdown event has been sent for the pointer, and
Some user agents implement complex gestures for behaviors that involve a series of separate discrete gestures, but which are all treated as part of a single continuous gesture. For example, consider a "fling to scroll" gesture on a touchscreen: a user starts panning the document with a rapid finger movement, lifts the finger from the touchscreen, and the document continues panning with simulated inertia. While the document is still moving, the user may place their finger on the touchscreen and execute another "fling" to provide further momentum for the panning, or counteract the current panning to slow it down, stop panning altogether, or reverse the direction of the panning. As this specification does not normatively define how gestures and behaviors are implemented, it is left up to the user agent to decide whether or not the second touch (before it is interpreted as a second "fling" or counteraction of the current panning) fires pointer events or not.
Note
touch-action does not apply/cascade through to embedded browsing contexts. For instance, even applying touch-action to an <iframe> won't have any effect on the behavior of direct manipulation interactions for panning and zooming within the <iframe> itself.
10.2 Determining supported direct manipulation behavior
When a user interacts with an element using a direct manipulation pointer (such as touch or stylus on a touchscreen), the effect of that input is determined by the value of the touch-action property, and the default direct manipulation behaviors of the element and its ancestors, as follows:
A direct manipulation interaction for panning and zooming conforms to an element's touch-action if the behavior is allowed in the coordinate space of the element. Note that if CSS transforms have been applied, the element's coordinate space may differ from the screen coordinate in a way that affects the conformity here; for example, the X axis of an element rotated by 90 degrees with respect to the screen will be parallel to the Y-axis of the screen coordinate.
A direct manipulation interaction for panning is supported if it conforms to the touch-action property of each element between the hit tested element and its nearest inclusive ancestor that is a scroll container (as defined in [CSS-OVERFLOW-3]).
A direct manipulation interaction for zooming is supported if it conforms to the touch-action property of each element between the hit tested element and the document element of the top-level browsing context (as defined in [HTML]).
Once panning or zooming has been started, and the user agent has already determined whether or not the gesture should be handled as a user agent direct manipulation behavior, any changes to the relevant touch-action value will be ignored for the duration of the action. For instance, programmatically changing the touch-action value for an element from auto to none as part of a pointerdown handler script will not result in the user agent aborting or suppressing any of the pan or zoom behavior for that input for as long as that pointer is active.
Similarly, in the case of the various touch-action values of pan-*, once the user agent has determined whether to handle a gesture directly or not at the start of the gesture, a subsequent change in the direction of the same gesture SHOULD be ignored by the user agent for as long as that pointer is active. For instance, if an element has been set to touch-action: pan-y (meaning that only vertical panning is handled by the user agent), and a touch gesture starts off horizontally, no vertical panning should occur if the user changes the direction of their gesture to be vertical while their finger is still touching the screen.
Note
Some user agents support panning and zooming interactions involving multiple concurrent pointers (e.g. multi-touch). Methods for processing or associating the touch-action values of multiple concurrent pointers is out of scope for this specification.
10.3 Details of touch-action values
The touch-action property covers direct manipulation behaviors related to viewport panning and zooming. Any additional user agent behaviors, such as text selection/highlighting, or activating links and form controls, MUST NOT be affected by this CSS property.
Note
The terms "panning" and "scrolling" are considered synonymous (or, more aptly, "panning" is "scrolling" using a direct manipulation input). Defining an interaction or gesture for triggering panning/scrolling, or for triggering behavior for the auto or none values, are out of scope for this specification.
auto
The user agentMAY consider any permitted direct manipulation behaviors related to panning and zooming of the viewport that begin on the element.
none
Direct manipulation interactions that begin on the element MUST NOT trigger behaviors related to viewport panning and zooming.
pan-x pan-left pan-right pan-y pan-up pan-down
The user agentMAY consider direct manipulation interactions that begin on the element only for the purposes of panning that starts in any of the directions specified by all of the listed values. Once panning has started, the direction may be reversed by the user even if panning that starts in the reversed direction is disallowed. In contrast, when panning is restricted to a single axis (for instance, with pan-x or pan-y), the axis cannot be changed during panning.
manipulation
The user agentMAY consider direct manipulation interactions that begin on the element only for the purposes of panning and continuous zooming (such as pinch-zoom), but MUST NOT trigger other related behaviors that rely on multiple activations that must happen within a set period of time (such as double-tap to zoom, or double-tap and hold for single-finger zoom).
The touch-action property only applies to elements that support both the CSS width and height properties (see [CSS21]). This restriction is designed to facilitate user agent optimizations for low-latencydirect manipulation panning and zooming. For elements not supported by default, such as <span> which is a non-replaced inline element, authors can set the display CSS property to a value, such as block, that supports width and height. Future specifications could extend this API to all elements.
Note
The direction-specific pan values are useful for customizing some overscroll behaviors.
For example, to implement a simple pull-to-refresh effect the document's touch-action can be set to pan-x pan-down whenever the scroll position is 0 and pan-x pan-y otherwise.
This allows pointer event handlers to define the behavior for upward panning/scrolling that start from the top of the document.
The direction-specific pan values can also be used for composing a component that implements custom panning with pointer event handling within an element that scrolls natively (or vice-versa).
For example, an image carousel may use pan-y to ensure it receives pointer events for any horizontal pan operations without interfering with vertical panning of the document.
When the carousel reaches its right-most extent, it may change its touch-action to pan-y pan-right so that a subsequent scroll operation beyond its extent can scroll the document within the viewport if possible.
It's not possible to change the behavior of a panning/scrolling operation while it is taking place.
Note
Disabling some default direct manipulation behaviors for panning and zooming may allow user agents to respond to other behaviors more quickly. For example, with auto user agents typically add 300ms of delay before click to allow for double-tap gestures to be handled. In these cases, explicitly setting touch-action: none or touch-action: manipulation will remove this delay. Note that the methods for determining a tap or double-tap gesture are out of scope for this specification.
Example 9: Disallowing all direct manipulation behaviors
<divstyle="touch-action: none;">
This element receives pointer events for all direct manipulation interactions that otherwise lead to panning or zooming.
</div>
<divstyle="touch-action: pan-x;">
This element receives pointer events when not panning in the horizontal direction.
</div>
Example 11: Child regions that disallow direct manipulation behaviors for panning and zooming
<divstyle="overflow: auto;"><divstyle="touch-action: none;">
This element receives pointer events for all direct manipulation interactions that otherwise lead to panning or zooming.
</div><div>
Direct manipulation interactions on this element MAY be consumed for manipulating the parent.
</div></div>
Example 12: Intermediate parent that disallows direct manipulation behaviors for panning and zooming
<divstyle="overflow: auto;"><divstyle="touch-action: pan-y;"><divstyle="touch-action: pan-x;">
This element receives pointer events for all direct manipulation interactions because
it allows only horizontal panning yet an intermediate ancestor
(between it and the scrollable element) only allows vertical panning.
Therefore, no direct manipulation behaviors for panning/zooming are
handled by the user agent.
</div></div></div>
Example 13: Intermediate parent that restricts allowed direct manipulation behaviors for panning and zooming
<divstyle="overflow: auto;"><divstyle="touch-action: pan-y pan-left;"><divstyle="touch-action: pan-x;">
This element receives pointer events when not panning to the left.
</div></div></div>
11. Pointer capture
11.1 Introduction
This section is non-normative.
Pointer capture allows the events for a particular pointer (including any compatibility mouse events) to be retargeted to a particular element other than the normal hit test result of the pointer's location. This is useful in scenarios like a custom slider control (e.g. similar to the [HTML] <input type="range"> control). Pointer capture can be set on the slider thumb element, allowing the user to slide the control back and forth even if the pointer slides off of the thumb.
Figure 7Example of a custom slider control that chooses a value by sliding the thumb element back and forth. After pointerdown on the thumb, pointer capture can be used to allow the user to slide the thumb even if the pointer drifts off of it.
11.2 Setting pointer capture
Pointer capture is set on an element of type Element by calling the element.setPointerCapture(pointerId) method.
When this method is invoked, the user agentMUST run the following steps:
For the specified pointerId, set the pending pointer capture target override to the Element on which this method was invoked.
Note
If a call to set or release a pointer capture is made while a previous set or release call is in a pending state (see process pending pointer capture), the second call overrides the first call if the second call is successful, otherwise the first call remains effective. This is true for a failed attempt to release an implicit pointer capture at a pointerdown listener.
11.3 Releasing pointer capture
Pointer capture is released on an element explicitly by calling the element.releasePointerCapture(pointerId) method. When this method is called, the user agentMUST run the following steps:
Inputs that implement direct manipulation interactions for panning and zooming (such as touch or stylus on a touchscreen) SHOULD behave exactly as if setPointerCapture was called on the target element just before the invocation of any pointerdown listeners. The hasPointerCapture API may be used (for instance, in a pointerdown listener) to determine whether this has occurred. If releasePointerCapture is not called for the pointer before the next pointer event is fired, then a gotpointercapture event will be dispatched to the target (as normal) indicating that capture is active.
Note
This is a breaking change from [PointerEvents], but does not impact the vast majority of existing content. In addition to matching typical platform UX conventions, this design for implicit capture enables user agents to make a performance optimization which prevents the need to invoke hit-testing on touch movement events without explicit developer opt-in (consistent with the performance properties of existing dominant native and web APIs for touch input).
Note
In addition, user agents may implement implicit pointer capture behavior for all input devices on specific UI widgets such as input range controls (allowing some finger movement to stray outside of the form control itself during the interaction).
The previous two paragraphs result in a lostpointercapture event
corresponding to the captured pointer being fired at the document
during the next Process pending pointer capture after the capture node is removed.
When a pointer lock [PointerLock] is successfully applied on an element, the user agentMUST run the steps as if the releasePointerCapture method has been called if any element is set to be captured or pending to be captured.
12. Coalesced and predicted events
Note
This specification does not define how user agents should coalesce or
predict pointer movement data. It only specifies the API for accessing this information.
12.1 Coalesced events
For performance reasons, user agents may choose not to send a pointermove
event every time a measurable property
(such as coordinates, pressure, tangential pressure, tilt, twist, or contact geometry)
of a pointer is updated. Instead, they may coalesce (combine/merge) multiple changes into
a single pointermove or pointerrawupdate event. While
this approach helps in reducing the amount of event handling the user agentMUST perform,
it will naturally reduce the granularity and fidelity when tracking a pointer position,
particularly for fast and large movements. Using the
getCoalescedEvents method
it is possible for applications to access the raw, un-coalesced position changes. These
allow for a more precise handling of pointer movement data. In the case of drawing
applications, for instance, the un-coalesced events can be used to draw smoother curves that
more closely match the actual movement of a pointer.
Figure 8Example of a curve in a drawing application — using only the coalesced
coordinates from pointermove events (the grey dots), the curve is noticeably
angular and jagged; the same line drawn using the more granular points provided by
getCoalescedEvents() (the red circles) results in a smoother approximation
of the pointer movement.
A PointerEvent has an associated coalesced events list (a list of
zero or more PointerEvents). For trusted pointermove and
pointerrawupdate events, the list is a sequence of all PointerEvents
that were coalesced into this event. The "parent" trusted pointermove and
pointerrawupdate event represents an accumulation of these coalesced events,
but may have additional processing (for example to align with the display refresh rate).
As a result, the coalesced events lists for these events always contain at least one event.
For all other trusted event types, it is an empty list. Untrusted events have their
coalesced events list initialized to the value passed to the constructor.
Note
Since a trusted parent event is a summary or aggregation of the
coalesced events, developers should only need to process either the parent events
or all of the coalesced events, but not both.
Note
When a trusted event containing a coalesced events list is re-dispatched from JavaScript, the event dispatch algorithm sets the isTrusted bit of the event to false but the same bits in the coalesced events list remain unchanged from their original true values.
The events in the coalesced events list of a trusted event will have:
Monotonically increasing timeStamp values [DOM] — all coalesced events have a
timeStamp that is smaller than or equal to the timeStamp of the dispatched pointer event that the
getPredictedEvents method was called on. The coalesced events list
MUST be chronologically sorted by timeStamp, so the first event will have the smallest timeStamp.
The same pointerId, pointerType, and isPrimary as the dispatched
"parent" pointer event.
Example 14: Basic canvas drawing application using the coalesced events list
<style>/* Disable intrinsic user agent direct manipulation behaviors (such as panning or zooming)
so that all events on the canvas element are given to the application instead. */canvas { touch-action: none; }
</style><canvasid="drawSurface"width="500px"height="500px"style="border:1px solid black;"></canvas><script>const canvas = document.getElementById("drawSurface"),
context = canvas.getContext("2d");
canvas.addEventListener("pointermove", (e)=> {
if (e.getCoalescedEvents) {
for (let coalesced_event of e.getCoalescedEvents()) {
paint(coalesced_event); // Paint all raw/non-coalesced points
}
} else {
paint(e); // Paint the final coalesced point
}
});
functionpaint(event) {
if (event.buttons>0) {
context.fillRect(event.clientX, event.clientY, 5, 5);
}
}
</script>
Note
The PointerEvent's attributes will be initialized in a way that best represents
the events in the coalesced events list. The specific method by which user agents should do this is not covered by
this specification.
The order of all these dispatched events MUST match the actual order of the original events.
For example if a pointerdown event causes the dispatch for the
coalesced pointermove events the user agentMUST first dispatch one pointermove
event with all those coalesced events of a pointerId followed by the pointerdown event.
Note
Here is an example of the actual events happening with increasing timeStamp values and the
events dispatched by the user agent:
Some user agents have built-in algorithms which, after a series of confirmed pointer movements,
can make a prediction (based on the preceding events for the current gesture, and the speed/trajectory of the movement) what
the position of future pointer movements may be. Applications can use this information with
the getPredictedEvents method to speculatively "draw ahead" to a predicted position
to reduce perceived latency, and then discarding these predicted points once the actual points
are received.
Figure 9Example of a line in a drawing application (the result of a drawing gesture from the bottom left to the top right), using the coalesced coordinates from pointermove events, showing the user agent's predicted future points (the grey circles).
A PointerEvent has an associated predicted events list (a list of zero or more
PointerEvents). For trusted pointermove events, it is a sequence of
PointerEvents that the user agent predicts will follow the event in the future.
For all other trusted event types, it is an empty list.
Untrusted events have their predicted events list initialized to the value passed to the
constructor.
When a trusted event containing a predicted events list is re-dispatched from JavaScript, the event dispatch algorithm sets the isTrusted bit of the event to false but the same bits in the predicted events list remain unchanged from their original true values.
The number of events in the list and how far they are from the current timestamp are determined by
the user agent and the prediction algorithm it uses.
The events in the predicted events list of a trusted event will have:
Monotonically increasing timeStamp values [DOM] — all predicted events have a
timeStamp that is greater than or equal to the timeStamp of the dispatched pointer event that the
getPredictedEvents method was called on. The predicted events list
MUST be chronologically sorted by timeStamp, so the first event will have the smallest timeStamp.
The same pointerId, pointerType, and isPrimary as the dispatched
"parent" pointer event.
Note that authors should only consider predicted events as valid predictions until the next pointer event is
dispatched. It is possible, depending on how far into the future the user agent predicts events, that regular
pointer events are dispatched earlier than the timestamp of one or more of the predicted events.
Example 15: Conceptual approach to drawing using coalesced events and predicted events
let predicted_points = [];
window.addEventListener("pointermove", function(event) {
// Clear the previously drawn predicted points.for (let e of predicted_points.reverse()) {
clearPoint(e.pageX, e.pageY);
}
// Draw the actual movements that happened since the last received event.for (let e of event.getCoalescedEvents()) {
drawPoint(e.pageX, e.pageY);
}
// Draw the current predicted points to reduce the perception of latency.
predicted_points = event.getPredictedEvents();
for (let e of predicted_points) {
drawPoint(e.pageX, e.pageY);
}
});
12.3 Populating and maintaining the coalesced and predicted events lists
Set the event's target to match the target of the "parent" pointer event.
13. Compatibility mapping with mouse events
The vast majority of web content existing today codes only to Mouse Events. The following describes an algorithm for how the user agentMAY map generic pointer input to mouse events for compatibility with this content.
The compatibility mapping with mouse events is an OPTIONAL feature of this specification. User agents are encouraged to support the feature for best compatibility with existing legacy content.
Note
At a high level, compatibility mouse events are intended to be "interleaved" with their respective pointer events. However, this specific order is not mandatory, and user agents that implement compatibility mouse events MAY decide to delay or group the dispatch of mouse events, as long as their relative order is consistent.
Particularly in the case of touchscreen inputs, user agents MAY apply additional heuristics for gesture recognition (unless explicitly suppressed by authors through touch-action). During a sequence of events between a pointerdown event and a pointerup event, the gesture recognition may have to wait until the pointerup event to detect or ignore a gesture. As a result the compatibility mouse events for the whole sequence may be dispatched together after the last pointerup event, if the user agent determined that an interaction was not intended as a particular gesture. These specifics of user agent gesture recognition are not defined in this specification, and they may differ between implementations.
Regardless of their support for compatibility mouse events, the user agents MUST always support the click, auxclick and contextmenu events because these events are of type PointerEvent and are therefore not compatibility mouse events. Calling preventDefault during a pointer event MUST NOT have an effect on whether click, auxclick, or contextmenu are fired or not.
Note
The relative order of some of these high-level events (such as contextmenu, focus, blur) with pointer events is undefined and varies between user agents. For example, in some user agents contextmenu will often follow a pointerup, while in others it'll often precede a pointerup or pointercancel, and in some situations it may be fired without any corresponding pointer event (for instance, as a result of a keyboard interaction).
In addition, user agents may apply their own heuristics to determine whether or not a click, auxclick, or contextmenu event should be fired. Some user agents may choose not to fire these events if there are other (non-primary) pointers of the same type, or other primary pointers of a different type. User agents may determine that a particular action was not a "clean" tap, click, or long-press (for instance, if an interaction with a finger on a touch screen includes too much movement while the finger is in contact with the screen) and decide not to fire a click, auxclick, or contextmenu event. These aspects of user agent behavior are not defined in this specification, and they may differ between implementations.
Unless otherwise noted, the target of any mapped mouse event SHOULD be the same target as the respective pointer event unless the target is no longer participating in its ownerDocument's tree. In this case, the mouse event should be fired at the original target's nearest ancestor node (at the time it was removed from the tree) that still participates in its ownerDocument's tree, meaning that a new event path (based on the new target node) is built for the mouse event.
Authors can prevent the production of certain compatibility mouse events by canceling the pointerdown event.
Mouse events can only be prevented when the pointer is down. Hovering pointers (e.g. a mouse with no buttons pressed) cannot have their mouse events prevented.
The mouseover, mouseout, mouseenter, and mouseleave events are never prevented (even if the pointer is down).
Compatibility mouse events can't be prevented when a pointer event EventListener is set to be passive [DOM].
13.1 Tracking the effective position of the legacy mouse pointer
While only primary pointers can produce compatibility mouse events, multiple primary pointers can be active simultaneously, each producing its own compatibility mouse events. For compatibility with scripts relying on MouseEvents, the mouse transition events (mouseover, mouseout, mouseenter and mouseleave) SHOULD simulate the movement of a single legacy mouse input. This means that the entry/exit state for every event target is valid, in accordance with [UIEVENTS]. User agents SHOULD guarantee this by maintaining the effective position of the legacy mouse pointer in the document as follows.
The effective position of the legacy mouse pointer models the fact that we cannot always have a direct mapping
from pointer transition events (pointerover, pointerout, pointerenter
and pointerleave) to corresponding legacy mouse transition events (mouseover,
mouseout, mouseenter and mouseleave). The following animation illustrates a case
where a user agent needs to dispatch more legacy mouse transition events than pointer transition events to be able to
reconcile two primary pointers using a single legacy mouse input.
Figure 10
Simultaneous mouse pointer (white cursor) and touch pointer (white "hand" cursor) causing the single legacy mouse input
(orange cursor) to move between the two pointers.
In this animation, note the time period between the mouse click and the touch tap. Button 1 receives no
pointerout event (because the "real" mouse pointer didn't leave the button rectangle within
this period), but Button 1 receives a mouseout event when the effective position of the
legacy mouse pointer moves to Button 2 on touch tap. Similarly, in the time period between the touch
tap and the moment before the mouse leaves Button 1, Button 1 receives no pointerover event
for the same reason, but Button 1 receives a mouseover event when the effective position
of the legacy mouse pointer moves back inside Button 1.
13.2 Mapping for devices that support hover
Whenever the user agent is to dispatch a pointer event for a device that supports hover, it SHOULD run the following steps:
If the isPrimary property for the pointer event to be dispatched is false then dispatch the pointer event and terminate these steps.
pointercancel, then fire a mouseup event at the window.
If the pointer event dispatched was pointerup or pointercancel, clear the PREVENT MOUSE EVENT flag for this pointerType.
13.3 Mapping for devices that do not support hover
Some devices, such as most touchscreens, do not support hovering a coordinate (or set of coordinates) while not in the active state. Much existing content coded to mouse events assumes that a mouse is producing the events and thus certain qualities are generally true:
The input can hover independently of activation (e.g. moving a mouse cursor without any buttons pressed).
The input will likely produce the mousemove event on an element before clicking it.
Note
Hover is sometimes used to toggle the visibility of UI elements in content designed for mouse (e.g. "hover menus"). This content is often incompatible with devices that do not support hover. This specification does not define a mapping or behavior for compatibility with this scenario. It will be considered in a future version of the specification.
This requires that user agents provide a different mapping for these types of input devices. Whenever the user agent is to dispatch a pointer event for a device that does not support hover, it SHOULD run the following steps:
If the isPrimary property for the pointer event to be dispatched is false then dispatch the pointer event and terminate these steps.
If the pointer event to be dispatched is pointerover and the pointerdown event has not yet been dispatched for this pointer, then fire a mousemove event (for compatibility with legacy mouse-specific code).
pointercancel, then fire a mouseup event at the window.
If the pointer event dispatched was pointerup or pointercancel, clear the PREVENT MOUSE EVENT flag for this pointerType.
If the user agent supports both Touch Events (as defined in [TOUCH-EVENTS]) and Pointer Events, the user agentMUST NOT generate both the compatibility mouse events as described in this section, and the fallback mouse events outlined in [TOUCH-EVENTS].
Note
The activation of an element (click) with a primary pointer that does not support hover (e.g. single finger on a touchscreen) would typically produce the following event sequence:
This appendix discusses security and privacy considerations for Pointer Events implementations. The discussion is limited to security and privacy issues that arise directly from implementation of the event model, APIs and events defined in this specification.
Many of the event types defined in this specification are dispatched in response to user actions. This allows malicious event listeners to gain access to information users would typically consider confidential, e.g., the exact path/movement of a user's mouse/stylus/finger while interacting with a page.
Pointer events contain additional information (where supported by the user's device), such as the angle or tilt at which a pen input is held, the geometry of the contact surface, and the pressure exerted on the stylus or touch screen. Information about angle, tilt, geometry and pressure are directly related to sensors on the user's device, meaning that this specification allows an origin access to these sensors.
This sensor data, as well as the ability to determine the type of input mechanism (mouse, touch, pen) used, may be used to infer characteristics of a user, or of the user's device and environment. These inferred characteristics and any device/environment information may themselves be sensitive — for instance, they may allow a malicious site to further infer if a user is using assistive technologies. This information can also be potentially used for the purposes of building a user profile and/or attempting to "fingerprint" and track a particular user.
As mitigation, user agents may consider including the ability for users to disable access to particular sensor data (such as angle, tilt, pressure), and/or to make it available only after an explicit opt-in from the user.
This specification defines the method by which authors can access "predicted events". The specification does not, itself, define the algorithms that user agents should use for their prediction. The specification authors envisage the algorithms to only rely on preceding pointer events related to the current gesture that a user is performing. It is the responsibility of user agents to ensure that their specific implementation of a prediction algorithm does not rely on any additional data - such as the user's full interaction history across different sites - that could reveal sensitive information about a user or be used to "fingerprint" and track them.
Beyond these considerations, the working group believes that this specification:
Does not expose personally-identifiable information.
Does not deal with high-value data.
Does not introduce new state for an origin that persists across browsing sessions.
Does not expose persistent, cross-origin state to the web.
Does not expose any other data to an origin that it doesn’t currently have access to.
Does not enable new script execution/loading mechanisms.
Does not allow an origin access to a user’s location.
Does not require any special handling when the user agent is in "incognito" mode.
Does not allow an origin access to other devices.
Does not allow an origin control over a user agent’s native UI.
Does not expose temporary identifiers to the web.
Does not distinguish between behavior in first-party and third-party contexts.
Does not persist data to a user’s local device.
Does not allow downgrading default security characteristics.
15. Glossary
This section is non-normative.
active buttons state
The condition when a pointer has a non-zero value for the buttons property. For mouse, this is when the device has at least one button depressed. For touch, this is when there is physical contact with the digitizer. For pen, this is when either the pen has physical contact with the digitizer, or at least one button is depressed while hovering.
active document
For every active pointer, the document that received the last event from that pointer.
active pointer
Any touch contact, pen/stylus, mouse cursor, or other pointer that can produce events. If it is possible for a given pointer (identified by a unique pointerId) to produce additional events within the document, then that pointer is still considered active. Examples:
A mouse connected to the device is always active.
A touch contact on the screen is considered active.
If a touch contact or pen/stylus is lifted beyond the range of the digitizer, then it is no longer considered active.
Note
On some platforms, the set of active pointers includes all pointer input to the device, including any that are not targeted at the user agent (e.g. those targeted at other applications).
contact geometry
The bounding box of an input (most commonly, touch) on a digitizer. This typically refers to devices with coarser pointer input resolution than a single pixel. Some devices do not report this data at all.
delta
The estimated scroll amount (in pixels, lines, or pages) that the user agent will scroll or zoom the page in response to the physical movement of an input device that supports the WheelEvent interface (such as a mouse wheel or touch pad). The value of a delta (e.g., the deltaX, deltaY, or deltaZ attributes) is to be interpreted in the context of the current deltaMode property. The relationship between the physical movement of a wheel (or other device) and whether the delta is positive or negative is environment and device dependent. However, if a user agent scrolls as the default action then the sign of the delta is given by a right-hand coordinate system where positive X,Y, and Z axes are directed towards the right-most edge, bottom-most edge, and farthest depth (away from the user) of the document, respectively.
digitizer
A type of input sensing device in which a surface can detect input which is in contact and/or in close proximity. Most commonly, this is the surface that senses input from the touch contact or a pen/stylus.
direct manipulation
Certain user agents (such as browsers on a touchscreen device) implement a "direct manipulation" metaphor where a pointer not only interacts with controls, but
is also used to directly pan or zoom the current page, providing the illusion of direct physical contact. As an example, users on a touchscreen device are generally
able to use a finger or a stylus to "grab" a page and pan it by moving the pointer, directly manipulating the page. Contrast this with a mouse pointer on a regular
desktop/laptop, where panning is done by using a scrollbar, rather than by "dragging" the page.
Note
In some cases, touchpads (like those found on a laptop) will allow the user to scroll by "dragging" on the touchpad. However, this is generally achieved
by the touchpad generating "fake" mouse wheel events, so this wouldn't count as a direct manipulation.
hysteresis
A feature of human interface design to accept input values within a certain range of location or time, in order to improve the user experience. For example, allowing for small deviation in the time it takes for a user to double-click a mouse button is temporal hysteresis, and not immediately closing a nested menu if the user mouses out from the parent window when transitioning to the child menu is locative hysteresis.
measurable properties
Measurable properties represent values relating to continuous pointer sensor data that is expressed using a real number or an
integer from a large domain. For pointer events, width, height, pressure,
tangentialPressure, tiltX, tiltY, twist,
altitudeAngle, azimuthAngle, and the [UIEVENTS] Mouse Event model properties
screenX, screenY, clientX, clientY are measurable properties.
In contrast pointerId, pointerType, isPrimary, and the
[UIEVENTS] Mouse Event model properties button, buttons, ctrlKey,
shiftKey, altKey, and metaKey are not considered measurable properties,
as they don't relate to sensor data.
pointer
A hardware-agnostic representation of input devices that can target a specific coordinate (or set of coordinates) on a screen, such as a mouse, pen, or touch contact.
rotation
An indication of incremental change on an input device using the WheelEvent interface. On some devices this MAY be a literal rotation of a wheel, while on others, it MAY be movement along a flat surface, or pressure on a particular button.
topmost event target
The topmost event targetMUST be the element highest in the rendering order which is capable of being a target. In graphical user interfaces this is the element under the user's pointing device. A user interface's hit testing facility is used to determine the target. For specific details regarding hit testing and stacking order, refer to the host language.
16. Legacy Event Initializers
This section is normative.
The following features are obsolete and should only be implemented by
user agents that require compatibility with legacy software. See also the legacy event initializers in [UIEvents].
Many thanks to lots of people for their proposals and recommendations, some of which are incorporated into this document. The group's Chair acknowledges contributions from the following past and present group members and participants:
Mustaq Ahmed,
Arthur Barstow,
Ben Boyle,
Matt Brubeck,
Rick Byers,
Marcos Cáceres,
Cathy Chan,
Bo Cupp,
Domenic Denicola,
Ted Dinklocker,
Adam Ettenberger,
Robert Flack,
Dave Fleck,
Mike Fraser,
Ella Ge,
Olga Gerchikov,
Scott González,
Kartikaya Gupta,
Dominique Hazael-Massieux,
Philippe Le Hégaret,
Hayato Ito,
Patrick Kettner,
Patrick H. Lauke,
Scott Low,
Sangwhan Moon,
Masayuki Nakano,
Olli Pettay,
Addison Phillips,
Alan Pyne,
Antoine Quint,
Jacob Rossi,
Kagami Sascha Rosylight,
Doug Schepers,
Ming-Chou Shih,
Brenton Simpson,
Dave Tapuska,
Liviu Tinta,
Asir Vedamuthu,
Lan Wei,
Jeffrey Yasskin,
Navid Zolghadr.
Thanks to those who took care of mouse and wheel events in the past:
Gary Kacmarcik,
Travis Leithead, and the various contributors over the years.
Special thanks to those that helped pioneer the first edition of this model, including especially: Charu Chandiram, Peter Freiling, Nathan Furtwangler, Thomas Olsen, Matt Rakow, Ramu Ramanathan, Justin Rogers, Jacob Rossi, Reed Townsend and Steve Wright.
