Expose InlineTextBoxes in the accessibility tree.

Source/testing/runner/AccessibilityUIElementChromium.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 114 matching lines @@
     case WebAXRoleIgnored:
         return result.append("Ignored");
     case WebAXRoleImageMapLink:
         return result.append("ImageMapLink");
     case WebAXRoleImageMap:
         return result.append("ImageMap");
     case WebAXRoleImage:
         return result.append("Image");
     case WebAXRoleIncrementor:
         return result.append("Incrementor");
+    case WebAXRoleInlineTextBox:
+        return result.append("InlineTextBox");
     case WebAXRoleLabel:
         return result.append("Label");
     case WebAXRoleLegend:
         return result.append("Legend");
     case WebAXRoleLink:
         return result.append("Link");
     case WebAXRoleListBoxOption:
         return result.append("ListBoxOption");
     case WebAXRoleListBox:
         return result.append("ListBox");
@@ skipping 193 matching lines @@
 {
     // FIXME: Concatenate all attributes of the AccessibilityObject.
     string attributes(getTitle(object));
     attributes.append("\n");
     attributes.append(getRole(object));
     attributes.append("\n");
     attributes.append(getDescription(object));
     return attributes;
 }
 
+WebRect boundsForCharacter(const WebAXObject& object, int characterIndex)
+{
+    BLINK_ASSERT(object.role() == WebAXRoleStaticText);
+    int end = 0;
+    for (unsigned i = 0; i < object.childCount(); i++) {
+        WebAXObject child = object.childAt(i);
+        BLINK_ASSERT(child.role() == WebAXRoleInlineTextBox);
+        int start = end;
+        end += child.stringValue().length();
+        if (end <= characterIndex)
+            continue;
+        WebRect childRect = child.boundingBoxRect();
+        int localIndex = characterIndex - start;
+        WebVector<int> characterOffsets;
+        child.characterOffsets(characterOffsets);
+        BLINK_ASSERT(characterOffsets.size() > 0 && characterOffsets.size() == child.stringValue().length());
+        switch (child.textDirection()) {
+        case WebAXTextDirectionLR: {
+            if (localIndex) {
+                int left = childRect.x + characterOffsets[localIndex - 1];
+                int width = characterOffsets[localIndex] - characterOffsets[localIndex - 1];
+                return WebRect(left, childRect.y, width, childRect.height);
+            }
+            return WebRect(childRect.x, childRect.y, characterOffsets[0], childRect.height);
+        }
+        case WebAXTextDirectionRL: {
+            int right = childRect.x + childRect.width;
+
+            if (localIndex) {
+                int left = right - characterOffsets[localIndex];
+                int width = characterOffsets[localIndex] - characterOffsets[localIndex - 1];
+                return WebRect(left, childRect.y, width, childRect.height);
+            }
+            int left = right - characterOffsets[0];
+            return WebRect(left, childRect.y, characterOffsets[0], childRect.height);
+        }
+        case WebAXTextDirectionTB: {
+            if (localIndex) {
+                int top = childRect.y + characterOffsets[localIndex - 1];
+                int height = characterOffsets[localIndex] - characterOffsets[localIndex - 1];
+                return WebRect(childRect.x, top, childRect.width, height);
+            }
+            return WebRect(childRect.x, childRect.y, childRect.width, characterOffsets[0]);
+        }
+        case WebAXTextDirectionBT: {
+            int bottom = childRect.y + childRect.height;
+
+            if (localIndex) {
+                int top = bottom - characterOffsets[localIndex];
+                int height = characterOffsets[localIndex] - characterOffsets[localIndex - 1];
+                return WebRect(childRect.x, top, childRect.width, height);
+            }
+            int top = bottom - characterOffsets[0];
+            return WebRect(childRect.x, top, childRect.width, characterOffsets[0]);
+        }
+        }
+    }
+
+    BLINK_ASSERT(false);
+    return WebRect();
+}
+
+void getWordBoundaries(const WebAXObject& object, int characterIndex, int& wordStart, int& wordEnd)
+{
+    int end = 0;
+    for (unsigned i = 0; i < object.childCount(); i++) {
+        WebAXObject child = object.childAt(i);
+        BLINK_ASSERT(child.role() == WebAXRoleInlineTextBox);
+        int start = end;
+        end += child.stringValue().length();
+        if (end <= characterIndex)
+            continue;
+        int localIndex = characterIndex - start;
+
+        WebVector<int> starts;
+        WebVector<int> ends;
+        child.wordBoundaries(starts, ends);
+        size_t wordCount = starts.size();
+        BLINK_ASSERT(ends.size() == wordCount);
+
+        // If there are no words, use the InlineTextBox boundaries.
+        if (!wordCount) {
+            wordStart = start;
+            wordEnd = end;
+            return;
+        }
+
+        // Look for a character within any word other than the last.
+        for (size_t j = 0; j < wordCount - 1; j++) {
+            if (localIndex <= ends[j]) {
+                wordStart = start + starts[j];
+                wordEnd = start + ends[j];
+                return;
+            }
+        }
+
+        // Return the last word by default.
+        wordStart = start + starts[wordCount - 1];
+        wordEnd = start + ends[wordCount - 1];
+        return;
+    }
+}
 
 // Collects attributes into a string, delimited by dashes. Used by all methods
 // that output lists of attributes: attributesOfLinkedUIElementsCallback,
 // AttributesOfChildrenCallback, etc.
 class AttributesCollector {
 public:
     void collectAttributes(const WebAXObject& object)
     {
         m_attributes.append("\n------------\n");
         m_attributes.append(getAttributes(object));
@@ skipping 93 matching lines @@
     bindMethod("decrement", &AccessibilityUIElement::decrementCallback);
     bindMethod("showMenu", &AccessibilityUIElement::showMenuCallback);
     bindMethod("press", &AccessibilityUIElement::pressCallback);
     bindMethod("isEqual", &AccessibilityUIElement::isEqualCallback);
     bindMethod("addNotificationListener", &AccessibilityUIElement::addNotificationListenerCallback);
     bindMethod("removeNotificationListener", &AccessibilityUIElement::removeNotificationListenerCallback);
     bindMethod("takeFocus", &AccessibilityUIElement::takeFocusCallback);
     bindMethod("scrollToMakeVisible", &AccessibilityUIElement::scrollToMakeVisibleCallback);
     bindMethod("scrollToMakeVisibleWithSubFocus", &AccessibilityUIElement::scrollToMakeVisibleWithSubFocusCallback);
     bindMethod("scrollToGlobalPoint", &AccessibilityUIElement::scrollToGlobalPointCallback);
+    bindMethod("wordStart", &AccessibilityUIElement::wordStartCallback);
+    bindMethod("wordEnd", &AccessibilityUIElement::wordEndCallback);
 
     bindFallbackMethod(&AccessibilityUIElement::fallbackCallback);
 }
 
 AccessibilityUIElement* AccessibilityUIElement::getChildAtIndex(unsigned index)
 {
     return m_factory->getOrCreate(accessibilityObject().childAt(index));
 }
 
 bool AccessibilityUIElement::isEqual(const WebKit::WebAXObject& other)
@@ skipping 269 matching lines @@
 
     WebVector<int> lineBreaks;
     accessibilityObject().lineBreaks(lineBreaks);
     int line = 0;
     int vectorSize = static_cast<int>(lineBreaks.size());
     while (line < vectorSize && lineBreaks[line] <= index)
         line++;
     result->set(line);
 }
 
-void AccessibilityUIElement::boundsForRangeCallback(const CppArgumentList&, CppVariant* result)
+void AccessibilityUIElement::boundsForRangeCallback(const CppArgumentList& arguments, CppVariant* result)
 {
     result->setNull();
+
+    if (arguments.size() != 2 || !arguments[0].isNumber() || !arguments[1].isNumber())
+        return;
+
+    if (accessibilityObject().role() != WebAXRoleStaticText)
+        return;
+
+    int start = arguments[0].toInt32();
+    int end = arguments[1].toInt32();
+    int len = end - start;
+
+    // Get the bounds for each character and union them into one large rectangle.
+    // This is just for testing so it doesn't need to be efficient.
+    WebRect bounds = boundsForCharacter(accessibilityObject(), start);
+    for (int i = 1; i < len; i++) {
+        WebRect next = boundsForCharacter(accessibilityObject(), start + i);
+        int right = std::max(bounds.x + bounds.width, next.x + next.width);
+        int bottom = std::max(bounds.y + bounds.height, next.y + next.height);
+        bounds.x = std::min(bounds.x, next.x);
+        bounds.y = std::min(bounds.y, next.y);
+        bounds.width = right - bounds.x;
+        bounds.height = bottom - bounds.y;
+    }
+
+    char buffer[100];
+    snprintf(buffer, sizeof(buffer), "{x: %d, y: %d, width: %d, height: %d}", bounds.x, bounds.y, bounds.width, bounds.height);
+    result->set(string(buffer));
 }
 
 void AccessibilityUIElement::stringForRangeCallback(const CppArgumentList&, CppVariant* result)
 {
     result->setNull();
 }
 
 void AccessibilityUIElement::childAtIndexCallback(const CppArgumentList& arguments, CppVariant* result)
 {
     if (!arguments.size() || !arguments[0].isNumber()) {
@@ skipping 265 matching lines @@
         || !arguments[1].isNumber())
         return;
 
     int x = arguments[0].toInt32();
     int y = arguments[1].toInt32();
 
     accessibilityObject().scrollToGlobalPoint(WebPoint(x, y));
     result->setNull();
 }
 
+void AccessibilityUIElement::wordStartCallback(const CppArgumentList& arguments, CppVariant* result)
+{
+    result->setNull();
+
+    if (arguments.size() != 1 || !arguments[0].isNumber())
+        return;
+
+    if (accessibilityObject().role() != WebAXRoleStaticText)
+        return;
+
+    int characterIndex = arguments[0].toInt32();
+    int wordStart, wordEnd;
+    getWordBoundaries(accessibilityObject(), characterIndex, wordStart, wordEnd);
+    result->set(wordStart);
+}
+
+void AccessibilityUIElement::wordEndCallback(const CppArgumentList& arguments, CppVariant* result)
+{
+    result->setNull();
+
+    if (arguments.size() != 1 || !arguments[0].isNumber())
+        return;
+
+    if (accessibilityObject().role() != WebAXRoleStaticText)
+        return;
+
+    int characterIndex = arguments[0].toInt32();
+    int wordStart, wordEnd;
+    getWordBoundaries(accessibilityObject(), characterIndex, wordStart, wordEnd);
+    result->set(wordEnd);
+}
+
 void AccessibilityUIElement::fallbackCallback(const CppArgumentList &, CppVariant* result)
 {
     // FIXME: Implement this.
     result->setNull();
 }
 
 RootAccessibilityUIElement::RootAccessibilityUIElement(const WebAXObject &object, Factory *factory)
     : AccessibilityUIElement(object, factory) { }
 
 AccessibilityUIElement* RootAccessibilityUIElement::getChildAtIndex(unsigned index)
@@ skipping 34 matching lines @@
 }
 
 AccessibilityUIElement* AccessibilityUIElementList::createRoot(const WebAXObject& object)
 {
     AccessibilityUIElement* element = new RootAccessibilityUIElement(object, this);
     m_elements.push_back(element);
     return element;
 }
 
 }