File webkit2gtk3-restore-atk.patch of Package webkit2gtk3.30069
diff -urpN webkitgtk-2.39.91.glib244/Source/cmake/OptionsGTK.cmake webkitgtk-2.39.91.atk/Source/cmake/OptionsGTK.cmake
--- webkitgtk-2.39.91.glib244/Source/cmake/OptionsGTK.cmake 2023-03-09 13:26:06.418428134 -0600
+++ webkitgtk-2.39.91.atk/Source/cmake/OptionsGTK.cmake 2023-03-09 13:26:47.258643737 -0600
@@ -27,6 +27,7 @@ find_package(SQLite3 REQUIRED)
find_package(Threads REQUIRED)
find_package(Unifdef REQUIRED)
find_package(ZLIB REQUIRED)
+find_package(ATK 2.16.0 REQUIRED)
find_package(WebP REQUIRED COMPONENTS demux)
find_package(ATSPI 2.5.3)
find_package(EGL)
@@ -287,7 +288,17 @@ if (NOT EXISTS "${TOOLS_DIR}/glib/apply-
set(BUILD_REVISION "tarball")
endif ()
-SET_AND_EXPOSE_TO_BUILD(USE_ATSPI ${ENABLE_ACCESSIBILITY})
+if (ENABLE_ACCESSIBILITY)
+ if (USE_ATSPI)
+ SET_AND_EXPOSE_TO_BUILD(USE_ATK FALSE)
+ else ()
+ SET_AND_EXPOSE_TO_BUILD(USE_ATK TRUE)
+ endif ()
+else ()
+ SET_AND_EXPOSE_TO_BUILD(USE_ATK FALSE)
+ SET_AND_EXPOSE_TO_BUILD(USE_ATSPI FALSE)
+endif ()
+
SET_AND_EXPOSE_TO_BUILD(HAVE_GTK_UNIX_PRINTING ${GTK_UNIX_PRINT_FOUND})
SET_AND_EXPOSE_TO_BUILD(HAVE_OS_DARK_MODE_SUPPORT 1)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/AccessibilityList.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/AccessibilityList.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/AccessibilityList.cpp 2023-02-20 03:22:15.241729000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/AccessibilityList.cpp 2023-03-09 13:26:47.258643737 -0600
@@ -117,7 +117,7 @@ bool AccessibilityList::childHasPseudoVi
// Platforms which expose rendered text content through the parent element will treat
// those renderers as "ignored" objects.
-#if USE(ATSPI)
+#if USE(ATK) || USE(ATSPI)
String text = axObj->textUnderElement();
return !text.isEmpty() && !text.isAllSpecialCharacters<isHTMLSpace>();
#else
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/AccessibilityNodeObject.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/AccessibilityNodeObject.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/AccessibilityNodeObject.cpp 2023-02-20 03:22:15.261729200 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/AccessibilityNodeObject.cpp 2023-03-09 13:26:47.258643737 -0600
@@ -2520,8 +2520,8 @@ bool AccessibilityNodeObject::canSetValu
if (isProgressIndicator() || isSlider() || isScrollbar())
return true;
-#if USE(ATSPI)
- // In ATSPI, input types which support aria-readonly are treated as having a
+#if USE(ATK) || USE(ATSPI)
+ // In ATK, input types which support aria-readonly are treated as having a
// settable value if the user can modify the widget's value or its state.
if (supportsReadOnly())
return true;
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/AccessibilityObject.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/AccessibilityObject.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/AccessibilityObject.cpp 2023-03-03 03:33:24.892969400 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/AccessibilityObject.cpp 2023-03-09 13:26:47.262643759 -0600
@@ -3572,8 +3572,8 @@ TextIteratorBehaviors AccessibilityObjec
{
TextIteratorBehaviors behaviors { TextIteratorBehavior::IgnoresStyleVisibility };
-#if USE(ATSPI)
- // We need to emit replaced elements for ATSPI, and present
+#if USE(ATK) || USE(ATSPI)
+ // We need to emit replaced elements for GTK, and present
// them with the 'object replacement character' (0xFFFC).
behaviors.add(TextIteratorBehavior::EmitsObjectReplacementCharacters);
#endif
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/AccessibilityObject.h webkitgtk-2.39.91.atk/Source/WebCore/accessibility/AccessibilityObject.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/AccessibilityObject.h 2023-02-20 03:22:15.265729200 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/AccessibilityObject.h 2023-03-09 13:26:47.266643779 -0600
@@ -42,6 +42,10 @@
#include <wtf/RetainPtr.h>
#endif
+#if USE(ATK)
+#include <wtf/glib/GRefPtr.h>
+#endif
+
#if PLATFORM(COCOA)
OBJC_CLASS NSArray;
@@ -869,7 +873,7 @@ inline void AccessibilityObject::updateB
inline void AccessibilityObject::detachPlatformWrapper(AccessibilityDetachmentType) { }
#endif
-#if !(ENABLE(ACCESSIBILITY) && USE(ATSPI))
+#if !(ENABLE(ACCESSIBILITY) && (USE(ATK) || USE(ATSPI)))
inline bool AccessibilityObject::allowsTextRanges() const { return true; }
inline unsigned AccessibilityObject::getLengthForTextRange() const { return text().length(); }
#endif
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/AccessibilityObjectInterface.h webkitgtk-2.39.91.atk/Source/WebCore/accessibility/AccessibilityObjectInterface.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/AccessibilityObjectInterface.h 2023-02-20 03:22:15.265729200 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/AccessibilityObjectInterface.h 2023-03-09 13:26:47.266643779 -0600
@@ -48,6 +48,10 @@
#include "AccessibilityObjectAtspi.h"
#endif
+#if USE(ATK)
+#include <wtf/glib/GRefPtr.h>
+#endif
+
#if PLATFORM(COCOA)
OBJC_CLASS WebAccessibilityObjectWrapper;
typedef WebAccessibilityObjectWrapper AccessibilityObjectWrapper;
@@ -56,6 +60,9 @@ typedef const struct __AXTextMarker* AXT
typedef const struct __AXTextMarkerRange* AXTextMarkerRangeRef;
#elif USE(ATSPI)
typedef WebCore::AccessibilityObjectAtspi AccessibilityObjectWrapper;
+#elif USE(ATK)
+typedef struct _WebKitAccessible WebKitAccessible;
+typedef struct _WebKitAccessible AccessibilityObjectWrapper;
#else
class AccessibilityObjectWrapper;
#endif
@@ -1430,6 +1437,8 @@ private:
COMPtr<AccessibilityObjectWrapper> m_wrapper;
#elif USE(ATSPI)
RefPtr<AccessibilityObjectAtspi> m_wrapper;
+#elif USE(ATK)
+ GRefPtr<WebKitAccessible> m_wrapper;
#endif
};
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/AccessibilityRenderObject.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/AccessibilityRenderObject.cpp 2023-03-03 03:33:24.896969600 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp 2023-03-09 13:26:47.270643800 -0600
@@ -2075,6 +2075,8 @@ int AccessibilityRenderObject::indexForV
TextIteratorBehaviors behaviors;
#if USE(ATSPI)
behaviors.add(TextIteratorBehavior::EmitsObjectReplacementCharacters);
+#elif USE(ATK)
+ behaviors.add(TextIteratorBehavior::EmitsCharactersBetweenAllVisiblePositions);
#endif
return WebCore::indexForVisiblePosition(*node, position, behaviors);
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/AccessibilityTableColumn.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/AccessibilityTableColumn.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/AccessibilityTableColumn.cpp 2023-02-20 03:22:15.277729300 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/AccessibilityTableColumn.cpp 2023-03-09 13:26:47.270643800 -0600
@@ -172,7 +172,7 @@ bool AccessibilityTableColumn::computeAc
if (!m_parent)
return true;
-#if PLATFORM(IOS_FAMILY) || USE(ATSPI)
+#if PLATFORM(IOS_FAMILY) || USE(ATK) || USE(ATSPI)
return true;
#endif
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/AccessibilityTableHeaderContainer.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/AccessibilityTableHeaderContainer.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/AccessibilityTableHeaderContainer.cpp 2023-02-20 03:22:15.277729300 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/AccessibilityTableHeaderContainer.cpp 2023-03-09 13:26:47.270643800 -0600
@@ -54,7 +54,7 @@ bool AccessibilityTableHeaderContainer::
if (!m_parent)
return true;
-#if PLATFORM(IOS_FAMILY) || USE(ATSPI)
+#if PLATFORM(IOS_FAMILY) || USE(ATK) || USE(ATSPI)
return true;
#endif
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/AccessibilityObjectAtk.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/AccessibilityObjectAtk.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/AccessibilityObjectAtk.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/AccessibilityObjectAtk.cpp 2023-03-09 13:26:47.274643822 -0600
@@ -0,0 +1,209 @@
+/*
+ * Copyright (C) 2008 Apple Ltd.
+ * Copyright (C) 2008 Alp Toker <alp@atoker.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "AccessibilityObject.h"
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include "AXObjectCache.h"
+#include "HTMLSpanElement.h"
+#include "RenderBlock.h"
+#include "RenderInline.h"
+#include "RenderIterator.h"
+#include "RenderTableCell.h"
+#include "RenderText.h"
+#include "TextControlInnerElements.h"
+#include "WebKitAccessible.h"
+#include <glib-object.h>
+
+namespace WebCore {
+
+void AccessibilityObject::detachPlatformWrapper(AccessibilityDetachmentType detachmentType)
+{
+ if (detachmentType != AccessibilityDetachmentType::CacheDestroyed) {
+ if (auto* cache = axObjectCache()) {
+ cache->detachWrapper(this, detachmentType);
+ return;
+ }
+ }
+
+ auto* wrapper = this->wrapper();
+ ASSERT(wrapper);
+ webkitAccessibleDetach(WEBKIT_ACCESSIBLE(wrapper));
+}
+
+bool AccessibilityObject::accessibilityIgnoreAttachment() const
+{
+ return false;
+}
+
+AccessibilityObjectInclusion AccessibilityObject::accessibilityPlatformIncludesObject() const
+{
+ AccessibilityObject* parent = parentObject();
+ if (!parent)
+ return AccessibilityObjectInclusion::DefaultBehavior;
+
+ // If the author has provided a role, platform-specific inclusion likely doesn't apply.
+ if (ariaRoleAttribute() != AccessibilityRole::Unknown)
+ return AccessibilityObjectInclusion::DefaultBehavior;
+
+ AccessibilityRole role = roleValue();
+ // We expose the slider as a whole but not its value indicator.
+ if (role == AccessibilityRole::SliderThumb)
+ return AccessibilityObjectInclusion::IgnoreObject;
+
+ // When a list item is made up entirely of children (e.g. paragraphs)
+ // the list item gets ignored. We need it.
+ if (isGroup() && parent->isList())
+ return AccessibilityObjectInclusion::IncludeObject;
+
+ // Entries and password fields have extraneous children which we want to ignore.
+ if (parent->isPasswordField() || parent->isTextControl())
+ return AccessibilityObjectInclusion::IgnoreObject;
+
+ // Include all tables, even layout tables. The AT can decide what to do with each.
+ if (role == AccessibilityRole::Cell || role == AccessibilityRole::Table || role == AccessibilityRole::ColumnHeader || role == AccessibilityRole::RowHeader)
+ return AccessibilityObjectInclusion::IncludeObject;
+
+ // The object containing the text should implement AtkText itself.
+ // However, WebCore also maps ARIA's "text" role to the StaticTextRole.
+ if (role == AccessibilityRole::StaticText)
+ return ariaRoleAttribute() != AccessibilityRole::Unknown ? AccessibilityObjectInclusion::DefaultBehavior : AccessibilityObjectInclusion::IgnoreObject;
+
+ // Include all list items, regardless they have or not inline children
+ if (role == AccessibilityRole::ListItem)
+ return AccessibilityObjectInclusion::IncludeObject;
+
+ // Bullets/numbers for list items shouldn't be exposed as AtkObjects.
+ if (role == AccessibilityRole::ListMarker)
+ return AccessibilityObjectInclusion::IgnoreObject;
+
+ // Never expose an unknown object, since AT's won't know what to
+ // do with them. This is what is done on the Mac as well.
+ if (role == AccessibilityRole::Unknown)
+ return AccessibilityObjectInclusion::IgnoreObject;
+
+ if (role == AccessibilityRole::Inline)
+ return AccessibilityObjectInclusion::IncludeObject;
+
+ // Lines past this point only make sense for AccessibilityRenderObjects.
+ RenderObject* renderObject = renderer();
+ if (!renderObject)
+ return AccessibilityObjectInclusion::DefaultBehavior;
+
+ // We always want to include paragraphs that have rendered content.
+ // WebCore Accessibility does so unless there is a RenderBlock child.
+ if (role == AccessibilityRole::Paragraph) {
+ auto child = childrenOfType<RenderBlock>(downcast<RenderElement>(*renderObject)).first();
+ return child ? AccessibilityObjectInclusion::IncludeObject : AccessibilityObjectInclusion::DefaultBehavior;
+ }
+
+ // We always want to include table cells (layout and CSS) that have rendered text content.
+ if (is<RenderTableCell>(renderObject)) {
+ for (const auto& child : childrenOfType<RenderObject>(downcast<RenderElement>(*renderObject))) {
+ if (is<RenderInline>(child) || is<RenderText>(child) || is<HTMLSpanElement>(child.node()))
+ return AccessibilityObjectInclusion::IncludeObject;
+ }
+ return AccessibilityObjectInclusion::DefaultBehavior;
+ }
+
+ if (renderObject->isAnonymousBlock()) {
+ // The text displayed by an ARIA menu item is exposed through the accessible name.
+ if (parent->isMenuItem())
+ return AccessibilityObjectInclusion::IgnoreObject;
+
+ // The text displayed in headings is typically exposed in the heading itself.
+ if (parent->isHeading())
+ return AccessibilityObjectInclusion::IgnoreObject;
+
+ // The text displayed in list items is typically exposed in the list item itself.
+ if (parent->isListItem())
+ return AccessibilityObjectInclusion::IgnoreObject;
+
+ // The text displayed in links is typically exposed in the link itself.
+ if (parent->isLink())
+ return AccessibilityObjectInclusion::IgnoreObject;
+
+ // FIXME: This next one needs some further consideration. But paragraphs are not
+ // typically huge (like divs). And ignoring anonymous block children of paragraphs
+ // will preserve existing behavior.
+ if (parent->roleValue() == AccessibilityRole::Paragraph)
+ return AccessibilityObjectInclusion::IgnoreObject;
+
+ return AccessibilityObjectInclusion::DefaultBehavior;
+ }
+
+ Node* node = renderObject->node();
+ if (!node)
+ return AccessibilityObjectInclusion::DefaultBehavior;
+
+ // We don't want <span> elements to show up in the accessibility hierarchy unless
+ // we have good reasons for that (e.g. focusable or visible because of containing
+ // a meaningful accessible name, maybe set through ARIA), so we can use
+ // atk_component_grab_focus() to set the focus to it.
+ if (is<HTMLSpanElement>(node) && !canSetFocusAttribute() && !hasAttributesRequiredForInclusion() && !supportsARIAAttributes())
+ return AccessibilityObjectInclusion::IgnoreObject;
+
+ // If we include TextControlInnerTextElement children, changes to those children
+ // will result in focus and text notifications that suggest the user is no longer
+ // in the control. This can be especially problematic for screen reader users with
+ // key echo enabled when typing in a password input.
+ if (is<TextControlInnerTextElement>(node))
+ return AccessibilityObjectInclusion::IgnoreObject;
+
+ return AccessibilityObjectInclusion::DefaultBehavior;
+}
+
+bool AccessibilityObject::allowsTextRanges() const
+{
+ // Check type for the AccessibilityObject.
+ if (isTextControl() || isWebArea() || isGroup() || isLink() || isHeading() || isListItem() || isTableCell())
+ return true;
+
+ // Check roles as the last fallback mechanism.
+ AccessibilityRole role = roleValue();
+ return role == AccessibilityRole::Paragraph || role == AccessibilityRole::Label || role == AccessibilityRole::Div || role == AccessibilityRole::Form || role == AccessibilityRole::Pre;
+}
+
+unsigned AccessibilityObject::getLengthForTextRange() const
+{
+ unsigned textLength = text().length();
+
+ if (textLength)
+ return textLength;
+
+ // Gtk ATs need this for all text objects; not just text controls.
+ Node* node = this->node();
+ RenderObject* renderer = node ? node->renderer() : nullptr;
+ if (is<RenderText>(renderer))
+ textLength = downcast<RenderText>(*renderer).text().length();
+
+ // Get the text length from the elements under the
+ // accessibility object if the value is still zero.
+ if (!textLength && allowsTextRanges())
+ textLength = textUnderElement(AccessibilityTextUnderElementMode(AccessibilityTextUnderElementMode::TextUnderElementModeIncludeAllChildren)).length();
+
+ return textLength;
+}
+
+} // namespace WebCore
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/AXObjectCacheAtk.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/AXObjectCacheAtk.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/AXObjectCacheAtk.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/AXObjectCacheAtk.cpp 2023-03-09 13:26:47.274643822 -0600
@@ -0,0 +1,410 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "AXObjectCache.h"
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include "AccessibilityObject.h"
+#include "AccessibilityRenderObject.h"
+#include "Document.h"
+#include "Element.h"
+#include "HTMLSelectElement.h"
+#include "Range.h"
+#include "TextIterator.h"
+#include "WebKitAccessible.h"
+#include <wtf/NeverDestroyed.h>
+#include <wtf/glib/GRefPtr.h>
+#include <wtf/text/CString.h>
+
+namespace WebCore {
+
+static AtkObject* wrapperParent(WebKitAccessible* wrapper)
+{
+ // Look for the right object to emit the signal from, but using the implementation
+ // of atk_object_get_parent from AtkObject class (which uses a cached pointer if set)
+ // since the accessibility hierarchy in WebCore will no longer be navigable.
+ gpointer webkitAccessibleClass = g_type_class_peek_parent(WEBKIT_ACCESSIBLE_GET_CLASS(wrapper));
+ gpointer atkObjectClass = g_type_class_peek_parent(webkitAccessibleClass);
+ AtkObject* atkParent = ATK_OBJECT_CLASS(atkObjectClass)->get_parent(ATK_OBJECT(wrapper));
+ // We don't want to emit any signal from an object outside WebKit's world.
+ return WEBKIT_IS_ACCESSIBLE(atkParent) ? atkParent : nullptr;
+}
+
+void AXObjectCache::detachWrapper(AXCoreObject* obj, AccessibilityDetachmentType detachmentType)
+{
+ auto* wrapper = obj->wrapper();
+ ASSERT(wrapper);
+
+ // If an object is being detached NOT because of the AXObjectCache being destroyed,
+ // then it's being removed from the accessibility tree and we should emit a signal.
+ if (detachmentType != AccessibilityDetachmentType::CacheDestroyed && obj->document() && wrapperParent(wrapper))
+ m_deferredDetachedWrapperList.add(wrapper);
+
+ webkitAccessibleDetach(WEBKIT_ACCESSIBLE(wrapper));
+}
+
+void AXObjectCache::attachWrapper(AccessibilityObject* accessibilityObject)
+{
+ GRefPtr<WebKitAccessible> wrapper = adoptGRef(webkitAccessibleNew(accessibilityObject));
+ accessibilityObject->setWrapper(wrapper.get());
+
+ // If an object is being attached and we are not in the middle of a layout update, then
+ // we should report ATs by emitting the children-changed::add signal from the parent.
+ Document* document = accessibilityObject->document();
+ if (!document || document->childNeedsStyleRecalc())
+ return;
+
+ // Don't emit the signal when the actual object being added is not going to be exposed.
+ if (accessibilityObject->accessibilityIsIgnoredByDefault())
+ return;
+
+ // Don't emit the signal if the object being added is not -- or not yet -- rendered,
+ // which can occur in nested iframes. In these instances we don't want to ignore the
+ // child. But if an assistive technology is listening, AT-SPI2 will attempt to create
+ // and cache the state set for the child upon emission of the signal. If the object
+ // has not yet been rendered, this will result in a crash.
+ if (!accessibilityObject->renderer())
+ return;
+
+ m_deferredAttachedWrapperObjectList.add(accessibilityObject);
+}
+
+void AXObjectCache::platformPerformDeferredCacheUpdate()
+{
+ for (auto& coreObject : m_deferredAttachedWrapperObjectList) {
+ auto* wrapper = coreObject->wrapper();
+ if (!wrapper)
+ continue;
+
+ // Don't emit the signal for objects whose parents won't be exposed directly.
+ auto* coreParent = coreObject->parentObjectUnignored();
+ if (!coreParent || coreParent->accessibilityIsIgnoredByDefault())
+ continue;
+
+ // Look for the right object to emit the signal from.
+ auto* atkParent = coreParent->wrapper();
+ if (!atkParent)
+ continue;
+
+ size_t index = coreParent->children(false).find(coreObject);
+ g_signal_emit_by_name(atkParent, "children-changed::add", index != notFound ? index : -1, wrapper);
+ }
+ m_deferredAttachedWrapperObjectList.clear();
+
+ for (auto& wrapper : m_deferredDetachedWrapperList) {
+ if (auto* atkParent = wrapperParent(wrapper.get())) {
+ // The accessibility hierarchy is already invalid, so the parent-children relationships
+ // in the AccessibilityObject tree are not there anymore, so we can't know the offset.
+ g_signal_emit_by_name(atkParent, "children-changed::remove", -1, wrapper.get());
+ }
+ }
+ m_deferredDetachedWrapperList.clear();
+}
+
+static AXCoreObject* getListObject(AXCoreObject* object)
+{
+ // Only list boxes and menu lists supported so far.
+ if (!object->isListBox() && !object->isMenuList())
+ return 0;
+
+ // For list boxes the list object is just itself.
+ if (object->isListBox())
+ return object;
+
+ // For menu lists we need to return the first accessible child,
+ // with role MenuListPopupRole, since that's the one holding the list
+ // of items with role MenuListOptionRole.
+ const AccessibilityObject::AccessibilityChildrenVector& children = object->children();
+ if (!children.size())
+ return 0;
+
+ AXCoreObject* listObject = children.at(0).get();
+ if (!listObject->isMenuListPopup())
+ return 0;
+
+ return listObject;
+}
+
+static void notifyChildrenSelectionChange(AXCoreObject* object)
+{
+ // This static variables are needed to keep track of the old
+ // focused object and its associated list object, as per previous
+ // calls to this function, in order to properly decide whether to
+ // emit some signals or not.
+ static NeverDestroyed<RefPtr<AXCoreObject>> oldListObject;
+ static NeverDestroyed<RefPtr<AXCoreObject>> oldFocusedObject;
+
+ // Only list boxes and menu lists supported so far.
+ if (!object || !(object->isListBox() || object->isMenuList()))
+ return;
+
+ // Only support HTML select elements so far (ARIA selectors not supported).
+ Node* node = object->node();
+ if (!is<HTMLSelectElement>(node))
+ return;
+
+ // Emit signal from the listbox's point of view first.
+ g_signal_emit_by_name(object->wrapper(), "selection-changed");
+
+ // Find the item where the selection change was triggered from.
+ HTMLSelectElement& select = downcast<HTMLSelectElement>(*node);
+ int changedItemIndex = select.activeSelectionStartListIndex();
+
+ AXCoreObject* listObject = getListObject(object);
+ if (!listObject) {
+ oldListObject.get() = nullptr;
+ return;
+ }
+
+ const AccessibilityObject::AccessibilityChildrenVector& items = listObject->children();
+ if (changedItemIndex < 0 || changedItemIndex >= static_cast<int>(items.size()))
+ return;
+ AXCoreObject* item = items.at(changedItemIndex).get();
+
+ // Ensure the current list object is the same than the old one so
+ // further comparisons make sense. Otherwise, just reset
+ // oldFocusedObject so it won't be taken into account.
+ if (oldListObject.get() != listObject)
+ oldFocusedObject.get() = nullptr;
+
+ WebKitAccessible* axItem = item ? item->wrapper() : nullptr;
+ WebKitAccessible* axOldFocusedObject = oldFocusedObject.get() ? oldFocusedObject.get()->wrapper() : nullptr;
+
+ // Old focused object just lost focus, so emit the events.
+ if (axOldFocusedObject && axItem != axOldFocusedObject) {
+ g_signal_emit_by_name(axOldFocusedObject, "focus-event", false);
+ atk_object_notify_state_change(ATK_OBJECT(axOldFocusedObject), ATK_STATE_FOCUSED, false);
+ }
+
+ // Emit needed events for the currently (un)selected item.
+ if (axItem) {
+ bool isSelected = item->isSelected();
+ atk_object_notify_state_change(ATK_OBJECT(axItem), ATK_STATE_SELECTED, isSelected);
+ // When the selection changes in a collapsed widget such as a combo box
+ // whose child menu is not showing, that collapsed widget retains focus.
+ AccessibilityObject* accessibilityObject = downcast<AccessibilityObject>(object);
+ if (!accessibilityObject->isCollapsed()) {
+ g_signal_emit_by_name(axItem, "focus-event", isSelected);
+ atk_object_notify_state_change(ATK_OBJECT(axItem), ATK_STATE_FOCUSED, isSelected);
+ }
+ }
+
+ // Update pointers to the previously involved objects.
+ oldListObject.get() = listObject;
+ oldFocusedObject.get() = item;
+}
+
+void AXObjectCache::postPlatformNotification(AXCoreObject* coreObject, AXNotification notification)
+{
+ auto* axObject = ATK_OBJECT(coreObject->wrapper());
+ if (!axObject)
+ return;
+
+ switch (notification) {
+ case AXCheckedStateChanged:
+ if (!coreObject->isCheckboxOrRadio() && !coreObject->isSwitch())
+ return;
+ atk_object_notify_state_change(axObject, ATK_STATE_CHECKED, coreObject->isChecked());
+ break;
+
+ case AXSelectedChildrenChanged:
+ case AXMenuListValueChanged:
+ // Accessible focus claims should not be made if the associated widget is not focused.
+ if (notification == AXMenuListValueChanged && coreObject->isMenuList() && coreObject->isFocused()) {
+ g_signal_emit_by_name(axObject, "focus-event", true);
+ atk_object_notify_state_change(axObject, ATK_STATE_FOCUSED, true);
+ }
+ notifyChildrenSelectionChange(coreObject);
+ break;
+
+ case AXValueChanged:
+ if (ATK_IS_VALUE(axObject)) {
+ AtkPropertyValues propertyValues;
+ propertyValues.property_name = "accessible-value";
+
+ memset(&propertyValues.new_value, 0, sizeof(GValue));
+
+ double value;
+ atk_value_get_value_and_text(ATK_VALUE(axObject), &value, nullptr);
+ g_value_set_double(g_value_init(&propertyValues.new_value, G_TYPE_DOUBLE), value);
+
+ g_signal_emit_by_name(axObject, "property-change::accessible-value", &propertyValues, NULL);
+ }
+ break;
+
+ case AXInvalidStatusChanged:
+ atk_object_notify_state_change(axObject, ATK_STATE_INVALID_ENTRY, coreObject->invalidStatus() != "false"_s);
+ break;
+
+ case AXElementBusyChanged:
+ atk_object_notify_state_change(axObject, ATK_STATE_BUSY, coreObject->isBusy());
+ break;
+
+ case AXCurrentStateChanged:
+ atk_object_notify_state_change(axObject, ATK_STATE_ACTIVE, coreObject->currentState() != AccessibilityCurrentState::False);
+ break;
+
+ case AXRowExpanded:
+ atk_object_notify_state_change(axObject, ATK_STATE_EXPANDED, true);
+ break;
+
+ case AXRowCollapsed:
+ atk_object_notify_state_change(axObject, ATK_STATE_EXPANDED, false);
+ break;
+
+ case AXExpandedChanged:
+ atk_object_notify_state_change(axObject, ATK_STATE_EXPANDED, coreObject->isExpanded());
+ break;
+
+ case AXDisabledStateChanged: {
+ bool enabledState = coreObject->isEnabled();
+ atk_object_notify_state_change(axObject, ATK_STATE_ENABLED, enabledState);
+ atk_object_notify_state_change(axObject, ATK_STATE_SENSITIVE, enabledState);
+ break;
+ }
+
+ case AXPressedStateChanged:
+ atk_object_notify_state_change(axObject, ATK_STATE_PRESSED, coreObject->isPressed());
+ break;
+
+ case AXReadOnlyStatusChanged:
+ atk_object_notify_state_change(axObject, ATK_STATE_READ_ONLY, !coreObject->canSetValueAttribute());
+ break;
+
+ case AXRequiredStatusChanged:
+ atk_object_notify_state_change(axObject, ATK_STATE_REQUIRED, coreObject->isRequired());
+ break;
+
+ case AXActiveDescendantChanged:
+ if (AXCoreObject* descendant = coreObject->activeDescendant())
+ platformHandleFocusedUIElementChanged(nullptr, descendant->node());
+ break;
+
+ default:
+ break;
+ }
+}
+
+void AXObjectCache::nodeTextChangePlatformNotification(AccessibilityObject* object, AXTextChange textChange, unsigned offset, const String& text)
+{
+ if (!object || text.isEmpty())
+ return;
+
+ AXCoreObject* parentObject = object->isNonNativeTextControl() ? object : object->parentObjectUnignored();
+ if (!parentObject)
+ return;
+
+ auto* wrapper = parentObject->wrapper();
+ if (!wrapper || !ATK_IS_TEXT(wrapper))
+ return;
+
+ Node* node = object->node();
+ if (!node)
+ return;
+
+ // Ensure document's layout is up-to-date before using TextIterator.
+ Document& document = node->document();
+ document.updateLayout();
+
+ // Select the right signal to be emitted
+ CString detail;
+ switch (textChange) {
+ case AXTextInserted:
+ detail = "text-insert";
+ break;
+ case AXTextDeleted:
+ detail = "text-remove";
+ break;
+ case AXTextAttributesChanged:
+ detail = "text-attributes-changed";
+ break;
+ }
+
+ String textToEmit = text;
+ unsigned offsetToEmit = offset;
+
+ // If the object we're emitting the signal from represents a
+ // password field, we will emit the masked text.
+ if (parentObject->isPasswordField()) {
+ AccessibilityObject* accessibilityObject = downcast<AccessibilityObject>(parentObject);
+ String maskedText = accessibilityObject->passwordFieldValue();
+ textToEmit = maskedText.substring(offset, text.length());
+ } else {
+ // Consider previous text objects that might be present for
+ // the current accessibility object to ensure we emit the
+ // right offset (e.g. multiline text areas).
+ offsetToEmit = offset + characterCount(SimpleRange { { *node->parentNode(), 0 }, { *node, 0 } });
+ }
+
+ g_signal_emit_by_name(wrapper, detail.data(), offsetToEmit, textToEmit.length(), textToEmit.utf8().data());
+}
+
+void AXObjectCache::frameLoadingEventPlatformNotification(AccessibilityObject* object, AXLoadingEvent loadingEvent)
+{
+ if (!object)
+ return;
+
+ auto* axObject = ATK_OBJECT(object->wrapper());
+ if (!axObject || !ATK_IS_DOCUMENT(axObject))
+ return;
+
+ switch (loadingEvent) {
+ case AXObjectCache::AXLoadingStarted:
+ atk_object_notify_state_change(axObject, ATK_STATE_BUSY, true);
+ break;
+ case AXObjectCache::AXLoadingReloaded:
+ atk_object_notify_state_change(axObject, ATK_STATE_BUSY, true);
+ g_signal_emit_by_name(axObject, "reload");
+ break;
+ case AXObjectCache::AXLoadingFailed:
+ g_signal_emit_by_name(axObject, "load-stopped");
+ atk_object_notify_state_change(axObject, ATK_STATE_BUSY, false);
+ break;
+ case AXObjectCache::AXLoadingFinished:
+ g_signal_emit_by_name(axObject, "load-complete");
+ atk_object_notify_state_change(axObject, ATK_STATE_BUSY, false);
+ break;
+ }
+}
+
+void AXObjectCache::platformHandleFocusedUIElementChanged(Node* oldFocusedNode, Node* newFocusedNode)
+{
+ RefPtr<AccessibilityObject> oldObject = getOrCreate(oldFocusedNode);
+ if (oldObject) {
+ auto* axObject = oldObject->wrapper();
+ g_signal_emit_by_name(axObject, "focus-event", false);
+ atk_object_notify_state_change(ATK_OBJECT(axObject), ATK_STATE_FOCUSED, false);
+ }
+ RefPtr<AccessibilityObject> newObject = getOrCreate(newFocusedNode);
+ if (newObject) {
+ auto* axObject = newObject->wrapper();
+ g_signal_emit_by_name(axObject, "focus-event", true);
+ atk_object_notify_state_change(ATK_OBJECT(axObject), ATK_STATE_FOCUSED, true);
+ }
+}
+
+void AXObjectCache::handleScrolledToAnchor(const Node*)
+{
+}
+
+} // namespace WebCore
+
+#endif
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessible.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessible.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessible.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessible.cpp 2023-03-09 13:26:47.278643843 -0600
@@ -0,0 +1,1386 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2009, 2010, 2011, 2012, 2019 Igalia S.L.
+ * Copyright (C) 2013 Samsung Electronics
+ *
+ * Portions from Mozilla a11y, copyright as follows:
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is
+ * Sun Microsystems, Inc.
+ * Portions created by the Initial Developer are Copyright (C) 2002
+ * the Initial Developer. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebKitAccessible.h"
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include "AXObjectCache.h"
+#include "AccessibilityList.h"
+#include "AccessibilityListBoxOption.h"
+#include "AccessibilityTable.h"
+#include "AccessibilityTableCell.h"
+#include "AccessibilityTableRow.h"
+#include "Document.h"
+#include "Editing.h"
+#include "ElementInlines.h"
+#include "Frame.h"
+#include "FrameView.h"
+#include "HTMLNames.h"
+#include "HTMLTableElement.h"
+#include "HostWindow.h"
+#include "RenderAncestorIterator.h"
+#include "RenderBlock.h"
+#include "RenderObject.h"
+#include "SVGElement.h"
+#include "Settings.h"
+#include "TextIterator.h"
+#include "VisibleUnits.h"
+#include "WebKitAccessibleHyperlink.h"
+#include "WebKitAccessibleInterfaceAction.h"
+#include "WebKitAccessibleInterfaceComponent.h"
+#include "WebKitAccessibleInterfaceDocument.h"
+#include "WebKitAccessibleInterfaceEditableText.h"
+#include "WebKitAccessibleInterfaceHyperlinkImpl.h"
+#include "WebKitAccessibleInterfaceHypertext.h"
+#include "WebKitAccessibleInterfaceImage.h"
+#include "WebKitAccessibleInterfaceSelection.h"
+#include "WebKitAccessibleInterfaceTable.h"
+#include "WebKitAccessibleInterfaceTableCell.h"
+#include "WebKitAccessibleInterfaceText.h"
+#include "WebKitAccessibleInterfaceValue.h"
+#include "WebKitAccessibleUtil.h"
+#include <glib/gprintf.h>
+#include <wtf/glib/WTFGType.h>
+#include <wtf/text/CString.h>
+
+using namespace WebCore;
+
+struct _WebKitAccessiblePrivate {
+ AccessibilityObject* object;
+
+ // Cached data for AtkObject.
+ CString accessibleName;
+ CString accessibleDescription;
+
+ // Cached data for AtkAction.
+ CString actionName;
+ CString actionKeyBinding;
+
+ // Cached data for AtkDocument.
+ CString documentLocale;
+ CString documentType;
+ CString documentEncoding;
+ CString documentURI;
+
+ // Cached data for AtkImage.
+ CString imageDescription;
+};
+
+WEBKIT_DEFINE_TYPE(WebKitAccessible, webkit_accessible, ATK_TYPE_OBJECT)
+
+static const gchar* webkitAccessibleGetName(AtkObject* object)
+{
+ auto* accessible = WEBKIT_ACCESSIBLE(object);
+ returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
+
+ if (!accessible->priv->object)
+ return "";
+
+ Vector<AccessibilityText> textOrder;
+ accessible->priv->object->accessibilityText(textOrder);
+
+ for (const auto& text : textOrder) {
+ // FIXME: This check is here because AccessibilityNodeObject::titleElementText()
+ // appends an empty String for the LabelByElementText source when there is a
+ // titleUIElement(). Removing this check makes some fieldsets lose their name.
+ if (text.text.isEmpty())
+ continue;
+
+ // WebCore Accessibility should provide us with the text alternative computation
+ // in the order defined by that spec. So take the first thing that our platform
+ // does not expose via the AtkObject description.
+ if (text.textSource != AccessibilityTextSource::Help && text.textSource != AccessibilityTextSource::Summary)
+ return webkitAccessibleCacheAndReturnAtkProperty(accessible, AtkCachedAccessibleName, text.text.utf8());
+ }
+
+ return webkitAccessibleCacheAndReturnAtkProperty(accessible, AtkCachedAccessibleName, "");
+}
+
+static const gchar* webkitAccessibleGetDescription(AtkObject* object)
+{
+ auto* accessible = WEBKIT_ACCESSIBLE(object);
+ returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
+
+ if (!accessible->priv->object)
+ return "";
+
+ Vector<AccessibilityText> textOrder;
+ accessible->priv->object->accessibilityText(textOrder);
+
+ bool nameTextAvailable = false;
+ for (const auto& text : textOrder) {
+ // WebCore Accessibility should provide us with the text alternative computation
+ // in the order defined by that spec. So take the first thing that our platform
+ // does not expose via the AtkObject name.
+ if (text.textSource == AccessibilityTextSource::Help || text.textSource == AccessibilityTextSource::Summary)
+ return webkitAccessibleCacheAndReturnAtkProperty(accessible, AtkCachedAccessibleDescription, text.text.utf8());
+
+ // If there is no other text alternative, the title tag contents will have been
+ // used for the AtkObject name. We don't want to duplicate it here.
+ if (text.textSource == AccessibilityTextSource::TitleTag && nameTextAvailable)
+ return webkitAccessibleCacheAndReturnAtkProperty(accessible, AtkCachedAccessibleDescription, text.text.utf8());
+
+ nameTextAvailable = true;
+ }
+
+ return webkitAccessibleCacheAndReturnAtkProperty(accessible, AtkCachedAccessibleDescription, "");
+}
+
+static void removeAtkRelationByType(AtkRelationSet* relationSet, AtkRelationType relationType)
+{
+ int count = atk_relation_set_get_n_relations(relationSet);
+ for (int i = 0; i < count; i++) {
+ AtkRelation* relation = atk_relation_set_get_relation(relationSet, i);
+ if (atk_relation_get_relation_type(relation) == relationType) {
+ atk_relation_set_remove(relationSet, relation);
+ break;
+ }
+ }
+}
+
+static void setAtkRelationSetFromCoreObject(AccessibilityObject* coreObject, AtkRelationSet* relationSet)
+{
+ // Elements with aria-labelledby should have the labelled-by relation as per the ARIA AAM spec.
+ // Controls with a label element and fieldsets with a legend element should also use this relation
+ // as per the HTML AAM spec. The reciprocal label-for relation should also be used.
+ removeAtkRelationByType(relationSet, ATK_RELATION_LABELLED_BY);
+ removeAtkRelationByType(relationSet, ATK_RELATION_LABEL_FOR);
+ if (coreObject->isControl()) {
+ if (AccessibilityObject* label = coreObject->correspondingLabelForControlElement())
+ atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_LABELLED_BY, ATK_OBJECT(label->wrapper()));
+ } else if (coreObject->isFieldset()) {
+ if (AccessibilityObject* label = coreObject->titleUIElement())
+ atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_LABELLED_BY, ATK_OBJECT(label->wrapper()));
+ } else if (coreObject->roleValue() == AccessibilityRole::Legend) {
+ if (RenderBlock* renderFieldset = ancestorsOfType<RenderBlock>(*coreObject->renderer()).first()) {
+ if (renderFieldset->isFieldset()) {
+ AccessibilityObject* fieldset = coreObject->axObjectCache()->getOrCreate(renderFieldset);
+ atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_LABEL_FOR, ATK_OBJECT(fieldset->wrapper()));
+ }
+ }
+ } else if (AccessibilityObject* control = coreObject->correspondingControlForLabelElement())
+ atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_LABEL_FOR, ATK_OBJECT(control->wrapper()));
+ else {
+ AccessibilityObject::AccessibilityChildrenVector ariaLabelledByElements;
+ ariaLabelledByElements = coreObject->labelledByObjects();
+ for (const auto& accessibilityObject : ariaLabelledByElements)
+ atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_LABELLED_BY, ATK_OBJECT(accessibilityObject->wrapper()));
+ }
+
+ // Elements referenced by aria-labelledby should have the label-for relation as per the ARIA AAM spec.
+ AccessibilityObject::AccessibilityChildrenVector labels;
+ labels = coreObject->labelForObjects();
+ for (const auto& accessibilityObject : labels)
+ atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_LABEL_FOR, ATK_OBJECT(accessibilityObject->wrapper()));
+
+ // Elements with aria-flowto should have the flows-to relation as per the ARIA AAM spec.
+ removeAtkRelationByType(relationSet, ATK_RELATION_FLOWS_TO);
+ AccessibilityObject::AccessibilityChildrenVector ariaFlowToElements;
+ ariaFlowToElements = coreObject->flowToObjects();
+ for (const auto& accessibilityObject : ariaFlowToElements)
+ atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_FLOWS_TO, ATK_OBJECT(accessibilityObject->wrapper()));
+
+ // Elements referenced by aria-flowto should have the flows-from relation as per the ARIA AAM spec.
+ removeAtkRelationByType(relationSet, ATK_RELATION_FLOWS_FROM);
+ AccessibilityObject::AccessibilityChildrenVector flowFrom;
+ flowFrom = coreObject->flowFromObjects();
+ for (const auto& accessibilityObject : flowFrom)
+ atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_FLOWS_FROM, ATK_OBJECT(accessibilityObject->wrapper()));
+
+ // Elements with aria-describedby should have the described-by relation as per the ARIA AAM spec.
+ removeAtkRelationByType(relationSet, ATK_RELATION_DESCRIBED_BY);
+ AccessibilityObject::AccessibilityChildrenVector ariaDescribedByElements;
+ ariaDescribedByElements = coreObject->describedByObjects();
+ for (const auto& accessibilityObject : ariaDescribedByElements)
+ atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_DESCRIBED_BY, ATK_OBJECT(accessibilityObject->wrapper()));
+
+ // Elements referenced by aria-describedby should have the description-for relation as per the ARIA AAM spec.
+ removeAtkRelationByType(relationSet, ATK_RELATION_DESCRIPTION_FOR);
+ AccessibilityObject::AccessibilityChildrenVector describers;
+ describers = coreObject->descriptionForObjects();
+ for (const auto& accessibilityObject : describers)
+ atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_DESCRIPTION_FOR, ATK_OBJECT(accessibilityObject->wrapper()));
+
+ // Elements with aria-controls should have the controller-for relation as per the ARIA AAM spec.
+ removeAtkRelationByType(relationSet, ATK_RELATION_CONTROLLER_FOR);
+ AccessibilityObject::AccessibilityChildrenVector ariaControls;
+ ariaControls = coreObject->controlledObjects();
+ for (const auto& accessibilityObject : ariaControls)
+ atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_CONTROLLER_FOR, ATK_OBJECT(accessibilityObject->wrapper()));
+
+ // Elements referenced by aria-controls should have the controlled-by relation as per the ARIA AAM spec.
+ removeAtkRelationByType(relationSet, ATK_RELATION_CONTROLLED_BY);
+ AccessibilityObject::AccessibilityChildrenVector controllers;
+ controllers = coreObject->controllers();
+ for (const auto& accessibilityObject : controllers)
+ atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_CONTROLLED_BY, ATK_OBJECT(accessibilityObject->wrapper()));
+
+ // Elements with aria-owns should have the node-parent-of relation as per the ARIA AAM spec.
+ removeAtkRelationByType(relationSet, ATK_RELATION_NODE_PARENT_OF);
+ AccessibilityObject::AccessibilityChildrenVector ariaOwns;
+ ariaOwns = coreObject->ownedObjects();
+ for (const auto& accessibilityObject : ariaOwns)
+ atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_NODE_PARENT_OF, ATK_OBJECT(accessibilityObject->wrapper()));
+
+ // Elements referenced by aria-owns should have the node-child-of relation as per the ARIA AAM spec.
+ removeAtkRelationByType(relationSet, ATK_RELATION_NODE_CHILD_OF);
+ AccessibilityObject::AccessibilityChildrenVector owners;
+ owners = coreObject->owners();
+ for (const auto& accessibilityObject : owners)
+ atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_NODE_CHILD_OF, ATK_OBJECT(accessibilityObject->wrapper()));
+
+#if ATK_CHECK_VERSION(2, 25, 2)
+ // Elements with aria-details should have the details relation as per the ARIA AAM spec.
+ removeAtkRelationByType(relationSet, ATK_RELATION_DETAILS);
+ AccessibilityObject::AccessibilityChildrenVector ariaDetails;
+ ariaDetails = coreObject->detailsForObjects();
+ for (const auto& accessibilityObject : ariaDetails)
+ atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_DETAILS, ATK_OBJECT(accessibilityObject->wrapper()));
+
+ // Elements referenced by aria-details should have the details-for relation as per the ARIA AAM spec.
+ removeAtkRelationByType(relationSet, ATK_RELATION_DETAILS_FOR);
+ AccessibilityObject::AccessibilityChildrenVector details;
+ details = coreObject->detailsForObjects();
+ for (const auto& accessibilityObject : details)
+ atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_DETAILS_FOR, ATK_OBJECT(accessibilityObject->wrapper()));
+
+ // Elements with aria-errormessage should have the error-message relation as per the ARIA AAM spec.
+ removeAtkRelationByType(relationSet, ATK_RELATION_ERROR_MESSAGE);
+ AccessibilityObject::AccessibilityChildrenVector ariaErrorMessage;
+ ariaErrorMessage = coreObject->errorMessageObjects();
+ for (const auto& accessibilityObject : ariaErrorMessage)
+ atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_ERROR_MESSAGE, ATK_OBJECT(accessibilityObject->wrapper()));
+
+ // Elements referenced by aria-errormessage should have the error-for relation as per the ARIA AAM spec.
+ removeAtkRelationByType(relationSet, ATK_RELATION_ERROR_FOR);
+ AccessibilityObject::AccessibilityChildrenVector errors;
+ errors = coreObject->errorMessageForObjects();
+ for (const auto& accessibilityObject : errors)
+ atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_ERROR_FOR, ATK_OBJECT(accessibilityObject->wrapper()));
+#endif
+}
+
+static bool isRootObject(AccessibilityObject* coreObject)
+{
+ // The root accessible object in WebCore is always an object with
+ // the ScrolledArea role with one child with the WebArea role.
+ if (!coreObject || !coreObject->isScrollView())
+ return false;
+
+ AccessibilityObject* firstChild = coreObject->firstChild();
+ return firstChild && firstChild->isWebArea();
+}
+
+static AtkObject* webkitAccessibleGetParent(AtkObject* object)
+{
+ auto* accessible = WEBKIT_ACCESSIBLE(object);
+ returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
+
+ // Check first if the parent has been already set.
+ AtkObject* accessibleParent = ATK_OBJECT_CLASS(webkit_accessible_parent_class)->get_parent(object);
+ if (accessibleParent)
+ return accessibleParent;
+
+ // Parent not set yet, so try to find it in the hierarchy.
+ auto* coreObject = accessible->priv->object;
+ if (!coreObject)
+ return nullptr;
+ auto* coreParent = coreObject->parentObjectUnignored();
+ if (!coreParent && isRootObject(coreObject)) {
+ // The top level object claims to not have a parent. This makes it
+ // impossible for assistive technologies to ascend the accessible
+ // hierarchy all the way to the application. (Bug 30489)
+ if (!coreObject->document())
+ return nullptr;
+ }
+
+ return coreParent ? ATK_OBJECT(coreParent->wrapper()) : nullptr;
+}
+
+static gint webkitAccessibleGetNChildren(AtkObject* object)
+{
+ auto* accessible = WEBKIT_ACCESSIBLE(object);
+ returnValIfWebKitAccessibleIsInvalid(accessible, 0);
+
+ if (!accessible->priv->object)
+ return 0;
+ return accessible->priv->object->children().size();
+}
+
+static AtkObject* webkitAccessibleRefChild(AtkObject* object, gint index)
+{
+ auto* accessible = WEBKIT_ACCESSIBLE(object);
+ returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
+
+ if (!accessible->priv->object || index < 0)
+ return nullptr;
+
+ const auto& children = accessible->priv->object->children();
+ if (static_cast<size_t>(index) >= children.size())
+ return nullptr;
+
+ auto& coreChild = children[index];
+ if (!coreChild)
+ return nullptr;
+
+ auto* child = coreChild->wrapper();
+ if (!child)
+ return nullptr;
+
+ atk_object_set_parent(ATK_OBJECT(child), object);
+ return ATK_OBJECT(g_object_ref(child));
+}
+
+static gint webkitAccessibleGetIndexInParent(AtkObject* object)
+{
+ auto* accessible = WEBKIT_ACCESSIBLE(object);
+ returnValIfWebKitAccessibleIsInvalid(accessible, -1);
+
+ auto* coreObject = accessible->priv->object;
+ if (!coreObject)
+ return -1;
+ auto* parent = coreObject->parentObjectUnignored();
+ if (!parent && isRootObject(coreObject)) {
+ if (!coreObject->document())
+ return -1;
+
+ auto* atkParent = parent ? ATK_OBJECT(parent->wrapper()) : nullptr;
+ if (!atkParent)
+ return -1;
+
+ unsigned count = atk_object_get_n_accessible_children(atkParent);
+ for (unsigned i = 0; i < count; ++i) {
+ GRefPtr<AtkObject> child = adoptGRef(atk_object_ref_accessible_child(atkParent, i));
+ if (child.get() == object)
+ return i;
+ }
+ }
+
+ if (!parent)
+ return -1;
+
+ size_t index = parent->children().find(coreObject);
+ return (index == notFound) ? -1 : index;
+}
+
+static AtkAttributeSet* webkitAccessibleGetAttributes(AtkObject* object)
+{
+ auto* accessible = WEBKIT_ACCESSIBLE(object);
+ returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
+
+ AtkAttributeSet* attributeSet = nullptr;
+#if PLATFORM(GTK)
+ attributeSet = addToAtkAttributeSet(attributeSet, "toolkit", "WebKitGtk");
+#elif PLATFORM(WPE)
+ attributeSet = addToAtkAttributeSet(attributeSet, "toolkit", "WPEWebKit");
+#endif
+
+ auto* coreObject = accessible->priv->object;
+ if (!coreObject)
+ return attributeSet;
+
+ // Hack needed for WebKit2 tests because obtaining an element by its ID
+ // cannot be done from the UIProcess. Assistive technologies have no need
+ // for this information.
+ Element* element = coreObject->element() ? coreObject->element() : coreObject->actionElement();
+ if (element) {
+ String tagName = element->tagName();
+ if (!tagName.isEmpty())
+ attributeSet = addToAtkAttributeSet(attributeSet, "tag", tagName.convertToASCIILowercase().utf8().data());
+ String id = element->getIdAttribute().string();
+ if (!id.isEmpty())
+ attributeSet = addToAtkAttributeSet(attributeSet, "html-id", id.utf8().data());
+ }
+
+ int level = coreObject->isHeading() ? coreObject->headingLevel() : coreObject->hierarchicalLevel();
+ if (level) {
+ String value = String::number(level);
+ attributeSet = addToAtkAttributeSet(attributeSet, "level", value.utf8().data());
+ }
+
+ if (coreObject->roleValue() == AccessibilityRole::MathElement) {
+ if (coreObject->isMathMultiscriptObject(AccessibilityMathMultiscriptObjectType::PreSuperscript) || coreObject->isMathMultiscriptObject(AccessibilityMathMultiscriptObjectType::PreSubscript))
+ attributeSet = addToAtkAttributeSet(attributeSet, "multiscript-type", "pre");
+ else if (coreObject->isMathMultiscriptObject(AccessibilityMathMultiscriptObjectType::PostSuperscript) || coreObject->isMathMultiscriptObject(AccessibilityMathMultiscriptObjectType::PostSubscript))
+ attributeSet = addToAtkAttributeSet(attributeSet, "multiscript-type", "post");
+ }
+
+ if (is<AccessibilityTable>(*coreObject) && downcast<AccessibilityTable>(*coreObject).isExposable()) {
+ auto& table = downcast<AccessibilityTable>(*coreObject);
+ int rowCount = table.axRowCount();
+ if (rowCount)
+ attributeSet = addToAtkAttributeSet(attributeSet, "rowcount", String::number(rowCount).utf8().data());
+
+ int columnCount = table.axColumnCount();
+ if (columnCount)
+ attributeSet = addToAtkAttributeSet(attributeSet, "colcount", String::number(columnCount).utf8().data());
+ } else if (is<AccessibilityTableRow>(*coreObject)) {
+ auto& row = downcast<AccessibilityTableRow>(*coreObject);
+ int rowIndex = row.axRowIndex();
+ if (rowIndex != -1)
+ attributeSet = addToAtkAttributeSet(attributeSet, "rowindex", String::number(rowIndex).utf8().data());
+ } else if (is<AccessibilityTableCell>(*coreObject)) {
+ auto& cell = downcast<AccessibilityTableCell>(*coreObject);
+ int rowIndex = cell.axRowIndex();
+ if (rowIndex != -1)
+ attributeSet = addToAtkAttributeSet(attributeSet, "rowindex", String::number(rowIndex).utf8().data());
+
+ int columnIndex = cell.axColumnIndex();
+ if (columnIndex != -1)
+ attributeSet = addToAtkAttributeSet(attributeSet, "colindex", String::number(columnIndex).utf8().data());
+
+ int rowSpan = cell.axRowSpan();
+ if (rowSpan != -1)
+ attributeSet = addToAtkAttributeSet(attributeSet, "rowspan", String::number(rowSpan).utf8().data());
+
+ int columnSpan = cell.axColumnSpan();
+ if (columnSpan != -1)
+ attributeSet = addToAtkAttributeSet(attributeSet, "colspan", String::number(columnSpan).utf8().data());
+ }
+
+ String placeholder = coreObject->placeholderValue();
+ if (!placeholder.isEmpty())
+ attributeSet = addToAtkAttributeSet(attributeSet, "placeholder-text", placeholder.utf8().data());
+
+ if (coreObject->supportsAutoComplete())
+ attributeSet = addToAtkAttributeSet(attributeSet, "autocomplete", coreObject->autoCompleteValue().utf8().data());
+
+ if (coreObject->supportsHasPopup())
+ attributeSet = addToAtkAttributeSet(attributeSet, "haspopup", coreObject->popupValue().utf8().data());
+
+ if (coreObject->supportsCurrent())
+ attributeSet = addToAtkAttributeSet(attributeSet, "current", coreObject->currentValue().utf8().data());
+
+ // The Core AAM states that an explicitly-set value should be exposed, including "none".
+ if (coreObject->hasAttribute(HTMLNames::aria_sortAttr)) {
+ switch (coreObject->sortDirection()) {
+ case AccessibilitySortDirection::Invalid:
+ break;
+ case AccessibilitySortDirection::Ascending:
+ attributeSet = addToAtkAttributeSet(attributeSet, "sort", "ascending");
+ break;
+ case AccessibilitySortDirection::Descending:
+ attributeSet = addToAtkAttributeSet(attributeSet, "sort", "descending");
+ break;
+ case AccessibilitySortDirection::Other:
+ attributeSet = addToAtkAttributeSet(attributeSet, "sort", "other");
+ break;
+ case AccessibilitySortDirection::None:
+ attributeSet = addToAtkAttributeSet(attributeSet, "sort", "none");
+ }
+ }
+
+ if (coreObject->supportsPosInSet())
+ attributeSet = addToAtkAttributeSet(attributeSet, "posinset", String::number(coreObject->posInSet()).utf8().data());
+
+ if (coreObject->supportsSetSize())
+ attributeSet = addToAtkAttributeSet(attributeSet, "setsize", String::number(coreObject->setSize()).utf8().data());
+
+ String isReadOnly = coreObject->readOnlyValue();
+ if (!isReadOnly.isEmpty())
+ attributeSet = addToAtkAttributeSet(attributeSet, "readonly", isReadOnly.utf8().data());
+
+ String valueDescription = coreObject->valueDescription();
+ if (!valueDescription.isEmpty())
+ attributeSet = addToAtkAttributeSet(attributeSet, "valuetext", valueDescription.utf8().data());
+
+ // According to the W3C Core Accessibility API Mappings 1.1, section 5.4.1 General Rules:
+ // "User agents must expose the WAI-ARIA role string if the API supports a mechanism to do so."
+ // In the case of ATK, the mechanism to do so is an object attribute pair (xml-roles:"string").
+ // We cannot use the computedRoleString for this purpose because it is not limited to elements
+ // with ARIA roles, and it might not contain the actual ARIA role value (e.g. DPub ARIA).
+ String roleString = coreObject->getAttribute(HTMLNames::roleAttr);
+ if (!roleString.isEmpty())
+ attributeSet = addToAtkAttributeSet(attributeSet, "xml-roles", roleString.utf8().data());
+
+ String computedRoleString = coreObject->computedRoleString();
+ if (!computedRoleString.isEmpty()) {
+ attributeSet = addToAtkAttributeSet(attributeSet, "computed-role", computedRoleString.utf8().data());
+
+ // The HTML AAM maps several elements to ARIA landmark roles. In order for the type of landmark
+ // to be obtainable in the same fashion as an ARIA landmark, fall back on the computedRoleString.
+ // We also want to do this for the style-format-group element types so that the type of format
+ // group it is doesn't get lost to a generic platform role.
+ if (coreObject->ariaRoleAttribute() == AccessibilityRole::Unknown
+ && (coreObject->isLandmark() || coreObject->isStyleFormatGroup()))
+ attributeSet = addToAtkAttributeSet(attributeSet, "xml-roles", computedRoleString.utf8().data());
+ }
+
+ String roleDescription = coreObject->roleDescription();
+ if (!roleDescription.isEmpty())
+ attributeSet = addToAtkAttributeSet(attributeSet, "roledescription", roleDescription.utf8().data());
+
+ // We need to expose the live region attributes even if the live region is currently disabled/off.
+ if (auto liveContainer = coreObject->liveRegionAncestor(false)) {
+ String liveStatus = liveContainer->liveRegionStatus();
+ String relevant = liveContainer->liveRegionRelevant();
+ bool isAtom = liveContainer->liveRegionAtomic();
+ String liveRole = roleString.isEmpty() ? computedRoleString : roleString;
+
+ // According to the Core AAM, we need to expose the above properties with "container-" prefixed
+ // object attributes regardless of whether the container is this object, or an ancestor of it.
+ attributeSet = addToAtkAttributeSet(attributeSet, "container-live", liveStatus.utf8().data());
+ attributeSet = addToAtkAttributeSet(attributeSet, "container-relevant", relevant.utf8().data());
+ if (isAtom)
+ attributeSet = addToAtkAttributeSet(attributeSet, "container-atomic", "true");
+ if (!liveRole.isEmpty())
+ attributeSet = addToAtkAttributeSet(attributeSet, "container-live-role", liveRole.utf8().data());
+
+ // According to the Core AAM, if this object is the live region (rather than its descendant),
+ // we must expose the above properties on the object without a "container-" prefix.
+ if (liveContainer == coreObject) {
+ attributeSet = addToAtkAttributeSet(attributeSet, "live", liveStatus.utf8().data());
+ attributeSet = addToAtkAttributeSet(attributeSet, "relevant", relevant.utf8().data());
+ if (isAtom)
+ attributeSet = addToAtkAttributeSet(attributeSet, "atomic", "true");
+ } else if (!isAtom && coreObject->liveRegionAtomic())
+ attributeSet = addToAtkAttributeSet(attributeSet, "atomic", "true");
+ }
+
+ // The Core AAM states the author-provided value should be exposed as-is.
+ String dropEffect = coreObject->getAttribute(HTMLNames::aria_dropeffectAttr);
+ if (!dropEffect.isEmpty())
+ attributeSet = addToAtkAttributeSet(attributeSet, "dropeffect", dropEffect.utf8().data());
+
+ if (coreObject->isGrabbed())
+ attributeSet = addToAtkAttributeSet(attributeSet, "grabbed", "true");
+ else if (coreObject->supportsDragging())
+ attributeSet = addToAtkAttributeSet(attributeSet, "grabbed", "false");
+
+ // The Core AAM states the author-provided value should be exposed as-is.
+ const String& keyShortcuts = coreObject->keyShortcuts();
+ if (!keyShortcuts.isEmpty())
+ attributeSet = addToAtkAttributeSet(attributeSet, "keyshortcuts", keyShortcuts.utf8().data());
+
+ return attributeSet;
+}
+
+static AtkRole atkRole(AccessibilityObject* coreObject)
+{
+ switch (coreObject->roleValue()) {
+ case AccessibilityRole::ApplicationAlert:
+ return ATK_ROLE_NOTIFICATION;
+ case AccessibilityRole::ApplicationAlertDialog:
+ return ATK_ROLE_ALERT;
+ case AccessibilityRole::ApplicationDialog:
+ return ATK_ROLE_DIALOG;
+ case AccessibilityRole::ApplicationStatus:
+ return ATK_ROLE_STATUSBAR;
+ case AccessibilityRole::Unknown:
+ return ATK_ROLE_UNKNOWN;
+ case AccessibilityRole::Audio:
+ return ATK_ROLE_AUDIO;
+ case AccessibilityRole::Video:
+ return ATK_ROLE_VIDEO;
+ case AccessibilityRole::Button:
+ return ATK_ROLE_PUSH_BUTTON;
+ case AccessibilityRole::Switch:
+ case AccessibilityRole::ToggleButton:
+ return ATK_ROLE_TOGGLE_BUTTON;
+ case AccessibilityRole::RadioButton:
+ return ATK_ROLE_RADIO_BUTTON;
+ case AccessibilityRole::CheckBox:
+ return ATK_ROLE_CHECK_BOX;
+ case AccessibilityRole::Slider:
+ return ATK_ROLE_SLIDER;
+ case AccessibilityRole::TabGroup:
+ case AccessibilityRole::TabList:
+ return ATK_ROLE_PAGE_TAB_LIST;
+ case AccessibilityRole::TextField:
+ case AccessibilityRole::TextArea:
+ case AccessibilityRole::SearchField:
+ return ATK_ROLE_ENTRY;
+ case AccessibilityRole::StaticText:
+ return ATK_ROLE_STATIC;
+ case AccessibilityRole::Outline:
+ case AccessibilityRole::Tree:
+ return ATK_ROLE_TREE;
+ case AccessibilityRole::TreeItem:
+ return ATK_ROLE_TREE_ITEM;
+ case AccessibilityRole::MenuBar:
+ return ATK_ROLE_MENU_BAR;
+ case AccessibilityRole::MenuListPopup:
+ case AccessibilityRole::Menu:
+ return ATK_ROLE_MENU;
+ case AccessibilityRole::MenuListOption:
+ case AccessibilityRole::MenuItem:
+ case AccessibilityRole::MenuButton:
+ return ATK_ROLE_MENU_ITEM;
+ case AccessibilityRole::MenuItemCheckbox:
+ return ATK_ROLE_CHECK_MENU_ITEM;
+ case AccessibilityRole::MenuItemRadio:
+ return ATK_ROLE_RADIO_MENU_ITEM;
+ case AccessibilityRole::Column:
+ // return ATK_ROLE_TABLE_COLUMN_HEADER; // Is this right?
+ return ATK_ROLE_UNKNOWN; // Matches Mozilla
+ case AccessibilityRole::Row:
+ return ATK_ROLE_TABLE_ROW;
+ case AccessibilityRole::Toolbar:
+ return ATK_ROLE_TOOL_BAR;
+ case AccessibilityRole::Meter:
+ return ATK_ROLE_LEVEL_BAR;
+ case AccessibilityRole::BusyIndicator:
+ case AccessibilityRole::ProgressIndicator:
+ return ATK_ROLE_PROGRESS_BAR;
+ case AccessibilityRole::Window:
+ return ATK_ROLE_WINDOW;
+ case AccessibilityRole::PopUpButton:
+ return coreObject->hasPopup() ? ATK_ROLE_PUSH_BUTTON : ATK_ROLE_COMBO_BOX;
+ case AccessibilityRole::ComboBox:
+ return ATK_ROLE_COMBO_BOX;
+ case AccessibilityRole::SplitGroup:
+ return ATK_ROLE_SPLIT_PANE;
+ case AccessibilityRole::Splitter:
+ return ATK_ROLE_SEPARATOR;
+#if PLATFORM(GTK)
+ case AccessibilityRole::ColorWell:
+ // ATK_ROLE_COLOR_CHOOSER is defined as a dialog (i.e. it's what appears when you push the button).
+ return ATK_ROLE_PUSH_BUTTON;
+#endif
+ case AccessibilityRole::List:
+ return ATK_ROLE_LIST;
+ case AccessibilityRole::ScrollBar:
+ return ATK_ROLE_SCROLL_BAR;
+ case AccessibilityRole::ScrollArea:
+ case AccessibilityRole::TabPanel:
+ return ATK_ROLE_SCROLL_PANE;
+ case AccessibilityRole::Grid:
+ case AccessibilityRole::Table:
+ return ATK_ROLE_TABLE;
+ case AccessibilityRole::TreeGrid:
+ return ATK_ROLE_TREE_TABLE;
+ case AccessibilityRole::Application:
+ return ATK_ROLE_APPLICATION;
+ case AccessibilityRole::ApplicationGroup:
+ case AccessibilityRole::Feed:
+ case AccessibilityRole::Figure:
+ case AccessibilityRole::GraphicsObject:
+ case AccessibilityRole::Group:
+ case AccessibilityRole::RadioGroup:
+ case AccessibilityRole::SVGRoot:
+ return ATK_ROLE_PANEL;
+ case AccessibilityRole::RowHeader:
+ return ATK_ROLE_ROW_HEADER;
+ case AccessibilityRole::ColumnHeader:
+ return ATK_ROLE_COLUMN_HEADER;
+ case AccessibilityRole::Caption:
+ return ATK_ROLE_CAPTION;
+ case AccessibilityRole::Cell:
+ case AccessibilityRole::GridCell:
+ return coreObject->inheritsPresentationalRole() ? ATK_ROLE_SECTION : ATK_ROLE_TABLE_CELL;
+ case AccessibilityRole::Link:
+ case AccessibilityRole::WebCoreLink:
+ case AccessibilityRole::ImageMapLink:
+ return ATK_ROLE_LINK;
+ case AccessibilityRole::ImageMap:
+ return ATK_ROLE_IMAGE_MAP;
+ case AccessibilityRole::GraphicsSymbol:
+ case AccessibilityRole::Image:
+ return ATK_ROLE_IMAGE;
+ case AccessibilityRole::ListMarker:
+ return ATK_ROLE_TEXT;
+ case AccessibilityRole::DocumentArticle:
+ return ATK_ROLE_ARTICLE;
+ case AccessibilityRole::Document:
+ case AccessibilityRole::GraphicsDocument:
+ return ATK_ROLE_DOCUMENT_FRAME;
+ case AccessibilityRole::DocumentNote:
+ return ATK_ROLE_COMMENT;
+ case AccessibilityRole::Heading:
+ return ATK_ROLE_HEADING;
+ case AccessibilityRole::ListBox:
+ // https://rawgit.com/w3c/aria/master/core-aam/core-aam.html#role-map-listbox
+ return coreObject->isDescendantOfRole(AccessibilityRole::ComboBox) ? ATK_ROLE_MENU : ATK_ROLE_LIST_BOX;
+ case AccessibilityRole::ListItem:
+ return coreObject->inheritsPresentationalRole() ? ATK_ROLE_SECTION : ATK_ROLE_LIST_ITEM;
+ case AccessibilityRole::ListBoxOption:
+ return coreObject->isDescendantOfRole(AccessibilityRole::ComboBox) ? ATK_ROLE_MENU_ITEM : ATK_ROLE_LIST_ITEM;
+ case AccessibilityRole::Paragraph:
+ return ATK_ROLE_PARAGRAPH;
+ case AccessibilityRole::Label:
+ case AccessibilityRole::Legend:
+ return ATK_ROLE_LABEL;
+ case AccessibilityRole::Blockquote:
+ return ATK_ROLE_BLOCK_QUOTE;
+#if ATK_CHECK_VERSION(2, 25, 2)
+ case AccessibilityRole::Footnote:
+ return ATK_ROLE_FOOTNOTE;
+#endif
+ case AccessibilityRole::ApplicationTextGroup:
+ case AccessibilityRole::Div:
+ case AccessibilityRole::Pre:
+ case AccessibilityRole::SVGText:
+ case AccessibilityRole::TextGroup:
+ return ATK_ROLE_SECTION;
+ case AccessibilityRole::Footer:
+ return ATK_ROLE_FOOTER;
+ case AccessibilityRole::Form:
+ if (coreObject->ariaRoleAttribute() != AccessibilityRole::Unknown)
+ return ATK_ROLE_LANDMARK;
+ return ATK_ROLE_FORM;
+ case AccessibilityRole::Canvas:
+ return ATK_ROLE_CANVAS;
+ case AccessibilityRole::HorizontalRule:
+ return ATK_ROLE_SEPARATOR;
+ case AccessibilityRole::SpinButton:
+ return ATK_ROLE_SPIN_BUTTON;
+ case AccessibilityRole::Tab:
+ return ATK_ROLE_PAGE_TAB;
+ case AccessibilityRole::UserInterfaceTooltip:
+ return ATK_ROLE_TOOL_TIP;
+ case AccessibilityRole::WebArea:
+ return ATK_ROLE_DOCUMENT_WEB;
+ case AccessibilityRole::WebApplication:
+ return ATK_ROLE_EMBEDDED;
+ case AccessibilityRole::ApplicationLog:
+ return ATK_ROLE_LOG;
+ case AccessibilityRole::ApplicationMarquee:
+ return ATK_ROLE_MARQUEE;
+ case AccessibilityRole::ApplicationTimer:
+ return ATK_ROLE_TIMER;
+ case AccessibilityRole::Definition:
+ return ATK_ROLE_DEFINITION;
+ case AccessibilityRole::DocumentMath:
+ return ATK_ROLE_MATH;
+ case AccessibilityRole::MathElement:
+ if (coreObject->isMathRow())
+ return ATK_ROLE_PANEL;
+ if (coreObject->isMathTable())
+ return ATK_ROLE_TABLE;
+ if (coreObject->isMathTableRow())
+ return ATK_ROLE_TABLE_ROW;
+ if (coreObject->isMathTableCell())
+ return ATK_ROLE_TABLE_CELL;
+ if (coreObject->isMathSubscriptSuperscript() || coreObject->isMathMultiscript())
+ return ATK_ROLE_SECTION;
+ if (coreObject->isMathFraction())
+ return ATK_ROLE_MATH_FRACTION;
+ if (coreObject->isMathSquareRoot() || coreObject->isMathRoot())
+ return ATK_ROLE_MATH_ROOT;
+ if (coreObject->isMathScriptObject(AccessibilityMathScriptObjectType::Subscript)
+ || coreObject->isMathMultiscriptObject(AccessibilityMathMultiscriptObjectType::PreSubscript) || coreObject->isMathMultiscriptObject(AccessibilityMathMultiscriptObjectType::PostSubscript))
+ return ATK_ROLE_SUBSCRIPT;
+ if (coreObject->isMathScriptObject(AccessibilityMathScriptObjectType::Superscript)
+ || coreObject->isMathMultiscriptObject(AccessibilityMathMultiscriptObjectType::PreSuperscript) || coreObject->isMathMultiscriptObject(AccessibilityMathMultiscriptObjectType::PostSuperscript))
+ return ATK_ROLE_SUPERSCRIPT;
+ if (coreObject->isMathToken())
+ return ATK_ROLE_STATIC;
+ return ATK_ROLE_UNKNOWN;
+ case AccessibilityRole::LandmarkBanner:
+ case AccessibilityRole::LandmarkComplementary:
+ case AccessibilityRole::LandmarkContentInfo:
+ case AccessibilityRole::LandmarkDocRegion:
+ case AccessibilityRole::LandmarkMain:
+ case AccessibilityRole::LandmarkNavigation:
+ case AccessibilityRole::LandmarkRegion:
+ case AccessibilityRole::LandmarkSearch:
+ return ATK_ROLE_LANDMARK;
+ case AccessibilityRole::DescriptionList:
+ return ATK_ROLE_DESCRIPTION_LIST;
+ case AccessibilityRole::Term:
+ case AccessibilityRole::DescriptionListTerm:
+ return ATK_ROLE_DESCRIPTION_TERM;
+ case AccessibilityRole::DescriptionListDetail:
+ return ATK_ROLE_DESCRIPTION_VALUE;
+ case AccessibilityRole::Deletion:
+#if ATK_CHECK_VERSION(2, 33, 3)
+ return ATK_ROLE_CONTENT_DELETION;
+#else
+ return ATK_ROLE_STATIC;
+#endif
+ case AccessibilityRole::Insertion:
+#if ATK_CHECK_VERSION(2, 33, 3)
+ return ATK_ROLE_CONTENT_INSERTION;
+#else
+ return ATK_ROLE_STATIC;
+#endif
+ case AccessibilityRole::Subscript:
+ return ATK_ROLE_SUBSCRIPT;
+ case AccessibilityRole::Superscript:
+ return ATK_ROLE_SUPERSCRIPT;
+ case AccessibilityRole::Inline:
+ case AccessibilityRole::SVGTextPath:
+ case AccessibilityRole::SVGTSpan:
+ case AccessibilityRole::Time:
+ return ATK_ROLE_STATIC;
+ default:
+ return ATK_ROLE_UNKNOWN;
+ }
+}
+
+static AtkRole webkitAccessibleGetRole(AtkObject* object)
+{
+ // ATK_ROLE_UNKNOWN should only be applied in cases where there is a valid
+ // WebCore accessible object for which the platform role mapping is unknown.
+ auto* accessible = WEBKIT_ACCESSIBLE(object);
+ returnValIfWebKitAccessibleIsInvalid(accessible, ATK_ROLE_INVALID);
+
+ if (!accessible->priv->object)
+ return ATK_ROLE_INVALID;
+
+ // Note: Why doesn't WebCore have a password field for this
+ if (accessible->priv->object->isPasswordField())
+ return ATK_ROLE_PASSWORD_TEXT;
+
+ return atkRole(accessible->priv->object);
+}
+
+static bool isTextWithCaret(AccessibilityObject* coreObject)
+{
+ if (!coreObject || !coreObject->isAccessibilityRenderObject())
+ return false;
+
+ Document* document = coreObject->document();
+ if (!document)
+ return false;
+
+ Frame* frame = document->frame();
+ if (!frame)
+ return false;
+
+ if (!frame->settings().caretBrowsingEnabled())
+ return false;
+
+ // Check text objects and paragraphs only.
+ auto* axObject = coreObject->wrapper();
+ AtkRole role = axObject ? atk_object_get_role(ATK_OBJECT(axObject)) : ATK_ROLE_INVALID;
+ if (role != ATK_ROLE_TEXT && role != ATK_ROLE_PARAGRAPH)
+ return false;
+
+ // Finally, check whether the caret is set in the current object.
+ VisibleSelection selection = coreObject->selection();
+ if (!selection.isCaret())
+ return false;
+
+ return selectionBelongsToObject(coreObject, selection);
+}
+
+static void setAtkStateSetFromCoreObject(AccessibilityObject* coreObject, AtkStateSet* stateSet)
+{
+ AccessibilityObject* parent = coreObject->parentObject();
+ bool isListBoxOption = parent && parent->isListBox();
+
+ // Please keep the state list in alphabetical order
+ if ((isListBoxOption && coreObject->isSelectedOptionActive())
+ || coreObject->currentState() != AccessibilityCurrentState::False)
+ atk_state_set_add_state(stateSet, ATK_STATE_ACTIVE);
+
+ if (coreObject->isBusy())
+ atk_state_set_add_state(stateSet, ATK_STATE_BUSY);
+
+ if (coreObject->supportsChecked() && coreObject->canSetValueAttribute())
+ atk_state_set_add_state(stateSet, ATK_STATE_CHECKABLE);
+
+ if (coreObject->isChecked())
+ atk_state_set_add_state(stateSet, ATK_STATE_CHECKED);
+
+ if ((coreObject->isTextControl() || coreObject->isNonNativeTextControl()) && coreObject->canSetValueAttribute())
+ atk_state_set_add_state(stateSet, ATK_STATE_EDITABLE);
+
+ // FIXME: Put both ENABLED and SENSITIVE together here for now
+ if (coreObject->isEnabled()) {
+ atk_state_set_add_state(stateSet, ATK_STATE_ENABLED);
+ atk_state_set_add_state(stateSet, ATK_STATE_SENSITIVE);
+ }
+
+ if (coreObject->canSetExpandedAttribute())
+ atk_state_set_add_state(stateSet, ATK_STATE_EXPANDABLE);
+
+ if (coreObject->isExpanded())
+ atk_state_set_add_state(stateSet, ATK_STATE_EXPANDED);
+
+ if (coreObject->canSetFocusAttribute())
+ atk_state_set_add_state(stateSet, ATK_STATE_FOCUSABLE);
+
+ // According to the Core AAM, if the element which is focused has a valid aria-activedescendant,
+ // we should not expose the focused state on the element which is actually focused, but instead
+ // on its active descendant.
+ if ((coreObject->isFocused() && !coreObject->activeDescendant()) || isTextWithCaret(coreObject))
+ atk_state_set_add_state(stateSet, ATK_STATE_FOCUSED);
+ else if (coreObject->isActiveDescendantOfFocusedContainer()) {
+ atk_state_set_add_state(stateSet, ATK_STATE_FOCUSABLE);
+ atk_state_set_add_state(stateSet, ATK_STATE_FOCUSED);
+ }
+
+ if (coreObject->orientation() == AccessibilityOrientation::Horizontal)
+ atk_state_set_add_state(stateSet, ATK_STATE_HORIZONTAL);
+ else if (coreObject->orientation() == AccessibilityOrientation::Vertical)
+ atk_state_set_add_state(stateSet, ATK_STATE_VERTICAL);
+
+ if (coreObject->hasPopup())
+ atk_state_set_add_state(stateSet, ATK_STATE_HAS_POPUP);
+
+ if (coreObject->isIndeterminate())
+ atk_state_set_add_state(stateSet, ATK_STATE_INDETERMINATE);
+ else if (coreObject->isCheckboxOrRadio() || coreObject->isMenuItem() || coreObject->isToggleButton()) {
+ if (coreObject->checkboxOrRadioValue() == AccessibilityButtonState::Mixed)
+ atk_state_set_add_state(stateSet, ATK_STATE_INDETERMINATE);
+ }
+
+ if (coreObject->isModalNode())
+ atk_state_set_add_state(stateSet, ATK_STATE_MODAL);
+
+ if (coreObject->invalidStatus() != "false"_s)
+ atk_state_set_add_state(stateSet, ATK_STATE_INVALID_ENTRY);
+
+ if (coreObject->isMultiSelectable())
+ atk_state_set_add_state(stateSet, ATK_STATE_MULTISELECTABLE);
+
+ // TODO: ATK_STATE_OPAQUE
+
+ if (coreObject->isPressed())
+ atk_state_set_add_state(stateSet, ATK_STATE_PRESSED);
+
+ if (!coreObject->canSetValueAttribute() && (coreObject->supportsReadOnly()))
+ atk_state_set_add_state(stateSet, ATK_STATE_READ_ONLY);
+
+ if (coreObject->isRequired())
+ atk_state_set_add_state(stateSet, ATK_STATE_REQUIRED);
+
+ // TODO: ATK_STATE_SELECTABLE_TEXT
+
+ if (coreObject->canSetSelectedAttribute()) {
+ atk_state_set_add_state(stateSet, ATK_STATE_SELECTABLE);
+ // Items in focusable lists have both STATE_SELECT{ABLE,ED}
+ // and STATE_FOCUS{ABLE,ED}. We'll fake the latter based on
+ // the former.
+ if (isListBoxOption)
+ atk_state_set_add_state(stateSet, ATK_STATE_FOCUSABLE);
+ }
+
+ if (coreObject->isSelected()) {
+ atk_state_set_add_state(stateSet, ATK_STATE_SELECTED);
+ // Items in focusable lists have both STATE_SELECT{ABLE,ED}
+ // and STATE_FOCUS{ABLE,ED}. We'll fake the latter based on the
+ // former.
+ if (isListBoxOption)
+ atk_state_set_add_state(stateSet, ATK_STATE_FOCUSED);
+ }
+
+ // FIXME: Group both SHOWING and VISIBLE here for now
+ // Not sure how to handle this in WebKit, see bug
+ // http://bugzilla.gnome.org/show_bug.cgi?id=509650 for other
+ // issues with SHOWING vs VISIBLE.
+ if (!coreObject->isOffScreen()) {
+ atk_state_set_add_state(stateSet, ATK_STATE_SHOWING);
+ atk_state_set_add_state(stateSet, ATK_STATE_VISIBLE);
+ }
+
+ // Mutually exclusive, so we group these two
+ if (coreObject->roleValue() == AccessibilityRole::TextArea || coreObject->ariaIsMultiline())
+ atk_state_set_add_state(stateSet, ATK_STATE_MULTI_LINE);
+ else if (coreObject->roleValue() == AccessibilityRole::TextField || coreObject->roleValue() == AccessibilityRole::SearchField)
+ atk_state_set_add_state(stateSet, ATK_STATE_SINGLE_LINE);
+
+ // TODO: ATK_STATE_SENSITIVE
+
+ if (coreObject->supportsAutoComplete() && coreObject->autoCompleteValue() != "none"_s)
+ atk_state_set_add_state(stateSet, ATK_STATE_SUPPORTS_AUTOCOMPLETION);
+
+ if (coreObject->isVisited())
+ atk_state_set_add_state(stateSet, ATK_STATE_VISITED);
+}
+
+static AtkStateSet* webkitAccessibleRefStateSet(AtkObject* object)
+{
+ auto* accessible = WEBKIT_ACCESSIBLE(object);
+ AtkStateSet* stateSet = ATK_OBJECT_CLASS(webkit_accessible_parent_class)->ref_state_set(object);
+
+ // Make sure the layout is updated to really know whether the object
+ // is defunct or not, so we can return the proper state.
+ if (accessible->priv->object)
+ accessible->priv->object->updateBackingStore();
+ if (!accessible->priv->object) {
+ atk_state_set_add_state(stateSet, ATK_STATE_DEFUNCT);
+ return stateSet;
+ }
+
+ // Text objects must be focusable.
+ AtkRole role = atk_object_get_role(object);
+ if (role == ATK_ROLE_TEXT || role == ATK_ROLE_PARAGRAPH)
+ atk_state_set_add_state(stateSet, ATK_STATE_FOCUSABLE);
+
+ setAtkStateSetFromCoreObject(accessible->priv->object, stateSet);
+ return stateSet;
+}
+
+static AtkRelationSet* webkitAccessibleRefRelationSet(AtkObject* object)
+{
+ auto* accessible = WEBKIT_ACCESSIBLE(object);
+ returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
+
+ AtkRelationSet* relationSet = ATK_OBJECT_CLASS(webkit_accessible_parent_class)->ref_relation_set(object);
+ if (accessible->priv->object)
+ setAtkRelationSetFromCoreObject(accessible->priv->object, relationSet);
+ return relationSet;
+}
+
+static void webkitAccessibleInit(AtkObject* object, gpointer data)
+{
+ if (ATK_OBJECT_CLASS(webkit_accessible_parent_class)->initialize)
+ ATK_OBJECT_CLASS(webkit_accessible_parent_class)->initialize(object, data);
+
+ WebKitAccessible* accessible = WEBKIT_ACCESSIBLE(object);
+ accessible->priv->object = reinterpret_cast<AccessibilityObject*>(data);
+}
+
+static const gchar* webkitAccessibleGetObjectLocale(AtkObject* object)
+{
+ auto* accessible = WEBKIT_ACCESSIBLE(object);
+ returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
+
+ if (!accessible->priv->object)
+ return nullptr;
+
+ if (ATK_IS_DOCUMENT(object)) {
+ // TODO: Should we fall back on lang xml:lang when the following comes up empty?
+ String language = accessible->priv->object->language();
+ if (!language.isEmpty())
+ return webkitAccessibleCacheAndReturnAtkProperty(accessible, AtkCachedDocumentLocale, language.utf8());
+
+ } else if (ATK_IS_TEXT(object)) {
+ const gchar* locale = nullptr;
+
+ AtkAttributeSet* textAttributes = atk_text_get_default_attributes(ATK_TEXT(object));
+ for (auto* attributes = textAttributes; attributes; attributes = attributes->next) {
+ auto* atkAttribute = static_cast<AtkAttribute*>(attributes->data);
+ if (!strcmp(atkAttribute->name, atk_text_attribute_get_name(ATK_TEXT_ATTR_LANGUAGE))) {
+ locale = webkitAccessibleCacheAndReturnAtkProperty(accessible, AtkCachedDocumentLocale, atkAttribute->value);
+ break;
+ }
+ }
+ atk_attribute_set_free(textAttributes);
+
+ return locale;
+ }
+
+ return nullptr;
+}
+
+static void webkit_accessible_class_init(WebKitAccessibleClass* klass)
+{
+ auto* atkObjectClass = ATK_OBJECT_CLASS(klass);
+ atkObjectClass->initialize = webkitAccessibleInit;
+ atkObjectClass->get_name = webkitAccessibleGetName;
+ atkObjectClass->get_description = webkitAccessibleGetDescription;
+ atkObjectClass->get_parent = webkitAccessibleGetParent;
+ atkObjectClass->get_n_children = webkitAccessibleGetNChildren;
+ atkObjectClass->ref_child = webkitAccessibleRefChild;
+ atkObjectClass->get_role = webkitAccessibleGetRole;
+ atkObjectClass->ref_state_set = webkitAccessibleRefStateSet;
+ atkObjectClass->get_index_in_parent = webkitAccessibleGetIndexInParent;
+ atkObjectClass->get_attributes = webkitAccessibleGetAttributes;
+ atkObjectClass->ref_relation_set = webkitAccessibleRefRelationSet;
+ atkObjectClass->get_object_locale = webkitAccessibleGetObjectLocale;
+}
+
+static const GInterfaceInfo atkInterfacesInitFunctions[] = {
+ {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleActionInterfaceInit)), nullptr, nullptr},
+ {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleSelectionInterfaceInit)), nullptr, nullptr},
+ {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleEditableTextInterfaceInit)), nullptr, nullptr},
+ {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleTextInterfaceInit)), nullptr, nullptr},
+ {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleComponentInterfaceInit)), nullptr, nullptr},
+ {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleImageInterfaceInit)), nullptr, nullptr},
+ {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleTableInterfaceInit)), nullptr, nullptr},
+ {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleTableCellInterfaceInit)), nullptr, nullptr},
+ {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleHypertextInterfaceInit)), nullptr, nullptr},
+ {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleHyperlinkImplInterfaceInit)), nullptr, nullptr},
+ {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleDocumentInterfaceInit)), nullptr, nullptr},
+ {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleValueInterfaceInit)), nullptr, nullptr}
+};
+
+enum WAIType {
+ WAIAction,
+ WAISelection,
+ WAIEditableText,
+ WAIText,
+ WAIComponent,
+ WAIImage,
+ WAITable,
+ WAITableCell,
+ WAIHypertext,
+ WAIHyperlink,
+ WAIDocument,
+ WAIValue,
+};
+
+static GType atkInterfaceTypeFromWAIType(WAIType type)
+{
+ switch (type) {
+ case WAIAction:
+ return ATK_TYPE_ACTION;
+ case WAISelection:
+ return ATK_TYPE_SELECTION;
+ case WAIEditableText:
+ return ATK_TYPE_EDITABLE_TEXT;
+ case WAIText:
+ return ATK_TYPE_TEXT;
+ case WAIComponent:
+ return ATK_TYPE_COMPONENT;
+ case WAIImage:
+ return ATK_TYPE_IMAGE;
+ case WAITable:
+ return ATK_TYPE_TABLE;
+ case WAITableCell:
+ return ATK_TYPE_TABLE_CELL;
+ case WAIHypertext:
+ return ATK_TYPE_HYPERTEXT;
+ case WAIHyperlink:
+ return ATK_TYPE_HYPERLINK_IMPL;
+ case WAIDocument:
+ return ATK_TYPE_DOCUMENT;
+ case WAIValue:
+ return ATK_TYPE_VALUE;
+ }
+
+ return G_TYPE_INVALID;
+}
+
+static bool roleIsTextType(AccessibilityRole role)
+{
+ return role == AccessibilityRole::Paragraph
+ || role == AccessibilityRole::Heading
+ || role == AccessibilityRole::Div
+ || role == AccessibilityRole::Cell
+ || role == AccessibilityRole::Link
+ || role == AccessibilityRole::WebCoreLink
+ || role == AccessibilityRole::ListItem
+ || role == AccessibilityRole::Pre
+ || role == AccessibilityRole::GridCell
+ || role == AccessibilityRole::TextGroup
+ || role == AccessibilityRole::ApplicationTextGroup
+ || role == AccessibilityRole::ApplicationGroup;
+}
+
+static guint16 interfaceMaskFromObject(AXCoreObject* coreObject)
+{
+ guint16 interfaceMask = 0;
+
+ // Component interface is always supported
+ interfaceMask |= 1 << WAIComponent;
+
+ AccessibilityRole role = coreObject->roleValue();
+
+ // Action
+ // As the implementation of the AtkAction interface is a very
+ // basic one (just relays in executing the default action for each
+ // object, and only supports having one action per object), it is
+ // better just to implement this interface for every instance of
+ // the WebKitAccessible class and let WebCore decide what to do.
+ interfaceMask |= 1 << WAIAction;
+
+ // Selection
+ if (coreObject->canHaveSelectedChildren() || coreObject->isMenuList())
+ interfaceMask |= 1 << WAISelection;
+
+ // Get renderer if available.
+ RenderObject* renderer = nullptr;
+ if (coreObject->isAccessibilityRenderObject())
+ renderer = coreObject->renderer();
+
+ // Hyperlink (links and embedded objects).
+ if (coreObject->isLink() || (renderer && renderer->isReplacedOrInlineBlock()))
+ interfaceMask |= 1 << WAIHyperlink;
+
+ // Text, Editable Text & Hypertext
+ if (role == AccessibilityRole::StaticText || coreObject->isMenuListOption())
+ interfaceMask |= 1 << WAIText;
+ else if (coreObject->isTextControl() || coreObject->isNonNativeTextControl()) {
+ interfaceMask |= 1 << WAIText;
+ if (coreObject->canSetValueAttribute())
+ interfaceMask |= 1 << WAIEditableText;
+ } else if (!coreObject->isWebArea()) {
+ if (role != AccessibilityRole::Table) {
+ interfaceMask |= 1 << WAIHypertext;
+ if ((renderer && renderer->childrenInline()) || roleIsTextType(role) || coreObject->isMathToken())
+ interfaceMask |= 1 << WAIText;
+ }
+
+ // Add the TEXT interface for list items whose
+ // first accessible child has a text renderer
+ if (role == AccessibilityRole::ListItem) {
+ const auto& children = coreObject->children();
+ if (!children.isEmpty())
+ interfaceMask |= interfaceMaskFromObject(children[0].get());
+ }
+ }
+
+ // Image
+ if (coreObject->isImage())
+ interfaceMask |= 1 << WAIImage;
+
+ // Table
+ if (coreObject->isTable())
+ interfaceMask |= 1 << WAITable;
+
+ if (role == AccessibilityRole::Cell || role == AccessibilityRole::GridCell || role == AccessibilityRole::ColumnHeader || role == AccessibilityRole::RowHeader)
+ interfaceMask |= 1 << WAITableCell;
+
+ // Document
+ if (role == AccessibilityRole::WebArea)
+ interfaceMask |= 1 << WAIDocument;
+
+ // Value
+ if (coreObject->supportsRangeValue())
+ interfaceMask |= 1 << WAIValue;
+
+#if ENABLE(INPUT_TYPE_COLOR)
+ // Color type.
+ if (role == AccessibilityRole::ColorWell)
+ interfaceMask |= 1 << WAIText;
+#endif
+
+ return interfaceMask;
+}
+
+static const char* uniqueAccessibilityTypeName(guint16 interfaceMask)
+{
+#define WAI_TYPE_NAME_LEN (30) // Enough for prefix + 5 hex characters (max).
+ static char name[WAI_TYPE_NAME_LEN + 1];
+
+ g_sprintf(name, "WAIType%x", interfaceMask);
+ name[WAI_TYPE_NAME_LEN] = '\0';
+
+ return name;
+}
+
+static GType accessibilityTypeFromObject(AccessibilityObject* coreObject)
+{
+ static const GTypeInfo typeInfo = {
+ sizeof(WebKitAccessibleClass),
+ nullptr, // GBaseInitFunc
+ nullptr, // GBaseFinalizeFunc
+ nullptr, // GClassInitFunc
+ nullptr, // GClassFinalizeFunc
+ nullptr, // class data
+ sizeof(WebKitAccessible), // instance size
+ 0, // nb preallocs
+ nullptr, // GInstanceInitFunc
+ nullptr // value table
+ };
+
+ guint16 interfaceMask = interfaceMaskFromObject(coreObject);
+ const char* atkTypeName = uniqueAccessibilityTypeName(interfaceMask);
+ if (GType type = g_type_from_name(atkTypeName))
+ return type;
+
+ GType type = g_type_register_static(WEBKIT_TYPE_ACCESSIBLE, atkTypeName, &typeInfo, static_cast<GTypeFlags>(0));
+ for (unsigned i = 0; i < G_N_ELEMENTS(atkInterfacesInitFunctions); ++i) {
+ if (interfaceMask & (1 << i)) {
+ g_type_add_interface_static(type,
+ atkInterfaceTypeFromWAIType(static_cast<WAIType>(i)),
+ &atkInterfacesInitFunctions[i]);
+ }
+ }
+
+ return type;
+}
+
+WebKitAccessible* webkitAccessibleNew(AccessibilityObject* coreObject)
+{
+ auto* object = ATK_OBJECT(g_object_new(accessibilityTypeFromObject(coreObject), nullptr));
+ atk_object_initialize(object, coreObject);
+ return WEBKIT_ACCESSIBLE(object);
+}
+
+AccessibilityObject& webkitAccessibleGetAccessibilityObject(WebKitAccessible* accessible)
+{
+ ASSERT(WEBKIT_IS_ACCESSIBLE(accessible));
+ ASSERT(accessible->priv->object);
+ return *accessible->priv->object;
+}
+
+void webkitAccessibleDetach(WebKitAccessible* accessible)
+{
+ ASSERT(WEBKIT_IS_ACCESSIBLE(accessible));
+
+ if (accessible->priv->object && accessible->priv->object->roleValue() == AccessibilityRole::WebArea)
+ atk_object_notify_state_change(ATK_OBJECT(accessible), ATK_STATE_DEFUNCT, TRUE);
+
+ accessible->priv->object = nullptr;
+}
+
+bool webkitAccessibleIsDetached(WebKitAccessible* accessible)
+{
+ ASSERT(WEBKIT_IS_ACCESSIBLE(accessible));
+ return !accessible->priv->object;
+}
+
+const char* webkitAccessibleCacheAndReturnAtkProperty(WebKitAccessible* accessible, AtkCachedProperty property, CString&& value)
+{
+ ASSERT(WEBKIT_IS_ACCESSIBLE(accessible));
+
+ WebKitAccessiblePrivate* priv = accessible->priv;
+ CString* propertyPtr = nullptr;
+
+ switch (property) {
+ case AtkCachedAccessibleName:
+ propertyPtr = &priv->accessibleName;
+ break;
+ case AtkCachedAccessibleDescription:
+ propertyPtr = &priv->accessibleDescription;
+ break;
+ case AtkCachedActionName:
+ propertyPtr = &priv->actionName;
+ break;
+ case AtkCachedActionKeyBinding:
+ propertyPtr = &priv->actionKeyBinding;
+ break;
+ case AtkCachedDocumentLocale:
+ propertyPtr = &priv->documentLocale;
+ break;
+ case AtkCachedDocumentType:
+ propertyPtr = &priv->documentType;
+ break;
+ case AtkCachedDocumentEncoding:
+ propertyPtr = &priv->documentEncoding;
+ break;
+ case AtkCachedDocumentURI:
+ propertyPtr = &priv->documentURI;
+ break;
+ case AtkCachedImageDescription:
+ propertyPtr = &priv->imageDescription;
+ break;
+ default:
+ ASSERT_NOT_REACHED();
+ }
+
+ // Don't invalidate old memory if not stricly needed, since other
+ // callers might be still holding on to it.
+ if (*propertyPtr != value)
+ *propertyPtr = WTFMove(value);
+
+ return (*propertyPtr).data();
+}
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessible.h webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessible.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessible.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessible.h 2023-03-09 13:26:47.278643843 -0600
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2009, 2010, 2011, 2012, 2019 Igalia S.L.
+ * Copyright (C) 2013 Samsung Electronics
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include <atk/atk.h>
+#include <wtf/text/WTFString.h>
+
+namespace WebCore {
+class AccessibilityObject;
+}
+
+G_BEGIN_DECLS
+
+#define WEBKIT_TYPE_ACCESSIBLE (webkit_accessible_get_type())
+#define WEBKIT_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), WEBKIT_TYPE_ACCESSIBLE, WebKitAccessible))
+#define WEBKIT_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), WEBKIT_TYPE_ACCESSIBLE, WebKitAccessibleClass))
+#define WEBKIT_IS_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), WEBKIT_TYPE_ACCESSIBLE))
+#define WEBKIT_IS_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), WEBKIT_TYPE_ACCESSIBLE))
+#define WEBKIT_ACCESSIBLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), WEBKIT_TYPE_ACCESSIBLE, WebKitAccessibleClass))
+
+typedef struct _WebKitAccessible WebKitAccessible;
+typedef struct _WebKitAccessibleClass WebKitAccessibleClass;
+typedef struct _WebKitAccessiblePrivate WebKitAccessiblePrivate;
+
+
+struct _WebKitAccessible {
+ AtkObject parent;
+
+ WebKitAccessiblePrivate *priv;
+};
+
+struct _WebKitAccessibleClass {
+ AtkObjectClass parentClass;
+};
+
+GType webkit_accessible_get_type(void);
+
+G_END_DECLS
+
+// The definitions below are only used in C++ code, and some use C++ types,
+// therefore they should be outside of the G_BEGIN_DECLS/G_END_DECLS block
+// to make them use the C++ ABI.
+
+enum AtkCachedProperty {
+ AtkCachedAccessibleName,
+ AtkCachedAccessibleDescription,
+ AtkCachedActionName,
+ AtkCachedActionKeyBinding,
+ AtkCachedDocumentLocale,
+ AtkCachedDocumentType,
+ AtkCachedDocumentEncoding,
+ AtkCachedDocumentURI,
+ AtkCachedImageDescription
+};
+
+WebKitAccessible* webkitAccessibleNew(WebCore::AccessibilityObject*);
+
+WebCore::AccessibilityObject& webkitAccessibleGetAccessibilityObject(WebKitAccessible*);
+
+void webkitAccessibleDetach(WebKitAccessible*);
+
+bool webkitAccessibleIsDetached(WebKitAccessible*);
+
+const char* webkitAccessibleCacheAndReturnAtkProperty(WebKitAccessible*, AtkCachedProperty, CString&&);
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleHyperlink.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleHyperlink.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleHyperlink.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleHyperlink.cpp 2023-03-09 13:26:47.278643843 -0600
@@ -0,0 +1,316 @@
+/*
+ * Copyright (C) 2010, 2011, 2012 Igalia S.L.
+ * Copyright (C) 2013 Samsung Electronics
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebKitAccessibleHyperlink.h"
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include "AXObjectCache.h"
+#include "AccessibilityObject.h"
+#include "Editing.h"
+#include "NotImplemented.h"
+#include "Position.h"
+#include "Range.h"
+#include "RenderListMarker.h"
+#include "RenderObject.h"
+#include "TextIterator.h"
+#include "WebKitAccessible.h"
+#include "WebKitAccessibleUtil.h"
+#include <wtf/glib/WTFGType.h>
+#include <wtf/text/CString.h>
+
+using namespace WebCore;
+
+static void webkit_accessible_hyperlink_atk_action_interface_init(AtkActionIface*);
+
+struct _WebKitAccessibleHyperlinkPrivate {
+ WebKitAccessible* hyperlinkImpl;
+
+ // We cache these values so we can return them as const values.
+ CString actionName;
+ CString actionKeyBinding;
+};
+
+WEBKIT_DEFINE_TYPE_WITH_CODE(
+ WebKitAccessibleHyperlink, webkit_accessible_hyperlink, ATK_TYPE_HYPERLINK,
+ G_IMPLEMENT_INTERFACE(ATK_TYPE_ACTION, webkit_accessible_hyperlink_atk_action_interface_init))
+
+enum {
+ PROP_0,
+
+ PROP_HYPERLINK_IMPL
+};
+
+static gboolean webkitAccessibleHyperlinkActionDoAction(AtkAction* action, gint)
+{
+ auto* accessibleHyperlink = WEBKIT_ACCESSIBLE_HYPERLINK(action);
+ returnValIfWebKitAccessibleIsInvalid(accessibleHyperlink->priv->hyperlinkImpl, FALSE);
+
+ if (!ATK_IS_ACTION(accessibleHyperlink->priv->hyperlinkImpl))
+ return FALSE;
+
+ auto& coreObject = webkitAccessibleGetAccessibilityObject(accessibleHyperlink->priv->hyperlinkImpl);
+ return coreObject.performDefaultAction();
+}
+
+static gint webkitAccessibleHyperlinkActionGetNActions(AtkAction* action)
+{
+ auto* accessibleHyperlink = WEBKIT_ACCESSIBLE_HYPERLINK(action);
+ returnValIfWebKitAccessibleIsInvalid(accessibleHyperlink->priv->hyperlinkImpl, 0);
+
+ return ATK_IS_ACTION(accessibleHyperlink->priv->hyperlinkImpl) ? 1 : 0;
+}
+
+static const gchar* webkitAccessibleHyperlinkActionGetDescription(AtkAction* action, gint)
+{
+ auto* accessibleHyperlink = WEBKIT_ACCESSIBLE_HYPERLINK(action);
+ returnValIfWebKitAccessibleIsInvalid(accessibleHyperlink->priv->hyperlinkImpl, nullptr);
+
+ // TODO: Need a way to provide/localize action descriptions.
+ notImplemented();
+ return "";
+}
+
+static const gchar* webkitAccessibleHyperlinkActionGetKeybinding(AtkAction* action, gint)
+{
+ auto* accessibleHyperlink = WEBKIT_ACCESSIBLE_HYPERLINK(action);
+ returnValIfWebKitAccessibleIsInvalid(accessibleHyperlink->priv->hyperlinkImpl, nullptr);
+
+ if (!ATK_IS_ACTION(accessibleHyperlink->priv->hyperlinkImpl))
+ return nullptr;
+
+ auto& coreObject = webkitAccessibleGetAccessibilityObject(accessibleHyperlink->priv->hyperlinkImpl);
+ accessibleHyperlink->priv->actionKeyBinding = coreObject.accessKey().utf8();
+ return accessibleHyperlink->priv->actionKeyBinding.data();
+}
+
+static const gchar* webkitAccessibleHyperlinkActionGetName(AtkAction* action, gint)
+{
+ auto* accessibleHyperlink = WEBKIT_ACCESSIBLE_HYPERLINK(action);
+ returnValIfWebKitAccessibleIsInvalid(accessibleHyperlink->priv->hyperlinkImpl, nullptr);
+
+ if (!ATK_IS_ACTION(accessibleHyperlink->priv->hyperlinkImpl))
+ return nullptr;
+
+ auto& coreObject = webkitAccessibleGetAccessibilityObject(accessibleHyperlink->priv->hyperlinkImpl);
+ accessibleHyperlink->priv->actionName = coreObject.localizedActionVerb().utf8();
+ return accessibleHyperlink->priv->actionName.data();
+}
+
+static void webkit_accessible_hyperlink_atk_action_interface_init(AtkActionIface* iface)
+{
+ iface->do_action = webkitAccessibleHyperlinkActionDoAction;
+ iface->get_n_actions = webkitAccessibleHyperlinkActionGetNActions;
+ iface->get_description = webkitAccessibleHyperlinkActionGetDescription;
+ iface->get_keybinding = webkitAccessibleHyperlinkActionGetKeybinding;
+ iface->get_name = webkitAccessibleHyperlinkActionGetName;
+}
+
+static gchar* webkitAccessibleHyperlinkGetURI(AtkHyperlink* link, gint index)
+{
+ // FIXME: Do NOT support more than one instance of an AtkObject
+ // implementing AtkHyperlinkImpl in every instance of AtkHyperLink
+ if (index)
+ return nullptr;
+
+ auto* accessibleHyperlink = WEBKIT_ACCESSIBLE_HYPERLINK(link);
+ returnValIfWebKitAccessibleIsInvalid(accessibleHyperlink->priv->hyperlinkImpl, nullptr);
+
+ auto& coreObject = webkitAccessibleGetAccessibilityObject(accessibleHyperlink->priv->hyperlinkImpl);
+ return !coreObject.url().isNull() ? g_strdup(coreObject.url().string().utf8().data()) : nullptr;
+}
+
+static AtkObject* webkitAccessibleHyperlinkGetObject(AtkHyperlink* link, gint index)
+{
+ // FIXME: Do NOT support more than one instance of an AtkObject
+ // implementing AtkHyperlinkImpl in every instance of AtkHyperLink
+ if (index)
+ return nullptr;
+
+ auto* accessibleHyperlink = WEBKIT_ACCESSIBLE_HYPERLINK(link);
+ returnValIfWebKitAccessibleIsInvalid(accessibleHyperlink->priv->hyperlinkImpl, 0);
+
+ return ATK_OBJECT(accessibleHyperlink->priv->hyperlinkImpl);
+}
+
+static gint rangeLengthForObject(AccessibilityObject& obj, const std::optional<SimpleRange>& range)
+{
+ if (!range)
+ return 0;
+
+ // This is going to be the actual length in most of the cases
+ int baseLength = characterCount(*range, TextIteratorBehavior::EmitsCharactersBetweenAllVisiblePositions);
+
+ // Check whether the current hyperlink belongs to a list item.
+ // If so, we need to consider the length of the item's marker
+ AXCoreObject* parent = obj.parentObjectUnignored();
+ if (!parent || !parent->isAccessibilityRenderObject() || !parent->isListItem())
+ return baseLength;
+
+ // Even if we don't expose list markers to Assistive
+ // Technologies, we need to have a way to measure their length
+ // for those cases when it's needed to take it into account
+ // separately (as in getAccessibilityObjectForOffset)
+ AXCoreObject* markerObj = reinterpret_cast<AccessibilityObject *>(parent)->firstChild();
+ if (!markerObj)
+ return baseLength;
+
+ RenderObject* renderer = markerObj->renderer();
+ if (!is<RenderListMarker>(renderer))
+ return baseLength;
+
+ return baseLength + downcast<RenderListMarker>(*renderer).textWithSuffix().length();
+}
+
+static gint webkitAccessibleHyperlinkGetStartIndex(AtkHyperlink* link)
+{
+ auto* accessibleHyperlink = WEBKIT_ACCESSIBLE_HYPERLINK(link);
+ returnValIfWebKitAccessibleIsInvalid(accessibleHyperlink->priv->hyperlinkImpl, 0);
+
+ auto& coreObject = webkitAccessibleGetAccessibilityObject(accessibleHyperlink->priv->hyperlinkImpl);
+ AXCoreObject* parentUnignored = coreObject.parentObjectUnignored();
+ if (!parentUnignored)
+ return 0;
+
+ Node* node = coreObject.node();
+ if (!node)
+ return 0;
+
+ Node* parentNode = parentUnignored->node();
+ if (!parentNode)
+ return 0;
+
+ return rangeLengthForObject(coreObject, makeSimpleRange(firstPositionInOrBeforeNode(parentNode), firstPositionInOrBeforeNode(node)));
+}
+
+static gint webkitAccessibleHyperlinkGetEndIndex(AtkHyperlink* link)
+{
+ auto* accessibleHyperlink = WEBKIT_ACCESSIBLE_HYPERLINK(link);
+ returnValIfWebKitAccessibleIsInvalid(accessibleHyperlink->priv->hyperlinkImpl, 0);
+
+ auto& coreObject = webkitAccessibleGetAccessibilityObject(accessibleHyperlink->priv->hyperlinkImpl);
+ AXCoreObject* parentUnignored = coreObject.parentObjectUnignored();
+ if (!parentUnignored)
+ return 0;
+
+ Node* node = coreObject.node();
+ if (!node)
+ return 0;
+
+ Node* parentNode = parentUnignored->node();
+ if (!parentNode)
+ return 0;
+
+ return rangeLengthForObject(coreObject, makeSimpleRange(firstPositionInOrBeforeNode(parentNode), lastPositionInOrAfterNode(node)));
+}
+
+static gboolean webkitAccessibleHyperlinkIsValid(AtkHyperlink* link)
+{
+ auto* accessibleHyperlink = WEBKIT_ACCESSIBLE_HYPERLINK(link);
+ returnValIfWebKitAccessibleIsInvalid(accessibleHyperlink->priv->hyperlinkImpl, FALSE);
+
+ // Link is valid for the whole object's lifetime
+ return TRUE;
+}
+
+static gint webkitAccessibleHyperlinkGetNAnchors(AtkHyperlink* link)
+{
+ // FIXME Do NOT support more than one instance of an AtkObject
+ // implementing AtkHyperlinkImpl in every instance of AtkHyperLink
+ auto* accessibleHyperlink = WEBKIT_ACCESSIBLE_HYPERLINK(link);
+ returnValIfWebKitAccessibleIsInvalid(accessibleHyperlink->priv->hyperlinkImpl, 0);
+
+ return 1;
+}
+
+static gboolean webkitAccessibleHyperlinkIsSelectedLink(AtkHyperlink* link)
+{
+ auto* accessibleHyperlink = WEBKIT_ACCESSIBLE_HYPERLINK(link);
+ returnValIfWebKitAccessibleIsInvalid(accessibleHyperlink->priv->hyperlinkImpl, FALSE);
+
+ // Not implemented: this function is deprecated in ATK now
+ notImplemented();
+ return FALSE;
+}
+
+static void webkitAccessibleHyperlinkGetProperty(GObject* object, guint propId, GValue* value, GParamSpec* pspec)
+{
+ auto* accessibleHyperlink = WEBKIT_ACCESSIBLE_HYPERLINK(object);
+
+ switch (propId) {
+ case PROP_HYPERLINK_IMPL:
+ g_value_set_object(value, accessibleHyperlink->priv->hyperlinkImpl);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, pspec);
+ }
+}
+
+static void webkitAccessibleHyperlinkSetProperty(GObject* object, guint propId, const GValue* value, GParamSpec* pspec)
+{
+ auto* accessibleHyperlink = WEBKIT_ACCESSIBLE_HYPERLINK(object);
+
+ switch (propId) {
+ case PROP_HYPERLINK_IMPL:
+ accessibleHyperlink->priv->hyperlinkImpl = WEBKIT_ACCESSIBLE(g_value_get_object(value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, pspec);
+ }
+}
+
+static void webkit_accessible_hyperlink_class_init(WebKitAccessibleHyperlinkClass* klass)
+{
+ GObjectClass* gobjectClass = G_OBJECT_CLASS(klass);
+ gobjectClass->set_property = webkitAccessibleHyperlinkSetProperty;
+ gobjectClass->get_property = webkitAccessibleHyperlinkGetProperty;
+
+ AtkHyperlinkClass* atkHyperlinkClass = ATK_HYPERLINK_CLASS(klass);
+ atkHyperlinkClass->get_uri = webkitAccessibleHyperlinkGetURI;
+ atkHyperlinkClass->get_object = webkitAccessibleHyperlinkGetObject;
+ atkHyperlinkClass->get_start_index = webkitAccessibleHyperlinkGetStartIndex;
+ atkHyperlinkClass->get_end_index = webkitAccessibleHyperlinkGetEndIndex;
+ atkHyperlinkClass->is_valid = webkitAccessibleHyperlinkIsValid;
+ atkHyperlinkClass->get_n_anchors = webkitAccessibleHyperlinkGetNAnchors;
+ atkHyperlinkClass->is_selected_link = webkitAccessibleHyperlinkIsSelectedLink;
+
+ g_object_class_install_property(gobjectClass, PROP_HYPERLINK_IMPL,
+ g_param_spec_object("hyperlink-impl",
+ "Hyperlink implementation",
+ "The associated WebKitAccessible instance.",
+ WEBKIT_TYPE_ACCESSIBLE,
+ static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));
+}
+
+WebKitAccessibleHyperlink* webkitAccessibleHyperlinkGetOrCreate(AtkHyperlinkImpl* hyperlinkImpl)
+{
+ g_return_val_if_fail(ATK_IS_HYPERLINK_IMPL(hyperlinkImpl), nullptr);
+ g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE(hyperlinkImpl), nullptr);
+
+ if (auto* currentHyperLink = g_object_get_data(G_OBJECT(hyperlinkImpl), "webkit-accessible-hyperlink-object"))
+ return WEBKIT_ACCESSIBLE_HYPERLINK(g_object_ref(currentHyperLink));
+
+ auto* hyperlink = WEBKIT_ACCESSIBLE_HYPERLINK(g_object_new(WEBKIT_TYPE_ACCESSIBLE_HYPERLINK, "hyperlink-impl", hyperlinkImpl, nullptr));
+ g_object_set_data_full(G_OBJECT(hyperlinkImpl), "webkit-accessible-hyperlink-object", hyperlink, g_object_unref);
+ return hyperlink;
+}
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleHyperlink.h webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleHyperlink.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleHyperlink.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleHyperlink.h 2023-03-09 13:26:47.278643843 -0600
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2010, 2011, 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include <atk/atk.h>
+
+G_BEGIN_DECLS
+
+#define WEBKIT_TYPE_ACCESSIBLE_HYPERLINK (webkit_accessible_hyperlink_get_type())
+#define WEBKIT_ACCESSIBLE_HYPERLINK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), WEBKIT_TYPE_ACCESSIBLE_HYPERLINK, WebKitAccessibleHyperlink))
+#define WEBKIT_ACCESSIBLE_HYPERLINK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), WEBKIT_TYPE_ACCESSIBLE_HYPERLINK, WebKitAccessibleHyperlinkClass))
+#define WEBKIT_IS_ACCESSIBLE_HYPERLINK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), WEBKIT_TYPE_ACCESSIBLE_HYPERLINK))
+#define WEBKIT_IS_ACCESSIBLE_HYPERLINK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), WEBKIT_TYPE_ACCESSIBLE_HYPERLINK))
+#define WEBKIT_ACCESSIBLE_HYPERLINK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), WEBKIT_TYPE_ACCESSIBLE_HYPERLINK, WebKitAccessibleHyperlinkClass))
+
+typedef struct _WebKitAccessibleHyperlink WebKitAccessibleHyperlink;
+typedef struct _WebKitAccessibleHyperlinkClass WebKitAccessibleHyperlinkClass;
+typedef struct _WebKitAccessibleHyperlinkPrivate WebKitAccessibleHyperlinkPrivate;
+
+struct _WebKitAccessibleHyperlink {
+ AtkHyperlink parent;
+
+ WebKitAccessibleHyperlinkPrivate *priv;
+};
+
+struct _WebKitAccessibleHyperlinkClass {
+ AtkHyperlinkClass parentClass;
+};
+
+GType webkit_accessible_hyperlink_get_type(void);
+
+WebKitAccessibleHyperlink* webkitAccessibleHyperlinkGetOrCreate(AtkHyperlinkImpl*);
+
+G_END_DECLS
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceAction.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceAction.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceAction.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceAction.cpp 2023-03-09 13:26:47.278643843 -0600
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2012 Igalia S.L.
+ * Copyright (C) 2013 Samsung Electronics
+ *
+ * Portions from Mozilla a11y, copyright as follows:
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is
+ * Sun Microsystems, Inc.
+ * Portions created by the Initial Developer are Copyright (C) 2002
+ * the Initial Developer. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebKitAccessibleInterfaceAction.h"
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include "AccessibilityObject.h"
+#include "NotImplemented.h"
+#include "WebKitAccessible.h"
+#include "WebKitAccessibleUtil.h"
+
+using namespace WebCore;
+
+static AccessibilityObject* core(AtkAction* action)
+{
+ if (!WEBKIT_IS_ACCESSIBLE(action))
+ return 0;
+
+ return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(action));
+}
+
+static gboolean webkitAccessibleActionDoAction(AtkAction* action, gint index)
+{
+ g_return_val_if_fail(ATK_IS_ACTION(action), FALSE);
+ g_return_val_if_fail(!index, FALSE);
+
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(action), FALSE);
+
+ return core(action)->performDefaultAction();
+}
+
+static gint webkitAccessibleActionGetNActions(AtkAction* action)
+{
+ g_return_val_if_fail(ATK_IS_ACTION(action), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(action), 0);
+
+ return 1;
+}
+
+static const gchar* webkitAccessibleActionGetDescription(AtkAction* action, gint)
+{
+ g_return_val_if_fail(ATK_IS_ACTION(action), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(action), 0);
+
+ // TODO: Need a way to provide/localize action descriptions.
+ notImplemented();
+ return "";
+}
+
+static const gchar* webkitAccessibleActionGetKeybinding(AtkAction* action, gint)
+{
+ auto* accessible = WEBKIT_ACCESSIBLE(action);
+ returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
+
+ // FIXME: Construct a proper keybinding string.
+ return webkitAccessibleCacheAndReturnAtkProperty(accessible, AtkCachedActionKeyBinding, core(action)->accessKey().utf8());
+}
+
+static const gchar* webkitAccessibleActionGetName(AtkAction* action, gint)
+{
+ auto* accessible = WEBKIT_ACCESSIBLE(action);
+ returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
+
+ return webkitAccessibleCacheAndReturnAtkProperty(accessible, AtkCachedActionName, core(action)->localizedActionVerb().utf8());
+}
+
+void webkitAccessibleActionInterfaceInit(AtkActionIface* iface)
+{
+ iface->do_action = webkitAccessibleActionDoAction;
+ iface->get_n_actions = webkitAccessibleActionGetNActions;
+ iface->get_description = webkitAccessibleActionGetDescription;
+ iface->get_keybinding = webkitAccessibleActionGetKeybinding;
+ iface->get_name = webkitAccessibleActionGetName;
+}
+
+#endif
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceAction.h webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceAction.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceAction.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceAction.h 2023-03-09 13:26:47.278643843 -0600
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include <atk/atk.h>
+
+void webkitAccessibleActionInterfaceInit(AtkActionIface*);
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceComponent.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceComponent.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceComponent.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceComponent.cpp 2023-03-09 13:26:47.278643843 -0600
@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2009, 2012 Igalia S.L.
+ *
+ * Portions from Mozilla a11y, copyright as follows:
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is
+ * Sun Microsystems, Inc.
+ * Portions created by the Initial Developer are Copyright (C) 2002
+ * the Initial Developer. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebKitAccessibleInterfaceComponent.h"
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include "AccessibilityObject.h"
+#include "FrameView.h"
+#include "IntRect.h"
+#include "RenderLayer.h"
+#include "WebKitAccessible.h"
+#include "WebKitAccessibleUtil.h"
+
+using namespace WebCore;
+
+static IntPoint atkToContents(const AccessibilityObject& coreObject, AtkCoordType coordType, gint x, gint y)
+{
+ auto* frameView = coreObject.documentFrameView();
+ if (!frameView)
+ return { x, y };
+
+ switch (coordType) {
+ case ATK_XY_SCREEN:
+ return frameView->screenToContents({ x, y });
+ case ATK_XY_WINDOW:
+ return frameView->windowToContents({ x, y });
+#if ATK_CHECK_VERSION(2, 30, 0)
+ case ATK_XY_PARENT:
+ RELEASE_ASSERT_NOT_REACHED();
+#endif
+ }
+
+ return { x, y };
+}
+
+static AtkObject* webkitAccessibleComponentRefAccessibleAtPoint(AtkComponent* component, gint x, gint y, AtkCoordType coordType)
+{
+ auto* accessible = WEBKIT_ACCESSIBLE(component);
+ returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
+
+ auto& coreObject = webkitAccessibleGetAccessibilityObject(accessible);
+ auto* target = downcast<AccessibilityObject>(coreObject.accessibilityHitTest(atkToContents(coreObject, coordType, x, y)));
+ if (!target)
+ return nullptr;
+
+ if (auto* wrapper = target->wrapper())
+ return ATK_OBJECT(g_object_ref(wrapper));
+
+ return nullptr;
+}
+
+static void webkitAccessibleComponentGetExtents(AtkComponent* component, gint* x, gint* y, gint* width, gint* height, AtkCoordType coordType)
+{
+ auto* accessible = WEBKIT_ACCESSIBLE(component);
+ returnIfWebKitAccessibleIsInvalid(accessible);
+
+ auto& coreObject = webkitAccessibleGetAccessibilityObject(accessible);
+ contentsRelativeToAtkCoordinateType(&coreObject, coordType, snappedIntRect(coreObject.elementRect()), x, y, width, height);
+}
+
+static gboolean webkitAccessibleComponentGrabFocus(AtkComponent* component)
+{
+ auto* accessible = WEBKIT_ACCESSIBLE(component);
+ returnValIfWebKitAccessibleIsInvalid(accessible, FALSE);
+
+ auto& coreObject = webkitAccessibleGetAccessibilityObject(accessible);
+ coreObject.setFocused(true);
+ return coreObject.isFocused();
+}
+
+#if ATK_CHECK_VERSION(2, 30, 0)
+static gboolean webkitAccessibleComponentScrollTo(AtkComponent* component, AtkScrollType scrollType)
+{
+ auto* accessible = WEBKIT_ACCESSIBLE(component);
+ returnValIfWebKitAccessibleIsInvalid(accessible, FALSE);
+
+ ScrollAlignment alignX;
+ ScrollAlignment alignY;
+
+ switch (scrollType) {
+ case ATK_SCROLL_TOP_LEFT:
+ alignX = ScrollAlignment::alignLeftAlways;
+ alignY = ScrollAlignment::alignTopAlways;
+ break;
+ case ATK_SCROLL_BOTTOM_RIGHT:
+ alignX = ScrollAlignment::alignRightAlways;
+ alignY = ScrollAlignment::alignBottomAlways;
+ break;
+ case ATK_SCROLL_TOP_EDGE:
+ case ATK_SCROLL_BOTTOM_EDGE:
+ // Align to a particular edge is not supported, it's always the closest edge.
+ alignX = ScrollAlignment::alignCenterIfNeeded;
+ alignY = ScrollAlignment::alignToEdgeIfNeeded;
+ break;
+ case ATK_SCROLL_LEFT_EDGE:
+ case ATK_SCROLL_RIGHT_EDGE:
+ // Align to a particular edge is not supported, it's always the closest edge.
+ alignX = ScrollAlignment::alignToEdgeIfNeeded;
+ alignY = ScrollAlignment::alignCenterIfNeeded;
+ break;
+ case ATK_SCROLL_ANYWHERE:
+ alignX = ScrollAlignment::alignCenterIfNeeded;
+ alignY = ScrollAlignment::alignCenterIfNeeded;
+ break;
+ }
+
+ auto& coreObject = webkitAccessibleGetAccessibilityObject(accessible);
+ coreObject.scrollToMakeVisible({ SelectionRevealMode::Reveal, alignX, alignY, ShouldAllowCrossOriginScrolling::Yes });
+
+ return TRUE;
+}
+
+static gboolean webkitAccessibleComponentScrollToPoint(AtkComponent* component, AtkCoordType coordType, gint x, gint y)
+{
+ auto* accessible = WEBKIT_ACCESSIBLE(component);
+ returnValIfWebKitAccessibleIsInvalid(accessible, FALSE);
+
+ auto& coreObject = webkitAccessibleGetAccessibilityObject(accessible);
+
+ IntPoint point(x, y);
+ if (coordType == ATK_XY_SCREEN) {
+ if (auto* frameView = coreObject.documentFrameView())
+ point = frameView->contentsToWindow(frameView->screenToContents(point));
+ }
+
+ coreObject.scrollToGlobalPoint(point);
+
+ return TRUE;
+}
+#endif
+
+void webkitAccessibleComponentInterfaceInit(AtkComponentIface* iface)
+{
+ iface->ref_accessible_at_point = webkitAccessibleComponentRefAccessibleAtPoint;
+ iface->get_extents = webkitAccessibleComponentGetExtents;
+ iface->grab_focus = webkitAccessibleComponentGrabFocus;
+#if ATK_CHECK_VERSION(2, 30, 0)
+ iface->scroll_to = webkitAccessibleComponentScrollTo;
+ iface->scroll_to_point = webkitAccessibleComponentScrollToPoint;
+#endif
+}
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceComponent.h webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceComponent.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceComponent.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceComponent.h 2023-03-09 13:26:47.278643843 -0600
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2009, 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include <atk/atk.h>
+
+void webkitAccessibleComponentInterfaceInit(AtkComponentIface*);
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceDocument.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceDocument.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceDocument.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceDocument.cpp 2023-03-09 13:26:47.282643864 -0600
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2012 Igalia S.L.
+ * Copyright (C) 2013 Samsung Electronics
+ *
+ * Portions from Mozilla a11y, copyright as follows:
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is
+ * Sun Microsystems, Inc.
+ * Portions created by the Initial Developer are Copyright (C) 2002
+ * the Initial Developer. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebKitAccessibleInterfaceDocument.h"
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include "AccessibilityObject.h"
+#include "DocumentInlines.h"
+#include "DocumentType.h"
+#include "WebKitAccessible.h"
+#include "WebKitAccessibleUtil.h"
+
+using namespace WebCore;
+
+static AccessibilityObject* core(AtkDocument* document)
+{
+ if (!WEBKIT_IS_ACCESSIBLE(document))
+ return 0;
+
+ return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(document));
+}
+
+static const gchar* documentAttributeValue(AtkDocument* document, const gchar* attribute)
+{
+ Document* coreDocument = core(document)->document();
+ if (!coreDocument)
+ return 0;
+
+ String value;
+ AtkCachedProperty atkCachedProperty;
+
+ if (!g_ascii_strcasecmp(attribute, "DocType") && coreDocument->doctype()) {
+ value = coreDocument->doctype()->name();
+ atkCachedProperty = AtkCachedDocumentType;
+ } else if (!g_ascii_strcasecmp(attribute, "Encoding")) {
+ value = coreDocument->charset();
+ atkCachedProperty = AtkCachedDocumentEncoding;
+ } else if (!g_ascii_strcasecmp(attribute, "URI")) {
+ value = coreDocument->documentURI();
+ atkCachedProperty = AtkCachedDocumentURI;
+ }
+
+ if (!value.isEmpty())
+ return webkitAccessibleCacheAndReturnAtkProperty(WEBKIT_ACCESSIBLE(document), atkCachedProperty, value.utf8());
+
+ return 0;
+}
+
+static const gchar* webkitAccessibleDocumentGetAttributeValue(AtkDocument* document, const gchar* attribute)
+{
+ g_return_val_if_fail(ATK_IS_DOCUMENT(document), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(document), 0);
+
+ return documentAttributeValue(document, attribute);
+}
+
+static AtkAttributeSet* webkitAccessibleDocumentGetAttributes(AtkDocument* document)
+{
+ g_return_val_if_fail(ATK_IS_DOCUMENT(document), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(document), 0);
+
+ AtkAttributeSet* attributeSet = nullptr;
+ const gchar* attributes[] = { "DocType", "Encoding", "URI" };
+
+ for (unsigned i = 0; i < G_N_ELEMENTS(attributes); i++) {
+ const gchar* value = documentAttributeValue(document, attributes[i]);
+ if (value)
+ attributeSet = addToAtkAttributeSet(attributeSet, attributes[i], value);
+ }
+
+ return attributeSet;
+}
+
+static const gchar* webkitAccessibleDocumentGetLocale(AtkDocument* document)
+{
+ g_return_val_if_fail(ATK_IS_DOCUMENT(document), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(document), 0);
+
+ // The logic to resolve locale has been moved to
+ // AtkObject::get_object_locale() virtual method. However, to avoid breaking
+ // clients expecting the deprecated AtkDocumentIface::get_document_locale()
+ // to be overriden, method is kept and chained up to
+ // AtkObject::get_object_locale(). <https://bugs.webkit.org/show_bug.cgi?id=115647>
+ return atk_object_get_object_locale(ATK_OBJECT(document));
+}
+
+void webkitAccessibleDocumentInterfaceInit(AtkDocumentIface* iface)
+{
+ iface->get_document_attribute_value = webkitAccessibleDocumentGetAttributeValue;
+ iface->get_document_attributes = webkitAccessibleDocumentGetAttributes;
+ iface->get_document_locale = webkitAccessibleDocumentGetLocale;
+}
+
+#endif
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceDocument.h webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceDocument.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceDocument.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceDocument.h 2023-03-09 13:26:47.282643864 -0600
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include <atk/atk.h>
+
+void webkitAccessibleDocumentInterfaceInit(AtkDocumentIface*);
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceEditableText.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceEditableText.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceEditableText.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceEditableText.cpp 2023-03-09 13:26:47.282643864 -0600
@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2011, 2012 Igalia S.L.
+ *
+ * Portions from Mozilla a11y, copyright as follows:
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is
+ * Sun Microsystems, Inc.
+ * Portions created by the Initial Developer are Copyright (C) 2002
+ * the Initial Developer. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebKitAccessibleInterfaceEditableText.h"
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include "AccessibilityObject.h"
+#include "Document.h"
+#include "Editor.h"
+#include "Frame.h"
+#include "NotImplemented.h"
+#include "WebKitAccessible.h"
+#include "WebKitAccessibleUtil.h"
+
+using namespace WebCore;
+
+static AccessibilityObject* core(AtkEditableText* text)
+{
+ if (!WEBKIT_IS_ACCESSIBLE(text))
+ return 0;
+
+ return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(text));
+}
+
+static gboolean webkitAccessibleEditableTextSetRunAttributes(AtkEditableText* text, AtkAttributeSet*, gint, gint)
+{
+ g_return_val_if_fail(ATK_IS_EDITABLE_TEXT(text), FALSE);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text), FALSE);
+
+ notImplemented();
+ return FALSE;
+}
+
+static void webkitAccessibleEditableTextSetTextContents(AtkEditableText* text, const gchar* string)
+{
+ g_return_if_fail(ATK_IS_EDITABLE_TEXT(text));
+ returnIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text));
+
+ // FIXME: string nullcheck?
+ core(text)->setValue(String::fromUTF8(string));
+}
+
+static void webkitAccessibleEditableTextInsertText(AtkEditableText* text, const gchar* string, gint length, gint* position)
+{
+ g_return_if_fail(ATK_IS_EDITABLE_TEXT(text));
+ returnIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text));
+
+ if (!string)
+ return;
+
+ AccessibilityObject* coreObject = core(text);
+ // FIXME: Not implemented in WebCore
+ // coreObject->setSelectedTextRange(PlainTextRange(*position, 0));
+ // coreObject->setSelectedText(String::fromUTF8(string));
+
+ Document* document = coreObject->document();
+ if (!document || !document->frame())
+ return;
+
+ coreObject->setSelectedVisiblePositionRange(coreObject->visiblePositionRangeForRange(PlainTextRange(*position, 0)));
+ coreObject->setFocused(true);
+ // FIXME: We should set position to the actual inserted text length, which may be less than that requested.
+ if (document->frame()->editor().insertTextWithoutSendingTextEvent(String::fromUTF8(string).substring(0, length), false, 0))
+ *position += length;
+}
+
+static void webkitAccessibleEditableTextCopyText(AtkEditableText* text, gint, gint)
+{
+ g_return_if_fail(ATK_IS_EDITABLE_TEXT(text));
+ returnIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text));
+
+ notImplemented();
+}
+
+static void webkitAccessibleEditableTextCutText(AtkEditableText* text, gint, gint)
+{
+ g_return_if_fail(ATK_IS_EDITABLE_TEXT(text));
+ returnIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text));
+
+ notImplemented();
+}
+
+static void webkitAccessibleEditableTextDeleteText(AtkEditableText* text, gint startPos, gint endPos)
+{
+ g_return_if_fail(ATK_IS_EDITABLE_TEXT(text));
+ returnIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text));
+
+ AccessibilityObject* coreObject = core(text);
+ // FIXME: Not implemented in WebCore
+ // coreObject->setSelectedTextRange(PlainTextRange(startPos, endPos - startPos));
+ // coreObject->setSelectedText(String());
+
+ Document* document = coreObject->document();
+ if (!document || !document->frame())
+ return;
+
+ coreObject->setSelectedVisiblePositionRange(coreObject->visiblePositionRangeForRange(PlainTextRange(startPos, endPos - startPos)));
+ coreObject->setFocused(true);
+ document->frame()->editor().performDelete();
+}
+
+static void webkitAccessibleEditableTextPasteText(AtkEditableText* text, gint)
+{
+ g_return_if_fail(ATK_IS_EDITABLE_TEXT(text));
+ returnIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text));
+
+ notImplemented();
+}
+
+void webkitAccessibleEditableTextInterfaceInit(AtkEditableTextIface* iface)
+{
+ iface->set_run_attributes = webkitAccessibleEditableTextSetRunAttributes;
+ iface->set_text_contents = webkitAccessibleEditableTextSetTextContents;
+ iface->insert_text = webkitAccessibleEditableTextInsertText;
+ iface->copy_text = webkitAccessibleEditableTextCopyText;
+ iface->cut_text = webkitAccessibleEditableTextCutText;
+ iface->delete_text = webkitAccessibleEditableTextDeleteText;
+ iface->paste_text = webkitAccessibleEditableTextPasteText;
+}
+
+#endif
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceEditableText.h webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceEditableText.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceEditableText.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceEditableText.h 2023-03-09 13:26:47.282643864 -0600
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2011, 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include <atk/atk.h>
+
+void webkitAccessibleEditableTextInterfaceInit(AtkEditableTextIface*);
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceHyperlinkImpl.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceHyperlinkImpl.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceHyperlinkImpl.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceHyperlinkImpl.cpp 2023-03-09 13:26:47.282643864 -0600
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2010, 2011, 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebKitAccessibleInterfaceHyperlinkImpl.h"
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include "WebKitAccessibleHyperlink.h"
+
+static AtkHyperlink* webkitAccessibleHyperlinkImplGetHyperlink(AtkHyperlinkImpl* hyperlink)
+{
+ return ATK_HYPERLINK(webkitAccessibleHyperlinkGetOrCreate(hyperlink));
+}
+
+void webkitAccessibleHyperlinkImplInterfaceInit(AtkHyperlinkImplIface* iface)
+{
+ iface->get_hyperlink = webkitAccessibleHyperlinkImplGetHyperlink;
+}
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceHyperlinkImpl.h webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceHyperlinkImpl.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceHyperlinkImpl.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceHyperlinkImpl.h 2023-03-09 13:26:47.282643864 -0600
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2010, 2011, 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include <atk/atk.h>
+
+void webkitAccessibleHyperlinkImplInterfaceInit(AtkHyperlinkImplIface*);
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceHypertext.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceHypertext.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceHypertext.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceHypertext.cpp 2023-03-09 13:26:47.282643864 -0600
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2010, 2011, 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebKitAccessibleInterfaceHypertext.h"
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include "AccessibilityObject.h"
+#include "WebKitAccessible.h"
+#include "WebKitAccessibleUtil.h"
+
+using namespace WebCore;
+
+static AccessibilityObject* core(AtkHypertext* hypertext)
+{
+ if (!WEBKIT_IS_ACCESSIBLE(hypertext))
+ return 0;
+
+ return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(hypertext));
+}
+
+static AtkHyperlink* webkitAccessibleHypertextGetLink(AtkHypertext* hypertext, gint index)
+{
+ g_return_val_if_fail(ATK_HYPERTEXT(hypertext), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(hypertext), 0);
+
+ const AccessibilityObject::AccessibilityChildrenVector& children = core(hypertext)->children();
+ if (index < 0 || static_cast<unsigned>(index) >= children.size())
+ return 0;
+
+ gint currentLink = -1;
+ for (const auto& child : children) {
+ AXCoreObject* coreChild = child.get();
+ if (!coreChild->accessibilityIsIgnored()) {
+ auto* axObject = coreChild->wrapper();
+ if (!axObject || !ATK_IS_HYPERLINK_IMPL(axObject))
+ continue;
+
+ currentLink++;
+ if (index != currentLink)
+ continue;
+
+ return atk_hyperlink_impl_get_hyperlink(ATK_HYPERLINK_IMPL(axObject));
+ }
+ }
+
+ return 0;
+}
+
+static gint webkitAccessibleHypertextGetNLinks(AtkHypertext* hypertext)
+{
+ g_return_val_if_fail(ATK_HYPERTEXT(hypertext), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(hypertext), 0);
+
+ const AccessibilityObject::AccessibilityChildrenVector& children = core(hypertext)->children();
+ gint linksFound = 0;
+ for (const auto& child : children) {
+ AXCoreObject* coreChild = child.get();
+ if (!coreChild->accessibilityIsIgnored()) {
+ auto* axObject = coreChild->wrapper();
+ if (axObject && ATK_IS_HYPERLINK_IMPL(axObject))
+ linksFound++;
+ }
+ }
+
+ return linksFound;
+}
+
+static gint webkitAccessibleHypertextGetLinkIndex(AtkHypertext* hypertext, gint charIndex)
+{
+ g_return_val_if_fail(ATK_HYPERTEXT(hypertext), -1);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(hypertext), -1);
+
+ size_t linksCount = webkitAccessibleHypertextGetNLinks(hypertext);
+ if (!linksCount)
+ return -1;
+
+ for (size_t i = 0; i < linksCount; i++) {
+ AtkHyperlink* hyperlink = ATK_HYPERLINK(webkitAccessibleHypertextGetLink(hypertext, i));
+ gint startIndex = atk_hyperlink_get_start_index(hyperlink);
+ gint endIndex = atk_hyperlink_get_end_index(hyperlink);
+
+ // Check if the char index in the link's offset range
+ if (startIndex <= charIndex && charIndex < endIndex)
+ return i;
+ }
+
+ // Not found if reached
+ return -1;
+}
+
+void webkitAccessibleHypertextInterfaceInit(AtkHypertextIface* iface)
+{
+ iface->get_link = webkitAccessibleHypertextGetLink;
+ iface->get_n_links = webkitAccessibleHypertextGetNLinks;
+ iface->get_link_index = webkitAccessibleHypertextGetLinkIndex;
+}
+
+#endif
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceHypertext.h webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceHypertext.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceHypertext.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceHypertext.h 2023-03-09 13:26:47.282643864 -0600
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2010, 2011, 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include <atk/atk.h>
+
+void webkitAccessibleHypertextInterfaceInit(AtkHypertextIface*);
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceImage.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceImage.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceImage.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceImage.cpp 2023-03-09 13:26:47.282643864 -0600
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2009, 2012 Igalia S.L.
+ * Copyright (C) 2013 Samsung Electronics
+ *
+ * Portions from Mozilla a11y, copyright as follows:
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is
+ * Sun Microsystems, Inc.
+ * Portions created by the Initial Developer are Copyright (C) 2002
+ * the Initial Developer. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebKitAccessibleInterfaceImage.h"
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include "AccessibilityObject.h"
+#include "IntRect.h"
+#include "WebKitAccessible.h"
+#include "WebKitAccessibleUtil.h"
+
+using namespace WebCore;
+
+static AccessibilityObject* core(AtkImage* image)
+{
+ if (!WEBKIT_IS_ACCESSIBLE(image))
+ return 0;
+
+ return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(image));
+}
+
+static void webkitAccessibleImageGetImagePosition(AtkImage* image, gint* x, gint* y, AtkCoordType coordType)
+{
+ g_return_if_fail(ATK_IMAGE(image));
+ returnIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(image));
+
+ IntRect rect = snappedIntRect(core(image)->elementRect());
+ contentsRelativeToAtkCoordinateType(core(image), coordType, rect, x, y);
+}
+
+static const gchar* webkitAccessibleImageGetImageDescription(AtkImage* image)
+{
+ auto* accessible = WEBKIT_ACCESSIBLE(image);
+ returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
+
+ return webkitAccessibleCacheAndReturnAtkProperty(accessible, AtkCachedImageDescription, accessibilityDescription(core(image)).utf8());
+}
+
+static void webkitAccessibleImageGetImageSize(AtkImage* image, gint* width, gint* height)
+{
+ g_return_if_fail(ATK_IMAGE(image));
+ returnIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(image));
+
+ IntSize size = snappedIntRect(core(image)->elementRect()).size();
+
+ if (width)
+ *width = size.width();
+ if (height)
+ *height = size.height();
+}
+
+void webkitAccessibleImageInterfaceInit(AtkImageIface* iface)
+{
+ iface->get_image_position = webkitAccessibleImageGetImagePosition;
+ iface->get_image_description = webkitAccessibleImageGetImageDescription;
+ iface->get_image_size = webkitAccessibleImageGetImageSize;
+}
+
+#endif
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceImage.h webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceImage.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceImage.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceImage.h 2023-03-09 13:26:47.282643864 -0600
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2009, 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include <atk/atk.h>
+
+void webkitAccessibleImageInterfaceInit(AtkImageIface*);
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceSelection.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceSelection.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceSelection.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceSelection.cpp 2023-03-09 13:26:47.282643864 -0600
@@ -0,0 +1,256 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2010, 2011, 2012 Igalia S.L.
+ *
+ * Portions from Mozilla a11y, copyright as follows:
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is
+ * Sun Microsystems, Inc.
+ * Portions created by the Initial Developer are Copyright (C) 2002
+ * the Initial Developer. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebKitAccessibleInterfaceSelection.h"
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include "AccessibilityListBox.h"
+#include "AccessibilityObject.h"
+#include "HTMLSelectElement.h"
+#include "RenderObject.h"
+#include "WebKitAccessible.h"
+#include "WebKitAccessibleUtil.h"
+
+using namespace WebCore;
+
+static AccessibilityObject* core(AtkSelection* selection)
+{
+ if (!WEBKIT_IS_ACCESSIBLE(selection))
+ return nullptr;
+
+ return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(selection));
+}
+
+static AXCoreObject* listObjectForCoreSelection(AccessibilityObject* coreSelection)
+{
+ // Only list boxes and menu lists supported so far.
+ if (!coreSelection->isListBox() && !coreSelection->isMenuList())
+ return nullptr;
+
+ // For list boxes the list object is just itself.
+ if (coreSelection->isListBox())
+ return coreSelection;
+
+ // For menu lists we need to return the first accessible child,
+ // with role MenuListPopupRole, since that's the one holding the list
+ // of items with role MenuListOptionRole.
+ const AccessibilityObject::AccessibilityChildrenVector& children = coreSelection->children();
+ if (!children.size())
+ return nullptr;
+
+ AXCoreObject* listObject = children.at(0).get();
+ if (!listObject->isMenuListPopup())
+ return nullptr;
+
+ return listObject;
+}
+
+static AXCoreObject* optionFromList(AtkSelection* selection, gint index)
+{
+ AccessibilityObject* coreSelection = core(selection);
+ if (!coreSelection || index < 0)
+ return nullptr;
+
+ // Need to select the proper list object depending on the type.
+ AXCoreObject* listObject = listObjectForCoreSelection(coreSelection);
+ if (!listObject)
+ return nullptr;
+
+ const AccessibilityObject::AccessibilityChildrenVector& options = listObject->children();
+ if (index < static_cast<gint>(options.size()))
+ return options.at(index).get();
+
+ return nullptr;
+}
+
+static AXCoreObject* optionFromSelection(AtkSelection* selection, gint index)
+{
+ AccessibilityObject* coreSelection = core(selection);
+ if (!coreSelection || !coreSelection->isAccessibilityRenderObject() || index < 0)
+ return nullptr;
+
+ // This method provides the functionality expected by atk_selection_ref_selection().
+ // According to the ATK documentation for this method, the index is "a gint specifying
+ // the index in the selection set. (e.g. the ith selection as opposed to the ith child)."
+ // There is different API, namely atk_object_ref_accessible_child(), when the ith child
+ // from the set of all children is sought.
+ AccessibilityObject::AccessibilityChildrenVector options;
+ coreSelection->selectedChildren(options);
+ if (index < static_cast<gint>(options.size()))
+ return options.at(index).get();
+
+ return nullptr;
+}
+
+static gboolean webkitAccessibleSelectionAddSelection(AtkSelection* selection, gint index)
+{
+ g_return_val_if_fail(ATK_SELECTION(selection), FALSE);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(selection), FALSE);
+
+ AccessibilityObject* coreSelection = core(selection);
+ if (!coreSelection)
+ return FALSE;
+
+ AXCoreObject* option = optionFromList(selection, index);
+ if (option && (coreSelection->isListBox() || coreSelection->isMenuList())) {
+ option->setSelected(true);
+ return option->isSelected();
+ }
+
+ return FALSE;
+}
+
+static gboolean webkitAccessibleSelectionClearSelection(AtkSelection* selection)
+{
+ g_return_val_if_fail(ATK_SELECTION(selection), FALSE);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(selection), FALSE);
+
+ AccessibilityObject* coreSelection = core(selection);
+ if (!coreSelection)
+ return FALSE;
+
+ AccessibilityObject::AccessibilityChildrenVector selectedItems;
+ if (is<AccessibilityListBox>(*coreSelection)) {
+ // Set the list of selected items to an empty list; then verify that it worked.
+ auto& listBox = downcast<AccessibilityListBox>(*coreSelection);
+ listBox.setSelectedChildren(selectedItems);
+ listBox.selectedChildren(selectedItems);
+ return selectedItems.isEmpty();
+ }
+ return FALSE;
+}
+
+static AtkObject* webkitAccessibleSelectionRefSelection(AtkSelection* selection, gint index)
+{
+ g_return_val_if_fail(ATK_SELECTION(selection), nullptr);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(selection), nullptr);
+
+ AXCoreObject* option = optionFromSelection(selection, index);
+ if (option) {
+ auto* child = option->wrapper();
+ g_object_ref(child);
+ return ATK_OBJECT(child);
+ }
+
+ return nullptr;
+}
+
+static gint webkitAccessibleSelectionGetSelectionCount(AtkSelection* selection)
+{
+ g_return_val_if_fail(ATK_SELECTION(selection), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(selection), 0);
+
+ AccessibilityObject* coreSelection = core(selection);
+ if (!coreSelection || !coreSelection->isAccessibilityRenderObject())
+ return 0;
+
+ if (coreSelection->isMenuList()) {
+ RenderObject* renderer = coreSelection->renderer();
+ if (!renderer)
+ return 0;
+
+ int selectedIndex = downcast<HTMLSelectElement>(renderer->node())->selectedIndex();
+ return selectedIndex >= 0 && selectedIndex < static_cast<int>(downcast<HTMLSelectElement>(renderer->node())->listItems().size());
+ }
+
+ AccessibilityObject::AccessibilityChildrenVector selectedItems;
+ coreSelection->selectedChildren(selectedItems);
+ return static_cast<gint>(selectedItems.size());
+}
+
+static gboolean webkitAccessibleSelectionIsChildSelected(AtkSelection* selection, gint index)
+{
+ g_return_val_if_fail(ATK_SELECTION(selection), FALSE);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(selection), FALSE);
+
+ AccessibilityObject* coreSelection = core(selection);
+ if (!coreSelection)
+ return FALSE;
+
+ AXCoreObject* option = optionFromList(selection, index);
+ if (option && (coreSelection->isListBox() || coreSelection->isMenuList()))
+ return option->isSelected();
+
+ return FALSE;
+}
+
+static gboolean webkitAccessibleSelectionRemoveSelection(AtkSelection* selection, gint index)
+{
+ g_return_val_if_fail(ATK_SELECTION(selection), FALSE);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(selection), FALSE);
+
+ AccessibilityObject* coreSelection = core(selection);
+ if (!coreSelection)
+ return FALSE;
+
+ AXCoreObject* option = optionFromSelection(selection, index);
+ if (option && (coreSelection->isListBox() || coreSelection->isMenuList())) {
+ option->setSelected(false);
+ return !option->isSelected();
+ }
+
+ return FALSE;
+}
+
+static gboolean webkitAccessibleSelectionSelectAllSelection(AtkSelection* selection)
+{
+ g_return_val_if_fail(ATK_SELECTION(selection), FALSE);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(selection), FALSE);
+
+ AccessibilityObject* coreSelection = core(selection);
+ if (!coreSelection || !coreSelection->isMultiSelectable())
+ return FALSE;
+
+ if (is<AccessibilityListBox>(*coreSelection)) {
+ const AccessibilityObject::AccessibilityChildrenVector& children = coreSelection->children();
+ AccessibilityListBox& listBox = downcast<AccessibilityListBox>(*coreSelection);
+ listBox.setSelectedChildren(children);
+ AccessibilityObject::AccessibilityChildrenVector selectedItems;
+ listBox.selectedChildren(selectedItems);
+ return selectedItems.size() == children.size();
+ }
+
+ return FALSE;
+}
+
+void webkitAccessibleSelectionInterfaceInit(AtkSelectionIface* iface)
+{
+ iface->add_selection = webkitAccessibleSelectionAddSelection;
+ iface->clear_selection = webkitAccessibleSelectionClearSelection;
+ iface->ref_selection = webkitAccessibleSelectionRefSelection;
+ iface->get_selection_count = webkitAccessibleSelectionGetSelectionCount;
+ iface->is_child_selected = webkitAccessibleSelectionIsChildSelected;
+ iface->remove_selection = webkitAccessibleSelectionRemoveSelection;
+ iface->select_all_selection = webkitAccessibleSelectionSelectAllSelection;
+}
+
+#endif
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceSelection.h webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceSelection.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceSelection.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceSelection.h 2023-03-09 13:26:47.282643864 -0600
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2010, 2011, 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include <atk/atk.h>
+
+void webkitAccessibleSelectionInterfaceInit(AtkSelectionIface*);
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceTableCell.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceTableCell.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceTableCell.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceTableCell.cpp 2023-03-09 13:26:47.286643885 -0600
@@ -0,0 +1,156 @@
+/*
+ * Copyright (C) 2014 Samsung Electronics. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebKitAccessibleInterfaceTableCell.h"
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include "AccessibilityObject.h"
+#include "AccessibilityTable.h"
+#include "AccessibilityTableCell.h"
+#include "WebKitAccessible.h"
+#include "WebKitAccessibleUtil.h"
+
+using namespace WebCore;
+
+static GPtrArray* convertToGPtrArray(const AccessibilityObject::AccessibilityChildrenVector& children)
+{
+ GPtrArray* array = g_ptr_array_new();
+ for (const auto& child : children) {
+ if (auto* atkObject = child->wrapper())
+ g_ptr_array_add(array, atkObject);
+ }
+ return array;
+}
+
+static AccessibilityObject* core(AtkTableCell* cell)
+{
+ if (!WEBKIT_IS_ACCESSIBLE(cell))
+ return nullptr;
+
+ return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(cell));
+}
+
+GPtrArray* webkitAccessibleTableCellGetColumnHeaderCells(AtkTableCell* cell)
+{
+ g_return_val_if_fail(ATK_TABLE_CELL(cell), nullptr);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(cell), nullptr);
+
+ AccessibilityObject* axObject = core(cell);
+ if (!is<AccessibilityTableCell>(axObject))
+ return nullptr;
+
+ auto columnHeaders = downcast<AccessibilityTableCell>(*axObject).columnHeaders();
+
+ return convertToGPtrArray(columnHeaders);
+}
+
+GPtrArray* webkitAccessibleTableCellGetRowHeaderCells(AtkTableCell* cell)
+{
+ g_return_val_if_fail(ATK_TABLE_CELL(cell), nullptr);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(cell), nullptr);
+
+ AccessibilityObject* axObject = core(cell);
+ if (!is<AccessibilityTableCell>(axObject))
+ return nullptr;
+
+ auto rowHeaders = downcast<AccessibilityTableCell>(*axObject).rowHeaders();
+
+ return convertToGPtrArray(rowHeaders);
+}
+
+gint webkitAccessibleTableCellGetColumnSpan(AtkTableCell* cell)
+{
+ g_return_val_if_fail(ATK_TABLE_CELL(cell), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(cell), 0);
+
+ AccessibilityObject* axObject = core(cell);
+ if (!is<AccessibilityTableCell>(axObject))
+ return 0;
+
+ return axObject->columnIndexRange().second;
+}
+
+gint webkitAccessibleTableCellGetRowSpan(AtkTableCell* cell)
+{
+ g_return_val_if_fail(ATK_TABLE_CELL(cell), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(cell), 0);
+
+ AccessibilityObject* axObject = core(cell);
+ if (!is<AccessibilityTableCell>(axObject))
+ return 0;
+
+ return axObject->rowIndexRange().second;
+}
+
+gboolean webkitAccessibleTableCellGetPosition(AtkTableCell* cell, gint* row, gint* column)
+{
+ g_return_val_if_fail(ATK_TABLE_CELL(cell), false);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(cell), false);
+
+ AccessibilityObject* axObject = core(cell);
+ if (!is<AccessibilityTableCell>(axObject))
+ return false;
+
+ if (row) {
+ // aria-rowindex is 1-based.
+ int rowIndex = axObject->axRowIndex() - 1;
+ if (rowIndex <= -1)
+ rowIndex = axObject->rowIndexRange().first;
+ *row = rowIndex;
+ }
+ if (column) {
+ // aria-colindex is 1-based.
+ int columnIndex = axObject->axColumnIndex() - 1;
+ if (columnIndex <= -1)
+ columnIndex = axObject->columnIndexRange().first;
+ *column = columnIndex;
+ }
+
+ return true;
+}
+
+AtkObject* webkitAccessibleTableCellGetTable(AtkTableCell* cell)
+{
+ g_return_val_if_fail(ATK_TABLE_CELL(cell), nullptr);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(cell), nullptr);
+
+ AccessibilityObject* axObject = core(cell);
+ if (!axObject || !axObject->isTableCell())
+ return nullptr;
+
+ auto* table = atk_object_get_parent(ATK_OBJECT(axObject->wrapper()));
+ if (!table || !ATK_IS_TABLE(table))
+ return nullptr;
+
+ return ATK_OBJECT(g_object_ref(table));
+}
+
+void webkitAccessibleTableCellInterfaceInit(AtkTableCellIface* iface)
+{
+ iface->get_column_header_cells = webkitAccessibleTableCellGetColumnHeaderCells;
+ iface->get_row_header_cells = webkitAccessibleTableCellGetRowHeaderCells;
+ iface->get_column_span = webkitAccessibleTableCellGetColumnSpan;
+ iface->get_row_span = webkitAccessibleTableCellGetRowSpan;
+ iface->get_position = webkitAccessibleTableCellGetPosition;
+ iface->get_table = webkitAccessibleTableCellGetTable;
+}
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceTableCell.h webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceTableCell.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceTableCell.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceTableCell.h 2023-03-09 13:26:47.286643885 -0600
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2009, 2010, 2011, 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include <atk/atk.h>
+
+void webkitAccessibleTableCellInterfaceInit(AtkTableCellIface*);
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceTable.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceTable.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceTable.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceTable.cpp 2023-03-09 13:26:47.286643885 -0600
@@ -0,0 +1,290 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2009, 2010, 2011, 2012 Igalia S.L.
+ *
+ * Portions from Mozilla a11y, copyright as follows:
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is
+ * Sun Microsystems, Inc.
+ * Portions created by the Initial Developer are Copyright (C) 2002
+ * the Initial Developer. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebKitAccessibleInterfaceTable.h"
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include "AccessibilityListBox.h"
+#include "AccessibilityObject.h"
+#include "AccessibilityTable.h"
+#include "AccessibilityTableCell.h"
+#include "HTMLTableCaptionElement.h"
+#include "HTMLTableElement.h"
+#include "RenderElement.h"
+#include "WebKitAccessible.h"
+#include "WebKitAccessibleInterfaceText.h"
+#include "WebKitAccessibleUtil.h"
+
+using namespace WebCore;
+
+static AccessibilityObject* core(AtkTable* table)
+{
+ if (!WEBKIT_IS_ACCESSIBLE(table))
+ return nullptr;
+
+ return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(table));
+}
+
+static AXCoreObject* cell(AtkTable* table, guint row, guint column)
+{
+ auto* accTable = core(table);
+ return accTable ? accTable->cellForColumnAndRow(column, row) : nullptr;
+}
+
+static gint cellIndex(AXCoreObject* axCell, AccessibilityTable* axTable)
+{
+ // Calculate the cell's index as if we had a traditional Gtk+ table in
+ // which cells are all direct children of the table, arranged row-first.
+ auto allCells = axTable->cells();
+ AXCoreObject::AccessibilityChildrenVector::iterator position;
+ position = std::find(allCells.begin(), allCells.end(), axCell);
+ if (position == allCells.end())
+ return -1;
+ return position - allCells.begin();
+}
+
+static AccessibilityTableCell* cellAtIndex(AtkTable* table, gint index)
+{
+ AccessibilityObject* accTable = core(table);
+ if (is<AccessibilityTable>(*accTable)) {
+ auto allCells = downcast<AccessibilityTable>(*accTable).cells();
+ if (0 <= index && static_cast<unsigned>(index) < allCells.size())
+ return downcast<AccessibilityTableCell>(allCells[index].get());
+ }
+ return nullptr;
+}
+
+static AtkObject* webkitAccessibleTableRefAt(AtkTable* table, gint row, gint column)
+{
+ g_return_val_if_fail(ATK_TABLE(table), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(table), 0);
+
+ auto* axCell = cell(table, row, column);
+ if (!axCell)
+ return 0;
+
+ auto* cell = axCell->wrapper();
+ if (!cell)
+ return 0;
+
+ // This method transfers full ownership over the returned
+ // AtkObject, so an extra reference is needed here.
+ return ATK_OBJECT(g_object_ref(cell));
+}
+
+static gint webkitAccessibleTableGetIndexAt(AtkTable* table, gint row, gint column)
+{
+ g_return_val_if_fail(ATK_TABLE(table), -1);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(table), -1);
+
+ auto* axCell = cell(table, row, column);
+ AccessibilityTable* axTable = downcast<AccessibilityTable>(core(table));
+ return cellIndex(axCell, axTable);
+}
+
+static gint webkitAccessibleTableGetColumnAtIndex(AtkTable* table, gint index)
+{
+ g_return_val_if_fail(ATK_TABLE(table), -1);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(table), -1);
+
+ AccessibilityTableCell* axCell = cellAtIndex(table, index);
+ if (axCell) {
+ auto columnRange = axCell->columnIndexRange();
+ return columnRange.first;
+ }
+ return -1;
+}
+
+static gint webkitAccessibleTableGetRowAtIndex(AtkTable* table, gint index)
+{
+ g_return_val_if_fail(ATK_TABLE(table), -1);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(table), -1);
+
+ AccessibilityTableCell* axCell = cellAtIndex(table, index);
+ if (axCell) {
+ auto rowRange = axCell->rowIndexRange();
+ return rowRange.first;
+ }
+ return -1;
+}
+
+static gint webkitAccessibleTableGetNColumns(AtkTable* table)
+{
+ g_return_val_if_fail(ATK_TABLE(table), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(table), 0);
+
+ AccessibilityObject* accTable = core(table);
+ if (!is<AccessibilityTable>(*accTable))
+ return 0;
+
+ if (int columnCount = downcast<AccessibilityTable>(*accTable).axColumnCount())
+ return columnCount;
+
+ return downcast<AccessibilityTable>(*accTable).columnCount();
+}
+
+static gint webkitAccessibleTableGetNRows(AtkTable* table)
+{
+ g_return_val_if_fail(ATK_TABLE(table), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(table), 0);
+
+ AccessibilityObject* accTable = core(table);
+ if (!is<AccessibilityTable>(*accTable))
+ return 0;
+
+ if (int rowCount = downcast<AccessibilityTable>(*accTable).axRowCount())
+ return rowCount;
+
+ return downcast<AccessibilityTable>(*accTable).rowCount();
+}
+
+static gint webkitAccessibleTableGetColumnExtentAt(AtkTable* table, gint row, gint column)
+{
+ g_return_val_if_fail(ATK_TABLE(table), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(table), 0);
+
+ auto* axCell = cell(table, row, column);
+ if (axCell) {
+ auto columnRange = axCell->columnIndexRange();
+ return columnRange.second;
+ }
+ return 0;
+}
+
+static gint webkitAccessibleTableGetRowExtentAt(AtkTable* table, gint row, gint column)
+{
+ g_return_val_if_fail(ATK_TABLE(table), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(table), 0);
+
+ auto* axCell = cell(table, row, column);
+ if (axCell) {
+ auto rowRange = axCell->rowIndexRange();
+ return rowRange.second;
+ }
+ return 0;
+}
+
+static AtkObject* webkitAccessibleTableGetColumnHeader(AtkTable* table, gint column)
+{
+ g_return_val_if_fail(ATK_TABLE(table), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(table), 0);
+
+ AccessibilityObject* accTable = core(table);
+ if (is<AccessibilityTable>(*accTable)) {
+ auto columnHeaders = downcast<AccessibilityTable>(*accTable).columnHeaders();
+
+ for (const auto& columnHeader : columnHeaders) {
+ auto columnRange = columnHeader->columnIndexRange();
+ if (columnRange.first <= static_cast<unsigned>(column) && static_cast<unsigned>(column) < columnRange.first + columnRange.second)
+ return ATK_OBJECT(columnHeader->wrapper());
+ }
+ }
+ return nullptr;
+}
+
+static AtkObject* webkitAccessibleTableGetRowHeader(AtkTable* table, gint row)
+{
+ g_return_val_if_fail(ATK_TABLE(table), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(table), 0);
+
+ AccessibilityObject* accTable = core(table);
+ if (is<AccessibilityTable>(*accTable)) {
+ auto rowHeaders = downcast<AccessibilityTable>(*accTable).rowHeaders();
+
+ for (const auto& rowHeader : rowHeaders) {
+ auto rowRange = rowHeader->rowIndexRange();
+ if (rowRange.first <= static_cast<unsigned>(row) && static_cast<unsigned>(row) < rowRange.first + rowRange.second)
+ return ATK_OBJECT(rowHeader->wrapper());
+ }
+ }
+ return nullptr;
+}
+
+static AtkObject* webkitAccessibleTableGetCaption(AtkTable* table)
+{
+ g_return_val_if_fail(ATK_TABLE(table), nullptr);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(table), nullptr);
+
+ AccessibilityObject* accTable = core(table);
+ if (accTable->isAccessibilityRenderObject()) {
+ Node* node = accTable->node();
+ if (is<HTMLTableElement>(node)) {
+ auto caption = downcast<HTMLTableElement>(*node).caption();
+ if (caption)
+ return ATK_OBJECT(AccessibilityObject::firstAccessibleObjectFromNode(caption->renderer()->element())->wrapper());
+ }
+ }
+ return nullptr;
+}
+
+static const gchar* webkitAccessibleTableGetColumnDescription(AtkTable* table, gint column)
+{
+ g_return_val_if_fail(ATK_TABLE(table), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(table), 0);
+
+ AtkObject* columnHeader = atk_table_get_column_header(table, column);
+ if (columnHeader && ATK_IS_TEXT(columnHeader))
+ return atk_text_get_text(ATK_TEXT(columnHeader), 0, -1);
+
+ return 0;
+}
+
+static const gchar* webkitAccessibleTableGetRowDescription(AtkTable* table, gint row)
+{
+ g_return_val_if_fail(ATK_TABLE(table), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(table), 0);
+
+ AtkObject* rowHeader = atk_table_get_row_header(table, row);
+ if (rowHeader && ATK_IS_TEXT(rowHeader))
+ return atk_text_get_text(ATK_TEXT(rowHeader), 0, -1);
+
+ return 0;
+}
+
+void webkitAccessibleTableInterfaceInit(AtkTableIface* iface)
+{
+ iface->ref_at = webkitAccessibleTableRefAt;
+ iface->get_index_at = webkitAccessibleTableGetIndexAt;
+ iface->get_column_at_index = webkitAccessibleTableGetColumnAtIndex;
+ iface->get_row_at_index = webkitAccessibleTableGetRowAtIndex;
+ iface->get_n_columns = webkitAccessibleTableGetNColumns;
+ iface->get_n_rows = webkitAccessibleTableGetNRows;
+ iface->get_column_extent_at = webkitAccessibleTableGetColumnExtentAt;
+ iface->get_row_extent_at = webkitAccessibleTableGetRowExtentAt;
+ iface->get_column_header = webkitAccessibleTableGetColumnHeader;
+ iface->get_row_header = webkitAccessibleTableGetRowHeader;
+ iface->get_caption = webkitAccessibleTableGetCaption;
+ iface->get_column_description = webkitAccessibleTableGetColumnDescription;
+ iface->get_row_description = webkitAccessibleTableGetRowDescription;
+}
+
+#endif
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceTable.h webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceTable.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceTable.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceTable.h 2023-03-09 13:26:47.286643885 -0600
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2009, 2010, 2011, 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include <atk/atk.h>
+
+void webkitAccessibleTableInterfaceInit(AtkTableIface*);
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceText.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceText.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceText.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceText.cpp 2023-03-09 13:26:47.286643885 -0600
@@ -0,0 +1,1270 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2009, 2010, 2011, 2012 Igalia S.L.
+ * Copyright (C) 2013 Samsung Electronics. All rights reserved.
+ *
+ * Portions from Mozilla a11y, copyright as follows:
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is
+ * Sun Microsystems, Inc.
+ * Portions created by the Initial Developer are Copyright (C) 2002
+ * the Initial Developer. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebKitAccessibleInterfaceText.h"
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include "AccessibilityObject.h"
+#include "Document.h"
+#include "Editing.h"
+#include "FontCascade.h"
+#include "FrameView.h"
+#include "HTMLParserIdioms.h"
+#include "HostWindow.h"
+#include "NotImplemented.h"
+#include "Range.h"
+#include "RenderListItem.h"
+#include "RenderListMarker.h"
+#include "RenderText.h"
+#include "TextIterator.h"
+#include "VisibleUnits.h"
+#include "WebKitAccessible.h"
+#include "WebKitAccessibleUtil.h"
+#include <pal/text/TextEncoding.h>
+#include <wtf/glib/GUniquePtr.h>
+#include <wtf/text/CString.h>
+
+using namespace WebCore;
+
+// Text attribute to expose the ARIA 'aria-invalid' attribute. Initially initialized
+// to ATK_TEXT_ATTR_INVALID (which means 'invalid' text attribute'), will later on
+// hold a reference to the custom registered AtkTextAttribute that we will use.
+static AtkTextAttribute atkTextAttributeInvalid = ATK_TEXT_ATTR_INVALID;
+
+static AccessibilityObject* core(AtkText* text)
+{
+ if (!WEBKIT_IS_ACCESSIBLE(text))
+ return 0;
+
+ return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(text));
+}
+
+static int baselinePositionForRenderObject(RenderObject* renderObject)
+{
+ // FIXME: This implementation of baselinePosition originates from RenderObject.cpp and was
+ // removed in r70072. The implementation looks incorrect though, because this is not the
+ // baseline of the underlying RenderObject, but of the AccessibilityRenderObject.
+ const FontMetrics& fontMetrics = renderObject->firstLineStyle().metricsOfPrimaryFont();
+ return fontMetrics.ascent() + (renderObject->firstLineStyle().computedLineHeight() - fontMetrics.height()) / 2;
+}
+
+static AtkAttributeSet* getAttributeSetForAccessibilityObject(const AccessibilityObject* object)
+{
+ if (!object->isAccessibilityRenderObject())
+ return 0;
+
+ RenderObject* renderer = object->renderer();
+ auto* style = &renderer->style();
+
+ AtkAttributeSet* result = nullptr;
+ GUniquePtr<gchar> buffer(g_strdup_printf("%i", style->computedFontPixelSize()));
+ result = addToAtkAttributeSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_SIZE), buffer.get());
+
+ Color bgColor = style->visitedDependentColor(CSSPropertyBackgroundColor);
+ if (bgColor.isValid()) {
+ auto [r, g, b, a] = bgColor.toColorTypeLossy<SRGBA<uint8_t>>().resolved();
+ buffer.reset(g_strdup_printf("%i,%i,%i", r, g, b));
+ result = addToAtkAttributeSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_BG_COLOR), buffer.get());
+ }
+
+ Color fgColor = style->visitedDependentColor(CSSPropertyColor);
+ if (fgColor.isValid()) {
+ auto [r, g, b, a] = fgColor.toColorTypeLossy<SRGBA<uint8_t>>().resolved();
+ buffer.reset(g_strdup_printf("%i,%i,%i", r, g, b));
+ result = addToAtkAttributeSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_FG_COLOR), buffer.get());
+ }
+
+ int baselinePosition;
+ bool includeRise = true;
+ switch (style->verticalAlign()) {
+ case VerticalAlign::Sub:
+ baselinePosition = -1 * baselinePositionForRenderObject(renderer);
+ break;
+ case VerticalAlign::Super:
+ baselinePosition = baselinePositionForRenderObject(renderer);
+ break;
+ case VerticalAlign::Baseline:
+ baselinePosition = 0;
+ break;
+ default:
+ includeRise = false;
+ break;
+ }
+
+ if (includeRise) {
+ buffer.reset(g_strdup_printf("%i", baselinePosition));
+ result = addToAtkAttributeSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_RISE), buffer.get());
+ }
+
+ if (!style->textIndent().isUndefined()) {
+ int indentation = valueForLength(style->textIndent(), object->size().width());
+ buffer.reset(g_strdup_printf("%i", indentation));
+ result = addToAtkAttributeSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_INDENT), buffer.get());
+ }
+
+ String fontFamilyName = style->fontCascade().firstFamily();
+ if (fontFamilyName.left(8) == "-webkit-"_s)
+ fontFamilyName = fontFamilyName.substring(8);
+
+ result = addToAtkAttributeSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_FAMILY_NAME), fontFamilyName.utf8().data());
+
+ int fontWeight = static_cast<float>(style->fontCascade().weight());
+ if (fontWeight > 0) {
+ buffer.reset(g_strdup_printf("%i", fontWeight));
+ result = addToAtkAttributeSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_WEIGHT), buffer.get());
+ }
+
+ switch (style->textAlign()) {
+ case TextAlignMode::Start:
+ case TextAlignMode::End:
+ break;
+ case TextAlignMode::Left:
+ case TextAlignMode::WebKitLeft:
+ result = addToAtkAttributeSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_JUSTIFICATION), "left");
+ break;
+ case TextAlignMode::Right:
+ case TextAlignMode::WebKitRight:
+ result = addToAtkAttributeSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_JUSTIFICATION), "right");
+ break;
+ case TextAlignMode::Center:
+ case TextAlignMode::WebKitCenter:
+ result = addToAtkAttributeSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_JUSTIFICATION), "center");
+ break;
+ case TextAlignMode::Justify:
+ result = addToAtkAttributeSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_JUSTIFICATION), "fill");
+ }
+
+ result = addToAtkAttributeSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_UNDERLINE), (style->textDecorationLine() & TextDecorationLine::Underline) ? "single" : "none");
+
+ result = addToAtkAttributeSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_STYLE), style->fontCascade().italic() ? "italic" : "normal");
+
+ result = addToAtkAttributeSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_STRIKETHROUGH), (style->textDecorationLine() & TextDecorationLine::LineThrough) ? "true" : "false");
+
+ result = addToAtkAttributeSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_INVISIBLE), (style->visibility() == Visibility::Hidden) ? "true" : "false");
+
+ result = addToAtkAttributeSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_EDITABLE), object->canSetValueAttribute() ? "true" : "false");
+
+ String language = object->language();
+ if (!language.isEmpty())
+ result = addToAtkAttributeSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_LANGUAGE), language.utf8().data());
+
+ String invalidStatus = object->invalidStatus();
+ if (invalidStatus != "false"_s) {
+ // Register the custom attribute for 'aria-invalid' if not done yet.
+ if (atkTextAttributeInvalid == ATK_TEXT_ATTR_INVALID)
+ atkTextAttributeInvalid = atk_text_attribute_register("invalid");
+
+ result = addToAtkAttributeSet(result, atk_text_attribute_get_name(atkTextAttributeInvalid), invalidStatus.utf8().data());
+ }
+
+ return result;
+}
+
+static gint compareAttribute(const AtkAttribute* a, const AtkAttribute* b)
+{
+ return g_strcmp0(a->name, b->name) || g_strcmp0(a->value, b->value);
+}
+
+// Returns an AtkAttributeSet with the elements of attributeSet1 which
+// are either not present or different in attributeSet2. Neither
+// attributeSet1 nor attributeSet2 should be used after calling this.
+static AtkAttributeSet* attributeSetDifference(AtkAttributeSet* attributeSet1, AtkAttributeSet* attributeSet2)
+{
+ if (!attributeSet2)
+ return attributeSet1;
+
+ AtkAttributeSet* currentSet = attributeSet1;
+ AtkAttributeSet* found;
+ AtkAttributeSet* toDelete = nullptr;
+
+ while (currentSet) {
+ found = g_slist_find_custom(attributeSet2, currentSet->data, (GCompareFunc)compareAttribute);
+ if (found) {
+ AtkAttributeSet* nextSet = currentSet->next;
+ toDelete = g_slist_prepend(toDelete, currentSet->data);
+ attributeSet1 = g_slist_delete_link(attributeSet1, currentSet);
+ currentSet = nextSet;
+ } else
+ currentSet = currentSet->next;
+ }
+
+ atk_attribute_set_free(attributeSet2);
+ atk_attribute_set_free(toDelete);
+ return attributeSet1;
+}
+
+static gchar* webkitAccessibleTextGetText(AtkText*, gint startOffset, gint endOffset);
+
+static guint accessibilityObjectLength(const AccessibilityObject* object)
+{
+ // Non render objects are not taken into account
+ if (!object->isAccessibilityRenderObject())
+ return 0;
+
+ // For those objects implementing the AtkText interface we use the
+ // well known API to always get the text in a consistent way
+ auto* atkObj = ATK_OBJECT(object->wrapper());
+ if (ATK_IS_TEXT(atkObj)) {
+ GUniquePtr<gchar> text(webkitAccessibleTextGetText(ATK_TEXT(atkObj), 0, -1));
+ return g_utf8_strlen(text.get(), -1);
+ }
+
+ // Even if we don't expose list markers to Assistive
+ // Technologies, we need to have a way to measure their length
+ // for those cases when it's needed to take it into account
+ // separately (as in getAccessibilityObjectForOffset)
+ if (auto renderer = object->renderer(); is<RenderListMarker>(renderer))
+ return downcast<RenderListMarker>(*renderer).textWithSuffix().length();
+
+ return 0;
+}
+
+static const AccessibilityObject* getAccessibilityObjectForOffset(const AccessibilityObject* object, guint offset, gint* startOffset, gint* endOffset)
+{
+ const AccessibilityObject* result;
+ guint length = accessibilityObjectLength(object);
+ if (length > offset) {
+ *startOffset = 0;
+ *endOffset = length;
+ result = object;
+ } else {
+ *startOffset = -1;
+ *endOffset = -1;
+ result = 0;
+ }
+
+ if (!object->firstChild())
+ return result;
+
+ AccessibilityObject* child = object->firstChild();
+ guint currentOffset = 0;
+ guint childPosition = 0;
+ while (child && currentOffset <= offset) {
+ guint childLength = accessibilityObjectLength(child);
+ currentOffset = childLength + childPosition;
+ if (currentOffset > offset) {
+ gint childStartOffset;
+ gint childEndOffset;
+ const AccessibilityObject* grandChild = getAccessibilityObjectForOffset(child, offset-childPosition, &childStartOffset, &childEndOffset);
+ if (childStartOffset >= 0) {
+ *startOffset = childStartOffset + childPosition;
+ *endOffset = childEndOffset + childPosition;
+ result = grandChild;
+ }
+ } else {
+ childPosition += childLength;
+ child = child->nextSibling();
+ }
+ }
+ return result;
+}
+
+static AtkAttributeSet* getRunAttributesFromAccessibilityObject(const AccessibilityObject* element, gint offset, gint* startOffset, gint* endOffset)
+{
+ const AccessibilityObject* child = getAccessibilityObjectForOffset(element, offset, startOffset, endOffset);
+ if (!child) {
+ *startOffset = -1;
+ *endOffset = -1;
+ return 0;
+ }
+
+ AtkAttributeSet* defaultAttributes = getAttributeSetForAccessibilityObject(element);
+ AtkAttributeSet* childAttributes = getAttributeSetForAccessibilityObject(child);
+
+ return attributeSetDifference(childAttributes, defaultAttributes);
+}
+
+static IntRect textExtents(AtkText* text, gint startOffset, gint length, AtkCoordType coords)
+{
+ GUniquePtr<char> textContent(webkitAccessibleTextGetText(text, startOffset, -1));
+ gint textLength = g_utf8_strlen(textContent.get(), -1);
+
+ // The first case (endOffset of -1) should work, but seems broken for all Gtk+ apps.
+ gint rangeLength = length;
+ if (rangeLength < 0 || rangeLength > textLength)
+ rangeLength = textLength;
+ AccessibilityObject* coreObject = core(text);
+
+ IntRect extents = coreObject->doAXBoundsForRange(PlainTextRange(startOffset, rangeLength));
+ switch (coords) {
+ case ATK_XY_SCREEN:
+ if (Document* document = coreObject->document())
+ extents = document->view()->contentsToScreen(extents);
+ break;
+ case ATK_XY_WINDOW:
+ // No-op
+ break;
+#if ATK_CHECK_VERSION(2, 30, 0)
+ case ATK_XY_PARENT:
+ RELEASE_ASSERT_NOT_REACHED();
+#endif
+ }
+
+ return extents;
+}
+
+static int offsetAdjustmentForListItem(const AXCoreObject* object)
+{
+ // We need to adjust the offsets for the list item marker in
+ // Left-To-Right text, since we expose it together with the text.
+ RenderObject* renderer = object->renderer();
+ if (is<RenderListItem>(renderer) && renderer->style().direction() == TextDirection::LTR)
+ return downcast<RenderListItem>(*renderer).markerTextWithSuffix().length();
+
+ return 0;
+}
+
+static int webCoreOffsetToAtkOffset(const AXCoreObject* object, int offset)
+{
+ if (!object->isListItem())
+ return offset;
+
+ return offset + offsetAdjustmentForListItem(object);
+}
+
+static int atkOffsetToWebCoreOffset(AtkText* text, int offset)
+{
+ AccessibilityObject* coreObject = core(text);
+ if (!coreObject || !coreObject->isListItem())
+ return offset;
+
+ return offset - offsetAdjustmentForListItem(coreObject);
+}
+
+static Node* getNodeForAccessibilityObject(AccessibilityObject* coreObject)
+{
+ if (!coreObject->isNativeTextControl())
+ return coreObject->node();
+
+ // For text controls, we get the first visible position on it (which will
+ // belong to its inner element, unreachable from the DOM) and return its
+ // parent node, so we have a "bounding node" for the accessibility object.
+ VisiblePosition positionInTextControlInnerElement = coreObject->visiblePositionForIndex(0, true);
+ Node* innerMostNode = positionInTextControlInnerElement.deepEquivalent().anchorNode();
+ if (!innerMostNode)
+ return 0;
+
+ return innerMostNode->parentNode();
+}
+
+static void getSelectionOffsetsForObject(AccessibilityObject* coreObject, VisibleSelection& selection, gint& startOffset, gint& endOffset)
+{
+ // Default values, unless the contrary is proved.
+ startOffset = 0;
+ endOffset = 0;
+
+ Node* node = getNodeForAccessibilityObject(coreObject);
+ if (!node)
+ return;
+
+ if (selection.isNone())
+ return;
+
+ // We need to limit our search to positions that fall inside the domain of the current object.
+ Position firstValidPosition = firstPositionInOrBeforeNode(node->firstDescendant());
+ Position lastValidPosition = lastPositionInOrAfterNode(node->lastDescendant());
+
+ // Find the proper range for the selection that falls inside the object.
+ auto nodeRangeStart = std::max(selection.start(), firstValidPosition);
+ auto nodeRangeEnd = std::min(selection.end(), lastValidPosition);
+
+ // Calculate position of the selected range inside the object.
+ Position parentFirstPosition = firstPositionInOrBeforeNode(node);
+ auto rangeInParent = *makeSimpleRange(parentFirstPosition, nodeRangeStart);
+
+ // Set values for start offsets and calculate initial range length.
+ // These values might be adjusted later to cover special cases.
+ startOffset = webCoreOffsetToAtkOffset(coreObject, characterCount(rangeInParent, TextIteratorBehavior::EmitsCharactersBetweenAllVisiblePositions));
+ auto nodeRange = *makeSimpleRange(nodeRangeStart, nodeRangeEnd);
+ int rangeLength = characterCount(nodeRange, TextIteratorBehavior::EmitsCharactersBetweenAllVisiblePositions);
+
+ // Special cases that are only relevant when working with *_END boundaries.
+ if (selection.affinity() == Affinity::Upstream) {
+ VisiblePosition visibleStart(nodeRangeStart, Affinity::Upstream);
+ VisiblePosition visibleEnd(nodeRangeEnd, Affinity::Upstream);
+
+ // We need to adjust offsets when finding wrapped lines so the position at the end
+ // of the line is properly taking into account when calculating the offsets.
+ if (isEndOfLine(visibleStart) && !lineBreakExistsAtVisiblePosition(visibleStart)) {
+ if (isStartOfLine(visibleStart.next()))
+ rangeLength++;
+
+ if (!isEndOfBlock(visibleStart))
+ startOffset = std::max(startOffset - 1, 0);
+ }
+
+ if (isEndOfLine(visibleEnd) && !lineBreakExistsAtVisiblePosition(visibleEnd) && !isEndOfBlock(visibleEnd))
+ rangeLength--;
+ }
+
+ endOffset = std::min(startOffset + rangeLength, static_cast<int>(accessibilityObjectLength(coreObject)));
+}
+
+static gchar* webkitAccessibleTextGetText(AtkText* text, gint startOffset, gint endOffset)
+{
+ g_return_val_if_fail(ATK_TEXT(text), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text), 0);
+
+ AccessibilityObject* coreObject = core(text);
+
+#if ENABLE(INPUT_TYPE_COLOR)
+ if (coreObject->roleValue() == AccessibilityRole::ColorWell) {
+ auto color = convertColor<SRGBA<float>>(coreObject->colorValue()).resolved();
+ return g_strdup_printf("rgb %7.5f %7.5f %7.5f 1", color.red, color.green, color.blue);
+ }
+#endif
+
+ String ret;
+ if (coreObject->isTextControl())
+ ret = coreObject->doAXStringForRange(PlainTextRange(0, endOffset));
+ else {
+ ret = coreObject->stringValue();
+ if (!ret)
+ ret = coreObject->textUnderElement(AccessibilityTextUnderElementMode(AccessibilityTextUnderElementMode::TextUnderElementModeIncludeAllChildren));
+ }
+
+ // Prefix a item number/bullet if needed
+ int actualEndOffset = endOffset == -1 ? ret.length() : endOffset;
+ if (coreObject->roleValue() == AccessibilityRole::ListItem) {
+ RenderObject* objRenderer = coreObject->renderer();
+ if (is<RenderListItem>(objRenderer)) {
+ String markerText = downcast<RenderListItem>(*objRenderer).markerTextWithSuffix().toString();
+ ret = objRenderer->style().direction() == TextDirection::LTR ? markerText + ret : ret + markerText;
+ if (endOffset == -1)
+ actualEndOffset = ret.length() + markerText.length();
+ }
+ }
+
+ ret = ret.substring(startOffset, actualEndOffset - startOffset);
+ return g_strdup(ret.utf8().data());
+}
+
+enum GetTextRelativePosition {
+ GetTextPositionAt,
+ GetTextPositionBefore,
+ GetTextPositionAfter
+};
+
+// Convenience function to be used in early returns.
+static char* emptyTextSelectionAtOffset(int offset, int* startOffset, int* endOffset)
+{
+ *startOffset = offset;
+ *endOffset = offset;
+ return g_strdup("");
+}
+
+static char* webkitAccessibleTextGetChar(AtkText* text, int offset, GetTextRelativePosition textPosition, int* startOffset, int* endOffset)
+{
+ int actualOffset = offset;
+ if (textPosition == GetTextPositionBefore)
+ actualOffset--;
+ else if (textPosition == GetTextPositionAfter)
+ actualOffset++;
+
+ GUniquePtr<char> textData(webkitAccessibleTextGetText(text, 0, -1));
+ int textLength = g_utf8_strlen(textData.get(), -1);
+
+ *startOffset = std::max(0, actualOffset);
+ *startOffset = std::min(*startOffset, textLength);
+
+ *endOffset = std::max(0, actualOffset + 1);
+ *endOffset = std::min(*endOffset, textLength);
+
+ if (*startOffset == *endOffset)
+ return g_strdup("");
+
+ return g_utf8_substring(textData.get(), *startOffset, *endOffset);
+}
+
+static VisiblePosition nextWordStartPosition(const VisiblePosition &position)
+{
+ VisiblePosition positionAfterCurrentWord = nextWordPosition(position);
+
+ // In order to skip spaces when moving right, we advance one word further
+ // and then move one word back. This will put us at the beginning of the
+ // word following.
+ VisiblePosition positionAfterSpacingAndFollowingWord = nextWordPosition(positionAfterCurrentWord);
+
+ if (positionAfterSpacingAndFollowingWord != positionAfterCurrentWord)
+ positionAfterCurrentWord = previousWordPosition(positionAfterSpacingAndFollowingWord);
+
+ bool movingBackwardsMovedPositionToStartOfCurrentWord = positionAfterCurrentWord == previousWordPosition(nextWordPosition(position));
+ if (movingBackwardsMovedPositionToStartOfCurrentWord)
+ positionAfterCurrentWord = positionAfterSpacingAndFollowingWord;
+
+ return positionAfterCurrentWord;
+}
+
+static VisiblePosition previousWordEndPosition(const VisiblePosition &position)
+{
+ // We move forward and then backward to position ourselves at the beginning
+ // of the current word for this boundary, making the most of the semantics
+ // of previousWordPosition() and nextWordPosition().
+ VisiblePosition positionAtStartOfCurrentWord = previousWordPosition(nextWordPosition(position));
+ VisiblePosition positionAtPreviousWord = previousWordPosition(position);
+
+ // Need to consider special cases (punctuation) when we are in the last word of a sentence.
+ if (isStartOfWord(position) && positionAtPreviousWord != position && positionAtPreviousWord == positionAtStartOfCurrentWord)
+ return nextWordPosition(positionAtStartOfCurrentWord);
+
+ // In order to skip spaces when moving left, we advance one word backwards
+ // and then move one word forward. This will put us at the beginning of
+ // the word following.
+ VisiblePosition positionBeforeSpacingAndPreceedingWord = previousWordPosition(positionAtStartOfCurrentWord);
+
+ if (positionBeforeSpacingAndPreceedingWord != positionAtStartOfCurrentWord)
+ positionAtStartOfCurrentWord = nextWordPosition(positionBeforeSpacingAndPreceedingWord);
+
+ bool movingForwardMovedPositionToEndOfCurrentWord = nextWordPosition(positionAtStartOfCurrentWord) == previousWordPosition(nextWordPosition(position));
+ if (movingForwardMovedPositionToEndOfCurrentWord)
+ positionAtStartOfCurrentWord = positionBeforeSpacingAndPreceedingWord;
+
+ return positionAtStartOfCurrentWord;
+}
+
+static VisibleSelection wordAtPositionForAtkBoundary(const AccessibilityObject* /*coreObject*/, const VisiblePosition& position, AtkTextBoundary boundaryType)
+{
+ VisiblePosition startPosition;
+ VisiblePosition endPosition;
+
+ switch (boundaryType) {
+ case ATK_TEXT_BOUNDARY_WORD_START:
+ // isStartOfWord() returns true both when at the beginning of a "real" word
+ // as when at the beginning of a whitespace range between two "real" words,
+ // since that whitespace is considered a "word" as well. And in case we are
+ // already at the beginning of a "real" word we do not need to look backwards.
+ if (isStartOfWord(position) && deprecatedIsEditingWhitespace(position.characterBefore()))
+ startPosition = position;
+ else
+ startPosition = previousWordPosition(position);
+ endPosition = nextWordStartPosition(startPosition);
+
+ // We need to make sure that we look for the word in the current line when
+ // we are at the beginning of a new line, and not look into the previous one
+ // at all, which might happen when lines belong to different nodes.
+ if (isStartOfLine(position) && isStartOfLine(endPosition)) {
+ startPosition = endPosition;
+ endPosition = nextWordStartPosition(startPosition);
+ }
+ break;
+
+ case ATK_TEXT_BOUNDARY_WORD_END:
+ startPosition = previousWordEndPosition(position);
+ endPosition = nextWordPosition(startPosition);
+ break;
+
+ default:
+ ASSERT_NOT_REACHED();
+ }
+
+ VisibleSelection selectedWord(startPosition, endPosition);
+
+ // We mark the selection as 'upstream' so we can use that information later,
+ // when finding the actual offsets in getSelectionOffsetsForObject().
+ if (boundaryType == ATK_TEXT_BOUNDARY_WORD_END)
+ selectedWord.setAffinity(Affinity::Upstream);
+
+ return selectedWord;
+}
+
+static int numberOfReplacedElementsBeforeOffset(AtkText* text, unsigned offset)
+{
+ GUniquePtr<char> textForObject(webkitAccessibleTextGetText(text, 0, offset));
+ String textBeforeOffset = String::fromUTF8(textForObject.get());
+
+ int count = 0;
+ size_t index = textBeforeOffset.find(objectReplacementCharacter, 0);
+ while (index < offset && index != notFound) {
+ index = textBeforeOffset.find(objectReplacementCharacter, index + 1);
+ count++;
+ }
+ return count;
+}
+
+static char* webkitAccessibleTextWordForBoundary(AtkText* text, int offset, AtkTextBoundary boundaryType, GetTextRelativePosition textPosition, int* startOffset, int* endOffset)
+{
+ AccessibilityObject* coreObject = core(text);
+ Document* document = coreObject->document();
+ if (!document)
+ return emptyTextSelectionAtOffset(0, startOffset, endOffset);
+
+ Node* node = getNodeForAccessibilityObject(coreObject);
+ if (!node)
+ return emptyTextSelectionAtOffset(0, startOffset, endOffset);
+
+ int actualOffset = atkOffsetToWebCoreOffset(text, offset);
+
+ // Besides of the usual conversion from ATK offsets to WebCore offsets,
+ // we need to consider the potential embedded objects that might have been
+ // inserted in the text exposed through AtkText when calculating the offset.
+ actualOffset -= numberOfReplacedElementsBeforeOffset(text, actualOffset);
+
+ VisiblePosition caretPosition = coreObject->visiblePositionForIndex(actualOffset);
+ VisibleSelection currentWord = wordAtPositionForAtkBoundary(coreObject, caretPosition, boundaryType);
+
+ // Take into account other relative positions, if needed, by
+ // calculating the new position that we would need to consider.
+ VisiblePosition newPosition = caretPosition;
+ switch (textPosition) {
+ case GetTextPositionAt:
+ break;
+
+ case GetTextPositionBefore:
+ // Early return if asking for the previous word while already at the beginning.
+ if (isFirstVisiblePositionInNode(currentWord.visibleStart(), node))
+ return emptyTextSelectionAtOffset(0, startOffset, endOffset);
+
+ if (isStartOfLine(currentWord.end()))
+ newPosition = currentWord.visibleStart().previous();
+ else
+ newPosition = startOfWord(currentWord.start(), LeftWordIfOnBoundary);
+ break;
+
+ case GetTextPositionAfter:
+ // Early return if asking for the following word while already at the end.
+ if (isLastVisiblePositionInNode(currentWord.visibleEnd(), node))
+ return emptyTextSelectionAtOffset(accessibilityObjectLength(coreObject), startOffset, endOffset);
+
+ if (isEndOfLine(currentWord.end()))
+ newPosition = currentWord.visibleEnd().next();
+ else
+ newPosition = endOfWord(currentWord.end(), RightWordIfOnBoundary);
+ break;
+
+ default:
+ ASSERT_NOT_REACHED();
+ }
+
+ // Determine the relevant word we are actually interested in
+ // and calculate the ATK offsets for it, then return everything.
+ VisibleSelection selectedWord = newPosition != caretPosition ? wordAtPositionForAtkBoundary(coreObject, newPosition, boundaryType) : currentWord;
+ getSelectionOffsetsForObject(coreObject, selectedWord, *startOffset, *endOffset);
+ return webkitAccessibleTextGetText(text, *startOffset, *endOffset);
+}
+
+static bool isSentenceBoundary(const VisiblePosition &pos)
+{
+ if (pos.isNull())
+ return false;
+
+ // It's definitely a sentence boundary if there's nothing before.
+ if (pos.previous().isNull())
+ return true;
+
+ // We go backwards and forward to make sure about this.
+ VisiblePosition startOfPreviousSentence = startOfSentence(pos);
+ return startOfPreviousSentence.isNotNull() && pos == endOfSentence(startOfPreviousSentence);
+}
+
+static bool isWhiteSpaceBetweenSentences(const VisiblePosition& position)
+{
+ if (position.isNull())
+ return false;
+
+ if (!deprecatedIsEditingWhitespace(position.characterAfter()))
+ return false;
+
+ auto start = startOfWord(position, RightWordIfOnBoundary);
+ auto end = endOfWord(start, RightWordIfOnBoundary);
+ if (!isSentenceBoundary(start) && !isSentenceBoundary(end))
+ return false;
+
+ auto range = makeSimpleRange(start, end);
+ return range && contains<ComposedTree>(*range, makeBoundaryPoint(position));
+}
+
+static VisibleSelection sentenceAtPositionForAtkBoundary(const AccessibilityObject*, const VisiblePosition& position, AtkTextBoundary boundaryType)
+{
+ VisiblePosition startPosition;
+ VisiblePosition endPosition;
+
+ bool isAtStartOfSentenceForEndBoundary = isWhiteSpaceBetweenSentences(position) || isSentenceBoundary(position);
+ if (boundaryType == ATK_TEXT_BOUNDARY_SENTENCE_START || !isAtStartOfSentenceForEndBoundary) {
+ startPosition = isSentenceBoundary(position) ? position : startOfSentence(position);
+ // startOfSentence might stop at a linebreak in the HTML source code,
+ // but we don't want to stop there yet, so keep going.
+ while (!isSentenceBoundary(startPosition) && isHTMLLineBreak(startPosition.characterBefore()))
+ startPosition = startOfSentence(startPosition);
+
+ endPosition = endOfSentence(startPosition);
+ }
+
+ if (boundaryType == ATK_TEXT_BOUNDARY_SENTENCE_END) {
+ if (isAtStartOfSentenceForEndBoundary) {
+ startPosition = position;
+ endPosition = endOfSentence(endOfWord(position, RightWordIfOnBoundary));
+ }
+
+ // startOfSentence returns a position after any white space previous to
+ // the sentence, so we might need to adjust that offset for this boundary.
+ if (deprecatedIsEditingWhitespace(startPosition.characterBefore()))
+ startPosition = startOfWord(startPosition, LeftWordIfOnBoundary);
+
+ // endOfSentence returns a position after any white space after the
+ // sentence, so we might need to adjust that offset for this boundary.
+ if (deprecatedIsEditingWhitespace(endPosition.characterBefore()))
+ endPosition = startOfWord(endPosition, LeftWordIfOnBoundary);
+
+ // Finally, do some additional adjustments that might be needed if
+ // positions are at the start or the end of a line.
+ if (isStartOfLine(startPosition) && !isStartOfBlock(startPosition))
+ startPosition = startPosition.previous();
+ if (isStartOfLine(endPosition) && !isStartOfBlock(endPosition))
+ endPosition = endPosition.previous();
+ }
+
+ VisibleSelection selectedSentence(startPosition, endPosition);
+
+ // We mark the selection as 'upstream' so we can use that information later,
+ // when finding the actual offsets in getSelectionOffsetsForObject().
+ if (boundaryType == ATK_TEXT_BOUNDARY_SENTENCE_END)
+ selectedSentence.setAffinity(Affinity::Upstream);
+
+ return selectedSentence;
+}
+
+static char* webkitAccessibleTextSentenceForBoundary(AtkText* text, int offset, AtkTextBoundary boundaryType, GetTextRelativePosition textPosition, int* startOffset, int* endOffset)
+{
+ AccessibilityObject* coreObject = core(text);
+ Document* document = coreObject->document();
+ if (!document)
+ return emptyTextSelectionAtOffset(0, startOffset, endOffset);
+
+ Node* node = getNodeForAccessibilityObject(coreObject);
+ if (!node)
+ return emptyTextSelectionAtOffset(0, startOffset, endOffset);
+
+ int actualOffset = atkOffsetToWebCoreOffset(text, offset);
+
+ // Besides of the usual conversion from ATK offsets to WebCore offsets,
+ // we need to consider the potential embedded objects that might have been
+ // inserted in the text exposed through AtkText when calculating the offset.
+ actualOffset -= numberOfReplacedElementsBeforeOffset(text, actualOffset);
+
+ VisiblePosition caretPosition = coreObject->visiblePositionForIndex(actualOffset);
+ VisibleSelection currentSentence = sentenceAtPositionForAtkBoundary(coreObject, caretPosition, boundaryType);
+
+ // Take into account other relative positions, if needed, by
+ // calculating the new position that we would need to consider.
+ VisiblePosition newPosition = caretPosition;
+ switch (textPosition) {
+ case GetTextPositionAt:
+ break;
+
+ case GetTextPositionBefore:
+ // Early return if asking for the previous sentence while already at the beginning.
+ if (isFirstVisiblePositionInNode(currentSentence.visibleStart(), node))
+ return emptyTextSelectionAtOffset(0, startOffset, endOffset);
+ newPosition = currentSentence.visibleStart().previous();
+ break;
+
+ case GetTextPositionAfter:
+ // Early return if asking for the following word while already at the end.
+ if (isLastVisiblePositionInNode(currentSentence.visibleEnd(), node))
+ return emptyTextSelectionAtOffset(accessibilityObjectLength(coreObject), startOffset, endOffset);
+ newPosition = currentSentence.visibleEnd().next();
+ break;
+
+ default:
+ ASSERT_NOT_REACHED();
+ }
+
+ // Determine the relevant sentence we are actually interested in
+ // and calculate the ATK offsets for it, then return everything.
+ VisibleSelection selectedSentence = newPosition != caretPosition ? sentenceAtPositionForAtkBoundary(coreObject, newPosition, boundaryType) : currentSentence;
+ getSelectionOffsetsForObject(coreObject, selectedSentence, *startOffset, *endOffset);
+ return webkitAccessibleTextGetText(text, *startOffset, *endOffset);
+}
+
+static VisibleSelection lineAtPositionForAtkBoundary(const AccessibilityObject* coreObject, const VisiblePosition& position, AtkTextBoundary boundaryType)
+{
+ UNUSED_PARAM(coreObject);
+ VisiblePosition startPosition;
+ VisiblePosition endPosition;
+
+ switch (boundaryType) {
+ case ATK_TEXT_BOUNDARY_LINE_START:
+ startPosition = isStartOfLine(position) ? position : logicalStartOfLine(position);
+ endPosition = logicalEndOfLine(position);
+
+ // In addition to checking that we are not at the end of a block, we need
+ // to check that endPosition has not UPSTREAM affinity, since that would
+ // cause trouble inside of text controls (we would be advancing too much).
+ if (!isEndOfBlock(endPosition) && endPosition.affinity() != Affinity::Upstream)
+ endPosition = endPosition.next();
+ break;
+
+ case ATK_TEXT_BOUNDARY_LINE_END:
+ startPosition = isEndOfLine(position) ? position : logicalStartOfLine(position);
+ if (!isStartOfBlock(startPosition))
+ startPosition = startPosition.previous();
+ endPosition = logicalEndOfLine(position);
+ break;
+
+ default:
+ ASSERT_NOT_REACHED();
+ }
+
+ VisibleSelection selectedLine(startPosition, endPosition);
+
+ // We mark the selection as 'upstream' so we can use that information later,
+ // when finding the actual offsets in getSelectionOffsetsForObject().
+ if (boundaryType == ATK_TEXT_BOUNDARY_LINE_END)
+ selectedLine.setAffinity(Affinity::Upstream);
+
+ return selectedLine;
+}
+
+static char* webkitAccessibleTextLineForBoundary(AtkText* text, int offset, AtkTextBoundary boundaryType, GetTextRelativePosition textPosition, int* startOffset, int* endOffset)
+{
+ AccessibilityObject* coreObject = core(text);
+ Document* document = coreObject->document();
+ if (!document)
+ return emptyTextSelectionAtOffset(0, startOffset, endOffset);
+
+ Node* node = getNodeForAccessibilityObject(coreObject);
+ if (!node)
+ return emptyTextSelectionAtOffset(0, startOffset, endOffset);
+
+ int actualOffset = atkOffsetToWebCoreOffset(text, offset);
+
+ // Besides the usual conversion from ATK offsets to WebCore offsets,
+ // we need to consider the potential embedded objects that might have been
+ // inserted in the text exposed through AtkText when calculating the offset.
+ actualOffset -= numberOfReplacedElementsBeforeOffset(text, actualOffset);
+
+ VisiblePosition caretPosition = coreObject->visiblePositionForIndex(actualOffset);
+ VisibleSelection currentLine = lineAtPositionForAtkBoundary(coreObject, caretPosition, boundaryType);
+
+ // Take into account other relative positions, if needed, by
+ // calculating the new position that we would need to consider.
+ VisiblePosition newPosition = caretPosition;
+ switch (textPosition) {
+ case GetTextPositionAt:
+ // No need to do additional work if we are using the "at" position, we just
+ // explicitly list this case option to catch invalid values in the default case.
+ break;
+
+ case GetTextPositionBefore:
+ // Early return if asking for the previous line while already at the beginning.
+ if (isFirstVisiblePositionInNode(currentLine.visibleStart(), node))
+ return emptyTextSelectionAtOffset(0, startOffset, endOffset);
+ newPosition = currentLine.visibleStart().previous();
+ break;
+
+ case GetTextPositionAfter:
+ // Early return if asking for the following word while already at the end.
+ if (isLastVisiblePositionInNode(currentLine.visibleEnd(), node))
+ return emptyTextSelectionAtOffset(accessibilityObjectLength(coreObject), startOffset, endOffset);
+ newPosition = currentLine.visibleEnd().next();
+ break;
+
+ default:
+ ASSERT_NOT_REACHED();
+ }
+
+ // Determine the relevant line we are actually interested in
+ // and calculate the ATK offsets for it, then return everything.
+ VisibleSelection selectedLine = newPosition != caretPosition ? lineAtPositionForAtkBoundary(coreObject, newPosition, boundaryType) : currentLine;
+ getSelectionOffsetsForObject(coreObject, selectedLine, *startOffset, *endOffset);
+
+ // We might need to adjust the start or end offset to include the list item marker,
+ // if present, when printing the first or the last full line for a list item.
+ RenderObject* renderer = coreObject->renderer();
+ if (renderer->isListItem()) {
+ // For Left-to-Right, the list item marker is at the beginning of the exposed text.
+ if (renderer->style().direction() == TextDirection::LTR && isFirstVisiblePositionInNode(selectedLine.visibleStart(), node))
+ *startOffset = 0;
+
+ // For Right-to-Left, the list item marker is at the end of the exposed text.
+ if (renderer->style().direction() == TextDirection::RTL && isLastVisiblePositionInNode(selectedLine.visibleEnd(), node))
+ *endOffset = accessibilityObjectLength(coreObject);
+ }
+
+ return webkitAccessibleTextGetText(text, *startOffset, *endOffset);
+}
+
+static gchar* webkitAccessibleTextGetTextForOffset(AtkText* text, gint offset, AtkTextBoundary boundaryType, GetTextRelativePosition textPosition, gint* startOffset, gint* endOffset)
+{
+ AccessibilityObject* coreObject = core(text);
+ if (!coreObject || !coreObject->isAccessibilityRenderObject())
+ return emptyTextSelectionAtOffset(0, startOffset, endOffset);
+
+ switch (boundaryType) {
+ case ATK_TEXT_BOUNDARY_CHAR:
+ return webkitAccessibleTextGetChar(text, offset, textPosition, startOffset, endOffset);
+
+ case ATK_TEXT_BOUNDARY_WORD_START:
+ case ATK_TEXT_BOUNDARY_WORD_END:
+ return webkitAccessibleTextWordForBoundary(text, offset, boundaryType, textPosition, startOffset, endOffset);
+
+ case ATK_TEXT_BOUNDARY_LINE_START:
+ case ATK_TEXT_BOUNDARY_LINE_END:
+ return webkitAccessibleTextLineForBoundary(text, offset, boundaryType, textPosition, startOffset, endOffset);
+
+ case ATK_TEXT_BOUNDARY_SENTENCE_START:
+ case ATK_TEXT_BOUNDARY_SENTENCE_END:
+ return webkitAccessibleTextSentenceForBoundary(text, offset, boundaryType, textPosition, startOffset, endOffset);
+
+ default:
+ ASSERT_NOT_REACHED();
+ }
+
+ // This should never be reached.
+ return 0;
+}
+
+static gchar* webkitAccessibleTextGetTextAfterOffset(AtkText* text, gint offset, AtkTextBoundary boundaryType, gint* startOffset, gint* endOffset)
+{
+ g_return_val_if_fail(ATK_TEXT(text), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text), 0);
+
+ return webkitAccessibleTextGetTextForOffset(text, offset, boundaryType, GetTextPositionAfter, startOffset, endOffset);
+}
+
+static gchar* webkitAccessibleTextGetTextAtOffset(AtkText* text, gint offset, AtkTextBoundary boundaryType, gint* startOffset, gint* endOffset)
+{
+ g_return_val_if_fail(ATK_TEXT(text), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text), 0);
+
+ return webkitAccessibleTextGetTextForOffset(text, offset, boundaryType, GetTextPositionAt, startOffset, endOffset);
+}
+
+static gchar* webkitAccessibleTextGetTextBeforeOffset(AtkText* text, gint offset, AtkTextBoundary boundaryType, gint* startOffset, gint* endOffset)
+{
+ g_return_val_if_fail(ATK_TEXT(text), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text), 0);
+
+ return webkitAccessibleTextGetTextForOffset(text, offset, boundaryType, GetTextPositionBefore, startOffset, endOffset);
+}
+
+static gunichar webkitAccessibleTextGetCharacterAtOffset(AtkText* text, gint)
+{
+ g_return_val_if_fail(ATK_TEXT(text), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text), 0);
+
+ notImplemented();
+ return 0;
+}
+
+static gint webkitAccessibleTextGetCaretOffset(AtkText* text)
+{
+ g_return_val_if_fail(ATK_TEXT(text), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text), 0);
+
+ // coreObject is the unignored object whose offset the caller is requesting.
+ // focusedObject is the object with the caret. It is likely ignored -- unless it's a link.
+ AXCoreObject* coreObject = core(text);
+ if (!coreObject->isAccessibilityRenderObject())
+ return 0;
+
+ // We need to make sure we pass a valid object as reference.
+ if (coreObject->accessibilityIsIgnored())
+ coreObject = coreObject->parentObjectUnignored();
+ if (!coreObject)
+ return 0;
+
+ int offset;
+ if (!objectFocusedAndCaretOffsetUnignored(coreObject, offset))
+ return 0;
+
+ return webCoreOffsetToAtkOffset(coreObject, offset);
+}
+
+static AtkAttributeSet* webkitAccessibleTextGetRunAttributes(AtkText* text, gint offset, gint* startOffset, gint* endOffset)
+{
+ g_return_val_if_fail(ATK_TEXT(text), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text), 0);
+
+ AccessibilityObject* coreObject = core(text);
+ AtkAttributeSet* result;
+
+ if (!coreObject) {
+ *startOffset = 0;
+ *endOffset = atk_text_get_character_count(text);
+ return 0;
+ }
+
+ if (offset == -1)
+ offset = atk_text_get_caret_offset(text);
+
+ result = getRunAttributesFromAccessibilityObject(coreObject, offset, startOffset, endOffset);
+
+ if (*startOffset < 0) {
+ *startOffset = offset;
+ *endOffset = offset;
+ }
+
+ return result;
+}
+
+static AtkAttributeSet* webkitAccessibleTextGetDefaultAttributes(AtkText* text)
+{
+ g_return_val_if_fail(ATK_TEXT(text), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text), 0);
+
+ AccessibilityObject* coreObject = core(text);
+ if (!coreObject || !coreObject->isAccessibilityRenderObject())
+ return 0;
+
+ return getAttributeSetForAccessibilityObject(coreObject);
+}
+
+static void webkitAccessibleTextGetCharacterExtents(AtkText* text, gint offset, gint* x, gint* y, gint* width, gint* height, AtkCoordType coords)
+{
+ g_return_if_fail(ATK_TEXT(text));
+ returnIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text));
+
+ IntRect extents = textExtents(text, offset, 1, coords);
+ *x = extents.x();
+ *y = extents.y();
+ *width = extents.width();
+ *height = extents.height();
+}
+
+static void webkitAccessibleTextGetRangeExtents(AtkText* text, gint startOffset, gint endOffset, AtkCoordType coords, AtkTextRectangle* rect)
+{
+ g_return_if_fail(ATK_TEXT(text));
+ returnIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text));
+
+ IntRect extents = textExtents(text, startOffset, endOffset - startOffset, coords);
+ rect->x = extents.x();
+ rect->y = extents.y();
+ rect->width = extents.width();
+ rect->height = extents.height();
+}
+
+static gint webkitAccessibleTextGetCharacterCount(AtkText* text)
+{
+ g_return_val_if_fail(ATK_TEXT(text), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text), 0);
+
+ return accessibilityObjectLength(core(text));
+}
+
+static gint webkitAccessibleTextGetOffsetAtPoint(AtkText* text, gint x, gint y, AtkCoordType)
+{
+ g_return_val_if_fail(ATK_TEXT(text), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text), 0);
+
+ // FIXME: Use the AtkCoordType
+ // TODO: Is it correct to ignore range.length?
+ IntPoint pos(x, y);
+ PlainTextRange range = core(text)->doAXRangeForPosition(pos);
+ return range.start;
+}
+
+static gint webkitAccessibleTextGetNSelections(AtkText* text)
+{
+ g_return_val_if_fail(ATK_TEXT(text), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text), 0);
+
+ AccessibilityObject* coreObject = core(text);
+ VisibleSelection selection = coreObject->selection();
+
+ // Only range selections are needed for the purpose of this method
+ if (!selection.isRange())
+ return 0;
+
+ // We don't support multiple selections for now, so there's only
+ // two possibilities
+ // Also, we don't want to do anything if the selection does not
+ // belong to the currently selected object. We have to check since
+ // there's no way to get the selection for a given object, only
+ // the global one (the API is a bit confusing)
+ return selectionBelongsToObject(coreObject, selection) ? 1 : 0;
+}
+
+static gchar* webkitAccessibleTextGetSelection(AtkText* text, gint selectionNum, gint* startOffset, gint* endOffset)
+{
+ g_return_val_if_fail(ATK_TEXT(text), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text), 0);
+
+ // WebCore does not support multiple selection, so anything but 0 does not make sense for now.
+ if (selectionNum)
+ return 0;
+
+ // Get the offsets of the selection for the selected object
+ AccessibilityObject* coreObject = core(text);
+ VisibleSelection selection = coreObject->selection();
+ getSelectionOffsetsForObject(coreObject, selection, *startOffset, *endOffset);
+
+ // Return 0 instead of "", as that's the expected result for
+ // this AtkText method when there's no selection
+ if (*startOffset == *endOffset)
+ return 0;
+
+ return webkitAccessibleTextGetText(text, *startOffset, *endOffset);
+}
+
+static gboolean webkitAccessibleTextAddSelection(AtkText* text, gint, gint)
+{
+ g_return_val_if_fail(ATK_TEXT(text), FALSE);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text), FALSE);
+
+ notImplemented();
+ return FALSE;
+}
+
+static gboolean webkitAccessibleTextSetSelection(AtkText* text, gint selectionNum, gint startOffset, gint endOffset)
+{
+ g_return_val_if_fail(ATK_TEXT(text), FALSE);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text), FALSE);
+
+ // WebCore does not support multiple selection, so anything but 0 does not make sense for now.
+ if (selectionNum)
+ return FALSE;
+
+ AccessibilityObject* coreObject = core(text);
+ if (!coreObject->isAccessibilityRenderObject())
+ return FALSE;
+
+ // Consider -1 and out-of-bound values and correct them to length
+ gint textCount = webkitAccessibleTextGetCharacterCount(text);
+ if (startOffset < 0 || startOffset > textCount)
+ startOffset = textCount;
+ if (endOffset < 0 || endOffset > textCount)
+ endOffset = textCount;
+
+ // We need to adjust the offsets for the list item marker.
+ int offsetAdjustment = offsetAdjustmentForListItem(coreObject);
+ if (offsetAdjustment) {
+ if (startOffset < offsetAdjustment || endOffset < offsetAdjustment)
+ return FALSE;
+
+ startOffset = atkOffsetToWebCoreOffset(text, startOffset);
+ endOffset = atkOffsetToWebCoreOffset(text, endOffset);
+ }
+
+ PlainTextRange textRange(startOffset, endOffset - startOffset);
+ VisiblePositionRange range = coreObject->visiblePositionRangeForRange(textRange);
+ if (range.isNull())
+ return FALSE;
+
+ coreObject->setSelectedVisiblePositionRange(range);
+ return TRUE;
+}
+
+static gboolean webkitAccessibleTextRemoveSelection(AtkText* text, gint selectionNum)
+{
+ g_return_val_if_fail(ATK_TEXT(text), FALSE);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(text), FALSE);
+
+ // WebCore does not support multiple selection, so anything but 0 does not make sense for now.
+ if (selectionNum)
+ return FALSE;
+
+ // Do nothing if current selection doesn't belong to the object
+ if (!webkitAccessibleTextGetNSelections(text))
+ return FALSE;
+
+ // Set a new 0-sized selection to the caret position, in order
+ // to simulate selection removal (GAIL style)
+ gint caretOffset = webkitAccessibleTextGetCaretOffset(text);
+ return webkitAccessibleTextSetSelection(text, selectionNum, caretOffset, caretOffset);
+}
+
+static gboolean webkitAccessibleTextSetCaretOffset(AtkText* text, gint offset)
+{
+ // Internally, setting the caret offset is equivalent to set a zero-length
+ // selection, so delegate in that implementation and void duplicated code.
+ return webkitAccessibleTextSetSelection(text, 0, offset, offset);
+}
+
+static gchar* webkitAccessibleTextGetStringAtOffset(AtkText* text, gint offset, AtkTextGranularity granularity, gint* startOffset, gint* endOffset)
+{
+ // This new API has been designed to simplify the AtkText interface and it has been
+ // designed to keep exactly the same behaviour the atk_text_get_text_at_text() for
+ // ATK_TEXT_BOUNDARY_*_START boundaries, so for now we just need to translate the
+ // granularity to the right old boundary and reuse the code for the old API.
+ // However, this should be simplified later on (and a lot of code removed) once
+ // WebKitGTK depends on ATK >= 2.9.4 *and* can safely assume that a version of
+ // AT-SPI2 new enough not to include the old APIs is being used. But until then,
+ // we will have to live with both the old and new APIs implemented here.
+ // FIXME: WebKit nowadays depends on much newer ATK and we can safely assume AT-SPI2
+ // isn't ancient. But whoever wrote this code didn't use ATK_CHECK_VERSION() guards,
+ // so it's unclear what is supposed to be changed here.
+ AtkTextBoundary boundaryType = ATK_TEXT_BOUNDARY_CHAR;
+ switch (granularity) {
+ case ATK_TEXT_GRANULARITY_CHAR:
+ break;
+
+ case ATK_TEXT_GRANULARITY_WORD:
+ boundaryType = ATK_TEXT_BOUNDARY_WORD_START;
+ break;
+
+ case ATK_TEXT_GRANULARITY_SENTENCE:
+ boundaryType = ATK_TEXT_BOUNDARY_SENTENCE_START;
+ break;
+
+ case ATK_TEXT_GRANULARITY_LINE:
+ boundaryType = ATK_TEXT_BOUNDARY_LINE_START;
+ break;
+
+ case ATK_TEXT_GRANULARITY_PARAGRAPH:
+ // FIXME: This has not been a need with the old AtkText API, which means ATs won't
+ // need it yet for some time, so we can skip it for now.
+ notImplemented();
+ return g_strdup("");
+
+ default:
+ ASSERT_NOT_REACHED();
+ }
+
+ return webkitAccessibleTextGetTextForOffset(text, offset, boundaryType, GetTextPositionAt, startOffset, endOffset);
+}
+
+void webkitAccessibleTextInterfaceInit(AtkTextIface* iface)
+{
+ iface->get_text = webkitAccessibleTextGetText;
+ iface->get_text_after_offset = webkitAccessibleTextGetTextAfterOffset;
+ iface->get_text_at_offset = webkitAccessibleTextGetTextAtOffset;
+ iface->get_text_before_offset = webkitAccessibleTextGetTextBeforeOffset;
+ iface->get_character_at_offset = webkitAccessibleTextGetCharacterAtOffset;
+ iface->get_caret_offset = webkitAccessibleTextGetCaretOffset;
+ iface->get_run_attributes = webkitAccessibleTextGetRunAttributes;
+ iface->get_default_attributes = webkitAccessibleTextGetDefaultAttributes;
+ iface->get_character_extents = webkitAccessibleTextGetCharacterExtents;
+ iface->get_range_extents = webkitAccessibleTextGetRangeExtents;
+ iface->get_character_count = webkitAccessibleTextGetCharacterCount;
+ iface->get_offset_at_point = webkitAccessibleTextGetOffsetAtPoint;
+ iface->get_n_selections = webkitAccessibleTextGetNSelections;
+ iface->get_selection = webkitAccessibleTextGetSelection;
+ iface->add_selection = webkitAccessibleTextAddSelection;
+ iface->remove_selection = webkitAccessibleTextRemoveSelection;
+ iface->set_selection = webkitAccessibleTextSetSelection;
+ iface->set_caret_offset = webkitAccessibleTextSetCaretOffset;
+ iface->get_string_at_offset = webkitAccessibleTextGetStringAtOffset;
+}
+
+#endif
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceText.h webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceText.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceText.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceText.h 2023-03-09 13:26:47.286643885 -0600
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2009, 2010, 2011, 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include <atk/atk.h>
+
+void webkitAccessibleTextInterfaceInit(AtkTextIface*);
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceValue.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceValue.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceValue.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceValue.cpp 2023-03-09 13:26:47.286643885 -0600
@@ -0,0 +1,200 @@
+/*
+ * Copyright (C) 2011, 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebKitAccessibleInterfaceValue.h"
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include "AccessibilityObject.h"
+#include "HTMLNames.h"
+#include "WebKitAccessible.h"
+#include "WebKitAccessibleUtil.h"
+#include <wtf/text/CString.h>
+
+using namespace WebCore;
+
+static AccessibilityObject* core(AtkValue* value)
+{
+ if (!WEBKIT_IS_ACCESSIBLE(value))
+ return 0;
+
+ return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(value));
+}
+
+static bool webkitAccessibleSetNewValue(AtkValue* coreValue, const gdouble newValue)
+{
+ AccessibilityObject* coreObject = core(coreValue);
+ if (!coreObject->canSetValueAttribute())
+ return FALSE;
+
+ // Check value against range limits
+ double value;
+ value = std::max(static_cast<double>(coreObject->minValueForRange()), newValue);
+ value = std::min(static_cast<double>(coreObject->maxValueForRange()), newValue);
+
+ coreObject->setValue(String::numberToStringFixedPrecision(value));
+ return TRUE;
+}
+
+static float webkitAccessibleGetIncrementValue(AccessibilityObject* coreObject)
+{
+ if (!coreObject->getAttribute(HTMLNames::stepAttr).isEmpty())
+ return coreObject->stepValueForRange();
+
+ // If 'step' attribute is not defined, WebCore assumes a 5% of the
+ // range between minimum and maximum values. Implicit value of step should be one or larger.
+ float step = (coreObject->maxValueForRange() - coreObject->minValueForRange()) * 0.05;
+ return step < 1 ? 1 : step;
+}
+
+static void webkitAccessibleGetValueAndText(AtkValue* value, gdouble* currentValue, gchar** alternativeText)
+{
+ g_return_if_fail(ATK_VALUE(value));
+ returnIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(value));
+
+ AccessibilityObject* coreObject = core(value);
+ if (!coreObject)
+ return;
+
+ if (currentValue)
+ *currentValue = coreObject->valueForRange();
+ if (alternativeText)
+ *alternativeText = g_strdup_printf("%s", coreObject->valueDescription().utf8().data());
+}
+
+static double webkitAccessibleGetIncrement(AtkValue* value)
+{
+ g_return_val_if_fail(ATK_VALUE(value), 0);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(value), 0);
+
+ AccessibilityObject* coreObject = core(value);
+ if (!coreObject)
+ return 0;
+
+ return webkitAccessibleGetIncrementValue(coreObject);
+}
+
+static void webkitAccessibleSetValue(AtkValue* value, const gdouble newValue)
+{
+ g_return_if_fail(ATK_VALUE(value));
+ returnIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(value));
+
+ webkitAccessibleSetNewValue(value, newValue);
+}
+
+static AtkRange* webkitAccessibleGetRange(AtkValue* value)
+{
+ g_return_val_if_fail(ATK_VALUE(value), nullptr);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(value), nullptr);
+
+ AccessibilityObject* coreObject = core(value);
+ if (!coreObject)
+ return nullptr;
+
+ gdouble minValue = coreObject->minValueForRange();
+ gdouble maxValue = coreObject->maxValueForRange();
+ gchar* valueDescription = g_strdup_printf("%s", coreObject->valueDescription().utf8().data());
+ return atk_range_new(minValue, maxValue, valueDescription);
+}
+
+static void webkitAccessibleValueGetCurrentValue(AtkValue* value, GValue* gValue)
+{
+ g_return_if_fail(ATK_VALUE(value));
+ returnIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(value));
+
+ memset(gValue, 0, sizeof(GValue));
+ g_value_init(gValue, G_TYPE_FLOAT);
+ g_value_set_float(gValue, core(value)->valueForRange());
+}
+
+static void webkitAccessibleValueGetMaximumValue(AtkValue* value, GValue* gValue)
+{
+ g_return_if_fail(ATK_VALUE(value));
+ returnIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(value));
+
+ memset(gValue, 0, sizeof(GValue));
+ g_value_init(gValue, G_TYPE_FLOAT);
+ g_value_set_float(gValue, core(value)->maxValueForRange());
+}
+
+static void webkitAccessibleValueGetMinimumValue(AtkValue* value, GValue* gValue)
+{
+ g_return_if_fail(ATK_VALUE(value));
+ returnIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(value));
+
+ memset(gValue, 0, sizeof(GValue));
+ g_value_init(gValue, G_TYPE_FLOAT);
+ g_value_set_float(gValue, core(value)->minValueForRange());
+}
+
+static gboolean webkitAccessibleValueSetCurrentValue(AtkValue* value, const GValue* gValue)
+{
+ g_return_val_if_fail(ATK_VALUE(value), FALSE);
+ returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(value), FALSE);
+
+ double newValue;
+ if (G_VALUE_HOLDS_DOUBLE(gValue))
+ newValue = g_value_get_double(gValue);
+ else if (G_VALUE_HOLDS_FLOAT(gValue))
+ newValue = g_value_get_float(gValue);
+ else if (G_VALUE_HOLDS_INT64(gValue))
+ newValue = g_value_get_int64(gValue);
+ else if (G_VALUE_HOLDS_INT(gValue))
+ newValue = g_value_get_int(gValue);
+ else if (G_VALUE_HOLDS_LONG(gValue))
+ newValue = g_value_get_long(gValue);
+ else if (G_VALUE_HOLDS_ULONG(gValue))
+ newValue = g_value_get_ulong(gValue);
+ else if (G_VALUE_HOLDS_UINT64(gValue))
+ newValue = g_value_get_uint64(gValue);
+ else if (G_VALUE_HOLDS_UINT(gValue))
+ newValue = g_value_get_uint(gValue);
+ else
+ return FALSE;
+
+ return webkitAccessibleSetNewValue(value, newValue);
+}
+
+static void webkitAccessibleValueGetMinimumIncrement(AtkValue* value, GValue* gValue)
+{
+ g_return_if_fail(ATK_VALUE(value));
+ returnIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(value));
+
+ memset(gValue, 0, sizeof(GValue));
+ g_value_init(gValue, G_TYPE_FLOAT);
+
+ AccessibilityObject* coreObject = core(value);
+ g_value_set_float(gValue, webkitAccessibleGetIncrementValue(coreObject));
+}
+
+void webkitAccessibleValueInterfaceInit(AtkValueIface* iface)
+{
+ iface->get_value_and_text = webkitAccessibleGetValueAndText;
+ iface->get_increment = webkitAccessibleGetIncrement;
+ iface->set_value = webkitAccessibleSetValue;
+ iface->get_range = webkitAccessibleGetRange;
+ iface->get_current_value = webkitAccessibleValueGetCurrentValue;
+ iface->get_maximum_value = webkitAccessibleValueGetMaximumValue;
+ iface->get_minimum_value = webkitAccessibleValueGetMinimumValue;
+ iface->set_current_value = webkitAccessibleValueSetCurrentValue;
+ iface->get_minimum_increment = webkitAccessibleValueGetMinimumIncrement;
+}
+
+#endif
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceValue.h webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceValue.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceValue.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceValue.h 2023-03-09 13:26:47.286643885 -0600
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2011, 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include <atk/atk.h>
+
+void webkitAccessibleValueInterfaceInit(AtkValueIface*);
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleUtil.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleUtil.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleUtil.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleUtil.cpp 2023-03-09 13:26:47.286643885 -0600
@@ -0,0 +1,242 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2009, 2010, 2012 Igalia S.L.
+ *
+ * Portions from Mozilla a11y, copyright as follows:
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is
+ * Sun Microsystems, Inc.
+ * Portions created by the Initial Developer are Copyright (C) 2002
+ * the Initial Developer. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebKitAccessibleUtil.h"
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include "AXObjectCache.h"
+#include "AccessibilityObject.h"
+#include "FrameView.h"
+#include "IntRect.h"
+#include "Node.h"
+#include "Range.h"
+#include "RenderObject.h"
+#include "TextIterator.h"
+#include "VisibleSelection.h"
+
+#include <wtf/text/AtomString.h>
+#include <wtf/text/CString.h>
+
+using namespace WebCore;
+
+AtkAttributeSet* addToAtkAttributeSet(AtkAttributeSet* attributeSet, const char* name, const char* value)
+{
+ AtkAttribute* attribute = static_cast<AtkAttribute*>(g_malloc(sizeof(AtkAttribute)));
+ attribute->name = g_strdup(name);
+ attribute->value = g_strdup(value);
+ attributeSet = g_slist_prepend(attributeSet, attribute);
+ return attributeSet;
+}
+
+void contentsRelativeToAtkCoordinateType(AccessibilityObject* coreObject, AtkCoordType coordType, IntRect rect, gint* x, gint* y, gint* width, gint* height)
+{
+ FrameView* frameView = coreObject->documentFrameView();
+
+ if (frameView) {
+ switch (coordType) {
+ case ATK_XY_WINDOW:
+ rect = frameView->contentsToWindow(rect);
+ break;
+ case ATK_XY_SCREEN:
+ rect = frameView->contentsToScreen(rect);
+ break;
+#if ATK_CHECK_VERSION(2, 30, 0)
+ case ATK_XY_PARENT:
+ RELEASE_ASSERT_NOT_REACHED();
+#endif
+ }
+ }
+
+ if (x)
+ *x = rect.x();
+ if (y)
+ *y = rect.y();
+ if (width)
+ *width = rect.width();
+ if (height)
+ *height = rect.height();
+}
+
+// FIXME: Different kinds of elements are putting the title tag to use
+// in different AX fields. This might not be 100% correct but we will
+// keep it now in order to achieve consistency with previous behavior.
+static bool titleTagShouldBeUsedInDescriptionField(AccessibilityObject* coreObject)
+{
+ return (coreObject->isLink() && !coreObject->isImageMapLink()) || coreObject->isImage();
+}
+
+// This should be the "visible" text that's actually on the screen if possible.
+// If there's alternative text, that can override the title.
+String accessibilityTitle(AccessibilityObject* coreObject)
+{
+ Vector<AccessibilityText> textOrder;
+ coreObject->accessibilityText(textOrder);
+
+ for (const AccessibilityText& text : textOrder) {
+ // Once we encounter visible text, or the text from our children that should be used foremost.
+ if (text.textSource == AccessibilityTextSource::Visible || text.textSource == AccessibilityTextSource::Children)
+ return text.text;
+
+ // If there's an element that labels this object and it's not exposed, then we should use
+ // that text as our title.
+ if (text.textSource == AccessibilityTextSource::LabelByElement && !coreObject->titleUIElement())
+ return text.text;
+
+ // Elements of role AccessibilityRole::Toolbar will return its title as AccessibilityTextSource::Alternative.
+ if (coreObject->roleValue() == AccessibilityRole::Toolbar && text.textSource == AccessibilityTextSource::Alternative)
+ return text.text;
+
+ // FIXME: The title tag is used in certain cases for the title. This usage should
+ // probably be in the description field since it's not "visible".
+ if (text.textSource == AccessibilityTextSource::TitleTag && !titleTagShouldBeUsedInDescriptionField(coreObject))
+ return text.text;
+ }
+
+ return String();
+}
+
+String accessibilityDescription(AccessibilityObject* coreObject)
+{
+ Vector<AccessibilityText> textOrder;
+ coreObject->accessibilityText(textOrder);
+
+ bool visibleTextAvailable = false;
+ for (const AccessibilityText& text : textOrder) {
+ if (text.textSource == AccessibilityTextSource::Alternative)
+ return text.text;
+
+ switch (text.textSource) {
+ case AccessibilityTextSource::Visible:
+ case AccessibilityTextSource::Children:
+ case AccessibilityTextSource::LabelByElement:
+ visibleTextAvailable = true;
+ default:
+ break;
+ }
+
+ if (text.textSource == AccessibilityTextSource::TitleTag && !visibleTextAvailable)
+ return text.text;
+ }
+
+ return String();
+}
+
+bool selectionBelongsToObject(AccessibilityObject* coreObject, VisibleSelection& selection)
+{
+ if (!coreObject || !coreObject->isAccessibilityRenderObject())
+ return false;
+
+ auto range = selection.firstRange();
+ return range && intersects<ComposedTree>(*range, *coreObject->node());
+}
+
+AXCoreObject* objectFocusedAndCaretOffsetUnignored(AXCoreObject* referenceObject, int& offset)
+{
+ // Indication that something bogus has transpired.
+ offset = -1;
+
+ Document* document = referenceObject->document();
+ if (!document)
+ return nullptr;
+
+ Node* focusedNode = referenceObject->selection().end().containerNode();
+ if (!focusedNode)
+ return nullptr;
+
+ RenderObject* focusedRenderer = focusedNode->renderer();
+ if (!focusedRenderer)
+ return nullptr;
+
+ AccessibilityObject* focusedObject = document->axObjectCache()->getOrCreate(focusedRenderer);
+ if (!focusedObject)
+ return nullptr;
+
+ // Look for the actual (not ignoring accessibility) selected object.
+ AXCoreObject* firstUnignoredParent = focusedObject;
+ if (firstUnignoredParent->accessibilityIsIgnored())
+ firstUnignoredParent = firstUnignoredParent->parentObjectUnignored();
+ if (!firstUnignoredParent)
+ return nullptr;
+
+ // Don't ignore links if the offset is being requested for a link
+ // or if the link is a block.
+ if (!referenceObject->isLink() && firstUnignoredParent->isLink()
+ && !(firstUnignoredParent->renderer() && !firstUnignoredParent->renderer()->isInline()))
+ firstUnignoredParent = firstUnignoredParent->parentObjectUnignored();
+ if (!firstUnignoredParent)
+ return nullptr;
+
+ // The reference object must either coincide with the focused
+ // object being considered, or be a descendant of it.
+ if (referenceObject->isDescendantOfObject(firstUnignoredParent))
+ referenceObject = firstUnignoredParent;
+
+ Node* startNode = nullptr;
+ if (firstUnignoredParent != referenceObject || firstUnignoredParent->isTextControl()) {
+ // We need to use the first child's node of the reference
+ // object as the start point to calculate the caret offset
+ // because we want it to be relative to the object of
+ // reference, not just to the focused object (which could have
+ // previous siblings which should be taken into account too).
+ AXCoreObject* axFirstChild = reinterpret_cast<AccessibilityObject *>(referenceObject)->firstChild();
+ if (axFirstChild)
+ startNode = axFirstChild->node();
+ }
+ // Getting the Position of a PseudoElement now triggers an assertion.
+ // This can occur when clicking on empty space in a render block.
+ if (!startNode || startNode->isPseudoElement())
+ startNode = firstUnignoredParent->node();
+
+ // Check if the node for the first parent object not ignoring
+ // accessibility is null again before using it. This might happen
+ // with certain kind of accessibility objects, such as the root
+ // one (the scroller containing the webArea object).
+ if (!startNode)
+ return nullptr;
+
+ VisiblePosition startPosition = VisiblePosition(positionBeforeNode(startNode));
+ VisiblePosition endPosition = firstUnignoredParent->selection().visibleEnd();
+
+ if (startPosition == endPosition)
+ offset = 0;
+ else if (!isStartOfLine(endPosition)) {
+ auto range = makeSimpleRange(startPosition, endPosition.previous());
+ offset = (range ? characterCount(*range, TextIteratorBehavior::EmitsCharactersBetweenAllVisiblePositions) : 0) + 1;
+ } else {
+ auto range = makeSimpleRange(startPosition, endPosition);
+ offset = range ? characterCount(*range, TextIteratorBehavior::EmitsCharactersBetweenAllVisiblePositions) : 0;
+ }
+
+ return firstUnignoredParent;
+}
+
+#endif
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleUtil.h webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleUtil.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atk/WebKitAccessibleUtil.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atk/WebKitAccessibleUtil.h 2023-03-09 13:26:47.286643885 -0600
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2008 Nuanti Ltd.
+ * Copyright (C) 2009 Jan Alonzo
+ * Copyright (C) 2009, 2010, 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include <atk/atk.h>
+#include <wtf/text/WTFString.h>
+
+namespace WebCore {
+class AXCoreObject;
+class AccessibilityObject;
+class IntRect;
+class VisibleSelection;
+}
+
+// An existing accessibility object is considered to be invalid whether it's already
+// detached or if it's not but just updating the layout will detach it anyway.
+#define returnIfWebKitAccessibleIsInvalid(webkitAccessible) G_STMT_START { \
+ if (!webkitAccessible || webkitAccessibleIsDetached(webkitAccessible)) \
+ return; \
+ auto& coreObject = webkitAccessibleGetAccessibilityObject(webkitAccessible); \
+ if (!coreObject.document()) \
+ return; \
+ coreObject.updateBackingStore(); \
+ if (webkitAccessibleIsDetached(webkitAccessible)) \
+ return; \
+ ; } G_STMT_END
+
+#define returnValIfWebKitAccessibleIsInvalid(webkitAccessible, val) G_STMT_START { \
+ if (!webkitAccessible || webkitAccessibleIsDetached(webkitAccessible)) \
+ return (val); \
+ auto& coreObject = webkitAccessibleGetAccessibilityObject(webkitAccessible); \
+ if (!coreObject.document()) \
+ return (val); \
+ coreObject.updateBackingStore(); \
+ if (webkitAccessibleIsDetached(webkitAccessible)) \
+ return (val); \
+ ; } G_STMT_END
+
+AtkAttributeSet* addToAtkAttributeSet(AtkAttributeSet*, const char* name, const char* value);
+
+void contentsRelativeToAtkCoordinateType(WebCore::AccessibilityObject*, AtkCoordType, WebCore::IntRect, gint* x, gint* y, gint* width = nullptr, gint* height = nullptr);
+
+String accessibilityTitle(WebCore::AccessibilityObject*);
+
+String accessibilityDescription(WebCore::AccessibilityObject*);
+
+bool selectionBelongsToObject(WebCore::AccessibilityObject*, WebCore::VisibleSelection&);
+
+WebCore::AXCoreObject* objectFocusedAndCaretOffsetUnignored(WebCore::AXCoreObject*, int& offset);
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp 2023-02-20 03:22:15.289729400 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp 2023-03-09 13:26:47.286643885 -0600
@@ -967,7 +967,7 @@ HashMap<String, String> AccessibilityObj
// According to the W3C Core Accessibility API Mappings 1.1, section 5.4.1 General Rules:
// "User agents must expose the WAI-ARIA role string if the API supports a mechanism to do so."
- // In the case of ATSPI, the mechanism to do so is an object attribute pair (xml-roles:"string").
+ // In the case of ATK, the mechanism to do so is an object attribute pair (xml-roles:"string").
// We cannot use the computedRoleString for this purpose because it is not limited to elements
// with ARIA roles, and it might not contain the actual ARIA role value (e.g. DPub ARIA).
String roleString = static_cast<AccessibilityObject*>(m_coreObject)->getAttribute(HTMLNames::roleAttr);
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/AXObjectCache.h webkitgtk-2.39.91.atk/Source/WebCore/accessibility/AXObjectCache.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/accessibility/AXObjectCache.h 2023-02-20 03:22:15.225729000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/accessibility/AXObjectCache.h 2023-03-09 13:26:47.290643907 -0600
@@ -39,6 +39,10 @@
#include <wtf/ListHashSet.h>
#include <wtf/WeakHashSet.h>
+#if USE(ATK)
+#include <wtf/glib/GRefPtr.h>
+#endif
+
namespace WTF {
class TextStream;
}
@@ -613,6 +617,10 @@ private:
bool m_relationsNeedUpdate { true };
HashSet<AXID> m_relationTargets;
+#if USE(ATK)
+ ListHashSet<RefPtr<AccessibilityObject>> m_deferredAttachedWrapperObjectList;
+ ListHashSet<GRefPtr<AccessibilityObjectWrapper>> m_deferredDetachedWrapperList;
+#endif
#if USE(ATSPI)
ListHashSet<RefPtr<AXCoreObject>> m_deferredParentChangedList;
#endif
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/editing/atk/FrameSelectionAtk.cpp webkitgtk-2.39.91.atk/Source/WebCore/editing/atk/FrameSelectionAtk.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/editing/atk/FrameSelectionAtk.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/editing/atk/FrameSelectionAtk.cpp 2023-03-09 13:26:47.290643907 -0600
@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2009 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "FrameSelection.h"
+
+#if ENABLE(ACCESSIBILITY) && USE(ATK)
+
+#include "AXObjectCache.h"
+#include "DocumentInlines.h"
+#include "Frame.h"
+#include "RenderListItem.h"
+#include "WebKitAccessible.h"
+#include "WebKitAccessibleUtil.h"
+#include <glib.h>
+#include <wtf/NeverDestroyed.h>
+#include <wtf/RefPtr.h>
+
+namespace WebCore {
+
+static void emitTextSelectionChange(AXCoreObject* object, VisibleSelection selection, int offset)
+{
+ auto* axObject = object->wrapper();
+ if (!axObject || !ATK_IS_TEXT(axObject))
+ return;
+
+ // We need to adjust the offset for the list item marker in Left-To-Right text because
+ // the list item marker is exposed through the text of the accessible list item rather
+ // than through a separate accessible object.
+ RenderObject* renderer = object->renderer();
+ if (is<RenderListItem>(renderer) && renderer->style().direction() == TextDirection::LTR)
+ offset += downcast<RenderListItem>(*renderer).markerTextWithSuffix().length();
+
+ g_signal_emit_by_name(axObject, "text-caret-moved", offset);
+ if (selection.isRange())
+ g_signal_emit_by_name(axObject, "text-selection-changed");
+}
+
+static void maybeEmitTextFocusChange(RefPtr<AXCoreObject>&& object)
+{
+ // This static variable is needed to keep track of the old object
+ // as per previous calls to this function, in order to properly
+ // decide whether to emit some signals or not.
+ static NeverDestroyed<RefPtr<AXCoreObject>> oldObject;
+
+ // Ensure the oldObject belongs to the same document that the
+ // current object so further comparisons make sense. Otherwise,
+ // just reset oldObject to 0 so it won't be taken into account in
+ // the immediately following call to this function.
+ if (object && oldObject.get() && oldObject.get()->document() != object->document())
+ oldObject.get() = nullptr;
+
+ auto* axObject = object ? object->wrapper() : nullptr;
+ auto* oldAxObject = oldObject.get() ? oldObject.get()->wrapper() : nullptr;
+
+ if (axObject != oldAxObject) {
+ if (oldAxObject && ATK_IS_TEXT(oldAxObject)) {
+ g_signal_emit_by_name(oldAxObject, "focus-event", FALSE);
+ atk_object_notify_state_change(ATK_OBJECT(oldAxObject), ATK_STATE_FOCUSED, FALSE);
+ }
+ if (axObject && ATK_IS_TEXT(axObject)) {
+ g_signal_emit_by_name(axObject, "focus-event", TRUE);
+ atk_object_notify_state_change(ATK_OBJECT(axObject), ATK_STATE_FOCUSED, TRUE);
+ }
+ }
+
+ // Update pointer to last focused object.
+ oldObject.get() = WTFMove(object);
+}
+
+
+void FrameSelection::notifyAccessibilityForSelectionChange(const AXTextStateChangeIntent&)
+{
+ if (!AXObjectCache::accessibilityEnabled())
+ return;
+
+ if (!m_selection.start().isNotNull() || !m_selection.end().isNotNull())
+ return;
+
+ Node* focusedNode = m_selection.end().containerNode();
+ if (!focusedNode)
+ return;
+
+ AXObjectCache* cache = m_document->existingAXObjectCache();
+ if (!cache)
+ return;
+
+ AccessibilityObject* accessibilityObject = cache->getOrCreate(focusedNode->renderer());
+ if (!accessibilityObject)
+ return;
+
+ int offset;
+ RefPtr<AXCoreObject> object = objectFocusedAndCaretOffsetUnignored(accessibilityObject, offset);
+ if (!object)
+ return;
+
+ emitTextSelectionChange(object.get(), m_selection, offset);
+ maybeEmitTextFocusChange(WTFMove(object));
+}
+
+} // namespace WebCore
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATK)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/editing/FrameSelection.h webkitgtk-2.39.91.atk/Source/WebCore/editing/FrameSelection.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/editing/FrameSelection.h 2023-02-20 03:22:16.373733500 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/editing/FrameSelection.h 2023-03-09 13:26:47.290643907 -0600
@@ -383,7 +383,7 @@ inline void FrameSelection::clearTypingS
m_typingStyle = nullptr;
}
-#if !(ENABLE(ACCESSIBILITY) && (PLATFORM(COCOA) || USE(ATSPI)))
+#if !(ENABLE(ACCESSIBILITY) && (PLATFORM(COCOA) || USE(ATK) || USE(ATSPI)))
inline void FrameSelection::notifyAccessibilityForSelectionChange(const AXTextStateChangeIntent&)
{
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/page/Settings.yaml webkitgtk-2.39.91.atk/Source/WebCore/page/Settings.yaml
--- webkitgtk-2.39.91.glib244/Source/WebCore/page/Settings.yaml 2023-02-20 03:22:17.725739000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/page/Settings.yaml 2023-03-09 13:26:47.290643907 -0600
@@ -264,6 +264,7 @@ LangAttributeAwareFormControlUIEnabled:
type: bool
defaultValue:
WebCore:
+ USE(ATSPI): true
default: false
LocalStorageDatabasePath:
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/platform/graphics/PlatformDisplay.cpp webkitgtk-2.39.91.atk/Source/WebCore/platform/graphics/PlatformDisplay.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/platform/graphics/PlatformDisplay.cpp 2023-03-08 03:00:32.710698800 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/platform/graphics/PlatformDisplay.cpp 2023-03-09 13:26:47.290643907 -0600
@@ -80,7 +80,7 @@
#include <wtf/NeverDestroyed.h>
#endif
-#if USE(ATSPI)
+#if USE(ATSPI) || USE(ATK)
#include <wtf/glib/GUniquePtr.h>
#endif
@@ -342,7 +342,7 @@ cmsHPROFILE PlatformDisplay::colorProfil
}
#endif
-#if USE(ATSPI)
+#if USE(ATSPI) || USE(ATK)
const String& PlatformDisplay::accessibilityBusAddress() const
{
if (m_accessibilityBusAddress)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/platform/graphics/PlatformDisplay.h webkitgtk-2.39.91.atk/Source/WebCore/platform/graphics/PlatformDisplay.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/platform/graphics/PlatformDisplay.h 2023-03-08 03:00:32.710698800 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/platform/graphics/PlatformDisplay.h 2023-03-09 13:26:47.290643907 -0600
@@ -104,7 +104,7 @@ public:
virtual cmsHPROFILE colorProfile() const;
#endif
-#if USE(ATSPI)
+#if USE(ATSPI) || USE(ATK)
const String& accessibilityBusAddress() const;
#endif
@@ -136,7 +136,7 @@ protected:
mutable LCMSProfilePtr m_iccProfile;
#endif
-#if USE(ATSPI)
+#if USE(ATSPI) || USE(ATK)
virtual String platformAccessibilityBusAddress() const { return { }; }
mutable std::optional<String> m_accessibilityBusAddress;
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/platform/graphics/x11/PlatformDisplayX11.cpp webkitgtk-2.39.91.atk/Source/WebCore/platform/graphics/x11/PlatformDisplayX11.cpp
--- webkitgtk-2.39.91.glib244/Source/WebCore/platform/graphics/x11/PlatformDisplayX11.cpp 2023-02-20 03:22:19.013744000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/platform/graphics/x11/PlatformDisplayX11.cpp 2023-03-09 13:26:47.290643907 -0600
@@ -271,7 +271,7 @@ cmsHPROFILE PlatformDisplayX11::colorPro
}
#endif
-#if USE(ATSPI)
+#if USE(ATSPI) || USE(ATK)
String PlatformDisplayX11::platformAccessibilityBusAddress() const
{
Atom atspiBusAtom = XInternAtom(m_display, "AT_SPI_BUS", False);
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/platform/graphics/x11/PlatformDisplayX11.h webkitgtk-2.39.91.atk/Source/WebCore/platform/graphics/x11/PlatformDisplayX11.h
--- webkitgtk-2.39.91.glib244/Source/WebCore/platform/graphics/x11/PlatformDisplayX11.h 2023-02-20 03:22:19.017744000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/platform/graphics/x11/PlatformDisplayX11.h 2023-03-09 13:26:47.290643907 -0600
@@ -71,7 +71,7 @@ private:
cmsHPROFILE colorProfile() const override;
#endif
-#if USE(ATSPI)
+#if USE(ATSPI) || USE(ATK)
String platformAccessibilityBusAddress() const override;
#endif
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/PlatformGTK.cmake webkitgtk-2.39.91.atk/Source/WebCore/PlatformGTK.cmake
--- webkitgtk-2.39.91.glib244/Source/WebCore/PlatformGTK.cmake 2023-02-20 03:22:15.125728600 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/PlatformGTK.cmake 2023-03-09 13:26:47.290643907 -0600
@@ -14,8 +14,10 @@ list(APPEND WebCore_UNIFIED_SOURCE_LIST_
)
list(APPEND WebCore_PRIVATE_INCLUDE_DIRECTORIES
+ "${WEBCORE_DIR}/accessibility/atk"
"${WEBCORE_DIR}/accessibility/atspi"
"${WEBCORE_DIR}/crypto/openssl"
+ "${WEBCORE_DIR}/editing/atk"
"${WEBCORE_DIR}/page/gtk"
"${WEBCORE_DIR}/platform/audio/glib"
"${WEBCORE_DIR}/platform/generic"
@@ -68,6 +70,7 @@ list(APPEND WebCore_PRIVATE_FRAMEWORK_HE
set(CSS_VALUE_PLATFORM_DEFINES "HAVE_OS_DARK_MODE_SUPPORT=1")
list(APPEND WebCore_LIBRARIES
+ ${ATK_LIBRARIES}
${ENCHANT_LIBRARIES}
${GLIB_GIO_LIBRARIES}
${GLIB_GMODULE_LIBRARIES}
@@ -86,6 +89,7 @@ list(APPEND WebCore_LIBRARIES
)
list(APPEND WebCore_SYSTEM_INCLUDE_DIRECTORIES
+ ${ATK_INCLUDE_DIRS}
${ENCHANT_INCLUDE_DIRS}
${GIO_UNIX_INCLUDE_DIRS}
${GLIB_INCLUDE_DIRS}
diff -urpN webkitgtk-2.39.91.glib244/Source/WebCore/SourcesGTK.txt webkitgtk-2.39.91.atk/Source/WebCore/SourcesGTK.txt
--- webkitgtk-2.39.91.glib244/Source/WebCore/SourcesGTK.txt 2023-03-09 11:32:30.594447910 -0600
+++ webkitgtk-2.39.91.atk/Source/WebCore/SourcesGTK.txt 2023-03-09 13:26:47.290643907 -0600
@@ -21,6 +21,24 @@
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
// THE POSSIBILITY OF SUCH DAMAGE.
+accessibility/atk/AXObjectCacheAtk.cpp
+accessibility/atk/AccessibilityObjectAtk.cpp
+accessibility/atk/WebKitAccessible.cpp
+accessibility/atk/WebKitAccessibleHyperlink.cpp
+accessibility/atk/WebKitAccessibleInterfaceAction.cpp @no-unify
+accessibility/atk/WebKitAccessibleInterfaceComponent.cpp
+accessibility/atk/WebKitAccessibleInterfaceDocument.cpp
+accessibility/atk/WebKitAccessibleInterfaceEditableText.cpp
+accessibility/atk/WebKitAccessibleInterfaceHyperlinkImpl.cpp
+accessibility/atk/WebKitAccessibleInterfaceHypertext.cpp
+accessibility/atk/WebKitAccessibleInterfaceImage.cpp
+accessibility/atk/WebKitAccessibleInterfaceSelection.cpp
+accessibility/atk/WebKitAccessibleInterfaceTable.cpp
+accessibility/atk/WebKitAccessibleInterfaceTableCell.cpp
+accessibility/atk/WebKitAccessibleInterfaceText.cpp
+accessibility/atk/WebKitAccessibleInterfaceValue.cpp
+accessibility/atk/WebKitAccessibleUtil.cpp
+
accessibility/atspi/AccessibilityAtspi.cpp
accessibility/atspi/AccessibilityObjectAtspi.cpp
accessibility/atspi/AccessibilityObjectActionAtspi.cpp
@@ -38,6 +56,8 @@ accessibility/atspi/AccessibilityObjectV
accessibility/atspi/AccessibilityRootAtspi.cpp
accessibility/atspi/AXObjectCacheAtspi.cpp
+editing/atk/FrameSelectionAtk.cpp
+
editing/atspi/FrameSelectionAtspi.cpp
editing/gtk/EditorGtk.cpp
diff -urpN webkitgtk-2.39.91.glib244/Source/WebKit/PlatformGTK.cmake webkitgtk-2.39.91.atk/Source/WebKit/PlatformGTK.cmake
--- webkitgtk-2.39.91.glib244/Source/WebKit/PlatformGTK.cmake 2023-03-09 13:26:06.422428155 -0600
+++ webkitgtk-2.39.91.atk/Source/WebKit/PlatformGTK.cmake 2023-03-09 13:26:47.290643907 -0600
@@ -287,10 +287,12 @@ list(APPEND WebKit_INCLUDE_DIRECTORIES
"${WEBKIT_DIR}/WebProcess/WebCoreSupport/gtk"
"${WEBKIT_DIR}/WebProcess/WebCoreSupport/soup"
"${WEBKIT_DIR}/WebProcess/WebPage/CoordinatedGraphics"
+ "${WEBKIT_DIR}/WebProcess/WebPage/atk"
"${WEBKIT_DIR}/WebProcess/WebPage/gtk"
)
list(APPEND WebKit_SYSTEM_INCLUDE_DIRECTORIES
+ ${ATK_INCLUDE_DIRS}
${ENCHANT_INCLUDE_DIRS}
${GIO_UNIX_INCLUDE_DIRS}
${GLIB_INCLUDE_DIRS}
diff -urpN webkitgtk-2.39.91.glib244/Source/WebKit/SourcesGTK.txt webkitgtk-2.39.91.atk/Source/WebKit/SourcesGTK.txt
--- webkitgtk-2.39.91.glib244/Source/WebKit/SourcesGTK.txt 2023-03-09 11:32:30.594447910 -0600
+++ webkitgtk-2.39.91.atk/Source/WebKit/SourcesGTK.txt 2023-03-09 13:26:47.290643907 -0600
@@ -324,6 +324,8 @@ WebProcess/WebPage/CoordinatedGraphics/C
WebProcess/WebPage/CoordinatedGraphics/DrawingAreaCoordinatedGraphics.cpp
WebProcess/WebPage/CoordinatedGraphics/LayerTreeHost.cpp
+WebProcess/WebPage/atk/WebKitWebPageAccessibilityObject.cpp
+
WebProcess/WebPage/glib/WebPageGLib.cpp
WebProcess/WebPage/gtk/AcceleratedSurfaceX11.cpp @no-unify
diff -urpN webkitgtk-2.39.91.glib244/Source/WebKit/UIProcess/API/glib/WebKitWebViewAccessible.cpp webkitgtk-2.39.91.atk/Source/WebKit/UIProcess/API/glib/WebKitWebViewAccessible.cpp
--- webkitgtk-2.39.91.glib244/Source/WebKit/UIProcess/API/glib/WebKitWebViewAccessible.cpp 2023-02-20 03:22:21.497753900 -0600
+++ webkitgtk-2.39.91.atk/Source/WebKit/UIProcess/API/glib/WebKitWebViewAccessible.cpp 2023-03-09 13:26:47.290643907 -0600
@@ -20,7 +20,7 @@
#include "config.h"
#include "WebKitWebViewAccessible.h"
-#if ENABLE(ACCESSIBILITY) && !USE(GTK4)
+#if ENABLE(ACCESSIBILITY)
#include <wtf/glib/WTFGType.h>
diff -urpN webkitgtk-2.39.91.glib244/Source/WebKit/UIProcess/API/glib/WebKitWebViewAccessible.h webkitgtk-2.39.91.atk/Source/WebKit/UIProcess/API/glib/WebKitWebViewAccessible.h
--- webkitgtk-2.39.91.glib244/Source/WebKit/UIProcess/API/glib/WebKitWebViewAccessible.h 2023-02-20 03:22:21.497753900 -0600
+++ webkitgtk-2.39.91.atk/Source/WebKit/UIProcess/API/glib/WebKitWebViewAccessible.h 2023-03-09 13:26:47.290643907 -0600
@@ -19,7 +19,7 @@
#pragma once
-#if ENABLE(ACCESSIBILITY) && !USE(GTK4)
+#if ENABLE(ACCESSIBILITY)
#include <atk/atk.h>
diff -urpN webkitgtk-2.39.91.glib244/Source/WebKit/UIProcess/API/gtk/WebKitWebViewBase.cpp webkitgtk-2.39.91.atk/Source/WebKit/UIProcess/API/gtk/WebKitWebViewBase.cpp
--- webkitgtk-2.39.91.glib244/Source/WebKit/UIProcess/API/gtk/WebKitWebViewBase.cpp 2023-03-09 11:32:30.602447951 -0600
+++ webkitgtk-2.39.91.atk/Source/WebKit/UIProcess/API/gtk/WebKitWebViewBase.cpp 2023-03-09 13:26:47.294643927 -0600
@@ -285,9 +285,7 @@ struct _WebKitWebViewBasePrivate {
CString tooltipText;
IntRect tooltipArea;
WebHitTestResultData::IsScrollbar mouseIsOverScrollbar;
-#if !USE(GTK4)
GRefPtr<AtkObject> accessible;
-#endif
GtkWidget* dialog { nullptr };
GtkWidget* inspectorView { nullptr };
AttachmentSide inspectorAttachmentSide { AttachmentSide::Bottom };
diff -urpN webkitgtk-2.39.91.glib244/Source/WebKit/WebProcess/WebPage/atk/WebKitWebPageAccessibilityObject.cpp webkitgtk-2.39.91.atk/Source/WebKit/WebProcess/WebPage/atk/WebKitWebPageAccessibilityObject.cpp
--- webkitgtk-2.39.91.glib244/Source/WebKit/WebProcess/WebPage/atk/WebKitWebPageAccessibilityObject.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebKit/WebProcess/WebPage/atk/WebKitWebPageAccessibilityObject.cpp 2023-03-09 13:26:47.294643927 -0600
@@ -0,0 +1,170 @@
+/*
+ * Copyright (C) 2012, 2019 Igalia S.L.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "WebKitWebPageAccessibilityObject.h"
+
+#if ENABLE(ACCESSIBILITY)
+
+#include "WebPage.h"
+#include <WebCore/AXObjectCache.h>
+#include <WebCore/AccessibilityScrollView.h>
+#include <WebCore/Document.h>
+#include <WebCore/Frame.h>
+#include <WebCore/Page.h>
+#include <WebCore/ScrollView.h>
+#include <wtf/glib/WTFGType.h>
+
+using namespace WebKit;
+using namespace WebCore;
+
+struct _WebKitWebPageAccessibilityObjectPrivate {
+ WebPage* page;
+};
+
+WEBKIT_DEFINE_TYPE(WebKitWebPageAccessibilityObject, webkit_web_page_accessibility_object, ATK_TYPE_PLUG)
+
+static void coreRootObjectWrapperDetachedCallback(AtkObject* wrapper, const char*, gboolean value, AtkObject* atkObject)
+{
+ if (!value)
+ return;
+
+ g_signal_emit_by_name(atkObject, "children-changed::remove", 0, wrapper);
+}
+
+static AccessibilityObjectWrapper* rootWebAreaWrapper(AXCoreObject& rootObject)
+{
+ if (!rootObject.isScrollView())
+ return nullptr;
+
+ if (auto* webAreaObject = downcast<AccessibilityObject>(rootObject).webAreaObject())
+ return webAreaObject->wrapper();
+
+ return nullptr;
+}
+
+static AtkObject* accessibilityRootObjectWrapper(AtkObject* atkObject)
+{
+ if (!AXObjectCache::accessibilityEnabled())
+ AXObjectCache::enableAccessibility();
+
+ auto* accessible = WEBKIT_WEB_PAGE_ACCESSIBILITY_OBJECT(atkObject);
+ if (!accessible->priv->page)
+ return nullptr;
+
+ Page* corePage = accessible->priv->page->corePage();
+ if (!corePage)
+ return nullptr;
+
+ Frame& coreFrame = corePage->mainFrame();
+ if (!coreFrame.document())
+ return nullptr;
+
+ AXObjectCache* cache = coreFrame.document()->axObjectCache();
+ if (!cache)
+ return nullptr;
+
+ AXCoreObject* coreRootObject = cache->rootObject();
+ if (!coreRootObject)
+ return nullptr;
+
+ auto* wrapper = ATK_OBJECT(coreRootObject->wrapper());
+ if (!wrapper)
+ return nullptr;
+
+ if (atk_object_peek_parent(wrapper) != ATK_OBJECT(accessible)) {
+ atk_object_set_parent(wrapper, ATK_OBJECT(accessible));
+ g_signal_emit_by_name(accessible, "children-changed::add", 0, wrapper);
+
+ if (auto* webAreaWrapper = rootWebAreaWrapper(*coreRootObject)) {
+ g_signal_connect_object(webAreaWrapper, "state-change::defunct",
+ G_CALLBACK(coreRootObjectWrapperDetachedCallback), accessible, static_cast<GConnectFlags>(0));
+ }
+ }
+
+ return wrapper;
+}
+
+static void webkitWebPageAccessibilityObjectInitialize(AtkObject* atkObject, gpointer data)
+{
+ if (ATK_OBJECT_CLASS(webkit_web_page_accessibility_object_parent_class)->initialize)
+ ATK_OBJECT_CLASS(webkit_web_page_accessibility_object_parent_class)->initialize(atkObject, data);
+
+ WEBKIT_WEB_PAGE_ACCESSIBILITY_OBJECT(atkObject)->priv->page = reinterpret_cast<WebPage*>(data);
+ atk_object_set_role(atkObject, ATK_ROLE_FILLER);
+}
+
+static gint webkitWebPageAccessibilityObjectGetIndexInParent(AtkObject*)
+{
+ // An AtkPlug is the only child an AtkSocket can have.
+ return 0;
+}
+
+static gint webkitWebPageAccessibilityObjectGetNChildren(AtkObject* atkObject)
+{
+ return accessibilityRootObjectWrapper(atkObject) ? 1 : 0;
+}
+
+static AtkObject* webkitWebPageAccessibilityObjectRefChild(AtkObject* atkObject, gint index)
+{
+ // It's supposed to have either one child or zero.
+ if (index && index != 1)
+ return nullptr;
+
+ if (auto* rootObjectWrapper = accessibilityRootObjectWrapper(atkObject))
+ return ATK_OBJECT(g_object_ref(rootObjectWrapper));
+
+ return nullptr;
+}
+
+static AtkStateSet* webkitWebPageAccessibilityObjectRefStateSet(AtkObject* atkObject)
+{
+ if (auto* rootObjectWrapper = accessibilityRootObjectWrapper(atkObject))
+ return atk_object_ref_state_set(rootObjectWrapper);
+
+ return atk_state_set_new();
+}
+
+static void webkit_web_page_accessibility_object_class_init(WebKitWebPageAccessibilityObjectClass* klass)
+{
+ AtkObjectClass* atkObjectClass = ATK_OBJECT_CLASS(klass);
+ // No need to implement get_parent() here since this is a subclass
+ // of AtkPlug and all the logic related to that function will be
+ // implemented by the ATK bridge.
+ atkObjectClass->initialize = webkitWebPageAccessibilityObjectInitialize;
+ atkObjectClass->get_index_in_parent = webkitWebPageAccessibilityObjectGetIndexInParent;
+ atkObjectClass->get_n_children = webkitWebPageAccessibilityObjectGetNChildren;
+ atkObjectClass->ref_child = webkitWebPageAccessibilityObjectRefChild;
+ atkObjectClass->ref_state_set = webkitWebPageAccessibilityObjectRefStateSet;
+}
+
+AtkObject* webkitWebPageAccessibilityObjectNew(WebPage* page)
+{
+ AtkObject* object = ATK_OBJECT(g_object_new(WEBKIT_TYPE_WEB_PAGE_ACCESSIBILITY_OBJECT, nullptr));
+ atk_object_initialize(object, page);
+ return object;
+}
+
+#endif // ENABLE(ACCESSIBILITY)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebKit/WebProcess/WebPage/atk/WebKitWebPageAccessibilityObject.h webkitgtk-2.39.91.atk/Source/WebKit/WebProcess/WebPage/atk/WebKitWebPageAccessibilityObject.h
--- webkitgtk-2.39.91.glib244/Source/WebKit/WebProcess/WebPage/atk/WebKitWebPageAccessibilityObject.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.39.91.atk/Source/WebKit/WebProcess/WebPage/atk/WebKitWebPageAccessibilityObject.h 2023-03-09 13:26:47.294643927 -0600
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2012, 2019 Igalia S.L.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#if ENABLE(ACCESSIBILITY)
+
+#include <atk/atk.h>
+
+namespace WebKit {
+class WebPage;
+}
+
+G_BEGIN_DECLS
+
+#define WEBKIT_TYPE_WEB_PAGE_ACCESSIBILITY_OBJECT (webkit_web_page_accessibility_object_get_type())
+#define WEBKIT_WEB_PAGE_ACCESSIBILITY_OBJECT(object) (G_TYPE_CHECK_INSTANCE_CAST((object), WEBKIT_TYPE_WEB_PAGE_ACCESSIBILITY_OBJECT, WebKitWebPageAccessibilityObject))
+#define WEBKIT_WEB_PAGE_ACCESSIBILITY_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), WEBKIT_TYPE_WEB_PAGE_ACCESSIBILITY_OBJECT, WebKitWebPageAccessibilityObjectClass))
+#define WEBKIT_IS_WEB_PAGE_ACCESSIBILITY_OBJECT(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), WEBKIT_TYPE_WEB_PAGE_ACCESSIBILITY_OBJECT))
+#define WEBKIT_IS_WEB_PAGE_ACCESSIBILITY_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), WEBKIT_TYPE_WEB_PAGE_ACCESSIBILITY_OBJECT))
+#define WEBKIT_WEB_PAGE_ACCESSIBILITY_OBJECT_GET_CLASS(object) (G_TYPE_INSTANCE_GET_CLASS((object), WEBKIT_TYPE_WEB_PAGE_ACCESSIBILITY_OBJECT, WebKitWebPageAccessibilityObjectClass))
+
+typedef struct _WebKitWebPageAccessibilityObject WebKitWebPageAccessibilityObject;
+typedef struct _WebKitWebPageAccessibilityObjectClass WebKitWebPageAccessibilityObjectClass;
+typedef struct _WebKitWebPageAccessibilityObjectPrivate WebKitWebPageAccessibilityObjectPrivate;
+
+struct _WebKitWebPageAccessibilityObject {
+ AtkPlug parent;
+
+ WebKitWebPageAccessibilityObjectPrivate* priv;
+};
+
+struct _WebKitWebPageAccessibilityObjectClass {
+ AtkPlugClass parentClass;
+};
+
+GType webkit_web_page_accessibility_object_get_type();
+
+AtkObject* webkitWebPageAccessibilityObjectNew(WebKit::WebPage*);
+
+G_END_DECLS
+
+#endif // ENABLE(ACCESSIBILITY)
diff -urpN webkitgtk-2.39.91.glib244/Source/WebKit/WebProcess/WebPage/glib/WebPageGLib.cpp webkitgtk-2.39.91.atk/Source/WebKit/WebProcess/WebPage/glib/WebPageGLib.cpp
--- webkitgtk-2.39.91.glib244/Source/WebKit/WebProcess/WebPage/glib/WebPageGLib.cpp 2023-03-08 00:53:12.550624400 -0600
+++ webkitgtk-2.39.91.atk/Source/WebKit/WebProcess/WebPage/glib/WebPageGLib.cpp 2023-03-09 13:29:01.763353832 -0600
@@ -29,6 +29,7 @@
#include "EditorState.h"
#include "InputMethodState.h"
#include "UserMessage.h"
+#include "WebKitWebPageAccessibilityObject.h"
#include "WebKitUserMessage.h"
#include "WebKitWebPagePrivate.h"
#include "WebPageProxyMessages.h"
@@ -55,11 +56,35 @@ using namespace WebCore;
void WebPage::platformInitialize(const WebPageCreationParameters&)
{
-#if USE(ATSPI)
+#if ENABLE(ACCESSIBILITY)
// Create the accessible object (the plug) that will serve as the
// entry point to the Web process, and send a message to the UI
// process to connect the two worlds through the accessibility
// object there specifically placed for that purpose (the socket).
+#if USE(ATK)
+ auto isValidPlugID = [](const char* plugID) -> bool {
+ if (!plugID || plugID[0] != ':')
+ return false;
+
+ auto* p = g_strrstr(plugID, ":");
+ if (!p)
+ return false;
+
+ if (!g_variant_is_object_path(p + 1))
+ return false;
+
+ GUniquePtr<char> name(g_strndup(plugID, p - plugID));
+ if (!g_dbus_is_unique_name(name.get()))
+ return false;
+
+ return true;
+ };
+
+ m_accessibilityObject = adoptGRef(webkitWebPageAccessibilityObjectNew(this));
+ GUniquePtr<gchar> plugID(atk_plug_get_id(ATK_PLUG(m_accessibilityObject.get())));
+ if (isValidPlugID(plugID.get()))
+ send(Messages::WebPageProxy::BindAccessibilityTree(String::fromLatin1(plugID.get())));
+#elif USE(ATSPI)
#if PLATFORM(GTK) && USE(GTK4)
// FIXME: we need a way to connect DOM and app a11y tree in GTK4.
#else
@@ -72,6 +97,7 @@ void WebPage::platformInitialize(const W
}
#endif
#endif
+#endif
}
void WebPage::platformDetach()
diff -urpN webkitgtk-2.39.91.glib244/Source/WebKit/WebProcess/WebPage/WebPage.h webkitgtk-2.39.91.atk/Source/WebKit/WebProcess/WebPage/WebPage.h
--- webkitgtk-2.39.91.glib244/Source/WebKit/WebProcess/WebPage/WebPage.h 2023-03-08 00:53:12.550624400 -0600
+++ webkitgtk-2.39.91.atk/Source/WebKit/WebProcess/WebPage/WebPage.h 2023-03-09 13:26:47.294643927 -0600
@@ -112,9 +112,14 @@
#include <wtf/WeakHashSet.h>
#include <wtf/text/WTFString.h>
-#if USE(ATSPI)
+#if ENABLE(ACCESSIBILITY)
+#if USE(ATK)
+typedef struct _AtkObject AtkObject;
+#include <wtf/glib/GRefPtr.h>
+#elif USE(ATSPI)
#include <WebCore/AccessibilityRootAtspi.h>
#endif
+#endif
#if PLATFORM(GTK)
#include "ArgumentCodersGtk.h"
@@ -2176,9 +2181,13 @@ private:
RetainPtr<NSDictionary> m_dataDetectionContext;
#endif
-#if USE(ATSPI)
+#if ENABLE(ACCESSIBILITY)
+#if USE(ATK)
+ GRefPtr<AtkObject> m_accessibilityObject;
+#elif USE(ATSPI)
RefPtr<WebCore::AccessibilityRootAtspi> m_accessibilityRootObject;
#endif
+#endif
#if USE(GRAPHICS_LAYER_TEXTURE_MAPPER) || USE(GRAPHICS_LAYER_WC)
uint64_t m_nativeWindowHandle { 0 };
