< prev index next >

src/jdk.accessibility/windows/native/libjavaaccessbridge/JavaAccessBridge.cpp

Print this page




  68             InitializeCriticalSection(&receiveMemoryIPCLock);
  69             theJavaAccessBridge = new JavaAccessBridge(hinstDll);
  70             break;
  71 
  72         case DLL_PROCESS_DETACH:        // A Windows executable unloaded us
  73             if (theJavaAccessBridge != (JavaAccessBridge *) 0) {
  74                 delete theJavaAccessBridge;
  75                 DeleteCriticalSection(&receiveMemoryIPCLock);
  76             }
  77             break;
  78         }
  79         return TRUE;
  80     }
  81 
  82     /**
  83      * Open a native window (and init the wrappers we'll be using)
  84      *
  85      */
  86     JNIEXPORT void JNICALL
  87     Java_com_sun_java_accessibility_internal_AccessBridge_runDLL(JNIEnv *env, jobject obj) {
  88         PrintDebugString("\r\nJavaAccessBridge.DLL runDLL() called");
  89         theJavaAccessBridge->javaRun(env, obj);
  90     }
  91 
  92     /**
  93      * Our window proc
  94      *
  95      */
  96     BOOL APIENTRY AccessBridgeDialogProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) {
  97         int command;
  98         COPYDATASTRUCT *sentToUs;
  99         char *package;
 100 
 101         switch (message) {
 102         case WM_INITDIALOG:
 103             PrintDebugString("In AccessBridgeDialog - Initializing");
 104             break;
 105 
 106         case WM_COMMAND:
 107             command = LOWORD (wParam);
 108             PrintDebugString("In AccessBridgeDialog - Got WM_COMMAND, command: %X", command);
 109             break;
 110 
 111             // call from Java with data for us to deliver
 112         case WM_COPYDATA:
 113             if (theDialogWindow == (HWND) wParam) {
 114                 PrintDebugString("In AccessBridgeDialog - Got WM_COPYDATA from ourselves");
 115             } else {
 116                 PrintDebugString("In AccessBridgeDialog - Got WM_COPYDATA from HWND %p", wParam);
 117                 sentToUs = (COPYDATASTRUCT *) lParam;
 118                 package = (char *) sentToUs->lpData;
 119                 theJavaAccessBridge->processPackage(package, sentToUs->cbData);
 120             }
 121             break;
 122 
 123             // call from Java with data for us retrieve from memory mapped file and deliver
 124         case AB_MESSAGE_WAITING:
 125             // wParam == sourceHwnd
 126             // lParam == buffer size in shared memory
 127             if (theDialogWindow == (HWND) wParam) {
 128                 PrintDebugString("In AccessBridgeDialog - Got AB_MESSAGE_WAITING from ourselves");
 129             } else {
 130                 PrintDebugString("In AccessBridgeDialog - Got AB_MESSAGE_WAITING from HWND %p", wParam);
 131                 LRESULT returnVal = theJavaAccessBridge->receiveMemoryPackage((HWND) wParam, (long) lParam);
 132             }
 133             break;
 134 
 135             // a JavaAccessBridge DLL is going away
 136         case AB_DLL_GOING_AWAY:
 137             PrintDebugString("In AccessBridgeDialog - Got AB_DLL_GOING_AWAY message");
 138             theJavaAccessBridge->WindowsATDestroyed((HWND) wParam);
 139             break;
 140 
 141         default:
 142             // the Windows AT is saying "hi"!
 143             // wParam == sourceHwnc; lParam unused
 144             if (message == theFromWindowsHelloMsgID) {
 145                 // A new Windows AT just said "hi";
 146                 // say "hi" back so it can mate up with us
 147                 // otherwise don't do anything (e.g. don't set up data structures yet)
 148                 PrintDebugString("In AccessBridgeDialog - Got theFromWindowsHelloMsgID message");
 149                 theJavaAccessBridge->postHelloToWindowsDLLMsg((HWND) wParam);
 150             }
 151         }
 152         return FALSE;
 153     }
 154 
 155 }
 156 
 157 
 158 // -----------------------------
 159 
 160 
 161 /**
 162  * Initialize the JavaAccessBridge
 163  *
 164  */
 165 JavaAccessBridge::JavaAccessBridge(HINSTANCE hInstance) {
 166     windowsInstance = hInstance;
 167     ATs = (AccessBridgeATInstance *) 0;

 168     initBroadcastMessageIDs();          // get the unique to us broadcast msg. IDs
 169 }
 170 
 171 extern DWORD JavaBridgeThreadId;
 172 
 173 /**
 174  * Destroy the JavaAccessBridge
 175  *
 176  */
 177 JavaAccessBridge::~JavaAccessBridge() {
 178     // inform all other AccessBridges that we're going away
 179 
 180     PrintDebugString("\r\nin JavaAccessBridge::~JavaAccessBridge()");
 181 
 182     // Send a shutdown message for those applications like StarOffice that do
 183     // send a shutdown message themselves.
 184     javaShutdown(NULL, 0);
 185 
 186     AccessBridgeATInstance *current = ATs;
 187     while (current != (AccessBridgeATInstance *) 0) {
 188         PrintDebugString("  telling %p we're going away", current->winAccessBridgeWindow);
 189                 SendMessage(current->winAccessBridgeWindow,
 190                     AB_DLL_GOING_AWAY, (WPARAM) dialogWindow, (LPARAM) 0);
 191         current = current->nextATInstance;
 192     }
 193 
 194     PrintDebugString("  finished telling ATs about our demise");
 195 
 196         if(JavaBridgeThreadId)
 197                 {
 198                 PostThreadMessage(JavaBridgeThreadId,WM_USER+1,0,0);
 199                 Sleep(100);
 200                 }
 201 
 202     delete ATs;
 203 
 204     PrintDebugString("  finished deleting ATs");
 205     PrintDebugString("GOODBYE CRUEL WORLD...");

 206 }
 207 
 208 
 209 void
 210 JavaAccessBridge::javaRun(JNIEnv *env, jobject obj) {
 211     MSG msg;
 212 
 213     PrintDebugString("JavaAccessBridge::javaRun(%p, %p) called", env, obj);
 214 
 215     if (env->GetJavaVM(&javaVM) != 0) {
 216         return; // huh!?!?!
 217     }
 218     PrintDebugString("  -> javaVM = %p", javaVM);
 219 
 220     if (javaVM->AttachCurrentThread((void **) &windowsThreadJNIEnv, NULL) != 0) {
 221         return; // huh!?!?!
 222     }
 223     PrintDebugString("  -> windowsThreadJNIEnv = %p", windowsThreadJNIEnv);
 224 
 225     javaThreadABObject = env->NewGlobalRef(obj);
 226     windowsThreadABObject = windowsThreadJNIEnv->NewGlobalRef(obj);
 227 
 228     // initialize the Java thread AccessBridge entry points
 229     javaThreadEntryPoints = new AccessBridgeJavaEntryPoints(env, javaThreadABObject);
 230     if (javaThreadEntryPoints->BuildJavaEntryPoints() == FALSE) {
 231         return;         // couldn't build our entry points; let's get out of here!
 232     }
 233     PrintDebugString("  all Java thread entry points successfully found.");
 234 
 235     // initialize the Windows thread AccessBridge entry points
 236     windowsThreadEntryPoints = new AccessBridgeJavaEntryPoints(windowsThreadJNIEnv,
 237                                                                windowsThreadABObject);
 238     if (windowsThreadEntryPoints->BuildJavaEntryPoints() == FALSE) {
 239         return;         // couldn't build our entry points; let's get out of here!
 240     }
 241     PrintDebugString("  all Windows thread entry points successfully found.");
 242 
 243 
 244     // open our window
 245     if (initWindow() == TRUE) {
 246         PrintDebugString("  Window created.  HWND = %p", dialogWindow);
 247 
 248         // post a broadcast msg.; let other AccessBridge DLLs know we exist
 249         postHelloToWindowsDLLMsg(HWND_BROADCAST);
 250 
 251         // do that message loop thing
 252         while (GetMessage(&msg, NULL, 0, 0)) {
 253             TranslateMessage(&msg);
 254             DispatchMessage(&msg);
 255         }
 256     } else {
 257         PrintDebugString("  FAILED TO CREATE WINDOW!!!");
 258     }
 259 
 260     javaVM->DetachCurrentThread();
 261 }
 262 
 263 /**
 264  * Bring up our window; make a connection to the rest of the world
 265  *
 266  */
 267 BOOL
 268 JavaAccessBridge::initWindow() {
 269     theDialogWindow = CreateDialog(windowsInstance,
 270                                    "ACCESSBRIDGESTATUSWINDOW", NULL,
 271                                    (DLGPROC) AccessBridgeDialogProc);
 272 
 273     // If window could not be created, return "failure".
 274     if (!theDialogWindow)
 275         return FALSE;
 276 
 277     dialogWindow = theDialogWindow;


 284 }
 285 
 286 
 287 
 288 // -----------------------
 289 
 290 
 291 /**
 292  * postHelloToWindowsDLLMsg
 293  *          - PostMessage(theFromJavaHelloMsgID) to let one or
 294  *            all WindowDLLs we're here and have a vmID
 295  *
 296  *            destHwnd is either a single hwnd or HWND_BROADCAST
 297  *              (former if a reply, latter if we're just born)
 298  *            wParam is our HWND
 299  *            lParam is our vmID
 300  *
 301  */
 302 void
 303 JavaAccessBridge::postHelloToWindowsDLLMsg(HWND destHwnd) {
 304     PrintDebugString("\r\nIn JavaAccessBridge::postHelloToWindowsDLLMsg");
 305     PrintDebugString("  calling PostMessage(%p, %X, %p, %p)",
 306                      destHwnd, theFromJavaHelloMsgID, dialogWindow, dialogWindow);
 307     PostMessage(destHwnd, theFromJavaHelloMsgID, (WPARAM) dialogWindow, (LPARAM) dialogWindow);
 308 }
 309 
 310 
 311 // -----------------------
 312 
 313 /**
 314  * sendPackage - uses SendMessage(WM_COPYDATA) to do IPC messaging
 315  *                                with the Java AccessBridge DLL
 316  *
 317  */
 318 void
 319 JavaAccessBridge::sendPackage(char *buffer, int bufsize, HWND destHwnd) {
 320     COPYDATASTRUCT toCopy;
 321     toCopy.dwData = 0;          // 32-bits we could use for something...
 322     toCopy.cbData = bufsize;
 323     toCopy.lpData = buffer;
 324 
 325     SendMessage(destHwnd, WM_COPYDATA, (WPARAM) dialogWindow, (LPARAM) &toCopy);
 326 }
 327 
 328 
 329 /**
 330  * sendJavaEventPackage - walk through ATs, sending event messages to 'em
 331  *
 332  */
 333 void
 334 JavaAccessBridge::sendJavaEventPackage(char *buffer, int bufsize, long type) {
 335 
 336     PrintDebugString("JavaAccessBridge::sendJavaEventPackage(), type = %X", type);
 337 
 338     if (ATs == (AccessBridgeATInstance *) 0) {
 339         PrintDebugString("  ERROR!! ATs == 0! (shouldn't happen here!)");
 340     }
 341 
 342     AccessBridgeATInstance *ati = ATs;
 343     while (ati != (AccessBridgeATInstance *) 0) {
 344         ati->sendJavaEventPackage(buffer, bufsize, type);
 345         ati = ati->nextATInstance;
 346     }
 347 }
 348 
 349 /**
 350  * sendAccessibilityEventPackage - walk through ATs, sending event messages to 'em
 351  *
 352  */
 353 void
 354 JavaAccessBridge::sendAccessibilityEventPackage(char *buffer, int bufsize, long type) {
 355 
 356     PrintDebugString("JavaAccessBridge::sendAccessibilityEventPackage(), type = %X", type);
 357 
 358     if (ATs == (AccessBridgeATInstance *) 0) {
 359         PrintDebugString("  ERROR!! ATs == 0! (shouldn't happen here!)");
 360     }
 361 
 362     AccessBridgeATInstance *ati = ATs;
 363     while (ati != (AccessBridgeATInstance *) 0) {
 364         ati->sendAccessibilityEventPackage(buffer, bufsize, type);
 365         ati = ati->nextATInstance;
 366     }
 367 }
 368 
 369 
 370 
 371 
 372 /**
 373  * receiveMemoryPackage - uses Memory-Mapped files to do IPC messaging
 374  *                        with the Java AccessBridge DLL, receiving the
 375  *                        message from Java AccessBridge DLL by reading the
 376  *                        contents of the shared memory mapped file that
 377  *                        is used for Java-initiated messages
 378  *
 379  */
 380 BOOL
 381 JavaAccessBridge::receiveMemoryPackage(HWND srcWindow, long bufsize) {
 382     char *IPCview;
 383 
 384     PrintDebugString("\r\nJavaAccessBridge::receiveMemoryPackage(%p, %d)", srcWindow, bufsize);
 385 
 386     // look-up the appropriate IPCview based on the srcHWND of the Windows AccessBridge DLL
 387     if (ATs == (AccessBridgeATInstance *) 0) {
 388         PrintDebugString("  ERROR! - ATs == 0 (shouldn't happen in receiveMemoryPackage()!");
 389         return FALSE;
 390     }
 391     AccessBridgeATInstance *ati = ATs->findABATInstanceFromATHWND(srcWindow);
 392     if (ati != (AccessBridgeATInstance *) 0) {
 393         IPCview = (char *) ati->memoryMappedView;
 394 
 395         // wait for the lock if someone else has it (re-entrancy)
 396         EnterCriticalSection(&receiveMemoryIPCLock);
 397         {
 398             // set byte at end of buffer to indicate to caller that we have reached this point
 399             IPCview[bufsize] = 1;
 400 
 401             // process the package
 402             processPackage(IPCview, bufsize);
 403         }
 404         // release re-entrance lock
 405         LeaveCriticalSection(&receiveMemoryIPCLock);
 406 
 407         return TRUE;
 408 
 409     } else {
 410         //DEBUG_CODE(AppendToCallInfo("ERROR receiving memory package: couldn't find srcWindow"));
 411         PrintDebugString("ERROR receiving memory package: couldn't find srcWindow");
 412         return FALSE;
 413     }
 414 }
 415 
 416 /**
 417  * processPackage - processes the output of SendMessage(WM_COPYDATA)
 418  *                                      to do IPC messaging with the Windows AccessBridge DLL
 419  *
 420  */
 421 LRESULT
 422 JavaAccessBridge::processPackage(char *buffer, int bufsize) {
 423     PrintDebugString("\r\nProcessing package sent from Windows, bufsize = %d:", bufsize);
 424 
 425     PackageType *type = (PackageType *) buffer;
 426     LRESULT returnVal = 0;
 427     PrintDebugString("  PackageType = %X:", *type);
 428     jobject rAC;
 429 
 430     switch (*type) {
 431 
 432 
 433     case cMemoryMappedFileCreatedPackage:
 434         // Windows is telling us it created a memory mapped file for us to use
 435         // in repsonding to various information querying packages (see below)
 436         PrintDebugString("   type == cMemoryMappedFileCreatedPackage");
 437         if (bufsize == (sizeof(PackageType) + sizeof(MemoryMappedFileCreatedPackage))) {
 438             MemoryMappedFileCreatedPackage *pkg =
 439                 (MemoryMappedFileCreatedPackage *) (buffer + sizeof(PackageType));
 440             returnVal = MemoryMappedFileCreated((HWND)ABLongToHandle(pkg->bridgeWindow), pkg->filename);
 441         } else {
 442             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
 443                              bufsize, sizeof(PackageType) + sizeof(MemoryMappedFileCreatedPackage));
 444         }
 445         break;
 446 
 447         // ------------ information querying packages ------------------
 448 
 449     case cReleaseJavaObjectPackage:
 450         PrintDebugString("   type == cReleaseJavaObjectPackage");
 451         if (bufsize == (sizeof(PackageType) + sizeof(ReleaseJavaObjectPackage))) {
 452             ReleaseJavaObjectPackage *pkg =
 453                 (ReleaseJavaObjectPackage *) (buffer + sizeof(PackageType));
 454             releaseJavaObject((jobject)pkg->object);
 455         } else {
 456             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
 457                              bufsize, sizeof(PackageType) + sizeof(ReleaseJavaObjectPackage));
 458         }
 459         break;
 460 
 461     case cGetAccessBridgeVersionPackage:
 462         PrintDebugString("   type == cGetAccessBridgeVersionPackage");
 463         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessBridgeVersionPackage))) {
 464             GetAccessBridgeVersionPackage *pkg =
 465                 (GetAccessBridgeVersionPackage *) (buffer + sizeof(PackageType));
 466             windowsThreadEntryPoints->getVersionInfo(&(pkg->rVersionInfo));
 467         } else {
 468             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
 469                              bufsize, sizeof(PackageType) + sizeof(GetAccessBridgeVersionPackage));
 470         }
 471         break;
 472 
 473     case cIsJavaWindowPackage:
 474         PrintDebugString("   type == cIsJavaWindowPackage");
 475         if (bufsize == (sizeof(PackageType) + sizeof(IsJavaWindowPackage))) {
 476             IsJavaWindowPackage *pkg =
 477                 (IsJavaWindowPackage *) (buffer + sizeof(PackageType));
 478             pkg->rResult =
 479                 windowsThreadEntryPoints->isJavaWindow(pkg->window);
 480             PrintDebugString("     -> returning result = %d", pkg->rResult);
 481         } else {
 482             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
 483                              bufsize, sizeof(PackageType) + sizeof(IsJavaWindowPackage));
 484         }
 485         break;
 486 
 487     case cIsSameObjectPackage:
 488         PrintDebugString("   type == cIsSameObjectPackage");
 489         if (bufsize == (sizeof(PackageType) + sizeof(IsSameObjectPackage))) {
 490             IsSameObjectPackage *pkg =
 491                 (IsSameObjectPackage *) (buffer + sizeof(PackageType));
 492             pkg->rResult =
 493                 windowsThreadEntryPoints->isSameObject((jobject)pkg->obj1, (jobject)pkg->obj2);
 494             PrintDebugString("     -> returning result = %d", pkg->rResult);
 495         } else {
 496             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
 497                              bufsize, sizeof(PackageType) + sizeof(IsSameObjectPackage));
 498         }
 499         break;
 500 
 501 
 502     case cGetAccessibleContextFromHWNDPackage:
 503         PrintDebugString("   type == cGetAccessibleContextFromHWNDPackage");
 504         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleContextFromHWNDPackage))) {
 505             GetAccessibleContextFromHWNDPackage *pkg =
 506                 (GetAccessibleContextFromHWNDPackage *) (buffer + sizeof(PackageType));
 507             rAC = windowsThreadEntryPoints->getAccessibleContextFromHWND(pkg->window);
 508             pkg->rAccessibleContext = (JOBJECT64)rAC;
 509             pkg->rVMID = HandleToLong(dialogWindow);
 510             PrintDebugString("     -> returning AC = %p, vmID = %X", rAC, pkg->rVMID);
 511         } else {
 512             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
 513                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleContextFromHWNDPackage));
 514         }
 515         break;
 516 
 517 
 518     case cGetHWNDFromAccessibleContextPackage:
 519         PrintDebugString("   type == cGetHWNDFromAccessibleContextPackage");
 520         if (bufsize == (sizeof(PackageType) + sizeof(GetHWNDFromAccessibleContextPackage))) {
 521             GetHWNDFromAccessibleContextPackage *pkg =
 522                 (GetHWNDFromAccessibleContextPackage *) (buffer + sizeof(PackageType));
 523             pkg->rHWND =
 524                 ABHandleToLong( windowsThreadEntryPoints->getHWNDFromAccessibleContext((jobject)pkg->accessibleContext) );
 525             PrintDebugString("     -> returning HWND = %p", pkg->rHWND);
 526         } else {
 527             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
 528                              bufsize, sizeof(PackageType) + sizeof(GetHWNDFromAccessibleContextPackage));
 529         }
 530         break;
 531 
 532 
 533         /* ===== utility methods ===== */
 534 
 535     case cSetTextContentsPackage:
 536         PrintDebugString("   type == cSetTextContentsPackage");
 537         if (bufsize == (sizeof(PackageType) + sizeof(SetTextContentsPackage))) {
 538             SetTextContentsPackage *pkg =
 539                 (SetTextContentsPackage *) (buffer + sizeof(PackageType));
 540             pkg->rResult =
 541                 windowsThreadEntryPoints->setTextContents((jobject)pkg->accessibleContext, pkg->text);
 542             PrintDebugString("     -> returning result = %d", pkg->rResult);
 543         } else {
 544             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
 545                              bufsize, sizeof(PackageType) + sizeof(SetTextContentsPackage));
 546         }
 547         break;
 548 
 549     case cGetParentWithRolePackage:
 550         if (bufsize == (sizeof(PackageType) + sizeof(GetParentWithRolePackage))) {
 551             GetParentWithRolePackage *pkg =
 552                 (GetParentWithRolePackage *) (buffer + sizeof(PackageType));
 553             rAC = windowsThreadEntryPoints->getParentWithRole((jobject)pkg->accessibleContext, pkg->role);
 554             pkg->rAccessibleContext = (JOBJECT64)rAC;
 555             PrintDebugString("   type == cGetParentWithRolePackage");
 556             PrintDebugString("     pkg->vmID: %X", pkg->vmID);
 557             PrintDebugString("     pkg->accessibleContext: %p", (jobject)pkg->accessibleContext);
 558             PrintDebugString("     pkg->role: %ls", pkg->role);
 559             PrintDebugString("     -> returning rAccessibleContext = %p", rAC);

 560         } else {
 561             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
 562                              bufsize, sizeof(PackageType) + sizeof(GetParentWithRolePackage));
 563         }
 564         break;
 565 
 566     case cGetTopLevelObjectPackage:
 567         PrintDebugString("   type == cGetTopLevelObjectPackage");
 568         if (bufsize == (sizeof(PackageType) + sizeof(GetTopLevelObjectPackage))) {
 569             GetTopLevelObjectPackage *pkg =
 570                 (GetTopLevelObjectPackage *) (buffer + sizeof(PackageType));
 571             rAC = windowsThreadEntryPoints->getTopLevelObject((jobject)pkg->accessibleContext);
 572             pkg->rAccessibleContext = (JOBJECT64)rAC;
 573             PrintDebugString("     -> returning rAccessibleContext = %p", rAC);
 574         } else {
 575             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
 576                              bufsize, sizeof(PackageType) + sizeof(GetTopLevelObjectPackage));
 577         }
 578         break;
 579 
 580     case cGetParentWithRoleElseRootPackage:
 581         PrintDebugString("   type == cGetParentWithRoleElseRootPackage");
 582         if (bufsize == (sizeof(PackageType) + sizeof(GetParentWithRoleElseRootPackage))) {
 583             GetParentWithRoleElseRootPackage *pkg =
 584                 (GetParentWithRoleElseRootPackage *) (buffer + sizeof(PackageType));
 585             rAC = windowsThreadEntryPoints->getParentWithRoleElseRoot((jobject)pkg->accessibleContext, pkg->role);
 586             pkg->rAccessibleContext = (JOBJECT64)rAC;
 587             PrintDebugString("     -> returning rAccessibleContext = %p", rAC);
 588         } else {
 589             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
 590                              bufsize, sizeof(PackageType) + sizeof(GetParentWithRoleElseRootPackage));
 591         }
 592         break;
 593 
 594     case cGetObjectDepthPackage:
 595         PrintDebugString("   type == cGetObjectDepthPackage");
 596         if (bufsize == (sizeof(PackageType) + sizeof(GetObjectDepthPackage))) {
 597             GetObjectDepthPackage *pkg =
 598                 (GetObjectDepthPackage *) (buffer + sizeof(PackageType));
 599             pkg->rResult =
 600                 windowsThreadEntryPoints->getObjectDepth((jobject)pkg->accessibleContext);
 601             PrintDebugString("     -> returning rResult = %d", pkg->rResult);
 602         } else {
 603             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
 604                              bufsize, sizeof(PackageType) + sizeof(GetObjectDepthPackage));
 605         }
 606         break;
 607 
 608     case cGetActiveDescendentPackage:
 609         PrintDebugString("   type == cGetActiveDescendentPackage");
 610         if (bufsize == (sizeof(PackageType) + sizeof(GetActiveDescendentPackage))) {
 611             GetActiveDescendentPackage *pkg =
 612                 (GetActiveDescendentPackage *) (buffer + sizeof(PackageType));
 613             rAC = windowsThreadEntryPoints->getActiveDescendent((jobject)pkg->accessibleContext);
 614             pkg->rAccessibleContext = (JOBJECT64)rAC;
 615             PrintDebugString("     -> returning rAccessibleContext = %p", rAC);
 616         } else {
 617             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
 618                              bufsize, sizeof(PackageType) + sizeof(GetActiveDescendentPackage));
 619         }
 620         break;
 621 
 622     case cGetAccessibleContextAtPackage:
 623         PrintDebugString("   type == cGetAccessibleContextAtPackage");
 624         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleContextAtPackage))) {
 625             GetAccessibleContextAtPackage *pkg =
 626                 (GetAccessibleContextAtPackage *) (buffer + sizeof(PackageType));
 627             pkg->rAccessibleContext = (JOBJECT64)
 628                 windowsThreadEntryPoints->getAccessibleContextAt(pkg->x, pkg->y,
 629                                                                  (jobject)pkg->AccessibleContext);
 630         } else {
 631             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
 632                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleContextAtPackage));
 633         }
 634         break;
 635 
 636     case cGetAccessibleContextWithFocusPackage:
 637         PrintDebugString("   type == cGetAccessibleContextWithFocusPackage");
 638         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleContextWithFocusPackage))) {
 639             GetAccessibleContextWithFocusPackage *pkg =
 640                 (GetAccessibleContextWithFocusPackage *) (buffer + sizeof(PackageType));
 641             pkg->rAccessibleContext = (JOBJECT64)
 642                 windowsThreadEntryPoints->getAccessibleContextWithFocus();
 643                         pkg->rVMID =  HandleToLong(dialogWindow);
 644         } else {
 645             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
 646                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleContextWithFocusPackage));
 647         }
 648         break;
 649 
 650     case cGetAccessibleContextInfoPackage:
 651         PrintDebugString("   type == cGetAccessibleContextInfoPackage");
 652         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleContextInfoPackage))) {
 653             GetAccessibleContextInfoPackage *pkg =
 654                 (GetAccessibleContextInfoPackage *) (buffer + sizeof(PackageType));
 655             windowsThreadEntryPoints->getAccessibleContextInfo(
 656                                                                (jobject)pkg->AccessibleContext, &(pkg->rAccessibleContextInfo));
 657         } else {
 658             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
 659                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleContextInfoPackage));
 660         }
 661         break;
 662 
 663     case cGetAccessibleChildFromContextPackage:
 664         PrintDebugString("   type == cGetAccessibleChildFromContextPackage");
 665         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleChildFromContextPackage))) {
 666             GetAccessibleChildFromContextPackage *pkg =
 667                 (GetAccessibleChildFromContextPackage *) (buffer + sizeof(PackageType));
 668             pkg->rAccessibleContext = (JOBJECT64)windowsThreadEntryPoints->getAccessibleChildFromContext(
 669                                                                                               (jobject)pkg->AccessibleContext, pkg->childIndex);
 670         } else {
 671             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
 672                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleChildFromContextPackage));
 673         }
 674         break;
 675 
 676     case cGetAccessibleParentFromContextPackage:
 677         PrintDebugString("   type == cGetAccessibleParentFromContextPackage");
 678         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleParentFromContextPackage))) {
 679             GetAccessibleParentFromContextPackage *pkg =
 680                 (GetAccessibleParentFromContextPackage *) (buffer + sizeof(PackageType));
 681             pkg->rAccessibleContext = (JOBJECT64)windowsThreadEntryPoints->getAccessibleParentFromContext(
 682                                                                                                (jobject)pkg->AccessibleContext);
 683         } else {
 684             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
 685                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleParentFromContextPackage));
 686         }
 687         break;
 688 
 689         // ------------ begin AccessibleTable packages ------------------
 690 
 691     case cGetAccessibleTableInfoPackage:
 692         PrintDebugString("   ##### type == cGetAccessibleTableInfoPackage");
 693         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableInfoPackage))) {
 694             GetAccessibleTableInfoPackage *pkg =
 695                 (GetAccessibleTableInfoPackage *) (buffer + sizeof(PackageType));
 696             windowsThreadEntryPoints->getAccessibleTableInfo((jobject)pkg->accessibleContext,
 697                                                              &(pkg->rTableInfo));
 698             PrintDebugString("   ##### processing succeeded");
 699         } else {
 700             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 701                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableInfoPackage));
 702         }
 703         break;
 704 
 705     case cGetAccessibleTableCellInfoPackage:
 706         PrintDebugString("   ##### type == cGetAccessibleTableCellInfoPackage");
 707         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableCellInfoPackage))) {
 708             GetAccessibleTableCellInfoPackage *pkg =
 709                 (GetAccessibleTableCellInfoPackage *) (buffer + sizeof(PackageType));
 710             windowsThreadEntryPoints->getAccessibleTableCellInfo((jobject)pkg->accessibleTable, pkg->row,
 711                                                                  pkg->column, &(pkg->rTableCellInfo));
 712             PrintDebugString("   ##### processing succeeded");
 713         } else {
 714             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 715                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableCellInfoPackage));
 716         }
 717         break;
 718 
 719     case cGetAccessibleTableRowHeaderPackage:
 720         PrintDebugString("   ##### type == cGetAccessibleTableRowHeaderPackage");
 721         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableRowHeaderPackage))) {
 722             GetAccessibleTableRowHeaderPackage *pkg =
 723                 (GetAccessibleTableRowHeaderPackage *) (buffer + sizeof(PackageType));
 724             windowsThreadEntryPoints->getAccessibleTableRowHeader((jobject)pkg->accessibleContext,
 725                                                                   &(pkg->rTableInfo));
 726             PrintDebugString("   ##### processing succeeded");
 727         } else {
 728             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 729                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableRowHeaderPackage));
 730         }
 731         break;
 732 
 733     case cGetAccessibleTableColumnHeaderPackage:
 734         PrintDebugString("   ##### type == cGetAccessibleTableColumnHeaderPackage");
 735         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableColumnHeaderPackage))) {
 736             GetAccessibleTableColumnHeaderPackage *pkg =
 737                 (GetAccessibleTableColumnHeaderPackage *) (buffer + sizeof(PackageType));
 738             windowsThreadEntryPoints->getAccessibleTableColumnHeader((jobject)pkg->accessibleContext,
 739                                                                      &(pkg->rTableInfo));
 740             PrintDebugString("   ##### processing succeeded");
 741         } else {
 742             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 743                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableColumnHeaderPackage));
 744         }
 745         break;
 746 
 747 
 748     case cGetAccessibleTableRowDescriptionPackage:
 749         PrintDebugString("   ##### type == cGetAccessibleTableRowDescriptionPackage");
 750         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableRowDescriptionPackage))) {
 751             GetAccessibleTableRowDescriptionPackage *pkg =
 752                 (GetAccessibleTableRowDescriptionPackage *) (buffer + sizeof(PackageType));
 753             pkg->rAccessibleContext = (JOBJECT64)windowsThreadEntryPoints->getAccessibleTableRowDescription(
 754                                                                                                  (jobject)pkg->accessibleContext, pkg->row);
 755             PrintDebugString("   ##### processing succeeded");
 756         } else {
 757             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 758                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableRowDescriptionPackage));
 759         }
 760         break;
 761 
 762     case cGetAccessibleTableColumnDescriptionPackage:
 763         PrintDebugString("   ##### type == cGetAccessibleTableColumnDescriptionPackage");
 764         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableColumnDescriptionPackage))) {
 765             GetAccessibleTableColumnDescriptionPackage *pkg =
 766                 (GetAccessibleTableColumnDescriptionPackage *) (buffer + sizeof(PackageType));
 767             pkg->rAccessibleContext = (JOBJECT64)windowsThreadEntryPoints->getAccessibleTableColumnDescription(
 768                                                                                                     (jobject)pkg->accessibleContext, pkg->column);
 769             PrintDebugString("   ##### processing succeeded");
 770         } else {
 771             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 772                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableColumnDescriptionPackage));
 773         }
 774         break;
 775 
 776     case cGetAccessibleTableColumnSelectionCountPackage:
 777         PrintDebugString("   ##### type == cGetAccessibleTableColumnSelectionCountPackage");
 778         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableColumnSelectionCountPackage))) {
 779             GetAccessibleTableColumnSelectionCountPackage *pkg =
 780                 (GetAccessibleTableColumnSelectionCountPackage *) (buffer + sizeof(PackageType));
 781             pkg->rCount = windowsThreadEntryPoints->getAccessibleTableColumnSelectionCount(
 782                                                                                            (jobject)pkg->accessibleTable);
 783             PrintDebugString("   ##### processing succeeded");
 784         } else {
 785             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 786                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableColumnSelectionCountPackage));
 787         }
 788         break;
 789 
 790     case cGetAccessibleTableRowSelectionCountPackage:
 791         PrintDebugString("   ##### type == cGetAccessibleTableRowSelectionCountPackage");
 792         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableRowSelectionCountPackage))) {
 793             GetAccessibleTableRowSelectionCountPackage *pkg =
 794                 (GetAccessibleTableRowSelectionCountPackage *) (buffer + sizeof(PackageType));
 795 
 796             pkg->rCount = windowsThreadEntryPoints->getAccessibleTableRowSelectionCount(
 797                                                                                         (jobject)pkg->accessibleTable);
 798 
 799             PrintDebugString("   ##### processing succeeded");
 800         } else {
 801             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 802                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableRowSelectionCountPackage));
 803         }
 804         break;
 805 
 806     case cIsAccessibleTableRowSelectedPackage:
 807         PrintDebugString("   ##### type == cIsAccessibleTableRowSelectedPackage");
 808         if (bufsize == (sizeof(PackageType) + sizeof(IsAccessibleTableRowSelectedPackage))) {
 809             IsAccessibleTableRowSelectedPackage *pkg =
 810                 (IsAccessibleTableRowSelectedPackage *) (buffer + sizeof(PackageType));
 811             pkg->rResult = windowsThreadEntryPoints->isAccessibleTableRowSelected(
 812                                                                                   (jobject)pkg->accessibleTable, pkg->row);
 813             PrintDebugString("   ##### processing succeeded");
 814         } else {
 815             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 816                              bufsize, sizeof(PackageType) + sizeof(IsAccessibleTableRowSelectedPackage));
 817         }
 818         break;
 819 
 820     case cIsAccessibleTableColumnSelectedPackage:
 821         PrintDebugString("   ##### type == cIsAccessibleTableColumnSelectedPackage");
 822         if (bufsize == (sizeof(PackageType) + sizeof(IsAccessibleTableColumnSelectedPackage))) {
 823             IsAccessibleTableColumnSelectedPackage *pkg =
 824                 (IsAccessibleTableColumnSelectedPackage *) (buffer + sizeof(PackageType));
 825             pkg->rResult = windowsThreadEntryPoints->isAccessibleTableColumnSelected(
 826                                                                                      (jobject)pkg->accessibleTable, pkg->column);
 827             PrintDebugString("   ##### processing succeeded");
 828         } else {
 829             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 830                              bufsize, sizeof(PackageType) + sizeof(IsAccessibleTableColumnSelectedPackage));
 831         }
 832         break;
 833 
 834     case cGetAccessibleTableColumnSelectionsPackage:
 835         PrintDebugString("   ##### type == cGetAccessibleTableColumnSelectionsPackage");
 836         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableColumnSelectionsPackage))) {
 837             GetAccessibleTableColumnSelectionsPackage *pkg =
 838                 (GetAccessibleTableColumnSelectionsPackage *) (buffer + sizeof(PackageType));
 839             PrintDebugString("     ##### cGetAccessibleTableColumnSelectionsPackage count=%d", pkg->count);
 840             windowsThreadEntryPoints->getAccessibleTableColumnSelections(
 841                                                                          (jobject)pkg->accessibleTable, pkg->count, pkg->rSelections);
 842 
 843             for (int i = 0; i < pkg->count; i++) {
 844                 PrintDebugString("     ##### cGetAccessibleTableColumnSelectionsPackage(%d)=%d", i, pkg->rSelections[i]);
 845             }
 846 
 847             PrintDebugString("   ##### processing succeeded");
 848         } else {
 849             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 850                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableColumnSelectionsPackage));
 851         }
 852         break;
 853 
 854 
 855     case cGetAccessibleTableRowSelectionsPackage:
 856         PrintDebugString("   ##### type == cGetAccessibleTableRowSelectionsPackage");
 857         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableRowSelectionsPackage))) {
 858             GetAccessibleTableRowSelectionsPackage *pkg =
 859                 (GetAccessibleTableRowSelectionsPackage *) (buffer + sizeof(PackageType));
 860             windowsThreadEntryPoints->getAccessibleTableRowSelections(
 861                                                                       (jobject)pkg->accessibleTable, pkg->count, pkg->rSelections);
 862             PrintDebugString("   ##### processing succeeded");
 863         } else {
 864             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 865                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableRowSelectionsPackage));
 866         }
 867         break;
 868 
 869     case cGetAccessibleTableRowPackage:
 870         PrintDebugString("   ##### type == cGetAccessibleTableRowPackage");
 871         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableRowPackage))) {
 872             GetAccessibleTableRowPackage *pkg =
 873                 (GetAccessibleTableRowPackage *) (buffer + sizeof(PackageType));
 874             pkg->rRow = windowsThreadEntryPoints->getAccessibleTableRow(
 875                                                                         (jobject)pkg->accessibleTable, pkg->index);
 876             PrintDebugString("   ##### processing succeeded");
 877         } else {
 878             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 879                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableRowPackage));
 880         }
 881         break;
 882 
 883     case cGetAccessibleTableColumnPackage:
 884         PrintDebugString("   ##### type == cGetAccessibleTableColumnPackage");
 885         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableColumnPackage))) {
 886             GetAccessibleTableColumnPackage *pkg =
 887                 (GetAccessibleTableColumnPackage *) (buffer + sizeof(PackageType));
 888             pkg->rColumn = windowsThreadEntryPoints->getAccessibleTableColumn(
 889                                                                               (jobject)pkg->accessibleTable, pkg->index);
 890             PrintDebugString("   ##### processing succeeded");
 891         } else {
 892             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 893                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableColumnPackage));
 894         }
 895         break;
 896 
 897     case cGetAccessibleTableIndexPackage:
 898         PrintDebugString("   ##### type == cGetAccessibleTableIndexPackage");
 899         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableIndexPackage))) {
 900             GetAccessibleTableIndexPackage *pkg =
 901                 (GetAccessibleTableIndexPackage *) (buffer + sizeof(PackageType));
 902             pkg->rIndex = windowsThreadEntryPoints->getAccessibleTableIndex(
 903                                                                             (jobject)pkg->accessibleTable, pkg->row, pkg->column);
 904             PrintDebugString("   ##### processing succeeded");
 905         } else {
 906             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 907                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableIndexPackage));
 908         }
 909         break;
 910 
 911         // ------------ end AccessibleTable packages ------------------
 912 
 913 
 914         // ------------ begin AccessibleRelationSet packages ------------------
 915 
 916     case cGetAccessibleRelationSetPackage:
 917         PrintDebugString("   ##### type == cGetAccessibleRelationSetPackage");
 918         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleRelationSetPackage))) {
 919             GetAccessibleRelationSetPackage *pkg =
 920                 (GetAccessibleRelationSetPackage *) (buffer + sizeof(PackageType));
 921             windowsThreadEntryPoints->getAccessibleRelationSet(
 922                                                                (jobject)pkg->accessibleContext, &(pkg->rAccessibleRelationSetInfo));
 923             PrintDebugString("   ##### processing succeeded");
 924         } else {
 925             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 926                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleRelationSetPackage));
 927         }
 928         break;
 929 
 930         // ------------ end AccessibleRelationSet packages ------------------
 931 
 932         // ------------ begin AccessibleHypertext packages ------------------
 933 
 934     case cGetAccessibleHypertextPackage:
 935         PrintDebugString("   ##### type == cGetAccessibleHypertextPackage");
 936         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleHypertextPackage))) {
 937             GetAccessibleHypertextPackage *pkg =
 938                 (GetAccessibleHypertextPackage *) (buffer + sizeof(PackageType));
 939             windowsThreadEntryPoints->getAccessibleHypertext(
 940                                                              (jobject)pkg->accessibleContext, &(pkg->rAccessibleHypertextInfo));
 941             PrintDebugString("   ##### processing succeeded");
 942         } else {
 943             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 944                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleHypertextPackage));
 945         }
 946         break;
 947 
 948     case cActivateAccessibleHyperlinkPackage:
 949         PrintDebugString("   ##### type == cActivateAccessibleHyperlinkPackage");
 950         if (bufsize == (sizeof(PackageType) + sizeof(ActivateAccessibleHyperlinkPackage))) {
 951             ActivateAccessibleHyperlinkPackage *pkg =
 952                 (ActivateAccessibleHyperlinkPackage *) (buffer + sizeof(PackageType));
 953             pkg->rResult = windowsThreadEntryPoints->activateAccessibleHyperlink(
 954                                                                                  (jobject)pkg->accessibleContext, (jobject)pkg->accessibleHyperlink);
 955             PrintDebugString("   ##### processing succeeded");
 956         } else {
 957             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 958                              bufsize, sizeof(PackageType) + sizeof(ActivateAccessibleHyperlinkPackage));
 959         }
 960         break;
 961 
 962     case cGetAccessibleHyperlinkCountPackage:
 963         PrintDebugString("   ##### type == cGetAccessibleHyperlinkCountPackage");
 964         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleHyperlinkCountPackage))) {
 965             GetAccessibleHyperlinkCountPackage *pkg =
 966                 (GetAccessibleHyperlinkCountPackage *) (buffer + sizeof(PackageType));
 967             pkg->rLinkCount = windowsThreadEntryPoints->getAccessibleHyperlinkCount(
 968                                                                                     (jobject)pkg->accessibleContext);
 969             PrintDebugString("   ##### processing succeeded: pkg->rLinkCount = %d", pkg->rLinkCount);
 970         } else {
 971             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 972                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleHyperlinkCountPackage));
 973         }
 974         break;
 975 
 976     case cGetAccessibleHypertextExtPackage:
 977         PrintDebugString("   ##### type == cGetAccessibleHypertextExtPackage");
 978         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleHypertextExtPackage))) {
 979             GetAccessibleHypertextExtPackage *pkg =
 980                 (GetAccessibleHypertextExtPackage *) (buffer + sizeof(PackageType));
 981             pkg->rSuccess = windowsThreadEntryPoints->getAccessibleHypertextExt(
 982                                                                                 (jobject)pkg->accessibleContext, pkg->startIndex, &(pkg->rAccessibleHypertextInfo));
 983             PrintDebugString("   ##### processing succeeded");
 984         } else {
 985             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 986                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleHypertextExtPackage));
 987         }
 988         break;
 989 
 990     case cGetAccessibleHypertextLinkIndexPackage:
 991         PrintDebugString("   ##### type == cGetAccessibleHypertextLinkIndexPackage");
 992         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleHypertextLinkIndexPackage))) {
 993             GetAccessibleHypertextLinkIndexPackage *pkg =
 994                 (GetAccessibleHypertextLinkIndexPackage *) (buffer + sizeof(PackageType));
 995             pkg->rLinkIndex = windowsThreadEntryPoints->getAccessibleHypertextLinkIndex(
 996                                                                                         (jobject)pkg->hypertext, pkg->charIndex);
 997             PrintDebugString("   ##### processing succeeded");
 998         } else {
 999             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1000                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleHypertextLinkIndexPackage));
1001         }
1002         break;
1003 
1004     case cGetAccessibleHyperlinkPackage:
1005         PrintDebugString("   ##### type == cGetAccessibleHyperlinkPackage");
1006         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleHyperlinkPackage))) {
1007             GetAccessibleHyperlinkPackage *pkg =
1008                 (GetAccessibleHyperlinkPackage *) (buffer + sizeof(PackageType));
1009             windowsThreadEntryPoints->getAccessibleHyperlink((jobject)pkg->hypertext, pkg->linkIndex,
1010                                                              &(pkg->rAccessibleHyperlinkInfo));
1011             PrintDebugString("   ##### processing succeeded");
1012         } else {
1013             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1014                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleHyperlinkPackage));
1015         }
1016         break;
1017 
1018         // ------------ end AccessibleHypertext packages
1019 
1020         // ------------ begin Accessible KeyBindings, Icons and Actions
1021 
1022     case cGetAccessibleKeyBindingsPackage:
1023         PrintDebugString("   ##### type == cGetAccessibleKeyBindingsPackage");
1024         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleKeyBindingsPackage))) {
1025             GetAccessibleKeyBindingsPackage *pkg =
1026                 (GetAccessibleKeyBindingsPackage *) (buffer + sizeof(PackageType));
1027             windowsThreadEntryPoints->getAccessibleKeyBindings (
1028                                                                 (jobject)pkg->accessibleContext, &(pkg->rAccessibleKeyBindings));
1029             PrintDebugString("   ##### processing succeeded");
1030         } else {
1031             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1032                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleKeyBindingsPackage));
1033         }
1034         break;
1035 
1036     case cGetAccessibleIconsPackage:
1037         PrintDebugString("   ##### type == cGetAccessibleIconsPackage");
1038         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleIconsPackage))) {
1039             GetAccessibleIconsPackage *pkg =
1040                 (GetAccessibleIconsPackage *) (buffer + sizeof(PackageType));
1041             windowsThreadEntryPoints->getAccessibleIcons (
1042                                                           (jobject)pkg->accessibleContext, &(pkg->rAccessibleIcons));
1043             PrintDebugString("   ##### processing succeeded");
1044         } else {
1045             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1046                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleIconsPackage));
1047         }
1048         break;
1049 
1050 
1051     case cGetAccessibleActionsPackage:
1052         PrintDebugString("   ##### type == cGetAccessibleActionsPackage");
1053         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleActionsPackage))) {
1054             GetAccessibleActionsPackage *pkg =
1055                 (GetAccessibleActionsPackage *) (buffer + sizeof(PackageType));
1056             windowsThreadEntryPoints->getAccessibleActions (
1057                                                             (jobject)pkg->accessibleContext, &(pkg->rAccessibleActions));
1058             PrintDebugString("   ##### processing succeeded");
1059         } else {
1060             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1061                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleActionsPackage));
1062         }
1063         break;
1064 
1065     case cDoAccessibleActionsPackage:
1066         PrintDebugString("   ##### type == cDoAccessibleActionsPackage");
1067         if (bufsize == (sizeof(PackageType) + sizeof(DoAccessibleActionsPackage))) {
1068             DoAccessibleActionsPackage *pkg =
1069                 (DoAccessibleActionsPackage *) (buffer + sizeof(PackageType));
1070             pkg->rResult =
1071                 windowsThreadEntryPoints->doAccessibleActions((jobject)pkg->accessibleContext, &(pkg->actionsToDo),
1072                                                               &(pkg->failure));
1073             PrintDebugString("   ##### processing succeeded");
1074         } else {
1075             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1076                              bufsize, sizeof(PackageType) + sizeof(DoAccessibleActionsPackage));
1077         }
1078         break;
1079 
1080         // ------------ begin addtional methods for Teton
1081 
1082     case cGetVirtualAccessibleNamePackage:
1083         PrintDebugString("   ##### type == GetVirtualAccessibleNamePackage");
1084         if (bufsize == (sizeof(PackageType) + sizeof(GetVirtualAccessibleNamePackage))) {
1085             GetVirtualAccessibleNamePackage *pkg =
1086                 (GetVirtualAccessibleNamePackage *) (buffer + sizeof(PackageType));
1087             windowsThreadEntryPoints->getVirtualAccessibleName ((const jobject)pkg->accessibleContext,
1088                                                              pkg->rName,
1089                                                              pkg->len);
1090             PrintDebugString("   ##### processing succeeded");
1091         } else {
1092             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1093                              bufsize, sizeof(PackageType) + sizeof(GetVirtualAccessibleNamePackage));
1094         }
1095         break;
1096 
1097     case cRequestFocusPackage:
1098         PrintDebugString("   ##### type == RequestFocusPackage");
1099         if (bufsize == (sizeof(PackageType) + sizeof(RequestFocusPackage))) {
1100             RequestFocusPackage *pkg =
1101                 (RequestFocusPackage *) (buffer + sizeof(PackageType));
1102             windowsThreadEntryPoints->requestFocus (
1103                                                     (jobject)pkg->accessibleContext);
1104             PrintDebugString("   ##### processing succeeded");
1105         } else {
1106             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1107                              bufsize, sizeof(PackageType) + sizeof(RequestFocusPackage));
1108         }
1109         break;
1110 
1111     case cSelectTextRangePackage:
1112         PrintDebugString("   ##### type == SelectTextRangePackage");
1113         if (bufsize == (sizeof(PackageType) + sizeof(SelectTextRangePackage))) {
1114             SelectTextRangePackage *pkg =
1115                 (SelectTextRangePackage *) (buffer + sizeof(PackageType));
1116             windowsThreadEntryPoints->selectTextRange (
1117                                                        (jobject)pkg->accessibleContext, pkg->startIndex, pkg->endIndex);
1118             PrintDebugString("   ##### processing succeeded");
1119         } else {
1120             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1121                              bufsize, sizeof(PackageType) + sizeof(SelectTextRangePackage));
1122         }
1123         break;
1124 
1125     case cGetTextAttributesInRangePackage:
1126         PrintDebugString("   ##### type == GetTextAttributesInRangePackage");
1127         if (bufsize == (sizeof(PackageType) + sizeof(GetTextAttributesInRangePackage))) {
1128             GetTextAttributesInRangePackage *pkg =
1129                 (GetTextAttributesInRangePackage *) (buffer + sizeof(PackageType));
1130             windowsThreadEntryPoints->getTextAttributesInRange (
1131                                                                 (jobject)pkg->accessibleContext, pkg->startIndex, pkg->endIndex,
1132                                                                 (AccessibleTextAttributesInfo *)&(pkg->attributes),
1133                                                                 &(pkg->rLength));
1134             PrintDebugString("   ##### processing succeeded");
1135         } else {
1136             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1137                              bufsize, sizeof(PackageType) + sizeof(GetTextAttributesInRangePackage));
1138         }
1139         break;
1140 
1141 
1142     case cGetVisibleChildrenCountPackage:
1143         PrintDebugString("   ##### type == GetVisibleChildrenCountPackage");
1144         if (bufsize == (sizeof(PackageType) + sizeof(GetVisibleChildrenCountPackage))) {
1145             GetVisibleChildrenCountPackage *pkg =
1146                 (GetVisibleChildrenCountPackage *) (buffer + sizeof(PackageType));
1147             pkg->rChildrenCount = windowsThreadEntryPoints->getVisibleChildrenCount ((jobject)pkg->accessibleContext);
1148 
1149             PrintDebugString("   ##### processing succeeded");
1150         } else {
1151             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1152                              bufsize, sizeof(PackageType) + sizeof(GetVisibleChildrenCountPackage));
1153         }
1154         break;
1155 
1156     case cGetVisibleChildrenPackage:
1157         PrintDebugString("   ##### type == GetVisibleChildrenPackage");
1158         if (bufsize == (sizeof(PackageType) + sizeof(GetVisibleChildrenPackage))) {
1159             GetVisibleChildrenPackage *pkg =
1160                 (GetVisibleChildrenPackage *) (buffer + sizeof(PackageType));
1161             pkg->rSuccess = windowsThreadEntryPoints->getVisibleChildren ((jobject)pkg->accessibleContext,
1162                                                                           pkg->startIndex,
1163                                                                           &(pkg->rVisibleChildrenInfo));
1164 
1165             PrintDebugString("   ##### processing succeeded");
1166         } else {
1167             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1168                              bufsize, sizeof(PackageType) + sizeof(GetVisibleChildrenPackage));
1169         }
1170         break;
1171 
1172     case cSetCaretPositionPackage:
1173         PrintDebugString("   ##### type == SetCaretPositionPackage");
1174         if (bufsize == (sizeof(PackageType) + sizeof(SetCaretPositionPackage))) {
1175             SetCaretPositionPackage *pkg =
1176                 (SetCaretPositionPackage *) (buffer + sizeof(PackageType));
1177             windowsThreadEntryPoints->setCaretPosition (
1178                                                         (jobject)pkg->accessibleContext, pkg->position);
1179             PrintDebugString("   ##### processing succeeded");
1180         } else {
1181             PrintDebugString("   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1182                              bufsize, sizeof(PackageType) + sizeof(SetCaretPositionPackage));
1183         }
1184         break;
1185 
1186         // ------------ end additional methods for Teton
1187 
1188         // ------------ end Accessible KeyBindings, Icons and Actions
1189 
1190         // ------------ Accessible Text packages ------------------
1191 
1192     case cGetAccessibleTextInfoPackage:
1193         PrintDebugString("   type == cGetAccessibleTextInfoPackage");
1194         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextInfoPackage))) {
1195             GetAccessibleTextInfoPackage *pkg =
1196                 (GetAccessibleTextInfoPackage *) (buffer + sizeof(PackageType));
1197             windowsThreadEntryPoints->getAccessibleTextInfo((jobject)pkg->AccessibleContext,
1198                                                             &(pkg->rTextInfo), pkg->x, pkg->y);
1199         } else {
1200             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1201                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextInfoPackage));
1202         }
1203         break;
1204 
1205     case cGetAccessibleTextItemsPackage:
1206         PrintDebugString("   type == cGetAccessibleTextItemsPackage");
1207         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextItemsPackage))) {
1208             GetAccessibleTextItemsPackage *pkg =
1209                 (GetAccessibleTextItemsPackage *) (buffer + sizeof(PackageType));
1210             windowsThreadEntryPoints->getAccessibleTextItems((jobject)pkg->AccessibleContext,
1211                                                              &(pkg->rTextItemsInfo), pkg->index);
1212         } else {
1213             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1214                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextInfoPackage));
1215         }
1216         break;
1217 
1218     case cGetAccessibleTextSelectionInfoPackage:
1219         PrintDebugString("   type == cGetAccessibleTextSelectionInfoPackage");
1220         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextSelectionInfoPackage))) {
1221             GetAccessibleTextSelectionInfoPackage *pkg =
1222                 (GetAccessibleTextSelectionInfoPackage *) (buffer + sizeof(PackageType));
1223             windowsThreadEntryPoints->getAccessibleTextSelectionInfo(
1224                                                                      (jobject)pkg->AccessibleContext, &(pkg->rTextSelectionItemsInfo));
1225         } else {
1226             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1227                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextSelectionInfoPackage));
1228         }
1229         break;
1230 
1231     case cGetAccessibleTextAttributeInfoPackage:
1232         PrintDebugString("   type == cGetAccessibleTextAttributeInfoPackage");
1233         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextAttributeInfoPackage))) {
1234             GetAccessibleTextAttributeInfoPackage *pkg =
1235                 (GetAccessibleTextAttributeInfoPackage *) (buffer + sizeof(PackageType));
1236             windowsThreadEntryPoints->getAccessibleTextAttributes(
1237                                                                   (jobject)pkg->AccessibleContext, pkg->index, (AccessibleTextAttributesInfo *) &(pkg->rAttributeInfo));
1238         } else {
1239             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1240                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextAttributeInfoPackage));
1241         }
1242         break;
1243 
1244     case cGetAccessibleTextRectInfoPackage:
1245         PrintDebugString("   type == cGetAccessibleTextRectInfoPackage");
1246         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextRectInfoPackage))) {
1247             GetAccessibleTextRectInfoPackage *pkg =
1248                 (GetAccessibleTextRectInfoPackage *) (buffer + sizeof(PackageType));
1249             windowsThreadEntryPoints->getAccessibleTextRect((jobject)pkg->AccessibleContext,
1250                                                             &(pkg->rTextRectInfo), pkg->index);
1251         } else {
1252             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1253                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextRectInfoPackage));
1254         }
1255         break;
1256 
1257     case cGetCaretLocationPackage:
1258         PrintDebugString("   type == cGetCaretLocationPackage");
1259         if (bufsize == (sizeof(PackageType) + sizeof(GetCaretLocationPackage))) {
1260             GetCaretLocationPackage *pkg =
1261                 (GetCaretLocationPackage *) (buffer + sizeof(PackageType));
1262             windowsThreadEntryPoints->getCaretLocation((jobject)pkg->AccessibleContext,
1263                                                             &(pkg->rTextRectInfo), pkg->index);
1264         } else {
1265             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1266                              bufsize, sizeof(PackageType) + sizeof(GetCaretLocationPackage));
1267         }
1268         break;
1269 
1270     case cGetAccessibleTextLineBoundsPackage:
1271         PrintDebugString("   type == cGetAccessibleTextLineBoundsPackage");
1272         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextLineBoundsPackage))) {
1273             GetAccessibleTextLineBoundsPackage *pkg =
1274                 (GetAccessibleTextLineBoundsPackage *) (buffer + sizeof(PackageType));
1275             windowsThreadEntryPoints->getAccessibleTextLineBounds((jobject)pkg->AccessibleContext,
1276                                                                   pkg->index, &(pkg->rLineStart), &(pkg->rLineEnd));
1277         } else {
1278             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1279                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextLineBoundsPackage));
1280         }
1281         break;
1282 
1283     case cGetAccessibleTextRangePackage:
1284         PrintDebugString("   type == cGetAccessibleTextRangePackage");
1285         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextRangePackage))) {
1286             GetAccessibleTextRangePackage *pkg =
1287                 (GetAccessibleTextRangePackage *) (buffer + sizeof(PackageType));
1288             windowsThreadEntryPoints->getAccessibleTextRange((jobject)pkg->AccessibleContext,
1289                                                              pkg->start, pkg->end, (wchar_t *) &(pkg->rText), (sizeof(pkg->rText) / sizeof(wchar_t)));
1290         } else {
1291             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1292                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextRangePackage));
1293         }
1294         break;
1295 
1296 
1297         // ------------ Accessible Value packages ------------------
1298 
1299     case cGetCurrentAccessibleValueFromContextPackage:
1300         PrintDebugString("   type == cGetCurrentAccessibleValueFromContextPackage");
1301         if (bufsize == (sizeof(PackageType) + sizeof(GetCurrentAccessibleValueFromContextPackage))) {
1302             GetCurrentAccessibleValueFromContextPackage *pkg =
1303                 (GetCurrentAccessibleValueFromContextPackage *) (buffer + sizeof(PackageType));
1304             windowsThreadEntryPoints->getCurrentAccessibleValueFromContext((jobject)pkg->AccessibleContext,
1305                                                                            (wchar_t *) &(pkg->rValue), (sizeof(pkg->rValue) / sizeof(wchar_t)));
1306         } else {
1307             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1308                              bufsize, sizeof(PackageType) + sizeof(GetCurrentAccessibleValueFromContextPackage));
1309         }
1310         break;
1311 
1312     case cGetMaximumAccessibleValueFromContextPackage:
1313         PrintDebugString("   type == cGetMaximumAccessibleValueFromContextPackage");
1314         if (bufsize == (sizeof(PackageType) + sizeof(GetMaximumAccessibleValueFromContextPackage))) {
1315             GetMaximumAccessibleValueFromContextPackage *pkg =
1316                 (GetMaximumAccessibleValueFromContextPackage *) (buffer + sizeof(PackageType));
1317             windowsThreadEntryPoints->getMaximumAccessibleValueFromContext((jobject)pkg->AccessibleContext,
1318                                                                            (wchar_t *) &(pkg->rValue), (sizeof(pkg->rValue) / sizeof(wchar_t)));
1319         } else {
1320             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1321                              bufsize, sizeof(PackageType) + sizeof(GetMaximumAccessibleValueFromContextPackage));
1322         }
1323         break;
1324 
1325     case cGetMinimumAccessibleValueFromContextPackage:
1326         PrintDebugString("   type == cGetMinimumAccessibleValueFromContextPackage");
1327         if (bufsize == (sizeof(PackageType) + sizeof(GetMinimumAccessibleValueFromContextPackage))) {
1328             GetMinimumAccessibleValueFromContextPackage *pkg =
1329                 (GetMinimumAccessibleValueFromContextPackage *) (buffer + sizeof(PackageType));
1330             windowsThreadEntryPoints->getMinimumAccessibleValueFromContext((jobject)pkg->AccessibleContext,
1331                                                                            (wchar_t *) &(pkg->rValue), (sizeof(pkg->rValue) / sizeof(wchar_t)));
1332         } else {
1333             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1334                              bufsize, sizeof(PackageType) + sizeof(GetMinimumAccessibleValueFromContextPackage));
1335         }
1336         break;
1337 
1338         // ------------ Accessible Selection packages ------------------
1339 
1340     case cAddAccessibleSelectionFromContextPackage:
1341         PrintDebugString("   type == cAddAccessibleSelectionFromContextPackage");
1342         if (bufsize == (sizeof(PackageType) + sizeof(AddAccessibleSelectionFromContextPackage))) {
1343             AddAccessibleSelectionFromContextPackage *pkg =
1344                 (AddAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType));
1345             windowsThreadEntryPoints->addAccessibleSelectionFromContext((jobject)pkg->AccessibleContext,
1346                                                                         pkg->index);
1347         } else {
1348             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1349                              bufsize, sizeof(PackageType) + sizeof(AddAccessibleSelectionFromContextPackage));
1350         }
1351         break;
1352 
1353     case cClearAccessibleSelectionFromContextPackage:
1354         PrintDebugString("   type == cClearAccessibleSelectionFromContextPackage");
1355         if (bufsize == (sizeof(PackageType) + sizeof(ClearAccessibleSelectionFromContextPackage))) {
1356             ClearAccessibleSelectionFromContextPackage *pkg =
1357                 (ClearAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType));
1358             windowsThreadEntryPoints->clearAccessibleSelectionFromContext((jobject)pkg->AccessibleContext);
1359         } else {
1360             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1361                              bufsize, sizeof(PackageType) + sizeof(ClearAccessibleSelectionFromContextPackage));
1362         }
1363         break;
1364 
1365     case cGetAccessibleSelectionFromContextPackage:
1366         PrintDebugString("   type == cGetAccessibleSelectionFromContextPackage");
1367         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleSelectionFromContextPackage))) {
1368             GetAccessibleSelectionFromContextPackage *pkg =
1369                 (GetAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType));
1370             pkg->rAccessibleContext = (JOBJECT64)windowsThreadEntryPoints->getAccessibleSelectionFromContext(
1371                                                                                                   (jobject)pkg->AccessibleContext, pkg->index);
1372         } else {
1373             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1374                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleSelectionFromContextPackage));
1375         }
1376         break;
1377 
1378     case cGetAccessibleSelectionCountFromContextPackage:
1379         PrintDebugString("   type == cGetAccessibleSelectionCountFromContextPackage");
1380         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleSelectionCountFromContextPackage))) {
1381             GetAccessibleSelectionCountFromContextPackage *pkg =
1382                 (GetAccessibleSelectionCountFromContextPackage *) (buffer + sizeof(PackageType));
1383             pkg->rCount = windowsThreadEntryPoints->getAccessibleSelectionCountFromContext(
1384                                                                                            (jobject)pkg->AccessibleContext);
1385         } else {
1386             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1387                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleSelectionCountFromContextPackage));
1388         }
1389         break;
1390 
1391     case cIsAccessibleChildSelectedFromContextPackage:
1392         PrintDebugString("   type == cIsAccessibleChildSelectedFromContextPackage");
1393         if (bufsize == (sizeof(PackageType) + sizeof(IsAccessibleChildSelectedFromContextPackage))) {
1394             IsAccessibleChildSelectedFromContextPackage *pkg =
1395                 (IsAccessibleChildSelectedFromContextPackage *) (buffer + sizeof(PackageType));
1396             pkg->rResult = windowsThreadEntryPoints->isAccessibleChildSelectedFromContext(
1397                                                                                           (jobject)pkg->AccessibleContext, pkg->index);
1398         } else {
1399             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1400                              bufsize, sizeof(PackageType) + sizeof(IsAccessibleChildSelectedFromContextPackage));
1401         }
1402         break;
1403 
1404     case cRemoveAccessibleSelectionFromContextPackage:
1405         PrintDebugString("   type == cRemoveAccessibleSelectionFromContextPackage");
1406         if (bufsize == (sizeof(PackageType) + sizeof(RemoveAccessibleSelectionFromContextPackage))) {
1407             RemoveAccessibleSelectionFromContextPackage *pkg =
1408                 (RemoveAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType));
1409             windowsThreadEntryPoints->removeAccessibleSelectionFromContext((jobject)pkg->AccessibleContext,
1410                                                                            pkg->index);
1411         } else {
1412             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1413                              bufsize, sizeof(PackageType) + sizeof(RemoveAccessibleSelectionFromContextPackage));
1414         }
1415         break;
1416 
1417     case cSelectAllAccessibleSelectionFromContextPackage:
1418         PrintDebugString("   type == cSelectAllAccessibleSelectionFromContextPackage");
1419         if (bufsize == (sizeof(PackageType) + sizeof(SelectAllAccessibleSelectionFromContextPackage))) {
1420             SelectAllAccessibleSelectionFromContextPackage *pkg =
1421                 (SelectAllAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType));
1422             windowsThreadEntryPoints->selectAllAccessibleSelectionFromContext((jobject)pkg->AccessibleContext);
1423         } else {
1424             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1425                              bufsize, sizeof(PackageType) + sizeof(SelectAllAccessibleSelectionFromContextPackage));
1426         }
1427         break;
1428 
1429 
1430         // ------------ event notification management packages ------------------
1431 
1432     case cAddJavaEventNotificationPackage:
1433         PrintDebugString("   type = cAddJavaEventNotificationPackage");
1434         if (bufsize == (sizeof(PackageType) + sizeof(AddJavaEventNotificationPackage))) {
1435             AddJavaEventNotificationPackage *pkg =
1436                 (AddJavaEventNotificationPackage *) (buffer + sizeof(PackageType));
1437             addJavaEventNotification(pkg->type, (HWND)ABLongToHandle( pkg->DLLwindow ) );
1438         } else {
1439             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1440                              bufsize, sizeof(PackageType) + sizeof(AddJavaEventNotificationPackage));
1441         }
1442         break;
1443 
1444     case cRemoveJavaEventNotificationPackage:
1445         PrintDebugString("   type = cRemoveJavaEventNotificationPackage");
1446         if (bufsize == (sizeof(PackageType) + sizeof(RemoveJavaEventNotificationPackage))) {
1447             RemoveJavaEventNotificationPackage *pkg =
1448                 (RemoveJavaEventNotificationPackage *) (buffer + sizeof(PackageType));
1449             removeJavaEventNotification(pkg->type, (HWND)ABLongToHandle( pkg->DLLwindow ));
1450         } else {
1451             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1452                              bufsize, sizeof(PackageType) + sizeof(RemoveJavaEventNotificationPackage));
1453         }
1454         break;
1455 
1456     case cAddAccessibilityEventNotificationPackage:
1457         PrintDebugString("   type = cAddAccessibilityEventNotificationPackage");
1458         if (bufsize == (sizeof(PackageType) + sizeof(AddAccessibilityEventNotificationPackage))) {
1459             AddAccessibilityEventNotificationPackage *pkg =
1460                 (AddAccessibilityEventNotificationPackage *) (buffer + sizeof(PackageType));
1461             addAccessibilityEventNotification(pkg->type, (HWND)ABLongToHandle(pkg->DLLwindow));
1462         } else {
1463             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1464                              bufsize, sizeof(PackageType) + sizeof(AddAccessibilityEventNotificationPackage));
1465         }
1466         break;
1467 
1468     case cRemoveAccessibilityEventNotificationPackage:
1469         PrintDebugString("   type = cRemoveAccessibilityEventNotificationPackage");
1470         if (bufsize == (sizeof(PackageType) + sizeof(RemoveAccessibilityEventNotificationPackage))) {
1471             RemoveAccessibilityEventNotificationPackage *pkg =
1472                 (RemoveAccessibilityEventNotificationPackage *) (buffer + sizeof(PackageType));
1473             removeAccessibilityEventNotification(pkg->type, (HWND)ABLongToHandle(pkg->DLLwindow));
1474         } else {
1475             PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",
1476                              bufsize, sizeof(PackageType) + sizeof(RemoveAccessibilityEventNotificationPackage));
1477         }
1478         break;
1479 
1480     default:
1481         PrintDebugString("   processing FAILED!! -> don't know how to handle type = %X", *type);
1482         returnVal = -1;
1483         break;
1484     }
1485 
1486     PrintDebugString("   package processing completed");
1487     return returnVal;
1488 }
1489 
1490 
1491 // -----------------------------
1492 
1493 
1494 /**
1495  * MemoryMappedFileCreated
1496  *          - WindowsDLL letting us know it's created a memory-mapped file
1497  *            for IPC.  We need to open it and write a magic string into
1498  *            it to let the WindowsDLL know all is OK.  Also we need to
1499  *            set up our own data structures to communicate with the
1500  *            WindowsDLL
1501  *
1502  */
1503 LRESULT
1504 JavaAccessBridge::MemoryMappedFileCreated(HWND ATBridgeDLLWindow, char *filename) {
1505     PrintDebugString("  in MemoryMappedFileCreated(%p, %s)!", ATBridgeDLLWindow, filename);
1506     AccessBridgeATInstance *newAT =
1507         new AccessBridgeATInstance(dialogWindow, ATBridgeDLLWindow, filename, ATs);
1508     PrintDebugString("    just created a new ATInstance = %p, old = %p", newAT, ATs);
1509     ATs = newAT;
1510 
1511     LRESULT returnVal = ATs->initiateIPC();
1512     if (returnVal == 0) {
1513         PrintDebugString("  Successfully initiated IPC with AT!!!");
1514     } else {
1515         PrintDebugString("  ERROR: Failed to initiate IPC with AT!!!");
1516     }
1517 
1518     return returnVal;
1519 }
1520 
1521 
1522 /**
1523  * WindowsATDestroyed - lets the JavaABDLL know a Windows AT disappeared
1524  *
1525  */
1526 void
1527 JavaAccessBridge::WindowsATDestroyed(HWND ATBridgeDLLWindow) {
1528     PrintDebugString("\r\nin JavaAccessBridge::WindowsATDestroyed(%p)", ATBridgeDLLWindow);
1529     if (ATs == (AccessBridgeATInstance *) 0) {
1530         PrintDebugString("  ERROR!! -> ATs == 0! (shouldn't happen here)");
1531         return;
1532     }
1533 
1534     AccessBridgeATInstance *currentAT = ATs;
1535     AccessBridgeATInstance *previousAT = ATs;
1536     if (ATs->winAccessBridgeWindow == ATBridgeDLLWindow) {
1537         ATs = ATs->nextATInstance;
1538         // remove event notification for this AT
1539         removeJavaEventNotification(currentAT->javaEventMask, ATBridgeDLLWindow);
1540         removeAccessibilityEventNotification(currentAT->accessibilityEventMask, ATBridgeDLLWindow);
1541         delete currentAT;
1542         PrintDebugString("  data structures successfully removed");
1543     } else {
1544         while (currentAT != (AccessBridgeATInstance *) NULL) {
1545             if (currentAT->winAccessBridgeWindow == ATBridgeDLLWindow) {
1546                 previousAT->nextATInstance = currentAT->nextATInstance;
1547                 delete currentAT;
1548                 PrintDebugString("  data structures successfully removed");
1549                 return;
1550             } else {
1551                 previousAT = currentAT;
1552                 currentAT = currentAT->nextATInstance;
1553             }
1554         }
1555         PrintDebugString("  ERROR!! couldn't find matching data structures!");
1556     }
1557 }
1558 
1559 
1560 // -----------------------------
1561 
1562 
1563 /**
1564  * releaseJavaObject - lets the JavaVM know it can release the Java Object
1565  *
1566  * Note: once you have made this call, the JavaVM will garbage collect
1567  * the jobject you pass in.  If you later use that jobject in another
1568  * call, you will cause all maner of havoc!
1569  *
1570  */
1571 void
1572 JavaAccessBridge::releaseJavaObject(jobject object) {
1573     PrintDebugString("In JavaAccessBridge::releaseJavaObject");
1574     PrintDebugString("  object X: %p", object);
1575     if (windowsThreadJNIEnv != (JNIEnv *) 0) {
1576         windowsThreadJNIEnv->DeleteGlobalRef(object);
1577         PrintDebugString("  global reference deleted.", object);
1578     } else {
1579         PrintDebugString("  Error! windowsThreadJNIEnv == 0");
1580     }
1581 }
1582 
1583 // -----------------------------
1584 
1585 /**
1586  * addJavaEventNotification - this AT now wants this type of events
1587  *
1588  */
1589 void
1590 JavaAccessBridge::addJavaEventNotification(jlong type, HWND DLLwindow) {
1591     // walk through list of ATs, find this one and add this type
1592     // and, if we weren't listening for these before, ask Java for 'em
1593     PrintDebugString("  adding Java event type %016I64X to HWND %p", type, DLLwindow);
1594     AccessBridgeATInstance *ati = ATs;
1595     long globalEventMask = 0;
1596     while (ati != (AccessBridgeATInstance *) 0) {
1597         if (ati->winAccessBridgeWindow == DLLwindow) {
1598             ati->javaEventMask |= type;
1599             PrintDebugString("  found HWND, javaEventMask now is %X", ati->javaEventMask);
1600         } else {
1601             globalEventMask |= ati->javaEventMask;
1602         }
1603         ati = ati->nextATInstance;
1604     }
1605     PrintDebugString("  union of all Java AT event masks: %X", globalEventMask);
1606     if (!(globalEventMask & type)) {
1607         // no other ATs wanted this event;
1608         // start getting them from Java
1609         PrintDebugString("  no other AT wanted this Java event (so not registered); adding to AccessBridge.java");
1610         windowsThreadEntryPoints->addJavaEventNotification(type);
1611     }
1612 }
1613 
1614 /**
1615  * removeJavaEventNotification - this AT no longer wants this type of events
1616  *
1617  */
1618 void
1619 JavaAccessBridge::removeJavaEventNotification(jlong type, HWND DLLwindow) {
1620     // walk through list of ATs, find this one and remove this type
1621     // and, if no other AT wants 'em either, tell Java we no longer want 'em
1622     PrintDebugString("  removing Java event type %016I64X from HWND %p", type, DLLwindow);
1623     AccessBridgeATInstance *ati = ATs;
1624     long globalEventMask = 0;
1625     while (ati != (AccessBridgeATInstance *) 0) {
1626         if (ati->winAccessBridgeWindow == DLLwindow) {
1627             ati->javaEventMask &= (0xFFFFFFFF - type);
1628             PrintDebugString("  found HWND, javaEventMask now is %X", ati->javaEventMask);
1629         } else {
1630             globalEventMask |= ati->javaEventMask;
1631         }
1632         ati = ati->nextATInstance;
1633     }
1634     PrintDebugString("  union of all Java AT event masks: %X", globalEventMask);
1635     if (!(globalEventMask & type)) {
1636         // no other ATs wanted this event;
1637         // stop getting them from Java
1638         PrintDebugString("  no other AT wanted this Java event (so can remove); removing from AccessBridge.java");
1639         windowsThreadEntryPoints->removeJavaEventNotification(type);
1640     }
1641 }
1642 
1643 
1644 /**
1645  * addAccesibilityEventNotification - this AT now wants this type of events
1646  *
1647  */
1648 void
1649 JavaAccessBridge::addAccessibilityEventNotification(jlong type, HWND DLLwindow) {
1650     // walk through list of ATs, find this one and add this type
1651     // and, if we weren't listening for these before, ask Java for 'em
1652     PrintDebugString("  adding Accesibility event type %016I64X to HWND %p", type, DLLwindow);
1653     AccessBridgeATInstance *ati = ATs;
1654     long globalEventMask = 0;
1655     while (ati != (AccessBridgeATInstance *) 0) {
1656         if (ati->winAccessBridgeWindow == DLLwindow) {
1657             ati->accessibilityEventMask |= type;
1658             PrintDebugString("  found HWND, accessibilityEventMask now is %X", ati->accessibilityEventMask);
1659         } else {
1660             globalEventMask |= ati->accessibilityEventMask;
1661         }
1662         ati = ati->nextATInstance;
1663     }
1664     PrintDebugString("  union of all Accessibility AT event masks: %X", globalEventMask);
1665     if (!(globalEventMask & type)) {
1666         // no other ATs wanted this event;
1667         // start getting them from Java
1668         PrintDebugString("  no other AT wanted this Accesibility event (so not registered); adding to AccessBridge.java");
1669         windowsThreadEntryPoints->addAccessibilityEventNotification(type);
1670     }
1671 }
1672 
1673 /**
1674  * removeAccesibilityEventNotification - this AT no longer wants this type of events
1675  *
1676  */
1677 void
1678 JavaAccessBridge::removeAccessibilityEventNotification(jlong type, HWND DLLwindow) {
1679     // walk through list of ATs, find this one and remove this type
1680     // and, if no other AT wants 'em either, tell Java we no longer want 'em
1681     PrintDebugString("  removing Accesibility event type %016I64X from HWND %p", type, DLLwindow);
1682     AccessBridgeATInstance *ati = ATs;
1683     long globalEventMask = 0;
1684     while (ati != (AccessBridgeATInstance *) 0) {
1685         if (ati->winAccessBridgeWindow == DLLwindow) {
1686             ati->accessibilityEventMask &= (0xFFFFFFFF - type);
1687             PrintDebugString("  found HWND, accessibilityEventMask now is %X", ati->accessibilityEventMask);
1688         } else {
1689             globalEventMask |= ati->accessibilityEventMask;
1690         }
1691         ati = ati->nextATInstance;
1692     }
1693     PrintDebugString("  union of all Accessibility AT event masks: %X", globalEventMask);
1694     if (!(globalEventMask & type)) {
1695         // no other ATs wanted this event;
1696         // stop getting them from Java
1697         PrintDebugString("  no other AT wanted this Accessibility event (so can remove); removing from AccessBridge.java");
1698         windowsThreadEntryPoints->removeAccessibilityEventNotification(type);
1699     }
1700 }
1701 
1702 
1703 
1704 
1705 /**
1706  * firePropertyCaretChange
1707  *
1708  */
1709 void
1710 JavaAccessBridge::firePropertyCaretChange(JNIEnv *env, jobject callingObj,
1711                                           jobject event, jobject source,
1712                                           jint oldValue, jint newValue) {
1713 
1714     PrintDebugString("\r\nJava_com_sun_java_accessibility_internal_AccessBridge_propertyCaretChanged(%p, %p, %p, %p, %d, %d)",
1715                      env, callingObj, event,
1716                      source, oldValue, newValue);
1717 
1718     // sanity check
1719     if (ATs == (AccessBridgeATInstance *) 0) {
1720         PrintDebugString("  ERROR!! ATs == 0! (shouldn't happen here!)");
1721         return;         // panic!
1722     }
1723 
1724     // common setup
1725     char buffer[sizeof(PackageType) + sizeof(PropertyCaretChangePackage)];
1726     PackageType *type = (PackageType *) buffer;
1727     PropertyCaretChangePackage *pkg = (PropertyCaretChangePackage *) (buffer + sizeof(PackageType));
1728     *type = cPropertyCaretChangePackage;
1729     pkg->vmID = (long) dialogWindow;
1730 
1731     // make new Global Refs and send events only to those ATs that want 'em
1732     AccessBridgeATInstance *ati = ATs;
1733     while (ati != (AccessBridgeATInstance *) 0) {
1734         if (ati->accessibilityEventMask & cPropertyCaretChangeEvent) {
1735 
1736             PrintDebugString("  sending to AT");
1737 
1738             // make new GlobalRefs for this AT
1739             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
1740             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
1741 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1742             PrintDebugString("  GlobalRef'd Event: %p", pkg->Event);
1743             PrintDebugString("  GlobalRef'd Source: %p", pkg->AccessibleContextSource);
1744 #else // JOBJECT64 is jlong (64 bit)
1745             PrintDebugString("  GlobalRef'd Event: %016I64X", pkg->Event);
1746             PrintDebugString("  GlobalRef'd Source: %016I64X", pkg->AccessibleContextSource);
1747 #endif
1748 
1749             pkg->oldPosition = oldValue;
1750             pkg->newPosition = newValue;
1751 
1752             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyCaretChangeEvent);
1753         }
1754         ati = ati->nextATInstance;
1755     }
1756     PrintDebugString("  done with propertyCaretChange event");
1757 }
1758 
1759 /**
1760  * firePropertyDescriptionChange
1761  *
1762  */
1763 void
1764 JavaAccessBridge::firePropertyDescriptionChange(JNIEnv *env, jobject callingObj,
1765                                                 jobject event, jobject source,
1766                                                 jstring oldValue, jstring newValue){
1767 
1768     PrintDebugString("\r\nJava_com_sun_java_accessibility_internal_AccessBridge_propertyDescriptionChanged(%p, %p, %p, %p, %p, %p)",
1769                      env, callingObj, event,
1770                      source, oldValue, newValue);
1771 
1772     // sanity check
1773     if (ATs == (AccessBridgeATInstance *) 0) {
1774         PrintDebugString("  ERROR!! ATs == 0! (shouldn't happen here!)");
1775         return;         // panic!
1776     }
1777 
1778     // common setup
1779     const wchar_t *stringBytes;
1780     char buffer[sizeof(PackageType) + sizeof(PropertyDescriptionChangePackage)];
1781     PackageType *type = (PackageType *) buffer;
1782     PropertyDescriptionChangePackage *pkg = (PropertyDescriptionChangePackage *) (buffer + sizeof(PackageType));
1783     *type = cPropertyDescriptionChangePackage;
1784     pkg->vmID = (long) dialogWindow;
1785 
1786     // make new Global Refs and send events only to those ATs that want 'em
1787     AccessBridgeATInstance *ati = ATs;
1788     while (ati != (AccessBridgeATInstance *) 0) {
1789         if (ati->accessibilityEventMask & cPropertyCaretChangeEvent) {
1790 
1791             PrintDebugString("  sending to AT");
1792 
1793             // make new GlobalRefs for this AT
1794             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
1795             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
1796 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1797             PrintDebugString("  GlobalRef'd Event: %p", pkg->Event);
1798             PrintDebugString("  GlobalRef'd Source: %p", pkg->AccessibleContextSource);
1799 #else // JOBJECT64 is jlong (64 bit)
1800             PrintDebugString("  GlobalRef'd Event: %016I64X", pkg->Event);
1801             PrintDebugString("  GlobalRef'd Source: %016I64X", pkg->AccessibleContextSource);
1802 #endif
1803 
1804             if (oldValue != (jstring) 0) {
1805                 stringBytes = (const wchar_t *) env->GetStringChars(oldValue, 0);
1806                 if (stringBytes == NULL) {
1807                     if (!env->ExceptionCheck()) {
1808                         jclass cls = env->FindClass("java/lang/OutOfMemoryError");
1809                         if (cls != NULL) {
1810                             env->ThrowNew(cls, NULL);
1811                         }
1812                     }
1813                     return;
1814                 }
1815                 wcsncpy(pkg->oldDescription, stringBytes, (sizeof(pkg->oldDescription) / sizeof(wchar_t)));
1816                 env->ReleaseStringChars(oldValue, stringBytes);
1817             } else {
1818                 wcsncpy(pkg->oldDescription, L"(null)", (sizeof(pkg->oldDescription) / sizeof(wchar_t)));
1819             }
1820 
1821             if (newValue != (jstring) 0) {
1822                 stringBytes = (const wchar_t *) env->GetStringChars(newValue, 0);
1823                 if (stringBytes == NULL) {
1824                    if (!env->ExceptionCheck()) {
1825                         jclass cls = env->FindClass("java/lang/OutOfMemoryError");
1826                         if (cls != NULL) {
1827                             env->ThrowNew(cls, NULL);
1828                         }
1829                     }
1830                     return;
1831                 }
1832                 wcsncpy(pkg->newDescription, stringBytes, (sizeof(pkg->newDescription) / sizeof(wchar_t)));
1833                 env->ReleaseStringChars(newValue, stringBytes);
1834             } else {
1835                 wcsncpy(pkg->newDescription, L"(null)", (sizeof(pkg->newDescription) / sizeof(wchar_t)));
1836             }
1837 
1838             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyDescriptionChangeEvent);
1839         }
1840         ati = ati->nextATInstance;
1841     }
1842     PrintDebugString("  done with propertyDescriptionChange event");
1843 }
1844 
1845 /**
1846  * firePropertyNameChange
1847  *
1848  */
1849 void
1850 JavaAccessBridge::firePropertyNameChange(JNIEnv *env, jobject callingObj,
1851                                          jobject event, jobject source,
1852                                          jstring oldValue, jstring newValue){
1853 
1854     PrintDebugString("\r\nJava_com_sun_java_accessibility_internal_AccessBridge_propertyNameChanged(%p, %p, %p, %p, %p, %p)",
1855                      env, callingObj, event,
1856                      source, oldValue, newValue);
1857 
1858     // sanity check
1859     if (ATs == (AccessBridgeATInstance *) 0) {
1860         PrintDebugString("  ERROR!! ATs == 0! (shouldn't happen here!)");
1861         return;         // panic!
1862     }
1863 
1864     // common setup
1865     const wchar_t *stringBytes;
1866     char buffer[sizeof(PackageType) + sizeof(PropertyNameChangePackage)];
1867     PackageType *type = (PackageType *) buffer;
1868     PropertyNameChangePackage *pkg = (PropertyNameChangePackage *) (buffer + sizeof(PackageType));
1869     *type = cPropertyNameChangePackage;
1870     pkg->vmID = (long) dialogWindow;
1871 
1872     // make new Global Refs and send events only to those ATs that want 'em
1873     AccessBridgeATInstance *ati = ATs;
1874     while (ati != (AccessBridgeATInstance *) 0) {
1875         if (ati->accessibilityEventMask & cPropertyNameChangeEvent) {
1876 
1877             PrintDebugString("  sending to AT");
1878 
1879             // make new GlobalRefs for this AT
1880             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
1881             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
1882 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1883             PrintDebugString("  GlobalRef'd Event: %p", pkg->Event);
1884             PrintDebugString("  GlobalRef'd Source: %p", pkg->AccessibleContextSource);
1885 #else // JOBJECT64 is jlong (64 bit)
1886             PrintDebugString("  GlobalRef'd Event: %016I64X", pkg->Event);
1887             PrintDebugString("  GlobalRef'd Source: %016I64X", pkg->AccessibleContextSource);
1888 #endif
1889 
1890             if (oldValue != (jstring) 0) {
1891                 stringBytes = (const wchar_t *) env->GetStringChars(oldValue, 0);
1892                 if (stringBytes == NULL) {
1893                     if (!env->ExceptionCheck()) {
1894                         jclass cls = env->FindClass("java/lang/OutOfMemoryError");
1895                         if (cls != NULL) {
1896                             env->ThrowNew(cls, NULL);
1897                         }
1898                     }
1899                     return;
1900                 }
1901                 wcsncpy(pkg->oldName, stringBytes, (sizeof(pkg->oldName) / sizeof(wchar_t)));
1902                 env->ReleaseStringChars(oldValue, stringBytes);
1903             } else {
1904                 wcsncpy(pkg->oldName, L"(null)", (sizeof(pkg->oldName) / sizeof(wchar_t)));
1905             }
1906 
1907             if (newValue != (jstring) 0) {
1908                 stringBytes = (const wchar_t *) env->GetStringChars(newValue, 0);
1909                 if (stringBytes == NULL) {
1910                     if (!env->ExceptionCheck()) {
1911                         jclass cls = env->FindClass("java/lang/OutOfMemoryError");
1912                         if (cls != NULL) {
1913                             env->ThrowNew(cls, NULL);
1914                         }
1915                     }
1916                     return;
1917                 }
1918                 wcsncpy(pkg->newName, stringBytes, (sizeof(pkg->newName) / sizeof(wchar_t)));
1919                 env->ReleaseStringChars(newValue, stringBytes);
1920             } else {
1921                 wcsncpy(pkg->newName, L"(null)", (sizeof(pkg->newName) / sizeof(wchar_t)));
1922             }
1923 
1924             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyNameChangeEvent);
1925         }
1926         ati = ati->nextATInstance;
1927     }
1928     PrintDebugString("  done with propertyNameChange event");
1929 }
1930 
1931 
1932 /**
1933  * firePropertySelectionChange
1934  *
1935  */
1936 void
1937 JavaAccessBridge::firePropertySelectionChange(JNIEnv *env, jobject callingObj,
1938                                               jobject event, jobject source) {
1939 
1940     PrintDebugString("\r\nJava_com_sun_java_accessibility_internal_AccessBridge_propertySelectionChanged(%p, %p, %p, %p)",
1941                      env, callingObj, event, source);
1942 
1943     // sanity check
1944     if (ATs == (AccessBridgeATInstance *) 0) {
1945         PrintDebugString("  ERROR!! ATs == 0! (shouldn't happen here!)");
1946         return;         // panic!
1947     }
1948 
1949     // common setup
1950     char buffer[sizeof(PackageType) + sizeof(PropertySelectionChangePackage)];
1951     PackageType *type = (PackageType *) buffer;
1952     PropertySelectionChangePackage *pkg = (PropertySelectionChangePackage *) (buffer + sizeof(PackageType));
1953     *type = cPropertySelectionChangePackage;
1954     pkg->vmID = (long) dialogWindow;
1955 
1956     // make new Global Refs and send events only to those ATs that want 'em
1957     AccessBridgeATInstance *ati = ATs;
1958     while (ati != (AccessBridgeATInstance *) 0) {
1959         if (ati->accessibilityEventMask & cPropertySelectionChangeEvent) {
1960 
1961             PrintDebugString("  sending to AT");
1962 
1963             // make new GlobalRefs for this AT
1964             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
1965             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
1966 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1967             PrintDebugString("  GlobalRef'd Event: %p", pkg->Event);
1968             PrintDebugString("  GlobalRef'd Source: %p", pkg->AccessibleContextSource);
1969 #else // JOBJECT64 is jlong (64 bit)
1970             PrintDebugString("  GlobalRef'd Event: %016I64X", pkg->Event);
1971             PrintDebugString("  GlobalRef'd Source: %016I64X", pkg->AccessibleContextSource);
1972 #endif
1973 
1974             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertySelectionChangeEvent);
1975         }
1976         ati = ati->nextATInstance;
1977     }
1978     PrintDebugString("  done with propertySelectionChange event");
1979 }
1980 
1981 
1982 /**
1983  * firePropertyStateChange
1984  *
1985  */
1986 void
1987 JavaAccessBridge::firePropertyStateChange(JNIEnv *env, jobject callingObj,
1988                                           jobject event, jobject source,
1989                                           jstring oldValue, jstring newValue){
1990 
1991     PrintDebugString("\r\nJava_com_sun_java_accessibility_internal_AccessBridge_propertyStateChanged(%p, %p, %p, %p, %p, %p)",
1992                      env, callingObj, event,
1993                      source, oldValue, newValue);
1994 
1995     // sanity check
1996     if (ATs == (AccessBridgeATInstance *) 0) {
1997         PrintDebugString("  ERROR!! ATs == 0! (shouldn't happen here!)");
1998         return;         // panic!
1999     }
2000 
2001     // common setup
2002     const wchar_t *stringBytes;
2003     char buffer[sizeof(PackageType) + sizeof(PropertyStateChangePackage)];
2004     PackageType *type = (PackageType *) buffer;
2005     PropertyStateChangePackage *pkg = (PropertyStateChangePackage *) (buffer + sizeof(PackageType));
2006     *type = cPropertyStateChangePackage;
2007     pkg->vmID = (long) dialogWindow;
2008 
2009     // make new Global Refs and send events only to those ATs that want 'em
2010     AccessBridgeATInstance *ati = ATs;
2011     while (ati != (AccessBridgeATInstance *) 0) {
2012         if (ati->accessibilityEventMask & cPropertyStateChangeEvent) {
2013 
2014             PrintDebugString("  sending to AT");
2015 
2016             // make new GlobalRefs for this AT
2017             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
2018             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
2019 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2020             PrintDebugString("  GlobalRef'd Event: %p", pkg->Event);
2021             PrintDebugString("  GlobalRef'd Source: %p", pkg->AccessibleContextSource);
2022 #else // JOBJECT64 is jlong (64 bit)
2023             PrintDebugString("  GlobalRef'd Event: %016I64X", pkg->Event);
2024             PrintDebugString("  GlobalRef'd Source: %016I64X", pkg->AccessibleContextSource);
2025 #endif
2026 
2027             if (oldValue != (jstring) 0) {
2028                 stringBytes = (const wchar_t *) env->GetStringChars(oldValue, 0);
2029                 if (stringBytes == NULL) {
2030                     if (!env->ExceptionCheck()) {
2031                         jclass cls = env->FindClass("java/lang/OutOfMemoryError");
2032                         if (cls != NULL) {
2033                             env->ThrowNew(cls, NULL);
2034                         }
2035                     }
2036                     return;
2037                 }
2038                 wcsncpy(pkg->oldState, stringBytes, (sizeof(pkg->oldState) / sizeof(wchar_t)));
2039                 env->ReleaseStringChars(oldValue, stringBytes);
2040             } else {
2041                 wcsncpy(pkg->oldState, L"(null)", (sizeof(pkg->oldState) / sizeof(wchar_t)));
2042             }
2043 
2044             if (newValue != (jstring) 0) {
2045                 stringBytes = (const wchar_t *) env->GetStringChars(newValue, 0);
2046                 if (stringBytes == NULL) {
2047                     if (!env->ExceptionCheck()) {
2048                         jclass cls = env->FindClass("java/lang/OutOfMemoryError");
2049                         if (cls != NULL) {
2050                             env->ThrowNew(cls, NULL);
2051                         }
2052                     }
2053                     return;
2054                 }
2055                 wcsncpy(pkg->newState, stringBytes, (sizeof(pkg->newState) / sizeof(wchar_t)));
2056                 env->ReleaseStringChars(newValue, stringBytes);
2057             } else {
2058                 wcsncpy(pkg->newState, L"(null)", (sizeof(pkg->newState) / sizeof(wchar_t)));
2059             }
2060 
2061             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyStateChangeEvent);
2062         }
2063         ati = ati->nextATInstance;
2064     }
2065     PrintDebugString("  done with propertyStateChange event");
2066 }
2067 
2068 
2069 /**
2070  * firePropertyTextChange
2071  *
2072  */
2073 void
2074 JavaAccessBridge::firePropertyTextChange(JNIEnv *env, jobject callingObj,
2075                                          jobject event, jobject source) {
2076 
2077     PrintDebugString("\r\nJava_com_sun_java_accessibility_internal_AccessBridge_propertyTextChanged(%p, %p, %p, %p)",
2078                      env, callingObj, event, source);
2079 
2080     // sanity check
2081     if (ATs == (AccessBridgeATInstance *) 0) {
2082         PrintDebugString("  ERROR!! ATs == 0! (shouldn't happen here!)");
2083         return;         // panic!
2084     }
2085 
2086     // common setup
2087     char buffer[sizeof(PackageType) + sizeof(PropertyTextChangePackage)];
2088     PackageType *type = (PackageType *) buffer;
2089     PropertyTextChangePackage *pkg = (PropertyTextChangePackage *) (buffer + sizeof(PackageType));
2090     *type = cPropertyTextChangePackage;
2091     pkg->vmID = (long) dialogWindow;
2092 
2093     // make new Global Refs and send events only to those ATs that want 'em
2094     AccessBridgeATInstance *ati = ATs;
2095     while (ati != (AccessBridgeATInstance *) 0) {
2096         if (ati->accessibilityEventMask & cPropertyTextChangeEvent) {
2097 
2098             PrintDebugString("  sending to AT");
2099 
2100             // make new GlobalRefs for this AT
2101             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
2102             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
2103 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2104             PrintDebugString("  GlobalRef'd Event: %p", pkg->Event);
2105             PrintDebugString("  GlobalRef'd Source: %p", pkg->AccessibleContextSource);
2106 #else // JOBJECT64 is jlong (64 bit)
2107             PrintDebugString("  GlobalRef'd Event: %016I64X", pkg->Event);
2108             PrintDebugString("  GlobalRef'd Source: %016I64X", pkg->AccessibleContextSource);
2109 #endif
2110 
2111             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyTextChangeEvent);
2112         }
2113         ati = ati->nextATInstance;
2114     }
2115     PrintDebugString("  done with propertyTextChange event");
2116 }
2117 
2118 
2119 /**
2120  * firePropertyValueChange
2121  *
2122  */
2123 void
2124 JavaAccessBridge::firePropertyValueChange(JNIEnv *env, jobject callingObj,
2125                                           jobject event, jobject source,
2126                                           jstring oldValue, jstring newValue){
2127 
2128     PrintDebugString("\r\nJava_com_sun_java_accessibility_internal_AccessBridge_propertyValueChanged(%p, %p, %p, %p, %p, %p)",
2129                      env, callingObj, event,
2130                      source, oldValue, newValue);
2131 
2132     // sanity check
2133     if (ATs == (AccessBridgeATInstance *) 0) {
2134         PrintDebugString("  ERROR!! ATs == 0! (shouldn't happen here!)");
2135         return;         // panic!
2136     }
2137 
2138     // common setup
2139     const wchar_t *stringBytes;
2140     char buffer[sizeof(PackageType) + sizeof(PropertyValueChangePackage)];
2141     PackageType *type = (PackageType *) buffer;
2142     PropertyValueChangePackage *pkg = (PropertyValueChangePackage *) (buffer + sizeof(PackageType));
2143     *type = cPropertyValueChangePackage;
2144     pkg->vmID = (long) dialogWindow;
2145 
2146     // make new Global Refs and send events only to those ATs that want 'em
2147     AccessBridgeATInstance *ati = ATs;
2148     while (ati != (AccessBridgeATInstance *) 0) {
2149         if (ati->accessibilityEventMask & cPropertyValueChangeEvent) {
2150 
2151             PrintDebugString("  sending to AT");
2152 
2153             // make new GlobalRefs for this AT
2154             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
2155             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
2156 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2157             PrintDebugString("  GlobalRef'd Event: %p", pkg->Event);
2158             PrintDebugString("  GlobalRef'd Source: %p", pkg->AccessibleContextSource);
2159 #else // JOBJECT64 is jlong (64 bit)
2160             PrintDebugString("  GlobalRef'd Event: %016I64X", pkg->Event);
2161             PrintDebugString("  GlobalRef'd Source: %016I64X", pkg->AccessibleContextSource);
2162 #endif
2163 
2164             if (oldValue != (jstring) 0) {
2165                 stringBytes = (const wchar_t *) env->GetStringChars(oldValue, 0);
2166                 if (stringBytes == NULL) {
2167                     if (!env->ExceptionCheck()) {
2168                         jclass cls = env->FindClass("java/lang/OutOfMemoryError");
2169                         if (cls != NULL) {
2170                             env->ThrowNew(cls, NULL);
2171                         }
2172                     }
2173                     return;
2174                 }
2175                 wcsncpy(pkg->oldValue, stringBytes, (sizeof(pkg->oldValue) / sizeof(wchar_t)));
2176                 env->ReleaseStringChars(oldValue, stringBytes);
2177             } else {
2178                 wcsncpy(pkg->oldValue, L"(null)", (sizeof(pkg->oldValue) / sizeof(wchar_t)));
2179             }
2180 
2181             if (newValue != (jstring) 0) {
2182                 stringBytes = (const wchar_t *) env->GetStringChars(newValue, 0);
2183                 if (stringBytes == NULL) {
2184                     if (!env->ExceptionCheck()) {
2185                         jclass cls = env->FindClass("java/lang/OutOfMemoryError");
2186                         if (cls != NULL) {
2187                             env->ThrowNew(cls, NULL);
2188                         }
2189                     }
2190                     return;
2191                 }
2192                 wcsncpy(pkg->newValue, stringBytes, (sizeof(pkg->newValue) / sizeof(wchar_t)));
2193                 env->ReleaseStringChars(newValue, stringBytes);
2194             } else {
2195                 wcsncpy(pkg->newValue, L"(null)", (sizeof(pkg->newValue) / sizeof(wchar_t)));
2196             }
2197 
2198             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyValueChangeEvent);
2199         }
2200         ati = ati->nextATInstance;
2201     }
2202     PrintDebugString("  done with propertyValueChange event");
2203 }
2204 
2205 /**
2206  * firePropertyVisibleDataChange
2207  *
2208  */
2209 void
2210 JavaAccessBridge::firePropertyVisibleDataChange(JNIEnv *env, jobject callingObj,
2211                                                 jobject event, jobject source) {
2212 
2213     PrintDebugString("\r\nJava_com_sun_java_accessibility_internal_AccessBridge_propertyVisibleDataChanged(%p, %p, %p, %p)",
2214                      env, callingObj, event, source);
2215 
2216     // sanity check
2217     if (ATs == (AccessBridgeATInstance *) 0) {
2218         PrintDebugString("  ERROR!! ATs == 0! (shouldn't happen here!)");
2219         return;         // panic!
2220     }
2221 
2222     // common setup
2223     char buffer[sizeof(PackageType) + sizeof(PropertyVisibleDataChangePackage)];
2224     PackageType *type = (PackageType *) buffer;
2225     PropertyVisibleDataChangePackage *pkg = (PropertyVisibleDataChangePackage *) (buffer + sizeof(PackageType));
2226     *type = cPropertyVisibleDataChangePackage;
2227     pkg->vmID = (long) dialogWindow;
2228 
2229     // make new Global Refs and send events only to those ATs that want 'em
2230     AccessBridgeATInstance *ati = ATs;
2231     while (ati != (AccessBridgeATInstance *) 0) {
2232         if (ati->accessibilityEventMask & cPropertyVisibleDataChangeEvent) {
2233 
2234             PrintDebugString("  sending to AT");
2235 
2236             // make new GlobalRefs for this AT
2237             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
2238             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
2239 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2240             PrintDebugString("  GlobalRef'd Event: %p", pkg->Event);
2241             PrintDebugString("  GlobalRef'd Source: %p", pkg->AccessibleContextSource);
2242 #else // JOBJECT64 is jlong (64 bit)
2243             PrintDebugString("  GlobalRef'd Event: %016I64X", pkg->Event);
2244             PrintDebugString("  GlobalRef'd Source: %016I64X", pkg->AccessibleContextSource);
2245 #endif
2246 
2247             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyVisibleDataChangeEvent);
2248         }
2249         ati = ati->nextATInstance;
2250     }
2251     PrintDebugString("  done with propertyVisibleDataChange event");
2252 }
2253 
2254 
2255 /**
2256  * firePropertyChildChange
2257  *
2258  */
2259 void
2260 JavaAccessBridge::firePropertyChildChange(JNIEnv *env, jobject callingObj,
2261                                           jobject event, jobject source,
2262                                           jobject oldValue, jobject newValue){
2263 
2264     PrintDebugString("\r\nJava_com_sun_java_accessibility_internal_AccessBridge_propertyChildPropertyChanged(%p, %p, %p, %p, %p, %p)",
2265                      env, callingObj, event,
2266                      source, oldValue, newValue);
2267 
2268     // sanity check
2269     if (ATs == (AccessBridgeATInstance *) 0) {
2270         PrintDebugString("  ERROR!! ATs == 0! (shouldn't happen here!)");
2271         return;         // panic!
2272     }
2273 
2274     // common setup
2275     char buffer[sizeof(PackageType) + sizeof(PropertyChildChangePackage)];
2276     PackageType *type = (PackageType *) buffer;
2277     PropertyChildChangePackage *pkg = (PropertyChildChangePackage *) (buffer + sizeof(PackageType));
2278     *type = cPropertyChildChangePackage;
2279     pkg->vmID = (long) dialogWindow;
2280 
2281     // make new Global Refs and send events only to those ATs that want 'em
2282     AccessBridgeATInstance *ati = ATs;
2283     while (ati != (AccessBridgeATInstance *) 0) {
2284         if (ati->accessibilityEventMask & cPropertyChildChangeEvent) {
2285 
2286             PrintDebugString("  sending to AT");
2287 
2288             // make new GlobalRefs for this AT
2289             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
2290             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
2291             pkg->oldChildAccessibleContext = (JOBJECT64)env->NewGlobalRef(oldValue);
2292             pkg->newChildAccessibleContext = (JOBJECT64)env->NewGlobalRef(newValue);
2293 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2294             PrintDebugString("  GlobalRef'd Event: %p", pkg->Event);
2295             PrintDebugString("  GlobalRef'd Source: %p", pkg->AccessibleContextSource);
2296             PrintDebugString("  GlobalRef'd OldChildAC: %p", pkg->oldChildAccessibleContext);
2297             PrintDebugString("  GlobalRef'd NewChildAC: %p", pkg->newChildAccessibleContext);

2298 #else // JOBJECT64 is jlong (64 bit)
2299             PrintDebugString("  GlobalRef'd Event: %016I64X", pkg->Event);
2300             PrintDebugString("  GlobalRef'd Source: %016I64X", pkg->AccessibleContextSource);
2301             PrintDebugString("  GlobalRef'd OldChildAC: %016I64X", pkg->oldChildAccessibleContext);
2302             PrintDebugString("  GlobalRef'd NewChildAC: %016I64X", pkg->newChildAccessibleContext);

2303 #endif
2304 
2305             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyChildChangeEvent);
2306         }
2307         ati = ati->nextATInstance;
2308     }
2309     PrintDebugString("  done with propertyChildChange event");
2310 }
2311 
2312 
2313 /**
2314  * firePropertyActiveDescendentChange
2315  *
2316  */
2317 void
2318 JavaAccessBridge::firePropertyActiveDescendentChange(JNIEnv *env, jobject callingObj,
2319                                                      jobject event, jobject source,
2320                                                      jobject oldValue, jobject newValue){
2321 
2322     PrintDebugString("\r\nJava_com_sun_java_accessibility_internal_AccessBridge_propertyActiveDescendentPropertyChanged(%p, %p, %p, %p, %p, %p)",
2323                      env, callingObj, event,
2324                      source, oldValue, newValue);
2325 
2326     // sanity check
2327     if (ATs == (AccessBridgeATInstance *) 0) {
2328         PrintDebugString("  ERROR!! ATs == 0! (shouldn't happen here!)");
2329         return;         // panic!
2330     }
2331 
2332     // common setup
2333     char buffer[sizeof(PackageType) + sizeof(PropertyActiveDescendentChangePackage)];
2334     PackageType *type = (PackageType *) buffer;
2335     PropertyActiveDescendentChangePackage *pkg = (PropertyActiveDescendentChangePackage *) (buffer + sizeof(PackageType));
2336     *type = cPropertyActiveDescendentChangePackage;
2337     pkg->vmID = (long) dialogWindow;
2338 
2339     // make new Global Refs and send events only to those ATs that want 'em
2340     AccessBridgeATInstance *ati = ATs;
2341     while (ati != (AccessBridgeATInstance *) 0) {
2342         if (ati->accessibilityEventMask & cPropertyActiveDescendentChangeEvent) {
2343 
2344             PrintDebugString("  sending to AT");
2345 
2346             // make new GlobalRefs for this AT
2347             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
2348             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
2349             pkg->oldActiveDescendentAccessibleContext = (JOBJECT64)env->NewGlobalRef(oldValue);
2350             pkg->newActiveDescendentAccessibleContext = (JOBJECT64)env->NewGlobalRef(newValue);
2351 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2352             PrintDebugString("  GlobalRef'd Event: %p", pkg->Event);
2353             PrintDebugString("  GlobalRef'd Source: %p", pkg->AccessibleContextSource);
2354             PrintDebugString("  GlobalRef'd OldActiveDescendentAC: %p", pkg->oldActiveDescendentAccessibleContext);
2355             PrintDebugString("  GlobalRef'd NewActiveDescendentAC: %p", pkg->newActiveDescendentAccessibleContext);

2356 #else // JOBJECT64 is jlong (64 bit)
2357             PrintDebugString("  GlobalRef'd Event: %016I64X", pkg->Event);
2358             PrintDebugString("  GlobalRef'd Source: %016I64X", pkg->AccessibleContextSource);
2359             PrintDebugString("  GlobalRef'd OldActiveDescendentAC: %016I64X", pkg->oldActiveDescendentAccessibleContext);
2360             PrintDebugString("  GlobalRef'd NewActiveDescendentAC: %016I64X", pkg->newActiveDescendentAccessibleContext);

2361 #endif
2362 
2363             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyActiveDescendentChangeEvent);
2364         }
2365         ati = ati->nextATInstance;
2366     }
2367     PrintDebugString("  done with propertyActiveChange event");
2368 }
2369 
2370 /**
2371  * firePropertyValueChange
2372  *
2373  */
2374 void
2375 JavaAccessBridge::firePropertyTableModelChange(JNIEnv *env, jobject callingObj,
2376                                                jobject event, jobject source,
2377                                                jstring oldValue, jstring newValue){
2378 
2379     PrintDebugString("\r\nJava_com_sun_java_accessibility_internal_AccessBridge_propertyTableModelChange(%p, %p, %p, %p, %p, %p)",
2380                      env, callingObj, event,
2381                      source, oldValue, newValue);
2382 
2383     // sanity check
2384     if (ATs == (AccessBridgeATInstance *) 0) {
2385         PrintDebugString("  ERROR!! ATs == 0! (shouldn't happen here!)");
2386         return;         // panic!
2387     }
2388 
2389     // common setup
2390     const wchar_t *stringBytes;
2391     char buffer[sizeof(PackageType) + sizeof(PropertyTableModelChangePackage)];
2392     PackageType *type = (PackageType *) buffer;
2393     PropertyTableModelChangePackage *pkg = (PropertyTableModelChangePackage *) (buffer + sizeof(PackageType));
2394     *type = cPropertyTableModelChangePackage;
2395     pkg->vmID = (long) dialogWindow;
2396 
2397     // make new Global Refs and send events only to those ATs that want 'em
2398     AccessBridgeATInstance *ati = ATs;
2399     while (ati != (AccessBridgeATInstance *) 0) {
2400         if (ati->accessibilityEventMask & cPropertyTableModelChangeEvent) {
2401 
2402             PrintDebugString("  sending to AT");
2403 
2404             // make new GlobalRefs for this AT
2405             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
2406             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
2407 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2408             PrintDebugString("  GlobalRef'd Event: %p", pkg->Event);
2409             PrintDebugString("  GlobalRef'd Source: %p", pkg->AccessibleContextSource);
2410 #else // JOBJECT64 is jlong (64 bit)
2411             PrintDebugString("  GlobalRef'd Event: %016I64X", pkg->Event);
2412             PrintDebugString("  GlobalRef'd Source: %016I64X", pkg->AccessibleContextSource);
2413 #endif
2414 
2415             if (oldValue != (jstring) 0) {
2416                 stringBytes = (const wchar_t *) env->GetStringChars(oldValue, 0);
2417                 if (stringBytes == NULL) {
2418                     if (!env->ExceptionCheck()) {
2419                         jclass cls = env->FindClass("java/lang/OutOfMemoryError");
2420                         if (cls != NULL) {
2421                             env->ThrowNew(cls, NULL);
2422                         }
2423                     }
2424                     return;
2425                 }
2426                 wcsncpy(pkg->oldValue, stringBytes, (sizeof(pkg->oldValue) / sizeof(wchar_t)));
2427                 env->ReleaseStringChars(oldValue, stringBytes);
2428             } else {
2429                 wcsncpy(pkg->oldValue, L"(null)", (sizeof(pkg->oldValue) / sizeof(wchar_t)));
2430             }
2431 
2432             if (newValue != (jstring) 0) {
2433                 stringBytes = (const wchar_t *) env->GetStringChars(newValue, 0);
2434                 if (stringBytes == NULL) {
2435                     if (!env->ExceptionCheck()) {
2436                         jclass cls = env->FindClass("java/lang/OutOfMemoryError");
2437                         if (cls != NULL) {
2438                             env->ThrowNew(cls, NULL);
2439                         }
2440                     }
2441                     return;
2442                 }
2443                 wcsncpy(pkg->newValue, stringBytes, (sizeof(pkg->newValue) / sizeof(wchar_t)));
2444                 env->ReleaseStringChars(newValue, stringBytes);
2445             } else {
2446                 wcsncpy(pkg->newValue, L"(null)", (sizeof(pkg->newValue) / sizeof(wchar_t)));
2447             }
2448 
2449             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyTableModelChangeEvent);
2450         }
2451         ati = ati->nextATInstance;
2452     }
2453     PrintDebugString("  done with propertyTableModelChange event");
2454 }
2455 
2456 
2457 
2458 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2459 #define PRINT_GLOBALREFS() \
2460     PrintDebugString("  GlobalRef'd Event: %p", pkg->Event); \
2461     PrintDebugString("  GlobalRef'd Source: %p", pkg->AccessibleContextSource);
2462 #else // JOBJECT64 is jlong (64 bit)
2463 #define PRINT_GLOBALREFS() \
2464     PrintDebugString("  GlobalRef'd Event: %016I64X", pkg->Event); \
2465     PrintDebugString("  GlobalRef'd Source: %016I64X", pkg->AccessibleContextSource);
2466 #endif
2467 
2468 #define FIRE_EVENT(function, packageStruct, packageConstant, eventConstant)             \
2469     void JavaAccessBridge::function(JNIEnv *env, jobject callingObj,                    \
2470                                     jobject eventObj, jobject source) {                 \
2471                                                                                         \
2472         PrintDebugString("\r\nFiring event id = %d(%p, %p, %p, %p); vmID = %X",         \
2473                          eventConstant, env, callingObj, eventObj, source, dialogWindow); \
2474                                                                                         \
2475         /* sanity check */                                                              \
2476         if (ATs == (AccessBridgeATInstance *) 0) {                                      \
2477             PrintDebugString("  ERROR!! ATs == 0! (shouldn't happen here!)");           \
2478             return;         /* panic! */                                                \
2479         }                                                                               \
2480                                                                                         \
2481         /* common setup */                                                              \
2482         char buffer[sizeof(PackageType) + sizeof(packageStruct)];                       \
2483         PackageType *type = (PackageType *) buffer;                                     \
2484         packageStruct *pkg = (packageStruct *) (buffer + sizeof(PackageType));          \
2485         *type = packageConstant;                                                        \
2486         pkg->vmID = (long) dialogWindow;                                                \
2487                                                                                         \
2488         /* make new Global Refs, send events only to those ATs that want 'em */         \
2489         AccessBridgeATInstance *ati = ATs;                                              \
2490         while (ati != (AccessBridgeATInstance *) 0) {                                   \
2491             PrintDebugString("\r\njavaEventMask = %X eventConstant=%d pkg->vmID=%X",    \
2492                              ati->javaEventMask, eventConstant, pkg->vmID );            \
2493             if (ati->javaEventMask & eventConstant) {                                   \
2494                                                                                         \
2495                 PrintDebugString("  sending to AT");                                    \
2496                 /* make new GlobalRefs for this AT */                                   \
2497                 pkg->Event = (JOBJECT64)env->NewGlobalRef(eventObj);                    \
2498                 pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);    \
2499                 PRINT_GLOBALREFS()                                                      \
2500                                                                                         \
2501                 ati->sendJavaEventPackage(buffer, sizeof(buffer), eventConstant);       \
2502             }                                                                           \
2503             ati = ati->nextATInstance;                                                  \
2504         }                                                                               \
2505         PrintDebugString("  done with firing AWT event");                               \
2506     }
2507 
2508     void JavaAccessBridge::javaShutdown(JNIEnv *env, jobject callingObj) {
2509 
2510         PrintDebugString("\r\nFiring event id = %d(%p, %p); vmID = %X",
2511                          cJavaShutdownEvent, env, callingObj, dialogWindow);
2512 
2513         /* sanity check */
2514         if (ATs == (AccessBridgeATInstance *) 0) {
2515             PrintDebugString("  ERROR!! ATs == 0! (shouldn't happen here!)");
2516             return;             /* panic! */
2517         }
2518 
2519         /* common setup */
2520         char buffer[sizeof(PackageType) + sizeof(JavaShutdownPackage)];
2521         PackageType *type = (PackageType *) buffer;
2522         JavaShutdownPackage *pkg = (JavaShutdownPackage *) (buffer + sizeof(PackageType));
2523         *type = cJavaShutdownPackage;
2524         pkg->vmID = (long) dialogWindow;
2525 
2526         /* make new Global Refs, send events only to those ATs that want 'em */
2527         AccessBridgeATInstance *ati = ATs;
2528         while (ati != (AccessBridgeATInstance *) 0) {
2529             if (ati->javaEventMask & cJavaShutdownEvent) {
2530                 PrintDebugString("  sending to AT");
2531                 ati->sendJavaEventPackage(buffer, sizeof(buffer), cJavaShutdownEvent);
2532             }
2533             ati = ati->nextATInstance;
2534         }
2535         PrintDebugString("  done with firing AWT event");
2536     }
2537 
2538     FIRE_EVENT(fireFocusGained, FocusGainedPackage, cFocusGainedPackage, cFocusGainedEvent)
2539     FIRE_EVENT(fireFocusLost, FocusLostPackage, cFocusLostPackage, cFocusLostEvent)
2540     FIRE_EVENT(fireCaretUpdate, CaretUpdatePackage, cCaretUpdatePackage, cCaretUpdateEvent)
2541     FIRE_EVENT(fireMouseClicked, MouseClickedPackage, cMouseClickedPackage, cMouseClickedEvent)
2542     FIRE_EVENT(fireMouseEntered, MouseEnteredPackage, cMouseEnteredPackage, cMouseEnteredEvent)
2543     FIRE_EVENT(fireMouseExited, MouseExitedPackage, cMouseExitedPackage, cMouseExitedEvent)
2544     FIRE_EVENT(fireMousePressed, MousePressedPackage, cMousePressedPackage, cMousePressedEvent)
2545     FIRE_EVENT(fireMouseReleased, MouseReleasedPackage, cMouseReleasedPackage, cMouseReleasedEvent)
2546     FIRE_EVENT(fireMenuCanceled, MenuCanceledPackage, cMenuCanceledPackage, cMenuCanceledEvent)
2547     FIRE_EVENT(fireMenuDeselected, MenuDeselectedPackage, cMenuDeselectedPackage, cMenuDeselectedEvent)
2548     FIRE_EVENT(fireMenuSelected, MenuSelectedPackage, cMenuSelectedPackage, cMenuSelectedEvent)
2549     FIRE_EVENT(firePopupMenuCanceled, PopupMenuCanceledPackage, cPopupMenuCanceledPackage, cPopupMenuCanceledEvent)
2550     FIRE_EVENT(firePopupMenuWillBecomeInvisible, PopupMenuWillBecomeInvisiblePackage, cPopupMenuWillBecomeInvisiblePackage, cPopupMenuWillBecomeInvisibleEvent)
2551     FIRE_EVENT(firePopupMenuWillBecomeVisible, PopupMenuWillBecomeVisiblePackage, cPopupMenuWillBecomeVisiblePackage, cPopupMenuWillBecomeVisibleEvent)
2552 
2553 
2554     // -----------------------------
2555 




  68             InitializeCriticalSection(&receiveMemoryIPCLock);
  69             theJavaAccessBridge = new JavaAccessBridge(hinstDll);
  70             break;
  71 
  72         case DLL_PROCESS_DETACH:        // A Windows executable unloaded us
  73             if (theJavaAccessBridge != (JavaAccessBridge *) 0) {
  74                 delete theJavaAccessBridge;
  75                 DeleteCriticalSection(&receiveMemoryIPCLock);
  76             }
  77             break;
  78         }
  79         return TRUE;
  80     }
  81 
  82     /**
  83      * Open a native window (and init the wrappers we'll be using)
  84      *
  85      */
  86     JNIEXPORT void JNICALL
  87     Java_com_sun_java_accessibility_internal_AccessBridge_runDLL(JNIEnv *env, jobject obj) {
  88         PrintDebugString("[INFO]: JavaAccessBridge.DLL runDLL() called");
  89         theJavaAccessBridge->javaRun(env, obj);
  90     }
  91 
  92     /**
  93      * Our window proc
  94      *
  95      */
  96     BOOL APIENTRY AccessBridgeDialogProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) {
  97         int command;
  98         COPYDATASTRUCT *sentToUs;
  99         char *package;
 100 
 101         switch (message) {
 102         case WM_INITDIALOG:
 103             PrintDebugString("[INFO]: In AccessBridgeDialog - Initializing");
 104             break;
 105 
 106         case WM_COMMAND:
 107             command = LOWORD (wParam);
 108             PrintDebugString("[INFO]: In AccessBridgeDialog - Got WM_COMMAND, command: %X", command);
 109             break;
 110 
 111             // call from Java with data for us to deliver
 112         case WM_COPYDATA:
 113             if (theDialogWindow == (HWND) wParam) {
 114                 PrintDebugString("[INFO]: In AccessBridgeDialog - Got WM_COPYDATA from ourselves");
 115             } else {
 116                 PrintDebugString("[INFO]: In AccessBridgeDialog - Got WM_COPYDATA from HWND %p", wParam);
 117                 sentToUs = (COPYDATASTRUCT *) lParam;
 118                 package = (char *) sentToUs->lpData;
 119                 theJavaAccessBridge->processPackage(package, sentToUs->cbData);
 120             }
 121             break;
 122 
 123             // call from Java with data for us retrieve from memory mapped file and deliver
 124         case AB_MESSAGE_WAITING:
 125             // wParam == sourceHwnd
 126             // lParam == buffer size in shared memory
 127             if (theDialogWindow == (HWND) wParam) {
 128                 PrintDebugString("[INFO]: In AccessBridgeDialog - Got AB_MESSAGE_WAITING from ourselves");
 129             } else {
 130                 PrintDebugString("[INFO]: In AccessBridgeDialog - Got AB_MESSAGE_WAITING from HWND %p", wParam);
 131                 LRESULT returnVal = theJavaAccessBridge->receiveMemoryPackage((HWND) wParam, (long) lParam);
 132             }
 133             break;
 134 
 135             // a JavaAccessBridge DLL is going away
 136         case AB_DLL_GOING_AWAY:
 137             PrintDebugString("[INFO]: In AccessBridgeDialog - Got AB_DLL_GOING_AWAY message");
 138             theJavaAccessBridge->WindowsATDestroyed((HWND) wParam);
 139             break;
 140 
 141         default:
 142             // the Windows AT is saying "hi"!
 143             // wParam == sourceHwnc; lParam unused
 144             if (message == theFromWindowsHelloMsgID) {
 145                 // A new Windows AT just said "hi";
 146                 // say "hi" back so it can mate up with us
 147                 // otherwise don't do anything (e.g. don't set up data structures yet)
 148                 PrintDebugString("[INFO]: In AccessBridgeDialog - Got theFromWindowsHelloMsgID message");
 149                 theJavaAccessBridge->postHelloToWindowsDLLMsg((HWND) wParam);
 150             }
 151         }
 152         return FALSE;
 153     }
 154 
 155 }
 156 
 157 
 158 // -----------------------------
 159 
 160 
 161 /**
 162  * Initialize the JavaAccessBridge
 163  *
 164  */
 165 JavaAccessBridge::JavaAccessBridge(HINSTANCE hInstance) {
 166     windowsInstance = hInstance;
 167     ATs = (AccessBridgeATInstance *) 0;
 168     initializeFileLogger("_java_access_bridge");
 169     initBroadcastMessageIDs();          // get the unique to us broadcast msg. IDs
 170 }
 171 
 172 extern DWORD JavaBridgeThreadId;
 173 
 174 /**
 175  * Destroy the JavaAccessBridge
 176  *
 177  */
 178 JavaAccessBridge::~JavaAccessBridge() {
 179     // inform all other AccessBridges that we're going away
 180 
 181     PrintDebugString("[INFO]: in JavaAccessBridge::~JavaAccessBridge()");
 182 
 183     // Send a shutdown message for those applications like StarOffice that do
 184     // send a shutdown message themselves.
 185     javaShutdown(NULL, 0);
 186 
 187     AccessBridgeATInstance *current = ATs;
 188     while (current != (AccessBridgeATInstance *) 0) {
 189         PrintDebugString("[INFO]:  telling %p we're going away", current->winAccessBridgeWindow);
 190                 SendMessage(current->winAccessBridgeWindow,
 191                     AB_DLL_GOING_AWAY, (WPARAM) dialogWindow, (LPARAM) 0);
 192         current = current->nextATInstance;
 193     }
 194 
 195     PrintDebugString("[INFO]:  finished telling ATs about our demise");
 196 
 197         if(JavaBridgeThreadId)
 198                 {
 199                 PostThreadMessage(JavaBridgeThreadId,WM_USER+1,0,0);
 200                 Sleep(100);
 201                 }
 202 
 203     delete ATs;
 204 
 205     PrintDebugString("[INFO]:   finished deleting ATs");
 206     PrintDebugString("[INFO]: GOODBYE CRUEL WORLD...");
 207     finalizeFileLogger();
 208 }
 209 
 210 
 211 void
 212 JavaAccessBridge::javaRun(JNIEnv *env, jobject obj) {
 213     MSG msg;
 214 
 215     PrintDebugString("[INFO]: JavaAccessBridge::javaRun(%p, %p) called", env, obj);
 216 
 217     if (env->GetJavaVM(&javaVM) != 0) {
 218         return; // huh!?!?!
 219     }
 220     PrintDebugString("[INFO]:   -> javaVM = %p", javaVM);
 221 
 222     if (javaVM->AttachCurrentThread((void **) &windowsThreadJNIEnv, NULL) != 0) {
 223         return; // huh!?!?!
 224     }
 225     PrintDebugString("[INFO]:  -> windowsThreadJNIEnv = %p", windowsThreadJNIEnv);
 226 
 227     javaThreadABObject = env->NewGlobalRef(obj);
 228     windowsThreadABObject = windowsThreadJNIEnv->NewGlobalRef(obj);
 229 
 230     // initialize the Java thread AccessBridge entry points
 231     javaThreadEntryPoints = new AccessBridgeJavaEntryPoints(env, javaThreadABObject);
 232     if (javaThreadEntryPoints->BuildJavaEntryPoints() == FALSE) {
 233         return;         // couldn't build our entry points; let's get out of here!
 234     }
 235     PrintDebugString("[INFO]:   all Java thread entry points successfully found.");
 236 
 237     // initialize the Windows thread AccessBridge entry points
 238     windowsThreadEntryPoints = new AccessBridgeJavaEntryPoints(windowsThreadJNIEnv,
 239                                                                windowsThreadABObject);
 240     if (windowsThreadEntryPoints->BuildJavaEntryPoints() == FALSE) {
 241         return;         // couldn't build our entry points; let's get out of here!
 242     }
 243     PrintDebugString("[INFO]:   all Windows thread entry points successfully found.");
 244 
 245 
 246     // open our window
 247     if (initWindow() == TRUE) {
 248         PrintDebugString("[INFO]:   Window created.  HWND = %p", dialogWindow);
 249 
 250         // post a broadcast msg.; let other AccessBridge DLLs know we exist
 251         postHelloToWindowsDLLMsg(HWND_BROADCAST);
 252 
 253         // do that message loop thing
 254         while (GetMessage(&msg, NULL, 0, 0)) {
 255             TranslateMessage(&msg);
 256             DispatchMessage(&msg);
 257         }
 258     } else {
 259         PrintDebugString("[ERROR]:   FAILED TO CREATE WINDOW!!!");
 260     }
 261 
 262     javaVM->DetachCurrentThread();
 263 }
 264 
 265 /**
 266  * Bring up our window; make a connection to the rest of the world
 267  *
 268  */
 269 BOOL
 270 JavaAccessBridge::initWindow() {
 271     theDialogWindow = CreateDialog(windowsInstance,
 272                                    "ACCESSBRIDGESTATUSWINDOW", NULL,
 273                                    (DLGPROC) AccessBridgeDialogProc);
 274 
 275     // If window could not be created, return "failure".
 276     if (!theDialogWindow)
 277         return FALSE;
 278 
 279     dialogWindow = theDialogWindow;


 286 }
 287 
 288 
 289 
 290 // -----------------------
 291 
 292 
 293 /**
 294  * postHelloToWindowsDLLMsg
 295  *          - PostMessage(theFromJavaHelloMsgID) to let one or
 296  *            all WindowDLLs we're here and have a vmID
 297  *
 298  *            destHwnd is either a single hwnd or HWND_BROADCAST
 299  *              (former if a reply, latter if we're just born)
 300  *            wParam is our HWND
 301  *            lParam is our vmID
 302  *
 303  */
 304 void
 305 JavaAccessBridge::postHelloToWindowsDLLMsg(HWND destHwnd) {
 306     PrintDebugString("[INFO]: In JavaAccessBridge::postHelloToWindowsDLLMsg");
 307     PrintDebugString("[INFO]:   calling PostMessage(%p, %X, %p, %p)",
 308                      destHwnd, theFromJavaHelloMsgID, dialogWindow, dialogWindow);
 309     PostMessage(destHwnd, theFromJavaHelloMsgID, (WPARAM) dialogWindow, (LPARAM) dialogWindow);
 310 }
 311 
 312 
 313 // -----------------------
 314 
 315 /**
 316  * sendPackage - uses SendMessage(WM_COPYDATA) to do IPC messaging
 317  *                                with the Java AccessBridge DLL
 318  *
 319  */
 320 void
 321 JavaAccessBridge::sendPackage(char *buffer, int bufsize, HWND destHwnd) {
 322     COPYDATASTRUCT toCopy;
 323     toCopy.dwData = 0;          // 32-bits we could use for something...
 324     toCopy.cbData = bufsize;
 325     toCopy.lpData = buffer;
 326 
 327     SendMessage(destHwnd, WM_COPYDATA, (WPARAM) dialogWindow, (LPARAM) &toCopy);
 328 }
 329 
 330 
 331 /**
 332  * sendJavaEventPackage - walk through ATs, sending event messages to 'em
 333  *
 334  */
 335 void
 336 JavaAccessBridge::sendJavaEventPackage(char *buffer, int bufsize, long type) {
 337 
 338     PrintDebugString("[INFO]: JavaAccessBridge::sendJavaEventPackage(), type = %X", type);
 339 
 340     if (ATs == (AccessBridgeATInstance *) 0) {
 341         PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)");
 342     }
 343 
 344     AccessBridgeATInstance *ati = ATs;
 345     while (ati != (AccessBridgeATInstance *) 0) {
 346         ati->sendJavaEventPackage(buffer, bufsize, type);
 347         ati = ati->nextATInstance;
 348     }
 349 }
 350 
 351 /**
 352  * sendAccessibilityEventPackage - walk through ATs, sending event messages to 'em
 353  *
 354  */
 355 void
 356 JavaAccessBridge::sendAccessibilityEventPackage(char *buffer, int bufsize, long type) {
 357 
 358     PrintDebugString("[INFO]: JavaAccessBridge::sendAccessibilityEventPackage(), type = %X", type);
 359 
 360     if (ATs == (AccessBridgeATInstance *) 0) {
 361         PrintDebugString("[ERROR] ATs == 0! (shouldn't happen here!)");
 362     }
 363 
 364     AccessBridgeATInstance *ati = ATs;
 365     while (ati != (AccessBridgeATInstance *) 0) {
 366         ati->sendAccessibilityEventPackage(buffer, bufsize, type);
 367         ati = ati->nextATInstance;
 368     }
 369 }
 370 
 371 
 372 
 373 
 374 /**
 375  * receiveMemoryPackage - uses Memory-Mapped files to do IPC messaging
 376  *                        with the Java AccessBridge DLL, receiving the
 377  *                        message from Java AccessBridge DLL by reading the
 378  *                        contents of the shared memory mapped file that
 379  *                        is used for Java-initiated messages
 380  *
 381  */
 382 BOOL
 383 JavaAccessBridge::receiveMemoryPackage(HWND srcWindow, long bufsize) {
 384     char *IPCview;
 385 
 386     PrintDebugString("[INFO]: JavaAccessBridge::receiveMemoryPackage(%p, %d)", srcWindow, bufsize);
 387 
 388     // look-up the appropriate IPCview based on the srcHWND of the Windows AccessBridge DLL
 389     if (ATs == (AccessBridgeATInstance *) 0) {
 390         PrintDebugString("[ERROR]: - ATs == 0 (shouldn't happen in receiveMemoryPackage()!");
 391         return FALSE;
 392     }
 393     AccessBridgeATInstance *ati = ATs->findABATInstanceFromATHWND(srcWindow);
 394     if (ati != (AccessBridgeATInstance *) 0) {
 395         IPCview = (char *) ati->memoryMappedView;
 396 
 397         // wait for the lock if someone else has it (re-entrancy)
 398         EnterCriticalSection(&receiveMemoryIPCLock);
 399         {
 400             // set byte at end of buffer to indicate to caller that we have reached this point
 401             IPCview[bufsize] = 1;
 402 
 403             // process the package
 404             processPackage(IPCview, bufsize);
 405         }
 406         // release re-entrance lock
 407         LeaveCriticalSection(&receiveMemoryIPCLock);
 408 
 409         return TRUE;
 410 
 411     } else {
 412         //DEBUG_CODE(AppendToCallInfo("ERROR receiving memory package: couldn't find srcWindow"));
 413         PrintDebugString("[ERROR]: receiving memory package: couldn't find srcWindow");
 414         return FALSE;
 415     }
 416 }
 417 
 418 /**
 419  * processPackage - processes the output of SendMessage(WM_COPYDATA)
 420  *                                      to do IPC messaging with the Windows AccessBridge DLL
 421  *
 422  */
 423 LRESULT
 424 JavaAccessBridge::processPackage(char *buffer, int bufsize) {
 425     PrintDebugString("[INFO]: Processing package sent from Windows, bufsize = %d:", bufsize);
 426 
 427     PackageType *type = (PackageType *) buffer;
 428     LRESULT returnVal = 0;
 429     PrintDebugString("[INFO]:  PackageType = %X:", *type);
 430     jobject rAC;
 431 
 432     switch (*type) {
 433 
 434 
 435     case cMemoryMappedFileCreatedPackage:
 436         // Windows is telling us it created a memory mapped file for us to use
 437         // in repsonding to various information querying packages (see below)
 438         PrintDebugString("[INFO]:   type == cMemoryMappedFileCreatedPackage");
 439         if (bufsize == (sizeof(PackageType) + sizeof(MemoryMappedFileCreatedPackage))) {
 440             MemoryMappedFileCreatedPackage *pkg =
 441                 (MemoryMappedFileCreatedPackage *) (buffer + sizeof(PackageType));
 442             returnVal = MemoryMappedFileCreated((HWND)ABLongToHandle(pkg->bridgeWindow), pkg->filename);
 443         } else {
 444             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
 445                              bufsize, sizeof(PackageType) + sizeof(MemoryMappedFileCreatedPackage));
 446         }
 447         break;
 448 
 449         // ------------ information querying packages ------------------
 450 
 451     case cReleaseJavaObjectPackage:
 452         PrintDebugString("[INFO]:   type == cReleaseJavaObjectPackage");
 453         if (bufsize == (sizeof(PackageType) + sizeof(ReleaseJavaObjectPackage))) {
 454             ReleaseJavaObjectPackage *pkg =
 455                 (ReleaseJavaObjectPackage *) (buffer + sizeof(PackageType));
 456             releaseJavaObject((jobject)pkg->object);
 457         } else {
 458             PrintDebugString("[ERROR]:   processing FAILED!! -> bufsize = %d; expectation = %d",
 459                              bufsize, sizeof(PackageType) + sizeof(ReleaseJavaObjectPackage));
 460         }
 461         break;
 462 
 463     case cGetAccessBridgeVersionPackage:
 464         PrintDebugString("[INFO]:   type == cGetAccessBridgeVersionPackage");
 465         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessBridgeVersionPackage))) {
 466             GetAccessBridgeVersionPackage *pkg =
 467                 (GetAccessBridgeVersionPackage *) (buffer + sizeof(PackageType));
 468             windowsThreadEntryPoints->getVersionInfo(&(pkg->rVersionInfo));
 469         } else {
 470             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
 471                              bufsize, sizeof(PackageType) + sizeof(GetAccessBridgeVersionPackage));
 472         }
 473         break;
 474 
 475     case cIsJavaWindowPackage:
 476         PrintDebugString("[INFO]:   type == cIsJavaWindowPackage");
 477         if (bufsize == (sizeof(PackageType) + sizeof(IsJavaWindowPackage))) {
 478             IsJavaWindowPackage *pkg =
 479                 (IsJavaWindowPackage *) (buffer + sizeof(PackageType));
 480             pkg->rResult =
 481                 windowsThreadEntryPoints->isJavaWindow(pkg->window);
 482             PrintDebugString("[INFO]:     -> returning result = %d", pkg->rResult);
 483         } else {
 484             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
 485                              bufsize, sizeof(PackageType) + sizeof(IsJavaWindowPackage));
 486         }
 487         break;
 488 
 489     case cIsSameObjectPackage:
 490         PrintDebugString("[INFO]:   type == cIsSameObjectPackage");
 491         if (bufsize == (sizeof(PackageType) + sizeof(IsSameObjectPackage))) {
 492             IsSameObjectPackage *pkg =
 493                 (IsSameObjectPackage *) (buffer + sizeof(PackageType));
 494             pkg->rResult =
 495                 windowsThreadEntryPoints->isSameObject((jobject)pkg->obj1, (jobject)pkg->obj2);
 496             PrintDebugString("[INFO]:     -> returning result = %d", pkg->rResult);
 497         } else {
 498             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
 499                              bufsize, sizeof(PackageType) + sizeof(IsSameObjectPackage));
 500         }
 501         break;
 502 
 503 
 504     case cGetAccessibleContextFromHWNDPackage:
 505         PrintDebugString("[INFO]:    type == cGetAccessibleContextFromHWNDPackage");
 506         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleContextFromHWNDPackage))) {
 507             GetAccessibleContextFromHWNDPackage *pkg =
 508                 (GetAccessibleContextFromHWNDPackage *) (buffer + sizeof(PackageType));
 509             rAC = windowsThreadEntryPoints->getAccessibleContextFromHWND(pkg->window);
 510             pkg->rAccessibleContext = (JOBJECT64)rAC;
 511             pkg->rVMID = HandleToLong(dialogWindow);
 512             PrintDebugString("[INFO]:      -> returning AC = %p, vmID = %X", rAC, pkg->rVMID);
 513         } else {
 514             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
 515                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleContextFromHWNDPackage));
 516         }
 517         break;
 518 
 519 
 520     case cGetHWNDFromAccessibleContextPackage:
 521         PrintDebugString("[INFO]:    type == cGetHWNDFromAccessibleContextPackage");
 522         if (bufsize == (sizeof(PackageType) + sizeof(GetHWNDFromAccessibleContextPackage))) {
 523             GetHWNDFromAccessibleContextPackage *pkg =
 524                 (GetHWNDFromAccessibleContextPackage *) (buffer + sizeof(PackageType));
 525             pkg->rHWND =
 526                 ABHandleToLong( windowsThreadEntryPoints->getHWNDFromAccessibleContext((jobject)pkg->accessibleContext) );
 527             PrintDebugString("[INFO]:     -> returning HWND = %p", pkg->rHWND);
 528         } else {
 529             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
 530                              bufsize, sizeof(PackageType) + sizeof(GetHWNDFromAccessibleContextPackage));
 531         }
 532         break;
 533 
 534 
 535         /* ===== utility methods ===== */
 536 
 537     case cSetTextContentsPackage:
 538         PrintDebugString("[INFO]:   type == cSetTextContentsPackage");
 539         if (bufsize == (sizeof(PackageType) + sizeof(SetTextContentsPackage))) {
 540             SetTextContentsPackage *pkg =
 541                 (SetTextContentsPackage *) (buffer + sizeof(PackageType));
 542             pkg->rResult =
 543                 windowsThreadEntryPoints->setTextContents((jobject)pkg->accessibleContext, pkg->text);
 544             PrintDebugString("[INFO]:     -> returning result = %d", pkg->rResult);
 545         } else {
 546             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
 547                              bufsize, sizeof(PackageType) + sizeof(SetTextContentsPackage));
 548         }
 549         break;
 550 
 551     case cGetParentWithRolePackage:
 552         if (bufsize == (sizeof(PackageType) + sizeof(GetParentWithRolePackage))) {
 553             GetParentWithRolePackage *pkg =
 554                 (GetParentWithRolePackage *) (buffer + sizeof(PackageType));
 555             rAC = windowsThreadEntryPoints->getParentWithRole((jobject)pkg->accessibleContext, pkg->role);
 556             pkg->rAccessibleContext = (JOBJECT64)rAC;
 557             PrintDebugString("[INFO]:   type == cGetParentWithRolePackage\n"\
 558                              "     pkg->vmID: %X"\
 559                              "     pkg->accessibleContext: %p"\
 560                              "     pkg->role: %ls"\
 561                              "     -> returning rAccessibleContext = %p"\
 562                 , pkg->vmID, (jobject)pkg->accessibleContext, pkg->role, rAC);
 563         } else {
 564             PrintDebugString("[ERROR]:   processing FAILED!! -> bufsize = %d; expectation = %d",
 565                              bufsize, sizeof(PackageType) + sizeof(GetParentWithRolePackage));
 566         }
 567         break;
 568 
 569     case cGetTopLevelObjectPackage:
 570         PrintDebugString("[INFO]:   type == cGetTopLevelObjectPackage");
 571         if (bufsize == (sizeof(PackageType) + sizeof(GetTopLevelObjectPackage))) {
 572             GetTopLevelObjectPackage *pkg =
 573                 (GetTopLevelObjectPackage *) (buffer + sizeof(PackageType));
 574             rAC = windowsThreadEntryPoints->getTopLevelObject((jobject)pkg->accessibleContext);
 575             pkg->rAccessibleContext = (JOBJECT64)rAC;
 576             PrintDebugString("[INFO]:      -> returning rAccessibleContext = %p", rAC);
 577         } else {
 578             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
 579                              bufsize, sizeof(PackageType) + sizeof(GetTopLevelObjectPackage));
 580         }
 581         break;
 582 
 583     case cGetParentWithRoleElseRootPackage:
 584         PrintDebugString("[INFO]:   type == cGetParentWithRoleElseRootPackage");
 585         if (bufsize == (sizeof(PackageType) + sizeof(GetParentWithRoleElseRootPackage))) {
 586             GetParentWithRoleElseRootPackage *pkg =
 587                 (GetParentWithRoleElseRootPackage *) (buffer + sizeof(PackageType));
 588             rAC = windowsThreadEntryPoints->getParentWithRoleElseRoot((jobject)pkg->accessibleContext, pkg->role);
 589             pkg->rAccessibleContext = (JOBJECT64)rAC;
 590             PrintDebugString("[INFO]:      -> returning rAccessibleContext = %p", rAC);
 591         } else {
 592             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
 593                              bufsize, sizeof(PackageType) + sizeof(GetParentWithRoleElseRootPackage));
 594         }
 595         break;
 596 
 597     case cGetObjectDepthPackage:
 598         PrintDebugString("[INFO]:   type == cGetObjectDepthPackage");
 599         if (bufsize == (sizeof(PackageType) + sizeof(GetObjectDepthPackage))) {
 600             GetObjectDepthPackage *pkg =
 601                 (GetObjectDepthPackage *) (buffer + sizeof(PackageType));
 602             pkg->rResult =
 603                 windowsThreadEntryPoints->getObjectDepth((jobject)pkg->accessibleContext);
 604             PrintDebugString("[INFO]:     -> returning rResult = %d", pkg->rResult);
 605         } else {
 606             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
 607                              bufsize, sizeof(PackageType) + sizeof(GetObjectDepthPackage));
 608         }
 609         break;
 610 
 611     case cGetActiveDescendentPackage:
 612         PrintDebugString("[INFO]:   type == cGetActiveDescendentPackage");
 613         if (bufsize == (sizeof(PackageType) + sizeof(GetActiveDescendentPackage))) {
 614             GetActiveDescendentPackage *pkg =
 615                 (GetActiveDescendentPackage *) (buffer + sizeof(PackageType));
 616             rAC = windowsThreadEntryPoints->getActiveDescendent((jobject)pkg->accessibleContext);
 617             pkg->rAccessibleContext = (JOBJECT64)rAC;
 618             PrintDebugString("[INFO]:  -> returning rAccessibleContext = %p", rAC);
 619         } else {
 620             PrintDebugString("[ERROR]:   processing FAILED!! -> bufsize = %d; expectation = %d",
 621                              bufsize, sizeof(PackageType) + sizeof(GetActiveDescendentPackage));
 622         }
 623         break;
 624 
 625     case cGetAccessibleContextAtPackage:
 626         PrintDebugString("[INFO]:   type == cGetAccessibleContextAtPackage");
 627         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleContextAtPackage))) {
 628             GetAccessibleContextAtPackage *pkg =
 629                 (GetAccessibleContextAtPackage *) (buffer + sizeof(PackageType));
 630             pkg->rAccessibleContext = (JOBJECT64)
 631                 windowsThreadEntryPoints->getAccessibleContextAt(pkg->x, pkg->y,
 632                                                                  (jobject)pkg->AccessibleContext);
 633         } else {
 634             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
 635                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleContextAtPackage));
 636         }
 637         break;
 638 
 639     case cGetAccessibleContextWithFocusPackage:
 640         PrintDebugString("[INFO]:   type == cGetAccessibleContextWithFocusPackage");
 641         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleContextWithFocusPackage))) {
 642             GetAccessibleContextWithFocusPackage *pkg =
 643                 (GetAccessibleContextWithFocusPackage *) (buffer + sizeof(PackageType));
 644             pkg->rAccessibleContext = (JOBJECT64)
 645                 windowsThreadEntryPoints->getAccessibleContextWithFocus();
 646                         pkg->rVMID =  HandleToLong(dialogWindow);
 647         } else {
 648             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
 649                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleContextWithFocusPackage));
 650         }
 651         break;
 652 
 653     case cGetAccessibleContextInfoPackage:
 654         PrintDebugString("[INFO]:   type == cGetAccessibleContextInfoPackage");
 655         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleContextInfoPackage))) {
 656             GetAccessibleContextInfoPackage *pkg =
 657                 (GetAccessibleContextInfoPackage *) (buffer + sizeof(PackageType));
 658             windowsThreadEntryPoints->getAccessibleContextInfo(
 659                                                                (jobject)pkg->AccessibleContext, &(pkg->rAccessibleContextInfo));
 660         } else {
 661             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
 662                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleContextInfoPackage));
 663         }
 664         break;
 665 
 666     case cGetAccessibleChildFromContextPackage:
 667         PrintDebugString("[INFO]:   type == cGetAccessibleChildFromContextPackage");
 668         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleChildFromContextPackage))) {
 669             GetAccessibleChildFromContextPackage *pkg =
 670                 (GetAccessibleChildFromContextPackage *) (buffer + sizeof(PackageType));
 671             pkg->rAccessibleContext = (JOBJECT64)windowsThreadEntryPoints->getAccessibleChildFromContext(
 672                                                                                               (jobject)pkg->AccessibleContext, pkg->childIndex);
 673         } else {
 674             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
 675                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleChildFromContextPackage));
 676         }
 677         break;
 678 
 679     case cGetAccessibleParentFromContextPackage:
 680         PrintDebugString("[INFO]:    type == cGetAccessibleParentFromContextPackage");
 681         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleParentFromContextPackage))) {
 682             GetAccessibleParentFromContextPackage *pkg =
 683                 (GetAccessibleParentFromContextPackage *) (buffer + sizeof(PackageType));
 684             pkg->rAccessibleContext = (JOBJECT64)windowsThreadEntryPoints->getAccessibleParentFromContext(
 685                                                                                                (jobject)pkg->AccessibleContext);
 686         } else {
 687             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
 688                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleParentFromContextPackage));
 689         }
 690         break;
 691 
 692         // ------------ begin AccessibleTable packages ------------------
 693 
 694     case cGetAccessibleTableInfoPackage:
 695         PrintDebugString("[INFO]:    ##### type == cGetAccessibleTableInfoPackage");
 696         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableInfoPackage))) {
 697             GetAccessibleTableInfoPackage *pkg =
 698                 (GetAccessibleTableInfoPackage *) (buffer + sizeof(PackageType));
 699             windowsThreadEntryPoints->getAccessibleTableInfo((jobject)pkg->accessibleContext,
 700                                                              &(pkg->rTableInfo));
 701             PrintDebugString("[INFO]:    ##### processing succeeded");
 702         } else {
 703             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 704                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableInfoPackage));
 705         }
 706         break;
 707 
 708     case cGetAccessibleTableCellInfoPackage:
 709         PrintDebugString("[INFO]:    ##### type == cGetAccessibleTableCellInfoPackage");
 710         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableCellInfoPackage))) {
 711             GetAccessibleTableCellInfoPackage *pkg =
 712                 (GetAccessibleTableCellInfoPackage *) (buffer + sizeof(PackageType));
 713             windowsThreadEntryPoints->getAccessibleTableCellInfo((jobject)pkg->accessibleTable, pkg->row,
 714                                                                  pkg->column, &(pkg->rTableCellInfo));
 715             PrintDebugString("[INFO]:    ##### processing succeeded");
 716         } else {
 717             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 718                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableCellInfoPackage));
 719         }
 720         break;
 721 
 722     case cGetAccessibleTableRowHeaderPackage:
 723         PrintDebugString("[INFO]:    ##### type == cGetAccessibleTableRowHeaderPackage");
 724         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableRowHeaderPackage))) {
 725             GetAccessibleTableRowHeaderPackage *pkg =
 726                 (GetAccessibleTableRowHeaderPackage *) (buffer + sizeof(PackageType));
 727             windowsThreadEntryPoints->getAccessibleTableRowHeader((jobject)pkg->accessibleContext,
 728                                                                   &(pkg->rTableInfo));
 729             PrintDebugString("[INFO]:    ##### processing succeeded");
 730         } else {
 731             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 732                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableRowHeaderPackage));
 733         }
 734         break;
 735 
 736     case cGetAccessibleTableColumnHeaderPackage:
 737         PrintDebugString("[INFO]:    ##### type == cGetAccessibleTableColumnHeaderPackage");
 738         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableColumnHeaderPackage))) {
 739             GetAccessibleTableColumnHeaderPackage *pkg =
 740                 (GetAccessibleTableColumnHeaderPackage *) (buffer + sizeof(PackageType));
 741             windowsThreadEntryPoints->getAccessibleTableColumnHeader((jobject)pkg->accessibleContext,
 742                                                                      &(pkg->rTableInfo));
 743             PrintDebugString("[INFO]:    ##### processing succeeded");
 744         } else {
 745             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 746                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableColumnHeaderPackage));
 747         }
 748         break;
 749 
 750 
 751     case cGetAccessibleTableRowDescriptionPackage:
 752         PrintDebugString("[INFO]:    ##### type == cGetAccessibleTableRowDescriptionPackage");
 753         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableRowDescriptionPackage))) {
 754             GetAccessibleTableRowDescriptionPackage *pkg =
 755                 (GetAccessibleTableRowDescriptionPackage *) (buffer + sizeof(PackageType));
 756             pkg->rAccessibleContext = (JOBJECT64)windowsThreadEntryPoints->getAccessibleTableRowDescription(
 757                                                                                                  (jobject)pkg->accessibleContext, pkg->row);
 758             PrintDebugString("[INFO]:    ##### processing succeeded");
 759         } else {
 760             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 761                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableRowDescriptionPackage));
 762         }
 763         break;
 764 
 765     case cGetAccessibleTableColumnDescriptionPackage:
 766         PrintDebugString("[INFO]:    ##### type == cGetAccessibleTableColumnDescriptionPackage");
 767         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableColumnDescriptionPackage))) {
 768             GetAccessibleTableColumnDescriptionPackage *pkg =
 769                 (GetAccessibleTableColumnDescriptionPackage *) (buffer + sizeof(PackageType));
 770             pkg->rAccessibleContext = (JOBJECT64)windowsThreadEntryPoints->getAccessibleTableColumnDescription(
 771                                                                                                     (jobject)pkg->accessibleContext, pkg->column);
 772             PrintDebugString("[INFO]:    ##### processing succeeded");
 773         } else {
 774             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 775                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableColumnDescriptionPackage));
 776         }
 777         break;
 778 
 779     case cGetAccessibleTableColumnSelectionCountPackage:
 780         PrintDebugString("[INFO]:    ##### type == cGetAccessibleTableColumnSelectionCountPackage");
 781         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableColumnSelectionCountPackage))) {
 782             GetAccessibleTableColumnSelectionCountPackage *pkg =
 783                 (GetAccessibleTableColumnSelectionCountPackage *) (buffer + sizeof(PackageType));
 784             pkg->rCount = windowsThreadEntryPoints->getAccessibleTableColumnSelectionCount(
 785                                                                                            (jobject)pkg->accessibleTable);
 786             PrintDebugString("[INFO]:    ##### processing succeeded");
 787         } else {
 788             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 789                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableColumnSelectionCountPackage));
 790         }
 791         break;
 792 
 793     case cGetAccessibleTableRowSelectionCountPackage:
 794         PrintDebugString("[INFO]:    ##### type == cGetAccessibleTableRowSelectionCountPackage");
 795         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableRowSelectionCountPackage))) {
 796             GetAccessibleTableRowSelectionCountPackage *pkg =
 797                 (GetAccessibleTableRowSelectionCountPackage *) (buffer + sizeof(PackageType));
 798 
 799             pkg->rCount = windowsThreadEntryPoints->getAccessibleTableRowSelectionCount(
 800                                                                                         (jobject)pkg->accessibleTable);
 801 
 802             PrintDebugString("[INFO]:    ##### processing succeeded");
 803         } else {
 804             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 805                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableRowSelectionCountPackage));
 806         }
 807         break;
 808 
 809     case cIsAccessibleTableRowSelectedPackage:
 810         PrintDebugString("[INFO]:    ##### type == cIsAccessibleTableRowSelectedPackage");
 811         if (bufsize == (sizeof(PackageType) + sizeof(IsAccessibleTableRowSelectedPackage))) {
 812             IsAccessibleTableRowSelectedPackage *pkg =
 813                 (IsAccessibleTableRowSelectedPackage *) (buffer + sizeof(PackageType));
 814             pkg->rResult = windowsThreadEntryPoints->isAccessibleTableRowSelected(
 815                                                                                   (jobject)pkg->accessibleTable, pkg->row);
 816             PrintDebugString("[INFO]:    ##### processing succeeded");
 817         } else {
 818             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 819                              bufsize, sizeof(PackageType) + sizeof(IsAccessibleTableRowSelectedPackage));
 820         }
 821         break;
 822 
 823     case cIsAccessibleTableColumnSelectedPackage:
 824         PrintDebugString("[INFO]:    ##### type == cIsAccessibleTableColumnSelectedPackage");
 825         if (bufsize == (sizeof(PackageType) + sizeof(IsAccessibleTableColumnSelectedPackage))) {
 826             IsAccessibleTableColumnSelectedPackage *pkg =
 827                 (IsAccessibleTableColumnSelectedPackage *) (buffer + sizeof(PackageType));
 828             pkg->rResult = windowsThreadEntryPoints->isAccessibleTableColumnSelected(
 829                                                                                      (jobject)pkg->accessibleTable, pkg->column);
 830             PrintDebugString("[INFO]:    ##### processing succeeded");
 831         } else {
 832             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 833                              bufsize, sizeof(PackageType) + sizeof(IsAccessibleTableColumnSelectedPackage));
 834         }
 835         break;
 836 
 837     case cGetAccessibleTableColumnSelectionsPackage:
 838         PrintDebugString("[INFO]:    ##### type == cGetAccessibleTableColumnSelectionsPackage");
 839         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableColumnSelectionsPackage))) {
 840             GetAccessibleTableColumnSelectionsPackage *pkg =
 841                 (GetAccessibleTableColumnSelectionsPackage *) (buffer + sizeof(PackageType));
 842             PrintDebugString("[INFO]:      ##### cGetAccessibleTableColumnSelectionsPackage count=%d", pkg->count);
 843             windowsThreadEntryPoints->getAccessibleTableColumnSelections(
 844                                                                          (jobject)pkg->accessibleTable, pkg->count, pkg->rSelections);
 845 
 846             for (int i = 0; i < pkg->count; i++) {
 847                 PrintDebugString("[INFO]:      ##### cGetAccessibleTableColumnSelectionsPackage(%d)=%d", i, pkg->rSelections[i]);
 848             }
 849 
 850             PrintDebugString("[INFO]:    ##### processing succeeded");
 851         } else {
 852             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 853                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableColumnSelectionsPackage));
 854         }
 855         break;
 856 
 857 
 858     case cGetAccessibleTableRowSelectionsPackage:
 859         PrintDebugString("[INFO]:    ##### type == cGetAccessibleTableRowSelectionsPackage");
 860         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableRowSelectionsPackage))) {
 861             GetAccessibleTableRowSelectionsPackage *pkg =
 862                 (GetAccessibleTableRowSelectionsPackage *) (buffer + sizeof(PackageType));
 863             windowsThreadEntryPoints->getAccessibleTableRowSelections(
 864                                                                       (jobject)pkg->accessibleTable, pkg->count, pkg->rSelections);
 865             PrintDebugString("[INFO]:    ##### processing succeeded");
 866         } else {
 867             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 868                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableRowSelectionsPackage));
 869         }
 870         break;
 871 
 872     case cGetAccessibleTableRowPackage:
 873         PrintDebugString("[INFO]:    ##### type == cGetAccessibleTableRowPackage");
 874         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableRowPackage))) {
 875             GetAccessibleTableRowPackage *pkg =
 876                 (GetAccessibleTableRowPackage *) (buffer + sizeof(PackageType));
 877             pkg->rRow = windowsThreadEntryPoints->getAccessibleTableRow(
 878                                                                         (jobject)pkg->accessibleTable, pkg->index);
 879             PrintDebugString("[INFO]:    ##### processing succeeded");
 880         } else {
 881             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 882                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableRowPackage));
 883         }
 884         break;
 885 
 886     case cGetAccessibleTableColumnPackage:
 887         PrintDebugString("[INFO]:    ##### type == cGetAccessibleTableColumnPackage");
 888         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableColumnPackage))) {
 889             GetAccessibleTableColumnPackage *pkg =
 890                 (GetAccessibleTableColumnPackage *) (buffer + sizeof(PackageType));
 891             pkg->rColumn = windowsThreadEntryPoints->getAccessibleTableColumn(
 892                                                                               (jobject)pkg->accessibleTable, pkg->index);
 893             PrintDebugString("[INFO]:    ##### processing succeeded");
 894         } else {
 895             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 896                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableColumnPackage));
 897         }
 898         break;
 899 
 900     case cGetAccessibleTableIndexPackage:
 901         PrintDebugString("[INFO]:    ##### type == cGetAccessibleTableIndexPackage");
 902         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTableIndexPackage))) {
 903             GetAccessibleTableIndexPackage *pkg =
 904                 (GetAccessibleTableIndexPackage *) (buffer + sizeof(PackageType));
 905             pkg->rIndex = windowsThreadEntryPoints->getAccessibleTableIndex(
 906                                                                             (jobject)pkg->accessibleTable, pkg->row, pkg->column);
 907             PrintDebugString("[INFO]:    ##### processing succeeded");
 908         } else {
 909             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 910                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTableIndexPackage));
 911         }
 912         break;
 913 
 914         // ------------ end AccessibleTable packages ------------------
 915 
 916 
 917         // ------------ begin AccessibleRelationSet packages ------------------
 918 
 919     case cGetAccessibleRelationSetPackage:
 920         PrintDebugString("[INFO]:    ##### type == cGetAccessibleRelationSetPackage");
 921         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleRelationSetPackage))) {
 922             GetAccessibleRelationSetPackage *pkg =
 923                 (GetAccessibleRelationSetPackage *) (buffer + sizeof(PackageType));
 924             windowsThreadEntryPoints->getAccessibleRelationSet(
 925                                                                (jobject)pkg->accessibleContext, &(pkg->rAccessibleRelationSetInfo));
 926             PrintDebugString("[INFO]:    ##### processing succeeded");
 927         } else {
 928             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 929                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleRelationSetPackage));
 930         }
 931         break;
 932 
 933         // ------------ end AccessibleRelationSet packages ------------------
 934 
 935         // ------------ begin AccessibleHypertext packages ------------------
 936 
 937     case cGetAccessibleHypertextPackage:
 938         PrintDebugString("[INFO]:    ##### type == cGetAccessibleHypertextPackage");
 939         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleHypertextPackage))) {
 940             GetAccessibleHypertextPackage *pkg =
 941                 (GetAccessibleHypertextPackage *) (buffer + sizeof(PackageType));
 942             windowsThreadEntryPoints->getAccessibleHypertext(
 943                                                              (jobject)pkg->accessibleContext, &(pkg->rAccessibleHypertextInfo));
 944             PrintDebugString("[INFO]:    ##### processing succeeded");
 945         } else {
 946             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 947                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleHypertextPackage));
 948         }
 949         break;
 950 
 951     case cActivateAccessibleHyperlinkPackage:
 952         PrintDebugString("[INFO]:    ##### type == cActivateAccessibleHyperlinkPackage");
 953         if (bufsize == (sizeof(PackageType) + sizeof(ActivateAccessibleHyperlinkPackage))) {
 954             ActivateAccessibleHyperlinkPackage *pkg =
 955                 (ActivateAccessibleHyperlinkPackage *) (buffer + sizeof(PackageType));
 956             pkg->rResult = windowsThreadEntryPoints->activateAccessibleHyperlink(
 957                                                                                  (jobject)pkg->accessibleContext, (jobject)pkg->accessibleHyperlink);
 958             PrintDebugString("[INFO]:    ##### processing succeeded");
 959         } else {
 960             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 961                              bufsize, sizeof(PackageType) + sizeof(ActivateAccessibleHyperlinkPackage));
 962         }
 963         break;
 964 
 965     case cGetAccessibleHyperlinkCountPackage:
 966         PrintDebugString("[INFO]:    ##### type == cGetAccessibleHyperlinkCountPackage");
 967         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleHyperlinkCountPackage))) {
 968             GetAccessibleHyperlinkCountPackage *pkg =
 969                 (GetAccessibleHyperlinkCountPackage *) (buffer + sizeof(PackageType));
 970             pkg->rLinkCount = windowsThreadEntryPoints->getAccessibleHyperlinkCount(
 971                                                                                     (jobject)pkg->accessibleContext);
 972             PrintDebugString("[INFO]:    ##### processing succeeded: pkg->rLinkCount = %d", pkg->rLinkCount);
 973         } else {
 974             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 975                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleHyperlinkCountPackage));
 976         }
 977         break;
 978 
 979     case cGetAccessibleHypertextExtPackage:
 980         PrintDebugString("[INFO]:    ##### type == cGetAccessibleHypertextExtPackage");
 981         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleHypertextExtPackage))) {
 982             GetAccessibleHypertextExtPackage *pkg =
 983                 (GetAccessibleHypertextExtPackage *) (buffer + sizeof(PackageType));
 984             pkg->rSuccess = windowsThreadEntryPoints->getAccessibleHypertextExt(
 985                                                                                 (jobject)pkg->accessibleContext, pkg->startIndex, &(pkg->rAccessibleHypertextInfo));
 986             PrintDebugString("[INFO]:    ##### processing succeeded");
 987         } else {
 988             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
 989                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleHypertextExtPackage));
 990         }
 991         break;
 992 
 993     case cGetAccessibleHypertextLinkIndexPackage:
 994         PrintDebugString("[INFO]:    ##### type == cGetAccessibleHypertextLinkIndexPackage");
 995         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleHypertextLinkIndexPackage))) {
 996             GetAccessibleHypertextLinkIndexPackage *pkg =
 997                 (GetAccessibleHypertextLinkIndexPackage *) (buffer + sizeof(PackageType));
 998             pkg->rLinkIndex = windowsThreadEntryPoints->getAccessibleHypertextLinkIndex(
 999                                                                                         (jobject)pkg->hypertext, pkg->charIndex);
1000             PrintDebugString("[INFO]:    ##### processing succeeded");
1001         } else {
1002             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1003                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleHypertextLinkIndexPackage));
1004         }
1005         break;
1006 
1007     case cGetAccessibleHyperlinkPackage:
1008         PrintDebugString("[INFO]:    ##### type == cGetAccessibleHyperlinkPackage");
1009         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleHyperlinkPackage))) {
1010             GetAccessibleHyperlinkPackage *pkg =
1011                 (GetAccessibleHyperlinkPackage *) (buffer + sizeof(PackageType));
1012             windowsThreadEntryPoints->getAccessibleHyperlink((jobject)pkg->hypertext, pkg->linkIndex,
1013                                                              &(pkg->rAccessibleHyperlinkInfo));
1014             PrintDebugString("[INFO]:    ##### processing succeeded");
1015         } else {
1016             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1017                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleHyperlinkPackage));
1018         }
1019         break;
1020 
1021         // ------------ end AccessibleHypertext packages
1022 
1023         // ------------ begin Accessible KeyBindings, Icons and Actions
1024 
1025     case cGetAccessibleKeyBindingsPackage:
1026         PrintDebugString("[INFO]:    ##### type == cGetAccessibleKeyBindingsPackage");
1027         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleKeyBindingsPackage))) {
1028             GetAccessibleKeyBindingsPackage *pkg =
1029                 (GetAccessibleKeyBindingsPackage *) (buffer + sizeof(PackageType));
1030             windowsThreadEntryPoints->getAccessibleKeyBindings (
1031                                                                 (jobject)pkg->accessibleContext, &(pkg->rAccessibleKeyBindings));
1032             PrintDebugString("[INFO]:    ##### processing succeeded");
1033         } else {
1034             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1035                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleKeyBindingsPackage));
1036         }
1037         break;
1038 
1039     case cGetAccessibleIconsPackage:
1040         PrintDebugString("[INFO]:    ##### type == cGetAccessibleIconsPackage");
1041         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleIconsPackage))) {
1042             GetAccessibleIconsPackage *pkg =
1043                 (GetAccessibleIconsPackage *) (buffer + sizeof(PackageType));
1044             windowsThreadEntryPoints->getAccessibleIcons (
1045                                                           (jobject)pkg->accessibleContext, &(pkg->rAccessibleIcons));
1046             PrintDebugString("[INFO]:    ##### processing succeeded");
1047         } else {
1048             PrintDebugString("[ERROR]:   ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1049                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleIconsPackage));
1050         }
1051         break;
1052 
1053 
1054     case cGetAccessibleActionsPackage:
1055         PrintDebugString("[INFO]:    ##### type == cGetAccessibleActionsPackage");
1056         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleActionsPackage))) {
1057             GetAccessibleActionsPackage *pkg =
1058                 (GetAccessibleActionsPackage *) (buffer + sizeof(PackageType));
1059             windowsThreadEntryPoints->getAccessibleActions (
1060                                                             (jobject)pkg->accessibleContext, &(pkg->rAccessibleActions));
1061             PrintDebugString("[INFO]:    ##### processing succeeded");
1062         } else {
1063             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1064                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleActionsPackage));
1065         }
1066         break;
1067 
1068     case cDoAccessibleActionsPackage:
1069         PrintDebugString("[INFO]:    ##### type == cDoAccessibleActionsPackage");
1070         if (bufsize == (sizeof(PackageType) + sizeof(DoAccessibleActionsPackage))) {
1071             DoAccessibleActionsPackage *pkg =
1072                 (DoAccessibleActionsPackage *) (buffer + sizeof(PackageType));
1073             pkg->rResult =
1074                 windowsThreadEntryPoints->doAccessibleActions((jobject)pkg->accessibleContext, &(pkg->actionsToDo),
1075                                                               &(pkg->failure));
1076             PrintDebugString("[INFO]:    ##### processing succeeded");
1077         } else {
1078             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1079                              bufsize, sizeof(PackageType) + sizeof(DoAccessibleActionsPackage));
1080         }
1081         break;
1082 
1083         // ------------ begin addtional methods for Teton
1084 
1085     case cGetVirtualAccessibleNamePackage:
1086         PrintDebugString("[INFO]:    ##### type == GetVirtualAccessibleNamePackage");
1087         if (bufsize == (sizeof(PackageType) + sizeof(GetVirtualAccessibleNamePackage))) {
1088             GetVirtualAccessibleNamePackage *pkg =
1089                 (GetVirtualAccessibleNamePackage *) (buffer + sizeof(PackageType));
1090             windowsThreadEntryPoints->getVirtualAccessibleName ((const jobject)pkg->accessibleContext,
1091                                                              pkg->rName,
1092                                                              pkg->len);
1093             PrintDebugString("[INFO]:    ##### processing succeeded");
1094         } else {
1095             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1096                              bufsize, sizeof(PackageType) + sizeof(GetVirtualAccessibleNamePackage));
1097         }
1098         break;
1099 
1100     case cRequestFocusPackage:
1101         PrintDebugString("[INFO]:    ##### type == RequestFocusPackage");
1102         if (bufsize == (sizeof(PackageType) + sizeof(RequestFocusPackage))) {
1103             RequestFocusPackage *pkg =
1104                 (RequestFocusPackage *) (buffer + sizeof(PackageType));
1105             windowsThreadEntryPoints->requestFocus (
1106                                                     (jobject)pkg->accessibleContext);
1107             PrintDebugString("[INFO]:    ##### processing succeeded");
1108         } else {
1109             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1110                              bufsize, sizeof(PackageType) + sizeof(RequestFocusPackage));
1111         }
1112         break;
1113 
1114     case cSelectTextRangePackage:
1115         PrintDebugString("[INFO]:    ##### type == SelectTextRangePackage");
1116         if (bufsize == (sizeof(PackageType) + sizeof(SelectTextRangePackage))) {
1117             SelectTextRangePackage *pkg =
1118                 (SelectTextRangePackage *) (buffer + sizeof(PackageType));
1119             windowsThreadEntryPoints->selectTextRange (
1120                                                        (jobject)pkg->accessibleContext, pkg->startIndex, pkg->endIndex);
1121             PrintDebugString("[INFO]:    ##### processing succeeded");
1122         } else {
1123             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1124                              bufsize, sizeof(PackageType) + sizeof(SelectTextRangePackage));
1125         }
1126         break;
1127 
1128     case cGetTextAttributesInRangePackage:
1129         PrintDebugString("[INFO]:    ##### type == GetTextAttributesInRangePackage");
1130         if (bufsize == (sizeof(PackageType) + sizeof(GetTextAttributesInRangePackage))) {
1131             GetTextAttributesInRangePackage *pkg =
1132                 (GetTextAttributesInRangePackage *) (buffer + sizeof(PackageType));
1133             windowsThreadEntryPoints->getTextAttributesInRange (
1134                                                                 (jobject)pkg->accessibleContext, pkg->startIndex, pkg->endIndex,
1135                                                                 (AccessibleTextAttributesInfo *)&(pkg->attributes),
1136                                                                 &(pkg->rLength));
1137             PrintDebugString("[INFO]:    ##### processing succeeded");
1138         } else {
1139             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1140                              bufsize, sizeof(PackageType) + sizeof(GetTextAttributesInRangePackage));
1141         }
1142         break;
1143 
1144 
1145     case cGetVisibleChildrenCountPackage:
1146         PrintDebugString("[INFO]:    ##### type == GetVisibleChildrenCountPackage");
1147         if (bufsize == (sizeof(PackageType) + sizeof(GetVisibleChildrenCountPackage))) {
1148             GetVisibleChildrenCountPackage *pkg =
1149                 (GetVisibleChildrenCountPackage *) (buffer + sizeof(PackageType));
1150             pkg->rChildrenCount = windowsThreadEntryPoints->getVisibleChildrenCount ((jobject)pkg->accessibleContext);
1151 
1152             PrintDebugString("[INFO]:    ##### processing succeeded");
1153         } else {
1154             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1155                              bufsize, sizeof(PackageType) + sizeof(GetVisibleChildrenCountPackage));
1156         }
1157         break;
1158 
1159     case cGetVisibleChildrenPackage:
1160         PrintDebugString("[INFO]:    ##### type == GetVisibleChildrenPackage");
1161         if (bufsize == (sizeof(PackageType) + sizeof(GetVisibleChildrenPackage))) {
1162             GetVisibleChildrenPackage *pkg =
1163                 (GetVisibleChildrenPackage *) (buffer + sizeof(PackageType));
1164             pkg->rSuccess = windowsThreadEntryPoints->getVisibleChildren ((jobject)pkg->accessibleContext,
1165                                                                           pkg->startIndex,
1166                                                                           &(pkg->rVisibleChildrenInfo));
1167 
1168             PrintDebugString("[INFO]:    ##### processing succeeded");
1169         } else {
1170             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1171                              bufsize, sizeof(PackageType) + sizeof(GetVisibleChildrenPackage));
1172         }
1173         break;
1174 
1175     case cSetCaretPositionPackage:
1176         PrintDebugString("[INFO]:    ##### type == SetCaretPositionPackage");
1177         if (bufsize == (sizeof(PackageType) + sizeof(SetCaretPositionPackage))) {
1178             SetCaretPositionPackage *pkg =
1179                 (SetCaretPositionPackage *) (buffer + sizeof(PackageType));
1180             windowsThreadEntryPoints->setCaretPosition (
1181                                                         (jobject)pkg->accessibleContext, pkg->position);
1182             PrintDebugString("[INFO]:    ##### processing succeeded");
1183         } else {
1184             PrintDebugString("[ERROR]:    ##### processing FAILED!! -> bufsize = %d; expectation = %d",
1185                              bufsize, sizeof(PackageType) + sizeof(SetCaretPositionPackage));
1186         }
1187         break;
1188 
1189         // ------------ end additional methods for Teton
1190 
1191         // ------------ end Accessible KeyBindings, Icons and Actions
1192 
1193         // ------------ Accessible Text packages ------------------
1194 
1195     case cGetAccessibleTextInfoPackage:
1196         PrintDebugString("[INFO]:    type == cGetAccessibleTextInfoPackage");
1197         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextInfoPackage))) {
1198             GetAccessibleTextInfoPackage *pkg =
1199                 (GetAccessibleTextInfoPackage *) (buffer + sizeof(PackageType));
1200             windowsThreadEntryPoints->getAccessibleTextInfo((jobject)pkg->AccessibleContext,
1201                                                             &(pkg->rTextInfo), pkg->x, pkg->y);
1202         } else {
1203             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1204                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextInfoPackage));
1205         }
1206         break;
1207 
1208     case cGetAccessibleTextItemsPackage:
1209         PrintDebugString("[INFO]:    type == cGetAccessibleTextItemsPackage");
1210         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextItemsPackage))) {
1211             GetAccessibleTextItemsPackage *pkg =
1212                 (GetAccessibleTextItemsPackage *) (buffer + sizeof(PackageType));
1213             windowsThreadEntryPoints->getAccessibleTextItems((jobject)pkg->AccessibleContext,
1214                                                              &(pkg->rTextItemsInfo), pkg->index);
1215         } else {
1216             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1217                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextInfoPackage));
1218         }
1219         break;
1220 
1221     case cGetAccessibleTextSelectionInfoPackage:
1222         PrintDebugString("[INFO]:    type == cGetAccessibleTextSelectionInfoPackage");
1223         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextSelectionInfoPackage))) {
1224             GetAccessibleTextSelectionInfoPackage *pkg =
1225                 (GetAccessibleTextSelectionInfoPackage *) (buffer + sizeof(PackageType));
1226             windowsThreadEntryPoints->getAccessibleTextSelectionInfo(
1227                                                                      (jobject)pkg->AccessibleContext, &(pkg->rTextSelectionItemsInfo));
1228         } else {
1229             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1230                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextSelectionInfoPackage));
1231         }
1232         break;
1233 
1234     case cGetAccessibleTextAttributeInfoPackage:
1235         PrintDebugString("[INFO]:    type == cGetAccessibleTextAttributeInfoPackage");
1236         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextAttributeInfoPackage))) {
1237             GetAccessibleTextAttributeInfoPackage *pkg =
1238                 (GetAccessibleTextAttributeInfoPackage *) (buffer + sizeof(PackageType));
1239             windowsThreadEntryPoints->getAccessibleTextAttributes(
1240                                                                   (jobject)pkg->AccessibleContext, pkg->index, (AccessibleTextAttributesInfo *) &(pkg->rAttributeInfo));
1241         } else {
1242             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1243                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextAttributeInfoPackage));
1244         }
1245         break;
1246 
1247     case cGetAccessibleTextRectInfoPackage:
1248         PrintDebugString("[INFO]:    type == cGetAccessibleTextRectInfoPackage");
1249         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextRectInfoPackage))) {
1250             GetAccessibleTextRectInfoPackage *pkg =
1251                 (GetAccessibleTextRectInfoPackage *) (buffer + sizeof(PackageType));
1252             windowsThreadEntryPoints->getAccessibleTextRect((jobject)pkg->AccessibleContext,
1253                                                             &(pkg->rTextRectInfo), pkg->index);
1254         } else {
1255             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1256                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextRectInfoPackage));
1257         }
1258         break;
1259 
1260     case cGetCaretLocationPackage:
1261         PrintDebugString("[INFO]:    type == cGetCaretLocationPackage");
1262         if (bufsize == (sizeof(PackageType) + sizeof(GetCaretLocationPackage))) {
1263             GetCaretLocationPackage *pkg =
1264                 (GetCaretLocationPackage *) (buffer + sizeof(PackageType));
1265             windowsThreadEntryPoints->getCaretLocation((jobject)pkg->AccessibleContext,
1266                                                             &(pkg->rTextRectInfo), pkg->index);
1267         } else {
1268             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1269                              bufsize, sizeof(PackageType) + sizeof(GetCaretLocationPackage));
1270         }
1271         break;
1272 
1273     case cGetAccessibleTextLineBoundsPackage:
1274         PrintDebugString("[INFO]:    type == cGetAccessibleTextLineBoundsPackage");
1275         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextLineBoundsPackage))) {
1276             GetAccessibleTextLineBoundsPackage *pkg =
1277                 (GetAccessibleTextLineBoundsPackage *) (buffer + sizeof(PackageType));
1278             windowsThreadEntryPoints->getAccessibleTextLineBounds((jobject)pkg->AccessibleContext,
1279                                                                   pkg->index, &(pkg->rLineStart), &(pkg->rLineEnd));
1280         } else {
1281             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1282                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextLineBoundsPackage));
1283         }
1284         break;
1285 
1286     case cGetAccessibleTextRangePackage:
1287         PrintDebugString("[INFO]:    type == cGetAccessibleTextRangePackage");
1288         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleTextRangePackage))) {
1289             GetAccessibleTextRangePackage *pkg =
1290                 (GetAccessibleTextRangePackage *) (buffer + sizeof(PackageType));
1291             windowsThreadEntryPoints->getAccessibleTextRange((jobject)pkg->AccessibleContext,
1292                                                              pkg->start, pkg->end, (wchar_t *) &(pkg->rText), (sizeof(pkg->rText) / sizeof(wchar_t)));
1293         } else {
1294             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1295                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleTextRangePackage));
1296         }
1297         break;
1298 
1299 
1300         // ------------ Accessible Value packages ------------------
1301 
1302     case cGetCurrentAccessibleValueFromContextPackage:
1303         PrintDebugString("[INFO]:    type == cGetCurrentAccessibleValueFromContextPackage");
1304         if (bufsize == (sizeof(PackageType) + sizeof(GetCurrentAccessibleValueFromContextPackage))) {
1305             GetCurrentAccessibleValueFromContextPackage *pkg =
1306                 (GetCurrentAccessibleValueFromContextPackage *) (buffer + sizeof(PackageType));
1307             windowsThreadEntryPoints->getCurrentAccessibleValueFromContext((jobject)pkg->AccessibleContext,
1308                                                                            (wchar_t *) &(pkg->rValue), (sizeof(pkg->rValue) / sizeof(wchar_t)));
1309         } else {
1310             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1311                              bufsize, sizeof(PackageType) + sizeof(GetCurrentAccessibleValueFromContextPackage));
1312         }
1313         break;
1314 
1315     case cGetMaximumAccessibleValueFromContextPackage:
1316         PrintDebugString("[INFO]:    type == cGetMaximumAccessibleValueFromContextPackage");
1317         if (bufsize == (sizeof(PackageType) + sizeof(GetMaximumAccessibleValueFromContextPackage))) {
1318             GetMaximumAccessibleValueFromContextPackage *pkg =
1319                 (GetMaximumAccessibleValueFromContextPackage *) (buffer + sizeof(PackageType));
1320             windowsThreadEntryPoints->getMaximumAccessibleValueFromContext((jobject)pkg->AccessibleContext,
1321                                                                            (wchar_t *) &(pkg->rValue), (sizeof(pkg->rValue) / sizeof(wchar_t)));
1322         } else {
1323             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1324                              bufsize, sizeof(PackageType) + sizeof(GetMaximumAccessibleValueFromContextPackage));
1325         }
1326         break;
1327 
1328     case cGetMinimumAccessibleValueFromContextPackage:
1329         PrintDebugString("[INFO]:    type == cGetMinimumAccessibleValueFromContextPackage");
1330         if (bufsize == (sizeof(PackageType) + sizeof(GetMinimumAccessibleValueFromContextPackage))) {
1331             GetMinimumAccessibleValueFromContextPackage *pkg =
1332                 (GetMinimumAccessibleValueFromContextPackage *) (buffer + sizeof(PackageType));
1333             windowsThreadEntryPoints->getMinimumAccessibleValueFromContext((jobject)pkg->AccessibleContext,
1334                                                                            (wchar_t *) &(pkg->rValue), (sizeof(pkg->rValue) / sizeof(wchar_t)));
1335         } else {
1336             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1337                              bufsize, sizeof(PackageType) + sizeof(GetMinimumAccessibleValueFromContextPackage));
1338         }
1339         break;
1340 
1341         // ------------ Accessible Selection packages ------------------
1342 
1343     case cAddAccessibleSelectionFromContextPackage:
1344         PrintDebugString("[INFO]:    type == cAddAccessibleSelectionFromContextPackage");
1345         if (bufsize == (sizeof(PackageType) + sizeof(AddAccessibleSelectionFromContextPackage))) {
1346             AddAccessibleSelectionFromContextPackage *pkg =
1347                 (AddAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType));
1348             windowsThreadEntryPoints->addAccessibleSelectionFromContext((jobject)pkg->AccessibleContext,
1349                                                                         pkg->index);
1350         } else {
1351             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1352                              bufsize, sizeof(PackageType) + sizeof(AddAccessibleSelectionFromContextPackage));
1353         }
1354         break;
1355 
1356     case cClearAccessibleSelectionFromContextPackage:
1357         PrintDebugString("[INFO]:    type == cClearAccessibleSelectionFromContextPackage");
1358         if (bufsize == (sizeof(PackageType) + sizeof(ClearAccessibleSelectionFromContextPackage))) {
1359             ClearAccessibleSelectionFromContextPackage *pkg =
1360                 (ClearAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType));
1361             windowsThreadEntryPoints->clearAccessibleSelectionFromContext((jobject)pkg->AccessibleContext);
1362         } else {
1363             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1364                              bufsize, sizeof(PackageType) + sizeof(ClearAccessibleSelectionFromContextPackage));
1365         }
1366         break;
1367 
1368     case cGetAccessibleSelectionFromContextPackage:
1369         PrintDebugString("[INFO]:    type == cGetAccessibleSelectionFromContextPackage");
1370         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleSelectionFromContextPackage))) {
1371             GetAccessibleSelectionFromContextPackage *pkg =
1372                 (GetAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType));
1373             pkg->rAccessibleContext = (JOBJECT64)windowsThreadEntryPoints->getAccessibleSelectionFromContext(
1374                                                                                                   (jobject)pkg->AccessibleContext, pkg->index);
1375         } else {
1376             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1377                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleSelectionFromContextPackage));
1378         }
1379         break;
1380 
1381     case cGetAccessibleSelectionCountFromContextPackage:
1382         PrintDebugString("[INFO]:    type == cGetAccessibleSelectionCountFromContextPackage");
1383         if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleSelectionCountFromContextPackage))) {
1384             GetAccessibleSelectionCountFromContextPackage *pkg =
1385                 (GetAccessibleSelectionCountFromContextPackage *) (buffer + sizeof(PackageType));
1386             pkg->rCount = windowsThreadEntryPoints->getAccessibleSelectionCountFromContext(
1387                                                                                            (jobject)pkg->AccessibleContext);
1388         } else {
1389             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1390                              bufsize, sizeof(PackageType) + sizeof(GetAccessibleSelectionCountFromContextPackage));
1391         }
1392         break;
1393 
1394     case cIsAccessibleChildSelectedFromContextPackage:
1395         PrintDebugString("[INFO]:    type == cIsAccessibleChildSelectedFromContextPackage");
1396         if (bufsize == (sizeof(PackageType) + sizeof(IsAccessibleChildSelectedFromContextPackage))) {
1397             IsAccessibleChildSelectedFromContextPackage *pkg =
1398                 (IsAccessibleChildSelectedFromContextPackage *) (buffer + sizeof(PackageType));
1399             pkg->rResult = windowsThreadEntryPoints->isAccessibleChildSelectedFromContext(
1400                                                                                           (jobject)pkg->AccessibleContext, pkg->index);
1401         } else {
1402             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1403                              bufsize, sizeof(PackageType) + sizeof(IsAccessibleChildSelectedFromContextPackage));
1404         }
1405         break;
1406 
1407     case cRemoveAccessibleSelectionFromContextPackage:
1408         PrintDebugString("[INFO]:    type == cRemoveAccessibleSelectionFromContextPackage");
1409         if (bufsize == (sizeof(PackageType) + sizeof(RemoveAccessibleSelectionFromContextPackage))) {
1410             RemoveAccessibleSelectionFromContextPackage *pkg =
1411                 (RemoveAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType));
1412             windowsThreadEntryPoints->removeAccessibleSelectionFromContext((jobject)pkg->AccessibleContext,
1413                                                                            pkg->index);
1414         } else {
1415             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1416                              bufsize, sizeof(PackageType) + sizeof(RemoveAccessibleSelectionFromContextPackage));
1417         }
1418         break;
1419 
1420     case cSelectAllAccessibleSelectionFromContextPackage:
1421         PrintDebugString("[INFO]:    type == cSelectAllAccessibleSelectionFromContextPackage");
1422         if (bufsize == (sizeof(PackageType) + sizeof(SelectAllAccessibleSelectionFromContextPackage))) {
1423             SelectAllAccessibleSelectionFromContextPackage *pkg =
1424                 (SelectAllAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType));
1425             windowsThreadEntryPoints->selectAllAccessibleSelectionFromContext((jobject)pkg->AccessibleContext);
1426         } else {
1427             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1428                              bufsize, sizeof(PackageType) + sizeof(SelectAllAccessibleSelectionFromContextPackage));
1429         }
1430         break;
1431 
1432 
1433         // ------------ event notification management packages ------------------
1434 
1435     case cAddJavaEventNotificationPackage:
1436         PrintDebugString("[INFO]:    type = cAddJavaEventNotificationPackage");
1437         if (bufsize == (sizeof(PackageType) + sizeof(AddJavaEventNotificationPackage))) {
1438             AddJavaEventNotificationPackage *pkg =
1439                 (AddJavaEventNotificationPackage *) (buffer + sizeof(PackageType));
1440             addJavaEventNotification(pkg->type, (HWND)ABLongToHandle( pkg->DLLwindow ) );
1441         } else {
1442             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1443                              bufsize, sizeof(PackageType) + sizeof(AddJavaEventNotificationPackage));
1444         }
1445         break;
1446 
1447     case cRemoveJavaEventNotificationPackage:
1448         PrintDebugString("[INFO]:    type = cRemoveJavaEventNotificationPackage");
1449         if (bufsize == (sizeof(PackageType) + sizeof(RemoveJavaEventNotificationPackage))) {
1450             RemoveJavaEventNotificationPackage *pkg =
1451                 (RemoveJavaEventNotificationPackage *) (buffer + sizeof(PackageType));
1452             removeJavaEventNotification(pkg->type, (HWND)ABLongToHandle( pkg->DLLwindow ));
1453         } else {
1454             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1455                              bufsize, sizeof(PackageType) + sizeof(RemoveJavaEventNotificationPackage));
1456         }
1457         break;
1458 
1459     case cAddAccessibilityEventNotificationPackage:
1460         PrintDebugString("[INFO]:    type = cAddAccessibilityEventNotificationPackage");
1461         if (bufsize == (sizeof(PackageType) + sizeof(AddAccessibilityEventNotificationPackage))) {
1462             AddAccessibilityEventNotificationPackage *pkg =
1463                 (AddAccessibilityEventNotificationPackage *) (buffer + sizeof(PackageType));
1464             addAccessibilityEventNotification(pkg->type, (HWND)ABLongToHandle(pkg->DLLwindow));
1465         } else {
1466             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1467                              bufsize, sizeof(PackageType) + sizeof(AddAccessibilityEventNotificationPackage));
1468         }
1469         break;
1470 
1471     case cRemoveAccessibilityEventNotificationPackage:
1472         PrintDebugString("[INFO]:    type = cRemoveAccessibilityEventNotificationPackage");
1473         if (bufsize == (sizeof(PackageType) + sizeof(RemoveAccessibilityEventNotificationPackage))) {
1474             RemoveAccessibilityEventNotificationPackage *pkg =
1475                 (RemoveAccessibilityEventNotificationPackage *) (buffer + sizeof(PackageType));
1476             removeAccessibilityEventNotification(pkg->type, (HWND)ABLongToHandle(pkg->DLLwindow));
1477         } else {
1478             PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
1479                              bufsize, sizeof(PackageType) + sizeof(RemoveAccessibilityEventNotificationPackage));
1480         }
1481         break;
1482 
1483     default:
1484         PrintDebugString("[ERROR]:    processing FAILED!! -> don't know how to handle type = %X", *type);
1485         returnVal = -1;
1486         break;
1487     }
1488 
1489     PrintDebugString("[INFO]:    package processing completed");
1490     return returnVal;
1491 }
1492 
1493 
1494 // -----------------------------
1495 
1496 
1497 /**
1498  * MemoryMappedFileCreated
1499  *          - WindowsDLL letting us know it's created a memory-mapped file
1500  *            for IPC.  We need to open it and write a magic string into
1501  *            it to let the WindowsDLL know all is OK.  Also we need to
1502  *            set up our own data structures to communicate with the
1503  *            WindowsDLL
1504  *
1505  */
1506 LRESULT
1507 JavaAccessBridge::MemoryMappedFileCreated(HWND ATBridgeDLLWindow, char *filename) {
1508     PrintDebugString("[INFO]:   in MemoryMappedFileCreated(%p, %s)!", ATBridgeDLLWindow, filename);
1509     AccessBridgeATInstance *newAT =
1510         new AccessBridgeATInstance(dialogWindow, ATBridgeDLLWindow, filename, ATs);
1511     PrintDebugString("[INFO]:     just created a new ATInstance = %p, old = %p", newAT, ATs);
1512     ATs = newAT;
1513 
1514     LRESULT returnVal = ATs->initiateIPC();
1515     if (returnVal == 0) {
1516         PrintDebugString("[INFO]:   Successfully initiated IPC with AT!!!");
1517     } else {
1518         PrintDebugString("[ERROR]: Failed to initiate IPC with AT!!!");
1519     }
1520 
1521     return returnVal;
1522 }
1523 
1524 
1525 /**
1526  * WindowsATDestroyed - lets the JavaABDLL know a Windows AT disappeared
1527  *
1528  */
1529 void
1530 JavaAccessBridge::WindowsATDestroyed(HWND ATBridgeDLLWindow) {
1531     PrintDebugString("[INFO]: in JavaAccessBridge::WindowsATDestroyed(%p)", ATBridgeDLLWindow);
1532     if (ATs == (AccessBridgeATInstance *) 0) {
1533         PrintDebugString("[ERROR]: -> ATs == 0! (shouldn't happen here)");
1534         return;
1535     }
1536 
1537     AccessBridgeATInstance *currentAT = ATs;
1538     AccessBridgeATInstance *previousAT = ATs;
1539     if (ATs->winAccessBridgeWindow == ATBridgeDLLWindow) {
1540         ATs = ATs->nextATInstance;
1541         // remove event notification for this AT
1542         removeJavaEventNotification(currentAT->javaEventMask, ATBridgeDLLWindow);
1543         removeAccessibilityEventNotification(currentAT->accessibilityEventMask, ATBridgeDLLWindow);
1544         delete currentAT;
1545         PrintDebugString("[INFO]:   data structures successfully removed");
1546     } else {
1547         while (currentAT != (AccessBridgeATInstance *) NULL) {
1548             if (currentAT->winAccessBridgeWindow == ATBridgeDLLWindow) {
1549                 previousAT->nextATInstance = currentAT->nextATInstance;
1550                 delete currentAT;
1551                 PrintDebugString("[INFO]:   data structures successfully removed");
1552                 return;
1553             } else {
1554                 previousAT = currentAT;
1555                 currentAT = currentAT->nextATInstance;
1556             }
1557         }
1558         PrintDebugString("[ERROR]: couldn't find matching data structures!");
1559     }
1560 }
1561 
1562 
1563 // -----------------------------
1564 
1565 
1566 /**
1567  * releaseJavaObject - lets the JavaVM know it can release the Java Object
1568  *
1569  * Note: once you have made this call, the JavaVM will garbage collect
1570  * the jobject you pass in.  If you later use that jobject in another
1571  * call, you will cause all maner of havoc!
1572  *
1573  */
1574 void
1575 JavaAccessBridge::releaseJavaObject(jobject object) {
1576     PrintDebugString("[INFO]: In JavaAccessBridge::releaseJavaObject");
1577     PrintDebugString("[INFO]:   object X: %p", object);
1578     if (windowsThreadJNIEnv != (JNIEnv *) 0) {
1579         windowsThreadJNIEnv->DeleteGlobalRef(object);
1580         PrintDebugString("[INFO]:   global reference deleted.", object);
1581     } else {
1582         PrintDebugString("[ERROR]: windowsThreadJNIEnv == 0");
1583     }
1584 }
1585 
1586 // -----------------------------
1587 
1588 /**
1589  * addJavaEventNotification - this AT now wants this type of events
1590  *
1591  */
1592 void
1593 JavaAccessBridge::addJavaEventNotification(jlong type, HWND DLLwindow) {
1594     // walk through list of ATs, find this one and add this type
1595     // and, if we weren't listening for these before, ask Java for 'em
1596     PrintDebugString("[INFO]:   adding Java event type %016I64X to HWND %p", type, DLLwindow);
1597     AccessBridgeATInstance *ati = ATs;
1598     long globalEventMask = 0;
1599     while (ati != (AccessBridgeATInstance *) 0) {
1600         if (ati->winAccessBridgeWindow == DLLwindow) {
1601             ati->javaEventMask |= type;
1602             PrintDebugString("[INFO]:   found HWND, javaEventMask now is %X", ati->javaEventMask);
1603         } else {
1604             globalEventMask |= ati->javaEventMask;
1605         }
1606         ati = ati->nextATInstance;
1607     }
1608     PrintDebugString("[INFO]:   union of all Java AT event masks: %X", globalEventMask);
1609     if (!(globalEventMask & type)) {
1610         // no other ATs wanted this event;
1611         // start getting them from Java
1612         PrintDebugString("[INFO]:   no other AT wanted this Java event (so not registered); adding to AccessBridge.java");
1613         windowsThreadEntryPoints->addJavaEventNotification(type);
1614     }
1615 }
1616 
1617 /**
1618  * removeJavaEventNotification - this AT no longer wants this type of events
1619  *
1620  */
1621 void
1622 JavaAccessBridge::removeJavaEventNotification(jlong type, HWND DLLwindow) {
1623     // walk through list of ATs, find this one and remove this type
1624     // and, if no other AT wants 'em either, tell Java we no longer want 'em
1625     PrintDebugString("[INFO]:   removing Java event type %016I64X from HWND %p", type, DLLwindow);
1626     AccessBridgeATInstance *ati = ATs;
1627     long globalEventMask = 0;
1628     while (ati != (AccessBridgeATInstance *) 0) {
1629         if (ati->winAccessBridgeWindow == DLLwindow) {
1630             ati->javaEventMask &= (0xFFFFFFFF - type);
1631             PrintDebugString("[INFO]:   found HWND, javaEventMask now is %X", ati->javaEventMask);
1632         } else {
1633             globalEventMask |= ati->javaEventMask;
1634         }
1635         ati = ati->nextATInstance;
1636     }
1637     PrintDebugString("[INFO]:   union of all Java AT event masks: %X", globalEventMask);
1638     if (!(globalEventMask & type)) {
1639         // no other ATs wanted this event;
1640         // stop getting them from Java
1641         PrintDebugString("[INFO]:   no other AT wanted this Java event (so can remove); removing from AccessBridge.java");
1642         windowsThreadEntryPoints->removeJavaEventNotification(type);
1643     }
1644 }
1645 
1646 
1647 /**
1648  * addAccesibilityEventNotification - this AT now wants this type of events
1649  *
1650  */
1651 void
1652 JavaAccessBridge::addAccessibilityEventNotification(jlong type, HWND DLLwindow) {
1653     // walk through list of ATs, find this one and add this type
1654     // and, if we weren't listening for these before, ask Java for 'em
1655     PrintDebugString("[INFO]:   adding Accesibility event type %016I64X to HWND %p", type, DLLwindow);
1656     AccessBridgeATInstance *ati = ATs;
1657     long globalEventMask = 0;
1658     while (ati != (AccessBridgeATInstance *) 0) {
1659         if (ati->winAccessBridgeWindow == DLLwindow) {
1660             ati->accessibilityEventMask |= type;
1661             PrintDebugString("[INFO]:   found HWND, accessibilityEventMask now is %X", ati->accessibilityEventMask);
1662         } else {
1663             globalEventMask |= ati->accessibilityEventMask;
1664         }
1665         ati = ati->nextATInstance;
1666     }
1667     PrintDebugString("[INFO]:   union of all Accessibility AT event masks: %X", globalEventMask);
1668     if (!(globalEventMask & type)) {
1669         // no other ATs wanted this event;
1670         // start getting them from Java
1671         PrintDebugString("[INFO]:   no other AT wanted this Accesibility event (so not registered); adding to AccessBridge.java");
1672         windowsThreadEntryPoints->addAccessibilityEventNotification(type);
1673     }
1674 }
1675 
1676 /**
1677  * removeAccesibilityEventNotification - this AT no longer wants this type of events
1678  *
1679  */
1680 void
1681 JavaAccessBridge::removeAccessibilityEventNotification(jlong type, HWND DLLwindow) {
1682     // walk through list of ATs, find this one and remove this type
1683     // and, if no other AT wants 'em either, tell Java we no longer want 'em
1684     PrintDebugString("[INFO]:   removing Accesibility event type %016I64X from HWND %p", type, DLLwindow);
1685     AccessBridgeATInstance *ati = ATs;
1686     long globalEventMask = 0;
1687     while (ati != (AccessBridgeATInstance *) 0) {
1688         if (ati->winAccessBridgeWindow == DLLwindow) {
1689             ati->accessibilityEventMask &= (0xFFFFFFFF - type);
1690             PrintDebugString("[INFO]:   found HWND, accessibilityEventMask now is %X", ati->accessibilityEventMask);
1691         } else {
1692             globalEventMask |= ati->accessibilityEventMask;
1693         }
1694         ati = ati->nextATInstance;
1695     }
1696     PrintDebugString("[INFO]:   union of all Accessibility AT event masks: %X", globalEventMask);
1697     if (!(globalEventMask & type)) {
1698         // no other ATs wanted this event;
1699         // stop getting them from Java
1700         PrintDebugString("[INFO]:   no other AT wanted this Accessibility event (so can remove); removing from AccessBridge.java");
1701         windowsThreadEntryPoints->removeAccessibilityEventNotification(type);
1702     }
1703 }
1704 
1705 
1706 
1707 
1708 /**
1709  * firePropertyCaretChange
1710  *
1711  */
1712 void
1713 JavaAccessBridge::firePropertyCaretChange(JNIEnv *env, jobject callingObj,
1714                                           jobject event, jobject source,
1715                                           jint oldValue, jint newValue) {
1716 
1717     PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertyCaretChanged(%p, %p, %p, %p, %d, %d)",
1718                      env, callingObj, event,
1719                      source, oldValue, newValue);
1720 
1721     // sanity check
1722     if (ATs == (AccessBridgeATInstance *) 0) {
1723         PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)");
1724         return;         // panic!
1725     }
1726 
1727     // common setup
1728     char buffer[sizeof(PackageType) + sizeof(PropertyCaretChangePackage)];
1729     PackageType *type = (PackageType *) buffer;
1730     PropertyCaretChangePackage *pkg = (PropertyCaretChangePackage *) (buffer + sizeof(PackageType));
1731     *type = cPropertyCaretChangePackage;
1732     pkg->vmID = (long) dialogWindow;
1733 
1734     // make new Global Refs and send events only to those ATs that want 'em
1735     AccessBridgeATInstance *ati = ATs;
1736     while (ati != (AccessBridgeATInstance *) 0) {
1737         if (ati->accessibilityEventMask & cPropertyCaretChangeEvent) {
1738 
1739             PrintDebugString("[INFO]:   sending to AT");
1740 
1741             // make new GlobalRefs for this AT
1742             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
1743             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
1744 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1745             PrintDebugString("[INFO]:   GlobalRef'd Event: %p"\
1746                              "          GlobalRef'd Source: %p", pkg->Event, pkg->AccessibleContextSource);
1747 #else // JOBJECT64 is jlong (64 bit)
1748             PrintDebugString("[INFO]:   GlobalRef'd Event: %016I64X"\
1749                              "          GlobalRef'd Source: %016I64X", pkg->Event, pkg->AccessibleContextSource);
1750 #endif
1751 
1752             pkg->oldPosition = oldValue;
1753             pkg->newPosition = newValue;
1754 
1755             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyCaretChangeEvent);
1756         }
1757         ati = ati->nextATInstance;
1758     }
1759     PrintDebugString("[INFO]:  done with propertyCaretChange event");
1760 }
1761 
1762 /**
1763  * firePropertyDescriptionChange
1764  *
1765  */
1766 void
1767 JavaAccessBridge::firePropertyDescriptionChange(JNIEnv *env, jobject callingObj,
1768                                                 jobject event, jobject source,
1769                                                 jstring oldValue, jstring newValue){
1770 
1771     PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertyDescriptionChanged(%p, %p, %p, %p, %p, %p)",
1772                      env, callingObj, event,
1773                      source, oldValue, newValue);
1774 
1775     // sanity check
1776     if (ATs == (AccessBridgeATInstance *) 0) {
1777         PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)");
1778         return;         // panic!
1779     }
1780 
1781     // common setup
1782     const wchar_t *stringBytes;
1783     char buffer[sizeof(PackageType) + sizeof(PropertyDescriptionChangePackage)];
1784     PackageType *type = (PackageType *) buffer;
1785     PropertyDescriptionChangePackage *pkg = (PropertyDescriptionChangePackage *) (buffer + sizeof(PackageType));
1786     *type = cPropertyDescriptionChangePackage;
1787     pkg->vmID = (long) dialogWindow;
1788 
1789     // make new Global Refs and send events only to those ATs that want 'em
1790     AccessBridgeATInstance *ati = ATs;
1791     while (ati != (AccessBridgeATInstance *) 0) {
1792         if (ati->accessibilityEventMask & cPropertyCaretChangeEvent) {
1793 
1794             PrintDebugString("[INFO]:   sending to AT");
1795 
1796             // make new GlobalRefs for this AT
1797             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
1798             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
1799 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1800             PrintDebugString("[INFO]:   GlobalRef'd Event: %p"\
1801                              "          GlobalRef'd Source: %p", pkg->Event, pkg->AccessibleContextSource);
1802 #else // JOBJECT64 is jlong (64 bit)
1803             PrintDebugString("[INFO]:  GlobalRef'd Event: %016I64X"\
1804                              "  GlobalRef'd Source: %016I64X", pkg->Event, pkg->AccessibleContextSource);
1805 #endif
1806 
1807             if (oldValue != (jstring) 0) {
1808                 stringBytes = (const wchar_t *) env->GetStringChars(oldValue, 0);
1809                 if (stringBytes == NULL) {
1810                     if (!env->ExceptionCheck()) {
1811                         jclass cls = env->FindClass("java/lang/OutOfMemoryError");
1812                         if (cls != NULL) {
1813                             env->ThrowNew(cls, NULL);
1814                         }
1815                     }
1816                     return;
1817                 }
1818                 wcsncpy(pkg->oldDescription, stringBytes, (sizeof(pkg->oldDescription) / sizeof(wchar_t)));
1819                 env->ReleaseStringChars(oldValue, stringBytes);
1820             } else {
1821                 wcsncpy(pkg->oldDescription, L"(null)", (sizeof(pkg->oldDescription) / sizeof(wchar_t)));
1822             }
1823 
1824             if (newValue != (jstring) 0) {
1825                 stringBytes = (const wchar_t *) env->GetStringChars(newValue, 0);
1826                 if (stringBytes == NULL) {
1827                    if (!env->ExceptionCheck()) {
1828                         jclass cls = env->FindClass("java/lang/OutOfMemoryError");
1829                         if (cls != NULL) {
1830                             env->ThrowNew(cls, NULL);
1831                         }
1832                     }
1833                     return;
1834                 }
1835                 wcsncpy(pkg->newDescription, stringBytes, (sizeof(pkg->newDescription) / sizeof(wchar_t)));
1836                 env->ReleaseStringChars(newValue, stringBytes);
1837             } else {
1838                 wcsncpy(pkg->newDescription, L"(null)", (sizeof(pkg->newDescription) / sizeof(wchar_t)));
1839             }
1840 
1841             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyDescriptionChangeEvent);
1842         }
1843         ati = ati->nextATInstance;
1844     }
1845     PrintDebugString("[INFO]:   done with propertyDescriptionChange event");
1846 }
1847 
1848 /**
1849  * firePropertyNameChange
1850  *
1851  */
1852 void
1853 JavaAccessBridge::firePropertyNameChange(JNIEnv *env, jobject callingObj,
1854                                          jobject event, jobject source,
1855                                          jstring oldValue, jstring newValue){
1856 
1857     PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertyNameChanged(%p, %p, %p, %p, %p, %p)",
1858                      env, callingObj, event,
1859                      source, oldValue, newValue);
1860 
1861     // sanity check
1862     if (ATs == (AccessBridgeATInstance *) 0) {
1863         PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)");
1864         return;         // panic!
1865     }
1866 
1867     // common setup
1868     const wchar_t *stringBytes;
1869     char buffer[sizeof(PackageType) + sizeof(PropertyNameChangePackage)];
1870     PackageType *type = (PackageType *) buffer;
1871     PropertyNameChangePackage *pkg = (PropertyNameChangePackage *) (buffer + sizeof(PackageType));
1872     *type = cPropertyNameChangePackage;
1873     pkg->vmID = (long) dialogWindow;
1874 
1875     // make new Global Refs and send events only to those ATs that want 'em
1876     AccessBridgeATInstance *ati = ATs;
1877     while (ati != (AccessBridgeATInstance *) 0) {
1878         if (ati->accessibilityEventMask & cPropertyNameChangeEvent) {
1879 
1880             PrintDebugString("[INFO]:   sending to AT");
1881 
1882             // make new GlobalRefs for this AT
1883             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
1884             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
1885 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1886             PrintDebugString("[INFO]:   GlobalRef'd Event: %p"\
1887                              "          GlobalRef'd Source: %p", pkg->Event, pkg->AccessibleContextSource);
1888 #else // JOBJECT64 is jlong (64 bit)
1889             PrintDebugString("[INFO]:  GlobalRef'd Event: %016I64X"\
1890                              "         GlobalRef'd Source: %016I64X", pkg->Event, pkg->AccessibleContextSource);
1891 #endif
1892 
1893             if (oldValue != (jstring) 0) {
1894                 stringBytes = (const wchar_t *) env->GetStringChars(oldValue, 0);
1895                 if (stringBytes == NULL) {
1896                     if (!env->ExceptionCheck()) {
1897                         jclass cls = env->FindClass("java/lang/OutOfMemoryError");
1898                         if (cls != NULL) {
1899                             env->ThrowNew(cls, NULL);
1900                         }
1901                     }
1902                     return;
1903                 }
1904                 wcsncpy(pkg->oldName, stringBytes, (sizeof(pkg->oldName) / sizeof(wchar_t)));
1905                 env->ReleaseStringChars(oldValue, stringBytes);
1906             } else {
1907                 wcsncpy(pkg->oldName, L"(null)", (sizeof(pkg->oldName) / sizeof(wchar_t)));
1908             }
1909 
1910             if (newValue != (jstring) 0) {
1911                 stringBytes = (const wchar_t *) env->GetStringChars(newValue, 0);
1912                 if (stringBytes == NULL) {
1913                     if (!env->ExceptionCheck()) {
1914                         jclass cls = env->FindClass("java/lang/OutOfMemoryError");
1915                         if (cls != NULL) {
1916                             env->ThrowNew(cls, NULL);
1917                         }
1918                     }
1919                     return;
1920                 }
1921                 wcsncpy(pkg->newName, stringBytes, (sizeof(pkg->newName) / sizeof(wchar_t)));
1922                 env->ReleaseStringChars(newValue, stringBytes);
1923             } else {
1924                 wcsncpy(pkg->newName, L"(null)", (sizeof(pkg->newName) / sizeof(wchar_t)));
1925             }
1926 
1927             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyNameChangeEvent);
1928         }
1929         ati = ati->nextATInstance;
1930     }
1931     PrintDebugString("[INFO]:  done with propertyNameChange event");
1932 }
1933 
1934 
1935 /**
1936  * firePropertySelectionChange
1937  *
1938  */
1939 void
1940 JavaAccessBridge::firePropertySelectionChange(JNIEnv *env, jobject callingObj,
1941                                               jobject event, jobject source) {
1942 
1943     PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertySelectionChanged(%p, %p, %p, %p)",
1944                      env, callingObj, event, source);
1945 
1946     // sanity check
1947     if (ATs == (AccessBridgeATInstance *) 0) {
1948         PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)");
1949         return;         // panic!
1950     }
1951 
1952     // common setup
1953     char buffer[sizeof(PackageType) + sizeof(PropertySelectionChangePackage)];
1954     PackageType *type = (PackageType *) buffer;
1955     PropertySelectionChangePackage *pkg = (PropertySelectionChangePackage *) (buffer + sizeof(PackageType));
1956     *type = cPropertySelectionChangePackage;
1957     pkg->vmID = (long) dialogWindow;
1958 
1959     // make new Global Refs and send events only to those ATs that want 'em
1960     AccessBridgeATInstance *ati = ATs;
1961     while (ati != (AccessBridgeATInstance *) 0) {
1962         if (ati->accessibilityEventMask & cPropertySelectionChangeEvent) {
1963 
1964             PrintDebugString("[INFO]:   sending to AT");
1965 
1966             // make new GlobalRefs for this AT
1967             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
1968             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
1969 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1970             PrintDebugString("[INFO]:   GlobalRef'd Event: %p"\
1971                              "          GlobalRef'd Source: %p", pkg->Event, pkg->AccessibleContextSource);
1972 #else // JOBJECT64 is jlong (64 bit)
1973             PrintDebugString("[INFO]:   GlobalRef'd Event: %016I64X"\
1974                              "          GlobalRef'd Source: %016I64X", pkg->Event, pkg->AccessibleContextSource);
1975 #endif
1976 
1977             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertySelectionChangeEvent);
1978         }
1979         ati = ati->nextATInstance;
1980     }
1981     PrintDebugString("[INFO]:   done with propertySelectionChange event");
1982 }
1983 
1984 
1985 /**
1986  * firePropertyStateChange
1987  *
1988  */
1989 void
1990 JavaAccessBridge::firePropertyStateChange(JNIEnv *env, jobject callingObj,
1991                                           jobject event, jobject source,
1992                                           jstring oldValue, jstring newValue){
1993 
1994     PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertyStateChanged(%p, %p, %p, %p, %p, %p)",
1995                      env, callingObj, event,
1996                      source, oldValue, newValue);
1997 
1998     // sanity check
1999     if (ATs == (AccessBridgeATInstance *) 0) {
2000         PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)");
2001         return;         // panic!
2002     }
2003 
2004     // common setup
2005     const wchar_t *stringBytes;
2006     char buffer[sizeof(PackageType) + sizeof(PropertyStateChangePackage)];
2007     PackageType *type = (PackageType *) buffer;
2008     PropertyStateChangePackage *pkg = (PropertyStateChangePackage *) (buffer + sizeof(PackageType));
2009     *type = cPropertyStateChangePackage;
2010     pkg->vmID = (long) dialogWindow;
2011 
2012     // make new Global Refs and send events only to those ATs that want 'em
2013     AccessBridgeATInstance *ati = ATs;
2014     while (ati != (AccessBridgeATInstance *) 0) {
2015         if (ati->accessibilityEventMask & cPropertyStateChangeEvent) {
2016 
2017             PrintDebugString("[INFO]:   sending to AT");
2018 
2019             // make new GlobalRefs for this AT
2020             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
2021             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
2022 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2023             PrintDebugString("[INFO]:   GlobalRef'd Event: %p"\
2024                              "  GlobalRef'd Source: %p", pkg->Event, pkg->AccessibleContextSource);
2025 #else // JOBJECT64 is jlong (64 bit)
2026             PrintDebugString("[INFO]:  GlobalRef'd Event: %016I64X"\
2027                              "  GlobalRef'd Source: %016I64X", pkg->Event, pkg->AccessibleContextSource);
2028 #endif
2029 
2030             if (oldValue != (jstring) 0) {
2031                 stringBytes = (const wchar_t *) env->GetStringChars(oldValue, 0);
2032                 if (stringBytes == NULL) {
2033                     if (!env->ExceptionCheck()) {
2034                         jclass cls = env->FindClass("java/lang/OutOfMemoryError");
2035                         if (cls != NULL) {
2036                             env->ThrowNew(cls, NULL);
2037                         }
2038                     }
2039                     return;
2040                 }
2041                 wcsncpy(pkg->oldState, stringBytes, (sizeof(pkg->oldState) / sizeof(wchar_t)));
2042                 env->ReleaseStringChars(oldValue, stringBytes);
2043             } else {
2044                 wcsncpy(pkg->oldState, L"(null)", (sizeof(pkg->oldState) / sizeof(wchar_t)));
2045             }
2046 
2047             if (newValue != (jstring) 0) {
2048                 stringBytes = (const wchar_t *) env->GetStringChars(newValue, 0);
2049                 if (stringBytes == NULL) {
2050                     if (!env->ExceptionCheck()) {
2051                         jclass cls = env->FindClass("java/lang/OutOfMemoryError");
2052                         if (cls != NULL) {
2053                             env->ThrowNew(cls, NULL);
2054                         }
2055                     }
2056                     return;
2057                 }
2058                 wcsncpy(pkg->newState, stringBytes, (sizeof(pkg->newState) / sizeof(wchar_t)));
2059                 env->ReleaseStringChars(newValue, stringBytes);
2060             } else {
2061                 wcsncpy(pkg->newState, L"(null)", (sizeof(pkg->newState) / sizeof(wchar_t)));
2062             }
2063 
2064             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyStateChangeEvent);
2065         }
2066         ati = ati->nextATInstance;
2067     }
2068     PrintDebugString("[INFO]:  done with propertyStateChange event");
2069 }
2070 
2071 
2072 /**
2073  * firePropertyTextChange
2074  *
2075  */
2076 void
2077 JavaAccessBridge::firePropertyTextChange(JNIEnv *env, jobject callingObj,
2078                                          jobject event, jobject source) {
2079 
2080     PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertyTextChanged(%p, %p, %p, %p)",
2081                      env, callingObj, event, source);
2082 
2083     // sanity check
2084     if (ATs == (AccessBridgeATInstance *) 0) {
2085         PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)");
2086         return;         // panic!
2087     }
2088 
2089     // common setup
2090     char buffer[sizeof(PackageType) + sizeof(PropertyTextChangePackage)];
2091     PackageType *type = (PackageType *) buffer;
2092     PropertyTextChangePackage *pkg = (PropertyTextChangePackage *) (buffer + sizeof(PackageType));
2093     *type = cPropertyTextChangePackage;
2094     pkg->vmID = (long) dialogWindow;
2095 
2096     // make new Global Refs and send events only to those ATs that want 'em
2097     AccessBridgeATInstance *ati = ATs;
2098     while (ati != (AccessBridgeATInstance *) 0) {
2099         if (ati->accessibilityEventMask & cPropertyTextChangeEvent) {
2100 
2101             PrintDebugString("[INFO]:   sending to AT");
2102 
2103             // make new GlobalRefs for this AT
2104             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
2105             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
2106 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2107             PrintDebugString("[INFO]:   GlobalRef'd Event: %p"\
2108                              "          GlobalRef'd Source: %p",pkg->Event, pkg->AccessibleContextSource);
2109 #else // JOBJECT64 is jlong (64 bit)
2110             PrintDebugString("[INFO]:  GlobalRef'd Event: %016I64X"\
2111                              "  GlobalRef'd Source: %016I64X", pkg->Event, pkg->AccessibleContextSource);
2112 #endif
2113 
2114             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyTextChangeEvent);
2115         }
2116         ati = ati->nextATInstance;
2117     }
2118     PrintDebugString("[INFO]:  done with propertyTextChange event");
2119 }
2120 
2121 
2122 /**
2123  * firePropertyValueChange
2124  *
2125  */
2126 void
2127 JavaAccessBridge::firePropertyValueChange(JNIEnv *env, jobject callingObj,
2128                                           jobject event, jobject source,
2129                                           jstring oldValue, jstring newValue){
2130 
2131     PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertyValueChanged(%p, %p, %p, %p, %p, %p)",
2132                      env, callingObj, event,
2133                      source, oldValue, newValue);
2134 
2135     // sanity check
2136     if (ATs == (AccessBridgeATInstance *) 0) {
2137         PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)");
2138         return;         // panic!
2139     }
2140 
2141     // common setup
2142     const wchar_t *stringBytes;
2143     char buffer[sizeof(PackageType) + sizeof(PropertyValueChangePackage)];
2144     PackageType *type = (PackageType *) buffer;
2145     PropertyValueChangePackage *pkg = (PropertyValueChangePackage *) (buffer + sizeof(PackageType));
2146     *type = cPropertyValueChangePackage;
2147     pkg->vmID = (long) dialogWindow;
2148 
2149     // make new Global Refs and send events only to those ATs that want 'em
2150     AccessBridgeATInstance *ati = ATs;
2151     while (ati != (AccessBridgeATInstance *) 0) {
2152         if (ati->accessibilityEventMask & cPropertyValueChangeEvent) {
2153 
2154             PrintDebugString("[INFO]:   sending to AT");
2155 
2156             // make new GlobalRefs for this AT
2157             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
2158             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
2159 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2160             PrintDebugString("[INFO]:   GlobalRef'd Event: %p"\
2161                              "          GlobalRef'd Source: %p", pkg->Event, pkg->AccessibleContextSource);
2162 #else // JOBJECT64 is jlong (64 bit)
2163             PrintDebugString("[INFO]:  GlobalRef'd Event: %016I64X"\
2164                              "  GlobalRef'd Source: %016I64X", pkg->Event, pkg->AccessibleContextSource);
2165 #endif
2166 
2167             if (oldValue != (jstring) 0) {
2168                 stringBytes = (const wchar_t *) env->GetStringChars(oldValue, 0);
2169                 if (stringBytes == NULL) {
2170                     if (!env->ExceptionCheck()) {
2171                         jclass cls = env->FindClass("java/lang/OutOfMemoryError");
2172                         if (cls != NULL) {
2173                             env->ThrowNew(cls, NULL);
2174                         }
2175                     }
2176                     return;
2177                 }
2178                 wcsncpy(pkg->oldValue, stringBytes, (sizeof(pkg->oldValue) / sizeof(wchar_t)));
2179                 env->ReleaseStringChars(oldValue, stringBytes);
2180             } else {
2181                 wcsncpy(pkg->oldValue, L"(null)", (sizeof(pkg->oldValue) / sizeof(wchar_t)));
2182             }
2183 
2184             if (newValue != (jstring) 0) {
2185                 stringBytes = (const wchar_t *) env->GetStringChars(newValue, 0);
2186                 if (stringBytes == NULL) {
2187                     if (!env->ExceptionCheck()) {
2188                         jclass cls = env->FindClass("java/lang/OutOfMemoryError");
2189                         if (cls != NULL) {
2190                             env->ThrowNew(cls, NULL);
2191                         }
2192                     }
2193                     return;
2194                 }
2195                 wcsncpy(pkg->newValue, stringBytes, (sizeof(pkg->newValue) / sizeof(wchar_t)));
2196                 env->ReleaseStringChars(newValue, stringBytes);
2197             } else {
2198                 wcsncpy(pkg->newValue, L"(null)", (sizeof(pkg->newValue) / sizeof(wchar_t)));
2199             }
2200 
2201             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyValueChangeEvent);
2202         }
2203         ati = ati->nextATInstance;
2204     }
2205     PrintDebugString("[INFO]:   done with propertyValueChange event");
2206 }
2207 
2208 /**
2209  * firePropertyVisibleDataChange
2210  *
2211  */
2212 void
2213 JavaAccessBridge::firePropertyVisibleDataChange(JNIEnv *env, jobject callingObj,
2214                                                 jobject event, jobject source) {
2215 
2216     PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertyVisibleDataChanged(%p, %p, %p, %p)",
2217                      env, callingObj, event, source);
2218 
2219     // sanity check
2220     if (ATs == (AccessBridgeATInstance *) 0) {
2221         PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)");
2222         return;         // panic!
2223     }
2224 
2225     // common setup
2226     char buffer[sizeof(PackageType) + sizeof(PropertyVisibleDataChangePackage)];
2227     PackageType *type = (PackageType *) buffer;
2228     PropertyVisibleDataChangePackage *pkg = (PropertyVisibleDataChangePackage *) (buffer + sizeof(PackageType));
2229     *type = cPropertyVisibleDataChangePackage;
2230     pkg->vmID = (long) dialogWindow;
2231 
2232     // make new Global Refs and send events only to those ATs that want 'em
2233     AccessBridgeATInstance *ati = ATs;
2234     while (ati != (AccessBridgeATInstance *) 0) {
2235         if (ati->accessibilityEventMask & cPropertyVisibleDataChangeEvent) {
2236 
2237             PrintDebugString("[INFO]:   sending to AT");
2238 
2239             // make new GlobalRefs for this AT
2240             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
2241             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
2242 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2243             PrintDebugString("[INFO]:   GlobalRef'd Event: %p"\
2244                              "          GlobalRef'd Source: %p", pkg->Event, pkg->AccessibleContextSource);
2245 #else // JOBJECT64 is jlong (64 bit)
2246             PrintDebugString("[INFO]:  GlobalRef'd Event: %016I64X"\
2247                              "         GlobalRef'd Source: %016I64X", pkg->Event, pkg->AccessibleContextSource);
2248 #endif
2249 
2250             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyVisibleDataChangeEvent);
2251         }
2252         ati = ati->nextATInstance;
2253     }
2254     PrintDebugString("[INFO]:  done with propertyVisibleDataChange event");
2255 }
2256 
2257 
2258 /**
2259  * firePropertyChildChange
2260  *
2261  */
2262 void
2263 JavaAccessBridge::firePropertyChildChange(JNIEnv *env, jobject callingObj,
2264                                           jobject event, jobject source,
2265                                           jobject oldValue, jobject newValue){
2266 
2267     PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertyChildPropertyChanged(%p, %p, %p, %p, %p, %p)",
2268                      env, callingObj, event,
2269                      source, oldValue, newValue);
2270 
2271     // sanity check
2272     if (ATs == (AccessBridgeATInstance *) 0) {
2273         PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)");
2274         return;         // panic!
2275     }
2276 
2277     // common setup
2278     char buffer[sizeof(PackageType) + sizeof(PropertyChildChangePackage)];
2279     PackageType *type = (PackageType *) buffer;
2280     PropertyChildChangePackage *pkg = (PropertyChildChangePackage *) (buffer + sizeof(PackageType));
2281     *type = cPropertyChildChangePackage;
2282     pkg->vmID = (long) dialogWindow;
2283 
2284     // make new Global Refs and send events only to those ATs that want 'em
2285     AccessBridgeATInstance *ati = ATs;
2286     while (ati != (AccessBridgeATInstance *) 0) {
2287         if (ati->accessibilityEventMask & cPropertyChildChangeEvent) {
2288 
2289             PrintDebugString("[INFO]:  sending to AT");
2290 
2291             // make new GlobalRefs for this AT
2292             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
2293             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
2294             pkg->oldChildAccessibleContext = (JOBJECT64)env->NewGlobalRef(oldValue);
2295             pkg->newChildAccessibleContext = (JOBJECT64)env->NewGlobalRef(newValue);
2296 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2297             PrintDebugString("[INFO]:  GlobalRef'd Event: %p"\
2298                              "  GlobalRef'd Source: %p"\
2299                              "  GlobalRef'd OldChildAC: %p"\
2300                              "  GlobalRef'd NewChildAC: %p"\
2301                             , pkg->Event, pkg->AccessibleContextSource, pkg->oldChildAccessibleContext, pkg->newChildAccessibleContext);
2302 #else // JOBJECT64 is jlong (64 bit)
2303             PrintDebugString("[INFO]:   GlobalRef'd Event: %016I64X"\
2304                              "  GlobalRef'd Source: %016I64X"\
2305                              "  GlobalRef'd OldChildAC: %016I64X"\
2306                              "  GlobalRef'd NewChildAC: %016I64X"\
2307                              , pkg->Event, pkg->AccessibleContextSource, pkg->oldChildAccessibleContext, pkg->newChildAccessibleContext);
2308 #endif
2309 
2310             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyChildChangeEvent);
2311         }
2312         ati = ati->nextATInstance;
2313     }
2314     PrintDebugString("[INFO]:  done with propertyChildChange event");
2315 }
2316 
2317 
2318 /**
2319  * firePropertyActiveDescendentChange
2320  *
2321  */
2322 void
2323 JavaAccessBridge::firePropertyActiveDescendentChange(JNIEnv *env, jobject callingObj,
2324                                                      jobject event, jobject source,
2325                                                      jobject oldValue, jobject newValue){
2326 
2327     PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertyActiveDescendentPropertyChanged(%p, %p, %p, %p, %p, %p)",
2328                      env, callingObj, event,
2329                      source, oldValue, newValue);
2330 
2331     // sanity check
2332     if (ATs == (AccessBridgeATInstance *) 0) {
2333         PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)");
2334         return;         // panic!
2335     }
2336 
2337     // common setup
2338     char buffer[sizeof(PackageType) + sizeof(PropertyActiveDescendentChangePackage)];
2339     PackageType *type = (PackageType *) buffer;
2340     PropertyActiveDescendentChangePackage *pkg = (PropertyActiveDescendentChangePackage *) (buffer + sizeof(PackageType));
2341     *type = cPropertyActiveDescendentChangePackage;
2342     pkg->vmID = (long) dialogWindow;
2343 
2344     // make new Global Refs and send events only to those ATs that want 'em
2345     AccessBridgeATInstance *ati = ATs;
2346     while (ati != (AccessBridgeATInstance *) 0) {
2347         if (ati->accessibilityEventMask & cPropertyActiveDescendentChangeEvent) {
2348 
2349             PrintDebugString("[INFO]:   sending to AT");
2350 
2351             // make new GlobalRefs for this AT
2352             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
2353             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
2354             pkg->oldActiveDescendentAccessibleContext = (JOBJECT64)env->NewGlobalRef(oldValue);
2355             pkg->newActiveDescendentAccessibleContext = (JOBJECT64)env->NewGlobalRef(newValue);
2356 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2357             PrintDebugString("[INFO]:   GlobalRef'd Event: %p"\
2358                              "  GlobalRef'd Source: %p"\
2359                              "  GlobalRef'd OldActiveDescendentAC: %p"\
2360                              "  GlobalRef'd NewActiveDescendentAC: %p"\
2361                              , pkg->Event, pkg->AccessibleContextSource, pkg->oldActiveDescendentAccessibleContext, pkg->newActiveDescendentAccessibleContext);
2362 #else // JOBJECT64 is jlong (64 bit)
2363             PrintDebugString("[INFO]:  GlobalRef'd Event: %016I64X"\
2364                              "  GlobalRef'd Source: %016I64X"\
2365                              "  GlobalRef'd OldActiveDescendentAC: %016I64X"\
2366                              "  GlobalRef'd NewActiveDescendentAC: %016I64X"\
2367             , pkg->Event, pkg->AccessibleContextSource, pkg->oldActiveDescendentAccessibleContext, pkg->newActiveDescendentAccessibleContext);
2368 #endif
2369 
2370             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyActiveDescendentChangeEvent);
2371         }
2372         ati = ati->nextATInstance;
2373     }
2374     PrintDebugString("[INFO]:  done with propertyActiveChange event");
2375 }
2376 
2377 /**
2378  * firePropertyValueChange
2379  *
2380  */
2381 void
2382 JavaAccessBridge::firePropertyTableModelChange(JNIEnv *env, jobject callingObj,
2383                                                jobject event, jobject source,
2384                                                jstring oldValue, jstring newValue){
2385 
2386     PrintDebugString("[INFO]: Java_com_sun_java_accessibility_internal_AccessBridge_propertyTableModelChange(%p, %p, %p, %p, %p, %p)",
2387                      env, callingObj, event,
2388                      source, oldValue, newValue);
2389 
2390     // sanity check
2391     if (ATs == (AccessBridgeATInstance *) 0) {
2392         PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)");
2393         return;         // panic!
2394     }
2395 
2396     // common setup
2397     const wchar_t *stringBytes;
2398     char buffer[sizeof(PackageType) + sizeof(PropertyTableModelChangePackage)];
2399     PackageType *type = (PackageType *) buffer;
2400     PropertyTableModelChangePackage *pkg = (PropertyTableModelChangePackage *) (buffer + sizeof(PackageType));
2401     *type = cPropertyTableModelChangePackage;
2402     pkg->vmID = (long) dialogWindow;
2403 
2404     // make new Global Refs and send events only to those ATs that want 'em
2405     AccessBridgeATInstance *ati = ATs;
2406     while (ati != (AccessBridgeATInstance *) 0) {
2407         if (ati->accessibilityEventMask & cPropertyTableModelChangeEvent) {
2408 
2409             PrintDebugString("  sending to AT");
2410 
2411             // make new GlobalRefs for this AT
2412             pkg->Event = (JOBJECT64)env->NewGlobalRef(event);
2413             pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);
2414 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2415             PrintDebugString("[INFO]:   GlobalRef'd Event: %p"\
2416                              "          GlobalRef'd Source: %p", pkg->Event, pkg->AccessibleContextSource);
2417 #else // JOBJECT64 is jlong (64 bit)
2418             PrintDebugString("[INFO]:   GlobalRef'd Event: %016I64X"\
2419                              "          GlobalRef'd Source: %016I64X", pkg->Event, pkg->AccessibleContextSource);
2420 #endif
2421 
2422             if (oldValue != (jstring) 0) {
2423                 stringBytes = (const wchar_t *) env->GetStringChars(oldValue, 0);
2424                 if (stringBytes == NULL) {
2425                     if (!env->ExceptionCheck()) {
2426                         jclass cls = env->FindClass("java/lang/OutOfMemoryError");
2427                         if (cls != NULL) {
2428                             env->ThrowNew(cls, NULL);
2429                         }
2430                     }
2431                     return;
2432                 }
2433                 wcsncpy(pkg->oldValue, stringBytes, (sizeof(pkg->oldValue) / sizeof(wchar_t)));
2434                 env->ReleaseStringChars(oldValue, stringBytes);
2435             } else {
2436                 wcsncpy(pkg->oldValue, L"(null)", (sizeof(pkg->oldValue) / sizeof(wchar_t)));
2437             }
2438 
2439             if (newValue != (jstring) 0) {
2440                 stringBytes = (const wchar_t *) env->GetStringChars(newValue, 0);
2441                 if (stringBytes == NULL) {
2442                     if (!env->ExceptionCheck()) {
2443                         jclass cls = env->FindClass("java/lang/OutOfMemoryError");
2444                         if (cls != NULL) {
2445                             env->ThrowNew(cls, NULL);
2446                         }
2447                     }
2448                     return;
2449                 }
2450                 wcsncpy(pkg->newValue, stringBytes, (sizeof(pkg->newValue) / sizeof(wchar_t)));
2451                 env->ReleaseStringChars(newValue, stringBytes);
2452             } else {
2453                 wcsncpy(pkg->newValue, L"(null)", (sizeof(pkg->newValue) / sizeof(wchar_t)));
2454             }
2455 
2456             ati->sendAccessibilityEventPackage(buffer, sizeof(buffer), cPropertyTableModelChangeEvent);
2457         }
2458         ati = ati->nextATInstance;
2459     }
2460     PrintDebugString("[INFO]:  done with propertyTableModelChange event");
2461 }
2462 
2463 
2464 
2465 #ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2466 #define PRINT_GLOBALREFS() \
2467     PrintDebugString("[INFO]:   GlobalRef'd Event: %p"\
2468                      "          GlobalRef'd Source: %p", pkg->Event, pkg->AccessibleContextSource);
2469 #else // JOBJECT64 is jlong (64 bit)
2470 #define PRINT_GLOBALREFS() \
2471     PrintDebugString("[INFO]:  GlobalRef'd Event: %016I64X"\
2472                      "  GlobalRef'd Source: %016I64X", pkg->Event, pkg->AccessibleContextSource);
2473 #endif
2474 
2475 #define FIRE_EVENT(function, packageStruct, packageConstant, eventConstant)             \
2476     void JavaAccessBridge::function(JNIEnv *env, jobject callingObj,                    \
2477                                     jobject eventObj, jobject source) {                 \
2478                                                                                         \
2479         PrintDebugString("[INFO]: Firing event id = %d(%p, %p, %p, %p); vmID = %X",     \
2480                         eventConstant, env, callingObj, eventObj, source, dialogWindow);\
2481                                                                                         \
2482         /* sanity check */                                                              \
2483         if (ATs == (AccessBridgeATInstance *) 0) {                                      \
2484             PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)");            \
2485             return;         /* panic! */                                                \
2486         }                                                                               \
2487                                                                                         \
2488         /* common setup */                                                              \
2489         char buffer[sizeof(PackageType) + sizeof(packageStruct)];                       \
2490         PackageType *type = (PackageType *) buffer;                                     \
2491         packageStruct *pkg = (packageStruct *) (buffer + sizeof(PackageType));          \
2492         *type = packageConstant;                                                        \
2493         pkg->vmID = (long) dialogWindow;                                                \
2494                                                                                         \
2495         /* make new Global Refs, send events only to those ATs that want 'em */         \
2496         AccessBridgeATInstance *ati = ATs;                                              \
2497         while (ati != (AccessBridgeATInstance *) 0) {                                   \
2498             PrintDebugString("[INFO]: javaEventMask = %X eventConstant=%d pkg->vmID=%X",\
2499                              ati->javaEventMask, eventConstant, pkg->vmID );            \
2500             if (ati->javaEventMask & eventConstant) {                                   \
2501                                                                                         \
2502                 PrintDebugString("[INFO]:   sending to AT");                            \
2503                 /* make new GlobalRefs for this AT */                                   \
2504                 pkg->Event = (JOBJECT64)env->NewGlobalRef(eventObj);                    \
2505                 pkg->AccessibleContextSource = (JOBJECT64)env->NewGlobalRef(source);    \
2506                 PRINT_GLOBALREFS()                                                      \
2507                                                                                         \
2508                 ati->sendJavaEventPackage(buffer, sizeof(buffer), eventConstant);       \
2509             }                                                                           \
2510             ati = ati->nextATInstance;                                                  \
2511         }                                                                               \
2512         PrintDebugString("[INFO]:   done with firing AWT event");                       \
2513     }
2514 
2515     void JavaAccessBridge::javaShutdown(JNIEnv *env, jobject callingObj) {
2516 
2517         PrintDebugString("[INFO]: Firing event id = %d(%p, %p); vmID = %X",
2518                          cJavaShutdownEvent, env, callingObj, dialogWindow);
2519 
2520         /* sanity check */
2521         if (ATs == (AccessBridgeATInstance *) 0) {
2522             PrintDebugString("[ERROR]: ATs == 0! (shouldn't happen here!)");
2523             return;             /* panic! */
2524         }
2525 
2526         /* common setup */
2527         char buffer[sizeof(PackageType) + sizeof(JavaShutdownPackage)];
2528         PackageType *type = (PackageType *) buffer;
2529         JavaShutdownPackage *pkg = (JavaShutdownPackage *) (buffer + sizeof(PackageType));
2530         *type = cJavaShutdownPackage;
2531         pkg->vmID = (long) dialogWindow;
2532 
2533         /* make new Global Refs, send events only to those ATs that want 'em */
2534         AccessBridgeATInstance *ati = ATs;
2535         while (ati != (AccessBridgeATInstance *) 0) {
2536             if (ati->javaEventMask & cJavaShutdownEvent) {
2537                 PrintDebugString("[INFO]:   sending to AT");
2538                 ati->sendJavaEventPackage(buffer, sizeof(buffer), cJavaShutdownEvent);
2539             }
2540             ati = ati->nextATInstance;
2541         }
2542         PrintDebugString("[INFO]:   done with firing AWT event");
2543     }
2544 
2545     FIRE_EVENT(fireFocusGained, FocusGainedPackage, cFocusGainedPackage, cFocusGainedEvent)
2546     FIRE_EVENT(fireFocusLost, FocusLostPackage, cFocusLostPackage, cFocusLostEvent)
2547     FIRE_EVENT(fireCaretUpdate, CaretUpdatePackage, cCaretUpdatePackage, cCaretUpdateEvent)
2548     FIRE_EVENT(fireMouseClicked, MouseClickedPackage, cMouseClickedPackage, cMouseClickedEvent)
2549     FIRE_EVENT(fireMouseEntered, MouseEnteredPackage, cMouseEnteredPackage, cMouseEnteredEvent)
2550     FIRE_EVENT(fireMouseExited, MouseExitedPackage, cMouseExitedPackage, cMouseExitedEvent)
2551     FIRE_EVENT(fireMousePressed, MousePressedPackage, cMousePressedPackage, cMousePressedEvent)
2552     FIRE_EVENT(fireMouseReleased, MouseReleasedPackage, cMouseReleasedPackage, cMouseReleasedEvent)
2553     FIRE_EVENT(fireMenuCanceled, MenuCanceledPackage, cMenuCanceledPackage, cMenuCanceledEvent)
2554     FIRE_EVENT(fireMenuDeselected, MenuDeselectedPackage, cMenuDeselectedPackage, cMenuDeselectedEvent)
2555     FIRE_EVENT(fireMenuSelected, MenuSelectedPackage, cMenuSelectedPackage, cMenuSelectedEvent)
2556     FIRE_EVENT(firePopupMenuCanceled, PopupMenuCanceledPackage, cPopupMenuCanceledPackage, cPopupMenuCanceledEvent)
2557     FIRE_EVENT(firePopupMenuWillBecomeInvisible, PopupMenuWillBecomeInvisiblePackage, cPopupMenuWillBecomeInvisiblePackage, cPopupMenuWillBecomeInvisibleEvent)
2558     FIRE_EVENT(firePopupMenuWillBecomeVisible, PopupMenuWillBecomeVisiblePackage, cPopupMenuWillBecomeVisiblePackage, cPopupMenuWillBecomeVisibleEvent)
2559 
2560 
2561     // -----------------------------
2562 


< prev index next >