Here's a new example script that does work with the latest Outfox 0.3.5 release. Instead of polluting the example with all the complications of navigating the GMail DOM, I've picked a much simpler target. This script simply speaks the number of major sections (level 2 headings) in a Wikipedia article when the page loads. It's not as sexy, but the code is much easier to understand.

To try this script, make sure you have the Greasemonkey 0.8 and Outfox 0.3.5 extensions installed on Firefox 3.0 or 3.5. Then visit the following link to have GM install the script: citation_announcer.user.js.

// ==UserScript==
// @name Sections count
// @namespace http://www.mindtrove.info/
// @description Speaks the number of h2 sections in a Wikipedia article
// @include http://*.wikipedia.org/wiki/*
// @require http://www.json.org/json2.js
// @require http://outfox.googlecode.com/svn/trunk/js/outfox.js
// ==/UserScript==
 
// number of major sections
var sections = 0;
 
function onOutfoxAudioInit(response) {
    // say the number of main sections
    outfox.audio.say(sections + ' main sections');
    // return the parameter for other outfox deferred callbacks
    return response;
}
 
function onOutfoxInit(version) {
    var content = document.getElementById('bodyContent');
    // count the number of main sections
    sections = content.getElementsByTagName('h2').length;
    // take one back for the TOC heading if it's present
    if(document.getElementById('toc')) {
        --sections;
    }
    // start the outfox audio service
    var def = outfox.startService('audio');
    def.addCallback(onOutfoxAudioInit);
    // return the parameter for other outfox deferred callbacks
    return version;
}
 
function onDOMContentLoaded() {
    // create a node for outfox use
    var div = document.createElement('div');
    document.body.appendChild(div);
    // initialize outfox
    var def = outfox.init(div, JSON.stringify, JSON.parse);
    def.addCallback(onOutfoxInit);
}
 
// this event triggers execution of the GM script
onDOMContentLoaded();

Can you remember a time when the title of this blog post might have landed me in a straight jacket? Can you believe that was just a few short years ago? Yea, I can't either.

Anyway, Gary's post Outfox: speech, sound, and more for Firefox talks about a new Firefox extension. He's using it to create cross-platform, self-voicing Web apps for kids with disabilities using a pure JS API. He hopes to extend his work to support alternative input devices such as game pads and switches as the Outfox extension matures and grows more flexible.

One of the other potential uses listed on the Outfox homepage is Adding new I/O to web sites with Greasemonkey. Interesting. It's one thing to include Outfox explicitly in a page, but can it possibly work when injected by GM? What about for a complex app like Gmail with multiple iframes, dynamic changes, refreshing, etc.?

To learn about Outfox (and for fun), I decided to write a quick GM script for Gmail that announces the senders and times of new messages (bold items) in the inbox. (I would have done subject and summary too, but Outfox 0.1.0 appears to have some unicode issues and balked at some of the Gmail separator characters. Less is more at this point.) The script makes the announcement when the Gmail interface first loads, any time Gmail automatically refreshes its inbox view, or when the user clicks the refresh link to check for new mail. It is smart enough to announce a given message only once, however, so you don't hear the same message over and over again on each refresh.

Yes. It does actually work.

To try this script, make sure you have the Greasemonkey 0.8 and Outfox 0.1 extensions installed on Firefox 3. (Or use the latest available version of each.) Then visit the following link to have GM install the script: gmail_announcer.user.js.

For reference, the entire script is listed below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

// ==UserScript==
// @name Gmail Announcer
// @namespace http://www.mindtrove.info/
// @description Speaks new Gmail inbox messages using Outfox
// @include https://mail.google.com/mail/*
// @include http://mail.google.com/mail/*
// @require http://outfox.googlecode.com/svn/trunk/js/outfox.js
// ==/UserScript==
 
var need_say = null;
var ids = {};
 
function sayMessages(msgs) {
    if(!outfox.defaults.config) {
	// outfox really needs a better way to detect ready ...
	need_say = msgs;
	return false;
    }
 
    var header = 'New messages';
    for(var id in msgs) {
	// say all messages
	var msg = msgs[id];
	var segs = msg.split('»');
	var sender = segs[0];
	var time = segs[1].slice(segs[1].search('…')+2);
	if(header) {
	    outfox.say(header);
	    header = null;
	}
	outfox.say(sender + ' at ' + time);
    }
    return true;
}
 
function onOutfoxReady() {
    if(need_say) {
	// say anything already queued
	sayMessages(need_say);
	ids = need_say;
	need_say = null;
    }
}
 
function onTableChange(event) {
    var div = event.target;
    var trs = div.getElementsByTagName('tr');
 
    var count = 0;
    var new_ids = {};
    var curr_ids = {};
    for(var i=0; i < trs.length; i++) {
	var tr = trs[i];
	if(tr.innerHTML.search('&lt;b&gt;') != -1) {
	    // marked as a new message
	    if(ids[tr.id] == undefined) {
		// never announced
		new_ids[tr.id] = tr.textContent;
		++count;
	    }
	    // curr is announced + new
	    curr_ids[tr.id] = tr.textContent;
	}
    }
 
    // report if we can
    if(sayMessages(new_ids)) {
	ids = curr_ids;
    } 
}
 
function onDocumentChange(event) {
    if(event.target.tagName == 'DIV') {
	var div = event.target;
	var tables = div.getElementsByTagName('table');
	for(var i in tables) {
	    var table = tables[i];
	    if(table.id != '' && !table.getAttribute('role')) {
		// watch just table changes from now on
		var div = table.parentNode.parentNode;
		div.addEventListener('DOMNodeInserted', onTableChange, false);
		document.removeEventListener('DOMNodeInserted', 
					     onDocumentChange, false);
		// start outfox
		var div = document.createElement('div');
		document.body.appendChild(div);
		outfox.init(div, onOutfoxReady);
		// kick off initial read manually
		onTableChange({'target' : table.parentNode});
	    }
	}
    }
}
 
document.addEventListener('DOMNodeInserted', onDocumentChange, false);

I've been brainstorming a bit about open-ended multi-user dungeons (MUDs) with rich sound and speech. Gary thinks it would be beneficial to use the MUD for educational purposes, not just as a reward after the work is done. I tend to agree, as long as its easy for teachers, older students, parents, and so on to translate lessons into in-game puzzles and adventures.

Here are some ideas I think could go into such a system to make it fun and rewarding for the kids, and an interesting platform for games.

• Rooms and items. A simple setup including the entire dungeon, rooms with arbitrary connections, items in rooms, and users in rooms can should account for a large number of adventure game designs.
• A basic command set. Take, drop, give, use, go, and a few other very simple commands can be supported everywhere to let the user navigate and interact with the environment.
• An extensible parser. Items can define additional supported commands, even to the extent where the become...
• In-world games. To go beyond exploring rooms, picking up items, and using items, items and rooms themselves can become full games. Imagine a puzzle game as an item or a room where everyone is participating in a guessing game.
• Other input methods. Items can reconfigure the keyboard to support simpler methods of interaction. For example, an multiple choice game might require only use of the arrow keys instead of requiring the user to enter full sentences. A game might enable other devices too (e.g., DDR pad).
• A rich audio client. Most MUD clients are text-only. When used with a screen reader, the game experience is entirely spoken. With a custom client, the game logic can provide responses the client renders as speech and sound in any number of streams.
• A client/server configuration over XMPP. The dungeon lives on a server, though not necessarily the same machine as the XMPP server. Instead, it's just another XMPP client with a well known JID. A bot of sorts. The rooms and items can be objects managed by that bot, or even become other bots themselves. The dungeon can exist across multiple machines.
• Collaboration. Rooms in the dungeon are like chat rooms where some text entered in the client is broadcast to everyone, and other commands are addressed to items in rooms. Going beyond simple text, clients could implement XMPP Jingle to support voice chat.

Is anyone working on a similar project? Heard of a similar project?

Gary came up with an interesting idea: create a shared Google Reader aggregate feed. The result is something very much like a Planet instance, but with Google doing the aggregation and hosting. I added most of the feed URLs from David's existing site, slapped a subdomain together to (partially) hide the big, ugly Google permalink, and voila: Accessibility Daily.

I'd like to give it a test run as an alternative to a Planet for now. Feel free to subscribe to the Atom feed or visit the HTML page. If you'd like your site listed, post a comment or shoot me an email with a link to your feed (preferably one that includes accessibility related news only).

Let me know if you're interested. I will volunteer time, effort, and maybe even hosting (if necessary) if public interest reaches some critical mass.

Nevertheless, I’m writing up some final documentation on LSR in hope that someone will find it useful:

1. A patterns document stating ways to solve different problems using the existing Perk scripting sytem.
2. A LSR in retrospect document starting what I would change, if I were starting over again today

I may work on making the latter changes myself in my spare time. I can see some usefulness is having a basic accessibility engine which I can use to script certain desktop actions or speech enable specific applications. For instance, maybe I want to listen to changes in a particular window (e.g. console with tail -f running, gaim chat window). Maybe I want some pre-recorded macros that perform a specific set of actions across applications that do not make their models public through dbus or another API. Or maybe I want a small toolbox window to augment an application with functions that aren’t immediately available in its toolbar.

I still plan on contributing to GNOME accessibility. I have some patches outstanding for pygtk that will allow widgets drawn with pycairo to become visible to AT-SPI clients (e.g. Orca, Accerciser, GOK). I just have to find time to work on them.