Implements the ability to get and set the caret position and the current selection from anywhere in…

Source/modules/accessibility/AXObject.h

 /*
  * Copyright (C) 2008, 2009, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nuanti Ltd.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 349 matching lines @@
     IgnoredReason(AXIgnoredReason r, const AXObject* obj)
         : reason(r)
         , relatedObject(obj)
     { }
 };
 
 class MODULES_EXPORT AXObject : public RefCounted<AXObject> {
 public:
     typedef Vector<RefPtr<AXObject>> AccessibilityChildrenVector;
 
-    struct PlainTextRange {
+    struct AXRange {
+        // The deepest descendant in which the range starts.
+        // (nullptr means the current object.)
+        RefPtrWillBePersistent<AXObject> anchorObject;
+        // The number of characters and child objects in the anchor object
+        // before the range starts.
+        int anchorOffset;
+        // The deepest descendant in which the range ends.
+        // (nullptr means the current object.)
+        RefPtrWillBePersistent<AXObject> focusObject;
+        // The number of characters and child objects in the focus object
+        // before the range ends.
+        int focusOffset;
 
-        unsigned start;
-        unsigned length;
-
-        PlainTextRange()
-            : start(0)
-            , length(0)
+        AXRange()
+            : anchorObject(nullptr)
+            , anchorOffset(-1)
+            , focusObject(nullptr)
+            , focusOffset(-1)
         { }
 
-        PlainTextRange(unsigned s, unsigned l)
-            : start(s)
-            , length(l)
+        AXRange(int startOffset, int endOffset)
+            : anchorObject(nullptr)
+            , anchorOffset(startOffset)
+            , focusObject(nullptr)
+            , focusOffset(endOffset)
         { }
 
-        bool isNull() const { return !start && !length; }
+        AXRange(PassRefPtrWillBeRawPtr<AXObject> anchorObject, int anchorOffset,
+            PassRefPtrWillBeRawPtr<AXObject> focusObject, int focusOffset)
+            : anchorObject(anchorObject)
+            , anchorOffset(anchorOffset)
+            , focusObject(focusObject)
+            , focusOffset(focusOffset)
+        { }
+
+        bool isNull() const

[dmazzoni, 2015/06/26 06:14:38]

Maybe this should be isValid?

isNull is usually taken to be much more literal, like for a wrapper object like
WebAXObject that has only one member variable and it's a pointer that can be
null. So not a big deal but isValid might be more clear since it checks more
than just null.

+        {
+            return (anchorObject && !focusObject)
+                || (!anchorObject && focusObject)
+                || (anchorOffset < 0 || focusOffset < 0);
+        }
+
+        // Determines if the range only refers to text offsets under the current object.
+        bool isSimple() const
+        {
+            return anchorObject == focusObject || !anchorObject || !focusObject;
+        }
     };
 
 protected:
     AXObject(AXObjectCacheImpl&);
 
 public:
     virtual ~AXObject();
 
     // After constructing an AXObject, it must be given a
     // unique ID, then added to AXObjectCacheImpl, and finally init() must
@@ skipping 196 matching lines @@
 
     // Walk the AXObjects on the same line. This is supported on any
     // object type but primarily intended to be used for inline text boxes.
     virtual AXObject* nextOnLine() const { return nullptr; }
     virtual AXObject* previousOnLine() const { return nullptr; }
 
     // For an inline text box.
     // The integer horizontal pixel offset of each character in the string; negative values for RTL.
     virtual void textCharacterOffsets(Vector<int>&) const { }
     // The start and end character offset of each word in the inline text box.
-    virtual void wordBoundaries(Vector<PlainTextRange>& words) const { }
+    virtual void wordBoundaries(Vector<AXRange>& words) const { }
 
     // Properties of interactive elements.
     virtual String actionVerb() const;
     virtual AccessibilityButtonState checkboxOrRadioValue() const;
     virtual InvalidState invalidState() const { return InvalidStateUndefined; }
     // Only used when invalidState() returns InvalidStateOther.
     virtual String ariaInvalidValue() const { return String(); }
     virtual String valueDescription() const { return String(); }
     virtual float valueForRange() const { return 0.0f; }
     virtual float maxValueForRange() const { return 0.0f; }
@@ skipping 93 matching lines @@
     virtual LayoutObject* layoutObject() const { return 0; }
     virtual Document* document() const;
     virtual FrameView* documentFrameView() const;
     virtual Element* anchorElement() const { return 0; }
     virtual Element* actionElement() const { return 0; }
     virtual Widget* widgetForAttachmentView() const { return 0; }
     String language() const;
     bool hasAttribute(const QualifiedName&) const;
     const AtomicString& getAttribute(const QualifiedName&) const;
 
-    // Selected text.
-    virtual PlainTextRange selectedTextRange() const { return PlainTextRange(); }
+    // Methods that retrieve or manipulate the current selection.
+
+    // Get the current selection from anywhere in the accessibility tree.
+    virtual AXRange selection() const { return AXRange(); }
+    // Gets only the start and end offsets of the selection computed using the
+    // current object as the starting point. Returns a null selection if there is
+    // no selection in the subtree rooted at this object.
+    virtual AXRange selectionUnderObject() const { return AXRange(); }
+    virtual void setSelection(const AXRange&) { }
 
     // Scrollable containers.
     bool isScrollableContainer() const;
     IntPoint scrollOffset() const;
     IntPoint minimumScrollOffset() const;
     IntPoint maximumScrollOffset() const;
     void setScrollOffset(const IntPoint&) const;
 
     // If this object itself scrolls, return its ScrollableArea.
     virtual ScrollableArea* getScrollableAreaIfScrollable() const { return 0; }
 
     // Modify or take an action on an object.
     virtual void increment() { }
     virtual void decrement() { }
     bool performDefaultAction() const { return press(); }
     virtual bool press() const;
     // Make this object visible by scrolling as many nested scrollable views as needed.
     void scrollToMakeVisible() const;
     // Same, but if the whole object can't be made visible, try for this subrect, in local coordinates.
     void scrollToMakeVisibleWithSubFocus(const IntRect&) const;
     // Scroll this object to a given point in global coordinates of the top-level window.
     void scrollToGlobalPoint(const IntPoint&) const;
     virtual void setFocused(bool) { }
     virtual void setSelected(bool) { }
     void setSelectedText(const String&) { }
-    virtual void setSelectedTextRange(const PlainTextRange&) { }
     virtual void setValue(const String&) { }
     virtual void setValue(float) { }
 
     // Notifications that this object may have changed.
     virtual void childrenChanged() { }
     virtual void handleActiveDescendantChanged() { }
     virtual void handleAriaExpandedChanged() { }
     void notifyIfIgnoredValueChanged();
     virtual void selectionChanged();
     virtual void textChanged() { }
@@ skipping 53 matching lines @@
     static bool includesARIAWidgetRole(const String&);
     static bool hasInteractiveARIAAttribute(const Element&);
 };
 
 #define DEFINE_AX_OBJECT_TYPE_CASTS(thisType, predicate) \
     DEFINE_TYPE_CASTS(thisType, AXObject, object, object->predicate, object.predicate)
 
 } // namespace blink
 
 #endif // AXObject_h