diff options
Diffstat (limited to 'accessible/jsat/OutputGenerator.jsm')
| -rw-r--r-- | accessible/jsat/OutputGenerator.jsm | 1003 |
1 files changed, 1003 insertions, 0 deletions
diff --git a/accessible/jsat/OutputGenerator.jsm b/accessible/jsat/OutputGenerator.jsm new file mode 100644 index 000000000..36b43a569 --- /dev/null +++ b/accessible/jsat/OutputGenerator.jsm @@ -0,0 +1,1003 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/* global Components, XPCOMUtils, Utils, PrefCache, States, Roles, Logger */ +/* exported UtteranceGenerator, BrailleGenerator */ + +'use strict'; + +const {utils: Cu, interfaces: Ci} = Components; + +const INCLUDE_DESC = 0x01; +const INCLUDE_NAME = 0x02; +const INCLUDE_VALUE = 0x04; +const NAME_FROM_SUBTREE_RULE = 0x10; +const IGNORE_EXPLICIT_NAME = 0x20; + +const OUTPUT_DESC_FIRST = 0; +const OUTPUT_DESC_LAST = 1; + +Cu.import('resource://gre/modules/XPCOMUtils.jsm'); +XPCOMUtils.defineLazyModuleGetter(this, 'Utils', // jshint ignore:line + 'resource://gre/modules/accessibility/Utils.jsm'); +XPCOMUtils.defineLazyModuleGetter(this, 'PrefCache', // jshint ignore:line + 'resource://gre/modules/accessibility/Utils.jsm'); +XPCOMUtils.defineLazyModuleGetter(this, 'Logger', // jshint ignore:line + 'resource://gre/modules/accessibility/Utils.jsm'); +XPCOMUtils.defineLazyModuleGetter(this, 'Roles', // jshint ignore:line + 'resource://gre/modules/accessibility/Constants.jsm'); +XPCOMUtils.defineLazyModuleGetter(this, 'States', // jshint ignore:line + 'resource://gre/modules/accessibility/Constants.jsm'); + +this.EXPORTED_SYMBOLS = ['UtteranceGenerator', 'BrailleGenerator']; // jshint ignore:line + +var OutputGenerator = { + + defaultOutputOrder: OUTPUT_DESC_LAST, + + /** + * Generates output for a PivotContext. + * @param {PivotContext} aContext object that generates and caches + * context information for a given accessible and its relationship with + * another accessible. + * @return {Object} An array of speech data. Depending on the utterance order, + * the data describes the context for an accessible object either + * starting from the accessible's ancestry or accessible's subtree. + */ + genForContext: function genForContext(aContext) { + let output = []; + let self = this; + let addOutput = function addOutput(aAccessible) { + output.push.apply(output, self.genForObject(aAccessible, aContext)); + }; + let ignoreSubtree = function ignoreSubtree(aAccessible) { + let roleString = Utils.AccService.getStringRole(aAccessible.role); + let nameRule = self.roleRuleMap[roleString] || 0; + // Ignore subtree if the name is explicit and the role's name rule is the + // NAME_FROM_SUBTREE_RULE. + return (((nameRule & INCLUDE_VALUE) && aAccessible.value) || + ((nameRule & NAME_FROM_SUBTREE_RULE) && + (Utils.getAttributes(aAccessible)['explicit-name'] === 'true' && + !(nameRule & IGNORE_EXPLICIT_NAME)))); + }; + + let contextStart = this._getContextStart(aContext); + + if (this.outputOrder === OUTPUT_DESC_FIRST) { + contextStart.forEach(addOutput); + addOutput(aContext.accessible); + for (let node of aContext.subtreeGenerator(true, ignoreSubtree)) { + addOutput(node); + } + } else { + for (let node of aContext.subtreeGenerator(false, ignoreSubtree)) { + addOutput(node); + } + addOutput(aContext.accessible); + + // If there are any documents in new ancestry, find a first one and place + // it in the beginning of the utterance. + let doc, docIndex = contextStart.findIndex( + ancestor => ancestor.role === Roles.DOCUMENT); + + if (docIndex > -1) { + doc = contextStart.splice(docIndex, 1)[0]; + } + + contextStart.reverse().forEach(addOutput); + if (doc) { + output.unshift.apply(output, self.genForObject(doc, aContext)); + } + } + + return output; + }, + + + /** + * Generates output for an object. + * @param {nsIAccessible} aAccessible accessible object to generate output + * for. + * @param {PivotContext} aContext object that generates and caches + * context information for a given accessible and its relationship with + * another accessible. + * @return {Array} A 2 element array of speech data. The first element + * describes the object and its state. The second element is the object's + * name. Whether the object's description or it's role is included is + * determined by {@link roleRuleMap}. + */ + genForObject: function genForObject(aAccessible, aContext) { + let roleString = Utils.AccService.getStringRole(aAccessible.role); + let func = this.objectOutputFunctions[ + OutputGenerator._getOutputName(roleString)] || + this.objectOutputFunctions.defaultFunc; + + let flags = this.roleRuleMap[roleString] || 0; + + if (aAccessible.childCount === 0) { + flags |= INCLUDE_NAME; + } + + return func.apply(this, [aAccessible, roleString, + Utils.getState(aAccessible), flags, aContext]); + }, + + /** + * Generates output for an action performed. + * @param {nsIAccessible} aAccessible accessible object that the action was + * invoked in. + * @param {string} aActionName the name of the action, one of the keys in + * {@link gActionMap}. + * @return {Array} A one element array with action data. + */ + genForAction: function genForAction(aObject, aActionName) {}, // jshint ignore:line + + /** + * Generates output for an announcement. + * @param {string} aAnnouncement unlocalized announcement. + * @return {Array} An announcement speech data to be localized. + */ + genForAnnouncement: function genForAnnouncement(aAnnouncement) {}, // jshint ignore:line + + /** + * Generates output for a tab state change. + * @param {nsIAccessible} aAccessible accessible object of the tab's attached + * document. + * @param {string} aTabState the tab state name, see + * {@link Presenter.tabStateChanged}. + * @return {Array} The tab state utterace. + */ + genForTabStateChange: function genForTabStateChange(aObject, aTabState) {}, // jshint ignore:line + + /** + * Generates output for announcing entering and leaving editing mode. + * @param {aIsEditing} boolean true if we are in editing mode + * @return {Array} The mode utterance + */ + genForEditingMode: function genForEditingMode(aIsEditing) {}, // jshint ignore:line + + _getContextStart: function getContextStart(aContext) {}, // jshint ignore:line + + /** + * Adds an accessible name and description to the output if available. + * @param {Array} aOutput Output array. + * @param {nsIAccessible} aAccessible current accessible object. + * @param {Number} aFlags output flags. + */ + _addName: function _addName(aOutput, aAccessible, aFlags) { + let name; + if ((Utils.getAttributes(aAccessible)['explicit-name'] === 'true' && + !(aFlags & IGNORE_EXPLICIT_NAME)) || (aFlags & INCLUDE_NAME)) { + name = aAccessible.name; + } + + let description = aAccessible.description; + if (description) { + // Compare against the calculated name unconditionally, regardless of name rule, + // so we can make sure we don't speak duplicated descriptions + let tmpName = name || aAccessible.name; + if (tmpName && (description !== tmpName)) { + name = name || ''; + name = this.outputOrder === OUTPUT_DESC_FIRST ? + description + ' - ' + name : + name + ' - ' + description; + } + } + + if (!name || !name.trim()) { + return; + } + aOutput[this.outputOrder === OUTPUT_DESC_FIRST ? 'push' : 'unshift'](name); + }, + + /** + * Adds a landmark role to the output if available. + * @param {Array} aOutput Output array. + * @param {nsIAccessible} aAccessible current accessible object. + */ + _addLandmark: function _addLandmark(aOutput, aAccessible) { + let landmarkName = Utils.getLandmarkName(aAccessible); + if (!landmarkName) { + return; + } + aOutput[this.outputOrder === OUTPUT_DESC_FIRST ? 'unshift' : 'push']({ + string: landmarkName + }); + }, + + /** + * Adds math roles to the output, for a MathML accessible. + * @param {Array} aOutput Output array. + * @param {nsIAccessible} aAccessible current accessible object. + * @param {String} aRoleStr aAccessible's role string. + */ + _addMathRoles: function _addMathRoles(aOutput, aAccessible, aRoleStr) { + // First, determine the actual role to use (e.g. mathmlfraction). + let roleStr = aRoleStr; + switch(aAccessible.role) { + case Roles.MATHML_CELL: + case Roles.MATHML_ENCLOSED: + case Roles.MATHML_LABELED_ROW: + case Roles.MATHML_ROOT: + case Roles.MATHML_SQUARE_ROOT: + case Roles.MATHML_TABLE: + case Roles.MATHML_TABLE_ROW: + // Use the default role string. + break; + case Roles.MATHML_MULTISCRIPTS: + case Roles.MATHML_OVER: + case Roles.MATHML_SUB: + case Roles.MATHML_SUB_SUP: + case Roles.MATHML_SUP: + case Roles.MATHML_UNDER: + case Roles.MATHML_UNDER_OVER: + // For scripted accessibles, use the string 'mathmlscripted'. + roleStr = 'mathmlscripted'; + break; + case Roles.MATHML_FRACTION: + // From a semantic point of view, the only important point is to + // distinguish between fractions that have a bar and those that do not. + // Per the MathML 3 spec, the latter happens iff the linethickness + // attribute is of the form [zero-float][optional-unit]. In that case, + // we use the string 'mathmlfractionwithoutbar'. + let linethickness = Utils.getAttributes(aAccessible).linethickness; + if (linethickness) { + let numberMatch = linethickness.match(/^(?:\d|\.)+/); + if (numberMatch && !parseFloat(numberMatch[0])) { + roleStr += 'withoutbar'; + } + } + break; + default: + // Otherwise, do not output the actual role. + roleStr = null; + break; + } + + // Get the math role based on the position in the parent accessible + // (e.g. numerator for the first child of a mathmlfraction). + let mathRole = Utils.getMathRole(aAccessible); + if (mathRole) { + aOutput[this.outputOrder === OUTPUT_DESC_FIRST ? 'push' : 'unshift'] + ({string: this._getOutputName(mathRole)}); + } + if (roleStr) { + aOutput[this.outputOrder === OUTPUT_DESC_FIRST ? 'push' : 'unshift'] + ({string: this._getOutputName(roleStr)}); + } + }, + + /** + * Adds MathML menclose notations to the output. + * @param {Array} aOutput Output array. + * @param {nsIAccessible} aAccessible current accessible object. + */ + _addMencloseNotations: function _addMencloseNotations(aOutput, aAccessible) { + let notations = Utils.getAttributes(aAccessible).notation || 'longdiv'; + aOutput[this.outputOrder === OUTPUT_DESC_FIRST ? 'push' : 'unshift'].apply( + aOutput, notations.split(' ').map(notation => { + return { string: this._getOutputName('notation-' + notation) }; + })); + }, + + /** + * Adds an entry type attribute to the description if available. + * @param {Array} aOutput Output array. + * @param {nsIAccessible} aAccessible current accessible object. + * @param {String} aRoleStr aAccessible's role string. + */ + _addType: function _addType(aOutput, aAccessible, aRoleStr) { + if (aRoleStr !== 'entry') { + return; + } + + let typeName = Utils.getAttributes(aAccessible)['text-input-type']; + // Ignore the the input type="text" case. + if (!typeName || typeName === 'text') { + return; + } + aOutput.push({string: 'textInputType_' + typeName}); + }, + + _addState: function _addState(aOutput, aState, aRoleStr) {}, // jshint ignore:line + + _addRole: function _addRole(aOutput, aAccessible, aRoleStr) {}, // jshint ignore:line + + get outputOrder() { + if (!this._utteranceOrder) { + this._utteranceOrder = new PrefCache('accessibility.accessfu.utterance'); + } + return typeof this._utteranceOrder.value === 'number' ? + this._utteranceOrder.value : this.defaultOutputOrder; + }, + + _getOutputName: function _getOutputName(aName) { + return aName.replace(/\s/g, ''); + }, + + roleRuleMap: { + 'menubar': INCLUDE_DESC, + 'scrollbar': INCLUDE_DESC, + 'grip': INCLUDE_DESC, + 'alert': INCLUDE_DESC | INCLUDE_NAME, + 'menupopup': INCLUDE_DESC, + 'menuitem': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE, + 'tooltip': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE, + 'columnheader': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE, + 'rowheader': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE, + 'column': NAME_FROM_SUBTREE_RULE, + 'row': NAME_FROM_SUBTREE_RULE, + 'cell': INCLUDE_DESC | INCLUDE_NAME, + 'application': INCLUDE_NAME, + 'document': INCLUDE_NAME, + 'grouping': INCLUDE_DESC | INCLUDE_NAME, + 'toolbar': INCLUDE_DESC, + 'table': INCLUDE_DESC | INCLUDE_NAME, + 'link': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE, + 'helpballoon': NAME_FROM_SUBTREE_RULE, + 'list': INCLUDE_DESC | INCLUDE_NAME, + 'listitem': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE, + 'outline': INCLUDE_DESC, + 'outlineitem': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE, + 'pagetab': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE, + 'graphic': INCLUDE_DESC, + 'switch': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE, + 'pushbutton': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE, + 'checkbutton': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE, + 'radiobutton': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE, + 'buttondropdown': NAME_FROM_SUBTREE_RULE, + 'combobox': INCLUDE_DESC | INCLUDE_VALUE, + 'droplist': INCLUDE_DESC, + 'progressbar': INCLUDE_DESC | INCLUDE_VALUE, + 'slider': INCLUDE_DESC | INCLUDE_VALUE, + 'spinbutton': INCLUDE_DESC | INCLUDE_VALUE, + 'diagram': INCLUDE_DESC, + 'animation': INCLUDE_DESC, + 'equation': INCLUDE_DESC, + 'buttonmenu': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE, + 'buttondropdowngrid': NAME_FROM_SUBTREE_RULE, + 'pagetablist': INCLUDE_DESC, + 'canvas': INCLUDE_DESC, + 'check menu item': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE, + 'label': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE, + 'password text': INCLUDE_DESC, + 'popup menu': INCLUDE_DESC, + 'radio menu item': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE, + 'table column header': NAME_FROM_SUBTREE_RULE, + 'table row header': NAME_FROM_SUBTREE_RULE, + 'tear off menu item': NAME_FROM_SUBTREE_RULE, + 'toggle button': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE, + 'parent menuitem': NAME_FROM_SUBTREE_RULE, + 'header': INCLUDE_DESC, + 'footer': INCLUDE_DESC, + 'entry': INCLUDE_DESC | INCLUDE_NAME | INCLUDE_VALUE, + 'caption': INCLUDE_DESC, + 'document frame': INCLUDE_DESC, + 'heading': INCLUDE_DESC, + 'calendar': INCLUDE_DESC | INCLUDE_NAME, + 'combobox option': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE, + 'listbox option': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE, + 'listbox rich option': NAME_FROM_SUBTREE_RULE, + 'gridcell': NAME_FROM_SUBTREE_RULE, + 'check rich option': NAME_FROM_SUBTREE_RULE, + 'term': NAME_FROM_SUBTREE_RULE, + 'definition': NAME_FROM_SUBTREE_RULE, + 'key': NAME_FROM_SUBTREE_RULE, + 'image map': INCLUDE_DESC, + 'option': INCLUDE_DESC, + 'listbox': INCLUDE_DESC, + 'definitionlist': INCLUDE_DESC | INCLUDE_NAME, + 'dialog': INCLUDE_DESC | INCLUDE_NAME, + 'chrome window': IGNORE_EXPLICIT_NAME, + 'app root': IGNORE_EXPLICIT_NAME, + 'statusbar': NAME_FROM_SUBTREE_RULE, + 'mathml table': INCLUDE_DESC | INCLUDE_NAME, + 'mathml labeled row': NAME_FROM_SUBTREE_RULE, + 'mathml table row': NAME_FROM_SUBTREE_RULE, + 'mathml cell': INCLUDE_DESC | INCLUDE_NAME, + 'mathml fraction': INCLUDE_DESC, + 'mathml square root': INCLUDE_DESC, + 'mathml root': INCLUDE_DESC, + 'mathml enclosed': INCLUDE_DESC, + 'mathml sub': INCLUDE_DESC, + 'mathml sup': INCLUDE_DESC, + 'mathml sub sup': INCLUDE_DESC, + 'mathml under': INCLUDE_DESC, + 'mathml over': INCLUDE_DESC, + 'mathml under over': INCLUDE_DESC, + 'mathml multiscripts': INCLUDE_DESC, + 'mathml identifier': INCLUDE_DESC, + 'mathml number': INCLUDE_DESC, + 'mathml operator': INCLUDE_DESC, + 'mathml text': INCLUDE_DESC, + 'mathml string literal': INCLUDE_DESC, + 'mathml row': INCLUDE_DESC, + 'mathml style': INCLUDE_DESC, + 'mathml error': INCLUDE_DESC }, + + mathmlRolesSet: new Set([ + Roles.MATHML_MATH, + Roles.MATHML_IDENTIFIER, + Roles.MATHML_NUMBER, + Roles.MATHML_OPERATOR, + Roles.MATHML_TEXT, + Roles.MATHML_STRING_LITERAL, + Roles.MATHML_GLYPH, + Roles.MATHML_ROW, + Roles.MATHML_FRACTION, + Roles.MATHML_SQUARE_ROOT, + Roles.MATHML_ROOT, + Roles.MATHML_FENCED, + Roles.MATHML_ENCLOSED, + Roles.MATHML_STYLE, + Roles.MATHML_SUB, + Roles.MATHML_SUP, + Roles.MATHML_SUB_SUP, + Roles.MATHML_UNDER, + Roles.MATHML_OVER, + Roles.MATHML_UNDER_OVER, + Roles.MATHML_MULTISCRIPTS, + Roles.MATHML_TABLE, + Roles.LABELED_ROW, + Roles.MATHML_TABLE_ROW, + Roles.MATHML_CELL, + Roles.MATHML_ACTION, + Roles.MATHML_ERROR, + Roles.MATHML_STACK, + Roles.MATHML_LONG_DIVISION, + Roles.MATHML_STACK_GROUP, + Roles.MATHML_STACK_ROW, + Roles.MATHML_STACK_CARRIES, + Roles.MATHML_STACK_CARRY, + Roles.MATHML_STACK_LINE + ]), + + objectOutputFunctions: { + _generateBaseOutput: + function _generateBaseOutput(aAccessible, aRoleStr, aState, aFlags) { + let output = []; + + if (aFlags & INCLUDE_DESC) { + this._addState(output, aState, aRoleStr); + this._addType(output, aAccessible, aRoleStr); + this._addRole(output, aAccessible, aRoleStr); + } + + if (aFlags & INCLUDE_VALUE && aAccessible.value.trim()) { + output[this.outputOrder === OUTPUT_DESC_FIRST ? 'push' : 'unshift']( + aAccessible.value); + } + + this._addName(output, aAccessible, aFlags); + this._addLandmark(output, aAccessible); + + return output; + }, + + label: function label(aAccessible, aRoleStr, aState, aFlags, aContext) { + if (aContext.isNestedControl || + aContext.accessible == Utils.getEmbeddedControl(aAccessible)) { + // If we are on a nested control, or a nesting label, + // we don't need the context. + return []; + } + + return this.objectOutputFunctions.defaultFunc.apply(this, arguments); + }, + + entry: function entry(aAccessible, aRoleStr, aState, aFlags) { + let rolestr = aState.contains(States.MULTI_LINE) ? 'textarea' : 'entry'; + return this.objectOutputFunctions.defaultFunc.apply( + this, [aAccessible, rolestr, aState, aFlags]); + }, + + pagetab: function pagetab(aAccessible, aRoleStr, aState, aFlags) { + let itemno = {}; + let itemof = {}; + aAccessible.groupPosition({}, itemof, itemno); + let output = []; + this._addState(output, aState); + this._addRole(output, aAccessible, aRoleStr); + output.push({ + string: 'objItemOfN', + args: [itemno.value, itemof.value] + }); + + this._addName(output, aAccessible, aFlags); + this._addLandmark(output, aAccessible); + + return output; + }, + + table: function table(aAccessible, aRoleStr, aState, aFlags) { + let output = []; + let table; + try { + table = aAccessible.QueryInterface(Ci.nsIAccessibleTable); + } catch (x) { + Logger.logException(x); + return output; + } finally { + // Check if it's a layout table, and bail out if true. + // We don't want to speak any table information for layout tables. + if (table.isProbablyForLayout()) { + return output; + } + this._addRole(output, aAccessible, aRoleStr); + output.push.call(output, { + string: this._getOutputName('tblColumnInfo'), + count: table.columnCount + }, { + string: this._getOutputName('tblRowInfo'), + count: table.rowCount + }); + this._addName(output, aAccessible, aFlags); + this._addLandmark(output, aAccessible); + return output; + } + }, + + gridcell: function gridcell(aAccessible, aRoleStr, aState, aFlags) { + let output = []; + this._addState(output, aState); + this._addName(output, aAccessible, aFlags); + this._addLandmark(output, aAccessible); + return output; + }, + + // Use the table output functions for MathML tabular elements. + mathmltable: function mathmltable() { + return this.objectOutputFunctions.table.apply(this, arguments); + }, + + mathmlcell: function mathmlcell() { + return this.objectOutputFunctions.cell.apply(this, arguments); + }, + + mathmlenclosed: function mathmlenclosed(aAccessible, aRoleStr, aState, + aFlags, aContext) { + let output = this.objectOutputFunctions.defaultFunc. + apply(this, [aAccessible, aRoleStr, aState, aFlags, aContext]); + this._addMencloseNotations(output, aAccessible); + return output; + } + } +}; + +/** + * Generates speech utterances from objects, actions and state changes. + * An utterance is an array of speech data. + * + * It should not be assumed that flattening an utterance array would create a + * gramatically correct sentence. For example, {@link genForObject} might + * return: ['graphic', 'Welcome to my home page']. + * Each string element in an utterance should be gramatically correct in itself. + * Another example from {@link genForObject}: ['list item 2 of 5', 'Alabama']. + * + * An utterance is ordered from the least to the most important. Speaking the + * last string usually makes sense, but speaking the first often won't. + * For example {@link genForAction} might return ['button', 'clicked'] for a + * clicked event. Speaking only 'clicked' makes sense. Speaking 'button' does + * not. + */ +this.UtteranceGenerator = { // jshint ignore:line + __proto__: OutputGenerator, // jshint ignore:line + + gActionMap: { + jump: 'jumpAction', + press: 'pressAction', + check: 'checkAction', + uncheck: 'uncheckAction', + on: 'onAction', + off: 'offAction', + select: 'selectAction', + unselect: 'unselectAction', + open: 'openAction', + close: 'closeAction', + switch: 'switchAction', + click: 'clickAction', + collapse: 'collapseAction', + expand: 'expandAction', + activate: 'activateAction', + cycle: 'cycleAction' + }, + + //TODO: May become more verbose in the future. + genForAction: function genForAction(aObject, aActionName) { + return [{string: this.gActionMap[aActionName]}]; + }, + + genForLiveRegion: + function genForLiveRegion(aContext, aIsHide, aModifiedText) { + let utterance = []; + if (aIsHide) { + utterance.push({string: 'hidden'}); + } + return utterance.concat(aModifiedText || this.genForContext(aContext)); + }, + + genForAnnouncement: function genForAnnouncement(aAnnouncement) { + return [{ + string: aAnnouncement + }]; + }, + + genForTabStateChange: function genForTabStateChange(aObject, aTabState) { + switch (aTabState) { + case 'newtab': + return [{string: 'tabNew'}]; + case 'loading': + return [{string: 'tabLoading'}]; + case 'loaded': + return [aObject.name, {string: 'tabLoaded'}]; + case 'loadstopped': + return [{string: 'tabLoadStopped'}]; + case 'reload': + return [{string: 'tabReload'}]; + default: + return []; + } + }, + + genForEditingMode: function genForEditingMode(aIsEditing) { + return [{string: aIsEditing ? 'editingMode' : 'navigationMode'}]; + }, + + objectOutputFunctions: { + + __proto__: OutputGenerator.objectOutputFunctions, // jshint ignore:line + + defaultFunc: function defaultFunc() { + return this.objectOutputFunctions._generateBaseOutput.apply( + this, arguments); + }, + + heading: function heading(aAccessible, aRoleStr, aState, aFlags) { + let level = {}; + aAccessible.groupPosition(level, {}, {}); + let utterance = [{string: 'headingLevel', args: [level.value]}]; + + this._addName(utterance, aAccessible, aFlags); + this._addLandmark(utterance, aAccessible); + + return utterance; + }, + + listitem: function listitem(aAccessible, aRoleStr, aState, aFlags) { + let itemno = {}; + let itemof = {}; + aAccessible.groupPosition({}, itemof, itemno); + let utterance = []; + if (itemno.value == 1) { + // Start of list + utterance.push({string: 'listStart'}); + } + else if (itemno.value == itemof.value) { + // last item + utterance.push({string: 'listEnd'}); + } + + this._addName(utterance, aAccessible, aFlags); + this._addLandmark(utterance, aAccessible); + + return utterance; + }, + + list: function list(aAccessible, aRoleStr, aState, aFlags) { + return this._getListUtterance + (aAccessible, aRoleStr, aFlags, aAccessible.childCount); + }, + + definitionlist: + function definitionlist(aAccessible, aRoleStr, aState, aFlags) { + return this._getListUtterance + (aAccessible, aRoleStr, aFlags, aAccessible.childCount / 2); + }, + + application: function application(aAccessible, aRoleStr, aState, aFlags) { + // Don't utter location of applications, it gets tiring. + if (aAccessible.name != aAccessible.DOMNode.location) { + return this.objectOutputFunctions.defaultFunc.apply(this, + [aAccessible, aRoleStr, aState, aFlags]); + } + + return []; + }, + + cell: function cell(aAccessible, aRoleStr, aState, aFlags, aContext) { + let utterance = []; + let cell = aContext.getCellInfo(aAccessible); + if (cell) { + let addCellChanged = + function addCellChanged(aUtterance, aChanged, aString, aIndex) { + if (aChanged) { + aUtterance.push({string: aString, args: [aIndex + 1]}); + } + }; + let addExtent = function addExtent(aUtterance, aExtent, aString) { + if (aExtent > 1) { + aUtterance.push({string: aString, args: [aExtent]}); + } + }; + let addHeaders = function addHeaders(aUtterance, aHeaders) { + if (aHeaders.length > 0) { + aUtterance.push.apply(aUtterance, aHeaders); + } + }; + + addCellChanged(utterance, cell.columnChanged, 'columnInfo', + cell.columnIndex); + addCellChanged(utterance, cell.rowChanged, 'rowInfo', cell.rowIndex); + + addExtent(utterance, cell.columnExtent, 'spansColumns'); + addExtent(utterance, cell.rowExtent, 'spansRows'); + + addHeaders(utterance, cell.columnHeaders); + addHeaders(utterance, cell.rowHeaders); + } + + this._addName(utterance, aAccessible, aFlags); + this._addLandmark(utterance, aAccessible); + + return utterance; + }, + + columnheader: function columnheader() { + return this.objectOutputFunctions.cell.apply(this, arguments); + }, + + rowheader: function rowheader() { + return this.objectOutputFunctions.cell.apply(this, arguments); + }, + + statictext: function statictext(aAccessible) { + if (Utils.isListItemDecorator(aAccessible, true)) { + return []; + } + + return this.objectOutputFunctions.defaultFunc.apply(this, arguments); + } + }, + + _getContextStart: function _getContextStart(aContext) { + return aContext.newAncestry; + }, + + _addRole: function _addRole(aOutput, aAccessible, aRoleStr) { + if (this.mathmlRolesSet.has(aAccessible.role)) { + this._addMathRoles(aOutput, aAccessible, aRoleStr); + } else { + aOutput.push({string: this._getOutputName(aRoleStr)}); + } + }, + + _addState: function _addState(aOutput, aState, aRoleStr) { + + if (aState.contains(States.UNAVAILABLE)) { + aOutput.push({string: 'stateUnavailable'}); + } + + if (aState.contains(States.READONLY)) { + aOutput.push({string: 'stateReadonly'}); + } + + // Don't utter this in Jelly Bean, we let TalkBack do it for us there. + // This is because we expose the checked information on the node itself. + // XXX: this means the checked state is always appended to the end, + // regardless of the utterance ordering preference. + if ((Utils.AndroidSdkVersion < 16 || Utils.MozBuildApp === 'browser') && + aState.contains(States.CHECKABLE)) { + let checked = aState.contains(States.CHECKED); + let statetr; + if (aRoleStr === 'switch') { + statetr = checked ? 'stateOn' : 'stateOff'; + } else { + statetr = checked ? 'stateChecked' : 'stateNotChecked'; + } + aOutput.push({string: statetr}); + } + + if (aState.contains(States.PRESSED)) { + aOutput.push({string: 'statePressed'}); + } + + if (aState.contains(States.EXPANDABLE)) { + let statetr = aState.contains(States.EXPANDED) ? + 'stateExpanded' : 'stateCollapsed'; + aOutput.push({string: statetr}); + } + + if (aState.contains(States.REQUIRED)) { + aOutput.push({string: 'stateRequired'}); + } + + if (aState.contains(States.TRAVERSED)) { + aOutput.push({string: 'stateTraversed'}); + } + + if (aState.contains(States.HASPOPUP)) { + aOutput.push({string: 'stateHasPopup'}); + } + + if (aState.contains(States.SELECTED)) { + aOutput.push({string: 'stateSelected'}); + } + }, + + _getListUtterance: + function _getListUtterance(aAccessible, aRoleStr, aFlags, aItemCount) { + let utterance = []; + this._addRole(utterance, aAccessible, aRoleStr); + utterance.push({ + string: this._getOutputName('listItemsCount'), + count: aItemCount + }); + + this._addName(utterance, aAccessible, aFlags); + this._addLandmark(utterance, aAccessible); + + return utterance; + } +}; + +this.BrailleGenerator = { // jshint ignore:line + __proto__: OutputGenerator, // jshint ignore:line + + genForContext: function genForContext(aContext) { + let output = OutputGenerator.genForContext.apply(this, arguments); + + let acc = aContext.accessible; + + // add the static text indicating a list item; do this for both listitems or + // direct first children of listitems, because these are both common + // browsing scenarios + let addListitemIndicator = function addListitemIndicator(indicator = '*') { + output.unshift(indicator); + }; + + if (acc.indexInParent === 1 && + acc.parent.role == Roles.LISTITEM && + acc.previousSibling.role == Roles.STATICTEXT) { + if (acc.parent.parent && acc.parent.parent.DOMNode && + acc.parent.parent.DOMNode.nodeName == 'UL') { + addListitemIndicator(); + } else { + addListitemIndicator(acc.previousSibling.name.trim()); + } + } else if (acc.role == Roles.LISTITEM && acc.firstChild && + acc.firstChild.role == Roles.STATICTEXT) { + if (acc.parent.DOMNode.nodeName == 'UL') { + addListitemIndicator(); + } else { + addListitemIndicator(acc.firstChild.name.trim()); + } + } + + return output; + }, + + objectOutputFunctions: { + + __proto__: OutputGenerator.objectOutputFunctions, // jshint ignore:line + + defaultFunc: function defaultFunc() { + return this.objectOutputFunctions._generateBaseOutput.apply( + this, arguments); + }, + + listitem: function listitem(aAccessible, aRoleStr, aState, aFlags) { + let braille = []; + + this._addName(braille, aAccessible, aFlags); + this._addLandmark(braille, aAccessible); + + return braille; + }, + + cell: function cell(aAccessible, aRoleStr, aState, aFlags, aContext) { + let braille = []; + let cell = aContext.getCellInfo(aAccessible); + if (cell) { + let addHeaders = function addHeaders(aBraille, aHeaders) { + if (aHeaders.length > 0) { + aBraille.push.apply(aBraille, aHeaders); + } + }; + + braille.push({ + string: this._getOutputName('cellInfo'), + args: [cell.columnIndex + 1, cell.rowIndex + 1] + }); + + addHeaders(braille, cell.columnHeaders); + addHeaders(braille, cell.rowHeaders); + } + + this._addName(braille, aAccessible, aFlags); + this._addLandmark(braille, aAccessible); + return braille; + }, + + columnheader: function columnheader() { + return this.objectOutputFunctions.cell.apply(this, arguments); + }, + + rowheader: function rowheader() { + return this.objectOutputFunctions.cell.apply(this, arguments); + }, + + statictext: function statictext(aAccessible) { + // Since we customize the list bullet's output, we add the static + // text from the first node in each listitem, so skip it here. + if (Utils.isListItemDecorator(aAccessible)) { + return []; + } + + return this.objectOutputFunctions._useStateNotRole.apply(this, arguments); + }, + + _useStateNotRole: + function _useStateNotRole(aAccessible, aRoleStr, aState, aFlags) { + let braille = []; + this._addState(braille, aState, aRoleStr); + this._addName(braille, aAccessible, aFlags); + this._addLandmark(braille, aAccessible); + + return braille; + }, + + switch: function braille_generator_object_output_functions_switch() { + return this.objectOutputFunctions._useStateNotRole.apply(this, arguments); + }, + + checkbutton: function checkbutton() { + return this.objectOutputFunctions._useStateNotRole.apply(this, arguments); + }, + + radiobutton: function radiobutton() { + return this.objectOutputFunctions._useStateNotRole.apply(this, arguments); + }, + + togglebutton: function togglebutton() { + return this.objectOutputFunctions._useStateNotRole.apply(this, arguments); + } + }, + + _getContextStart: function _getContextStart(aContext) { + if (aContext.accessible.parent.role == Roles.LINK) { + return [aContext.accessible.parent]; + } + + return []; + }, + + _getOutputName: function _getOutputName(aName) { + return OutputGenerator._getOutputName(aName) + 'Abbr'; + }, + + _addRole: function _addRole(aBraille, aAccessible, aRoleStr) { + if (this.mathmlRolesSet.has(aAccessible.role)) { + this._addMathRoles(aBraille, aAccessible, aRoleStr); + } else { + aBraille.push({string: this._getOutputName(aRoleStr)}); + } + }, + + _addState: function _addState(aBraille, aState, aRoleStr) { + if (aState.contains(States.CHECKABLE)) { + aBraille.push({ + string: aState.contains(States.CHECKED) ? + this._getOutputName('stateChecked') : + this._getOutputName('stateUnchecked') + }); + } + if (aRoleStr === 'toggle button') { + aBraille.push({ + string: aState.contains(States.PRESSED) ? + this._getOutputName('statePressed') : + this._getOutputName('stateUnpressed') + }); + } + } +}; |