Generated should not be supported for things with a shadow
[WebKit-https.git] / Source / WebCore / accessibility / AXObjectCache.h
1 /*
2  * Copyright (C) 2003, 2006, 2007, 2008, 2009, 2010, 2011 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  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef AXObjectCache_h
27 #define AXObjectCache_h
28
29 #include "AccessibilityObject.h"
30 #include "Timer.h"
31 #include <limits.h>
32 #include <wtf/Forward.h>
33 #include <wtf/HashMap.h>
34 #include <wtf/HashSet.h>
35 #include <wtf/RefPtr.h>
36
37 namespace WebCore {
38
39 class Document;
40 class HTMLAreaElement;
41 class Node;
42 class Page;
43 class RenderObject;
44 class ScrollView;
45 class VisiblePosition;
46 class Widget;
47
48 struct TextMarkerData {
49     AXID axID;
50     Node* node;
51     int offset;
52     EAffinity affinity;
53 };
54
55 enum PostType { PostSynchronously, PostAsynchronously };
56
57 class AXObjectCache {
58     WTF_MAKE_NONCOPYABLE(AXObjectCache); WTF_MAKE_FAST_ALLOCATED;
59 public:
60     explicit AXObjectCache(const Document*);
61     ~AXObjectCache();
62
63     static AccessibilityObject* focusedUIElementForPage(const Page*);
64
65     // Returns the root object for the entire document.
66     AccessibilityObject* rootObject();
67     // Returns the root object for a specific frame.
68     AccessibilityObject* rootObjectForFrame(Frame*);
69     
70     // For AX objects with elements that back them.
71     AccessibilityObject* getOrCreate(RenderObject*);
72     AccessibilityObject* getOrCreate(Widget*);
73     AccessibilityObject* getOrCreate(Node*);
74
75     // used for objects without backing elements
76     AccessibilityObject* getOrCreate(AccessibilityRole);
77     
78     // will only return the AccessibilityObject if it already exists
79     AccessibilityObject* get(RenderObject*);
80     AccessibilityObject* get(Widget*);
81     AccessibilityObject* get(Node*);
82     
83     void remove(RenderObject*);
84     void remove(Node*);
85     void remove(Widget*);
86     void remove(AXID);
87
88     void detachWrapper(AccessibilityObject*);
89     void attachWrapper(AccessibilityObject*);
90     void childrenChanged(Node*);
91     void childrenChanged(RenderObject*);
92     void checkedStateChanged(Node*);
93     void selectedChildrenChanged(Node*);
94     void selectedChildrenChanged(RenderObject*);
95     // Called by a node when text or a text equivalent (e.g. alt) attribute is changed.
96     void contentChanged(Node*);
97     void contentChanged(RenderObject*);
98     // Called when a node has just been attached, so we can make sure we have the right subclass of AccessibilityObject.
99     void updateCacheAfterNodeIsAttached(Node*);
100
101     void handleActiveDescendantChanged(Node*);
102     void handleAriaRoleChanged(Node*);
103     void handleFocusedUIElementChanged(Node* oldFocusedNode, Node* newFocusedNode);
104     void handleScrolledToAnchor(const Node* anchorNode);
105     void handleAriaExpandedChange(Node*);
106     void handleScrollbarUpdate(ScrollView*);
107
108 #if HAVE(ACCESSIBILITY)
109     static void enableAccessibility() { gAccessibilityEnabled = true; }
110     // Enhanced user interface accessibility can be toggled by the assistive technology.
111     static void setEnhancedUserInterfaceAccessibility(bool flag) { gAccessibilityEnhancedUserInterfaceEnabled = flag; }
112     
113     static bool accessibilityEnabled() { return gAccessibilityEnabled; }
114     static bool accessibilityEnhancedUserInterfaceEnabled() { return gAccessibilityEnhancedUserInterfaceEnabled; }
115 #else
116     static void enableAccessibility() { }
117     static void setEnhancedUserInterfaceAccessibility(bool) { }
118     static bool accessibilityEnabled() { return false; }
119     static bool accessibilityEnhancedUserInterfaceEnabled() { return false; }
120 #endif
121
122     void removeAXID(AccessibilityObject*);
123     bool isIDinUse(AXID id) const { return m_idsInUse.contains(id); }
124
125     Element* rootAXEditableElement(Node*);
126     const Element* rootAXEditableElement(const Node*);
127     bool nodeIsTextControl(const Node*);
128
129     AXID platformGenerateAXID() const;
130     AccessibilityObject* objectFromAXID(AXID id) const { return m_objects.get(id).get(); }
131
132     // Text marker utilities.
133     void textMarkerDataForVisiblePosition(TextMarkerData&, const VisiblePosition&);
134     VisiblePosition visiblePositionForTextMarkerData(TextMarkerData&);
135
136     enum AXNotification {
137         AXActiveDescendantChanged,
138         AXAutocorrectionOccured,
139         AXCheckedStateChanged,
140         AXChildrenChanged,
141         AXFocusedUIElementChanged,
142         AXLayoutComplete,
143         AXLoadComplete,
144         AXSelectedChildrenChanged,
145         AXSelectedTextChanged,
146         AXValueChanged,
147         AXScrolledToAnchor,
148         AXLiveRegionChanged,
149         AXMenuListItemSelected,
150         AXMenuListValueChanged,
151         AXRowCountChanged,
152         AXRowCollapsed,
153         AXRowExpanded,
154         AXInvalidStatusChanged,
155     };
156
157     void postNotification(RenderObject*, AXNotification, bool postToElement, PostType = PostAsynchronously);
158     void postNotification(Node*, AXNotification, bool postToElement, PostType = PostAsynchronously);
159     void postNotification(AccessibilityObject*, Document*, AXNotification, bool postToElement, PostType = PostAsynchronously);
160
161     enum AXTextChange {
162         AXTextInserted,
163         AXTextDeleted,
164     };
165
166     void nodeTextChangeNotification(Node*, AXTextChange, unsigned offset, const String&);
167
168     enum AXLoadingEvent {
169         AXLoadingStarted,
170         AXLoadingReloaded,
171         AXLoadingFailed,
172         AXLoadingFinished
173     };
174
175     void frameLoadingEventNotification(Frame*, AXLoadingEvent);
176
177     bool nodeHasRole(Node*, const AtomicString& role);
178
179 protected:
180     void postPlatformNotification(AccessibilityObject*, AXNotification);
181     void nodeTextChangePlatformNotification(AccessibilityObject*, AXTextChange, unsigned offset, const String&);
182     void frameLoadingEventPlatformNotification(AccessibilityObject*, AXLoadingEvent);
183
184     // This is a weak reference cache for knowing if Nodes used by TextMarkers are valid.
185     void setNodeInUse(Node* n) { m_textMarkerNodes.add(n); }
186     void removeNodeForUse(Node* n) { m_textMarkerNodes.remove(n); }
187     bool isNodeInUse(Node* n) { return m_textMarkerNodes.contains(n); }
188
189 private:
190     Document* m_document;
191     HashMap<AXID, RefPtr<AccessibilityObject> > m_objects;
192     HashMap<RenderObject*, AXID> m_renderObjectMapping;
193     HashMap<Widget*, AXID> m_widgetObjectMapping;
194     HashMap<Node*, AXID> m_nodeObjectMapping;
195     HashSet<Node*> m_textMarkerNodes;
196     static bool gAccessibilityEnabled;
197     static bool gAccessibilityEnhancedUserInterfaceEnabled;
198     
199     HashSet<AXID> m_idsInUse;
200     
201     Timer<AXObjectCache> m_notificationPostTimer;
202     Vector<pair<RefPtr<AccessibilityObject>, AXNotification> > m_notificationsToPost;
203     void notificationPostTimerFired(Timer<AXObjectCache>*);
204     
205     static AccessibilityObject* focusedImageMapUIElement(HTMLAreaElement*);
206     
207     AXID getAXID(AccessibilityObject*);
208 };
209
210 bool nodeHasRole(Node*, const String& role);
211 // This will let you know if aria-hidden was explicitly set to false.
212 bool isNodeAriaVisible(Node*);
213     
214 #if !HAVE(ACCESSIBILITY)
215 inline AXObjectCache::AXObjectCache(const Document* doc) : m_document(const_cast<Document*>(doc)), m_notificationPostTimer(this, 0) { }
216 inline AXObjectCache::~AXObjectCache() { }
217 inline AccessibilityObject* AXObjectCache::focusedUIElementForPage(const Page*) { return 0; }
218 inline AccessibilityObject* AXObjectCache::get(RenderObject*) { return 0; }
219 inline AccessibilityObject* AXObjectCache::get(Node*) { return 0; }
220 inline AccessibilityObject* AXObjectCache::get(Widget*) { return 0; }
221 inline AccessibilityObject* AXObjectCache::getOrCreate(AccessibilityRole) { return 0; }
222 inline AccessibilityObject* AXObjectCache::getOrCreate(RenderObject*) { return 0; }
223 inline AccessibilityObject* AXObjectCache::getOrCreate(Node*) { return 0; }
224 inline AccessibilityObject* AXObjectCache::getOrCreate(Widget*) { return 0; }
225 inline AccessibilityObject* AXObjectCache::rootObject() { return 0; }
226 inline AccessibilityObject* AXObjectCache::rootObjectForFrame(Frame*) { return 0; }
227 inline Element* AXObjectCache::rootAXEditableElement(Node*) { return 0; }
228 inline bool nodeHasRole(Node*, const String&) { return false; }
229 inline bool isNodeAriaVisible(Node*) { return true; }
230 inline const Element* AXObjectCache::rootAXEditableElement(const Node*) { return 0; }
231 inline void AXObjectCache::attachWrapper(AccessibilityObject*) { }
232 inline void AXObjectCache::checkedStateChanged(Node*) { }
233 inline void AXObjectCache::childrenChanged(RenderObject*) { }
234 inline void AXObjectCache::childrenChanged(Node*) { }
235 inline void AXObjectCache::contentChanged(RenderObject*) { }
236 inline void AXObjectCache::contentChanged(Node*) { }
237 inline void AXObjectCache::updateCacheAfterNodeIsAttached(Node*) { }
238 inline void AXObjectCache::detachWrapper(AccessibilityObject*) { }
239 inline void AXObjectCache::frameLoadingEventNotification(Frame*, AXLoadingEvent) { }
240 inline void AXObjectCache::frameLoadingEventPlatformNotification(AccessibilityObject*, AXLoadingEvent) { }
241 inline void AXObjectCache::handleActiveDescendantChanged(Node*) { }
242 inline void AXObjectCache::handleAriaExpandedChange(Node*) { }
243 inline void AXObjectCache::handleAriaRoleChanged(Node*) { }
244 inline void AXObjectCache::handleFocusedUIElementChanged(Node*, Node*) { }
245 inline void AXObjectCache::handleScrollbarUpdate(ScrollView*) { }
246 inline void AXObjectCache::handleScrolledToAnchor(const Node*) { }
247 inline void AXObjectCache::nodeTextChangeNotification(Node*, AXTextChange, unsigned, const String&) { }
248 inline void AXObjectCache::nodeTextChangePlatformNotification(AccessibilityObject*, AXTextChange, unsigned, const String&) { }
249 inline void AXObjectCache::postNotification(AccessibilityObject*, Document*, AXNotification, bool, PostType) { }
250 inline void AXObjectCache::postNotification(RenderObject*, AXNotification, bool, PostType) { }
251 inline void AXObjectCache::postNotification(Node*, AXNotification, bool, PostType) { }
252 inline void AXObjectCache::postPlatformNotification(AccessibilityObject*, AXNotification) { }
253 inline void AXObjectCache::remove(AXID) { }
254 inline void AXObjectCache::remove(RenderObject*) { }
255 inline void AXObjectCache::remove(Node*) { }
256 inline void AXObjectCache::remove(Widget*) { }
257 inline void AXObjectCache::selectedChildrenChanged(RenderObject*) { }
258 inline void AXObjectCache::selectedChildrenChanged(Node*) { }
259 #endif
260
261 }
262
263 #endif