Provide complete, smart, spoken feedback for editable selection

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');
@@ skipping 235 matching lines @@
 
     var prevAnchorLine = this.anchorLine_;
     var prevFocusLine = this.focusLine_;
     this.anchorLine_ = anchorLine;
     this.focusLine_ = focusLine;
 
     // Compute the current line based upon whether the current selection was
     // extended from anchor or focus. The default behavior is to compute lines
     // via focus.
     var baseLineOnStart = prevFocusLine.isSameLineAndSelection(focusLine);
+    var isSameSelection =
+        baseLineOnStart && prevAnchorLine.isSameLineAndSelection(anchorLine);
 
-    var cur = new editing.EditableLine(
-        root.anchorObject, root.anchorOffset, root.focusObject,
-        root.focusOffset, baseLineOnStart);
+    var cur;
+    if (isSameSelection && this.line_) {
+      // Nothing changed, return.
+      return;
+    } else {
+      cur = new editing.EditableLine(
+          root.anchorObject, root.anchorOffset, root.focusObject,
+          root.focusOffset, baseLineOnStart);
+    }
     var prev = this.line_;
     this.line_ = cur;
 
     // Selection stayed within the same line(s) and didn't cross into new lines.
     if (anchorLine.isSameLine(prevAnchorLine) &&
         focusLine.isSameLine(prevFocusLine)) {
       // Intra-line changes.
       this.changed(new cvox.TextChangeEvent(
           cur.text || '', cur.startOffset, cur.endOffset, true));
       this.brailleCurrentRichLine_();
@@ skipping 40 matching lines @@
 
     if (cur.text == '') {
       // This line has no text content. Describe the DOM selection.
       new Output()
           .withRichSpeechAndBraille(
               new Range(cur.start_, cur.end_),
               new Range(prev.start_, prev.end_), Output.EventType.NAVIGATE)
           .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);
+
+      // Speech requires many more states than braille.
+      // Note that base and extend are used here rather than anchor

[dmazzoni, 2017/07/06 21:47:01]

We should use terminology correctly. Currently Blink
is exposing the selection start and end, but that's a bug.
This change fixes it so that it really exposes the focus
and anchor, as advertised:

https://chromium-review.googlesource.com/c/562645/

Inside Blink code, base and extent (not extend) are
the same as focus and anchor. I don't think we need to
invent different names here, we should just fix the
underlying bug and then use focus and anchor consistently.

[David Tseng, 2017/07/06 22:01:36]

I agree but would also like to land this and the dependent Docs change. I've
renamed the extend -> extent and added a TODO.

Note that this class already tries to detect the anchor (as you've correctly
defined) above so it requires another change at least anyway to clean up.

+      // and focus as concepts because anchor and focus are absolute
+      // while base and extend are relative.
+      var curBase = baseLineOnStart ? focusLine : anchorLine;
+      var curExtend = baseLineOnStart ? anchorLine : focusLine;
+      var text = '';
+      var suffixMsg = '';
+      if (curBase.isBeforeLine(curExtend)) {
+        // Forward selection.
+        if (prev.isBeforeLine(curBase)) {
+          // Wrapped across the baseline. Read out the new selection.
+          suffixMsg = 'selected';
+          text = this.getTextSelection_(
+              curBase.startContainer_, curBase.localStartOffset,
+              curExtend.endContainer_, curExtend.localEndOffset);
+        } else {
+          if (prev.isBeforeLine(curExtend)) {
+            // Grew.
+            suffixMsg = 'selected';
+            text = this.getTextSelection_(
+                prev.endContainer_, prev.localEndOffset,
+                curExtend.endContainer_, curExtend.localEndOffset);
+          } else {
+            // Shrank.
+            suffixMsg = 'unselected';
+            text = this.getTextSelection_(
+                curExtend.endContainer_, curExtend.localEndOffset,
+                prev.endContainer_, prev.localEndOffset);
+          }
+        }
+      } else {
+        // Backward selection.
+        if (curBase.isBeforeLine(prev)) {
+          // Wrapped across the baseline. Read out the new selection.
+          suffixMsg = 'selected';
+          text = this.getTextSelection_(
+              curExtend.startContainer_, curExtend.localStartOffset,
+              curBase.endContainer_, curBase.localEndOffset);
+        } else {
+          if (curExtend.isBeforeLine(prev)) {
+            // Grew.
+            suffixMsg = 'selected';
+            text = this.getTextSelection_(
+                curExtend.startContainer_, curExtend.localStartOffset,
+                prev.startContainer_, prev.localStartOffset);
+          } else {
+            // Shrank.
+            suffixMsg = 'unselected';
+            text = this.getTextSelection_(
+                prev.startContainer_, prev.localStartOffset,
+                curExtend.startContainer_, curExtend.localStartOffset);
+          }
+        }
+      }
+
+      cvox.ChromeVox.tts.speak(text, cvox.QueueMode.CATEGORY_FLUSH);
+      cvox.ChromeVox.tts.speak(Msgs.getMsg(suffixMsg), 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.
       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;
   },
 
   /**
+   * @param {AutomationNode|undefined} startNode
+   * @param {number} startOffset
+   * @param {AutomationNode|undefined} endNode
+   * @param {number} endOffset
+   * @return {string}
+   */
+  getTextSelection_: function(startNode, startOffset, endNode, endOffset) {
+    if (!startNode || !endNode)
+      return '';
+
+    if (startNode == endNode) {
+      return startNode.name ? startNode.name.substring(startOffset, endOffset) :
+                              '';
+    }
+
+    var text = '';
+    if (startNode.name)
+      text = startNode.name.substring(startOffset);
+
+    for (var node = startNode;
+         (node = AutomationUtil.findNextNode(
+              node, Dir.FORWARD, AutomationPredicate.leafOrStaticText)) &&
+         node != endNode;) {
+      // Padding needs to get added to break up speech utterances.
+      if (node.name)
+        text += ' ' + node.name;
+    }
+
+    if (endNode.name)
+      text += ' ' + endNode.name.substring(0, endOffset);
+    return text;
+  },
+
+  /**
    * @param {number} markerType
    * @param {boolean=} opt_end
    * @private
    */
   speakTextMarker_: function(markerType, opt_end) {
     // TODO(dtseng): Plumb through constants to automation.
     var msgs = [];
     if (markerType & 1)
       msgs.push(opt_end ? 'misspelling_end' : 'misspelling_start');
     if (markerType & 2)
@@ skipping 186 matching lines @@
     startNode, startIndex, endNode, endIndex, opt_baseLineOnStart) {
   /** @private {!Cursor} */
   this.start_ = new Cursor(startNode, startIndex);
   this.start_ = this.start_.deepEquivalent || this.start_;
 
   /** @private {!Cursor} */
   this.end_ = new Cursor(endNode, endIndex);
   this.end_ = this.end_.deepEquivalent || this.end_;
   /** @private {number} */
   this.localContainerStartOffset_ = startIndex;
+  /** @private {number} */
+  this.localContainerEndOffset_ = endIndex;
 
   // Computed members.
   /** @private {Spannable} */
   this.value_;
   /** @private {AutomationNode|undefined} */
   this.lineStart_;
   /** @private {AutomationNode|undefined} */
   this.lineEnd_;
   /** @private {AutomationNode|undefined} */
   this.startContainer_;
@@ skipping 20 matching lines @@
     var lineBase = opt_baseLineOnStart ? this.start_ : this.end_;
     var lineExtend = opt_baseLineOnStart ? this.end_ : this.start_;
 
     if (lineBase.node.name)
       nameLen = lineBase.node.name.length;
 
     this.value_ = new Spannable(lineBase.node.name || '', lineBase);
     if (lineBase.node == lineExtend.node)
       this.value_.setSpan(lineExtend, 0, nameLen);
 
+    this.startContainer_ = this.start_.node;
+    if (this.startContainer_.role == RoleType.INLINE_TEXT_BOX)
+      this.startContainer_ = this.startContainer_.parent;
+    this.endContainer_ = this.end_.node;
+    if (this.endContainer_.role == RoleType.INLINE_TEXT_BOX)
+      this.endContainer_ = this.endContainer_.parent;
+
     // Initialize defaults.
     this.lineStart_ = lineBase.node;
     this.lineEnd_ = this.lineStart_;
-    this.startContainer_ = this.lineStart_.parent;
     this.lineStartContainer_ = this.lineStart_.parent;
     this.lineEndContainer_ = this.lineStart_.parent;
 
     // Annotate each chunk with its associated inline text box node.
     this.value_.setSpan(this.lineStart_, 0, nameLen);
 
     // Also, track the nodes necessary for selection (either their parents, in
     // the case of inline text boxes, or the node itself).
     var parents = [this.startContainer_];
 
@@ skipping 132 matching lines @@
       return this.value_.length;
     }
   },
 
   /**
    * Gets the selection offset based on the parent's text.
    * The parent is expected to be static text.
    * @return {number}
    */
   get localStartOffset() {
-    return this.startOffset - this.containerStartOffset;
+    return this.localContainerStartOffset_;
   },
 
   /**
    * Gets the selection offset based on the parent's text.
    * The parent is expected to be static text.
    * @return {number}
    */
   get localEndOffset() {
-    return this.endOffset - this.containerStartOffset;
+    return this.localContainerEndOffset_;
   },
 
   /**
    * Gets the start offset of the container, relative to the line text content.
    * The container refers to the static text parenting the inline text box.
    * @return {number}
    */
   get containerStartOffset() {
     return this.value_.getSpanStart(this.startContainer_);
   },
@@ skipping 46 matching lines @@
   /**
    * Returns true if |otherLine| surrounds the same line as |this| and has the
    * same selection.
    * @param {editing.EditableLine} otherLine
    * @return {boolean}
    */
   isSameLineAndSelection: function(otherLine) {
     return this.isSameLine(otherLine) &&
         this.startOffset == otherLine.startOffset &&
         this.endOffset == otherLine.endOffset;
+  },
+
+  /**
+   * Returns whether this line comes before |otherLine| in document order.
+   * @return {boolean}
+   */
+  isBeforeLine: function(otherLine) {
+    if (this.isSameLine(otherLine) || !this.lineStartContainer_ ||
+        !otherLine.lineStartContainer_)
+      return false;
+    return AutomationUtil.getDirection(
+               this.lineStartContainer_, otherLine.lineStartContainer_) ==
+        Dir.FORWARD;
   }
 };
 
 });