summaryrefslogtreecommitdiffstats
path: root/accessible/jsat/OutputGenerator.jsm
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /accessible/jsat/OutputGenerator.jsm
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'accessible/jsat/OutputGenerator.jsm')
-rw-r--r--accessible/jsat/OutputGenerator.jsm1003
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')
+ });
+ }
+ }
+};