//============================================================================= // // msaa.h -- Stub module that fakes Microsoft Active Accessibility APIs on // Win32 OSes without them. // // By using this header your code will be able to run on systems that do not // have updated versions of USER and GDI with Active Accessibility support, and // that do not have OLEACC.DLL installed. In those cases, you will get back // reasonable error codes for the following functions: // USER!BlockInput // USER!GetGUIThreadInfo // USER!GetWindowModuleFileName // USER!NotifyWinEvent // USER!SendInput // USER!SetWinEventHook // USER!UnhookWinEvent // // USER!GetCursorInfo // USER!GetWindowInfo // USER!GetTitleBarInfo // USER!GetScrollBarInfo // USER!GetComboBoxInfo // USER!GetAncestor // USER!RealChildWindowFromPoint // USER!RealGetWindowClass // USER!GetAltTabInfo // USER!GetListBoxInfo // USER!GetMenuBarInfo // // OLEACC!AccessibleChildren // OLEACC!AccessibleObjectFromEvent // OLEACC!AccessibleObjectFromPoint // OLEACC!AccessibleObjectFromWindow // OLEACC!CreateStdAccessibleObject // OLEACC!GetRoleText // OLEACC!GetStateText // OLEACC!LresultFromObject // OLEACC!ObjectFromLresult // OLEACC!WindowFromAccessibleObject // // Exactly one source must include this with COMPILE_MSAA_STUBS defined. // // Copyright (c) 1985-1997, Microsoft Corporation // //============================================================================= #ifdef __cplusplus extern "C" { // Assume C declarations for C++ #endif // __cplusplus // // If we are building with Win95/NT4 headers, we need to declare // the msaa-related constants and APIs ourselves. We can do that // by including the files that come with the MSAA SDK. // #ifndef NO_WINABLE #ifndef INPUT #include // support for new USER API's (WinEvents,GetGuiThreadInfo,SendInput, etc.) #endif // INPUT not defined #endif // NO_WINABLE not defined #ifdef COMPILE_MSAA_STUBS #include #endif #ifndef NO_OLEACC #ifndef ROLE_SYSTEM_TITLEBAR #include // support for IAccessible interface #endif // ROLE_SYSTEM_TITLEBAR not defined #endif // NO_OLEACC not defined // UnDefine these names so we can re-define them below. #undef BlockInput #undef GetGUIThreadInfo #undef GetWindowModuleFileName #undef NotifyWinEvent #undef SendInput #undef SetWinEventHook #undef UnhookWinEvent #undef GetCursorInfo #undef GetWindowInfo #undef GetTitleBarInfo #undef GetScrollBarInfo #undef GetComboBoxInfo #undef GetAncestor #undef RealChildWindowFromPoint #undef RealGetWindowClass #undef GetAltTabInfo #undef GetListBoxInfo #undef GetMenuBarInfo #undef AccessibleChildren #undef AccessibleObjectFromEvent #undef AccessibleObjectFromPoint #undef AccessibleObjectFromWindow #undef CreateStdAccessibleObject #undef GetRoleText #undef GetStateText #undef LresultFromObject #undef ObjectFromLresult #undef WindowFromAccessibleObject // // Define COMPILE_MSAA_STUBS to compile the stubs; // otherwise, you get the declarations. // #ifdef COMPILE_MSAA_STUBS //----------------------------------------------------------------------------- // // Implement the API stubs. // //----------------------------------------------------------------------------- #ifndef MSAA_FNS_DEFINED // USER BOOL (WINAPI* g_pfnBlockInput)(BOOL) = NULL; BOOL (WINAPI* g_pfnGetGUIThreadInfo)(DWORD,PGUITHREADINFO) = NULL; UINT (WINAPI* g_pfnGetWindowModuleFileName)(HWND,LPTSTR,UINT) = NULL; void (WINAPI* g_pfnNotifyWinEvent)(DWORD,HWND,LONG,LONG) = NULL; UINT (WINAPI* g_pfnSendInput)(UINT,LPINPUT,INT) = NULL; HWINEVENTHOOK (WINAPI* g_pfnSetWinEventHook)(UINT,UINT,HMODULE,WINEVENTPROC,DWORD,DWORD,UINT) = NULL; BOOL (WINAPI* g_pfnUnhookWinEvent)(HWINEVENTHOOK) = NULL; BOOL (WINAPI *g_pfnGetCursorInfo)(LPCURSORINFO) = NULL; BOOL (WINAPI *g_pfnGetWindowInfo)(HWND, LPWINDOWINFO) = NULL; BOOL (WINAPI *g_pfnGetTitleBarInfo)(HWND, LPTITLEBARINFO) = NULL; BOOL (WINAPI *g_pfnGetScrollBarInfo)(HWND, LONG, LPSCROLLBARINFO) = NULL; BOOL (WINAPI *g_pfnGetComboBoxInfo)(HWND, LPCOMBOBOXINFO) = NULL; HWND (WINAPI *g_pfnGetAncestor)(HWND, UINT) = NULL; HWND (WINAPI *g_pfnRealChildWindowFromPoint)(HWND, POINT) = NULL; UINT (WINAPI *g_pfnRealGetWindowClass)(HWND, LPTSTR, UINT) = NULL; BOOL (WINAPI *g_pfnGetAltTabInfo)(HWND, int, LPALTTABINFO, LPTSTR, UINT) = NULL; DWORD (WINAPI* g_pfnGetListBoxInfo)(HWND) = NULL; BOOL (WINAPI *g_pfnGetMenuBarInfo)(HWND, LONG, LONG, LPMENUBARINFO) = NULL; // OLEACC HRESULT (WINAPI* g_pfnAccessibleChildren)(IAccessible*,LONG,LONG,VARIANT*,LONG*) = NULL; HRESULT (WINAPI* g_pfnAccessibleObjectFromEvent)(HWND,DWORD,DWORD,IAccessible**,VARIANT*) = NULL; HRESULT (WINAPI* g_pfnAccessibleObjectFromPoint)(POINT,IAccessible**,VARIANT*) = NULL; HRESULT (WINAPI* g_pfnAccessibleObjectFromWindow)(HWND,DWORD,REFIID,void **) = NULL; HRESULT (WINAPI* g_pfnCreateStdAccessibleObject)(HWND,LONG,REFIID,void **) = NULL; UINT (WINAPI* g_pfnGetRoleText)(DWORD,LPTSTR,UINT) = NULL; UINT (WINAPI* g_pfnGetStateText)(DWORD,LPTSTR,UINT) = NULL; LRESULT (WINAPI* g_pfnLresultFromObject)(REFIID,WPARAM,LPUNKNOWN) = NULL; HRESULT (WINAPI* g_pfnObjectFromLresult)(LRESULT,REFIID,WPARAM,void**) = NULL; HRESULT (WINAPI* g_pfnWindowFromAccessibleObject)(IAccessible*,HWND*) = NULL; // STATUS BOOL g_fMSAAInitDone = FALSE; #endif //----------------------------------------------------------------------------- // This is the function that checks that all the required API's exist, and // then allows apps that include this file to call the real functions if they // exist, or the 'stubs' if they do not. This function is only called by the // stub functions - client code never needs to call this. //----------------------------------------------------------------------------- BOOL InitMSAAStubs(void) { HMODULE hUser32; HMODULE hOleacc; if (g_fMSAAInitDone) { return g_pfnBlockInput != NULL; } hOleacc = GetModuleHandle(TEXT("OLEACC.DLL")); if (!hOleacc) hOleacc = LoadLibrary(TEXT("OLEACC.DLL")); if ((hUser32 = GetModuleHandle(TEXT("USER32"))) && (*(FARPROC*)&g_pfnBlockInput = GetProcAddress(hUser32,"BlockInput")) && (*(FARPROC*)&g_pfnGetGUIThreadInfo = GetProcAddress(hUser32,"GetGUIThreadInfo")) && (*(FARPROC*)&g_pfnNotifyWinEvent = GetProcAddress(hUser32,"NotifyWinEvent")) && (*(FARPROC*)&g_pfnSendInput = GetProcAddress(hUser32,"SendInput")) && (*(FARPROC*)&g_pfnSetWinEventHook = GetProcAddress(hUser32,"SetWinEventHook")) && (*(FARPROC*)&g_pfnUnhookWinEvent = GetProcAddress(hUser32,"UnhookWinEvent")) && (*(FARPROC*)&g_pfnGetCursorInfo = GetProcAddress(hUser32,"GetCursorInfo")) && (*(FARPROC*)&g_pfnGetWindowInfo = GetProcAddress(hUser32,"GetWindowInfo")) && (*(FARPROC*)&g_pfnGetTitleBarInfo = GetProcAddress(hUser32,"GetTitleBarInfo")) && (*(FARPROC*)&g_pfnGetScrollBarInfo = GetProcAddress(hUser32,"GetScrollBarInfo")) && (*(FARPROC*)&g_pfnGetComboBoxInfo = GetProcAddress(hUser32,"GetComboBoxInfo")) && (*(FARPROC*)&g_pfnGetAncestor = GetProcAddress(hUser32,"GetAncestor")) && (*(FARPROC*)&g_pfnRealChildWindowFromPoint = GetProcAddress(hUser32,"RealChildWindowFromPoint")) && (*(FARPROC*)&g_pfnGetListBoxInfo = GetProcAddress(hUser32,"GetListBoxInfo")) && (*(FARPROC*)&g_pfnGetMenuBarInfo = GetProcAddress(hUser32,"GetMenuBarInfo")) && #ifdef UNICODE (*(FARPROC*)&g_pfnGetWindowModuleFileName = GetProcAddress(hUser32,"GetWindowModuleFileNameW")) && (*(FARPROC*)&g_pfnRealGetWindowClass = GetProcAddress(hUser32,"RealGetWindowClassW")) && (*(FARPROC*)&g_pfnGetAltTabInfo = GetProcAddress(hUser32,"GetAltTabInfoW")) && #else (*(FARPROC*)&g_pfnGetWindowModuleFileName = GetProcAddress(hUser32,"GetWindowModuleFileNameA")) && (*(FARPROC*)&g_pfnRealGetWindowClass = GetProcAddress(hUser32,"RealGetWindowClass")) && (*(FARPROC*)&g_pfnGetAltTabInfo = GetProcAddress(hUser32,"GetAltTabInfo")) && #endif (hOleacc) && #ifdef UNICODE (*(FARPROC*)&g_pfnGetRoleText = GetProcAddress(hOleacc,"GetRoleTextW")) && (*(FARPROC*)&g_pfnGetStateText = GetProcAddress(hOleacc,"GetStateTextW")) && #else (*(FARPROC*)&g_pfnGetRoleText = GetProcAddress(hOleacc,"GetRoleTextA")) && (*(FARPROC*)&g_pfnGetStateText = GetProcAddress(hOleacc,"GetStateTextA")) && #endif (*(FARPROC*)&g_pfnAccessibleChildren = GetProcAddress(hOleacc,"AccessibleChildren")) && (*(FARPROC*)&g_pfnAccessibleObjectFromEvent = GetProcAddress(hOleacc,"AccessibleObjectFromEvent")) && (*(FARPROC*)&g_pfnAccessibleObjectFromPoint = GetProcAddress(hOleacc,"AccessibleObjectFromPoint")) && (*(FARPROC*)&g_pfnAccessibleObjectFromWindow = GetProcAddress(hOleacc,"AccessibleObjectFromWindow")) && (*(FARPROC*)&g_pfnCreateStdAccessibleObject = GetProcAddress(hOleacc,"CreateStdAccessibleObject")) && (*(FARPROC*)&g_pfnLresultFromObject = GetProcAddress(hOleacc,"LresultFromObject")) && (*(FARPROC*)&g_pfnObjectFromLresult = GetProcAddress(hOleacc,"ObjectFromLresult")) && (*(FARPROC*)&g_pfnWindowFromAccessibleObject = GetProcAddress(hOleacc,"WindowFromAccessibleObject")) ) { g_fMSAAInitDone = TRUE; return TRUE; } else { g_pfnBlockInput = NULL; g_pfnGetGUIThreadInfo = NULL; g_pfnGetWindowModuleFileName = NULL; g_pfnNotifyWinEvent = NULL; g_pfnSendInput = NULL; g_pfnSetWinEventHook = NULL; g_pfnUnhookWinEvent = NULL; g_pfnGetCursorInfo = NULL; g_pfnGetWindowInfo = NULL; g_pfnGetTitleBarInfo = NULL; g_pfnGetScrollBarInfo = NULL; g_pfnGetComboBoxInfo = NULL; g_pfnGetAncestor = NULL; g_pfnRealChildWindowFromPoint = NULL; g_pfnRealGetWindowClass = NULL; g_pfnGetAltTabInfo = NULL; g_pfnGetListBoxInfo = NULL; g_pfnGetMenuBarInfo = NULL; g_pfnAccessibleChildren = NULL; g_pfnAccessibleObjectFromEvent = NULL; g_pfnAccessibleObjectFromPoint = NULL; g_pfnAccessibleObjectFromWindow = NULL; g_pfnCreateStdAccessibleObject = NULL; g_pfnGetRoleText = NULL; g_pfnGetStateText = NULL; g_pfnLresultFromObject = NULL; g_pfnObjectFromLresult = NULL; g_pfnWindowFromAccessibleObject = NULL; g_fMSAAInitDone = TRUE; return FALSE; } } //----------------------------------------------------------------------------- // // Fake implementations of MSAA APIs that return error codes. // No special parameter validation is made since these run in client code // //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- // Fake implementation of BlockInput. Always returns FALSE if API not present. //----------------------------------------------------------------------------- BOOL WINAPI xBlockInput (BOOL fBlock) { if (InitMSAAStubs()) return g_pfnBlockInput(fBlock); return FALSE; } //----------------------------------------------------------------------------- // Fake implementation of GetGUIThreadInfo. Returns FALSE if API not present. //----------------------------------------------------------------------------- BOOL WINAPI xGetGUIThreadInfo (DWORD idThread,PGUITHREADINFO lpGuiThreadInfo) { if (InitMSAAStubs()) return g_pfnGetGUIThreadInfo(idThread,lpGuiThreadInfo); lpGuiThreadInfo->flags = 0; lpGuiThreadInfo->hwndActive = NULL; lpGuiThreadInfo->hwndFocus = NULL; lpGuiThreadInfo->hwndCapture = NULL; lpGuiThreadInfo->hwndMenuOwner = NULL; lpGuiThreadInfo->hwndMoveSize = NULL; lpGuiThreadInfo->hwndCaret = NULL; return FALSE; } //----------------------------------------------------------------------------- // Fake implementation of GetWindowModuleFileName. //----------------------------------------------------------------------------- UINT WINAPI xGetWindowModuleFileName (HWND hWnd,LPTSTR lpszFileName,UINT cchFileNameMax) { if (InitMSAAStubs()) return g_pfnGetWindowModuleFileName(hWnd,lpszFileName,cchFileNameMax); return 0; } //----------------------------------------------------------------------------- // Fake implementation of NotifyWinEvent //----------------------------------------------------------------------------- void xNotifyWinEvent (DWORD dwEvent,HWND hWnd,LONG idObject,LONG idChild) { if (InitMSAAStubs()) g_pfnNotifyWinEvent(dwEvent,hWnd,idObject,idChild); return; } //----------------------------------------------------------------------------- // Fake implementation of SendInput. Always returns 0 if API not present. //----------------------------------------------------------------------------- UINT WINAPI xSendInput (UINT cInputs,LPINPUT lpInput,INT cbSize) { if (InitMSAAStubs()) return g_pfnSendInput (cInputs,lpInput,cbSize); return 0; } //----------------------------------------------------------------------------- // Fake implementation of SetWinEventHook. Returns NULL if API not present. //----------------------------------------------------------------------------- HWINEVENTHOOK WINAPI xSetWinEventHook (UINT eventMin,UINT eventMax, HMODULE hModWinEventHook, WINEVENTPROC lpfnWinEventProc, DWORD idProcess,DWORD idThread, UINT dwFlags) { if (InitMSAAStubs()) return g_pfnSetWinEventHook (eventMin,eventMax,hModWinEventHook, lpfnWinEventProc,idProcess,idThread,dwFlags); return NULL; } //----------------------------------------------------------------------------- // Fake implementation of UnhookWinEvent. Returns FALSE if API not present. //----------------------------------------------------------------------------- BOOL WINAPI xUnhookWinEvent (HWINEVENTHOOK hWinEventHook) { if (InitMSAAStubs()) return g_pfnUnhookWinEvent (hWinEventHook); return FALSE; } //----------------------------------------------------------------------------- // Fake implementation of GetCursorInfo. Returns FALSE if API not present. //----------------------------------------------------------------------------- BOOL WINAPI xGetCursorInfo(LPCURSORINFO lpCursorInfo) { if (InitMSAAStubs()) return g_pfnGetCursorInfo(lpCursorInfo); return FALSE; } //----------------------------------------------------------------------------- // Fake implementation of GetWindowInfo. Returns TRUE if API not present, but // not all the fields are correctly filled in. //----------------------------------------------------------------------------- BOOL WINAPI xGetWindowInfo(HWND hwnd, LPWINDOWINFO lpwi) { if (InitMSAAStubs()) return g_pfnGetWindowInfo(hwnd,lpwi); // this is an incomplete implementation of GetWindowInfo GetWindowRect(hwnd,&lpwi->rcWindow); GetClientRect(hwnd,&lpwi->rcClient); lpwi->dwStyle = GetWindowLong (hwnd,GWL_STYLE); lpwi->dwExStyle = GetWindowLong (hwnd,GWL_EXSTYLE); lpwi->dwWindowsState = 0; // should have WS_ACTIVECAPTION in here if active lpwi->cxWindowBorders = 0; // wrong lpwi->cyWindowBorders = 0; // wrong lpwi->atomWindowType = 0; // wrong lpwi->wCreatorVersion = 0; // wrong return TRUE; } //----------------------------------------------------------------------------- // Fake implementation of GetTitleBarInfo. Returns FALSE if API not present. //----------------------------------------------------------------------------- BOOL WINAPI xGetTitleBarInfo(HWND hwnd, LPTITLEBARINFO lpTitleBarInfo) { if (InitMSAAStubs()) return g_pfnGetTitleBarInfo(hwnd,lpTitleBarInfo); return FALSE; } //----------------------------------------------------------------------------- // Fake implementation of GetScrollBarInfo. Returns FALSE if API not present. //----------------------------------------------------------------------------- BOOL WINAPI xGetScrollBarInfo(HWND hwnd, LONG idObject, LPSCROLLBARINFO lpScrollBarInfo) { if (InitMSAAStubs()) return g_pfnGetScrollBarInfo(hwnd,idObject,lpScrollBarInfo); return FALSE; } //----------------------------------------------------------------------------- // Fake implementation of GetComboBoxInfo. Returns if API not present. //----------------------------------------------------------------------------- BOOL WINAPI xGetComboBoxInfo(HWND hwnd, LPCOMBOBOXINFO lpComboBoxInfo) { if (InitMSAAStubs()) return g_pfnGetComboBoxInfo(hwnd,lpComboBoxInfo); return FALSE; } //----------------------------------------------------------------------------- // Fake implementation of GetAncestor. If API not present, this will try to // do what the real implementation does. //----------------------------------------------------------------------------- HWND WINAPI xGetAncestor(HWND hwnd, UINT gaFlags) { HWND hwndParent; HWND hwndDesktop; DWORD dwStyle; if (InitMSAAStubs()) return g_pfnGetAncestor(hwnd,gaFlags); // HERE IS THE FAKE IMPLEMENTATION if (!IsWindow(hwnd)) return(NULL); if ((gaFlags < GA_MIC) || (gaFlags > GA_MAC)) return(NULL); hwndDesktop = GetDesktopWindow(); if (hwnd == hwndDesktop) return(NULL); dwStyle = GetWindowLong (hwnd,GWL_STYLE); switch (gaFlags) { case GA_PARENT: if (dwStyle & WS_CHILD) hwndParent = GetParent(hwnd); else hwndParent = GetWindow (hwnd,GW_OWNER); if (hwndParent == NULL) hwndParent = hwnd; break; case GA_ROOT: if (dwStyle & WS_CHILD) hwndParent = GetParent(hwnd); else hwndParent = GetWindow (hwnd,GW_OWNER); while (hwndParent != hwndDesktop && hwndParent != NULL) { hwnd = hwndParent; dwStyle = GetWindowLong(hwnd,GWL_STYLE); if (dwStyle & WS_CHILD) hwndParent = GetParent(hwnd); else hwndParent = GetWindow (hwnd,GW_OWNER); } break; case GA_ROOTOWNER: while (hwndParent = GetParent(hwnd)) hwnd = hwndParent; break; } return(hwndParent); } //----------------------------------------------------------------------------- // Fake implementation of RealChildWindowFromPoint. Returns NULL if API not present. //----------------------------------------------------------------------------- HWND WINAPI xRealChildWindowFromPoint(HWND hwnd, POINT pt) { if (InitMSAAStubs()) return g_pfnRealChildWindowFromPoint(hwnd,pt); return (NULL); } //----------------------------------------------------------------------------- // Fake implementation of RealGetWindowClass. Returns regular ClassName if API // not present. //----------------------------------------------------------------------------- UINT WINAPI xRealGetWindowClass(HWND hwnd, LPTSTR lpszClass, UINT cchMax) { if (InitMSAAStubs()) return g_pfnRealGetWindowClass(hwnd,lpszClass,cchMax); #ifdef UNICODE return (GetClassNameW(hwnd,lpszClass,cchMax)); #else return (GetClassName(hwnd,lpszClass,cchMax)); #endif } //----------------------------------------------------------------------------- // Fake implementation of GetAltTabInfo. Returns FALSE if API not present. //----------------------------------------------------------------------------- BOOL WINAPI xGetAltTabInfo(HWND hwnd,int iItem,LPALTTABINFO lpati,LPTSTR lpszItemText,UINT cchItemText) { if (InitMSAAStubs()) return g_pfnGetAltTabInfo(hwnd,iItem,lpati,lpszItemText,cchItemText); return FALSE; } //----------------------------------------------------------------------------- // Fake implementation of GetListBoxInfo. Returns FALSE if API not present. //----------------------------------------------------------------------------- DWORD WINAPI xGetListBoxInfo(HWND hwnd) { if (InitMSAAStubs()) return g_pfnGetListBoxInfo(hwnd); return FALSE; } //----------------------------------------------------------------------------- // Fake implementation of GetMenuBarInfo. Returns FALSE if API not present. //----------------------------------------------------------------------------- BOOL WINAPI xGetMenuBarInfo(HWND hwnd, long idObject, long idItem, LPMENUBARINFO lpmbi) { if (InitMSAAStubs()) return g_pfnGetMenuBarInfo(hwnd,idObject,idItem,lpmbi); return FALSE; } //----------------------------------------------------------------------------- // Fake implementation of AccessibleChildren. Returns E_NOTIMPL if API not present. //----------------------------------------------------------------------------- HRESULT xAccessibleChildren (IAccessible* paccContainer,LONG iChildStart, LONG cChildren,VARIANT* rgvarChildren,LONG* pcObtained) { if (InitMSAAStubs()) return g_pfnAccessibleChildren (paccContainer,iChildStart,cChildren, rgvarChildren,pcObtained); return (E_NOTIMPL); } //----------------------------------------------------------------------------- // Fake implementation of AccessibleObjectFromEvent. Returns E_NOTIMPL if the // real API is not present. //----------------------------------------------------------------------------- HRESULT WINAPI xAccessibleObjectFromEvent (HWND hWnd,DWORD dwID,DWORD dwChild, IAccessible** ppacc,VARIANT*pvarChild) { if (InitMSAAStubs()) return g_pfnAccessibleObjectFromEvent (hWnd,dwID,dwChild,ppacc,pvarChild); return (E_NOTIMPL); } //----------------------------------------------------------------------------- // Fake implementation of AccessibleObjectFromPoint. Returns E_NOTIMPL if the // real API is not present. //----------------------------------------------------------------------------- HRESULT WINAPI xAccessibleObjectFromPoint (POINT ptScreen,IAccessible** ppacc, VARIANT* pvarChild) { if (InitMSAAStubs()) return g_pfnAccessibleObjectFromPoint (ptScreen,ppacc,pvarChild); return (E_NOTIMPL); } //----------------------------------------------------------------------------- // Fake implementation of AccessibleObjectFromWindow. Returns E_NOTIMPL if the // real API is not present. //----------------------------------------------------------------------------- HRESULT WINAPI xAccessibleObjectFromWindow (HWND hWnd,DWORD dwID,REFIID riidInterface, void ** ppvObject) { if (InitMSAAStubs()) return g_pfnAccessibleObjectFromWindow (hWnd,dwID,riidInterface,ppvObject); return (E_NOTIMPL); } //----------------------------------------------------------------------------- // Fake implementation of CreateStdAccessibleObject. Returns E_NOTIMPL if the // real API is not present. //----------------------------------------------------------------------------- HRESULT WINAPI xCreateStdAccessibleObject (HWND hWnd,LONG dwID,REFIID riidInterface, void ** ppvObject) { if (InitMSAAStubs()) return g_pfnCreateStdAccessibleObject (hWnd,dwID,riidInterface,ppvObject); return (E_NOTIMPL); } //----------------------------------------------------------------------------- // Fake implementation of GetRoleText. Returns 0 if real API not present. //----------------------------------------------------------------------------- UINT WINAPI xGetRoleText (DWORD dwRole,LPTSTR lpszRole,UINT cchRoleMax) { if (InitMSAAStubs()) return g_pfnGetRoleText (dwRole,lpszRole,cchRoleMax); return (0); } //----------------------------------------------------------------------------- // Fake implementation of GetStateText. Returns 0 if real API not present. //----------------------------------------------------------------------------- UINT WINAPI xGetStateText (DWORD dwState,LPTSTR lpszState,UINT cchStateMax) { if (InitMSAAStubs()) return g_pfnGetStateText (dwState,lpszState,cchStateMax); return (0); } //----------------------------------------------------------------------------- // Fake implementation of LresultFromObject. Returns E_NOTIMPL if the real API // is not present. //----------------------------------------------------------------------------- LRESULT WINAPI xLresultFromObject (REFIID riidInterface,WPARAM wParam,LPUNKNOWN pUnk) { if (InitMSAAStubs()) return g_pfnLresultFromObject (riidInterface,wParam,pUnk); return (E_NOTIMPL); } //----------------------------------------------------------------------------- // Fake implementation of ObjectFromLresult. Returns E_NOTIMPL if the // real API is not present. //----------------------------------------------------------------------------- HRESULT WINAPI xObjectFromLresult (LRESULT lResult,REFIID riidInterface,WPARAM wParam, void** ppvObject) { if (InitMSAAStubs()) return g_pfnObjectFromLresult (lResult,riidInterface,wParam,ppvObject); return (E_NOTIMPL); } //----------------------------------------------------------------------------- // Fake implementation of WindowFromAccessibleObject. Returns E_NOTIMPL if the // real API is not present. //----------------------------------------------------------------------------- HRESULT WINAPI xWindowFromAccessibleObject (IAccessible* pAcc,HWND* phWnd) { if (InitMSAAStubs()) return g_pfnWindowFromAccessibleObject (pAcc,phWnd); return (E_NOTIMPL); } #undef COMPILE_MSAA_STUBS #else // COMPILE_MSAA_STUBS extern BOOL WINAPI xBlockInput (BOOL fBlock); extern BOOL WINAPI xGetGUIThreadInfo (DWORD idThread, PGUITHREADINFO lpGuiThreadInfo); extern UINT WINAPI xGetWindowModuleFileName (HWND hWnd, LPTSTR lpszFileName, UINT cchFileNameMax); extern void WINAPI xNotifyWinEvent (DWORD dwEvent, HWND hWnd, LONG idObject, LONG idChild); extern UINT WINAPI xSendInput (UINT cInputs, LPINPUT lpInput, INT cbSize); extern HWINEVENTHOOK WINAPI xSetWinEventHook (DWORD eventMin, DWORD eventMax, HMODULE hModWinEventHook, WINEVENTPROC lpfnWinEventProc, DWORD idProcess, DWORD idThread, DWORD dwFlags); extern BOOL WINAPI xUnhookWinEvent (HWINEVENTHOOK hWinEventHook); extern BOOL WINAPI xGetCursorInfo (LPCURSORINFO lpCursorInfo); extern BOOL WINAPI xGetWindowInfo (HWND hwnd, LPWINDOWINFO lpwi); extern BOOL WINAPI xGetTitleBarInfo (HWND hwnd, LPTITLEBARINFO lpTitleBarInfo); extern BOOL WINAPI xGetScrollBarInfo (HWND hwnd, LONG idObject, LPSCROLLBARINFO lpScrollBarInfo); extern BOOL WINAPI xGetComboBoxInfo (HWND hwnd, LPCOMBOBOXINFO lpComboBoxInfo); extern HWND WINAPI xGetAncestor (HWND hwnd, UINT gaFlags); extern HWND WINAPI xRealChildWindowFromPoint (HWND hwnd, POINT pt); extern UINT WINAPI xRealGetWindowClass (HWND hwnd, LPTSTR lpszClass, UINT cchMax); extern BOOL WINAPI xGetAltTabInfo (HWND hwnd, int iItem, LPALTTABINFO lpati, LPTSTR lpszItemText, UINT cchItemText); extern DWORD WINAPI xGetListBoxInfo (HWND hwnd); extern BOOL WINAPI xGetMenuBarInfo (HWND hwnd, long idObject, long idItem, LPMENUBARINFO lpmbi); extern HRESULT WINAPI xAccessibleChildren (IAccessible* paccContainer, LONG iChildStart, LONG cChildren, VARIANT* rgvarChildren, LONG* pcObtained); extern HRESULT WINAPI xAccessibleObjectFromEvent (HWND hWnd, DWORD dwID, DWORD dwChild, IAccessible** ppacc, VARIANT*pvarChild); extern HRESULT WINAPI xAccessibleObjectFromPoint (POINT ptScreen, IAccessible** ppacc, VARIANT* pvarChild); extern HRESULT WINAPI xAccessibleObjectFromWindow (HWND hWnd, DWORD dwID, REFIID riidInterface, void ** ppvObject); extern HRESULT WINAPI xCreateStdAccessibleObject (HWND hWnd, LONG dwID, REFIID riidInterface, void ** ppvObject); extern UINT WINAPI xGetRoleText (DWORD dwRole, LPTSTR lpszRole, UINT cchRoleMax); extern UINT WINAPI xGetStateText (DWORD dwState, LPTSTR lpszState, UINT cchStateMax); extern LRESULT WINAPI xLresultFromObject (REFIID riidInterface, WPARAM wParam, LPUNKNOWN pUnk); extern HRESULT WINAPI xObjectFromLresult (LRESULT lResult, REFIID riidInterface, WPARAM wParam, void** ppvObject); extern HRESULT WINAPI xWindowFromAccessibleObject (IAccessible* pAcc, HWND* phWnd); #endif // COMPILE_MSAA_STUBS // // build defines that replace the regular APIs with our versions // #define BlockInput xBlockInput #define GetGUIThreadInfo xGetGUIThreadInfo #define GetWindowModuleFileName xGetWindowModuleFileName #define NotifyWinEvent xNotifyWinEvent #define SendInput xSendInput #define SetWinEventHook xSetWinEventHook #define UnhookWinEvent xUnhookWinEvent #define GetCursorInfo xGetCursorInfo #define GetWindowInfo xGetWindowInfo #define GetTitleBarInfo xGetTitleBarInfo #define GetScrollBarInfo xGetScrollBarInfo #define GetComboBoxInfo xGetComboBoxInfo #define GetAncestor xGetAncestor #define RealChildWindowFromPoint xRealChildWindowFromPoint #define RealGetWindowClass xRealGetWindowClass #define GetAltTabInfo xGetAltTabInfo #define GetListBoxInfo xGetListBoxInfo #define GetMenuBarInfo xGetMenuBarInfo #define AccessibleChildren xAccessibleChildren #define AccessibleObjectFromEvent xAccessibleObjectFromEvent #define AccessibleObjectFromPoint xAccessibleObjectFromPoint #define AccessibleObjectFromWindow xAccessibleObjectFromWindow #define CreateStdAccessibleObject xCreateStdAccessibleObject #define GetRoleText xGetRoleText #define GetStateText xGetStateText #define LresultFromObject xLresultFromObject #define ObjectFromLresult xObjectFromLresult #define WindowFromAccessibleObject xWindowFromAccessibleObject #ifdef __cplusplus } #endif // __cplusplus