Abstract
This document describes techniques that user agent developers
may use to satisfy the checkpoints listed in
"User Agent Accessibility Guidelines." Techniques relate to the accessibility of
user interfaces, content rendering, program interfaces, and
accessibility features of languages such as HTML, CSS and SMIL.
Like "User Agent Accessibility Guidelines", the current document emphasizes the
accessibility of interoperability between two important classes of
user agents - graphical desktop browsers and dependent assistive
technologies (including screen readers, screen magnifiers, and voice
input software). However, it is meant to be applicable to user
agents in general, including text and voice browsers, and multimedia
players.
While "User Agent Accessibility Guidelines" has been designed
to be a stable document of principles,
the current document will continue to evolve as
technologies change and user agent manufacturers discover more
effective techniques for designing accessible user agents.
This document is part of a series of accessibility documents published
by the W3C Web Accessibility Initiative.
Status of this document
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.
Although the organization of this document has begun to stabilize,
the Working Group has not yet filled in the details of all the
techniques. This draft does not distinguish those techniques
that mainstream user agents are expected to implement
natively from those that may be satisfied by providing
information through an interface.
Please send comments about this document to the public mailing list:
w3c-wai-ua@w3.org.
This document has been produced as part of the
Web Accessibility Initiative and intends
to improve user agent accessibility for all users.
The goals of the WAI UA
Working Group are discussed in the WAI UA
charter. A list of
the current Working Group
members is
available.
A list of current W3C Recommendations and other technical documents
can be found at http://www.w3.org/TR.
The guidelines documents have been organized to address readers
seeking abstract principles of accessible user agent design and
readers seeking concrete solutions. The guidelines documents define
three terms for different levels of abstraction:
- Guideline
- A guideline is a general principle of accessible design.
A guideline addresses the question "What
accessibility issues should I be aware of?"
- Checkpoint
- A checkpoint is a specific way of satisfying one or
more guidelines. While checkpoints describe verifiable
actions that may be carried out by the user agent
developer, implementation
details are described elsewhere. A checkpoint answers
the question "What should I do to improve accessibility?"
- Technique
- A technique is an implementation of one or more checkpoints in a
given language (e.g., HTML, XML, CSS, DOM, ...). A technique
answers the question "How do I do that in HTML or SMIL
or CSS...?"
The current document contains techniques, according to different
interfaces between the user agent and the operating system, the
document, the user, and other software. Note that each technique in
this document is numbered according to its number in the guidelines document.
[Checkpoint 7.2.4] Follow operating system conventions and accessibility settings in user interface design, configuration (including configuration profiles), product installation, and documentation.
[Priority 2]
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 WAI Working Group strongly recommends using and supporting APIs that
improve accessibility and compatibility with 3rd 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 support
accessibility:
Many major 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:
- Makes use of operating system level features.
See the appendix of
accessibility features for some comment operating systems.
- 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.
[Checkpoint 4.1.1] Ensure that the software may be installed in a device-independent manner using any supported input and output devices.
[Priority 1]
Ensure that software may be installed, when possible, according to
the conventions of the operating system.
In order for the user agent to satisfy many
of the techniques in this document (related to rendering,
notification, navigation, etc.), it must be able to
identify certain types of information in addition to
recognizing object types such as images, video, sound, and
elements of the document language.
User agents must be able to recognize sources of
alternative representations of content.
- In HTML
-
- For the IMG element: The "alt", "title", and "longdesc" attributes
- For the OBJECT element: The content of the element and the "title" attribute.
- For the APPLET element: The "alt" attribute and the content
of the element.
- For the AREA element: The "alt" attribute.
- For the INPUT element: The "alt" attribute.
- For the ACRONYM and ABBR elements: The "title" attribute
may be used for the acronym or abbreviation expansion.
- For the TABLE element, the "summary" attribute
- For frames, the NOFRAMES element and the "longdesc" attribute
on FRAME and IFRAME.
- For scripts, the NOSCRIPT element.
- In SMIL
- The "alt", "title", "longdesc", and "abstract" attributes.
To be completed..
User agents that recognize the following sources of
blinking text and animations must enable users to freeze that text.
- In HTML
-
- 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.
- In CSS
-
- The 'blink' value of the 'text-decoration' property.
- In GIF animated images.
- To be completed.
Certain elements of the document language may have associated event
handlers that are triggered when certain events occur. User agents
must be able to identify those elements with event handlers statically
associated (i.e., associated in the document source, not in a script).
- In HTML
- All of the attributes beginning with the prefix "on": "onblur", "onchange", "onclick", "ondblclick", "onkeydown", "onkeypress", "onkeyup", "onload", "onmousedown", "onmousemove", "onmouseout", "onmouseover", "onmouseup", "onreset", "onselect", "onsubmit", and "onunload".
-
-
User agents must be able to compute the following
information about a document:
- Has the document been fully loaded?
- What is the size in bytes of the document?
- How many active
components are in the document?
- Where is the point of regard?
See the section on sources
of alternative information
[Checkpoint 5.2.1] Ensure that the user has access to alternative representations of content (e.g., the value of "alt" in HTML or SMIL, the resource designated by "longdesc", or the content of OBJECT in HTML 4.0, the "summary" attribute for tables in HTML, etc.).
[Priority 1]
[Checkpoint 5.2.2] When no alternative text representation has been specified, indicate what type of object is present.
[Priority 2]
[Checkpoint 5.2.3] When alternative text has been specified explicitly as empty (i.e., an empty string), render nothing.
[Priority 3]
[Checkpoint 5.2.5] Allow the user to specify that captions for audio be rendered at the same time as the audio.
[Priority 2]
Scenario-video showing professor
writing complex equations and graphs on the overhead and discussing them but
not describing what he/she actually wrote on the overhead. Without
description this would be inaccessible to people with visual impairments.
This could be generalize to any video presentation of visually rich or
complex information where the visually presented information is critical to
the understanding of the presentation.
[Checkpoint 5.2.8] Allow the user to specify that captions or descriptions for video be rendered at the same time as the video.
[Priority 1]
[Checkpoint 5.1.10] Allow the user to control the position of captions.
[Priority 1]
[Checkpoint 5.2.9] Allow the user to specify that audio descriptions of video be rendered at the same time as the video.
[Priority 2]
In HTML, content of NOSCRIPT.
- In HTML, content of NOFRAMES.
- Otherwise, list of frames. Use "title" as name of
frame, otherwise "name".
In HTML, "summary" attribute. Also, the "abbr" attribute
for headers (see the section on table cells and headers).
Generated content specified through style sheets can help orient
the user. For instance, if, through style sheets, the user can insert
the word "Link" before every link, this text may be used by a speech
synthesizer or Braille devices. See the section on
the support for CSS2 accessibility features
below.
Properly constructed data tables generally have distinct TH head
cells and TD data cells. The TD cell content gains gain implicit
identification from TH cells in the same column and/or row.
For layout tables, a user agent can assist the reader by indicating
that no relationship between cells should be expected. Authors should
not use TH cells just for their formatting purpose in layout tables is
discouraged, as those TH cells imply that some TD cells should gain
meaning from the TH cell content.
[Checkpoint 5.4.1] Provide access to the contents of a specific table cell.
[Priority 1]
When a table is "read" from the screen, the contents of multiline
cells may become intermingled. For example, consider the following
table:
This is the top left cell This is the top right cell
table of the of the table.
This is the bottom left This is the bottom right
cell of the table. cell of the table.
If read directly from the screen, this table might be rendered
as "This is the top left cell This is the top right cell", which
would be confusing to the user.
A user agent should provide a means of determining the contents of
cells as discrete from neighboring cells, regardless of the size and
formatting of the cells. This information is made available through
the DOM ([DOM1]).
[Checkpoint 5.4.2] Provide access to header information for a specific table cell.
[Priority 1]
The contents of a cell in a data table are generally only
comprehensible in context (i.e., with associated header information,
row/column position, neighboring cell information etc.). User agents
should provide users with header information and other contextual
agent. Techniques include:
- Provide this information through an API.
- Ignore table markup entirely. This may assist some screen readers.
- Render cells as blocks. This may assist some screen readers.
Using this strategy, the user agent might render individual cells with the
relevant top and side headers attached.
- Allow navigation and querying of cell/header information.
When the point of regard is on an individual cell, the user would be able to
use a keyboard command to receive the top and left header information for
that cell. The user agent should appropriately account for headers that
span multiple cells.
- Allow users to read one table column or row at a time, which
may help them identify headers.
Since not all tables are designed with the header information, a conforming
user agent should provide, as an option, a "best guess" of the header
information for a cell. Possible strategies include:
-
Consider the top and left-most cells of a column or row to be header
information.
-
Consider upper and left-most cells which have formatting markup to be header
information.
The user may choose the form and amount of this information,
possibly announcing the row heads only once and then the column head
or its abbreviation ("abbr") to announce the cell content.
Possible solutions:
- Provide info through an API.
- Frames as blocks.
- Frameset as list of links to individual frames
(based on frame name).
- NOFRAMES content (when?)
[Checkpoint 5.3.6] Provide a mechanism (e.g., through style sheets) to distinguish visited links from unvisited links.
[Priority 3]
[Checkpoint 5.3.7] Allow the user to specify (e.g., through style sheets) that images used in links must have borders.
[Priority 3]
[Checkpoint 5.5.5] Provide the user with access to any label explicitly associated with a form control.
[Priority 2]
[Checkpoint 6.1.1] Provide a mechanism for highlighting and identifying (through a standard interface where available) the current view.
[Priority 1]
[Checkpoint 6.1.2] Provide a mechanism for highlighting and identifying (through a standard interface where available) the user selection.
[Priority 1]
[Checkpoint 6.1.3] Provide a mechanism for highlighting and identifying (through a standard interface where available) the current focus.
[Priority 1]
[Checkpoint 6.2.2] Allow the user to view a document outline constructed from its structural elements (e.g., from header and list elements).
[Priority 2]
In general, this requirement may be met by providing keyboard
access to all functionality and by exposing that functionality to third
party technology.
[Checkpoint 6.1.4] Ensure that when the selection changes, it is in the viewport after the change.
[Priority 2]
[Checkpoint 6.1.5] Ensure that when the focus changes, it is in the viewport after the change.
[Priority 2]
[Checkpoint 6.1.7] Keep track of the user's point of regard in each view and restore it when the user returns to the view.
[Priority 1]
There are different ways a user may want to navigate while browsing
the Web, including:
- By changing the position of the viewport
(e.g., by scrolling down the page).
- By shifting focus and/or selection from one active component to the next of the same type (e.g., from link to link).
- By navigating among documents.
[Checkpoint 6.1.6] Allow the user to navigate views (notably those with frame viewports). Navigating into a view makes it the current view.
[Priority 1]
[Checkpoint 6.2.3] Allow the user to navigate the document tree.
[Priority 2]
[Checkpoint 6.2.1] Allow the user to navigate sequentially among all active elements in the document. See also checkpoints [#Tnav-links], [#Tnav-longdesc], [#Tnav-tables], [#Tnav-form-controls], and [#Tnav-forms].
[Priority 1]
Sequential navigation includes all active elements. User
agents might provide other navigation mechanisms limited
to a particular type of element. For example "Find the next table"
or "Find the previous form". The following checkpoints suggest
some types of navigation.
[Checkpoint 5.3.1] Allow the user to navigate sequentially among links. [-Tnav-sequential]
[Priority 2]
[Checkpoint 5.5.2] Allow the user to navigate among forms in a document. [-Tnav-sequential]
[Priority 2]
[Checkpoint 5.5.1] Allow the user to navigate among form controls within a form. [-Tnav-sequential]
[Priority 2]
[Checkpoint 6.3.1] Allow the user to navigate among elements with associated event handlers.
[Priority 1]
[Checkpoint 6.2.4] Allow the user to navigate sequentially among headers.
[Priority 2]
[Checkpoint 6.2.5] Allow the user to navigate sequentially among block elements (e.g., paragraphs, lists and list items, etc.)
[Priority 2]
[Checkpoint 5.3.8] Allow the user to navigate among elements with associated long descriptions. [-Tnav-sequential]
[Priority 2]
Users of non-visual rendering technologies and users with learning
disabilities, when browsing a page, should be able to quickly
determine the nature of a table located on a page. The able-bodied
user is able to visually examine the table and extract a sense of the
table contents with a quick scan of the cells. A non-visual user, or a
user with difficulty translating printed material is not able to do
this. Providing table summary information, when first moving the
point-of-regard to a table allows the nature of a table to be easily
determined.
An auditory rendering agent, when the point-of-regard moves to a
table, might say, "Table: Tax tables for 1998," thus identifying the
nature of the table. The user could then use keyboard commands to move
the point of regard to the next logical block of information, or use a
different command to "burrow" into the table.
The "burrow" command should have an opposite "pop" command, which
would move the point of regard from an individual cell to the table as
a whole, so that the user can leave a table from any cell within it,
rather than navigating to the end.
If the user "pops" up to look over the summary information, it
should be possible to "burrow" back to the same cell.
When navigating a table that contains another table, this strategy
can avoid confusion. For example, if each row of a table
contained five cells, but the second row contained a 4x4 table in the
third cell, a user could be disoriented when the row did not end as
expected. However, when the point of regard moved to the third cell of
the table, a compliant browser would report that this was a table, and
describe its contents. The user would have the option of navigating to
the forth cell of the parent table, or burrowing into the table within
this cell.
[Checkpoint 5.4.3] Allow the user to navigate among tables in a document. [-Tnav-sequential]
[Priority 2]
When rendering tabular information, the fact that it is tabular
information should be apparent. For a visual user agent, such
information is commonly made obvious by the border attribute. However,
for a non-visual agent, such information must also be made
appreciable.
As the user agent shifts the point of regard to a table, it should
first provide information about the entire table. This information
might be the Caption, Title, or Summary information of the
table. Access to this information would allow the user to determine
whether or not to examine the contents of the table, or to move the
point of regard to the next block of content.
[Checkpoint 5.4.4] Allow the user to navigate among table cells of a table (notably left and right within a row and up and down within a column).
[Priority 1]
In many data tables, the meaning of the contents of a cell are
related to the contents of adjacent cells. For example, in a table of
sales figures, the sales for the current quarter might be best
understood in relation to the sales for the previous quarter, located
in the adjacent cell.
In order to provide access to contextual information for
individuals using non-visual browsers, or for individuals with certain
types of learning disabilities, it is necessary for the user agent to
allow the point of regard to be moved from cell to cell, both
right/left and up/down via keyboard commands.
The most direct method of performing such navigation would be via
the cursor keys, though other navigation strategies might be used.
User agents can also help users by allowing them to
choose their own navigation patterns, based, for example,
on element names, text, attribute values, etc.
[Checkpoint 5.3.2] Allow the user to search for a link in the current document based on its link text.
[Priority 1]
[Checkpoint 5.3.3] Allow the user to search for a link based on its attribute values.
[Priority 1]
[Checkpoint 5.3.4] Allow the user to move the focus to a link based on its integer (tabbing-order) position.
[Priority 1]
[Checkpoint 5.5.3] Allow the user to search for a form control based on its text content.
[Priority 1]
[Checkpoint 5.5.4] Allow the user to search for a form control based on its attribute values.
[Priority 1]
[Checkpoint 6.2.6] Allow the user to search for content. In case of a match, move the selection to the content.
[Priority 2]
[Checkpoint 5.3.9] Allow the user to search linked long description text (i.e., in another document). In case of a match, the focus should be moved to the link in the current document.
[Priority 2]
[Checkpoint 5.4.5] Allow the user to search for a table cell based on its contents or header information.
[Priority 2]
Users of visual browsers can easily locate cells within a table
that are at the intersection of a row and column of interest. To
provide equivalent access to users of non-visual browsers, equivalent
means of navigation should be provided. The search function of a
browser will allow the user to locate key terms within a table, but
will not allow the user to find cells that are at the intersection of
rows and columns of interest.
Techniques:
- An advanced search mode might provide entries for header information,
allowing the user to find information at the intersection of columns and
rows using the key terms.
-
A search mode might allow the user to search for key terms that are related
to key header terms, allowing searches to be restricted to specific rows or
headers within a table.
The header information visible in a TH cell may be abbreviated,
in which case it should be user preference to see the "abbr"
value if any or the full contents.
Axis information may also help the user search into confined
portions of the table.
Column groups and row groups are other confining partitions of a
table in which a search may be limited.
[Checkpoint 5.3.5] Provide the user with information about the number of links in a document.
[Priority 2]
[Checkpoint 5.5.6] Provide the user with information about the number of forms in a document.
[Priority 2]
[Checkpoint 5.5.7] Provide the user with information about the number of controls in a form.
[Priority 2]
[Checkpoint 5.4.8] Allow the user to find out the number of tables in a document.
[Priority 2]
Users of non-visual rendering technologies may wish, on entering a
document, to determine the degree to which tables are used on the
page. This information may allow the user to make guesses about the
nature of the tables included (layout or data), and to relocate
information that was previously browsed.
[Checkpoint 5.4.6] Allow the user to select a table cell and find out its row/column coordinates in the table.
[Priority 2]
Non-visual rendering of information by a browser or an assistive
technology working through a browser will generally not render more
than a single cell, or a few adjacent cells at a time. Because of
this, the location of a cell of interest within a large table may be
difficult to determine for the users of non-visual rendering.
In order to provide equivalent access to these users, compliant
browsers should provide a means of determining the row and column
coordinates of the cell having the point of regard via keyboard
commands. Additionally, to allow the user of a non-visual rendering
technology to return to a cell, the browser should allow a means of
moving the point of regard to a cell based on its row and column
coordinates.
At the time the user enters a table, or while the point of regard
is located within a table, the user agent should allow an assistive
technology to provide information to the user regarding the dimensions
(in rows and columns) of the table. This information, in combination
with the summary, title, and caption, can allow the user with a
disability to quickly decide whether to explore the table of skip over
it.
[Checkpoint 5.4.7] Allow the user to find out the dimensions of a table.
[Priority 2]
Dimensions is an appropriate term, though dimensions needn't be
constants. For example a table description could read: "4 columns for
4 rows with 2 header rows. In those 2 header rows the first two
columns have "colspan=2". The last two columns have a common header
and two subheads. The first column, after the first two rows, contains
the row headers.
Some parts of a table may have 2 dimensions, others three, others
four, etc. Dimensionality higher than 2 are projected onto 2 in a
table presentation.
[Checkpoint 6.1.9] When a document is loaded or when requested by the user, make available document summary information.
[Priority 2]
[Checkpoint 6.1.8] Provide the user with information about the number of viewports.
[Priority 2]
[Checkpoint 6.1.10] Provide the user with information about how much of the document has been viewed (i.e., where the point of regard is with respect to the beginning of the document).
[Priority 2]
[Checkpoint 4.3.2] Ensure that user can find out about all keyboard bindings (e.g., through menus).
[Priority 2]
[Checkpoint 4.2.3] Ensure that the user can activate the links and form controls in a document in an input device-independent manner.
[Priority 1]
[Checkpoint 4.2.1] Ensure that all functionalities offered by the user agent interface are available through all supported input devices. These include the installation procedure, access to documentation, and software configuration.
[Priority 1]
[Checkpoint 4.2.2] Ensure that all messages to the user (e.g., warnings, errors, etc.) are available in an output device-independent manner using any supported output devices.
[Priority 1]
Universal design means that access to features that help
accessibility should be integrated into normal menus. User agents
should avoid regrouping access to accessibility features into
specialized menus. Documentation includes anything that explains how
to install, get help for, use, or configure the product. Users must
have access to installation information, either in electronic form
(diskette, over the Web), by fax, or by telephone.
[Checkpoint 4.1.3] Describe product features known to promote accessibility in a section of the product documentation.
[Priority 2]
For instance, include references to
accessibility features in these places:
- Indexes.
Include terms related to product accessibility in the documentation index
(e.g., "accessibility", "disability" or "disabilities").
- Tables of Contents
Include terms related to product accessibility in the documentation table
of contents (e.g., features that promote accessibility)
- Include instructions on how to modify all user
configurable defaults and preferences
(e.g, images, video, style sheets, and scripts) as specified
by the documentation.
- Include a list of all
keyboard shortcuts in the accessibility section of
the documentation.
[Checkpoint 4.1.2] Ensure that all product documentation conforms to the Web Content Accessibility Guidelines ([WAI-PAGEAUTH]).
[Priority 1]
Documentation created in HTML should follow the Web Content Accessibility Guidelines.
Electronic documentation created in open standard formats such as
HTML and ASCII can often be accessed in the user's choice of
application such as a word processor or browser. Accessing
documentation in familiar applications is particularly important to
users with disabilities who must learn the functionalities of their
tools, be able to configure them for their needs, and to be compatible
with assistive technology. Electronic documentation should not be
provided in proprietary formats.
Users with print impairments may need or desire documentation in
alternative formats such as Braille, large print, or audio tape. User
agent manufacturers may provide user manuals in alternative
formats. Documents in alternative format documents can be created by
agencies such as Recording for the
Blind and Dyslexic and the National
Braille Press.
User instructions should be created in an input device-independent
manner. Provide instructions for using or configuring the user agent
in a manner that can be understood by a user of any input device
including a mouse or keyboard. For example, "Click on the Home button
on the toolbar or select "Home" from the Go menu to return to the Home
page. "
[Checkpoint 4.3.3] Provide a mechanism to render the presence of a keyboard binding for an active element.
[Priority 2]
To ensure accessibility, users must have final control
over certain renderings.
For text and color:
[Checkpoint 5.1.1] Allow the user to control font family.
[Priority 1]
[Checkpoint 5.1.2] Allow the user to control font size.
[Priority 1]
[Checkpoint 5.1.3] Allow the user to control foreground color.
[Priority 1]
[Checkpoint 5.1.4] Allow the user to control background color.
[Priority 1]
[Checkpoint 5.1.5] Allow the user to control selection highlighting (e.g., foreground and background color).
[Priority 1]
[Checkpoint 5.1.6] Allow the user to control focus highlighting (e.g., foreground and background color).
[Priority 1]
For images, applets, and animations:
[Checkpoint 4.4.2] Allow the user to turn on and off rendering of background images.
[Priority 1]
[Checkpoint 5.1.7] Allow the user to control animation rate.
[Priority 2]
For user agents rendering audio:
[Checkpoint 5.1.11] Allow the user to control audio playback rate.
[Priority 1]
[Checkpoint 5.1.12] Allow the user to start, stop, pause, and rewind audio.
[Priority 2]
[Checkpoint 5.1.13] Allow the user to control audio volume.
[Priority 2]
[Checkpoint 5.2.7] If a technology allows for more than one audio track for video, allow the user to choose from among tracks.
[Priority 1]
[Checkpoint 5.2.4] If a technology allows for more than one caption or description track for audio, allow the user to choose from among tracks.
[Priority 1]
For user agents rendering video:
[Checkpoint 5.1.8] Allow the user to control video frame rates.
[Priority 1]
[Checkpoint 5.1.9] Allow the user to start, stop, pause, and rewind video.
[Priority 2]
[Checkpoint 5.2.6] If a technology allows for more than one caption or description track (e.g., text, video of sign language, etc.) for video, allow the user to choose from among tracks.
[Priority 1]
For user agents rendering speech:
[Checkpoint 5.1.15] Allow the user to control speech volume, pitch, gender and other articulation characteristics.
[Priority 2]
[Checkpoint 5.1.14] Allow the user to control speech playback rate.
[Priority 1]
User interface:
[Checkpoint 5.1.16] When new windows or user interface components are spawned, allow the user to control window size and position.
[Priority 2]
A configuration profile allows users to save their user agent
settings and re-apply them easily, which is particularly valuable in an
environment where several people may use the same machine.
[Checkpoint 4.1.4] Allow the user to configure the user agent in named profiles that may be shared (by other users or software).
[Priority 2]
The user should be able to easily transfer their profiles between
installations of the same user agent. One way to facilitate this is to
follow operating system conventions for profiles where applicable.
Users should be able to switch rapidly between profiles (or the
default settings). This is helpful when:
- Several people use the same machine.
- A user with a disability is being helped by
able-bodied user who may not recognize the information
being displayed using the user's profile.
User agents may apply a profile when the user logs
in. They may also allow users to apply settings
interactively, for example by allowing them to choose
from a list of named profiles in a menu.
Sample profiles (based on common usage scenarios)
can assist users in the initial set up of the user
agent. These profiles can serve as models and may be copied and
fine-tuned to mean an individual's particular needs.
[Checkpoint 4.4.1] Allow the user to turn on and off rendering of images.
[Priority 1]
[Checkpoint 4.4.3] Allow the user to turn on and off rendering of video.
[Priority 1]
[Checkpoint 4.4.4] Allow the user to turn on and off rendering of sound.
[Priority 1]
[Checkpoint 4.4.5] Allow the user to turn on and off rendering of captions.
[Priority 1]
[Checkpoint 4.4.6] Allow the user to turn on and off animated or blinking text.
[Priority 1]
[Checkpoint 4.4.7] Allow the user to turn on and off animations and blinking images.
[Priority 1]
[Checkpoint 4.4.8] Allow the user to turn on and off support for scripts and applets.
[Priority 1]
[Checkpoint 4.4.10] Allow the user to turn on and off support for author style sheets.
[Priority 1]
[Checkpoint 4.4.9] Allow the user to turn on and off support for user style sheets.
[Priority 1]
[Checkpoint 4.4.11] Allow the user to turn on and off rendering of frames.
[Priority 2]
[Checkpoint 4.4.12] Allow the user to turn on and off support for spawned windows.
[Priority 1]
User agents may:
- Allow users to turn of 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.
[Checkpoint 4.4.14] Allow the user to turn on and off automatic page refresh.
[Priority 3]
Period page refresh 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 page refresh.
[Checkpoint 4.4.13] Allow the user to turn on and off automatic page forwarding.
[Priority 3]
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 another page rather than
changing the page automatically.
[Checkpoint 4.3.1] Allow the user to configure keyboard access to user agent functionalities. Configuration includes the ability to specify single keystroke commands as well as commands that require keystroke combinations.
[Priority 2]
[Checkpoint 6.1.11] Provide the user with information about document loading status (e.g., whether loading has stalled, whether enough of the page has loaded to begin navigating, whether following a link involves a fee, etc.)
[Priority 3]
[Checkpoint 6.3.2] Alert the user when scripts or applets are executed.
[Priority 2]
[Checkpoint 6.3.3] Provide information about document changes resulting from the execution of a script.
[Priority 3]
[Checkpoint 5.5.8] Allow the user to request to be prompted before a form is submitted.
[Priority 3]
[Checkpoint 7.2.2] For desktop graphical browsers. Ensure that exported interfaces conform to those specified by a W3C DOM Recommendation.
[Priority 1]
Use DOM Level 1 [DOM1] for access to HTML and XML
document information. However, as the DOM specification indicates:
The DOM Level 1 does not include mechanisms to access and
modify style specified through CSS 1. Furthermore, it does not define
an event model for HTML documents. This functionality is planned to be
specified in a future Level of this specification.
It is important for user agents to provide access to
style and scripting information in a document, so the
following techniques should be used to achieve this.
[Checkpoint 7.2.1] For desktop graphical browsers. Export programmatic interfaces to ATs and follow operating system conventions to do so (e.g., Microsoft Active Accessibility, Sun Microsystems Java Accessibility).
[Priority 1]
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.
[Checkpoint 7.2.3] Use standard interfaces defined for the operating system.
[Priority 1]
For instance, software should use the standard interface
for keyboard events rather than working around it.
Access to application specific data across process boundaries can be costly in terms of performance. Also,
access to the DOM through a specifed accessibility API inhibits the ability for assistive technologies to access
object model data not yet provided in that API. Therefore, user agents should provide a mechanism
to load an assistive technology (AT) into the process space of the application, as a separate thread, with
direct access to the DOM.
A technique for accomplishing this would be to store a reference to an assistive technology in a system
registry file or properties file in the case of Java. Registry files are common among many operating system
platforms.
In Windows you have the system registry file. On OS/2 you have the system.ini file and on distributed
network client networks you often have a system registry server that can be querried by an application running
on the network client computer.
In Java 2, the existence of an accessibility.properties causes the system event
queue to check the file for assistive technologies required for loading. If the file contains a property
called assistive_technologes, it will load all registered assistive technologies and start them on
there own thread in the Java Virtual Machine which is a single process. An example entry for Java is as follows:
assistive_technologies=com.ibm.sns.svk.AccessEngine
In Windows, a similar technique could be followed by storing the name of a Dynamic Link Library (DLL) for
an assistive technology in a designated assistive technology key name, AT pair. An example entry for Windows
could be as follows:
HKEY_LOCAL_MACHINE\Software\Accessibility\DOM "ScreenReader, VoiceNavigation"
Once the assistive technology is determined from the registry, any user agent on the given operating system
can now determine if an assistive technology needs to be loaded with their application and load it.
On a non-Java platform, a technique to do this would be to create a separate thread with a reference to
the User Agent's DOM using a Dynamic Link Library (DLL). This new thread will load the DLL and call a specified DLL entry name with a
pointer to the DOM interface. The assistive technology's task will then run until such time as is
necessary to end communication with the DOM.
Once loaded, the assistive technology can monitor the DOM as needed. The assistive technology has the
option of communicating with a main assistive technology of its own and process the DOM as a caching mechanism
for the main AT application or be used as a bridge to the DOM for the main assistive technology.
In the future, it will be necessary to provide a more comprehensive reference to the application
that not only provides direct access to it's client area DOM, but also multiple DOM's that it is processing and
an event model for monitoring them.
Java is a working example where the direct access to application components is performed in a timely manner. Here,
an assistive technology running on a separate thread monitors GUI events such as focus changes. Focus changes
give the AT notification of which component object has focus. The AT can communicate directly with all components
in the application by walking the parent/child hierarchy and connecting to each component's methods and monitor events
directly. In this case an AT has direct access to component specific methods as well as those provided
for by the Java Accessibility API. There is no reason that a DOM interface to UA components could not
be provided
In Java 1.1.x, Sun's Java access utilities load an assistive by monitoring the Java awt.properties
file for the presence of assistive technologies and loads them as shown in the folowing code example:
import java.awt.*;
import java.util.*;
String atNames = Toolkit.getProperty("AWT.assistive_technologies",null);
if (atNames != null) {
StringTokenizer parser = new StringTokenizer(atNames," ,");
String atName;
while (parser.hasMoreTokens()) {
atName = parser.nextToken();
try {
Class.forName(atName).newInstance();
} catch (ClassNotFoundException e) {
throw new AWTError("Assistive Technology not found: "
+ atName);
} catch (InstantiationException e) {
throw new AWTError("Could not instantiate Assistive"
+ " Technology: " + atName);
} catch (IllegalAccessException e) {
throw new AWTError("Could not access Assistive"
+ " Technology: " + atName);
} catch (Exception e) {
throw new AWTError("Error trying to install Assistive"
+ " Technology: " + atName + " " + e);
}
}
}
In the above code example, the function Class.forName(atName).newInstance() creates a new instance
of the assistive technology. The constructor for the assistive technology will then be responsible for
monitoring application component objects by monitoring system events.
In the following code example, the constructor for the the assistive technology "Access Engine,"
adds a focus change listener using Java accessibility utilities. When the assistive technology is
notified of an objects gaining focus it has direct access to that object. If the Object, o, implemented
a DOM interface the assistive technology would now have direct access to the DOM in the same
process space as the application.
import java.awt.*;
import javax.accessibility.*;
import com.sun.java.accessibility.util.*;
import java.awt.event.FocusListener;
class AccessEngine implements FocusListener {
public AccessEngine() {
//Add the AccessEngine as a focus change listener
SwingEventMonitor.addFocusListener((FocusListener)this);
}
public void focusGained(FocusEvent theEvent) {
// get the component object source
Object o = theEvent.getSource();
// check to see if this is a DOM component
if (o instanceof DOM) {
...
}
}
public void focusLost(FocusEvent theEvent) {
// Do Nothing
}
}
In this example, the assistive technology has the option of running standalone or acting as a cache
for a bridge that communicates with a main assistive technology running outside the
Java virtual machine.
[Checkpoint 7.1.1] Support accessibility features defined by W3C Recommendations for HTML.
[Priority 1]
- Support the "longdesc" attribute defined
for IMG elements ([HTML 4.0], section 13.2).
This attribute may be used to attach additional descriptive information
to images.
[Priority 1]
- Support the CAPTION element ([HTML40],
section 11.2.2) for rich table captions. [Priority 2]
- Support the ACRONYM and ABBR elements
([HTML40],
section 9.2.1) for acronyms and abbreviations. [Priority 2]
- Support the "summary" attribute for TABLE
([HTML40], section 11.2.1) for table summary
information. [Priority 2]
- Support the NOSCRIPT element ([HTML40],
sections 18.3.1 and 16.4.1) for accessible alternatives to scripts.
[Priority 2]
- Support the NOFRAMES element ([HTML40],
sections 18.3.1 and 16.4.1) for accessible alternatives to frames. [Priority 2]
- Support the "lang" attribute ([HTML40],
section 8.1). [Priority 2]
- Support the "tabindex" attribute ([HTML40],
section 17.11.1) for assigning the order of keyboard navigation within a
document. [Priority 3]
- Support the "accesskey" attribute ([HTML40],
section 17.11.2) for assigning keyboard commands to
active components such as links, and form
controls. [Priority 3]
[Checkpoint 7.1.2] Support accessibility features defined by W3C Recommendations for CSS.
[Priority 1]
The following techniques apply to user agents that implement Cascading
Style Sheets (see CSS, level 1 and
CSS, level 2). Cascading Style Sheets may be part
of a source document or linked externally.
Stand-alone style sheets are useful for implementing user profiles in public access computer
environments where several people use the same computer. User profiles
allow for convenient customization and may be shared by a group.
- Completely implement
Cascading Style Sheets, level 1 [Priority 1]
- Allow the user to turn off
author styles represented by author
style sheets. [Priority 1]
- Allow the user to adjust
default values represented by user agent
style sheets. [Priority 1]
- Support the :before and :after pseudo-elements as
defined in CSS2 ([CSS2], section 12.1).
[Priority 1]
- Support the 'outline' property as defined in CSS2 ([CSS2],
section 18.4). Outlines may be used to customize the focus display. [Priority 1]
- Allow the user to specify
user styles through style sheets (see
[CSS2], section 6.4). [Priority 2]
- Implement the !important rule as defined in CSS2 ([CSS2],
section 6.4.2). These rules offer a way for users to override
author styles and
user agent defaults [Priority 2]
- Support aural cascading style sheets (see
[CSS2], chapter 19) for the auditory
presentation of documents. [Priority 2]
[Checkpoint 7.1.3] Support accessibility features defined by W3C Recommendations for SMIL.
[Priority 1]
Several of the more popular mainstream operating systems now
include a common suite of built-in accessibility features that are
designed to assist individuals with varying abilities. Despite
operating systems differences, the built-in accessibility features use
a similar naming convention and offer similar functionalities, within the
limits imposed by each operating system (or particular hardware
platform).
The following is a list of built-in accessibility features from
several platforms:
- StickyKeys
- These allow users to perform a multiple simultaneous
key sequence by pressing and releasing each key in sequential order. StickyKeys
is designed to work with only those keys defined as modifier keys. Modifier
keys are pressed in combination with other keys, to change the outcome of the
second (or more) pressed keys. For example, the SHIFT key is defined as a
modifier key, since it is commonly used to create upper case characters. Each
operating system or hardware platform typically defines a set of keys which can
act as modifier keys. The most common modifier keys include SHIFT, CONTROL, and
ALTERNATE.
- MouseKeys
- These allow users to move the mouse cursor and activate
the mouse button(s) from the keyboard.
- RepeatKeys
- These allow users to set how fast a key repeats (e.g.,
sometimes referred to as typematic rate) when the key is held pressed (e.g.,
Repeat Rate), and also allows control over how quickly the key starts to repeat
after the key has been pressed (e.g., delay Until Repeat). Key repeating may
also be eliminated.
- SlowKeys
- These instruct the computer not to accept a key as
pressed until it has been pressed and held down for a specific user adjustable
length of time.
- BounceKeys
- These prevent extra characters from being typed if
the user bounces (e.g., tremor) on the same key when
pressing or releasing it.
- ToggleKeys
- These provide an audible indication for the status
of keys that have a toggled state (e.g., keys that maintain status after
being released). The most common toggling keys include Caps Lock, Num Lock, and
Scroll Lock.
- SoundSentry
- These monitor the operating system and applications
for sounds, and attempt to provide a visual indication when a sound is being
played. Older versions of Sound Sentry may have flashed the entire display
screen for example, while newer versions of SoundSentry provide the user with a
selection of options, such as flashing the active window or flashing the active
window caption bar.
The next three built in accessibility features are not as commonly
available as the above group of features, but are included here for
definition, completeness, and future compatibility.
- ShowSounds
- These are user setting or software switches that are
available for the operating system and application (including user agents)
APIs to read, to notify them that the user wishes audio information to also be
presented in a visual format.
- High Contrast
- These automatically change the display fonts and
colors to choices which should provide for easier reading.
- TimeOut
- These allow the built-in accessibility features to
automatically turn off if the computer is unused for a specified length of
time, and is intended for use when the computer is in a public setting (e.g.,
library). TimeOut might also be referred to as reset or automatic
reset.
The next accessibility feature listed here is not considered to be
a built in accessibility feature (since it only provides an alternate
input channel) and is presented here only for definition,
completeness, and future compatibility.
- SerialKeys
- These allow a user to perform all keyboard and
mouse functions from an external assistive device (such as communication aid)
communicating with the computer via a serial character stream (e.g., serial
port, IR port, etc.) rather than or in conjunction with, the keyboard, mouse,
and other standard input devices/methods.
The following accessibility features can be adjusted from the Accessibility
Options Control Panel:
- StickyKeys: modifier keys include SHIFT, CONTROL, and ALTERNATE
- FilterKeys: grouping term for SlowKeys, RepeatKeys, and BounceKeys
- MouseKeys:
- ToggleKeys:
- SoundSentry:
- ShowSounds:
- Automatic reset: term used for TimeOut
- High Contrast:
- SerialKeys:
Additional accessibility features available in Windows 98:
-
- Magnifier
- This is a windowed, screen enlargement and enhancement program used
by persons with low vision to magnify an area of the visual display (e.g., by
tracking the text cursor, focus, etc.). Magnifier can also invert the colors
used by the system within the magnification window.
- Accessibility Wizard
- This is a setup tool intended to assist a person with
making choices which setting up the accessibility features on a workstation.
The following accessibility features can be adjusted from the Easy
Access Control panel (Note: Apple convention uses a space within the
accessibility feature names.)
- Sticky Keys: modifier keys include the SHIFT, OPEN APPLE (COMMAND),
OPTION (ALT) and CONTROL keys.
- Slow Keys:
- Mouse Keys:
The following accessibility features can be adjusted from the Keyboard
Control Panel.
- Key Repeat Rate (e.g., part of RepeatKeys)
- Delay Unit Repeat (e.g., part of RepeatKeys)
The following accessibility feature can be adjusted from the Sound or
Monitors and Sound Control Panel (depends upon which version of the OS).
- Adjusting the volume to off or mute causes the Macintosh to flash the
title bar whenever the operating system detects a sound (e.g., SoundSentry)
Additional accessibility features available for the Macintosh OS:
- CloseView
- This is a full screen, screen enlargement and enhancement program
used by persons with low vision to magnify the information on the visual
display, and it can also change the colors used by the system.
- SerialKeys
- This is available as freeware from Apple and several other
Web sites.
(Note: AccessX became a supported part of the X Window System X Server with
the release of the X Keyboard Extension in version X11R6.1)
The following accessibility features can be adjusted from the AccessX
graphical user interface X client on some DEC, SUN, and SGI operating systems.
Other systems supporting XKB may require the user to manipulate the features
via a command line parameter(s).
- StickyKeys: modifier keys are platform dependent, but usually include the
SHIFT, CONTROL, and META keys.
- RepeatKeys:
- SlowKeys:
- BounceKeys:
- MouseKeys:
- ToggleKeys:
The following accessibility features are available from a freeware program
called AccessDOS, which is available from several Internet Web sites including
IBM, Microsoft, and the Trace Center, for either PC-DOS or MS-DOS versions 3.3
or higher.
- StickyKeys: modifier keys include the SHIFT, CONTROL, and ALTERNATE keys.
- Keyboard Response Group: grouping term for SlowKeys, RepeatKeys, and
BounceKeys
- MouseKeys:
- ToggleKeys:
- SoundSentry (incorrectly name ShowSounds):
- SerialKeys:
- TimeOut:
Many thanks to the following people who have contributed
through review and comment: Paul Adelson, James Allan, Denis
Anson, Kitch Barnicle, Harvey Bingham, Olivier Borius, Judy
Brewer, Bryan Campbell, Kevin Carey, Wendy Chisholm, David Clark,
Chetz Colwell, Wilson Craig, Nir Dagan, Daniel Dardailler,
B. K. Delong, Neal Ewers, Geoff Freed, John Gardner, Al Gilman,
Larry Goldberg, John Grotting, Markku Hakkinen, Earle Harrison,
Chris Hasser, Kathy Hewitt, Philipp Hoschka, Masayasu Ishikawa,
Phill Jenkins, Leonard Kasday, George Kerscher, Marja-Riitta
Koivunen, Josh Krieger, Catherine Laws, Greg Lowney, Scott
Luebking, William Loughborough, Napoleon Maou, Charles
McCathieNevile, Masafumi Nakane, Mark Novak, Charles Oppermann,
Mike Paciello, David Pawson, Michael Pederson, Helen Petrie, David
Poehlman, Michael Pieper, Jan Richards, Hans Riesebos, Joe Roeder,
Lakespur L. Roca, Greg Rosmaita, Lloyd Rutledge, Liam Quinn,
T.V. Raman, Robert Savellis, Rich Schwerdtfeger, Constantine
Stephanidis, Jim Thatcher, Jutta Treviranus, Claus Thogersen,
Steve Tyler, Gregg Vanderheiden, Jaap van Lelieveld, Jon S. von
Tetzchner, Willie Walker, Ben Weiss, Evan Wies, Chris Wilson, Henk
Wittingen, and Tom Wlodkowski,
- [CSS1]
- "CSS, level 1 Recommendation", B. Bos, H. Wium Lie, eds. The
CSS1 Recommendation is:
http://www.w3.org/TR/1999/REC-CSS1-19990111.
- [CSS2]
- "CSS, level 2 Recommendation", B. Bos, H. Wium Lie, C. Lilley,
and I. Jacobs, eds. The CSS2 Recommendation is:
http://www.w3.org/TR/1998/REC-CSS2-19980512.
- [DOM1]
- "Document Object Model (DOM) Level 1 Specification",
V. Apparao, S. Byrne, M. Champion, S. Isaacs, I. Jacobs, A. Le Hors, G. Nicol,
J. Robie, R. Sutor, C. Wilson, and L. Wood, eds. The DOM Level 1
Recommendation is:
http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001.
- [HTML40]
- "HTML 4.0 Recommendation", D. Raggett, A. Le Hors, and I.
Jacobs, eds. The HTML 4.0 Recommendation is:
http://www.w3.org/TR/1998/REC-html40-19980424.
- [HTML32]
- "HTML 3.2 Recommendation", D. Raggett, ed. The HTML 3.2
Recommendation is:
http://www.w3.org/TR/REC-html32.
- [MATHML]
- "Mathematical Markup Language", P. Ion and R. Miner, eds. The MathML 1.0
Recommendation is:
http://www.w3.org/TR/1998/REC-MathML-19980407.
- [RFC2119]
- "Key words for use in RFCs to Indicate Requirement Levels",
S. Bradner, March 1997.
Available at
http://www.ietf.org/rfc/rfc2119.txt
- [SMIL]
- "Synchronized Multimedia Integration Language (SMIL) 1.0
Specification", P. Hoschka, editor. The SMIL 1.0 Recommendation is:
http://www.w3.org/TR/1998/REC-smil-19980615
- [WAI-AUTOOLS]
- "Authoring Tool Accessibility Guidelines", J. Treviranus,
J. Richards, I. Jacobs, C. McCathieNevile, eds.
The latest Working Draft of these guidelines for designing
accessible authoring tools is available at:
http://www.w3.org/TR/WD-WAI-AUTOOLS/
- [WAI-PAGEAUTH]
- "Web Content Accessibility Guidelines", W. Chisholm,
G. Vanderheiden, and I. Jacobs, eds.
The latest Working Draft of these guidelines for designing
accessible Web pages and sites is available at:
http://www.w3.org/TR/WD-WAI-PAGEAUTH.
- [XML]
- "Extensible Markup Language (XML) 1.0.", T. Bray, J. Paoli, C.M.
Sperberg-McQueen, eds. The XML 1.0 Recommendation is:
http://www.w3.org/TR/1998/REC-xml-19980210