WCAG 2.5.2 · Level A · EN 301 549 9.2.5.2

Pointer Cancellation

Requires that pointer actions are not executed on the down-event, or can be aborted, undone or reversed, so mistakes can be cancelled.

In brief

People with tremors, limited dexterity or low vision often touch the wrong thing. If the action fires the instant the finger lands, there is no chance to take it back. If it fires when the finger lifts, they can slide away and cancel.

This criterion requires that for functionality that can be operated with a single pointer, at least one of four things is true: the down-event does not execute any part of the function, completion happens on the up-event and can be aborted or undone, the up-event reverses the down-event, or completing the function on the down-event is essential.

What does it cover?

  • No down-event: The function does not run on the down-event, so pressing alone does nothing. This is the standard behavior of native controls.
  • Abort or undo: The function completes on the up-event, and there is a way to abort it before completion or undo it afterwards, such as moving the pointer off the target or an undo button.
  • Up reversal: The up-event reverses the outcome of the down-event, as in press-and-hold behaviors that are undone when released.
  • Essential: Down-event activation is allowed when it is essential, for example the keys of an on-screen keyboard or piano.
  • Keyboard emulation: Functions that emulate a keyboard or numeric keypad key press are considered essential.
  • Native controls: Standard links and buttons activate on the up-event by default (G212), so using them meets the criterion with no extra work.
  • Out of scope: Actions needed to operate the browser or assistive technology are not covered. Drag operations are covered by 2.5.7. Gestures are covered by 2.5.1.

Who does it affect?

People with tremors or limited dexterity, who often press the wrong control. People with low vision or cognitive disabilities who press a control by mistake. People using touch screens, trackballs or head pointers, where accidental contact is common. Anyone who touches a control and then realises it was the wrong one.

In the EAA and EN 301 549

The European Accessibility Act (Directive (EU) 2019/882) applies to in-scope products and services placed on the market after 28 June 2025. Recital 47 names four principles for websites and mobile applications: perceivable, operable, understandable and robust. Protection against accidental activation is part of "operable".

The technical counterpart is the standard EN 301 549, which incorporates WCAG 2.5.2 by reference and turns it into separate clauses for each kind of ICT.

Where WCAG 2.5.2 appears in EN 301 549
ClauseType of ICTWhat it requires
9.2.5.2Web pagesWeb content must satisfy WCAG success criterion 2.5.2.
10.2.5.2Non-web documents (PDF, Office files)Documents must meet the same rule where the standard applies the criterion to them.
11.2.5.2Non-web software (native mobile apps)Software must let users cancel a pointer action before it is completed.

Whether and how the criterion applies to non-web documents is stated in clause 10 of the standard. Clause numbers follow the "9. + WCAG number" pattern of EN 301 549. In V3.2.1 the software clause is divided into further subclauses for open and closed functionality. Check the exact numbers in the standard when you cite them.

Standard version: EN 301 549 V4.1.1 (September 2026) is based on WCAG 2.2 and is the first version prepared specifically for the EAA. It has not yet been cited in the Official Journal of the European Union, so for now it is best treated as a voluntary technical route to the EAA's requirements. Once cited, it will give a presumption of conformity. The text of criterion 2.5.2 is the same in WCAG 2.1 and 2.2.

A note on EAA scope: Article 2(4) of the Directive excludes certain content from the requirements, for example office file formats published before 28 June 2025 and archives that are not updated after that date. Content you publish or change after that date is not covered by these exclusions.

Directive (EU) 2019/882, EUR-Lex, opens in a new tab

Code examples for the web

1. Use the click event

click fires on the up-event and also works with keyboard and touch. It is the simplest way to comply.

Incorrect
<div onmousedown="buy()">Buy now</div>
Correct
<button type="button" onclick="buy()">Buy now</button>

2. Do not execute on pointerdown or touchstart

Running the action on the down-event leaves no chance to cancel.

Incorrect
btn.addEventListener("pointerdown", submitOrder);
Correct
btn.addEventListener("click", submitOrder); // fires on release

3. Make drag and drop cancellable

Let users abort a drag, for example by pressing Escape or by dropping the item back in its original place (G210).

Incorrect
document.addEventListener("pointerup", dropItem); // no way to cancel
Correct
let dragging = false;
document.addEventListener("keydown", e => {
  if (e.key === "Escape" && dragging) { cancelDrag(); dragging = false; }
});
document.addEventListener("pointerup", () => {
  if (dragging) { dropItem(); dragging = false; }
});

4. Offer undo after a destructive action

If the action completes on the up-event, an undo option is an acceptable safety net.

Incorrect
deleteBtn.addEventListener("click", () => remove(item)); // gone for good
Correct
deleteBtn.addEventListener("click", () => {
  remove(item);
  showToast("Item deleted", { action: "Undo", onAction: () => restore(item) });
});

5. Up reversal

If something happens on the down-event, make the up-event reverse it. For example a preview shown while the button is held, hidden on release.

Incorrect
btn.addEventListener("pointerdown", () => openPreview()); // stays open
Correct
btn.addEventListener("pointerdown", () => showPreview());
btn.addEventListener("pointerup",   () => hidePreview());

6. On-screen keyboard keys

A virtual keyboard key may act on the down-event, because it emulates a key press, which is essential.

Incorrect
/* Using the down-event for an ordinary button */
Correct
key.addEventListener("pointerdown", () => typeCharacter(key.dataset.char));
// Emulates a key press, so the down-event is acceptable here

Code examples for mobile

On mobile, standard buttons fire when the finger lifts inside the control, so a user can slide off to cancel. Custom touch handlers that fire on touch-down break this.

iOS (SwiftUI)

import SwiftUI

struct BuyButton: View {
    var body: some View {
        // Button fires on touch-up inside, so sliding the finger away cancels it
        Button("Buy now") { buy() }

        // Avoid: acting on the first touch
        // Text("Buy now").gesture(DragGesture(minimumDistance: 0).onChanged { _ in buy() })
    }
}

Android (Jetpack Compose)

import androidx.compose.foundation.clickable
import androidx.compose.material3.Button
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier

@Composable
fun BuyButton() {
    // Button and clickable fire on release, so sliding off cancels the action
    Button(onClick = { buy() }) { Text("Buy now") }

    // Avoid: pointerInput { detectTapGestures(onPress = { buy() }) }
    // onPress runs on the down-event.
}

How to test

  • Press and slide away: Press a control, move off it and release. Does the action not run?
  • Press and hold: Hold a control down without releasing. Does anything happen on the press alone?
  • Check the code: Search for mousedown, pointerdown, touchstart and onPress handlers that execute a function.
  • Check drag and drop: Can a drag be cancelled, or an item returned to its place? Is there an undo?
  • Check destructive actions: If an action completes on release, is there a confirmation or an undo?
  • Check the exceptions: Is a down-event action genuinely essential, such as a virtual keyboard key?
  • Check mobile: Touch down on a control and slide away. Is the action cancelled?
  • Use a checker as a starting point: Automated tools cannot see which event runs an action. A person must test and read the code.

Common mistakes

  • Using mousedown or touchstart for buttons: The classic failure (F101).
  • Custom controls instead of button: You lose the native up-event behaviour.
  • Drag and drop that cannot be cancelled: A wrong drop is permanent.
  • Delete with no undo: It fires on release, but nothing brings the item back.
  • Confusing down-event essential with convenience: Speed is not a reason, unless it is a keyboard emulation.
  • Menus that act on pointer down: They commit a choice before the user lifts.
  • Gesture libraries with touch-start defaults: Check their defaults.
  • Forgetting hover and focus: Only the pointer down-event is covered, but mixing handlers causes accidents.

Sources

Standard version: EN 301 549 V4.1.1 (2026-09), WCAG 2.2. This page is for informational purposes only and is not legal advice. For binding requirements, refer to the official texts of the European Accessibility Act (Directive (EU) 2019/882) and EN 301 549.

Corpowid is recognized by Gartner

Corpowid has been recognized by Gartner, a leading global research and advisory firm, for our innovation and performance in digital accessibility. These badges reflect our commitment to creating inclusive, AI-powered web experiences.

Have questions about Corpowid?

Let’s connect.

We will get back to you as soon as possible.