W3C

States and Properties Module for Accessible Rich Internet Applications (WAI-ARIA States and Properties)

Syntax for adding accessible state information and author settable properties for XML

W3C Working Draft 1 June 2007

This version:
http://www.w3.org/TR/2007/WD-aria-state-20070601/
Latest version:
http://www.w3.org/TR/aria-state/
Previous version:
http://www.w3.org/TR/2006/WD-aria-state-20061220/
Editors:
Lisa Seeman, UB Access
Michael Cooper, W3C
Principal Authors:
Lisa Seeman, UB Access
Rich Schwerdtfeger, IBM
Aaron Leventhal, IBM

Abstract

The attributes defined in this specification enable XML [XML] languages to add information about the behavior of an element. States and Properties are mapped to accessibility frameworks (such as a screen reader) that use this information to provide alternative access solutions. Similarly, States and Properties can be used to change the rendering of content dynamically using different style sheet properties. The result is an interoperable method for associating behaviors with document-level markup.

This document and the Roles for Accessible Rich Internet Applications (WAI-ARIA Roles) [ARIA_ROLE] fill information gaps identified by the Roadmap for Accessible Rich Internet Applications (WAI-ARIA Roadmap) [ARIA-ROADMAP] to enable accessible dynamic Web content and applications. The WAI-ARIA Roadmap performs the gap analysis identifying what technology is needed to keep the new, richly interactive Web universally accessible. The WAI-ARIA Roles specification sets out an abstract model of building blocks for accessible interfaces. This includes interactive widgets, navigable structures, and an extension mechanism. This specification creates a language module implementing the functional requirements of the abstract model that is ready for incorporation in content format profiles that follow the methods of XHTML Modularization [XHTMLMOD]. It also introduces one such profile for the use of this module in XHTML.

Status of This Document

This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.

This document is a Working Draft by the Protocols & Formats Working Group of the Web Accessibility Initiative. This version provides additional states and properties to improve alignment with accessibility APIs, and documents applicability to the roles defined in Roles for Accessible Rich Internet Applications (WAI-ARIA Roles) [ARIA_ROLE]. Some now apply to all roles or all elements of the host language. The document has also been restructured for easier comprehension, and explanatory materials expanded. Refer to the history of changes to WAI-ARIA States and Properties for more details.

Feedback on the module provided here is essential to the ultimate success of the Web in creating Rich Internet Applications that afford full access to their information and operations. The PFWG asks in particular:

Comments on this document may be sent to public-pfwg-comments@w3.org (Archive).

Publication as a Working Draft does not imply endorsement by the W3C Membership. 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 5 February 2004 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.

The disclosure obligations of the Participants of this group are described in the charter.

Table of Contents

  1. 1 Introduction
    1. 1.1 Terms and Definitions
    2. 1.2 Design Aims
    3. 1.3 Building Accessible Applications
  2. 2 The States and Properties Module
    1. 2.1 Using States and Properties Attached to an Element
    2. 2.2 Examples
  3. 3 Conformance Requirements
    1. 3.1 Document Conformance
    2. 3.2 Host Language Conformance
    3. 3.3 User Agent Conformance
  4. 4 Supported States and Properties
    1. 4.1 Widget states
    2. 4.2 Live Regions
    3. 4.3 Drag and Drop
    4. 4.4 Focus
    5. 4.5 Relationships
    6. 4.6 Uncategorized states
  5. 5 Appendices
    1. 5.1 Index of States and Properties
    2. 5.2 DTD Implementation
    3. 5.3 Managed States
    4. 5.4 Mapping States and Properties to Accessibility
    5. 5.5 References
    6. 5.6 Acknowledgments (Non-Normative)

1 Introduction

This section is informative.

The domain of Web accessibility defines how to make Web content usable by people with disabilities. People with some types of disabilities use Assistive Technology (AT) to interact with content. AT can transform the presentation of content into a format more suitable to the user, and can allow the user to interact in different ways than the author designed. In order to accomplish this, AT must understand the semantics of the content. Semantics are knowledge of roles, states, and properties, as a person would understand them, that apply to elements within the content. For instance, if a paragraph is semantically identified as such, AT can interact with it as a unit separable from the rest of the content, knowing the exact boundaries of that paragraph. A slider or tree control is a more complex example, in which various parts of a widget each have semantics that must be properly identified for the computer to support effective interaction.

Established content technologies define semantics for elements commonly used in those technologies. However, new technologies can overlook some of the semantics required for accessibility. Furthermore, new authoring practices evolve which override the intended semantics—elements that have one defined semantic meaning in the technology are used with a different semantic meaning intended to be understood by the user.

For example, Dynamic HTML can be used to present a tree control even though HTML lacks a semantic element for that. A different element must be used, possibly a list element with display instructions to make it look and behave like a tree control. Assistive technology, however, must re-present the element in a different modality and the display instructions may not be applicable. The AT will present it as a list, which has very different display and interaction from a tree control, and the user may be unsuccessful at understanding and operating the control.

Roles for Accessible Rich Internet Applications [ARIA_ROLE] provides a way to identify element types that do not change with time or user actions. Changeable states and properties of elements are defined in this specification. States and Properties are used to declare important properties of an element that affect and describe interaction. These properties enable the user agent or operating system to properly handle the element—even when these properties are altered dynamically by scripts. For example, alternative input and output technology such as screen readers, speech dictation software and on-screen keyboards must recognize the state of an element (such as: if an object is disabled, checked, focused, collapsed, hidden, etc.).

While it is possible for assistive technologies to access these properties through the Document Object Model [DOM], the preferred mechanism is for the user agent to map the States and Properties to the accessibility API of the operating system.

Figure 1.0 illustrates a typical Document Object Model (DOM) [DOM] node. Placed within the DOM node and the assistive technology is a box containing the contract provided by the user agent to the assistive technology. This data includes typical accessibility information found in the accessibility API for many of our accessible platforms for GUIs (role, state, caret, selection, event notification, parent/child information, relationship, and descriptions).

The contract model with accessibility APIs

Figure 1: The contract model with accessibility APIs

For more information see the Roadmap for Accessible Rich Internet Applications for the use of roles in making interactive content accessible.

1.1 Terms and Definitions

While some terms are defined in place, the following definitions are used throughout this document. Familiarity with W3C XHTML 1.1 Recommendation [XHTML] and the W3C XML 1.0 Recommendation [XML] is highly recommended to understand these definitions.

Accessibility API
Operating systems and other platforms provide a set of interfaces that expose information about objects and events to assistive technology. Assistive technology uses these interfaces to get information about and interact with those controls. Examples of this are the Java Accessibility API [JAPI], Microsoft Active Accessibility [MSAA], Apple Accessibility for COCOA [AAC], the Gnome Accessibility Toolkit (ATK) [GAP], and IAccessible2 [IA2].
Functionality
Processes and outcomes achievable through user action
User Agent
Any software that retrieves and renders Web content for users, such as Web browsers, media players, plug-ins, and other programs including assistive technologies that help retrieve and render Web content.
Assistive Technology
A user agent that:
  1. Provides services beyond those offered by the host user agents to meet the requirements of users with disabilities. Additional services include alternative renderings (e.g., as synthesized speech or magnified content), alternative input methods (e.g., voice), additional navigation or orientation mechanisms, and content transformations (e.g., to make tables more accessible).
  2. Relies on services (such as retrieving Web content and parsing markup) provided by one or more other "host" user agents. Assistive technologies communicate data and messages with host user agents by using and monitoring APIs, especially Accessibility APIs.
Examples of assistive technologies that are important in the context of this document include the following:
  • Screen magnifiers, which are used by people with visual disabilities to enlarge and change colors on the screen to improve the visual readability of rendered text and images;
  • Screen readers, which are used by people who are blind or have reading disabilities to read textual information through synthesized speech or braille displays;
  • Voice recognition software, which may be used by people who have some physical disabilities;
  • Alternative keyboards, which are used by people with certain physical disabilities to simulate the keyboard;
  • Alternative pointing devices, which are used by people with certain physical disabilities to simulate mouse pointing and button activations.
Note: This definition is based on the definition in Web Content Accessibility Guidelines 2.0 [WCAG20, Appendix A].

1.2 Design Aims

This section is informative.

The design aims of creating this specification include:

1.3 Building Accessible Applications

This section is informative.

An application becomes accessible when:

  1. Each element or widget has with full and correct semantics that completely describes its behavior (using element names or roles).
  2. The relationships between elements and groups are known.
  3. States, properties, and relationships are valid for each element's behavior and are accessible via the Document Object Model [DOM].
  4. Allow script author to move focus to allow all document elements in the body to receive focus with or without effecting the tab order.

Features of the States and Properties Module can be used to provide information about any missing states, properties, and relationships that the assistive technology needs to understand the behavior of the elements inside the application.

States and Properties can be used to assign meaningful properties that change with time and events. For element types and semantics that do not change with time, use a role taxonomy such as such as that defined in Roles for Accessible Rich Internet Applications [ARIA-ROLE].

To build an accessible application first check that each element or widget is marked with full and correct semantics that fully describes its behavior. The procedure for this is described in ARIA Roles [ARIA-ROLE, Section 2.1]. Then use the features of this specification to ensure:

  1. States, properties, and relationships are valid for each element's behavior and are accessible via the [DOM].
  2. Elements have the correct input focus.

This requires the author to:

  1. Set properties to define the behavior of the element.
  2. Control the behavior of the element using device-independent events, states, and properties.
  3. Where possible, tie the behavior of the user interface to accessible states and properties using style sheet selectors.

For example: If the user is required to fill in a form element, set the aaa:required property to "true" on that element.

The States and Properties module also defines ways to indicate certain relationships. For example: If container A contains search results, and container B contains the search controls, then mark each container as a region and set the aaa:controls property in region B to reference region A (by ID).

Sometimes the relationships can be made clear via facilities of the native markup language, such as the label tag in [HTML]. Relationships can also be implied via the [DOM]. For example, when a well marked-up list contains list items, it is known that they belong to the containing list. In such cases you do not need to set properties from this specification to make the relationship explicit.

This specification corrects keyboard focus gaps in XTML. For details on those changes see section 4.4.

2 The States and Properties Module

This section is normative.

This specification defines the States and Properties module for XHTML [XHTML]. It also defines a representative profile which extends the XHTML 1.1 - Full profile by adding this module.

All examples are informative. Examples in this document that use the namespace prefix "aaa" all assume a valid XML namespace declaration xmlns:aaa = "http://www.w3.org/2005/07/aaa" in the document involved.

Section 3.1 below discusses examples of how the module may be integrated into language profiles. Section 3.2 below then defines the particulars of the module.

2.1 Using States and Properties Attached to an Element

Language profiles wishing to use these states and properties must integrate the module in a way which makes this document the governing specification for the semantics of these language features. Appropriate methods of module integration include but are not limited to all methods as specified in XHTML Modularization [XHTMLMOD].

2.1.1 XHTML

Appendix A.2 provides a driver DTD which integrates a new profile for XHTML which augments XHTML 1.1 Full with the capabilities in the new module introduced here.

Valid XHTML 1.1 documents that wish to use this profile must use the following DOCTYPE declaration:

<DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1 For Accessible Adaptable Applications//EN"
 "http://www.w3.org/2005/07/aaa/xhtml11-aaa.dtd">
2.1.1.1 XHTML with prefixes
2.1.1.1.1 The default prefix

Attributes for States and Properties should be used with prefix "aaa". For example:

<?xml version="1.0" encoding="UTF-8"?>

<DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1 For Accessible Adaptable Applications//EN">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">

<head>
<title>DHTML Checkbox</title>
</head>

<body>

<p>Here's a three state checkbox that you can click on.</p>

<div class="checkboxtristate " role="checkboxtristate" id=" chbox1" aaa:required="true" aaa:readonly="true " aaa:random="sometext " onkeydown="return checkBoxEvent(event);" onclick="return checkBoxEvent(event);" >
Sign me up for all the weekly rdf and xml newsletters :)
</div>

</body>
</html>
2.1.1.1.2 Changing the prefix

You can change the default prefix by extending the DOCTYPE of your XHTML document.

The following code would define "state" as the prefix for the WAI-ARIA attributes.

<!DOCTYPE html PUBLIC "-//W3C//ELEMENTS DTD XHTML 1.1 For Accessible Adaptable Applications//EN"

"http://www.w3.org/2005/07/aaa/xhtml11-aaa-base.dtd" [

<!ENTITY % aaa.prefixed "INCLUDE">

<!ENTITY % aaa.prefix "state">

]>
2.1.1.1.3 Tabindex

tabindex is not a state and has not been added to the http://www.w3.org/2005/07/aaa namespace. However, to help the accessibility of accessible XHTML applications, tabindex has been added to the tags div, span, p, td, th and li in the extended XHTML Doctype. The tabindex change enables support of User Agent Accessibility Guidelines ([UAAG]). tabindex should not be used with a prefix.

tabindex also supports the values of "0" and "-1." See section 4.4 for details.

2.1.1.2 XHTML without prefixes

Prefixes can sometimes be dropped when using XHTML 1.1 For Accessible Adaptable Applications. For example:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//ELEMENTS DTD XHTML 1.1 For
    Accessible Adaptable Applications//EN"
    "http://www.w3.org/2005/07/aaa/xhtml11-aaa-base.dtd"> 
<html
    xmlns="http://www.w3.org/1999/xhtml " xml:lang="en ">
  <head>
    <title>DHTML Checkbox</title >
  </head>
  <body>
    <p >Here's a three state checkbox that you can click on.</p>
    <div class="checkboxtristate " role= "checkboxtristate"
        id="chbox1 " required="true" readonly="true " random="sometext "
        onkeydown="return checkBoxEvent(event);" onclick="return
        checkBoxEvent(event);">
      Sign me up for weekly rdf newsletter :)
    </div>
   </body>
</html>
				

However, this is not advisable because of namespace conflict. The ARIA States and Properties XHTML 1.1 module extends already existing attributes such as readonly. These attributes therefore require prefixing. We therefore recommend always using the default "aaa" prefix.

The list of conflicts are:

  • checked
  • disabled
  • readonly
  • selected

2.1.2 States and Properties with other XML languages

States and Properties can also be used with other XML languages using the following namespace :

 xmlns:aaa="http://www.w3.org/2005/07/aaa"

The following example demonstrates using States and Properties with SVG [SVG]:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11-flat-20030114.dtd">
<svg xmlns="http://www.w3.org/2000/svg " xmlns:aaa="http://www.w3.org/2005/07/aaa " width="100% " height="100% ">

<desc>
Example of using state-attributes from Accessible Adaptable Applications Namespace:

</desc>

<!-- an expanded group of rectangles -->
<g aaa:expanded="true ">
<!-- this rectangle is zoomed -->

 x="1cm " y="3cm " width="1cm " height="1cm " />
<rect x="3cm " y="3cm " width="1cm " height="1cm " />
</g>
</svg>

2.1.3 States and Properties with HTML

There is no normative way to apply states and properties in HTML, but it is recommended to use the HTML implementation technique.

2.2 Examples

This section is informative.

This example shows a role being used to make a simple widget known to the user agent, so that the user agent can handle it correctly.

In this example a div has been used with scripts to act as a tristate checkbox. The ARIA State and Properties of checked has been set to true.

The XHTML role element gives the use agent information about the behavior of the widget. For more information on Roles see the Roles for Accessible Rich Internet Applications [ARIA_ROLE].

<span
    class="checkboxtristate" 
    id="chbox1" 
    role="wairole:checkboxtristate" 
    aaa:checked="true" 
    tabindex="0"
    onkeydown="return checkBoxEvent(event);" 
    onkeyup="return checkBoxEvent(event);" >
  A checkbox label
</span>

JavaScript can then manipulate the widget via the DOM. However, because States and Properties are mapped to the accessibility platforms, the assistive technology and user agents can understand the widget behavior and respond appropriately.

java script snippet :

 if ((event.type == "keyup" && event.button == 0){

    // Toggle checkbox

    var checkbox = event.target;

    if (checkbox.getAttributeNS("				http://www.w3.org/2005/07/aaa
			", "checked") == "true") {

       checkbox.removeAttributeNS("				http://www.w3.org/2005/07/aaa
			", "checked");

    }


    return false;  // Don't continue propagating event}

  return true;  // Browser can still use event

}

Typically, States and Properties will work well with other supporting technologies, such as the Roles for Accessible Rich Internet Applications [ARIA_ROLE] and [XML events].

3 Conformance Requirements

This section is normative.

The keywords "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 [RFC2119].

3.1 Document Conformance

States and Properties is not a stand-alone document type. It is intended to be integrated into other host languages such as XHTML. A conforming document is a document that requires only the facilities described as mandatory in this specification and the facilities described as mandatory in its host language. Such a document must meet all the following criteria:

  1. The document must conform to the constraints expressed in Appendix A. DTD Implementation combined with the constraints expressed in its host language implementation.

  2. The document must use either of the following:
    1. The following Doctype declaration: <DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1 For Accessible Adaptable Applications//EN" "http://www.w3.org/2005/07/aaa/xhtml11-aaa.dtd"> This extends XHTML with ARIA States and Properties added to the common attribute set.

      Editorial Note: the public string of the DTD may need to be updated to match ARIA name, here and elsewhere it appears. We also need to look at what this would do to the aaa namespace, and whether it should have trailing slash (currently does because of link checker).

    2. The document may also contain an XML Namespace [XML-NAMES] declaration for the author properties namespace. The namespace for States and Properties module is defined to be: http://www.w3.org/2005/07/aaa. An example start tag of a root element might look like:
      <html xmlns=" http://www.w3.org/1999/xhtml " xml:lang="en" xmlns:aaa=" http://www.w3.org/2005/07/aaa " >

3.2 Host Language Conformance

When States and Properties are included in a host language, all of the facilities required in this specification must be included in the host language.

3.3 User Agent Conformance

User agents that conform to States and Properties Module for Accessible Rich Internet Applications expose state information provided by the author to assistive technologies, and if they are assistive technologies themselves, use state information to enhance the presentation and interaction. Conformance requirements:

  1. User agents MUST make all states and properties, and their values, provided by the author available in the DOM, using the attribute name, namespace, and values defined in this specification. This requirement parallels User Agent Accessibility Guidelines 1.0 Section 6.2: DOM access to HTML/XML content [UAAG, Section 6.2].

  2. User agents SHOULD expose state and property information provided by the author to the platform accessibility API. Refer to Mapping States and Properties to Accessibility APIs for guidance about how to expose this information. This requirement parallels User Agent Accessibility Guidelines 1.0 Section 6.3: Programmatic Access to non-HTML/XML Content [UAAG, Section 6.3], except that it applies even to HTML and XML content.

    Note: Not all platforms provide accessibility APIs, or provide interfaces that map to all the states and properties defined in this specification. User agents should expose those states and properties that are supported in order to support assistive technologies that work through the accessibility API. The remaining states and properties are available to assistive technologies via the DOM as per point 1 above, for those that provide explicit support for this specification.

  3. Assistive technologies that conform to this specification MUST use state and property information to present content to and support interaction with users in a manner appropriate to that state or property. The manner in which this is done is specific to each user agent but should be appropriate to the specified description of the state or property. This requirements parallels User Agent Accessibility Guidelines 1.0 Section 6.5: Programmatic operation of user agent user interface and Section 6.6: Programmatic notification of changes [UAAG, Section 6.5 and 6.6] except that it applies to content, not just the user agent itself.

    Note: This does not specify how assistive technology obtains state and property information. Assistive technologies may obtain state and property information directly from content, through the DOM, or through the platform accessibility API. In the latter case, only incomplete state and property information may be available. This point only requires that assistive technology use the states and properties that are actually available to it to support the user.

4 Supported States and Properties

The States and Properties Module supports the following attributes:

4.1 Widget states

This section contains states specific to user common interface elements found on GUI systems or in a Rich Internet Applications which receive user input and process user actions. These states are used to support the widget roles found in the ARIA Roles taxonomy. Widget states may be mapped by a user agent to platform accessibility API states, for access by an assistive technology, or they may be accessed directly from the [DOM]. Changes in states should result in a notification to an assistive technology either through DOM attribute change events or platform accessibility API events.

checked

Value: (true | false | mixed)
Related Concepts:
Applicability:
Descendant Roles:

This state is used for 2-state or 3-state widgets such as checkboxes to indicate whether they are checked.

Values:

true indicates that the current item is checked.
false roles that support being checked but are not currently checked.
mixed indicates a mixed mode for a tri-state checkbox. This is only supported on checkboxtristate and menuitemcheckbox.  

pressed

Value: (true | false )
Related Concepts:
Applicability: button
Descendant Roles:  

Used for buttons that are toggleable to indicate their current pressed state.

Toggle buttons require a full pressed and released cycle to toggle their value. Activating it once changes the pressed state to "true", and activating it another time changes the pressed state back to "false". If the state is not present, the button is not a toggle button.

Values:

true indicates that the button is depressed.
false the button is not depressed.

disabled

Value: (true | false)
Related Concepts:
Applicability:
Descendant Roles:

Indicates that the widget is present, but is not allowed for user actions. For example, irrelevant options in a radio group may be disabled.

Disabled elements often cannot have focus.

There should be a change of appearance to indicate that the item has been disabled (grayed out, etc.).

Values:

true :
false  

readonly

Value: (true | false)
Related Concepts:
Applicability:
Descendant Roles:

Indicates that the widget is not editable.

Unlike a disabled object, readonly objects are relevant to the user.

Examples include:

  • A form element which represents a constant.
  • Row or column headers in a spreadsheet
  • The result of a calculation such as a shopping cart total

Values:

true :
false  

multiselectable

Value: (true | false)
Related Concepts:
Applicability:
Descendant Roles:  

Indicates that user may select more than one item from the current list.

Examples include: lists, trees, spreadsheets

Values:

true :
false  

expanded

Value: (true | false | undefined)
Related Concepts:
Applicability:
Descendant Roles:

Indicates whether an expandable/collapsible group of elements is currently expanded or collapsed.

  • A value of true indicates the group is expanded.
  • A value of false indicates the group is collapsed.
  • A value of undefined means the group is neither expandable nor collapsible (all its child elements are shown).

Examples include: to expand or collapse a portion of the tree, or an "expanded" version such as acronyms, rollovers, diagram sections.

Values:

true :
false  
undefined  

selected

Value: (true | false | undefined)
Related Concepts:
Applicability:
Descendant Roles:

Sets whether the user has selected an item or not.

For example, a role such as a radio button may support being selected, but that does not mean that at any one time it is checked.

Values:

true a selectable element is actually selected.
false the element is not selected.
undefined the element is not selectable.

required

Value: (true | false)
Related Concepts:
Applicability: All elements of the base markup
Descendant Roles:  

Indicates that user input is required on the control before a form may be submitted.

For example, if a user must fill in an address field, then required is set to true.

Note: the fact that the element is required is often visually presented (such as a sign or symbol after the control). Using the required attribute makes it much easier for user agents to pass on this important information to the user.

Values:

true :
false  

datatype

Value: CDATA
Related Concepts:
Applicability: All elements of the base markup
Descendant Roles:  

Datatype defines the format type of an element.

Datatype should be a qname that refer to an XML Schema [XSD] defined type. For example, a datatype may be xsd:integer. The author may also reference their own custom datatypes as long as they are simple types. Clearly [XSD] base types are simpler for the user agent to understand.

Datatype applies to the content of an element, e.g., the value of an input element that the user could change. This can facilitate automatic validation of user input. Datatype also applies to the value of valuenow when provided. If no datatype is provided, the default value the user agent should assume is "xsd:string", which is a simple character string with no intrinsic format.

Values:

Val: description

valuenow

Value: CDATA
Related Concepts:
Applicability:
Descendant Roles:

The current value of a widget.

Used, for example, for a range control such as a slider or progress bar, and for a date.

If the value is not known (as often occurs with progress bars) then the valuenow attribute should not be set at all. If the valuenow attribute is absent, no information is implied about the current value.

An author has the option of specifying a datatype for valuenow to help an assistive technology process the value in a meaningful way, such as providing a datatype="xsd:date". If the valuenow has a known maximum and minimum, the author should provide properties for valuemax and valuemin.

Values:

Val: description

valuemax

Value: CDATA
Related Concepts:
Applicability:
Descendant Roles:

Maximum allowed value for a range type of widget.

A range control may start with a given value, which can be increased until a maximum value, defined by this property, is reached.

Declaring the valuemax will allow for alternate device to calibrate an arrow up effect, validate, or simply let the user know the size of the range on offer.

An author has the option of specifying a datatype for valuenow to help an assistive technology process the value in a meaningful way, such as providing a datatype="xsd:date". If the valuenow has a known maximum and minimum, the author should provide properties for valuemax and valuemin.

Values:

Val: description

valuemin

Value: CDATA
Related Concepts:
Applicability:
Descendant Roles:

Minimum allowed value for a range type of widget.

A range control may start with a given value, which can be decreased until a minimum value, defined by this property, is reached.

Declaring the valuemin allows for alternate device to calibrate an arrow up effect, validate, or simply let the user know the size of the range on offer.

An author has the option of specifying a datatype for valuenow to help an assistive technology process the value in a meaningful way, such as providing a datatype="xsd:date". If the valuenow has a known maximum and minimum, the author should provide properties for valuemax and valuemin.

Values:

Val: description

invalid

Value: (true | false)
Related Concepts:
Applicability: All elements of the base markup
Descendant Roles:  

Indicates that the element's value is currently invalid, which discourages the form from being submitted.

If the state is computed to be invalid, out-of-range, or required this value should be set as true.

Values:

true Todo:
false  

haspopup

Value: ( true | false )
Related Concepts:
Applicability: All elements of the base markup
Descendant Roles:  

Indicates that element may launch a pop-up window such as a context menu or submenu.

This is a special case of owns where activation renders conditional content. Note that tooltips are not considered popups in this context.

Values:

true indicates it has a popup menu, either as a descendant or pointed to by owns  
false (default) has no popup

level

Value: Number
Related Concepts:
Applicability: treeitem
Descendant Roles:  

Level is the hierarchical level of an element within a structure. This can be applied inside trees to tree items, or to headings inside a document. Levels must be >= 1.

Values:

Val: description

4.2 Live Regions

This section contains properties specific to live regions in your rich internet application. These properties may be applied to any element. The purpose of these properties is to indicate that changes to this section may occur without it having focus and to provide the assistive technology information on how to process live updates in this section of the page. If possible, it is best that the live property be assigned to sections of the document with a pre-defined specific role such as the standard XHTML role landmarks or custom regions such as log.

live

Value: (off | polite | assertive | rude)
Related Concepts:
Applicability: All elements of the base markup
Descendant Roles:  

Describes the types of updates the user agent, assistive technology, and user can expect from an alert or live region of Web content.

It is essential to describe the types of updates the user agent and user can expect from a live region of Web content.

Examples include:

  • A section of updated basketball statistics.
  • A region that updates in response to a users control of a Web page (such as requesting a photograph).

An example of assertive content is a site notifying its users that its connection is going down in 5 minutes.

Values:

off (Default) The region is not currently live.
polite (Background change) This is normal operation and the default behavior for live regions. It is not necessary to respond until user completes their current activity.
assertive This information has a higher priority than normal but does not necessarily interrupt immediately.
rude This information has the highest priority and should typically result in an interrupt to the user. This may disorientate users causing them not to continue in their current task.

atomic

Value: (true | false)
Related Concepts:
Applicability: All elements of the base markup
Descendant Roles:  

Atomic is an optional property of live regions. When the region is updated, the atomic property is used to indicate if the assistive technology should present all or part of the changed region to the user.

Both accessibility APIs and the Document Object Model [DOM] provide events to allow the assistive technology to determine changes areas of the document.

When a node changes, the AT should look at the current element and then traverse the ancestors to find the first element with aaa:atomic set.

  1. If none of the ancestors have explicitly set atomic, this is the default (aaa:atomic="false") case, and the AT only needs to present the changed node to the user.
  2. If aaa:atomic is explicitly set to false, then the AT can stop searching up the ancestor chain, and should present only the changed node to the user.
  3. If aaa:atomic is explicitly set to true, then the AT should present the entire subtree that aaa:atomic="true" was set on.

The AT may choose to combine several changes and present the entire changed region at once.

Values:

true the assistive technology should present the entire region as a whole.
false (default), a change within the region may be processed by the assistive technology on its own

relevant

Value: (additions | removals | text | all)
Related Concepts:
Applicability: All elements of the base markup
Descendant Roles:  

Indicates the relevant areas of change within a live region.

The property is represented as space delimited list of the following values: additions, removals, text, all.

Relevant is an optional property of live regions within a document. Relevant is unrestrictive as to how an assistive technology processes attributes. When the relevant property is not provided, the default is to assume there are text changes and additions.

Both accessibility APIs and the Document Object Model [DOM] provide events to allow the assistive technology to determine changes areas of the document.

Values:

additions Nodes are added to the [DOM] within the region
removals Nodes are removed from the [DOM]
text Text is added or removed from the [DOM]
all Additions, removals, text

busy

Value: ( true | false | error )
Related Concepts:
Applicability: All elements of the base markup
Descendant Roles:  

Indicates whether a live region is finished updating.

The default is that busy is false. For example, if authors know that multiple parts of the same live region need to be loaded, they can set busy to true when the first part is loaded and then set busy to false when the last part is loaded.

Values:

true The live region is still being updated
false (default) There are no more expected updates for that live region
error An error has occurred and the live region may not have received all the updates that it should have

4.3 Drag and Drop

This section defines properties which must be applied by an author to indicate the state of objects which may be “grabbed” for a drag operation as well as the state of drop targets once a drag operation has been started. This information is designed to facilitate a drag and drop operation by identify “draggable” objects and drop target. This information by rendered visually or provided to the user by an assistive technology through and alternative modality.

grab

Value: ( true | supported | false )
Related Concepts:
Applicability: All elements of the base markup
Descendant Roles:  

This property is set to show an object's state in drag and drop.

When it is set to "grab" it has been selected for dragging, supported indicates that the object is grabable, but is not currently grabbed, false indicates the object is is not grabable (default). When set to drop the drag over IDREF is the IDREF of final target element. This is an event after which the application needs to act out the drop effect by adjusting the DOM and/or states and properties settings, so that now the new relationships, ownerships and elements are represented in the mark-up.

Values:

true Indicates that the document element has been "grabbed" for dragging.:
supported Indicates that the document element supports being dragged.
false (default) Indicates that the document element does not support being dragged.

dropeffect

Value: ( copy | move | reference | none )
Related Concepts:
Applicability: All elements of the base markup
Descendant Roles:  

This property is set for the target of a drag and drop operation to show the effect when the dragged object is released.

Also, providing a property allows authors to provide a visual indication of the drag source to the user during drag operations with a style sheet. Alternatively, if only one type of operation is supported, it can be set at page load.

Values:

copy A duplicate of the source object will be dropped into the target.
move The source object will be removed from its original location and dropped into the target.
reference A reference or short cut to the dragged object will be created in the target object.
none (default) No operation can be performed; effectively cancels the drag operation if an attempt is made to drop on this object

4.4 Focus

This section defines properties are used to help the user agent and assistive technology process user focus.

tabindex

Value: integer
Related Concepts:
Applicability: All elements of the base markup
Descendant Roles:  

Indicates tab order of elements. Elements with negative values are able to receive focus but are not included in the basic tabbing navigation list or cycle.

Elements of types div, span, p, td, th and li for which no TABINDEX value is given likewise do not participate in the 'tabbing' navigation list.

Elements with disabled="true" do not participate in the tabbing navigation list.

Elements bearing positive values of TABINDEX are navigated as in the [HTML] 4.01 Specification, to whit:

Those elements that support the tabindex attribute and assign a positive value to it are navigated first. Navigation proceeds from the element with the lowest tabindex value to the element with the highest value. Values need not be sequential nor must they begin with any particular value. Elements that have identical tabindex values should be navigated in the order they appear in the character stream.

Elements of types div, span, p, td, th and li bearing a zero value of TABINDEX, together with elements of types A, AREA, BUTTON, INPUT, OBJECT, SELECT, TEXTAREA bearing a zero value or no value of TABINDEX, are navigated next, as in [HTML] 4.01:

These elements are navigated in the order they appear in the character stream.

(Note: The applicability of this attribute has been extended to the div, span, p, td, th and li elements, within the XHTML namespace. It should not be used with a prefix referring to the [aaa namespace].)

Values:

Val: description

activedescendent

Value: IDREF
Related Concepts:
Applicability:
Descendant Roles:

An element which has focus may specify its current active child. This is used when a element is responsible for managing its current active child to reduce the overhead of having all children be focusable.

Examples include: multi-level lists, trees, spreadsheets.

Values:

Val: description

4.5 Relationships

This section defines relationships or associations between elements which cannot be readily determined from the document structure.

labelledby

Value: IDREFS
Related Concepts:
Applicability: All elements of the base markup
Descendant Roles:  

Points to the element which labels the current element.

The label should provide the user with the essence of the what the object does whereas describedby provides additional information which some users might need.

Values:

Val: description

describedby

Value: IDREFS
Related Concepts:
Applicability: All elements of the base markup
Descendant Roles:  

Points to an element which describes the widget.

(A label should provide the user with the essence of the what the object does whereas describedby is intended to provide additional information which some users might need. )

Values:

Val: description

flowto

Value: IDREF
Related Concepts:
Applicability: All elements of the base markup
Descendant Roles:  

Establishes the recommended reading order of content, overriding the general default to read in document order. The IDREF refers to the next object that should be read.

Values:

Val: description

controls

Value: IDREFS
Related Concepts:
Applicability: All elements of the base markup
Descendant Roles:  

Defines the elements that are controlled by the current element.

Values:

Val: description

owns

Value: IDREFS
Related Concepts:
Applicability: All elements of the base markup
Descendant Roles:  

Defines an object as a parent of another document element, when the child does not appear directly in the subtree of the owner.

Values:

Val: description
 

4.6 Uncategorized states

This section defines miscellaneous accessibility properties in a rich internet application which do not fall under a specific category.

posinset

Value: Number
Related Concepts:
Applicability:
Descendant Roles:

Indicates an item's number or position within the current level of a tree or list.

For example, if this element is the third item in a group then posinset is equal to three (integer: 1<=posinset<=n.)

Values:

Val: description

setsize

Value: Number
Related Concepts:
Applicability:
Descendant Roles:

The setsize property refers to the number of items in the current level of a list or tree.

For example, if this element is in a group of six items at the same level then setsize is equal to six. Setsize must be >= 1.

Editorial Note: it is currently under discussion whether this should apply to container or leaf nodes.

Values:

Val: description

sort

Value: ( ascending | descending)
Related Concepts:
Applicability:
Descendant Roles:  

The sort property is used to indicate if items in a table or grid are sorted in ascending or descending order. Should be applied only to table or grid headers.

Values:

ascending items are sorted in ascending order
descending items are sorted in descending order

hidden

Value: ( true | false )
Related Concepts:
Applicability: All elements of the base markup
Descendant Roles:  

Defines whether or not the object is visible to the user.

For example, if a menu is only visible after some user action, this property would be set to true until the user performs the necessary action at which time this property would then be set to false.

It is recommended that authors key visibility of objects off this attribute, rather than change visibility and separately have to remember to update this property. CSS 2 provides a way to select on attribute values [CSS, Section 5.8.1]. The following pair of CSS declarations make content visible unless the hidden property is true; scripts need only update the value of this property to change visibility:

*{visibility: visible;}
*[waistate:hidden=true] {visibility: hidden;} 

Values:

true Indicates that this section of the document and its children are hidden from the rendered view.
false (default) Indicates that this section of the document is rendered.

5 Appendices

5.1 Index of States and Properties

For reference purposes, here is an alphabetical list of states and properties defined in this specification.

State Definition
activedescendent An element which has focus may specify its current active child. This is used when a element is responsible for managing its current active child to reduce the overhead of having all children be focusable.
atomic Atomic is an optional property of live regions. When the region is updated, the atomic property is used to indicate if the assistive technology should present all or part of the changed region to the user.
busy Indicates whether a live region is finished updating.
checked This state is used for 2-state or 3-state widgets such as checkboxes to indicate whether they are checked.
controls Defines the elements that are controlled by the current element.
datatype Datatype defines the format type of an element.
describedby Points to an element which describes the widget.
disabled Indicates that the widget is present, but is not allowed for user actions. For example, irrelevant options in a radio group may be disabled.
dropeffect This property is set for the target of a drag and drop operation to show the effect when the dragged object is released.
expanded Indicates whether an expandable/collapsible group of elements is currently expanded or collapsed.
flowto Establishes the recommended reading order of content, overriding the general default to read in document order. The IDREF refers to the next object that should be read.
grab This property is set to show an object's state in drag and drop.
haspopup Indicates that element may launch a pop-up window such as a context menu or submenu.
hidden Defines whether or not the object is visible to the user.
invalid Indicates that the element's value is currently invalid, which discourages the form from being submitted.
labelledby Points to the element which labels the current element.
level Level is the hierarchical level of an element within a structure. This can be applied inside trees to tree items, or to headings inside a document. Levels must be >= 1.
live Describes the types of updates the user agent, assistive technology, and user can expect from an alert or live region of Web content.
multiselectable Indicates that user may select more than one item from the current list.
owns Defines an object as a parent of another document element, when the child does not appear directly in the subtree of the owner.
posinset Indicates an item's number or position within the current level of a tree or list.
pressed Used for buttons that are toggleable to indicate their current pressed state.
readonly Indicates that the widget is not editable.
relevant Indicates the relevant areas of change within a live region.
required Indicates that user input is required on the control before a form may be submitted.
selected Sets whether the user has selected an item or not.
setsize The setsize property refers to the number of items in the current level of a list or tree.
sort The sort property is used to indicate if items in a table or grid are sorted in ascending or descending order. Should be applied only to table or grid headers.
tabindex Indicates tab order of elements. Elements with negative values are able to receive focus but are not included in the basic tabbing navigation list or cycle.
valuemax Maximum allowed value for a range type of widget.
valuemin Minimum allowed value for a range type of widget.
valuenow The current value of a widget.

5.2 DTD Implementation

This section is normative.

5.2.1 Qualified Names Module

Note that this module defines the parameter entity aaa.attrs.qname;. This entity is intended to be used in the attribute lists of elements in any host language that permits the use of AAA attributes on elements in its own namespace. In this case the Host Language driver should set a parameter entity %aaa.prefixed; to INCLUDE. The default prefix to be used is aaa:.

<!-- ...................................................................... -->
<!-- aaa-qname Module ................................................... -->
<!-- file: aaa-qname.mod

  PUBLIC "-//W3C//DTD XHTML 1.1 For Accessible Adaptable Applications Namespace//EN"
SYSTEM "http://www.w3.org/2005/07/aaa/aaa-qname.mod">

xmlns:aaa="http://www.w3.org/2005/07/aaa "
...................................................................... -->

<!ENTITY % XHTML.version
    "-//W3C//DTD XHTML 1.1 For Accessible Adaptable Applications Namespace//EN" >

<!-- 1. Namespace declarations ::::::::::::::::::::::::::::: -->

<!ENTITY % NS.prefixed     "IGNORE" >
<!ENTITY % aaa.prefixed "%NS.prefixed;" >

<!-- Declare the actual namespace of this module -->

<!ENTITY % aaa.xmlns "http://www.w3.org/2005/07/aaa" >

<!ENTITY % aaa.prefix   "aaa" >
<![%aaa.prefixed;[
<!ENTITY % aaa.xmlns.extra.attrib  "" >
]]>

<!ENTITY % aaa.xmlns.extra.attrib
     "" >

<![%aaa.prefixed;[
<!ENTITY % aaa.pfx  "%aaa.prefix;:" >

<!ENTITY % aaa.xmlns.attrib
     "xmlns:%aaa.prefix;  CDATA   #FIXED '%aaa.xmlns;'
      %aaa.xmlns.extra.attrib;"
>
]]>
<!ENTITY % aaa.pfx  "" >
<!ENTITY % aaa.xmlns.attrib
     "xmlns        CDATA           #FIXED '%aaa.xmlns;'
      %aaa.xmlns.extra.attrib;"
>

<![%NS.prefixed;[
<!ENTITY % XHTML.xmlns.extra.attrib
     "%aaa.xmlns.attrib;" >

]]>

<!-- 2. XML Qualified Names for AAA ::::::::::::::::::::::::::::: -->

<!--   This section declares parameter entities used to provide
        namespace-qualified names for all element types.
-->

<!ENTITY % xhtml-datatypes.mod
     PUBLIC "-//W3C//ENTITIES XHTML Datatypes 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-datatypes-1.mod" >
%xhtml-datatypes.mod;

<!-- core attributes to add to all elements; -->

<!-- states -->

<!ENTITY % aaa.busy.qname "%aaa.pfx;busy">
<!ENTITY % aaa.checked.qname "%aaa.pfx;checked">
<!ENTITY % aaa.disabled.qname "%aaa.pfx;disabled">
<!ENTITY % aaa.expanded.qname "%aaa.pfx;expanded">
<!ENTITY % aaa.grab.qname "%aaa.pfx;grab">
<!ENTITY % aaa.hidden.qname "%aaa.pfx;hidden">
<!ENTITY % aaa.invalid.qname "%aaa.pfx;invalid">
<!ENTITY % aaa.pressed.qname "%aaa.pfx;pressed">
<!ENTITY % aaa.selected.qname "%aaa.pfx;selected">

<!-- properties -->

<!ENTITY % aaa.activedescendent.qname "%aaa.pfx;activedescendent">
<!ENTITY % aaa.atomic.qname "%aaa.pfx;atomic">
<!ENTITY % aaa.controls.qname "%aaa.pfx;controls">
<!ENTITY % aaa.datatype.qname "%aaa.pfx;datatype">
<!ENTITY % aaa.describedby.qname "%aaa.pfx;describedby">
<!ENTITY % aaa.dropeffect.qname "%aaa.pfx;dropeffect">
<!ENTITY % aaa.flowto.qname "%aaa.pfx;flowto">
<!ENTITY % aaa.haspopup.qname "%aaa.pfx;haspopup">
<!ENTITY % aaa.labelledby.qname "%aaa.pfx;labelledby">
<!ENTITY % aaa.level.qname "%aaa.pfx;level">
<!ENTITY % aaa.live.qname "%aaa.pfx;live">
<!ENTITY % aaa.multiselectable.qname "%aaa.pfx;multiselectable">
<!ENTITY % aaa.owns.qname "%aaa.pfx;owns">
<!ENTITY % aaa.posinset.qname "%aaa.pfx;posinset">
<!ENTITY % aaa.readonly.qname "%aaa.pfx;readonly">
<!ENTITY % aaa.relevant.qname "%aaa.pfx;relevant">
<!ENTITY % aaa.required.qname "%aaa.pfx;required">
<!ENTITY % aaa.setsize.qname "%aaa.pfx;setsize">
<!ENTITY % aaa.sort.qname "%aaa.pfx;sort">
<!ENTITY % aaa.valuemax.qname "%aaa.pfx;valuemax">
<!ENTITY % aaa.valuemin.qname "%aaa.pfx;valuemin">
<!ENTITY % aaa.valuenow.qname "%aaa.pfx;valuenow">

<!-- tabindex -->

<!ENTITY % aaa.tabindex.qname "tabindex">

<!-- The following defines a PE for use in the attribute sets of elements in
	other namespaces that want to incorporate the XML Role attributes. Note
	that in this case the XML-ROLES.pfx should always be defined. -->

<!ENTITY % aaa.states.qname "
	%aaa.busy.qname; ( true | false | error ) 'false'
	%aaa.checked.qname; (true | false | mixed) #IMPLIED
	%aaa.disabled.qname; (true | false) #IMPLIED
	%aaa.expanded.qname; (true | false | undefined) #IMPLIED
	%aaa.grab.qname; ( true | supported | false ) 'false'
	%aaa.hidden.qname; ( true | false ) 'false'
	%aaa.invalid.qname; (true | false) #IMPLIED
	%aaa.pressed.qname; (true | false ) #IMPLIED
	%aaa.selected.qname; (true | false | undefined) #IMPLIED
">

<!ENTITY % aaa.props.qname "
	%aaa.activedescendent.qname; IDREF #IMPLIED
	%aaa.atomic.qname; (true | false) 'false'
	%aaa.controls.qname; IDREFS #IMPLIED
	%aaa.datatype.qname; CDATA #IMPLIED
	%aaa.describedby.qname; IDREFS #IMPLIED
	%aaa.dropeffect.qname; ( copy  | move | reference | none ) 'none'
	%aaa.flowto.qname; IDREF #IMPLIED
	%aaa.haspopup.qname; ( true | false )  'false'
	%aaa.labelledby.qname; IDREFS #IMPLIED
	%aaa.level.qname; %Number.datatype; #IMPLIED
	%aaa.live.qname; (off | polite | assertive | rude) 'off'
	%aaa.multiselectable.qname; (true | false) #IMPLIED
	%aaa.owns.qname; IDREFS #IMPLIED
	%aaa.posinset.qname; %Number.datatype; #IMPLIED
	%aaa.readonly.qname; (true | false) #IMPLIED
	%aaa.relevant.qname; (additions | removals | text | all) #IMPLIED
	%aaa.required.qname; (true | false) #IMPLIED
	%aaa.setsize.qname; %Number.datatype; #IMPLIED
	%aaa.sort.qname; (ascending | descending) #IMPLIED
	%aaa.valuemax.qname; CDATA #IMPLIED
	%aaa.valuemin.qname; CDATA #IMPLIED
	%aaa.valuenow.qname; CDATA #IMPLIED
">

<!ENTITY % aaa.extra.attrs.qname
	"%aaa.tabindex.qname;   %Number.datatype;   #IMPLIED"
>

<!ENTITY % aaa.attrs.qname
     "%aaa.states.qname;
      %aaa.props.qname; 
       %aaa.extra.attrs.qname;"
>

<!ENTITY % aaa-qname.module "IGNORE" >

<!-- End aaa-qname Module ................................................... -->

5.2.2 ELEMENTS XHTML 1.1 For Accessible Adaptable Applications DTD

This DTD extends XHTML 1.1 and adds the States and Property attributes to all its elements.

The attribute tabindex is added to elements p, div, span, th, td and li

<!-- ELEMENTS  DTD XHTML 1.1 For Accessible Adaptable Applications -->
<!-- File: xhtml11-aaa-base.dtd

 Copyright (c) 2005, Unbounded Access,
 All Rights Reserved.

 This DTD module is identified by the PUBLIC and SYSTEM identifiers:

 PUBLIC "-//W3C//ELEMENTS DTD XHTML 1.1 For Accessible Adaptable Applications//EN"
 SYSTEM "http://www.w3.org/2005/07/aaa/xhtml11-aaa-base.dtd"
 xmlns:aaa="http://www.w3.org/2005/07/aaa"

 The DOCTYPE declaration that should be used is as follows;

        <!DOCTYPE html
        PUBLIC "-//W3C//ELEMENTS DTD XHTML 1.1 For Accessible Adaptable Applications//EN"
        "http://www.w3.org/2005/07/aaa/xhtml11-aaa-base.dtd">

...................................................................... -->

<!ENTITY % XHTML.version
    "-//W3C//ELEMENTS DTD XHTML 1.1 For Accessible Adaptable Applications//EN" >

<!ENTITY % aaa-qname.mod
    PUBLIC "-//W3C//DTD XHTML 1.1 For Accessible Adaptable Applications Namespace//EN"
    "http://www.w3.org/2005/07/aaa/aaa-qname.mod" >

%aaa-qname.mod;

<!-- add AAA attribute set to all XHTML elements -->

<!ENTITY % Common.extra.attrib
    "%aaa.attrs.qname;"
>

<!ENTITY % xhtml11.mod
    PUBLIC "-//W3C//DTD XHTML 1.1//EN"
    "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"

>

%xhtml11.mod;

<!-- add tabindex to text containers -->

<!ATTLIST %div.qname;
    %aaa.extra.attrs.qname;
>

<!ATTLIST %span.qname;
    %aaa.extra.attrs.qname;
>

<!ATTLIST %p.qname;
    %aaa.extra.attrs.qname;
>

<!ATTLIST %th.qname;
    %aaa.extra.attrs.qname;
>

<!ATTLIST %td.qname;
    %aaa.extra.attrs.qname;
>

<!ATTLIST %li.qname;
    %aaa.extra.attrs.qname;
>

<!ENTITY % aaa.prefixed "INCLUDE">

<!-- End xhtml11-aaa-base.dtd  -->

5.2.3 XHTML 1.1 For Accessible Adaptable Applications DTD

This DTD requires the use of the "aaa" prefix.

<!-- DTD XHTML 1.1 For Accessible Adaptable Applications -->

<!-- File: xhtml11-aaa.dtd

 Copyright (c) 2005, Unbounded Access,
 All Rights Reserved.

 This DTD module is identified by the PUBLIC and SYSTEM identifiers:

 PUBLIC "-//W3C//DTD XHTML 1.1 For Accessible Adaptable Applications//EN"
 SYSTEM "http://www.w3.org/2005/07/aaa/xhtml11-aaa.dtd"
 xmlns:aaa="http://www.w3.org/2005/07/aaa"

 The DOCTYPE declaration that should be used is as follows;

        <!DOCTYPE html
        PUBLIC "-//W3C//DTD XHTML 1.1 For Accessible Adaptable Applications//EN"
        "http://www.w3.org/2005/07/aaa/xhtml11-aaa.dtd">


...................................................................... -->

<!ENTITY % XHTML.version
    "-//W3C//DTD XHTML 1.1 For Accessible Adaptable Applications//EN"

>

<!-- Enable prefixing -->

<!ENTITY % aaa.prefixed "INCLUDE">

<!ENTITY % xhtml11-aaa.mod
    PUBLIC "-//W3C//ELEMENTS DTD XHTML 1.1 For Accessible Adaptable Applications//EN"
    "http://www.w3.org/2005/07/aaa/xhtml11-aaa-base.dtd" >

%xhtml11-aaa.mod;

<!-- End xhtml11-aaa.dtd -->

5.3 Managed States

This section is informative.

Managed states are state attributes managed and controlled by the user agent. Often these states have corresponding CSS pseudo classes to reflect necessary style changes. The states in this specification are typically controlled by the author and are not managed (unmanaged) states.

Accessibility APIs typically map to both managed and unmanaged states. An example of a managed state would be element focus and hover.

Note: Invalid is a managed state in [XForms]. However in most other languages (such as [HTML] forms) it is not managed.

5.4 Mapping States and Properties to Accessibility APIs

This section is informative.

Mapped properties (Please note: This is a common subset of all mapping options)

States and Properties module User Agent mapping via MSAA User Agent mapping via ATK
disabled MSAA:STATE_SYSTEM_UNAVAILABLE ATK:ATK_STATE_DISABLED
checked MSAA: STATE_SYSTEM_CHECKED ATK: ATK_STATE_CHECKED
expanded If the hidden property is set to true : MSAA:STATE_SYSTEM_COLLAPSED

If the hidden property is set to false: MSAA:STATE_SYSTEM_EXPANDED

If the hidden property is set to true : ATK: ATK_STATE_EXPANDABLE

If the hidden property is set to false: ATK:ATK_STATE_EXPANDED

haspopup This state should be mapped to true on Windows systems when an event handler has a role of pop-up menu.

MSAA: haspopup

ATK: not necessary in ATK because it has multiple actions with description
invalid MSAA: no mapping

In the case of MSAA the user agent should provide a specialized API to return its value. Alternatively, if the user agent provides a specialized API for [XForms] it may provide invalid(), outOfRange(), or empty() (returns true when required but not available). This information is computed from the instance data associated with the form element.

ATK:ATK_STATE_INVALID
multiselectable MSAA:STATE_SYSTEM_EXTSELECTABLE ATK:ATK_STATE_MULTISELECTABLE
pressed MSAA: STATE_SYSTEM_PRESSED is true when checked. ATK: ATK_STATE_PRESSED is true when checked
readonly MSAA:STATE_SYSTEM_READONLY ATK:ATK_STATE_READONLY=inverse of readonly
required MSAA: There is no mapping.

User agent must make available through the [DOM] or a specialized API.

Note: While optional could be combined with required this is kept to be consistent with CSS3 pseudo classes and [XForms].

ATK: There is no mapping.
selected MSAA:STATE_SYSTEM_SELECTED ATK:ATK_STATE_SELECTED
unknown MSAA:mixed ATK:indeterminate
value MSAA: should return the value for getValue(). ATK: should return this as part of the AccessibleValue structure.

(As yet) unmapped properties are:

5.5 References

[AAC]
Apple Accessibility for Cocoa™. Available at: http://developer.apple.com/documentation/Cocoa/Conceptual/Accessibility/index.html.
[ARIA-ROLE]
Roles for Accessible Rich Internet Applications (WAI-ARIA Roles), L. Seeman, Editor. World Wide Web Consortium, 26 September 2006. This version of WAI-ARIA Roles is available at http://www.w3.org/TR/2006/WD-aria-role-20060926/. The latest version of WAI-ARIA Roles is available at http://www.w3.org/TR/aria-role/.
[ARIA-ROADMAP]
Roadmap for Accessible Rich Internet Applications (WAI-ARIA Roadmap), R. Schwerdtfeger, Editor. World Wide Web Consortium, 26 September 2006. This version of WAI-ARIA Roadmap is available at http://www.w3.org/TR/2006/WD-aria-roadmap-20060926/. The latest version of WAI-ARIA Roadmap is available at http://www.w3.org/TR/aria-roadmap/.
[CSS]
Cascading Style Sheets, level 2 (CSS2) Specification, I. Jacobs, B. Bos, H. Lie, C. Lilley, Editors, W3C Recommendation, 12 May 1998, http://www.w3.org/TR/1998/REC-CSS2-19980512/. Latest version available at http://www.w3.org/TR/REC-CSS2/.
[DOM]
Document Object Model (DOM) Level 2 Core Specification, L. Wood, G. Nicol, A. Le Hors, J. Robie, S. Byrne, P. Le Hégaret, M. Champion, Editors, W3C Recommendation, 13 November 2000, http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/. Latest version available at http://www.w3.org/TR/DOM-Level-2-Core/.
[GAP]
Gnome Accessibility Project (GAP) State and StateSets. Available at: http://developer.gnome.org/projects/gap/tech-docs/at-spi-docs/at-spi-cspi-state-and-statesets.html.
[IA2]
IAccessible2. Available at http://www.linux-foundation.org/en/Accessibility/IAccessible2.
[JAPI]
Java Accessibility API (JAPI). Available at: http://java.sun.com/products/jfc/accessibility/index.jsp.
[MSAA]
Microsoft Active Accessibility (MSAA). Available at: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/msaa/msaastart_9w2t.asp.
[RFC2119]
"Key words for use in RFCs to indicate requirement levels", RFC 2119, S. Bradner, March 1997. Available at: http://www.rfc-editor.org/rfc/rfc2119.txt.
[SMIL]
Synchronized Multimedia Integration Language (SMIL) 1.0 Specification, P. Hoschka, Editor, W3C Recommendation, 15 June 1998, http://www.w3.org/TR/1998/REC-smil-19980615/. Latest version available at http://www.w3.org/TR/REC-smil/.
[SVG]
Scalable Vector Graphics (SVG) 1.1 Specification, D. Jackson, J. Ferraiolo, ??, Editors, W3C Recommendation, 14 January 2003, http://www.w3.org/TR/2003/REC-SVG11-20030114/. Latest version available at http://www.w3.org/TR/SVG11/.
[UAAG]
User Agent Accessibility Guidelines 1.0, I. Jacobs, J. Gunderson, E. Hansen, Editors, W3C Recommendation, 17 December 2002, http://www.w3.org/TR/2002/REC-UAAG10-20021217/. Latest version available at http://www.w3.org/TR/UAAG10/.
[WCAG20]
Web Content Accessibility Guidelines 2.0, M. Cooper, B. Caldwell, G. Vanderheiden, L. Guarino Reid, Editors, W3C Working Draft (work in progress), 17 May 2007, http://www.w3.org/TR/2007/WD-WCAG20-20070517/. Latest version available at http://www.w3.org/TR/WCAG20/.
[XFORMS]
XForms 1.0 (Second Edition), R. Merrick, M. Dubinko, T. V. Raman, J. Boyer, D. Landwehr, L. L. Klotz, Editors, W3C Recommendation, 14 March 2006, http://www.w3.org/TR/2006/REC-xforms-20060314/. Latest version available at http://www.w3.org/TR/xforms/.
[XHTML]
XHTML™ 1.0 The Extensible HyperText Markup Language (Second Edition), S. Pemberton, Editor, W3C Recommendation, 1 August 2002, http://www.w3.org/TR/2002/REC-xhtml1-20020801/. Latest version available at http://www.w3.org/TR/xhtml1/.
[XHTMLMOD]
XHTML™ Modularization 1.1 , M. Altheim, F. Boumphrey, S. McCarron, S. Schnitzenbaumer, S. Dooley, T. Wugofski, Editors, W3C Working Draft (work in progress), 5 July 2006, http://www.w3.org/TR/2006/WD-xhtml-modularization-20060705/. Latest version available at http://www.w3.org/TR/xhtml-modularization/.
[XML]
Extensible Markup Language (XML) 1.0 (Fourth Edition) , T. Bray, J. Paoli, E. Maler, C. M. Sperberg-McQueen, F. Yergeau, Editors, W3C Recommendation, 16 August 2006, http://www.w3.org/TR/2006/REC-xml-20060816/. Latest version available at http://www.w3.org/TR/xml/.
[XML-EVENTS]
XML Events, S. McCarron, S. Pemberton, T. V. Raman, Editors, W3C Recommendation, 14 October 2003, http://www.w3.org/TR/2003/REC-xml-events-20031014/. Latest version available at http://www.w3.org/TR/xml-events/.
[XML-NAMES]
Namespaces in XML 1.0 (Second Edition) , D. Hollander, A. Layman, R. Tobin, T. Bray, Editors, W3C Recommendation, 16 August 2006, http://www.w3.org/TR/2006/REC-xml-names-20060816/. Latest version available at http://www.w3.org/TR/xml-names/.
[XSD]
XML Schema Part 0: Primer Second Edition, D. C. Fallside, P. Walmsley, Editors, W3C Recommendation, 28 October 2004, http://www.w3.org/TR/2004/REC-xmlschema-0-20041028/. Latest version available at http://www.w3.org/TR/xmlschema-0/.

5.6 Acknowledgments (Non-Normative)

This section is informative.

The following contributed to the development of this document.

5.6.1 Participants active in the PFWG at the time of publication

  • Jim Allan (TSBVI)
  • Judy Brewer (W3C/MIT)
  • Michael Cooper (W3C/MIT)
  • Donald Evans (AOL)
  • Kentarou Fukuda (IBM)
  • Alfred S. Gilman
  • Andres Gonzalez (Adobe)
  • Georgios Grigoriadis (SAP AG)
  • Jeff Grimes (Oracle)
  • Jon Gunderson (UIUC)
  • Alex Li (SAP AG)
  • Charles McCathieNevile (Opera)
  • Dave Pawson (RNIB)
  • David Poehlman (State of MD)
  • Janina Sajka (FSG)
  • Richard Schwerdtfeger (IBM)
  • Lisa Seeman (UB Access)
  • Ryan Williams (Oracle)
  • Gottfried Zimmermann (Access Technologies Group)

5.6.2 Other previously active PFWG participants and other contributors to States and Properties Module for Accessible Rich Internet Applications

Special thanks to Aaron Leventhal for effort and insight as he implemented a working prototype of accessibility API bindings.

Christian Cohrs, Becky Gibson, Barbara Hartel, Jael Kurz, Vitaly Sourikov.

5.6.3 Enabling funders

This publication has been funded in part with Federal funds from the U.S. Department of Education under contract number ED05CO0039. 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.