Copyright © 1999 W3C (MIT, INRIA, Keio), All Rights Reserved. W3C liability, trademark, document use and software licensing rules apply.
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 HTML, CSS and SMIL.
This document is part of a series of accessibility documents published by the Web Accessibility Initiative.
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.
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 User Agent Guidelines Working Group are discussed in the Working Group 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.
Please send comments about this document to the public mailing list: w3c-wai-ua@w3.org.
Each checkpoint in this document is assigned a priority that indicates its importance for users.
The checkpoints in this document are numbered to match their numbering in User Agent Accessibility Guidelines 1.0.
This document is organized as follows:
A checkpoint map has been provided for navigation of the techniques. For each checkpoint, the map includes its definition (as it appears in the "User Agent Accessibility Guidelines 1.0") and links to applicable techniques for the checkpoint. In addition, the beginning of each section of this document lists the checkpoints that are addressed in that section.
This document contains a number of examples that illustrate accessible solutions in HTML, CSS, etc. but also deprecated examples that illustrate what content developers should not do. The deprecated examples are highlighted and readers should approach them with caution -- they are meant for illustrative purposes only.
Checkpoints in this section: 6.1, 6.2.
Checkpoints in this section: 6.4.
Checkpoints in this section: 1.3, 1.1, 1.4, 1.5, 1.6, 1.7
To ensure accessibility, users must have final control over certain renderings.
For text and color:
Checkpoints in this section: 5.1, 5.2, 5.3, 5.4, 5.5, and 5.6.
[Ed. These may be rendered in a variety of ways. How do we specify rendering?]
For images, applets, and animations:
Checkpoints in this section: 4.2 and 5.7.
For user agents rendering audio:
Checkpoints in this section: 5.11, 5.12, 5.13, 6.10, and 6.7.
For user agents rendering video:
Checkpoints in this section: 5.8, 5.10, and 6.9.
For user agents rendering speech:
Checkpoints in this section: 5.15 and 5.14.
User interface:
Checkpoints in this section: 5.16.
Checkpoints in this section: 4.1, 4.3, 4.4, 4.10, 4.9, and 4.5.
[Ed. Add note here that while useful to turn off support, say for all images, it's also useful to be able to view one particular image.]
User agents may:
For example, user agents may recognize the HTML construct target="_blank" and spawn the window according to the user's preference.
Checkpoints in this section: 4.14.
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.
Checkpoints in this section: 4.13.
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.
Checkpoints in this section: 8.2 and 8.3.
Checkpoints in this section: 8.5, 8.6, and 7.2.
Checkpoints in this section: 2.4
Checkpoints in this section: 7.4.
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.
Checkpoints in this section: 7.5.
Checkpoints in this section: 7.8
Checkpoints in this section: 7.3
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.
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.
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.
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:
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.
Checkpoints in this section: 7.6, 7.7.
Checkpoints in this section: 7.1, 8.8.
Checkpoints in this section: 8.14, 9.4, 9.3.
Checkpoints in this section: 8.9, 8.11, 8.10, 8.12, 8.4, 8.13.
Checkpoints in this section: 8.18, 8.17, 8.15, 8.16, 8.10, 8.16
Checkpoints in this section: 8.19, 8.20.
Checkpoints in this section: 8.22, 8.21, and 8.23.
Checkpoints in this section: 8.24, 9.5.
[Ed. Talk about "for" attribute for LABEL]
Checkpoints in this section: 8.7.
Checkpoints in this section: 9.1, 9.2.
Checkpoints in this section: 1.2.
Checkpoints in this section: 3.3, 3.4, 2.2.
Checkpoints in this section: 2.1
[Ed. Discuss keyboard access here. How access is specified in HTML: "accesskey".]
[Ed. New section. Users must be allowed to control keyboard configuration based on specific needs. For poor motor control, keys far apart. For poor mobility, keys close together. General principle: fewest keystrokes, short distance to move.]
Checkpoints in this section: 2.3
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.
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:
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.
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.
Checkpoints in this section: 3.2.
Include references to accessibility features in these parts of the documentation:
Checkpoints in this section: 3.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. "
Checkpoints in this section: 11.6
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. If your custom interface cannot provide information or operation as defined above, then you may need to design your UA using any additional options provided by that platform.
For instance, software should use the standard interface for keyboard events rather than working around it.
[Ed. to be completed]
Refer to [MSGuidelines]. Microsoft includes things like a "Checklist of Accessibility Design Guidelines" at this web site. The checklist includes topics like providing keyboard access to all features, exposing keyboard focus within a control, and to avoid conveying important information by color alone.
Refer to [MacGuidelines]. Apple includes information on topics like responses to user input via the keyboard and mouse, clear and consistent use of language, and designing for an international market.
Refer to [XGuidelines]. The Open Group has various guides which explain the Motif and Common Desktop Environment (CDE) with topics like how users interact with Motif/CDE applications and how to customize these environments.
There are a couple of protocols that should be mentioned regarding inter client communication in X. Also, please keep in mind that in X, the idea/terminology of a client and server is reversed from what you are used to thinking of in terms to the Web.
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:
Ensure your UA can be operated using the standard interfaces on the target platform(s). Some example tests include:
Checkpoints in this section: 11.1, 11.2, 11.3, 11.5.
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 support accessibility:
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:
Checkpoints in this section: 11.4.
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.
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.
[Ed. To be completed.]
[Ed. Link to W3C Note on HTML Accessibility Features instead of this section]
Checkpoints in this section: 10.2, 10.1
Following is a list of accessibility features in HTML:
Checkpoints in this section: 6.3.
User agents must be able to recognize sources of alternative representations of content.
Checkpoints in this section: 4.6 and 4.7.
User agents that recognize the following sources of blinking text and animations must enable users to freeze that text.
Checkpoints in this section: 6.5, 6.6.
[Ed. How to handle null/absent alt.]
Checkpoints in this section: 6.8, 6.11, 5.9
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.
Checkpoints in this section: 6.12.
Checkpoints in this section: 4.12 and 4.11.
[Ed. See Scott's suggestions]
In HTML, "summary" attribute. Also, the "abbr" attribute for headers (see the section on table cells and headers).
Checkpoints in this section: 6.13 and 6.14.
[Ed. Talk about CSS pseudo-classes for :hover]
[Ed. Talk about using :before to clearly indicate that something is a link (e.g., 'A:before { content : "LINK:" }')]
Tables were designed to structure relationships among data. In visual media, tables are often rendered on a two-dimensional grid, but this is just one possible interpretation of the data. On the Web, the HTML TABLE element has been used more often than not to achieve a formatting effect ("layout tables") rather than as a way to structure true tabular data ("data tables")
Layout tables cause problems for some screen readers and when rendered, confuse users. Even data tables can be difficult to understand for users that browse in essentially one dimension, i.e. for whom tables are rendered serially. Large tables pose particular problems since remembering cell position and header information becomes more difficult as the table grows.
User agents facilitate browsing by providing access to specific table cells and their associated header information. How headers are associated with table cells is markup language-dependent.
Tabular navigation is required by people with visual impairments and some types of learning disabilities to determine the content of a particular cell and spatial relationships between cells (which may convey information). If table navigation is not available users with some types of visual impairments and learning disabilities may not be able to understand the purpose of a table or table cell.
Properly constructed data tables generally have distinct TH head cells and TD data cells. The TD cell content gains 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, as those TH cells imply that some TD cells should gain meaning from the TH cell content.
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]).
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:
[Ed. Discuss repair strategies for finding header information?]
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:
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.
[Ed. Define algorithm for finding "header information" here. Does it come from THEAD, TH, attributes, HTML 4.0 algorithm for finding header information, etc. Allow the user to choose either "abbr" or what is calculated by the header algorithm.]
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.
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.
User agents should use the algorithm to calculate header information provided in the HTML 4.0 specification ([HTML40], section 11.4.3).
[Ed. The following issues were raised by Harvey Bingham.]
Checkpoints in this section: 4.12, 5.16, 8.1 8.7, and 8.4
Checkpoints in this section: 8.1.
Possible solutions:
Checkpoints in this section: 4.8.
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).
[Ed. Talk about EMBED? Charles recommends that it be put inside an OBJECT if used.]
[Ed. Link to W3C Note on HTML Accessibility Features instead of this section]
Checkpoints in this section: 10.2, 10.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.
[Ed. Link to W3C Note on HTML Accessibility Features instead of this section]
Checkpoints in this section: 10.2, 10.1
[Ed. Ensure that in SMIL, users can stop temporal links. See proposal from Marja.]
Accessible presentation means here that the information can be easily accessed by using different media and that the user can easily control whether to show the information or not.
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:
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.
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.
The following accessibility features can be adjusted from the Accessibility Options Control Panel:
Additional accessibility features available in Windows 98:
The following accessibility features can be adjusted from the Easy Access Control panel (Note: Apple convention uses a space within the accessibility feature names.)
The following accessibility features can be adjusted from the Keyboard Control Panel.
The following accessibility feature can be adjusted from the Sound or Monitors and Sound Control Panel (depends upon which version of the OS).
Additional accessibility features available for the Macintosh OS:
(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).
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.
There are several methods for developers to accomplish this. Most of these methods fall into four categories:
These methods are ordered as developments within a rapidly changing technology with the most recent advances/methods listed first.
Note.This method and the method described in the next section are very similar. What differs is the amount of, or capability of, the AT that actually gets loaded in the same process or address space as the User Agent.)
Access to application specific data across process boundaries might be costly in terms of performance. Therefore, user agents may wish to provide a mechanism to load the entire assistive technology (AT), into the process space of the application as a separate thread with direct access to the DOM.
One technique is to store a reference to an assistive technology in a system registry file or, in the case of Jave, a properties file. 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 an application running on the network client computer can query.
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_technologies", it will load all registered assistive technologies and start them on there own thread in the Java Virtual Machine that 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.
Access to application specific data across process boundaries might be costly in terms of performance. Therefore, user agents may wish to provide a mechanism to load part of the assistive technology (AT) into the process space of the application as a separate thread, with direct access to the DOM, to provide the specific functionality they require. This could consist of a piece of stub code, a DLL, a Browser Helper Object, etc. An example of how to do this follows.
In order to attach to a running instance of Internet Explorer 4.0, you can use a "Browser Helper Object." A "Browser Helper Object" is a DLL that will attach itself to every new instance of Internet Explorer 4.0 (only if you explicitly run iexplore.exe). You can use this feature to gain access to the object model of a particular running instance of Internet Explorer. You can also use this feature to get events from an instance of Internet Explorer 4.0. This can be tremendously helpful when many method calls need to be made to IE, as each call will be performed much more quickly than the out of process case.
There are some requirements when creating a Browser Helper Object
For more information, please check out:
http://support.microsoft.com/support/kb/articles/Q179/2/30.asp.In order for native Windows ATs to gain access to Java applications without the creating a Java native solution Sun Microsystems provides the "Java Access Bridge." This bridge is loaded as an AT as described in section 6.1.3. The bridge uses a Java Native Invocation (JNI) to Dynamic Link Library) (DLL) communication and caching mechanism that allows a native assistive technology to gather and monitor accessibility information in the Java environment. In this environment, the AT determines that a Java application or applet is running and communicates with the Java Access Bridge DLL to process accessibility information about the application/applet running in the Java Virtual Machine.
Specialized user agents might also include the necessary assistive technology as part of their interface, and thus provide possibly the best of both worlds. An example would be pwWebSpeak, from The Productivity Works (refer to [Prodworks]).
[Ed. Have The Productivity Works provide short description.]
Access to application specific data across process boundaries or address space might be costly in terms of performance. However, there are other reasons to consider when accessing the User Agent DOM that might lead a developer to wish to access the DOM from their own process or memory address space. One obvious protection this method provides, is that if the User Agent application fails, it doesn't disable the user's AT as well. Another consideration would be legacy systems, where the user relies on their AT for access to other applications as well as the User Agent, and thus would have their AT loaded all the time, not just for accessing the User Agent.
There are several ways to gain access to the User Agent's DOM. Most User Agents support some kind of external interface, or act as a mini-server to other applications running on the desktop. Internet Explorer is a good example of this, as IE can behave as a component object model (COM) server to other applications. Mozilla, the open source release of Navigator also supports cross platform COM (XPCOM).
An example of using COM to access the IE Object Model can be seen in the code snippet below. This is an example of how to use COM to get a pointer to the WebBrowser2 module, which in turn allows you to get a interface/pointer to the document object, or IE DOM for the web page in view.
/* first, get a pointer to the WebBrowser2 control */ if (m_pIE == NULL) { hr = CoCreateInstance(CLSID_InternetExplorer, NULL, CLSCTX_LOCAL_SERVER, IID_IWebBrowser2, (void**)&m_pIE); /* next, get a interface/pointer to the document in view, this is an interface to the document object model (DOM)*/ void CHelpdbDlg::Digest_Document() { HRESULT hr; if (m_pIE != NULL) { IDispatch* pDisp; hr = m_pIE->QueryInterface(IID_IDispatch, (void**) &pDisp); if (SUCCEEDED(hr)) { IDispatch* lDisp; hr = m_pIE->get_Document(&lDisp); if (SUCCEEDED(hr)) { IHTMLDocument2* pHTMLDocument2; hr = lDisp->QueryInterface(IID_IHTMLDocument2, (void**) &pHTMLDocument2); if (SUCCEEDED(hr)) { /* with this interface/pointer, IHTMLDocument2*, you can then work on the document */ IHTMLElementCollection* pColl; hr = pHTMLDocument2->get_all(&pColl); if (SUCCEEDED(hr)) { LONG c_elem; hr = pColl->get_length(&c_elem); if (SUCCEEDED(hr)) { FindElements(c_elem, pColl); } pColl->Release(); } pHTMLDocument2->Release(); } lDisp->Release(); } pDisp->Release(); } } } }
For more information on using COM with IE, please visit the Microsoft web site:
http://www.microsoft.com/com/default.aspFor more information on using XPCOM with Mozilla, please visit the Mozilla web site:
http://www.mozilla.org/For a working example of the method described in 6.1.4, please visit the following web site and review HelpDB, developed as a testing tool for web table navigation.
http://trace.wisc.edu/world/web/document_access/This index lists each checkpoint and the sections in this document where it is discussed. Furthermore, each guideline number links to its definition in the guidelines document. Each checkpoint also links to its definition in the guidelines document.
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,
Note. W3C cannot maintain stability for any of the following references outside of its control. These references are included for convenience.