add support for rich text selections

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 197 matching lines @@
  * A |ChromeVoxEditableTextBase| that implements text editing feedback
  * for automation tree text fields using anchor and focus selection.
  * @constructor
  * @param {!AutomationNode} node
  * @extends {AutomationEditableText}
  */
 function AutomationRichEditableText(node) {
   AutomationEditableText.call(this, node);
 
   var root = this.node_.root;
-  if (!root || !root.anchorObject || !root.focusObject)
+  if (!root || !root.anchorObject || !root.focusObject ||
+      root.anchorOffset === undefined || root.focusOffset === undefined)
     return;
 
-  this.line_ = new editing.EditableLine(
-      root.anchorObject, root.anchorOffset, root.focusObject, root.focusOffset);
+  this.anchorLine_ = new editing.EditableLine(
+      root.anchorObject, root.anchorOffset, root.anchorObject,
+      root.anchorOffset);
+  this.focusLine_ = new editing.EditableLine(
+      root.focusObject, root.focusOffset, root.focusObject, root.focusOffset);
 }
 
 AutomationRichEditableText.prototype = {
   __proto__: AutomationEditableText.prototype,
 
   /** @override */
   onUpdate: function() {
     var root = this.node_.root;
-    if (!root.anchorObject || !root.focusObject)
+    if (!root.anchorObject || !root.focusObject ||
+        root.anchorOffset === undefined || root.focusOffset === undefined)
       return;
 
+    var anchorLine = new editing.EditableLine(
+        root.anchorObject, root.anchorOffset, root.anchorObject,
+        root.anchorOffset);
+    var focusLine = new editing.EditableLine(
+        root.focusObject, root.focusOffset, root.focusObject, root.focusOffset);
+
+    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.equalsStrict(focusLine);
+
     var cur = new editing.EditableLine(
-        root.anchorObject, root.anchorOffset || 0, root.focusObject,
-        root.focusOffset || 0);
+        root.anchorObject, root.anchorOffset, root.focusObject,
+        root.focusOffset, baseLineOnStart);
     var prev = this.line_;
     this.line_ = cur;
 
-    if (prev.equals(cur)) {
-      // Collapsed cursor.
+    // Selection stayed within the same line(s) and didn't cross into new lines.
+    if (anchorLine.equals(prevAnchorLine) && focusLine.equals(prevFocusLine)) {
+      // Intra-line changes.
       this.changed(new cvox.TextChangeEvent(
-          cur.text || '', cur.startOffset || 0, cur.endOffset || 0, true));
+          cur.text || '', cur.startOffset, cur.endOffset, true));
       this.brailleCurrentRichLine_();
 
       // Finally, queue up any text markers/styles at bounds.
       var container = cur.startContainer_;
       if (!container)
         return;
 
       if (container.markerTypes) {
         // Only consider markers that start or end at the selection bounds.
         var markerStartIndex = -1, markerEndIndex = -1;
@@ skipping 22 matching lines @@
 
       // Start of the container.
       if (cur.containerStartOffset == cur.startOffset)
         this.speakTextStyle_(container);
       else if (cur.containerEndOffset == cur.endOffset)
         this.speakTextStyle_(container, true);
 
       return;
     }
 
-    // Just output the current line.
-    cvox.ChromeVox.tts.speak(cur.text, cvox.QueueMode.CATEGORY_FLUSH);
-    this.brailleCurrentRichLine_();
+    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 {
+      // 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.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 135 matching lines @@
 };
 
 /**
  * @private {ChromeVoxStateObserver}
  */
 editing.observer_ = new editing.EditingChromeVoxStateObserver();
 
 /**
  * An EditableLine encapsulates all data concerning a line in the automation
  * tree necessary to provide output.
+ * Editable: an editable selection (e.g. start/end offsets) get saved.
+ * Line: nodes/offsets at the beginning/end of a line get saved.
+ * @param {!AutomationNode} startNode
+ * @param {number} startIndex
+ * @param {!AutomationNode} endNode
+ * @param {number} endIndex
+ * @param {boolean=} opt_baseLineOnStart Controls whether to use anchor or
+ * focus for Line computations as described above. Selections are automatically
+ * truncated up to either the line start or end.
  * @constructor
  */
-editing.EditableLine = function(startNode, startIndex, endNode, endIndex) {
+editing.EditableLine = function(
+    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;
 
   // Computed members.
   /** @private {Spannable} */
   this.value_;
   /** @private {AutomationNode} */
   this.lineStart_;
   /** @private {AutomationNode} */
   this.lineEnd_;
   /** @private {AutomationNode|undefined} */
   this.startContainer_;
   /** @private {AutomationNode|undefined} */
   this.lineStartContainer_;
   /** @private {number} */
   this.localLineStartContainerOffset_ = 0;
+  /** @private {AutomationNode|undefined} */
+  this.lineEndContainer_;
+  /** @private {number} */
+  this.localLineEndContainerOffset_ = 0;
 
-  this.computeLineData_();
+  this.computeLineData_(opt_baseLineOnStart);
 };
 
 editing.EditableLine.prototype = {
   /** @private */
-  computeLineData_: function() {
+  computeLineData_: function(opt_baseLineOnStart) {
+    // Note that we calculate the line based only upon anchor or focus even if
+    // they do not fall on the same line. It is up to the caller to specify
+    // which end to base this line upon since it requires reasoning about two
+    // lines.
     var nameLen = 0;
-    if (this.start_.node.name)
-      nameLen = this.start_.node.name.length;
+    var lineBase = opt_baseLineOnStart ? this.start_ : this.end_;
+    var lineExtend = opt_baseLineOnStart ? this.end_ : this.start_;
 
-    this.value_ = new Spannable(this.start_.node.name || '', this.start_);
-    if (this.start_.node == this.end_.node)
-      this.value_.setSpan(this.end_, 0, nameLen);
+    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);
 
     // Initialize defaults.
-    this.lineStart_ = this.start_.node;
+    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, this.lineStart_.name.length);
+    this.value_.setSpan(this.lineStart_, 0, nameLen);
 
     // If the current selection is not on an inline text box (e.g. an image),
     // return early here so that the line contents are just the node. This is
     // pending the ability to show non-text leaf inline objects.
     if (this.lineStart_.role != RoleType.INLINE_TEXT_BOX)
       return;
 
     // Also, track their static text parents.
     var parents = [this.startContainer_];
 
@@ skipping 23 matching lines @@
       this.lineEnd_ = lineEnd;
       if (parents[parents.length - 1] != lineEnd.parent)
         parents.push(this.lineEnd_.parent);
 
       var annotation = lineEnd;
       if (lineEnd == this.end_.node)
         annotation = this.end_;
 
       this.value_.append(new Spannable(lineEnd.name, annotation));
     }
+    this.lineEndContainer_ = this.lineEnd_.parent;
 
     // Finally, annotate with all parent static texts as NodeSpan's so that
     // braille routing can key properly into the node with an offset.
     // Note that both line start and end needs to account for
     // potential offsets into the static texts as follows.
     var textCountBeforeLineStart = 0, textCountAfterLineEnd = 0;
     var finder = this.lineStart_;
     while (finder.previousSibling) {
       finder = finder.previousSibling;
       textCountBeforeLineStart += finder.name.length;
     }
     this.localLineStartContainerOffset_ = textCountBeforeLineStart;
 
     finder = this.lineEnd_;
     while (finder.nextSibling) {
       finder = finder.nextSibling;
       textCountAfterLineEnd += finder.name.length;
     }
 
+    if (this.lineEndContainer_.name) {
+      this.localLineEndContainerOffset_ =
+          this.lineEndContainer_.name.length - textCountAfterLineEnd;
+    }
+
     var len = 0;
     for (var i = 0; i < parents.length; i++) {
       var parent = parents[i];
 
       if (!parent.name)
         continue;
 
       var prevLen = len;
 
       var currentLen = parent.name.length;
@@ skipping 20 matching lines @@
       } catch (e) {
       }
     }
   },
 
   /**
    * Gets the selection offset based on the text content of this line.
    * @return {number}
    */
   get startOffset() {
-    return this.value_.getSpanStart(this.start_) + this.start_.index;
+    // It is possible that the start cursor points to content before this line
+    // (e.g. in a multi-line selection).
+    try {
+      return this.value_.getSpanStart(this.start_) + this.start_.index;
+    } catch (e) {
+      // When that happens, fall back to the start of this line.
+      return 0;
+    }
   },
 
   /**
    * Gets the selection offset based on the text content of this line.
    * @return {number}
    */
   get endOffset() {
-    return this.value_.getSpanStart(this.end_) + this.end_.index;
+    try {
+      return this.value_.getSpanStart(this.end_) + this.end_.index;
+    } catch (e) {
+      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;
   },
@@ skipping 27 matching lines @@
 
   /**
    * The text content of this line.
    * @return {string} The text of this line.
    */
   get text() {
     return this.value_.toString();
   },
 
   /**
+   * Returns true if |otherLine| shares its start position with this line.
+   * @return {boolean}

[dmazzoni, 2017/06/21 06:22:07]

Add @param {editing.EditableLine}, I'm assuming a self-reference is allowed

[David Tseng, 2017/06/21 16:58:28]

Acknowledged and done elsewhere for isSameLine and isSameLineAndSelection
(I renamed those for clarity as requested; not seeing those comments now that
were in email only).

+   */
+  equalsStart: function(otherLine) {

[dmazzoni, 2017/06/21 06:22:08]

how about hasSameStart?

[David Tseng, 2017/06/21 16:58:28]

Start is really overloaded in all of the editing code; it would be more like
hasSameLineStart or something.

I removed the two methods to reduce the complexity of the public interface.

+    return otherLine.lineStartContainer_ == this.lineStartContainer_ &&
+        otherLine.localLineStartContainerOffset_ ==
+        this.localLineStartContainerOffset_;
+  },
+
+  /**
+   * Returns true if |otherLine| shares its end position with this line.
+   * @return {boolean}
+   */
+  equalsEnd: function(otherLine) {
+    return otherLine.lineEndContainer_ == this.lineEndContainer_ &&
+        otherLine.localLineEndContainerOffset_ ==
+        this.localLineEndContainerOffset_;
+  },
+
+  /**
    * Returns true if |otherLine| surrounds the same line as |this|. Note that
    * the contents of the line might be different.
    * @return {boolean}
    */
   equals: function(otherLine) {

[dmazzoni, 2017/06/21 06:22:07]

I think it'd be more clear to rename equalsStrict to equals, and call this
something like
spansSameLines or something like that

     // Equality is intentionally loose here as any of the state nodes can be
     // invalidated at any time. We rely upon the start/anchor of the line
     // staying the same.
-    return otherLine.lineStartContainer_ == this.lineStartContainer_ &&
-        otherLine.localLineStartContainerOffset_ ==
-        this.localLineStartContainerOffset_;
+    return this.equalsStart(otherLine) || this.equalsEnd(otherLine);
+  },
+
+  /**
+   * Returns true if |otherLine| surrounds the same line as |this| and has the
+   * same selection.
+   * @return {boolean}
+   */
+  equalsStrict: function(otherLine) {
+    return this.equals(otherLine) &&
+        this.startOffset == otherLine.startOffset &&
+        this.endOffset == otherLine.endOffset;
   }
 };
 
 });