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