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()->notificationReceived(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 void AccessibilityController::notificationReceived(PlatformUIElement element, const string& eventName)
 285 {
 286     for (HashMap<PlatformUIElement, JSObjectRef>::iterator it = m_notificationListeners.begin(); it != m_notificationListeners.end(); ++it) {
 287         COMPtr<IServiceProvider> thisServiceProvider(Query, it->first);
 288         if (!thisServiceProvider)
 289             continue;
 290
 291         COMPtr<IAccessibleComparable> thisComparable = comparableObject(thisServiceProvider);
 292         if (!thisComparable)
 293             continue;
 294
 295         COMPtr<IServiceProvider> elementServiceProvider(Query, element);
 296         if (!elementServiceProvider)
 297             continue;
 298
 299         COMPtr<IAccessibleComparable> elementComparable = comparableObject(elementServiceProvider);
 300         if (!elementComparable)
 301             continue;
 302
 303         BOOL isSame = FALSE;
 304         thisComparable->isSameObject(elementComparable.get(), &isSame);
 305         if (!isSame)
 306             continue;
 307
 308         JSRetainPtr<JSStringRef> jsNotification(Adopt, JSStringCreateWithUTF8CString(eventName.c_str()));
 309         JSValueRef argument = JSValueMakeString(frame->globalContext(), jsNotification.get());
 310         JSObjectCallAsFunction(frame->globalContext(), it->second, NULL, 1, &argument, NULL);
 311     }
 312 }
 313
 314 void AccessibilityController::addNotificationListener(PlatformUIElement element, JSObjectRef functionCallback)
 315 {
 316     if (!m_notificationsEventHook)
 317         m_notificationsEventHook = SetWinEventHook(EVENT_MIN, EVENT_MAX, GetModuleHandle(0), notificationListenerProc, GetCurrentProcessId(), 0, WINEVENT_INCONTEXT);
 318
 319     JSValueProtect(frame->globalContext(), functionCallback);
 320     m_notificationListeners.add(element, functionCallback);
 321 }