Techniques for User Agent Accessibility Guidelines 1.0

Abstract

This document provides techniques for implementing the checkpoints defined in "User Agent Accessibility Guidelines 1.0". These techniques address the accessibility of user interfaces, content rendering, program interfaces, and languages such as the Hypertext Markup Language (HTML), Cascading Style Sheets (CSS) and the Synchronized Multimedia Integration Language (SMIL).

This document is part of a series of accessibility documents published by the Web Accessibility Initiative (WAI).

Status of this document

This section describes the status of this document at the time of its publication. Other documents may supersede this document. The latest status of this document series is maintained at the W3C.

This is a W3C Working Draft for review by W3C Members and other interested parties. It is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to use W3C Working Drafts as reference material or to cite them as other than "work in progress". This is work in progress and does not imply endorsement by, or the consensus of, either W3C or Members of the WAI User Agent (UA) Working Group.

While User Agent Accessibility Guidelines 1.0 strives to be a stable document (as a W3C Recommendation), the current document is expected to evolve as technologies change and content developers discover more effective techniques for designing accessible Web sites and pages.

Please send comments about this document to the public mailing list: w3c-wai-ua@w3.org. Mailing list archives are available on the Web.

This document has been produced as part of the Web Accessibility Initiative. The goals of the WAI UA Working Group are discussed in the WAI UA charter. A list of the UA Working Group participants is available.

A list of current W3C Recommendations and other technical documents can be found at http://www.w3.org/TR.

1 Introduction

This document suggests techniques for satisfying each requirement of "User Agent Accessibility Guidelines 1.0". It also includes references to other accessibility resources (such as platform-specific software accessibility guidelines) that provide additional information on how a user agent may satisfy each checkpoint. The Techniques provided are informative examples only, and other strategies may be used to meet the checkpoint as well as, or in place of, those discussed. The Techniques Document has been designed to track changes in technology and implementation solutions and is expected to be updated more frequently than the current document.

"User Agent Accessibility Guidelines 1.0" is part of a series of accessibility guidelines published by the Web Accessibility Initiative (WAI) . The series also includes "Web Content Accessibility Guidelines 1.0" [WAI-WEBCONTENT] and "Authoring Tool Accessibility Guidelines 1.0" [WAI-AUTOOLS].

1.1 Document conventions

The following editorial conventions are used throughout this document:

• HTML element names are in uppercase letters (e.g., H1, BLOCKQUOTE, TABLE, etc.)
• HTML attribute names are quoted in lowercase letters (e.g., "alt", "title", "class", etc.)

1.2 Priorities

Each checkpoint in this document is assigned a priority that indicates its importance for users with disabilities.

[Priority 1]

This checkpoint must be satisfied by user agents, otherwise one or more groups of users with disabilities will find it impossible to access information. Satisfying this checkpoint is a basic requirement for some individuals to be able to use the Web.

[Priority 2]

This checkpoint should be satisfied by user agents, otherwise one or more groups of users with disabilities will find it difficult to access information. Satisfying this checkpoint will remove significant barriers to Web access.

[Priority 3]

This checkpoint may be satisfied by user agents to make it easier for one or more groups of users with disabilities to access information. Satisfying this checkpoint will improve Web accessibility.

2 User Agent Accessibility Guidelines

This section lists each checkpoint of the Guidelines along with some possible techniques for satisfying it. Each checkpoint also links to larger accessibility topics where appropriate.

Guideline 1. Support input and output device-independence

Checkpoints for user interface accessibility:

1.1 Ensure that every functionality offered through the user interface is available through every input device API used by the user agent. User agents are not required to reimplement low-level functionalities (e.g., for character input or pointer motion) that are inherently bound to a particular API and most naturally accomplished with that API. [Priority 1]

Note. The device-independence required by this checkpoint applies to functionalities described by the other checkpoints in this document unless otherwise stated by individual checkpoints. This checkpoint does not require user agents to use all operating system input device APIs, only to make the software accessible through those they do use.

Techniques:

Operating system and application frameworks provide standard mechanisms for controlling application navigation for standard input devices. In the case of Windows, OS/2, the X Windows System, and MacOS, the window manger provides GUI applications with this information through the messaging queue. In the case of non-GUI applications, the compiler run-time libraries provide standard mechanisms for receiving keyboard input in the case of desktop operating systems. Should you use an application framework such as the Microsoft Foundation Classes, the framework used must support the same standard input mechanisms.

When implementing custom GUI controls do so using the standard input mechanisms defined above. Examples of not using the standard input devices are:

• Do not communicate directly with the device. For instance, in Windows, do not open the keyboard device driver directly. This may circumvent system messaging. It is often the case that the windowing system needs to change the form and method for processing standard input mechanisms for proper application coexistence within the user interface framework.
• Do not implement your own input queue handler. Devices for mobility access, such as those that use serial keys, use standard system facilities for simulating keyboard and mouse input to all graphical applications. Example facilities for generating these input device events are the Journal Playback Hooks in both OS/2 and Windows. These hooks feed the standard system message queues in these respective windowing systems. To the application, the resulting keyboard and mouse input messages are treated as standard input and output device messages generated by the user's actions.
• If you implement an interface where the user selects text then issues a command related to it (e.g., select text then create a link using the selected text as content), all operations related to the selection and operation on the selected text must be done in a device-independent manner. In the case of a desktop user agent this means that the user must be able to perform these tasks using either keyboard or mouse.

---

1.2 Use the standard input and output device APIs of the operating system. [Priority 1]

For example, do not directly manipulate the memory associated with information being rendered since screen review utilities, which monitor rendering through the standard APIs, will not work properly.

Techniques:

• When writing textual information in a GUI operating system, use standard text drawing APIs of an operating system. Text converted to offscreen images or sequences of strokes cannot be intercepted as text drawing calls at the graphics engine or display driver subsystem of a GUI. Legacy screen reading solutions intercept these drawing calls before being transferred to the display and use the text drawn to create a text model representation of what you see on the screen. This "offscreen model" is used to speak GUI text. If you do not use the standard text drawing APIs, legacy screen reading systems will not be able to render it as speech or Braille. More information on this is provided in the techniques for checkpoint 1.5.
• Use operating system resources for rendering audio information. In operating systems like Windows, a set of standard audio sound resources are provided to support standard sounds such as alerts. These preset sounds are used to activate SoundSentry visual queues when a problem occurs; this benefits users with hearing disabilities. These queues may be manifested by flashing the desktop, active caption bar, or active window. It is important to use the standard mechanisms to generated audio feedback so that operating system or special assistive technologies can add additional functionality for the hearing disabled.
• Enhance the functionality of standard system controls to improve accessibility where none is provided by responding to standard keyboard input mechanisms. For example provide keyboard navigation to menus and dialog box controls in the Apple Macintosh operating system. Another example is the Java Foundation Classes, where internal frames do not provide a keyboard mechanisms to give them focus. In this case your will need to add keyboard activation through the standard keyboard activation facility for Abstract Window Toolkit components.
• Use standard operating system resources for rendering audio information. When doing so, do not take exclusive control of system audio resources. This could prevent an assistive technology such as screen reader from speaking if they use software text-to-speech conversion.

---

1.3 Ensure that the user can interact with all active elements in a device-independent manner. [Priority 1]

For example, users who are blind or have physical disabilities must be able to activate text links, the links in a client-side image map, and form controls without a pointing device. Note. This checkpoint is an important special case of checkpoint 1.1.

Techniques:

Refer to checkpoint 1.1 and checkpoint 1.5.

Users must be able to activate text links, form controls, image maps, and other active elements with mouse or keyboard or whatever input device is supported.

For client-side image maps:

• Render client-side image maps as text links on user demand.
• If a text equivalent (specified via "alt" or "title" in HTML) is available and not null for the element (like INPUT or IMG in HTML) that has an associated client-side map, indicate the presence of a map in text (e.g., "Start of map") plus the text equivalent and the number of areas in the map. If the text equivalent is null, do not render the map or its areas.
• For each AREA in the map, if a text equivalent ("alt" or "title") is available and not null, render the text equivalent as a link. Otherwise, render some text like "Map area" plus part or all of the href value as a link. If alt "text" is null for an AREA, do not render that AREA.
• In SMIL, image maps may be created with "anchor" elements using the "href" attribute for the link. Refer to "Accessibility Features of SMIL" [SMIL-ACCESS] for details.
• When reading through the whole Web page, read the start of the map's text equivalent with the number of areas, but skip over the AREA links. To read and activate the map areas, use keys that read and navigate link by link or element by element.

Use the document object model to enable device independent activation of elements:

• When implementing Document Object Model specifications ([DOM1], [DOM2]), allow programmatic activation of active elements, whether they are links, links in an image map, or any DOM element that can respond to an event causing a secondary action.
• In the "Document Object Model (DOM) Level 2 Specification" [DOM2], all elements can be potentially active and it is helpful to allow for activation of all DOM elements by an assistive technology. For example, a DOM2 'focusin' event may result in the construction of a pull-down menu by an attached JavaScript function. Providing a programmatic mechanism of activating the 'focusin' function will allow users to operate the user agent through speech. Each DOM element may have more than one set of activation mechanism based on the DOM event received and it is helpful to enable an assistive technology to enumerate those functions by description and to activate them. An example of this type of functionality can be seen in the Java Accessibility API [JAVAAPI]. This API provides an an AccessibleAction Java interface. This interface provides a list of actions and descriptions that can be used to describe and activate each function selectively.

---

1.4 Ensure that every functionality offered through the user interface is available through the standard keyboard API. [Priority 1]

The keystroke-only command protocol of the user interface should be efficient enough to support production use. Functionalities include being able to show, hide, resize and move graphical viewports created by the user agent. Note. This checkpoint is an important special case of checkpoint 1.1.

Techniques:

• Ensure that the user can trigger mouseover, mouseout, click, etc. events from the keyboard.
• Ensure that the user can use the keyboard (e.g., to navigate links sequentially).
• Ensure that the user can use the graphical user interface menus from the keyboard.
• Ensure that the keyboard can be used to cut, copy, paste, and drag.
• Ensure that the user can select text using the keyboard standards for the platform.
• Allow the user to change the state of form controls using the keyboard.

---

1.5 Ensure that all messages to the user (e.g., informational messages, warnings, errors, etc.) are available through all output device APIs used by the user agent. Do not bypass the standard output APIs when rendering information (e.g., for reasons of speed, efficiency, etc.). [Priority 1]

For instance, ensure that information about how much content has been viewed is available through output device APIs. Proportional navigation bars may provide this information graphically, but the information must be available (e.g., as text) to users relying on synthesized speech or Braille output.

Techniques:

Operating system and application frameworks provide standard mechanisms for using standard output devices. In the case of common desktop operating systems such as Windows, OS/2, and MacOS, standard API are provided for writing to the display and the multimedia subsystems.

It is important to also support standard output notification of sound such as notifications found in the Windows control panel for sounds. Windows maps accessibility features to the event caused by generation of these specific system sounds. Accessibility features such as SoundSentry will flash the screen, as appropriate, in response to events that would cause these sounds to play. This enables users with hearing i to use the application.

When implementing standard output:

• Do not render text in the form of bitmap before transferring to the screen. Screen Readers intercept text drawing calls to create a text representation of the screen, called an offscreen model, which is read to the user. Common operating system 2D graphics engines and drawing libraries provide functions for drawing text to the screen. Examples of this are the Graphics Device Interface (GDI) for Windows, Graphics Programming Interface (GPI) for OS/2, and for the X Windows System or Motif it is the X library (XLIB).
• Do not provide your own mechanism for generating pre-defined system sounds.
• When using a device do not use the device driver directly. In the case of display drivers, screen readers are designed to monitor what is drawn on the screen by hooking drawing calls at different points in the of the drawing process. By calling the display driver directly you may be drawing to the display below the point at which a screen reader for the blind is intercepting the drawing call.
• Do not draw directly to the video frame buffer. This circumvents the interception point at which a screen reader hooks the display calls.
• Do not forget to provide a text equivalent to voiced messages. Make sure an auditory message also has a redundant visual text message. For example, a message like "You've got mail" should also be presented graphically or with text.
• Do not preclude text presentation when providing auditory tutorials. Tutorials that use speech to guide a user through the operation of the user agent should also be available at the same time as graphically displayed text.

---

Guideline 2. Ensure user access to all content

Checkpoints for content accessibility:

2.1 Ensure that the user has access to all content, including alternative equivalents for content. [Priority 1]

Note. Although it is not a requirement that alternative equivalents be available at the same time as primary content, some users may benefit from simultaneous access. For instance, users with low vision may want to view images (even imperfectly) but require a text equivalent for the image to be rendered in a very large size or as speech.

Techniques:

• Refer to the section on access to content.
• Refer to the section on link techniques.
• Refer to the section on table techniques.
• Refer to the section on frame techniques.
• Refer to the section on form techniques.
• Refer to the section on abbreviations and acronyms.
• The "Altifier Tool" [ALTIFIER] illustrates smart techniques for generating text equivalents for images, etc. when the author hasn't supplied any.
• In HTML 4.0 [HTML40], authors supply alternative equivalents for content as follows:
  • For the IMG element (section 13.2): The "alt" (section 13.8), "title" (section 7.4.3), and "longdesc" (section 13.2) attributes.
  • For the OBJECT element (section 13.3): The content of the element and the "title" attribute.
  • For the deprecated APPLET element (section 13.4): The "alt" attribute and the content of the element.
  • For the AREA element (section 13.6.1): The "alt" attribute.
  • For the INPUT element (section 17.4): The "alt" attribute.
  • For the ACRONYM and ABBR elements (section 9.2.1): The "title" attribute may be used for the acronym or abbreviation expansion.
  • For the TABLE element (section 11.2.1), the "summary" attribute.
  • For frames, the NOFRAMES element (section 16.4.1) and the "longdesc" attribute (section 16.2.2) on FRAME and IFRAME (section 16.5).
  • For scripts, the NOSCRIPT element (section 18.3.1).
• For information about alternative equivalents for SMIL content, refer to "Accessibility Features of SMIL" [SMIL-ACCESS].

---

2.2 Render content according to natural language identification. [Priority 1]

For example, render text with the appropriate font family or synthesized speech dictionary. Lay out text in the appropriate direction (right-to-left, left-to-right, etc.) Natural language may be identified by markup (e.g., the "lang" attribute in HTML 4.0 ([HTML40] section 8.1) or "xml:lang" in XML 1.0 ([XML], section 2.12), or by the HTTP Content-Language header ([RFC2616], section 14.12). Refer also to checkpoint 2.9 and checkpoint 5.4.

Note. A user agent may not support all languages. When a user agent supports a language identified by a multipart identifier (e.g., "en-us"), the user agent must indicate in its conformance claim which language it claims to support (e.g., "en" alone, "en-us" alone, or both).

Techniques:

Assistive technologies may recognize different languages and can render content according to language markup defined for a certain part of the document. For instance, a screen reader might change the pronunciation of spoken text according to the language definition. This is usually desired and done according to the capabilities of the tool. Some specialized tools might give some finer user control for the pronunciation as well.

Sometimes the user might also want to know when content contains content in other languages. The user should be able to control rendering of the language change. For instance, the user might choose to hear "language:German" when the language changes to German and "language:default" when it changes back. This may be implemented in CSS 2 with the ':before' and ':after' pseudo-elements ([CSS2], section 5.12.3)

For example, with the following definition in the stylesheet:

    [lang|=es]:before { content: "start Spanish "; }
    [lang|=es]:after { content: " end Spanish"; }

the following HTML example:

<P lang="es" class="Spanish">
 <A href="foo_esp.html" 
    hreflang="es">Esta pagina en español</A></P>

might be spoken "start Spanish _Esta pagina en espanol_ end Spanish". Refer also to information on matching attributes and attribute values useful for language matching in CSS 2 ([CSS2], section 5.8.1).

If users don't want to see or hear blocks of content in another language, allow the user to suggest hiding that content (e.g., with style sheets).

• Implement content negotiation so that users may specify language preferences. Or allow the user to choose a resource when several are available in different languages.
• Use an appropriate glyph set when rendering visually.
• Use an appropriate voice set when rendering as speech.
• Render characters with the appropriate directionality. Refer to the "dir" attribute and the BDO element in HTML 4.0 ([HTML40], sections 8.2 and 8.2.4 respectively). Refer also to the Unicode standard [UNICODE].
• A user agent may not be able to render all characters in a document meaningfully, for instance, because the user agent lacks a suitable font, a character has a value that may not be expressed in the user agent's internal character encoding, etc. In this case, section 5.4 of HTML 4.0 [HTML40] recommends the following for undisplayable characters:
  1. Adopt a clearly visible (or audible), but unobtrusive mechanism to alert the user of missing resources.
  2. If missing characters are presented using their numeric representation, use the hexadecimal (not decimal) form since this is the form used in character set standards.
• Refer to "Character Model for the World Wide Web" [CHARMOD], which defines various aspects of a character model for the World Wide Web. It contains basic definitions and models, specifications to be used by other specifications or directly by implementations, and explanatory material. In particular, early uniform normalization, string identity matching, string indexing, and conventions for URIs are addressed.

---

2.3 Provide time-independent access to time-dependent active elements or allow the user to control the timing of changes. [Priority 1]

Techniques:

• Render time-dependent links instead as a static list that occupies the same screen real estate. Include (temporal) context in the list of links. For example, provide the time at which the link appeared along with a way to easily jump to that portion of the presentation.
• Provide easy-to-use controls (including both mouse and keyboard commands) to allow viewers to pause the presentation and advance and rewind by small and large time increments.
• Allow the user to navigate sequences of related links that vary over time.
• Provide a mode in which all active elements are highlighted in some way and can be navigated sequentially. For example, use a status bar to indicate the presence of active elements and allow the user to navigate among them with the keyboard or mouse to identify each element when the presentation is moving and when it is paused.
• Allow the user to to stop and start the flow of changes to content. Prompt the user for confirmation of a pending change.

---

2.4 When no text equivalent has been supplied, indicate what type of object is present. [Priority 2]

Techniques:

• If no captioning information is available and captioning is turned on, render "no captioning information available" in the captioning region of the viewport.
• The "Altifier Tool" [ALTIFIER] illustrates smart techniques for generating text equivalents for images, etc. when the author hasn't supplied any.
• Use values of other known attributes that might give clues about the object.
• Refer to the section on frame techniques.
• Refer to the section on link techniques.

---

2.5 When a text equivalent for content is explicitly empty (i.e., an empty string), render nothing. [Priority 3]

Checkpoints for user interface accessibility:

2.6 If more than one alternative equivalent is available for content, allow the user to choose from among the alternatives. This includes the choice of viewing no alternatives. [Priority 1]

For example, if a multimedia presentation has several tracks of captions (or subtitles) available (e.g., in different languages, different levels of detail, different reading levels, etc.) allow the user to choose from among them.

Techniques:

• Distinguish image links from their long descriptions ("longdesc" in HTML).
• Allow users to received long description text, according to their preference:
  1. always
  2. on request, with a brief signal should indicate its presence (e.g. a tone)
  3. on request, but without even that signal.
• Make information available with different levels of detail. For example, for a voice-activated browser, offer two options for alternative equivalents to HTML images:
  1. Speak only "alt" text by default, but allow the user to hear "longdesc" text on an image by image basis.
  2. Speak "alt" text and "longdesc" for all images.
• Provide an interface which displays all available tracks, with as much identifying information as the author has provided, and allow users to choose which tracks are rendered. For example, if the author has provided "alt" or "title" for various tracks, use that information to construct the list of tracks.
• Provide an interface which allows users to indicate their preferred language separately for each kind of equivalent. The selection can be based on user preferences in either the user agent (cf., the Content-Language entity-header field of RFC 2616 [RFC2616], section 14.12) or the operating system. Users with disabilities may need to choose the language they are most familiar with in order to understand a presentation which may not include all equivalent tracks in all desired languages. In addition, international users may prefer to hear the program audio in its original language while reading captions in their first language, fulfilling the function of subtitles or to improve foreign language comprehension. In classrooms, teachers may wish to control the language of various multimedia elements to achieve specific educational goals.

  The following image illustrates how users select preferred language for captions in the Real Player.

  

  The next image illustrates how users select preferred language in the Windows operating system under properties for Regional Settings. This preference could be inherited by the user agent.

  

---

2.7 Allow the user to specify that captions and auditory descriptions be rendered at the same time as the associated auditory and visual tracks. [Priority 1]

Note. Respect synchronization cues during rendering.

Techniques:

It is important that captions and auditory descriptions be rendered synchronously with the primary content. This ensures that users with disabilities can use the primary and equivalent content in combination. For example, if a hard-of- hearing user is watching a video and reading captions, it is important for the captions to be synchronized with the audio so that the viewer can use any residual hearing. For audio description, it is crucial that the primary audio track and the auditory description track be kept in sync to avoid having them both play at once, which would reduce the clarity of the presentation.

User agents that play SMIL ([SMIL]) presentations should take advantage of a variety of access features defined in SMIL (refer to "Accessibility Features of SMIL" [SMIL-ACCESS]). A future version of SMIL (known currently as SMIL "Boston") is in development and additional access features may be available when this specification becomes a W3C Recommendation.

As defined in SMIL 1.0, SMIL players should allow users to turn captions on and off by implementing the test attribute system-captions which takes the values "on" and "off." For example, include in the player preferences a way for users to indicate that they wish to view captions, when available. SMIL files with captions available should use the following syntax:

<textstream alt="English captions for My Favorite Movie"
            system-captions="on"
            src="closed-caps.txt"/>

In this case, when the user has requested captions, this textstream should be rendered, and when they have not it should not be rendered.

SMIL 1.0 does not provide a test attribute to control auditory descriptions. However, future versions of SMIL (including SMIL "Boston") are expected to include such a test attribute. Should SMIL "Boston" become a W3C Recommendation, developers should implement it then. A test attribute to turn auditory descriptions on and off should be implemented in parallel to the implementation of the 'system-captions' attribute. Users should be able to indicate the preference to receive auditory description, when content authors make it available, through the standard preferences setting section of user interface.

Another test attribute, 'system-overdub-or-captions' in SMIL 1.0, allows the user to choose between alternate language text or sound. This attribute specifies whether subtitles or overdub should be rendered for people who are watching a presentation where the audio may be in a language they do not understand fluently. This attribute can have two values: "overdub", which selects for substitution of one voice track for another, and "subtitle", which means that the user prefers the display of subtitles. However, this attribute should not be used to determine if users need captions. When both are available, deaf users will prefer to view captions, which contain additional information on music, sound effects, and who is speaking, which are not included in subtitles since those are intended for hearing people.

User agents that play QuickTime movies should provide the user with a way to turn on and off the different tracks embedded in the movie. Authors may use these alternate tracks to provide alternative equivalents for use by viewers with disabilities. The Apple QuickTime player currently provides this feature through the menu item "Enable Tracks."

User agents that play Microsoft Windows Media Object presentations should provide support for Synchronized Accessible Media Interchange (SAMI), a protocol for creating and displaying caption text synchronized with a multimedia presentation. Users should be given a way to indicate their preference for viewing captions. In addition, user agents which play Microsoft Windows Media Object presentations should enable viewers to turn on and off other alternative equivalents, including auditory description and alternate visual tracks.

Other video or animation formats should incorporate similar features. At a minimum, users who are blind and users who are deaf need to be able to turn on and off auditory description and and captions. The interface to set these preferences must be accessible. Information on how to author accessible tracks should be included in documentation about the media player.

---

2.8 If a technology allows for more than one audio track, allow the user to choose from among tracks. [Priority 1]

Techniques:

• Refer to techniques for [#choose-equivalent].
• Make apparent through the user interface which tracks are meant to be played mutually exclusively.

---

2.9 For identified but unsupported natural languages, allow the user to request notification of language changes. [Priority 3]

Note. The user should be able to request no notification of language changes.

Techniques:

A user agent should treat content language as part of contextual information. When the language changes, the user agent should either render the content in the supported language or notify the user of the language change (if configured for notification). Rendering could involve speaking in the designated language in the case of an audio browser or screen reader. If the language was not supported, the language change notification could be spoken in the default language by a screen reader or audio browser.

Language switching for blocks of content may be more helpful than inline language switching. In some language combinations, less than a few words long foreign phrases are often well-integrated in the primary language (e.g., Japanese being the primary and English being the secondary or quoted). In such situations, dynamic switching in in-line level may make the reading sound unnatural, and possibly harder to be understood.

Language information for HTML ("lang", "dir") and the Extensible Markup Language (XML) ("xml:lang") should be made available through the Document Object Model (DOM) ([DOM1], [DOM2]).

User agents may announce language changes using style sheets to generate text (refer to CSS 2 [CSS2] and XSLT [XSLT]) that indicates the change of language.

---

Guideline 3. Allow the user to turn off inaccessible features

In addition to the techniques below, refer also to the section on user control of style.

Checkpoints for content accessibility:

3.1 Allow the user to turn on and off rendering of background images. [Priority 1]

Techniques:

• Allow the user to turn off embedded or background images through the user interface. Note that any alternative equivalents for those images must still be available.
• In CSS background images may be turned on/off with the 'background' and 'background-image' properties ([CSS2], section 14.2.1).

---

3.2 Allow the user to turn on and off rendering of background audio. [Priority 1]

Techniques:

• Allow the user to turn off background audio through the user interface.
• Users sometimes specify background sounds with the "bgsound" attribute. Note. This attribute is not part of HTML 4.0 [HTML40].
• In CSS 2, background sounds may be turned on/off with the 'play-during' property ([CSS2], section 19.6).

---

3.3 Allow the user to turn on and off rendering of video. [Priority 1]

Techniques:

• Allow the user to turn off video through the user interface. Render a still image in its place.
• Support the 'display' property in CSS.

---

3.4 When the user agent renders audio natively, allow the user to turn on and off rendering of audio. [Priority 1]

Note. To render audio natively means that the user agent drives the speaker directly.

Techniques:

• Allow the user to turn off audio through the user interface.
• Support the CSS 2 'display', 'play-during', and 'speak' properties in ([CSS2], sections 9.2.5, 19.6, and 19.5, respectively).

---

3.5 Allow the user to turn on and off animated or blinking text. [Priority 1]

Techniques:

• Allow the user to turn off animated or blinking text through the user interface (e.g., by hitting the ESCAPE key to stop animations). Render static text in place of blinking text.
• The BLINK element. Note. The BLINK element is not defined by a W3C specification.
• The MARQUEE element. Note. The MARQUEE element is not defined by a W3C specification.
• The CSS 'blink' value of the 'text-decoration' property.

---

3.6 Allow the user to turn on and off animations and blinking images. [Priority 1]

Techniques:

• Allow the user to turn off animated or blinking text through the user interface (e.g., by hitting the ESCAPE key to stop animations). Render a still image in its place.x

---

3.7 Allow the user to turn on and off support for scripts and applets. [Priority 1]

Note. This is particularly important for scripts that cause the screen to flicker, since people with photosensitive epilepsy can have seizures triggered by flickering or flashing particularly in the 4 to 59 flashes per second (Hertz) range.

Techniques:

Peak sensitivity to flickering or flashing occurs at 20 Hertz.

Refer to the section on script techniques

---

3.8 Allow the user to turn on and off rendering of images. [Priority 3]

Techniques:

Refer to techniques for checkpoint 3.1.

---

3.9 Allow the user to turn on and off author-specified forwards that occur after a time delay and without user intervention. [Priority 3]

Techniques:

Content refresh according to an author-specified time interval can be achieved with the following markup in HTML:

<META http-equiv="refresh" content="60">

The user agent should allow the user to disable this type of content refresh.

Although no HTML specification defines this behavior formally, some user agents support the use of the META element to refresh the current page after a specified number of seconds, with the option of replacing it by a different URI. Instead of this markup, authors should use server-side redirects (with HTTP).

User agents can provide a link to other content rather than changing the content automatically.

User agents may also prompt the user and ask whether to continue with forwards.

---

For example, when forwarding has been turned off, offer a static link to the target.

3.10 Allow the user to turn on and off automatic content refresh. [Priority 3]

For example, when turned off, indicate to the user that content needs refreshing and allow the user to do so through the user interface.

Guideline 4. Ensure user control over styles

In addition to the techniques below, refer also to the section on user control of style.

Checkpoints for fonts and colors:

4.1 Allow the user to control font family. [Priority 1]

Techniques:

• Implement the CSS 'font-family' property.
• Allow the user to override the author's specified fonts.
• Inherit font information from user's settings for the operating system.

---

4.2 Allow the user to control the size of text. [Priority 1]

For example, allow the user to specify a font family and style directly through the user interface. Or, allow the user to give preferences through a user style sheet. Or allow the user to magnify text.

Techniques:

• Implement the CSS 'font-size' property.
• Allow the user to configure the user agent to ignore author-specified font size.
• Inherit font size information from user's settings for the operating system.

---

4.3 Allow the user to control foreground color. [Priority 1]

Techniques:

• Implement the CSS 'color' and 'border-color' properties.
• Allow the user to specify minimal contrast between foreground and background colors, adjusting colors dynamically to meet those requirements.
• Allow the user to impose a specific foreground color, ignoring author-supplied colors.
• Inherit foreground color information from user's settings for the operating system.

---

4.4 Allow the user to control background color. [Priority 1]

Techniques:

• Implement the CSS 'background-color' property and other background properties.
• Allow the user to impose a specific background color, ignoring author-supplied colors.
• Inherit background color information from user's settings for the operating system.

---

4.5 Allow the user to control selection highlighting (e.g., foreground and background color). [Priority 1]

Techniques:

• For instance, in X Windows, the following resources controls the selection colors in Netscape Navigator: "*selectForeground" and "*selectBackground".
• Implement the CSS 2 "HighLightText and "Highlight" predefined color values ([CSS2], section 18.2).
• Inherit selection/focus information from user's settings for the operating system.

---

4.6 Allow the user to control focus highlighting (e.g., foreground and background color). [Priority 1]

Checkpoints for applets and animations:

4.7 Allow the user to control animation rate. [Priority 2]

Checkpoints for video.

4.8 Allow the user to control video frame rates. [Priority 1]

4.9 Allow the user to control the position of captions. [Priority 1]

4.10 Allow the user to start, stop, pause, fast forward, and rewind video. [Priority 2]

Checkpoints for audio:

4.11 Allow the user to control audio playback rate. [Priority 1]

Note. User agents may not be able to control the playback rate for some audio formats.

4.12 When the user agent renders audio natively, allow the user to control the audio volume. [Priority 2]

4.13 Allow the user to start, stop, pause, fast forward, and rewind audio. [Priority 2]

Checkpoints for synthesized speech:

4.14 Allow the user to control synthesized speech playback rate. [Priority 1]

Techniques:

• In CSS2, use the 'speech-rate' property.

---

4.15 Allow the user to control synthesized speech volume. [Priority 1]

4.16 Allow the user to control synthesized speech pitch, gender, and other articulation characteristics. [Priority 2]

Checkpoints for user interface accessibility:

4.17 Allow the user to select from available author and user style sheets, including no author or user style sheets. [Priority 1]

Note. The browsers default style sheet is always present.

Techniques:

• Make available "class" and "id" information so that users can override styles.
• Allow the user to define custom styles for "class" and "id" attributes specified in the document.

---

4.18 Allow the user to control user agent-initiated spawned viewports. [Priority 2]

For example, in HTML, allow the user to control the process of opening a document in a new target frame or a viewport created by author-supplied scripts. In SMIL 1.0, allow the user to control viewports created with show="new". Control may involve prompting the user to confirm or cancel the viewport creation. Users may also want to control the size or position of the viewport and to be able to close the viewport (e.g., with the "back" functionality).

Techniques:

User agents may:

• Allow users to turn off support for spawned viewports entirely
• Prompt them before spawning a viewport

For example, user agents may recognize the HTML construct target="_blank" and spawn the window according to the user's preference.

---

Guideline 5. Observe system conventions and standard interfaces

Checkpoints for content accessibility:

5.1 Provide accessible APIs to other technologies. [Priority 1]

5.2 Conform to W3C Document Object Model specifications and export interfaces defined by those specifications. [Priority 1]

For example, refer to the DOM ([DOM1], [DOM2]). User agents should export these interfaces using available operating system conventions.

Techniques:

A Document Object Model (DOM) is an interface to a standardized tree structure representation of a document. This interface allows authors to access and modify the document with client-side scripting language (e.g., JavaScript) in a consistent manner across scripting languages. As a standard interface, a DOM makes it easier not just for authors but for assistive technology developers to extract information and render it in ways most suited to the needs of particular users. Information of particular importance to accessibility that must be available through the DOM includes:

• Content, including alternative equivalents.
• Style sheet information (for user control of styles).
• Script and event handlers (for device-independent control of behavior).
• The document structure (for navigation, creation of alternative views).

User agents should implement W3C DOM Recommendations, including DOM Level 1 [DOM1] and DOM Level 2 [DOM2]]. The W3C Recommendation for DOM Level 1 ([DOM1]) provides access to HTML and XML document information. The DOM Level 2 ([DOM2]) is made of a set of core interfaces to create and manipulate the structure and contents of a document and a set of optional modules. These modules contain specialized interfaces dedicated to XML, HTML, an abstract view, generic stylesheets, Cascading Style Sheets, Events, traversing the document structure, and a Range object.

It is important to note that DOM is designed to be used on a server as well as a client and therefore a lot of user interface-specific information such as screen coordinate information is not relevant and not addressed by the DOM specification.

Assistive technologies also require information about browser highlight mechanisms (e.g., the selection and focus) that may not be available through the W3C DOM.

The DOM Level 1 specification states that "DOM applications may provide additional interfaces and objects not found in this specification and still be considered DOM compliant."

Note. The WAI Protocols and Formats Working Group is focusing its efforts on the DOM as the conduit from which to extract accessibility information and enhance the accessibility of a rendered document through a user agent.

---

Checkpoints for user interface accessibility:

5.3 Use accessibility resources and conventions of the operating system and supported programming languages, including those for plug-ins and virtual machine environments. [Priority 1]

For instance, if the user agent supports Java applets and provides a Java Virtual Machine to run them, the user agent should support the proper loading and operation of a Java native assistive technology. This assistive technology can provide access to the applet as defined by Java accessibility standards.

Techniques:

The operating system application programming interfaces (APIs) that support accessibility are designed to provide a bridge between the standard user interface supported by the operating system and alternative user interfaces developed by third-party assistive technology vendors to provide access to persons with disabilities. Applications supporting these APIs are therefore generally more compatible with third-party assistive technology.

The User Agent Accessibility Guidelines Working Group strongly recommends using and supporting APIs that improve accessibility and compatibility with third-party assistive technology. Third-party assistive technology can use the accessibility information provided by the APIs to provide an alternative user interface for various disabilities.

The following is an informative list of currently public APIs that promote accessibility:

• Microsoft Active Accessibility ([MSAA]) in Windows 95/98/NT versions.
• Sun Microsystems Java Accessibility API ([JAVAAPI]) in Java Code.

Many operating systems have built-in accessibility features for improving the usability of the standard operating system by persons with disabilities. When designing software that runs above an underlying operating system, developers should ensure that the application:

1. Makes use of operating system level features. See the appendix of accessibility features for some common operating systems.
2. Inherits operating system settings related to accessibility. Pertinent settings include font and color information as well as other pieces of information discussed in this document.

Write output to and take input from standard system APIs rather than directly from hardware controls where possible. This will enable the I/O to be redirected from or to assistive technology devices - for example, screen readers and Braille devices often redirect output (or copy it) to a serial port, while many devices provide character input, or mimic mouse functionality. The use of generic APIs makes this feasible in a way that allows for interoperability of the assistive technology with a range of applications.

User agents should use standard rather than custom controls when designing user agents. Third-party assistive technology developers are more likely able to access standard controls than custom controls. If you must use custom controls, review them for accessibility and compatibility with third-party assistive technology.

For information about rapid access to Microsoft Internet Explorer's DOM through COM, refer to [BHO].

---

5.4 Provide programmatic read and write access to user agent functionalities and user interface controls. [Priority 1]

For example, ensure that assistive technologies have access to information about the current input configuration so that they can trigger functionalities through keyboard events, mouse events, etc. Refer also to checkpoint 5.3.

5.5 Implement selection and focus mechanisms and make the selection and focus available to users and through APIs. [Priority 1]

Refer also to checkpoint 7.1 and checkpoint 5.4. Note. This checkpoint is an important special case of checkpoint 5.4.

5.6 Provide programmatic notification of changes to content and user interface controls (including selection and focus). [Priority 1]

Refer also to checkpoint 5.3.

5.7 Provide programmatic exchange of information in a timely manner. [Priority 2]

This is important for synchronous alternative renderings and simulation of events.

5.8 Follow operating system conventions and accessibility settings. In particular, follow conventions for user interface design, default keyboard configuration, product installation, and documentation. [Priority 2]

Refer also to checkpoint 10.5.

Techniques:

Develop the UA User Interface (UI) with standard interface components per the target platform(s). Most major operating system platforms provide a series of design and usability guidelines; these should be followed when possible (see platforms below). These checklists, style guides, and human interface guidelines provide very valuable information for developing applications (e.g., UAs) for any platform/operating system/GUI.

For instance, software should use the standard interface for keyboard events rather than working around it.

Evaluate your standard interface components on the target platform against any built in operating system accessibility functions (see Appendix 8) and be sure your UA operates properly with all these functions.

For example, take caution with the following:

• Microsoft Windows supports an accessibility function called "High Contrast". Standard window classes and controls automatically support this setting. However, applications created with custom classes or controls must understand how to work with the "GetSysColor" API to ensure compatibility with High Contrast.
• Apple Macintosh supports an accessibility function called "Sticky Keys". Sticky Keys operates with keys the operating system recognizes as modifier keys, and therefore a custom UA control should not attempt to define a new modifier key.

Some guidelines for specific platforms:

• "Macintosh Human Interface Guidelines" [APPLE-HI] Apple Computer Inc.
• "IBM Guidelines for Writing Accessible Applications Using 100% Pure Java" [JAVA-ACCESS].
• "An ICE Rendezvous Mechanism for X Window System Clients" [ICE-RAP].
• "Information for Developers About Microsoft Active Accessibility" [MSAA].
• "The Inter-Client communication conventions manual" [ICCCM].
• "Lotus Notes accessibility guidelines" [NOTES-ACCESS].
• "Java accessibility guidelines and checklist" [JAVA-CHECKLIST].
• "The Java Tutorial. Trail: Creating a GUI with JFC/Swing" [JAVA-TUT].
• "The Microsoft Windows Guidelines for Accessible Software Design" [MS-SOFTWARE].

General guidelines for producing accessible software:

• "Accessibility for applications designers" [MS-ENABLE].
• "Application Software Design Guidelines" [TRACE-REF].
• "Designing for Accessibility" [SUN-DESIGN].
• "EITAAC Desktop Software standards" [EITAAC].
• "Requirements for Accessible Software Design" [ED-DEPT].
• "Software Accessibility" [IBM-ACCESS].
• Towards Accessible Human-Computer Interaction" [SUN-HCI].
• "What is Accessible Software" [WHAT-IS].
• Accessibility guidelines for Unix and X Window applications [XGUIDELINES].

Follow System Conventions for loading Assistive Technologies:

User agents should follow operating system or application environment (e.g., Java) conventions for loading assistive technologies. In the case of Java applets, the browser's Java Virtual Machine should follow the Sun convention for loading an assistive technology. Writing an application that follows the Java system conventions for accessible software does not allow the applet to be accessible if an assistive technology designed for that environment cannot be run to make the applet accessible. Refer to the appendix on loading assistive technologies for DOM access for information about how an assistive technology developer can load its software into a Java Virtual Machine.

---

Guideline 6. Implement accessible specifications

Checkpoints for content accessibility:

6.1 Implement the accessibility features of supported specifications (markup languages, style sheet languages, metadata languages, graphics formats, etc.). [Priority 1]

Note. The Techniques Document [UA-TECHNIQUES] discusses accessibility features of W3C specifications.

Techniques:

• The accessibility features of Cascading Style Sheets ([CSS1], [CSS2]) are described in "Accessibility Features of CSS" [CSS-ACCESS]. Note that CSS 2 includes properties for controlling synthesized speech styles.
• The accessibility features of SMIL 1.0 [SMIL] are described in "Accessibility Features of SMIL" [SMIL-ACCESS].
• The following is a list of accessibility features of HTML 4.0 [HTML40] in addition to those described in techniques for checkpoint 2.1:
  • The CAPTION element (section 11.2.2) for rich table captions.
  • Table elements (THEAD, TBODY, TFOOT (section 11.2.3), COLGROUP, and COL (section 11.2.4) that group table rows and columns into meaningful sections.
  • Attributes ( "scope", "headers", and "axis", section 11.2.6) that non-visual browsers may use to render a table in a linear fashion, based on the semantically significant labels.
  • The "tabindex" attribute (section 17.11.1) for assigning the order of keyboard navigation within a document.
  • The "accesskey" attribute (section 17.11.2) for assigning keyboard commands to active components such as links and form controls.

---

6.2 Conform to W3C specifications when they are appropriate for a task. [Priority 2]

For instance, for markup, implement HTML 4.0 [HTML40] or XML 1.0 [XML]. For style sheets, implement CSS ([CSS1], [CSS2]). For mathematics, implement MathML [MATHML]. For synchronized multimedia, implement SMIL 1.0 [SMIL]. For access to the structure of HTML or XML documents, implement the DOM ([DOM1], [DOM2]). Refer also to checkpoint 5.2.

Note. For reasons of backward compatibility, user agents should continue to support deprecated features of specifications. The current guidelines refer to some deprecated language features that do not necessarily promote accessibility but are widely deployed.

Guideline 7. Provide navigation mechanisms

Checkpoints for user interface accessibility:

7.1 Allow the user to navigate viewports (including frames). [Priority 1]

Note. For example, when all frames of a frameset are displayed side-by-side, allow the user to navigate among them with the keyboard. Or, when frames are accessed or viewed one at a time (e.g., by a text browser or speech synthesizer), provide a list of links to other frames. Navigating into a viewport makes it the current viewport.

Techniques:

• Some operating systems provide a means to navigate among all open windows using multiple input devices (e.g., keyboard and mouse). This technique would suffice for switching among user agent viewports that are separate windows. However, user agents may also provide a mechanism to shift the focus among user agent windows, independent of the standard operating system mechanism.
• Consult the section on frame techniques.

---

7.2 For user agents that offer a browsing history mechanism, when the user returns to a previous view, restore the point of regard in the viewport. [Priority 1]

For example, when users navigate "back" and "forth" among views, for each view they should find the viewport position where they left it.

7.3 Allow the user to navigate just among cells of a table (notably left and right within a row and up and down within a column). [Priority 1]

Note. Navigation techniques include keyboard navigation from cell to cell (e.g., using the arrow keys) and page up/down scrolling. Refer also to checkpoint 1.1 and checkpoint 5.4.

Techniques:

Refer to the section on table navigation.

---

7.4 Allow the user to navigate all active elements. [Priority 1]

Navigation mechanisms may range from sequential (e.g., sequential navigation) to direct (e.g., by entering link text) to searching on active elements only (e.g., based on form control text, associated labels, or form control names). Note. This checkpoint is an important special case of checkpoint 7.7.

7.5 Allow the user to navigate just among all active elements. [Priority 2]

Note. In checkpoint 7.4, navigation may include non-active elements in addition to active elements.

Techniques:

2.7.1 Sequential navigation techniques

Allow the user to sequential navigate all active elements using a single keystroke. User agents might also provide other sequential navigation mechanisms for particular element types or semantic unit. For example "Find the next table" or "Find the previous form".

It is important that application developers maintain a logical element navigation order. For instance, users may use the keyboard to navigate among elements or element groups and using the arrow keys within a group of elements. One example of a group of elements is a set of radio buttons. Users should be able to navigate to the group of buttons, then be able to select each button in the group. Similarly, allow users to navigate from table to table, but also among the cells within a given table (up, down, left, right, etc.)

• How to indicate that something is in navigation order in Java: A component is inclusive in the sequential navigation order when added to a panel and its isFocusTraversable() method returns true. A component can be removed from the navigation order by simply extending the component, overloading this method, and returning false.
• Give the users the option of navigating to and activating a link, or just moving the focus to the link. When the user returns to the page after following the link, restore focus to that link.
• Many user agents today allow users to navigate sequentially by tabbing -- for example, using the "tab" key for forward navigation and "shift-tab" for reverse navigation. Because the "tab" key is typically on one side of the keyboard while arrow keys are located on the other, users should be allowed to configure the user agent so that sequential navigation is possible with keys that are physically closer to the arrow keys. Refer also to checkpoint 10.3.

2.7.2 Direct navigation techniques

Excessive use of sequential navigation can reduce the usability of software for both disabled and non-disabled users. Direct access (e.g., through keyboard shortcuts) should also be possible. Providing direct access involves:

• Assigning each active element a unique identifier (or use the identifier provided by the author, e.g., "accesskey" in HTML). For example number each active element in a document.
• Documenting how the user may access elements.
• Allowing direct access by element content (e.g., the first letter of element content).
• Allowing direct access to a table cell by its row/column position.

---

7.6 Allow the user to search for rendered text content, including text equivalents of visual and auditory content. [Priority 2]

Note. Use operating system conventions for marking the result of a search (e.g., selection and focus).

Techniques:

• Allow users to search for element content and attribute values (human-readable ones).
• Allow forward and backward searching from the point of regard, beginning of document, or end of document.
• Allow users to search the document source view.
• For forms, allow users to find required controls. Allow users to search on labels as well as content of some controls.
• Allow the user to search among just text equivalents of other content.
• For multimedia presentations:
  • Allow users to search and examine time-dependent media elements and links in a time-independent manner. For example, present a static list of time-dependent links.
  • Allow users to find all media elements active at a particular time in the presentation.
  • Allow users to view a list of all media elements or links of the presentations sorted by start or end time or alphabetically.
  • For frames, allow users to search for content in all frames (without having to be in a particular frame).

---

7.7 Allow the user to navigate according to structure. [Priority 2]

For example, allow the user to navigate familiar elements of a document: paragraphs, tables, headers, lists, etc. Note. Use operating system conventions to indicate navigation progress (e.g., selection and focus).

Techniques:

• DOM is minimal (tree navigation)
• Best navigation will involve a mix of source tree information and rendered information.
• May use commonly understood document models rather than strict Document Type Definition (DTD) navigation. E.g., properly nesting headers in HTML. Headers should be used only to convey hierarchy, not for graphical side-effects.
• Goal of simplifying the structure view as much as possible.
• Allow the user to control level of detail/ view of structure.
• Depth first as well as breadth first possible. Allow next/previous sibling, up to parent, and end of element.
• Navigation of synchronized multimedia: allow users to stop, pause, fast forward, advance to the next clip, etc.
• Allow the user to navigate characters, words, sentences, paragraphs, screenfuls, and other language-dependent pieces of text content. This may be particularly useful with a speech-based user interface. Precise and flexible navigation of this kind with a system cursor is often useful when browsing with accessibility aids. Evidence of this point is that the leading Windows screen readers have super-imposed such navigation on a popular web browser that does not natively support it (e.g., Winvision, Window-Eyes, and JAWS with Internet Explorer).

Skipping navigation bars:

Author-supplied navigation mechanisms such as navigation bars at the top of each page may force users with screen readers or some physical disabilities to wade through numerous links on each page of a site. User agents may facilitate browsing for these users by allowing them to skip recognized navigation bars (e.g., through a configuration option). Some techniques for doing so include:

1. Provide a functionality to jump to the first non-link content.
2. In HTML, the MAP element may be used to mark up a navigation bar (even when there is no associated image). Thus, users might ask that MAP elements not be rendered in order to hide links inside the MAP element. Note. Starting in HTML 4.0, the MAP element allows block content, not just AREA elements.

---

7.8 Allow the user to configure structured navigation. [Priority 3]

For example, allow the user to navigate only paragraphs, or only headers and paragraphs, etc.

Techniques:

• Allow the user to navigate by element type.
• Allow the user to navigate HTML elements that share the same "class" attribute.
• Allow the user to expand or shrink portions of the structured view (control detail level) for faster access to important parts content.

---

Guideline 8. Orient the user

Checkpoints for content accessibility:

8.1 Convey the author-specified purpose of each table and the relationships among the table cells and headers. [Priority 1]

For example, provide information about table headers, how headers relate to cells, table caption and summary information, cell position information, table dimensions, etc. Note. This checkpoint is an important special case of checkpoint 2.1.

Techniques:

• Refer to the section on table techniques
• Allow the user to access this information on demand (e.g., by activating a menu or keystroke).

---

8.2 Indicate whether a focused link has been marked up to indicate that following it will involve a fee. [Priority 2]

Note. This checkpoint is an important special case of checkpoint 8.3. "Common Markup for micropayment per-fee-links" [MICROPAYMENT] describes how authors may mark up micropayment information in an interoperable manner. This information may be provided through the standard user interface provided the interface is accessible. Thus, any prompt asking the user to confirm payment must be accessible.

Techniques:

• Refer to the section on link techniques.
• Allow the user to access this information on demand (e.g., by activating a menu or keystroke for a focused link).

---

8.3 Provide information to help the user decide whether to follow a focused link. [Priority 2]

Note. Useful information includes: whether the link has already been visited, whether it designates an internal anchor, the type of the target resource, the length and size of an audio or video clip that will be started, and the expected natural language of target resource.

Techniques:

• Refer to the section on link techniques.
• Allow the user to access this information on demand (e.g., by activating a menu or keystroke).
• Implement CSS ':visited' and ':link' pseudo-classes, with ':before' class and the 'content' property to insert text before a link such as "visited" or "un-visited".

---

Checkpoints for user interface accessibility:

8.4 Provide a mechanism for highlighting and identifying (through a standard interface where available) the current viewport, selection, and focus. [Priority 1]

Note. This includes highlighting and identifying frames. Refer also to checkpoint 9.1.

Techniques:

• If colors are used to highlight the current viewport, selection, or focus, allow the user to set preferred colors and to ensure sufficient contrasts.
• If the current viewport is a window, allow the user to cause the window to pop to the foreground.
• If the current viewport is a frame or the user doesn't want windows to pop to the foreground, use colors, reverse videos, or other visual clues to indicate the current viewport. For speech or Braille output, render the title or name of a frame or window and indicate changes in the current viewport.
• Use operating system conventions, where available, for specifying selection and focus (e.g., schemes in Windows).
• Implement the CSS pseudo-classes ':hover', ':active', and ':focus'. This will allow users to modify focus presentation in user style sheets.

Refer also to the section on frame techniques

The following image illustrates the use by Opera 3.6 of a solid line border to indicate focus:

The following image illustrates the use of system highlight colors to indicate focus:

The following image illustrates the use of a dotted line border to indicate focus:

---

8.5 Provide an outline view of a resource built from the resource's structural elements (e.g., frames, headers, lists, forms, tables, etc.) [Priority 2]

For example, for each frame in a frameset, provide a table of contents composed of headers where each entry in the table of contents links to the header in the document.

Techniques:

• Use commonly understood document models rather than strict DTD navigation. E.g., properly nesting headers in HTML.
• For documents that don't use structure properly, user agents may try to create an outline from presentation elements used (insufficiently) to convey structure.
• Allow the user to shrink and expand the outline view selectively.
• Provide context-sensitive navigation: for instance, when the user navigates to a list or table, provide locally useful navigation mechanisms (e.g., within a table, cell-by-cell navigation) using similar input commands.
• Refer to the section on list techniques.

The following technique ideas were provided by the National Information Standards Organization [NISO]:

A "Navigation Control Center" (NCC) (NCC) resembles a traditional table of contents, but it is more. The NCC contains links to all headings at all levels in the book. In addition to the headings, links to all pages are inserted. Finally we include in the NCC links to all items that the reader may select to turn off for reading. For example, if the reader has the automatic reading of footnotes turned off, there must be a way to quickly get back to that information. For this reason, the reference to the footnote is placed in the NCC and the reader can go to the reference, understand the context for the footnote, and then read the footnote. All items that have the option of turning off automatic reading can be reached through the NCC.

Once the reader is at a desired location and wishes to begin reading, the navigation process changes. Of course, the reader may elect to read sequentially, but often some navigation is required (e.g., frequently people navigate forward or backward one word or character at a time). Moving from one sentence or paragraph at a time is also needed. This type of local navigation is different from the global navigation used to get to the location of what you want to read. It is frequently desirable to move from one block element to the next. For example, moving from a paragraph to the next block element which may be a list, blockquote, or sidebar is the normally expected mechanism for local navigation.

---

8.6 Allow the user to configure the outline view. [Priority 3]

For example, allow the user to control the level of detail of the outline. Refer also to checkpoint 8.5. Refer also to checkpoint 5.4.

8.7 Allow the user to configure what information about links to present. [Priority 3]

Note. Using color as the only distinguishing factor between visited and unvisited links does not suffice since color may not be perceivable by all users or rendered by all devices. Refer also to checkpoint 8.3.

Techniques:

• Allow the user to access this information on demand (e.g., by activating a menu or keystroke).
• Implement CSS ':visited' and ':link' pseudo-classes, with ':before' class and the 'content' property to insert text before a link such as "visited" or "un-visited".

---

8.8 Provide a mechanism for highlighting and identifying (through a standard interface where available) active elements. [Priority 3]

Note. User agents may satisfy this checkpoint by implementing the appropriate style sheet mechanisms, such as link highlighting.

8.9 Maintain consistent user agent behavior and default configurations between software releases. Consistency is less important than accessibility and adoption of operating system conventions. [Priority 3]

In particular, make changes conservatively to the layout of user interface controls, behavior of existing functionalities, and default keyboard configuration.

Guideline 9. Notify the user of content and viewport changes

Checkpoints for user interface accessibility:

9.1 Provide information about user agent-initiated content and viewport changes through the user interface and through APIs. [Priority 1]

For example, inform the users when a script causes a popup menu to appear.

Techniques:

• Refer to the section on frame techniques
• Render the changed content graphically.
• Highlight the current viewport.
• Emit an audible signal when a change occurs.
• Make DOM methods fire a "change" event that can be trapped.

---

9.2 Ensure that when the selection or focus changes, it is in a viewport after the change. [Priority 2]

Techniques:

• There are time when the focus changes (e.g., link navigation) and the viewport must be moved to track it. There are other times when the viewport changes position (e.g., scrolling) and the focus must be moved to follow it. In both cases, the focus (or selection) is in the viewport after the change.
• Make sure that search windows do not place the new focus that is the found object under a search popup.
• When the focus changes, "register" the newly focused element in the navigation sequence; sequential navigation should start from there.
• Only change selection/focus in the current viewport, not other viewports.

---

9.3 Prompt the user to confirm any form submission triggered indirectly, that is by any means other than the user activating an explicit form submit control. [Priority 2]

Techniques:

• Put up a dialog indicating the form will be submitted if it is done by an onChange, after a certain time, or for other script-based submission. Allow the user to suppress these dialogs for good.
• If the submit button is not the last control in the form, and no controls after it have been focused, put up a dialog pointing this out/asking if the user has filled in the information after the button.
• If a Javascript submission is fired, allow the user to ask for it to be intercepted and trigger the dialog mentioned above.

---

For example, do not submit a form automatically when a menu option is selected, when all fields of a form have been filled out, on a mouseover event, etc.

9.4 Allow the user to configure notification preferences for common types of content and viewport changes. [Priority 3]

For example, allow the user to choose to be notified (or not) that a script has been executed, that a new viewport has been opened, that a pulldown menu has been opened, that a new frame has received focus, etc.

Techniques:

• Refer to the section on frame techniques
• Allow the user to specify an element type for which notification should be disabled (e.g., table, body, img, ...)
• Allow the user to disable notification of changes to CSS properties
• Allow the user to disable notification of images that are changed

---

9.5 When loading content (e.g., document, video clip, audio clip, etc.) indicate what portion of the content has loaded and whether loading has stalled. [Priority 3]

Techniques:

Status information - on resource loading - should be provided in a device-independent manner. Techniques include text and non-text status indicators. Users should be able to request status information or have it rendered automatically. User agents may allow users to configure when status information should be rendered (e.g., by hiding or showing the status bar).

Screen readers may provide access on demand (e.g., through the keyboard) to the most recent status information, or to announce the new information whenever it changes.

Useful status information:

• Document proportions (numbers of lines, pages, width, etc.)
• Number of elements of a particular type (e.g., tables)
• The viewport is at the beginning or end of the document.
• Size of document in bytes.

User agents may allow users to configure what status information they want rendered. Allow users to access status information on demand through a keyboard or other shortcut.

Indicate when loading has finished, for example with a percentage indication or a special message. Indication must not depend on a particular output device.

---

9.6 Indicate the relative position of the viewport in content (e.g., the percentage of an audio or video clip that has been played, the percentage of a Web page that has been viewed, etc.). [Priority 3]

Note. The user agent may calculate the percentage according to focus position, selection position, or viewport position, depending on how the user has been browsing.

Techniques:

• Provide a scrollbar for the viewport.
• Give the size of the document as well, so that users may decide whether to download for offline viewing. For example, the playing time of an audio file could be stated in terms of hours, minutes, and seconds. The size of a primarily text based web page might be stated in both kilobytes and screens, where a screen of information is calculated based on the current dimensions of the viewport.
• List the current "page" as page X of a total of Y pages.
• Use a variable pitch audible signal to indicate position.
• Keep the information numerically and generate the output on user request. See new HTML work on Forms for further examples (a slider is like a dial is like a menu of lots of options...)
• Provide standard markers for specific percentages through the document (mile posts)
• Provide markers for positions relative to some position - a user selected point, the bottom, the H1, etc.
• Put a marker on the scrollbar, or a highlight at the bottom of the page while scrolling (so you can see what was the bottom before you started scrolling

---

Guideline 10. Allow configuration and customization

Checkpoints for user interface accessibility:

10.1 Provide information directly to the user and through APIs about the current user-specified input configuration (e.g., keyboard or voice bindings specified through the user agent's user interface). [Priority 1]

Techniques:

If the currently active configuration changes locally (e.g., a search prompt opens, changing the keyboard mapping for the duration of the prompt), alert the user. The user must also be informed of the changed (currently active) configuration. Do not rely on visual or audio cues alone to alert the user of the change. Do not limit the user to only one type of alert mechanism. Do not rely on visual cues (e.g., the underlining of an accelerator key) alone to inform the user of changes in the configuration.

Named configurations are easier to remember. This is especially important for persons with certain types of cognitive disabilities. For example, if the invocation of a search prompt changes the currently active configuration, the user may remember more easily which keystrokes are active in search mode if alerted that there is a "Search Mode". Context-sensitive help (if available) should reflect the change in mode, and a list of keybindings for the current mode should be readily available to the user.

2.10.1 Documentation of sequential navigation order

• Specified by the HTML 4.0 "tabindex" attribute ([HTML40], section 17.11.1).
• Provide a list of form controls according to the sequential navigation order of the form. This allows users to know whether, for example, a submit button is the last control in a form or whether the user must activate controls that follow it.
• Provide a structured view of form controls (e.g., those grouped by LEGEND or OPTGROUP in HTML) along with their labels.

2.10.2 Documentation of keyboard shortcuts

• Specified by the HTML 4.0 "accesskey" attribute ([HTML40], section 17.11.2).
• Use system conventions to indicate the current configuration.
• Document the default configuration.
• Allow direct access to active elements (links, form controls, etc.). For instance, through a menu that allows users to enter a link number of link text and to move the focus there.
• Allow the user to separate setting the focus and activating the control. For links, first-time users of a page may want to hear link text (focus) before deciding whether to follow the link (activate). More experienced users of a page would prefer to follow the link directly, without the intervening focus step.

2.10.3 Configuration of the user interface

• Allow the user to configure the user agent so that the current viewport is automatically maximized. For example, the parent window of the browser would automatically be maximized when launched, and each child window would automatically be maximized when it received input focus. Maximizing does not necessarily mean occupying the whole screen or parent window; it means expanding the current window so that the need to scroll horizontally or vertically is as little as possible.

---

10.2 Provide information directly to the user and through APIs about the current author-specified input configuration (e.g., keyboard bindings specified in content such as by "accesskey" in HTML 4.0). [Priority 2]

Techniques:

Distinguish the following classes of user input configurations:

• What are the defaults "out of the box"?
• What are the current settings different from those out of the box.
• What are those in effect for the current document only?
• What are those that have been overridden by the configuration of the current document? Also, how to access functionalities no longer available due to the current input configuration.

In association with local (e.g., this page only) and off-default bindings, provide information about how to work around the override.

Note that user support personnel, particularly remote support personnel, will need the "departures from shipping defaults" view for orientation.

The above classes may be distinguished by displayed properties in a combined presentation as well as by filtering to present only a restricted class.

Some reserved keyboard shortcuts are listed in the appendix on accessibility features of some operating systems.

In case of conflicts between author-supplied configuration and user-supplied, operating system defaults, or user agent default configurations, here is some possible behavior:

• Do not override default system and user agent controls, but alert the user of author-supplied configuration and provide a pass-through mechanism to allow author-specified configurations that conflict with default UA or OS keybindings to be invoked.
• Allow author-defined configurations to override user agent and operating system configurations, but alert the user of the conflicts and provide a pass-through mechanism so that the conflicting user agent or operating system configurations can be invoked.
• Remap author-supplied configurations to currently unused keystrokes, voice commands, etc. and alert the user to which configurations have been remapped.

---

10.3 Allow the user to change and control the input configuration. Users should be able to activate a functionality with a single-stroke (e.g., single-key, single voice command, etc.). [Priority 2]

For voice-activated browsers, allow the user to modify what voice commands activate functionalities Similarly, allow the user to modify the graphical user interface for quick access to commonly used functionalities (e.g., through buttons).

Techniques:

Provide a convenient interface for allowing users to control input configurations. For example, allow them to select from available options, rather than having them enter combinations themselves. This will speed up configuration and reduce questions to support staff later on how to configure the user agent.

User agents that allow users to customize or reconfigure mappings from keyboard, voice, etc. to user agent functionalities should allow each mapping to be accompanied by a description so that the user can understand the mapping. For example, if "Control-P" maps to a print functionality, a short description would be "Print" or "Print setup".

• Profiles
• Default values
• Device-independent configuration

When using a physical keyboard, some users require single-key access, others require that keys activated in combination be physically close together, while others require that they be spaced physically far apart. When allowing users to configure keyboard access to functionalities, user agents must consider operating system conventions, author-specified shortcuts, and user preferences. The user agent's default configuration should include shortcuts for frequently performed actions and should respect opera