Core Accessibility API Mappings 1.2

W3C Candidate Recommendation Draft

More details about this document
This version:
https://www.w3.org/TR/2023/CRD-core-aam-1.2-20230518/
Latest published version:
https://www.w3.org/TR/core-aam-1.2/
Latest editor's draft:
https://w3c.github.io/core-aam/
History:
https://www.w3.org/standards/history/core-aam-1.2
Commit history
Implementation report:
https://w3c.github.io/test-results/core-aam-1.2/
Latest Recommendation:
https://www.w3.org/TR/core-aam-1.1/
Editors:
Valerie Young (Igalia, S.L.)
Alexander Surkov (Igalia, S.L.)
Michael Cooper (W3C)
Former editors:
Joanmarie Diggs (Igalia, S.L.) (Editor until October 2022)
Richard Schwerdtfeger (Knowbility) (Editor until October 2017)
Joseph Scheuhammer (Inclusive Design Research Centre, OCAD University) (Editor until May 2017)
Andi Snow-Weaver (IBM) (Editor until December 2012)
Aaron Leventhal (IBM) (Editor until January 2009)
Platform Mapping Maintainers:
Benjamin Beaudry (Microsoft Corp.) (UIA)
James Craig (Apple, Inc.) (AX API)
Joanmarie Diggs (Igalia, S.L.) (ATK / AT-SPI)
Alexander Surkov (Igalia, S.L.) (MSAA, IAccessible2)
Feedback:
GitHub w3c/core-aam (pull requests, new issue, open issues)

Copyright © 2014-2023 World Wide Web Consortium. W3C® liability, trademark and permissive document license rules apply.

Abstract

This document describes how user agents should expose semantics of web content languages to accessibility APIs. This helps users with disabilities to obtain and interact with information using assistive technologies. Documenting these mappings promotes interoperable exposure of roles, states, properties, and events implemented by accessibility APIs and helps to ensure that this information appears in a manner consistent with author intent.

This Core Accessibility API Mappings specification defines support that applies across multiple content technologies, including general keyboard navigation support and mapping of general-purpose roles, states, and properties provided in Web content via WAI-ARIA [WAI-ARIA-1.2]. Other Accessibility API Mappings specifications depend on and extend this Core specification for specific technologies, including native technology features and WAI-ARIA extensions. This document updates and will eventually supersede the guidance in the Core Accessibility API Mappings 1.1 [CORE-AAM-1.1] W3C Recommendation. It is part of the WAI-ARIA suite described in the WAI-ARIA Overview.

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 technical reports index at https://www.w3.org/TR/.

The Accessible Rich Internet Applications Working Group seeks feedback on any aspect of the specification. When submitting feedback, please consider issues in the context of the companion documents. To comment, file an issue in the W3C core-aam GitHub repository. If this is not feasible, send email to public-aria@w3.org (comment archive). In-progress updates to the document may be viewed in the publicly visible editors' draft.

This document was published by the Accessible Rich Internet Applications Working Group as a Candidate Recommendation Draft using the Recommendation track.

Publication as a Candidate Recommendation does not imply endorsement by W3C and its Members. A Candidate Recommendation Draft integrates changes from the previous Candidate Recommendation that the Working Group intends to include in a subsequent Candidate Recommendation Snapshot.

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 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 which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.

This document is governed by the 2 November 2021 W3C Process Document.

1. Introduction

This section is non-normative.

The Core Accessibility API Mappings specifies how WAI-ARIA roles, states, and properties are expected to be exposed by user agents via platform accessibility APIs. It is part of a set of resources that define and support the WAI-ARIA specification which includes the following documents:

For an introduction to WAI-ARIA, see the WAI-ARIA Overview.

1.1 Accessibility APIs

Accessibility APIs make it possible to communicate accessibility information about user interfaces to assistive technologies. This information includes:

  1. Descriptive properties (role, name, value, position, etc.)
  2. Transient states (pressed, focused, etc.)
  3. Events (text changed, button was clicked, checkbox was toggled)
  4. Actions the user might take (click, check/toggle, drag, etc.)
  5. Relationships (parent/child, description/described object, previous object/next object, etc.)
  6. Textual content

Accessibility APIs covered by this specification are:

The WAI-ARIA 1.0 User Agent Implementation Guide included mappings for [UIA-EXPRESS], also known as IAccessibleEx, which was implemented in Microsoft Internet Explorer 8.0 - 11. New implementations are strongly encouraged to use UI Automation instead.

If user agent developers need to expose information using other accessibility APIs, it is recommended that they work closely with the developer of the platform where the API runs, and assistive technology developers on that platform.

1.2 Comparing Accessibility APIs

For various technological and historical reasons, accessibility APIs do not all work in the same way. In many cases, there is no simple one-to-one relationship between how each of them names or exposes roles, states, and properties to user agents. The following subsections describe a few of the distinguishing characteristics of some of the APIs.

1.2.1 ATK/AT-SPI

MSAA, IAccessible2, UIA, and AX API each define an API that is shared by both the software application exposing information about its content and interactive components, and the user agent (assistive technology) consuming that information. Conversely, Linux/GNOME separates that shared interface into its two aspects, each represented by a different accessibility API: ATK or AT-SPI.

ATK defines an interface that is implemented by software in order to expose accessibility information, whereas AT-SPI is a desktop service that gathers accessibility information from active applications and relays it to other interested applications, usually assistive technologies.

For example, the GNOME GUI toolkit [GTK], implements the relevant aspects of ATK for each widget (menu, combobox, checkbox, etc.) in order that GTK widgets expose accessibility information about themselves. AT-SPI then acquires the information from applications built with GTK and makes it available to interested parties.

ATK is most relevant to implementors, whereas AT-SPI is relevant to consumers. In the context of mapping WAI-ARIA roles, states and properties, user agents are implementors and use ATK. Assistive Technologies are consumers, and use AT-SPI.

1.2.2 UIA (UI Automation)

UI Automation expresses every element of the application user interface as an automation element. Automation elements form the nodes of the application accessibility tree, that can be queried, traversed and interacted with by automation clients.

There are several concepts central to UI Automation:

  • Automation element - controls and some application content are presented as automation elements.
  • Element properties - Automation elements have several common properties describing native framework element characteristics in an agnostic way that all automation clients can understand. There are several ways to access element property values, described below.
  • Control Patterns - Some common interactivity in different frameworks is expressed as control patterns in UIA, allowing different automation clients to interact with controls using common programmatic interfaces.
  • Events - Similar to other accessibility APIs, automation elements support various events that allow automation providers to notify clients on important state changes.

All automation elements inherit from the IUIAutomationElement interface and all properties that are not specific to a particular control pattern can be queried through that interface. There are several ways to access UI Automation element properties:

  • Direct property accessors to the current values - Current{PropertyName}, e.g. IUIAutomationElement::CurrentName for the Name property
  • Cached property accessors - Cached{PropertyName}, e.g. IUIAutomationElement::CachedName for the Name property. Using cached values is preferred when providers and clients are used in remote environments.
  • GetCurrentPropertyValue and passing the UIA Property ID enumeration value corresponding to that property to get the current value, e.g. IUIAutomationElement::GetCurrentPropertyValue(UIA_NamePropertyId) for the Name property.
  • GetCachedPropertyValue and passing the UIA Property ID enumeration value corresponding to that property to get the cached value, e.g. IUIAutomationElement::GetCachedPropertyValue(UIA_NamePropertyId) for the Name property.

Properties for specific UIA control patterns are queried the same way using relevant control pattern interfaces. Taking Toggle Pattern as an example, to query the ToggleState property clients can use IUIAutomationTogglePattern::CurrentToggleState or IUIAutomationTogglePattern::GetCurrentPropertyValue(UIA_ToggleToggleStatePropertyId) to get the current value.

The property mappings in this specification provide the {PropertyName} and do not specify all specific ways to access the property value. Automation clients can access current or cached values using conventions described above, depending on specific needs and coding style conventions.

1.2.3 Accessible Names and Descriptions

Each platform accessibility API includes a way to assign and retrieve accessible name and accessible description properties for each accessible object created in the accessibility tree. How these properties are implemented and what they are called vary depending on the API.

For instance, in MSAA, all accessible objects support the accName property, which stores the object's accessible name. Where the object also supports having an accessible description, MSAA stores this property in the object's accDescription property.

Software using ATK can read and write to an object's accessible-name and accessible-description properties. In turn, AT-SPI can query the values of those properties through its atspi_accessible_get_name and atspi_accessible_get_description functions.

Automation elements in the UIA accessibility tree have a Name property. Where the object also supports having an accessible description, UIA stores this property in the object's FullDescription property.

The approach to accessible names and accessible descriptions in AX API is somewhat different to the other platform APIs. Accessible names are exposed using the AXTitle property when the name is visually rendered, while the AXDescription property is used when the object's name is not rendered visually. An object's accessible description, where provided by aria-description or aria-describedby, should be exposed in the accessibilityCustomContent API. Otherwise, it should be exposed as AXHelp.

For more detail, see the Accessible Name and Description Computation specification.

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, SHOULD, and SHOULD NOT 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.

2.1 RFC-2119 Keywords

RFC-2119 keywords are formatted in uppercase and contained in a strong element with class="rfc2119". When the keywords shown above are used, but do not share this format, they do not convey formal information in the RFC 2119 sense, and are merely explanatory, i.e., informative. As much as possible, such usages are avoided in this specification.

2.2 Normative and Informative Sections

The indication whether a section is normative or non-normative (informative) applies to the entire section including sub-sections.

Informative sections provide information useful to understanding the specification. Such sections may contain examples of recommended practice, but it is not required to follow such recommendations in order to conform to this specification.

2.3 Features Deprecated in WAI-ARIA

The WAI-ARIA specification lists some features as deprecated. Although this means authors are encouraged not to use such features, it is expected that the features could still be used in legacy content. Therefore, it is important that user agents continue to map these features to accessibility APIs, and doing so is part of conformance to this specification. When future versions of the WAI-ARIA specification change such features from deprecated to removed, they will be removed from the mappings as well and user agents will no longer be asked to continue support for those features.

3. Important Terms

This section is non-normative.

While some terms are defined in place, the following definitions are used throughout this document.

Accessibility Subtree

An accessible object in the accessibility tree and its descendants in that tree. It does not include objects which have relationships other than parent-child in that tree. For example, it does not include objects linked via aria-flowto unless those objects are also descendants in the accessibility tree.

Activation behavior

The action taken when an event, typically initiated by users through an input device, causes an element to fulfill a defined role. The role may be defined for that element by the host language, or by author-defined variables, or both. The role for any given element may be a generic action, or may be unique to that element. For example, the activation behavior of an HTML or SVG <a> element shall be to cause the user agent to traverse the link specified in the href attribute, with the further optional parameter of specifying the browsing context for the traversal (such as the current window or tab, a named window, or a new window); the activation behavior of an HTML <input> element with the type attribute value submit shall be to send the values of the form elements to an author-defined IRI by the author-defined HTTP method.

4. Mapping WAI-ARIA to Accessibility APIs

4.1 General rules for exposing WAI-ARIA semantics

Where supported by the platform Accessibility API, user agents expose WAI-ARIA semantics through the standard mechanisms of the desktop accessibility API. For example, for WAI-ARIA widgets, compare how the widget is exposed in a similar desktop widget. In general most WAI-ARIA widget capabilities are exposed through the role, value, Boolean states, and relations of the accessibility API.

With respect to WAI-ARIA 1.0 and 1.1, accessibility APIs operate in one direction only. User agents publish WAI-ARIA information (roles, states, and properties) via an accessibility API, and an AT can acquire that information using the same API. However, the other direction is not supported. WAI-ARIA 1.0 and 1.1 do not define mechanisms for assistive technologies to directly modify WAI-ARIA information.

The terms "exposing", "mapping", and "including" refer to the creation of accessible object nodes within the accessibility tree, and populating these objects with Accessibility API specific states and properties.

4.2 Conflicts between native markup semantics and WAI-ARIA

WAI-ARIA roles, states, and properties are intended to add semantic information when native host language elements with these semantics are not available, and are generally used on elements that have no native semantics of their own. They can also be used on elements that have similar but not identical semantics to the intended object (for instance, a nested list could be used to represent a tree structure). This method can be part of a fallback strategy for older browsers that have no WAI-ARIA implementation, or because native presentation of the repurposed element reduces the amount of style and/or script needed. Except for the cases outlined below, user agents MUST always use the WAI-ARIA semantics to define how it exposes the element to accessibility APIs, rather than using the host language semantics.

Host languages can have features that have implicit WAI-ARIA semantics corresponding to roles. When a WAI-ARIA role is provided that has a corresponding role in the accessibility API, user agents MUST use the semantic of the WAI-ARIA role for processing, not the native semantic, unless the role requires WAI-ARIA states and properties whose attributes are explicitly forbidden on the native element by the host language. Values for roles do not conflict in the same way as values for states and properties, and because authors are expected to have a valid reason to provide a WAI-ARIA role even on elements that would not normally be repurposed. For example, spin buttons are typically constructed from text fields (<input type="text">) in order to get most of the default keyboard support. But, the native role, "text field", is not correct because it does not properly communicate the additional features of a spin button. The author adds the WAI-ARIA role of spinbutton (<input type="text" role="spinbutton" ...>) so that the control is properly mapped in the accessibility API. When a WAI-ARIA role is provided that does not have a corresponding role in the accessibility API, user agents MAY expose the native semantic in addition to the WAI-ARIA role. If the host language element is overridden by a WAI-ARIA role whose semantics or structure is not equivalent to the native host language semantics or to a subclass of those semantics, then treat any required owned elements of the native role as having role presentation or none.

Note

The above text differs slightly from the WAI-ARIA specification. The requirement for user agents to expose the WAI-ARIA role instead of the native role was intended to only apply in cases where there is a direct mapping from the WAI-ARIA role to a corresponding role in the accessibility API. The wording of the requirement is not clear in the WAI-ARIA specification, however, and has been interpreted differently by implementers. The requirement has been clarified here and an additional statement added to indicate that user agents may expose native semantics if there is not a direct mapping to a role in the accessibility API. Because there are differing implementations, authors will be advised against adding such WAI-ARIA roles to native elements that have their own semantics in the WAI-ARIA Authoring Practices Guide.

When WAI-ARIA states and properties correspond to host language features that have the same implicit WAI-ARIA semantic, it can be problematic if the values become out of sync. For example, the HTML checked attribute and the aria-checked attribute could have conflicting values. Therefore to prevent providing conflicting states and properties to assistive technologies, host languages will explicitly declare where the use of WAI-ARIA attributes on a host language element conflict with native attributes for that element. When a host language declares a WAI-ARIA attribute to be in direct semantic conflict with a native attribute for a given element, user agents MUST ignore the WAI-ARIA attribute and instead use the host language attribute with the same implicit semantic.

Host languages might also document features that cannot be overridden with WAI-ARIA (these are called "strong native semantics"). These can be features that have implicit WAI-ARIA semantics as well as features where the processing would be uncertain if the semantics were changed with WAI-ARIA. While conformance checkers might signal an error or warning when a WAI-ARIA role is used on elements with strong native semantics, user agents MUST still use the value of the semantic of the WAI-ARIA role when exposing the element to accessibility APIs.

4.3 Exposing attributes that do not directly map to accessibility API properties

Platform accessibility APIs might have features that are not in WAI-ARIA. Likewise, WAI-ARIA exposes capabilities that are not supported by accessibility APIs at the time of publication. There typically is not a one to one relationship between all WAI-ARIA attributes and platform accessibility APIs. When WAI-ARIA roles, states and properties do not directly map to an accessibility API, and there is a mechanism in the API to expose the WAI-ARIA role, states, and properties and their values, user agents MUST expose the WAI-ARIA data using that mechanism as follows:

Note

MSAA does not provide a mechanism for exposing attributes that do not map directly to the API and among implementers, there is no agreement on how to do it.

User agents MUST also expose the entire role string through this mechanism and MAY also expose WAI-ARIA attributes and values through this mechanism even when there is a direct mapping to an accessibility API.

Browser implementers are advised to publicly document their API methods for exposing any relevant information, so that assistive technology developers can use the API to support user features.

4.4 Role mapping

Platform accessibility APIs traditionally have had a finite set of predefined roles that are expected by assistive technologies on that platform and only one or two roles may be exposed. In contrast, WAI-ARIA allows multiple roles to be specified as an ordered set of space-separated valid role tokens. The additional roles are fallback roles similar to the concept of specifying multiple fonts in case the first choice font type is not supported.

4.4.1 General rules

User agents MUST expose the WAI-ARIA role string if the API supports a mechanism to do so. This allows assistive technologies to do their own additional processing of roles.

  • MSAA: not supported. User agents SHOULD NOT expose a custom role in MSAA's accRole property.
  • IAccessible2: expose as an object attribute pair (xml-roles:"string")
  • UIA: expose as AriaRole property. The AriaRole property can also support secondary roles using a space as a separator.
  • ATK/AT-SPI: expose as an object attribute pair (xml-roles:"string")

4.4.2 Computed Role

The computed role of an element is a string that represents the role of the element for the purposes of specification comformance testing. When an element has a role but is not contained in the required context (for example, a role listitem used on an element outside of a list), the computed role of the element is unspecified.

Note

User agents can provide this role string, for example, in response to the WebDriver function getComputedRole.

4.4.3 Role Mapping Table

Note

Translators: For label text associated with the following table and its toggle buttons, see the mappingTableLabels object in the <head> section of this document.

alert
alert
Computed Role

alert

MSAA + IAccessible2 Role: ROLE_SYSTEM_ALERT
Event: The user agent SHOULD fire EVENT_SYSTEM_ALERT. [Note 2]
UIA Control Type: Group
Localized Control Type: alert
LiveSetting: Assertive (2)
Event: The user agent SHOULD fire a system alert event. [Note 2]
ATK/AT-SPI Role: ROLE_NOTIFICATION
Event: The user agent SHOULD fire a system alert event. [Note 2]
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXApplicationAlert
Event: The user agent SHOULD fire a system alert event. [Note 2]
alertdialog
alertdialog
Computed Role

alertdialog

MSAA + IAccessible2 Role: ROLE_SYSTEM_DIALOG
Event: The user agent SHOULD fire EVENT_SYSTEM_ALERT. [Note 2]
UIA Control Type: Pane
Event: The user agent SHOULD fire a system alert event. [Note 2]
ATK/AT-SPI Role: ROLE_ALERT
Interface: Window
Event: The user agent SHOULD fire a system alert event. [Note 2]
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXApplicationAlertDialog
Event: The user agent SHOULD fire a system alert event. [Note 2]
application
application
Computed Role

application

MSAA + IAccessible2 Role: ROLE_SYSTEM_APPLICATION
UIA Control Type: Pane
Localized Control Type: application
ATK/AT-SPI Role: ROLE_EMBEDDED
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXWebApplication
article
article
Computed Role

article

MSAA + IAccessible2 Role: ROLE_SYSTEM_DOCUMENT
State: STATE_SYSTEM_READONLY
Object Attribute: xml-roles:article
UIA Control Type: Group
Localized Control Type: article
ATK/AT-SPI Role: ROLE_ARTICLE
Object Attribute: xml-roles:article
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXDocumentArticle
banner
banner
Computed Role

banner

MSAA + IAccessible2 Role: IA2_ROLE_LANDMARK
Object Attribute: xml-roles:banner
UIA Control Type: Group
Localized Control Type: banner
Landmark Type: Custom
Localized Landmark Type: banner
ATK/AT-SPI Role: ROLE_LANDMARK
Object Attribute: xml-roles:banner
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXLandmarkBanner
blockquote
blockquote
Computed Role

blockquote

MSAA + IAccessible2 Role: ROLE_SYSTEM_GROUPING
Role: IA2_ROLE_BLOCK_QUOTE
UIA Control Type: Group
Localized Control Type: blockquote
ATK/AT-SPI Role: ROLE_BLOCK_QUOTE
AX API[Note 1] AXRole: AXGroup
AXSubrole: <nil>
button with default values for aria-pressed and aria-haspopup
button with default values for aria-pressed and aria-haspopup
Computed Role

button

MSAA + IAccessible2 Role: ROLE_SYSTEM_PUSHBUTTON
UIA Control Type: Button
ATK/AT-SPI Role: ROLE_PUSH_BUTTON
AX API[Note 1] AXRole: AXButton
AXSubrole: <nil>
button with non-false value for aria-haspopup
button with non-false value for aria-haspopup
Computed Role

button

MSAA + IAccessible2 Role: ROLE_SYSTEM_BUTTONMENU
UIA Control Type: Button
ATK/AT-SPI Role: ROLE_PUSH_BUTTON
AX API[Note 1] AXRole: AXPopUpButton
AXSubrole: <nil>
button with defined value for aria-pressed
button with defined value for aria-pressed
Computed Role

button

MSAA + IAccessible2 Role: ROLE_SYSTEM_PUSHBUTTON
Role: IA2_ROLE_TOGGLE_BUTTON
UIA Control Type: Button
ATK/AT-SPI Role: ROLE_TOGGLE_BUTTON
AX API[Note 1] AXRole: AXCheckBox
AXSubrole: AXToggle
caption
caption
Computed Role

caption

MSAA + IAccessible2 Role: ROLE_SYSTEM_GROUPING
Role: IA2_ROLE_CAPTION
UIA Control Type: Text
ATK/AT-SPI Role: ROLE_CAPTION
AX API[Note 1] AXRole: AXGroup
AXSubrole: <nil>
cell
cell
Computed Role

cell

MSAA + IAccessible2 Role: ROLE_SYSTEM_CELL
Interface: IAccessibleTableCell
UIA Control Type: DataItem
Localized Control Type: item
Control Pattern: GridItem
Control Pattern: TableItem
ATK/AT-SPI Role: ROLE_TABLE_CELL
Interface: TableCell
AX API[Note 1] AXRole: AXCell
AXSubrole: <nil>
checkbox
checkbox
Computed Role

checkbox

MSAA + IAccessible2 Role: ROLE_SYSTEM_CHECKBUTTON
See also: aria-checked in the State and Property Mapping Table
UIA Control Type: Checkbox
See also: aria-checked in the State and Property Mapping Table
ATK/AT-SPI Role: ROLE_CHECK_BOX
See also: aria-checked in the State and Property Mapping Table
AX API[Note 1] AXRole: AXCheckBox
AXSubrole: <nil>
See also: aria-checked in the State and Property Mapping Table
code
code
Computed Role

code

MSAA + IAccessible2 Role: IA2_ROLE_TEXT_FRAME
Object Attribute: xml-roles:code
UIA Control Type: Text
Localized Control Type: code
ATK/AT-SPI Role: ROLE_STATIC
Object Attribute: xml-roles:code
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXCodeStyleGroup
columnheader
columnheader
Computed Role

columnheader

MSAA + IAccessible2 Role: ROLE_SYSTEM_COLUMNHEADER
Interface: IAccessibleTableCell
UIA Control Type: DataItem
Localized Control Type: column header
Control Pattern: GridItem
Control Pattern: TableItem
ATK/AT-SPI Role: ROLE_COLUMN_HEADER
Interface: TableCell
AX API[Note 1] AXRole: AXCell
AXSubrole: <nil>
combobox
combobox
Computed Role

combobox

MSAA + IAccessible2 Role: ROLE_SYSTEM_COMBOBOX
State: STATE_SYSTEM_HASPOPUP
State: STATE_SYSTEM_COLLAPSED if aria-expanded is not "true"
UIA Control Type: Combobox
ATK/AT-SPI Role: ROLE_COMBO_BOX
State: STATE_EXPANDABLE
State: STATE_HAS_POPUP
AX API[Note 1] AXRole: AXComboBox
AXSubrole: <nil>
comment
comment
Computed Role

comment

MSAA + IAccessible2 Role: IA2_ROLE_COMMENT
Object Attribute: xml-roles:comment
UIA Control Type: Group
Localized Control Type: comment
ATK/AT-SPI Role: ROLE_COMMENT
Object Attribute: xml-roles:comment
AX API[Note 1] AXRole: AXGroup
complementary
complementary
Computed Role

complementary

MSAA + IAccessible2 Role: IA2_ROLE_LANDMARK
Object Attribute: xml-roles:complementary
UIA Control Type: Group
Localized Control Type: complementary
Landmark Type: Custom
Localized Landmark Type: complementary
ATK/AT-SPI Role: ROLE_LANDMARK
Object Attribute: xml-roles:complementary
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXLandmarkComplementary
contentinfo
contentinfo
Computed Role

contentinfo

MSAA + IAccessible2 Role: IA2_ROLE_LANDMARK
Object Attribute: xml-roles:contentinfo
UIA Control Type: Group
Localized Control Type: content information
Landmark Type: Custom
Localized Landmark Type: content information
ATK/AT-SPI Role: ROLE_LANDMARK
Object Attribute: xml-roles:contentinfo
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXLandmarkContentInfo
definition
definition
Computed Role

definition

MSAA + IAccessible2 Object Attribute: xml-roles:definition
UIA Control Type: Group
Localized Control Type: definition
ATK/AT-SPI Role: ROLE_DESCRIPTION_VALUE
Object Attribute: xml-roles:definition
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXDefinition
deletion
deletion
Computed Role

deletion

MSAA + IAccessible2 Role: IA2_ROLE_CONTENT_DELETION
UIA Control Type: Text
Localized Control Type: deletion
ATK/AT-SPI Role: ROLE_CONTENT_DELETION
Object Attribute: xml-roles:deletion
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXDeleteStyleGroup
AXAttributedStringForTextMarkerRange: contains AXIsSuggestedDeletion = 1; for all text contained in a deletion
dialog
dialog
Computed Role

dialog

MSAA + IAccessible2 Role: ROLE_SYSTEM_DIALOG
UIA Control Type: Pane
ATK/AT-SPI Role: ROLE_DIALOG
Interface: Window
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXApplicationDialog
directory
directory
Computed Role

list

MSAA + IAccessible2 Role: ROLE_SYSTEM_LIST
UIA Control Type: List
ATK/AT-SPI Role: ROLE_LIST
AX API[Note 1] AXRole: AXList
AXSubrole: AXContentList
document
document
Computed Role

document

MSAA + IAccessible2 Role: ROLE_SYSTEM_DOCUMENT
State: STATE_SYSTEM_READONLY
UIA Control Type: Document
ATK/AT-SPI Role: ROLE_DOCUMENT_FRAME
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXDocument
emphasis
emphasis
Computed Role

emphasis

MSAA + IAccessible2 Role: IA2_ROLE_TEXT_FRAME
Object Attribute: xml-roles:emphasis
UIA Control Type: Text
Localized Control Type: emphasis
ATK/AT-SPI Role: ROLE_STATIC
Object Attribute: xml-roles:emphasis
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXEmphasisStyleGroup
feed
feed
Computed Role

feed

MSAA + IAccessible2 Role: ROLE_SYSTEM_GROUPING
Object Attribute: xml-roles:feed
UIA Control Type: Group
Localized Control Type: feed
ATK/AT-SPI Role: ROLE_PANEL
Object Attribute: xml-roles:feed
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXApplicationGroup
figure
figure
Computed Role

figure

MSAA + IAccessible2 Role: ROLE_SYSTEM_GROUPING
Object Attribute: xml-roles:figure
UIA Control Type: Group
Localized Control Type: figure
ATK/AT-SPI Role: ROLE_PANEL
Object Attribute: xml-roles:figure
AX API[Note 1] AXRole: AXGroup
AXSubrole: <nil>
form with an accessible name
form with an accessible name
Computed Role

form

MSAA + IAccessible2 Role: IA2_ROLE_FORM
Object Attribute: xml-roles:form
UIA Control Type: Group
Localized Control Type: form
Landmark Type: Form
ATK/AT-SPI Role: ROLE_LANDMARK
Object Attribute: xml-roles:form
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXLandmarkForm
form without an accessible name
form without an accessible name
Computed Role

form

MSAA + IAccessible2 Do not expose the element as a landmark. Use the native host language role of the element instead.
UIA Do not expose the element as a landmark. Use the native host language role of the element instead.
ATK/AT-SPI Do not expose the element as a landmark. Use the native host language role of the element instead.
AX API[Note 1] Do not expose the element as a landmark. Use the native host language role of the element instead.
generic
generic
Computed Role

generic

MSAA + IAccessible2 Role: ROLE_SYSTEM_GROUPING
Role: IA2_ROLE_SECTION
UIA Control Type: Group
ATK/AT-SPI Role: ROLE_SECTION
AX API[Note 1] AXRole: AXGroup
AXSubrole: <nil>
grid
grid
Computed Role

grid

MSAA + IAccessible2 Role: ROLE_SYSTEM_TABLE
Object Attribute: xml-roles:grid
Interface: IAccessibleTable2
Method: IAccessible::accSelect()
Method: IAccessible::get_accSelection()
UIA Control Type: DataGrid
Control Pattern: Grid
Control Pattern: Table
Control Pattern: Selection
ATK/AT-SPI Role: ROLE_TABLE
Object Attribute: xml-roles:grid
Interface: Table
Interface: Selection

Because WAI-ARIA does not support modifying the selection via the accessibility API, user agents MUST return false for all Selection methods that provide a means to modify the selection.

AX API[Note 1] AXRole: AXTable
AXSubrole: <nil>
AXColumnHeaderUIElements: a list of pointers to the columnheader elements
AXHeader: a pointer to the row or group containing those columnheader elements
AXRowHeaderUIElements: a list of pointers to the rowheader elements
gridcell
gridcell
Computed Role

gridcell

MSAA + IAccessible2 Role: ROLE_SYSTEM_CELL
Interface: IAccessibleTableCell
UIA Control Type: DataItem
Localized Control Type: item
Control Pattern: SelectionItem
Control Pattern: GridItem
Control Pattern: TableItem
SelectionItem.SelectionContainer: the containing grid
ATK/AT-SPI Role: ROLE_TABLE_CELL
Interface: TableCell
AX API[Note 1] AXRole: AXCell
AXSubrole: <nil>
group
group
Computed Role

group

MSAA + IAccessible2 Role: ROLE_SYSTEM_GROUPING
UIA Control Type: Group
ATK/AT-SPI Role: ROLE_PANEL
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXApplicationGroup
heading
heading
Computed Role

heading

MSAA + IAccessible2 Role: IA2_ROLE_HEADING
Object Attribute: xml-roles:heading
UIA Control Type: Text
Localized Control Type: heading
ATK/AT-SPI Role: ROLE_HEADING
AX API[Note 1] AXRole: AXHeading
AXSubrole: <nil>
img
img
Computed Role

image

MSAA + IAccessible2 Role: ROLE_SYSTEM_GRAPHIC
Interface: IAccessibleImage
UIA Control Type: Image
ATK/AT-SPI Role: ROLE_IMAGE
Interface: Image
AX API[Note 1] AXRole: AXImage
AXSubrole: <nil>
insertion
insertion
Computed Role

insertion

MSAA + IAccessible2 Role: IA2_ROLE_CONTENT_INSERTION
UIA Control Type: Text
Localized Control Type: insertion
ATK/AT-SPI Role: ROLE_CONTENT_INSERTION
Object Attribute: xml-roles:insertion
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXInsertStyleGroup
AXAttributedStringForTextMarkerRange: contains AXIsSuggestedInsertion = 1; for all text contained in a insertion
link
link
Computed Role

link

MSAA + IAccessible2 Role: ROLE_SYSTEM_LINK
State: STATE_SYSTEM_LINKED
State: STATE_SYSTEM_LINKED on its descendants
Interface: IAccessibleHypertext
UIA Control Type: HyperLink
Control Pattern: Value
ATK/AT-SPI Role: ROLE_LINK
Interface: HyperlinkImpl
AX API[Note 1] AXRole: AXLink
AXSubrole: <nil>
list
list
Computed Role

list

MSAA + IAccessible2 Role: ROLE_SYSTEM_LIST
State: STATE_SYSTEM_READONLY
UIA Control Type: List
ATK/AT-SPI Role: ROLE_LIST
AX API[Note 1] AXRole: AXList
AXSubrole: AXContentList
listbox not owned by or child of combobox
listbox not owned by or child of combobox
Computed Role

listbox

MSAA + IAccessible2 Role: ROLE_SYSTEM_LIST
Method: IAccessible::accSelect()
Method: IAccessible::get_accSelection()
UIA Control Type: List
Control Pattern: Selection
ATK/AT-SPI Role: ROLE_LIST_BOX
Interface: Selection

Because WAI-ARIA does not support modifying the selection via the accessibility API, user agents MUST return false for all Selection methods that provide a means to modify the selection.

AX API[Note 1] AXRole: AXList
AXSubrole: <nil>
listbox owned by or child of combobox
listbox owned by or child of combobox
Computed Role

listbox

MSAA + IAccessible2 Role: ROLE_SYSTEM_LIST
Method: IAccessible::accSelect()
Method: IAccessible::get_accSelection()
UIA Control Type: List
Control Pattern: Selection
ATK/AT-SPI Role: ROLE_MENU
Interface: Selection

Because WAI-ARIA does not support modifying the selection via the accessibility API, user agents MUST return false for all Selection methods that provide a means to modify the selection.

AX API[Note 1] AXRole: AXList
AXSubrole: <nil>
listitem
listitem
Computed Role

listitem

MSAA + IAccessible2 Role: ROLE_SYSTEM_LISTITEM
State: STATE_SYSTEM_READONLY
UIA Control Type: ListItem
Control Pattern: SelectionItem
SelectionItem.SelectionContainer: the containing list
ATK/AT-SPI Role: ROLE_LIST_ITEM
AX API[Note 1] AXRole: AXGroup
AXSubrole: <nil>
log
log
Computed Role

log

MSAA + IAccessible2 Object Attribute: xml-roles:log
Object Attribute: container-live:polite
Object Attribute: live:polite
Object Attribute: container-live-role:log
UIA Control Type: Group
Localized Control Type: log
LiveSetting: Polite (1)
ATK/AT-SPI Role: ROLE_LOG
Object Attribute: xml-roles:log
Object Attribute: container-live:polite
Object Attribute: live:polite
Object Attribute: container-live-role:log
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXApplicationLog
main
main
Computed Role

main

MSAA + IAccessible2 Role: IA2_ROLE_LANDMARK
Object Attribute: xml-roles:main
UIA Control Type: Group
Localized Control Type: main
Landmark Type: Main
ATK/AT-SPI Role: ROLE_LANDMARK
Object Attribute: xml-roles:main
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXLandmarkMain
mark
mark
Computed Role

mark

MSAA + IAccessible2 Role: ROLE_SYSTEM_GROUPING
Role: IA2_ROLE_MARK
Object Attribute: xml-roles:mark
UIA Control Type: Group
ATK/AT-SPI Role: ROLE_MARK
Object Attribute: xml-roles:mark
AX API[Note 1] AXRole: AXGroup
AXRoleDescription: highlight
AXAttributedStringForTextMarkerRange: contains AXHighlight = 1; for all text contained in a mark
marquee
marquee
Computed Role

marquee

MSAA + IAccessible2 Role: ROLE_SYSTEM_ANIMATION
Object Attribute: xml-roles:marquee
Object Attribute: container-live:off
Object Attribute: live:off
UIA Control Type: Group
Localized Control Type: marquee
LiveSetting: Off (0)
ATK/AT-SPI Role: ROLE_MARQUEE
Object Attribute: container-live:off
Object Attribute: live:off
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXApplicationMarquee
math
math
Computed Role

math

MSAA + IAccessible2 Role: ROLE_SYSTEM_EQUATION
UIA Control Type: Group
Localized Control Type: math
ATK/AT-SPI Role: ROLE_MATH
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXDocumentMath
menu
menu
Computed Role

menu

MSAA + IAccessible2 Role: ROLE_SYSTEM_MENUPOPUP
Method: IAccessible::accSelect()
Method: IAccessible::get_accSelection()
UIA Control Type: Menu
ATK/AT-SPI Role: ROLE_MENU
Interface: Selection

Because WAI-ARIA does not support modifying the selection via the accessibility API, user agents MUST return false for all Selection methods that provide a means to modify the selection.

AX API[Note 1] AXRole: AXMenu
AXSubrole: <nil>
menubar
menubar
Computed Role

menubar

MSAA + IAccessible2 Role: ROLE_SYSTEM_MENUBAR
Method: IAccessible::accSelect()
Method: IAccessible::get_accSelection()
UIA Control Type: MenuBar
ATK/AT-SPI Role: ROLE_MENU_BAR
Interface: Selection

Because WAI-ARIA does not support modifying the selection via the accessibility API, user agents MUST return false for all Selection methods that provide a means to modify the selection.

AX API[Note 1] AXRole: AXMenuBar
AXSubrole: <nil>
menuitem
menuitem
Computed Role

menuitem

MSAA + IAccessible2 Role: ROLE_SYSTEM_MENUITEM
UIA Control Type: MenuItem
ATK/AT-SPI Role: ROLE_MENU_ITEM
AX API[Note 1] AXRole: AXMenuItem
AXSubrole: <nil>
menuitemcheckbox
menuitemcheckbox
Computed Role

menuitemcheckbox

MSAA + IAccessible2 Role: ROLE_SYSTEM_CHECKBUTTON or ROLE_SYSTEM_MENUITEM
Role: IA2_ROLE_CHECK_MENU_ITEM
See also: aria-checked in the State and Property Mapping Table
UIA Control Type: MenuItem
Control Pattern: Toggle
See also: aria-checked in the State and Property Mapping Table
ATK/AT-SPI Role: ROLE_CHECK_MENU_ITEM
See also: aria-checked in the State and Property Mapping Table
AX API[Note 1] AXRole: AXMenuItem
AXSubrole: <nil>
See also: aria-checked in the State and Property Mapping Table
menuitemradio
menuitemradio
Computed Role

menuitemradio

MSAA + IAccessible2 Role: ROLE_SYSTEM_RADIOBUTTON or ROLE_SYSTEM_MENUITEM
Role: IA2_ROLE_RADIO_MENU_ITEM
See also: aria-checked in the State and Property Mapping Table
UIA Control Type: MenuItem
Control Pattern: Toggle
Control Pattern: SelectionItem
See also: aria-checked in the State and Property Mapping Table
ATK/AT-SPI Role: ROLE_RADIO_MENU_ITEM
See also: aria-checked in the State and Property Mapping Table
AX API[Note 1] AXRole: AXMenuItem
AXSubrole: <nil>
See also: aria-checked in the State and Property Mapping Table
meter
meter
Computed Role

meter

MSAA + IAccessible2 Role: IA2_ROLE_LEVEL_BAR
Interface: IAcesssibleValue
UIA Control Type: ProgressBar
Localized Control Type: meter
Control Pattern: RangeValue
ATK/AT-SPI Role: ROLE_LEVEL_BAR
Interface: Value
AX API[Note 1] AXRole: AXLevelIndicator
AXSubrole: AXMeter
navigation
navigation
Computed Role

navigation

MSAA + IAccessible2 Role: IA2_ROLE_LANDMARK
Object Attribute: xml-roles:navigation
UIA Control Type: Group
Localized Control Type: navigation
Landmark Type: Navigation
ATK/AT-SPI Role: ROLE_LANDMARK
Object Attribute: xml-roles:navigation
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXLandmarkNavigation
none
none
Computed Role

none

MSAA + IAccessible2

For objects that have required owned descendants (e.g., a grid owns gridcells, a list owns listitems), and the descendant is in the accessibility tree, expose it as IA2_ROLE_TEXT_FRAME. user agents SHOULD prune empty descendants from the accessibility tree.

UIA

For objects that have required owned descendants (e.g., a grid owns gridcells, a list owns listitems), and the descendant is in the accessibility tree, expose it using the text pattern. user agents SHOULD prune empty descendants from the accessibility tree.

ATK/AT-SPI

For objects that have required owned descendants (e.g., a grid owns gridcells, a list owns listitems), and the descendant is in the accessibility tree, expose it as ROLE_SECTION. user agents SHOULD prune empty descendants from the accessibility tree.

AX API[Note 1]

For objects that have required owned descendants (e.g., a grid owns gridcells, a list owns listitems), and the descendant is in the accessibility tree, expose it as AXGroup. user agents SHOULD prune empty descendants from the accessibility tree.

note
note
Computed Role

note

MSAA + IAccessible2 Role: IA2_ROLE_NOTE
UIA Control Type: Group
Localized Control Type: note
ATK/AT-SPI Role: ROLE_COMMENT
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXDocumentNote
option not inside combobox
option not inside combobox
Computed Role

option

MSAA + IAccessible2 Role: ROLE_SYSTEM_LISTITEM
See also: aria-checked in the State and Property Mapping Table
UIA Control Type: ListItem
Control Pattern: Invoke
See also: aria-checked in the State and Property Mapping Table
ATK/AT-SPI Role: ROLE_LIST_ITEM
See also: aria-checked in the State and Property Mapping Table
AX API[Note 1] AXRole: AXStaticText
AXSubrole: <nil>
See also: aria-checked in the State and Property Mapping Table
option inside combobox
option inside combobox
Computed Role

option

MSAA + IAccessible2 Role: ROLE_SYSTEM_LISTITEM
See also: aria-checked in the State and Property Mapping Table
UIA Control Type: ListItem
Control Pattern: Invoke
See also: aria-checked in the State and Property Mapping Table
ATK/AT-SPI Role: ROLE_MENU_ITEM
See also: aria-checked in the State and Property Mapping Table
AX API[Note 1] AXRole: AXStaticText
AXSubrole: <nil>
See also: aria-checked in the State and Property Mapping Table
paragraph
paragraph
Computed Role

paragraph

MSAA + IAccessible2 Role: ROLE_SYSTEM_GROUPING
Role: IA2_ROLE_PARAGRAPH
UIA Control Type: Text
ATK/AT-SPI Role: ROLE_PARAGRAPH
AX API[Note 1] AXRole: AXGroup
AXSubrole: <nil>
presentation
presentation
Computed Role

none

MSAA + IAccessible2

For objects that have required owned descendants (e.g., a grid owns gridcells, a list owns listitems), and the descendant is in the accessibility tree, expose it as IA2_ROLE_TEXT_FRAME. user agents SHOULD prune empty descendants from the accessibility tree.

UIA

For objects that have required owned descendants (e.g., a grid owns gridcells, a list owns listitems), and the descendant is in the accessibility tree, expose it using the text pattern. user agents SHOULD prune empty descendants from the accessibility tree.

ATK/AT-SPI

For objects that have required owned descendants (e.g., a grid owns gridcells, a list owns listitems), and the descendant is in the accessibility tree, expose it as ROLE_SECTION. user agents SHOULD prune empty descendants from the accessibility tree.

AX API[Note 1]

For objects that have required owned descendants (e.g., a grid owns gridcells, a list owns listitems), and the descendant is in the accessibility tree, expose it as AXGroup. user agents SHOULD prune empty descendants from the accessibility tree.

progressbar
progressbar
Computed Role

progressbar

MSAA + IAccessible2 Role: ROLE_SYSTEM_PROGRESSBAR
State: STATE_SYSTEM_READONLY
Interface: IAcesssibleValue
UIA Control Type: ProgressBar
Control Pattern: RangeValue if aria-valuenow, aria-valuemax, or aria-valuemin is present
ATK/AT-SPI Role: ROLE_PROGRESS_BAR
Interface: Value

Because WAI-ARIA does not support modifying the value via the accessibility API, user agents MUST return false for all Value methods that provide a means to modify the value.

AX API[Note 1] AXRole: AXProgressIndicator
AXSubrole: <nil>
radio
radio
Computed Role

radio

MSAA + IAccessible2 Role: ROLE_SYSTEM_RADIOBUTTON
See also: aria-checked in the State and Property Mapping Table
UIA Control Type: RadioButton
Control Pattern: Toggle
Control Pattern: SelectionItem
See also: aria-checked in the State and Property Mapping Table
ATK/AT-SPI Role: ROLE_RADIO_BUTTON
See also: aria-checked in the State and Property Mapping Table
AX API[Note 1] AXRole: AXRadioButton
AXSubrole: <nil>
See also: aria-checked in the State and Property Mapping Table
radiogroup
radiogroup
Computed Role

ragiogroup

MSAA + IAccessible2 Role: ROLE_SYSTEM_GROUPING
UIA Control Type: List
ATK/AT-SPI Role: ROLE_PANEL
AX API[Note 1] AXRole: AXRadioGroup
AXSubrole: <nil>
region with an accessible name
region with an accessible name
Computed Role

region

MSAA + IAccessible2 Role: IA2_ROLE_LANDMARK
Object Attribute: xml-roles:region
UIA Control Type: Group
Localized Control Type: region
Landmark Type: Custom
Localized Landmark Type: region
ATK/AT-SPI Role: ROLE_LANDMARK
Object Attribute: xml-roles:region
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXLandmarkRegion
region without an accessible name
region without an accessible name
Computed Role

Use native host language role.

MSAA + IAccessible2 Do not expose the element as a landmark. Use the native host language role of the element instead.
UIA Do not expose the element as a landmark. Use the native host language role of the element instead.
ATK/AT-SPI Do not expose the element as a landmark. Use the native host language role of the element instead.
AX API[Note 1] Do not expose the element as a landmark. Use the native host language role of the element instead.
row not inside treegrid
row not inside treegrid
Computed Role

row

MSAA + IAccessible2 Role: ROLE_SYSTEM_ROW
UIA Control Type: DataItem
Localized Control Type: row
Control Pattern: SelectionItem
ATK/AT-SPI Role: ROLE_TABLE_ROW
AX API[Note 1] AXRole: AXRow
AXSubrole: <nil>
row inside treegrid
row inside treegrid
Computed Role

treegrid

MSAA + IAccessible2 Role: ROLE_SYSTEM_OUTLINEITEM
UIA Control Type: DataItem
Localized Control Type: row
Control Pattern: SelectionItem
ATK/AT-SPI Role: ROLE_TABLE_ROW
AX API[Note 1] AXRole: AXRow
AXSubrole: <nil>
rowgroup
rowgroup
Computed Role

rowgroup

MSAA + IAccessible2 Role: ROLE_SYSTEM_GROUPING
UIA Control Type: Group
ATK/AT-SPI Role: ROLE_PANEL
AX API[Note 1] Not mapped
rowheader
rowheader
Computed Role

rowheader

MSAA + IAccessible2 Role: ROLE_SYSTEM_ROWHEADER
Interface: IAccessibleTableCell
UIA Control Type: HeaderItem
ATK/AT-SPI Role: ROLE_ROW_HEADER
Interface: TableCell
AX API[Note 1] AXRole: AXCell
AXSubrole: <nil>
scrollbar
scrollbar
Computed Role

scrollbar

MSAA + IAccessible2 Role: ROLE_SYSTEM_SCROLLBAR
Interface: IAcesssibleValue
UIA Control Type: ScrollBar
Control Pattern: RangeValue
ATK/AT-SPI Role: ROLE_SCROLL_BAR
Interface: Value

Because WAI-ARIA does not support modifying the value via the accessibility API, user agents MUST return false for all Value methods that provide a means to modify the value.

AX API[Note 1] AXRole: AXScrollBar
AXSubrole: <nil>
search
search
Computed Role

search

MSAA + IAccessible2 Role: IA2_ROLE_LANDMARK
Object Attribute: xml-roles:search
UIA Control Type: Group
Localized Control Type: search
Landmark Type: Search
ATK/AT-SPI Role: ROLE_LANDMARK
Object Attribute: xml-roles:search
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXLandmarkSearch
searchbox
searchbox
Computed Role

searchbox

MSAA + IAccessible2 Role: ROLE_SYSTEM_TEXT
Object Attribute: text-input-type:search
UIA Control Type: Edit
Localized Control Type: search box
ATK/AT-SPI Role: ROLE_ENTRY
Object Attribute: xml-roles:searchbox
Interface: EditableText if aria-readonly is not "true"
AX API[Note 1] AXRole: AXTextField
AXSubrole: AXSearchField
separator (non-focusable)
separator (non-focusable)
Computed Role

seperator

MSAA + IAccessible2 Role: ROLE_SYSTEM_SEPARATOR
UIA Control Type: Separator
ATK/AT-SPI Role: ROLE_SEPARATOR
AX API[Note 1] AXRole: AXSplitter
AXSubrole: <nil>
separator (focusable)
separator (focusable)
Computed Role

seperator

MSAA + IAccessible2 Role: ROLE_SYSTEM_SEPARATOR
Interface: IAccessibleValue
UIA Control Type: Thumb
Control Pattern: RangeValue
ATK/AT-SPI Role: ROLE_SEPARATOR
Interface: Value

Because WAI-ARIA does not support modifying the value via the accessibility API, user agents MUST return false for all Value methods that provide a means to modify the value.

AX API[Note 1] AXRole: AXSplitter
AXSubrole: <nil>
slider
slider
Computed Role

slider

MSAA + IAccessible2 Role: ROLE_SYSTEM_SLIDER
Interface: IAcesssibleValue
UIA Control Type: Slider
Control Pattern: RangeValue
ATK/AT-SPI Role: ROLE_SLIDER
Interface: Value

Because WAI-ARIA does not support modifying the value via the accessibility API, user agents MUST return false for all Value methods that provide a means to modify the value.

AX API[Note 1] AXRole: AXSlider
AXSubrole: <nil>
spinbutton
spinbutton
Computed Role

spinbutton

MSAA + IAccessible2 Role: ROLE_SYSTEM_SPINBUTTON
Interface: IAcesssibleValue
UIA Control Type: Spinner
Control Pattern: RangeValue
ATK/AT-SPI Role: ROLE_SPIN_BUTTON
Interface: Value

Because WAI-ARIA does not support modifying the value via the accessibility API, user agents MUST return false for all Value methods that provide a means to modify the value.

AX API[Note 1] AXRole: AXIncrementor
AXSubrole: <nil>
status
status
Computed Role

status

MSAA + IAccessible2 Role: ROLE_SYSTEM_STATUSBAR
Object Attribute: container-live:polite
Object Attribute: live:polite
Object Attribute: container-live-role:status
UIA Control Type: Group
Localized Control Type: status
LiveSetting: Polite (1)
ATK/AT-SPI Role: ROLE_STATUSBAR
Object Attribute: container-live:polite
Object Attribute: live:polite
Object Attribute: container-live-role:status
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXApplicationStatus
strong
strong
Computed Role

strong

MSAA + IAccessible2 Role: IA2_ROLE_TEXT_FRAME
Object Attribute: xml-roles:strong
UIA Control Type: Text
Localized Control Type: strong
ATK/AT-SPI Role: ROLE_STATIC
Object Attribute: xml-roles:strong
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXStrongStyleGroup
subscript
subscript
Computed Role

subscript

MSAA + IAccessible2 Role: ROLE_SYSTEM_GROUPING
Role: IA2_ROLE_TEXT_FRAME
Text Attribute: text-position:sub
UIA Control Type: Text
Styles used are exposed by IsSubscript attribute of the TextRange Control Pattern implemented on the accessible object.
ATK/AT-SPI Role: ROLE_SUBSCRIPT
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXSubscriptStyleGroup
suggestion
suggestion
Computed Role

suggestion

MSAA + IAccessible2 Role: IA2_ROLE_SUGGESTION
Object Attribute: xml-roles:suggestion
UIA Control Type: Group
Localized Control Type: suggestion
ATK/AT-SPI Role: ROLE_SUGGESTION
Object Attribute: xml-roles:suggestion
AX API[Note 1] AXRole: AXGroup
AXAttributedStringForTextMarkerRange: contains AXIsSuggestion = 1; for all text contained in a suggestion
superscript
superscript
Computed Role

superscript

MSAA + IAccessible2 Role: ROLE_SYSTEM_GROUPING
Role: IA2_ROLE_TEXT_FRAME
Text Attribute: text-position:super
UIA Control Type: Text
Styles used are exposed by IsSuperscript attribute of the TextRange Control Pattern implemented on the accessible object.
ATK/AT-SPI Role: ROLE_SUPERSCRIPT
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXSuperscriptStyleGroup
switch
switch
Computed Role

switch

MSAA + IAccessible2 Role: ROLE_SYSTEM_CHECKBUTTON
Role: IA2_ROLE_TOGGLE_BUTTON
Object Attribute: xml-roles:switch
See also: aria-checked in the State and Property Mapping Table
UIA Control Type: Button
Localized Control Type: toggleswitch
Control Pattern: Toggle
See also: aria-checked in the State and Property Mapping Table
ATK/AT-SPI Role: ROLE_TOGGLE_BUTTON
Object Attribute: xml-roles:switch
See also: aria-checked in the State and Property Mapping Table
AX API[Note 1] AXRole: AXCheckBox
AXSubrole: AXSwitch
See also: aria-checked in the State and Property Mapping Table
tab
tab
Computed Role

tab

MSAA + IAccessible2 Role: ROLE_SYSTEM_PAGETAB
State: STATE_SYSTEM_SELECTED if focus is inside tabpanel associated with aria-labelledby
UIA Control Type: TabItem
ATK/AT-SPI Role: ROLE_PAGE_TAB
State: STATE_SELECTED if focus is inside tabpanel associated with aria-labelledby
AX API[Note 1] AXRole: AXRadioButton
AXSubrole: AXTabButton
table
table
Computed Role

table

MSAA + IAccessible2 Role: ROLE_SYSTEM_TABLE
Object Attribute: xml-roles:table
Interface: IAccessibleTable2
UIA Control Type: Table
Control Pattern: Grid
Control Pattern: Table
ATK/AT-SPI Role: ROLE_TABLE
Object Attribute: xml-roles:table
Interface: Table
AX API[Note 1] AXRole: AXTable
AXSubrole: <nil>
AXColumnHeaderUIElements: a list of pointers to the columnheader elements
AXHeader: a pointer to the row or group containing those columnheader elements
AXRowHeaderUIElements: a list of pointers to the rowheader elements
tablist
tablist
Computed Role

tablist

MSAA + IAccessible2 Role: ROLE_SYSTEM_PAGETABLIST
Method: IAccessible::accSelect()
Method: IAccessible::get_accSelection()
UIA Control Type: Tab
Control Pattern: Selection
ATK/AT-SPI Role: ROLE_PAGE_TAB_LIST
Interface: Selection

Because WAI-ARIA does not support modifying the selection via the accessibility API, user agents MUST return false for all Selection methods that provide a means to modify the selection.

AX API[Note 1] AXRole: AXTabGroup
AXSubrole: <nil>
tabpanel
tabpanel
Computed Role

tabpanel

MSAA + IAccessible2 Role: ROLE_SYSTEM_PANE or ROLE_SYSTEM_PROPERTYPAGE
UIA Control Type: Pane
ATK/AT-SPI Role: ROLE_SCROLL_PANE
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXTabPanel
term
term
Computed Role

term

MSAA + IAccessible2 Role: IA2_ROLE_TEXT_FRAME
Object Attribute: xml-roles:term
UIA Control Type: Text
Localized Control Type: term
ATK/AT-SPI Role: ROLE_DESCRIPTION_TERM
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXTerm
textbox when aria-multiline is false
textbox when aria-multiline is false
Computed Role

textbox

MSAA + IAccessible2 Role: ROLE_SYSTEM_TEXT
State: IA2_STATE_SINGLE_LINE
UIA Control Type: Edit
ATK/AT-SPI Role: ROLE_ENTRY
State: STATE_SINGLE_LINE
Interface: EditableText if aria-readonly is not "true"
AX API[Note 1] AXRole: AXTextField
AXSubrole: <nil>
textbox when aria-multiline is true
textbox when aria-multiline is true
Computed Role

textbox

MSAA + IAccessible2 Role: ROLE_SYSTEM_TEXT
State: IA2_STATE_MULTI_LINE
UIA Control Type: Edit
ATK/AT-SPI Role: ROLE_ENTRY
State: STATE_MULTI_LINE
Interface: EditableText if aria-readonly is not "true"
AX API[Note 1] AXRole: AXTextArea
AXSubrole: <nil>
time
time
Computed Role

time

MSAA + IAccessible2 Role: ROLE_SYSTEM_GROUPING
Object Attribute: xml-roles:time
UIA Control Type: Text
Localized Control Type: time
Note: create a separate UIA Control of type Text. This is different from most UIA text mappings, which only create ranges in the page text pattern.
ATK/AT-SPI Role: ROLE_STATIC
Object Attribute: xml-roles:time
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXTimeGroup
timer
timer
Computed Role

timer

MSAA + IAccessible2 Object Attribute: xml-roles:timer
Object Attribute: container-live:off
Object Attribute: live:off
Object Attribute: container-live-role:timer
UIA Control Type: Group
Localized Control Type: timer
LiveSetting: Off (0)
ATK/AT-SPI Role: ROLE_TIMER
Object Attribute: container-live:off
Object Attribute: live:off
Object Attribute: container-live-role:timer
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXApplicationTimer
toolbar
toolbar
Computed Role

toolbar

MSAA + IAccessible2 Role: ROLE_SYSTEM_TOOLBAR
UIA Control Type: ToolBar
ATK/AT-SPI Role: ROLE_TOOL_BAR
AX API[Note 1] AXRole: AXToolbar
AXSubrole: <nil>
tooltip
tooltip
Computed Role

tooltip

MSAA + IAccessible2 Role: ROLE_SYSTEM_TOOLTIP
UIA Control Type: ToolTip
ATK/AT-SPI Role: ROLE_TOOL_TIP
AX API[Note 1] AXRole: AXGroup
AXSubrole: AXUserInterfaceTooltip
tree
tree
Computed Role

tree

MSAA + IAccessible2 Role: ROLE_SYSTEM_OUTLINE
Method: IAccessible::accSelect()
Method: IAccessible::get_accSelection()
UIA Control Type: Tree
ATK/AT-SPI Role: ROLE_TREE
Interface: Selection

Because WAI-ARIA does not support modifying the selection via the accessibility API, user agents MUST return false for all Selection methods that provide a means to modify the selection.

AX API[Note 1] AXRole: AXOutline
AXSubrole: <nil>
treegrid
treegrid
Computed Role

treegrid

MSAA + IAccessible2 Role: ROLE_SYSTEM_OUTLINE
Interface: IAccessibleTable2
Method: IAccessible::accSelect()
Method: IAccessible::get_accSelection()
UIA Control Type: DataGrid
ATK/AT-SPI Role: ROLE_TREE_TABLE
Interface: Table
Interface: Selection

Because WAI-ARIA does not support modifying the selection via the accessibility API, user agents MUST return false for all Selection methods that provide a means to modify the selection.

AX API[Note 1] AXRole: AXTable
AXSubrole: <nil>
treeitem
treeitem
Computed Role

treeitem

MSAA + IAccessible2 Role: ROLE_SYSTEM_OUTLINEITEM
See also: aria-checked in the State and Property Mapping Table
UIA Control Type: TreeItem
See also: aria-checked in the State and Property Mapping Table
ATK/AT-SPI Role: ROLE_TREE_ITEM
See also: aria-checked in the State and Property Mapping Table
AX API[Note 1] AXRole: AXRow
AXSubrole: AXOutlineRow
See also: aria-checked in the State and Property Mapping Table
Note

[Note 1] User agent should return a user-presentable, localized string value for the AXRoleDescription.

Note

[Note 2] This specification does not currently contain guidance for when user agents should fire system alert events. Some guidance may be added to the specification at a later date but it will be a recommendation (SHOULD), not a requirement (MUST).

4.5 State and Property Mapping

This section describes how to expose WAI-ARIA states and properties.

4.5.1 General rules

  1. User agents MUST compute managed states VISIBLE/INVISIBLE, SHOWING/OFFSCREEN, etc. This typically is done in the same way as for ordinary elements that do not have WAI-ARIA attributes present. The FOCUSABLE/FOCUSED states may be affected by aria-activedescendant.
  2. User agents MUST continue to expose native semantics in addition to WAI-ARIA state and property semantics except where an explicit WAI-ARIA override is allowed by the host language. For example, an HTML checkbox may have an aria-labelledby attribute but the native HTML semantics must still be exposed.
  3. User agents MUST expose additional states for certain roles as defined in the Role Mapping Table.
  4. User agents MUST compute states for the relevant WAI-ARIA attributes and map to the accessibility API as specified in the State and Property Mapping Table. To determine the relevant WAI-ARIA attributes, refer to the Definition of Roles [WAI-ARIA-1.2]]. Where the author has not provided values for required attributes, user agents SHOULD process as if the default value was provided.
  5. Some WAI-ARIA properties are not global, and are only supported on certain roles. If a non-global WAI-ARIA state or property is used where it is not supported, user agents SHOULD NOT map the given WAI-ARIA property to the platform accessibility API. For example, if aria-checked="true" is specified on <div role="grid">, it should not be exposed in MSAA implementations as STATE_SYSTEM_CHECKED.
  6. When an explicit or inherited role of none or presentation is applied to an element, the user agent MUST implement the rules for the none or the presentation role defined in Accessible Rich Internet Applications (WAI-ARIA) 1.2 [WAI-ARIA-1.2]].

4.5.2 State and Property Mapping Table

4.5.2.1 Not Mapped

There are a number of occurrences in the table where a given state or property is declared "Not mapped". In some cases, this occurs for the default value of the state/property, and is equivalent to its absence. User agents might find it quicker to map the value than check to see if it is the default. For computational efficiency, user agents MAY expose the state or property value if doing so is equivalent to not mapping it. These cases are marked with an asterisk.

In other cases, it is mandatory that the state/property not be mapped, since exposing it implies a related affordance. An example is aria-grabbed. Its absence not only indicates that the accessible object is not grabbed, but further defines it as not grab-able. These cases are marked as "Not mapped" without an asterisk.

Note

Translators: For label text associated with the following table and its toggle buttons, see the mappingTableLabels object in the <head> section of this document.

aria-activedescendant
aria-activedescendant
MSAA + IAccessible2 See Focus Changes.
UIA See Focus Changes.
ATK/AT-SPI See Focus Changes.
AX API See Focus Changes.
Property: AXSelectedRows: pointer to active descendant node
aria-atomic=true
aria-atomic=true
MSAA + IAccessible2 Object Attribute: atomic:true
Object Attribute: container-atomic:true
Object Attribute: container-atomic:true on all descendants
Relation: IA2_RELATION_MEMBER_OF pointing to this element (the atomic root)
See also: Changes to document content or node visibility
UIA Property: AriaProperties.atomic: true
See also: Changes to document content or node visibility
ATK/AT-SPI Object Attribute: atomic:true
Object Attribute: container-atomic:true
Object Attribute: container-atomic:true on all descendants
Relation: RELATION_MEMBER_OF pointing to this element (the atomic root)
See also: Changes to document content or node visibility
AX API Property: AXARIAAtomic: YES
See also: Changes to document content or node visibility
aria-atomic=false
aria-atomic=false
MSAA + IAccessible2 Not mapped*, but if mapped:
Object Attribute: atomic:false
Object Attribute: container-atomic:false
Object Attribute: container-atomic:false on all descendants
Relation: IA2_RELATION_MEMBER_OF pointing to this element (the atomic root)
See also: Changes to document content or node visibility
UIA Property: AriaProperties.atomic: false
See also: Changes to document content or node visibility
ATK/AT-SPI Not mapped*, but if mapped:
Object Attribute: atomic:false
Object Attribute: container-atomic:false
Object Attribute: container-atomic:false on all descendants
Relation: RELATION_MEMBER_OF pointing to this element (the atomic root)
See also: Changes to document content or node visibility
AX API Property: AXARIAAtomic: NO
See also: Changes to document content or node visibility
aria-autocomplete=inline, list, or both
aria-autocomplete=inline, list, or both
MSAA + IAccessible2 Object Attribute: autocomplete:<value>
State: IA2_STATE_SUPPORTS_AUTOCOMPLETION
UIA Not mapped
ATK/AT-SPI Object Attribute: autocomplete:<value>
State: STATE_SUPPORTS_AUTOCOMPLETION
AX API Not mapped
aria-autocomplete=none
aria-autocomplete=none
MSAA + IAccessible2 Not mapped*
UIA Not mapped*
ATK/AT-SPI Not mapped*
AX API Not mapped*
aria-braillelabel
aria-braillelabel
MSAA + IAccessible2 Object Attribute: braillelabel:<value>
UIA Property: AriaProperties.braillelabel: <value>
ATK/AT-SPI Object Attribute: braillelabel:<value>
AX API Property: AXBrailleLabel
aria-brailleroledescription
aria-brailleroledescription
MSAA + IAccessible2 Object Attribute: brailleroledescription:<value>
UIA Property: AriaProperties.brailleroledescription: <value>
ATK/AT-SPI Object Attribute: brailleroledescription:<value>
AX API Property: AXBrailleRoleDescription
aria-brailleroledescription is undefined or the empty string
aria-brailleroledescription is undefined or the empty string
MSAA + IAccessible2 Not mapped
UIA Not mapped
ATK/AT-SPI Not mapped
AX API Not mapped
aria-busy=true
aria-busy=true
MSAA + IAccessible2 State: STATE_SYSTEM_BUSY
UIA Property: AriaProperties.busy: true
ATK/AT-SPI State: STATE_BUSY
AX API Property: AXElementBusy: YES
aria-busy=false
aria-busy=false
MSAA + IAccessible2 State: STATE_SYSTEM_BUSY not exposed
UIA Property: AriaProperties.busy: false
ATK/AT-SPI State: STATE_BUSY not exposed
AX API Property: AXElementBusy: NO
aria-checked=true
aria-checked=true
MSAA + IAccessible2 State: STATE_SYSTEM_CHECKED
Object Attribute: checkable:true
UIA Property: Toggle.ToggleState: On (1)
Property: SelectionItem.IsSelected: True for radio and menuitemradio
ATK/AT-SPI State: STATE_CHECKABLE
State: STATE_CHECKED
AX API Property: AXValue: 1
Property: AXMenuItemMarkChar: ✓ for menuitemcheckbox and menuitemradio
aria-checked=false
aria-checked=false
MSAA + IAccessible2 State: STATE_SYSTEM_CHECKED not exposed
Object Attribute: checkable:true
UIA Property: Toggle.ToggleState: Off (0)
Property: SelectionItem.IsSelected: False for radio and menuitemradio
ATK/AT-SPI State: STATE_CHECKABLE
State: STATE_CHECKED not exposed
AX API Property: AXValue: 0
Property: AXMenuItemMarkChar: <nil> for menuitemcheckbox and menuitemradio
aria-checked=mixed
aria-checked=mixed
MSAA + IAccessible2 State: STATE_SYSTEM_MIXED
Object Attribute: checkable:true
UIA Property: Toggle.ToggleState: Indeterminate (2)
ATK/AT-SPI State: STATE_INDETERMINATE
State: STATE_CHECKABLE
State: STATE_CHECKED not exposed
AX API Property: AXValue: 2
Property: AXMenuItemMarkChar: <nil> for menuitemcheckbox and menuitemradio
aria-checked is undefined
aria-checked is undefined
MSAA + IAccessible2 Not mapped
UIA Not mapped
ATK/AT-SPI Not mapped
AX API Not mapped
aria-colcount
aria-colcount
MSAA + IAccessible2 Object Attribute: colcount:<value>
Method: IAccessible2::groupPosition(): similarItemsInGroup=<value> on cells and headers
UIA Property: Grid.ColumnCount: <value>
ATK/AT-SPI Object Attribute: colcount should contain the author-provided value.
Method: atk_table_get_n_columns() should return the actual number of columns.
AX API Property: AXARIAColumnCount: <value>
aria-colindex
aria-colindex
MSAA + IAccessible2 Object Attribute: colindex:<value>
Method: IAccessible2::groupPosition(): positionInGroup=<value> on cells and headers
UIA Property: GridItem.Column: <value> (zero-based)
ATK/AT-SPI Object Attribute: colindex should contain the author-provided value.
Method: atk_table_cell_get_position() should return the actual (zero-based) column index.
AX API Property: AXARIAColumnIndex: <value>
aria-colindextext
aria-colindextext
MSAA + IAccessible2 Object Attribute: colindextext:<value>
UIA Property: AriaProperties.colindextext: <value>
ATK/AT-SPI Object Attribute: colindextext:<value>
AX API Property: TBD
aria-colspan
aria-colspan
MSAA + IAccessible2 Object Attribute: colspan:<value>
Method: IAccessibleTableCell::columnExtent(): <value>
UIA Property: GridItem.ColumnSpan: <value>
ATK/AT-SPI Object Attribute: colspan should contain the author-provided value.
Method: atk_table_cell_get_row_column_span() should return the actual column span.
AX API Property: AXColumnIndexRange.length: <value>
aria-controls
aria-controls
MSAA + IAccessible2 Relation: IA2_RELATION_CONTROLLER_FOR points to accessible nodes matching IDREFs
Reverse Relation: IA2_RELATION_CONTROLLED_BY points to element
See also: Mapping Additional Relations
UIA Property: ControllerFor: pointers to accessible nodes matching IDREFs
ATK/AT-SPI Relation: RELATION_CONTROLLER_FOR points to accessible nodes matching IDREFs
Reverse Relation: RELATION_CONTROLLED_BY points to element
See also: Mapping Additional Relations
AX API Property: AXLinkedUIElements: pointers to accessible nodes matching IDREFs
aria-current with non-false allowed value
aria-current with non-false allowed value
MSAA + IAccessible2 Object Attribute: current:<value>
UIA Property: AriaProperties.current: <value>
ATK/AT-SPI Object Attribute: current:<value>
State: STATE_ACTIVE
AX API Property: AXARIACurrent: <value>
aria-current with unrecognized value
aria-current with unrecognized value
MSAA + IAccessible2 Object Attribute: current:true
UIA Property: AriaProperties.current: true
ATK/AT-SPI Object Attribute: current:true
State: STATE_ACTIVE
AX API Property: AXARIACurrent: true
aria-current is false or undefined
aria-current is false or undefined
MSAA + IAccessible2 Not mapped*
UIA Not mapped*
ATK/AT-SPI Not mapped*
AX API Not mapped*
aria-describedby
aria-describedby
MSAA + IAccessible2 Property: accDescription: <value>
Relation: IA2_RELATION_DESCRIBED_BY points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree
Reverse Relation: IA2_RELATION_DESCRIPTION_FOR points to element
See also: Name Computation and Mapping Additional Relations
UIA Property: FullDescription: <value>
Property: DescribedBy: points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree
See also: Name Computation
ATK/AT-SPI Property: Description: <value>
Relation: RELATION_DESCRIBED_BY points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree
Reverse Relation: RELATION_DESCRIPTION_FOR points to element
See also: Name Computation and Mapping Additional Relations
AX API In the accessibilityCustomContent API, expose as an AXCustomContent object with { label: "description" } and `value` set to the description string.
- See also: Name Computation
aria-description
aria-description
MSAA + IAccessible2 Property: accDescription: <value>
See also: Name Computation
UIA Property: FullDescription: <value>
See also: Name Computation
ATK/AT-SPI Property: Description: <value>
See also: Name Computation
AX API In the accessibilityCustomContent API, expose as an AXCustomContent object with { label: "description" } and `value` set to the description string.
See also: Name Computation
aria-details
aria-details
MSAA + IAccessible2 Relation: IA2_RELATION_DETAILS points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree
Reverse Relation: IA2_RELATION_DETAILS_FOR points to element
See also: Mapping Additional Relations
UIA Property: DescribedBy: points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree
ATK/AT-SPI Relation: RELATION_DETAILS points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree
Reverse Relation: RELATION_DETAILS_FOR points to element
See also: Mapping Additional Relations
AX API Not mapped*
aria-disabled=true
aria-disabled=true
MSAA + IAccessible2 State: STATE_SYSTEM_UNAVAILABLE
State: STATE_SYSTEM_UNAVAILABLE on all descendants with STATE_SYSTEM_FOCUSABLE
UIA Property: IsEnabled: false
ATK/AT-SPI State: STATE_ENABLED not exposed
AX API Property: AXEnabled: NO
aria-disabled=false
aria-disabled=false
MSAA + IAccessible2 State: STATE_SYSTEM_UNAVAILABLE not exposed
UIA Property: IsEnabled: true
ATK/AT-SPI State: STATE_ENABLED
AX API Property: AXEnabled: YES
aria-dropeffect=copy, move, link, execute, or popup
aria-dropeffect=copy, move, link, execute, or popup
MSAA + IAccessible2 Object Attribute: dropeffect:<value>
UIA Property: AriaProperties.dropeffect: <value>
ATK/AT-SPI Object Attribute: dropeffect:<value>
AX API array AXDropEffects
aria-dropeffect=none
aria-dropeffect=none
MSAA + IAccessible2 Object Attribute: dropeffect:none if there are no other valid tokens
Not mapped* if not specified by the author
UIA Not mapped*
ATK/AT-SPI Object Attribute: dropeffect:none if there are no other valid tokens
Not mapped* if not specified by the author
AX API Not mapped*
aria-errormessage
aria-errormessage
MSAA + IAccessible2 Relation: IA2_RELATION_ERROR points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree
Reverse Relation: IA2_RELATION_ERROR_FOR points to element
See also: Mapping Additional Relations
UIA Property: ControllerFor: pointer to the target accessible object
ATK/AT-SPI Relation: RELATION_ERROR_MESSAGE points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree
Reverse Relation: RELATION_ERROR_FOR points to element
See also: Mapping Additional Relations
AX API Property: AXValidationError: textual content of the referenced element
aria-expanded=true
aria-expanded=true
MSAA + IAccessible2 State: STATE_SYSTEM_EXPANDED
UIA Property: ExpandCollapse.ExpandCollapseState: Expanded
ATK/AT-SPI State: STATE_EXPANDABLE
State: STATE_EXPANDED
AX API Property: AXExpanded: YES
aria-expanded=false
aria-expanded=false
MSAA + IAccessible2 State: STATE_SYSTEM_COLLAPSED
UIA Property: ExpandCollapse.ExpandCollapseState: Collapsed
ATK/AT-SPI State: STATE_EXPANDABLE
State: STATE_EXPANDED not exposed
AX API Property: AXExpanded: NO
aria-expanded is undefined
aria-expanded is undefined
MSAA + IAccessible2 Not mapped
UIA Not mapped
ATK/AT-SPI Not mapped
AX API Not mapped
aria-flowto
aria-flowto
MSAA + IAccessible2 Relation: IA2_RELATION_FLOW_TO points to accessible nodes matching IDREFs
Reverse Relation: IA2_RELATION_FLOW_FROM points to element
See also: Mapping Additional Relations
UIA Property: FlowsTo: pointers to accessible nodes matching IDREFs
ATK/AT-SPI Relation: RELATION_FLOWS_TO points to accessible nodes matching IDREFs
Reverse Relation: RELATION_FLOWS_FROM points to element
See also: Mapping Additional Relations
AX API Property: AXLinkedUIElements: pointers to accessible nodes matching IDREFs
aria-grabbed=true
aria-grabbed=true
MSAA + IAccessible2 Object Attribute: grabbed:true
UIA Property: AriaProperties.grabbed: true
ATK/AT-SPI Object Attribute: grabbed:true
AX API Property: AXGrabbed: YES
aria-grabbed=false
aria-grabbed=false
MSAA + IAccessible2 Object Attribute: grabbed:false
UIA Property: AriaProperties.grabbed: false
ATK/AT-SPI Object Attribute: grabbed:false
AX API Property: AXGrabbed: NO
aria-grabbed is undefined
aria-grabbed is undefined
MSAA + IAccessible2 Not mapped
UIA Not mapped
ATK/AT-SPI Not mapped
AX API Not mapped
aria-haspopup=true
aria-haspopup=true
MSAA + IAccessible2 State: STATE_SYSTEM_HASPOPUP
Object Attribute: haspopup:true
UIA Control Pattern: ExpandCollapse See also: aria-expanded
ATK/AT-SPI State: STATE_HAS_POPUP
Object Attribute: haspopup:true
AX API Property: Action: AXShowMenu
aria-haspopup=false
aria-haspopup=false
MSAA + IAccessible2 State: STATE_SYSTEM_HASPOPUP not exposed
Object Attribute: haspopup:false
UIA Not mapped*
ATK/AT-SPI Not mapped*
AX API Not mapped*
aria-haspopup=dialog
aria-haspopup=dialog
MSAA + IAccessible2 State: STATE_SYSTEM_HASPOPUP
Object Attribute: haspopup:dialog
UIA Control Pattern: ExpandCollapse
See also: aria-expanded
ATK/AT-SPI State: STATE_HAS_POPUP
Object Attribute: haspopup:dialog
AX API Action: AXShowMenu
aria-haspopup=listbox
aria-haspopup=listbox
MSAA + IAccessible2 State: STATE_SYSTEM_HASPOPUP
Object Attribute: haspopup:listbox
UIA Control Pattern: ExpandCollapse
See also: aria-expanded
ATK/AT-SPI State: STATE_HAS_POPUP
Object Attribute: haspopup:listbox
AX API Action: AXShowMenu
aria-haspopup=menu
aria-haspopup=menu
MSAA + IAccessible2 State: STATE_SYSTEM_HASPOPUP
Object Attribute: haspopup:menu
UIA Control Pattern: ExpandCollapse
See also: aria-expanded
ATK/AT-SPI State: STATE_HAS_POPUP
Object Attribute: haspopup:menu
AX API Action: AXShowMenu
aria-haspopup=tree
aria-haspopup=tree
MSAA + IAccessible2 State: STATE_SYSTEM_HASPOPUP
Object Attribute: haspopup:tree
UIA Control Pattern: ExpandCollapse
See also: aria-expanded
ATK/AT-SPI State: STATE_HAS_POPUP
Object Attribute: haspopup:tree
AX API Action: AXShowMenu
aria-hidden=true on unfocused element
aria-hidden=true on unfocused element
MSAA + IAccessible2 Element SHOULD NOT be exposed
See also: Including Elements in the Accessibility Tree in the WAI-ARIA specification
UIA Element SHOULD NOT be exposed
See also: Including Elements in the Accessibility Tree in the WAI-ARIA specification
ATK/AT-SPI Element SHOULD NOT be exposed
See also: Including Elements in the Accessibility Tree in the WAI-ARIA specification
AX API Element SHOULD NOT be exposed
See also: Including Elements in the Accessibility Tree in the WAI-ARIA specification
aria-hidden=true when element is focused or fires an accessibility event
aria-hidden=true when element is focused or fires an accessibility event
MSAA + IAccessible2 Object Attribute: hidden:true
See also: Including Elements in the Accessibility Tree in the WAI-ARIA specification
UIA Property: AriaProperties.hidden: true
See also: Including Elements in the Accessibility Tree in the WAI-ARIA specification
ATK/AT-SPI Object Attribute: hidden:true
See also: Including Elements in the Accessibility Tree in the WAI-ARIA specification
AX API Not mapped
See also: Including Elements in the Accessibility Tree in the WAI-ARIA specification
aria-hidden=false
aria-hidden=false
MSAA + IAccessible2 Not mapped
UIA Not mapped
ATK/AT-SPI Not mapped
AX API Not mapped
aria-invalid=true
aria-invalid=true
MSAA + IAccessible2 State: IA2_STATE_INVALID_ENTRY
Text Attribute: invalid:true
UIA Property: IsDataValidForForm: false
ATK/AT-SPI State: STATE_INVALID_ENTRY
Text Attribute: invalid:true
AX API Property: AXInvalid: true
aria-invalid=false
aria-invalid=false
MSAA + IAccessible2 State: IA2_STATE_INVALID_ENTRY not exposed
UIA Property: IsDataValidForForm: true
ATK/AT-SPI State: STATE_INVALID_ENTRY not exposed
AX API Property: AXInvalid: false
aria-invalid=spelling or grammar
aria-invalid=spelling or grammar
MSAA + IAccessible2 State: IA2_STATE_INVALID_ENTRY
Text Attribute: invalid:<value>
UIA Property: IsDataValidForForm: <value>
ATK/AT-SPI State: STATE_INVALID_ENTRY
Text Attribute: invalid:<value>
AX API Property: AXInvalid: <value>
aria-invalid with unrecognized value
aria-invalid with unrecognized value
MSAA + IAccessible2 State: IA2_STATE_INVALID_ENTRY
Text Attribute: invalid:true
UIA Property: IsDataValidForForm: false
ATK/AT-SPI State: STATE_INVALID_ENTRY
Text Attribute: invalid:true
AX API Property: AXInvalid: true
aria-keyshortcuts
aria-keyshortcuts
MSAA + IAccessible2 Property: accKeyboardShortcut: <value>
UIA Property: AcceleratorKey: <value>
ATK/AT-SPI Object Attribute: keyshortcuts:<value>
AX API Property: AXKeyShortcutsValue: <value>
aria-label
aria-label
MSAA + IAccessible2 Property: accName: <value>
See also: Name Computation
UIA Property: Name: <value>
See also: Name Computation
ATK/AT-SPI Property: Name: <value>
See also: Name Computation
AX API Property: AXDescription: <value>
See also: Name Computation
aria-labelledby
aria-labelledby
MSAA + IAccessible2 Property: accName: <value>
Relation: IA2_RELATION_LABELLED_BY points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree
Reverse Relation: IA2_RELATION_LABEL_FOR points to element
See also: Name Computation and Mapping Additional Relations
UIA Property: Name: <value>
Property: LabeledBy: points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree
See also: Name Computation
ATK/AT-SPI Property: Name: <value>
Relation: RELATION_LABELLED_BY points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree
Reverse Relation: RELATION_LABEL_FOR points to element
See also: Name Computation and Mapping Additional Relations
AX API Property: AXDescription: <value> if the value is not exposed visually
Property: AXTitle: <value> if the value is exposed visually
Property: AXTitleUIElement points to accessible node matching IDREF, if there is a single referenced element that is in the accessibility tree
See also: Name Computation
aria-level on non-heading
aria-level on non-heading
MSAA + IAccessible2 Object Attribute: level:<value>
Method: IAccessible2::groupPosition(): groupLevel=<value> on roles that support aria-posinset and aria-setsize
See also: groupPosition()
UIA Property: AriaProperties.level: <value>
ATK/AT-SPI Object Attribute: level:<value>
AX API Property: AXDisclosureLevel: <value> (zero-based), when used on an outline row (like a treeitem or group)
aria-level on heading
aria-level on heading
MSAA + IAccessible2 Object Attribute: level:<value>
UIA Property: AriaProperties.level: <value>
Property: StyleId_Heading: <value>
ATK/AT-SPI Object Attribute: level:<value>
AX API Property: AXValue: <value>
aria-live=assertive
aria-live=assertive
MSAA + IAccessible2 Object Attribute: live:assertive
Object Attribute: container-live:assertive
Object Attribute: container-live:assertive on all descendants
See also: Changes to document content or node visibility
UIA Property: LiveSetting: "assertive"
See also: Changes to document content or node visibility
ATK/AT-SPI Object Attribute: live:assertive
Object Attribute: container-live:assertive
Object Attribute: container-live:assertive on all descendants
See also: Changes to document content or node visibility
AX API Property: AXARIALive: "assertive"
See also: Changes to document content or node visibility
aria-live=polite
aria-live=polite
MSAA + IAccessible2 Object Attribute: live:polite
Object Attribute: container-live:polite
Object Attribute: container-live:polite on all descendants
See also: Changes to document content or node visibility
UIA Property: LiveSetting: "polite"
See also: Changes to document content or node visibility
ATK/AT-SPI Object Attribute: live:polite
Object Attribute: container-live:polite
Object Attribute: container-live:polite on all descendants
See also: Changes to document content or node visibility
AX API Property: AXARIALive: "polite"
See also: Changes to document content or node visibility
aria-live=off
aria-live=off
MSAA + IAccessible2 Object Attribute: live:off
Object Attribute: container-live:off
Object Attribute: container-live:off on all descendants
UIA Property: LiveSetting: "off"
ATK/AT-SPI Object Attribute: live:off
Object Attribute: container-live:off
Object Attribute: container-live:off on all descendants
AX API Property: AXARIALive: "off"
aria-modal=true
aria-modal=true
MSAA + IAccessible2 State: IA2_STATE_MODAL
UIA Property: Window.IsModal: true
ATK/AT-SPI State: STATE_MODAL
AX API Prune the accessibility tree such that the background content is no longer exposed. No specific property is set on the accessible object that corresponds to the element with aria-modal="true". Only the tree whose root is that modal accessible object is exposed.
aria-modal=false
aria-modal=false
MSAA + IAccessible2 State: IA2_STATE_MODAL not exposed
UIA Property: Window.IsModal: false
ATK/AT-SPI State: STATE_MODAL not exposed
AX API Grow the accessibility tree such that the background content is exposed. No specific property is set on the accessible object that corresponds to the element with aria-modal="false".
aria-multiline=true
aria-multiline=true
MSAA + IAccessible2 State: IA2_STATE_MULTI_LINE
State: IA2_STATE_SINGLE_LINE not exposed
UIA Property: AriaProperties.multiline: true
ATK/AT-SPI State: STATE_MULTI_LINE
State: STATE_SINGLE_LINE not exposed
AX API Not mapped
See also: textbox in the Role Mapping Table
aria-multiline=false
aria-multiline=false
MSAA + IAccessible2 State: IA2_STATE_SINGLE_LINE
State: IA2_STATE_MULTI_LINE not exposed
UIA Not mapped
ATK/AT-SPI State: STATE_SINGLE_LINE
State: STATE_MULTI_LINE not exposed
AX API Not mapped
See also: textbox in the Role Mapping Table
aria-multiselectable=true
aria-multiselectable=true
MSAA + IAccessible2 State: STATE_SYSTEM_MULTISELECTABLE
State: STATE_SYSTEM_EXTSELECTABLE
See also: Selection for details on accessibility events
UIA Property: Selection.CanSelectMultiple: true
See also: Selection for details on accessibility events
ATK/AT-SPI State: STATE_MULTISELECTABLE
See also: Selection for details on accessibility events
AX API Not mapped
See also: Selection for details on accessibility events
aria-multiselectable=false
aria-multiselectable=false
MSAA + IAccessible2 State: STATE_SYSTEM_MULTISELECTABLE not exposed
State: STATE_SYSTEM_EXTSELECTABLE not exposed
See also: Selection for details on accessibility events
UIA Not mapped*
ATK/AT-SPI State: STATE_MULTISELECTABLE not exposed
AX API Not mapped*
aria-orientation=horizontal
aria-orientation=horizontal
MSAA + IAccessible2 State: IA2_STATE_HORIZONTAL
State: IA2_STATE_VERTICAL not exposed
UIA Property: Orientation: horizontal
ATK/AT-SPI State: STATE_HORIZONTAL
State: STATE_VERTICAL not exposed
AX API Property: AXOrientation: AXHorizontalOrientation
aria-orientation=vertical
aria-orientation=vertical
MSAA + IAccessible2 State: IA2_STATE_VERTICAL
State: IA2_STATE_HORIZONTAL not exposed
UIA Property: Orientation: vertical
ATK/AT-SPI State: STATE_VERTICAL
State: STATE_HORIZONTAL not exposed
AX API Property: AXOrientation: AXVerticalOrientation
aria-orientation is undefined
aria-orientation is undefined
MSAA + IAccessible2 Not mapped*
UIA Not mapped*
ATK/AT-SPI State: STATE_VERTICAL not exposed
State: STATE_HORIZONTAL not exposed
AX API Property: AXOrientation: AXUnknownOrientation
aria-owns
aria-owns
MSAA + IAccessible2

User agents MAY expose the elements that are referenced by this property as children of the current element. In which case, if multiple aria-owns relationships are found, use only the first one. If the accessibility tree is not modified, expose as:

Relation: IA2_RELATION_NODE_PARENT_OF points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree
Reverse Relation: IA2_RELATION_NODE_CHILD_OF points to element
See also: Mapping Additional Relations
UIA Expose the elements that are referenced by this property as children of the current element. If multiple aria-owns relationships are found, use only the first one.
ATK/AT-SPI

User agents MAY expose the elements that are referenced by this property as children of the current element. In which case, if multiple aria-owns relationships are found, use only the first one. If the accessibility tree is not modified, expose as:

Relation: RELATION_NODE_PARENT_OF points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree
Reverse Relation: RELATION_NODE_CHILD_OF points to element
See also: Mapping Additional Relations
AX API Property: AXOwns: pointers to accessible nodes matching IDREFs
aria-placeholder
aria-placeholder
MSAA + IAccessible2 Object Attribute: placeholder-text:<value>
UIA Property: HelpText: <value>
ATK/AT-SPI Object Attribute: placeholder-text:<value>
AX API Property: AXPlaceholderValue: <value>
aria-posinset
aria-posinset
MSAA + IAccessible2 Object Attribute: posinset:<value>
See also: Group Position
UIA Property: AriaProperties.posinset: <value>
See also: Group Position
ATK/AT-SPI Object Attribute: posinset:<value>
See also: Group Position
AX API Property: AXARIAPosInSet: <value>
See also: Group Position
aria-pressed=true
aria-pressed=true
MSAA + IAccessible2 State: STATE_SYSTEM_PRESSED
See also: button with defined value for aria-pressed
UIA Property: Toggle.ToggleState: On (1)
ATK/AT-SPI State: STATE_PRESSED
See also: button with defined value for aria-pressed
AX API Property: AXValue: 1
See also: button with defined value for aria-pressed
aria-pressed=mixed
aria-pressed=mixed
MSAA + IAccessible2 State: STATE_SYSTEM_MIXED
See also: button with defined value for aria-pressed
UIA Property: Toggle.ToggleState: Indeterminate (2)
ATK/AT-SPI State: STATE_INDETERMINATE
See also: button with defined value for aria-pressed
AX API Property: AXValue: 2
See also: button with defined value for aria-pressed
aria-pressed=false
aria-pressed=false
MSAA + IAccessible2 State: STATE_SYSTEM_PRESSED not exposed
See also: button with defined value for aria-pressed
UIA Property: Toggle.ToggleState: Off (3)
ATK/AT-SPI State: STATE_PRESSED not exposed
See also: button with defined value for aria-pressed
AX API Property: AXValue: 0
See also: button with defined value for aria-pressed
aria-pressed is undefined
aria-pressed is undefined
MSAA + IAccessible2 Not mapped*
UIA Not mapped*
ATK/AT-SPI Not mapped*
AX API Not mapped*
aria-readonly=true
aria-readonly=true
MSAA + IAccessible2 State: STATE_SYSTEM_READONLY
UIA Property: Value.IsReadOnly: true
ATK/AT-SPI State: STATE_READ_ONLY
State: STATE_EDITABLE not exposed on text input roles
State: STATE_CHECKABLE not exposed on roles supporting aria-checked
State: STATE_CHECKABLE not exposed on radio descendants when used on a radiogroup
AX API Method: AXUIElementIsAttributeSettable(AXValue): NO
aria-readonly=false
aria-readonly=false
MSAA + IAccessible2 State: STATE_SYSTEM_READONLY not exposed
State: IA2_STATE_EDITABLE
UIA Property: Value.IsReadOnly: false
ATK/AT-SPI State: STATE_READ_ONLY not exposed
AX API Method: AXUIElementIsAttributeSettable(AXValue): YES
aria-readonly is unspecified on gridcell
aria-readonly is unspecified on gridcell
MSAA + IAccessible2 The gridcell MUST inherit any author-provided value for aria-readonly from the containing grid or treegrid. Expose the inherited value on the gridcell as described for aria-readonly="true" and aria-readonly="false".
UIA The gridcell MUST inherit any author-provided value for aria-readonly from the containing grid or treegrid. Expose the inherited value on the gridcell as described for aria-readonly="true" and aria-readonly="false".
ATK/AT-SPI The gridcell MUST inherit any author-provided value for aria-readonly from the containing grid or treegrid. Expose the inherited value on the gridcell as described for aria-readonly="true" and aria-readonly="false".
AX API The gridcell MUST inherit any author-provided value for aria-readonly from the containing grid or treegrid. Expose the inherited value on the gridcell as described for aria-readonly="true" and aria-readonly="false".
aria-relevant
aria-relevant
MSAA + IAccessible2 Object Attribute: relevant:<value>
Object Attribute: container-relevant:<value>
Object Attribute: container-relevant:<value> on all descendants
See also: Changes to document content or node visibility
UIA Property: AriaProperties.relevant: <value>
See also: Changes to document content or node visibility
ATK/AT-SPI Object Attribute: relevant:<value>
Object Attribute: container-relevant:<value>
Object Attribute: container-relevant:<value> on all descendants
See also: Changes to document content or node visibility
AX API Property: AXARIARelevant: <value>
See also: Changes to document content or node visibility
aria-required=true
aria-required=true
MSAA + IAccessible2 State: IA2_STATE_REQUIRED
UIA Property: IsRequiredForForm: true
ATK/AT-SPI State: STATE_REQUIRED
AX API Property: AXRequired: YES
aria-required=false
aria-required=false
MSAA + IAccessible2 Not mapped*
UIA Not mapped*
ATK/AT-SPI Not mapped*
AX API Not mapped*
aria-roledescription
aria-roledescription
MSAA + IAccessible2 Method: localizedExtendedRole(): <value>
UIA Localized Control Type: <value>
ATK/AT-SPI Object Attribute: roledescription:<value>
AX API Property: AXRoleDescription: <value>
aria-roledescription is undefined or the empty string
aria-roledescription is undefined or the empty string
MSAA + IAccessible2 Not mapped
UIA Localized Control Type is defined as that specified for the role of the element: based on the explicit role if the role attribute is provided; otherwise, based on the implicit role for the host language.
ATK/AT-SPI Not mapped
AX API AXRoleDescription is defined as that specified for the role of the element: based on the explicit role if the role attribute is provided; otherwise, based on the implicit role for the host language.
aria-rowcount
aria-rowcount
MSAA + IAccessible2 Object Attribute: rowcount:<value>
Method: IAccessible2::groupPosition(): similarItemsInGroup=<value> on rows
UIA Property: Grid.RowCount: <value>
ATK/AT-SPI Object Attribute: rowcount should contain the author-provided value.
Method: atk_table_get_n_rows() should return the actual number of rows.
AX API Property: AXARIARowCount: <value>
aria-rowindex
aria-rowindex
MSAA + IAccessible2 Object Attribute: rowindex:<value>
Method: IAccessible2::groupPosition(): positionInGroup=<value> on rows
UIA Property: GridItem.Row: <value> (zero-based)
ATK/AT-SPI Object Attribute: rowindex should contain the author-provided value.
Method: atk_table_cell_get_position() should return the actual (zero-based) row index.
AX API Property: AXARIARowIndex: <value>
aria-rowindextext
aria-rowindextext
MSAA + IAccessible2 Object Attribute: rowindextext:<value>
UIA Property: AriaProperties.rowindextext: <value>
ATK/AT-SPI Object Attribute: rowindextext:<value>
AX API Property: TBD
aria-rowspan
aria-rowspan
MSAA + IAccessible2 Object Attribute: rowspan:<value>
Method: IAccessibleTableCell::rowExtent(): column=<value>
UIA Property: GridItem.RowSpan: <value>
ATK/AT-SPI Object Attribute: rowspan should contain the author-provided value.
Method: atk_table_cell_get_row_column_span() should return the actual row span.
AX API Property: AXRowIndexRange.length: <value>
aria-selected=true
aria-selected=true
MSAA + IAccessible2 State: STATE_SYSTEM_SELECTABLE
State: STATE_SYSTEM_SELECTED
See also: Selection for details on accessibility events
UIA Property: SelectionItem.IsSelected: true
ATK/AT-SPI State: STATE_SELECTABLE
State: STATE_SELECTED
See also: Selection for details on accessibility events
AX API Property: AXSelected: YES
aria-selected=false
aria-selected=false
MSAA + IAccessible2 State: STATE_SYSTEM_SELECTABLE
State: STATE_SYSTEM_SELECTED not exposed
See also: Selection for details on accessibility events
UIA Property: SelectionItem.IsSelected: false
ATK/AT-SPI State: STATE_SELECTABLE
State: STATE_SELECTED not exposed
See also: Selection for details on accessibility events
AX API Property: AXSelected: NO
aria-selected is undefined
aria-selected is undefined
MSAA + IAccessible2 Not mapped
UIA Not mapped
ATK/AT-SPI Not mapped
AX API Not mapped
aria-setsize
aria-setsize
MSAA + IAccessible2 Object Attribute: setsize:<value>
See also: Group Position
UIA Property: AriaProperties.setsize: <value>
See also: Group Position
ATK/AT-SPI

If the author-provided value of aria-setsize is -1, the exposed value should be based on the number of objects in the DOM.

Object Attribute: setsize:<value>
State: STATE_INDETERMINATE if the author-provided value is -1
See also: Group Position
AX API Property: AXARIASetSize: <value>
See also: Group Position
aria-sort=ascending
aria-sort=ascending
MSAA + IAccessible2 Object Attribute: sort:ascending
UIA Property: AriaProperties.sort: ascending
Property: ItemStatus: ascending if the element maps to HeaderItem Control Type
ATK/AT-SPI Object Attribute: sort:ascending
AX API Property: AXSortDirection: AXAscendingSortDirection
aria-sort=descending
aria-sort=descending
MSAA + IAccessible2 Object Attribute: sort:descending
UIA Property: AriaProperties.sort: descending
Property: ItemStatus: descending if the element maps to HeaderItem Control Type
ATK/AT-SPI Object Attribute: sort:descending
AX API Property: AXSortDirection: AXDescendingSortDirection
aria-sort=other
aria-sort=other
MSAA + IAccessible2 Object Attribute: sort:other
UIA Property: AriaProperties.sort: other
Property: ItemStatus: other if the element maps to HeaderItem Control Type
ATK/AT-SPI Object Attribute: sort:other
AX API Property: AXSortDirection: AXUnknownSortDirection
aria-sort=none
aria-sort=none
MSAA + IAccessible2 Object Attribute: sort:none, if the value is not unspecified
UIA Not mapped*
ATK/AT-SPI Object Attribute: sort:none, if the value is not unspecified
AX API Not mapped*
aria-valuemax
aria-valuemax
MSAA + IAccessible2 Method: IAccessibleValue::maximumValue(): <value>
See also: Handling Author Errors for States and Properties
UIA Property: RangeValue.Maximum: <value>
See also: Handling Author Errors for States and Properties
ATK/AT-SPI Method: atk_value_get_maximum_value(): <value>
See also: Handling Author Errors for States and Properties
AX API Property: AXMaxValue: <value>
See also: Handling Author Errors for States and Properties
aria-valuemin
aria-valuemin
MSAA + IAccessible2 Method: IAccessibleValue::minimumValue(): <value>
See also: Handling Author Errors for States and Properties
UIA Property: RangeValue.Minimum: <value>
See also: Handling Author Errors for States and Properties
ATK/AT-SPI Method: atk_value_get_minimum_value(): <value>
See also: Handling Author Errors for States and Properties
AX API Property: AXMinValue: <value>
See also: Handling Author Errors for States and Properties
aria-valuenow
aria-valuenow
MSAA + IAccessible2 Method: IAccessibleValue::currentValue(): <value>
Method: IAccessible::get_accValue(): <value> if aria-valuetext is not defined
See also: Handling Author Errors for States and Properties
UIA Property: RangeValue.Value: <value>
See also: Handling Author Errors for States and Properties
ATK/AT-SPI Method: atk_value_get_current_value(): <value>
See also: Handling Author Errors for States and Properties
AX API Property: AXValue: <value>
See also: Handling Author Errors for States and Properties
aria-valuetext
aria-valuetext
MSAA + IAccessible2 Method: IAccessible::get_accValue(): <value>
Object Attribute: valuetext:<value>
See also: Handling Author Errors for States and Properties
UIA Property: Value.Value: <value>
See also: Handling Author Errors for States and Properties
ATK/AT-SPI Object Attribute: valuetext:<value>
See also: Handling Author Errors for States and Properties
AX API Property: AXValueDescription: <value>
See also: Handling Author Errors for States and Properties

4.6 Special Processing Requiring Additional Computation

4.6.1 Name and Description

For information on how to compute an accessible name or accessible description, see the section titled Accessible Name and Description Computation of the Accessible Name and Description Computation specification.

4.6.2 Relations

Often in a GUI, there are relationships between the widgets that can be exposed programmatically to assistive technology. WAI-ARIA provides several relationship properties which are globally applicable to any element: aria-controls, aria-describedby, aria-flowto, aria-labelledby, aria-owns, aria-posinset, and aria-setsize. Therefore, it is not important to check the role before computing them. User agents can simply map these relations to accessibility APIs as defined in the section titled State and Property Mapping.

4.6.2.1 Reverse Relations

A reverse relation exists when an element's ID is referenced by a property in another element. For APIs that support reverse relations, user agents MUST use the mapping defined in the State and Property Mapping Table when an element's ID is referenced by a relation property of another element and the referenced element is in the accessibility tree. All WAI-ARIA references must point to an element that is exposed as an accessible object in the accessibility tree. When the referenced object is not exposed in the accessibility tree (e.g. because it is hidden), the reference is null. aria-labelledby and aria-describedby have an additional feature, which allows them to pull a flattened string from the referenced element to populate the name or description fields of the accessibility API. This feature is described in the Name and Description section.

Special case: If both aria-labelledby and HTML <label for= … > are used, the user agent MUST use the WAI-ARIA relation and MUST ignore the HTML label relation.

Note that aria-describedby may reference structured or interactive information where users would want to be able to navigate to different sections of content. User agents MAY provide a way for the user to navigate to structured information referenced by aria-describedby and assistive technology SHOULD provide such a method.

4.6.2.2 Implied reverse relations

In addition to the explicit relations defined by WAI-ARIA properties, reverse relations are implied in two other situations: elements with role="treeitem" where the ancestor does not have an aria-owns property and descendants of elements with aria-atomic property.

In the case of role="treeitem", when aria-owns is not used, user agents SHOULD do the following where reverse relations are supported by the API:

  • If the current treeitem uses aria-level, then walk backwards in the tree until a treeitem is found with a lower aria-level, then set RELATION_NODE_CHILD_OF to that element. If the top of the tree is reached, then set RELATION_NODE_CHILD_OF to the tree element itself.
  • If the parent of the treeitem has a role of group, then walk backwards from the group until an element with a role of treeitem is found, then set RELATION_NODE_CHILD_OF to that element.

In the case of aria-atomic, where reverse relations are supported by the API:

  • User agents SHOULD check the chain of ancestor elements for aria-atomic="true". If found, user agents SHOULD set the RELATION_MEMBER_OF relation to point to the ancestor that sets aria-atomic="true".

4.6.3 Group Position

aria-level, aria-posinset, and aria-setsize are all 1-based. When the property is not present or is "0", it indicates the property is not computed or not supported. If any of these properties are specified by the author as either "0" or a negative number, user agents SHOULD use "1" instead.

If aria-level is not provided or inherited for an element of role treeitem or comment, user agents implementing IAccessible2 or ATK/AT-SPI MUST compute it by following the explicit or computed RELATION_NODE_CHILD_OF relations.

If aria-posinset and aria-setsize are not provided, user agents MUST compute them as follows:

  • for role="treeitem" and role="comment", walk the tree backward and forward until the explicit or computed level becomes less than the current item's level. Count items only if they are at the same level as the current item.
  • Otherwise, if the role supports aria-posinset and aria-setsize, process the parent (DOM parent or parent defined by aria-owns), counting items that have the same role.
  • Because these value are 1-based, include the current item in the computation. For aria-posinset, include the current item and other group items if they are before the current item in the DOM. For aria-setsize, add to that the number of items in the same group after the current item in the DOM.

If the author provides one or more of aria-setsize and aria-posinset, it is the author's responsibility to supply them for all elements in the set. User agent correction of missing values in this case is not defined.

MSAA/IAccessible2 API mappings involve an additional function, groupPosition() [IAccessible2], when aria-level, aria-posinset, and/or aria-setsize are present on an element, or are computed by the user agent. When this occurs:

  • aria-level is exposed in the groupLevel parameter of groupPosition(),
  • aria-setsize is exposed in the similarItemsInGroup parameter, and
  • aria-posinset is exposed in the positionInGroup parameter.

4.7 Actions

As part of mapping roles to accessible objects as defined in Role Mapping, users agents expose a default action on the object.

Note

Authors will need to create handlers for those click events that update WAI-ARIA states and properties in the DOM accordingly, so that those updated states can be populated by the user agent in the Accessibility API.

4.8 Events

User agents fire events for user actions, WAI-ARIA state changes, changes to document content or node visibility, changes in selection and operation of menus as defined in the following sections.

4.8.1 State and Property Change Events

User agents MUST notify assistive technology of state changes as defined in the table below, SHOULD notify assistive technology of property changes if the accessibility API defines a change event for the property, and SHOULD NOT notify assistive technology of property changes if the accessibility API does not define a change event for the property. For example, IAccessible2 defines an event to be used when aria-activedescendant changes. WAI-ARIA properties that are expected to change include aria-activedescendant, aria-valuenow, and aria-valuetext.

Note

In some APIs, AT will only be notified of events to which it has subscribed.

For simplicity and performance the user agent MAY trim out change events for state or property changes that assistive technologies typically ignore, such as events that are happening in a window that does not currently have focus.

Note

Translators: For label text associated with the following table and its toggle buttons, see the mappingTableLabels object in the <head> section of this document.

aria-activedescendant
aria-activedescendant
MSAA + IAccessible2 event See Focus Changes.

In addition:

IA2_EVENT_ACTIVE_DESCENDANT_CHANGED

UIA eventSee Focus Changes.

In addition:

PropertyChangedEvent

Property: AriaProperties

ATK/AT-SPI eventSee Focus Changes.
AX API NotificationSee Focus Changes.

In addition: AXSelectedChildrenChanged

aria-busy (state)
aria-busy (state)
MSAA + IAccessible2 event EVENT_OBJECT_STATECHANGE
UIA event PropertyChangedEvent

Property: AriaProperties

ATK/AT-SPI eventobject:state-changed:busy
AX API NotificationAXElementBusyChanged
aria-checked (state)
aria-checked (state)
MSAA + IAccessible2 event EVENT_OBJECT_STATECHANGE
UIA event PropertyChangedEvent

Properties: AriaProperties, ToggleState as part of toggle pattern

ATK/AT-SPI eventobject:state-changed:checked
AX API NotificationAXValueChanged
aria-current (state)
aria-current (state)
MSAA + IAccessible2 event IA2_EVENT_OBJECT_ATTRIBUTE_CHANGED
UIA event PropertyChangedEvent

Property: AriaProperties

ATK/AT-SPI eventobject:state-changed:active
AX API NotificationNo notification
aria-disabled (state)
aria-disabled (state)
MSAA + IAccessible2 event EVENT_OBJECT_STATECHANGE
UIA event PropertyChangedEvent

Properties: AriaProperties, IsEnabled

ATK/AT-SPI eventobject:state-changed:enabled and object:state-changed:sensitive
AX API NotificationNo notification
aria-describedby
aria-describedby
MSAA + IAccessible2 event EVENT_OBJECT_DESCRIPTIONCHANGE
UIA event PropertyChangedEvent

Properties: DescribedBy

ATK/AT-SPI eventobject:property-change:accessible-description
AX API NotificationTBD
aria-dropeffect (property)
aria-dropeffect (property)
MSAA + IAccessible2 event IA2_EVENT_OBJECT_ATTRIBUTE_CHANGED
UIA event PropertyChangedEvent

Property: AriaProperties

ATK/AT-SPI eventobject:property-change
AX API NotificationNo notification
aria-expanded (state)
aria-expanded (state)
MSAA + IAccessible2 event EVENT_OBJECT_STATECHANGE
UIA event PropertyChangedEvent

Properties: AriaProperties, ExpandCollapseState as part of the ExpandCollapse pattern

ATK/AT-SPI eventobject:state-changed:expanded
AX API NotificationAXRowExpanded,
AXRowCollapsed,
AXRowCountChanged
aria-grabbed (state)
aria-grabbed (state)
MSAA + IAccessible2 event

EVENT_OBJECT_SELECTION

IA2_EVENT_OBJECT_ATTRIBUTE_CHANGED

UIA event PropertyChangedEvent

Property: AriaProperties

ATK/AT-SPI eventobject:property-change
AX API NotificationNo notification
aria-hidden (state)
aria-hidden (state)
MSAA + IAccessible2 event IA2_EVENT_OBJECT_ATTRIBUTE_CHANGED
UIA event StructureChangedEvent

PropertyChangedEvent

Property: AriaProperties

ATK/AT-SPI eventobject:property-change
AX API NotificationAXUIElementDestroyed,
AXUIElementCreated
aria-invalid (state)
aria-invalid (state)
MSAA + IAccessible2 event EVENT_OBJECT_STATECHANGE
UIA event PropertyChangedEvent

Properties: AriaProperties, IsDataValidForForm

ATK/AT-SPI eventobject:state-changed:invalid_entry
AX API NotificationAXInvalidStatusChanged
aria-label and aria-labelledby
aria-label and aria-labelledby
MSAA + IAccessible2 event EVENT_OBJECT_NAMECHANGE
UIA event PropertyChangedEvent

Property for aria-label: AriaProperties

Property for aria-labelledby: LabeledBy

ATK/AT-SPI eventobject:property-change:accessible-name
AX API NotificationTBD
aria-pressed (state)
aria-pressed (state)
MSAA + IAccessible2 event EVENT_OBJECT_STATECHANGE
UIA event PropertyChangedEvent

Properties: AriaProperties, ToggleState as part of toggle pattern

ATK/AT-SPI eventobject:state-changed:pressed
AX API NotificationNo notification
aria-readonly
aria-readonly
MSAA + IAccessible2 event EVENT_OBJECT_STATECHANGE
UIA event PropertyChangedEvent

Property: AriaProperties

ATK/AT-SPI eventobject:state-changed:readonly
AX API NotificationNo notification
aria-required
aria-required
MSAA + IAccessible2 event EVENT_OBJECT_STATECHANGE
UIA event PropertyChangedEvent

Properties: AriaProperties, IsRequiredForForm

ATK/AT-SPI eventobject:state-changed:required
AX API NotificationNo notification
aria-selected (state)
aria-selected (state)
MSAA + IAccessible2 event See section Selection for details.
UIA eventSee section Selection for details.
ATK/AT-SPI eventSee section Selection for details.
AX API NotificationSee section Selection for details.
aria-valuenow
aria-valuenow
MSAA + IAccessible2 event EVENT_OBJECT_VALUECHANGE
UIA event PropertyChangedEvent

Properties: AriaProperties, also RangeValueValue if element is mapped with RangeValue Control Pattern

ATK/AT-SPI eventobject:property-change:accessible-value
AX API NotificationAXValueChanged
aria-valuetext
aria-valuetext
MSAA + IAccessible2 event EVENT_OBJECT_VALUECHANGE
UIA event PropertyChangedEvent

Property: AriaProperties

ATK/AT-SPI eventobject:property-change:accessible-value
AX API NotificationAXValueChanged

4.8.2 Changes to document content or node visibility

Processing document changes is important regardless of WAI-ARIA. The events described in the table below are used by user agents to inform AT of changes to the DOM via the accessibility tree. For the purposes of conformance with this standard, user agents MUST implement the behavior described in this section whenever WAI-ARIA attributes are applied to dynamic content on a Web page.

Table of document change scenarios and events to be fired in each API
Scenario MSAA + IAccessible2 event UIA event ATK/AT-SPI event AX API Notification
When text is removed IA2_EVENT_TEXT_REMOVED EVENT_OBJECT_LIVEREGIONCHANGED text_changed::delete If in a live region, AXLiveRegionChanged.
If in aria-errormessage, AXValidationErrorChanged.
When text is inserted IA2_EVENT_TEXT_INSERTED EVENT_OBJECT_LIVEREGIONCHANGED text_changed::insert If in a live region, AXLiveRegionChanged.
If in aria-errormessage, AXValidationErrorChanged.
When text is changed IA2_EVENT_TEXT_REMOVE and IA2_EVENT_TEXT_INSERTED EVENT_OBJECT_LIVEREGIONCHANGED text_changed::delete and text_changed::insert If in a live region, AXLiveRegionChanged.
If in aria-errormessage, AXValidationErrorChanged.

Fire these events for node changes where the node in question is an element and has an accessible object:

Table of document change scenarios and events to be fired in each API
Scenario MSAA Microsoft UIA event ATK/AT-SPI event AX API Notification
When an accessibility subtree is hidden EVENT_OBJECT_HIDE
The MSAA event called EVENT_OBJECT_DESTROY is not used because this has a history of stability issues and assistive technology avoids it. In any case, from the user's point of view, there is no difference between something that is hidden or destroyed. 		AutomationElement..::.StructureChangedEvent children_changed::remove

AXUIElementDestroyed

If in a live region, AXLiveRegionChanged
When an accessibility subtree is removed EVENT_OBJECT_REORDER
The MSAA event called EVENT_OBJECT_DESTROY is not used because this has a history of stability issues and assistive technology avoids it. In any case, from the user's point of view, there is no difference between something that is hidden or destroyed. 		AutomationElement..::.StructureChangedEvent children_changed::remove

AXUIElementDestroyed

If in a live region, AXLiveRegionChanged
When an accessibility subtree is shown EVENT_OBJECT_SHOW   children_changed::add

AXUIElementCreated

If in a live region, AXLiveRegionChanged
When an accessibility subtree is inserted EVENT_OBJECT_REORDER   children_changed::add

AXUIElementCreated

If in a live region, AXLiveRegionChanged
When an accessibility subtree is moved Treat it as a removal from one place and insertion in another Treat it as a removal from one place and insertion in another Treat it as a removal from one place and insertion in another

AXUIElementDestroyed/ AXUIElementCreated

If in a live region, AXLiveRegionChanged
When an accessibility subtree is changed (e.g. replaceNode) Treat it as a removal and insertion Treat it as a removal and insertion Treat it as a removal and insertion

AXUIElementDestroyed/ AXUIElementCreated

If in a live region, AXLiveRegionChanged

In some cases, node changes may occur where the node is not an element or has no accessible object. For example, a numbered list bullet ("12.") may have a node in the accessibility tree but not in the DOM tree. For text within a paragraph marked in HTML as <strong>, the <strong> element has a node in the DOM tree but may not have one in the accessibility tree. The text itself will of course be in the accessibility tree along with the identification of the range of text that is formatted as strong. If any of the changes described in the table above occur on such a node, user agents SHOULD compute and fire relevant text change events as described above.

User agents SHOULD ensure that an assistive technology, running in process can receive notification of a node being removed prior to removal. This allows an assistive technology, such as a screen reader, to refer back to the corresponding DOM node being deleted. This is important for live regions where removals are important. For example, a screen reader would want to notify a user that another user has left a chat room. The event in MSAA would be EVENT_OBJECT_HIDE. For ATK/AT-SPI this would be children_changed::remove. And in macOS, the event is AXLiveRegionChanged. This also requires the user agent to provide a unique ID in the accessibility API notification identifying the unique node being removed.

When firing any of the above-mentioned change events, it is very useful to provide information about whether the change was caused by user input (as opposed to a timeout initiated from the page load, etc.). This allows the assistive technology to have different rules for presenting changes from the real world as opposed to from user action. Mouse hovers are not considered explicit user input because they can occur from accidental bumps of the mouse.

To expose whether a change occurred from user input:

  • In ATK/AT-SPI this can be provided by appending the string ":system" to the event name when the user did not cause the change.
  • In IAccessible2, which screen readers typically access in process on the same thread, the best practice is to expose the object attribute event-from-user-input:true on the accessible object for the event, if the user caused the change.

Exposing additional useful information about the context of the change:

  • In ATK/AT-SPI and IAccessible2, the RELATION_MEMBER_OF relation on the accessible event's target accessible object SHOULD point to any ancestor with aria-atomic="true" (if any).
  • In ATK/AT-SPI and IAccessible2, the container-live, container-relevant, container-busy, container-atomic object attributes SHOULD be exposed on the accessible event object, providing the computed value for the related WAI-ARIA properties. The computed value is the value of the closest ancestor. It is recommended to not expose the object attribute if the default value is used.

Additional MSAA events may be necessary:

  • If something changes in an ancestor with a mapped MSAA role of ROLE_SYSTEM_ALERT, then an EVENT_SYSTEM_ALERT event SHOULD be fired for the alert. The alert role has an implied value of "assertive" for the aria-live property.
  • Menu events may need to be fired. See Special Events for Menus.

4.8.3 Focus Changes

The following table defines the accessibility API keyboard focus states and events.

Table of accessibility APIs for focus states and events
  MSAA Microsoft UIA ATK/AT-SPI AX API
Focusable state STATE_SYSTEM_FOCUSABLE Current state reflected in IUIAutomationElement::CurrentIsKeyboardFocusable, can be retrieved with IUIAutomationElement::GetCurrentPropertyValue method using UIA_IsKeyboardFocusablePropertyId property identifier. STATE_FOCUSABLE boolean AXFocused: the AXUIElementIsAttributeSettable method returns YES.
Focused state STATE_SYSTEM_FOCUSED Current state reflected in IUIAutomationElement::CurrentHasKeyboardFocus, can be retrieved with IUIAutomationElement::GetCurrentPropertyValue method using UIA_HasKeyboardFocusPropertyId property identifier. STATE_FOCUSED boolean AXFocused
Focus event EVENT_OBJECT_FOCUS Clients can subscribe with IUIAutomation::AddFocusChangedEventHandler using callback interface is IUIAutomationFocusChangedEventHandler object:state-changed:focused and: AXFocusedUIElementChanged

4.8.4 Selection

There are two cases for selection:

  • Single selection
  • Multiple selection

In the single selection case, selection follows focus (see the section "Focus States and Events Table" for information about focus events). User agents MUST fire the following events when aria-selected changes:

Single selection events
Scenario MSAA Microsoft UIA ATK/AT-SPI AX API
Focus change EVENT_OBJECT_SELECTION and EVENT_OBJECT_STATECHANGE on newly focused item. UIA_SelectionItem_ElementSelectedEventId on the newly focused element.

If on a gridcell, row, option, or tab, fire UIA_SelectionItem_ElementSelectedEventId.
  • object:selection-changed on the current container,
  • object:state-changed:selected on the descendant accessible object whose selection has changed:
    • detail1 = 1 for the descendant which just became selected.
    • detail1 = 0 for the descendant which just became unselected.
 AXSelectedChildrenChanged

The multiple selection case occurs when aria-multiselectable="true" on an element with a role that supports that property. User agents MUST fire the following events when aria-selected changes on a descendant, as follows:

The multiple selection case occurs when aria-multiselectable="true" on an element with a role that supports that property. There are several important aspects:

  1. In Microsoft UIA, the Selection and SelectionItem Control Patterns expose the selection availability, state, and methods.
  2. User agents MUST fire the following events when aria-selected changes on a descendant, as follows:
Multiple selection events
Scenario MSAA Microsoft UIA ATK/AT-SPI AX API
Toggle aria-selected EVENT_OBJECT_SELECTIONADD/EVENT_OBJECT_SELECTIONREMOVE on the item. SelectionItem Control Pattern:UIA_SelectionItem_ElementAddedToSelectionEventId or UIA_SelectionItem_ElementRemovedFromSelectionEventId on the item.
  • object:selection-changed on the current container,
  • object:state-changed:selected on any descendant accessible object whose selection has changed:
    • detail1 = 1 for any descendant which just became selected.
    • detail1 = 0 for any descendant which just became unselected.
 AXSelectedChildrenChanged
Selection follows focus EVENT_OBJECT_SELECTION and EVENT_OBJECT_STATECHANGE on newly focused item. FocusChangedEvent should be fired but individual selection event may not happen, to avoid redundancy.
  • object:selection-changed on the current container,
  • object:state-changed:selected on any descendant accessible object whose selection has changed:
AXSelectedChildrenChanged
Select or deselect many items at once User agent MAY fire an EVENT_OBJECT_SELECTIONWITHIN. If this event is fired the other events noted above MAY be trimmed out for performance. For each element selected or deselected, fire SelectionItem Control Pattern: UIA_SelectionItem_ElementAddedToSelectionEventId or UIA_SelectionItem_ElementRemovedFromSelectionEventId on the current container. User agents MAY choose to fire the Selection Control Pattern Invalidated event, which indicates that the selection in a container has changed significantly and requires sending more addition and removal events than the InvalidateLimit constant permits.
  • the user agent MAY fire a single object:selection-changed event on the container, vs. multiple events, for performance,
  • object:state-changed:selected on any descendant accessible object whose selection has changed:
AXSelectedChildrenChanged

4.8.5 Special Events for Menus

Some APIs, provide special events whenever a menu is opened or closed. User agents SHOULD provide the events as described in the table below. If provided, because menus can be made visible or hidden using a variety of techniques, a user agent MUST ensure that the events are nested and symmetrical.

Frequently, a menubar is used to organize a hierarchy of menus. In those cases, the menubar MUST be a DOM parent of the associated menuitems, or one defined by aria-owns. In other cases, no menubar is involved; for example, when the menu is associated with a toolbar button, or is a context menu. Nonetheless the relevant menu events are provided as described in the following table.

Menu events
Scenario MSAA Microsoft UIA AX API

Menubar is currently not active, and user moves focus to the menubar from elsewhere thereby activating it. As a result, a menuitem in the menubar is focused.

Activate the menubar and fire EVENT_SYSTEM_MENUSTART on the accessible object for the menubar. MenuModeStartEvent on the accessible object for the menu. AXMenuOpenedNotification

Focus a menuitem while menubar is activated, or focus a menuitem in a menu.

 EVENT_OBJECT_FOCUS AutomationFocusChangedEvent AXMenuItemSelectedNotification

Menu popup made visible (menu is opened).

Should only be fired once until the menu is closed and opened again.

 EVENT_SYSTEM_MENUPOPUPSTART MenuOpenedEvent, then a focus event on a menuitem. AXMenuOpenedNotification
Menu popup hidden (menu is closed). EVENT_SYSTEM_MENUPOPUPEND once only for accessible menu object and only if EVENT_SYSTEM_MENUPOPUPSTART was fired for it. MenuClosedEvent AXMenuClosedNotification
Any open menus are closed including sub-menus, and user moves focus away from the menubar; menubar is deactivated. EVENT_SYSTEM_MENUEND on the menubar and deactivate the menubar. MenuClosedEvent, then MenuModeEndEvent AXMenuClosedNotification

5. Privacy considerations

In accordance with Web Platform Design Principles, this specification provides no programmatic interface to determine if information is being used by Assistive Technologies. However, this specification does allow an author to present different information to users of Assistive Technologies from the information available to users who do not use Assistive Technologies. This is possible using many features of the ARIA and CORE-AAM specifications, just as this is possible using many other parts of the web technology stack. This content disparity could be abused to perform active fingerprinting of users of Assistive Technologies.

6. Security considerations

This specification introduces no new security considerations.

A. Change Log

A.1 Substantive changes since the last public working draft

A.2 Substantive changes since the Core Accessibility API Mappings 1.1 Recommendation

B. Acknowledgments

This section is non-normative.

The following people contributed to the development of this document.

B.1 Participants active in the ARIA WG at the time of publication

B.2 Other ARIA contributors, commenters, and previously active participants

B.3 Enabling funders

This publication has been funded in part with U.S. Federal funds from the Department of Education, National Institute on Disability, Independent Living, and Rehabilitation Research (NIDILRR), initially under contract number ED-OSE-10-C-0067, then under contract number HHSP23301500054C, and now under HHS75P00120P00168. The content of this publication does not necessarily reflect the views or policies of the U.S. Department of Education, nor does mention of trade names, commercial products, or organizations imply endorsement by the U.S. Government.

C. References

C.1 Normative references

[IAccessible2]
IAccessible2. Linux Foundation. URL: https://wiki.linuxfoundation.org/accessibility/iaccessible2/
[infra]
Infra Standard. Anne van Kesteren; Domenic Denicola. WHATWG. Living Standard. URL: https://infra.spec.whatwg.org/
[RFC2119]
Key words for use in RFCs to Indicate Requirement Levels. S. Bradner. IETF. March 1997. Best Current Practice. URL: https://www.rfc-editor.org/rfc/rfc2119
[RFC8174]
Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words. B. Leiba. IETF. May 2017. Best Current Practice. URL: https://www.rfc-editor.org/rfc/rfc8174
[WAI-ARIA-1.2]
Accessible Rich Internet Applications (WAI-ARIA) 1.2. Michael Cooper; James Nurthen; Joanmarie Diggs; Carolyn MacLeod. W3C. 28 March 2023. W3C Proposed Recommendation. URL: https://www.w3.org/TR/wai-aria-1.2/

C.2 Informative references

[accname-1.2]
Accessible Name and Description Computation 1.2. Bryan Garaventa; Joanmarie Diggs; Michael Cooper. W3C. 11 July 2019. W3C Working Draft. URL: https://www.w3.org/TR/accname-1.2/
[AT-SPI]
Assistive Technology Service Provider Interface. The GNOME Project. URL: https://developer-old.gnome.org/libatspi/stable/
[ATK]
ATK - Accessibility Toolkit. The GNOME Project. URL: https://developer.gnome.org/atk/stable/
[AXAPI]
The NSAccessibility Protocol for macOS. Apple, Inc. URL: https://developer.apple.com/documentation/appkit/nsaccessibility
[CORE-AAM-1.1]
Core Accessibility API Mappings 1.1. Joanmarie Diggs; Joseph Scheuhammer; Richard Schwerdtfeger; Michael Cooper; Andi Snow-Weaver; Aaron Leventhal. W3C. 14 December 2017. W3C Recommendation. URL: https://www.w3.org/TR/core-aam-1.1/
[dom]
DOM Standard. Anne van Kesteren. WHATWG. Living Standard. URL: https://dom.spec.whatwg.org/
[UI-AUTOMATION]
UI Automation. Microsoft Corporation. URL: https://docs.microsoft.com/en-us/windows/win32/winauto/ui-automation-specification
[UIA-EXPRESS]
The IAccessibleEx Interface. Microsoft Corporation. URL: https://docs.microsoft.com/en-us/windows/win32/winauto/iaccessibleex
[wai-aria]
Accessible Rich Internet Applications (WAI-ARIA) 1.0. James Craig; Michael Cooper et al. W3C. 20 March 2014. W3C Recommendation. URL: https://www.w3.org/TR/wai-aria/
[WAI-ARIA-PRACTICES-1.2]
WAI-ARIA Authoring Practices 1.2. Matthew King; JaEun Jemma Ku; James Nurthen; Zoë Bijl; Michael Cooper. W3C. 19 May 2022. W3C Working Group Note. URL: https://www.w3.org/TR/wai-aria-practices-1.2/
[WAI-ARIA-ROADMAP]
Roadmap for Accessible Rich Internet Applications (WAI-ARIA Roadmap). Richard Schwerdtfeger. W3C. 4 February 2008. W3C Working Draft. URL: https://www.w3.org/TR/wai-aria-roadmap/