bb183d162fc3e1e15f9e48d01c532d8b3aab10b7
[WebKit-https.git] / Source / WebCore / accessibility / atk / AXObjectCacheAtk.cpp
1 /*
2  * Copyright (C) 2008 Nuanti Ltd.
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public License
15  * along with this library; see the file COPYING.LIB.  If not, write to
16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  * Boston, MA 02110-1301, USA.
18  */
19
20 #include "config.h"
21 #include "AXObjectCache.h"
22
23 #if HAVE(ACCESSIBILITY)
24
25 #include "AccessibilityObject.h"
26 #include "AccessibilityRenderObject.h"
27 #include "Document.h"
28 #include "Element.h"
29 #include "HTMLSelectElement.h"
30 #include "Range.h"
31 #include "TextIterator.h"
32 #include "WebKitAccessibleWrapperAtk.h"
33 #include <wtf/NeverDestroyed.h>
34 #include <wtf/glib/GRefPtr.h>
35 #include <wtf/text/CString.h>
36
37 namespace WebCore {
38
39 void AXObjectCache::detachWrapper(AccessibilityObject* obj, AccessibilityDetachmentType detachmentType)
40 {
41     auto* wrapper = obj->wrapper();
42     ASSERT(wrapper);
43
44     // If an object is being detached NOT because of the AXObjectCache being destroyed,
45     // then it's being removed from the accessibility tree and we should emit a signal.
46     if (detachmentType != AccessibilityDetachmentType::CacheDestroyed) {
47         if (obj->document()) {
48             // Look for the right object to emit the signal from, but using the implementation
49             // of atk_object_get_parent from AtkObject class (which uses a cached pointer if set)
50             // since the accessibility hierarchy in WebCore will no longer be navigable.
51             gpointer webkitAccessibleClass = g_type_class_peek_parent(WEBKIT_ACCESSIBLE_GET_CLASS(wrapper));
52             gpointer atkObjectClass = g_type_class_peek_parent(webkitAccessibleClass);
53             AtkObject* atkParent = ATK_OBJECT_CLASS(atkObjectClass)->get_parent(ATK_OBJECT(wrapper));
54
55             // We don't want to emit any signal from an object outside WebKit's world.
56             if (WEBKIT_IS_ACCESSIBLE(atkParent)) {
57                 // The accessibility hierarchy is already invalid, so the parent-children relationships
58                 // in the AccessibilityObject tree are not there anymore, so we can't know the offset.
59                 g_signal_emit_by_name(atkParent, "children-changed::remove", -1, wrapper);
60             }
61         }
62     }
63
64     webkitAccessibleDetach(WEBKIT_ACCESSIBLE(wrapper));
65 }
66
67 void AXObjectCache::attachWrapper(AccessibilityObject* obj)
68 {
69     GRefPtr<WebKitAccessible> wrapper = adoptGRef(webkitAccessibleNew(obj));
70     obj->setWrapper(wrapper.get());
71
72     // If an object is being attached and we are not in the middle of a layout update, then
73     // we should report ATs by emitting the children-changed::add signal from the parent.
74     Document* document = obj->document();
75     if (!document || document->childNeedsStyleRecalc())
76         return;
77
78     // Don't emit the signal when the actual object being added is not going to be exposed.
79     if (obj->accessibilityIsIgnoredByDefault())
80         return;
81
82     // Don't emit the signal if the object being added is not -- or not yet -- rendered,
83     // which can occur in nested iframes. In these instances we don't want to ignore the
84     // child. But if an assistive technology is listening, AT-SPI2 will attempt to create
85     // and cache the state set for the child upon emission of the signal. If the object
86     // has not yet been rendered, this will result in a crash.
87     if (!obj->renderer())
88         return;
89
90     // Don't emit the signal for objects whose parents won't be exposed directly.
91     AccessibilityObject* coreParent = obj->parentObjectUnignored();
92     if (!coreParent || coreParent->accessibilityIsIgnoredByDefault())
93         return;
94
95     // Look for the right object to emit the signal from.
96     auto* atkParent = coreParent->wrapper();
97     if (!atkParent)
98         return;
99
100     size_t index = coreParent->children(false).find(obj);
101     g_signal_emit_by_name(atkParent, "children-changed::add", index != notFound ? index : -1, wrapper.get());
102 }
103
104 static AccessibilityObject* getListObject(AccessibilityObject* object)
105 {
106     // Only list boxes and menu lists supported so far.
107     if (!object->isListBox() && !object->isMenuList())
108         return 0;
109
110     // For list boxes the list object is just itself.
111     if (object->isListBox())
112         return object;
113
114     // For menu lists we need to return the first accessible child,
115     // with role MenuListPopupRole, since that's the one holding the list
116     // of items with role MenuListOptionRole.
117     const AccessibilityObject::AccessibilityChildrenVector& children = object->children();
118     if (!children.size())
119         return 0;
120
121     AccessibilityObject* listObject = children.at(0).get();
122     if (!listObject->isMenuListPopup())
123         return 0;
124
125     return listObject;
126 }
127
128 static void notifyChildrenSelectionChange(AccessibilityObject* object)
129 {
130     // This static variables are needed to keep track of the old
131     // focused object and its associated list object, as per previous
132     // calls to this function, in order to properly decide whether to
133     // emit some signals or not.
134     static NeverDestroyed<RefPtr<AccessibilityObject>> oldListObject;
135     static NeverDestroyed<RefPtr<AccessibilityObject>> oldFocusedObject;
136
137     // Only list boxes and menu lists supported so far.
138     if (!object || !(object->isListBox() || object->isMenuList()))
139         return;
140
141     // Only support HTML select elements so far (ARIA selectors not supported).
142     Node* node = object->node();
143     if (!is<HTMLSelectElement>(node))
144         return;
145
146     // Emit signal from the listbox's point of view first.
147     g_signal_emit_by_name(object->wrapper(), "selection-changed");
148
149     // Find the item where the selection change was triggered from.
150     HTMLSelectElement& select = downcast<HTMLSelectElement>(*node);
151     int changedItemIndex = select.activeSelectionStartListIndex();
152
153     AccessibilityObject* listObject = getListObject(object);
154     if (!listObject) {
155         oldListObject.get() = nullptr;
156         return;
157     }
158
159     const AccessibilityObject::AccessibilityChildrenVector& items = listObject->children();
160     if (changedItemIndex < 0 || changedItemIndex >= static_cast<int>(items.size()))
161         return;
162     AccessibilityObject* item = items.at(changedItemIndex).get();
163
164     // Ensure the current list object is the same than the old one so
165     // further comparisons make sense. Otherwise, just reset
166     // oldFocusedObject so it won't be taken into account.
167     if (oldListObject.get() != listObject)
168         oldFocusedObject.get() = nullptr;
169
170     WebKitAccessible* axItem = item ? item->wrapper() : nullptr;
171     WebKitAccessible* axOldFocusedObject = oldFocusedObject.get() ? oldFocusedObject.get()->wrapper() : nullptr;
172
173     // Old focused object just lost focus, so emit the events.
174     if (axOldFocusedObject && axItem != axOldFocusedObject) {
175         g_signal_emit_by_name(axOldFocusedObject, "focus-event", false);
176         atk_object_notify_state_change(ATK_OBJECT(axOldFocusedObject), ATK_STATE_FOCUSED, false);
177     }
178
179     // Emit needed events for the currently (un)selected item.
180     if (axItem) {
181         bool isSelected = item->isSelected();
182         atk_object_notify_state_change(ATK_OBJECT(axItem), ATK_STATE_SELECTED, isSelected);
183         // When the selection changes in a collapsed widget such as a combo box
184         // whose child menu is not showing, that collapsed widget retains focus.
185         if (!object->isCollapsed()) {
186             g_signal_emit_by_name(axItem, "focus-event", isSelected);
187             atk_object_notify_state_change(ATK_OBJECT(axItem), ATK_STATE_FOCUSED, isSelected);
188         }
189     }
190
191     // Update pointers to the previously involved objects.
192     oldListObject.get() = listObject;
193     oldFocusedObject.get() = item;
194 }
195
196 void AXObjectCache::postPlatformNotification(AccessibilityObject* coreObject, AXNotification notification)
197 {
198     auto* axObject = ATK_OBJECT(coreObject->wrapper());
199     if (!axObject)
200         return;
201
202     switch (notification) {
203     case AXCheckedStateChanged:
204         if (!coreObject->isCheckboxOrRadio() && !coreObject->isSwitch())
205             return;
206         atk_object_notify_state_change(axObject, ATK_STATE_CHECKED, coreObject->isChecked());
207         break;
208
209     case AXSelectedChildrenChanged:
210     case AXMenuListValueChanged:
211         // Accessible focus claims should not be made if the associated widget is not focused.
212         if (notification == AXMenuListValueChanged && coreObject->isMenuList() && coreObject->isFocused()) {
213             g_signal_emit_by_name(axObject, "focus-event", true);
214             atk_object_notify_state_change(axObject, ATK_STATE_FOCUSED, true);
215         }
216         notifyChildrenSelectionChange(coreObject);
217         break;
218
219     case AXValueChanged:
220         if (ATK_IS_VALUE(axObject)) {
221             AtkPropertyValues propertyValues;
222             propertyValues.property_name = "accessible-value";
223
224             memset(&propertyValues.new_value,  0, sizeof(GValue));
225 #if ATK_CHECK_VERSION(2,11,92)
226             double value;
227             atk_value_get_value_and_text(ATK_VALUE(axObject), &value, nullptr);
228             g_value_set_double(g_value_init(&propertyValues.new_value, G_TYPE_DOUBLE), value);
229 #else
230             atk_value_get_current_value(ATK_VALUE(axObject), &propertyValues.new_value);
231 #endif
232
233             g_signal_emit_by_name(axObject, "property-change::accessible-value", &propertyValues, NULL);
234         }
235         break;
236
237     case AXInvalidStatusChanged:
238         atk_object_notify_state_change(axObject, ATK_STATE_INVALID_ENTRY, coreObject->invalidStatus() != "false");
239         break;
240
241     case AXElementBusyChanged:
242         atk_object_notify_state_change(axObject, ATK_STATE_BUSY, coreObject->isBusy());
243         break;
244
245     case AXCurrentChanged:
246         atk_object_notify_state_change(axObject, ATK_STATE_ACTIVE, coreObject->currentState() != AccessibilityCurrentState::False);
247         break;
248
249     case AXRowExpanded:
250         atk_object_notify_state_change(axObject, ATK_STATE_EXPANDED, true);
251         break;
252
253     case AXRowCollapsed:
254         atk_object_notify_state_change(axObject, ATK_STATE_EXPANDED, false);
255         break;
256
257     case AXExpandedChanged:
258         atk_object_notify_state_change(axObject, ATK_STATE_EXPANDED, coreObject->isExpanded());
259         break;
260
261     case AXDisabledStateChanged: {
262         bool enabledState = coreObject->isEnabled();
263         atk_object_notify_state_change(axObject, ATK_STATE_ENABLED, enabledState);
264         atk_object_notify_state_change(axObject, ATK_STATE_SENSITIVE, enabledState);
265         break;
266     }
267
268     case AXPressedStateChanged:
269         atk_object_notify_state_change(axObject, ATK_STATE_PRESSED, coreObject->isPressed());
270         break;
271
272     case AXReadOnlyStatusChanged:
273 #if ATK_CHECK_VERSION(2,15,3)
274         atk_object_notify_state_change(axObject, ATK_STATE_READ_ONLY, !coreObject->canSetValueAttribute());
275 #endif
276         break;
277
278     case AXRequiredStatusChanged:
279         atk_object_notify_state_change(axObject, ATK_STATE_REQUIRED, coreObject->isRequired());
280         break;
281
282     case AXActiveDescendantChanged:
283         if (AccessibilityObject* descendant = coreObject->activeDescendant())
284             platformHandleFocusedUIElementChanged(nullptr, descendant->node());
285         break;
286
287     default:
288         break;
289     }
290 }
291
292 void AXObjectCache::nodeTextChangePlatformNotification(AccessibilityObject* object, AXTextChange textChange, unsigned offset, const String& text)
293 {
294     if (!object || text.isEmpty())
295         return;
296
297     AccessibilityObject* parentObject = object->isNonNativeTextControl() ? object : object->parentObjectUnignored();
298     if (!parentObject)
299         return;
300
301     auto* wrapper = parentObject->wrapper();
302     if (!wrapper || !ATK_IS_TEXT(wrapper))
303         return;
304
305     Node* node = object->node();
306     if (!node)
307         return;
308
309     // Ensure document's layout is up-to-date before using TextIterator.
310     Document& document = node->document();
311     document.updateLayout();
312
313     // Select the right signal to be emitted
314     CString detail;
315     switch (textChange) {
316     case AXTextInserted:
317         detail = "text-insert";
318         break;
319     case AXTextDeleted:
320         detail = "text-remove";
321         break;
322     case AXTextAttributesChanged:
323         detail = "text-attributes-changed";
324         break;
325     }
326
327     String textToEmit = text;
328     unsigned offsetToEmit = offset;
329
330     // If the object we're emitting the signal from represents a
331     // password field, we will emit the masked text.
332     if (parentObject->isPasswordField()) {
333         String maskedText = parentObject->passwordFieldValue();
334         textToEmit = maskedText.substring(offset, text.length());
335     } else {
336         // Consider previous text objects that might be present for
337         // the current accessibility object to ensure we emit the
338         // right offset (e.g. multiline text areas).
339         auto range = Range::create(document, node->parentNode(), 0, node, 0);
340         offsetToEmit = offset + TextIterator::rangeLength(range.ptr());
341     }
342
343     g_signal_emit_by_name(wrapper, detail.data(), offsetToEmit, textToEmit.length(), textToEmit.utf8().data());
344 }
345
346 void AXObjectCache::frameLoadingEventPlatformNotification(AccessibilityObject* object, AXLoadingEvent loadingEvent)
347 {
348     if (!object)
349         return;
350
351     auto* axObject = ATK_OBJECT(object->wrapper());
352     if (!axObject || !ATK_IS_DOCUMENT(axObject))
353         return;
354
355     switch (loadingEvent) {
356     case AXObjectCache::AXLoadingStarted:
357         atk_object_notify_state_change(axObject, ATK_STATE_BUSY, true);
358         break;
359     case AXObjectCache::AXLoadingReloaded:
360         atk_object_notify_state_change(axObject, ATK_STATE_BUSY, true);
361         g_signal_emit_by_name(axObject, "reload");
362         break;
363     case AXObjectCache::AXLoadingFailed:
364         g_signal_emit_by_name(axObject, "load-stopped");
365         atk_object_notify_state_change(axObject, ATK_STATE_BUSY, false);
366         break;
367     case AXObjectCache::AXLoadingFinished:
368         g_signal_emit_by_name(axObject, "load-complete");
369         atk_object_notify_state_change(axObject, ATK_STATE_BUSY, false);
370         break;
371     }
372 }
373
374 void AXObjectCache::platformHandleFocusedUIElementChanged(Node* oldFocusedNode, Node* newFocusedNode)
375 {
376     RefPtr<AccessibilityObject> oldObject = getOrCreate(oldFocusedNode);
377     if (oldObject) {
378         auto* axObject = oldObject->wrapper();
379         g_signal_emit_by_name(axObject, "focus-event", false);
380         atk_object_notify_state_change(ATK_OBJECT(axObject), ATK_STATE_FOCUSED, false);
381     }
382     RefPtr<AccessibilityObject> newObject = getOrCreate(newFocusedNode);
383     if (newObject) {
384         auto* axObject = newObject->wrapper();
385         g_signal_emit_by_name(axObject, "focus-event", true);
386         atk_object_notify_state_change(ATK_OBJECT(axObject), ATK_STATE_FOCUSED, true);
387     }
388 }
389
390 void AXObjectCache::handleScrolledToAnchor(const Node*)
391 {
392 }
393
394 } // namespace WebCore
395
396 #endif