Source/WebCore: AccessibilityController should support listening to notifications...
[WebKit-https.git] / Tools / DumpRenderTree / win / AccessibilityControllerWin.cpp
1 /*
2  * Copyright (C) 2008, 2009, 2010 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 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 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 #include "config.h"
27 #include "AccessibilityController.h"
28
29 #include "AccessibilityUIElement.h"
30 #include "DumpRenderTree.h"
31 #include "FrameLoadDelegate.h"
32 #include <JavaScriptCore/Assertions.h>
33 #include <JavaScriptCore/JSRetainPtr.h>
34 #include <JavaScriptCore/JSStringRef.h>
35 #include <WebCore/COMPtr.h>
36 #include <WebKit/WebKit.h>
37 #include <oleacc.h>
38 #include <string>
39
40 using namespace std;
41
42 AccessibilityController::AccessibilityController()
43     : m_focusEventHook(0)
44     , m_scrollingStartEventHook(0)
45     , m_valueChangeEventHook(0)
46     , m_allEventsHook(0)
47     , m_notificationsEventHook(0)
48 {
49 }
50
51 AccessibilityController::~AccessibilityController()
52 {
53     setLogFocusEvents(false);
54     setLogAccessibilityEvents(false);
55     setLogValueChangeEvents(false);
56
57     if (m_notificationsEventHook)
58         UnhookWinEvent(m_notificationsEventHook);
59
60     for (HashMap<PlatformUIElement, JSObjectRef>::iterator it = m_notificationListeners.begin(); it != m_notificationListeners.end(); ++it)
61         JSValueUnprotect(frame->globalContext(), it->second);
62 }
63
64 AccessibilityUIElement AccessibilityController::elementAtPoint(int x, int y)
65 {
66     // FIXME: implement
67     return 0;
68 }
69
70 AccessibilityUIElement AccessibilityController::focusedElement()
71 {
72     COMPtr<IAccessible> rootAccessible = rootElement().platformUIElement();
73
74     VARIANT vFocus;
75     if (FAILED(rootAccessible->get_accFocus(&vFocus)))
76         return 0;
77
78     if (V_VT(&vFocus) == VT_I4) {
79         ASSERT(V_I4(&vFocus) == CHILDID_SELF);
80         // The root accessible object is the focused object.
81         return rootAccessible;
82     }
83
84     ASSERT(V_VT(&vFocus) == VT_DISPATCH);
85     // We have an IDispatch; query for IAccessible.
86     return COMPtr<IAccessible>(Query, V_DISPATCH(&vFocus));
87 }
88
89 AccessibilityUIElement AccessibilityController::rootElement()
90 {
91     COMPtr<IWebView> view;
92     if (FAILED(frame->webView(&view)))
93         return 0;
94
95     COMPtr<IWebViewPrivate> viewPrivate(Query, view);
96     if (!viewPrivate)
97         return 0;
98
99     HWND webViewWindow;
100     if (FAILED(viewPrivate->viewWindow((OLE_HANDLE*)&webViewWindow)))
101         return 0;
102
103     // Get the root accessible object by querying for the accessible object for the
104     // WebView's window.
105     COMPtr<IAccessible> rootAccessible;
106     if (FAILED(AccessibleObjectFromWindow(webViewWindow, static_cast<DWORD>(OBJID_CLIENT), __uuidof(IAccessible), reinterpret_cast<void**>(&rootAccessible))))
107         return 0;
108
109     return rootAccessible;
110 }
111
112 static void CALLBACK logEventProc(HWINEVENTHOOK, DWORD event, HWND hwnd, LONG idObject, LONG idChild, DWORD, DWORD)
113 {
114     // Get the accessible object for this event.
115     COMPtr<IAccessible> parentObject;
116
117     VARIANT vChild;
118     VariantInit(&vChild);
119
120     HRESULT hr = AccessibleObjectFromEvent(hwnd, idObject, idChild, &parentObject, &vChild);
121     ASSERT(SUCCEEDED(hr));
122
123     // Get the name of the focused element, and log it to stdout.
124     BSTR nameBSTR;
125     hr = parentObject->get_accName(vChild, &nameBSTR);
126     ASSERT(SUCCEEDED(hr));
127     wstring name(nameBSTR, ::SysStringLen(nameBSTR));
128     SysFreeString(nameBSTR);
129
130     switch (event) {
131         case EVENT_OBJECT_FOCUS:
132             printf("Received focus event for object '%S'.\n", name.c_str());
133             break;
134
135         case EVENT_OBJECT_SELECTION:
136             printf("Received selection event for object '%S'.\n", name.c_str());
137             break;
138
139         case EVENT_OBJECT_VALUECHANGE: {
140             BSTR valueBSTR;
141             hr = parentObject->get_accValue(vChild, &valueBSTR);
142             ASSERT(SUCCEEDED(hr));
143             wstring value(valueBSTR, ::SysStringLen(valueBSTR));
144             SysFreeString(valueBSTR);
145
146             printf("Received value change event for object '%S', value '%S'.\n", name.c_str(), value.c_str());
147             break;
148         }
149
150         case EVENT_SYSTEM_SCROLLINGSTART:
151             printf("Received scrolling start event for object '%S'.\n", name.c_str());
152             break;
153
154         default:
155             printf("Received unknown event for object '%S'.\n", name.c_str());
156             break;
157     }
158
159     VariantClear(&vChild);
160 }
161
162 void AccessibilityController::setLogFocusEvents(bool logFocusEvents)
163 {
164     if (!!m_focusEventHook == logFocusEvents)
165         return;
166
167     if (!logFocusEvents) {
168         UnhookWinEvent(m_focusEventHook);
169         m_focusEventHook = 0;
170         return;
171     }
172
173     // Ensure that accessibility is initialized for the WebView by querying for
174     // the root accessible object.
175     rootElement();
176
177     m_focusEventHook = SetWinEventHook(EVENT_OBJECT_FOCUS, EVENT_OBJECT_FOCUS, GetModuleHandle(0), logEventProc, GetCurrentProcessId(), 0, WINEVENT_INCONTEXT);
178
179     ASSERT(m_focusEventHook);
180 }
181
182 void AccessibilityController::setLogValueChangeEvents(bool logValueChangeEvents)
183 {
184     if (!!m_valueChangeEventHook == logValueChangeEvents)
185         return;
186
187     if (!logValueChangeEvents) {
188         UnhookWinEvent(m_valueChangeEventHook);
189         m_valueChangeEventHook = 0;
190         return;
191     }
192
193     // Ensure that accessibility is initialized for the WebView by querying for
194     // the root accessible object.
195     rootElement();
196
197     m_valueChangeEventHook = SetWinEventHook(EVENT_OBJECT_VALUECHANGE, EVENT_OBJECT_VALUECHANGE, GetModuleHandle(0), logEventProc, GetCurrentProcessId(), 0, WINEVENT_INCONTEXT);
198
199     ASSERT(m_valueChangeEventHook);
200 }
201
202 void AccessibilityController::setLogScrollingStartEvents(bool logScrollingStartEvents)
203 {
204     if (!!m_scrollingStartEventHook == logScrollingStartEvents)
205         return;
206
207     if (!logScrollingStartEvents) {
208         UnhookWinEvent(m_scrollingStartEventHook);
209         m_scrollingStartEventHook = 0;
210         return;
211     }
212
213     // Ensure that accessibility is initialized for the WebView by querying for
214     // the root accessible object.
215     rootElement();
216
217     m_scrollingStartEventHook = SetWinEventHook(EVENT_SYSTEM_SCROLLINGSTART, EVENT_SYSTEM_SCROLLINGSTART, GetModuleHandle(0), logEventProc, GetCurrentProcessId(), 0, WINEVENT_INCONTEXT);
218
219     ASSERT(m_scrollingStartEventHook);
220 }
221
222 void AccessibilityController::setLogAccessibilityEvents(bool logAccessibilityEvents)
223 {
224     if (!!m_allEventsHook == logAccessibilityEvents)
225         return;
226
227     if (!logAccessibilityEvents) {
228         UnhookWinEvent(m_allEventsHook);
229         m_allEventsHook = 0;
230         return;
231     }
232
233     // Ensure that accessibility is initialized for the WebView by querying for
234     // the root accessible object.
235     rootElement();
236
237     m_allEventsHook = SetWinEventHook(EVENT_MIN, EVENT_MAX, GetModuleHandle(0), logEventProc, GetCurrentProcessId(), 0, WINEVENT_INCONTEXT);
238
239     ASSERT(m_allEventsHook);
240 }
241
242 static string stringEvent(DWORD event)
243 {
244     switch(event) {
245         case EVENT_OBJECT_VALUECHANGE:
246             return "value change event";
247         default:
248             return "unknown event";
249     }
250 }
251
252 static void CALLBACK notificationListenerProc(HWINEVENTHOOK, DWORD event, HWND hwnd, LONG idObject, LONG idChild, DWORD, DWORD)
253 {
254     // Get the accessible object for this event.
255     COMPtr<IAccessible> parentObject;
256
257     VARIANT vChild;
258     VariantInit(&vChild);
259
260     HRESULT hr = AccessibleObjectFromEvent(hwnd, idObject, idChild, &parentObject, &vChild);
261     if (FAILED(hr) || !parentObject)
262         return;
263
264     COMPtr<IDispatch> childDispatch;
265     if (FAILED(parentObject->get_accChild(vChild, &childDispatch))) {
266         VariantClear(&vChild);
267         return;
268     }
269
270     COMPtr<IAccessible> childAccessible(Query, childDispatch);
271
272     sharedFrameLoadDelegate->accessibilityController()->winNotificationReceived(childAccessible, stringEvent(event));
273
274     VariantClear(&vChild);
275 }
276
277 static COMPtr<IAccessibleComparable> comparableObject(const COMPtr<IServiceProvider>& serviceProvider)
278 {
279     COMPtr<IAccessibleComparable> comparable;
280     serviceProvider->QueryService(SID_AccessibleComparable, __uuidof(IAccessibleComparable), reinterpret_cast<void**>(&comparable));
281     return comparable;
282 }
283
284 bool AccessibilityController::addNotificationListener(JSObjectRef functionCallback)
285 {
286     return false;
287 }
288
289 void AccessibilityController::removeNotificationListener()
290 {
291 }
292
293 void AccessibilityController::winNotificationReceived(PlatformUIElement element, const string& eventName)
294 {
295     for (HashMap<PlatformUIElement, JSObjectRef>::iterator it = m_notificationListeners.begin(); it != m_notificationListeners.end(); ++it) {
296         COMPtr<IServiceProvider> thisServiceProvider(Query, it->first);
297         if (!thisServiceProvider)
298             continue;
299
300         COMPtr<IAccessibleComparable> thisComparable = comparableObject(thisServiceProvider);
301         if (!thisComparable)
302             continue;
303
304         COMPtr<IServiceProvider> elementServiceProvider(Query, element);
305         if (!elementServiceProvider)
306             continue;
307
308         COMPtr<IAccessibleComparable> elementComparable = comparableObject(elementServiceProvider);
309         if (!elementComparable)
310             continue;
311
312         BOOL isSame = FALSE;
313         thisComparable->isSameObject(elementComparable.get(), &isSame);
314         if (!isSame)
315             continue;
316
317         JSRetainPtr<JSStringRef> jsNotification(Adopt, JSStringCreateWithUTF8CString(eventName.c_str()));
318         JSValueRef argument = JSValueMakeString(frame->globalContext(), jsNotification.get());
319         JSObjectCallAsFunction(frame->globalContext(), it->second, NULL, 1, &argument, NULL);
320     }
321 }
322
323 void AccessibilityController::winAddNotificationListener(PlatformUIElement element, JSObjectRef functionCallback)
324 {
325     if (!m_notificationsEventHook)
326         m_notificationsEventHook = SetWinEventHook(EVENT_MIN, EVENT_MAX, GetModuleHandle(0), notificationListenerProc, GetCurrentProcessId(), 0, WINEVENT_INCONTEXT);
327
328     JSValueProtect(frame->globalContext(), functionCallback);
329     m_notificationListeners.add(element, functionCallback);
330 }