blob: 2b1c340211d1a8d7b104b00dba59417093c22276 [file] [log] [blame]
/*
* 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(AXCoreObject* obj)
{
// FIXME: at the moment, only allow to attach AccessibilityObjects.
if (!is<AccessibilityObject>(obj))
return;
AccessibilityObject* accessibilityObject = downcast<AccessibilityObject>(obj);
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.
if (!object->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");
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()) {
String maskedText = parentObject->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