| /* | |
| * 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; | |
| } | |
| } |