1 /* 2 * Copyright (c) 2005, 2016, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 /* 27 * A DLL which is loaded by Windows executables to handle communication 28 * between Java VMs purposes of Accessbility. 29 */ 30 31 #include "AccessBridgeDebug.h" 32 #include "WinAccessBridge.h" 33 #include "accessBridgeResource.h" 34 #include "accessBridgeCallbacks.h" 35 #include "AccessBridgeMessages.h" 36 #include "AccessBridgeMessageQueue.h" 37 38 #include <windows.h> 39 #include <jni.h> 40 #include <stdio.h> 41 42 // send memory lock 43 // 44 // This lock is need to serialize access to the buffer used by sendMemoryPackage. 45 // If a JVM goes away while the associated memory buffer is in use, a thread switch 46 // allows a call to JavaVMDestroyed and deallocation of the memory buffer. 47 CRITICAL_SECTION sendMemoryIPCLock; 48 49 // registry paths to newly found JVMs that don't have the bridge installed 50 char **newJVMs; 51 52 WinAccessBridge *theWindowsAccessBridge; 53 HWND theDialogWindow; 54 55 // unique broadcast msg. IDs gotten dymanically 56 extern UINT theFromJavaHelloMsgID; 57 extern UINT theFromWindowsHelloMsgID; 58 59 // protects the javaVMs chain while in use 60 bool isVMInstanceChainInUse; 61 62 /* =================================================================================== */ 63 64 65 66 /** 67 * Proc for "New JVM Found" dialog 68 */ 69 BOOL CALLBACK newJVMFoundDialogProc(HWND hwndDlg, UINT message, WPARAM wParam, LPARAM lParam) { 70 71 switch (message) { 72 case WM_COMMAND: 73 // PrintDebugString(" newJVMDialogProc: LOWORD(wParam) = %d", LOWORD(wParam)); 74 75 switch (LOWORD(wParam)) { 76 77 // Remind user later that a new JVM was installed 78 case cRemindThereIsNewJVM: 79 PrintDebugString("[INFO]: newJVMDialogProc: cRemindThereIsNewJVM"); 80 // do nothing 81 EndDialog(hwndDlg, wParam); 82 return TRUE; 83 84 // Do not remind user later that a new JVM was installed 85 /* 86 case cDoNotRemindThereIsNewJVM: 87 PrintDebugString(" newJVMDialogProc: cDoNotRemindThereIsNewJVM"); 88 // remember to not remind the user there are new JVMs 89 PrintDebugString("theWindowsAccessBridge = %x", theWindowsAccessBridge); 90 if (theWindowsAccessBridge != NULL) { 91 dontRemindUser(newJVMs); 92 } 93 EndDialog(hwndDlg, wParam); 94 return TRUE; 95 */ 96 97 // Run the AccessBridge installer 98 /* 99 case cInstallAccessBridge: 100 PrintDebugString(" newJVMDialogProc: cInstallAccessBridge"); 101 // start the installer 102 if (theWindowsAccessBridge != NULL) { 103 startInstaller(newJVMs); 104 } 105 EndDialog(hwndDlg, wParam); 106 return TRUE; 107 */ 108 109 default: 110 ; 111 } 112 default: 113 ; 114 } 115 return FALSE; 116 } 117 118 119 120 /* =========================================================================== */ 121 122 // --------------------------------------------------------------------------- 123 124 extern "C" { 125 /** 126 * DllMain - where Windows executables will load/unload us 127 * 128 */ 129 BOOL WINAPI DllMain(HINSTANCE hinstDll, DWORD fdwReason, LPVOID lpvReserved) { 130 131 switch (fdwReason) { 132 case DLL_PROCESS_ATTACH: // A Windows executable loaded us 133 initializeFileLogger("_windows_access_bridge"); 134 PrintDebugString("[INFO]: DLL_PROCESS_ATTACH"); 135 theWindowsAccessBridge = new WinAccessBridge(hinstDll); 136 break; 137 138 case DLL_PROCESS_DETACH: // A Windows executable unloaded us 139 if (theWindowsAccessBridge != (WinAccessBridge *) 0) { 140 PrintDebugString("[INFO]: *** AccessBridgeDialogProc -> deleting theWindowsAccessBridge"); 141 delete theWindowsAccessBridge; 142 } 143 break; 144 } 145 146 return(TRUE); 147 } 148 149 /** 150 * Append debug info to dialog 151 * 152 * replaced with code to send output to debug file 153 * 154 */ 155 void AppendToCallInfo(char *s) { 156 157 /* 158 _CrtDbgReport(_CRT_WARN, (const char *) NULL, NULL, (const char *) NULL, 159 (const char *) "WinAccessBridge: %s", s); 160 */ 161 162 char buf[1024]; 163 sprintf(buf, "WinAccessBridge: %s", s); 164 OutputDebugString(buf); 165 } 166 167 /** 168 * Our window proc 169 * 170 */ 171 BOOL CALLBACK AccessBridgeDialogProc(HWND hDlg, UINT message, UINT wParam, LONG lParam) { 172 COPYDATASTRUCT *sentToUs; 173 char *package; 174 175 switch (message) { 176 case WM_INITDIALOG: 177 PrintDebugString("[INFO]: AccessBridgeDialogProc -> Initializing"); 178 break; 179 180 // call from Java with data for us to deliver 181 case WM_COPYDATA: 182 if (theDialogWindow == (HWND) wParam) { 183 PrintDebugString("[INFO]: AccessBridgeDialogProc -> Got WM_COPYDATA from Java Bridge DLL"); 184 } else { 185 PrintDebugString("[INFO]: AccessBridgeDialogProc -> Got WM_COPYDATA from HWND %p", wParam); 186 sentToUs = (COPYDATASTRUCT *) lParam; 187 package = (char *) sentToUs->lpData; 188 theWindowsAccessBridge->preProcessPackage(package, sentToUs->cbData); 189 } 190 break; 191 192 // message to ourselves -> de-queue messages and send 'em 193 case AB_MESSAGE_QUEUED: 194 PrintDebugString("[INFO]: AccessBridgeDialogProc -> Got AB_MESSAGE_QUEUED from ourselves"); 195 theWindowsAccessBridge->receiveAQueuedPackage(); 196 break; 197 198 // a JavaAccessBridge DLL is going away 199 // 200 // When JavaVMDestroyed is called a AccessBridgeJavaVMInstance in the 201 // javaVMs chain will be removed. If that chain is in use this will 202 // cause a crash. One way AB_DLL_GOING_AWAY can arrive is on any 203 // outgoing SendMessage call. SendMessage normally spins waiting for 204 // a response. However, if there is an incoming SendMessage, e.g. for 205 // AB_DLL_GOING_AWAY Windows will send that request to this DialogProc. 206 // One seemingly easy way to combat that is to use SendMessageTimeout 207 // with the SMTO_BLOCK flag set. However, it has been the case that 208 // even after using that technique AB_DLL_GOING_AWAY can still arrive 209 // in the middle of processing the javaVMs chain. An alternative that 210 // was tried was to use a critical section around any access ot the 211 // javaVMs chain but unfortunately the AB_DLL_GOING_AWAY message arrives 212 // on the same thread and thus the use of a critical section is ineffective. 213 // The solution then is to set a flag whenever the javaVMs chain is being 214 // used and if that flag is set at this point the message will be posted 215 // to the message queue. That would delay the destruction of the instance 216 // until the chain is not being traversed. 217 case AB_DLL_GOING_AWAY: 218 PrintDebugString("[INFO]: ***** AccessBridgeDialogProc -> Got AB_DLL_GOING_AWAY message"); 219 if (isVMInstanceChainInUse) { 220 PrintDebugString("[INFO]: javaVMs chain in use, calling PostMessage"); 221 PostMessage(hDlg, AB_DLL_GOING_AWAY, wParam, (LPARAM)0); 222 } else { 223 PrintDebugString("[INFO]: calling javaVMDestroyed"); 224 theWindowsAccessBridge->JavaVMDestroyed((HWND) wParam); 225 } 226 break; 227 228 default: 229 // the JavaVM is saying "hi"! 230 // wParam == sourceHwnd; lParam == JavaVMID 231 if (message == theFromJavaHelloMsgID) { 232 PrintDebugString("[INFO]: AccessBridgeDialogProc -> Got theFromJavaHelloMsgID; wParam = %p, lParam = %p", wParam, lParam); 233 theWindowsAccessBridge->rendezvousWithNewJavaDLL((HWND) wParam, (long ) lParam); 234 } 235 break; 236 } 237 238 return (FALSE); 239 } 240 241 } 242 243 244 245 246 // --------------------------------------------------------------------------- 247 248 /** 249 * Initialize the WinAccessBridge 250 * 251 */ 252 WinAccessBridge::WinAccessBridge(HINSTANCE hInstance) { 253 254 PrintDebugString("[INFO]: WinAccessBridge ctor"); 255 256 // IntializeCriticalSection should only be called once. 257 InitializeCriticalSection(&sendMemoryIPCLock); 258 windowsInstance = hInstance; 259 javaVMs = (AccessBridgeJavaVMInstance *) 0; 260 eventHandler = new AccessBridgeEventHandler(); 261 messageQueue = new AccessBridgeMessageQueue(); 262 initBroadcastMessageIDs(); // get the unique to us broadcast msg. IDs 263 theWindowsAccessBridge = this; 264 isVMInstanceChainInUse = false; 265 266 ShowWindow(theDialogWindow, SW_SHOW); 267 } 268 269 270 271 /** 272 * Destroy the WinAccessBridge 273 * 274 */ 275 WinAccessBridge::~WinAccessBridge() { 276 // inform all other AccessBridges that we're going away 277 // -> shut down all event listening 278 // -> release all objects held in the JVM by us 279 280 PrintDebugString("[INFO]: *****in WinAccessBridge::~WinAccessBridge()"); 281 282 // send a broadcast msg.; let other AccessBridge DLLs know we're going away 283 AccessBridgeJavaVMInstance *current = javaVMs; 284 while (current != (AccessBridgeJavaVMInstance *) 0) { 285 PrintDebugString("[INFO]: telling %p we're going away", current->javaAccessBridgeWindow); 286 SendMessage(current->javaAccessBridgeWindow, 287 AB_DLL_GOING_AWAY, (WPARAM) dialogWindow, (LPARAM) 0); 288 current = current->nextJVMInstance; 289 } 290 291 PrintDebugString("[INFO]: finished telling JVMs about our demise"); 292 293 delete eventHandler; 294 delete messageQueue; 295 delete javaVMs; 296 297 PrintDebugString("[INFO]: finished deleting eventHandler, messageQueue, and javaVMs"); 298 PrintDebugString("[INFO]: GOODBYE CRUEL WORLD..."); 299 300 DestroyWindow(theDialogWindow); 301 } 302 303 304 /** 305 * Bring up our window; make a connection to the rest of the world 306 * 307 */ 308 BOOL 309 WinAccessBridge::initWindow() { 310 theDialogWindow = CreateDialog(windowsInstance, 311 "ACCESSBRIDGESTATUSWINDOW", NULL, 312 (DLGPROC) AccessBridgeDialogProc); 313 314 // If window could not be created, return "failure". 315 if (!theDialogWindow) 316 return (FALSE); 317 318 dialogWindow = theDialogWindow; 319 320 // Make the window visible, update its client area, & return "success". 321 // DEBUG_CODE(ShowWindow (theDialogWindow, SW_SHOWNORMAL)); 322 // DEBUG_CODE(UpdateWindow (theDialogWindow)); 323 324 // post a broadcast msg.; let other AccessBridge DLLs know we exist 325 PostMessage(HWND_BROADCAST, theFromWindowsHelloMsgID, (WPARAM) dialogWindow, (LPARAM) 0); 326 327 return (TRUE); 328 } 329 330 // ----------------------- 331 332 /** 333 * rendezvousWithNewJavaDLL 334 * - Build AccessBridgeJavaVMInstance data structure 335 * (including setting up Memory-Mapped file info) 336 * 337 */ 338 LRESULT 339 WinAccessBridge::rendezvousWithNewJavaDLL(HWND JavaBridgeDLLwindow, long vmID) { 340 LRESULT returnVal; 341 342 PrintDebugString("[INFO]: in WinAccessBridge::rendezvousWithNewJavaDLL(%p, %X)", 343 JavaBridgeDLLwindow, vmID); 344 345 isVMInstanceChainInUse = true; 346 AccessBridgeJavaVMInstance *newVM = 347 new AccessBridgeJavaVMInstance(dialogWindow, JavaBridgeDLLwindow, vmID, javaVMs); 348 javaVMs = newVM; 349 isVMInstanceChainInUse = false; 350 351 returnVal = javaVMs->initiateIPC(); 352 if (returnVal == 0) { 353 354 // tell the newly created JavaVM what events we're interested in, if any 355 long javaEventMask = eventHandler->getJavaEventMask(); 356 long accessibilityEventMask = eventHandler->getAccessibilityEventMask(); 357 358 PrintDebugString("[INFO]: Setting Java event mask to: %X", javaEventMask); 359 360 if (javaEventMask != 0) { 361 addJavaEventNotification(javaEventMask); 362 } 363 364 PrintDebugString("[INFO]: Setting Accessibility event mask to: %X", accessibilityEventMask); 365 366 if (accessibilityEventMask != 0) { 367 addAccessibilityEventNotification(accessibilityEventMask); 368 } 369 } else { 370 PrintDebugString("[ERROR]: Failed to initiate IPC with newly created JavaVM!!!"); 371 return FALSE; 372 } 373 374 PrintDebugString("[INFO]: Success!! We rendezvoused with the JavaDLL"); 375 return returnVal; 376 } 377 378 // ----------------------- 379 380 /** 381 * sendPackage - uses SendMessage(WM_COPYDATA) to do IPC messaging 382 * with the Java AccessBridge DLL 383 * 384 * NOTE: WM_COPYDATA is only for one-way IPC; there 385 * is now way to return parameters (especially big ones) 386 * Use sendMemoryPackage() to do that! 387 */ 388 void 389 WinAccessBridge::sendPackage(char *buffer, long bufsize, HWND destWindow) { 390 COPYDATASTRUCT toCopy; 391 toCopy.dwData = 0; // 32-bits we could use for something... 392 toCopy.cbData = bufsize; 393 toCopy.lpData = buffer; 394 395 SendMessage(destWindow, WM_COPYDATA, (WPARAM) dialogWindow, (LPARAM) &toCopy); 396 } 397 398 399 /** 400 * sendMemoryPackage - uses Memory-Mapped files to do IPC messaging 401 * with the Java AccessBridge DLL, informing the 402 * Java AccessBridge DLL via SendMessage that something 403 * is waiting for it in the shared file... 404 * 405 * In the SendMessage call, the third param (WPARAM) is 406 * the source HWND (theDialogWindow in this case), and 407 * the fourth param (LPARAM) is the size in bytes of 408 * the package put into shared memory. 409 * 410 */ 411 BOOL 412 WinAccessBridge::sendMemoryPackage(char *buffer, long bufsize, HWND destWindow) { 413 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 414 return FALSE; 415 } 416 AccessBridgeJavaVMInstance *ourABJavaVMInstance; 417 ourABJavaVMInstance = javaVMs->findABJavaVMInstanceFromJavaHWND(destWindow); 418 if (ourABJavaVMInstance != (AccessBridgeJavaVMInstance *) 0) { 419 if (!ourABJavaVMInstance->sendMemoryPackage(buffer, bufsize)) { 420 // return falue to the caller 421 memset(buffer, 0, bufsize); 422 return FALSE; 423 } 424 } else { 425 PrintDebugString("[ERROR]: sending memory package: couldn't find destWindow"); 426 return FALSE; 427 } 428 return TRUE; 429 } 430 431 432 /** 433 * queuePackage - put a package onto the queue for latter processing 434 * 435 */ 436 BOOL 437 WinAccessBridge::queuePackage(char *buffer, long bufsize) { 438 PrintDebugString("[INFO]: in WinAccessBridge::queuePackage(%p, %d)", buffer, bufsize); 439 440 AccessBridgeQueueElement *element = new AccessBridgeQueueElement(buffer, bufsize); 441 442 messageQueue->add(element); 443 PostMessage(dialogWindow, AB_MESSAGE_QUEUED, (WPARAM) 0, (LPARAM) 0); 444 return TRUE; 445 } 446 447 448 /** 449 * receiveAQueuedPackage - remove a pending packge from the queue and 450 * handle it. If the queue is busy, post a 451 * message to self to retrieve it later 452 * 453 */ 454 BOOL 455 WinAccessBridge::receiveAQueuedPackage() { 456 AccessBridgeQueueElement *element = NULL; 457 458 PrintDebugString("[INFO]: in WinAccessBridge::receiveAQueuedPackage()"); 459 460 // ensure against re-entrancy problems... 461 if (messageQueue->getRemoveLockSetting() == FALSE) { 462 messageQueue->setRemoveLock(TRUE); 463 464 PrintDebugString("[INFO]: dequeueing message"); 465 466 QueueReturns result = messageQueue->remove(&element); 467 468 switch (result) { 469 470 case cQueueBroken: 471 PrintDebugString("[ERROR]: Queue seems to be broken!"); 472 messageQueue->setRemoveLock(FALSE); 473 return FALSE; 474 475 case cMoreMessages: 476 case cQueueEmpty: 477 if (element != (AccessBridgeQueueElement *) 0) { 478 PrintDebugString("[INFO]: found one; sending it!"); 479 processPackage(element->buffer, element->bufsize); 480 delete element; 481 } else { 482 PrintDebugString("[WARN]: ODD... element == 0!"); 483 return FALSE; 484 } 485 break; 486 487 case cQueueInUse: 488 PrintDebugString("[WARN]: Queue in use, will try again later..."); 489 PostMessage(dialogWindow, AB_MESSAGE_QUEUED, (WPARAM) 0, (LPARAM) 0); 490 break; 491 492 default: 493 messageQueue->setRemoveLock(FALSE); 494 return FALSE; // should never get something we don't recognize! 495 } 496 } else { 497 PrintDebugString("[WARN]: unable to dequeue message; remove lock is set"); 498 PostMessage(dialogWindow, AB_MESSAGE_QUEUED, (WPARAM) 0, (LPARAM) 0); // Fix for 6995891 499 } 500 501 messageQueue->setRemoveLock(FALSE); 502 return TRUE; 503 } 504 505 // ----------------------- 506 507 /** 508 * preProcessPackage 509 * - do triage on incoming packages; queue some, deal with others 510 * 511 */ 512 void 513 WinAccessBridge::preProcessPackage(char *buffer, long bufsize) { 514 PrintDebugString("[INFO]: PreProcessing package sent from Java:"); 515 516 PackageType *type = (PackageType *) buffer; 517 518 switch (*type) { 519 520 PrintDebugString("[INFO]: type == %X", *type); 521 522 // event packages all get queued for later handling 523 //case cPropertyChangePackage: 524 case cJavaShutdownPackage: 525 case cFocusGainedPackage: 526 case cFocusLostPackage: 527 case cCaretUpdatePackage: 528 case cMouseClickedPackage: 529 case cMouseEnteredPackage: 530 case cMouseExitedPackage: 531 case cMousePressedPackage: 532 case cMouseReleasedPackage: 533 case cMenuCanceledPackage: 534 case cMenuDeselectedPackage: 535 case cMenuSelectedPackage: 536 case cPopupMenuCanceledPackage: 537 case cPopupMenuWillBecomeInvisiblePackage: 538 case cPopupMenuWillBecomeVisiblePackage: 539 540 case cPropertyCaretChangePackage: 541 case cPropertyDescriptionChangePackage: 542 case cPropertyNameChangePackage: 543 case cPropertySelectionChangePackage: 544 case cPropertyStateChangePackage: 545 case cPropertyTextChangePackage: 546 case cPropertyValueChangePackage: 547 case cPropertyVisibleDataChangePackage: 548 case cPropertyChildChangePackage: 549 case cPropertyActiveDescendentChangePackage: 550 551 case cPropertyTableModelChangePackage: 552 553 queuePackage(buffer, bufsize); 554 break; 555 556 // perhaps there will be some other packages to process at some point... // 557 558 default: 559 PrintDebugString("[ERROR]: processing FAILED!! -> don't know how to handle type = %X", *type); 560 break; 561 } 562 563 PrintDebugString("[INFO]: package preprocessing completed"); 564 } 565 566 567 #define DISPATCH_EVENT_PACKAGE(packageID, eventPackage, fireEventMethod) \ 568 case packageID: \ 569 if (bufsize == sizeof(PackageType) + sizeof(eventPackage)) { \ 570 eventPackage *pkg = \ 571 (eventPackage *) (buffer + sizeof(PackageType)); \ 572 PrintDebugString("[INFO]: begin callback to AT, type == %X", *type); \ 573 theWindowsAccessBridge->eventHandler->fireEventMethod( \ 574 pkg->vmID, pkg->Event, pkg->AccessibleContextSource); \ 575 PrintDebugString("[INFO]: event callback complete!"); \ 576 } else { \ 577 PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", \ 578 bufsize, sizeof(PackageType) + sizeof(eventPackage)); \ 579 } \ 580 break; 581 582 #define DISPATCH_PROPERTY_CHANGE_PACKAGE(packageID, eventPackage, fireEventMethod, oldValue, newValue) \ 583 case packageID: \ 584 if (bufsize == sizeof(PackageType) + sizeof(eventPackage)) { \ 585 eventPackage *pkg = \ 586 (eventPackage *) (buffer + sizeof(PackageType)); \ 587 PrintDebugString("[INFO]: begin callback to AT, type == %X", *type); \ 588 theWindowsAccessBridge->eventHandler->fireEventMethod( \ 589 pkg->vmID, pkg->Event, pkg->AccessibleContextSource, \ 590 pkg->oldValue, pkg->newValue); \ 591 PrintDebugString("[INFO]: event callback complete!"); \ 592 } else { \ 593 PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", \ 594 bufsize, sizeof(PackageType) + sizeof(eventPackage)); \ 595 } \ 596 break; 597 598 #define DISPATCH_PROPERTY_TABLE_MODEL_CHANGE_PACKAGE(packageID, eventPackage, fireEventMethod, oldValue, newValue) \ 599 case packageID: \ 600 if (bufsize == sizeof(PackageType) + sizeof(eventPackage)) { \ 601 eventPackage *pkg = \ 602 (eventPackage *) (buffer + sizeof(PackageType)); \ 603 PrintDebugString("[INFO]: begin callback to AT, type == %X", *type); \ 604 theWindowsAccessBridge->eventHandler->fireEventMethod( \ 605 pkg->vmID, pkg->Event, pkg->AccessibleContextSource, \ 606 pkg->oldValue, pkg->newValue); \ 607 PrintDebugString("[INFO]: event callback complete!"); \ 608 } else { \ 609 PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", \ 610 bufsize, sizeof(PackageType) + sizeof(eventPackage)); \ 611 } \ 612 break; 613 614 /** 615 * processPackage - processes the output of SendMessage(WM_COPYDATA) 616 * to do IPC messaging with the Java AccessBridge DLL 617 * 618 */ 619 void 620 WinAccessBridge::processPackage(char *buffer, long bufsize) { 621 PrintDebugString("[INFO]: WinAccessBridge::Processing package sent from Java:"); 622 623 PackageType *type = (PackageType *) buffer; 624 625 switch (*type) { 626 627 PrintDebugString("[INFO]: type == %X", *type); 628 629 case cJavaShutdownPackage: 630 PrintDebugString("[INFO]: type == cJavaShutdownPackage"); 631 if (bufsize == sizeof(PackageType) + sizeof(JavaShutdownPackage)) { 632 JavaShutdownPackage *pkg = 633 (JavaShutdownPackage *) (buffer + sizeof(PackageType)); 634 theWindowsAccessBridge->eventHandler->fireJavaShutdown(pkg->vmID); 635 PrintDebugString("[INFO]: event callback complete!"); 636 PrintDebugString("[INFO]: event fired!"); 637 } else { 638 PrintDebugString("[ERROR]: processing FAILED!! -> bufsize = %d; expectation = %d", 639 bufsize, sizeof(PackageType) + sizeof(JavaShutdownPackage)); 640 } 641 break; 642 643 644 DISPATCH_EVENT_PACKAGE(cFocusGainedPackage, FocusGainedPackage, fireFocusGained); 645 DISPATCH_EVENT_PACKAGE(cFocusLostPackage, FocusLostPackage, fireFocusLost); 646 647 DISPATCH_EVENT_PACKAGE(cCaretUpdatePackage, CaretUpdatePackage, fireCaretUpdate); 648 649 DISPATCH_EVENT_PACKAGE(cMouseClickedPackage, MouseClickedPackage, fireMouseClicked); 650 DISPATCH_EVENT_PACKAGE(cMouseEnteredPackage, MouseEnteredPackage, fireMouseEntered); 651 DISPATCH_EVENT_PACKAGE(cMouseExitedPackage, MouseExitedPackage, fireMouseExited); 652 DISPATCH_EVENT_PACKAGE(cMousePressedPackage, MousePressedPackage, fireMousePressed); 653 DISPATCH_EVENT_PACKAGE(cMouseReleasedPackage, MouseReleasedPackage, fireMouseReleased); 654 655 DISPATCH_EVENT_PACKAGE(cMenuCanceledPackage, MenuCanceledPackage, fireMenuCanceled); 656 DISPATCH_EVENT_PACKAGE(cMenuDeselectedPackage, MenuDeselectedPackage, fireMenuDeselected); 657 DISPATCH_EVENT_PACKAGE(cMenuSelectedPackage, MenuSelectedPackage, fireMenuSelected); 658 DISPATCH_EVENT_PACKAGE(cPopupMenuCanceledPackage, PopupMenuCanceledPackage, firePopupMenuCanceled); 659 DISPATCH_EVENT_PACKAGE(cPopupMenuWillBecomeInvisiblePackage, PopupMenuWillBecomeInvisiblePackage, firePopupMenuWillBecomeInvisible); 660 DISPATCH_EVENT_PACKAGE(cPopupMenuWillBecomeVisiblePackage, PopupMenuWillBecomeVisiblePackage, firePopupMenuWillBecomeVisible); 661 662 DISPATCH_PROPERTY_CHANGE_PACKAGE(cPropertyNameChangePackage, 663 PropertyNameChangePackage, 664 firePropertyNameChange, oldName, newName) 665 DISPATCH_PROPERTY_CHANGE_PACKAGE(cPropertyDescriptionChangePackage, 666 PropertyDescriptionChangePackage, 667 firePropertyDescriptionChange, 668 oldDescription, newDescription) 669 DISPATCH_PROPERTY_CHANGE_PACKAGE(cPropertyStateChangePackage, 670 PropertyStateChangePackage, 671 firePropertyStateChange, oldState, newState) 672 DISPATCH_PROPERTY_CHANGE_PACKAGE(cPropertyValueChangePackage, 673 PropertyValueChangePackage, 674 firePropertyValueChange, oldValue, newValue) 675 DISPATCH_EVENT_PACKAGE(cPropertySelectionChangePackage, 676 PropertySelectionChangePackage, firePropertySelectionChange) 677 DISPATCH_EVENT_PACKAGE(cPropertyTextChangePackage, 678 PropertyTextChangePackage, firePropertyTextChange) 679 DISPATCH_PROPERTY_CHANGE_PACKAGE(cPropertyCaretChangePackage, 680 PropertyCaretChangePackage, 681 firePropertyCaretChange, oldPosition, newPosition) 682 DISPATCH_EVENT_PACKAGE(cPropertyVisibleDataChangePackage, 683 PropertyVisibleDataChangePackage, firePropertyVisibleDataChange) 684 DISPATCH_PROPERTY_CHANGE_PACKAGE(cPropertyChildChangePackage, 685 PropertyChildChangePackage, 686 firePropertyChildChange, 687 oldChildAccessibleContext, 688 newChildAccessibleContext) 689 DISPATCH_PROPERTY_CHANGE_PACKAGE(cPropertyActiveDescendentChangePackage, 690 PropertyActiveDescendentChangePackage, 691 firePropertyActiveDescendentChange, 692 oldActiveDescendentAccessibleContext, 693 newActiveDescendentAccessibleContext) 694 695 DISPATCH_PROPERTY_TABLE_MODEL_CHANGE_PACKAGE(cPropertyTableModelChangePackage, 696 PropertyTableModelChangePackage, 697 firePropertyTableModelChange, 698 oldValue, newValue) 699 700 701 default: 702 PrintDebugString("[ERROR]: processing FAILED!! -> don't know how to handle type = %X", *type); 703 break; 704 } 705 706 PrintDebugString("[INFO]: package processing completed"); 707 } 708 709 710 // ----------------------------- 711 712 void 713 WinAccessBridge::JavaVMDestroyed(HWND VMBridgeDLLWindow) { 714 PrintDebugString("[INFO]: ***** WinAccessBridge::JavaVMDestroyed(%p)", VMBridgeDLLWindow); 715 716 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 717 return; 718 } 719 720 isVMInstanceChainInUse = true; 721 AccessBridgeJavaVMInstance *currentVM = javaVMs; 722 AccessBridgeJavaVMInstance *previousVM = javaVMs; 723 if (javaVMs->javaAccessBridgeWindow == VMBridgeDLLWindow) { 724 javaVMs = javaVMs->nextJVMInstance; 725 delete currentVM; 726 727 PrintDebugString("[INFO]: data structures successfully removed"); 728 729 // [[[FIXME]]] inform Windows AT that a JVM went away, 730 // and that any jobjects it's got lying around for that JVM 731 // are now invalid 732 733 } else { 734 while (currentVM != (AccessBridgeJavaVMInstance *) 0) { 735 if (currentVM->javaAccessBridgeWindow == VMBridgeDLLWindow) { 736 previousVM->nextJVMInstance = currentVM->nextJVMInstance; 737 delete currentVM; 738 739 PrintDebugString("[INFO]: data structures successfully removed"); 740 741 // [[[FIXME]]] inform Windows AT that a JVM went away, 742 // and that any jobjects it's got lying around for that JVM 743 // are now invalid 744 isVMInstanceChainInUse = false; 745 return; 746 } else { 747 previousVM = currentVM; 748 currentVM = currentVM->nextJVMInstance; 749 } 750 } 751 PrintDebugString("[ERROR]: couldn't find matching data structures!"); 752 } 753 isVMInstanceChainInUse = false; 754 } 755 756 // ----------------------- 757 758 /** 759 * releaseJavaObject - lets the JavaVM know it can release the Java Object 760 * 761 * Note: once you have made this call, the JavaVM will garbage collect 762 * the jobject you pass in. If you later use that jobject in another 763 * call, you will cause all maner of havoc! 764 * 765 */ 766 void 767 WinAccessBridge::releaseJavaObject(long vmID, JOBJECT64 object) { 768 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 769 PrintDebugString("[INFO]: WinAccessBridge::releaseJavaObject(%X, %p)", vmID, object); 770 #else // JOBJECT64 is jlong (64 bit) 771 PrintDebugString("[INFO]: WinAccessBridge::releaseJavaObject(%X, %016I64X)", vmID, object); 772 #endif 773 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 774 return; 775 } 776 char buffer[sizeof(PackageType) + sizeof(ReleaseJavaObjectPackage)]; 777 PackageType *type = (PackageType *) buffer; 778 ReleaseJavaObjectPackage *pkg = (ReleaseJavaObjectPackage *) (buffer + sizeof(PackageType)); 779 *type = cReleaseJavaObjectPackage; 780 pkg->vmID = vmID; 781 pkg->object = object; 782 783 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 784 if (destABWindow != (HWND) 0) { 785 sendPackage(buffer, sizeof(buffer), destABWindow); // no return values! 786 } 787 } 788 789 // ----------------------- 790 791 /** 792 * getVersionInfo - fill the AccessBridgeVersionInfo struct 793 * 794 */ 795 BOOL 796 WinAccessBridge::getVersionInfo(long vmID, AccessBridgeVersionInfo *info) { 797 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 798 return FALSE; 799 } 800 char buffer[sizeof(PackageType) + sizeof(GetAccessBridgeVersionPackage)]; 801 PackageType *type = (PackageType *) buffer; 802 GetAccessBridgeVersionPackage *pkg = (GetAccessBridgeVersionPackage *) (buffer + sizeof(PackageType)); 803 *type = cGetAccessBridgeVersionPackage; 804 pkg->vmID = vmID; 805 806 PrintDebugString("[INFO]: WinAccessBridge::getVersionInfo(%X, )", vmID); 807 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 808 if (destABWindow != (HWND) 0) { 809 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 810 memcpy(info, &(pkg->rVersionInfo), sizeof(AccessBridgeVersionInfo)); 811 PrintDebugString("[INFO]: VMversion: %ls\n"\ 812 " bridgeJavaClassVersion: %ls\n"\ 813 " bridgeJavaDLLVersion: %ls\n"\ 814 " bridgeWinDLLVersion: %ls\n"\ 815 , info->VMversion, info->bridgeJavaClassVersion, info->bridgeJavaDLLVersion, info->bridgeWinDLLVersion); 816 return TRUE; 817 } 818 } 819 return FALSE; 820 } 821 822 823 /********** Window-related routines ***********************************/ 824 825 /** 826 * isJavaWindow - returns TRUE if the HWND is a top-level Java Window 827 * 828 * Note: just because the Windnow is a top-level Java window, that doesn't 829 * mean that it is accessible. Call getAccessibleContextFromHWND(HWND) to get the 830 * AccessibleContext, if any, for an HWND that is a Java Window. 831 * 832 */ 833 BOOL 834 WinAccessBridge::isJavaWindow(HWND window) { 835 HWND hwnd; 836 837 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 838 return FALSE; 839 } 840 841 // quick check to see if 'window' is top-level; if not, it's not interesting... 842 // [[[FIXME]]] is this for sure an OK optimization? 843 hwnd = getTopLevelHWND(window); 844 if (hwnd == (HWND) NULL) { 845 return FALSE; 846 } 847 848 PrintDebugString("[INFO]: In WinAccessBridge::isJavaWindow"); 849 850 851 852 char buffer[sizeof(PackageType) + sizeof(IsJavaWindowPackage)]; 853 PackageType *type = (PackageType *) buffer; 854 IsJavaWindowPackage *pkg = (IsJavaWindowPackage *) (buffer + sizeof(PackageType)); 855 *type = cIsJavaWindowPackage; 856 pkg->window = (jint) window; 857 858 PrintDebugString("[INFO]: WinAccessBridge::isJavaWindow(%p)", window); 859 860 isVMInstanceChainInUse = true; 861 AccessBridgeJavaVMInstance *current = javaVMs; 862 while (current != (AccessBridgeJavaVMInstance *) 0) { 863 if (sendMemoryPackage(buffer, sizeof(buffer), current->javaAccessBridgeWindow) == TRUE) { 864 if (pkg->rResult != 0) { 865 isVMInstanceChainInUse = false; 866 return TRUE; 867 } 868 } 869 current = current->nextJVMInstance; 870 } 871 isVMInstanceChainInUse = false; 872 return FALSE; 873 874 875 /* 876 char classname[256]; 877 HWND hwnd; 878 879 hwnd = getTopLevelHWND(window); 880 if (hwnd == (HWND) NULL) { 881 return FALSE; 882 } 883 GetClassName(hwnd, classname, 256); 884 885 if (strstr(classname, "AwtFrame") != 0) { 886 return TRUE; 887 } else if (strstr(classname, "AwtWindow") != 0) { 888 return TRUE; 889 } else if (strstr(classname, "AwtDialog") != 0) { 890 return TRUE; 891 } 892 */ 893 // JDK 1.4 introduces new (and changes old) classnames 894 /* 895 else if (strstr(classname, "SunAwtToolkit") != 0) { 896 return TRUE; 897 } else if (strstr(classname, "javax.swing.JFrame") != 0) { 898 return TRUE; 899 } 900 */ 901 902 return FALSE; 903 } 904 905 /** 906 * isSameObject - returns TRUE if the two object references refer to 907 * the same object. Otherwise, this method returns FALSE: 908 */ 909 BOOL 910 WinAccessBridge::isSameObject(long vmID, JOBJECT64 obj1, JOBJECT64 obj2) { 911 912 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 913 PrintDebugString("[INFO]: WinAccessBridge::isSameObject(%p %p)", obj1, obj2); 914 #else // JOBJECT64 is jlong (64 bit) 915 PrintDebugString("[INFO]: WinAccessBridge::isSameObject(%016I64X %016I64X)", obj1, obj2); 916 #endif 917 918 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 919 return FALSE; 920 } 921 922 char buffer[sizeof(PackageType) + sizeof(IsSameObjectPackage)]; 923 PackageType *type = (PackageType *) buffer; 924 IsSameObjectPackage *pkg = (IsSameObjectPackage *) (buffer + sizeof(PackageType)); 925 *type = cIsSameObjectPackage; 926 pkg->vmID = vmID; 927 pkg->obj1 = obj1; 928 pkg->obj2 = obj2; 929 930 HWND destABWindow = javaVMs->findAccessBridgeWindow(pkg->vmID); 931 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 932 if (pkg->rResult != 0) { 933 PrintDebugString("[INFO]: WinAccessBridge::isSameObject returning TRUE (same object)"); 934 return TRUE; 935 } else { 936 PrintDebugString("[INFO]: WinAccessBridge::isSameObject returning FALSE (different object)"); 937 return FALSE; 938 } 939 } 940 PrintDebugString("[ERROR]: WinAccessBridge::isSameObject returning FALSE (sendMemoryPackage failed)"); 941 return FALSE; 942 } 943 944 /** 945 * FromHWND - returns the AccessibleContext jobject for the HWND 946 * 947 * Note: this routine can return null, even if the HWND is a Java Window, 948 * because the Java Window may not be accessible. 949 * 950 */ 951 BOOL 952 WinAccessBridge::getAccessibleContextFromHWND(HWND window, long *vmID, JOBJECT64 *AccessibleContext) { 953 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 954 return FALSE; 955 } 956 957 char buffer[sizeof(PackageType) + sizeof(GetAccessibleContextFromHWNDPackage)]; 958 PackageType *type = (PackageType *) buffer; 959 GetAccessibleContextFromHWNDPackage *pkg = (GetAccessibleContextFromHWNDPackage *) (buffer + sizeof(PackageType)); 960 *type = cGetAccessibleContextFromHWNDPackage; 961 pkg->window = (jint) window; 962 963 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleContextFromHWND(%p, )", window); 964 965 DEBUG_CODE(pkg->rVMID = (long ) 0x01010101); 966 DEBUG_CODE(pkg->rAccessibleContext = (JOBJECT64) 0x01010101); 967 968 isVMInstanceChainInUse = true; 969 AccessBridgeJavaVMInstance *current = javaVMs; 970 while (current != (AccessBridgeJavaVMInstance *) 0) { 971 972 if (sendMemoryPackage(buffer, sizeof(buffer), current->javaAccessBridgeWindow) == TRUE) { 973 if (pkg->rAccessibleContext != 0) { 974 *vmID = pkg->rVMID; 975 *AccessibleContext = (JOBJECT64)pkg->rAccessibleContext; 976 PrintDebugString("[INFO]: current->vmID = %X, pkg->rVMID = %X", current->vmID, pkg->rVMID); 977 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 978 PrintDebugString("[INFO]: pkg->rAccessibleContext = %p", pkg->rAccessibleContext); 979 #else // JOBJECT64 is jlong (64 bit) 980 PrintDebugString("[INFO]: pkg->rAccessibleContext = %016I64X", pkg->rAccessibleContext); 981 #endif 982 if (pkg->rVMID != current->vmID) { 983 PrintDebugString("[ERROR]: getAccessibleContextFromHWND vmIDs don't match!"); 984 isVMInstanceChainInUse = false; 985 return FALSE; 986 } 987 isVMInstanceChainInUse = false; 988 return TRUE; 989 } 990 } 991 current = current->nextJVMInstance; 992 } 993 isVMInstanceChainInUse = false; 994 995 // This isn't really an error; it just means that the HWND was for a non-Java 996 // window. It's also possible the HWND was for a Java window but the JVM has 997 // since been shut down and sendMemoryPackage returned FALSE. 998 PrintDebugString("[ERROR]: getAccessibleContextFromHWND no matching HWND found!"); 999 return FALSE; 1000 } 1001 1002 /** 1003 * Returns the HWND for an AccessibleContext. Returns (HWND)0 on error. 1004 */ 1005 HWND 1006 WinAccessBridge::getHWNDFromAccessibleContext(long vmID, JOBJECT64 accessibleContext) { 1007 PrintDebugString("[INFO]: in WinAccessBridge::getHWNDFromAccessibleContext"); 1008 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1009 return (HWND)0; 1010 } 1011 1012 char buffer[sizeof(PackageType) + sizeof(GetHWNDFromAccessibleContextPackage)]; 1013 PackageType *type = (PackageType *) buffer; 1014 GetHWNDFromAccessibleContextPackage *pkg = (GetHWNDFromAccessibleContextPackage *) (buffer + sizeof(PackageType)); 1015 *type = cGetHWNDFromAccessibleContextPackage; 1016 pkg->accessibleContext = accessibleContext; 1017 1018 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1019 PrintDebugString("[INFO]: WinAccessBridge::getHWNDFromAccessibleContext(%p)", accessibleContext); 1020 #else // JOBJECT64 is jlong (64 bit) 1021 PrintDebugString("[INFO]: WinAccessBridge::getHWNDFromAccessibleContext(%016I64X)", accessibleContext); 1022 #endif 1023 1024 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1025 if (destABWindow != (HWND) 0) { 1026 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1027 return ((HWND)ABLongToHandle(pkg->rHWND)); 1028 } 1029 } 1030 return (HWND)0; 1031 } 1032 1033 /********** AccessibleContext routines ***********************************/ 1034 1035 /** 1036 * Walk through Java Windows, in front-to-back Z-order. 1037 * If NULL is passed it, this function starts at the top. 1038 * 1039 */ 1040 HWND 1041 WinAccessBridge::getNextJavaWindow(HWND previous) { 1042 HWND current = previous; 1043 if (current == NULL) { 1044 current = GetTopWindow(NULL); 1045 } else { 1046 current = GetNextWindow(current, GW_HWNDNEXT); 1047 } 1048 while (current != NULL) { 1049 if (isJavaWindow(current)) { 1050 return current; 1051 } 1052 current = GetNextWindow(current, GW_HWNDNEXT); 1053 } 1054 return NULL; 1055 } 1056 1057 1058 /** 1059 * getAccessibleContextAt - performs the Java code: 1060 * Accessible a = EventQueueMonitor.getAccessibleAt(x, y); 1061 * return a.getAccessibleContext(); 1062 * 1063 * Note: this call explicitly goes through the AccessBridge, 1064 * so that the AccessBridge can hide expected changes in how this functions 1065 * between JDK 1.1.x w/AccessibilityUtility classes, and JDK 1.2, when some 1066 * of this functionality may be built into the platform 1067 * 1068 */ 1069 BOOL 1070 WinAccessBridge::getAccessibleContextAt(long vmID, JOBJECT64 AccessibleContextParent, 1071 jint x, jint y, JOBJECT64 *AccessibleContext) { 1072 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1073 return FALSE; 1074 } 1075 1076 char buffer[sizeof(PackageType) + sizeof(GetAccessibleContextAtPackage)]; 1077 PackageType *type = (PackageType *) buffer; 1078 GetAccessibleContextAtPackage *pkg = (GetAccessibleContextAtPackage *) (buffer + sizeof(PackageType)); 1079 *type = cGetAccessibleContextAtPackage; 1080 pkg->vmID = vmID; 1081 pkg->AccessibleContext = AccessibleContextParent; 1082 pkg->x = x; 1083 pkg->y = y; 1084 1085 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleContextAt(%X, %p, %d, %c)", vmID, AccessibleContextParent, x, y); 1086 HWND destABWindow = javaVMs->findAccessBridgeWindow(pkg->vmID); 1087 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1088 *AccessibleContext = pkg->rAccessibleContext; 1089 return TRUE; 1090 } 1091 1092 return FALSE; 1093 } 1094 1095 1096 /** 1097 * getAccessibleContextWithFocus - performs the Java code: 1098 * Accessible a = Translator.getAccessible(SwingEventMonitor.getComponentWithFocus()); 1099 * return a.getAccessibleContext(); 1100 * 1101 * Note: this call explicitly goes through the AccessBridge, 1102 * so that the AccessBridge can hide expected changes in how this functions 1103 * between JDK 1.1.x w/AccessibilityUtility classes, and JDK 1.2, when some 1104 * of this functionality may be built into the platform 1105 * 1106 */ 1107 BOOL 1108 WinAccessBridge::getAccessibleContextWithFocus(HWND window, long *vmID, JOBJECT64 *AccessibleContext) { 1109 1110 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1111 return FALSE; 1112 } 1113 char buffer[sizeof(PackageType) + sizeof(GetAccessibleContextWithFocusPackage)]; 1114 PackageType *type = (PackageType *) buffer; 1115 GetAccessibleContextWithFocusPackage *pkg = (GetAccessibleContextWithFocusPackage *) (buffer + sizeof(PackageType)); 1116 *type = cGetAccessibleContextWithFocusPackage; 1117 1118 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleContextWithFocus(%p, %X, )", window, vmID); 1119 // find vmID, etc. from HWND; ask that VM for the AC w/Focus 1120 HWND pkgVMID; 1121 if (getAccessibleContextFromHWND(window, (long *)&(pkgVMID), &(pkg->rAccessibleContext)) == TRUE) { 1122 HWND destABWindow = javaVMs->findAccessBridgeWindow((long)pkgVMID); // ineffecient [[[FIXME]]] 1123 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1124 *vmID = pkg->rVMID; 1125 *AccessibleContext = pkg->rAccessibleContext; 1126 return TRUE; 1127 } 1128 } 1129 1130 return FALSE; 1131 } 1132 1133 /** 1134 * getAccessibleContextInfo - fills a struct with a bunch of information 1135 * contained in the Java Accessibility API 1136 * 1137 * 1138 * Note: if the AccessibleContext parameter is bogus, this call will blow up 1139 */ 1140 BOOL 1141 WinAccessBridge::getAccessibleContextInfo(long vmID, 1142 JOBJECT64 accessibleContext, 1143 AccessibleContextInfo *info) { 1144 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1145 return FALSE; 1146 } 1147 char buffer[sizeof(PackageType) + sizeof(GetAccessibleContextInfoPackage)]; 1148 PackageType *type = (PackageType *) buffer; 1149 GetAccessibleContextInfoPackage *pkg = (GetAccessibleContextInfoPackage *) (buffer + sizeof(PackageType)); 1150 *type = cGetAccessibleContextInfoPackage; 1151 pkg->vmID = vmID; 1152 pkg->AccessibleContext = accessibleContext; 1153 1154 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1155 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleContextInfo(%X, %p, )", vmID, accessibleContext); 1156 #else // JOBJECT64 is jlong (64 bit) 1157 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleContextInfo(%X, %016I64X, )", vmID, accessibleContext); 1158 #endif 1159 // need to call only the HWND/VM that contains this AC 1160 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1161 if (destABWindow != (HWND) 0) { 1162 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1163 memcpy(info, &(pkg->rAccessibleContextInfo), sizeof(AccessibleContextInfo)); 1164 PrintDebugString("[INFO]: name: %ls\n"\ 1165 " description: %ls\n"\ 1166 " role: %ls\n"\ 1167 " role_en_US: %ls\n"\ 1168 " states: %ls\n"\ 1169 " states_en_US: %ls\n"\ 1170 , info->name, info->description, info->role, info->role_en_US, info->states, info->states_en_US); 1171 return TRUE; 1172 } 1173 } 1174 1175 return FALSE; 1176 } 1177 1178 /** 1179 * getAccessibleChildFromContext - performs the Java code: 1180 * Accessible child = ac.getAccessibleChild(i); 1181 * return child.getAccessibleContext(); 1182 * 1183 * Note: this call explicitly goes through the AccessBridge, 1184 * so that the AccessBridge can hide expected changes in how this functions 1185 * between JDK 1.1.x w/AccessibilityUtility classes, and JDK 1.2, when some 1186 * of this functionality may be built into the platform 1187 * 1188 */ 1189 JOBJECT64 1190 WinAccessBridge::getAccessibleChildFromContext(long vmID, 1191 JOBJECT64 AccessibleContext, 1192 jint childIndex) { 1193 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1194 return (JOBJECT64)0; 1195 } 1196 char buffer[sizeof(PackageType) + sizeof(GetAccessibleChildFromContextPackage)]; 1197 PackageType *type = (PackageType *) buffer; 1198 GetAccessibleChildFromContextPackage *pkg = (GetAccessibleChildFromContextPackage *) (buffer + sizeof(PackageType)); 1199 *type = cGetAccessibleChildFromContextPackage; 1200 pkg->vmID = vmID; 1201 pkg->AccessibleContext = AccessibleContext; 1202 pkg->childIndex = childIndex; 1203 1204 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1205 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleChildFromContext(%X, %p, %d)", vmID, AccessibleContext, childIndex); 1206 #else // JOBJECT64 is jlong (64 bit) 1207 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleChildFromContext(%X, %016I64X, %d)", vmID, AccessibleContext, childIndex); 1208 #endif 1209 // need to call only the HWND/VM that contains this AC 1210 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1211 if (destABWindow != (HWND) 0) { 1212 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1213 return pkg->rAccessibleContext; 1214 } 1215 } 1216 1217 return (JOBJECT64) 0; 1218 } 1219 1220 /** 1221 * getAccessibleParentFromContext - returns the parent AccessibleContext jobject 1222 * 1223 * Note: this may be null, if the AccessibleContext passed in is a top-level 1224 * window, then it has no parent. 1225 * 1226 */ 1227 JOBJECT64 1228 WinAccessBridge::getAccessibleParentFromContext(long vmID, 1229 JOBJECT64 AccessibleContext) { 1230 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1231 return (JOBJECT64)0; 1232 } 1233 char buffer[sizeof(PackageType) + sizeof(GetAccessibleParentFromContextPackage)]; 1234 PackageType *type = (PackageType *) buffer; 1235 GetAccessibleParentFromContextPackage *pkg = (GetAccessibleParentFromContextPackage *) (buffer + sizeof(PackageType)); 1236 *type = cGetAccessibleParentFromContextPackage; 1237 pkg->vmID = vmID; 1238 pkg->AccessibleContext = AccessibleContext; 1239 1240 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleParentFromContext(%X, %p)", vmID, AccessibleContext); 1241 // need to call only the HWND/VM that contains this AC 1242 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1243 if (destABWindow != (HWND) 0) { 1244 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1245 return pkg->rAccessibleContext; 1246 } 1247 } 1248 1249 return (JOBJECT64) 0; 1250 } 1251 1252 /********** AccessibleTable routines ***********************************/ 1253 1254 BOOL 1255 WinAccessBridge::getAccessibleTableInfo(long vmID, 1256 JOBJECT64 accessibleContext, 1257 AccessibleTableInfo *tableInfo) { 1258 1259 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1260 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableInfo(%X, %p, %p)", vmID, accessibleContext, 1261 tableInfo); 1262 #else // JOBJECT64 is jlong (64 bit) 1263 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableInfo(%X, %016I64X, %p)", vmID, accessibleContext, 1264 tableInfo); 1265 #endif 1266 1267 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1268 return FALSE; 1269 } 1270 char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableInfoPackage)]; 1271 PackageType *type = (PackageType *) buffer; 1272 GetAccessibleTableInfoPackage *pkg = (GetAccessibleTableInfoPackage *) (buffer + sizeof(PackageType)); 1273 *type = cGetAccessibleTableInfoPackage; 1274 pkg->vmID = vmID; 1275 pkg->accessibleContext = accessibleContext; 1276 1277 // need to call only the HWND/VM that contains this AC 1278 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1279 if (destABWindow != (HWND) 0) { 1280 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1281 memcpy(tableInfo, &(pkg->rTableInfo), sizeof(AccessibleTableInfo)); 1282 if (pkg->rTableInfo.rowCount != -1) { 1283 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableInfo succeeded"); 1284 return TRUE; 1285 } 1286 } 1287 } 1288 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleTableInfo failed"); 1289 return FALSE; 1290 } 1291 1292 BOOL 1293 WinAccessBridge::getAccessibleTableCellInfo(long vmID, JOBJECT64 accessibleTable, 1294 jint row, jint column, 1295 AccessibleTableCellInfo *tableCellInfo) { 1296 1297 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableCellInfo(%X, %p, %d, %d, %p)", vmID, 1298 accessibleTable, row, column, tableCellInfo); 1299 1300 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1301 return FALSE; 1302 } 1303 1304 char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableCellInfoPackage)]; 1305 PackageType *type = (PackageType *) buffer; 1306 GetAccessibleTableCellInfoPackage *pkg = (GetAccessibleTableCellInfoPackage *) (buffer + sizeof(PackageType)); 1307 *type = cGetAccessibleTableCellInfoPackage; 1308 pkg->vmID = vmID; 1309 pkg->accessibleTable = accessibleTable; 1310 pkg->row = row; 1311 pkg->column = column; 1312 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1313 1314 if (destABWindow != (HWND) 0) { 1315 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1316 PrintDebugString("[INFO]: XXXX pkg->rTableCellInfo.accessibleContext = %p", pkg->rTableCellInfo.accessibleContext); 1317 memcpy(tableCellInfo, &(pkg->rTableCellInfo), sizeof(AccessibleTableCellInfo)); 1318 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableCellInfo succeeded"); 1319 return TRUE; 1320 } 1321 } 1322 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleTableCellInfo failed"); 1323 return FALSE; 1324 } 1325 1326 1327 BOOL 1328 WinAccessBridge::getAccessibleTableRowHeader(long vmID, JOBJECT64 accessibleContext, AccessibleTableInfo *tableInfo) { 1329 1330 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1331 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRowHeader(%X, %p)", vmID, accessibleContext); 1332 #else // JOBJECT64 is jlong (64 bit) 1333 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRowHeader(%X, %016I64X)", vmID, accessibleContext); 1334 #endif 1335 1336 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1337 return FALSE; 1338 } 1339 char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableRowHeaderPackage)]; 1340 PackageType *type = (PackageType *) buffer; 1341 GetAccessibleTableRowHeaderPackage *pkg = (GetAccessibleTableRowHeaderPackage *) (buffer + sizeof(PackageType)); 1342 *type = cGetAccessibleTableRowHeaderPackage; 1343 pkg->vmID = vmID; 1344 pkg->accessibleContext = accessibleContext; 1345 1346 // need to call only the HWND/VM that contains this AC 1347 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1348 if (destABWindow != (HWND) 0) { 1349 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1350 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRowHeader succeeded"); 1351 memcpy(tableInfo, &(pkg->rTableInfo), sizeof(AccessibleTableInfo)); 1352 return TRUE; 1353 } 1354 } 1355 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleTableRowHeader failed"); 1356 return FALSE; 1357 } 1358 1359 BOOL 1360 WinAccessBridge::getAccessibleTableColumnHeader(long vmID, JOBJECT64 accessibleContext, AccessibleTableInfo *tableInfo) { 1361 1362 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1363 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumnHeader(%X, %p)", vmID, accessibleContext); 1364 #else // JOBJECT64 is jlong (64 bit) 1365 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumnHeader(%X, %016I64X)", vmID, accessibleContext); 1366 #endif 1367 1368 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1369 return FALSE; 1370 } 1371 char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableColumnHeaderPackage)]; 1372 PackageType *type = (PackageType *) buffer; 1373 GetAccessibleTableColumnHeaderPackage *pkg = (GetAccessibleTableColumnHeaderPackage *) (buffer + sizeof(PackageType)); 1374 *type = cGetAccessibleTableColumnHeaderPackage; 1375 pkg->vmID = vmID; 1376 pkg->accessibleContext = accessibleContext; 1377 1378 // need to call only the HWND/VM that contains this AC 1379 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1380 if (destABWindow != (HWND) 0) { 1381 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1382 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumnHeader succeeded"); 1383 memcpy(tableInfo, &(pkg->rTableInfo), sizeof(AccessibleTableInfo)); 1384 return TRUE; 1385 } 1386 } 1387 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleTableColumnHeader failed"); 1388 return FALSE; 1389 } 1390 1391 JOBJECT64 1392 WinAccessBridge::getAccessibleTableRowDescription(long vmID, 1393 JOBJECT64 accessibleContext, 1394 jint row) { 1395 1396 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1397 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRowDescription(%X, %p, %d)", vmID, accessibleContext, 1398 row); 1399 #else // JOBJECT64 is jlong (64 bit) 1400 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRowDescription(%X, %016I64X, %d)", vmID, accessibleContext, 1401 row); 1402 #endif 1403 1404 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1405 return FALSE; 1406 } 1407 char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableRowDescriptionPackage)]; 1408 PackageType *type = (PackageType *) buffer; 1409 GetAccessibleTableRowDescriptionPackage *pkg = (GetAccessibleTableRowDescriptionPackage *) (buffer + sizeof(PackageType)); 1410 *type = cGetAccessibleTableRowDescriptionPackage; 1411 pkg->vmID = vmID; 1412 pkg->row = row; 1413 pkg->accessibleContext = accessibleContext; 1414 1415 // need to call only the HWND/VM that contains this AC 1416 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1417 if (destABWindow != (HWND) 0) { 1418 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1419 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRowDescription succeeded"); 1420 return pkg->rAccessibleContext; 1421 } 1422 } 1423 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleTableRowDescription failed"); 1424 return (JOBJECT64)0; 1425 } 1426 1427 JOBJECT64 1428 WinAccessBridge::getAccessibleTableColumnDescription(long vmID, 1429 JOBJECT64 accessibleContext, 1430 jint column) { 1431 1432 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1433 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumnDescription(%X, %p, %d)", vmID, accessibleContext, 1434 column); 1435 #else // JOBJECT64 is jlong (64 bit) 1436 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumnDescription(%X, %016I64X, %d)", vmID, accessibleContext, 1437 column); 1438 #endif 1439 1440 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1441 return FALSE; 1442 } 1443 char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableColumnDescriptionPackage)]; 1444 PackageType *type = (PackageType *) buffer; 1445 GetAccessibleTableColumnDescriptionPackage *pkg = 1446 (GetAccessibleTableColumnDescriptionPackage *) (buffer + sizeof(PackageType)); 1447 *type = cGetAccessibleTableColumnDescriptionPackage; 1448 pkg->vmID = vmID; 1449 pkg->column = column; 1450 pkg->accessibleContext = accessibleContext; 1451 1452 // need to call only the HWND/VM that contains this AC 1453 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1454 if (destABWindow != (HWND) 0) { 1455 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1456 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumnDescription succeeded"); 1457 return pkg->rAccessibleContext; 1458 } 1459 } 1460 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleTableColumnDescription failed"); 1461 return (JOBJECT64)0; 1462 } 1463 1464 jint 1465 WinAccessBridge::getAccessibleTableRowSelectionCount(long vmID, JOBJECT64 accessibleTable) { 1466 1467 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1468 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRowSelectionCount(%X, %p)", vmID, accessibleTable); 1469 #else // JOBJECT64 is jlong (64 bit) 1470 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRowSelectionCount(%X, %016I64X)", vmID, accessibleTable); 1471 #endif 1472 1473 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1474 return 0; 1475 } 1476 char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableRowSelectionCountPackage)]; 1477 PackageType *type = (PackageType *) buffer; 1478 GetAccessibleTableRowSelectionCountPackage *pkg = 1479 (GetAccessibleTableRowSelectionCountPackage *) (buffer + sizeof(PackageType)); 1480 *type = cGetAccessibleTableRowSelectionCountPackage; 1481 pkg->vmID = vmID; 1482 pkg->accessibleTable = accessibleTable; 1483 1484 // need to call only the HWND/VM that contains this AC 1485 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1486 if (destABWindow != (HWND) 0) { 1487 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1488 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRowSelectionCount succeeded"); 1489 return pkg->rCount; 1490 } 1491 } 1492 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleTableRowSelectionCount failed"); 1493 return 0; 1494 } 1495 1496 BOOL 1497 WinAccessBridge::isAccessibleTableRowSelected(long vmID, JOBJECT64 accessibleTable, jint row) { 1498 1499 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1500 PrintDebugString("[INFO]: ##### WinAccessBridge::isAccessibleTableRowSelected(%X, %p)", vmID, accessibleTable); 1501 #else // JOBJECT64 is jlong (64 bit) 1502 PrintDebugString("[INFO]: ##### WinAccessBridge::isAccessibleTableRowSelected(%X, %016I64X)", vmID, accessibleTable); 1503 #endif 1504 1505 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1506 return FALSE; 1507 } 1508 char buffer[sizeof(PackageType) + sizeof(IsAccessibleTableRowSelectedPackage)]; 1509 PackageType *type = (PackageType *) buffer; 1510 IsAccessibleTableRowSelectedPackage *pkg = (IsAccessibleTableRowSelectedPackage *) (buffer + sizeof(PackageType)); 1511 *type = cIsAccessibleTableRowSelectedPackage; 1512 pkg->vmID = vmID; 1513 pkg->accessibleTable = accessibleTable; 1514 pkg->row = row; 1515 1516 // need to call only the HWND/VM that contains this AC 1517 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1518 if (destABWindow != (HWND) 0) { 1519 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1520 PrintDebugString("[INFO]: ##### WinAccessBridge::isAccessibleTableRowSelected succeeded"); 1521 return pkg->rResult; 1522 } 1523 } 1524 PrintDebugString("[ERROR]: ##### WinAccessBridge::isAccessibleTableRowSelected failed"); 1525 return FALSE; 1526 } 1527 1528 BOOL 1529 WinAccessBridge::getAccessibleTableRowSelections(long vmID, JOBJECT64 accessibleTable, jint count, jint *selections) { 1530 1531 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1532 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRowSelections(%X, %p)", vmID, accessibleTable); 1533 #else // JOBJECT64 is jlong (64 bit) 1534 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRowSelections(%X, %016I64X)", vmID, accessibleTable); 1535 #endif 1536 1537 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1538 return FALSE; 1539 } 1540 char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableRowSelectionsPackage)]; 1541 PackageType *type = (PackageType *) buffer; 1542 GetAccessibleTableRowSelectionsPackage *pkg = 1543 (GetAccessibleTableRowSelectionsPackage *) (buffer + sizeof(PackageType)); 1544 *type = cGetAccessibleTableRowSelectionsPackage; 1545 pkg->vmID = vmID; 1546 pkg->accessibleTable = accessibleTable; 1547 pkg->count = count; 1548 1549 // need to call only the HWND/VM that contains this AC 1550 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1551 if (destABWindow != (HWND) 0) { 1552 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1553 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRowSelections succeeded"); 1554 memcpy(selections, pkg->rSelections, count * sizeof(jint)); 1555 return TRUE; 1556 } 1557 } 1558 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleTableRowSelections failed"); 1559 return FALSE; 1560 } 1561 1562 1563 jint 1564 WinAccessBridge::getAccessibleTableColumnSelectionCount(long vmID, JOBJECT64 accessibleTable) { 1565 1566 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1567 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumnSelectionCount(%X, %p)", vmID, 1568 accessibleTable); 1569 #else // JOBJECT64 is jlong (64 bit) 1570 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumnSelectionCount(%X, %016I64X)", vmID, 1571 accessibleTable); 1572 #endif 1573 1574 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1575 return FALSE; 1576 } 1577 char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableColumnSelectionCountPackage)]; 1578 PackageType *type = (PackageType *) buffer; 1579 GetAccessibleTableColumnSelectionCountPackage *pkg = 1580 (GetAccessibleTableColumnSelectionCountPackage *) (buffer + sizeof(PackageType)); 1581 *type = cGetAccessibleTableColumnSelectionCountPackage; 1582 pkg->vmID = vmID; 1583 pkg->accessibleTable = accessibleTable; 1584 1585 // need to call only the HWND/VM that contains this AC 1586 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1587 if (destABWindow != (HWND) 0) { 1588 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1589 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumnSelectionCount succeeded"); 1590 return pkg->rCount; 1591 } 1592 } 1593 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleTableColumnSelectionCount failed"); 1594 return 0; 1595 } 1596 1597 BOOL 1598 WinAccessBridge::isAccessibleTableColumnSelected(long vmID, JOBJECT64 accessibleTable, jint column) { 1599 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1600 PrintDebugString("[INFO]: ##### WinAccessBridge::isAccessibleTableColumnSelected(%X, %p)", vmID, accessibleTable); 1601 #else // JOBJECT64 is jlong (64 bit) 1602 PrintDebugString("[INFO]: ##### WinAccessBridge::isAccessibleTableColumnSelected(%X, %016I64X)", vmID, accessibleTable); 1603 #endif 1604 1605 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1606 return FALSE; 1607 } 1608 char buffer[sizeof(PackageType) + sizeof(IsAccessibleTableColumnSelectedPackage)]; 1609 PackageType *type = (PackageType *) buffer; 1610 IsAccessibleTableColumnSelectedPackage *pkg = (IsAccessibleTableColumnSelectedPackage *) (buffer + sizeof(PackageType)); 1611 *type = cIsAccessibleTableColumnSelectedPackage; 1612 pkg->vmID = vmID; 1613 pkg->accessibleTable = accessibleTable; 1614 pkg->column = column; 1615 1616 // need to call only the HWND/VM that contains this AC 1617 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1618 if (destABWindow != (HWND) 0) { 1619 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1620 PrintDebugString("[INFO]: ##### WinAccessBridge::isAccessibleTableColumnSelected succeeded"); 1621 return pkg->rResult; 1622 } 1623 } 1624 PrintDebugString("[ERROR]: ##### WinAccessBridge::isAccessibleTableColumnSelected failed"); 1625 return FALSE; 1626 } 1627 1628 BOOL 1629 WinAccessBridge::getAccessibleTableColumnSelections(long vmID, JOBJECT64 accessibleTable, jint count, 1630 jint *selections) { 1631 1632 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1633 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumnSelections(%X, %p)", vmID, accessibleTable); 1634 #else // JOBJECT64 is jlong (64 bit) 1635 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleTableColumnSelections(%X, %016I64X)", vmID, accessibleTable); 1636 #endif 1637 1638 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1639 return FALSE; 1640 } 1641 char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableColumnSelectionsPackage)]; 1642 PackageType *type = (PackageType *) buffer; 1643 GetAccessibleTableColumnSelectionsPackage *pkg = 1644 (GetAccessibleTableColumnSelectionsPackage *) (buffer + sizeof(PackageType)); 1645 *type = cGetAccessibleTableColumnSelectionsPackage; 1646 pkg->vmID = vmID; 1647 pkg->count = count; 1648 pkg->accessibleTable = accessibleTable; 1649 1650 // need to call only the HWND/VM that contains this AC 1651 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1652 if (destABWindow != (HWND) 0) { 1653 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1654 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumnSelections succeeded"); 1655 memcpy(selections, pkg->rSelections, count * sizeof(jint)); 1656 return TRUE; 1657 } 1658 } 1659 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleTableColumnSelections failed"); 1660 return FALSE; 1661 } 1662 1663 jint 1664 WinAccessBridge::getAccessibleTableRow(long vmID, JOBJECT64 accessibleTable, jint index) { 1665 1666 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1667 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRow(%X, %p, index=%d)", vmID, 1668 accessibleTable, index); 1669 #else // JOBJECT64 is jlong (64 bit) 1670 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRow(%X, %016I64X, index=%d)", vmID, 1671 accessibleTable, index); 1672 #endif 1673 1674 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1675 return FALSE; 1676 } 1677 char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableRowPackage)]; 1678 PackageType *type = (PackageType *) buffer; 1679 GetAccessibleTableRowPackage *pkg = 1680 (GetAccessibleTableRowPackage *) (buffer + sizeof(PackageType)); 1681 *type = cGetAccessibleTableRowPackage; 1682 pkg->vmID = vmID; 1683 pkg->accessibleTable = accessibleTable; 1684 pkg->index = index; 1685 1686 // need to call only the HWND/VM that contains this AC 1687 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1688 if (destABWindow != (HWND) 0) { 1689 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1690 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRow succeeded"); 1691 return pkg->rRow; 1692 } 1693 } 1694 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleTableRow failed"); 1695 return 0; 1696 } 1697 1698 jint 1699 WinAccessBridge::getAccessibleTableColumn(long vmID, JOBJECT64 accessibleTable, jint index) { 1700 1701 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1702 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumn(%X, %p, index=%d)", vmID, 1703 accessibleTable, index); 1704 #else // JOBJECT64 is jlong (64 bit) 1705 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumn(%X, %016I64X, index=%d)", vmID, 1706 accessibleTable, index); 1707 #endif 1708 1709 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1710 return FALSE; 1711 } 1712 char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableColumnPackage)]; 1713 PackageType *type = (PackageType *) buffer; 1714 GetAccessibleTableColumnPackage *pkg = 1715 (GetAccessibleTableColumnPackage *) (buffer + sizeof(PackageType)); 1716 *type = cGetAccessibleTableColumnPackage; 1717 pkg->vmID = vmID; 1718 pkg->accessibleTable = accessibleTable; 1719 pkg->index = index; 1720 1721 // need to call only the HWND/VM that contains this AC 1722 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1723 if (destABWindow != (HWND) 0) { 1724 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1725 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumn succeeded"); 1726 return pkg->rColumn; 1727 } 1728 } 1729 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleTableColumn failed"); 1730 return 0; 1731 } 1732 1733 jint 1734 WinAccessBridge::getAccessibleTableIndex(long vmID, JOBJECT64 accessibleTable, jint row, jint column) { 1735 1736 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1737 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableIndex(%X, %p, row=%d, col=%d)", vmID, 1738 accessibleTable, row, column); 1739 #else // JOBJECT64 is jlong (64 bit) 1740 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableIndex(%X, %016I64X, row=%d, col=%d)", vmID, 1741 accessibleTable, row, column); 1742 #endif 1743 1744 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1745 return FALSE; 1746 } 1747 char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableIndexPackage)]; 1748 PackageType *type = (PackageType *) buffer; 1749 GetAccessibleTableIndexPackage *pkg = 1750 (GetAccessibleTableIndexPackage *) (buffer + sizeof(PackageType)); 1751 *type = cGetAccessibleTableIndexPackage; 1752 pkg->vmID = vmID; 1753 pkg->accessibleTable = accessibleTable; 1754 pkg->row = row; 1755 pkg->column = column; 1756 1757 // need to call only the HWND/VM that contains this AC 1758 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1759 if (destABWindow != (HWND) 0) { 1760 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1761 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableIndex succeeded"); 1762 return pkg->rIndex; 1763 } 1764 } 1765 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleTableIndex failed"); 1766 return 0; 1767 } 1768 1769 /********** end AccessibleTable routines ******************************/ 1770 1771 BOOL 1772 WinAccessBridge::getAccessibleRelationSet(long vmID, JOBJECT64 accessibleContext, 1773 AccessibleRelationSetInfo *relationSetInfo) { 1774 1775 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1776 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleRelationSet(%X, %p, %X)", vmID, 1777 accessibleContext, relationSetInfo); 1778 #else // JOBJECT64 is jlong (64 bit) 1779 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleRelationSet(%X, %016I64X, %X)", vmID, 1780 accessibleContext, relationSetInfo); 1781 #endif 1782 1783 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1784 return FALSE; 1785 } 1786 1787 char buffer[sizeof(PackageType) + sizeof(GetAccessibleRelationSetPackage)]; 1788 PackageType *type = (PackageType *) buffer; 1789 GetAccessibleRelationSetPackage *pkg = (GetAccessibleRelationSetPackage *) (buffer + sizeof(PackageType)); 1790 *type = cGetAccessibleRelationSetPackage; 1791 pkg->vmID = vmID; 1792 pkg->accessibleContext = accessibleContext; 1793 1794 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1795 if (destABWindow != (HWND) 0) { 1796 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1797 PrintDebugString("[INFO]: ##### pkg->rAccessibleRelationSetInfo.relationCount = %X", 1798 pkg->rAccessibleRelationSetInfo.relationCount); 1799 memcpy(relationSetInfo, &(pkg->rAccessibleRelationSetInfo), sizeof(AccessibleRelationSetInfo)); 1800 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleRelationSet succeeded"); 1801 return TRUE; 1802 } 1803 } 1804 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleRelationSet failed"); 1805 return FALSE; 1806 } 1807 1808 1809 /********** AccessibleHypertext routines ***********/ 1810 1811 BOOL 1812 WinAccessBridge::getAccessibleHypertext(long vmID, JOBJECT64 accessibleContext, 1813 AccessibleHypertextInfo *hypertextInfo) { 1814 1815 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1816 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHypertext(%X, %p, %X)", vmID, 1817 accessibleContext, hypertextInfo); 1818 #else // JOBJECT64 is jlong (64 bit) 1819 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHypertext(%X, %016I64X, %X)", vmID, 1820 accessibleContext, hypertextInfo); 1821 #endif 1822 1823 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1824 return FALSE; 1825 } 1826 1827 char buffer[sizeof(PackageType) + sizeof(GetAccessibleHypertextPackage)]; 1828 PackageType *type = (PackageType *) buffer; 1829 GetAccessibleHypertextPackage *pkg = (GetAccessibleHypertextPackage *) (buffer + sizeof(PackageType)); 1830 *type = cGetAccessibleHypertextPackage; 1831 pkg->vmID = vmID; 1832 pkg->accessibleContext = accessibleContext; 1833 1834 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1835 if (destABWindow != (HWND) 0) { 1836 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1837 memcpy(hypertextInfo, &(pkg->rAccessibleHypertextInfo), sizeof(AccessibleHypertextInfo)); 1838 1839 PrintDebugString("[INFO]: ##### hypertextInfo.linkCount = %d", hypertextInfo->linkCount); 1840 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHypertext succeeded"); 1841 1842 return TRUE; 1843 } 1844 } 1845 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleHypertext failed"); 1846 return FALSE; 1847 } 1848 1849 1850 BOOL 1851 WinAccessBridge::activateAccessibleHyperlink(long vmID, JOBJECT64 accessibleContext, 1852 JOBJECT64 accessibleHyperlink) { 1853 1854 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1855 PrintDebugString("[INFO]: WinAccessBridge::activateAccessibleHyperlink(%p %p)", accessibleContext, 1856 accessibleHyperlink); 1857 #else // JOBJECT64 is jlong (64 bit) 1858 PrintDebugString("[INFO]: WinAccessBridge::activateAccessibleHyperlink(%016I64X %016I64X)", accessibleContext, 1859 accessibleHyperlink); 1860 #endif 1861 1862 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1863 return FALSE; 1864 } 1865 1866 char buffer[sizeof(PackageType) + sizeof(ActivateAccessibleHyperlinkPackage)]; 1867 PackageType *type = (PackageType *) buffer; 1868 ActivateAccessibleHyperlinkPackage *pkg = (ActivateAccessibleHyperlinkPackage *) (buffer + sizeof(PackageType)); 1869 *type = cActivateAccessibleHyperlinkPackage; 1870 pkg->vmID = vmID; 1871 pkg->accessibleContext = accessibleContext; 1872 pkg->accessibleHyperlink = accessibleHyperlink; 1873 1874 HWND destABWindow = javaVMs->findAccessBridgeWindow(pkg->vmID); 1875 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1876 return pkg->rResult; 1877 } 1878 PrintDebugString("[ERROR]: WinAccessBridge::activateAccessibleHyperlink returning FALSE (sendMemoryPackage failed)"); 1879 return FALSE; 1880 } 1881 1882 /* 1883 * Returns the number of hyperlinks in a component 1884 * Maps to AccessibleHypertext.getLinkCount. 1885 * Returns -1 on error. 1886 */ 1887 jint 1888 WinAccessBridge::getAccessibleHyperlinkCount(const long vmID, 1889 const AccessibleContext accessibleContext) { 1890 1891 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1892 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHyperlinkCount(%X, %p)", 1893 vmID, accessibleContext); 1894 #else // JOBJECT64 is jlong (64 bit) 1895 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHyperlinkCount(%X, %016I64X)", 1896 vmID, accessibleContext); 1897 #endif 1898 1899 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1900 return FALSE; 1901 } 1902 1903 char buffer[sizeof(PackageType) + sizeof(GetAccessibleHyperlinkCountPackage)]; 1904 PackageType *type = (PackageType *) buffer; 1905 GetAccessibleHyperlinkCountPackage *pkg = (GetAccessibleHyperlinkCountPackage *) (buffer + sizeof(PackageType)); 1906 *type = cGetAccessibleHyperlinkCountPackage; 1907 pkg->vmID = vmID; 1908 pkg->accessibleContext = accessibleContext; 1909 1910 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1911 if (destABWindow != (HWND) 0) { 1912 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1913 PrintDebugString("[INFO]: ##### hypetext link count = %d", pkg->rLinkCount); 1914 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHyperlinkCount succeeded"); 1915 return pkg->rLinkCount; 1916 } 1917 } 1918 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleHyperlinkCount failed"); 1919 return -1; 1920 } 1921 1922 /* 1923 * This method is used to iterate through the hyperlinks in a component. It 1924 * returns hypertext information for a component starting at hyperlink index 1925 * nStartIndex. No more than MAX_HYPERLINKS AccessibleHypertextInfo objects will 1926 * be returned for each call to this method. 1927 * returns FALSE on error. 1928 */ 1929 BOOL 1930 WinAccessBridge::getAccessibleHypertextExt(const long vmID, 1931 const AccessibleContext accessibleContext, 1932 const jint startIndex, 1933 /* OUT */ AccessibleHypertextInfo *hypertextInfo) { 1934 1935 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1936 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHypertextExt(%X, %p %p)", vmID, 1937 accessibleContext, hypertextInfo); 1938 #else // JOBJECT64 is jlong (64 bit) 1939 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHypertextExt(%X, %016I64X %p)", vmID, 1940 accessibleContext, hypertextInfo); 1941 #endif 1942 1943 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1944 return FALSE; 1945 } 1946 1947 char buffer[sizeof(PackageType) + sizeof(GetAccessibleHypertextExtPackage)]; 1948 PackageType *type = (PackageType *) buffer; 1949 GetAccessibleHypertextExtPackage *pkg = (GetAccessibleHypertextExtPackage *) (buffer + sizeof(PackageType)); 1950 *type = cGetAccessibleHypertextExtPackage; 1951 pkg->vmID = vmID; 1952 pkg->accessibleContext = accessibleContext; 1953 pkg->startIndex = startIndex; 1954 1955 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 1956 if (destABWindow != (HWND) 0) { 1957 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 1958 PrintDebugString("[INFO]: ##### pkg->rSuccess = %d", pkg->rSuccess); 1959 1960 memcpy(hypertextInfo, &(pkg->rAccessibleHypertextInfo), sizeof(AccessibleHypertextInfo)); 1961 if (pkg->rSuccess == TRUE) { 1962 PrintDebugString("[INFO]: ##### hypertextInfo.linkCount = %d", hypertextInfo->linkCount); 1963 } else { 1964 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleHypertextExt failed"); 1965 } 1966 return pkg->rSuccess; 1967 } 1968 } 1969 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleHypertextExt failed"); 1970 return FALSE; 1971 } 1972 1973 1974 /* 1975 * Returns the index into an array of hyperlinks that is associated with 1976 * a character index in document; 1977 * Maps to AccessibleHypertext.getLinkIndex. 1978 * Returns -1 on error. 1979 */ 1980 jint 1981 WinAccessBridge::getAccessibleHypertextLinkIndex(const long vmID, 1982 const AccessibleHyperlink hypertext, 1983 const jint charIndex) { 1984 1985 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 1986 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHypertextLinkIndex(%X, %p)", 1987 vmID, hypertext); 1988 #else // JOBJECT64 is jlong (64 bit) 1989 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHypertextLinkIndex(%X, %016I64X)", 1990 vmID, hypertext); 1991 #endif 1992 1993 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 1994 return FALSE; 1995 } 1996 1997 char buffer[sizeof(PackageType) + sizeof(GetAccessibleHypertextLinkIndexPackage)]; 1998 PackageType *type = (PackageType *) buffer; 1999 GetAccessibleHypertextLinkIndexPackage *pkg = (GetAccessibleHypertextLinkIndexPackage *) (buffer + sizeof(PackageType)); 2000 *type = cGetAccessibleHypertextLinkIndexPackage; 2001 pkg->vmID = vmID; 2002 pkg->hypertext = hypertext; 2003 pkg->charIndex = charIndex; 2004 2005 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2006 if (destABWindow != (HWND) 0) { 2007 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2008 PrintDebugString("[INFO]: ##### hypetext link index = %d", pkg->rLinkIndex); 2009 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHypertextLinkIndex succeeded"); 2010 return pkg->rLinkIndex; 2011 } 2012 } 2013 PrintDebugString("[ERROR] ##### WinAccessBridge::getAccessibleHypertextLinkIndex failed"); 2014 return -1; 2015 } 2016 2017 /* 2018 * Returns the nth hyperlink in a document. 2019 * Maps to AccessibleHypertext.getLink. 2020 * Returns -1 on error 2021 */ 2022 BOOL 2023 WinAccessBridge::getAccessibleHyperlink(const long vmID, 2024 const AccessibleHyperlink hypertext, 2025 const jint linkIndex, 2026 /* OUT */ AccessibleHyperlinkInfo *hyperlinkInfo) { 2027 2028 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2029 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHyperlink(%X, %p, %p)", vmID, 2030 hypertext, hyperlinkInfo); 2031 #else // JOBJECT64 is jlong (64 bit) 2032 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHyperlink(%X, %016I64X, %p)", vmID, 2033 hypertext, hyperlinkInfo); 2034 #endif 2035 2036 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2037 return FALSE; 2038 } 2039 2040 char buffer[sizeof(PackageType) + sizeof(GetAccessibleHyperlinkPackage)]; 2041 PackageType *type = (PackageType *) buffer; 2042 GetAccessibleHyperlinkPackage *pkg = (GetAccessibleHyperlinkPackage *) (buffer + sizeof(PackageType)); 2043 *type = cGetAccessibleHyperlinkPackage; 2044 pkg->vmID = vmID; 2045 pkg->hypertext = hypertext; 2046 pkg->linkIndex = linkIndex; 2047 2048 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2049 if (destABWindow != (HWND) 0) { 2050 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2051 memcpy(hyperlinkInfo, &(pkg->rAccessibleHyperlinkInfo), 2052 sizeof(AccessibleHyperlinkInfo)); 2053 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHypertext succeeded"); 2054 return TRUE; 2055 } 2056 } 2057 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleHypertext failed"); 2058 return FALSE; 2059 } 2060 2061 2062 /********** AccessibleKeyBinding routines ***********/ 2063 2064 BOOL 2065 WinAccessBridge::getAccessibleKeyBindings(long vmID, JOBJECT64 accessibleContext, 2066 AccessibleKeyBindings *keyBindings) { 2067 2068 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2069 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleKeyBindings(%X, %p, %p)", vmID, 2070 accessibleContext, keyBindings); 2071 #else // JOBJECT64 is jlong (64 bit) 2072 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleKeyBindings(%X, %016I64X, %p)", vmID, 2073 accessibleContext, keyBindings); 2074 #endif 2075 2076 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2077 return FALSE; 2078 } 2079 2080 char buffer[sizeof(PackageType) + sizeof(GetAccessibleKeyBindingsPackage)]; 2081 PackageType *type = (PackageType *) buffer; 2082 GetAccessibleKeyBindingsPackage *pkg = (GetAccessibleKeyBindingsPackage *) (buffer + sizeof(PackageType)); 2083 *type = cGetAccessibleKeyBindingsPackage; 2084 pkg->vmID = vmID; 2085 pkg->accessibleContext = accessibleContext; 2086 2087 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2088 if (destABWindow != (HWND) 0) { 2089 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2090 memcpy(keyBindings, &(pkg->rAccessibleKeyBindings), sizeof(AccessibleKeyBindings)); 2091 2092 PrintDebugString("[INFO]: ##### keyBindings.keyBindingsCount = %d", keyBindings->keyBindingsCount); 2093 for (int i = 0; i < keyBindings->keyBindingsCount; ++i) { 2094 PrintDebugString("[INFO]: Key Binding # %d"\ 2095 " Modifiers: 0x%x"\ 2096 " Character (hex): 0x%x"\ 2097 " Character (wide char): %lc"\ 2098 , i+1, keyBindings->keyBindingInfo[i].modifiers, keyBindings->keyBindingInfo[i].character, keyBindings->keyBindingInfo[i].character); 2099 } 2100 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleKeyBindings succeeded"); 2101 2102 return TRUE; 2103 } 2104 } 2105 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleKeyBindings failed"); 2106 return FALSE; 2107 } 2108 2109 BOOL 2110 WinAccessBridge::getAccessibleIcons(long vmID, JOBJECT64 accessibleContext, AccessibleIcons *icons) { 2111 2112 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2113 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleIcons(%X, %p, %p)", vmID, 2114 accessibleContext, icons); 2115 #else // JOBJECT64 is jlong (64 bit) 2116 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleIcons(%X, %016I64X, %p)", vmID, 2117 accessibleContext, icons); 2118 #endif 2119 2120 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2121 return FALSE; 2122 } 2123 2124 char buffer[sizeof(PackageType) + sizeof(GetAccessibleIconsPackage)]; 2125 PackageType *type = (PackageType *) buffer; 2126 GetAccessibleIconsPackage *pkg = (GetAccessibleIconsPackage *) (buffer + sizeof(PackageType)); 2127 *type = cGetAccessibleIconsPackage; 2128 pkg->vmID = vmID; 2129 pkg->accessibleContext = accessibleContext; 2130 2131 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2132 if (destABWindow != (HWND) 0) { 2133 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2134 memcpy(icons, &(pkg->rAccessibleIcons), sizeof(AccessibleIcons)); 2135 2136 PrintDebugString("[INFO]: ##### icons.iconsCount = %d", icons->iconsCount); 2137 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleIcons succeeded"); 2138 2139 return TRUE; 2140 } 2141 } 2142 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleIcons failed"); 2143 return FALSE; 2144 } 2145 2146 BOOL 2147 WinAccessBridge::getAccessibleActions(long vmID, JOBJECT64 accessibleContext, AccessibleActions *actions) { 2148 2149 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2150 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleActions(%X, %p, %p)", vmID, 2151 accessibleContext, actions); 2152 #else // JOBJECT64 is jlong (64 bit) 2153 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleActions(%X, %016I64X, %p)", vmID, 2154 accessibleContext, actions); 2155 #endif 2156 2157 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2158 return FALSE; 2159 } 2160 2161 char buffer[sizeof(PackageType) + sizeof(GetAccessibleActionsPackage)]; 2162 PackageType *type = (PackageType *) buffer; 2163 GetAccessibleActionsPackage *pkg = (GetAccessibleActionsPackage *) (buffer + sizeof(PackageType)); 2164 *type = cGetAccessibleActionsPackage; 2165 pkg->vmID = vmID; 2166 pkg->accessibleContext = accessibleContext; 2167 2168 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2169 if (destABWindow != (HWND) 0) { 2170 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2171 memcpy(actions, &(pkg->rAccessibleActions), sizeof(AccessibleActions)); 2172 2173 PrintDebugString("[INFO]: ##### actions.actionsCount = %d", actions->actionsCount); 2174 PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleActions succeeded"); 2175 2176 return TRUE; 2177 } 2178 } 2179 PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleActions failed"); 2180 return FALSE; 2181 } 2182 2183 BOOL 2184 WinAccessBridge::doAccessibleActions(long vmID, JOBJECT64 accessibleContext, 2185 AccessibleActionsToDo *actionsToDo, jint *failure) { 2186 2187 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2188 PrintDebugString("[INFO]: WinAccessBridge::doAccessibleActions(%p #actions %d %ls)", accessibleContext, 2189 actionsToDo->actionsCount, 2190 actionsToDo->actions[0].name); 2191 #else // JOBJECT64 is jlong (64 bit) 2192 PrintDebugString("[INFO]: WinAccessBridge::doAccessibleActions(%016I64X #actions %d %ls)", accessibleContext, 2193 actionsToDo->actionsCount, 2194 actionsToDo->actions[0].name); 2195 #endif 2196 2197 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2198 return FALSE; 2199 } 2200 char buffer[sizeof(PackageType) + sizeof(DoAccessibleActionsPackage)]; 2201 PackageType *type = (PackageType *) buffer; 2202 DoAccessibleActionsPackage *pkg = (DoAccessibleActionsPackage *) (buffer + sizeof(PackageType)); 2203 *type = cDoAccessibleActionsPackage; 2204 pkg->vmID = vmID; 2205 pkg->accessibleContext = accessibleContext; 2206 memcpy((void *)(&(pkg->actionsToDo)), (void *)actionsToDo, sizeof(AccessibleActionsToDo)); 2207 pkg->failure = -1; 2208 2209 HWND destABWindow = javaVMs->findAccessBridgeWindow(pkg->vmID); 2210 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2211 *failure = pkg->failure; 2212 return pkg->rResult; 2213 } 2214 PrintDebugString("[ERROR]: WinAccessBridge::doAccessibleActions returning FALSE (sendMemoryPackage failed)"); 2215 return FALSE; 2216 } 2217 2218 /* ====== Utility methods ====== */ 2219 2220 /** 2221 * Sets a text field to the specified string. Returns whether successful. 2222 */ 2223 BOOL 2224 WinAccessBridge::setTextContents (const long vmID, const AccessibleContext accessibleContext, 2225 const wchar_t *text) { 2226 2227 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2228 return FALSE; 2229 } 2230 char buffer[sizeof(PackageType) + sizeof(SetTextContentsPackage)]; 2231 PackageType *type = (PackageType *) buffer; 2232 SetTextContentsPackage *pkg = (SetTextContentsPackage *) (buffer + sizeof(PackageType)); 2233 *type = cSetTextContentsPackage; 2234 pkg->vmID = vmID; 2235 pkg->accessibleContext = accessibleContext; 2236 wcsncpy(pkg->text, text, sizeof(pkg->text)/sizeof(wchar_t)); // wide character copy 2237 2238 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2239 PrintDebugString("[INFO]: WinAccessBridge::setTextContents(%X, %016I64X %ls)", vmID, accessibleContext, text); 2240 #else // JOBJECT64 is jlong (64 bit) 2241 PrintDebugString("[INFO]: WinAccessBridge::setTextContents(%X, %p %ls)", vmID, accessibleContext, text); 2242 #endif 2243 // need to call only the HWND/VM that contains this AC 2244 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2245 if (destABWindow != (HWND) 0) { 2246 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2247 return pkg->rResult; 2248 } 2249 } 2250 return FALSE; 2251 } 2252 2253 /** 2254 * Returns the Accessible Context of a Page Tab object that is the 2255 * ancestor of a given object. If the object is a Page Tab object 2256 * or a Page Tab ancestor object was found, returns the object 2257 * AccessibleContext. 2258 * If there is no ancestor object that has an Accessible Role of Page Tab, 2259 * returns (AccessibleContext)0. 2260 */ 2261 AccessibleContext 2262 WinAccessBridge::getParentWithRole (const long vmID, const AccessibleContext accessibleContext, const wchar_t *role) { 2263 2264 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2265 return (JOBJECT64)0; 2266 } 2267 char buffer[sizeof(PackageType) + sizeof(GetParentWithRolePackage)]; 2268 PackageType *type = (PackageType *) buffer; 2269 GetParentWithRolePackage *pkg = (GetParentWithRolePackage *) (buffer + sizeof(PackageType)); 2270 *type = cGetParentWithRolePackage; 2271 pkg->vmID = vmID; 2272 pkg->accessibleContext = accessibleContext; 2273 memcpy((void *)(&(pkg->role)), (void *)role, sizeof(pkg->role)); 2274 2275 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2276 PrintDebugString("[INFO]: WinAccessBridge::getParentWithRole(%X, %p)", vmID, accessibleContext); 2277 #else // JOBJECT64 is jlong (64 bit) 2278 PrintDebugString("[INFO]: WinAccessBridge::getParentWithRole(%X, %016I64X)", vmID, accessibleContext); 2279 #endif 2280 PrintDebugString("[INFO]: pkg->vmID: %X"\ 2281 " pkg->accessibleContext: %p"\ 2282 " pkg->role: %ls"\ 2283 , pkg->vmID, pkg->accessibleContext, pkg->role); 2284 // need to call only the HWND/VM that contains this AC 2285 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2286 if (destABWindow != (HWND) 0) { 2287 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2288 PrintDebugString("[INFO]: pkg->rAccessibleContext: %p", pkg->rAccessibleContext); 2289 return pkg->rAccessibleContext; 2290 } 2291 } 2292 return (JOBJECT64) 0; 2293 } 2294 2295 2296 /** 2297 * Returns the Accessible Context for the top level object in 2298 * a Java Window. This is same Accessible Context that is obtained 2299 * from GetAccessibleContextFromHWND for that window. Returns 2300 * (AccessibleContext)0 on error. 2301 */ 2302 AccessibleContext 2303 WinAccessBridge::getTopLevelObject (const long vmID, const AccessibleContext accessibleContext) { 2304 2305 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2306 return (JOBJECT64)0; 2307 } 2308 char buffer[sizeof(PackageType) + sizeof(GetTopLevelObjectPackage)]; 2309 PackageType *type = (PackageType *) buffer; 2310 GetTopLevelObjectPackage *pkg = (GetTopLevelObjectPackage *) (buffer + sizeof(PackageType)); 2311 *type = cGetTopLevelObjectPackage; 2312 pkg->vmID = vmID; 2313 pkg->accessibleContext = accessibleContext; 2314 2315 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2316 PrintDebugString("[INFO]: WinAccessBridge::getTopLevelObject(%X, %p)", vmID, accessibleContext); 2317 #else // JOBJECT64 is jlong (64 bit) 2318 PrintDebugString("[INFO]: WinAccessBridge::getTopLevelObject(%X, %016I64X)", vmID, accessibleContext); 2319 #endif 2320 // need to call only the HWND/VM that contains this AC 2321 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2322 if (destABWindow != (HWND) 0) { 2323 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2324 return pkg->rAccessibleContext; 2325 } 2326 } 2327 return (JOBJECT64) 0; 2328 } 2329 2330 /** 2331 * If there is an Ancestor object that has an Accessible Role of 2332 * Internal Frame, returns the Accessible Context of the Internal 2333 * Frame object. Otherwise, returns the top level object for that 2334 * Java Window. Returns (AccessibleContext)0 on error. 2335 */ 2336 AccessibleContext 2337 WinAccessBridge::getParentWithRoleElseRoot (const long vmID, const AccessibleContext accessibleContext, const wchar_t *role) { 2338 2339 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2340 return (JOBJECT64)0; 2341 } 2342 char buffer[sizeof(PackageType) + sizeof(GetParentWithRoleElseRootPackage)]; 2343 PackageType *type = (PackageType *) buffer; 2344 GetParentWithRoleElseRootPackage *pkg = (GetParentWithRoleElseRootPackage *) (buffer + sizeof(PackageType)); 2345 *type = cGetParentWithRoleElseRootPackage; 2346 pkg->vmID = vmID; 2347 pkg->accessibleContext = accessibleContext; 2348 memcpy((void *)(&(pkg->role)), (void *)role, sizeof(pkg->role)); 2349 2350 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2351 PrintDebugString("[INFO]: WinAccessBridge::getParentWithRoleElseRoot(%X, %p)", vmID, accessibleContext); 2352 #else // JOBJECT64 is jlong (64 bit) 2353 PrintDebugString("[INFO]: WinAccessBridge::getParentWithRoleElseRoot(%X, %016I64X)", vmID, accessibleContext); 2354 #endif 2355 // need to call only the HWND/VM that contains this AC 2356 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2357 if (destABWindow != (HWND) 0) { 2358 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2359 return pkg->rAccessibleContext; 2360 } 2361 } 2362 return (JOBJECT64) 0; 2363 } 2364 2365 /** 2366 * Returns how deep in the object hierarchy a given object is. 2367 * The top most object in the object hierarchy has an object depth of 0. 2368 * Returns -1 on error. 2369 */ 2370 int 2371 WinAccessBridge::getObjectDepth (const long vmID, const AccessibleContext accessibleContext) { 2372 2373 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2374 return -1; 2375 } 2376 char buffer[sizeof(PackageType) + sizeof(GetObjectDepthPackage)]; 2377 PackageType *type = (PackageType *) buffer; 2378 GetObjectDepthPackage *pkg = (GetObjectDepthPackage *) (buffer + sizeof(PackageType)); 2379 *type = cGetObjectDepthPackage; 2380 pkg->vmID = vmID; 2381 pkg->accessibleContext = accessibleContext; 2382 2383 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2384 PrintDebugString("[INFO]: WinAccessBridge::getObjectDepth(%X, %p)", vmID, accessibleContext); 2385 #else // JOBJECT64 is jlong (64 bit) 2386 PrintDebugString("[INFO]: WinAccessBridge::getObjectDepth(%X, %016I64X)", vmID, accessibleContext); 2387 #endif 2388 // need to call only the HWND/VM that contains this AC 2389 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2390 if (destABWindow != (HWND) 0) { 2391 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2392 return pkg->rResult; 2393 } 2394 } 2395 return -1; 2396 } 2397 2398 /** 2399 * Returns the Accessible Context of the currently ActiveDescendent of an object. 2400 * Returns (AccessibleContext)0 on error. 2401 */ 2402 AccessibleContext 2403 WinAccessBridge::getActiveDescendent (const long vmID, const AccessibleContext accessibleContext) { 2404 2405 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2406 return (JOBJECT64)0; 2407 } 2408 char buffer[sizeof(PackageType) + sizeof(GetActiveDescendentPackage)]; 2409 PackageType *type = (PackageType *) buffer; 2410 GetActiveDescendentPackage *pkg = (GetActiveDescendentPackage *) (buffer + sizeof(PackageType)); 2411 *type = cGetActiveDescendentPackage; 2412 pkg->vmID = vmID; 2413 pkg->accessibleContext = accessibleContext; 2414 2415 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2416 PrintDebugString("[INFO]: WinAccessBridge::getActiveDescendent(%X, %p)", vmID, accessibleContext); 2417 #else // JOBJECT64 is jlong (64 bit) 2418 PrintDebugString("[INFO]: WinAccessBridge::getActiveDescendent(%X, %016I64X)", vmID, accessibleContext); 2419 #endif 2420 // need to call only the HWND/VM that contains this AC 2421 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2422 if (destABWindow != (HWND) 0) { 2423 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2424 return pkg->rAccessibleContext; 2425 } 2426 } 2427 return (JOBJECT64) 0; 2428 } 2429 2430 /** 2431 * Additional methods for Teton 2432 */ 2433 2434 /** 2435 * Gets the AccessibleName for a component based upon the JAWS algorithm. Returns 2436 * whether successful. 2437 * 2438 * Bug ID 4916682 - Implement JAWS AccessibleName policy 2439 */ 2440 BOOL 2441 WinAccessBridge::getVirtualAccessibleName(long vmID, AccessibleContext accessibleContext, 2442 wchar_t *name, int len) { 2443 2444 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2445 return FALSE; 2446 } 2447 char buffer[sizeof(PackageType) + sizeof(GetVirtualAccessibleNamePackage)]; 2448 PackageType *type = (PackageType *) buffer; 2449 GetVirtualAccessibleNamePackage *pkg = (GetVirtualAccessibleNamePackage *) (buffer + sizeof(PackageType)); 2450 *type = cGetVirtualAccessibleNamePackage; 2451 pkg->vmID = vmID; 2452 pkg->accessibleContext = accessibleContext; 2453 size_t max = (len > sizeof(pkg->rName)) ? sizeof(pkg->rName) : len; 2454 pkg->len = (int)max; 2455 2456 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2457 PrintDebugString("[INFO]: WinAccessBridge::getVirtualAccessibleName(%X, %p)", vmID, accessibleContext); 2458 #else // JOBJECT64 is jlong (64 bit) 2459 PrintDebugString("[INFO]: WinAccessBridge::getVirtualAccessibleName(%X, %016I64X)", vmID, accessibleContext); 2460 #endif 2461 // need to call only the HWND/VM that contains this AC 2462 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2463 if (destABWindow != (HWND) 0) { 2464 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2465 wcsncpy(name, pkg->rName, max); 2466 PrintDebugString("[INFO]: WinAccessBridge::getVirtualAccessibleName: Virtual name = %ls", name); 2467 return TRUE; 2468 } 2469 } 2470 return FALSE; 2471 } 2472 2473 /** 2474 * Request focus for a component. Returns whether successful; 2475 * 2476 * Bug ID 4944757 - requestFocus method needed 2477 */ 2478 BOOL 2479 WinAccessBridge::requestFocus(long vmID, AccessibleContext accessibleContext) { 2480 2481 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2482 return FALSE; 2483 } 2484 char buffer[sizeof(PackageType) + sizeof(RequestFocusPackage)]; 2485 PackageType *type = (PackageType *) buffer; 2486 RequestFocusPackage *pkg = (RequestFocusPackage *) (buffer + sizeof(PackageType)); 2487 *type = cRequestFocusPackage; 2488 pkg->vmID = vmID; 2489 pkg->accessibleContext = accessibleContext; 2490 2491 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2492 PrintDebugString("[INFO]: WinAccessBridge::requestFocus(%X, %p)", vmID, accessibleContext); 2493 #else // JOBJECT64 is jlong (64 bit) 2494 PrintDebugString("[INFO]: WinAccessBridge::requestFocus(%X, %016I64X)", vmID, accessibleContext); 2495 #endif 2496 // need to call only the HWND/VM that contains this AC 2497 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2498 if (destABWindow != (HWND) 0) { 2499 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2500 return TRUE; 2501 } 2502 } 2503 return FALSE; 2504 } 2505 2506 /** 2507 * Selects text between two indices. Selection includes the text at the start index 2508 * and the text at the end index. Returns whether successful; 2509 * 2510 * Bug ID 4944758 - selectTextRange method needed 2511 */ 2512 BOOL 2513 WinAccessBridge::selectTextRange(long vmID, AccessibleContext accessibleContext, int startIndex, int endIndex) { 2514 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2515 return FALSE; 2516 } 2517 char buffer[sizeof(PackageType) + sizeof(SelectTextRangePackage)]; 2518 PackageType *type = (PackageType *) buffer; 2519 SelectTextRangePackage *pkg = (SelectTextRangePackage *) (buffer + sizeof(PackageType)); 2520 *type = cSelectTextRangePackage; 2521 pkg->vmID = vmID; 2522 pkg->accessibleContext = accessibleContext; 2523 pkg->startIndex = startIndex; 2524 pkg->endIndex = endIndex; 2525 2526 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2527 PrintDebugString("[INFO]: WinAccessBridge::selectTextRange(%X, %p %d %d)", vmID, accessibleContext, 2528 startIndex, endIndex); 2529 #else // JOBJECT64 is jlong (64 bit) 2530 PrintDebugString("[INFO]: WinAccessBridge::selectTextRange(%X, %016I64X %d %d)", vmID, accessibleContext, 2531 startIndex, endIndex); 2532 #endif 2533 // need to call only the HWND/VM that contains this AC 2534 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2535 if (destABWindow != (HWND) 0) { 2536 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2537 return TRUE; 2538 } 2539 } 2540 return FALSE; 2541 } 2542 2543 /** 2544 * Get text attributes between two indices. The attribute list includes the text at the 2545 * start index and the text at the end index. Returns whether successful; 2546 * 2547 * Bug ID 4944761 - getTextAttributes between two indices method needed 2548 */ 2549 BOOL 2550 WinAccessBridge::getTextAttributesInRange(long vmID, AccessibleContext accessibleContext, 2551 int startIndex, int endIndex, 2552 AccessibleTextAttributesInfo *attributes, short *len) { 2553 2554 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2555 return FALSE; 2556 } 2557 char buffer[sizeof(PackageType) + sizeof(GetTextAttributesInRangePackage)]; 2558 PackageType *type = (PackageType *) buffer; 2559 GetTextAttributesInRangePackage *pkg = (GetTextAttributesInRangePackage *) (buffer + sizeof(PackageType)); 2560 *type = cGetTextAttributesInRangePackage; 2561 pkg->vmID = vmID; 2562 pkg->accessibleContext = accessibleContext; 2563 pkg->startIndex = startIndex; 2564 pkg->endIndex = endIndex; 2565 memcpy(&(pkg->attributes), attributes, sizeof(AccessibleTextAttributesInfo)); 2566 2567 2568 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2569 PrintDebugString("[INFO]: WinAccessBridge::getTextAttributesInRange(%X, %p %d %d)", vmID, accessibleContext, 2570 startIndex, endIndex); 2571 #else // JOBJECT64 is jlong (64 bit) 2572 PrintDebugString("[INFO]: WinAccessBridge::getTextAttributesInRange(%X, %016I64X %d %d)", vmID, accessibleContext, 2573 startIndex, endIndex); 2574 #endif 2575 // need to call only the HWND/VM that contains this AC 2576 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2577 if (destABWindow != (HWND) 0) { 2578 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2579 *attributes = pkg->attributes; 2580 *len = pkg->rLength; 2581 return TRUE; 2582 } 2583 } 2584 return FALSE; 2585 } 2586 2587 /** 2588 * Gets the number of visible children of a component. Returns -1 on error. 2589 * 2590 * Bug ID 4944762- getVisibleChildren for list-like components needed 2591 */ 2592 int 2593 WinAccessBridge::getVisibleChildrenCount(long vmID, AccessibleContext accessibleContext) { 2594 2595 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2596 return -1; 2597 } 2598 char buffer[sizeof(PackageType) + sizeof(GetVisibleChildrenCountPackage)]; 2599 PackageType *type = (PackageType *) buffer; 2600 GetVisibleChildrenCountPackage *pkg = (GetVisibleChildrenCountPackage *) (buffer + sizeof(PackageType)); 2601 *type = cGetVisibleChildrenCountPackage; 2602 pkg->vmID = vmID; 2603 pkg->accessibleContext = accessibleContext; 2604 2605 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2606 PrintDebugString("[INFO]: WinAccessBridge::getVisibleChildrenCount(%X, %p)", vmID, accessibleContext); 2607 #else // JOBJECT64 is jlong (64 bit) 2608 PrintDebugString("[INFO]: WinAccessBridge::getVisibleChildrenCount(%X, %016I64X)", vmID, accessibleContext); 2609 #endif 2610 // need to call only the HWND/VM that contains this AC 2611 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2612 if (destABWindow != (HWND) 0) { 2613 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2614 return pkg->rChildrenCount; 2615 } 2616 } 2617 return -1; 2618 } 2619 2620 /** 2621 * Gets the visible children of an AccessibleContext. Returns whether successful; 2622 * 2623 * Bug ID 4944762- getVisibleChildren for list-like components needed 2624 */ 2625 BOOL 2626 WinAccessBridge::getVisibleChildren(long vmID, AccessibleContext accessibleContext, int startIndex, 2627 VisibleChildrenInfo *visibleChildrenInfo) { 2628 2629 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2630 return FALSE; 2631 } 2632 char buffer[sizeof(PackageType) + sizeof(GetVisibleChildrenPackage)]; 2633 PackageType *type = (PackageType *) buffer; 2634 GetVisibleChildrenPackage *pkg = (GetVisibleChildrenPackage *) (buffer + sizeof(PackageType)); 2635 *type = cGetVisibleChildrenPackage; 2636 pkg->vmID = vmID; 2637 pkg->accessibleContext = accessibleContext; 2638 pkg->startIndex = startIndex; 2639 2640 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2641 PrintDebugString("[INFO]: WinAccessBridge::getVisibleChildren(%X, %p)", vmID, accessibleContext); 2642 #else // JOBJECT64 is jlong (64 bit) 2643 PrintDebugString("[INFO]: WinAccessBridge::getVisibleChildren(%X, %016I64X)", vmID, accessibleContext); 2644 #endif 2645 // need to call only the HWND/VM that contains this AC 2646 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2647 if (destABWindow != (HWND) 0) { 2648 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2649 memcpy(visibleChildrenInfo, &(pkg->rVisibleChildrenInfo), sizeof(pkg->rVisibleChildrenInfo)); 2650 return pkg->rSuccess; 2651 } 2652 } 2653 return FALSE; 2654 } 2655 2656 /** 2657 * Set the caret to a text position. Returns whether successful; 2658 * 2659 * Bug ID 4944770 - setCaretPosition method needed 2660 */ 2661 BOOL 2662 WinAccessBridge::setCaretPosition(long vmID, AccessibleContext accessibleContext, int position) { 2663 2664 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2665 return FALSE; 2666 } 2667 char buffer[sizeof(PackageType) + sizeof(SetCaretPositionPackage)]; 2668 PackageType *type = (PackageType *) buffer; 2669 SetCaretPositionPackage *pkg = (SetCaretPositionPackage *) (buffer + sizeof(PackageType)); 2670 *type = cSetCaretPositionPackage; 2671 pkg->vmID = vmID; 2672 pkg->accessibleContext = accessibleContext; 2673 pkg->position = position; 2674 2675 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2676 PrintDebugString("[INFO]: WinAccessBridge::setCaretPosition(%X, %p %ls)", vmID, accessibleContext); 2677 #else // JOBJECT64 is jlong (64 bit) 2678 PrintDebugString("[INFO]: WinAccessBridge::setCaretPosition(%X, %016I64X %ls)", vmID, accessibleContext); 2679 #endif 2680 // need to call only the HWND/VM that contains this AC 2681 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2682 if (destABWindow != (HWND) 0) { 2683 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2684 return TRUE; 2685 } 2686 } 2687 return FALSE; 2688 } 2689 2690 2691 /********** AccessibleText routines ***********************************/ 2692 2693 /** 2694 * getAccessibleTextInfo - fills a struct with a bunch of information 2695 * contained in the Java Accessibility AccessibleText API 2696 * 2697 * 2698 * Note: if the AccessibleContext parameter is bogus, this call will blow up 2699 */ 2700 BOOL 2701 WinAccessBridge::getAccessibleTextInfo(long vmID, 2702 JOBJECT64 AccessibleContext, 2703 AccessibleTextInfo *textInfo, 2704 jint x, jint y) { 2705 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2706 return FALSE; 2707 } 2708 char buffer[sizeof(PackageType) + sizeof(GetAccessibleTextInfoPackage)]; 2709 PackageType *type = (PackageType *) buffer; 2710 GetAccessibleTextInfoPackage *pkg = (GetAccessibleTextInfoPackage *) (buffer + sizeof(PackageType)); 2711 *type = cGetAccessibleTextInfoPackage; 2712 pkg->vmID = vmID; 2713 pkg->AccessibleContext = AccessibleContext; 2714 pkg->x = x; 2715 pkg->y = y; 2716 2717 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2718 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextInfo(%X, %p, %p, %d, %d)", vmID, AccessibleContext, textInfo, x, y); 2719 #else // JOBJECT64 is jlong (64 bit) 2720 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextInfo(%X, %016I64X, %p, %d, %d)", vmID, AccessibleContext, textInfo, x, y); 2721 #endif 2722 // need to call only the HWND/VM that contains this AC 2723 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2724 if (destABWindow != (HWND) 0) { 2725 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2726 memcpy(textInfo, &(pkg->rTextInfo), sizeof(AccessibleTextInfo)); 2727 if (pkg->rTextInfo.charCount != -1) { 2728 PrintDebugString("[INFO]: charCount: %d"\ 2729 " caretIndex: %d"\ 2730 " indexAtPoint: %d"\ 2731 , textInfo->charCount, textInfo->caretIndex, textInfo->indexAtPoint); 2732 return TRUE; 2733 } 2734 } 2735 } 2736 2737 return FALSE; 2738 } 2739 2740 /** 2741 * getAccessibleTextItems - fills a struct with letter, word, and sentence info 2742 * of the AccessibleText interface at a given index 2743 * 2744 * Note: if the AccessibleContext parameter is bogus, this call will blow up 2745 */ 2746 BOOL 2747 WinAccessBridge::getAccessibleTextItems(long vmID, 2748 JOBJECT64 AccessibleContext, 2749 AccessibleTextItemsInfo *textItems, 2750 jint index) { 2751 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2752 return FALSE; 2753 } 2754 char buffer[sizeof(PackageType) + sizeof(GetAccessibleTextItemsPackage)]; 2755 PackageType *type = (PackageType *) buffer; 2756 GetAccessibleTextItemsPackage *pkg = (GetAccessibleTextItemsPackage *) (buffer + sizeof(PackageType)); 2757 *type = cGetAccessibleTextItemsPackage; 2758 pkg->vmID = vmID; 2759 pkg->AccessibleContext = AccessibleContext; 2760 pkg->index = index; 2761 // zero things out, in case the call fails 2762 pkg->rTextItemsInfo.letter = '\0'; 2763 pkg->rTextItemsInfo.word[0] = '\0'; 2764 pkg->rTextItemsInfo.sentence[0] = '\0'; 2765 2766 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2767 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextItems(%X, %p, %p, %d)", vmID, AccessibleContext, textItems, index); 2768 #else // JOBJECT64 is jlong (64 bit) 2769 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextItems(%X, %016I64X, %p, %d)", vmID, AccessibleContext, textItems, index); 2770 #endif 2771 // need to call only the HWND/VM that contains this AC 2772 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2773 if (destABWindow != (HWND) 0) { 2774 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2775 memcpy(textItems, &(pkg->rTextItemsInfo), sizeof(AccessibleTextItemsInfo)); 2776 if (pkg->rTextItemsInfo.letter != '/0') { 2777 return TRUE; 2778 } 2779 } 2780 } 2781 2782 return FALSE; 2783 } 2784 2785 /** 2786 * getAccessibleTextSelectionInfo - returns information about the selected 2787 * text of the object implementing AccessibleText 2788 * 2789 * Note: if the AccessibleContext parameter is bogus, this call will blow up 2790 */ 2791 BOOL 2792 WinAccessBridge::getAccessibleTextSelectionInfo(long vmID, 2793 JOBJECT64 AccessibleContext, 2794 AccessibleTextSelectionInfo *selectionInfo) { 2795 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2796 return FALSE; 2797 } 2798 char buffer[sizeof(PackageType) + sizeof(GetAccessibleTextSelectionInfoPackage)]; 2799 PackageType *type = (PackageType *) buffer; 2800 GetAccessibleTextSelectionInfoPackage *pkg = (GetAccessibleTextSelectionInfoPackage *) (buffer + sizeof(PackageType)); 2801 *type = cGetAccessibleTextSelectionInfoPackage; 2802 pkg->vmID = vmID; 2803 pkg->AccessibleContext = AccessibleContext; 2804 2805 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2806 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextSelectionInfo(%X, %p, %p)", vmID, AccessibleContext, selectionInfo); 2807 #else // JOBJECT64 is jlong (64 bit) 2808 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextSelectionInfo(%X, %016I64X, %p)", vmID, AccessibleContext, selectionInfo); 2809 #endif 2810 // need to call only the HWND/VM that contains this AC 2811 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2812 if (destABWindow != (HWND) 0) { 2813 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2814 memcpy(selectionInfo, &(pkg->rTextSelectionItemsInfo), sizeof(AccessibleTextSelectionInfo)); 2815 // [[[FIXME]]] should test to see if valid info returned; return FALSE if not 2816 return TRUE; 2817 } 2818 } 2819 2820 return FALSE; 2821 } 2822 2823 /** 2824 * getAccessibleTextAttributes - performs the Java code: 2825 * ...[[[FIXME]]] fill in this comment... 2826 * 2827 * Note: if the AccessibleContext parameter is bogus, this call will blow up 2828 */ 2829 BOOL 2830 WinAccessBridge::getAccessibleTextAttributes(long vmID, 2831 JOBJECT64 AccessibleContext, 2832 jint index, 2833 AccessibleTextAttributesInfo *attributes) { 2834 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2835 return FALSE; 2836 } 2837 char buffer[sizeof(PackageType) + sizeof(GetAccessibleTextAttributeInfoPackage)]; 2838 PackageType *type = (PackageType *) buffer; 2839 GetAccessibleTextAttributeInfoPackage *pkg = (GetAccessibleTextAttributeInfoPackage *) (buffer + sizeof(PackageType)); 2840 *type = cGetAccessibleTextAttributeInfoPackage; 2841 pkg->vmID = vmID; 2842 pkg->AccessibleContext = AccessibleContext; 2843 pkg->index = index; 2844 2845 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2846 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextAttributes(%X, %p, %d, %p)", vmID, AccessibleContext, index, attributes); 2847 #else // JOBJECT64 is jlong (64 bit) 2848 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextAttributes(%X, %016I64X, %d, %p)", vmID, AccessibleContext, index, attributes); 2849 #endif 2850 // need to call only the HWND/VM that contains this AC 2851 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2852 if (destABWindow != (HWND) 0) { 2853 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2854 memcpy(attributes, &(pkg->rAttributeInfo), sizeof(AccessibleTextAttributesInfo)); 2855 return TRUE; 2856 } 2857 } 2858 2859 return FALSE; 2860 } 2861 2862 /** 2863 * getAccessibleTextRect - gets the text bounding rectangle 2864 * 2865 * Note: if the AccessibleContext parameter is bogus, this call will blow up 2866 */ 2867 BOOL 2868 WinAccessBridge::getAccessibleTextRect(long vmID, 2869 JOBJECT64 AccessibleContext, 2870 AccessibleTextRectInfo *rectInfo, 2871 jint index) { 2872 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2873 return FALSE; 2874 } 2875 char buffer[sizeof(PackageType) + sizeof(GetAccessibleTextRectInfoPackage)]; 2876 PackageType *type = (PackageType *) buffer; 2877 GetAccessibleTextRectInfoPackage *pkg = (GetAccessibleTextRectInfoPackage *) (buffer + sizeof(PackageType)); 2878 *type = cGetAccessibleTextRectInfoPackage; 2879 pkg->vmID = vmID; 2880 pkg->AccessibleContext = AccessibleContext; 2881 pkg->index = index; 2882 2883 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2884 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextRect(%X, %p, %p, %d)", vmID, AccessibleContext, rectInfo, index); 2885 #else // JOBJECT64 is jlong (64 bit) 2886 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextRect(%X, %016I64X, %p, %d)", vmID, AccessibleContext, rectInfo, index); 2887 #endif 2888 // need to call only the HWND/VM that contains this AC 2889 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2890 if (destABWindow != (HWND) 0) { 2891 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2892 memcpy(rectInfo, (&pkg->rTextRectInfo), sizeof(AccessibleTextRectInfo)); 2893 // [[[FIXME]]] should test to see if valid info returned; return FALSE if not 2894 return TRUE; 2895 } 2896 } 2897 2898 return FALSE; 2899 } 2900 2901 2902 /** 2903 * getAccessibleTextRect - gets the text bounding rectangle 2904 * 2905 * Note: if the AccessibleContext parameter is bogus, this call will blow up 2906 */ 2907 BOOL 2908 WinAccessBridge::getCaretLocation(long vmID, 2909 JOBJECT64 AccessibleContext, 2910 AccessibleTextRectInfo *rectInfo, 2911 jint index) { 2912 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2913 return FALSE; 2914 } 2915 char buffer[sizeof(PackageType) + sizeof(GetCaretLocationPackage)]; 2916 PackageType *type = (PackageType *) buffer; 2917 GetCaretLocationPackage *pkg = (GetCaretLocationPackage *) (buffer + sizeof(PackageType)); 2918 *type = cGetCaretLocationPackage; 2919 pkg->vmID = vmID; 2920 pkg->AccessibleContext = AccessibleContext; 2921 pkg->index = index; 2922 2923 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2924 PrintDebugString("[INFO]: WinAccessBridge::getCaretLocation(%X, %p, %p, %d)", vmID, AccessibleContext, rectInfo, index); 2925 #else // JOBJECT64 is jlong (64 bit) 2926 PrintDebugString("[INFO]: WinAccessBridge::getCaretLocation(%X, %016I64X, %p, %d)", vmID, AccessibleContext, rectInfo, index); 2927 #endif 2928 // need to call only the HWND/VM that contains this AC 2929 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2930 if (destABWindow != (HWND) 0) { 2931 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2932 memcpy(rectInfo, (&pkg->rTextRectInfo), sizeof(AccessibleTextRectInfo)); 2933 return TRUE; 2934 } 2935 } 2936 2937 return FALSE; 2938 } 2939 2940 2941 /** 2942 * getEventsWaiting - gets the number of events waiting to fire 2943 * 2944 * Note: if the AccessibleContext parameter is bogus, this call will blow up 2945 */ 2946 int 2947 WinAccessBridge::getEventsWaiting() { 2948 if(messageQueue) { 2949 return(messageQueue->getEventsWaiting()); 2950 } 2951 return(0); 2952 } 2953 2954 2955 /** 2956 * getAccessibleTextLineBounds - gets the bounding rectangle for the text line 2957 * 2958 * Note: if the AccessibleContext parameter is bogus, this call will blow up 2959 */ 2960 BOOL 2961 WinAccessBridge::getAccessibleTextLineBounds(long vmID, 2962 JOBJECT64 AccessibleContext, 2963 jint index, jint *startIndex, jint *endIndex) { 2964 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 2965 return FALSE; 2966 } 2967 char buffer[sizeof(PackageType) + sizeof(GetAccessibleTextLineBoundsPackage)]; 2968 PackageType *type = (PackageType *) buffer; 2969 GetAccessibleTextLineBoundsPackage *pkg = (GetAccessibleTextLineBoundsPackage *) (buffer + sizeof(PackageType)); 2970 *type = cGetAccessibleTextLineBoundsPackage; 2971 pkg->vmID = vmID; 2972 pkg->AccessibleContext = AccessibleContext; 2973 pkg->index = index; 2974 2975 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 2976 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextLineBounds(%X, %p, %d, )", vmID, AccessibleContext, index); 2977 #else // JOBJECT64 is jlong (64 bit) 2978 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextLineBounds(%X, %016I64X, %d, )", vmID, AccessibleContext, index); 2979 #endif 2980 // need to call only the HWND/VM that contains this AC 2981 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 2982 if (destABWindow != (HWND) 0) { 2983 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 2984 *startIndex = pkg->rLineStart; 2985 *endIndex = pkg->rLineEnd; 2986 // [[[FIXME]]] should test to see if valid info returned; return FALSE if not 2987 return TRUE; 2988 } 2989 } 2990 2991 return FALSE; 2992 } 2993 2994 2995 /** 2996 * getAccessibleTextLineBounds - performs the Java code: 2997 * ...[[[FIXME]]] fill in this comment... 2998 * 2999 * Note: if the AccessibleContext parameter is bogus, this call will blow up 3000 */ 3001 BOOL 3002 WinAccessBridge::getAccessibleTextRange(long vmID, 3003 JOBJECT64 AccessibleContext, 3004 jint start, jint end, wchar_t *text, short len) { 3005 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 3006 return FALSE; 3007 } 3008 char buffer[sizeof(PackageType) + sizeof(GetAccessibleTextRangePackage)]; 3009 PackageType *type = (PackageType *) buffer; 3010 GetAccessibleTextRangePackage *pkg = (GetAccessibleTextRangePackage *) (buffer + sizeof(PackageType)); 3011 *type = cGetAccessibleTextRangePackage; 3012 pkg->vmID = vmID; 3013 pkg->AccessibleContext = AccessibleContext; 3014 pkg->start = start; 3015 pkg->end = end; 3016 3017 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer) 3018 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextRange(%X, %p, %d, %d, )", vmID, AccessibleContext, start, end); 3019 #else // JOBJECT64 is jlong (64 bit) 3020 PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextRange(%X, %016I64X, %d, %d, )", vmID, AccessibleContext, start, end); 3021 #endif 3022 // need to call only the HWND/VM that contains this AC 3023 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 3024 if (destABWindow != (HWND) 0) { 3025 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 3026 wcsncpy(text, pkg->rText, len); 3027 // [[[FIXME]]] should test to see if valid info returned; return FALSE if not 3028 return TRUE; 3029 } 3030 } 3031 3032 return FALSE; 3033 } 3034 3035 3036 3037 3038 /********** AccessibleValue routines ***************/ 3039 3040 BOOL 3041 WinAccessBridge::getCurrentAccessibleValueFromContext(long vmID, 3042 JOBJECT64 AccessibleContext, 3043 wchar_t *value, short len) { 3044 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 3045 return FALSE; 3046 } 3047 char buffer[sizeof(PackageType) + sizeof(GetCurrentAccessibleValueFromContextPackage)]; 3048 PackageType *type = (PackageType *) buffer; 3049 GetCurrentAccessibleValueFromContextPackage *pkg = (GetCurrentAccessibleValueFromContextPackage *) (buffer + sizeof(PackageType)); 3050 *type = cGetCurrentAccessibleValueFromContextPackage; 3051 pkg->vmID = vmID; 3052 pkg->AccessibleContext = AccessibleContext; 3053 3054 // need to call only the HWND/VM that contains this AC 3055 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 3056 if (destABWindow != (HWND) 0) { 3057 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 3058 wcsncpy(value, pkg->rValue, len); 3059 // [[[FIXME]]] should test to see if valid info returned; return FALSE if not 3060 return TRUE; 3061 } 3062 } 3063 3064 return FALSE; 3065 } 3066 3067 BOOL 3068 WinAccessBridge::getMaximumAccessibleValueFromContext(long vmID, 3069 JOBJECT64 AccessibleContext, 3070 wchar_t *value, short len) { 3071 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 3072 return FALSE; 3073 } 3074 char buffer[sizeof(PackageType) + sizeof(GetMaximumAccessibleValueFromContextPackage)]; 3075 PackageType *type = (PackageType *) buffer; 3076 GetMaximumAccessibleValueFromContextPackage *pkg = (GetMaximumAccessibleValueFromContextPackage *) (buffer + sizeof(PackageType)); 3077 *type = cGetMaximumAccessibleValueFromContextPackage; 3078 pkg->vmID = vmID; 3079 pkg->AccessibleContext = AccessibleContext; 3080 3081 // need to call only the HWND/VM that contains this AC 3082 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 3083 if (destABWindow != (HWND) 0) { 3084 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 3085 wcsncpy(value, pkg->rValue, len); 3086 // [[[FIXME]]] should test to see if valid info returned; return FALSE if not 3087 return TRUE; 3088 } 3089 } 3090 3091 return FALSE; 3092 } 3093 3094 BOOL 3095 WinAccessBridge::getMinimumAccessibleValueFromContext(long vmID, 3096 JOBJECT64 AccessibleContext, 3097 wchar_t *value, short len) { 3098 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 3099 return FALSE; 3100 } 3101 char buffer[sizeof(PackageType) + sizeof(GetMinimumAccessibleValueFromContextPackage)]; 3102 PackageType *type = (PackageType *) buffer; 3103 GetMinimumAccessibleValueFromContextPackage *pkg = (GetMinimumAccessibleValueFromContextPackage *) (buffer + sizeof(PackageType)); 3104 *type = cGetMinimumAccessibleValueFromContextPackage; 3105 pkg->vmID = vmID; 3106 pkg->AccessibleContext = AccessibleContext; 3107 3108 // need to call only the HWND/VM that contains this AC 3109 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 3110 if (destABWindow != (HWND) 0) { 3111 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 3112 wcsncpy(value, pkg->rValue, len); 3113 // [[[FIXME]]] should test to see if valid info returned; return FALSE if not 3114 return TRUE; 3115 } 3116 } 3117 3118 return FALSE; 3119 } 3120 3121 3122 /********** AccessibleSelection routines ***************/ 3123 3124 void 3125 WinAccessBridge::addAccessibleSelectionFromContext(long vmID, 3126 JOBJECT64 AccessibleContext, int i) { 3127 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 3128 return; 3129 } 3130 char buffer[sizeof(PackageType) + sizeof(AddAccessibleSelectionFromContextPackage)]; 3131 PackageType *type = (PackageType *) buffer; 3132 AddAccessibleSelectionFromContextPackage *pkg = (AddAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType)); 3133 *type = cAddAccessibleSelectionFromContextPackage; 3134 pkg->vmID = vmID; 3135 pkg->AccessibleContext = AccessibleContext; 3136 pkg->index = i; 3137 3138 // need to call only the HWND/VM that contains this AC 3139 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 3140 if (destABWindow != (HWND) 0) { 3141 sendMemoryPackage(buffer, sizeof(buffer), destABWindow); 3142 } 3143 } 3144 3145 void 3146 WinAccessBridge::clearAccessibleSelectionFromContext(long vmID, 3147 JOBJECT64 AccessibleContext) { 3148 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 3149 return; 3150 } 3151 char buffer[sizeof(PackageType) + sizeof(ClearAccessibleSelectionFromContextPackage)]; 3152 PackageType *type = (PackageType *) buffer; 3153 ClearAccessibleSelectionFromContextPackage *pkg = (ClearAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType)); 3154 *type = cClearAccessibleSelectionFromContextPackage; 3155 pkg->vmID = vmID; 3156 pkg->AccessibleContext = AccessibleContext; 3157 3158 // need to call only the HWND/VM that contains this AC 3159 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 3160 if (destABWindow != (HWND) 0) { 3161 sendMemoryPackage(buffer, sizeof(buffer), destABWindow); 3162 } 3163 } 3164 3165 JOBJECT64 3166 WinAccessBridge::getAccessibleSelectionFromContext(long vmID, 3167 JOBJECT64 AccessibleContext, int i) { 3168 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 3169 return (JOBJECT64)0; 3170 } 3171 char buffer[sizeof(PackageType) + sizeof(GetAccessibleSelectionFromContextPackage)]; 3172 PackageType *type = (PackageType *) buffer; 3173 GetAccessibleSelectionFromContextPackage *pkg = (GetAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType)); 3174 *type = cGetAccessibleSelectionFromContextPackage; 3175 pkg->vmID = vmID; 3176 pkg->AccessibleContext = AccessibleContext; 3177 pkg->index = i; 3178 3179 // need to call only the HWND/VM that contains this AC 3180 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 3181 if (destABWindow != (HWND) 0) { 3182 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 3183 return pkg->rAccessibleContext; 3184 } 3185 } 3186 3187 return (JOBJECT64) 0; 3188 } 3189 3190 int 3191 WinAccessBridge::getAccessibleSelectionCountFromContext(long vmID, 3192 JOBJECT64 AccessibleContext) { 3193 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 3194 return -1; 3195 } 3196 char buffer[sizeof(PackageType) + sizeof(GetAccessibleSelectionCountFromContextPackage)]; 3197 PackageType *type = (PackageType *) buffer; 3198 GetAccessibleSelectionCountFromContextPackage *pkg = (GetAccessibleSelectionCountFromContextPackage *) (buffer + sizeof(PackageType)); 3199 *type = cGetAccessibleSelectionCountFromContextPackage; 3200 pkg->vmID = vmID; 3201 pkg->AccessibleContext = AccessibleContext; 3202 3203 // need to call only the HWND/VM that contains this AC 3204 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 3205 if (destABWindow != (HWND) 0) { 3206 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 3207 return (int) pkg->rCount; 3208 } 3209 } 3210 3211 return -1; 3212 } 3213 3214 BOOL 3215 WinAccessBridge::isAccessibleChildSelectedFromContext(long vmID, 3216 JOBJECT64 AccessibleContext, int i) { 3217 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 3218 return FALSE; 3219 } 3220 char buffer[sizeof(PackageType) + sizeof(IsAccessibleChildSelectedFromContextPackage)]; 3221 PackageType *type = (PackageType *) buffer; 3222 IsAccessibleChildSelectedFromContextPackage *pkg = (IsAccessibleChildSelectedFromContextPackage *) (buffer + sizeof(PackageType)); 3223 *type = cIsAccessibleChildSelectedFromContextPackage; 3224 pkg->vmID = vmID; 3225 pkg->AccessibleContext = AccessibleContext; 3226 pkg->index = i; 3227 3228 // need to call only the HWND/VM that contains this AC 3229 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 3230 if (destABWindow != (HWND) 0) { 3231 if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) { 3232 if (pkg->rResult != 0) { 3233 return TRUE; 3234 } 3235 } 3236 } 3237 3238 return FALSE; 3239 } 3240 3241 3242 void 3243 WinAccessBridge::removeAccessibleSelectionFromContext(long vmID, 3244 JOBJECT64 AccessibleContext, int i) { 3245 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 3246 return; 3247 } 3248 char buffer[sizeof(PackageType) + sizeof(RemoveAccessibleSelectionFromContextPackage)]; 3249 PackageType *type = (PackageType *) buffer; 3250 RemoveAccessibleSelectionFromContextPackage *pkg = (RemoveAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType)); 3251 *type = cRemoveAccessibleSelectionFromContextPackage; 3252 pkg->vmID = vmID; 3253 pkg->AccessibleContext = AccessibleContext; 3254 pkg->index = i; 3255 3256 // need to call only the HWND/VM that contains this AC 3257 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 3258 if (destABWindow != (HWND) 0) { 3259 sendMemoryPackage(buffer, sizeof(buffer), destABWindow); 3260 } 3261 } 3262 3263 void 3264 WinAccessBridge::selectAllAccessibleSelectionFromContext(long vmID, 3265 JOBJECT64 AccessibleContext) { 3266 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 3267 return; 3268 } 3269 char buffer[sizeof(PackageType) + sizeof(SelectAllAccessibleSelectionFromContextPackage)]; 3270 PackageType *type = (PackageType *) buffer; 3271 SelectAllAccessibleSelectionFromContextPackage *pkg = (SelectAllAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType)); 3272 *type = cSelectAllAccessibleSelectionFromContextPackage; 3273 pkg->vmID = vmID; 3274 pkg->AccessibleContext = AccessibleContext; 3275 3276 // need to call only the HWND/VM that contains this AC 3277 HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID); 3278 if (destABWindow != (HWND) 0) { 3279 sendMemoryPackage(buffer, sizeof(buffer), destABWindow); 3280 } 3281 } 3282 3283 3284 /*********** Event handling methods **********************************/ 3285 3286 /** 3287 * addEventNotification - tell all Java-launched AccessBridge DLLs 3288 * that we want events of the specified type 3289 * 3290 * [[[FIXME]]] since we're just sending a long & a source window, 3291 * we could use a private message rather than WM_COPYDATA 3292 * (though we still may want it to be synchronous; dunno...) 3293 * 3294 */ 3295 void 3296 WinAccessBridge::addJavaEventNotification(jlong type) { 3297 PrintDebugString("[INFO]: WinAccessBridge::addJavaEventNotification(%016I64X)", type); 3298 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 3299 return; 3300 } 3301 3302 char buffer[sizeof(PackageType) + sizeof(AddJavaEventNotificationPackage)]; 3303 PackageType *pkgType = (PackageType *) buffer; 3304 AddJavaEventNotificationPackage *pkg = (AddJavaEventNotificationPackage *) (buffer + sizeof(PackageType)); 3305 *pkgType = cAddJavaEventNotificationPackage; 3306 pkg->type = type; 3307 pkg->DLLwindow = ABHandleToLong(dialogWindow); 3308 3309 PrintDebugString("[INFO]: ->pkgType = %X, eventType = %016I64X, DLLwindow = %p", 3310 *pkgType, pkg->type, pkg->DLLwindow); 3311 3312 // send addEventNotification message to all JVMs 3313 isVMInstanceChainInUse = true; 3314 AccessBridgeJavaVMInstance *current = javaVMs; 3315 while (current != (AccessBridgeJavaVMInstance *) 0) { 3316 current->sendPackage(buffer, sizeof(buffer)); // no return values! 3317 current = current->nextJVMInstance; 3318 } 3319 isVMInstanceChainInUse = false; 3320 } 3321 3322 /** 3323 * removeEventNotification - tell all Java-launched AccessBridge DLLs 3324 * that we no longer want events of the 3325 * specified type 3326 * 3327 * [[[FIXME]]] since we're just sending a long & a source window, 3328 * we could use a private message rather than WM_COPYDATA 3329 * (though we still may want it to be synchronous; dunno...) 3330 * 3331 */ 3332 void 3333 WinAccessBridge::removeJavaEventNotification(jlong type) { 3334 PrintDebugString("[INFO]: in WinAccessBridge::removeJavaEventNotification(%016I64X)", type); 3335 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 3336 return; 3337 } 3338 char buffer[sizeof(PackageType) + sizeof(RemoveJavaEventNotificationPackage)]; 3339 PackageType *pkgType = (PackageType *) buffer; 3340 RemoveJavaEventNotificationPackage *pkg = (RemoveJavaEventNotificationPackage *) (buffer + sizeof(PackageType)); 3341 *pkgType = cRemoveJavaEventNotificationPackage; 3342 pkg->type = type; 3343 pkg->DLLwindow = ABHandleToLong(dialogWindow); 3344 3345 PrintDebugString("[INFO]: ->pkgType = %X, eventType = %016I64X, DLLwindow = %p", 3346 *pkgType, pkg->type, pkg->DLLwindow); 3347 3348 // send removeEventNotification message to all JVMs 3349 isVMInstanceChainInUse = true; 3350 AccessBridgeJavaVMInstance *current = javaVMs; 3351 while (current != (AccessBridgeJavaVMInstance *) 0) { 3352 current->sendPackage(buffer, sizeof(buffer)); // no return values! 3353 current = current->nextJVMInstance; 3354 } 3355 isVMInstanceChainInUse = false; 3356 } 3357 3358 3359 /*********** Event handling methods **********************************/ 3360 3361 /** 3362 * addAccessibilityEventNotification - tell all Java-launched AccessBridge DLLs 3363 * that we want events of the specified type 3364 * 3365 * [[[FIXME]]] since we're just sending a long & a source window, 3366 * we could use a private message rather than WM_COPYDATA 3367 * (though we still may want it to be synchronous; dunno...) 3368 * 3369 */ 3370 void 3371 WinAccessBridge::addAccessibilityEventNotification(jlong type) { 3372 PrintDebugString("[INFO]: in WinAccessBridge::addAccessibilityEventNotification(%016I64X)", type); 3373 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 3374 return; 3375 } 3376 char buffer[sizeof(PackageType) + sizeof(AddAccessibilityEventNotificationPackage)]; 3377 PackageType *pkgType = (PackageType *) buffer; 3378 AddAccessibilityEventNotificationPackage *pkg = (AddAccessibilityEventNotificationPackage *) (buffer + sizeof(PackageType)); 3379 *pkgType = cAddAccessibilityEventNotificationPackage; 3380 pkg->type = type; 3381 pkg->DLLwindow = ABHandleToLong(dialogWindow); 3382 3383 PrintDebugString("[INFO]: ->pkgType = %X, eventType = %016I64X, DLLwindow = %X", 3384 *pkgType, pkg->type, pkg->DLLwindow); 3385 3386 // send addEventNotification message to all JVMs 3387 isVMInstanceChainInUse = true; 3388 AccessBridgeJavaVMInstance *current = javaVMs; 3389 while (current != (AccessBridgeJavaVMInstance *) 0) { 3390 current->sendPackage(buffer, sizeof(buffer)); // no return values! 3391 current = current->nextJVMInstance; 3392 } 3393 isVMInstanceChainInUse = false; 3394 } 3395 3396 /** 3397 * removeAccessibilityEventNotification - tell all Java-launched AccessBridge DLLs 3398 * that we no longer want events of the 3399 * specified type 3400 * 3401 * [[[FIXME]]] since we're just sending a long & a source window, 3402 * we could use a private message rather than WM_COPYDATA 3403 * (though we still may want it to be synchronous; dunno...) 3404 * 3405 */ 3406 void 3407 WinAccessBridge::removeAccessibilityEventNotification(jlong type) { 3408 PrintDebugString("[INFO]: in WinAccessBridge::removeAccessibilityEventNotification(%016I64X)", type); 3409 if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) { 3410 return; 3411 } 3412 char buffer[sizeof(PackageType) + sizeof(RemoveAccessibilityEventNotificationPackage)]; 3413 PackageType *pkgType = (PackageType *) buffer; 3414 RemoveAccessibilityEventNotificationPackage *pkg = (RemoveAccessibilityEventNotificationPackage *) (buffer + sizeof(PackageType)); 3415 *pkgType = cRemoveAccessibilityEventNotificationPackage; 3416 pkg->type = type; 3417 pkg->DLLwindow = ABHandleToLong(dialogWindow); 3418 3419 PrintDebugString("[INFO]: ->pkgType = %X, eventType = %016I64X, DLLwindow = %X", 3420 *pkgType, pkg->type, pkg->DLLwindow); 3421 3422 // send removeEventNotification message to all JVMs 3423 isVMInstanceChainInUse = true; 3424 AccessBridgeJavaVMInstance *current = javaVMs; 3425 while (current != (AccessBridgeJavaVMInstance *) 0) { 3426 current->sendPackage(buffer, sizeof(buffer)); // no return values! 3427 current = current->nextJVMInstance; 3428 } 3429 isVMInstanceChainInUse = false; 3430 } 3431 3432 3433 #define CALL_SET_EVENT_FP(function, callbackFP) \ 3434 void WinAccessBridge::function(callbackFP fp) { \ 3435 eventHandler->function(fp, this); \ 3436 /* eventHandler calls back to winAccessBridgeDLL to set eventMask */ \ 3437 } 3438 3439 void WinAccessBridge::setJavaShutdownFP(AccessBridge_JavaShutdownFP fp) { 3440 eventHandler->setJavaShutdownFP(fp, this); 3441 } 3442 3443 CALL_SET_EVENT_FP(setPropertyChangeFP, AccessBridge_PropertyChangeFP) 3444 CALL_SET_EVENT_FP(setFocusGainedFP, AccessBridge_FocusGainedFP) 3445 CALL_SET_EVENT_FP(setFocusLostFP, AccessBridge_FocusLostFP) 3446 CALL_SET_EVENT_FP(setCaretUpdateFP, AccessBridge_CaretUpdateFP) 3447 CALL_SET_EVENT_FP(setMouseClickedFP, AccessBridge_MouseClickedFP) 3448 CALL_SET_EVENT_FP(setMouseEnteredFP, AccessBridge_MouseEnteredFP) 3449 CALL_SET_EVENT_FP(setMouseExitedFP, AccessBridge_MouseExitedFP) 3450 CALL_SET_EVENT_FP(setMousePressedFP, AccessBridge_MousePressedFP) 3451 CALL_SET_EVENT_FP(setMouseReleasedFP, AccessBridge_MouseReleasedFP) 3452 CALL_SET_EVENT_FP(setMenuCanceledFP, AccessBridge_MenuCanceledFP) 3453 CALL_SET_EVENT_FP(setMenuDeselectedFP, AccessBridge_MenuDeselectedFP) 3454 CALL_SET_EVENT_FP(setMenuSelectedFP, AccessBridge_MenuSelectedFP) 3455 CALL_SET_EVENT_FP(setPopupMenuCanceledFP, AccessBridge_PopupMenuCanceledFP) 3456 CALL_SET_EVENT_FP(setPopupMenuWillBecomeInvisibleFP, AccessBridge_PopupMenuWillBecomeInvisibleFP) 3457 CALL_SET_EVENT_FP(setPopupMenuWillBecomeVisibleFP, AccessBridge_PopupMenuWillBecomeVisibleFP) 3458 3459 CALL_SET_EVENT_FP(setPropertyNameChangeFP, AccessBridge_PropertyNameChangeFP) 3460 CALL_SET_EVENT_FP(setPropertyDescriptionChangeFP, AccessBridge_PropertyDescriptionChangeFP) 3461 CALL_SET_EVENT_FP(setPropertyStateChangeFP, AccessBridge_PropertyStateChangeFP) 3462 CALL_SET_EVENT_FP(setPropertyValueChangeFP, AccessBridge_PropertyValueChangeFP) 3463 CALL_SET_EVENT_FP(setPropertySelectionChangeFP, AccessBridge_PropertySelectionChangeFP) 3464 CALL_SET_EVENT_FP(setPropertyTextChangeFP, AccessBridge_PropertyTextChangeFP) 3465 CALL_SET_EVENT_FP(setPropertyCaretChangeFP, AccessBridge_PropertyCaretChangeFP) 3466 CALL_SET_EVENT_FP(setPropertyVisibleDataChangeFP, AccessBridge_PropertyVisibleDataChangeFP) 3467 CALL_SET_EVENT_FP(setPropertyChildChangeFP, AccessBridge_PropertyChildChangeFP) 3468 CALL_SET_EVENT_FP(setPropertyActiveDescendentChangeFP, AccessBridge_PropertyActiveDescendentChangeFP) 3469 3470 CALL_SET_EVENT_FP(setPropertyTableModelChangeFP, AccessBridge_PropertyTableModelChangeFP)