| /* |
| * Copyright (c) 2005, 2015, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /* |
| * A sample Assistive Technology which queries the JavaVM to get the Java |
| * Accessibility information available for a Java UI object, using the Java |
| * Access Bridge. |
| */ |
| |
| #include <windows.h> // includes basic windows functionality |
| #include <jni.h> |
| |
| #include "jaccessinspectorResource.h" |
| #include "AccessBridgeCalls.h" |
| #include "AccessBridgeCallbacks.h" |
| |
| #include <stdio.h> |
| #include <time.h> |
| #include <string.h> |
| |
| #include "jaccessinspector.h" |
| #include "AccessInfo.h" |
| #include "MessageHistory.h" |
| |
| #define TIMER_ID 1 |
| #define DISPLAY_INFO_MESSAGE WM_USER+1 |
| #define DISPLAY_HWND_INFO_MESSAGE WM_USER+2 |
| |
| HWND theDialogWindow; |
| HWND theGoToDialogWindow; |
| HINSTANCE theInstance; |
| BOOL theAccessBridgeLoadedFlag; |
| |
| HHOOK prevKbdHook; |
| HHOOK prevMouseHook; |
| |
| BOOL updateMouse; |
| BOOL updateF1; |
| BOOL updateF2; |
| |
| BOOL trackMouse; |
| BOOL trackMouseExited; |
| BOOL trackMouseClicked; |
| BOOL trackMousePressed; |
| BOOL trackMouseReleased; |
| |
| BOOL trackFocus; |
| BOOL trackFocusLost; |
| BOOL trackCaret; |
| BOOL trackShutdown; |
| |
| BOOL trackMenuSelected; |
| BOOL trackMenuDeselected; |
| BOOL trackMenuCanceled; |
| |
| BOOL trackPopupVisible; |
| BOOL trackPopupInvisible; |
| BOOL trackPopupCanceled; |
| |
| //BOOL trackPropertyChange; |
| |
| BOOL trackPropertyNameChange; |
| BOOL trackPropertyDescriptionChange; |
| BOOL trackPropertyStateChange; |
| BOOL trackPropertyValueChange; |
| BOOL trackPropertySelectionChange; |
| BOOL trackPropertyTextChange; |
| BOOL trackPropertyCaretChange; |
| BOOL trackPropertyVisibleDataChange; |
| BOOL trackPropertyChildChange; |
| BOOL trackPropertyActiveDescendentChange; |
| BOOL trackPropertyTableModelChange; |
| |
| |
| FILE *logfile = NULL; |
| |
| MessageHistory g_MessageHistory; |
| |
| /** |
| * WinMain |
| * |
| */ |
| int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nShowCmd) { |
| MSG msg; |
| |
| g_LogStringCallback = AddToMessageHistory; |
| theInstance = hInst; |
| theDialogWindow = NULL; |
| theGoToDialogWindow = NULL; |
| |
| updateF1 = FALSE; |
| updateF2 = FALSE; |
| updateMouse = FALSE; |
| |
| theAccessBridgeLoadedFlag = FALSE; |
| |
| ReadActiveEventOptionsFromRegistry (); |
| |
| if (InitWindow(hInst)) { |
| if (initializeAccessBridge() == TRUE) { |
| theAccessBridgeLoadedFlag = TRUE; |
| ApplyEventOptions(theDialogWindow); |
| EnableMessageNavButtons(); |
| HACCEL hAccel = |
| ::LoadAccelerators (theInstance, MAKEINTRESOURCE(IDR_ACCELERATOR)); |
| |
| while (GetMessage(&msg, NULL, 0, 0)) { |
| if ( FALSE == TranslateAccelerator(theDialogWindow, hAccel, &msg) ) { |
| if ( ( ( NULL == theDialogWindow ) || |
| ( FALSE == IsDialogMessage(theDialogWindow, &msg) ) ) && |
| ( ( NULL == theGoToDialogWindow ) || |
| ( FALSE == IsDialogMessage(theGoToDialogWindow, &msg) ) ) ) { |
| TranslateMessage(&msg); |
| DispatchMessage(&msg); |
| } |
| } |
| } |
| if (theAccessBridgeLoadedFlag == TRUE) { |
| shutdownAccessBridge(); |
| } |
| SaveActiveEventOptionsToRegistry (); |
| } |
| } |
| return(0); |
| } |
| |
| char szAppName [] = "JACCESSINSPECTORWINDOW"; |
| |
| /** |
| * Real(tm) MS-Windows window initialization |
| * |
| */ |
| BOOL InitWindow (HANDLE hInstance) { |
| theDialogWindow = CreateDialog((struct HINSTANCE__ *)hInstance, |
| szAppName, |
| NULL, |
| jaccessinspectorDialogProc); |
| |
| // If window could not be created, return "failure". |
| if (!theDialogWindow) |
| return FALSE; |
| |
| if (logfile == null) { |
| logfile = fopen(JACCESSINSPECTOR_LOG, "w"); // overwrite existing log file |
| logString(logfile, "Starting jaccessinspector.exe %s\n", getTimeAndDate()); |
| } |
| |
| // Make the window visible, update its client area, & return "success". |
| SetWindowText(theDialogWindow, "jaccessinspector"); |
| ShowWindow(theDialogWindow, SW_SHOWNORMAL); |
| UpdateWindow(theDialogWindow); |
| |
| return TRUE; |
| } |
| |
| /** |
| * Display Accessible information about the object under the mouse |
| */ |
| void displayAccessibleInfo(long vmID, AccessibleContext ac, int x, int y) { |
| char buffer[HUGE_BUFSIZE]; |
| |
| getAccessibleInfo(vmID, ac, x, y, buffer, (int)(sizeof(buffer))); |
| displayAndLog(theDialogWindow, cjaccessinspectorText, logfile, (char *)buffer); |
| } |
| |
| /** |
| * Display Java event info |
| */ |
| void displayJavaEvent(long vmID, AccessibleContext ac, char *announcement) { |
| char buffer[HUGE_BUFSIZE]; |
| char *bufOffset; |
| |
| strncpy(buffer, announcement, sizeof(buffer)); |
| |
| bufOffset = (char *)(buffer + strlen(buffer)); |
| getAccessibleInfo( vmID, ac, -1, -1, bufOffset, |
| (int)(sizeof(buffer) - strlen(buffer)) ); |
| displayAndLog(theDialogWindow, cjaccessinspectorText, logfile, (char *)buffer); |
| } |
| |
| |
| /** |
| * Display Accessible propertyChange event info |
| */ |
| void displayAccessiblePropertyChange(long vmID, AccessibleContext ac, |
| char *announcement) { |
| char buffer[HUGE_BUFSIZE]; |
| char *bufOffset; |
| |
| strncpy(buffer, announcement, sizeof(buffer)); |
| |
| bufOffset = (char *) (buffer + strlen(buffer)); |
| getAccessibleInfo( vmID, ac, -1, -1, bufOffset, |
| (int)(sizeof(buffer) - strlen(buffer)) ); |
| displayAndLog(theDialogWindow, cjaccessinspectorText, logfile, (char *)buffer); |
| } |
| |
| |
| /** |
| * Update display under mouse when it moves |
| */ |
| void echoMouseObject() { |
| long vmID; |
| AccessibleContext acParent; |
| AccessibleContext ac; |
| POINT p; |
| HWND hwnd; |
| RECT windowRect; |
| |
| GetCursorPos(&p); |
| hwnd = WindowFromPoint(p); |
| if (GetAccessibleContextFromHWND(hwnd, &vmID, &acParent)) { |
| GetWindowRect(hwnd, &windowRect); |
| // send the point in global coordinates; Java will handle it! |
| if (GetAccessibleContextAt(vmID, acParent, (jint) p.x, (jint) p.y, &ac)) { |
| displayAccessibleInfo(vmID, ac, p.x, p.y); // can handle null |
| ReleaseJavaObject(vmID, ac); |
| } |
| } |
| } |
| |
| |
| /** |
| * Update display under HWND the mouse is in |
| */ |
| void echoMouseHWNDObject() { |
| long vmID; |
| AccessibleContext ac; |
| POINT p; |
| HWND hwnd; |
| |
| GetCursorPos(&p); |
| hwnd = WindowFromPoint(p); |
| |
| if (GetAccessibleContextFromHWND(hwnd, &vmID, &ac)) { |
| displayAccessibleInfo(vmID, ac, 0, 0); // can handle null |
| ReleaseJavaObject(vmID, ac); |
| } |
| } |
| |
| /** |
| * Display Accessible information about the object that has focus in |
| * the topmost Java HWND |
| * |
| */ |
| void displayFocusedObject() { |
| HWND hWnd; |
| long vmID; |
| AccessibleContext ac; |
| |
| hWnd = GetTopWindow(NULL); |
| while (hWnd != NULL) { |
| if (IsJavaWindow(hWnd)) { |
| if (GetAccessibleContextWithFocus(hWnd, &vmID, &ac) == TRUE) { |
| displayAccessibleInfo(vmID, ac, 0, 0); |
| ReleaseJavaObject(vmID, ac); |
| } |
| return; |
| } else { |
| hWnd = GetNextWindow(hWnd, GW_HWNDNEXT); |
| } |
| } |
| } |
| |
| /* |
| * Handle notification of the Java application shutting down |
| */ |
| void HandleJavaShutdown(long vmID) { |
| char s[1024]; |
| wsprintf(s, "Java VM 0x%X terminated\r\n\r\n", vmID); |
| |
| displayJavaEvent(vmID, null, s); // intentially passing null AccessibleContext |
| displayAndLog(theDialogWindow, cjaccessinspectorText, logfile, (char *)s); |
| } |
| |
| /** |
| * Handle a FocusGained event |
| */ |
| void HandleJavaFocusGained(long vmID, FocusEvent event, AccessibleContext ac) { |
| |
| char s[1024]; |
| wsprintf(s, "FocusGained\r\n\r\n"); |
| |
| if (ac != (AccessibleContext) 0) { |
| displayJavaEvent(vmID, ac, s); |
| } |
| |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a FocusLost event |
| */ |
| void HandleJavaFocusLost(long vmID, FocusEvent event, AccessibleContext ac) { |
| |
| // NOTE: calling GetAccessibleContextWithFocus() after a FocusLost event |
| // would result in a null AccessibleContext being returned, since |
| // at that point, no object has the focus. If the topmost window |
| // does not belong to a JavaVM, then no component within a JavaVM |
| // will have the focus (and again, GetAccessibleContextWithFocus() |
| // will return a null AccessibleContext). You should always get |
| // a FocusLost event when a window not belonging to a JavaVM becomes |
| // topmost. |
| |
| char s[1024]; |
| wsprintf(s, "FocusLost\r\n\r\n"); |
| |
| if (ac != (AccessibleContext) 0) { |
| displayJavaEvent(vmID, ac, s); |
| } |
| /* |
| if (ac != (AccessibleContext) 0) { |
| displayAccessibleInfo(vmID, ac, 0, 0); |
| } |
| */ |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a CaretUpdate event |
| */ |
| void HandleJavaCaretUpdate(long vmID, CaretEvent event, AccessibleContext ac) { |
| if (ac != (AccessibleContext) 0) { |
| displayAccessibleInfo(vmID, ac, 0, 0); |
| } |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a MouseClicked event |
| */ |
| void HandleMouseClicked(long vmID, MouseEvent event, AccessibleContext ac) { |
| if (ac != (AccessibleContext) 0) { |
| displayAccessibleInfo(vmID, ac, 0, 0); |
| } |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a MouseEntered event |
| */ |
| void HandleMouseEntered(long vmID, MouseEvent event, AccessibleContext ac) { |
| if (ac != (AccessibleContext) 0) { |
| displayAccessibleInfo(vmID, ac, 0, 0); |
| } |
| |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a MouseExited event |
| */ |
| void HandleMouseExited(long vmID, MouseEvent event, AccessibleContext ac) { |
| if (ac != (AccessibleContext) 0) { |
| displayAccessibleInfo(vmID, ac, 0, 0); |
| } |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a MousePressed event |
| */ |
| void HandleMousePressed(long vmID, MouseEvent event, AccessibleContext ac) { |
| if (ac != (AccessibleContext) 0) { |
| displayAccessibleInfo(vmID, ac, 0, 0); |
| } |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a MouseReleased event |
| */ |
| void HandleMouseReleased(long vmID, MouseEvent event, AccessibleContext ac) { |
| if (ac != (AccessibleContext) 0) { |
| displayAccessibleInfo(vmID, ac, 0, 0); |
| } |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a MenuCanceled event |
| */ |
| void HandleMenuCanceled(long vmID, MenuEvent event, AccessibleContext ac) { |
| if (ac != (AccessibleContext) 0) { |
| displayAccessibleInfo(vmID, ac, 0, 0); |
| } |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a MenuDeselected event |
| */ |
| void HandleMenuDeselected(long vmID, MenuEvent event, AccessibleContext ac) { |
| if (ac != (AccessibleContext) 0) { |
| displayAccessibleInfo(vmID, ac, 0, 0); |
| } |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a MenuSelected event |
| */ |
| void HandleMenuSelected(long vmID, MenuEvent event, AccessibleContext ac) { |
| if (ac != (AccessibleContext) 0) { |
| displayAccessibleInfo(vmID, ac, 0, 0); |
| } |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a PopupMenuCanceled event |
| */ |
| void HandlePopupMenuCanceled(long vmID, MenuEvent event, AccessibleContext ac) { |
| if (ac != (AccessibleContext) 0) { |
| displayAccessibleInfo(vmID, ac, 0, 0); |
| } |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a PopupMenuWillBecomeInvisible event |
| */ |
| void HandlePopupMenuWillBecomeInvisible(long vmID, MenuEvent event, AccessibleContext ac) { |
| if (ac != (AccessibleContext) 0) { |
| displayAccessibleInfo(vmID, ac, 0, 0); |
| } |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a PopupMenuWillBecomeVisible event |
| */ |
| void HandlePopupMenuWillBecomeVisible(long vmID, MenuEvent event, AccessibleContext ac) { |
| if (ac != (AccessibleContext) 0) { |
| displayAccessibleInfo(vmID, ac, 0, 0); |
| } |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| |
| |
| |
| /** |
| * Handle a HandlePropertyNameChange event |
| */ |
| void HandlePropertyNameChange(long vmID, PropertyChangeEvent event, AccessibleContext ac, |
| wchar_t *oldName, wchar_t *newName) { |
| char s[1024]; |
| wsprintf(s, "Name changed event: old = %ls; new = %ls\r\n\r\n", oldName, newName); |
| |
| if (ac != (AccessibleContext) 0) { |
| displayAccessiblePropertyChange(vmID, ac, s); |
| } |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a HandlePropertyDescriptionChange event |
| */ |
| void HandlePropertyDescriptionChange( long vmID, |
| PropertyChangeEvent event, |
| AccessibleContext ac, |
| wchar_t *oldDescription, |
| wchar_t *newDescription ) { |
| char s[1024]; |
| wsprintf( s, "Description changed event: old = %ls; new = %ls\r\n\r\n", |
| oldDescription, newDescription ); |
| |
| if (ac != (AccessibleContext) 0) { |
| displayAccessiblePropertyChange(vmID, ac, s); |
| } |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a HandlePropertyStateChange event |
| */ |
| void HandlePropertyStateChange( long vmID, PropertyChangeEvent event, |
| AccessibleContext ac, |
| wchar_t *oldState, wchar_t *newState ) { |
| char s[1024]; |
| wsprintf( s, "State changed event: old = %ls; new = %ls\r\n\r\n", |
| oldState, newState ); |
| |
| if (ac != (AccessibleContext) 0) { |
| displayAccessiblePropertyChange(vmID, ac, s); |
| } |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a HandlePropertyValueChange event |
| */ |
| void HandlePropertyValueChange( long vmID, PropertyChangeEvent event, |
| AccessibleContext ac, |
| wchar_t *oldValue, wchar_t *newValue ) { |
| char s[1024]; |
| wsprintf( s, "Value changed event: old = %ls; new = %ls\r\n\r\n", |
| oldValue, newValue ); |
| |
| if (ac != (AccessibleContext) 0) { |
| displayAccessiblePropertyChange(vmID, ac, s); |
| } |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a HandlePropertySelectionChange event |
| */ |
| void HandlePropertySelectionChange( long vmID, PropertyChangeEvent event, |
| AccessibleContext ac ) { |
| if (ac != (AccessibleContext) 0) { |
| displayAccessiblePropertyChange( vmID, ac, |
| "Selection changed event\r\n\r\n" ); |
| } |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a HandlePropertyTextChange event |
| */ |
| void HandlePropertyTextChange( long vmID, PropertyChangeEvent event, |
| AccessibleContext ac ) { |
| if (ac != (AccessibleContext) 0) { |
| displayAccessiblePropertyChange(vmID, ac, "Text changed event\r\n\r\n"); |
| } |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a HandlePropertyCaretChange event |
| */ |
| void HandlePropertyCaretChange( long vmID, PropertyChangeEvent event, |
| AccessibleContext ac, |
| int oldPosition, int newPosition ) { |
| char s[1024]; |
| |
| wsprintf( s, "Caret changed event: oldPosition = %d; newPosition = %d\r\n\r\n", |
| oldPosition, newPosition ); |
| |
| if (ac != (AccessibleContext) 0) { |
| displayAccessiblePropertyChange(vmID, ac, s); |
| } |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a HandlePropertyVisibleDataChange event |
| */ |
| void HandlePropertyVisibleDataChange( long vmID, PropertyChangeEvent event, |
| AccessibleContext ac ) { |
| if (ac != (AccessibleContext) 0) { |
| displayAccessiblePropertyChange( vmID, ac, |
| "VisibleData changed event\r\n\r\n" ); |
| } |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a HandlePropertyChildChange event |
| */ |
| void HandlePropertyChildChange( long vmID, PropertyChangeEvent event, |
| AccessibleContext ac, |
| JOBJECT64 oldChild, JOBJECT64 newChild ) { |
| char buffer[HUGE_BUFSIZE]; |
| char *bufOffset; |
| |
| sprintf( buffer, |
| "Child property changed event:\r\n=======================\r\n\r\n" ); |
| |
| if (oldChild != 0) { |
| strncat(buffer, "Old Accessible Child info:\r\n\r\n", sizeof(buffer)); |
| bufOffset = (char *) (buffer + strlen(buffer)); |
| getAccessibleInfo( vmID, oldChild, 0, 0, bufOffset, |
| (int)(sizeof(buffer) - strlen(buffer)) ); |
| strncat(buffer, "\r\n\r\n", sizeof(buffer)); |
| } |
| |
| if (newChild != 0) { |
| strncat(buffer, "New Accessible Child info:\r\n\r\n", sizeof(buffer)); |
| bufOffset = (char *) (buffer + strlen(buffer)); |
| getAccessibleInfo( vmID, newChild, 0, 0, bufOffset, |
| (int)(sizeof(buffer) - strlen(buffer)) ); |
| strncat(buffer, "\r\n\r\n", sizeof(buffer)); |
| } |
| |
| if (ac != (AccessibleContext) 0) { |
| displayAccessiblePropertyChange(vmID, ac, buffer); |
| } |
| |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, oldChild); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, newChild); // must always release, to stave off memory leaks |
| } |
| |
| /** |
| * Handle a HandlePropertyActiveDescendentChange event |
| */ |
| void HandlePropertyActiveDescendentChange( long vmID, PropertyChangeEvent event, |
| AccessibleContext ac, |
| JOBJECT64 oldActiveDescendent, |
| JOBJECT64 newActiveDescendent ) { |
| char buffer[HUGE_BUFSIZE]; |
| |
| sprintf( buffer, |
| "ActiveDescendent property changed event:\r\n=======================\r\n\r\n" ); |
| |
| #ifdef _notdef |
| char *bufOffset; |
| if (oldActiveDescendent != 0) { |
| strncat(buffer, "Old Accessible ActiveDescendent info:\r\n\r\n", sizeof(buffer)); |
| bufOffset = (char *) (buffer + strlen(buffer)); |
| getAccessibleInfo( vmID, oldActiveDescendent, 0, 0, bufOffset, |
| (int)(sizeof(buffer) - strlen(buffer)) ); |
| strncat(buffer, "\r\n\r\n", sizeof(buffer)); |
| } |
| |
| if (newActiveDescendent != 0) { |
| strncat( buffer, "New Accessible ActiveDescendent info:\r\n\r\n", |
| sizeof(buffer) ); |
| bufOffset = (char *) (buffer + strlen(buffer)); |
| getAccessibleInfo( vmID, newActiveDescendent, 0, 0, bufOffset, |
| (int)(sizeof(buffer) - strlen(buffer)) ); |
| strncat(buffer, "\r\n\r\n", sizeof(buffer)); |
| } |
| #endif _notdef |
| |
| if (newActiveDescendent != (AccessibleContext) 0) { |
| displayAccessiblePropertyChange(vmID, newActiveDescendent, buffer); |
| } |
| |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, oldActiveDescendent); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, newActiveDescendent); // must always release, to stave off memory leaks |
| } |
| |
| |
| /** |
| * Handle a HandlePropertyTableModelChange event |
| */ |
| void HandlePropertyTableModelChange( long vmID, PropertyChangeEvent event, |
| AccessibleContext ac, |
| wchar_t *oldValue, wchar_t *newValue ) { |
| |
| char s[1024]; |
| wsprintf( s, "Table Model Change: old = %ls; new = %ls\r\n\r\n", |
| oldValue, newValue ); |
| |
| if (ac != (AccessibleContext) 0) { |
| displayAccessiblePropertyChange(vmID, ac, s); |
| } |
| ReleaseJavaObject(vmID, ac); // must always release, to stave off memory leaks |
| ReleaseJavaObject(vmID, event); // must always release, to stave off memory leaks |
| } |
| |
| |
| |
| #define DOWN_UP_FLAG 1<<31 |
| |
| void CALLBACK TimerProc(HWND hWnd, UINT uTimerMsg, UINT uTimerID, DWORD dwTime) { |
| // when mouse settles from movement |
| KillTimer(hWnd, uTimerID); |
| if (updateMouse == TRUE) { |
| PostMessage(theDialogWindow, DISPLAY_INFO_MESSAGE, 0, 0); |
| } |
| } |
| |
| LRESULT CALLBACK KeyboardProc(int code, WPARAM wParam, LPARAM lParam) { |
| // on mouse-up of F1 |
| if (code < 0) { |
| CallNextHookEx(prevKbdHook, code, wParam, lParam); |
| } else if (wParam == VK_F1 && lParam & DOWN_UP_FLAG && updateF1) { |
| PostMessage(theDialogWindow, DISPLAY_INFO_MESSAGE, wParam, lParam); |
| } else if (wParam == VK_F2 && lParam & DOWN_UP_FLAG && updateF2) { |
| PostMessage(theDialogWindow, DISPLAY_HWND_INFO_MESSAGE, wParam, lParam); |
| } |
| return 0; |
| } |
| |
| LRESULT CALLBACK MouseProc(int code, WPARAM wParam, LPARAM lParam) { |
| // when mouse settles from movement |
| if (code < 0) { |
| CallNextHookEx(prevMouseHook, code, wParam, lParam); |
| } else { |
| // reset the timer every time the mouse moves |
| KillTimer(theDialogWindow, TIMER_ID); |
| SetTimer(theDialogWindow, TIMER_ID, 1000, (TIMERPROC)TimerProc); |
| } |
| return 0; |
| } |
| |
| void exitjaccessinspector(HWND hWnd) { |
| EndDialog(hWnd, TRUE); |
| PostQuitMessage (0); |
| } |
| |
| #define INSTALL_EVENT_LISTENER(toggleVal, setFP, handler) \ |
| if (toggleVal) { \ |
| setFP(handler); \ |
| } |
| |
| void reinstallEventListeners() { |
| INSTALL_EVENT_LISTENER(trackMouse, SetMouseEntered, HandleMouseEntered); |
| INSTALL_EVENT_LISTENER(trackMouseExited, SetMouseExited, HandleMouseExited); |
| INSTALL_EVENT_LISTENER(trackMouseClicked, SetMouseClicked, HandleMouseClicked); |
| INSTALL_EVENT_LISTENER(trackMousePressed, SetMousePressed, HandleMousePressed); |
| INSTALL_EVENT_LISTENER(trackMouseReleased, SetMouseReleased, HandleMouseReleased); |
| INSTALL_EVENT_LISTENER(trackShutdown, SetJavaShutdown, HandleJavaShutdown); |
| INSTALL_EVENT_LISTENER(trackFocus, SetFocusGained, HandleJavaFocusGained); |
| INSTALL_EVENT_LISTENER(trackFocusLost, SetFocusLost, HandleJavaFocusLost); |
| INSTALL_EVENT_LISTENER(trackCaret, SetCaretUpdate, HandleJavaCaretUpdate); |
| |
| INSTALL_EVENT_LISTENER(trackMenuSelected, SetMenuSelected, HandleMenuSelected); |
| INSTALL_EVENT_LISTENER(trackMenuDeselected, SetMenuDeselected, HandleMenuDeselected); |
| INSTALL_EVENT_LISTENER(trackMenuCanceled, SetMenuCanceled, HandleMenuCanceled); |
| |
| INSTALL_EVENT_LISTENER( trackPopupVisible, SetPopupMenuWillBecomeVisible, |
| HandlePopupMenuWillBecomeVisible ); |
| INSTALL_EVENT_LISTENER( trackPopupInvisible, SetPopupMenuWillBecomeInvisible, |
| HandlePopupMenuWillBecomeInvisible ); |
| INSTALL_EVENT_LISTENER( trackPopupCanceled, SetPopupMenuCanceled, |
| HandlePopupMenuCanceled ); |
| |
| INSTALL_EVENT_LISTENER( trackPropertyNameChange, SetPropertyNameChange, |
| HandlePropertyNameChange); |
| INSTALL_EVENT_LISTENER( trackPropertyDescriptionChange, |
| SetPropertyDescriptionChange, |
| HandlePropertyDescriptionChange ); |
| INSTALL_EVENT_LISTENER( trackPropertyStateChange, SetPropertyStateChange, |
| HandlePropertyStateChange ); |
| INSTALL_EVENT_LISTENER( trackPropertyValueChange, SetPropertyValueChange, |
| HandlePropertyValueChange ); |
| INSTALL_EVENT_LISTENER( trackPropertySelectionChange, |
| SetPropertySelectionChange, |
| HandlePropertySelectionChange ); |
| INSTALL_EVENT_LISTENER( trackPropertyTextChange, SetPropertyTextChange, |
| HandlePropertyTextChange ); |
| INSTALL_EVENT_LISTENER( trackPropertyCaretChange, SetPropertyCaretChange, |
| HandlePropertyCaretChange ); |
| INSTALL_EVENT_LISTENER( trackPropertyVisibleDataChange, |
| SetPropertyVisibleDataChange, |
| HandlePropertyVisibleDataChange ); |
| INSTALL_EVENT_LISTENER( trackPropertyChildChange, SetPropertyChildChange, |
| HandlePropertyChildChange ); |
| INSTALL_EVENT_LISTENER( trackPropertyActiveDescendentChange, |
| SetPropertyActiveDescendentChange, |
| HandlePropertyActiveDescendentChange ); |
| INSTALL_EVENT_LISTENER( trackPropertyTableModelChange, |
| SetPropertyTableModelChange, |
| HandlePropertyTableModelChange ); |
| } |
| |
| |
| #define TRACK_EVENT_TOGGLE(menuItem, toggleVal, setFP, handler) \ |
| case menuItem: \ |
| menu = GetMenu(hWnd); \ |
| if (toggleVal) { \ |
| toggleVal = FALSE; \ |
| CheckMenuItem(menu, menuItem, \ |
| MF_BYCOMMAND | MF_UNCHECKED); \ |
| setFP(NULL); \ |
| } else { \ |
| toggleVal = TRUE; \ |
| CheckMenuItem(menu, menuItem, \ |
| MF_BYCOMMAND | MF_CHECKED); \ |
| setFP(handler); \ |
| } \ |
| MaybeCheckMonitorTheSameEventsAsJAWS(menu); \ |
| MaybeCheckMonitorAllEvents(menu); \ |
| return TRUE |
| |
| INT_PTR CALLBACK jaccessinspectorDialogProc( HWND hWnd, UINT message, |
| WPARAM wParam, LPARAM lParam ) { |
| const int minWindowWidth = 540; |
| const int minWindowHeight = 300; |
| static int titleBarHeight = ::GetSystemMetrics(SM_CYSIZE); |
| static int menuBarHeight = ::GetSystemMetrics(SM_CYMENU); |
| static int borderHeight = ::GetSystemMetrics(SM_CYBORDER); |
| static int borderWidth = ::GetSystemMetrics(SM_CXBORDER); |
| static int verticalScrollBarWidth = ::GetSystemMetrics(SM_CXVSCROLL); |
| int command; |
| short width, height; |
| HWND dlgItem; |
| RECT dlgItemRect; |
| RECT dialogBoxRect; |
| LONG lT; |
| HMENU menu; |
| DWORD lastError = 0; |
| |
| switch (message) { |
| |
| case WM_CREATE: |
| return 0; |
| |
| case WM_INITDIALOG: |
| CheckMenuItem(GetMenu(hWnd), cAccessBridgeDLLLoaded, MF_BYCOMMAND | MF_CHECKED); |
| return TRUE; |
| |
| case WM_CLOSE: |
| exitjaccessinspector(hWnd); |
| return TRUE; |
| |
| case WM_SIZE: |
| width = LOWORD(lParam); |
| height = HIWORD(lParam); |
| dlgItem = GetDlgItem(theDialogWindow, cjaccessinspectorText); |
| ::GetWindowRect(dlgItem, &dlgItemRect); |
| ::GetWindowRect(theDialogWindow, &dialogBoxRect); |
| lT = dlgItemRect.top - dialogBoxRect.top - titleBarHeight - |
| menuBarHeight + (borderHeight * 4); |
| SetWindowPos( dlgItem, NULL, 0, 0, |
| width - (borderWidth * 2) - verticalScrollBarWidth, |
| height - lT, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE); |
| return FALSE; // let windows finish handling this |
| |
| case WM_GETMINMAXINFO: |
| { |
| LPMINMAXINFO lpMMI = (LPMINMAXINFO)lParam; |
| lpMMI->ptMinTrackSize.x = minWindowWidth; |
| lpMMI->ptMinTrackSize.y = minWindowHeight; |
| return TRUE; |
| } |
| break; |
| |
| case WM_COMMAND: |
| command = LOWORD(wParam); |
| |
| switch(command) { |
| case cAccessBridgeDLLLoaded: // toggle; unload or load AccessBridge |
| if (theAccessBridgeLoadedFlag) { |
| shutdownAccessBridge(); |
| theAccessBridgeLoadedFlag = FALSE; |
| CheckMenuItem( GetMenu(hWnd), cAccessBridgeDLLLoaded, |
| MF_BYCOMMAND | MF_UNCHECKED ); |
| } else { |
| theAccessBridgeLoadedFlag = initializeAccessBridge(); |
| if (theAccessBridgeLoadedFlag) { |
| CheckMenuItem( GetMenu(hWnd), cAccessBridgeDLLLoaded, |
| MF_BYCOMMAND | MF_CHECKED ); |
| reinstallEventListeners(); |
| } |
| } |
| return TRUE; |
| |
| case cExitMenuItem: |
| exitjaccessinspector(hWnd); |
| return TRUE; |
| |
| TRACK_EVENT_TOGGLE( cTrackMouseMenuItem, trackMouse, SetMouseEntered, |
| HandleMouseEntered ); |
| TRACK_EVENT_TOGGLE( cTrackMouseExitedMenuItem, trackMouseExited, |
| SetMouseExited, HandleMouseExited ); |
| TRACK_EVENT_TOGGLE( cTrackMouseClickedMenuItem, trackMouseClicked, |
| SetMouseClicked, HandleMouseClicked ); |
| TRACK_EVENT_TOGGLE( cTrackMousePressedMenuItem, trackMousePressed, |
| SetMousePressed, HandleMousePressed ); |
| TRACK_EVENT_TOGGLE( cTrackMouseReleasedMenuItem, trackMouseReleased, |
| SetMouseReleased, HandleMouseReleased ); |
| TRACK_EVENT_TOGGLE( cTrackShutdownMenuItem, trackShutdown, |
| SetJavaShutdown, HandleJavaShutdown ); |
| TRACK_EVENT_TOGGLE( cTrackFocusMenuItem, trackFocus, SetFocusGained, |
| HandleJavaFocusGained ); |
| TRACK_EVENT_TOGGLE( cTrackFocusLostMenuItem, trackFocusLost, |
| SetFocusLost, HandleJavaFocusLost ); |
| TRACK_EVENT_TOGGLE( cTrackCaretMenuItem, trackCaret, SetCaretUpdate, |
| HandleJavaCaretUpdate ); |
| |
| TRACK_EVENT_TOGGLE( cTrackMenuSelectedMenuItem, trackMenuSelected, |
| SetMenuSelected, HandleMenuSelected ); |
| TRACK_EVENT_TOGGLE( cTrackMenuDeselectedMenuItem, trackMenuDeselected, |
| SetMenuDeselected, HandleMenuDeselected ); |
| TRACK_EVENT_TOGGLE( cTrackMenuCanceledItem, trackMenuCanceled, |
| SetMenuCanceled, HandleMenuCanceled ); |
| |
| TRACK_EVENT_TOGGLE( cTrackPopupBecomeVisibleMenuItem, trackPopupVisible, |
| SetPopupMenuWillBecomeVisible, |
| HandlePopupMenuWillBecomeVisible ); |
| TRACK_EVENT_TOGGLE( cTrackPopupBecomeInvisibleMenuItem, |
| trackPopupInvisible, |
| SetPopupMenuWillBecomeInvisible, |
| HandlePopupMenuWillBecomeInvisible ); |
| TRACK_EVENT_TOGGLE( cTrackPopupCanceledItem, trackPopupCanceled, |
| SetPopupMenuCanceled, HandlePopupMenuCanceled ); |
| |
| TRACK_EVENT_TOGGLE( cTrackPropertyNameItem, trackPropertyNameChange, |
| SetPropertyNameChange, HandlePropertyNameChange ); |
| TRACK_EVENT_TOGGLE( cTrackPropertyDescriptionItem, |
| trackPropertyDescriptionChange, |
| SetPropertyDescriptionChange, |
| HandlePropertyDescriptionChange ); |
| TRACK_EVENT_TOGGLE( cTrackPropertyStateItem, trackPropertyStateChange, |
| SetPropertyStateChange, HandlePropertyStateChange ); |
| TRACK_EVENT_TOGGLE( cTrackPropertyValueItem, trackPropertyValueChange, |
| SetPropertyValueChange, HandlePropertyValueChange ); |
| TRACK_EVENT_TOGGLE( cTrackPropertySelectionItem, |
| trackPropertySelectionChange, |
| SetPropertySelectionChange, |
| HandlePropertySelectionChange ); |
| TRACK_EVENT_TOGGLE( cTrackPropertyTextItem, trackPropertyTextChange, |
| SetPropertyTextChange, HandlePropertyTextChange ); |
| TRACK_EVENT_TOGGLE( cTrackPropertyCaretItem, trackPropertyCaretChange, |
| SetPropertyCaretChange, HandlePropertyCaretChange ); |
| TRACK_EVENT_TOGGLE( cTrackPropertyVisibleDataItem, |
| trackPropertyVisibleDataChange, |
| SetPropertyVisibleDataChange, |
| HandlePropertyVisibleDataChange ); |
| TRACK_EVENT_TOGGLE( cTrackPropertyChildItem, trackPropertyChildChange, |
| SetPropertyChildChange, HandlePropertyChildChange ); |
| TRACK_EVENT_TOGGLE( cTrackPropertyActiveDescendentItem, |
| trackPropertyActiveDescendentChange, |
| SetPropertyActiveDescendentChange, |
| HandlePropertyActiveDescendentChange ); |
| TRACK_EVENT_TOGGLE( cTrackPropertyTableModelChangeItem, |
| trackPropertyTableModelChange, |
| SetPropertyTableModelChange, |
| HandlePropertyTableModelChange ); |
| |
| case cUpdateFromMouseMenuItem: |
| menu = GetMenu(hWnd); |
| if (updateMouse) { |
| updateMouse = FALSE; |
| CheckMenuItem( menu, cUpdateFromMouseMenuItem, |
| MF_BYCOMMAND | MF_UNCHECKED ); |
| UnhookWindowsHookEx((HHOOK)MouseProc); |
| KillTimer(hWnd, TIMER_ID); |
| } else { |
| updateMouse = TRUE; |
| CheckMenuItem( menu, cUpdateFromMouseMenuItem, |
| MF_BYCOMMAND | MF_CHECKED ); |
| prevMouseHook = SetWindowsHookEx( WH_MOUSE, MouseProc, |
| theInstance, |
| ::GetCurrentThreadId() ); |
| if (! prevMouseHook) { |
| lastError = ::GetLastError(); |
| } |
| } |
| return TRUE; |
| |
| case cUpdateWithF1Item: |
| menu = GetMenu(hWnd); |
| if (updateF1) { |
| updateF1 = FALSE; |
| CheckMenuItem( menu, cUpdateWithF1Item, |
| MF_BYCOMMAND | MFS_UNCHECKED ); |
| UnhookWindowsHookEx((HHOOK)KeyboardProc); |
| } else { |
| updateF1 = TRUE; |
| CheckMenuItem( menu, cUpdateWithF1Item, |
| MF_BYCOMMAND | MFS_CHECKED ); |
| prevKbdHook = SetWindowsHookEx( WH_KEYBOARD, KeyboardProc, |
| theInstance, |
| ::GetCurrentThreadId() ); |
| if (! prevKbdHook) { |
| lastError = ::GetLastError(); |
| } |
| } |
| return TRUE; |
| |
| case cUpdateWithF2Item: |
| menu = GetMenu(hWnd); |
| if (updateF2) { |
| updateF2 = FALSE; |
| CheckMenuItem( menu, cUpdateWithF2Item, |
| MF_BYCOMMAND | MFS_UNCHECKED ); |
| UnhookWindowsHookEx((HHOOK)KeyboardProc); |
| } else { |
| updateF2 = TRUE; |
| CheckMenuItem(menu, cUpdateWithF2Item, |
| MF_BYCOMMAND | MFS_CHECKED); |
| prevKbdHook = SetWindowsHookEx( WH_KEYBOARD, KeyboardProc, |
| theInstance, ::GetCurrentThreadId() ); |
| if (! prevKbdHook) { |
| lastError = ::GetLastError(); |
| } |
| } |
| return TRUE; |
| |
| case cMonitorTheSameEventsAsJAWS: |
| /* |
| Causes jaccessinspetor to monitor the same events as JAWS. Useful |
| when testing to determine if a bug is specific to JAWS or if it can |
| be reproduced in jaccessinspector as well. |
| */ |
| trackMouse = FALSE; |
| trackMouseExited = FALSE; |
| trackMouseClicked = FALSE; |
| trackMousePressed = FALSE; |
| trackMouseReleased = FALSE; |
| trackFocus = TRUE; |
| trackFocusLost = TRUE; |
| trackCaret = FALSE; |
| trackShutdown = FALSE; |
| |
| trackMenuSelected = FALSE; |
| trackMenuDeselected = FALSE; |
| trackMenuCanceled = FALSE; |
| |
| trackPopupVisible = FALSE; |
| trackPopupInvisible = FALSE; |
| trackPopupCanceled = FALSE; |
| |
| trackPropertyNameChange = TRUE; |
| trackPropertyDescriptionChange = TRUE; |
| trackPropertyStateChange = TRUE; |
| trackPropertyValueChange = TRUE; |
| trackPropertySelectionChange = TRUE; |
| trackPropertyTextChange = TRUE; |
| trackPropertyCaretChange = TRUE; |
| trackPropertyVisibleDataChange = FALSE; |
| trackPropertyChildChange = TRUE; |
| trackPropertyActiveDescendentChange = TRUE; |
| trackPropertyTableModelChange = FALSE; |
| |
| ApplyEventOptions(hWnd); |
| |
| return TRUE; |
| |
| case cMonitorAllEvents: |
| /* |
| Causes jaccessinspector to monitor all Java Events and all |
| Accessibility Events. |
| */ |
| trackMouse = TRUE; |
| trackMouseExited = TRUE; |
| trackMouseClicked = TRUE; |
| trackMousePressed = TRUE; |
| trackMouseReleased = TRUE; |
| trackFocus = TRUE; |
| trackFocusLost = TRUE; |
| trackCaret = TRUE; |
| trackShutdown = TRUE; |
| |
| trackMenuSelected = TRUE; |
| trackMenuDeselected = TRUE; |
| trackMenuCanceled = TRUE; |
| |
| trackPopupVisible = TRUE; |
| trackPopupInvisible = TRUE; |
| trackPopupCanceled = TRUE; |
| |
| trackPropertyNameChange = TRUE; |
| trackPropertyDescriptionChange = TRUE; |
| trackPropertyStateChange = TRUE; |
| trackPropertyValueChange = TRUE; |
| trackPropertySelectionChange = TRUE; |
| trackPropertyTextChange = TRUE; |
| trackPropertyCaretChange = TRUE; |
| trackPropertyVisibleDataChange = TRUE; |
| trackPropertyChildChange = TRUE; |
| trackPropertyActiveDescendentChange = TRUE; |
| trackPropertyTableModelChange = TRUE; |
| |
| ApplyEventOptions(hWnd); |
| |
| return TRUE; |
| |
| case cFirstMessage: |
| { |
| const char * messageText = g_MessageHistory.GetFirstMessage (); |
| if ( ( NULL != messageText ) && ( 0 != messageText [0] ) ) { |
| ::SetDlgItemText( theDialogWindow, cjaccessinspectorText, |
| messageText ); |
| } |
| EnableMessageNavButtons(); |
| UpdateMessageNumber(); |
| return TRUE; |
| } |
| break; |
| |
| case cPreviousMessage: |
| { |
| const char * messageText = g_MessageHistory.GetPreviousMessage (); |
| if ( ( NULL != messageText ) && ( 0 != messageText [0] ) ) { |
| ::SetDlgItemText( theDialogWindow, cjaccessinspectorText, |
| messageText ); |
| } |
| EnableMessageNavButtons(); |
| UpdateMessageNumber(); |
| return TRUE; |
| } |
| break; |
| |
| case cNextMessage: |
| { |
| const char * messageText = g_MessageHistory.GetNextMessage (); |
| if ( ( NULL != messageText ) && ( 0 != messageText [0] ) ) { |
| ::SetDlgItemText( theDialogWindow, cjaccessinspectorText, |
| messageText ); |
| } |
| EnableMessageNavButtons(); |
| UpdateMessageNumber(); |
| return TRUE; |
| } |
| break; |
| |
| case cLastMessage: |
| { |
| const char * messageText = g_MessageHistory.GetLastMessage(); |
| if ( ( NULL != messageText ) && ( 0 != messageText [0] ) ) { |
| ::SetDlgItemText( theDialogWindow, cjaccessinspectorText, |
| messageText ); |
| } |
| EnableMessageNavButtons(); |
| UpdateMessageNumber(); |
| return TRUE; |
| } |
| break; |
| |
| case cResetAllEvents: |
| trackMouse = FALSE; |
| trackMouseExited = FALSE; |
| trackMouseClicked = FALSE; |
| trackMousePressed = FALSE; |
| trackMouseReleased = FALSE; |
| trackFocus = FALSE; |
| trackFocusLost = FALSE; |
| trackCaret = FALSE; |
| trackShutdown = FALSE; |
| |
| trackMenuSelected = FALSE; |
| trackMenuDeselected = FALSE; |
| trackMenuCanceled = FALSE; |
| |
| trackPopupVisible = FALSE; |
| trackPopupInvisible = FALSE; |
| trackPopupCanceled = FALSE; |
| |
| trackPropertyNameChange = FALSE; |
| trackPropertyDescriptionChange = FALSE; |
| trackPropertyStateChange = FALSE; |
| trackPropertyValueChange = FALSE; |
| trackPropertySelectionChange = FALSE; |
| trackPropertyTextChange = FALSE; |
| trackPropertyCaretChange = FALSE; |
| trackPropertyVisibleDataChange = FALSE; |
| trackPropertyChildChange = FALSE; |
| trackPropertyActiveDescendentChange = FALSE; |
| trackPropertyTableModelChange = FALSE; |
| |
| ApplyEventOptions(hWnd); |
| |
| return TRUE; |
| |
| case cGoToMessage: |
| InitGoToMessageDialogBox(theInstance); |
| break; |
| |
| case cClearMessageHistory: |
| g_MessageHistory.clear(); |
| ::SetDlgItemText(theDialogWindow, cjaccessinspectorText, NULL); |
| EnableMessageNavButtons(); |
| UpdateMessageNumber(); |
| break; |
| } |
| break; |
| |
| case DISPLAY_INFO_MESSAGE: |
| echoMouseObject(); |
| return TRUE; |
| |
| case DISPLAY_HWND_INFO_MESSAGE: |
| echoMouseHWNDObject(); |
| return TRUE; |
| } |
| |
| return FALSE; |
| } |
| |
| #define SaveOptionToRegistry(optionVar) { \ |
| SetValue = RegSetValueEx( hKey, #optionVar, 0, REG_DWORD, \ |
| (LPBYTE)(&optionVar), sizeof(DWORD)); \ |
| if ( ERROR_SUCCESS != SetValue ) { \ |
| ++ failureCount; \ |
| } \ |
| } |
| |
| BOOL SaveActiveEventOptionsToRegistry() { |
| LONG CreateKey = ERROR_SUCCESS; |
| HKEY hKey = NULL; |
| DWORD Disposition = 0; |
| |
| CreateKey = ::RegCreateKeyEx( HKEY_CURRENT_USER, |
| jaccessinspectorOptionsRegistryKey, 0, 0, 0, |
| KEY_READ|KEY_WRITE, 0, &hKey, &Disposition ); |
| if ( ( ERROR_SUCCESS != CreateKey ) || ( NULL == hKey ) ) { |
| return FALSE; |
| } |
| |
| LONG SetValue = ERROR_SUCCESS; |
| unsigned long failureCount = 0; |
| |
| SaveOptionToRegistry(trackMouse); |
| SaveOptionToRegistry(trackMouseExited); |
| SaveOptionToRegistry(trackMouseClicked); |
| SaveOptionToRegistry(trackMousePressed); |
| SaveOptionToRegistry(trackMouseReleased); |
| SaveOptionToRegistry(trackShutdown); |
| SaveOptionToRegistry(trackFocus); |
| SaveOptionToRegistry(trackFocusLost); |
| SaveOptionToRegistry(trackCaret); |
| SaveOptionToRegistry(trackMenuSelected); |
| SaveOptionToRegistry(trackMenuDeselected); |
| SaveOptionToRegistry(trackMenuCanceled); |
| SaveOptionToRegistry(trackPopupVisible); |
| SaveOptionToRegistry(trackPopupInvisible); |
| SaveOptionToRegistry(trackPopupCanceled); |
| SaveOptionToRegistry(trackPropertyNameChange); |
| SaveOptionToRegistry(trackPropertyDescriptionChange); |
| SaveOptionToRegistry(trackPropertyStateChange); |
| SaveOptionToRegistry(trackPropertyValueChange); |
| SaveOptionToRegistry(trackPropertySelectionChange); |
| SaveOptionToRegistry(trackPropertyTextChange); |
| SaveOptionToRegistry(trackPropertyCaretChange); |
| SaveOptionToRegistry(trackPropertyVisibleDataChange); |
| SaveOptionToRegistry(trackPropertyChildChange); |
| SaveOptionToRegistry(trackPropertyActiveDescendentChange); |
| SaveOptionToRegistry(trackPropertyTableModelChange); |
| |
| ::RegFlushKey(hKey); |
| ::RegCloseKey(hKey); |
| |
| if ( 0 == failureCount ) { |
| return TRUE; |
| } |
| return FALSE; |
| } |
| |
| #define ReadOptionFromRegistry(optionVar) { \ |
| Type = Value = 0; \ |
| ValueSize = sizeof(DWORD); \ |
| QueryValue = ::RegQueryValueEx( hKey, #optionVar, NULL, &Type, \ |
| (LPBYTE)(&Value), &ValueSize); \ |
| if ( ( ERROR_SUCCESS == QueryValue ) && ( REG_DWORD == Type ) ) { \ |
| optionVar = static_cast<BOOL>(Value); \ |
| } else { \ |
| ++ failureCount; \ |
| } \ |
| } |
| |
| BOOL ReadActiveEventOptionsFromRegistry() { |
| |
| trackMouse = FALSE; |
| trackMouseExited = FALSE; |
| trackMouseClicked = FALSE; |
| trackMousePressed = FALSE; |
| trackMouseReleased = FALSE; |
| |
| trackShutdown = FALSE; |
| trackFocus = FALSE; |
| trackFocusLost = FALSE; |
| trackCaret = FALSE; |
| trackMenuSelected = FALSE; |
| trackMenuDeselected = FALSE; |
| trackMenuCanceled = FALSE; |
| trackPopupVisible = FALSE; |
| trackPopupInvisible = FALSE; |
| trackPopupCanceled = FALSE; |
| |
| trackPropertyNameChange = FALSE; |
| trackPropertyDescriptionChange = FALSE; |
| trackPropertyStateChange = FALSE; |
| trackPropertyValueChange = FALSE; |
| trackPropertySelectionChange = FALSE; |
| trackPropertyTextChange = FALSE; |
| trackPropertyCaretChange = FALSE; |
| trackPropertyVisibleDataChange = FALSE; |
| trackPropertyChildChange = FALSE; |
| trackPropertyActiveDescendentChange = FALSE; |
| trackPropertyTableModelChange = FALSE; |
| |
| LONG OpenKey = ERROR_SUCCESS; |
| HKEY hKey = NULL; |
| OpenKey = ::RegOpenKeyEx( HKEY_CURRENT_USER, |
| jaccessinspectorOptionsRegistryKey, 0, |
| KEY_READ, &hKey ); |
| if ( ( ERROR_SUCCESS != OpenKey ) || ( NULL == hKey ) ) { |
| return FALSE; |
| } |
| |
| LONG QueryValue = ERROR_SUCCESS; |
| unsigned long failureCount = 0; |
| DWORD Type, Value, ValueSize; |
| |
| ReadOptionFromRegistry(trackMouse); |
| ReadOptionFromRegistry(trackMouseExited); |
| ReadOptionFromRegistry(trackMouseClicked); |
| ReadOptionFromRegistry(trackMousePressed); |
| ReadOptionFromRegistry(trackMouseReleased); |
| ReadOptionFromRegistry(trackShutdown); |
| ReadOptionFromRegistry(trackFocus); |
| ReadOptionFromRegistry(trackFocusLost); |
| ReadOptionFromRegistry(trackCaret); |
| ReadOptionFromRegistry(trackMenuSelected); |
| ReadOptionFromRegistry(trackMenuDeselected); |
| ReadOptionFromRegistry(trackMenuCanceled); |
| ReadOptionFromRegistry(trackPopupVisible); |
| ReadOptionFromRegistry(trackPopupInvisible); |
| ReadOptionFromRegistry(trackPopupCanceled); |
| ReadOptionFromRegistry(trackPropertyNameChange); |
| ReadOptionFromRegistry(trackPropertyDescriptionChange); |
| ReadOptionFromRegistry(trackPropertyStateChange); |
| ReadOptionFromRegistry(trackPropertyValueChange); |
| ReadOptionFromRegistry(trackPropertySelectionChange); |
| ReadOptionFromRegistry(trackPropertyTextChange); |
| ReadOptionFromRegistry(trackPropertyCaretChange); |
| ReadOptionFromRegistry(trackPropertyVisibleDataChange); |
| ReadOptionFromRegistry(trackPropertyChildChange); |
| ReadOptionFromRegistry(trackPropertyActiveDescendentChange); |
| ReadOptionFromRegistry(trackPropertyTableModelChange); |
| |
| ::RegCloseKey(hKey); |
| |
| if ( 0 == failureCount ) { |
| return TRUE; |
| } |
| return FALSE; |
| } |
| |
| #define APPLY_EVENT_OPTION(menuItem, optionVar, setFP, handler) \ |
| { \ |
| if ( optionVar ) { \ |
| ::CheckMenuItem(menu, menuItem, MF_BYCOMMAND | MF_CHECKED); \ |
| setFP (handler); \ |
| } else { \ |
| ::CheckMenuItem(menu, menuItem, MF_BYCOMMAND | MF_UNCHECKED); \ |
| setFP (NULL); \ |
| } \ |
| } |
| |
| void ApplyEventOptions (HWND hWnd) { |
| |
| HMENU menu = ::GetMenu (hWnd); |
| APPLY_EVENT_OPTION( cTrackMouseMenuItem, trackMouse, SetMouseEntered, |
| HandleMouseEntered ); |
| APPLY_EVENT_OPTION( cTrackMouseExitedMenuItem, trackMouseExited, |
| SetMouseExited, HandleMouseExited ); |
| APPLY_EVENT_OPTION( cTrackMouseClickedMenuItem, trackMouseClicked, |
| SetMouseClicked, HandleMouseClicked ); |
| APPLY_EVENT_OPTION( cTrackMousePressedMenuItem, trackMousePressed, |
| SetMousePressed, HandleMousePressed ); |
| APPLY_EVENT_OPTION( cTrackMouseReleasedMenuItem, trackMouseReleased, |
| SetMouseReleased, HandleMouseReleased ); |
| |
| APPLY_EVENT_OPTION( cTrackShutdownMenuItem, trackShutdown, SetJavaShutdown, |
| HandleJavaShutdown ); |
| APPLY_EVENT_OPTION( cTrackFocusMenuItem, trackFocus, SetFocusGained, |
| HandleJavaFocusGained ); |
| APPLY_EVENT_OPTION( cTrackFocusLostMenuItem, trackFocusLost, SetFocusLost, |
| HandleJavaFocusLost ); |
| APPLY_EVENT_OPTION( cTrackCaretMenuItem, trackCaret, SetCaretUpdate, |
| HandleJavaCaretUpdate ); |
| |
| APPLY_EVENT_OPTION( cTrackMenuSelectedMenuItem, trackMenuSelected, |
| SetMenuSelected, HandleMenuSelected ); |
| APPLY_EVENT_OPTION( cTrackMenuDeselectedMenuItem, trackMenuDeselected, |
| SetMenuDeselected, HandleMenuDeselected ); |
| APPLY_EVENT_OPTION( cTrackMenuCanceledItem, trackMenuCanceled, |
| SetMenuCanceled, HandleMenuCanceled ); |
| |
| APPLY_EVENT_OPTION( cTrackPopupBecomeVisibleMenuItem, trackPopupVisible, |
| SetPopupMenuWillBecomeVisible, |
| HandlePopupMenuWillBecomeVisible ); |
| APPLY_EVENT_OPTION( cTrackPopupBecomeInvisibleMenuItem, trackPopupInvisible, |
| SetPopupMenuWillBecomeInvisible, |
| HandlePopupMenuWillBecomeInvisible ); |
| APPLY_EVENT_OPTION( cTrackPopupCanceledItem, trackPopupCanceled, |
| SetPopupMenuCanceled, HandlePopupMenuCanceled ); |
| |
| APPLY_EVENT_OPTION( cTrackPropertyNameItem, trackPropertyNameChange, |
| SetPropertyNameChange, HandlePropertyNameChange ); |
| APPLY_EVENT_OPTION( cTrackPropertyDescriptionItem, |
| trackPropertyDescriptionChange, |
| SetPropertyDescriptionChange, |
| HandlePropertyDescriptionChange ); |
| APPLY_EVENT_OPTION( cTrackPropertyStateItem, trackPropertyStateChange, |
| SetPropertyStateChange, HandlePropertyStateChange ); |
| APPLY_EVENT_OPTION( cTrackPropertyValueItem, trackPropertyValueChange, |
| SetPropertyValueChange, HandlePropertyValueChange ); |
| APPLY_EVENT_OPTION( cTrackPropertySelectionItem, |
| trackPropertySelectionChange, |
| SetPropertySelectionChange, |
| HandlePropertySelectionChange); |
| APPLY_EVENT_OPTION( cTrackPropertyTextItem, trackPropertyTextChange, |
| SetPropertyTextChange, HandlePropertyTextChange ); |
| APPLY_EVENT_OPTION( cTrackPropertyCaretItem, trackPropertyCaretChange, |
| SetPropertyCaretChange, HandlePropertyCaretChange ); |
| APPLY_EVENT_OPTION( cTrackPropertyVisibleDataItem, |
| trackPropertyVisibleDataChange, |
| SetPropertyVisibleDataChange, |
| HandlePropertyVisibleDataChange ); |
| APPLY_EVENT_OPTION( cTrackPropertyChildItem, trackPropertyChildChange, |
| SetPropertyChildChange, HandlePropertyChildChange ); |
| APPLY_EVENT_OPTION( cTrackPropertyActiveDescendentItem, |
| trackPropertyActiveDescendentChange, |
| SetPropertyActiveDescendentChange, |
| HandlePropertyActiveDescendentChange ); |
| APPLY_EVENT_OPTION( cTrackPropertyTableModelChangeItem, |
| trackPropertyTableModelChange, |
| SetPropertyTableModelChange, |
| HandlePropertyTableModelChange ); |
| |
| MaybeCheckMonitorTheSameEventsAsJAWS(menu); |
| MaybeCheckMonitorAllEvents(menu); |
| } |
| |
| BOOL EnableDlgItem(HWND hDlg, int nIDDlgItem, BOOL bEnable) { |
| HWND dlgItem = ::GetDlgItem(hDlg, nIDDlgItem); |
| if ( NULL == dlgItem ) { |
| return FALSE; |
| } |
| return ::EnableWindow (dlgItem, bEnable); |
| } |
| |
| void EnableMessageNavButtons() { |
| HWND FocusWindow = ::GetFocus(); |
| int FocusCtrlID = ::GetDlgCtrlID(FocusWindow); |
| BOOL DisabledFocusWindow = FALSE; |
| if ( 0 == g_MessageHistory.GetMessageCount () ) { |
| EnableDlgItem(theDialogWindow, cFirstMessage, FALSE); |
| EnableDlgItem(theDialogWindow, cPreviousMessage, FALSE); |
| EnableDlgItem(theDialogWindow, cMessageNumber, FALSE); |
| EnableDlgItem(theDialogWindow, cNextMessage, FALSE); |
| EnableDlgItem(theDialogWindow, cLastMessage, FALSE); |
| } else if ( g_MessageHistory.IsFirstMessage () ) { |
| EnableDlgItem(theDialogWindow, cFirstMessage, FALSE); |
| EnableDlgItem(theDialogWindow, cPreviousMessage, FALSE); |
| EnableDlgItem(theDialogWindow, cMessageNumber, TRUE); |
| EnableDlgItem(theDialogWindow, cNextMessage, TRUE); |
| EnableDlgItem(theDialogWindow, cLastMessage, TRUE); |
| if ( ( cFirstMessage == FocusCtrlID ) || |
| ( cPreviousMessage == FocusCtrlID ) ) { |
| DisabledFocusWindow = TRUE; |
| } |
| } else if ( g_MessageHistory.IsLastMessage () ) { |
| EnableDlgItem(theDialogWindow, cFirstMessage, TRUE); |
| EnableDlgItem(theDialogWindow, cPreviousMessage, TRUE); |
| EnableDlgItem(theDialogWindow, cMessageNumber, TRUE); |
| EnableDlgItem(theDialogWindow, cNextMessage, FALSE); |
| EnableDlgItem(theDialogWindow, cLastMessage, FALSE); |
| |
| if ( ( cNextMessage == FocusCtrlID ) || |
| ( cLastMessage == FocusCtrlID ) ) { |
| DisabledFocusWindow = TRUE; |
| } |
| } else { |
| EnableDlgItem(theDialogWindow, cFirstMessage, TRUE); |
| EnableDlgItem(theDialogWindow, cPreviousMessage, TRUE); |
| EnableDlgItem(theDialogWindow, cMessageNumber, TRUE); |
| EnableDlgItem(theDialogWindow, cNextMessage, TRUE); |
| EnableDlgItem(theDialogWindow, cLastMessage, TRUE); |
| } |
| |
| if ( DisabledFocusWindow ) { |
| /* |
| We just disabled the window that had the focus. Set focus to the |
| cjaccessinspectorText window. Otherwise it will no longer be possible |
| to tab through the controls in jaccessinspector. |
| */ |
| HWND jaccessinspectorText = |
| ::GetDlgItem(theDialogWindow, cjaccessinspectorText); |
| if ( jaccessinspectorText ) { |
| ::SetFocus(jaccessinspectorText); |
| } |
| } |
| } |
| |
| void WINAPI AddToMessageHistory(const char * message) { |
| g_MessageHistory.AddMessage(message); |
| EnableMessageNavButtons(); |
| UpdateMessageNumber(); |
| } |
| |
| BOOL UpdateMessageNumber () { |
| HWND dlgItem = ::GetDlgItem(theDialogWindow, cMessageNumber); |
| if ( NULL == dlgItem ) { |
| return FALSE; |
| } |
| |
| size_t messageCount = g_MessageHistory.GetMessageCount(); |
| size_t messageNumber = g_MessageHistory.GetCurrentMessageIndex() + 1; |
| char text [32] = {0}; |
| if ( 0 != messageCount ) { |
| ::_snprintf(text, sizeof(text), "%d of %d", messageNumber, messageCount); |
| } |
| return ::SetWindowText(dlgItem, text); |
| } |
| |
| INT_PTR CALLBACK GoToMessageDialogProc( HWND hDlg, UINT message, WPARAM wParam, |
| LPARAM lParam ) { |
| BOOL ret_val = FALSE; |
| switch ( message ) { |
| case WM_INITDIALOG: |
| { |
| /* |
| This code to center the Go To Message dialog box in the |
| jaccessinspector window was taken from |
| <http://msdn.microsoft.com/en-us/library/ms644996(VS.85).aspx>. |
| */ |
| HWND hwndOwner = NULL; |
| RECT rcOwner = { 0, 0, 0, 0 }; |
| RECT rc = { 0, 0, 0, 0 }; |
| RECT rcDlg = { 0, 0, 0, 0 }; |
| |
| // Get the owner window and dialog box rectangles. |
| if ( NULL == (hwndOwner = GetParent(hDlg)) ) { |
| hwndOwner = GetDesktopWindow(); |
| } |
| |
| GetWindowRect(hwndOwner, &rcOwner); |
| GetWindowRect(hDlg, &rcDlg); |
| CopyRect(&rc, &rcOwner); |
| |
| // Offset the owner and dialog box rectangles so that right and |
| // bottom values represent the width and height, and then offset |
| // the owner again to discard space taken up by the dialog box. |
| OffsetRect(&rcDlg, -rcDlg.left, -rcDlg.top); |
| OffsetRect(&rc, -rc.left, -rc.top); |
| OffsetRect(&rc, -rcDlg.right, -rcDlg.bottom); |
| |
| // The new position is the sum of half the remaining space and the |
| // owner's original position. |
| SetWindowPos (hDlg, |
| HWND_TOP, |
| rcOwner.left + (rc.right / 2), |
| rcOwner.top + (rc.bottom / 2), |
| 0, 0, // Ignores size arguments. |
| SWP_NOSIZE); |
| } |
| break; |
| |
| case WM_COMMAND: |
| switch ( LOWORD (wParam) ) { |
| case IDOK: |
| { |
| size_t GoToMessageNumber = 0; |
| BOOL Translated = FALSE; |
| GoToMessageNumber = GetDlgItemInt( hDlg, IDC_MESSAGE_NUMBER_EDIT, |
| &Translated, FALSE ); |
| EndDialog (hDlg, IDOK); |
| theGoToDialogWindow = NULL; |
| |
| if ( ( Translated ) && ( GoToMessageNumber > 0 ) ) { |
| const char * messageText = NULL; |
| if ( (GoToMessageNumber - 1) < |
| g_MessageHistory.GetMessageCount() ) { |
| messageText = |
| g_MessageHistory.GetMessage(GoToMessageNumber - 1); |
| } else if ( (GoToMessageNumber - 1) >= |
| g_MessageHistory.GetMessageCount() ) { |
| messageText = g_MessageHistory.GetLastMessage(); |
| } |
| if ( ( NULL != messageText ) && ( 0 != messageText [0] ) ) { |
| ::SetDlgItemText( theDialogWindow, cjaccessinspectorText, |
| messageText ); |
| } |
| EnableMessageNavButtons(); |
| UpdateMessageNumber(); |
| } |
| } |
| break; |
| case IDCANCEL: |
| EndDialog(hDlg, IDCANCEL); |
| theGoToDialogWindow = NULL; |
| break; |
| } |
| break; |
| } |
| return ret_val; |
| } |
| |
| BOOL InitGoToMessageDialogBox (HANDLE hInstance) { |
| theGoToDialogWindow = CreateDialog ( |
| (struct HINSTANCE__ *)hInstance, MAKEINTRESOURCE(IDD_GO_TO_MESSAGE), |
| theDialogWindow, GoToMessageDialogProc); |
| |
| if ( NULL == theGoToDialogWindow ) { |
| return FALSE; |
| } |
| |
| ShowWindow (theGoToDialogWindow, SW_SHOW); |
| return TRUE; |
| } |
| |
| BOOL ShouldCheckMonitorTheSameEventsAsJAWS () { |
| if ( |
| ( FALSE == trackMouse ) |
| && ( FALSE == trackMouseExited ) |
| && ( FALSE == trackMouseClicked ) |
| && ( FALSE == trackMousePressed ) |
| && ( FALSE == trackMouseReleased ) |
| && ( TRUE == trackFocus ) |
| && ( TRUE == trackFocusLost ) |
| && ( FALSE == trackCaret ) |
| && ( FALSE == trackShutdown ) |
| && ( FALSE == trackMenuSelected ) |
| && ( FALSE == trackMenuDeselected ) |
| && ( FALSE == trackMenuCanceled ) |
| && ( FALSE == trackPopupVisible ) |
| && ( FALSE == trackPopupInvisible ) |
| && ( FALSE == trackPopupCanceled ) |
| && ( TRUE == trackPropertyNameChange ) |
| && ( TRUE == trackPropertyDescriptionChange ) |
| && ( TRUE == trackPropertyStateChange ) |
| && ( TRUE == trackPropertyValueChange ) |
| && ( TRUE == trackPropertySelectionChange ) |
| && ( TRUE == trackPropertyTextChange ) |
| && ( TRUE == trackPropertyCaretChange ) |
| && ( FALSE == trackPropertyVisibleDataChange ) |
| && ( TRUE == trackPropertyChildChange ) |
| && ( TRUE == trackPropertyActiveDescendentChange ) |
| && ( FALSE == trackPropertyTableModelChange ) |
| ) |
| { |
| return TRUE; |
| } |
| |
| return FALSE; |
| } |
| |
| void MaybeCheckMonitorTheSameEventsAsJAWS(HMENU menu) { |
| UINT uCheck = MF_BYCOMMAND | MF_UNCHECKED; |
| if ( ShouldCheckMonitorTheSameEventsAsJAWS() ) { |
| uCheck = MF_BYCOMMAND | MF_CHECKED; |
| } |
| ::CheckMenuItem(menu, cMonitorTheSameEventsAsJAWS, uCheck); |
| } |
| |
| BOOL ShouldCheckMonitorAllEvents() { |
| if ( |
| ( TRUE == trackMouse ) |
| && ( TRUE == trackMouseExited ) |
| && ( TRUE == trackMouseClicked ) |
| && ( TRUE == trackMousePressed ) |
| && ( TRUE == trackMouseReleased ) |
| && ( TRUE == trackFocus ) |
| && ( TRUE == trackFocusLost ) |
| && ( TRUE == trackCaret ) |
| && ( TRUE == trackShutdown ) |
| && ( TRUE == trackMenuSelected ) |
| && ( TRUE == trackMenuDeselected ) |
| && ( TRUE == trackMenuCanceled ) |
| && ( TRUE == trackPopupVisible ) |
| && ( TRUE == trackPopupInvisible ) |
| && ( TRUE == trackPopupCanceled ) |
| && ( TRUE == trackPropertyNameChange ) |
| && ( TRUE == trackPropertyDescriptionChange ) |
| && ( TRUE == trackPropertyStateChange ) |
| && ( TRUE == trackPropertyValueChange ) |
| && ( TRUE == trackPropertySelectionChange ) |
| && ( TRUE == trackPropertyTextChange ) |
| && ( TRUE == trackPropertyCaretChange ) |
| && ( TRUE == trackPropertyVisibleDataChange ) |
| && ( TRUE == trackPropertyChildChange ) |
| && ( TRUE == trackPropertyActiveDescendentChange ) |
| && ( TRUE == trackPropertyTableModelChange ) |
| ) |
| { |
| return TRUE; |
| } |
| |
| return FALSE; |
| } |
| |
| void MaybeCheckMonitorAllEvents(HMENU menu) { |
| UINT uCheck = MF_BYCOMMAND | MF_UNCHECKED; |
| if ( ShouldCheckMonitorAllEvents() ) { |
| uCheck = MF_BYCOMMAND | MF_CHECKED; |
| } |
| ::CheckMenuItem(menu, cMonitorAllEvents, uCheck); |
| } |