Implement rich editable line output

chrome/browser/resources/chromeos/chromevox/cvox2/background/cursors.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 Classes related to cursors that point to and select parts of
  * the automation tree.
  */
 
 goog.provide('cursors.Cursor');
@@ skipping 116 matching lines @@
     while (rNode && (rNode.role == RoleType.INLINE_TEXT_BOX ||
         rNode.role == RoleType.STATIC_TEXT))
       rNode = rNode.parent;
 
     // Ignore indicies for now.
 
     return lNode === rNode && lNode != undefined;
   },
 
   /**
+   * Compares this cursor with |rhs|.
+   * @param {cursors.Cursor} rhs
+   * @return Dir.BACKWARD if |rhs| comes before this cursor in
+   * document order. Forward otherwise.
+   */
+  compare: function(rhs) {
+    if (!this.node || !rhs.node)
+      return Dir.FORWARD;
+
+    if (rhs.node == this.node)
+      return rhs.index < this.index ? Dir.BACKWARD : Dir.FORWARD;
+    return AutomationUtil.getDirection(this.node, rhs.node);
+  },
+
+  /**
    * Returns the node. If the node is invalid since the last time it
    * was accessed, moves the cursor to the nearest valid ancestor first.
    * @return {AutomationNode}
    */
   get node() {
     for (var i = 0; i < this.ancestry_.length; i++) {
       var firstValidNode = this.ancestry_[i];
       if (firstValidNode != null && firstValidNode.role !== undefined &&
           firstValidNode.root != undefined) {
         return firstValidNode;
@@ skipping 210 matching lines @@
           case Movement.DIRECTIONAL:
             var pred = unit == Unit.TEXT ?
                 AutomationPredicate.leaf : AutomationPredicate.object;
             newNode = AutomationUtil.findNextNode(newNode, dir, pred) ||
                 originalNode;
             newIndex = cursors.NODE_INDEX;
             break;
         }
         break;
       case Unit.LINE:
-        newIndex = 0;
+        var deepEquivalent = this.deepEquivalent;
+        newNode = deepEquivalent.node || newNode;
+        newIndex = deepEquivalent.index || 0;
+
         switch (movement) {
           case Movement.BOUND:
             newNode = AutomationUtil.findNodeUntil(newNode, dir,
                 AutomationPredicate.linebreak, true);
             newNode = newNode || originalNode;
             newIndex =
                 dir == Dir.FORWARD ? AutomationUtil.getText(newNode).length : 0;
             break;
           case Movement.DIRECTIONAL:
             newNode = AutomationUtil.findNodeUntil(
                 newNode, dir, AutomationPredicate.linebreak);
             break;
           }
       break;
       default:
         throw Error('Unrecognized unit: ' + unit);
     }
     newNode = newNode || originalNode;
     newIndex = goog.isDef(newIndex) ? newIndex : this.index_;
     return new cursors.Cursor(newNode, newIndex);
   },
 
   /**
+   * Returns the deepest equivalent cursor.
+   * @return {cursors.Cursor}
+   */
+  get deepEquivalent() {
+    var newNode = this.node;
+    var newIndex = this.index_;
+    while (newNode.firstChild) {
+      if (newNode.role == RoleType.STATIC_TEXT) {
+        // Text offset.
+        // Re-interpret the index as an offset into an inlineTextBox.
+        var target = newNode.firstChild;
+        var length = 0;
+        while (target && length < newIndex) {
+          if (length <= newIndex && newIndex < (length + target.name.length))
+            break;
+          length += target.name.length;
+          target = target.nextSibling;
+        }
+        if (target) {
+          newNode = target;
+          newIndex = newIndex - length;
+        }
+        break;
+      } else if (newNode.role != RoleType.INLINE_TEXT_BOX &&
+          newNode.children[newIndex]) {
+        // Valid node offset.
+        newNode = newNode.children[newIndex];
+        newIndex = 0;
+      } else {
+        // Invalid offset.
+        break;
+      }
+    }
+
+    return new cursors.Cursor(newNode, newIndex);
+  },
+
+  /**
    * Returns whether this cursor points to a valid position.
    * @return {boolean}
    */
   isValid: function() {
     return this.node != null;
   }
 };
 
 /**
  * A cursors.Cursor that wraps from beginning to end and vice versa when moved.
@@ skipping 286 matching lines @@
   /**
    * Returns whether this range has valid start and end cursors.
    * @return {boolean}
    */
   isValid: function() {
     return this.start.isValid() && this.end.isValid();
   }
 };
 
 });  // goog.scope