Complete table support in ChromeVox Next.

chrome/browser/resources/chromeos/chromevox/cvox2/background/output.js

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @fileoverview Provides output services for ChromeVox.
  */
 
 goog.provide('Output');
 goog.provide('Output.EventType');
@@ skipping 69 matching lines @@
    * @private
    */
   this.speechCategory_ = cvox.TtsCategory.NAV;
 
   /**
    * The speech queue mode for the generated speech utterance.
    * @type {cvox.QueueMode}
    * @private
    */
   this.queueMode_ = cvox.QueueMode.QUEUE;
+
+  /**
+   * @type {boolean}
+   * @private
+   */
+  this.outputContextFirst_ = localStorage['outputContextFirst'] == 'true';
 };
 
 /**
  * Delimiter to use between output values.
  * @type {string}
  */
 Output.SPACE = ' ';
 
 /**
  * Metadata about supported automation roles.
@@ skipping 29 matching lines @@
   },
   button: {
     msgId: 'role_button',
     earconId: 'BUTTON'
   },
   buttonDropDown: {
     msgId: 'role_button',
     earconId: 'BUTTON'
   },
   cell: {
-    msgId: 'role_gridcell'
+    msgId: 'role_column'

[dmazzoni, 2016/07/13 23:38:28]

Why is "cell" speaking the "column" message?

[David Tseng, 2016/07/14 20:24:41]

This is unused by the cell speech rule...removed.

   },
   checkBox: {
     msgId: 'role_checkbox'
   },
   columnHeader: {
     msgId: 'role_columnheader',
-    inherits: 'abstractContainer'
+    inherits: 'cell'
   },
   comboBox: {
     msgId: 'role_combobox'
   },
   complementary: {
     msgId: 'role_complementary',
     inherits: 'abstractContainer'
   },
   contentInfo: {
     msgId: 'role_contentinfo',
@@ skipping 104 matching lines @@
   popUpButton: {
     msgId: 'role_button',
     earconId: 'POP_UP_BUTTON'
   },
   radioButton: {
     msgId: 'role_radio'
   },
   radioGroup: {
     msgId: 'role_radiogroup',
   },
+  row: {
+    msgId: 'role_row',
+    inherits: 'abstractContainer'
+  },
   rowHeader: {
     msgId: 'role_rowheader',
-    inherits: 'abstractContainer'
+    inherits: 'cell'
   },
   scrollBar: {
     msgId: 'role_scrollbar',
   },
   search: {
     msgId: 'role_search',
     inherits: 'abstractContainer'
   },
   separator: {
     msgId: 'role_separator',
@@ skipping 120 matching lines @@
  * Rules specifying format of AutomationNodes for output.
  * @type {!Object<Object<Object<string>>>}
  */
 Output.RULES = {
   navigate: {
     'default': {
       speak: '$name $value $state $role $description',
       braille: ''
     },
     abstractContainer: {
-      enter: '$nameFromNode $role $description',
-      leave: '@exited_container($role)'

[dmazzoni, 2016/07/13 23:38:28]

I think it's particularly useful to have exited_container for "dialog", what do
you think about moving it to the leave: rule for the dialog role for now?

[David Tseng, 2016/07/14 20:24:41]

Leaving for another cl where I can do an audit on what might make sense (e.g.
alert dialogs, windows, etc).

+      enter: '$nameFromNode $role $description'
     },
     alert: {
       speak: '!doNotInterrupt $role $descendants'
     },
     alertDialog: {
       enter: '$nameFromNode $role $description',
       speak: '$name $role $descendants'
     },
     cell: {
-      enter: '@column_granularity $tableCellColumnIndex'
+      enter: '@cell_summary($tableCellRowIndex, $tableCellColumnIndex) ' +
+          '$node(tableColumnHeader)',
+      speak: '@cell_summary($tableCellRowIndex, $tableCellColumnIndex) ' +
+          '$node(tableColumnHeader)'
     },
     checkBox: {
       speak: '$if($checked, $earcon(CHECK_ON), $earcon(CHECK_OFF)) ' +
              '$name $role $checked $description'
     },
     dialog: {
       enter: '$nameFromNode $role $description'
     },
     div: {
       enter: '$nameFromNode',
@@ skipping 71 matching lines @@
       enter: '$name $role $description'
     },
     rootWebArea: {
       enter: '$name',
       speak: '$if($name, $name, $docUrl)'
     },
     region: {
       speak: '$descendants'
     },
     row: {
-      enter: '@row_granularity $tableRowIndex'
+      enter: '$node(tableRowHeader)'
+    },
+    rowHeader: {
+      speak: '$descendants'
     },
     slider: {
       speak: '$earcon(SLIDER) @describe_slider($value, $name) $description'
     },
     staticText: {
       speak: '$name='
     },
     tab: {
       speak: '@describe_tab($name)'
     },
+    table: {
+      enter: '@table_summary($name, $tableRowCount, $tableColumnCount) ' +
+          '$node(tableHeader)'
+    },
+    tableHeaderContainer: {
+      speak: '$descendants'
+    },
     textField: {
       speak: '$name $value $if($multiline, @tag_textarea, $if(' +
           '$inputType, $inputType, $role)) $description',
       braille: ''
     },
     toggleButton: {
       speak: '$if($pressed, $earcon(CHECK_ON), $earcon(CHECK_OFF)) ' +
              '$name $role $pressed $description'
     },
     toolbar: {
@@ skipping 261 matching lines @@
    * Output a string literal.
    * @param {string} value
    * @return {!Output}
    */
   withString: function(value) {
     this.append_(this.speechBuffer_, value);
     this.append_(this.brailleBuffer_, value);
     return this;
   },
 
+
+  /**
+   * Outputs formatting nodes after this will contain context first.
+   * @return {!Output}
+   */
+  withContextFirst: function() {
+    this.outputContextFirst_ = true;
+    return this;
+  },
+
   /**
    * Apply a format string directly to the output buffer. This lets you
    * output a message directly to the buffer using the format syntax.
    * @param {string} formatStr
    * @param {!AutomationNode=} opt_node An optional node to apply the
    *     formatting to.
    * @return {!Output} |this| for chaining
    */
   format: function(formatStr, opt_node) {
     return this
@@ skipping 307 matching lines @@
           this.append_(buff, msg, options);
         } else if (token == 'inputType') {
           if (!node.inputType)
             return;
           options.annotation.push(token);
           var msgId = Output.INPUT_TYPE_MESSAGE_IDS_[node.inputType] ||
               'input_type_text';
           if (this.formatOptions_.braille)
             msgId = msgId + '_brl';
           this.append_(buff, Msgs.getMsg(msgId), options);
-        } else if (token == 'tableRowIndex' ||
+        } else if (token == 'tableCellRowIndex' ||
             token == 'tableCellColumnIndex') {
           var value = node[token];
-          if (!value)
+          if (value == undefined)
             return;
           value = String(value + 1);
           options.annotation.push(token);
           this.append_(buff, value, options);
+        } else if (token == 'node') {
+          if (!tree.firstChild || !node[tree.firstChild.value])
+            return;
+          var related = node[tree.firstChild.value];
+          this.node_(related, related, Output.EventType.NAVIGATE, buff);
         } else if (node[token] !== undefined) {
           options.annotation.push(token);
           var value = node[token];
           if (typeof value == 'number')
             value = String(value);
           this.append_(buff, value, options);
         } else if (Output.STATE_INFO_[token]) {
           options.annotation.push('state');
           var stateInfo = Output.STATE_INFO_[token];
           var resolvedInfo = {};
@@ skipping 139 matching lines @@
     if (!range.start.node || !range.end.node)
       return;
 
     if (!prevRange && range.start.node.root)
       prevRange = cursors.Range.fromNode(range.start.node.root);
     var cursor = cursors.Cursor.fromNode(range.start.node);
     var prevNode = prevRange.start.node;
 
     var formatNodeAndAncestors = function(node, prevNode) {
       var buff = [];
-      var outputContextFirst = localStorage['outputContextFirst'] == 'true';
-      if (outputContextFirst)
+
+      if (this.outputContextFirst_)
         this.ancestry_(node, prevNode, type, buff);
       this.node_(node, prevNode, type, buff);
-      if (!outputContextFirst)
+      if (!this.outputContextFirst_)
         this.ancestry_(node, prevNode, type, buff);
       if (node.location)
         this.locations_.push(node.location);
       return buff;
     }.bind(this);
 
     while (cursor.node != range.end.node) {
       var node = cursor.node;
       rangeBuff.push.apply(rangeBuff, formatNodeAndAncestors(node, prevNode));
       prevNode = node;
@@ skipping 123 matching lines @@
       var selStart = node.textSelStart;
       var selEnd = node.textSelEnd;
       if (selStart !== undefined &&
           (selEnd >= startIndex && selStart <= endIndex)) {
         options.annotation.push(new Output.SelectionSpan(
             selStart - startIndex,
             selEnd - startIndex,
             startIndex));
       }
     }
-    var outputContextFirst = localStorage['outputContextFirst'] == 'true';
-    if (outputContextFirst)
+
+    if (this.outputContextFirst_)
       this.ancestry_(node, prevNode, type, buff);
     var earcon = this.findEarcon_(node, prevNode);
     if (earcon)
       options.annotation.push(earcon);
     this.append_(buff, range.start.getText().substring(startIndex, endIndex),
         options);
-    if (!outputContextFirst)
+    if (!this.outputContextFirst_)
       this.ancestry_(node, prevNode, type, buff);
 
     var loc =
         range.start.node.boundsForRange(startIndex, endIndex);
     if (loc)
       this.locations_.push(loc);
   },
 
   /**
    * Appends output to the |buff|.
@@ skipping 173 matching lines @@
           break;
         }
         earconFinder = earconFinder.parent;
       }
     }
     return null;
   }
 };
 
 });  // goog.scope