Support rich line output in both speech and braille

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

 // Copyright 2015 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 Processes events related to editing text and emits the
  * appropriate spoken and braille feedback.
  */
 
 goog.provide('editing.TextEditHandler');
 
 goog.require('AutomationTreeWalker');
 goog.require('AutomationUtil');
 goog.require('Output');
 goog.require('Output.EventType');
 goog.require('cursors.Cursor');
 goog.require('cursors.Range');
 goog.require('cvox.BrailleBackground');
 goog.require('cvox.ChromeVoxEditableTextBase');
+goog.require('cvox.LibLouis.FormType');
 
 goog.scope(function() {
 var AutomationEvent = chrome.automation.AutomationEvent;
 var AutomationNode = chrome.automation.AutomationNode;
 var Cursor = cursors.Cursor;
 var Dir = constants.Dir;
 var EventType = chrome.automation.EventType;
+var FormType = cvox.LibLouis.FormType;
 var Range = cursors.Range;
 var RoleType = chrome.automation.RoleType;
 var StateType = chrome.automation.StateType;
 var Movement = cursors.Movement;
 var Unit = cursors.Unit;
 
 /**
  * A handler for automation events in a focused text field or editable root
  * such as a |contenteditable| subtree.
  * @constructor
@@ skipping 278 matching lines @@
           .go();
     } else if (!cur.hasCollapsedSelection()) {
       // This is a selection.
       cvox.ChromeVox.tts.speak(cur.selectedText, cvox.QueueMode.CATEGORY_FLUSH);
       cvox.ChromeVox.tts.speak(Msgs.getMsg('selected'), cvox.QueueMode.QUEUE);
       this.brailleCurrentRichLine_();
     } else {
       // Describe the current line. This accounts for previous/current
       // selections and picking the line edge boundary that changed (as computed
       // above). This is also the code path for describing paste.
-      cvox.ChromeVox.tts.speak(cur.text, cvox.QueueMode.CATEGORY_FLUSH);
+      this.speakCurrentRichLine_(prev);
       this.brailleCurrentRichLine_();
     }
 
     // The state in EditableTextBase needs to get updated with the new line
     // contents, so that subsequent intra-line changes get the right state
     // transitions.
     this.value = cur.text;
     this.start = cur.startOffset;
     this.end = cur.endOffset;
   },
@@ skipping 42 matching lines @@
 
     if (msgs.length) {
       msgs.forEach(function(msg) {
         cvox.ChromeVox.tts.speak(
             Msgs.getMsg(msg), cvox.QueueMode.QUEUE,
             cvox.AbstractTts.PERSONALITY_ANNOTATION);
       });
     }
   },
 
+  /**
+   * @param {editing.EditableLine} prevLine
+   * @private
+   */
+  speakCurrentRichLine_: function(prevLine) {
+    var prev = prevLine ? prevLine.startContainer_ : this.node_;
+    var lineNodes =
+        this.line_.value_.getSpansInstanceOf(this.node_.constructor);
+    var queueMode = cvox.QueueMode.CATEGORY_FLUSH;
+    for (var i = 0, cur; cur = lineNodes[i]; i++) {
+      if (cur.children.length)
+        continue;
+      new Output()
+          .withRichSpeech(
+              Range.fromNode(cur), Range.fromNode(prev),
+              Output.EventType.NAVIGATE)
+          .withQueueMode(queueMode)
+          .go();
+      prev = cur;
+      queueMode = cvox.QueueMode.QUEUE;
+    }
+  },
+
   /** @private */
   brailleCurrentRichLine_: function() {
     var cur = this.line_;
-    var value = cur.value_;
+    var value = new Spannable(cur.value_);
+    if (!this.node_.constructor)
+      return;
+    value.getSpansInstanceOf(this.node_.constructor).forEach(function(span) {
+      var parent = span.parent;

[dmazzoni, 2017/06/27 21:21:52]

Rather than always checking the parent, I'd only go to the parent
if the current role is inline text box. Then I wouldn't bother
returning if the parent is not static text, because any element
can have a style. For example, it probably makes sense to underline
a whole link, not just the text of a link

[David Tseng, 2017/06/27 23:52:41]

Acknowledged.

+      if (!parent || parent.role != RoleType.STATIC_TEXT)
+        return;
+      var formType = FormType.PLAIN_TEXT;
+      if (parent.bold)
+        formType |= FormType.BOLD;
+      if (parent.italic)
+        formType |= FormType.ITALIC;
+      if (parent.underline)
+        formType |= FormType.UNDERLINE;
+      if (formType == FormType.PLAIN_TEXT)
+        return;
+      var start = value.getSpanStart(span);
+      var end = value.getSpanEnd(span);
+      value.setSpan(new cvox.FormSpan(formType), start, end);
+    });
     value.setSpan(new cvox.ValueSpan(0), 0, cur.value_.length);
     value.setSpan(
         new cvox.ValueSelectionSpan(), cur.startOffset, cur.endOffset);
     cvox.ChromeVox.braille.write(new cvox.NavBraille(
         {text: value, startIndex: cur.startOffset, endIndex: cur.endOffset}));
   },
 
   /** @override */
   describeSelectionChanged: function(evt) {
     // Note that since Chrome allows for selection to be placed immediately at
@@ skipping 364 matching lines @@
    * @return {boolean}
    */
   isSameLineAndSelection: function(otherLine) {
     return this.isSameLine(otherLine) &&
         this.startOffset == otherLine.startOffset &&
         this.endOffset == otherLine.endOffset;
   }
 };
 
 });