Complete live region 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 46 matching lines @@
   /** @type {!Array<!Spannable>} */
   this.brailleBuffer_ = [];
   /** @type {!Array<!Object>} */
   this.locations_ = [];
   /** @type {function(?)} */
   this.speechEndCallback_;
 
   /**
    * Current global options.
    * @type {{speech: boolean, braille: boolean}}
+   * @private
    */
   this.formatOptions_ = {speech: true, braille: false};
 
   /**
    * Speech properties to apply to the entire output.
    * @type {!Object<*>}
+   * @private
    */
   this.speechProperties_ = {};
+
+  /**
+   * The speech category for the generated speech utterance.
+   * @type {cvox.TtsCategory}
+   * @private
+   */
+  this.speechCategory_ = cvox.TtsCategory.NAV;
+
+  /**
+   * The speech queue mode for the generated speech utterance.
+   * @type {cvox.QueueMode}
+   * @private
+   */
+  this.queueMode_ = cvox.QueueMode.QUEUE;
 };
 
 /**
  * Delimiter to use between output values.
  * @type {string}
  */
 Output.SPACE = ' ';
 
 /**
  * Metadata about supported automation roles.
@@ skipping 495 matching lines @@
 };
 
 /**
  * Possible events handled by ChromeVox internally.
  * @enum {string}
  */
 Output.EventType = {
   NAVIGATE: 'navigate'
 };
 
+/**
+ * If true, the next speech utterance will flush instead of the normal
+ * queueing mode.
+ * @type {boolean}
+ * @private
+ */
+Output.flushNextSpeechUtterance_ = false;
+
+/**
+ * Calling this will make the next speech utterance flush even if it would
+ * normally queue or do a category flush.
+ */
+Output.flushNextSpeechUtterance = function() {
+  Output.flushNextSpeechUtterance_ = true;
+};
+
 Output.prototype = {
   /**
    * Gets the spoken output with separator '|'.
    * @return {!Spannable}
    */
   get speechOutputForTest() {
     return this.speechBuffer_.reduce(function(prev, cur) {
       if (prev === null)
         return cur;
       prev.append('|');
       prev.append(cur);
       return prev;
     }, null);
   },
 
   /**
    * Gets the output buffer for braille.
    * @return {!Spannable}
    */
   get brailleOutputForTest() {
     return this.createBrailleOutput_();
   },
 
   /**
+   * @return {boolean} True if there's any speech that will be output.
+   */
+  get hasSpeech() {
+    for (var i = 0; i < this.speechBuffer_.length; i++) {
+      if (this.speechBuffer_[i].trim().length)
+        return true;
+    }
+    return false;
+  },
+
+  /**
    * Specify ranges for speech.
    * @param {!cursors.Range} range
    * @param {cursors.Range} prevRange
    * @param {chrome.automation.EventType|Output.EventType} type
    * @return {!Output}
    */
   withSpeech: function(range, prevRange, type) {
     this.formatOptions_ = {speech: true, braille: false};
     this.render_(range, prevRange, type, this.speechBuffer_);
     return this;
@@ skipping 37 matching lines @@
     this.withBraille(range, prevRange, type);
     return this;
   },
 
   /**
    * Applies the given speech category to the output.
    * @param {cvox.TtsCategory} category
    * @return {!Output}
    */
   withSpeechCategory: function(category) {
-    this.speechProperties_['category'] = category;
+    this.speechCategory_ = category;
     return this;
   },
 
+  /**
+   * Applies the given speech queue mode to the output.
+   * @param {cvox.QueueMode} queueMode The queueMode for the speech.
+   * @return {!Output}
+   */
+  withQueueMode: function(queueMode) {
+    this.queueMode_ = queueMode;
+    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 {!chrome.automation.AutomationNode=} opt_node An optional
+   *     node to apply the formatting to.
    * @return {!Output}
    */
-  format: function(formatStr) {
+  format: function(formatStr, opt_node) {
+    var node = opt_node || null;
+
     this.formatOptions_ = {speech: true, braille: false};
-    this.format_(null, formatStr, this.speechBuffer_);
+    this.format_(node, formatStr, this.speechBuffer_);
 
     this.formatOptions_ = {speech: false, braille: true};
-    this.format_(null, formatStr, this.brailleBuffer_);
+    this.format_(node, formatStr, this.brailleBuffer_);
 
     return this;
   },
 
   /**
    * Triggers callback for a speech event.
    * @param {function()} callback
    */
   onSpeechEnd: function(callback) {
     this.speechEndCallback_ = function(opt_cleanupOnly) {
       if (!opt_cleanupOnly)
         callback();
     }.bind(this);
     return this;
   },
 
   /**
    * Executes all specified output.
    */
   go: function() {
     // Speech.
-    var queueMode = this.speechProperties_['category'] ?
-        cvox.QueueMode.CATEGORY_FLUSH : cvox.QueueMode.FLUSH;
+    var queueMode = this.queueMode_;
+    if (Output.flushNextSpeechUtterance_) {
+      queueMode = cvox.QueueMode.FLUSH;
+      Output.flushNextSpeechUtterance_ = false;
+    }
+
+    this.speechProperties_.category = this.speechCategory_;
+
     this.speechBuffer_.forEach(function(buff, i, a) {
       (function() {
         var scopedBuff = buff;
         this.speechProperties_['startCallback'] = function() {
           var actions = scopedBuff.getSpansInstanceOf(Output.Action);
           if (actions) {
             actions.forEach(function(a) {
               a.run();
             });
           }
@@ skipping 27 matching lines @@
       var output = new cvox.NavBraille({
         text: buff,
         startIndex: startIndex,
         endIndex: endIndex
       });
 
       cvox.ChromeVox.braille.write(output);
     }
 
     // Display.
-    if (cvox.ChromeVox.isChromeOS)
+    if (cvox.ChromeVox.isChromeOS &&
+        this.speechCategory_ != cvox.TtsCategory.LIVE) {
       chrome.accessibilityPrivate.setFocusRing(this.locations_);
+    }
   },
 
   /**
    * Renders the given range using optional context previous range and event
    * type.
    * @param {!cursors.Range} range
    * @param {cursors.Range} prevRange
    * @param {chrome.automation.EventType|string} type
    * @param {!Array<Spannable>} buff Buffer to receive rendered output.
    * @private
@@ skipping 568 matching lines @@
             elem.end);
       });
       spansToRemove.forEach(result.removeSpan.bind(result));
       separator = Output.SPACE;
     });
     return result;
   }
 };
 
 });  // goog.scope