[contents]
This document describes techniques for authoring accessible content using RDF and metadata. This a proposed draft for WCAG WG consideration and is based on the latest Working Draft of the Web Content Accessibility Guidelines 2.0.This document is intended to help authors of Web content who wish to claim conformance to "Web Content Accessibility Guidelines 2.0" [WCAG20]. While the techniques in this document should help people author content that conforms to "Web Content Accessibility Guidelines 2.0", these techniques are neither guarantees of conformance nor the only way an author might produce conforming content.
This document will be part of a series of documents published by the W3C Web Accessibility Initiative (WAI) to support WCAG 2.0.
This document is prepared for the Web Content Accessibility Guidelines Working Group (WCAG WG) to show how RDF (semantic web?) Techniques for WCAG 2.0 might read. This draft is not yet based on consensus of the WCAG Working Group nor has it gone through W3C process.
Please refer to "Issue tracking for WCAG 2.0 Techniques for RDF/semantic web?" for a list of open issues related to this Working Draft. The "@@History of Changes to RDF Techniques for WCAG 2.0 Working Drafts" is also available.
This is a draft document and may be updated, replaced, or obsolete 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". A list of current W3C Recommendations and other technical documents is available.
The Working Group welcomes comments on this document at public-wcag20-comments@w3.org. The archives for this list are publicly available.
Patent disclosures relevant to this specification may be found on the WCAG Working Group's patent disclosure page in conformance with W3C policy.
This is a proposed draft for WCAG WG consideration and is based on the latest Working Draft of the Web Content Accessibility Guidelines 2.0. The goals of the WCAG WG are discussed in the Working Group charter. The WCAG WG is part of the WAI Technical Activity.
RDF is a powerful W3C technology for annotating a site with information with relationships and knowledge about content.
Areas and types of annotations where RDF can be used to enhance the accessibility and usability of a site include:
Media Equivalents including: Providing text equivalents for resources attached to any resource by anybody, such as the graphic artist who created resource. Mapping can also include to web service that optimizes the site for the user (such as a no frames transcoder, or high contrast rendering).
Structured Textual Markup - enhancing structure of the markup of a document, including Data Tables outside a document, or translating the structure of an XML document to a markup structure that user agents are used to dealing with (e.g. myXML to XHTML) Binding sections of a document to a common role. Mapping different content sections as a block with common task/role.
Specifying roles and associations of elements and formats
For example you have used pink to imply content aimed at women, A black and white rendering of a site may put an icon of women to portray that concept. Similarly it is useful for the user agent to know page concepts such as a format implies important content, or the role of content such as a field being for a date, or this page is used as a site map
Clarifying Text so that assistive technologies can simplify the content.
Example techniques include: (such as lexical references, resolving ambiguities such as pronouns (which "he" did you mean?) and specifying implied meanings.
Simplifying Text: Annotations can provide simplifications or summaries of important text. Examples of annotations c to simplify content can include: Pictures, symbols and summaries. These annotations can be attached to sections of content including section annotated with a role or as a block, marking sections of content as important for a given profile.
Forms and Interactivity: RDF annotations can map to the accessible interactivity model, accessible form information, building and binding functional equivalents to inaccessible content.
Robustness and cross technology solutions: RDF can be used to map accessibility and content model on non W3C technologies and non WCAG supported markup languages (see XAG) .RDF can also be used with user profiling for different interpretations and rendering of web content
Annotation base accessibility usage could solve accessibility problems in the following situations:
Simplified, annotated or multimedia content required for accessibility for some, is inappropriate for other audiences. For example: annotations can provide titles, headers, summaries (non normative) , glossary references and links to background information
The original rendering is incapable of change, such as when web authors are unable to use simplified language.
There are a large amount of pages to be made accessible including legacy pages - Annotations work generically on a site and are constructed to apply to the whole site. A single annotation can address a violation that occurs on multiple pages, and will fix each occurrence of the accessibility violation. The site does not have to be pulled down and retrofitted, and many pages can be automatically repaired. Annotations can also be constructed to apply generically to any content that is based on the same template. The same annotation repairs multiple pages that are created by the same application and template.
XML schema can be annotated to increase accessibility usage, which could have an effect of an immeasurable number of documents based on that schema.
Multiple alternatives / conditional content in different media's can be provided. For instance, an auditory rendering of a visual aid might be more appropriate in some contexts than text.
User profiles can be attached to Web content and alternatives, so renderings can be optimized to the individual user.
User profiles can be attached to Web content and alternatives, so renderings can be optimized to the individual user.
As a secondary benefit, RDF Improves compatibility Knowledge-Based Services and the Semantic Web. In integrating accessibility and the semantic web, accessibility can be moved forward, paving the way for customized accessible searches and intelligent user agents with additional applications.
The Resource Description Framework (RDF ), is an XML based infrastructure that allows the capture, encoding, sharing, and reuse of structured metadata and semantic information. RDF does not provide syntax or a vocabularies for each resource description community, but provides the ability for communities to define and share terms. (Ontologies)
This section describes some existing ontolgies and mechanisms that are usefully to to the accessibility community, for the capture and sharing of information that may help move accessibility forward.
(Story to help explain what steps need to be taken to enhace accessibility through RDF )
Loretta’s site is inaccessible. she decided to use RDF to change that. Firstly Loretta chooses a framework and ontology support. She then creates goes through her site and find accessibility violations AND places were she would like to enhance the existing accessibility.
Loretta then creates a file of annotations that either provides the extra information required for the user agent or user service to make her site accessible or more accessible. Loretta uploads the file onto the internet at a place that user agent or user service can access.
Loretta also creates a linking mechanism on her website so that: i, The user can easily get from the website to the presentation of the website that is most appropriate for them. And ii, that user agent or user service can easily find the annotation file.
Looking at the steps involved:
The stage for improving accessibility on a site is typically to identify accessibility issues existing on a site. This involves going through the a looking for accessibility violations AND places were she would like to enhance the existing accessibility. Loretta has a few option.
She could ask people with different disabilities to use her site, and see where dificalties arise.
She could manual go through the site and look for any instance of a violation from WCAG.
She could use a tool to pinpoint some violations, and perform manual check to find others
She could use an integrated tool that identifies accessibility violations and help build RDF annotation to repair the violations
Having identified where people have problems in perceiving, operating and comprehending her site, Loretta now needs to select a useful ontology or set of terms to use for her annotations. She can then use these terms to build annotations that will correct the accessibility problems. Again, there are a few ways that Loretta can build the accessibility related annotations file.
She can write the RDF in a text or RDF editor, and validate it using the W3C RDF syntax valuator.
She can use an annotation tool, such as Amaya, to help her build the RDF statements correctly.
She could use an integrated tool that identifies accessibility violations and builds RDF annotations to repair the violations.
Most annotation tools will have a mechanism for uploading to a URL automatically. If Loretta built annotations using a text editor, then she will have to FTP the file to a URL.
Annotation tools and Integrated accessibility review and annotation tools will provide their own linking method. Otherwise there are standard linking mechanisms to use.
Linking the the web site and annotation file.
The following code illustrates how annotations can be included into a web page, by inserting the code directly into the page header.
<head> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://purl.org/dc/elements/1.1/"> rdf:Description rdf:about="http://www.w3.org/" dc:title="About RDF and accessibility"/> </rdf:RDF> </head>
Linking the web site and annotation file
The following code illustrates how to provide a link in the header of a web page to a separate file that contains RDF annotations
<head> <title>About RDF and accessibility</title> <link rel="meta" type="application/rdf+xml" href="meta.rdf"/> </head>
RDF statements and semantic web annotations are written using a language or syntax of the semantic web (an ontology).
Ultimately the use of RDF to achieve WCAG conformance is only valid if the user can easily access an accessible rendering of the original page. Hence there must be a free, publicly available engine where any end user or user agent can receive render the site accessibly for free. with out this the accessibility of the page can not be considered robust. Web technologies used must maximize the ability of the content to work with current and future accessibility technologies and user agents. Secondly care must be taken that all the accessibility features that you require through RDF are provided within the ontology.
The user needs to know how to access the accessibility fetchers. This can be done through an accessible link at the beginning of the original page. Clear instructions can also be used, but they run the risk of adding burden to the end user. If instructions are to be used they should be short step by step and quick to use. to use.
Once you have chosen and RDF language the web author need to fulfill all the accessibility requirements of ensuring that all content is perceivable, operable, navigatable and understandable.
Editorial Note: Place holder - using Amaya - we can just get this from the Amaya page.. How you can use Amaya to annotate a page with RDF
Editorial Note: These are examples of examples. I think I used it at WCAG a year ago, but it is not currently active. If we like the example I will make it live on permanent URI
The following examples demonstrate how one can construct an RDF file that render a page accessible.
The ontology in used in these examples have been developed by UB Access.
A page can be made accessible by use of annotation. In he following example page the users are given a choise of difrent accessible versions of the page that are optimized to their needs
The page http://www.yadsarah.org.il/english/index.asp?id=95 was not WCAG compliant.
However an RDF file with annotations with accessibility related annotation and equivalents was created. Users can now go to the Unbounded Access server and receive renderings of the page that are accessible and optimized to their needs.
<ul><li>see <a href="http://69.10.136.193/applications/yadsarahBasic">a basic accessible</a> SWAPView</li>
See <a href="http://69.10.136.193/applications/yadsarahTrueText">true text</a> SWAPView</li>
See <a href="http://69.10.136.193/applications/yadsarahpageMap">enhanced navigation</a> SWAPView</li>
The following examples demonstrate how one can construct an RDF to enhance accessibility.
Case - Using a header file:
Original page: http://ubaccess.com/swaptest.html This Web page contains a picture of a house. However no text equivalent has been provided within the page encoding.
However it has in the header a reference to a RDF resource document http://www.ubaccess.com/RDFtest1.xml .
If you go to UB Access test server you can see SWAP take the resource , take the RDF file and render an accessible page http://69.10.136.193/applications/swap/www.ubaccess.com/swaptest.html
Using this application anyone can make your own page, RDF file and go to http://69.10.136.193/applications/swap/ + the url of my document.... (where "my document" is your inaccessible page with a link to an RDF document). Note: please mimic my RDF as much as possible - flexible ways of writing RDF is not supported. Note: in this case the inaccessible page should be XML compliant (like XHTML)
Case - Using a referencing file:
This is an example where you can not add the header line into the inaccessible page (maybe because you do not have access to the inaccessible source pages) A separate file that links the resource and the resource document. See http://ubaccess.com/swaptestlinks.html
SWAP will render the linked to resources accessible It needs a separate pipeline.
This section describes ways to provide media equivalents using metadata.
Note: Text equivalents for resources can be attached to a site by anybody, not just the page author. However a summary, description and text equivalent can also be provided by the author of the resource (such as the graphic artist) when the resource itself is created. This approach will allow an organization to build a library of equivalent that are created by people who understand the function and aims of the resource, whilst taking the burden of creating equivalents off the page author.
Making text perceivable
In the following examples alternatives to media or image elements are provided using RDF
Alternatives for Images - In the following examples a image is provided without a text equivalent. In a header file or header the RDF points to the image and associates textual alternatives for the image. This example uses the SWAP ontology by UB Access
Editorial Note: I have tried to make this a fully worked example so we can see how much detail we want to add. I think it is too much...
In this example the RDF staments contain alternive text to a picture as litral or pure text. The long discription is pionted to as a URL.
<rdf:description about="xpointer to an image" > <ub:alternativeContent> <bag> <rdf:li><ub:altText value="A house"/></rdf:li> <rdf:li><ub:longdesc value="http://mysite.com/longdesc_library/longdesc_house.html"/></rdf:li> </bag> </ub:alternativeContent> </rdf:description>
In this example the RDF staments contain alternive text and a long discription to a picture as a pionted to as a URL.
<head> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://purl.org/dc/elements/1.1/"> <rdf:description about="xpointer to an image" > <ub:alternativeContent> <bag> <rdf:li><ub:altText value=""http://mysite.com/lalttext_library/house.htm"/></rdf:li> <rdf:li><ub:longdesc value="http://mysite.com/longdesc_library/longdesc_house.html"/></rdf:li> </bag> </ub:alternativeContent> </rdf:description> </rdf:RDF> </head>
In this example the RDF staments are placed in the header of the web page. They contain alternive text and a long discription to a picture as a pionted to as a URL.
<head> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ub="http://ubaccess.com/RDF/swap02.rdf"> <rdf:description about="xpointer to an image" > <ub:alternativeContent> <bag> <rdf:li><ub:altText value=""http://mysite.com/lalttext_library/house.htm"/></rdf:li> <rdf:li><ub:longdesc value="http://mysite.com/longdesc_library/longdesc_house.html"/></rdf:li> </bag> </ub:alternativeContent> </rdf:description> </rdf:RDF> </head>
In this example the RDF staments are placed in a seprate file . The file is linked in the head of the web page. They contain alternive text and a long discription to a picture as a pionted to as a URL.
In the web page: <head> <title>About RDF and accessibility</title> <link rel="meta" type="application/rdf+xml" href="myMeta.rdf"/> </head> And myMeta.rdf would read <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ub="http://ubaccess.com/RDF/swap02.rdf"> <rdf:description about="xpointer to an image" > <ub:alternativeContent> <bag> <rdf:li><ub:altText value=""http://mysite.com/lalttext_library/house.htm"/></rdf:li> <rdf:li><ub:longdesc value="http://mysite.com/longdesc_library/longdesc_house.html"/></rdf:li> </bag> </ub:alternativeContent> </rdf:description> </rdf:RDF> Note: In this example lots of web pages and resourses can point to the same RDF file, So the anotaitions only have to be created one time to make every instance of the picture accessible.
Place holder: Using Amaya - Annotea associated alternatives. Note this allows third-party annotations of any Web Resource.
Place holder: using time stamped RDF to annotate W3C multi media (like SMIL) to proved Sync multi media equivalents...:)
Place holder: image annotation, using SVG (need to ping Patrick Roth)
Place holder: SVG Metadata Charles is working this out....
Making text perceivable
Simple alternatives for Non images
Simple alternatives for scripts - In the following examples, alterative for scripts are missing. To correct this accessibility error, RDF is provided that links XHTML alternatives to the scripts. This example uses the SWAP ontology by UB Access
<rdf:description about="//script/etc"> <ub:alternativeContent xmlns:ub="http://www.ubaccess.com/UB-rdf-schema#"> <rdf:Seq> <rdf:li><ub:noscript value="<noscript></noscript>"/></rdf:li> </rdf:Seq> </ub:alternativeContent> </rdf:description>
Alternatives for Frames: An alternative for a frame set can be referenced using RDF . However a transcoding service can also be referenced.
For example see the page http://ue.eu.int/newsroom/newmain.asp?LANG=1. In this page frames have been used inaccessibly. Annotations can provide titles to the frames helping the user orientate themselves between frame sets as required by WCAG 1.0.
Non frames equivalents can be references, and can be created automatically by transcoding. For example see http%3A//ue.eu.int/newsroom/newmain.asp%3FLANG%3D1 has been automatically transcoded into a no frames rendering: See http://69.10.136.193/applications/convertToPDACompliant/http%3A//ue.eu.int/newsroom/newmain.asp%3FLANG%3D1
<rdf:description about="//script/etc" xmlns:ub="http://www.ubaccess.com/UB-rdf-schema#"> <ub:alternativeContent > <ub:noframe value="http://69.10.136.193/applications/convertToPDACompliant/http%3A//ue.eu.int/newsroom/newmain.asp%3FLANG%3D1"/> </ub:alternativeContent> </rdf:description>
Semantically described services: The use of Semantically rich descriptions for services on the Web can include machine-processable information about alternative versions of a service that may be appropriate to a particular delivery context. This can allow searching for more accessible versions of a script or applet being used, or directing users directly to an alternative.
The techniques in this category demonstrate how to clarify text using metadata.
Ambiguous use of language creates problems with translation, misunderstandings and accessibility for cognitive disabilities. Translation to symbolic languages or simpler language for cognitive disabilities can not be automated. A controlled language restricts author's ability to stylize and express them-selves. However, by referencing textual content, it's meaning becomes unambiguous, translatable and machine-readable without restricting the author's use of language.
Making content understandable
In the following examples, RDF is used to provide a link a phrase or word to a definition. This makes the text unambiguous.
In the following examples, RDF is used to provide a link a document to a lexicon. This makes the text unambiguous, and easy to translate and simplify.
Note: that this can be overridden by a word specific definition.
A document can link to a sequence of default lexicons. The LexiconPriority property, sets the priorities of a lexicon, were the highest priority lexicon is referenced and used first. This is like cascading lexicons so that words and phrases can default to a small but preferred lexicon (jargon or local),
Rules for defaulting
1. If a word is part of a known phrase found in the default lexicon, the meaning of the phrase is the first meaning found in the default lexicon for that phrase
2. If a word is part of a known phrase found in a lower priority lexicon then the default meaning of the phrase is the first meaning found in the highest priority lexicon
3. If a word is found in the default lexicon, then the meaning of the word is the first meaning found in the default lexicon
4. If a word is found in a lower priority lexicon then the default meaning of the word is the first meaning found in the highest priority lexicon
<ub:lexicon rdf:rdfID = "myBestLexicon" rdf:about="myBestLexicon.xml" >www.ubaccess.com/simplelexicon.xml</ ub:lexicon > <ub:lexiconPriority rdf:ref="#myBestLexicon Value="5"/>
In the following examples, RDF is used to provide a link a specific instance of phrase or word to a definition in an onsite glossary. This helps makes the text unambiguous and/or clearer.
Note that this would override a general reference to a lexicon.
<rdf:description rdf:about="xpointer to text" type="ub:lexicon" value ="www.mysite.com/my glossary#this word/>
Place holder: annotating the components of a VoiceXML application or a timed text track, to concepts or symbols...
Making content understandable
What is concept code....
rely on a stable foundation of concepts with unique IDs referring to one or more Ontologies where the concepts are clearly defined - including their relations to other concepts. The parts are:
Concept Code Definitions (CCD) - which contains a plain list of all the concepts of the CCF
Base Reference Ontology (RO) - which contains the concepts of the CCD that have been derived from WordNet
Complementary Reference Ontology (CO) - that contains the concept of the CCD that is not found in WordNet.
CCF Bridge - which links the three parts of the CCF to each other, and all of them to external resources.
In the following examples, RDF is used to provide a link to each word in a document to a concept....
<html>
I want a cup of coffee.
</html>
<rdf:rdf
xml:xmlns ccf="http://www.wwaac.org/2003/10/ConceptCodingFramework-ns#">
<rdf:description rdf:about="#xpointer("l")">
<ccf:Concept <rdf:resource="scc:#CC-FIRST-PERSON-1"/>
<ccf:Representation rdf:resource="&iso-bliss;14916"/>
</rdf:description>
<rdf:description rdf:about=#xpointer("want")>
<ccf:Concept rdf:resource="scc:#CC-WANT-2"/>
<ccf:Representation rdf:resource="&iso-bliss;18035"/>
</rdf:description>
</rdf:description rdf:about="#xpointer("a")>
<ccf:Concept rdf:resource="scc:#CC-A-1"/>
<ccf:Representation rdf:resource="&iso-bliss;12321"/>
</rdf:description>
<rdf:description rdf:about="#xpointer("cup")>
<ccf:Concept rdf:resource="scc:#CC-CUP-2"/>
<ccf:Representation rdf:resource="&iso-bliss;13621"/>
</rdf:description>
</rdf:description rdf:about="#xpointer("of")>
<ccf:Concept rdf:resource="scc:#CC-OF-1"/>
<ccf:Representation rdf:resource="&iso-bliss;13100"/>
</rdf:description>
</rdf:description rdf:about="#xpointer("coffee")>
<ccf:Concept rdf:resource="scc:#CC-COFFEE-1"/>
<ccf:Representation rdf:resource="&iso-bliss;13373"/>
</rdf:description>
</rdf:rdf >
The techniques show how to simplify text using metadata.
Making content understandable
People with learning disabilities may unable to access important content as a result of the design chosen by website creators. The first problem in converting normal text to symbols is that there is simply too much of it. To be simplified in the most functional manner, a lot of text must be omitted. However, a user agent cannot distinguish the relative importance of sections of content. Importance also varies depending on the user's intentions when reading a document, as well as their actual capabilities. For example, legal footnotes and annotations are an important feature of many documents. But legal annotations are often not relevant when somebody is simply trying to understand the technical implications of a specification. In fact many proficient readers will simply skip over such material without bothering to try and understand the detail. To make an appropriate simplification for a dyslexic engineer trying to understand the technical implications, it is useful to remove the legal material as it avoids confusion and time wasted trying to understand something unnecessary. Annotations that explain or clarify terms however, should be included. In other words, the importance of any textual feature depends on the user profile. This varies from user-to-user, according to what he/she is doing, and according to each person's specific abilities.
An RDF vocabulary can an author to attach a level of importance to any section of web content. All accessibility annotations can have user profile information attached that states how important certain text is to each profile. For example some text is important content for any type of comprehension while some text is merely ornamentation intended to heighten the reading pleasure of the expected audience. The user can then adjust the amount of content rendered based on how relevant it is
An RDF vocabulary can an author to attach a level of importance to any section of web content. All accessibility annotations can have user profile information attached that states how important certain text is to each profile. For example some text is important content for any type of comprehension while some text is merely ornamentation intended to heighten the reading pleasure of the expected audience. The user can then adjust the amount of content rendered based on how relevant it is.
In this example, a relevance of "0" implies content is irrelevant for a given user profile. A relevance of "1" implies content is key information for a given user profile.
This example shows how to provide alterative content to help summarize or simplified sections of web content.
<rdf:description rdf:about="some xpointer to obtuse legal paragraph" > <ub:alternativeContent> <bag> <rdf:li><ub:summary value="we own you from now on"/></rdf:li> <rdf:li><ub:nonText="picture_of_ slave_in_chains.gif"/></rdf:li> </bag> </ub:alternativeContent> </rdf:description>
This example shows how to provide alterative content to summarize or simplify a word or phrase were ever it occurs in a web document.
<rdf:description rdf:about="xpointer to phrase - in the event of" > <ub:alternativeContent> <ub:profile>simplified</ub:profile> <rdf:li><ub:summary value="if"/></rdf:li> </ub:alternativeContent> </rdf:description>
Annotations can be used to describe the relationships between elements of content. This includes adding page structure, and associating a label with a form control, and associating sections of page content that act or are seen together.
The techniques in this category demonstrate how to add structure to sections of web content using metadata.
Use the strong and em elements, rather than b and i, to denote emphasis.
Making content understandable
An RDF vocabulary can an author to attach a level of importance to any section of web content. All accessibility annotations can have user profile information attached that states how important certain text is to each profile. For example some text is important content for any type of comprehension while some text is merely ornamentation intended to heighten the reading pleasure of the expected audience. The user can then adjust the amount of content rendered based on how relevant it is.
In this example a relevance of" 0" implies content is irrelevant to a given profile. A relevance of" 1" implies content is key information for a given profile.
Making content understandable
place holder - why add structure..
This allows an author to associate elements as belonging to a block of elements. These can be standard blocks (menu 1, menu 2, menu 3, menu 4,) or to an element that is a block owner like a table header). You can define a block owner using isBlock. This promotes the structural integrity of the site.
Blocks can reference a know identifies of different block types
We can add hear URI for known blocks types: main menu, submenu, copy write info, main content....
We can also add types of content on another level- informative, pricing, ....
This example shows how to use the abbr attribute in a table heading.
Use the acronym element to identify and expand acronyms where they first occur.
Making content understandable
Use the quote element to identify quotations.
Making content understandable
Making content understandable
In the following examples RDF is used to provide a link a phrase or word to a summary and picture. This makes the text understandable.
:
<rdf:description rdf:about="some xpointer to obtuse legal paragraph" >
<ub:alternativeContent >
<ub:profile>simplified</ub:profile>
<bag>
<rdf:li><ub:summary value="we own you from now on"/></rdf:li>
<rdf:li><ub:nonText value="picture_of_ slave_in_chains.gif"/></rdf:li>
</bag>
</ub:alternativeContent>
</rdf:description>
Meta data or RDF annotations, can describe the role of different elements and content. Web authors can annotate sections of document content, linking them to known types of content.
This enhances the knowledge of page structure and the role of content. Assistive technologies and transcoders to be able to encapsulate the functional substructures in a page, and marking their roles in the page known.
Note: With the flexibility of RDF that we can allow for this encapsulation without the requiring a full or near full list of content types. Firstly we could compile a short and incomplete list of known common types of content section each with a valid reference -able URI. Authors could create new types as needed.
This example illustrates the benefits of assistive technologies comprehending the role of a link.
If it is known that a page hyperlink has the role of taking the user to the site’s home page, and we store that piece of knowledge in RDF then that knowledge can be used to create enhanced accessibility in different ways in many different scenarios. For example, the home page hyperlink and all similar elements can be rendered for a user, across all pages, with an keyboard access alternative of “alt+h”. However, if we consider a different user, such as a native Russian speaker, and remembering that ‘home’ in Russian, is “dom”, it may be preferable to use “alt+d” to consistently provide keyboard access for links to the home page, across any site. Similarly, a user with a learning disability may prefer all links to home pages to be represented by an icon of a home, perhaps with the site name displayed underneath.
As the cases or types of content in RDF, we make programmatically explicit the relationship between different classes and types of content. In making a description for each type obligatory (using OWL) we allow for anyone to access - in plain English (or French Spanish, Dutch...) -what the content type is meant to represent. It allows us to miss out some definitions of content types without there being the least loss to the implementation or the speciation. Defining types as sub classes and type instances in RDF allows us to add new ones at any time Because content types are not limited to thoughs that the W3C defined, web communities can have there own, derived, content types. For example IMPS and educational content typically use : tutor, help, glossary, back, up, next If the user agent is only familiar with the base classes, then it can handle a derived class the same way it would handle it's parent. However tools that are intended for a known audience can have special features for a derived schema.
Add link to interface for adding a type
Editorial Note: This section will provide qnames and URI's for standard types, and the base classes . Should I include the UB access types or just provide a link?
Standard types will include:
main menu
secondary menu
footer
Contact us link
site map
Advertising
Each type would require a valid URI. Identifier types of content typically found in a page could include:
Base types will include:
Types of pages
Sections
Types of links
Types of blocks of links
Actions
States
Handlers
Associations
This section discusses the accessibility of tables and elements through annotations
Use the title attribute to provide additional descriptive information. (optional. summary or caption are preferred)
Making content understandable
The summary, title and caption properties from the UB Access ontology adds additional information to a table. Note:It can and can be applied to any element including, but not limited to, a data table.
An RDF vocabulary can an author to associate rows with headers
<rdf:description about="//table//tr[1]/tdetc"> <ub:alternativeContent xmlns:ub="http://www.ubaccess.com/UB-rdf-schema#"> <rdf:Seq> <rdf:li> <ub:alternativeTagName about="" value="th"/></rdf:li> <rdf:li> <ub:scope value="col"/></rdf:li> </rdf:Seqs> </ub:alternativeContent> </rdf:description>
An RDF vocabulary can an author to a summary with any page element, including a table.
<rdf:description rdf:about="some xpointer to obtuse legal paragraph" > <ub:alternativeContent> <rdf:li><ub:summary value="we own you from now on"/></rdf: li> </ub:alternativeContent> </rdf:description>
Use the colgroup and col elements to group columns. (optional)
Making content understandable
An RDF vocabulary can an author to associate table data with headers.
An RDF vocabulary can an author to associate a table summary
<rdf:description about="//table[not(@summary)]"> <ub:alternativeContent xmlns:ub="http://www.ubaccess.com/UB-rdf-schema#"> <ub:summary value="This table shows that we are getting less rain each year"/> </ub:alternativeContent> </rdf:description>
An RDF vocabulary can an author to associate rows with headers
<rdf:description rdf:about="some xpointer to obtuse legal paragraph" > <ub:alternativeContent ><ub:profile>simplified</ub:profile> <code>"mso-tab-count: 1"> <bag> <rdf:li><ub:summary value="we own you from now on"/></rdf: li> <rdf:li><ub:nonText="picture_of_ slave_in_chains.gif"/></rdf:li> </bag>
This example shows how to provide alterative content to summarize or simplify a word or phrase were ever it occurs in a web document.
<rdf:description rdf:about="xpointer to phase in the event of" > <ub:alternativeContent > <ub:profile>simplified</ub:profile> <rdf:li><ub:summary value="if"/></rdf:li> </ub:alternativeContent> </rdf:description>
This section discusses the accessibility of Forms and form elements through annotations
It involves apping the interactivity of a page to known terms, actions, conditions, and element states.
Base types will include:
Actions
States
Handlers
Conditions
Editorial Note: Do we want to include an ontogie or just link to one?
In pages that not written in XHTML annotations can provide a mapping to standard XHTML tags so that assistive technology knows how to handle it. The relationships requiring mapping include the standard XML linking and pointing mechanism and semantic relationships such as headers. The XML schema itself can also be annotated to solve such accessibility issues for any derived document.
The WAI's XML Accessibility Guidelines - 1 October 2002 begins with the following problem statement:
"One area of concern with the advent of XML is that the freedom of design it brings has and can result in a loss of accessibility features, present today because of HTML's pervasive presence and widely available specification. For instance, one could design a new XML language that would make it much more difficult to create accessible documents, by not including in the element or attribute set a way to attach an alternate textual description for a photo:" With RDF an author could provide alterative content to any valid XML document. The co-author's of the XML Accessibility Guidelines have bean instrumental in the putting together of the WCAG-RDF project as a potential and credible solution for these emerging accessibility problems.
Some XML Accessibility Guidelines (such as use the standard XML linking and pointing mechanism and provide semantic relationships to other schema where appropriate and possible) could be best supported best though RDF without restricting the language authors style. Beyond that an XML schema could be annotated to solve such accessibility issues for any derived document.
Editorial Note: note: I have a whole mapping lang, which is quite powerful, I know that there are others - should we link to them?
Use the title attribute to provide additional descriptive information. (optional. summary or caption are preferred)
Making content understandable
isSimilarToElement allows one to associate elements as being similar to other known elements. The content of an isSimilarToElement should be the URI of the definition of the known element.
Note: The isSimilarToElement can also be used to annotate annotations as similar to different annotation- for example a ClarifiedText annotation can also be literal, and a summary
<rdf:li> <ub:isSimilarToElement value="xhtml:head"> </rdf:li>
Use the colgroup and col elements to group columns. (optional)
Making content operable
From SWAD EU -(as is a lot of this...) Annotating elements of schemas which are new, obsolete or deprecated, or render sections of earlier specifications obsolete would allow for some automatic testing of this checkpoint.
An XHTML profile for RDF Site Summaries Dan Connolly
DAML+OIL for Application DevelopersMike Dean
SWIPE: a simple RDF vocabulary for basic facilities to support the extraction of structured RDF data from arbitrary HTML