Split spoken feedback up on a per format rule basis.

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 75 matching lines @@
     msgId: 'aria_role_alert',
     earcon: 'ALERT_NONMODAL',
   },
   button: {
     msgId: 'tag_button',
     earcon: 'BUTTON'
   },
   checkbox: {
     msgId: 'input_type_checkbox'
   },
+  dialog: {
+    msgId: 'dialog'
+  },
   heading: {
     msgId: 'aria_role_heading',
   },
   link: {
     msgId: 'tag_link',
     earcon: 'LINK'
   },
   listItem: {
     msgId: 'ARIA_ROLE_LISTITEM',
     earcon: 'list_item'
@@ skipping 97 matching lines @@
     toolbar: {
       enter: '$name $role'
     },
     window: {
       enter: '$name',
       speak: '@describe_window($name) $earcon(OBJECT_OPEN)'
     }
   },
   menuStart: {
     'default': {
-      speak: '@chrome_menu_opened($name) $role $earcon(OBJECT_OPEN)'
+      speak: '@chrome_menu_opened($name) $earcon(OBJECT_OPEN)'
     }
   },
   menuEnd: {
     'default': {
       speak: '$earcon(OBJECT_CLOSE)'
     }
   },
   menuListValueChanged: {
     'default': {
       speak: '$value $name ' +
@@ skipping 27 matching lines @@
   this.action_ = action;
 };
 
 Output.Action.prototype = {
   run: function() {
     this.action_();
   }
 };
 
 /**
+ * Annotation for string splitting.
+ * @constructor
+ */
+Output.StringSplit = function() {};
+
+/**
  * Annotation for selection.
  * @param {number} startIndex
  * @param {number} endIndex
  * @constructor
  */
 Output.SelectionSpan = function(startIndex, endIndex) {
   // TODO(dtseng): Direction lost below; should preserve for braille panning.
   this.startIndex = startIndex < endIndex ? startIndex : endIndex;
   this.endIndex = endIndex > startIndex ? endIndex : startIndex;
 };
@@ skipping 72 matching lines @@
     return this;
   },
 
   /**
    * Executes all specified output.
    */
   go: function() {
     // Speech.
     var buff = this.buffer_;
     if (buff.toString()) {
-      if (this.speechStartCallback_)
-        this.speechProperties_['startCallback'] = this.speechStartCallback_;
-      if (this.speechEndCallback_) {
-        this.speechProperties_['endCallback'] = this.speechEndCallback_;
+      var splits =
+          buff.getSpansInstanceOf(Output.StringSplit).map(function(split) {
+            return buff.getSpanStart(split);
+      });
+
+      if (splits.length == 0) {
+        cvox.ChromeVox.tts.speak(buff.toString(),
+                                 cvox.QueueMode.FLUSH, this.speechProperties_);
+      } else {
+        var start = -1;
+        var seen = {};
+        splits = splits.filter(function(i) {

[Peter Lundblad, 2015/03/30 15:27:46]

When are we going to have duplicates here?

+          if (seen[i])
+            return false;
+          seen[i] = true;
+          return true;
+        });
+        var queueMode = cvox.QueueMode.FLUSH;
+        do {
+          start++;
+          if (this.speechStartCallback_ && start == 0)
+            this.speechProperties_['startCallback'] = this.speechStartCallback_;
+          else
+            this.speechProperties_['startCallback'] = null;
+          if (this.speechEndCallback_ && start == splits.length - 1)
+            this.speechProperties_['endCallback'] = this.speechEndCallback_;
+          else
+            this.speechProperties_['endCallback'] = null;
+          var startIndex = splits[start];
+          var endIndex = splits[start + 1] || buff.getLength();
+
+          cvox.ChromeVox.tts.speak(buff.substring(startIndex,
+              endIndex).toString(), queueMode, this.speechProperties_);
+          queueMode = cvox.QueueMode.QUEUE;
+        } while (start < splits.length - 1);
       }
-
-      cvox.ChromeVox.tts.speak(
-          buff.toString(), cvox.QueueMode.FLUSH, this.speechProperties_);
     }
 
     var actions = buff.getSpansInstanceOf(Output.Action);
     if (actions) {
       actions.forEach(function(a) {
         a.run();
       });
     }
 
     // Braille.
@@ skipping 58 matching lines @@
 
     // Hacky way to support args.
     if (typeof(format) == 'string') {
       format = format.replace(/([,:])\W/g, '$1');
       tokens = format.split(' ');
     } else {
       tokens = [format];
     }
 
     tokens.forEach(function(token) {
+      // Always split at the beginning of each token for speech.
+      var splitOptions = {};
+      splitOptions.annotation = new Output.StringSplit();
+      this.addToSpannable_(buff, new cvox.Spannable(), splitOptions);
+
       // Ignore empty tokens.
       if (!token)
         return;
 
       // Parse the token.
       var tree;
       if (typeof(token) == 'string')
         tree = this.createParseTree(token);
       else
         tree = token;
@@ skipping 166 matching lines @@
     }.bind(this);
 
     while (cursor.getNode() != range.getEnd().getNode()) {
       var node = cursor.getNode();
       this.addToSpannable_(
           rangeBuff, formatNodeAndAncestors(node, prevNode));
       prevNode = node;
       cursor = cursor.move(cursors.Unit.NODE,
                            cursors.Movement.DIRECTIONAL,
                            Dir.FORWARD);
+      var options = {};
+      options.annotation = new Output.StringSplit();
+      this.addToSpannable_(rangeBuff, new cvox.Spannable(), options);
     }
     var lastNode = range.getEnd().getNode();
     this.addToSpannable_(rangeBuff, formatNodeAndAncestors(lastNode, prevNode));
   },
 
   /**
    * @param {!chrome.automation.AutomationNode} node
    * @param {!chrome.automation.AutomationNode} prevNode
    * @param {chrome.automation.EventType|string} type
    * @param {!cvox.Spannable} buff
@@ skipping 85 matching lines @@
     if (startIndex === endIndex)
       endIndex++;
     this.addToSpannable_(
         buff, range.getStart().getText().substring(startIndex, endIndex));
   },
 
   /**
    * Adds to the given buffer with proper delimiters added.
    * @param {!cvox.Spannable} spannable
    * @param {string|!cvox.Spannable} value
-   * @param {{ifEmpty: boolean,
-   *      annotation: (string|Output.Action|undefined)}=} opt_options
+   * @param {{ifEmpty: (boolean|undefined),
+   *      annotation: *}=} opt_options
    */
   addToSpannable_: function(spannable, value, opt_options) {
     opt_options = opt_options || {ifEmpty: false, annotation: undefined};
     if ((!value || value.length == 0) && !opt_options.annotation)
       return;
 
     var spannableToAdd = new cvox.Spannable(value, opt_options.annotation);
     if (spannable.getLength() == 0) {
       spannable.append(spannableToAdd);
       return;
     }
 
     if (opt_options.ifEmpty &&
         opt_options.annotation &&
         (spannable.getSpanStart(opt_options.annotation) != undefined ||
             spannable.getSpanStart(
                 Output.ATTRIBUTE_ALIAS[opt_options.annotation]) != undefined))
       return;
 
-    var prefixed = new cvox.Spannable(Output.SPACE);
+    // Figure out if we need to add the spacing prefix.
+    var needsPrefix = this.formatOptions_.braille;
+      if (needsPrefix) {

[Peter Lundblad, 2015/03/30 15:27:46]

Indentation.

+        needsPrefix = value instanceof cvox.Spannable ?
+            value.getLength() > 0 : value.length > 0;
+    }
+    var prefixed = new cvox.Spannable(needsPrefix ? Output.SPACE : '');
     prefixed.append(spannableToAdd);
     spannable.append(prefixed);
   },
 
   /**
    * Parses the token containing a custom function and returns a tree.
    * @param {string} inputStr
    * @return {Object}
    */
   createParseTree: function(inputStr) {
@@ skipping 25 matching lines @@
     }
 
     if (currentNode != root)
       throw 'Unbalanced parenthesis.';
 
     return root;
   }
 };
 
 });  // goog.scope