| /* |
| * Copyright (c) 2005, 2019, 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 DLL which is loaded by Java applications to handle communication |
| * between Java VMs purposes of Accessbility. |
| */ |
| |
| #include "AccessBridgeDebug.h" |
| #include "JavaAccessBridge.h" |
| #include "com_sun_java_accessibility_internal_AccessBridge.h" // programatically generated by JNI |
| #include "accessBridgeResource.h" |
| #include "accessBridgeCallbacks.h" |
| #include "AccessBridgeMessages.h" |
| |
| |
| #include <windows.h> |
| #include <stdio.h> |
| |
| #include <jawt.h> |
| #include <jawt_md.h> |
| |
| JavaAccessBridge *theJavaAccessBridge; |
| HWND theDialogWindow; |
| |
| // re-entrance lock for receiving memory messages |
| CRITICAL_SECTION receiveMemoryIPCLock; |
| |
| |
| // unique broadcast msg. IDs gotten dymanically |
| extern UINT theFromJavaHelloMsgID; |
| extern UINT theFromWindowsHelloMsgID; |
| |
| |
| // --------------------------------------------------------------------------- |
| |
| extern "C" { |
| /** |
| * DllMain - where Windows executables will load/unload us |
| * |
| */ |
| BOOL WINAPI DllMain(HINSTANCE hinstDll, DWORD fdwReason, LPVOID lpvReserved) { |
| |
| switch (fdwReason) { |
| case DLL_PROCESS_ATTACH: |
| InitializeCriticalSection(&receiveMemoryIPCLock); |
| theJavaAccessBridge = new JavaAccessBridge(hinstDll); |
| break; |
| |
| case DLL_PROCESS_DETACH: // A Windows executable unloaded us |
| if (theJavaAccessBridge != (JavaAccessBridge *) 0) { |
| delete theJavaAccessBridge; |
| DeleteCriticalSection(&receiveMemoryIPCLock); |
| } |
| break; |
| } |
| return TRUE; |
| } |
| |
| /** |
| * Open a native window (and init the wrappers we'll be using) |
| * |
| */ |
| JNIEXPORT void JNICALL |
| Java_com_sun_java_accessibility_internal_AccessBridge_runDLL(JNIEnv *env, jobject obj) { |
| PrintDebugString("[INFO]: JavaAccessBridge.DLL runDLL() called"); |
| theJavaAccessBridge->javaRun(env, obj); |
| } |
| |
| /** |
| * Our window proc |
| * |
| */ |
| BOOL APIENTRY AccessBridgeDialogProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) { |
| int command; |
| COPYDATASTRUCT *sentToUs; |
| char *package; |
| |
| switch (message) { |
| case WM_INITDIALOG: |
| PrintDebugString("[INFO]: In AccessBridgeDialog - Initializing"); |
| break; |
| |
| case WM_COMMAND: |
| command = LOWORD (wParam); |
| PrintDebugString("[INFO]: In AccessBridgeDialog - Got WM_COMMAND, command: %X", command); |
| break; |
| |
| // call from Java with data for us to deliver |
| case WM_COPYDATA: |
| if (theDialogWindow == (HWND) wParam) { |
| PrintDebugString("[INFO]: In AccessBridgeDialog - Got WM_COPYDATA from ourselves"); |
| } else { |
| PrintDebugString("[INFO]: In AccessBridgeDialog - Got WM_COPYDATA from HWND %p", wParam); |
| sentToUs = (COPYDATASTRUCT *) lParam; |
| package = (char *) sentToUs->lpData; |
| theJavaAccessBridge->processPackage(package, sentToUs->cbData); |
| } |
| break; |
| |
| // call from Java with data for us retrieve from memory mapped file and deliver |
| case AB_MESSAGE_WAITING: |
| // wParam == sourceHwnd |
| // lParam == buffer size in shared memory |
| if (theDialogWindow == (HWND) wParam) { |
| PrintDebugString("[INFO]: In AccessBridgeDialog - Got AB_MESSAGE_WAITING from ourselves"); |
| } else { |
| PrintDebugString("[INFO]: In AccessBridgeDialog - Got AB_MESSAGE_WAITING from HWND %p", wParam); |
| LRESULT returnVal = theJavaAccessBridge->receiveMemoryPackage((HWND) wParam, (long) lParam); |
| } |
| break; |
| |
| // a JavaAccessBridge DLL is going away |
| case AB_DLL_GOING_AWAY: |
| PrintDebugString("[INFO]: In AccessBridgeDialog - Got AB_DLL_GOING_AWAY message"); |
| theJavaAccessBridge->WindowsATDestroyed((HWND) wParam); |
| break; |
| |
| default: |
| // the Windows AT is saying "hi"! |
| // wParam == sourceHwnc; lParam unused |
| if (message == theFromWindowsHelloMsgID) { |
| // A new Windows AT just said "hi"; |
| // say "hi" back so it can mate up with us |
| // otherwise don't do anything (e.g. don't set up data structures yet) |
| PrintDebugString("[INFO]: In AccessBridgeDialog - Got theFromWindowsHelloMsgID message"); |
| theJavaAccessBridge->postHelloToWindowsDLLMsg((HWND) wParam); |
| } |
| } |
| return FALSE; |
| } |
| |
| } |
| |
| |
| // ----------------------------- |
| |
| |
| /** |
| * Initialize the JavaAccessBridge |
| * |
| */ |
| JavaAccessBridge::JavaAccessBridge(HINSTANCE hInstance) { |
| windowsInstance = hInstance; |
| ATs = (AccessBridgeATInstance *) 0; |
| initializeFileLogger("java_access_bridge"); |
| initBroadcastMessageIDs(); // get the unique to us broadcast msg. IDs |
| } |
| |
| extern DWORD JavaBridgeThreadId; |
| |
| /** |
| * Destroy the JavaAccessBridge |
| * |
| */ |
| JavaAccessBridge::~JavaAccessBridge() { |
| // inform all other AccessBridges that we're going away |
| |
| PrintDebugString("[INFO]: in JavaAccessBridge::~JavaAccessBridge()"); |
| |
| // Send a shutdown message for those applications like StarOffice that do |
| // send a shutdown message themselves. |
| javaShutdown(NULL, 0); |
| |
| AccessBridgeATInstance *current = ATs; |
| while (current != (AccessBridgeATInstance *) 0) { |
| PrintDebugString("[INFO]: telling %p we're going away", current->winAccessBridgeWindow); |
| SendMessage(current->winAccessBridgeWindow, |
| AB_DLL_GOING_AWAY, (WPARAM) dialogWindow, (LPARAM) 0); |
| current = current->nextATInstance; |
| } |
| |
| PrintDebugString("[INFO]: finished telling ATs about our demise"); |
| |
| if(JavaBridgeThreadId) |
| { |
| PostThreadMessage(JavaBridgeThreadId,WM_USER+1,0,0); |
| Sleep(100); |
| } |
| |
| delete ATs; |
| |
| PrintDebugString("[INFO]: finished deleting ATs"); |
| PrintDebugString("[INFO]: GOODBYE CRUEL WORLD..."); |
| finalizeFileLogger(); |
| } |
| |
| |
| void |
| JavaAccessBridge::javaRun(JNIEnv *env, jobject obj) { |
| MSG msg; |
| |
| PrintDebugString("[INFO]: JavaAccessBridge::javaRun(%p, %p) called", env, obj); |
| |
| if (env->GetJavaVM(&javaVM) != 0) { |
| return; // huh!?!?! |
| } |
| PrintDebugString("[INFO]: -> javaVM = %p", javaVM); |
| |
| if (javaVM->AttachCurrentThread((void **) &windowsThreadJNIEnv, NULL) != 0) { |
| return; // huh!?!?! |
| } |
| PrintDebugString("[INFO]: -> windowsThreadJNIEnv = %p", windowsThreadJNIEnv); |
| |
| javaThreadABObject = env->NewGlobalRef(obj); |
| windowsThreadABObject = windowsThreadJNIEnv->NewGlobalRef(obj); |
| |
| // initialize the Java thread AccessBridge entry points |
| javaThreadEntryPoints = new AccessBridgeJavaEntryPoints(env, javaThreadABObject); |
| if (javaThreadEntryPoints->BuildJavaEntryPoints() == FALSE) { |
| return; // couldn't build our entry points; let's get out of here! |
| } |
| PrintDebugString("[INFO]: all Java thread entry points successfully found."); |
| |
| // initialize the Windows thread AccessBridge entry points |
| windowsThreadEntryPoints = new AccessBridgeJavaEntryPoints(windowsThreadJNIEnv, |
| windowsThreadABObject); |
| if (windowsThreadEntryPoints->BuildJavaEntryPoints() == FALSE) { |
| return; // couldn't build our entry points; let's get out of here! |
| } |
| PrintDebugString("[INFO]: all Windows thread entry points successfully found."); |
| |
| |
| // open our window |
| if (initWindow() == TRUE) { |
| PrintDebugString("[INFO]: Window created. HWND = %p", dialogWindow); |
| |
| // post a broadcast msg.; let other AccessBridge DLLs know we exist |
| postHelloToWindowsDLLMsg(HWND_BROADCAST); |
| |
| // do that message loop thing |
| while (GetMessage(&msg, NULL, 0, 0)) { |
| TranslateMessage(&msg); |
| DispatchMessage(&msg); |
| } |
| } else { |
| PrintDebugString("[ERROR]: FAILED TO CREATE WINDOW!!!"); |
| } |
| |
| javaVM->DetachCurrentThread(); |
| } |
| |
| /** |
| * Bring up our window; make a connection to the rest of the world |
| * |
| */ |
| BOOL |
| JavaAccessBridge::initWindow() { |
| theDialogWindow = CreateDialog(windowsInstance, |
| "ACCESSBRIDGESTATUSWINDOW", NULL, |
| (DLGPROC) AccessBridgeDialogProc); |
| |
| // If window could not be created, return "failure". |
| if (!theDialogWindow) |
| return FALSE; |
| |
| dialogWindow = theDialogWindow; |
| |
| // Make the window visible, update its client area, & return "success". |
| // DEBUG_CODE(ShowWindow (theDialogWindow, SW_SHOWNORMAL)); |
| // DEBUG_CODE(UpdateWindow (theDialogWindow)); |
| |
| return TRUE; |
| } |
| |
| |
| |
| // ----------------------- |
| |
| |
| /** |
| * postHelloToWindowsDLLMsg |
| * - PostMessage(theFromJavaHelloMsgID) to let one or |
| * all WindowDLLs we're here and have a vmID |
| * |
| * destHwnd is either a single hwnd or HWND_BROADCAST |
| * (former if a reply, latter if we're just born) |
| * wParam is our HWND |
| * lParam is our vmID |
| * |
| */ |
| void |
| JavaAccessBridge::postHelloToWindowsDLLMsg(HWND destHwnd) { |
| PrintDebugString("[INFO]: In JavaAccessBridge::postHelloToWindowsDLLMsg"); |
| PrintDebugString("[INFO]: calling PostMessage(%p, %X, %p, %p)", |
| destHwnd, theFromJavaHelloMsgID, dialogWindow, dialogWindow); |
| PostMessage(destHwnd, theFromJavaHelloMsgID, (WPARAM) dialogWindow, (LPARAM) dialogWindow); |
| } |
| |
| |
| // ----------------------- |
| |
| /** |
| * sendPackage - uses SendMessage(WM_COPYDATA) to do IPC messaging |
| * with the Java AccessBridge DLL |
| * |
| */ |
| void |
| JavaAccessBridge::sendPackage(char *buffer, int bufsize, HWND destHwnd) { |
| COPYDATASTRUCT toCopy; |
| toCopy.dwData = 0; // 32-bits we could use for something... |
| toCopy.cbData = bufsize; |
| toCopy.lpData = buffer; |
| |
| SendMessage(destHwnd, WM_COPYDATA, (WPARAM) dialogWindow, (LPARAM) &toCopy); |
| } |
| |
| |
| /** |
| * sendJavaEventPackage - walk through ATs, sending event messages to 'em |
| * |
| */ |
| void |
| JavaAccessBridge::sendJavaEventPackage(char *buffer, int bufsize, long type) { |
| |
| PrintDebugString("[INFO]: JavaAccessBridge::sendJavaEventPackage(), type = %X", type); |
| |
| if (ATs == (AccessBridgeATInstance *) 0) { |
| PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)"); |
| } |
| |
| AccessBridgeATInstance *ati = ATs; |
| while (ati != (AccessBridgeATInstance *) 0) { |
| ati->sendJavaEventPackage(buffer, bufsize, type); |
| ati = ati->nextATInstance; |
| } |
| } |
| |
| /** |
| * sendAccessibilityEventPackage - walk through ATs, sending event messages to 'em |
| * |
| */ |
| void |
| JavaAccessBridge::sendAccessibilityEventPackage(char *buffer, int bufsize, long type) { |
| |
| PrintDebugString("[INFO]: JavaAccessBridge::sendAccessibilityEventPackage(), type = %X", type); |
| |
| if (ATs == (AccessBridgeATInstance *) 0) { |
| PrintDebugString("[ERROR] ATs == 0! (shouldn't happen here!)"); |
| } |
| |
| AccessBridgeATInstance *ati = ATs; |
| while (ati != (AccessBridgeATInstance *) 0) { |
| ati->sendAccessibilityEventPackage(buffer, bufsize, type); |
| ati = ati->nextATInstance; |
| } |
| } |
| |
| |
| |
| |
| /** |
| * receiveMemoryPackage - uses Memory-Mapped files to do IPC messaging |
| * with the Java AccessBridge DLL, receiving the |
| * message from Java AccessBridge DLL by reading the |
| * contents of the shared memory mapped file that |
| * is used for Java-initiated messages |
| * |
| */ |
| BOOL |
| JavaAccessBridge::receiveMemoryPackage(HWND srcWindow, long bufsize) { |
| char *IPCview; |
| |
| PrintDebugString("[INFO]: JavaAccessBridge::receiveMemoryPackage(%p, %d)", srcWindow, bufsize); |
| |
| // look-up the appropriate IPCview based on the srcHWND of the Windows AccessBridge DLL |
| if (ATs == (AccessBridgeATInstance *) 0) { |
| PrintDebugString("[ERROR]: - ATs == 0 (shouldn't happen in receiveMemoryPackage()!"); |
| return FALSE; |
| } |
| AccessBridgeATInstance *ati = ATs->findABATInstanceFromATHWND(srcWindow); |
| if (ati != (AccessBridgeATInstance *) 0) { |
| IPCview = (char *) ati->memoryMappedView; |
| |
| // wait for the lock if someone else has it (re-entrancy) |
| EnterCriticalSection(&receiveMemoryIPCLock); |
| { |
| // set byte at end of buffer to indicate to caller that we have reached this point |
| IPCview[bufsize] = 1; |
| |
| // process the package |
| processPackage(IPCview, bufsize); |
| } |
| // release re-entrance lock |
| LeaveCriticalSection(&receiveMemoryIPCLock); |
| |
| return TRUE; |
| |
| } else { |
| //DEBUG_CODE(AppendToCallInfo("ERROR receiving memory package: couldn't find srcWindow")); |
| PrintDebugString("[ERROR]: receiving memory package: couldn't find srcWindow"); |
| return FALSE; |
| } |
| } |
| |
| /** |
| * processPackage - processes the output of SendMessage(WM_COPYDATA) |
| * to do IPC messaging with the Windows AccessBridge DLL |
| * |
| */ |
| LRESULT |
| JavaAccessBridge::processPackage(char *buffer, int bufsize) { |
| PrintDebugString("[INFO]: Processing package sent from Windows, bufsize = %d:", bufsize); |
| |
| PackageType *type = (PackageType *) buffer; |
| LRESULT returnVal = 0; |
| PrintDebugString("[INFO]: PackageType = %X:", *type); |
| jobject rAC; |
| |
| switch (*type) { |
| |
| |
| case cMemoryMappedFileCreatedPackage: |
| // Windows is telling us it created a memory mapped file for us to use |
| // in repsonding to various information querying packages (see below) |
| PrintDebugString("[INFO]: type == cMemoryMappedFileCreatedPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(MemoryMappedFileCreatedPackage))) { |
| MemoryMappedFileCreatedPackage *pkg = |
| (MemoryMappedFileCreatedPackage *) (buffer + sizeof(PackageType)); |
| returnVal = MemoryMappedFileCreated((HWND)ABLongToHandle(pkg->bridgeWindow), pkg->filename); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(MemoryMappedFileCreatedPackage)); |
| } |
| break; |
| |
| // ------------ information querying packages ------------------ |
| |
| case cReleaseJavaObjectPackage: |
| PrintDebugString("[INFO]: type == cReleaseJavaObjectPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(ReleaseJavaObjectPackage))) { |
| ReleaseJavaObjectPackage *pkg = |
| (ReleaseJavaObjectPackage *) (buffer + sizeof(PackageType)); |
| releaseJavaObject((jobject)pkg->object); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(ReleaseJavaObjectPackage)); |
| } |
| break; |
| |
| case cGetAccessBridgeVersionPackage: |
| PrintDebugString("[INFO]: type == cGetAccessBridgeVersionPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessBridgeVersionPackage))) { |
| GetAccessBridgeVersionPackage *pkg = |
| (GetAccessBridgeVersionPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getVersionInfo(&(pkg->rVersionInfo)); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessBridgeVersionPackage)); |
| } |
| break; |
| |
| case cIsJavaWindowPackage: |
| PrintDebugString("[INFO]: type == cIsJavaWindowPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(IsJavaWindowPackage))) { |
| IsJavaWindowPackage *pkg = |
| (IsJavaWindowPackage *) (buffer + sizeof(PackageType)); |
| pkg->rResult = |
| windowsThreadEntryPoints->isJavaWindow(pkg->window); |
| PrintDebugString("[INFO]: -> returning result = %d", pkg->rResult); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(IsJavaWindowPackage)); |
| } |
| break; |
| |
| case cIsSameObjectPackage: |
| PrintDebugString("[INFO]: type == cIsSameObjectPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(IsSameObjectPackage))) { |
| IsSameObjectPackage *pkg = |
| (IsSameObjectPackage *) (buffer + sizeof(PackageType)); |
| pkg->rResult = |
| windowsThreadEntryPoints->isSameObject((jobject)pkg->obj1, (jobject)pkg->obj2); |
| PrintDebugString("[INFO]: -> returning result = %d", pkg->rResult); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(IsSameObjectPackage)); |
| } |
| break; |
| |
| |
| case cGetAccessibleContextFromHWNDPackage: |
| PrintDebugString("[INFO]: type == cGetAccessibleContextFromHWNDPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleContextFromHWNDPackage))) { |
| GetAccessibleContextFromHWNDPackage *pkg = |
| (GetAccessibleContextFromHWNDPackage *) (buffer + sizeof(PackageType)); |
| rAC = windowsThreadEntryPoints->getAccessibleContextFromHWND(pkg->window); |
| pkg->rAccessibleContext = (JOBJECT64)rAC; |
| pkg->rVMID = HandleToLong(dialogWindow); |
| PrintDebugString("[INFO]: -> returning AC = %p, vmID = %X", rAC, pkg->rVMID); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleContextFromHWNDPackage)); |
| } |
| break; |
| |
| |
| case cGetHWNDFromAccessibleContextPackage: |
| PrintDebugString("[INFO]: type == cGetHWNDFromAccessibleContextPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetHWNDFromAccessibleContextPackage))) { |
| GetHWNDFromAccessibleContextPackage *pkg = |
| (GetHWNDFromAccessibleContextPackage *) (buffer + sizeof(PackageType)); |
| pkg->rHWND = |
| ABHandleToLong( windowsThreadEntryPoints->getHWNDFromAccessibleContext((jobject)pkg->accessibleContext) ); |
| PrintDebugString("[INFO]: -> returning HWND = %p", pkg->rHWND); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetHWNDFromAccessibleContextPackage)); |
| } |
| break; |
| |
| |
| /* ===== utility methods ===== */ |
| |
| case cSetTextContentsPackage: |
| PrintDebugString("[INFO]: type == cSetTextContentsPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(SetTextContentsPackage))) { |
| SetTextContentsPackage *pkg = |
| (SetTextContentsPackage *) (buffer + sizeof(PackageType)); |
| pkg->rResult = |
| windowsThreadEntryPoints->setTextContents((jobject)pkg->accessibleContext, pkg->text); |
| PrintDebugString("[INFO]: -> returning result = %d", pkg->rResult); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(SetTextContentsPackage)); |
| } |
| break; |
| |
| case cGetParentWithRolePackage: |
| if (bufsize == (sizeof(PackageType) + sizeof(GetParentWithRolePackage))) { |
| GetParentWithRolePackage *pkg = |
| (GetParentWithRolePackage *) (buffer + sizeof(PackageType)); |
| rAC = windowsThreadEntryPoints->getParentWithRole((jobject)pkg->accessibleContext, pkg->role); |
| pkg->rAccessibleContext = (JOBJECT64)rAC; |
| PrintDebugString("[INFO]: type == cGetParentWithRolePackage\n"\ |
| " pkg->vmID: %X"\ |
| " pkg->accessibleContext: %p"\ |
| " pkg->role: %ls"\ |
| " -> returning rAccessibleContext = %p"\ |
| , pkg->vmID, (jobject)pkg->accessibleContext, pkg->role, rAC); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetParentWithRolePackage)); |
| } |
| break; |
| |
| case cGetTopLevelObjectPackage: |
| PrintDebugString("[INFO]: type == cGetTopLevelObjectPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetTopLevelObjectPackage))) { |
| GetTopLevelObjectPackage *pkg = |
| (GetTopLevelObjectPackage *) (buffer + sizeof(PackageType)); |
| rAC = windowsThreadEntryPoints->getTopLevelObject((jobject)pkg->accessibleContext); |
| pkg->rAccessibleContext = (JOBJECT64)rAC; |
| PrintDebugString("[INFO]: -> returning rAccessibleContext = %p", rAC); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetTopLevelObjectPackage)); |
| } |
| break; |
| |
| case cGetParentWithRoleElseRootPackage: |
| PrintDebugString("[INFO]: type == cGetParentWithRoleElseRootPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetParentWithRoleElseRootPackage))) { |
| GetParentWithRoleElseRootPackage *pkg = |
| (GetParentWithRoleElseRootPackage *) (buffer + sizeof(PackageType)); |
| rAC = windowsThreadEntryPoints->getParentWithRoleElseRoot((jobject)pkg->accessibleContext, pkg->role); |
| pkg->rAccessibleContext = (JOBJECT64)rAC; |
| PrintDebugString("[INFO]: -> returning rAccessibleContext = %p", rAC); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetParentWithRoleElseRootPackage)); |
| } |
| break; |
| |
| case cGetObjectDepthPackage: |
| PrintDebugString("[INFO]: type == cGetObjectDepthPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetObjectDepthPackage))) { |
| GetObjectDepthPackage *pkg = |
| (GetObjectDepthPackage *) (buffer + sizeof(PackageType)); |
| pkg->rResult = |
| windowsThreadEntryPoints->getObjectDepth((jobject)pkg->accessibleContext); |
| PrintDebugString("[INFO]: -> returning rResult = %d", pkg->rResult); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetObjectDepthPackage)); |
| } |
| break; |
| |
| case cGetActiveDescendentPackage: |
| PrintDebugString("[INFO]: type == cGetActiveDescendentPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetActiveDescendentPackage))) { |
| GetActiveDescendentPackage *pkg = |
| (GetActiveDescendentPackage *) (buffer + sizeof(PackageType)); |
| rAC = windowsThreadEntryPoints->getActiveDescendent((jobject)pkg->accessibleContext); |
| pkg->rAccessibleContext = (JOBJECT64)rAC; |
| PrintDebugString("[INFO]: -> returning rAccessibleContext = %p", rAC); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetActiveDescendentPackage)); |
| } |
| break; |
| |
| case cGetAccessibleContextAtPackage: |
| PrintDebugString("[INFO]: type == cGetAccessibleContextAtPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleContextAtPackage))) { |
| GetAccessibleContextAtPackage *pkg = |
| (GetAccessibleContextAtPackage *) (buffer + sizeof(PackageType)); |
| pkg->rAccessibleContext = (JOBJECT64) |
| windowsThreadEntryPoints->getAccessibleContextAt(pkg->x, pkg->y, |
| (jobject)pkg->AccessibleContext); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleContextAtPackage)); |
| } |
| break; |
| |
| case cGetAccessibleContextWithFocusPackage: |
| PrintDebugString("[INFO]: type == cGetAccessibleContextWithFocusPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleContextWithFocusPackage))) { |
| GetAccessibleContextWithFocusPackage *pkg = |
| (GetAccessibleContextWithFocusPackage *) (buffer + sizeof(PackageType)); |
| pkg->rAccessibleContext = (JOBJECT64) |
| windowsThreadEntryPoints->getAccessibleContextWithFocus(); |
| pkg->rVMID = HandleToLong(dialogWindow); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleContextWithFocusPackage)); |
| } |
| break; |
| |
| case cGetAccessibleContextInfoPackage: |
| PrintDebugString("[INFO]: type == cGetAccessibleContextInfoPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleContextInfoPackage))) { |
| GetAccessibleContextInfoPackage *pkg = |
| (GetAccessibleContextInfoPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getAccessibleContextInfo( |
| (jobject)pkg->AccessibleContext, &(pkg->rAccessibleContextInfo)); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleContextInfoPackage)); |
| } |
| break; |
| |
| case cGetAccessibleChildFromContextPackage: |
| PrintDebugString("[INFO]: type == cGetAccessibleChildFromContextPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleChildFromContextPackage))) { |
| GetAccessibleChildFromContextPackage *pkg = |
| (GetAccessibleChildFromContextPackage *) (buffer + sizeof(PackageType)); |
| pkg->rAccessibleContext = (JOBJECT64)windowsThreadEntryPoints->getAccessibleChildFromContext( |
| (jobject)pkg->AccessibleContext, pkg->childIndex); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleChildFromContextPackage)); |
| } |
| break; |
| |
| case cGetAccessibleParentFromContextPackage: |
| PrintDebugString("[INFO]: type == cGetAccessibleParentFromContextPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleParentFromContextPackage))) { |
| GetAccessibleParentFromContextPackage *pkg = |
| (GetAccessibleParentFromContextPackage *) (buffer + sizeof(PackageType)); |
| pkg->rAccessibleContext = (JOBJECT64)windowsThreadEntryPoints->getAccessibleParentFromContext( |
| (jobject)pkg->AccessibleContext); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleParentFromContextPackage)); |
| } |
| break; |
| |
| // ------------ begin AccessibleTable packages ------------------ |
| |
| case cGetAccessibleTableInfoPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleTableInfoPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableInfoPackage))) { |
| GetAccessibleTableInfoPackage *pkg = |
| (GetAccessibleTableInfoPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getAccessibleTableInfo((jobject)pkg->accessibleContext, |
| &(pkg->rTableInfo)); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableInfoPackage)); |
| } |
| break; |
| |
| case cGetAccessibleTableCellInfoPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleTableCellInfoPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableCellInfoPackage))) { |
| GetAccessibleTableCellInfoPackage *pkg = |
| (GetAccessibleTableCellInfoPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getAccessibleTableCellInfo((jobject)pkg->accessibleTable, pkg->row, |
| pkg->column, &(pkg->rTableCellInfo)); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableCellInfoPackage)); |
| } |
| break; |
| |
| case cGetAccessibleTableRowHeaderPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleTableRowHeaderPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableRowHeaderPackage))) { |
| GetAccessibleTableRowHeaderPackage *pkg = |
| (GetAccessibleTableRowHeaderPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getAccessibleTableRowHeader((jobject)pkg->accessibleContext, |
| &(pkg->rTableInfo)); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableRowHeaderPackage)); |
| } |
| break; |
| |
| case cGetAccessibleTableColumnHeaderPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleTableColumnHeaderPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableColumnHeaderPackage))) { |
| GetAccessibleTableColumnHeaderPackage *pkg = |
| (GetAccessibleTableColumnHeaderPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getAccessibleTableColumnHeader((jobject)pkg->accessibleContext, |
| &(pkg->rTableInfo)); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableColumnHeaderPackage)); |
| } |
| break; |
| |
| |
| case cGetAccessibleTableRowDescriptionPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleTableRowDescriptionPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableRowDescriptionPackage))) { |
| GetAccessibleTableRowDescriptionPackage *pkg = |
| (GetAccessibleTableRowDescriptionPackage *) (buffer + sizeof(PackageType)); |
| pkg->rAccessibleContext = (JOBJECT64)windowsThreadEntryPoints->getAccessibleTableRowDescription( |
| (jobject)pkg->accessibleContext, pkg->row); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableRowDescriptionPackage)); |
| } |
| break; |
| |
| case cGetAccessibleTableColumnDescriptionPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleTableColumnDescriptionPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableColumnDescriptionPackage))) { |
| GetAccessibleTableColumnDescriptionPackage *pkg = |
| (GetAccessibleTableColumnDescriptionPackage *) (buffer + sizeof(PackageType)); |
| pkg->rAccessibleContext = (JOBJECT64)windowsThreadEntryPoints->getAccessibleTableColumnDescription( |
| (jobject)pkg->accessibleContext, pkg->column); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableColumnDescriptionPackage)); |
| } |
| break; |
| |
| case cGetAccessibleTableColumnSelectionCountPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleTableColumnSelectionCountPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableColumnSelectionCountPackage))) { |
| GetAccessibleTableColumnSelectionCountPackage *pkg = |
| (GetAccessibleTableColumnSelectionCountPackage *) (buffer + sizeof(PackageType)); |
| pkg->rCount = windowsThreadEntryPoints->getAccessibleTableColumnSelectionCount( |
| (jobject)pkg->accessibleTable); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableColumnSelectionCountPackage)); |
| } |
| break; |
| |
| case cGetAccessibleTableRowSelectionCountPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleTableRowSelectionCountPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableRowSelectionCountPackage))) { |
| GetAccessibleTableRowSelectionCountPackage *pkg = |
| (GetAccessibleTableRowSelectionCountPackage *) (buffer + sizeof(PackageType)); |
| |
| pkg->rCount = windowsThreadEntryPoints->getAccessibleTableRowSelectionCount( |
| (jobject)pkg->accessibleTable); |
| |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableRowSelectionCountPackage)); |
| } |
| break; |
| |
| case cIsAccessibleTableRowSelectedPackage: |
| PrintDebugString("[INFO]: ##### type == cIsAccessibleTableRowSelectedPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(IsAccessibleTableRowSelectedPackage))) { |
| IsAccessibleTableRowSelectedPackage *pkg = |
| (IsAccessibleTableRowSelectedPackage *) (buffer + sizeof(PackageType)); |
| pkg->rResult = windowsThreadEntryPoints->isAccessibleTableRowSelected( |
| (jobject)pkg->accessibleTable, pkg->row); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(IsAccessibleTableRowSelectedPackage)); |
| } |
| break; |
| |
| case cIsAccessibleTableColumnSelectedPackage: |
| PrintDebugString("[INFO]: ##### type == cIsAccessibleTableColumnSelectedPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(IsAccessibleTableColumnSelectedPackage))) { |
| IsAccessibleTableColumnSelectedPackage *pkg = |
| (IsAccessibleTableColumnSelectedPackage *) (buffer + sizeof(PackageType)); |
| pkg->rResult = windowsThreadEntryPoints->isAccessibleTableColumnSelected( |
| (jobject)pkg->accessibleTable, pkg->column); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(IsAccessibleTableColumnSelectedPackage)); |
| } |
| break; |
| |
| case cGetAccessibleTableColumnSelectionsPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleTableColumnSelectionsPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableColumnSelectionsPackage))) { |
| GetAccessibleTableColumnSelectionsPackage *pkg = |
| (GetAccessibleTableColumnSelectionsPackage *) (buffer + sizeof(PackageType)); |
| PrintDebugString("[INFO]: ##### cGetAccessibleTableColumnSelectionsPackage count=%d", pkg->count); |
| windowsThreadEntryPoints->getAccessibleTableColumnSelections( |
| (jobject)pkg->accessibleTable, pkg->count, pkg->rSelections); |
| |
| for (int i = 0; i < pkg->count; i++) { |
| PrintDebugString("[INFO]: ##### cGetAccessibleTableColumnSelectionsPackage(%d)=%d", i, pkg->rSelections[i]); |
| } |
| |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableColumnSelectionsPackage)); |
| } |
| break; |
| |
| |
| case cGetAccessibleTableRowSelectionsPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleTableRowSelectionsPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableRowSelectionsPackage))) { |
| GetAccessibleTableRowSelectionsPackage *pkg = |
| (GetAccessibleTableRowSelectionsPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getAccessibleTableRowSelections( |
| (jobject)pkg->accessibleTable, pkg->count, pkg->rSelections); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableRowSelectionsPackage)); |
| } |
| break; |
| |
| case cGetAccessibleTableRowPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleTableRowPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableRowPackage))) { |
| GetAccessibleTableRowPackage *pkg = |
| (GetAccessibleTableRowPackage *) (buffer + sizeof(PackageType)); |
| pkg->rRow = windowsThreadEntryPoints->getAccessibleTableRow( |
| (jobject)pkg->accessibleTable, pkg->index); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableRowPackage)); |
| } |
| break; |
| |
| case cGetAccessibleTableColumnPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleTableColumnPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableColumnPackage))) { |
| GetAccessibleTableColumnPackage *pkg = |
| (GetAccessibleTableColumnPackage *) (buffer + sizeof(PackageType)); |
| pkg->rColumn = windowsThreadEntryPoints->getAccessibleTableColumn( |
| (jobject)pkg->accessibleTable, pkg->index); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableColumnPackage)); |
| } |
| break; |
| |
| case cGetAccessibleTableIndexPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleTableIndexPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableIndexPackage))) { |
| GetAccessibleTableIndexPackage *pkg = |
| (GetAccessibleTableIndexPackage *) (buffer + sizeof(PackageType)); |
| pkg->rIndex = windowsThreadEntryPoints->getAccessibleTableIndex( |
| (jobject)pkg->accessibleTable, pkg->row, pkg->column); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableIndexPackage)); |
| } |
| break; |
| |
| // ------------ end AccessibleTable packages ------------------ |
| |
| |
| // ------------ begin AccessibleRelationSet packages ------------------ |
| |
| case cGetAccessibleRelationSetPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleRelationSetPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleRelationSetPackage))) { |
| GetAccessibleRelationSetPackage *pkg = |
| (GetAccessibleRelationSetPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getAccessibleRelationSet( |
| (jobject)pkg->accessibleContext, &(pkg->rAccessibleRelationSetInfo)); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleRelationSetPackage)); |
| } |
| break; |
| |
| // ------------ end AccessibleRelationSet packages ------------------ |
| |
| // ------------ begin AccessibleHypertext packages ------------------ |
| |
| case cGetAccessibleHypertextPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleHypertextPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleHypertextPackage))) { |
| GetAccessibleHypertextPackage *pkg = |
| (GetAccessibleHypertextPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getAccessibleHypertext( |
| (jobject)pkg->accessibleContext, &(pkg->rAccessibleHypertextInfo)); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleHypertextPackage)); |
| } |
| break; |
| |
| case cActivateAccessibleHyperlinkPackage: |
| PrintDebugString("[INFO]: ##### type == cActivateAccessibleHyperlinkPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(ActivateAccessibleHyperlinkPackage))) { |
| ActivateAccessibleHyperlinkPackage *pkg = |
| (ActivateAccessibleHyperlinkPackage *) (buffer + sizeof(PackageType)); |
| pkg->rResult = windowsThreadEntryPoints->activateAccessibleHyperlink( |
| (jobject)pkg->accessibleContext, (jobject)pkg->accessibleHyperlink); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(ActivateAccessibleHyperlinkPackage)); |
| } |
| break; |
| |
| case cGetAccessibleHyperlinkCountPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleHyperlinkCountPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleHyperlinkCountPackage))) { |
| GetAccessibleHyperlinkCountPackage *pkg = |
| (GetAccessibleHyperlinkCountPackage *) (buffer + sizeof(PackageType)); |
| pkg->rLinkCount = windowsThreadEntryPoints->getAccessibleHyperlinkCount( |
| (jobject)pkg->accessibleContext); |
| PrintDebugString("[INFO]: ##### processing succeeded: pkg->rLinkCount = %d", pkg->rLinkCount); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleHyperlinkCountPackage)); |
| } |
| break; |
| |
| case cGetAccessibleHypertextExtPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleHypertextExtPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleHypertextExtPackage))) { |
| GetAccessibleHypertextExtPackage *pkg = |
| (GetAccessibleHypertextExtPackage *) (buffer + sizeof(PackageType)); |
| pkg->rSuccess = windowsThreadEntryPoints->getAccessibleHypertextExt( |
| (jobject)pkg->accessibleContext, pkg->startIndex, &(pkg->rAccessibleHypertextInfo)); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleHypertextExtPackage)); |
| } |
| break; |
| |
| case cGetAccessibleHypertextLinkIndexPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleHypertextLinkIndexPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleHypertextLinkIndexPackage))) { |
| GetAccessibleHypertextLinkIndexPackage *pkg = |
| (GetAccessibleHypertextLinkIndexPackage *) (buffer + sizeof(PackageType)); |
| pkg->rLinkIndex = windowsThreadEntryPoints->getAccessibleHypertextLinkIndex( |
| (jobject)pkg->hypertext, pkg->charIndex); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleHypertextLinkIndexPackage)); |
| } |
| break; |
| |
| case cGetAccessibleHyperlinkPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleHyperlinkPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleHyperlinkPackage))) { |
| GetAccessibleHyperlinkPackage *pkg = |
| (GetAccessibleHyperlinkPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getAccessibleHyperlink((jobject)pkg->hypertext, pkg->linkIndex, |
| &(pkg->rAccessibleHyperlinkInfo)); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleHyperlinkPackage)); |
| } |
| break; |
| |
| // ------------ end AccessibleHypertext packages |
| |
| // ------------ begin Accessible KeyBindings, Icons and Actions |
| |
| case cGetAccessibleKeyBindingsPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleKeyBindingsPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleKeyBindingsPackage))) { |
| GetAccessibleKeyBindingsPackage *pkg = |
| (GetAccessibleKeyBindingsPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getAccessibleKeyBindings ( |
| (jobject)pkg->accessibleContext, &(pkg->rAccessibleKeyBindings)); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleKeyBindingsPackage)); |
| } |
| break; |
| |
| case cGetAccessibleIconsPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleIconsPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleIconsPackage))) { |
| GetAccessibleIconsPackage *pkg = |
| (GetAccessibleIconsPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getAccessibleIcons ( |
| (jobject)pkg->accessibleContext, &(pkg->rAccessibleIcons)); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleIconsPackage)); |
| } |
| break; |
| |
| |
| case cGetAccessibleActionsPackage: |
| PrintDebugString("[INFO]: ##### type == cGetAccessibleActionsPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleActionsPackage))) { |
| GetAccessibleActionsPackage *pkg = |
| (GetAccessibleActionsPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getAccessibleActions ( |
| (jobject)pkg->accessibleContext, &(pkg->rAccessibleActions)); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleActionsPackage)); |
| } |
| break; |
| |
| case cDoAccessibleActionsPackage: |
| PrintDebugString("[INFO]: ##### type == cDoAccessibleActionsPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(DoAccessibleActionsPackage))) { |
| DoAccessibleActionsPackage *pkg = |
| (DoAccessibleActionsPackage *) (buffer + sizeof(PackageType)); |
| pkg->rResult = |
| windowsThreadEntryPoints->doAccessibleActions((jobject)pkg->accessibleContext, &(pkg->actionsToDo), |
| &(pkg->failure)); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(DoAccessibleActionsPackage)); |
| } |
| break; |
| |
| // ------------ begin addtional methods for Teton |
| |
| case cGetVirtualAccessibleNamePackage: |
| PrintDebugString("[INFO]: ##### type == GetVirtualAccessibleNamePackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetVirtualAccessibleNamePackage))) { |
| GetVirtualAccessibleNamePackage *pkg = |
| (GetVirtualAccessibleNamePackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getVirtualAccessibleName ((const jobject)pkg->accessibleContext, |
| pkg->rName, |
| pkg->len); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetVirtualAccessibleNamePackage)); |
| } |
| break; |
| |
| case cRequestFocusPackage: |
| PrintDebugString("[INFO]: ##### type == RequestFocusPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(RequestFocusPackage))) { |
| RequestFocusPackage *pkg = |
| (RequestFocusPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->requestFocus ( |
| (jobject)pkg->accessibleContext); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(RequestFocusPackage)); |
| } |
| break; |
| |
| case cSelectTextRangePackage: |
| PrintDebugString("[INFO]: ##### type == SelectTextRangePackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(SelectTextRangePackage))) { |
| SelectTextRangePackage *pkg = |
| (SelectTextRangePackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->selectTextRange ( |
| (jobject)pkg->accessibleContext, pkg->startIndex, pkg->endIndex); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(SelectTextRangePackage)); |
| } |
| break; |
| |
| case cGetTextAttributesInRangePackage: |
| PrintDebugString("[INFO]: ##### type == GetTextAttributesInRangePackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetTextAttributesInRangePackage))) { |
| GetTextAttributesInRangePackage *pkg = |
| (GetTextAttributesInRangePackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getTextAttributesInRange ( |
| (jobject)pkg->accessibleContext, pkg->startIndex, pkg->endIndex, |
| (AccessibleTextAttributesInfo *)&(pkg->attributes), |
| &(pkg->rLength)); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetTextAttributesInRangePackage)); |
| } |
| break; |
| |
| |
| case cGetVisibleChildrenCountPackage: |
| PrintDebugString("[INFO]: ##### type == GetVisibleChildrenCountPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetVisibleChildrenCountPackage))) { |
| GetVisibleChildrenCountPackage *pkg = |
| (GetVisibleChildrenCountPackage *) (buffer + sizeof(PackageType)); |
| pkg->rChildrenCount = windowsThreadEntryPoints->getVisibleChildrenCount ((jobject)pkg->accessibleContext); |
| |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetVisibleChildrenCountPackage)); |
| } |
| break; |
| |
| case cGetVisibleChildrenPackage: |
| PrintDebugString("[INFO]: ##### type == GetVisibleChildrenPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetVisibleChildrenPackage))) { |
| GetVisibleChildrenPackage *pkg = |
| (GetVisibleChildrenPackage *) (buffer + sizeof(PackageType)); |
| pkg->rSuccess = windowsThreadEntryPoints->getVisibleChildren ((jobject)pkg->accessibleContext, |
| pkg->startIndex, |
| &(pkg->rVisibleChildrenInfo)); |
| |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetVisibleChildrenPackage)); |
| } |
| break; |
| |
| case cSetCaretPositionPackage: |
| PrintDebugString("[INFO]: ##### type == SetCaretPositionPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(SetCaretPositionPackage))) { |
| SetCaretPositionPackage *pkg = |
| (SetCaretPositionPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->setCaretPosition ( |
| (jobject)pkg->accessibleContext, pkg->position); |
| PrintDebugString("[INFO]: ##### processing succeeded"); |
| } else { |
| PrintDebugString("[ERROR]: ##### processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(SetCaretPositionPackage)); |
| } |
| break; |
| |
| // ------------ end additional methods for Teton |
| |
| // ------------ end Accessible KeyBindings, Icons and Actions |
| |
| // ------------ Accessible Text packages ------------------ |
| |
| case cGetAccessibleTextInfoPackage: |
| PrintDebugString("[INFO]: type == cGetAccessibleTextInfoPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextInfoPackage))) { |
| GetAccessibleTextInfoPackage *pkg = |
| (GetAccessibleTextInfoPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getAccessibleTextInfo((jobject)pkg->AccessibleContext, |
| &(pkg->rTextInfo), pkg->x, pkg->y); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextInfoPackage)); |
| } |
| break; |
| |
| case cGetAccessibleTextItemsPackage: |
| PrintDebugString("[INFO]: type == cGetAccessibleTextItemsPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextItemsPackage))) { |
| GetAccessibleTextItemsPackage *pkg = |
| (GetAccessibleTextItemsPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getAccessibleTextItems((jobject)pkg->AccessibleContext, |
| &(pkg->rTextItemsInfo), pkg->index); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextInfoPackage)); |
| } |
| break; |
| |
| case cGetAccessibleTextSelectionInfoPackage: |
| PrintDebugString("[INFO]: type == cGetAccessibleTextSelectionInfoPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextSelectionInfoPackage))) { |
| GetAccessibleTextSelectionInfoPackage *pkg = |
| (GetAccessibleTextSelectionInfoPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getAccessibleTextSelectionInfo( |
| (jobject)pkg->AccessibleContext, &(pkg->rTextSelectionItemsInfo)); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextSelectionInfoPackage)); |
| } |
| break; |
| |
| case cGetAccessibleTextAttributeInfoPackage: |
| PrintDebugString("[INFO]: type == cGetAccessibleTextAttributeInfoPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextAttributeInfoPackage))) { |
| GetAccessibleTextAttributeInfoPackage *pkg = |
| (GetAccessibleTextAttributeInfoPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getAccessibleTextAttributes( |
| (jobject)pkg->AccessibleContext, pkg->index, (AccessibleTextAttributesInfo *) &(pkg->rAttributeInfo)); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextAttributeInfoPackage)); |
| } |
| break; |
| |
| case cGetAccessibleTextRectInfoPackage: |
| PrintDebugString("[INFO]: type == cGetAccessibleTextRectInfoPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextRectInfoPackage))) { |
| GetAccessibleTextRectInfoPackage *pkg = |
| (GetAccessibleTextRectInfoPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getAccessibleTextRect((jobject)pkg->AccessibleContext, |
| &(pkg->rTextRectInfo), pkg->index); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextRectInfoPackage)); |
| } |
| break; |
| |
| case cGetCaretLocationPackage: |
| PrintDebugString("[INFO]: type == cGetCaretLocationPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetCaretLocationPackage))) { |
| GetCaretLocationPackage *pkg = |
| (GetCaretLocationPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getCaretLocation((jobject)pkg->AccessibleContext, |
| &(pkg->rTextRectInfo), pkg->index); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetCaretLocationPackage)); |
| } |
| break; |
| |
| case cGetAccessibleTextLineBoundsPackage: |
| PrintDebugString("[INFO]: type == cGetAccessibleTextLineBoundsPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextLineBoundsPackage))) { |
| GetAccessibleTextLineBoundsPackage *pkg = |
| (GetAccessibleTextLineBoundsPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getAccessibleTextLineBounds((jobject)pkg->AccessibleContext, |
| pkg->index, &(pkg->rLineStart), &(pkg->rLineEnd)); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextLineBoundsPackage)); |
| } |
| break; |
| |
| case cGetAccessibleTextRangePackage: |
| PrintDebugString("[INFO]: type == cGetAccessibleTextRangePackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextRangePackage))) { |
| GetAccessibleTextRangePackage *pkg = |
| (GetAccessibleTextRangePackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getAccessibleTextRange((jobject)pkg->AccessibleContext, |
| pkg->start, pkg->end, (wchar_t *) &(pkg->rText), (sizeof(pkg->rText) / sizeof(wchar_t))); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextRangePackage)); |
| } |
| break; |
| |
| |
| // ------------ Accessible Value packages ------------------ |
| |
| case cGetCurrentAccessibleValueFromContextPackage: |
| PrintDebugString("[INFO]: type == cGetCurrentAccessibleValueFromContextPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetCurrentAccessibleValueFromContextPackage))) { |
| GetCurrentAccessibleValueFromContextPackage *pkg = |
| (GetCurrentAccessibleValueFromContextPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getCurrentAccessibleValueFromContext((jobject)pkg->AccessibleContext, |
| (wchar_t *) &(pkg->rValue), (sizeof(pkg->rValue) / sizeof(wchar_t))); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetCurrentAccessibleValueFromContextPackage)); |
| } |
| break; |
| |
| case cGetMaximumAccessibleValueFromContextPackage: |
| PrintDebugString("[INFO]: type == cGetMaximumAccessibleValueFromContextPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetMaximumAccessibleValueFromContextPackage))) { |
| GetMaximumAccessibleValueFromContextPackage *pkg = |
| (GetMaximumAccessibleValueFromContextPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getMaximumAccessibleValueFromContext((jobject)pkg->AccessibleContext, |
| (wchar_t *) &(pkg->rValue), (sizeof(pkg->rValue) / sizeof(wchar_t))); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetMaximumAccessibleValueFromContextPackage)); |
| } |
| break; |
| |
| case cGetMinimumAccessibleValueFromContextPackage: |
| PrintDebugString("[INFO]: type == cGetMinimumAccessibleValueFromContextPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetMinimumAccessibleValueFromContextPackage))) { |
| GetMinimumAccessibleValueFromContextPackage *pkg = |
| (GetMinimumAccessibleValueFromContextPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->getMinimumAccessibleValueFromContext((jobject)pkg->AccessibleContext, |
| (wchar_t *) &(pkg->rValue), (sizeof(pkg->rValue) / sizeof(wchar_t))); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetMinimumAccessibleValueFromContextPackage)); |
| } |
| break; |
| |
| // ------------ Accessible Selection packages ------------------ |
| |
| case cAddAccessibleSelectionFromContextPackage: |
| PrintDebugString("[INFO]: type == cAddAccessibleSelectionFromContextPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(AddAccessibleSelectionFromContextPackage))) { |
| AddAccessibleSelectionFromContextPackage *pkg = |
| (AddAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->addAccessibleSelectionFromContext((jobject)pkg->AccessibleContext, |
| pkg->index); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(AddAccessibleSelectionFromContextPackage)); |
| } |
| break; |
| |
| case cClearAccessibleSelectionFromContextPackage: |
| PrintDebugString("[INFO]: type == cClearAccessibleSelectionFromContextPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(ClearAccessibleSelectionFromContextPackage))) { |
| ClearAccessibleSelectionFromContextPackage *pkg = |
| (ClearAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->clearAccessibleSelectionFromContext((jobject)pkg->AccessibleContext); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(ClearAccessibleSelectionFromContextPackage)); |
| } |
| break; |
| |
| case cGetAccessibleSelectionFromContextPackage: |
| PrintDebugString("[INFO]: type == cGetAccessibleSelectionFromContextPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleSelectionFromContextPackage))) { |
| GetAccessibleSelectionFromContextPackage *pkg = |
| (GetAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType)); |
| pkg->rAccessibleContext = (JOBJECT64)windowsThreadEntryPoints->getAccessibleSelectionFromContext( |
| (jobject)pkg->AccessibleContext, pkg->index); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleSelectionFromContextPackage)); |
| } |
| break; |
| |
| case cGetAccessibleSelectionCountFromContextPackage: |
| PrintDebugString("[INFO]: type == cGetAccessibleSelectionCountFromContextPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleSelectionCountFromContextPackage))) { |
| GetAccessibleSelectionCountFromContextPackage *pkg = |
| (GetAccessibleSelectionCountFromContextPackage *) (buffer + sizeof(PackageType)); |
| pkg->rCount = windowsThreadEntryPoints->getAccessibleSelectionCountFromContext( |
| (jobject)pkg->AccessibleContext); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(GetAccessibleSelectionCountFromContextPackage)); |
| } |
| break; |
| |
| case cIsAccessibleChildSelectedFromContextPackage: |
| PrintDebugString("[INFO]: type == cIsAccessibleChildSelectedFromContextPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(IsAccessibleChildSelectedFromContextPackage))) { |
| IsAccessibleChildSelectedFromContextPackage *pkg = |
| (IsAccessibleChildSelectedFromContextPackage *) (buffer + sizeof(PackageType)); |
| pkg->rResult = windowsThreadEntryPoints->isAccessibleChildSelectedFromContext( |
| (jobject)pkg->AccessibleContext, pkg->index); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(IsAccessibleChildSelectedFromContextPackage)); |
| } |
| break; |
| |
| case cRemoveAccessibleSelectionFromContextPackage: |
| PrintDebugString("[INFO]: type == cRemoveAccessibleSelectionFromContextPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(RemoveAccessibleSelectionFromContextPackage))) { |
| RemoveAccessibleSelectionFromContextPackage *pkg = |
| (RemoveAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->removeAccessibleSelectionFromContext((jobject)pkg->AccessibleContext, |
| pkg->index); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(RemoveAccessibleSelectionFromContextPackage)); |
| } |
| break; |
| |
| case cSelectAllAccessibleSelectionFromContextPackage: |
| PrintDebugString("[INFO]: type == cSelectAllAccessibleSelectionFromContextPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(SelectAllAccessibleSelectionFromContextPackage))) { |
| SelectAllAccessibleSelectionFromContextPackage *pkg = |
| (SelectAllAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType)); |
| windowsThreadEntryPoints->selectAllAccessibleSelectionFromContext((jobject)pkg->AccessibleContext); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(SelectAllAccessibleSelectionFromContextPackage)); |
| } |
| break; |
| |
| |
| // ------------ event notification management packages ------------------ |
| |
| case cAddJavaEventNotificationPackage: |
| PrintDebugString("[INFO]: type = cAddJavaEventNotificationPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(AddJavaEventNotificationPackage))) { |
| AddJavaEventNotificationPackage *pkg = |
| (AddJavaEventNotificationPackage *) (buffer + sizeof(PackageType)); |
| addJavaEventNotification(pkg->type, (HWND)ABLongToHandle( pkg->DLLwindow ) ); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(AddJavaEventNotificationPackage)); |
| } |
| break; |
| |
| case cRemoveJavaEventNotificationPackage: |
| PrintDebugString("[INFO]: type = cRemoveJavaEventNotificationPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(RemoveJavaEventNotificationPackage))) { |
| RemoveJavaEventNotificationPackage *pkg = |
| (RemoveJavaEventNotificationPackage *) (buffer + sizeof(PackageType)); |
| removeJavaEventNotification(pkg->type, (HWND)ABLongToHandle( pkg->DLLwindow )); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(RemoveJavaEventNotificationPackage)); |
| } |
| break; |
| |
| case cAddAccessibilityEventNotificationPackage: |
| PrintDebugString("[INFO]: type = cAddAccessibilityEventNotificationPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(AddAccessibilityEventNotificationPackage))) { |
| AddAccessibilityEventNotificationPackage *pkg = |
| (AddAccessibilityEventNotificationPackage *) (buffer + sizeof(PackageType)); |
| addAccessibilityEventNotification(pkg->type, (HWND)ABLongToHandle(pkg->DLLwindow)); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(AddAccessibilityEventNotificationPackage)); |
| } |
| break; |
| |
| case cRemoveAccessibilityEventNotificationPackage: |
| PrintDebugString("[INFO]: type = cRemoveAccessibilityEventNotificationPackage"); |
| if (bufsize == (sizeof(PackageType) + sizeof(RemoveAccessibilityEventNotificationPackage))) { |
| RemoveAccessibilityEventNotificationPackage *pkg = |
| (RemoveAccessibilityEventNotificationPackage *) (buffer + sizeof(PackageType)); |
| removeAccessibilityEventNotification(pkg->type, (HWND)ABLongToHandle(pkg->DLLwindow)); |
| } else { |
| PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", |
| bufsize, sizeof(PackageType) + sizeof(RemoveAccessibilityEventNotificationPackage)); |
| } |
| break; |
| |
| default: |
| PrintDebugString("[ERROR]: processing FAILED!! -> don't know how to handle type = %X", *type); |
| returnVal = -1; |
| break; |
| } |
| |
| PrintDebugString("[INFO]: package processing completed"); |
| return returnVal; |
| } |
| |
| |
| // ----------------------------- |
| |
| |
| /** |
| * MemoryMappedFileCreated |
| * - WindowsDLL letting us know it's created a memory-mapped file |
| * for IPC. We need to open it and write a magic string into |
| * it to let the WindowsDLL know all is OK. Also we need to |
| * set up our own data structures to communicate with the |
| * WindowsDLL |
| * |
| */ |
| LRESULT |
| JavaAccessBridge::MemoryMappedFileCreated(HWND ATBridgeDLLWindow, char *filename) { |
| PrintDebugString("[INFO]: in MemoryMappedFileCreated(%p, %s)!", ATBridgeDLLWindow, filename); |
| AccessBridgeATInstance *newAT = |
| new AccessBridgeATInstance(dialogWindow, ATBridgeDLLWindow, filename, ATs); |
| PrintDebugString("[INFO]: just created a new ATInstance = %p, old = %p", newAT, ATs); |
| ATs = newAT; |
| |
| LRESULT returnVal = ATs->initiateIPC(); |
| if (returnVal == 0) { |
| PrintDebugString("[INFO]: Successfully initiated IPC with AT!!!"); |
| } else { |
| PrintDebugString("[ERROR]: Failed to initiate IPC with AT!!!"); |
| } |
| |
| return returnVal; |
| } |
| |
| |
| /** |
| * WindowsATDestroyed - lets the JavaABDLL know a Windows AT disappeared |
| * |
| */ |
| void |
| JavaAccessBridge::WindowsATDestroyed(HWND ATBridgeDLLWindow) { |
| PrintDebugString("[INFO]: in JavaAccessBridge::WindowsATDestroyed(%p)", ATBridgeDLLWindow); |
| if (ATs == (AccessBridgeATInstance *) 0) { |
| PrintDebugString("[ERROR]: -> ATs == 0! (shouldn't happen here)"); |
| return; |
| } |
| |
| AccessBridgeATInstance *currentAT = ATs; |
| AccessBridgeATInstance *previousAT = ATs; |
| if (ATs->winAccessBridgeWindow == ATBridgeDLLWindow) { |
| ATs = ATs->nextATInstance; |
| // remove event notification for this AT |
| removeJavaEventNotification(currentAT->javaEventMask, ATBridgeDLLWindow); |
| removeAccessibilityEventNotification(currentAT->accessibilityEventMask, ATBridgeDLLWindow); |
| delete currentAT; |
| PrintDebugString("[INFO]: data structures successfully removed"); |
| } else { |
| while (currentAT != (AccessBridgeATInstance *) NULL) { |
| if (currentAT->winAccessBridgeWindow == ATBridgeDLLWindow) { |
| previousAT->nextATInstance = currentAT->nextATInstance; |
| delete currentAT; |
| PrintDebugString("[INFO]: data structures successfully removed"); |
| return; |
| } else { |
| previousAT = currentAT; |
| currentAT = currentAT->nextATInstance; |
| } |
| } |
| PrintDebugString("[ERROR]: couldn't find matching data structures!"); |
| } |
| } |
| |
| |
| // ----------------------------- |
| |
| |
| /** |
| * releaseJavaObject - lets the JavaVM know it can release the Java Object |
| * |
| * Note: once you have made this call, the JavaVM will garbage collect |
| * the jobject you pass in. If you later use that jobject in another |
| * call, you will cause all maner of havoc! |
| * |
| */ |
| void |
| JavaAccessBridge::releaseJavaObject(jobject object) { |
| PrintDebugString("[INFO]: In JavaAccessBridge::releaseJavaObject"); |
| PrintDebugString("[INFO]: object X: %p", object); |
| if (windowsThreadJNIEnv != (JNIEnv *) 0) { |
| windowsThreadJNIEnv->DeleteGlobalRef(object); |
| PrintDebugString("[INFO]: global reference deleted.", object); |
| } else { |
| PrintDebugString("[ERROR]: windowsThreadJNIEnv == 0"); |
| } |
| } |
| |
| // ----------------------------- |
| |
| /** |
| * addJavaEventNotification - this AT now wants this type of events |
| * |
| */ |
| void |
| JavaAccessBridge::addJavaEventNotification(jlong type, HWND DLLwindow) { |
| // walk through list of ATs, find this one and add this type |
| // and, if we weren't listening for these before, ask Java for 'em |
| PrintDebugString("[INFO]: adding Java event type %016I64X to HWND %p", type, DLLwindow); |
| AccessBridgeATInstance *ati = ATs; |
| long globalEventMask = 0; |
| while (ati != (AccessBridgeATInstance *) 0) { |
| if (ati->winAccessBridgeWindow == DLLwindow) { |
| ati->javaEventMask |= type; |
| PrintDebugString("[INFO]: found HWND, javaEventMask now is %X", ati->javaEventMask); |
| } else { |
| globalEventMask |= ati->javaEventMask; |
| } |
| ati = ati->nextATInstance; |
| } |
| PrintDebugString("[INFO]: union of all Java AT event masks: %X", globalEventMask); |
| if (!(globalEventMask & type)) { |
| // no other ATs wanted this event; |
| // start getting them from Java |
| PrintDebugString("[INFO]: no other AT wanted this Java event (so not registered); adding to AccessBridge.java"); |
| windowsThreadEntryPoints->addJavaEventNotification(type); |
| } |
| } |
| |
| /** |
| * removeJavaEventNotification - this AT no longer wants this type of events |
| * |
| */ |
| void |
| JavaAccessBridge::removeJavaEventNotification(jlong type, HWND DLLwindow) { |
| // walk through list of ATs, find this one and remove this type |
| // and, if no other AT wants 'em either, tell Java we no longer want 'em |
| PrintDebugString("[INFO]: removing Java event type %016I64X from HWND %p", type, DLLwindow); |
| AccessBridgeATInstance *ati = ATs; |
| long globalEventMask = 0; |
| while (ati != (AccessBridgeATInstance *) 0) { |
| if (ati->winAccessBridgeWindow == DLLwindow) { |
| ati->javaEventMask &= (0xFFFFFFFF - type); |
| PrintDebugString("[INFO]: found HWND, javaEventMask now is %X", ati->javaEventMask); |
| } else { |
| globalEventMask |= ati->javaEventMask; |
| } |
| ati = ati->nextATInstance; |
| } |
| PrintDebugString("[INFO]: union of all Java AT event masks: %X", globalEventMask); |
| if (!(globalEventMask & type)) { |
| // no other ATs wanted this event; |
| // stop getting them from Java |
| PrintDebugString("[INFO]: no other AT wanted this Java event (so can remove); removing from AccessBridge.java"); |
| windowsThreadEntryPoints->removeJavaEventNotification(type); |
| } |
| } |
| |
| |
| /** |
| * addAccesibilityEventNotification - this AT now wants this type of events |
| * |
| */ |
| void |
| JavaAccessBridge::addAccessibilityEventNotification(jlong type, HWND DLLwindow) { |
| // walk through list of ATs, find this one and add this type |
| // and, if we weren't listening for these before, ask Java for 'em |
| PrintDebugString("[INFO]: adding Accesibility event type %016I64X to HWND %p", type, DLLwindow); |
| AccessBridgeATInstance *ati = ATs; |
| long globalEventMask = 0; |
| while (ati != (AccessBridgeATInstance *) 0) { |
| if (ati->winAccessBridgeWindow == DLLwindow) { |
| ati->accessibilityEventMask |= type; |
| PrintDebugString("[INFO]: found HWND, accessibilityEventMask now is %X", ati->accessibilityEventMask); |
| } else { |
| globalEventMask |= ati->accessibilityEventMask; |
| } |
| ati = ati->nextATInstance; |
| } |
| PrintDebugString("[INFO]: union of all Accessibility AT event masks: %X", globalEventMask); |
| if (!(globalEventMask & type)) { |
| // no other ATs wanted this event; |
| // start getting them from Java |
| PrintDebugString("[INFO]: no other AT wanted this Accesibility event (so not registered); adding to AccessBridge.java"); |
| windowsThreadEntryPoints->addAccessibilityEventNotification(type); |
| } |
| } |
| |
| /** |
| * removeAccesibilityEventNotification - this AT no longer wants this type of events |
| * |
| */ |
| void |
| JavaAccessBridge::removeAccessibilityEventNotification(jlong type, HWND DLLwindow) { |
| // walk through list of ATs, find this one and remove this type |
| // and, if no other AT wants 'em either, tell Java we no longer want 'em |
| PrintDebugString("[INFO]: removing Accesibility event type %016I64X from HWND %p", type, DLLwindow); |
| AccessBridgeATInstance *ati = ATs; |
| long globalEventMask = 0; |
| while (ati != (AccessBridgeATInstance *) 0) { |
| if (ati->winAccessBridgeWindow == DLLwindow) { |
| ati->accessibilityEventMask &= (0xFFFFFFFF - type); |
| PrintDebugString("[INFO]: found HWND, accessibilityEventMask now is %X", ati->accessibilityEventMask); |
| } else { |
| globalEventMask |= ati->accessibilityEventMask; |
| } |
| ati = ati->nextATInstance; |
| } |
| PrintDebugString("[INFO]: union of all Accessibility AT event masks: %X", globalEventMask); |
| if (!(globalEventMask & type)) { |
| // no other ATs wanted this event; |
| // stop getting them from Java |
| PrintDebugString("[INFO]: no other AT wanted this Accessibility event (so can remove); removing from AccessBridge.java"); |
| windowsThreadEntryPoints->removeAccessibilityEventNotification(type); |
| } |
| } |
| |
| |
| |
| |
| /** |
| * firePropertyCaretChange |
| * |
| */ |
| void |
| JavaAccessBridge::firePropertyCaretChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source, |
| jint oldValue, jint newValue) { |
| |
| PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertyCaretChanged(%p, %p, %p, %p, %d, %d)", |
| env, callingObj, event, |
| source, oldValue, newValue); |
| |
| // sanity check |
| if (ATs == (AccessBridgeATInstance *) 0) { |
| PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)"); |
| return; // panic! |
| } |
| |
| // common setup |
| char buffer[sizeof(PackageType) + sizeof(PropertyCaretChangePackage)]; |
| PackageType *type = (PackageType *) buffer; |
| PropertyCaretChangePackage *pkg = (PropertyCaretChangePackage *) (buffer + sizeof(PackageType)); |
| *type = cPropertyCaretChangePackage; |
| pkg->vmID = (long) dialogWindow; |
| |
| // make new Global Refs and send events only to those ATs that want 'em |
| AccessBridgeATInstance *ati = ATs; |
| while (ati != (AccessBridgeATInstance *) 0) { |
| if (ati->accessibilityEventMask & cPropertyCaretChangeEvent) { |
| |
| PrintDebugString("[INFO]: sending to AT"); |
| |
| // make new GlobalRefs for this AT |
| pkg->Event = (JOBJECT64)env->NewGlobalRef(event); |
| pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source); |
| #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %p"\ |
| " GlobalRef'd Source: %p", pkg->Event, pkg->AccessibleContextSource); |
| #else // JOBJECT64 is jlong (64 bit) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %016I64X"\ |
| " GlobalRef'd Source: %016I64X", pkg->Event, pkg->AccessibleContextSource); |
| #endif |
| |
| pkg->oldPosition = oldValue; |
| pkg->newPosition = newValue; |
| |
| ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyCaretChangeEvent); |
| } |
| ati = ati->nextATInstance; |
| } |
| PrintDebugString("[INFO]: done with propertyCaretChange event"); |
| } |
| |
| /** |
| * firePropertyDescriptionChange |
| * |
| */ |
| void |
| JavaAccessBridge::firePropertyDescriptionChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source, |
| jstring oldValue, jstring newValue){ |
| |
| PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertyDescriptionChanged(%p, %p, %p, %p, %p, %p)", |
| env, callingObj, event, |
| source, oldValue, newValue); |
| |
| // sanity check |
| if (ATs == (AccessBridgeATInstance *) 0) { |
| PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)"); |
| return; // panic! |
| } |
| |
| // common setup |
| const wchar_t *stringBytes; |
| char buffer[sizeof(PackageType) + sizeof(PropertyDescriptionChangePackage)]; |
| PackageType *type = (PackageType *) buffer; |
| PropertyDescriptionChangePackage *pkg = (PropertyDescriptionChangePackage *) (buffer + sizeof(PackageType)); |
| *type = cPropertyDescriptionChangePackage; |
| pkg->vmID = (long) dialogWindow; |
| |
| // make new Global Refs and send events only to those ATs that want 'em |
| AccessBridgeATInstance *ati = ATs; |
| while (ati != (AccessBridgeATInstance *) 0) { |
| if (ati->accessibilityEventMask & cPropertyCaretChangeEvent) { |
| |
| PrintDebugString("[INFO]: sending to AT"); |
| |
| // make new GlobalRefs for this AT |
| pkg->Event = (JOBJECT64)env->NewGlobalRef(event); |
| pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source); |
| #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %p"\ |
| " GlobalRef'd Source: %p", pkg->Event, pkg->AccessibleContextSource); |
| #else // JOBJECT64 is jlong (64 bit) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %016I64X"\ |
| " GlobalRef'd Source: %016I64X", pkg->Event, pkg->AccessibleContextSource); |
| #endif |
| |
| if (oldValue != (jstring) 0) { |
| stringBytes = (const wchar_t *) env->GetStringChars(oldValue, 0); |
| if (stringBytes == NULL) { |
| if (!env->ExceptionCheck()) { |
| jclass cls = env->FindClass("java/lang/OutOfMemoryError"); |
| if (cls != NULL) { |
| env->ThrowNew(cls, NULL); |
| } |
| } |
| return; |
| } |
| wcsncpy(pkg->oldDescription, stringBytes, (sizeof(pkg->oldDescription) / sizeof(wchar_t))); |
| env->ReleaseStringChars(oldValue, stringBytes); |
| } else { |
| wcsncpy(pkg->oldDescription, L"(null)", (sizeof(pkg->oldDescription) / sizeof(wchar_t))); |
| } |
| |
| if (newValue != (jstring) 0) { |
| stringBytes = (const wchar_t *) env->GetStringChars(newValue, 0); |
| if (stringBytes == NULL) { |
| if (!env->ExceptionCheck()) { |
| jclass cls = env->FindClass("java/lang/OutOfMemoryError"); |
| if (cls != NULL) { |
| env->ThrowNew(cls, NULL); |
| } |
| } |
| return; |
| } |
| wcsncpy(pkg->newDescription, stringBytes, (sizeof(pkg->newDescription) / sizeof(wchar_t))); |
| env->ReleaseStringChars(newValue, stringBytes); |
| } else { |
| wcsncpy(pkg->newDescription, L"(null)", (sizeof(pkg->newDescription) / sizeof(wchar_t))); |
| } |
| |
| ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyDescriptionChangeEvent); |
| } |
| ati = ati->nextATInstance; |
| } |
| PrintDebugString("[INFO]: done with propertyDescriptionChange event"); |
| } |
| |
| /** |
| * firePropertyNameChange |
| * |
| */ |
| void |
| JavaAccessBridge::firePropertyNameChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source, |
| jstring oldValue, jstring newValue){ |
| |
| PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertyNameChanged(%p, %p, %p, %p, %p, %p)", |
| env, callingObj, event, |
| source, oldValue, newValue); |
| |
| // sanity check |
| if (ATs == (AccessBridgeATInstance *) 0) { |
| PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)"); |
| return; // panic! |
| } |
| |
| // common setup |
| const wchar_t *stringBytes; |
| char buffer[sizeof(PackageType) + sizeof(PropertyNameChangePackage)]; |
| PackageType *type = (PackageType *) buffer; |
| PropertyNameChangePackage *pkg = (PropertyNameChangePackage *) (buffer + sizeof(PackageType)); |
| *type = cPropertyNameChangePackage; |
| pkg->vmID = (long) dialogWindow; |
| |
| // make new Global Refs and send events only to those ATs that want 'em |
| AccessBridgeATInstance *ati = ATs; |
| while (ati != (AccessBridgeATInstance *) 0) { |
| if (ati->accessibilityEventMask & cPropertyNameChangeEvent) { |
| |
| PrintDebugString("[INFO]: sending to AT"); |
| |
| // make new GlobalRefs for this AT |
| pkg->Event = (JOBJECT64)env->NewGlobalRef(event); |
| pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source); |
| #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %p"\ |
| " GlobalRef'd Source: %p", pkg->Event, pkg->AccessibleContextSource); |
| #else // JOBJECT64 is jlong (64 bit) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %016I64X"\ |
| " GlobalRef'd Source: %016I64X", pkg->Event, pkg->AccessibleContextSource); |
| #endif |
| |
| if (oldValue != (jstring) 0) { |
| stringBytes = (const wchar_t *) env->GetStringChars(oldValue, 0); |
| if (stringBytes == NULL) { |
| if (!env->ExceptionCheck()) { |
| jclass cls = env->FindClass("java/lang/OutOfMemoryError"); |
| if (cls != NULL) { |
| env->ThrowNew(cls, NULL); |
| } |
| } |
| return; |
| } |
| wcsncpy(pkg->oldName, stringBytes, (sizeof(pkg->oldName) / sizeof(wchar_t))); |
| env->ReleaseStringChars(oldValue, stringBytes); |
| } else { |
| wcsncpy(pkg->oldName, L"(null)", (sizeof(pkg->oldName) / sizeof(wchar_t))); |
| } |
| |
| if (newValue != (jstring) 0) { |
| stringBytes = (const wchar_t *) env->GetStringChars(newValue, 0); |
| if (stringBytes == NULL) { |
| if (!env->ExceptionCheck()) { |
| jclass cls = env->FindClass("java/lang/OutOfMemoryError"); |
| if (cls != NULL) { |
| env->ThrowNew(cls, NULL); |
| } |
| } |
| return; |
| } |
| wcsncpy(pkg->newName, stringBytes, (sizeof(pkg->newName) / sizeof(wchar_t))); |
| env->ReleaseStringChars(newValue, stringBytes); |
| } else { |
| wcsncpy(pkg->newName, L"(null)", (sizeof(pkg->newName) / sizeof(wchar_t))); |
| } |
| |
| ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyNameChangeEvent); |
| } |
| ati = ati->nextATInstance; |
| } |
| PrintDebugString("[INFO]: done with propertyNameChange event"); |
| } |
| |
| |
| /** |
| * firePropertySelectionChange |
| * |
| */ |
| void |
| JavaAccessBridge::firePropertySelectionChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source) { |
| |
| PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertySelectionChanged(%p, %p, %p, %p)", |
| env, callingObj, event, source); |
| |
| // sanity check |
| if (ATs == (AccessBridgeATInstance *) 0) { |
| PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)"); |
| return; // panic! |
| } |
| |
| // common setup |
| char buffer[sizeof(PackageType) + sizeof(PropertySelectionChangePackage)]; |
| PackageType *type = (PackageType *) buffer; |
| PropertySelectionChangePackage *pkg = (PropertySelectionChangePackage *) (buffer + sizeof(PackageType)); |
| *type = cPropertySelectionChangePackage; |
| pkg->vmID = (long) dialogWindow; |
| |
| // make new Global Refs and send events only to those ATs that want 'em |
| AccessBridgeATInstance *ati = ATs; |
| while (ati != (AccessBridgeATInstance *) 0) { |
| if (ati->accessibilityEventMask & cPropertySelectionChangeEvent) { |
| |
| PrintDebugString("[INFO]: sending to AT"); |
| |
| // make new GlobalRefs for this AT |
| pkg->Event = (JOBJECT64)env->NewGlobalRef(event); |
| pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source); |
| #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %p"\ |
| " GlobalRef'd Source: %p", pkg->Event, pkg->AccessibleContextSource); |
| #else // JOBJECT64 is jlong (64 bit) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %016I64X"\ |
| " GlobalRef'd Source: %016I64X", pkg->Event, pkg->AccessibleContextSource); |
| #endif |
| |
| ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertySelectionChangeEvent); |
| } |
| ati = ati->nextATInstance; |
| } |
| PrintDebugString("[INFO]: done with propertySelectionChange event"); |
| } |
| |
| |
| /** |
| * firePropertyStateChange |
| * |
| */ |
| void |
| JavaAccessBridge::firePropertyStateChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source, |
| jstring oldValue, jstring newValue){ |
| |
| PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertyStateChanged(%p, %p, %p, %p, %p, %p)", |
| env, callingObj, event, |
| source, oldValue, newValue); |
| |
| // sanity check |
| if (ATs == (AccessBridgeATInstance *) 0) { |
| PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)"); |
| return; // panic! |
| } |
| |
| // common setup |
| const wchar_t *stringBytes; |
| char buffer[sizeof(PackageType) + sizeof(PropertyStateChangePackage)]; |
| PackageType *type = (PackageType *) buffer; |
| PropertyStateChangePackage *pkg = (PropertyStateChangePackage *) (buffer + sizeof(PackageType)); |
| *type = cPropertyStateChangePackage; |
| pkg->vmID = (long) dialogWindow; |
| |
| // make new Global Refs and send events only to those ATs that want 'em |
| AccessBridgeATInstance *ati = ATs; |
| while (ati != (AccessBridgeATInstance *) 0) { |
| if (ati->accessibilityEventMask & cPropertyStateChangeEvent) { |
| |
| PrintDebugString("[INFO]: sending to AT"); |
| |
| // make new GlobalRefs for this AT |
| pkg->Event = (JOBJECT64)env->NewGlobalRef(event); |
| pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source); |
| #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %p"\ |
| " GlobalRef'd Source: %p", pkg->Event, pkg->AccessibleContextSource); |
| #else // JOBJECT64 is jlong (64 bit) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %016I64X"\ |
| " GlobalRef'd Source: %016I64X", pkg->Event, pkg->AccessibleContextSource); |
| #endif |
| |
| if (oldValue != (jstring) 0) { |
| stringBytes = (const wchar_t *) env->GetStringChars(oldValue, 0); |
| if (stringBytes == NULL) { |
| if (!env->ExceptionCheck()) { |
| jclass cls = env->FindClass("java/lang/OutOfMemoryError"); |
| if (cls != NULL) { |
| env->ThrowNew(cls, NULL); |
| } |
| } |
| return; |
| } |
| wcsncpy(pkg->oldState, stringBytes, (sizeof(pkg->oldState) / sizeof(wchar_t))); |
| env->ReleaseStringChars(oldValue, stringBytes); |
| } else { |
| wcsncpy(pkg->oldState, L"(null)", (sizeof(pkg->oldState) / sizeof(wchar_t))); |
| } |
| |
| if (newValue != (jstring) 0) { |
| stringBytes = (const wchar_t *) env->GetStringChars(newValue, 0); |
| if (stringBytes == NULL) { |
| if (!env->ExceptionCheck()) { |
| jclass cls = env->FindClass("java/lang/OutOfMemoryError"); |
| if (cls != NULL) { |
| env->ThrowNew(cls, NULL); |
| } |
| } |
| return; |
| } |
| wcsncpy(pkg->newState, stringBytes, (sizeof(pkg->newState) / sizeof(wchar_t))); |
| env->ReleaseStringChars(newValue, stringBytes); |
| } else { |
| wcsncpy(pkg->newState, L"(null)", (sizeof(pkg->newState) / sizeof(wchar_t))); |
| } |
| |
| ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyStateChangeEvent); |
| } |
| ati = ati->nextATInstance; |
| } |
| PrintDebugString("[INFO]: done with propertyStateChange event"); |
| } |
| |
| |
| /** |
| * firePropertyTextChange |
| * |
| */ |
| void |
| JavaAccessBridge::firePropertyTextChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source) { |
| |
| PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertyTextChanged(%p, %p, %p, %p)", |
| env, callingObj, event, source); |
| |
| // sanity check |
| if (ATs == (AccessBridgeATInstance *) 0) { |
| PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)"); |
| return; // panic! |
| } |
| |
| // common setup |
| char buffer[sizeof(PackageType) + sizeof(PropertyTextChangePackage)]; |
| PackageType *type = (PackageType *) buffer; |
| PropertyTextChangePackage *pkg = (PropertyTextChangePackage *) (buffer + sizeof(PackageType)); |
| *type = cPropertyTextChangePackage; |
| pkg->vmID = (long) dialogWindow; |
| |
| // make new Global Refs and send events only to those ATs that want 'em |
| AccessBridgeATInstance *ati = ATs; |
| while (ati != (AccessBridgeATInstance *) 0) { |
| if (ati->accessibilityEventMask & cPropertyTextChangeEvent) { |
| |
| PrintDebugString("[INFO]: sending to AT"); |
| |
| // make new GlobalRefs for this AT |
| pkg->Event = (JOBJECT64)env->NewGlobalRef(event); |
| pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source); |
| #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %p"\ |
| " GlobalRef'd Source: %p",pkg->Event, pkg->AccessibleContextSource); |
| #else // JOBJECT64 is jlong (64 bit) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %016I64X"\ |
| " GlobalRef'd Source: %016I64X", pkg->Event, pkg->AccessibleContextSource); |
| #endif |
| |
| ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyTextChangeEvent); |
| } |
| ati = ati->nextATInstance; |
| } |
| PrintDebugString("[INFO]: done with propertyTextChange event"); |
| } |
| |
| |
| /** |
| * firePropertyValueChange |
| * |
| */ |
| void |
| JavaAccessBridge::firePropertyValueChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source, |
| jstring oldValue, jstring newValue){ |
| |
| PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertyValueChanged(%p, %p, %p, %p, %p, %p)", |
| env, callingObj, event, |
| source, oldValue, newValue); |
| |
| // sanity check |
| if (ATs == (AccessBridgeATInstance *) 0) { |
| PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)"); |
| return; // panic! |
| } |
| |
| // common setup |
| const wchar_t *stringBytes; |
| char buffer[sizeof(PackageType) + sizeof(PropertyValueChangePackage)]; |
| PackageType *type = (PackageType *) buffer; |
| PropertyValueChangePackage *pkg = (PropertyValueChangePackage *) (buffer + sizeof(PackageType)); |
| *type = cPropertyValueChangePackage; |
| pkg->vmID = (long) dialogWindow; |
| |
| // make new Global Refs and send events only to those ATs that want 'em |
| AccessBridgeATInstance *ati = ATs; |
| while (ati != (AccessBridgeATInstance *) 0) { |
| if (ati->accessibilityEventMask & cPropertyValueChangeEvent) { |
| |
| PrintDebugString("[INFO]: sending to AT"); |
| |
| // make new GlobalRefs for this AT |
| pkg->Event = (JOBJECT64)env->NewGlobalRef(event); |
| pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source); |
| #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %p"\ |
| " GlobalRef'd Source: %p", pkg->Event, pkg->AccessibleContextSource); |
| #else // JOBJECT64 is jlong (64 bit) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %016I64X"\ |
| " GlobalRef'd Source: %016I64X", pkg->Event, pkg->AccessibleContextSource); |
| #endif |
| |
| if (oldValue != (jstring) 0) { |
| stringBytes = (const wchar_t *) env->GetStringChars(oldValue, 0); |
| if (stringBytes == NULL) { |
| if (!env->ExceptionCheck()) { |
| jclass cls = env->FindClass("java/lang/OutOfMemoryError"); |
| if (cls != NULL) { |
| env->ThrowNew(cls, NULL); |
| } |
| } |
| return; |
| } |
| wcsncpy(pkg->oldValue, stringBytes, (sizeof(pkg->oldValue) / sizeof(wchar_t))); |
| env->ReleaseStringChars(oldValue, stringBytes); |
| } else { |
| wcsncpy(pkg->oldValue, L"(null)", (sizeof(pkg->oldValue) / sizeof(wchar_t))); |
| } |
| |
| if (newValue != (jstring) 0) { |
| stringBytes = (const wchar_t *) env->GetStringChars(newValue, 0); |
| if (stringBytes == NULL) { |
| if (!env->ExceptionCheck()) { |
| jclass cls = env->FindClass("java/lang/OutOfMemoryError"); |
| if (cls != NULL) { |
| env->ThrowNew(cls, NULL); |
| } |
| } |
| return; |
| } |
| wcsncpy(pkg->newValue, stringBytes, (sizeof(pkg->newValue) / sizeof(wchar_t))); |
| env->ReleaseStringChars(newValue, stringBytes); |
| } else { |
| wcsncpy(pkg->newValue, L"(null)", (sizeof(pkg->newValue) / sizeof(wchar_t))); |
| } |
| |
| ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyValueChangeEvent); |
| } |
| ati = ati->nextATInstance; |
| } |
| PrintDebugString("[INFO]: done with propertyValueChange event"); |
| } |
| |
| /** |
| * firePropertyVisibleDataChange |
| * |
| */ |
| void |
| JavaAccessBridge::firePropertyVisibleDataChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source) { |
| |
| PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertyVisibleDataChanged(%p, %p, %p, %p)", |
| env, callingObj, event, source); |
| |
| // sanity check |
| if (ATs == (AccessBridgeATInstance *) 0) { |
| PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)"); |
| return; // panic! |
| } |
| |
| // common setup |
| char buffer[sizeof(PackageType) + sizeof(PropertyVisibleDataChangePackage)]; |
| PackageType *type = (PackageType *) buffer; |
| PropertyVisibleDataChangePackage *pkg = (PropertyVisibleDataChangePackage *) (buffer + sizeof(PackageType)); |
| *type = cPropertyVisibleDataChangePackage; |
| pkg->vmID = (long) dialogWindow; |
| |
| // make new Global Refs and send events only to those ATs that want 'em |
| AccessBridgeATInstance *ati = ATs; |
| while (ati != (AccessBridgeATInstance *) 0) { |
| if (ati->accessibilityEventMask & cPropertyVisibleDataChangeEvent) { |
| |
| PrintDebugString("[INFO]: sending to AT"); |
| |
| // make new GlobalRefs for this AT |
| pkg->Event = (JOBJECT64)env->NewGlobalRef(event); |
| pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source); |
| #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %p"\ |
| " GlobalRef'd Source: %p", pkg->Event, pkg->AccessibleContextSource); |
| #else // JOBJECT64 is jlong (64 bit) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %016I64X"\ |
| " GlobalRef'd Source: %016I64X", pkg->Event, pkg->AccessibleContextSource); |
| #endif |
| |
| ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyVisibleDataChangeEvent); |
| } |
| ati = ati->nextATInstance; |
| } |
| PrintDebugString("[INFO]: done with propertyVisibleDataChange event"); |
| } |
| |
| |
| /** |
| * firePropertyChildChange |
| * |
| */ |
| void |
| JavaAccessBridge::firePropertyChildChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source, |
| jobject oldValue, jobject newValue){ |
| |
| PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertyChildPropertyChanged(%p, %p, %p, %p, %p, %p)", |
| env, callingObj, event, |
| source, oldValue, newValue); |
| |
| // sanity check |
| if (ATs == (AccessBridgeATInstance *) 0) { |
| PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)"); |
| return; // panic! |
| } |
| |
| // common setup |
| char buffer[sizeof(PackageType) + sizeof(PropertyChildChangePackage)]; |
| PackageType *type = (PackageType *) buffer; |
| PropertyChildChangePackage *pkg = (PropertyChildChangePackage *) (buffer + sizeof(PackageType)); |
| *type = cPropertyChildChangePackage; |
| pkg->vmID = (long) dialogWindow; |
| |
| // make new Global Refs and send events only to those ATs that want 'em |
| AccessBridgeATInstance *ati = ATs; |
| while (ati != (AccessBridgeATInstance *) 0) { |
| if (ati->accessibilityEventMask & cPropertyChildChangeEvent) { |
| |
| PrintDebugString("[INFO]: sending to AT"); |
| |
| // make new GlobalRefs for this AT |
| pkg->Event = (JOBJECT64)env->NewGlobalRef(event); |
| pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source); |
| pkg->oldChildAccessibleContext = (JOBJECT64)env->NewGlobalRef(oldValue); |
| pkg->newChildAccessibleContext = (JOBJECT64)env->NewGlobalRef(newValue); |
| #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %p"\ |
| " GlobalRef'd Source: %p"\ |
| " GlobalRef'd OldChildAC: %p"\ |
| " GlobalRef'd NewChildAC: %p"\ |
| , pkg->Event, pkg->AccessibleContextSource, pkg->oldChildAccessibleContext, pkg->newChildAccessibleContext); |
| #else // JOBJECT64 is jlong (64 bit) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %016I64X"\ |
| " GlobalRef'd Source: %016I64X"\ |
| " GlobalRef'd OldChildAC: %016I64X"\ |
| " GlobalRef'd NewChildAC: %016I64X"\ |
| , pkg->Event, pkg->AccessibleContextSource, pkg->oldChildAccessibleContext, pkg->newChildAccessibleContext); |
| #endif |
| |
| ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyChildChangeEvent); |
| } |
| ati = ati->nextATInstance; |
| } |
| PrintDebugString("[INFO]: done with propertyChildChange event"); |
| } |
| |
| |
| /** |
| * firePropertyActiveDescendentChange |
| * |
| */ |
| void |
| JavaAccessBridge::firePropertyActiveDescendentChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source, |
| jobject oldValue, jobject newValue){ |
| |
| PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertyActiveDescendentPropertyChanged(%p, %p, %p, %p, %p, %p)", |
| env, callingObj, event, |
| source, oldValue, newValue); |
| |
| // sanity check |
| if (ATs == (AccessBridgeATInstance *) 0) { |
| PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)"); |
| return; // panic! |
| } |
| |
| // common setup |
| char buffer[sizeof(PackageType) + sizeof(PropertyActiveDescendentChangePackage)]; |
| PackageType *type = (PackageType *) buffer; |
| PropertyActiveDescendentChangePackage *pkg = (PropertyActiveDescendentChangePackage *) (buffer + sizeof(PackageType)); |
| *type = cPropertyActiveDescendentChangePackage; |
| pkg->vmID = (long) dialogWindow; |
| |
| // make new Global Refs and send events only to those ATs that want 'em |
| AccessBridgeATInstance *ati = ATs; |
| while (ati != (AccessBridgeATInstance *) 0) { |
| if (ati->accessibilityEventMask & cPropertyActiveDescendentChangeEvent) { |
| |
| PrintDebugString("[INFO]: sending to AT"); |
| |
| // make new GlobalRefs for this AT |
| pkg->Event = (JOBJECT64)env->NewGlobalRef(event); |
| pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source); |
| pkg->oldActiveDescendentAccessibleContext = (JOBJECT64)env->NewGlobalRef(oldValue); |
| pkg->newActiveDescendentAccessibleContext = (JOBJECT64)env->NewGlobalRef(newValue); |
| #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %p"\ |
| " GlobalRef'd Source: %p"\ |
| " GlobalRef'd OldActiveDescendentAC: %p"\ |
| " GlobalRef'd NewActiveDescendentAC: %p"\ |
| , pkg->Event, pkg->AccessibleContextSource, pkg->oldActiveDescendentAccessibleContext, pkg->newActiveDescendentAccessibleContext); |
| #else // JOBJECT64 is jlong (64 bit) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %016I64X"\ |
| " GlobalRef'd Source: %016I64X"\ |
| " GlobalRef'd OldActiveDescendentAC: %016I64X"\ |
| " GlobalRef'd NewActiveDescendentAC: %016I64X"\ |
| , pkg->Event, pkg->AccessibleContextSource, pkg->oldActiveDescendentAccessibleContext, pkg->newActiveDescendentAccessibleContext); |
| #endif |
| |
| ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyActiveDescendentChangeEvent); |
| } |
| ati = ati->nextATInstance; |
| } |
| PrintDebugString("[INFO]: done with propertyActiveChange event"); |
| } |
| |
| /** |
| * firePropertyValueChange |
| * |
| */ |
| void |
| JavaAccessBridge::firePropertyTableModelChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source, |
| jstring oldValue, jstring newValue){ |
| |
| PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertyTableModelChange(%p, %p, %p, %p, %p, %p)", |
| env, callingObj, event, |
| source, oldValue, newValue); |
| |
| // sanity check |
| if (ATs == (AccessBridgeATInstance *) 0) { |
| PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)"); |
| return; // panic! |
| } |
| |
| // common setup |
| const wchar_t *stringBytes; |
| char buffer[sizeof(PackageType) + sizeof(PropertyTableModelChangePackage)]; |
| PackageType *type = (PackageType *) buffer; |
| PropertyTableModelChangePackage *pkg = (PropertyTableModelChangePackage *) (buffer + sizeof(PackageType)); |
| *type = cPropertyTableModelChangePackage; |
| pkg->vmID = (long) dialogWindow; |
| |
| // make new Global Refs and send events only to those ATs that want 'em |
| AccessBridgeATInstance *ati = ATs; |
| while (ati != (AccessBridgeATInstance *) 0) { |
| if (ati->accessibilityEventMask & cPropertyTableModelChangeEvent) { |
| |
| PrintDebugString(" sending to AT"); |
| |
| // make new GlobalRefs for this AT |
| pkg->Event = (JOBJECT64)env->NewGlobalRef(event); |
| pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source); |
| #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %p"\ |
| " GlobalRef'd Source: %p", pkg->Event, pkg->AccessibleContextSource); |
| #else // JOBJECT64 is jlong (64 bit) |
| PrintDebugString("[INFO]: GlobalRef'd Event: %016I64X"\ |
| " GlobalRef'd Source: %016I64X", pkg->Event, pkg->AccessibleContextSource); |
| #endif |
| |
| if (oldValue != (jstring) 0) { |
| stringBytes = (const wchar_t *) env->GetStringChars(oldValue, 0); |
| if (stringBytes == NULL) { |
| if (!env->ExceptionCheck()) { |
| jclass cls = env->FindClass("java/lang/OutOfMemoryError"); |
| if (cls != NULL) { |
| env->ThrowNew(cls, NULL); |
| } |
| } |
| return; |
| } |
| wcsncpy(pkg->oldValue, stringBytes, (sizeof(pkg->oldValue) / sizeof(wchar_t))); |
| env->ReleaseStringChars(oldValue, stringBytes); |
| } else { |
| wcsncpy(pkg->oldValue, L"(null)", (sizeof(pkg->oldValue) / sizeof(wchar_t))); |
| } |
| |
| if (newValue != (jstring) 0) { |
| stringBytes = (const wchar_t *) env->GetStringChars(newValue, 0); |
| if (stringBytes == NULL) { |
| if (!env->ExceptionCheck()) { |
| jclass cls = env->FindClass("java/lang/OutOfMemoryError"); |
| if (cls != NULL) { |
| env->ThrowNew(cls, NULL); |
| } |
| } |
| return; |
| } |
| wcsncpy(pkg->newValue, stringBytes, (sizeof(pkg->newValue) / sizeof(wchar_t))); |
| env->ReleaseStringChars(newValue, stringBytes); |
| } else { |
| wcsncpy(pkg->newValue, L"(null)", (sizeof(pkg->newValue) / sizeof(wchar_t))); |
| } |
| |
| ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyTableModelChangeEvent); |
| } |
| ati = ati->nextATInstance; |
| } |
| PrintDebugString("[INFO]: done with propertyTableModelChange event"); |
| } |
| |
| |
| |
| #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) |
| #define PRINT_GLOBALREFS() \ |
| PrintDebugString("[INFO]: GlobalRef'd Event: %p"\ |
| " GlobalRef'd Source: %p", pkg->Event, pkg->AccessibleContextSource); |
| #else // JOBJECT64 is jlong (64 bit) |
| #define PRINT_GLOBALREFS() \ |
| PrintDebugString("[INFO]: GlobalRef'd Event: %016I64X"\ |
| " GlobalRef'd Source: %016I64X", pkg->Event, pkg->AccessibleContextSource); |
| #endif |
| |
| #define FIRE_EVENT(function, packageStruct, packageConstant, eventConstant) \ |
| void JavaAccessBridge::function(JNIEnv *env, jobject callingObj, \ |
| jobject eventObj, jobject source) { \ |
| \ |
| PrintDebugString("[INFO]: Firing event id = %d(%p, %p, %p, %p); vmID = %X", \ |
| eventConstant, env, callingObj, eventObj, source, dialogWindow);\ |
| \ |
| /* sanity check */ \ |
| if (ATs == (AccessBridgeATInstance *) 0) { \ |
| PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)"); \ |
| return; /* panic! */ \ |
| } \ |
| \ |
| /* common setup */ \ |
| char buffer[sizeof(PackageType) + sizeof(packageStruct)]; \ |
| PackageType *type = (PackageType *) buffer; \ |
| packageStruct *pkg = (packageStruct *) (buffer + sizeof(PackageType)); \ |
| *type = packageConstant; \ |
| pkg->vmID = (long) dialogWindow; \ |
| \ |
| /* make new Global Refs, send events only to those ATs that want 'em */ \ |
| AccessBridgeATInstance *ati = ATs; \ |
| while (ati != (AccessBridgeATInstance *) 0) { \ |
| PrintDebugString("[INFO]: javaEventMask = %X eventConstant=%d pkg->vmID=%X",\ |
| ati->javaEventMask, eventConstant, pkg->vmID ); \ |
| if (ati->javaEventMask & eventConstant) { \ |
| \ |
| PrintDebugString("[INFO]: sending to AT"); \ |
| /* make new GlobalRefs for this AT */ \ |
| pkg->Event = (JOBJECT64)env->NewGlobalRef(eventObj); \ |
| pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source); \ |
| PRINT_GLOBALREFS() \ |
| \ |
| ati->sendJavaEventPackage(buffer, sizeof(buffer), eventConstant); \ |
| } \ |
| ati = ati->nextATInstance; \ |
| } \ |
| PrintDebugString("[INFO]: done with firing AWT event"); \ |
| } |
| |
| void JavaAccessBridge::javaShutdown(JNIEnv *env, jobject callingObj) { |
| |
| PrintDebugString("[INFO]: Firing event id = %d(%p, %p); vmID = %X", |
| cJavaShutdownEvent, env, callingObj, dialogWindow); |
| |
| /* sanity check */ |
| if (ATs == (AccessBridgeATInstance *) 0) { |
| PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)"); |
| return; /* panic! */ |
| } |
| |
| /* common setup */ |
| char buffer[sizeof(PackageType) + sizeof(JavaShutdownPackage)]; |
| PackageType *type = (PackageType *) buffer; |
| JavaShutdownPackage *pkg = (JavaShutdownPackage *) (buffer + sizeof(PackageType)); |
| *type = cJavaShutdownPackage; |
| pkg->vmID = (long) dialogWindow; |
| |
| /* make new Global Refs, send events only to those ATs that want 'em */ |
| AccessBridgeATInstance *ati = ATs; |
| while (ati != (AccessBridgeATInstance *) 0) { |
| if (ati->javaEventMask & cJavaShutdownEvent) { |
| PrintDebugString("[INFO]: sending to AT"); |
| ati->sendJavaEventPackage(buffer, sizeof(buffer), cJavaShutdownEvent); |
| } |
| ati = ati->nextATInstance; |
| } |
| PrintDebugString("[INFO]: done with firing AWT event"); |
| } |
| |
| FIRE_EVENT(fireFocusGained, FocusGainedPackage, cFocusGainedPackage, cFocusGainedEvent) |
| FIRE_EVENT(fireFocusLost, FocusLostPackage, cFocusLostPackage, cFocusLostEvent) |
| FIRE_EVENT(fireCaretUpdate, CaretUpdatePackage, cCaretUpdatePackage, cCaretUpdateEvent) |
| FIRE_EVENT(fireMouseClicked, MouseClickedPackage, cMouseClickedPackage, cMouseClickedEvent) |
| FIRE_EVENT(fireMouseEntered, MouseEnteredPackage, cMouseEnteredPackage, cMouseEnteredEvent) |
| FIRE_EVENT(fireMouseExited, MouseExitedPackage, cMouseExitedPackage, cMouseExitedEvent) |
| FIRE_EVENT(fireMousePressed, MousePressedPackage, cMousePressedPackage, cMousePressedEvent) |
| FIRE_EVENT(fireMouseReleased, MouseReleasedPackage, cMouseReleasedPackage, cMouseReleasedEvent) |
| FIRE_EVENT(fireMenuCanceled, MenuCanceledPackage, cMenuCanceledPackage, cMenuCanceledEvent) |
| FIRE_EVENT(fireMenuDeselected, MenuDeselectedPackage, cMenuDeselectedPackage, cMenuDeselectedEvent) |
| FIRE_EVENT(fireMenuSelected, MenuSelectedPackage, cMenuSelectedPackage, cMenuSelectedEvent) |
| FIRE_EVENT(firePopupMenuCanceled, PopupMenuCanceledPackage, cPopupMenuCanceledPackage, cPopupMenuCanceledEvent) |
| FIRE_EVENT(firePopupMenuWillBecomeInvisible, PopupMenuWillBecomeInvisiblePackage, cPopupMenuWillBecomeInvisiblePackage, cPopupMenuWillBecomeInvisibleEvent) |
| FIRE_EVENT(firePopupMenuWillBecomeVisible, PopupMenuWillBecomeVisiblePackage, cPopupMenuWillBecomeVisiblePackage, cPopupMenuWillBecomeVisibleEvent) |
| |
| |
| // ----------------------------- |
| |
| |
| extern "C" { // event stuff from AccessBridge.h, generated by JNI |
| |
| JNIEXPORT void JNICALL |
| Java_com_sun_java_accessibility_internal_AccessBridge_sendDebugString(JNIEnv *env, jobject callingObj, jstring debugStr) { |
| |
| const wchar_t *stringBytes; |
| stringBytes = (const wchar_t *) env->GetStringChars(debugStr, 0); |
| if (stringBytes == NULL) { |
| if (!env->ExceptionCheck()) { |
| jclass cls = env->FindClass("java/lang/OutOfMemoryError"); |
| if (cls != NULL) { |
| env->ThrowNew(cls, NULL); |
| } |
| } |
| return; |
| } |
| wPrintJavaDebugString(L"AccessBridge.java: %ls", stringBytes); |
| env->ReleaseStringChars(debugStr, stringBytes); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_com_sun_java_accessibility_internal_AccessBridge_propertyCaretChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source, |
| jint oldValue, jint newValue) { |
| theJavaAccessBridge->firePropertyCaretChange(env, callingObj, |
| event, source, |
| oldValue, newValue); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_com_sun_java_accessibility_internal_AccessBridge_propertyDescriptionChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source, |
| jstring oldValue, jstring newValue) { |
| theJavaAccessBridge->firePropertyDescriptionChange(env, callingObj, |
| event, source, |
| oldValue, newValue); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_com_sun_java_accessibility_internal_AccessBridge_propertyNameChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source, |
| jstring oldValue, jstring newValue) { |
| theJavaAccessBridge->firePropertyNameChange(env, callingObj, |
| event, source, |
| oldValue, newValue); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_com_sun_java_accessibility_internal_AccessBridge_propertySelectionChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source) { |
| theJavaAccessBridge->firePropertySelectionChange(env, callingObj, |
| event, source); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_com_sun_java_accessibility_internal_AccessBridge_propertyStateChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source, |
| jstring oldValue, jstring newValue) { |
| theJavaAccessBridge->firePropertyStateChange(env, callingObj, |
| event, source, |
| oldValue, newValue); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_com_sun_java_accessibility_internal_AccessBridge_propertyTextChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source) { |
| theJavaAccessBridge->firePropertyTextChange(env, callingObj, |
| event, source); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_com_sun_java_accessibility_internal_AccessBridge_propertyValueChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source, |
| jstring oldValue, jstring newValue) { |
| theJavaAccessBridge->firePropertyValueChange(env, callingObj, |
| event, source, |
| oldValue, newValue); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_com_sun_java_accessibility_internal_AccessBridge_propertyVisibleDataChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source) { |
| theJavaAccessBridge->firePropertyVisibleDataChange(env, callingObj, |
| event, source); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_com_sun_java_accessibility_internal_AccessBridge_propertyChildChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source, |
| jobject oldValue, jobject newValue) { |
| theJavaAccessBridge->firePropertyChildChange(env, callingObj, |
| event, source, |
| oldValue, newValue); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_com_sun_java_accessibility_internal_AccessBridge_propertyActiveDescendentChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source, |
| jobject oldValue, |
| jobject newValue) { |
| theJavaAccessBridge->firePropertyActiveDescendentChange(env, callingObj, |
| event, source, |
| oldValue, newValue); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_com_sun_java_accessibility_internal_AccessBridge_propertyTableModelChange(JNIEnv *env, jobject callingObj, |
| jobject event, jobject source, |
| jstring oldValue, jstring newValue) { |
| |
| theJavaAccessBridge->firePropertyTableModelChange(env, callingObj, |
| event, source, |
| oldValue, newValue); |
| } |
| |
| #define HANDLE_STANDARD_EVENT_FROM_JAVA(function, method) \ |
| JNIEXPORT void JNICALL \ |
| function(JNIEnv *env, jobject callingObj, jobject event, jobject source) { \ |
| theJavaAccessBridge->method(env, callingObj, event, source); \ |
| } |
| |
| |
| JNIEXPORT void JNICALL |
| Java_com_sun_java_accessibility_internal_AccessBridge_javaShutdown(JNIEnv *env, jobject callingObj) { |
| theJavaAccessBridge->javaShutdown(env, callingObj); |
| } |
| |
| HANDLE_STANDARD_EVENT_FROM_JAVA(Java_com_sun_java_accessibility_internal_AccessBridge_focusGained, fireFocusGained) |
| HANDLE_STANDARD_EVENT_FROM_JAVA(Java_com_sun_java_accessibility_internal_AccessBridge_focusLost, fireFocusLost) |
| HANDLE_STANDARD_EVENT_FROM_JAVA(Java_com_sun_java_accessibility_internal_AccessBridge_caretUpdate, fireCaretUpdate) |
| HANDLE_STANDARD_EVENT_FROM_JAVA(Java_com_sun_java_accessibility_internal_AccessBridge_mouseClicked, fireMouseClicked) |
| HANDLE_STANDARD_EVENT_FROM_JAVA(Java_com_sun_java_accessibility_internal_AccessBridge_mouseEntered, fireMouseEntered) |
| HANDLE_STANDARD_EVENT_FROM_JAVA(Java_com_sun_java_accessibility_internal_AccessBridge_mouseExited, fireMouseExited) |
| HANDLE_STANDARD_EVENT_FROM_JAVA(Java_com_sun_java_accessibility_internal_AccessBridge_mousePressed, fireMousePressed) |
| HANDLE_STANDARD_EVENT_FROM_JAVA(Java_com_sun_java_accessibility_internal_AccessBridge_mouseReleased, fireMouseReleased) |
| HANDLE_STANDARD_EVENT_FROM_JAVA(Java_com_sun_java_accessibility_internal_AccessBridge_menuCanceled, fireMenuCanceled) |
| HANDLE_STANDARD_EVENT_FROM_JAVA(Java_com_sun_java_accessibility_internal_AccessBridge_menuDeselected, fireMenuDeselected) |
| HANDLE_STANDARD_EVENT_FROM_JAVA(Java_com_sun_java_accessibility_internal_AccessBridge_menuSelected, fireMenuSelected) |
| HANDLE_STANDARD_EVENT_FROM_JAVA(Java_com_sun_java_accessibility_internal_AccessBridge_popupMenuCanceled, firePopupMenuCanceled) |
| HANDLE_STANDARD_EVENT_FROM_JAVA(Java_com_sun_java_accessibility_internal_AccessBridge_popupMenuWillBecomeInvisible, firePopupMenuWillBecomeInvisible) |
| HANDLE_STANDARD_EVENT_FROM_JAVA(Java_com_sun_java_accessibility_internal_AccessBridge_popupMenuWillBecomeVisible, firePopupMenuWillBecomeVisible) |
| |
| /* |
| * Map a HWND to a Java component |
| * |
| * Class: com_sun_java_accessibility_internal_AccessBridge |
| * Method: jawtGetComponentFromNativeWindowHandle |
| * Signature: (I)Ljava/awt/Component; |
| */ |
| JNIEXPORT jobject JNICALL |
| Java_com_sun_java_accessibility_internal_AccessBridge_jawtGetComponentFromNativeWindowHandle |
| (JNIEnv *env, jobject callingObj, jint windowHandle) { |
| |
| JAWT awt; |
| jboolean result; |
| jobject component = (jobject)0; |
| |
| // Get the AWT |
| awt.version = JAWT_VERSION_1_4; |
| result = JAWT_GetAWT(env, &awt); |
| if (result == JNI_FALSE) { |
| return (jobject)0; |
| } |
| |
| // Get the component |
| return awt.GetComponent(env, (void *)windowHandle); |
| } |
| |
| |
| /* |
| * Map a Java component to a HWND |
| * |
| * Class: com_sun_java_accessibility_internal_AccessBridge |
| * Method: jawtGetNativeWindowHandleFromComponent |
| * Signature: (Ljava/awt/Component;)I |
| */ |
| JNIEXPORT jint JNICALL |
| Java_com_sun_java_accessibility_internal_AccessBridge_jawtGetNativeWindowHandleFromComponent |
| (JNIEnv *env, jobject callingObj, jobject component) { |
| |
| JAWT awt; |
| JAWT_DrawingSurface* ds; |
| JAWT_DrawingSurfaceInfo* dsi; |
| JAWT_Win32DrawingSurfaceInfo* dsi_win; |
| jboolean result; |
| // jint lock; |
| jint windowHandle = -1; |
| |
| // Get the AWT |
| awt.version = JAWT_VERSION_1_4; |
| result = JAWT_GetAWT(env, &awt); |
| if (result == JNI_FALSE) { |
| return -1; |
| } |
| |
| // Get the drawing surface |
| ds = awt.GetDrawingSurface(env, component); |
| if (ds == NULL) { |
| return -1; |
| } |
| |
| // Get the drawing surface info |
| dsi = ds->GetDrawingSurfaceInfo(ds); |
| |
| // Get the platform-specific drawing info |
| dsi_win = (JAWT_Win32DrawingSurfaceInfo *)dsi->platformInfo; |
| |
| // Get the window handle |
| windowHandle = (jint)dsi_win->hwnd; |
| |
| // Free the drawing surface info |
| ds->FreeDrawingSurfaceInfo(dsi); |
| |
| // Free the drawing surface |
| awt.FreeDrawingSurface(ds); |
| |
| return windowHandle; |
| } |
| |
| } |
