⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 285996 in webkit


Ignore:
Timestamp:
Nov 18, 2021, 3:46:10 AM (5 years ago)
Author:
Carlos Garcia Campos
Message:

[GTK][a11y] Add initial WTR accessibility support when building with ATSPI
​https://bugs.webkit.org/show_bug.cgi?id=230259

Reviewed by Adrian Perez de Castro.

Source/WebCore:

Export symbols required by WTR.

  • accessibility/atspi/AccessibilityAtspi.cpp:

(WebCore::AccessibilityAtspi::runLoop const):

  • accessibility/atspi/AccessibilityAtspi.h:
  • accessibility/atspi/AccessibilityObjectAtspi.h:
  • accessibility/atspi/AccessibilityRootAtspi.cpp:

(WebCore::AccessibilityRootAtspi::focusedObject const):

  • accessibility/atspi/AccessibilityRootAtspi.h:

Source/WebKit:

In case of ATSPI we need the web page accessibility object to get the root and focused object wrappers.

  • WebProcess/InjectedBundle/API/c/WKBundlePage.cpp:

(WKAccessibilityRootObject):
(WKAccessibilityFocusedObject):

Tools:

  • WebKitTestRunner/InjectedBundle/AccessibilityController.h:
  • WebKitTestRunner/InjectedBundle/AccessibilityUIElement.h:
  • WebKitTestRunner/InjectedBundle/atspi/AccessibilityControllerAtspi.cpp:

(WTR::findAccessibleObjectById):
(WTR::AccessibilityController::accessibleElementById):
(WTR::AccessibilityController::platformName):
(WTR::AccessibilityController::axRunLoop):
(WTR::AccessibilityController::executeOnAXThreadAndWait):
(WTR::AccessibilityController::executeOnAXThread):
(WTR::AccessibilityController::executeOnMainThread):

  • WebKitTestRunner/InjectedBundle/atspi/AccessibilityUIElementAtspi.cpp:

(WTR::AccessibilityUIElement::AccessibilityUIElement):
(WTR::AccessibilityUIElement::isEqual):
(WTR::AccessibilityUIElement::childrenCount):
(WTR::AccessibilityUIElement::elementAtPoint):
(WTR::AccessibilityUIElement::childAtIndex):
(WTR::elementForRelationAtIndex):
(WTR::AccessibilityUIElement::ariaOwnsElementAtIndex):
(WTR::AccessibilityUIElement::ariaFlowToElementAtIndex):
(WTR::AccessibilityUIElement::ariaControlsElementAtIndex):
(WTR::AccessibilityUIElement::titleUIElement):
(WTR::AccessibilityUIElement::parentElement):
(WTR::attributesOfElement):
(WTR::attributesOfElements):
(WTR::AccessibilityUIElement::attributesOfChildren):
(WTR::AccessibilityUIElement::allAttributes):
(WTR::AccessibilityUIElement::stringAttributeValue):
(WTR::AccessibilityUIElement::numberAttributeValue):
(WTR::checkElementState):
(WTR::AccessibilityUIElement::boolAttributeValue):
(WTR::AccessibilityUIElement::isAttributeSupported):
(WTR::roleValueToString):
(WTR::AccessibilityUIElement::role):
(WTR::AccessibilityUIElement::roleDescription):
(WTR::AccessibilityUIElement::computedRoleString):
(WTR::AccessibilityUIElement::title):
(WTR::AccessibilityUIElement::description):
(WTR::AccessibilityUIElement::orientation const):
(WTR::AccessibilityUIElement::stringValue):
(WTR::AccessibilityUIElement::helpText const):
(WTR::AccessibilityUIElement::x):
(WTR::AccessibilityUIElement::y):
(WTR::AccessibilityUIElement::width):
(WTR::AccessibilityUIElement::height):
(WTR::AccessibilityUIElement::clickPointX):
(WTR::AccessibilityUIElement::clickPointY):
(WTR::AccessibilityUIElement::isEnabled):
(WTR::AccessibilityUIElement::isRequired const):
(WTR::AccessibilityUIElement::isFocused const):
(WTR::AccessibilityUIElement::isSelected const):
(WTR::AccessibilityUIElement::isSelectedOptionActive const):
(WTR::AccessibilityUIElement::isExpanded const):
(WTR::AccessibilityUIElement::isChecked const):
(WTR::AccessibilityUIElement::isIndeterminate const):
(WTR::AccessibilityUIElement::hierarchicalLevel const):
(WTR::AccessibilityUIElement::ariaIsGrabbed const):
(WTR::AccessibilityUIElement::ariaDropEffects const):
(WTR::AccessibilityUIElement::lineForIndex):
(WTR::AccessibilityUIElement::rangeForLine):
(WTR::AccessibilityUIElement::boundsForRange):
(WTR::AccessibilityUIElement::stringForRange):
(WTR::AccessibilityUIElement::attributedStringForRange):
(WTR::AccessibilityUIElement::selectedTextRange):
(WTR::AccessibilityUIElement::setSelectedTextRange):
(WTR::AccessibilityUIElement::isFocusable const):
(WTR::AccessibilityUIElement::isSelectable const):
(WTR::AccessibilityUIElement::isMultiSelectable const):
(WTR::AccessibilityUIElement::isVisible const):
(WTR::AccessibilityUIElement::isOffScreen const):
(WTR::AccessibilityUIElement::isCollapsed const):
(WTR::AccessibilityUIElement::isSingleLine const):
(WTR::AccessibilityUIElement::isMultiLine const):
(WTR::AccessibilityUIElement::hasPopup const):
(WTR::AccessibilityUIElement::scrollToMakeVisible):
(WTR::AccessibilityUIElement::scrollToGlobalPoint):
(WTR::stringAtOffset):
(WTR::AccessibilityUIElement::characterAtOffset):
(WTR::AccessibilityUIElement::wordAtOffset):
(WTR::AccessibilityUIElement::lineAtOffset):
(WTR::AccessibilityUIElement::sentenceAtOffset):

  • WebKitTestRunner/gtk/main.cpp:

(main):

Location:
trunk
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r285994 r285996  
     12021-10-25  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        [GTK][a11y] Add initial WTR accessibility support when building with ATSPI
     4        https://bugs.webkit.org/show_bug.cgi?id=230259
     5
     6        Reviewed by Adrian Perez de Castro.
     7
     8        Export symbols required by WTR.
     9
     10        * accessibility/atspi/AccessibilityAtspi.cpp:
     11        (WebCore::AccessibilityAtspi::runLoop const):
     12        * accessibility/atspi/AccessibilityAtspi.h:
     13        * accessibility/atspi/AccessibilityObjectAtspi.h:
     14        * accessibility/atspi/AccessibilityRootAtspi.cpp:
     15        (WebCore::AccessibilityRootAtspi::focusedObject const):
     16        * accessibility/atspi/AccessibilityRootAtspi.h:
     17
    1182021-11-18  Carlos Garcia Campos  <cgarcia@igalia.com>
    219

  • trunk/Source/WebCore/accessibility/atspi/AccessibilityAtspi.cpp

    r284676 r285996  
    4747            g_warning("Can't connect to a11y bus: %s", error->message);
    4848    });
     49}
     50
     51RunLoop& AccessibilityAtspi::runLoop() const
     52{
     53    return m_queue->runLoop();
    4954}
    5055

  • trunk/Source/WebCore/accessibility/atspi/AccessibilityAtspi.h

    r284675 r285996  
    4444    ~AccessibilityAtspi() = default;
    4545
     46    WEBCORE_EXPORT RunLoop& runLoop() const;
     47
    4648    const char* uniqueName() const;
    4749    GVariant* nullReference() const;

  • trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.h

    r284675 r285996  
    5151
    5252    void setRoot(AccessibilityRootAtspi*);
    53     AccessibilityRootAtspi* root() const;
     53    WEBCORE_EXPORT AccessibilityRootAtspi* root() const;
    5454    void setParent(std::optional<AccessibilityObjectAtspi*>);
    55     std::optional<AccessibilityObjectAtspi*> parent() const;
    56     void updateBackingStore();
     55    WEBCORE_EXPORT std::optional<AccessibilityObjectAtspi*> parent() const;
     56    WEBCORE_EXPORT void updateBackingStore();
    5757
    5858    void attach(AXCoreObject*);
    … …  
    6767    void serialize(GVariantBuilder*) const;
    6868
    69     String id() const;
    70     CString name() const;
    71     CString description() const;
    72     unsigned role() const;
    73     unsigned childCount() const;
    74     Vector<RefPtr<AccessibilityObjectAtspi>> children() const;
    75     AccessibilityObjectAtspi* childAt(unsigned) const;
    76     uint64_t state() const;
     69    WEBCORE_EXPORT String id() const;
     70    WEBCORE_EXPORT CString name() const;
     71    WEBCORE_EXPORT CString description() const;
     72    WEBCORE_EXPORT unsigned role() const;
     73    WEBCORE_EXPORT unsigned childCount() const;
     74    WEBCORE_EXPORT Vector<RefPtr<AccessibilityObjectAtspi>> children() const;
     75    WEBCORE_EXPORT AccessibilityObjectAtspi* childAt(unsigned) const;
     76    WEBCORE_EXPORT uint64_t state() const;
    7777    void stateChanged(const char*, bool);
    78     HashMap<String, String> attributes() const;
    79     HashMap<uint32_t, Vector<RefPtr<AccessibilityObjectAtspi>>> relationMap() const;
     78    WEBCORE_EXPORT HashMap<String, String> attributes() const;
     79    WEBCORE_EXPORT HashMap<uint32_t, Vector<RefPtr<AccessibilityObjectAtspi>>> relationMap() const;
    8080
    81     AccessibilityObjectAtspi* hitTest(const IntPoint&, uint32_t) const;
    82     IntRect elementRect(uint32_t) const;
    83     void scrollToMakeVisible(uint32_t) const;
    84     void scrollToPoint(const IntPoint&, uint32_t) const;
     81    WEBCORE_EXPORT AccessibilityObjectAtspi* hitTest(const IntPoint&, uint32_t) const;
     82    WEBCORE_EXPORT IntRect elementRect(uint32_t) const;
     83    WEBCORE_EXPORT void scrollToMakeVisible(uint32_t) const;
     84    WEBCORE_EXPORT void scrollToPoint(const IntPoint&, uint32_t) const;
    8585
    86     String text() const;
     86    WEBCORE_EXPORT String text() const;
    8787    enum class TextGranularity {
    8888        Character,
    … …  
    9595        Paragraph
    9696    };
    97     IntPoint boundaryOffset(unsigned, TextGranularity) const;
    98     IntRect boundsForRange(unsigned, unsigned, uint32_t) const;
     97    WEBCORE_EXPORT IntPoint boundaryOffset(unsigned, TextGranularity) const;
     98    WEBCORE_EXPORT IntRect boundsForRange(unsigned, unsigned, uint32_t) const;
    9999    struct TextAttributes {
    100100        HashMap<String, String> attributes;
    … …  
    102102        int endOffset;
    103103    };
    104     TextAttributes textAttributes(std::optional<unsigned> = std::nullopt, bool = false) const;
    105     IntPoint selectedRange() const;
    106     void setSelectedRange(unsigned, unsigned);
     104    WEBCORE_EXPORT TextAttributes textAttributes(std::optional<unsigned> = std::nullopt, bool = false) const;
     105    WEBCORE_EXPORT IntPoint selectedRange() const;
     106    WEBCORE_EXPORT void setSelectedRange(unsigned, unsigned);
    107107    void textInserted(const String&, const VisiblePosition&);
    108108    void textDeleted(const String&, const VisiblePosition&);

  • trunk/Source/WebCore/accessibility/atspi/AccessibilityRootAtspi.cpp

    r284367 r285996  
    2626#include "AccessibilityAtspiInterfaces.h"
    2727#include "Document.h"
     28#include "FocusController.h"
    2829#include "Frame.h"
    2930#include "Page.h"
    … …  
    221222    wrapper->setRoot(const_cast<AccessibilityRootAtspi*>(this));
    222223    wrapper->setParent(nullptr); // nullptr parent means root.
     224
     225    return wrapper;
     226}
     227
     228AccessibilityObjectAtspi* AccessibilityRootAtspi::focusedObject() const
     229{
     230    RELEASE_ASSERT(isMainThread());
     231    if (!AXObjectCache::accessibilityEnabled())
     232        AXObjectCache::enableAccessibility();
     233
     234    if (!m_page)
     235        return nullptr;
     236
     237    auto* focusedDocument = m_page->focusController().focusedOrMainFrame().document();
     238    if (!focusedDocument)
     239        return nullptr;
     240
     241    auto* cache = focusedDocument->axObjectCache();
     242    if (!cache)
     243        return nullptr;
     244
     245    auto* focusedObject = cache->focusedObjectForPage(m_page.get());
     246    if (!focusedObject)
     247        return nullptr;
     248
     249    auto* wrapper = focusedObject->wrapper();
     250    if (!wrapper)
     251        return nullptr;
     252
     253    wrapper->setRoot(const_cast<AccessibilityRootAtspi*>(this));
    223254
    224255    return wrapper;

  • trunk/Source/WebCore/accessibility/atspi/AccessibilityRootAtspi.h

    r284367 r285996  
    5050    AccessibilityAtspi& atspi() const { return m_atspi; }
    5151    AccessibilityObjectAtspi* child() const;
     52    AccessibilityObjectAtspi* focusedObject() const;
    5253
    5354    void serialize(GVariantBuilder*) const;

  • trunk/Source/WebKit/ChangeLog

    r285993 r285996  
     12021-10-25  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        [GTK][a11y] Add initial WTR accessibility support when building with ATSPI
     4        https://bugs.webkit.org/show_bug.cgi?id=230259
     5
     6        Reviewed by Adrian Perez de Castro.
     7
     8        In case of ATSPI we need the web page accessibility object to get the root and focused object wrappers.
     9
     10        * WebProcess/InjectedBundle/API/c/WKBundlePage.cpp:
     11        (WKAccessibilityRootObject):
     12        (WKAccessibilityFocusedObject):
     13
    1142021-11-18  Youenn Fablet  <youenn@apple.com>
    215

  • trunk/Source/WebKit/WebProcess/InjectedBundle/API/c/WKBundlePage.cpp

    r285399 r285996  
    247247    if (!pageRef)
    248248        return 0;
    249    
     249
     250#if USE(ATSPI)
     251    return WebKit::toImpl(pageRef)->accessibilityRootObject().child();
     252#endif
     253
    250254    WebCore::Page* page = WebKit::toImpl(pageRef)->corePage();
    251255    if (!page)
    … …  
    274278    if (!pageRef)
    275279        return 0;
     280
     281#if USE(ATSPI)
     282    return WebKit::toImpl(pageRef)->accessibilityRootObject().focusedObject();
     283#endif
    276284
    277285    WebCore::Page* page = WebKit::toImpl(pageRef)->corePage();

  • trunk/Tools/ChangeLog

    r285993 r285996  
     12021-10-25  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        [GTK][a11y] Add initial WTR accessibility support when building with ATSPI
     4        https://bugs.webkit.org/show_bug.cgi?id=230259
     5
     6        Reviewed by Adrian Perez de Castro.
     7
     8        * WebKitTestRunner/InjectedBundle/AccessibilityController.h:
     9        * WebKitTestRunner/InjectedBundle/AccessibilityUIElement.h:
     10        * WebKitTestRunner/InjectedBundle/atspi/AccessibilityControllerAtspi.cpp:
     11        (WTR::findAccessibleObjectById):
     12        (WTR::AccessibilityController::accessibleElementById):
     13        (WTR::AccessibilityController::platformName):
     14        (WTR::AccessibilityController::axRunLoop):
     15        (WTR::AccessibilityController::executeOnAXThreadAndWait):
     16        (WTR::AccessibilityController::executeOnAXThread):
     17        (WTR::AccessibilityController::executeOnMainThread):
     18        * WebKitTestRunner/InjectedBundle/atspi/AccessibilityUIElementAtspi.cpp:
     19        (WTR::AccessibilityUIElement::AccessibilityUIElement):
     20        (WTR::AccessibilityUIElement::isEqual):
     21        (WTR::AccessibilityUIElement::childrenCount):
     22        (WTR::AccessibilityUIElement::elementAtPoint):
     23        (WTR::AccessibilityUIElement::childAtIndex):
     24        (WTR::elementForRelationAtIndex):
     25        (WTR::AccessibilityUIElement::ariaOwnsElementAtIndex):
     26        (WTR::AccessibilityUIElement::ariaFlowToElementAtIndex):
     27        (WTR::AccessibilityUIElement::ariaControlsElementAtIndex):
     28        (WTR::AccessibilityUIElement::titleUIElement):
     29        (WTR::AccessibilityUIElement::parentElement):
     30        (WTR::attributesOfElement):
     31        (WTR::attributesOfElements):
     32        (WTR::AccessibilityUIElement::attributesOfChildren):
     33        (WTR::AccessibilityUIElement::allAttributes):
     34        (WTR::AccessibilityUIElement::stringAttributeValue):
     35        (WTR::AccessibilityUIElement::numberAttributeValue):
     36        (WTR::checkElementState):
     37        (WTR::AccessibilityUIElement::boolAttributeValue):
     38        (WTR::AccessibilityUIElement::isAttributeSupported):
     39        (WTR::roleValueToString):
     40        (WTR::AccessibilityUIElement::role):
     41        (WTR::AccessibilityUIElement::roleDescription):
     42        (WTR::AccessibilityUIElement::computedRoleString):
     43        (WTR::AccessibilityUIElement::title):
     44        (WTR::AccessibilityUIElement::description):
     45        (WTR::AccessibilityUIElement::orientation const):
     46        (WTR::AccessibilityUIElement::stringValue):
     47        (WTR::AccessibilityUIElement::helpText const):
     48        (WTR::AccessibilityUIElement::x):
     49        (WTR::AccessibilityUIElement::y):
     50        (WTR::AccessibilityUIElement::width):
     51        (WTR::AccessibilityUIElement::height):
     52        (WTR::AccessibilityUIElement::clickPointX):
     53        (WTR::AccessibilityUIElement::clickPointY):
     54        (WTR::AccessibilityUIElement::isEnabled):
     55        (WTR::AccessibilityUIElement::isRequired const):
     56        (WTR::AccessibilityUIElement::isFocused const):
     57        (WTR::AccessibilityUIElement::isSelected const):
     58        (WTR::AccessibilityUIElement::isSelectedOptionActive const):
     59        (WTR::AccessibilityUIElement::isExpanded const):
     60        (WTR::AccessibilityUIElement::isChecked const):
     61        (WTR::AccessibilityUIElement::isIndeterminate const):
     62        (WTR::AccessibilityUIElement::hierarchicalLevel const):
     63        (WTR::AccessibilityUIElement::ariaIsGrabbed const):
     64        (WTR::AccessibilityUIElement::ariaDropEffects const):
     65        (WTR::AccessibilityUIElement::lineForIndex):
     66        (WTR::AccessibilityUIElement::rangeForLine):
     67        (WTR::AccessibilityUIElement::boundsForRange):
     68        (WTR::AccessibilityUIElement::stringForRange):
     69        (WTR::AccessibilityUIElement::attributedStringForRange):
     70        (WTR::AccessibilityUIElement::selectedTextRange):
     71        (WTR::AccessibilityUIElement::setSelectedTextRange):
     72        (WTR::AccessibilityUIElement::isFocusable const):
     73        (WTR::AccessibilityUIElement::isSelectable const):
     74        (WTR::AccessibilityUIElement::isMultiSelectable const):
     75        (WTR::AccessibilityUIElement::isVisible const):
     76        (WTR::AccessibilityUIElement::isOffScreen const):
     77        (WTR::AccessibilityUIElement::isCollapsed const):
     78        (WTR::AccessibilityUIElement::isSingleLine const):
     79        (WTR::AccessibilityUIElement::isMultiLine const):
     80        (WTR::AccessibilityUIElement::hasPopup const):
     81        (WTR::AccessibilityUIElement::scrollToMakeVisible):
     82        (WTR::AccessibilityUIElement::scrollToGlobalPoint):
     83        (WTR::stringAtOffset):
     84        (WTR::AccessibilityUIElement::characterAtOffset):
     85        (WTR::AccessibilityUIElement::wordAtOffset):
     86        (WTR::AccessibilityUIElement::lineAtOffset):
     87        (WTR::AccessibilityUIElement::sentenceAtOffset):
     88        * WebKitTestRunner/gtk/main.cpp:
     89        (main):
     90
    1912021-11-18  Youenn Fablet  <youenn@apple.com>
    292

  • trunk/Tools/WebKitTestRunner/InjectedBundle/AccessibilityController.h

    r285859 r285996  
    3535#include <wtf/RetainPtr.h>
    3636#endif
     37#include <wtf/RunLoop.h>
    3738#include <wtf/Threading.h>
    3839
    … …  
    6970    RefPtr<AccessibilityUIElement> accessibleElementById(JSStringRef idAttribute);
    7071
    71 #if PLATFORM(COCOA)
     72#if PLATFORM(COCOA) || USE(ATSPI)
    7273    void executeOnAXThreadAndWait(Function<void()>&&);
    7374    void executeOnAXThread(Function<void()>&&);
    … …  
    104105    void updateIsolatedTreeMode();
    105106
     107#if USE(ATSPI)
     108    RunLoop& axRunLoop();
     109#endif
     110
    106111#if PLATFORM(COCOA)
    107112    void spinMainRunLoop() const;
    … …  
    113118#endif
    114119    bool m_accessibilityIsolatedTreeMode { false };
     120#if USE(ATSPI)
     121    RunLoop* m_axRunLoop { nullptr };
     122#endif
    115123#endif
    116124};

  • trunk/Tools/WebKitTestRunner/InjectedBundle/AccessibilityUIElement.h

    r285589 r285996  
    431431    RefPtr<AccessibilityNotificationHandler> m_notificationHandler;
    432432#elif USE(ATSPI)
     433    static RefPtr<AccessibilityController> s_controller;
    433434    RefPtr<WebCore::AccessibilityObjectAtspi> m_element;
    434435#endif

  • trunk/Tools/WebKitTestRunner/InjectedBundle/atspi/AccessibilityControllerAtspi.cpp

    r282643 r285996  
    3333#include "InjectedBundle.h"
    3434#include "InjectedBundlePage.h"
     35#include "StringFunctions.h"
    3536#include <WebCore/AccessibilityObjectAtspi.h>
     37#include <WebCore/AccessibilityRootAtspi.h>
    3638#include <WebKit/WKBundlePagePrivate.h>
    3739
    … …  
    4244}
    4345
     46static WebCore::AccessibilityObjectAtspi* findAccessibleObjectById(WebCore::AccessibilityObjectAtspi& axObject, const String& elementID)
     47{
     48    axObject.updateBackingStore();
     49    if (axObject.id() == elementID)
     50        return &axObject;
     51
     52    Vector<RefPtr<WebCore::AccessibilityObjectAtspi>> children;
     53    InjectedBundle::singleton().accessibilityController()->executeOnAXThreadAndWait([axObject = Ref { axObject }, &children] {
     54        axObject->updateBackingStore();
     55        children = axObject->children();
     56    });
     57    for (const auto& child : children) {
     58        if (auto* element = findAccessibleObjectById(*child, elementID))
     59            return element;
     60    }
     61
     62    return nullptr;
     63}
     64
    4465RefPtr<AccessibilityUIElement> AccessibilityController::accessibleElementById(JSStringRef id)
    4566{
     67    WKBundlePageRef page = InjectedBundle::singleton().page()->page();
     68    auto* rootObject = static_cast<WebCore::AccessibilityObjectAtspi*>(WKAccessibilityRootObject(page));
     69    if (!rootObject)
     70        return nullptr;
     71
     72    String elementID = toWTFString(id);
     73    if (auto* element = findAccessibleObjectById(*rootObject, elementID))
     74        return AccessibilityUIElement::create(element);
    4675    return nullptr;
    4776}
    … …  
    4978JSRetainPtr<JSStringRef> AccessibilityController::platformName()
    5079{
    51     JSRetainPtr<JSStringRef> platformName(Adopt, JSStringCreateWithUTF8CString("atspi"));
     80    // FIXME: Use atk as platform name for now, because the expected behavior is the same.
     81    // Once we replace the atk implementation with the atspi one we can use atspi and
     82    // update the tests helper scripts. https://bugs.webkit.org/show_bug.cgi?id=232227.
     83    JSRetainPtr<JSStringRef> platformName(Adopt, JSStringCreateWithUTF8CString("atk"));
    5284    return platformName;
    5385}
    … …  
    6193    WKBundlePageRef page = InjectedBundle::singleton().page()->page();
    6294    auto* element = static_cast<WebCore::AccessibilityObjectAtspi*>(WKAccessibilityRootObject(page));
    63 
    6495    return AccessibilityUIElement::create(element);
    6596}
    6697
    67 Ref<AccessibilityUIElement> AccessibilityController::focusedElement()
     98RefPtr<AccessibilityUIElement> AccessibilityController::focusedElement()
    6899{
    69100    WKBundlePageRef page = InjectedBundle::singleton().page()->page();
    70     auto* element = static_cast<WebCore::AccessibilityObjectAtspi*>(WKAccessibilityFocusedObject(page));
    71 
    72     return AccessibilityUIElement::create(element);
     101    if (auto* element = static_cast<WebCore::AccessibilityObjectAtspi*>(WKAccessibilityFocusedObject(page)))
     102        return AccessibilityUIElement::create(element);
     103    return nullptr;
    73104}
    74105
    … …  
    87118}
    88119
     120RunLoop& AccessibilityController::axRunLoop()
     121{
     122    if (!m_axRunLoop) {
     123        WKBundlePageRef page = InjectedBundle::singleton().page()->page();
     124        auto* element = static_cast<WebCore::AccessibilityObjectAtspi*>(WKAccessibilityRootObject(page));
     125        RELEASE_ASSERT(element);
     126        m_axRunLoop = &element->root()->atspi().runLoop();
     127    }
     128
     129    return *m_axRunLoop;
     130}
     131
     132void AccessibilityController::executeOnAXThreadAndWait(Function<void()>&& function)
     133{
     134    RELEASE_ASSERT(isMainThread());
     135    std::atomic<bool> done = false;
     136    axRunLoop().dispatch([this, function = WTFMove(function), &done] {
     137        function();
     138        done.store(true);
     139    });
     140    while (!done.load())
     141        g_main_context_iteration(nullptr, FALSE);
     142}
     143
     144void AccessibilityController::executeOnAXThread(Function<void()>&& function)
     145{
     146    axRunLoop().dispatch([this, function = WTFMove(function)] {
     147        function();
     148    });
     149}
     150
     151void AccessibilityController::executeOnMainThread(Function<void()>&& function)
     152{
     153    if (isMainThread()) {
     154        function();
     155        return;
     156    }
     157
     158    axRunLoop().dispatch([this, function = WTFMove(function)]() mutable {
     159        callOnMainThread(WTFMove(function));
     160    });
     161}
     162
    89163} // namespace WTR
    90164

  • trunk/Tools/WebKitTestRunner/InjectedBundle/atspi/AccessibilityUIElementAtspi.cpp

    r282643 r285996  
    3232#include <JavaScriptCore/JSStringRef.h>
    3333#include <JavaScriptCore/OpaqueJSString.h>
     34#include <WebCore/AccessibilityAtspiEnums.h>
    3435#include <WebCore/AccessibilityObjectAtspi.h>
    3536#include <WebKit/WKBundleFrame.h>
     37#include <wtf/text/CString.h>
     38#include <wtf/text/StringBuilder.h>
     39#include <wtf/text/StringToIntegerConversion.h>
     40#include <wtf/unicode/CharacterNames.h>
    3641
    3742namespace WTR {
     43
     44RefPtr<AccessibilityController> AccessibilityUIElement::s_controller;
    3845
    3946AccessibilityUIElement::AccessibilityUIElement(PlatformUIElement element)
    4047    : m_element(element)
    4148{
     49    if (!s_controller)
     50        s_controller = InjectedBundle::singleton().accessibilityController();
    4251}
    4352
    … …  
    5463bool AccessibilityUIElement::isEqual(AccessibilityUIElement* otherElement)
    5564{
    56     return m_element.get() == otherElement->platformUIElement();
     65    return otherElement && m_element.get() == otherElement->platformUIElement();
    5766}
    5867
    … …  
    7281int AccessibilityUIElement::childrenCount()
    7382{
     83    unsigned childCount;
     84    s_controller->executeOnAXThreadAndWait([this, &childCount] {
     85        m_element->updateBackingStore();
     86        childCount = m_element->childCount();
     87    });
     88    return childCount;
     89}
     90
     91RefPtr<AccessibilityUIElement> AccessibilityUIElement::elementAtPoint(int x, int y)
     92{
     93    auto* element = m_element->hitTest({ x, y }, WebCore::Atspi::CoordinateType::WindowCoordinates);
     94    return AccessibilityUIElement::create(element ? element : m_element.get());
     95}
     96
     97unsigned AccessibilityUIElement::indexOfChild(AccessibilityUIElement* element)
     98{
    7499    return 0;
    75100}
    76101
    77 RefPtr<AccessibilityUIElement> AccessibilityUIElement::elementAtPoint(int x, int y)
    78 {
    79     return nullptr;
    80 }
    81 
    82 unsigned AccessibilityUIElement::indexOfChild(AccessibilityUIElement* element)
     102RefPtr<AccessibilityUIElement> AccessibilityUIElement::childAtIndex(unsigned index)
     103{
     104    m_element->updateBackingStore();
     105
     106    RefPtr<WebCore::AccessibilityObjectAtspi> child;
     107    s_controller->executeOnAXThreadAndWait([this, &child, index] {
     108        m_element->updateBackingStore();
     109        child = m_element->childAt(index);
     110    });
     111    if (!child)
     112        return nullptr;
     113
     114    return AccessibilityUIElement::create(child.get());
     115}
     116
     117static RefPtr<AccessibilityUIElement> elementForRelationAtIndex(WebCore::AccessibilityObjectAtspi* element, WebCore::Atspi::Relation relation, unsigned index)
     118{
     119    auto relationMap = element->relationMap();
     120    auto targets = relationMap.get(relation);
     121    if (targets.isEmpty() || index >= targets.size())
     122        return nullptr;
     123
     124    auto target = targets[index];
     125    if (!target)
     126        return nullptr;
     127
     128    return AccessibilityUIElement::create(target.get());
     129}
     130
     131RefPtr<AccessibilityUIElement> AccessibilityUIElement::linkedUIElementAtIndex(unsigned index)
     132{
     133    return nullptr;
     134}
     135
     136RefPtr<AccessibilityUIElement> AccessibilityUIElement::ariaOwnsElementAtIndex(unsigned index)
     137{
     138    return elementForRelationAtIndex(m_element.get(), WebCore::Atspi::Relation::NodeParentOf, index);
     139}
     140
     141RefPtr<AccessibilityUIElement> AccessibilityUIElement::ariaFlowToElementAtIndex(unsigned index)
     142{
     143    return elementForRelationAtIndex(m_element.get(), WebCore::Atspi::Relation::FlowsTo, index);
     144}
     145
     146RefPtr<AccessibilityUIElement> AccessibilityUIElement::ariaControlsElementAtIndex(unsigned index)
     147{
     148    return elementForRelationAtIndex(m_element.get(), WebCore::Atspi::Relation::ControllerFor, index);
     149}
     150
     151RefPtr<AccessibilityUIElement> AccessibilityUIElement::disclosedRowAtIndex(unsigned index)
     152{
     153    return nullptr;
     154}
     155
     156RefPtr<AccessibilityUIElement> AccessibilityUIElement::rowAtIndex(unsigned index)
     157{
     158    return nullptr;
     159}
     160
     161RefPtr<AccessibilityUIElement> AccessibilityUIElement::selectedChildAtIndex(unsigned index) const
     162{
     163    return nullptr;
     164}
     165
     166unsigned AccessibilityUIElement::selectedChildrenCount() const
    83167{
    84168    return 0;
    85169}
    86170
    87 RefPtr<AccessibilityUIElement> AccessibilityUIElement::childAtIndex(unsigned index)
    88 {
    89     return nullptr;
    90 }
    91 
    92 RefPtr<AccessibilityUIElement> AccessibilityUIElement::linkedUIElementAtIndex(unsigned index)
    93 {
    94     return nullptr;
    95 }
    96 
    97 RefPtr<AccessibilityUIElement> AccessibilityUIElement::ariaOwnsElementAtIndex(unsigned index)
    98 {
    99     return nullptr;
    100 }
    101 
    102 RefPtr<AccessibilityUIElement> AccessibilityUIElement::ariaFlowToElementAtIndex(unsigned index)
    103 {
    104     return nullptr;
    105 }
    106 
    107 RefPtr<AccessibilityUIElement> AccessibilityUIElement::ariaControlsElementAtIndex(unsigned index)
    108 {
    109     return nullptr;
    110 }
    111 
    112 RefPtr<AccessibilityUIElement> AccessibilityUIElement::disclosedRowAtIndex(unsigned index)
    113 {
    114     return nullptr;
    115 }
    116 
    117 RefPtr<AccessibilityUIElement> AccessibilityUIElement::rowAtIndex(unsigned index)
    118 {
    119     return nullptr;
    120 }
    121 
    122 RefPtr<AccessibilityUIElement> AccessibilityUIElement::selectedChildAtIndex(unsigned index) const
    123 {
    124     return nullptr;
    125 }
    126 
    127 unsigned AccessibilityUIElement::selectedChildrenCount() const
    128 {
     171RefPtr<AccessibilityUIElement> AccessibilityUIElement::selectedRowAtIndex(unsigned index)
     172{
     173    return nullptr;
     174}
     175
     176RefPtr<AccessibilityUIElement> AccessibilityUIElement::titleUIElement()
     177{
     178    return elementForRelationAtIndex(m_element.get(), WebCore::Atspi::Relation::LabelledBy, 0);
     179}
     180
     181RefPtr<AccessibilityUIElement> AccessibilityUIElement::parentElement()
     182{
     183    m_element->updateBackingStore();
     184
     185    RefPtr<WebCore::AccessibilityObjectAtspi> parent;
     186    s_controller->executeOnAXThreadAndWait([this, &parent] {
     187        m_element->updateBackingStore();
     188        auto parentWrapper = m_element->parent();
     189        if (parentWrapper)
     190            parent = parentWrapper.value();
     191    });
     192    if (!parent)
     193        return nullptr;
     194
     195    return AccessibilityUIElement::create(parent.get());
     196}
     197
     198RefPtr<AccessibilityUIElement> AccessibilityUIElement::disclosedByRow()
     199{
     200    return nullptr;
     201}
     202
     203JSRetainPtr<JSStringRef> AccessibilityUIElement::attributesOfLinkedUIElements()
     204{
     205    return JSStringCreateWithCharacters(0, 0);
     206}
     207
     208JSRetainPtr<JSStringRef> AccessibilityUIElement::attributesOfDocumentLinks()
     209{
     210    return JSStringCreateWithCharacters(0, 0);
     211}
     212
     213static String attributesOfElement(AccessibilityUIElement& element)
     214{
     215    StringBuilder builder;
     216
     217    builder.append(element.role()->string(), '\n');
     218
     219    builder.append("AXParent: ");
     220    if (auto parent = element.parentElement()) {
     221        builder.append(parent->role()->string().substring(8));
     222        auto parentName = parent->title()->string().substring(9);
     223        if (!parentName.isEmpty())
     224            builder.append(": ", parentName);
     225    } else
     226        builder.append("(null)");
     227    builder.append('\n');
     228
     229    builder.append("AXChildren: ", element.childrenCount(), '\n');
     230
     231    builder.append("AXPosition:  { ", FormattedNumber::fixedPrecision(element.x(), 6, KeepTrailingZeros));
     232    builder.append(", ", FormattedNumber::fixedPrecision(element.y(), 6, KeepTrailingZeros));
     233    builder.append(" }\n");
     234
     235    builder.append("AXSize: { ", FormattedNumber::fixedPrecision(element.width(), 6, KeepTrailingZeros));
     236    builder.append(", ", FormattedNumber::fixedPrecision(element.height(), 6, KeepTrailingZeros));
     237    builder.append(" }\n");
     238
     239    String title = element.title()->string();
     240    if (!title.isEmpty()) {
     241        builder.append(title);
     242        builder.append('\n');
     243    }
     244
     245    String description = element.description()->string();
     246    if (!description.isEmpty())
     247        builder.append(description.utf8().data(), '\n');
     248
     249    String value = element.stringValue()->string();
     250    if (!value.isEmpty())
     251        builder.append(value, '\n');
     252
     253    builder.append("AXFocusable: ", element.isFocusable(), '\n');
     254    builder.append("AXFocused: ", element.isFocused(), '\n');
     255    builder.append("AXSelectable: ", element.isSelectable(), '\n');
     256    builder.append("AXSelected: ", element.isSelected(), '\n');
     257    builder.append("AXMultiSelectable: ", element.isMultiSelectable(), '\n');
     258    builder.append("AXEnabled: ", element.isEnabled(), '\n');
     259    builder.append("AXExpanded: ", element.isExpanded(), '\n');
     260    builder.append("AXRequired: ", element.isRequired(), '\n');
     261    builder.append("AXChecked: ", element.isChecked(), '\n');
     262
     263    String url = element.url()->string();
     264    if (!url.isEmpty())
     265        builder.append(url, '\n');
     266
     267    // We append the platform attributes as a single line at the end.
     268    builder.append("AXPlatformAttributes: ");
     269    auto attributes = element.platformUIElement()->attributes();
     270    bool isFirst = true;
     271    for (const auto& it : attributes) {
     272        if (!isFirst)
     273            builder.append(", ");
     274        isFirst = false;
     275        builder.append(it.key, ':', it.value);
     276    }
     277    builder.append('\n');
     278
     279    return builder.toString();
     280}
     281
     282static String attributesOfElements(Vector<RefPtr<AccessibilityUIElement>>& elements)
     283{
     284    StringBuilder builder;
     285    for (auto& element : elements)
     286        builder.append(attributesOfElement(*element), "\n------------\n");
     287    return builder.toString();
     288}
     289
     290JSRetainPtr<JSStringRef> AccessibilityUIElement::attributesOfChildren()
     291{
     292    m_element->updateBackingStore();
     293
     294    Vector<RefPtr<WebCore::AccessibilityObjectAtspi>> children;
     295    s_controller->executeOnAXThreadAndWait([this, &children] {
     296        m_element->updateBackingStore();
     297        children = m_element->children();
     298    });
     299
     300    Vector<RefPtr<AccessibilityUIElement>> elements;
     301    elements.reserveInitialCapacity(children.size());
     302    for (auto& child : children)
     303        elements.uncheckedAppend(AccessibilityUIElement::create(child.get()));
     304
     305    return OpaqueJSString::tryCreate(attributesOfElements(elements)).leakRef();
     306}
     307
     308JSRetainPtr<JSStringRef> AccessibilityUIElement::allAttributes()
     309{
     310    return OpaqueJSString::tryCreate(attributesOfElement(*this)).leakRef();
     311}
     312
     313JSRetainPtr<JSStringRef> AccessibilityUIElement::stringDescriptionOfAttributeValue(JSStringRef attribute)
     314{
     315    return JSStringCreateWithCharacters(0, 0);
     316}
     317
     318JSRetainPtr<JSStringRef> AccessibilityUIElement::stringAttributeValue(JSStringRef attribute)
     319{
     320    String attributeName = toWTFString(attribute);
     321    if (attributeName == "AXSelectedText") {
     322        if (!m_element->interfaces().contains(WebCore::AccessibilityObjectAtspi::Interface::Text))
     323            return JSStringCreateWithCharacters(0, 0);
     324
     325        m_element->updateBackingStore();
     326        auto text = m_element->text();
     327        auto offset = m_element->selectedRange();
     328        return OpaqueJSString::tryCreate(text.substring(offset.x(), offset.y() - offset.x())).leakRef();
     329    }
     330
     331    auto attributes = m_element->attributes();
     332    if (attributeName == "AXPlaceholderValue")
     333        return OpaqueJSString::tryCreate(attributes.get("placeholder-text")).leakRef();
     334
     335    return JSStringCreateWithCharacters(0, 0);
     336}
     337
     338double AccessibilityUIElement::numberAttributeValue(JSStringRef attribute)
     339{
     340    String attributeName = toWTFString(attribute);
     341    auto attributes = m_element->attributes();
     342    if (attributeName == "AXARIASetSize")
     343        return attributes.get("setsize").toDouble();
     344    if (attributeName == "AXARIAPosInSet")
     345        return attributes.get("posinset").toDouble();
     346
    129347    return 0;
    130348}
    131349
    132 RefPtr<AccessibilityUIElement> AccessibilityUIElement::selectedRowAtIndex(unsigned index)
    133 {
    134     return nullptr;
    135 }
    136 
    137 RefPtr<AccessibilityUIElement> AccessibilityUIElement::titleUIElement()
    138 {
    139     return nullptr;
    140 }
    141 
    142 RefPtr<AccessibilityUIElement> AccessibilityUIElement::parentElement()
    143 {
    144     return nullptr;
    145 }
    146 
    147 RefPtr<AccessibilityUIElement> AccessibilityUIElement::disclosedByRow()
    148 {
    149     return nullptr;
    150 }
    151 
    152 JSRetainPtr<JSStringRef> AccessibilityUIElement::attributesOfLinkedUIElements()
    153 {
    154     return JSStringCreateWithCharacters(0, 0);
    155 }
    156 
    157 JSRetainPtr<JSStringRef> AccessibilityUIElement::attributesOfDocumentLinks()
    158 {
    159     return JSStringCreateWithCharacters(0, 0);
    160 }
    161 
    162 JSRetainPtr<JSStringRef> AccessibilityUIElement::attributesOfChildren()
    163 {
    164     return JSStringCreateWithCharacters(0, 0);
    165 }
    166 
    167 JSRetainPtr<JSStringRef> AccessibilityUIElement::allAttributes()
    168 {
    169     return JSStringCreateWithCharacters(0, 0);
    170 }
    171 
    172 JSRetainPtr<JSStringRef> AccessibilityUIElement::stringDescriptionOfAttributeValue(JSStringRef attribute)
    173 {
    174     return JSStringCreateWithCharacters(0, 0);
    175 }
    176 
    177 JSRetainPtr<JSStringRef> AccessibilityUIElement::stringAttributeValue(JSStringRef attribute)
    178 {
    179     return JSStringCreateWithCharacters(0, 0);
    180 }
    181 
    182 double AccessibilityUIElement::numberAttributeValue(JSStringRef attribute)
     350JSValueRef AccessibilityUIElement::uiElementArrayAttributeValue(JSStringRef attribute) const
     351{
     352    return nullptr;
     353}
     354
     355JSValueRef AccessibilityUIElement::rowHeaders() const
     356{
     357    return nullptr;
     358}
     359
     360JSValueRef AccessibilityUIElement::columnHeaders() const
     361{
     362    return nullptr;
     363}
     364
     365RefPtr<AccessibilityUIElement> AccessibilityUIElement::uiElementAttributeValue(JSStringRef attribute) const
     366{
     367    return nullptr;
     368}
     369
     370static bool checkElementState(WebCore::AccessibilityObjectAtspi* element, WebCore::Atspi::State state)
     371{
     372    return element->state() & (G_GUINT64_CONSTANT(1) << state);
     373}
     374
     375bool AccessibilityUIElement::boolAttributeValue(JSStringRef attribute)
     376{
     377    String attributeName = toWTFString(attribute);
     378    if (attributeName == "AXElementBusy")
     379        return checkElementState(m_element.get(), WebCore::Atspi::State::Busy);
     380
     381    return false;
     382}
     383
     384bool AccessibilityUIElement::isAttributeSettable(JSStringRef attribute)
     385{
     386    return false;
     387}
     388
     389bool AccessibilityUIElement::isAttributeSupported(JSStringRef attribute)
     390{
     391    String attributeName = toWTFString(attribute);
     392    auto attributes = m_element->attributes();
     393    if (attributeName == "AXARIASetSize")
     394        return attributes.contains("setsize");
     395    if (attributeName == "AXARIAPosInSet")
     396        return attributes.contains("posinset");
     397
     398    return false;
     399}
     400
     401JSRetainPtr<JSStringRef> AccessibilityUIElement::parameterizedAttributeNames()
     402{
     403    return JSStringCreateWithCharacters(0, 0);
     404}
     405
     406static String roleValueToString(unsigned roleValue)
     407{
     408    switch (roleValue) {
     409    case WebCore::Atspi::Role::Alert:
     410        return "AXAlert"_s;
     411    case WebCore::Atspi::Role::Article:
     412        return "AXArticle"_s;
     413    case WebCore::Atspi::Role::Audio:
     414        return "AXAudio"_s;
     415    case WebCore::Atspi::Role::BlockQuote:
     416        return "AXBlockquote"_s;
     417    case WebCore::Atspi::Role::Canvas:
     418        return "AXCanvas"_s;
     419    case WebCore::Atspi::Role::Caption:
     420        return "AXCaption"_s;
     421    case WebCore::Atspi::Role::CheckBox:
     422        return "AXCheckBox"_s;
     423    case WebCore::Atspi::Role::CheckMenuItem:
     424        return "AXCheckMenuItem"_s;
     425    case WebCore::Atspi::Role::ColorChooser:
     426        return "AXColorWell"_s;
     427    case WebCore::Atspi::Role::ColumnHeader:
     428    case WebCore::Atspi::Role::TableColumnHeader:
     429        return "AXColumnHeader"_s;
     430    case WebCore::Atspi::Role::ComboBox:
     431        return "AXComboBox"_s;
     432    case WebCore::Atspi::Role::Comment:
     433        return "AXComment"_s;
     434    case WebCore::Atspi::Role::ContentDeletion:
     435        return "AXDeletion"_s;
     436    case WebCore::Atspi::Role::ContentInsertion:
     437        return "AXInsertion"_s;
     438    case WebCore::Atspi::Role::Definition:
     439        return "AXDefinition"_s;
     440    case WebCore::Atspi::Role::DescriptionList:
     441        return "AXDescriptionList"_s;
     442    case WebCore::Atspi::Role::DescriptionTerm:
     443        return "AXDescriptionTerm"_s;
     444    case WebCore::Atspi::Role::DescriptionValue:
     445        return "AXDescriptionValue"_s;
     446    case WebCore::Atspi::Role::Dialog:
     447        return "AXDialog"_s;
     448    case WebCore::Atspi::Role::DocumentFrame:
     449        return "AXDocument"_s;
     450    case WebCore::Atspi::Role::DocumentWeb:
     451        return "AXWebArea"_s;
     452    case WebCore::Atspi::Role::Embedded:
     453        return "AXEmbedded"_s;
     454    case WebCore::Atspi::Role::Entry:
     455        return "AXTextField"_s;
     456    case WebCore::Atspi::Role::Footer:
     457        return "AXFooter"_s;
     458    case WebCore::Atspi::Role::Footnote:
     459        return "AXFootnote"_s;
     460    case WebCore::Atspi::Role::Form:
     461        return "AXForm"_s;
     462    case WebCore::Atspi::Role::Grouping:
     463    case WebCore::Atspi::Role::Panel:
     464        return "AXGroup"_s;
     465    case WebCore::Atspi::Role::Heading:
     466        return "AXHeading"_s;
     467    case WebCore::Atspi::Role::Image:
     468        return "AXImage"_s;
     469    case WebCore::Atspi::Role::ImageMap:
     470        return "AXImageMap"_s;
     471    case WebCore::Atspi::Role::InvalidRole:
     472        return "AXInvalid"_s;
     473    case WebCore::Atspi::Role::Label:
     474        return "AXLabel"_s;
     475    case WebCore::Atspi::Role::LevelBar:
     476        return "AXLevelIndicator"_s;
     477    case WebCore::Atspi::Role::Link:
     478        return "AXLink"_s;
     479    case WebCore::Atspi::Role::ListBox:
     480        return "AXListBox"_s;
     481    case WebCore::Atspi::Role::List:
     482        return "AXList"_s;
     483    case WebCore::Atspi::Role::ListItem:
     484        return "AXListItem"_s;
     485    case WebCore::Atspi::Role::Log:
     486        return "AXLog"_s;
     487    case WebCore::Atspi::Role::Marquee:
     488        return "AXMarquee"_s;
     489    case WebCore::Atspi::Role::Math:
     490        return "AXMath"_s;
     491    case WebCore::Atspi::Role::MathFraction:
     492        return "AXMathFraction"_s;
     493    case WebCore::Atspi::Role::MathRoot:
     494        return "AXMathRoot"_s;
     495    case WebCore::Atspi::Role::Menu:
     496        return "AXMenu"_s;
     497    case WebCore::Atspi::Role::MenuBar:
     498        return "AXMenuBar"_s;
     499    case WebCore::Atspi::Role::MenuItem:
     500        return "AXMenuItem"_s;
     501    case WebCore::Atspi::Role::Notification:
     502        return "AXNotification"_s;
     503    case WebCore::Atspi::Role::PageTab:
     504        return "AXTab"_s;
     505    case WebCore::Atspi::Role::PageTabList:
     506        return "AXTabGroup"_s;
     507    case WebCore::Atspi::Role::Paragraph:
     508        return "AXParagraph"_s;
     509    case WebCore::Atspi::Role::PasswordText:
     510        return "AXPasswordField"_s;
     511    case WebCore::Atspi::Role::ProgressBar:
     512        return "AXProgressIndicator"_s;
     513    case WebCore::Atspi::Role::PushButton:
     514        return "AXButton"_s;
     515    case WebCore::Atspi::Role::RadioButton:
     516        return "AXRadioButton"_s;
     517    case WebCore::Atspi::Role::RadioMenuItem:
     518        return "AXRadioMenuItem"_s;
     519    case WebCore::Atspi::Role::RowHeader:
     520    case WebCore::Atspi::Role::TableRowHeader:
     521        return "AXRowHeader"_s;
     522    case WebCore::Atspi::Role::Ruler:
     523        return "AXRuler"_s;
     524    case WebCore::Atspi::Role::ScrollBar:
     525        return "AXScrollBar"_s;
     526    case WebCore::Atspi::Role::ScrollPane:
     527        return "AXScrollArea";
     528    case WebCore::Atspi::Role::Section:
     529        return "AXSection"_s;
     530    case WebCore::Atspi::Role::Separator:
     531        return "AXSeparator"_s;
     532    case WebCore::Atspi::Role::Slider:
     533        return "AXSlider"_s;
     534    case WebCore::Atspi::Role::SpinButton:
     535        return "AXSpinButton"_s;
     536    case WebCore::Atspi::Role::Static:
     537        return "AXStatic"_s;
     538    case WebCore::Atspi::Role::StatusBar:
     539        return "AXStatusBar"_s;
     540    case WebCore::Atspi::Role::Subscript:
     541        return "AXSubscript"_s;
     542    case WebCore::Atspi::Role::Superscript:
     543        return "AXSuperscript"_s;
     544    case WebCore::Atspi::Role::Table:
     545        return "AXTable"_s;
     546    case WebCore::Atspi::Role::TableCell:
     547        return "AXCell"_s;
     548    case WebCore::Atspi::Role::TableRow:
     549        return "AXRow"_s;
     550    case WebCore::Atspi::Role::Timer:
     551        return "AXTimer"_s;
     552    case WebCore::Atspi::Role::ToggleButton:
     553        return "AXToggleButton"_s;
     554    case WebCore::Atspi::Role::ToolBar:
     555        return "AXToolbar"_s;
     556    case WebCore::Atspi::Role::ToolTip:
     557        return "AXUserInterfaceTooltip"_s;
     558    case WebCore::Atspi::Role::Tree:
     559        return "AXTree"_s;
     560    case WebCore::Atspi::Role::TreeTable:
     561        return "AXTreeGrid"_s;
     562    case WebCore::Atspi::Role::TreeItem:
     563        return "AXTreeItem"_s;
     564    case WebCore::Atspi::Role::Unknown:
     565        return "AXUnknown"_s;
     566    case WebCore::Atspi::Role::Video:
     567        return "AXVideo"_s;
     568    case WebCore::Atspi::Role::Window:
     569        return "AXWindow"_s;
     570    default:
     571        break;
     572    }
     573
     574    return { };
     575}
     576
     577JSRetainPtr<JSStringRef> AccessibilityUIElement::role()
     578{
     579    unsigned roleValue;
     580    s_controller->executeOnAXThreadAndWait([this, &roleValue] {
     581        m_element->updateBackingStore();
     582        roleValue = m_element->role();
     583    });
     584    auto roleValueString = roleValueToString(roleValue);
     585    if (roleValueString.isEmpty())
     586        return JSStringCreateWithCharacters(0, 0);
     587
     588    return OpaqueJSString::tryCreate(makeString("AXRole: ", roleValueString)).leakRef();
     589}
     590
     591JSRetainPtr<JSStringRef> AccessibilityUIElement::subrole()
     592{
     593    return JSStringCreateWithCharacters(0, 0);
     594}
     595
     596JSRetainPtr<JSStringRef> AccessibilityUIElement::roleDescription()
     597{
     598    auto roleDescription = m_element->attributes().get("roledescription");
     599    return OpaqueJSString::tryCreate(makeString("AXRoleDescription: ", roleDescription)).leakRef();
     600}
     601
     602JSRetainPtr<JSStringRef> AccessibilityUIElement::computedRoleString()
     603{
     604    auto computedRole = m_element->attributes().get("computed-role");
     605    if (computedRole.isEmpty())
     606        return JSStringCreateWithCharacters(0, 0);
     607
     608    return OpaqueJSString::tryCreate(computedRole).leakRef();
     609}
     610
     611JSRetainPtr<JSStringRef> AccessibilityUIElement::title()
     612{
     613    String name;
     614    s_controller->executeOnAXThreadAndWait([this, &name] {
     615        m_element->updateBackingStore();
     616        name = String::fromUTF8(m_element->name().data());
     617    });
     618
     619    auto titleValue = makeString("AXTitle: ", name);
     620    return OpaqueJSString::tryCreate(titleValue).leakRef();
     621}
     622
     623JSRetainPtr<JSStringRef> AccessibilityUIElement::description()
     624{
     625    String description;
     626    s_controller->executeOnAXThreadAndWait([this, &description] {
     627        m_element->updateBackingStore();
     628        description = String::fromUTF8(m_element->description().data());
     629    });
     630
     631    auto descriptionValue = makeString("AXDescription: ", description);
     632    return OpaqueJSString::tryCreate(descriptionValue).leakRef();
     633}
     634
     635JSRetainPtr<JSStringRef> AccessibilityUIElement::orientation() const
     636{
     637    const char* orientation = nullptr;
     638    if (checkElementState(m_element.get(), WebCore::Atspi::State::Horizontal))
     639        orientation = "AXHorizontalOrientation";
     640    else if (checkElementState(m_element.get(), WebCore::Atspi::State::Vertical))
     641        orientation = "AXVerticalOrientation";
     642    else
     643        orientation = "AXUnknownOrientation";
     644
     645    auto orientationValue = makeString("AXOrientation: ", orientation);
     646    return OpaqueJSString::tryCreate(orientationValue).leakRef();
     647}
     648
     649JSRetainPtr<JSStringRef> AccessibilityUIElement::stringValue()
     650{
     651    if (!m_element->interfaces().contains(WebCore::AccessibilityObjectAtspi::Interface::Text))
     652        return JSStringCreateWithCharacters(0, 0);
     653
     654    m_element->updateBackingStore();
     655    auto value = makeString("AXValue: ", m_element->text().replace("\n", "<\\n>").replace(objectReplacementCharacter, "<obj>"));
     656    return OpaqueJSString::tryCreate(value).leakRef();
     657}
     658
     659JSRetainPtr<JSStringRef> AccessibilityUIElement::language()
     660{
     661    return JSStringCreateWithCharacters(0, 0);
     662}
     663
     664JSRetainPtr<JSStringRef> AccessibilityUIElement::helpText() const
     665{
     666    auto relationMap = m_element->relationMap();
     667    auto targets = relationMap.get(WebCore::Atspi::Relation::DescribedBy);
     668    if (targets.isEmpty())
     669        return JSStringCreateWithCharacters(0, 0);
     670
     671    StringBuilder builder;
     672    builder.append("AXHelp: ");
     673
     674    bool isFirst = true;
     675    for (const auto& target : targets) {
     676        if (!isFirst)
     677            builder.append(' ');
     678        isFirst = false;
     679        target->updateBackingStore();
     680        builder.append(target->text());
     681    }
     682
     683    return OpaqueJSString::tryCreate(builder.toString()).leakRef();
     684}
     685
     686double AccessibilityUIElement::x()
     687{
     688    return m_element->elementRect(WebCore::Atspi::CoordinateType::ScreenCoordinates).x();
     689}
     690
     691double AccessibilityUIElement::y()
     692{
     693    return m_element->elementRect(WebCore::Atspi::CoordinateType::ScreenCoordinates).y();
     694}
     695
     696double AccessibilityUIElement::width()
     697{
     698    return m_element->elementRect(WebCore::Atspi::CoordinateType::ScreenCoordinates).width();
     699}
     700
     701double AccessibilityUIElement::height()
     702{
     703    return m_element->elementRect(WebCore::Atspi::CoordinateType::ScreenCoordinates).height();
     704}
     705
     706double AccessibilityUIElement::clickPointX()
     707{
     708    auto rect = m_element->elementRect(WebCore::Atspi::CoordinateType::WindowCoordinates);
     709    return rect.center().x();
     710}
     711
     712double AccessibilityUIElement::clickPointY()
     713{
     714    auto rect = m_element->elementRect(WebCore::Atspi::CoordinateType::WindowCoordinates);
     715    return rect.center().y();
     716}
     717
     718double AccessibilityUIElement::intValue() const
    183719{
    184720    return 0;
    185721}
    186722
    187 JSValueRef AccessibilityUIElement::uiElementArrayAttributeValue(JSStringRef attribute) const
    188 {
    189     return nullptr;
    190 }
    191 
    192 JSValueRef AccessibilityUIElement::rowHeaders() const
    193 {
    194     return nullptr;
    195 }
    196 
    197 JSValueRef AccessibilityUIElement::columnHeaders() const
    198 {
    199     return nullptr;
    200 }
    201 
    202 RefPtr<AccessibilityUIElement> AccessibilityUIElement::uiElementAttributeValue(JSStringRef attribute) const
    203 {
    204     return nullptr;
    205 }
    206 
    207 bool AccessibilityUIElement::boolAttributeValue(JSStringRef attribute)
     723double AccessibilityUIElement::minValue()
     724{
     725    return 0;
     726}
     727
     728double AccessibilityUIElement::maxValue()
     729{
     730    return 0;
     731}
     732
     733JSRetainPtr<JSStringRef> AccessibilityUIElement::valueDescription()
     734{
     735    return JSStringCreateWithCharacters(0, 0);
     736}
     737
     738int AccessibilityUIElement::insertionPointLineNumber()
     739{
     740    return -1;
     741}
     742
     743bool AccessibilityUIElement::isPressActionSupported()
    208744{
    209745    return false;
    210746}
    211747
    212 bool AccessibilityUIElement::isAttributeSettable(JSStringRef attribute)
     748bool AccessibilityUIElement::isIncrementActionSupported()
    213749{
    214750    return false;
    215751}
    216752
    217 bool AccessibilityUIElement::isAttributeSupported(JSStringRef attribute)
     753bool AccessibilityUIElement::isDecrementActionSupported()
    218754{
    219755    return false;
    220756}
    221757
    222 JSRetainPtr<JSStringRef> AccessibilityUIElement::parameterizedAttributeNames()
    223 {
    224     return JSStringCreateWithCharacters(0, 0);
    225 }
    226 
    227 JSRetainPtr<JSStringRef> AccessibilityUIElement::role()
    228 {
    229     return JSStringCreateWithCharacters(0, 0);
    230 }
    231 
    232 JSRetainPtr<JSStringRef> AccessibilityUIElement::subrole()
    233 {
    234     return JSStringCreateWithCharacters(0, 0);
    235 }
    236 
    237 JSRetainPtr<JSStringRef> AccessibilityUIElement::roleDescription()
    238 {
    239     return JSStringCreateWithCharacters(0, 0);
    240 }
    241 
    242 JSRetainPtr<JSStringRef> AccessibilityUIElement::computedRoleString()
    243 {
    244     return JSStringCreateWithCharacters(0, 0);
    245 }
    246 
    247 JSRetainPtr<JSStringRef> AccessibilityUIElement::title()
    248 {
    249     return JSStringCreateWithCharacters(0, 0);
    250 }
    251 
    252 JSRetainPtr<JSStringRef> AccessibilityUIElement::description()
    253 {
    254     return JSStringCreateWithCharacters(0, 0);
    255 }
    256 
    257 JSRetainPtr<JSStringRef> AccessibilityUIElement::orientation() const
    258 {
    259     return JSStringCreateWithCharacters(0, 0);
    260 }
    261 
    262 JSRetainPtr<JSStringRef> AccessibilityUIElement::stringValue()
    263 {
    264     return JSStringCreateWithCharacters(0, 0);
    265 }
    266 
    267 JSRetainPtr<JSStringRef> AccessibilityUIElement::language()
    268 {
    269     return JSStringCreateWithCharacters(0, 0);
    270 }
    271 
    272 JSRetainPtr<JSStringRef> AccessibilityUIElement::helpText() const
    273 {
    274     return JSStringCreateWithCharacters(0, 0);
    275 }
    276 
    277 double AccessibilityUIElement::x()
     758bool AccessibilityUIElement::isEnabled()
     759{
     760    return checkElementState(m_element.get(), WebCore::Atspi::State::Enabled);
     761}
     762
     763bool AccessibilityUIElement::isRequired() const
     764{
     765    return checkElementState(m_element.get(), WebCore::Atspi::State::Required);
     766}
     767
     768bool AccessibilityUIElement::isFocused() const
     769{
     770    return checkElementState(m_element.get(), WebCore::Atspi::State::Focused);
     771}
     772
     773bool AccessibilityUIElement::isSelected() const
     774{
     775    return checkElementState(m_element.get(), WebCore::Atspi::State::Selected);
     776}
     777
     778bool AccessibilityUIElement::isSelectedOptionActive() const
     779{
     780    return checkElementState(m_element.get(), WebCore::Atspi::State::Active);
     781}
     782
     783bool AccessibilityUIElement::isExpanded() const
     784{
     785    return checkElementState(m_element.get(), WebCore::Atspi::State::Expanded);
     786}
     787
     788bool AccessibilityUIElement::isChecked() const
     789{
     790    return checkElementState(m_element.get(), WebCore::Atspi::State::Checked);
     791}
     792
     793bool AccessibilityUIElement::isIndeterminate() const
     794{
     795    return checkElementState(m_element.get(), WebCore::Atspi::State::Indeterminate);
     796}
     797
     798int AccessibilityUIElement::hierarchicalLevel() const
     799{
     800    auto level = m_element->attributes().get("level");
     801    if (level.isEmpty())
     802        return 0;
     803
     804    return parseIntegerAllowingTrailingJunk<int>(level).value_or(0);
     805}
     806
     807JSRetainPtr<JSStringRef> AccessibilityUIElement::speakAs()
     808{
     809    return JSStringCreateWithCharacters(0, 0);
     810}
     811
     812bool AccessibilityUIElement::ariaIsGrabbed() const
     813{
     814    return m_element->attributes().get("grabbed") == "true";
     815}
     816
     817JSRetainPtr<JSStringRef> AccessibilityUIElement::ariaDropEffects() const
     818{
     819    auto dropEffects = m_element->attributes().get("dropeffect");
     820    if (dropEffects.isEmpty())
     821        return JSStringCreateWithCharacters(0, 0);
     822    return OpaqueJSString::tryCreate(dropEffects).leakRef();
     823}
     824
     825int AccessibilityUIElement::lineForIndex(int index)
     826{
     827    if (!m_element->interfaces().contains(WebCore::AccessibilityObjectAtspi::Interface::Text))
     828        return -1;
     829
     830    m_element->updateBackingStore();
     831    auto text = m_element->text();
     832    if (index < 0 || index > static_cast<int>(text.length()))
     833        return -1;
     834
     835    int lineNumber = 0;
     836    for (int i = 0; i < index; ++i) {
     837        if (text[i] == '\n')
     838            lineNumber++;
     839    }
     840
     841    return lineNumber;
     842}
     843
     844JSRetainPtr<JSStringRef> AccessibilityUIElement::rangeForLine(int line)
     845{
     846    if (!m_element->interfaces().contains(WebCore::AccessibilityObjectAtspi::Interface::Text))
     847        return JSStringCreateWithCharacters(0, 0);
     848
     849    WebCore::IntPoint offset;
     850    for (int i = 0; i <= line; ++i)
     851        offset = m_element->boundaryOffset(offset.y(), WebCore::AccessibilityObjectAtspi::TextGranularity::LineStart);
     852
     853    auto range = makeString('{', offset.x(), ", ", offset.y() - offset.x(), '}');
     854    return OpaqueJSString::tryCreate(range).leakRef();
     855}
     856
     857JSRetainPtr<JSStringRef> AccessibilityUIElement::rangeForPosition(int x, int y)
     858{
     859    return JSStringCreateWithCharacters(0, 0);
     860}
     861
     862JSRetainPtr<JSStringRef> AccessibilityUIElement::boundsForRange(unsigned location, unsigned length)
     863{
     864    if (!m_element->interfaces().contains(WebCore::AccessibilityObjectAtspi::Interface::Text))
     865        return JSStringCreateWithCharacters(0, 0);
     866
     867    auto rect = m_element->boundsForRange(location, length, WebCore::Atspi::CoordinateType::WindowCoordinates);
     868    auto bounds = makeString('{', rect.x(), ", ", rect.y(), ", ", rect.width(), ", ", rect.height(), '}');
     869    return OpaqueJSString::tryCreate(bounds).leakRef();
     870}
     871
     872JSRetainPtr<JSStringRef> AccessibilityUIElement::stringForRange(unsigned location, unsigned length)
     873{
     874    if (!m_element->interfaces().contains(WebCore::AccessibilityObjectAtspi::Interface::Text))
     875        return JSStringCreateWithCharacters(0, 0);
     876
     877    m_element->updateBackingStore();
     878    return OpaqueJSString::tryCreate(m_element->text().substring(location, length)).leakRef();
     879}
     880
     881JSRetainPtr<JSStringRef> AccessibilityUIElement::attributedStringForRange(unsigned location, unsigned length)
     882{
     883    if (!m_element->interfaces().contains(WebCore::AccessibilityObjectAtspi::Interface::Text))
     884        return JSStringCreateWithCharacters(0, 0);
     885
     886    StringBuilder builder;
     887
     888    auto buildAttributes = [&](const WebCore::AccessibilityObjectAtspi::TextAttributes& attributes) {
     889        for (const auto& it : attributes.attributes) {
     890            builder.append("\n\t\t");
     891            builder.append(it.key, ':', it.value);
     892        }
     893    };
     894
     895    builder.append("\n\tDefault text attributes:");
     896    buildAttributes(m_element->textAttributes());
     897
     898    auto text = m_element->text();
     899    int endOffset = 0;
     900    for (unsigned i = location; i < location + length; i = endOffset) {
     901        auto attributes = m_element->textAttributes(i);
     902        auto rangeStart = std::max<int>(location, attributes.startOffset);
     903        auto rangeEnd = std::min<int>(location + length, attributes.endOffset);
     904        builder.append("\n\tRange attributes for '", text.substring(rangeStart, rangeEnd - rangeStart).replace("\n", "<\\n>").replace(objectReplacementCharacter, "<obj>"), "':");
     905        buildAttributes(attributes);
     906        endOffset = attributes.endOffset;
     907    }
     908
     909    return OpaqueJSString::tryCreate(builder.toString()).leakRef();
     910}
     911
     912bool AccessibilityUIElement::attributedStringRangeIsMisspelled(unsigned location, unsigned length)
     913{
     914    return false;
     915}
     916
     917unsigned AccessibilityUIElement::uiElementCountForSearchPredicate(JSContextRef context, AccessibilityUIElement* startElement, bool isDirectionNext, JSValueRef searchKey, JSStringRef searchText, bool visibleOnly, bool immediateDescendantsOnly)
    278918{
    279919    return 0;
    280920}
    281921
    282 double AccessibilityUIElement::y()
     922RefPtr<AccessibilityUIElement> AccessibilityUIElement::uiElementForSearchPredicate(JSContextRef context, AccessibilityUIElement* startElement, bool isDirectionNext, JSValueRef searchKey, JSStringRef searchText, bool visibleOnly, bool immediateDescendantsOnly)
     923{
     924    return nullptr;
     925}
     926
     927JSRetainPtr<JSStringRef> AccessibilityUIElement::selectTextWithCriteria(JSContextRef context, JSStringRef ambiguityResolution, JSValueRef searchStrings, JSStringRef replacementString, JSStringRef activity)
     928{
     929    return nullptr;
     930}
     931
     932JSRetainPtr<JSStringRef> AccessibilityUIElement::attributesOfColumnHeaders()
     933{
     934    return JSStringCreateWithCharacters(0, 0);
     935}
     936
     937JSRetainPtr<JSStringRef> AccessibilityUIElement::attributesOfRowHeaders()
     938{
     939    return JSStringCreateWithCharacters(0, 0);
     940}
     941
     942JSRetainPtr<JSStringRef> AccessibilityUIElement::attributesOfColumns()
     943{
     944    return JSStringCreateWithCharacters(0, 0);
     945}
     946
     947JSRetainPtr<JSStringRef> AccessibilityUIElement::attributesOfRows()
     948{
     949    return JSStringCreateWithCharacters(0, 0);
     950}
     951
     952JSRetainPtr<JSStringRef> AccessibilityUIElement::attributesOfVisibleCells()
     953{
     954    return JSStringCreateWithCharacters(0, 0);
     955}
     956
     957JSRetainPtr<JSStringRef> AccessibilityUIElement::attributesOfHeader()
     958{
     959    return JSStringCreateWithCharacters(0, 0);
     960}
     961
     962int AccessibilityUIElement::rowCount()
    283963{
    284964    return 0;
    285965}
    286966
    287 double AccessibilityUIElement::width()
     967int AccessibilityUIElement::columnCount()
    288968{
    289969    return 0;
    290970}
    291971
    292 double AccessibilityUIElement::height()
    293 {
    294     return 0;
    295 }
    296 
    297 double AccessibilityUIElement::clickPointX()
    298 {
    299     return 0;
    300 }
    301 
    302 double AccessibilityUIElement::clickPointY()
    303 {
    304     return 0;
    305 }
    306 
    307 double AccessibilityUIElement::intValue() const
    308 {
    309     return 0;
    310 }
    311 
    312 double AccessibilityUIElement::minValue()
    313 {
    314     return 0;
    315 }
    316 
    317 double AccessibilityUIElement::maxValue()
    318 {
    319     return 0;
    320 }
    321 
    322 JSRetainPtr<JSStringRef> AccessibilityUIElement::valueDescription()
    323 {
    324     return JSStringCreateWithCharacters(0, 0);
    325 }
    326 
    327 int AccessibilityUIElement::insertionPointLineNumber()
     972int AccessibilityUIElement::indexInTable()
    328973{
    329974    return -1;
    330975}
    331976
    332 bool AccessibilityUIElement::isPressActionSupported()
     977JSRetainPtr<JSStringRef> AccessibilityUIElement::rowIndexRange()
     978{
     979    return JSStringCreateWithCharacters(0, 0);
     980}
     981
     982JSRetainPtr<JSStringRef> AccessibilityUIElement::columnIndexRange()
     983{
     984    return JSStringCreateWithCharacters(0, 0);
     985}
     986
     987RefPtr<AccessibilityUIElement> AccessibilityUIElement::cellForColumnAndRow(unsigned col, unsigned row)
     988{
     989    return nullptr;
     990}
     991
     992RefPtr<AccessibilityUIElement> AccessibilityUIElement::horizontalScrollbar() const
     993{
     994    return nullptr;
     995}
     996
     997RefPtr<AccessibilityUIElement> AccessibilityUIElement::verticalScrollbar() const
     998{
     999    return nullptr;
     1000}
     1001
     1002JSRetainPtr<JSStringRef> AccessibilityUIElement::selectedTextRange()
     1003{
     1004    if (!m_element->interfaces().contains(WebCore::AccessibilityObjectAtspi::Interface::Text))
     1005        return JSStringCreateWithCharacters(0, 0);
     1006
     1007    auto offset = m_element->selectedRange();
     1008    auto range = makeString('{', offset.x(), ", ", offset.y() - offset.x(), '}');
     1009    return OpaqueJSString::tryCreate(range).leakRef();
     1010}
     1011
     1012bool AccessibilityUIElement::setSelectedTextRange(unsigned location, unsigned length)
     1013{
     1014    if (!m_element->interfaces().contains(WebCore::AccessibilityObjectAtspi::Interface::Text))
     1015        return false;
     1016
     1017    m_element->updateBackingStore();
     1018    auto textLength = m_element->text().length();
     1019    m_element->setSelectedRange(std::min(location, textLength), std::min(length, textLength));
     1020    return true;
     1021}
     1022
     1023void AccessibilityUIElement::increment()
     1024{
     1025}
     1026
     1027void AccessibilityUIElement::decrement()
     1028{
     1029}
     1030
     1031void AccessibilityUIElement::showMenu()
     1032{
     1033}
     1034
     1035void AccessibilityUIElement::press()
     1036{
     1037}
     1038
     1039void AccessibilityUIElement::setSelectedChild(AccessibilityUIElement* element) const
     1040{
     1041}
     1042
     1043void AccessibilityUIElement::setSelectedChildAtIndex(unsigned index) const
     1044{
     1045}
     1046
     1047void AccessibilityUIElement::removeSelectionAtIndex(unsigned index) const
     1048{
     1049}
     1050
     1051void AccessibilityUIElement::clearSelectedChildren() const
     1052{
     1053}
     1054
     1055JSRetainPtr<JSStringRef> AccessibilityUIElement::accessibilityValue() const
     1056{
     1057    return JSStringCreateWithCharacters(0, 0);
     1058}
     1059
     1060JSRetainPtr<JSStringRef> AccessibilityUIElement::documentEncoding()
     1061{
     1062    return JSStringCreateWithCharacters(0, 0);
     1063}
     1064
     1065JSRetainPtr<JSStringRef> AccessibilityUIElement::documentURI()
     1066{
     1067    return JSStringCreateWithCharacters(0, 0);
     1068}
     1069
     1070JSRetainPtr<JSStringRef> AccessibilityUIElement::url()
     1071{
     1072    return JSStringCreateWithCharacters(0, 0);
     1073}
     1074
     1075bool AccessibilityUIElement::addNotificationListener(JSValueRef functionCallback)
    3331076{
    3341077    return false;
    3351078}
    3361079
    337 bool AccessibilityUIElement::isIncrementActionSupported()
     1080bool AccessibilityUIElement::removeNotificationListener()
     1081{
     1082    return true;
     1083}
     1084
     1085bool AccessibilityUIElement::isFocusable() const
     1086{
     1087    return checkElementState(m_element.get(), WebCore::Atspi::State::Focusable);
     1088}
     1089
     1090bool AccessibilityUIElement::isSelectable() const
     1091{
     1092    return checkElementState(m_element.get(), WebCore::Atspi::State::Selectable);
     1093}
     1094
     1095bool AccessibilityUIElement::isMultiSelectable() const
     1096{
     1097    return checkElementState(m_element.get(), WebCore::Atspi::State::Multiselectable);
     1098}
     1099
     1100bool AccessibilityUIElement::isVisible() const
     1101{
     1102    return checkElementState(m_element.get(), WebCore::Atspi::State::Visible);
     1103}
     1104
     1105bool AccessibilityUIElement::isOffScreen() const
     1106{
     1107    return !checkElementState(m_element.get(), WebCore::Atspi::State::Showing);
     1108}
     1109
     1110bool AccessibilityUIElement::isCollapsed() const
     1111{
     1112    return checkElementState(m_element.get(), WebCore::Atspi::State::Collapsed);
     1113}
     1114
     1115bool AccessibilityUIElement::isIgnored() const
    3381116{
    3391117    return false;
    3401118}
    3411119
    342 bool AccessibilityUIElement::isDecrementActionSupported()
    343 {
    344     return false;
    345 }
    346 
    347 bool AccessibilityUIElement::isEnabled()
    348 {
    349     return false;
    350 }
    351 
    352 bool AccessibilityUIElement::isRequired() const
    353 {
    354     return false;
    355 }
    356 
    357 bool AccessibilityUIElement::isFocused() const
    358 {
    359     return false;
    360 }
    361 
    362 bool AccessibilityUIElement::isSelected() const
    363 {
    364     return false;
    365 }
    366 
    367 bool AccessibilityUIElement::isSelectedOptionActive() const
    368 {
    369     return false;
    370 }
    371 
    372 bool AccessibilityUIElement::isExpanded() const
    373 {
    374     return false;
    375 }
    376 
    377 bool AccessibilityUIElement::isChecked() const
    378 {
    379     return false;
    380 }
    381 
    382 bool AccessibilityUIElement::isIndeterminate() const
    383 {
    384     return false;
    385 }
    386 
    387 int AccessibilityUIElement::hierarchicalLevel() const
    388 {
    389     return false;
    390 }
    391 
    392 JSRetainPtr<JSStringRef> AccessibilityUIElement::speakAs()
    393 {
    394     return JSStringCreateWithCharacters(0, 0);
    395 }
    396 
    397 bool AccessibilityUIElement::ariaIsGrabbed() const
    398 {
    399     return false;
    400 }
    401 
    402 JSRetainPtr<JSStringRef> AccessibilityUIElement::ariaDropEffects() const
    403 {
    404     return JSStringCreateWithCharacters(0, 0);
    405 }
    406 
    407 int AccessibilityUIElement::lineForIndex(int index)
    408 {
    409     return -1;
    410 }
    411 
    412 JSRetainPtr<JSStringRef> AccessibilityUIElement::rangeForLine(int line)
    413 {
    414     return JSStringCreateWithCharacters(0, 0);
    415 }
    416 
    417 JSRetainPtr<JSStringRef> AccessibilityUIElement::rangeForPosition(int x, int y)
    418 {
    419     return JSStringCreateWithCharacters(0, 0);
    420 }
    421 
    422 JSRetainPtr<JSStringRef> AccessibilityUIElement::boundsForRange(unsigned location, unsigned length)
    423 {
    424     return JSStringCreateWithCharacters(0, 0);
    425 }
    426 
    427 JSRetainPtr<JSStringRef> AccessibilityUIElement::stringForRange(unsigned location, unsigned length)
    428 {
    429     return JSStringCreateWithCharacters(0, 0);
    430 }
    431 
    432 JSRetainPtr<JSStringRef> AccessibilityUIElement::attributedStringForRange(unsigned location, unsigned length)
    433 {
    434     return JSStringCreateWithCharacters(0, 0);
    435 }
    436 
    437 bool AccessibilityUIElement::attributedStringRangeIsMisspelled(unsigned location, unsigned length)
    438 {
    439     return false;
    440 }
    441 
    442 unsigned AccessibilityUIElement::uiElementCountForSearchPredicate(JSContextRef context, AccessibilityUIElement* startElement, bool isDirectionNext, JSValueRef searchKey, JSStringRef searchText, bool visibleOnly, bool immediateDescendantsOnly)
    443 {
    444     return 0;
    445 }
    446 
    447 RefPtr<AccessibilityUIElement> AccessibilityUIElement::uiElementForSearchPredicate(JSContextRef context, AccessibilityUIElement* startElement, bool isDirectionNext, JSValueRef searchKey, JSStringRef searchText, bool visibleOnly, bool immediateDescendantsOnly)
    448 {
    449     return nullptr;
    450 }
    451 
    452 JSRetainPtr<JSStringRef> AccessibilityUIElement::selectTextWithCriteria(JSContextRef context, JSStringRef ambiguityResolution, JSValueRef searchStrings, JSStringRef replacementString, JSStringRef activity)
    453 {
    454     return nullptr;
    455 }
    456 
    457 JSRetainPtr<JSStringRef> AccessibilityUIElement::attributesOfColumnHeaders()
    458 {
    459     return JSStringCreateWithCharacters(0, 0);
    460 }
    461 
    462 JSRetainPtr<JSStringRef> AccessibilityUIElement::attributesOfRowHeaders()
    463 {
    464     return JSStringCreateWithCharacters(0, 0);
    465 }
    466 
    467 JSRetainPtr<JSStringRef> AccessibilityUIElement::attributesOfColumns()
    468 {
    469     return JSStringCreateWithCharacters(0, 0);
    470 }
    471 
    472 JSRetainPtr<JSStringRef> AccessibilityUIElement::attributesOfRows()
    473 {
    474     return JSStringCreateWithCharacters(0, 0);
    475 }
    476 
    477 JSRetainPtr<JSStringRef> AccessibilityUIElement::attributesOfVisibleCells()
    478 {
    479     return JSStringCreateWithCharacters(0, 0);
    480 }
    481 
    482 JSRetainPtr<JSStringRef> AccessibilityUIElement::attributesOfHeader()
    483 {
    484     return JSStringCreateWithCharacters(0, 0);
    485 }
    486 
    487 int AccessibilityUIElement::rowCount()
    488 {
    489     return 0;
    490 }
    491 
    492 int AccessibilityUIElement::columnCount()
    493 {
    494     return 0;
    495 }
    496 
    497 int AccessibilityUIElement::indexInTable()
    498 {
    499     return -1;
    500 }
    501 
    502 JSRetainPtr<JSStringRef> AccessibilityUIElement::rowIndexRange()
    503 {
    504     return JSStringCreateWithCharacters(0, 0);
    505 }
    506 
    507 JSRetainPtr<JSStringRef> AccessibilityUIElement::columnIndexRange()
    508 {
    509     return JSStringCreateWithCharacters(0, 0);
    510 }
    511 
    512 RefPtr<AccessibilityUIElement> AccessibilityUIElement::cellForColumnAndRow(unsigned col, unsigned row)
    513 {
    514     return nullptr;
    515 }
    516 
    517 RefPtr<AccessibilityUIElement> AccessibilityUIElement::horizontalScrollbar() const
    518 {
    519     return nullptr;
    520 }
    521 
    522 RefPtr<AccessibilityUIElement> AccessibilityUIElement::verticalScrollbar() const
    523 {
    524     return nullptr;
    525 }
    526 
    527 JSRetainPtr<JSStringRef> AccessibilityUIElement::selectedTextRange()
    528 {
    529     return JSStringCreateWithCharacters(0, 0);
    530 }
    531 
    532 bool AccessibilityUIElement::setSelectedTextRange(unsigned location, unsigned length)
    533 {
    534     return false;
    535 }
    536 
    537 void AccessibilityUIElement::increment()
    538 {
    539 }
    540 
    541 void AccessibilityUIElement::decrement()
    542 {
    543 }
    544 
    545 void AccessibilityUIElement::showMenu()
    546 {
    547 }
    548 
    549 void AccessibilityUIElement::press()
    550 {
    551 }
    552 
    553 void AccessibilityUIElement::setSelectedChild(AccessibilityUIElement* element) const
    554 {
    555 }
    556 
    557 void AccessibilityUIElement::setSelectedChildAtIndex(unsigned index) const
    558 {
    559 }
    560 
    561 void AccessibilityUIElement::removeSelectionAtIndex(unsigned index) const
    562 {
    563 }
    564 
    565 void AccessibilityUIElement::clearSelectedChildren() const
    566 {
    567 }
    568 
    569 JSRetainPtr<JSStringRef> AccessibilityUIElement::accessibilityValue() const
    570 {
    571     return JSStringCreateWithCharacters(0, 0);
    572 }
    573 
    574 JSRetainPtr<JSStringRef> AccessibilityUIElement::documentEncoding()
    575 {
    576     return JSStringCreateWithCharacters(0, 0);
    577 }
    578 
    579 JSRetainPtr<JSStringRef> AccessibilityUIElement::documentURI()
    580 {
    581     return JSStringCreateWithCharacters(0, 0);
    582 }
    583 
    584 JSRetainPtr<JSStringRef> AccessibilityUIElement::url()
    585 {
    586     return JSStringCreateWithCharacters(0, 0);
    587 }
    588 
    589 bool AccessibilityUIElement::addNotificationListener(JSValueRef functionCallback)
    590 {
    591     return false;
    592 }
    593 
    594 bool AccessibilityUIElement::removeNotificationListener()
    595 {
    596     return true;
    597 }
    598 
    599 bool AccessibilityUIElement::isFocusable() const
    600 {
    601     return false;
    602 }
    603 
    604 bool AccessibilityUIElement::isSelectable() const
    605 {
    606     return false;
    607 }
    608 
    609 bool AccessibilityUIElement::isMultiSelectable() const
    610 {
    611     return false;
    612 }
    613 
    614 bool AccessibilityUIElement::isVisible() const
    615 {
    616     return false;
    617 }
    618 
    619 bool AccessibilityUIElement::isOffScreen() const
    620 {
    621     return false;
    622 }
    623 
    624 bool AccessibilityUIElement::isCollapsed() const
    625 {
    626     return false;
    627 }
    628 
    629 bool AccessibilityUIElement::isIgnored() const
    630 {
    631     return false;
    632 }
    633 
    6341120bool AccessibilityUIElement::isSingleLine() const
    6351121{
    636     return false;
     1122    return checkElementState(m_element.get(), WebCore::Atspi::State::SingleLine);
    6371123}
    6381124
    6391125bool AccessibilityUIElement::isMultiLine() const
    6401126{
    641     return false;
     1127    return checkElementState(m_element.get(), WebCore::Atspi::State::MultiLine);
    6421128}
    6431129
    6441130bool AccessibilityUIElement::hasPopup() const
    6451131{
    646     return false;
     1132    return checkElementState(m_element.get(), WebCore::Atspi::State::HasPopup);
    6471133}
    6481134
    … …  
    7811267void AccessibilityUIElement::scrollToMakeVisible()
    7821268{
     1269    m_element->scrollToMakeVisible(WebCore::Atspi::ScrollType::Anywhere);
    7831270}
    7841271
    7851272void AccessibilityUIElement::scrollToGlobalPoint(int x, int y)
    7861273{
     1274    m_element->scrollToPoint({ x, y }, WebCore::Atspi::CoordinateType::WindowCoordinates);
    7871275}
    7881276
    … …  
    8161304}
    8171305
     1306static String stringAtOffset(WebCore::AccessibilityObjectAtspi* element, int offset, WebCore::AccessibilityObjectAtspi::TextGranularity granularity)
     1307{
     1308    if (!element || !element->interfaces().contains(WebCore::AccessibilityObjectAtspi::Interface::Text))
     1309        return { };
     1310
     1311    element->updateBackingStore();
     1312    auto text = element->text();
     1313    if (offset < 0 || offset > static_cast<int>(text.length()))
     1314        return { };
     1315
     1316    auto bounds = element->boundaryOffset(offset, granularity);
     1317    unsigned startOffset = std::max<int>(bounds.x(), 0);
     1318    unsigned endOffset = std::min<int>(bounds.y(), text.length());
     1319    return makeString(text.substring(startOffset, endOffset - startOffset), ", ", startOffset, ", ", endOffset);
     1320}
     1321
    8181322JSRetainPtr<JSStringRef> AccessibilityUIElement::characterAtOffset(int offset)
    8191323{
    820     return JSStringCreateWithCharacters(0, 0);
     1324    if (!m_element->interfaces().contains(WebCore::AccessibilityObjectAtspi::Interface::Text))
     1325        return JSStringCreateWithCharacters(0, 0);
     1326
     1327    m_element->updateBackingStore();
     1328    auto text = m_element->text();
     1329    if (offset < 0 || offset > static_cast<int>(text.length()))
     1330        return JSStringCreateWithCharacters(0, 0);
     1331
     1332    auto string = makeString(text.substring(offset, 1), ", ", offset, ", ", offset + 1);
     1333    return OpaqueJSString::tryCreate(string).leakRef();
    8211334}
    8221335
    8231336JSRetainPtr<JSStringRef> AccessibilityUIElement::wordAtOffset(int offset)
    8241337{
    825     return JSStringCreateWithCharacters(0, 0);
     1338    return OpaqueJSString::tryCreate(stringAtOffset(m_element.get(), offset, WebCore::AccessibilityObjectAtspi::TextGranularity::WordStart)).leakRef();
    8261339}
    8271340
    8281341JSRetainPtr<JSStringRef> AccessibilityUIElement::lineAtOffset(int offset)
    8291342{
    830     return JSStringCreateWithCharacters(0, 0);
     1343    return OpaqueJSString::tryCreate(stringAtOffset(m_element.get(), offset, WebCore::AccessibilityObjectAtspi::TextGranularity::LineStart)).leakRef();
    8311344}
    8321345
    8331346JSRetainPtr<JSStringRef> AccessibilityUIElement::sentenceAtOffset(int offset)
    8341347{
    835     return JSStringCreateWithCharacters(0, 0);
     1348    return OpaqueJSString::tryCreate(stringAtOffset(m_element.get(), offset, WebCore::AccessibilityObjectAtspi::TextGranularity::SentenceStart)).leakRef();
    8361349}
    8371350

  • trunk/Tools/WebKitTestRunner/gtk/main.cpp

    r283876 r285996  
    3434{
    3535    g_setenv("WEBKIT_DISABLE_MEMORY_PRESSURE_MONITOR", "1", FALSE);
     36    g_setenv("WEBKIT_A11Y_BUS_ADDRESS", "", FALSE);
    3637
    3738    gtk_init(&argc, &argv);
Note: See TracChangeset for help on using the changeset viewer.