0cac8be880675ecaf7fc91016a6ba9036c12550b
[WebKit-https.git] / WebCore / accessibility / AXObjectCache.cpp
1 /*
2  * Copyright (C) 2008 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include "config.h"
30 #include "AXObjectCache.h"
31
32 #include "AccessibilityARIAGrid.h"
33 #include "AccessibilityARIAGridRow.h"
34 #include "AccessibilityARIAGridCell.h"
35 #include "AccessibilityList.h"
36 #include "AccessibilityListBox.h"
37 #include "AccessibilityListBoxOption.h"
38 #include "AccessibilityImageMapLink.h"
39 #include "AccessibilityRenderObject.h"
40 #include "AccessibilitySlider.h"
41 #include "AccessibilityTable.h"
42 #include "AccessibilityTableCell.h"
43 #include "AccessibilityTableColumn.h"
44 #include "AccessibilityTableHeaderContainer.h"
45 #include "AccessibilityTableRow.h"
46 #include "FocusController.h"
47 #include "Frame.h"
48 #include "HTMLNames.h"
49 #include "InputElement.h"
50 #include "Page.h"
51 #include "RenderObject.h"
52 #include "RenderView.h"
53
54 #include <wtf/PassRefPtr.h>
55
56 namespace WebCore {
57
58 using namespace HTMLNames;
59     
60 bool AXObjectCache::gAccessibilityEnabled = false;
61 bool AXObjectCache::gAccessibilityEnhancedUserInterfaceEnabled = false;
62
63 AXObjectCache::AXObjectCache(const Document* document)
64     : m_notificationPostTimer(this, &AXObjectCache::notificationPostTimerFired)
65     , m_document(document)
66 {
67 }
68
69 AXObjectCache::~AXObjectCache()
70 {
71     HashMap<AXID, RefPtr<AccessibilityObject> >::iterator end = m_objects.end();
72     for (HashMap<AXID, RefPtr<AccessibilityObject> >::iterator it = m_objects.begin(); it != end; ++it) {
73         AccessibilityObject* obj = (*it).second.get();
74         detachWrapper(obj);
75         obj->detach();
76         removeAXID(obj);
77     }
78 }
79
80 AccessibilityObject* AXObjectCache::focusedUIElementForPage(const Page* page)
81 {
82     // get the focused node in the page
83     Document* focusedDocument = page->focusController()->focusedOrMainFrame()->document();
84     Node* focusedNode = focusedDocument->focusedNode();
85     if (!focusedNode)
86         focusedNode = focusedDocument;
87
88     RenderObject* focusedNodeRenderer = focusedNode->renderer();
89     if (!focusedNodeRenderer)
90         return 0;
91
92     AccessibilityObject* obj = focusedNodeRenderer->document()->axObjectCache()->getOrCreate(focusedNodeRenderer);
93
94     if (obj->shouldFocusActiveDescendant()) {
95         if (AccessibilityObject* descendant = obj->activeDescendant())
96             obj = descendant;
97     }
98
99     // the HTML element, for example, is focusable but has an AX object that is ignored
100     if (obj->accessibilityIsIgnored())
101         obj = obj->parentObjectUnignored();
102
103     return obj;
104 }
105
106 AccessibilityObject* AXObjectCache::get(RenderObject* renderer)
107 {
108     if (!renderer)
109         return 0;
110     
111     AccessibilityObject* obj = 0;
112     AXID axID = m_renderObjectMapping.get(renderer);
113     ASSERT(!HashTraits<AXID>::isDeletedValue(axID));
114
115     if (axID)
116         obj = m_objects.get(axID).get();
117     
118     return obj;
119 }
120     
121 bool AXObjectCache::nodeIsAriaType(Node* node, String role)
122 {
123     if (!node || !node->isElementNode())
124         return false;
125     
126     return equalIgnoringCase(static_cast<Element*>(node)->getAttribute(roleAttr), role);
127 }
128
129 AccessibilityObject* AXObjectCache::getOrCreate(RenderObject* renderer)
130 {
131     if (!renderer)
132         return 0;
133     
134     AccessibilityObject* obj = get(renderer);
135
136     if (!obj) {
137         Node* node = renderer->node();
138         RefPtr<AccessibilityObject> newObj = 0;
139         if (renderer->isListBox())
140             newObj = AccessibilityListBox::create(renderer);
141         else if (node && (nodeIsAriaType(node, "list") || node->hasTagName(ulTag) || node->hasTagName(olTag) || node->hasTagName(dlTag)))
142             newObj = AccessibilityList::create(renderer);
143         
144         // aria tables
145         else if (nodeIsAriaType(node, "grid"))
146             newObj = AccessibilityARIAGrid::create(renderer);
147         else if (nodeIsAriaType(node, "row"))
148             newObj = AccessibilityARIAGridRow::create(renderer);
149         else if (nodeIsAriaType(node, "gridcell") || nodeIsAriaType(node, "columnheader") || nodeIsAriaType(node, "rowheader"))
150             newObj = AccessibilityARIAGridCell::create(renderer);
151
152         // standard tables
153         else if (renderer->isTable())
154             newObj = AccessibilityTable::create(renderer);
155         else if (renderer->isTableRow())
156             newObj = AccessibilityTableRow::create(renderer);
157         else if (renderer->isTableCell())
158             newObj = AccessibilityTableCell::create(renderer);
159
160         // input type=range
161         else if (renderer->isSlider())
162             newObj = AccessibilitySlider::create(renderer);
163
164         else
165             newObj = AccessibilityRenderObject::create(renderer);
166         
167         obj = newObj.get();
168         
169         getAXID(obj);
170         
171         m_renderObjectMapping.set(renderer, obj->axObjectID());
172         m_objects.set(obj->axObjectID(), obj);    
173         attachWrapper(obj);
174     }
175     
176     return obj;
177 }
178
179 AccessibilityObject* AXObjectCache::getOrCreate(AccessibilityRole role)
180 {
181     RefPtr<AccessibilityObject> obj = 0;
182     
183     // will be filled in...
184     switch (role) {
185         case ListBoxOptionRole:
186             obj = AccessibilityListBoxOption::create();
187             break;
188         case ImageMapLinkRole:
189             obj = AccessibilityImageMapLink::create();
190             break;
191         case ColumnRole:
192             obj = AccessibilityTableColumn::create();
193             break;            
194         case TableHeaderContainerRole:
195             obj = AccessibilityTableHeaderContainer::create();
196             break;   
197         case SliderThumbRole:
198             obj = AccessibilitySliderThumb::create();
199             break;
200         default:
201             obj = 0;
202     }
203     
204     if (obj)
205         getAXID(obj.get());
206     else
207         return 0;
208
209     m_objects.set(obj->axObjectID(), obj);    
210     attachWrapper(obj.get());
211     return obj.get();
212 }
213
214 void AXObjectCache::remove(AXID axID)
215 {
216     if (!axID)
217         return;
218     
219     // first fetch object to operate some cleanup functions on it 
220     AccessibilityObject* obj = m_objects.get(axID).get();
221     if (!obj)
222         return;
223     
224     detachWrapper(obj);
225     obj->detach();
226     removeAXID(obj);
227     
228     // finally remove the object
229     if (!m_objects.take(axID)) {
230         return;
231     }
232     
233     ASSERT(m_objects.size() >= m_idsInUse.size());    
234 }
235     
236 void AXObjectCache::remove(RenderObject* renderer)
237 {
238     if (!renderer)
239         return;
240     
241     AXID axID = m_renderObjectMapping.get(renderer);
242     remove(axID);
243     m_renderObjectMapping.remove(renderer);
244 }
245
246 #if !PLATFORM(WIN)
247 AXID AXObjectCache::platformGenerateAXID() const
248 {
249     static AXID lastUsedID = 0;
250
251     // Generate a new ID.
252     AXID objID = lastUsedID;
253     do {
254         ++objID;
255     } while (objID == 0 || HashTraits<AXID>::isDeletedValue(objID) || m_idsInUse.contains(objID));
256
257     lastUsedID = objID;
258
259     return objID;
260 }
261 #endif
262
263 AXID AXObjectCache::getAXID(AccessibilityObject* obj)
264 {
265     // check for already-assigned ID
266     AXID objID = obj->axObjectID();
267     if (objID) {
268         ASSERT(m_idsInUse.contains(objID));
269         return objID;
270     }
271
272     objID = platformGenerateAXID();
273
274     m_idsInUse.add(objID);
275     obj->setAXObjectID(objID);
276     
277     return objID;
278 }
279
280 void AXObjectCache::removeAXID(AccessibilityObject* obj)
281 {
282     if (!obj)
283         return;
284     
285     AXID objID = obj->axObjectID();
286     if (objID == 0)
287         return;
288     ASSERT(!HashTraits<AXID>::isDeletedValue(objID));
289     ASSERT(m_idsInUse.contains(objID));
290     obj->setAXObjectID(0);
291     m_idsInUse.remove(objID);
292 }
293
294 void AXObjectCache::childrenChanged(RenderObject* renderer)
295 {
296     if (!renderer)
297         return;
298  
299     AXID axID = m_renderObjectMapping.get(renderer);
300     if (!axID)
301         return;
302     
303     AccessibilityObject* obj = m_objects.get(axID).get();
304     if (obj)
305         obj->childrenChanged();
306 }
307     
308 void AXObjectCache::notificationPostTimerFired(Timer<AXObjectCache>*)
309 {
310     m_notificationPostTimer.stop();
311
312     unsigned i = 0, count = m_notificationsToPost.size();
313     for (i = 0; i < count; ++i) {
314         AccessibilityObject* obj = m_notificationsToPost[i].first.get();
315 #ifndef NDEBUG
316         // Make sure none of the render views are in the process of being layed out.
317         // Notifications should only be sent after the renderer has finished
318         if (obj->isAccessibilityRenderObject()) {
319             AccessibilityRenderObject* renderObj = static_cast<AccessibilityRenderObject*>(obj);
320             RenderObject* renderer = renderObj->renderer();
321             if (renderer && renderer->view())
322                 ASSERT(!renderer->view()->layoutState());
323         }
324 #endif
325         
326         postPlatformNotification(obj, m_notificationsToPost[i].second);
327     }
328     
329     m_notificationsToPost.clear();
330 }
331     
332 #if HAVE(ACCESSIBILITY)
333 void AXObjectCache::postNotification(RenderObject* renderer, const String& message, bool postToElement)
334 {
335     // Notifications for text input objects are sent to that object.
336     // All others are sent to the top WebArea.
337     if (!renderer)
338         return;
339     
340     // Get an accessibility object that already exists. One should not be created here
341     // because a render update may be in progress and creating an AX object can re-trigger a layout
342     RefPtr<AccessibilityObject> obj = get(renderer);
343     while (!obj && renderer) {
344         renderer = renderer->parent();
345         obj = get(renderer); 
346     }
347     
348     if (!renderer)
349         return;
350
351     if (obj && !postToElement)
352         obj = obj->observableObject();
353     
354     Document* document = renderer->document();
355     if (!obj && document)
356         obj = get(document->renderer());
357     
358     if (!obj)
359         return;
360
361     m_notificationsToPost.append(make_pair(obj, message));
362     if (!m_notificationPostTimer.isActive())
363         m_notificationPostTimer.startOneShot(0);
364 }
365
366 void AXObjectCache::selectedChildrenChanged(RenderObject* renderer)
367 {
368     postNotification(renderer, "AXSelectedChildrenChanged", true);
369 }
370 #endif
371
372 #if HAVE(ACCESSIBILITY)
373 void AXObjectCache::handleActiveDescendantChanged(RenderObject* renderer)
374 {
375     if (!renderer)
376         return;
377     AccessibilityObject* obj = getOrCreate(renderer);
378     if (obj)
379         obj->handleActiveDescendantChanged();
380 }
381
382 void AXObjectCache::handleAriaRoleChanged(RenderObject* renderer)
383 {
384     if (!renderer)
385         return;
386     AccessibilityObject* obj = getOrCreate(renderer);
387     if (obj && obj->isAccessibilityRenderObject())
388         static_cast<AccessibilityRenderObject*>(obj)->updateAccessibilityRole();
389 }
390 #endif
391     
392 VisiblePosition AXObjectCache::visiblePositionForTextMarkerData(TextMarkerData& textMarkerData)
393 {
394     VisiblePosition visiblePos = VisiblePosition(textMarkerData.node, textMarkerData.offset, textMarkerData.affinity);
395     Position deepPos = visiblePos.deepEquivalent();
396     if (deepPos.isNull())
397         return VisiblePosition();
398     
399     RenderObject* renderer = deepPos.node()->renderer();
400     if (!renderer)
401         return VisiblePosition();
402     
403     AXObjectCache* cache = renderer->document()->axObjectCache();
404     if (!cache->isIDinUse(textMarkerData.axID))
405         return VisiblePosition();
406     
407     if (deepPos.node() != textMarkerData.node || deepPos.deprecatedEditingOffset() != textMarkerData.offset)
408         return VisiblePosition();
409     
410     return visiblePos;
411 }
412
413 void AXObjectCache::textMarkerDataForVisiblePosition(TextMarkerData& textMarkerData, const VisiblePosition& visiblePos)
414 {
415     // This memory must be bzero'd so instances of TextMarkerData can be tested for byte-equivalence.
416     // This also allows callers to check for failure by looking at textMarkerData upon return.
417     memset(&textMarkerData, 0, sizeof(TextMarkerData));
418     
419     if (visiblePos.isNull())
420         return;
421     
422     Position deepPos = visiblePos.deepEquivalent();
423     Node* domNode = deepPos.node();
424     ASSERT(domNode);
425     if (!domNode)
426         return;
427     
428     if (domNode->isHTMLElement()) {
429         InputElement* inputElement = toInputElement(static_cast<Element*>(domNode));
430         if (inputElement && inputElement->isPasswordField())
431             return;
432     }
433     
434     // locate the renderer, which must exist for a visible dom node
435     RenderObject* renderer = domNode->renderer();
436     ASSERT(renderer);
437     
438     // find or create an accessibility object for this renderer
439     AXObjectCache* cache = renderer->document()->axObjectCache();
440     RefPtr<AccessibilityObject> obj = cache->getOrCreate(renderer);
441     
442     textMarkerData.axID = obj.get()->axObjectID();
443     textMarkerData.node = domNode;
444     textMarkerData.offset = deepPos.deprecatedEditingOffset();
445     textMarkerData.affinity = visiblePos.affinity();    
446 }
447     
448 } // namespace WebCore