CoCalc -- WinAccessBridge.cpp

GitHub Repository: PojavLauncherTeam/mobile
Path: blob/master/src/jdk.accessibility/windows/native/libwindowsaccessbridge/WinAccessBridge.cpp
⁴⁰⁹⁵⁷ views
1
/*
2
 * Copyright (c) 2005, 2020, Oracle and/or its affiliates. All rights reserved.
3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
 *
5
 * This code is free software; you can redistribute it and/or modify it
6
 * under the terms of the GNU General Public License version 2 only, as
7
 * published by the Free Software Foundation.  Oracle designates this
8
 * particular file as subject to the "Classpath" exception as provided
9
 * by Oracle in the LICENSE file that accompanied this code.
10
 *
11
 * This code is distributed in the hope that it will be useful, but WITHOUT
12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14
 * version 2 for more details (a copy is included in the LICENSE file that
15
 * accompanied this code).
16
 *
17
 * You should have received a copy of the GNU General Public License version
18
 * 2 along with this work; if not, write to the Free Software Foundation,
19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20
 *
21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22
 * or visit www.oracle.com if you need additional information or have any
23
 * questions.
24
 */
25

26
/*
27
 * A DLL which is loaded by Windows executables to handle communication
28
 * between Java VMs purposes of Accessbility.
29
 */
30

31
#include "AccessBridgeDebug.h"
32
#include "WinAccessBridge.h"
33
#include "accessBridgeResource.h"
34
#include "accessBridgeCallbacks.h"
35
#include "AccessBridgeMessages.h"
36
#include "AccessBridgeMessageQueue.h"
37

38
#include <windows.h>
39
#include <jni.h>
40
#include <stdio.h>
41

42
// send memory lock
43
//
44
// This lock is need to serialize access to the buffer used by sendMemoryPackage.
45
// If a JVM goes away while the associated memory buffer is in use, a thread switch
46
// allows a call to JavaVMDestroyed and deallocation of the memory buffer.
47
CRITICAL_SECTION sendMemoryIPCLock;
48

49
// registry paths to newly found JVMs that don't have the bridge installed
50
char **newJVMs;
51

52
WinAccessBridge *theWindowsAccessBridge;
53
HWND theDialogWindow;
54

55
// unique broadcast msg. IDs gotten dymanically
56
extern UINT theFromJavaHelloMsgID;
57
extern UINT theFromWindowsHelloMsgID;
58

59
// protects the javaVMs chain while in use
60
bool isVMInstanceChainInUse;
61

62
/* =================================================================================== */
63

64

65

66
/**
67
 * Proc for "New JVM Found" dialog
68
 */
69
BOOL CALLBACK newJVMFoundDialogProc(HWND hwndDlg, UINT message, WPARAM wParam, LPARAM lParam) {
70

71
    switch (message) {
72
    case WM_COMMAND:
73
        // PrintDebugString("    newJVMDialogProc: LOWORD(wParam) = %d", LOWORD(wParam));
74

75
        switch (LOWORD(wParam)) {
76

77
            // Remind user later that a new JVM was installed
78
        case cRemindThereIsNewJVM:
79
            PrintDebugString("[INFO]:    newJVMDialogProc: cRemindThereIsNewJVM");
80
            // do nothing
81
            EndDialog(hwndDlg, wParam);
82
            return TRUE;
83

84
            // Do not remind user later that a new JVM was installed
85
            /*
86
        case cDoNotRemindThereIsNewJVM:
87
            PrintDebugString("    newJVMDialogProc: cDoNotRemindThereIsNewJVM");
88
            // remember to not remind the user there are new JVMs
89
            PrintDebugString("theWindowsAccessBridge = %x", theWindowsAccessBridge);
90
            if (theWindowsAccessBridge != NULL) {
91
                dontRemindUser(newJVMs);
92
            }
93
            EndDialog(hwndDlg, wParam);
94
            return TRUE;
95
            */
96

97
            // Run the AccessBridge installer
98
            /*
99
        case cInstallAccessBridge:
100
            PrintDebugString("    newJVMDialogProc: cInstallAccessBridge");
101
            // start the installer
102
            if (theWindowsAccessBridge != NULL) {
103
                startInstaller(newJVMs);
104
            }
105
            EndDialog(hwndDlg, wParam);
106
            return TRUE;
107
            */
108

109
        default:
110
            ;
111
        }
112
    default:
113
        ;
114
    }
115
    return FALSE;
116
}
117

118

119

120
/* =========================================================================== */
121

122
// ---------------------------------------------------------------------------
123

124
extern "C" {
125
    /**
126
     * DllMain - where Windows executables will load/unload us
127
     *
128
     */
129
    BOOL WINAPI DllMain(HINSTANCE hinstDll, DWORD fdwReason, LPVOID lpvReserved) {
130

131
        switch (fdwReason) {
132
        case DLL_PROCESS_ATTACH:        // A Windows executable loaded us
133
            initializeFileLogger("windows_access_bridge");
134
            PrintDebugString("[INFO]: DLL_PROCESS_ATTACH");
135
            theWindowsAccessBridge = new WinAccessBridge(hinstDll);
136
            break;
137

138
        case DLL_PROCESS_DETACH:        // A Windows executable unloaded us
139
            if (theWindowsAccessBridge != (WinAccessBridge *) 0) {
140
                PrintDebugString("[INFO]: *** AccessBridgeDialogProc -> deleting theWindowsAccessBridge");
141
                delete theWindowsAccessBridge;
142
            }
143
            break;
144
        }
145

146
        return(TRUE);
147
    }
148

149
    /**
150
     * Append debug info to dialog
151
     *
152
     * replaced with code to send output to debug file
153
     *
154
     */
155
    void AppendToCallInfo(char *s) {
156

157
        /*
158
          _CrtDbgReport(_CRT_WARN, (const char *) NULL, NULL, (const char *) NULL,
159
          (const char *) "WinAccessBridge: %s", s);
160
        */
161

162
        char buf[1024];
163
        sprintf(buf, "WinAccessBridge: %s", s);
164
        OutputDebugString(buf);
165
    }
166

167
    /**
168
     * Our window proc
169
     *
170
     */
171
    BOOL CALLBACK AccessBridgeDialogProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) {
172
        COPYDATASTRUCT *sentToUs;
173
        char *package;
174

175
        switch (message) {
176
        case WM_INITDIALOG:
177
            PrintDebugString("[INFO]: AccessBridgeDialogProc -> Initializing");
178
            break;
179

180
            // call from Java with data for us to deliver
181
        case WM_COPYDATA:
182
            if (theDialogWindow == (HWND) wParam) {
183
                PrintDebugString("[INFO]: AccessBridgeDialogProc -> Got WM_COPYDATA from Java Bridge DLL");
184
            } else {
185
                PrintDebugString("[INFO]: AccessBridgeDialogProc -> Got WM_COPYDATA from HWND %p", wParam);
186
                sentToUs = (COPYDATASTRUCT *) lParam;
187
                package = (char *) sentToUs->lpData;
188
                theWindowsAccessBridge->preProcessPackage(package, sentToUs->cbData);
189
            }
190
            break;
191

192
            // message to ourselves -> de-queue messages and send 'em
193
        case AB_MESSAGE_QUEUED:
194
            PrintDebugString("[INFO]: AccessBridgeDialogProc -> Got AB_MESSAGE_QUEUED from ourselves");
195
            theWindowsAccessBridge->receiveAQueuedPackage();
196
            break;
197

198
            // a JavaAccessBridge DLL is going away
199
            //
200
            // When JavaVMDestroyed is called a AccessBridgeJavaVMInstance in the
201
            // javaVMs chain will be removed.  If that chain is in use this will
202
            // cause a crash.  One way AB_DLL_GOING_AWAY can arrive is on any
203
            // outgoing SendMessage call.  SendMessage normally spins waiting for
204
            // a response.  However, if there is an incoming SendMessage, e.g. for
205
            // AB_DLL_GOING_AWAY Windows will send that request to this DialogProc.
206
            // One seemingly easy way to combat that is to use SendMessageTimeout
207
            // with the SMTO_BLOCK flag set.  However, it has been the case that
208
            // even after using that technique AB_DLL_GOING_AWAY can still arrive
209
            // in the middle of processing the javaVMs chain.  An alternative that
210
            // was tried was to use a critical section around any access ot the
211
            // javaVMs chain but unfortunately the AB_DLL_GOING_AWAY message arrives
212
            // on the same thread and thus the use of a critical section is ineffective.
213
            // The solution then is to set a flag whenever the javaVMs chain is being
214
            // used and if that flag is set at this point the message will be posted
215
            // to the message queue.  That would delay the destruction of the instance
216
            // until the chain is not being traversed.
217
        case AB_DLL_GOING_AWAY:
218
            PrintDebugString("[INFO]: ***** AccessBridgeDialogProc -> Got AB_DLL_GOING_AWAY message");
219
            if (isVMInstanceChainInUse) {
220
                PrintDebugString("[INFO]:   javaVMs chain in use, calling PostMessage");
221
                PostMessage(hDlg, AB_DLL_GOING_AWAY, wParam, (LPARAM)0);
222
            } else {
223
                PrintDebugString("[INFO]:   calling javaVMDestroyed");
224
                theWindowsAccessBridge->JavaVMDestroyed((HWND) wParam);
225
            }
226
            break;
227

228
        default:
229
            // the JavaVM is saying "hi"!
230
            // wParam == sourceHwnd; lParam == JavaVMID
231
            if (message == theFromJavaHelloMsgID) {
232
                PrintDebugString("[INFO]: AccessBridgeDialogProc -> Got theFromJavaHelloMsgID; wParam = %p, lParam = %p", wParam, lParam);
233
                theWindowsAccessBridge->rendezvousWithNewJavaDLL((HWND) wParam, (long ) lParam);
234
            }
235
            break;
236
        }
237

238
        return (FALSE);
239
    }
240

241
}
242

243

244

245

246
// ---------------------------------------------------------------------------
247

248
/**
249
 * Initialize the WinAccessBridge
250
 *
251
 */
252
WinAccessBridge::WinAccessBridge(HINSTANCE hInstance) {
253

254
    PrintDebugString("[INFO]: WinAccessBridge ctor");
255

256
    //  IntializeCriticalSection should only be called once.
257
    InitializeCriticalSection(&sendMemoryIPCLock);
258
    windowsInstance = hInstance;
259
    javaVMs = (AccessBridgeJavaVMInstance *) 0;
260
    eventHandler = new AccessBridgeEventHandler();
261
    messageQueue = new AccessBridgeMessageQueue();
262
    initBroadcastMessageIDs();          // get the unique to us broadcast msg. IDs
263
    theWindowsAccessBridge = this;
264
    isVMInstanceChainInUse = false;
265

266
    ShowWindow(theDialogWindow, SW_SHOW);
267
}
268

269

270

271
/**
272
 * Destroy the WinAccessBridge
273
 *
274
 */
275
WinAccessBridge::~WinAccessBridge() {
276
    // inform all other AccessBridges that we're going away
277
    //  -> shut down all event listening
278
    //  -> release all objects held in the JVM by us
279

280
    PrintDebugString("[INFO]: *****in WinAccessBridge::~WinAccessBridge()");
281

282
    // send a broadcast msg.; let other AccessBridge DLLs know we're going away
283
    AccessBridgeJavaVMInstance *current = javaVMs;
284
    while (current != (AccessBridgeJavaVMInstance *) 0) {
285
        PrintDebugString("[INFO]:   telling %p we're going away", current->javaAccessBridgeWindow);
286
        SendMessage(current->javaAccessBridgeWindow,
287
                    AB_DLL_GOING_AWAY, (WPARAM) dialogWindow, (LPARAM) 0);
288
        current = current->nextJVMInstance;
289
    }
290

291
    PrintDebugString("[INFO]:   finished telling JVMs about our demise");
292

293
    delete eventHandler;
294
    delete messageQueue;
295
    delete javaVMs;
296

297
    PrintDebugString("[INFO]:   finished deleting eventHandler, messageQueue, and javaVMs");
298
    PrintDebugString("[INFO]: GOODBYE CRUEL WORLD...");
299
    finalizeFileLogger();
300
    DestroyWindow(theDialogWindow);
301
}
302

303

304
/**
305
 * Bring up our window; make a connection to the rest of the world
306
 *
307
 */
308
BOOL
309
WinAccessBridge::initWindow() {
310
    theDialogWindow = CreateDialog(windowsInstance,
311
                                   "ACCESSBRIDGESTATUSWINDOW", NULL,
312
                                   (DLGPROC) AccessBridgeDialogProc);
313

314
    // If window could not be created, return "failure".
315
    if (!theDialogWindow)
316
        return (FALSE);
317

318
    dialogWindow = theDialogWindow;
319

320
    // Make the window visible, update its client area, & return "success".
321
    // DEBUG_CODE(ShowWindow (theDialogWindow, SW_SHOWNORMAL));
322
    // DEBUG_CODE(UpdateWindow (theDialogWindow));
323

324
    // post a broadcast msg.; let other AccessBridge DLLs know we exist
325
    PostMessage(HWND_BROADCAST, theFromWindowsHelloMsgID, (WPARAM) dialogWindow, (LPARAM) 0);
326

327
    return (TRUE);
328
}
329

330
// -----------------------
331

332
/**
333
 * rendezvousWithNewJavaDLL
334
 *              - Build AccessBridgeJavaVMInstance data structure
335
 *                (including setting up Memory-Mapped file info)
336
 *
337
 */
338
LRESULT
339
WinAccessBridge::rendezvousWithNewJavaDLL(HWND JavaBridgeDLLwindow, long vmID) {
340
    LRESULT returnVal;
341

342
    PrintDebugString("[INFO]: in WinAccessBridge::rendezvousWithNewJavaDLL(%p, %X)",
343
                     JavaBridgeDLLwindow, vmID);
344

345
    isVMInstanceChainInUse = true;
346
    AccessBridgeJavaVMInstance *newVM =
347
        new AccessBridgeJavaVMInstance(dialogWindow, JavaBridgeDLLwindow, vmID, javaVMs);
348
    javaVMs = newVM;
349
    isVMInstanceChainInUse = false;
350

351
    returnVal = javaVMs->initiateIPC();
352
    if (returnVal == 0) {
353

354
        // tell the newly created JavaVM what events we're interested in, if any
355
        long javaEventMask = eventHandler->getJavaEventMask();
356
        long accessibilityEventMask = eventHandler->getAccessibilityEventMask();
357

358
        PrintDebugString("[INFO]:   Setting Java event mask to: %X", javaEventMask);
359

360
        if (javaEventMask != 0) {
361
            addJavaEventNotification(javaEventMask);
362
        }
363

364
        PrintDebugString("[INFO]:   Setting Accessibility event mask to: %X", accessibilityEventMask);
365

366
        if (accessibilityEventMask != 0) {
367
            addAccessibilityEventNotification(accessibilityEventMask);
368
        }
369
    } else {
370
        PrintDebugString("[ERROR]: Failed to initiate IPC with newly created JavaVM!!!");
371
        return FALSE;
372
    }
373

374
    PrintDebugString("[INFO]:   Success!!  We rendezvoused with the JavaDLL");
375
    return returnVal;
376
}
377

378
// -----------------------
379

380
/**
381
 * sendPackage - uses SendMessage(WM_COPYDATA) to do IPC messaging
382
 *               with the Java AccessBridge DLL
383
 *
384
 *               NOTE: WM_COPYDATA is only for one-way IPC; there
385
 *               is now way to return parameters (especially big ones)
386
 *               Use sendMemoryPackage() to do that!
387
 */
388
void
389
WinAccessBridge::sendPackage(char *buffer, long bufsize, HWND destWindow) {
390
    COPYDATASTRUCT toCopy;
391
    toCopy.dwData = 0;          // 32-bits we could use for something...
392
    toCopy.cbData = bufsize;
393
    toCopy.lpData = buffer;
394

395
    SendMessage(destWindow, WM_COPYDATA, (WPARAM) dialogWindow, (LPARAM) &toCopy);
396
}
397

398

399
/**
400
 * sendMemoryPackage - uses Memory-Mapped files to do IPC messaging
401
 *                     with the Java AccessBridge DLL, informing the
402
 *                     Java AccessBridge DLL via SendMessage that something
403
 *                     is waiting for it in the shared file...
404
 *
405
 *                     In the SendMessage call, the third param (WPARAM) is
406
 *                     the source HWND (theDialogWindow in this case), and
407
 *                     the fourth param (LPARAM) is the size in bytes of
408
 *                     the package put into shared memory.
409
 *
410
 */
411
BOOL
412
WinAccessBridge::sendMemoryPackage(char *buffer, long bufsize, HWND destWindow) {
413
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
414
        return FALSE;
415
    }
416
    AccessBridgeJavaVMInstance *ourABJavaVMInstance;
417
    ourABJavaVMInstance = javaVMs->findABJavaVMInstanceFromJavaHWND(destWindow);
418
    if (ourABJavaVMInstance != (AccessBridgeJavaVMInstance *) 0) {
419
        if (!ourABJavaVMInstance->sendMemoryPackage(buffer, bufsize)) {
420
            // return falue to the caller
421
            memset(buffer, 0, bufsize);
422
            return FALSE;
423
        }
424
    } else {
425
        PrintDebugString("[ERROR]: sending memory package: couldn't find destWindow");
426
        return FALSE;
427
    }
428
    return TRUE;
429
}
430

431

432
/**
433
 * queuePackage - put a package onto the queue for latter processing
434
 *
435
 */
436
BOOL
437
WinAccessBridge::queuePackage(char *buffer, long bufsize) {
438
    PrintDebugString("[INFO]:  in WinAccessBridge::queuePackage(%p, %d)", buffer, bufsize);
439

440
    AccessBridgeQueueElement *element = new AccessBridgeQueueElement(buffer, bufsize);
441

442
    messageQueue->add(element);
443
    PostMessage(dialogWindow, AB_MESSAGE_QUEUED, (WPARAM) 0, (LPARAM) 0);
444
    return TRUE;
445
}
446

447

448
/**
449
 * receiveAQueuedPackage - remove a pending packge from the queue and
450
 *                         handle it. If the queue is busy, post a
451
 *                         message to self to retrieve it later
452
 *
453
 */
454
BOOL
455
WinAccessBridge::receiveAQueuedPackage() {
456
    AccessBridgeQueueElement *element = NULL;
457

458
    PrintDebugString("[INFO]: in WinAccessBridge::receiveAQueuedPackage()");
459

460
    // ensure against re-entrancy problems...
461
    if (messageQueue->getRemoveLockSetting() == FALSE) {
462
        messageQueue->setRemoveLock(TRUE);
463

464
        PrintDebugString("[INFO]:  dequeueing message");
465

466
        QueueReturns result = messageQueue->remove(&element);
467

468
        switch (result) {
469

470
        case cQueueBroken:
471
            PrintDebugString("[ERROR]: Queue seems to be broken!");
472
            messageQueue->setRemoveLock(FALSE);
473
            return FALSE;
474

475
        case cMoreMessages:
476
        case cQueueEmpty:
477
            if (element != (AccessBridgeQueueElement *) 0) {
478
                PrintDebugString("[INFO]:  found one; sending it!");
479
                processPackage(element->buffer, element->bufsize);
480
                delete element;
481
            } else {
482
                PrintDebugString("[WARN]:   ODD... element == 0!");
483
                return FALSE;
484
            }
485
            break;
486

487
        case cQueueInUse:
488
            PrintDebugString("[WARN]:  Queue in use, will try again later...");
489
            PostMessage(dialogWindow, AB_MESSAGE_QUEUED, (WPARAM) 0, (LPARAM) 0);
490
            break;
491

492
        default:
493
            messageQueue->setRemoveLock(FALSE);
494
            return FALSE;       // should never get something we don't recognize!
495
        }
496
    } else {
497
        PrintDebugString("[WARN]:  unable to dequeue message; remove lock is set");
498
        PostMessage(dialogWindow, AB_MESSAGE_QUEUED, (WPARAM) 0, (LPARAM) 0); // Fix for 6995891
499
    }
500

501
    messageQueue->setRemoveLock(FALSE);
502
    return TRUE;
503
}
504

505
// -----------------------
506

507
/**
508
 * preProcessPackage
509
 *              - do triage on incoming packages; queue some, deal with others
510
 *
511
 */
512
void
513
WinAccessBridge::preProcessPackage(char *buffer, long bufsize) {
514
    PrintDebugString("[INFO]: PreProcessing package sent from Java:");
515

516
    PackageType *type = (PackageType *) buffer;
517

518
    switch (*type) {
519

520
    PrintDebugString("[INFO]:    type == %X", *type);
521

522
    // event packages all get queued for later handling
523
    //case cPropertyChangePackage:
524
    case cJavaShutdownPackage:
525
    case cFocusGainedPackage:
526
    case cFocusLostPackage:
527
    case cCaretUpdatePackage:
528
    case cMouseClickedPackage:
529
    case cMouseEnteredPackage:
530
    case cMouseExitedPackage:
531
    case cMousePressedPackage:
532
    case cMouseReleasedPackage:
533
    case cMenuCanceledPackage:
534
    case cMenuDeselectedPackage:
535
    case cMenuSelectedPackage:
536
    case cPopupMenuCanceledPackage:
537
    case cPopupMenuWillBecomeInvisiblePackage:
538
    case cPopupMenuWillBecomeVisiblePackage:
539

540
    case cPropertyCaretChangePackage:
541
    case cPropertyDescriptionChangePackage:
542
    case cPropertyNameChangePackage:
543
    case cPropertySelectionChangePackage:
544
    case cPropertyStateChangePackage:
545
    case cPropertyTextChangePackage:
546
    case cPropertyValueChangePackage:
547
    case cPropertyVisibleDataChangePackage:
548
    case cPropertyChildChangePackage:
549
    case cPropertyActiveDescendentChangePackage:
550

551
    case cPropertyTableModelChangePackage:
552

553
        queuePackage(buffer, bufsize);
554
        break;
555

556
        // perhaps there will be some other packages to process at some point... //
557

558
    default:
559
        PrintDebugString("[ERROR]:   processing FAILED!! -> don't know how to handle type = %X", *type);
560
        break;
561
    }
562

563
    PrintDebugString("[INFO]:    package preprocessing completed");
564
}
565

566

567
#define DISPATCH_EVENT_PACKAGE(packageID, eventPackage, fireEventMethod)            \
568
    case packageID:                                                                 \
569
        if (bufsize == sizeof(PackageType) + sizeof(eventPackage)) {                \
570
            eventPackage *pkg =                                                     \
571
                (eventPackage *) (buffer + sizeof(PackageType));                    \
572
            PrintDebugString("[INFO]:    begin callback to AT, type == %X", *type);         \
573
                theWindowsAccessBridge->eventHandler->fireEventMethod(              \
574
                    pkg->vmID, pkg->Event, pkg->AccessibleContextSource);           \
575
                PrintDebugString("[INFO]:    event callback complete!");                    \
576
        } else {                                                                    \
577
            PrintDebugString("[ERROR]:   processing FAILED!! -> bufsize = %d; expectation = %d", \
578
                bufsize, sizeof(PackageType) + sizeof(eventPackage));               \
579
        }                                                                           \
580
        break;
581

582
#define DISPATCH_PROPERTY_CHANGE_PACKAGE(packageID, eventPackage, fireEventMethod, oldValue, newValue) \
583
    case packageID:                                                                 \
584
        if (bufsize == sizeof(PackageType) + sizeof(eventPackage)) {                \
585
            eventPackage *pkg =                                                     \
586
                (eventPackage *) (buffer + sizeof(PackageType));                    \
587
            PrintDebugString("[INFO]:    begin callback to AT, type == %X", *type);         \
588
            theWindowsAccessBridge->eventHandler->fireEventMethod(                  \
589
                pkg->vmID, pkg->Event, pkg->AccessibleContextSource,                \
590
                pkg->oldValue, pkg->newValue);                                      \
591
            PrintDebugString("[INFO]:    event callback complete!");                        \
592
        } else {                                                                    \
593
            PrintDebugString("[ERROR]:   processing FAILED!! -> bufsize = %d; expectation = %d", \
594
                bufsize, sizeof(PackageType) + sizeof(eventPackage));               \
595
        }                                                                           \
596
        break;
597

598
#define DISPATCH_PROPERTY_TABLE_MODEL_CHANGE_PACKAGE(packageID, eventPackage, fireEventMethod, oldValue, newValue) \
599
    case packageID:                                                                 \
600
        if (bufsize == sizeof(PackageType) + sizeof(eventPackage)) {                \
601
            eventPackage *pkg =                                                     \
602
                (eventPackage *) (buffer + sizeof(PackageType));                    \
603
            PrintDebugString("[INFO]:    begin callback to AT, type == %X", *type);         \
604
            theWindowsAccessBridge->eventHandler->fireEventMethod(                  \
605
                pkg->vmID, pkg->Event, pkg->AccessibleContextSource,                \
606
                pkg->oldValue, pkg->newValue);                                      \
607
            PrintDebugString("[INFO]:    event callback complete!");                        \
608
        } else {                                                                    \
609
            PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d", \
610
                bufsize, sizeof(PackageType) + sizeof(eventPackage));                \
611
        }                                                                            \
612
        break;
613

614
/**
615
 * processPackage - processes the output of SendMessage(WM_COPYDATA)
616
 *                  to do IPC messaging with the Java AccessBridge DLL
617
 *
618
 */
619
void
620
WinAccessBridge::processPackage(char *buffer, long bufsize) {
621
    PrintDebugString("[INFO]: WinAccessBridge::Processing package sent from Java:");
622

623
    PackageType *type = (PackageType *) buffer;
624

625
    switch (*type) {
626

627
    PrintDebugString("[INFO]:    type == %X", *type);
628

629
    case cJavaShutdownPackage:
630
        PrintDebugString("[INFO]:    type == cJavaShutdownPackage");
631
        if (bufsize == sizeof(PackageType) + sizeof(JavaShutdownPackage)) {
632
            JavaShutdownPackage *pkg =
633
                (JavaShutdownPackage *) (buffer + sizeof(PackageType));
634
            theWindowsAccessBridge->eventHandler->fireJavaShutdown(pkg->vmID);
635
            PrintDebugString("[INFO]:    event callback complete!");
636
            PrintDebugString("[INFO]:    event fired!");
637
        } else {
638
            PrintDebugString("[ERROR]:    processing FAILED!! -> bufsize = %d; expectation = %d",
639
                             bufsize, sizeof(PackageType) + sizeof(JavaShutdownPackage));
640
        }
641
        break;
642

643

644
        DISPATCH_EVENT_PACKAGE(cFocusGainedPackage, FocusGainedPackage, fireFocusGained);
645
        DISPATCH_EVENT_PACKAGE(cFocusLostPackage, FocusLostPackage, fireFocusLost);
646

647
        DISPATCH_EVENT_PACKAGE(cCaretUpdatePackage, CaretUpdatePackage, fireCaretUpdate);
648

649
        DISPATCH_EVENT_PACKAGE(cMouseClickedPackage, MouseClickedPackage, fireMouseClicked);
650
        DISPATCH_EVENT_PACKAGE(cMouseEnteredPackage, MouseEnteredPackage, fireMouseEntered);
651
        DISPATCH_EVENT_PACKAGE(cMouseExitedPackage, MouseExitedPackage, fireMouseExited);
652
        DISPATCH_EVENT_PACKAGE(cMousePressedPackage, MousePressedPackage, fireMousePressed);
653
        DISPATCH_EVENT_PACKAGE(cMouseReleasedPackage, MouseReleasedPackage, fireMouseReleased);
654

655
        DISPATCH_EVENT_PACKAGE(cMenuCanceledPackage, MenuCanceledPackage, fireMenuCanceled);
656
        DISPATCH_EVENT_PACKAGE(cMenuDeselectedPackage, MenuDeselectedPackage, fireMenuDeselected);
657
        DISPATCH_EVENT_PACKAGE(cMenuSelectedPackage, MenuSelectedPackage, fireMenuSelected);
658
        DISPATCH_EVENT_PACKAGE(cPopupMenuCanceledPackage, PopupMenuCanceledPackage, firePopupMenuCanceled);
659
        DISPATCH_EVENT_PACKAGE(cPopupMenuWillBecomeInvisiblePackage, PopupMenuWillBecomeInvisiblePackage, firePopupMenuWillBecomeInvisible);
660
        DISPATCH_EVENT_PACKAGE(cPopupMenuWillBecomeVisiblePackage, PopupMenuWillBecomeVisiblePackage, firePopupMenuWillBecomeVisible);
661

662
        DISPATCH_PROPERTY_CHANGE_PACKAGE(cPropertyNameChangePackage,
663
                                         PropertyNameChangePackage,
664
                                         firePropertyNameChange, oldName, newName)
665
            DISPATCH_PROPERTY_CHANGE_PACKAGE(cPropertyDescriptionChangePackage,
666
                                             PropertyDescriptionChangePackage,
667
                                             firePropertyDescriptionChange,
668
                                             oldDescription, newDescription)
669
            DISPATCH_PROPERTY_CHANGE_PACKAGE(cPropertyStateChangePackage,
670
                                             PropertyStateChangePackage,
671
                                             firePropertyStateChange, oldState, newState)
672
            DISPATCH_PROPERTY_CHANGE_PACKAGE(cPropertyValueChangePackage,
673
                                             PropertyValueChangePackage,
674
                                             firePropertyValueChange, oldValue, newValue)
675
            DISPATCH_EVENT_PACKAGE(cPropertySelectionChangePackage,
676
                                   PropertySelectionChangePackage, firePropertySelectionChange)
677
            DISPATCH_EVENT_PACKAGE(cPropertyTextChangePackage,
678
                                   PropertyTextChangePackage, firePropertyTextChange)
679
            DISPATCH_PROPERTY_CHANGE_PACKAGE(cPropertyCaretChangePackage,
680
                                             PropertyCaretChangePackage,
681
                                             firePropertyCaretChange, oldPosition, newPosition)
682
            DISPATCH_EVENT_PACKAGE(cPropertyVisibleDataChangePackage,
683
                                   PropertyVisibleDataChangePackage, firePropertyVisibleDataChange)
684
            DISPATCH_PROPERTY_CHANGE_PACKAGE(cPropertyChildChangePackage,
685
                                             PropertyChildChangePackage,
686
                                             firePropertyChildChange,
687
                                             oldChildAccessibleContext,
688
                                             newChildAccessibleContext)
689
            DISPATCH_PROPERTY_CHANGE_PACKAGE(cPropertyActiveDescendentChangePackage,
690
                                             PropertyActiveDescendentChangePackage,
691
                                             firePropertyActiveDescendentChange,
692
                                             oldActiveDescendentAccessibleContext,
693
                                             newActiveDescendentAccessibleContext)
694

695
            DISPATCH_PROPERTY_TABLE_MODEL_CHANGE_PACKAGE(cPropertyTableModelChangePackage,
696
                                                         PropertyTableModelChangePackage,
697
                                                         firePropertyTableModelChange,
698
                                                         oldValue, newValue)
699

700

701
            default:
702
        PrintDebugString("[ERROR]:    processing FAILED!! -> don't know how to handle type = %X", *type);
703
        break;
704
    }
705

706
    PrintDebugString("[INFO]:    package processing completed");
707
}
708

709

710
// -----------------------------
711

712
void
713
WinAccessBridge::JavaVMDestroyed(HWND VMBridgeDLLWindow) {
714
    PrintDebugString("[INFO]: ***** WinAccessBridge::JavaVMDestroyed(%p)", VMBridgeDLLWindow);
715

716
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
717
        return;
718
    }
719

720
    isVMInstanceChainInUse = true;
721
    AccessBridgeJavaVMInstance *currentVM = javaVMs;
722
    AccessBridgeJavaVMInstance *previousVM = javaVMs;
723
    if (javaVMs->javaAccessBridgeWindow == VMBridgeDLLWindow) {
724
        javaVMs = javaVMs->nextJVMInstance;
725
        delete currentVM;
726

727
        PrintDebugString("[INFO]:   data structures successfully removed");
728

729
        // [[[FIXME]]] inform Windows AT that a JVM went away,
730
        // and that any jobjects it's got lying around for that JVM
731
        // are now invalid
732

733
    } else {
734
        while (currentVM != (AccessBridgeJavaVMInstance *) 0) {
735
            if (currentVM->javaAccessBridgeWindow == VMBridgeDLLWindow) {
736
                previousVM->nextJVMInstance = currentVM->nextJVMInstance;
737
                delete currentVM;
738

739
                PrintDebugString("[INFO]:   data structures successfully removed");
740

741
                // [[[FIXME]]] inform Windows AT that a JVM went away,
742
                // and that any jobjects it's got lying around for that JVM
743
                // are now invalid
744
                isVMInstanceChainInUse = false;
745
                return;
746
            } else {
747
                previousVM = currentVM;
748
                currentVM = currentVM->nextJVMInstance;
749
            }
750
        }
751
        PrintDebugString("[ERROR]: couldn't find matching data structures!");
752
    }
753
    isVMInstanceChainInUse = false;
754
}
755

756
// -----------------------
757

758
/**
759
 * releaseJavaObject - lets the JavaVM know it can release the Java Object
760
 *
761
 * Note: once you have made this call, the JavaVM will garbage collect
762
 * the jobject you pass in.  If you later use that jobject in another
763
 * call, you will cause all maner of havoc!
764
 *
765
 */
766
void
767
WinAccessBridge::releaseJavaObject(long vmID, JOBJECT64 object) {
768
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
769
    PrintDebugString("[INFO]: WinAccessBridge::releaseJavaObject(%X, %p)", vmID, object);
770
#else // JOBJECT64 is jlong (64 bit)
771
    PrintDebugString("[INFO]: WinAccessBridge::releaseJavaObject(%X, %016I64X)", vmID, object);
772
#endif
773
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
774
        return;
775
    }
776
    char buffer[sizeof(PackageType) + sizeof(ReleaseJavaObjectPackage)];
777
    PackageType *type = (PackageType *) buffer;
778
    ReleaseJavaObjectPackage *pkg = (ReleaseJavaObjectPackage *) (buffer + sizeof(PackageType));
779
    *type = cReleaseJavaObjectPackage;
780
    pkg->vmID = vmID;
781
    pkg->object = object;
782

783
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
784
    if (destABWindow != (HWND) 0) {
785
        sendPackage(buffer, sizeof(buffer), destABWindow);              // no return values!
786
    }
787
}
788

789
// -----------------------
790

791
/**
792
 * getVersionInfo - fill the AccessBridgeVersionInfo struct
793
 *
794
 */
795
BOOL
796
WinAccessBridge::getVersionInfo(long vmID, AccessBridgeVersionInfo *info) {
797
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
798
        return FALSE;
799
    }
800
    char buffer[sizeof(PackageType) + sizeof(GetAccessBridgeVersionPackage)];
801
    PackageType *type = (PackageType *) buffer;
802
    GetAccessBridgeVersionPackage *pkg = (GetAccessBridgeVersionPackage *) (buffer + sizeof(PackageType));
803
    *type = cGetAccessBridgeVersionPackage;
804
    pkg->vmID = vmID;
805

806
    PrintDebugString("[INFO]: WinAccessBridge::getVersionInfo(%X, )", vmID);
807
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
808
    if (destABWindow != (HWND) 0) {
809
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
810
            memcpy(info, &(pkg->rVersionInfo), sizeof(AccessBridgeVersionInfo));
811
            PrintDebugString("[INFO]:   VMversion: %ls\n"\
812
                             "          bridgeJavaClassVersion: %ls\n"\
813
                             "          bridgeJavaDLLVersion: %ls\n"\
814
                             "          bridgeWinDLLVersion: %ls\n"\
815
            , info->VMversion, info->bridgeJavaClassVersion, info->bridgeJavaDLLVersion, info->bridgeWinDLLVersion);
816
            return TRUE;
817
        }
818
    }
819
    return FALSE;
820
}
821

822

823
/********** Window-related routines ***********************************/
824

825
/**
826
 * isJavaWindow - returns TRUE if the HWND is a top-level Java Window
827
 *
828
 * Note: just because the Windnow is a top-level Java window, that doesn't
829
 * mean that it is accessible.  Call getAccessibleContextFromHWND(HWND) to get the
830
 * AccessibleContext, if any, for an HWND that is a Java Window.
831
 *
832
 */
833
BOOL
834
WinAccessBridge::isJavaWindow(HWND window) {
835
    HWND hwnd;
836

837
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
838
        return FALSE;
839
    }
840

841
    // quick check to see if 'window' is top-level; if not, it's not interesting...
842
    // [[[FIXME]]] is this for sure an OK optimization?
843
    hwnd = getTopLevelHWND(window);
844
    if (hwnd == (HWND) NULL) {
845
        return FALSE;
846
    }
847

848
    PrintDebugString("[INFO]: In WinAccessBridge::isJavaWindow");
849

850

851

852
    char buffer[sizeof(PackageType) + sizeof(IsJavaWindowPackage)];
853
    PackageType *type = (PackageType *) buffer;
854
    IsJavaWindowPackage *pkg = (IsJavaWindowPackage *) (buffer + sizeof(PackageType));
855
    *type = cIsJavaWindowPackage;
856
    pkg->window = (jint) window;
857

858
    PrintDebugString("[INFO]: WinAccessBridge::isJavaWindow(%p)", window);
859

860
    isVMInstanceChainInUse = true;
861
    AccessBridgeJavaVMInstance *current = javaVMs;
862
    while (current != (AccessBridgeJavaVMInstance *) 0) {
863
        if (sendMemoryPackage(buffer, sizeof(buffer), current->javaAccessBridgeWindow) == TRUE) {
864
            if (pkg->rResult != 0) {
865
                isVMInstanceChainInUse = false;
866
                return TRUE;
867
            }
868
        }
869
        current = current->nextJVMInstance;
870
    }
871
    isVMInstanceChainInUse = false;
872
    return FALSE;
873

874

875
    /*
876
      char classname[256];
877
      HWND hwnd;
878

879
      hwnd = getTopLevelHWND(window);
880
      if (hwnd == (HWND) NULL) {
881
      return FALSE;
882
      }
883
      GetClassName(hwnd, classname, 256);
884

885
      if (strstr(classname, "AwtFrame") != 0) {
886
      return TRUE;
887
      } else if (strstr(classname, "AwtWindow") != 0) {
888
      return TRUE;
889
      } else if (strstr(classname, "AwtDialog") != 0) {
890
      return TRUE;
891
      }
892
    */
893
    // JDK 1.4 introduces new (and changes old) classnames
894
    /*
895
      else if (strstr(classname, "SunAwtToolkit") != 0) {
896
      return TRUE;
897
      } else if (strstr(classname, "javax.swing.JFrame") != 0) {
898
      return TRUE;
899
      }
900
    */
901

902
    return FALSE;
903
}
904

905
/**
906
 * isSameObject - returns TRUE if the two object references refer to
907
 *     the same object. Otherwise, this method returns FALSE:
908
 */
909
BOOL
910
WinAccessBridge::isSameObject(long vmID, JOBJECT64 obj1, JOBJECT64 obj2) {
911

912
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
913
    PrintDebugString("[INFO]: WinAccessBridge::isSameObject(%p %p)", obj1, obj2);
914
#else // JOBJECT64 is jlong (64 bit)
915
    PrintDebugString("[INFO]: WinAccessBridge::isSameObject(%016I64X %016I64X)", obj1, obj2);
916
#endif
917

918
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
919
        return FALSE;
920
    }
921

922
    char buffer[sizeof(PackageType) + sizeof(IsSameObjectPackage)];
923
    PackageType *type = (PackageType *) buffer;
924
    IsSameObjectPackage *pkg = (IsSameObjectPackage *) (buffer + sizeof(PackageType));
925
    *type = cIsSameObjectPackage;
926
    pkg->vmID = vmID;
927
    pkg->obj1 = obj1;
928
    pkg->obj2 = obj2;
929

930
    HWND destABWindow = javaVMs->findAccessBridgeWindow(pkg->vmID);
931
    if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
932
        if (pkg->rResult != 0) {
933
            PrintDebugString("[INFO]:   WinAccessBridge::isSameObject returning TRUE (same object)");
934
            return TRUE;
935
        } else {
936
            PrintDebugString("[INFO]:   WinAccessBridge::isSameObject returning FALSE (different object)");
937
            return FALSE;
938
        }
939
    }
940
    PrintDebugString("[ERROR]:   WinAccessBridge::isSameObject returning FALSE (sendMemoryPackage failed)");
941
    return FALSE;
942
}
943

944
/**
945
 * FromHWND - returns the AccessibleContext jobject for the HWND
946
 *
947
 * Note: this routine can return null, even if the HWND is a Java Window,
948
 * because the Java Window may not be accessible.
949
 *
950
 */
951
BOOL
952
WinAccessBridge::getAccessibleContextFromHWND(HWND window, long *vmID, JOBJECT64 *AccessibleContext) {
953
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
954
        return FALSE;
955
    }
956

957
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleContextFromHWNDPackage)];
958
    PackageType *type = (PackageType *) buffer;
959
    GetAccessibleContextFromHWNDPackage *pkg = (GetAccessibleContextFromHWNDPackage *) (buffer + sizeof(PackageType));
960
    *type = cGetAccessibleContextFromHWNDPackage;
961
    pkg->window = (jint) window;
962

963
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleContextFromHWND(%p, )", window);
964

965
    DEBUG_CODE(pkg->rVMID = (long ) 0x01010101);
966
    DEBUG_CODE(pkg->rAccessibleContext = (JOBJECT64) 0x01010101);
967

968
    isVMInstanceChainInUse = true;
969
    AccessBridgeJavaVMInstance *current = javaVMs;
970
    while (current != (AccessBridgeJavaVMInstance *) 0) {
971

972
        if (sendMemoryPackage(buffer, sizeof(buffer), current->javaAccessBridgeWindow) == TRUE) {
973
            if (pkg->rAccessibleContext != 0) {
974
                *vmID = pkg->rVMID;
975
                *AccessibleContext = (JOBJECT64)pkg->rAccessibleContext;
976
                PrintDebugString("[INFO]:     current->vmID = %X, pkg->rVMID = %X", current->vmID, pkg->rVMID);
977
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
978
                PrintDebugString("[INFO]:     pkg->rAccessibleContext = %p", pkg->rAccessibleContext);
979
#else // JOBJECT64 is jlong (64 bit)
980
                PrintDebugString("[INFO]:     pkg->rAccessibleContext = %016I64X", pkg->rAccessibleContext);
981
#endif
982
                if (pkg->rVMID != current->vmID) {
983
                    PrintDebugString("[ERROR]: getAccessibleContextFromHWND vmIDs don't match!");
984
                    isVMInstanceChainInUse = false;
985
                    return FALSE;
986
                }
987
                isVMInstanceChainInUse = false;
988
                return TRUE;
989
            }
990
        }
991
        current = current->nextJVMInstance;
992
    }
993
    isVMInstanceChainInUse = false;
994

995
    // This isn't really an error; it just means that the HWND was for a non-Java
996
    // window.  It's also possible the HWND was for a Java window but the JVM has
997
    // since been shut down and sendMemoryPackage returned FALSE.
998
    PrintDebugString("[ERROR]: getAccessibleContextFromHWND no matching HWND found!");
999
    return FALSE;
1000
}
1001

1002
/**
1003
 * Returns the HWND for an AccessibleContext.  Returns (HWND)0 on error.
1004
 */
1005
HWND
1006
WinAccessBridge::getHWNDFromAccessibleContext(long vmID, JOBJECT64 accessibleContext) {
1007
    PrintDebugString("[INFO]:   in WinAccessBridge::getHWNDFromAccessibleContext");
1008
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1009
        return (HWND)0;
1010
    }
1011

1012
    char buffer[sizeof(PackageType) + sizeof(GetHWNDFromAccessibleContextPackage)];
1013
    PackageType *type = (PackageType *) buffer;
1014
    GetHWNDFromAccessibleContextPackage *pkg = (GetHWNDFromAccessibleContextPackage *) (buffer + sizeof(PackageType));
1015
    *type = cGetHWNDFromAccessibleContextPackage;
1016
    pkg->accessibleContext = accessibleContext;
1017

1018
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1019
    PrintDebugString("[INFO]: WinAccessBridge::getHWNDFromAccessibleContext(%p)", accessibleContext);
1020
#else // JOBJECT64 is jlong (64 bit)
1021
    PrintDebugString("[INFO]: WinAccessBridge::getHWNDFromAccessibleContext(%016I64X)", accessibleContext);
1022
#endif
1023

1024
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1025
    if (destABWindow != (HWND) 0) {
1026
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1027
            return ((HWND)ABLongToHandle(pkg->rHWND));
1028
        }
1029
    }
1030
    return (HWND)0;
1031
}
1032

1033
/********** AccessibleContext routines ***********************************/
1034

1035
/**
1036
 * Walk through Java Windows, in front-to-back Z-order.
1037
 * If NULL is passed it, this function starts at the top.
1038
 *
1039
 */
1040
HWND
1041
WinAccessBridge::getNextJavaWindow(HWND previous) {
1042
    HWND current = previous;
1043
    if (current == NULL) {
1044
        current = GetTopWindow(NULL);
1045
    } else {
1046
        current = GetNextWindow(current, GW_HWNDNEXT);
1047
    }
1048
    while (current != NULL) {
1049
        if (isJavaWindow(current)) {
1050
            return current;
1051
        }
1052
        current = GetNextWindow(current, GW_HWNDNEXT);
1053
    }
1054
    return NULL;
1055
}
1056

1057

1058
/**
1059
 * getAccessibleContextAt - performs the Java code:
1060
 *   Accessible a = EventQueueMonitor.getAccessibleAt(x, y);
1061
 *       return a.getAccessibleContext();
1062
 *
1063
 * Note: this call explicitly goes through the AccessBridge,
1064
 * so that the AccessBridge can hide expected changes in how this functions
1065
 * between JDK 1.1.x w/AccessibilityUtility classes, and JDK 1.2, when some
1066
 * of this functionality may be built into the platform
1067
 *
1068
 */
1069
BOOL
1070
WinAccessBridge::getAccessibleContextAt(long vmID, JOBJECT64 AccessibleContextParent,
1071
                                        jint x, jint y, JOBJECT64 *AccessibleContext) {
1072
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1073
        return FALSE;
1074
    }
1075

1076
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleContextAtPackage)];
1077
    PackageType *type = (PackageType *) buffer;
1078
    GetAccessibleContextAtPackage *pkg = (GetAccessibleContextAtPackage *) (buffer + sizeof(PackageType));
1079
    *type = cGetAccessibleContextAtPackage;
1080
    pkg->vmID = vmID;
1081
    pkg->AccessibleContext = AccessibleContextParent;
1082
    pkg->x = x;
1083
    pkg->y = y;
1084

1085
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleContextAt(%X, %p, %d, %c)", vmID, AccessibleContextParent, x, y);
1086
    HWND destABWindow = javaVMs->findAccessBridgeWindow(pkg->vmID);
1087
    if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1088
        *AccessibleContext = pkg->rAccessibleContext;
1089
        return TRUE;
1090
    }
1091

1092
    return FALSE;
1093
}
1094

1095

1096
/**
1097
 * getAccessibleContextWithFocus - performs the Java code:
1098
 *   Accessible a = Translator.getAccessible(SwingEventMonitor.getComponentWithFocus());
1099
 *   return a.getAccessibleContext();
1100
 *
1101
 * Note: this call explicitly goes through the AccessBridge,
1102
 * so that the AccessBridge can hide expected changes in how this functions
1103
 * between JDK 1.1.x w/AccessibilityUtility classes, and JDK 1.2, when some
1104
 * of this functionality may be built into the platform
1105
 *
1106
 */
1107
BOOL
1108
WinAccessBridge::getAccessibleContextWithFocus(HWND window, long *vmID, JOBJECT64 *AccessibleContext) {
1109

1110
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1111
        return FALSE;
1112
    }
1113
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleContextWithFocusPackage)];
1114
    PackageType *type = (PackageType *) buffer;
1115
    GetAccessibleContextWithFocusPackage *pkg = (GetAccessibleContextWithFocusPackage *) (buffer + sizeof(PackageType));
1116
    *type = cGetAccessibleContextWithFocusPackage;
1117

1118
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleContextWithFocus(%p, %X, )", window, vmID);
1119
    // find vmID, etc. from HWND; ask that VM for the AC w/Focus
1120
    HWND pkgVMID;
1121
    if (getAccessibleContextFromHWND(window, (long *)&(pkgVMID), &(pkg->rAccessibleContext)) == TRUE) {
1122
        HWND destABWindow = javaVMs->findAccessBridgeWindow((long)pkgVMID);     // ineffecient [[[FIXME]]]
1123
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1124
            *vmID = pkg->rVMID;
1125
            *AccessibleContext = pkg->rAccessibleContext;
1126
            return TRUE;
1127
        }
1128
    }
1129

1130
    return FALSE;
1131
}
1132

1133
/**
1134
 * getAccessibleContextInfo - fills a struct with a bunch of information
1135
 * contained in the Java Accessibility API
1136
 *
1137
 *
1138
 * Note: if the AccessibleContext parameter is bogus, this call will blow up
1139
 */
1140
BOOL
1141
WinAccessBridge::getAccessibleContextInfo(long vmID,
1142
                                          JOBJECT64 accessibleContext,
1143
                                          AccessibleContextInfo *info) {
1144
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1145
        return FALSE;
1146
    }
1147
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleContextInfoPackage)];
1148
    PackageType *type = (PackageType *) buffer;
1149
    GetAccessibleContextInfoPackage *pkg = (GetAccessibleContextInfoPackage *) (buffer + sizeof(PackageType));
1150
    *type = cGetAccessibleContextInfoPackage;
1151
    pkg->vmID = vmID;
1152
    pkg->AccessibleContext = accessibleContext;
1153

1154
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1155
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleContextInfo(%X, %p, )", vmID, accessibleContext);
1156
#else // JOBJECT64 is jlong (64 bit)
1157
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleContextInfo(%X, %016I64X, )", vmID, accessibleContext);
1158
#endif
1159
    // need to call only the HWND/VM that contains this AC
1160
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1161
    if (destABWindow != (HWND) 0) {
1162
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1163
            memcpy(info, &(pkg->rAccessibleContextInfo), sizeof(AccessibleContextInfo));
1164
            PrintDebugString("[INFO]:   name: %ls\n"\
1165
                             "          description: %ls\n"\
1166
                             "          role: %ls\n"\
1167
                             "          role_en_US: %ls\n"\
1168
                             "          states: %ls\n"\
1169
                             "          states_en_US: %ls\n"\
1170
            , info->name, info->description, info->role, info->role_en_US, info->states, info->states_en_US);
1171
            return TRUE;
1172
        }
1173
    }
1174

1175
    return FALSE;
1176
}
1177

1178
/**
1179
 * getAccessibleChildFromContext - performs the Java code:
1180
 *   Accessible child = ac.getAccessibleChild(i);
1181
 *   return child.getAccessibleContext();
1182
 *
1183
 * Note: this call explicitly goes through the AccessBridge,
1184
 * so that the AccessBridge can hide expected changes in how this functions
1185
 * between JDK 1.1.x w/AccessibilityUtility classes, and JDK 1.2, when some
1186
 * of this functionality may be built into the platform
1187
 *
1188
 */
1189
JOBJECT64
1190
WinAccessBridge::getAccessibleChildFromContext(long vmID,
1191
                                               JOBJECT64 AccessibleContext,
1192
                                               jint childIndex) {
1193
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1194
        return (JOBJECT64)0;
1195
    }
1196
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleChildFromContextPackage)];
1197
    PackageType *type = (PackageType *) buffer;
1198
    GetAccessibleChildFromContextPackage *pkg = (GetAccessibleChildFromContextPackage *) (buffer + sizeof(PackageType));
1199
    *type = cGetAccessibleChildFromContextPackage;
1200
    pkg->vmID = vmID;
1201
    pkg->AccessibleContext = AccessibleContext;
1202
    pkg->childIndex = childIndex;
1203

1204
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1205
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleChildFromContext(%X, %p, %d)", vmID, AccessibleContext, childIndex);
1206
#else // JOBJECT64 is jlong (64 bit)
1207
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleChildFromContext(%X, %016I64X, %d)", vmID, AccessibleContext, childIndex);
1208
#endif
1209
    // need to call only the HWND/VM that contains this AC
1210
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1211
    if (destABWindow != (HWND) 0) {
1212
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1213
            return pkg->rAccessibleContext;
1214
        }
1215
    }
1216

1217
    return (JOBJECT64) 0;
1218
}
1219

1220
/**
1221
 * getAccessibleParentFromContext - returns the parent AccessibleContext jobject
1222
 *
1223
 * Note: this may be null, if the AccessibleContext passed in is a top-level
1224
 * window, then it has no parent.
1225
 *
1226
 */
1227
JOBJECT64
1228
WinAccessBridge::getAccessibleParentFromContext(long vmID,
1229
                                                JOBJECT64 AccessibleContext) {
1230
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1231
        return (JOBJECT64)0;
1232
    }
1233
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleParentFromContextPackage)];
1234
    PackageType *type = (PackageType *) buffer;
1235
    GetAccessibleParentFromContextPackage *pkg = (GetAccessibleParentFromContextPackage *) (buffer + sizeof(PackageType));
1236
    *type = cGetAccessibleParentFromContextPackage;
1237
    pkg->vmID = vmID;
1238
    pkg->AccessibleContext = AccessibleContext;
1239

1240
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleParentFromContext(%X, %p)", vmID, AccessibleContext);
1241
    // need to call only the HWND/VM that contains this AC
1242
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1243
    if (destABWindow != (HWND) 0) {
1244
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1245
            return pkg->rAccessibleContext;
1246
        }
1247
    }
1248

1249
    return (JOBJECT64) 0;
1250
}
1251

1252
/********** AccessibleTable routines ***********************************/
1253

1254
BOOL
1255
WinAccessBridge::getAccessibleTableInfo(long vmID,
1256
                                        JOBJECT64 accessibleContext,
1257
                                        AccessibleTableInfo *tableInfo) {
1258

1259
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1260
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableInfo(%X, %p, %p)", vmID, accessibleContext,
1261
                     tableInfo);
1262
#else // JOBJECT64 is jlong (64 bit)
1263
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableInfo(%X, %016I64X, %p)", vmID, accessibleContext,
1264
                     tableInfo);
1265
#endif
1266

1267
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1268
        return FALSE;
1269
    }
1270
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableInfoPackage)];
1271
    PackageType *type = (PackageType *) buffer;
1272
    GetAccessibleTableInfoPackage *pkg = (GetAccessibleTableInfoPackage *) (buffer + sizeof(PackageType));
1273
    *type = cGetAccessibleTableInfoPackage;
1274
    pkg->vmID = vmID;
1275
    pkg->accessibleContext = accessibleContext;
1276

1277
    // need to call only the HWND/VM that contains this AC
1278
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1279
    if (destABWindow != (HWND) 0) {
1280
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1281
            memcpy(tableInfo, &(pkg->rTableInfo), sizeof(AccessibleTableInfo));
1282
            if (pkg->rTableInfo.rowCount != -1) {
1283
                PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleTableInfo succeeded");
1284
                return TRUE;
1285
            }
1286
        }
1287
    }
1288
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::getAccessibleTableInfo failed");
1289
    return FALSE;
1290
}
1291

1292
BOOL
1293
WinAccessBridge::getAccessibleTableCellInfo(long vmID, JOBJECT64 accessibleTable,
1294
                                            jint row, jint column,
1295
                                            AccessibleTableCellInfo *tableCellInfo) {
1296

1297
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableCellInfo(%X, %p, %d, %d, %p)", vmID,
1298
                     accessibleTable, row, column, tableCellInfo);
1299

1300
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1301
        return FALSE;
1302
    }
1303

1304
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableCellInfoPackage)];
1305
    PackageType *type = (PackageType *) buffer;
1306
    GetAccessibleTableCellInfoPackage *pkg = (GetAccessibleTableCellInfoPackage *) (buffer + sizeof(PackageType));
1307
    *type = cGetAccessibleTableCellInfoPackage;
1308
    pkg->vmID = vmID;
1309
    pkg->accessibleTable = accessibleTable;
1310
    pkg->row = row;
1311
    pkg->column = column;
1312
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1313

1314
    if (destABWindow != (HWND) 0) {
1315
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1316
            PrintDebugString("[INFO]:   XXXX pkg->rTableCellInfo.accessibleContext = %p", pkg->rTableCellInfo.accessibleContext);
1317
            memcpy(tableCellInfo, &(pkg->rTableCellInfo), sizeof(AccessibleTableCellInfo));
1318
            PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleTableCellInfo succeeded");
1319
            return TRUE;
1320
        }
1321
    }
1322
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::getAccessibleTableCellInfo failed");
1323
    return FALSE;
1324
}
1325

1326

1327
BOOL
1328
WinAccessBridge::getAccessibleTableRowHeader(long vmID, JOBJECT64 accessibleContext, AccessibleTableInfo *tableInfo) {
1329

1330
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1331
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRowHeader(%X, %p)", vmID, accessibleContext);
1332
#else // JOBJECT64 is jlong (64 bit)
1333
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRowHeader(%X, %016I64X)", vmID, accessibleContext);
1334
#endif
1335

1336
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1337
        return FALSE;
1338
    }
1339
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableRowHeaderPackage)];
1340
    PackageType *type = (PackageType *) buffer;
1341
    GetAccessibleTableRowHeaderPackage *pkg = (GetAccessibleTableRowHeaderPackage *) (buffer + sizeof(PackageType));
1342
    *type = cGetAccessibleTableRowHeaderPackage;
1343
    pkg->vmID = vmID;
1344
    pkg->accessibleContext = accessibleContext;
1345

1346
    // need to call only the HWND/VM that contains this AC
1347
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1348
    if (destABWindow != (HWND) 0) {
1349
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1350
            PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleTableRowHeader succeeded");
1351
            memcpy(tableInfo, &(pkg->rTableInfo), sizeof(AccessibleTableInfo));
1352
            return TRUE;
1353
        }
1354
    }
1355
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::getAccessibleTableRowHeader failed");
1356
    return FALSE;
1357
}
1358

1359
BOOL
1360
WinAccessBridge::getAccessibleTableColumnHeader(long vmID, JOBJECT64 accessibleContext, AccessibleTableInfo *tableInfo) {
1361

1362
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1363
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumnHeader(%X, %p)", vmID, accessibleContext);
1364
#else // JOBJECT64 is jlong (64 bit)
1365
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumnHeader(%X, %016I64X)", vmID, accessibleContext);
1366
#endif
1367

1368
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1369
        return FALSE;
1370
    }
1371
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableColumnHeaderPackage)];
1372
    PackageType *type = (PackageType *) buffer;
1373
    GetAccessibleTableColumnHeaderPackage *pkg = (GetAccessibleTableColumnHeaderPackage *) (buffer + sizeof(PackageType));
1374
    *type = cGetAccessibleTableColumnHeaderPackage;
1375
    pkg->vmID = vmID;
1376
    pkg->accessibleContext = accessibleContext;
1377

1378
    // need to call only the HWND/VM that contains this AC
1379
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1380
    if (destABWindow != (HWND) 0) {
1381
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1382
            PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleTableColumnHeader succeeded");
1383
            memcpy(tableInfo, &(pkg->rTableInfo), sizeof(AccessibleTableInfo));
1384
            return TRUE;
1385
        }
1386
    }
1387
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::getAccessibleTableColumnHeader failed");
1388
    return FALSE;
1389
}
1390

1391
JOBJECT64
1392
WinAccessBridge::getAccessibleTableRowDescription(long vmID,
1393
                                                  JOBJECT64 accessibleContext,
1394
                                                  jint row) {
1395

1396
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1397
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRowDescription(%X, %p, %d)", vmID, accessibleContext,
1398
                     row);
1399
#else // JOBJECT64 is jlong (64 bit)
1400
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRowDescription(%X, %016I64X, %d)", vmID, accessibleContext,
1401
                     row);
1402
#endif
1403

1404
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1405
        return FALSE;
1406
    }
1407
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableRowDescriptionPackage)];
1408
    PackageType *type = (PackageType *) buffer;
1409
    GetAccessibleTableRowDescriptionPackage *pkg = (GetAccessibleTableRowDescriptionPackage *) (buffer + sizeof(PackageType));
1410
    *type = cGetAccessibleTableRowDescriptionPackage;
1411
    pkg->vmID = vmID;
1412
    pkg->row = row;
1413
    pkg->accessibleContext = accessibleContext;
1414

1415
    // need to call only the HWND/VM that contains this AC
1416
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1417
    if (destABWindow != (HWND) 0) {
1418
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1419
            PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleTableRowDescription succeeded");
1420
            return pkg->rAccessibleContext;
1421
        }
1422
    }
1423
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::getAccessibleTableRowDescription failed");
1424
    return (JOBJECT64)0;
1425
}
1426

1427
JOBJECT64
1428
WinAccessBridge::getAccessibleTableColumnDescription(long vmID,
1429
                                                     JOBJECT64 accessibleContext,
1430
                                                     jint column) {
1431

1432
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1433
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumnDescription(%X, %p, %d)", vmID, accessibleContext,
1434
                     column);
1435
#else // JOBJECT64 is jlong (64 bit)
1436
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumnDescription(%X, %016I64X, %d)", vmID, accessibleContext,
1437
                     column);
1438
#endif
1439

1440
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1441
        return FALSE;
1442
    }
1443
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableColumnDescriptionPackage)];
1444
    PackageType *type = (PackageType *) buffer;
1445
    GetAccessibleTableColumnDescriptionPackage *pkg =
1446
        (GetAccessibleTableColumnDescriptionPackage *) (buffer + sizeof(PackageType));
1447
    *type = cGetAccessibleTableColumnDescriptionPackage;
1448
    pkg->vmID = vmID;
1449
    pkg->column = column;
1450
    pkg->accessibleContext = accessibleContext;
1451

1452
    // need to call only the HWND/VM that contains this AC
1453
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1454
    if (destABWindow != (HWND) 0) {
1455
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1456
            PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleTableColumnDescription succeeded");
1457
            return pkg->rAccessibleContext;
1458
        }
1459
    }
1460
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::getAccessibleTableColumnDescription failed");
1461
    return (JOBJECT64)0;
1462
}
1463

1464
jint
1465
WinAccessBridge::getAccessibleTableRowSelectionCount(long vmID, JOBJECT64 accessibleTable) {
1466

1467
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1468
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRowSelectionCount(%X, %p)", vmID, accessibleTable);
1469
#else // JOBJECT64 is jlong (64 bit)
1470
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRowSelectionCount(%X, %016I64X)", vmID, accessibleTable);
1471
#endif
1472

1473
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1474
        return 0;
1475
    }
1476
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableRowSelectionCountPackage)];
1477
    PackageType *type = (PackageType *) buffer;
1478
    GetAccessibleTableRowSelectionCountPackage *pkg =
1479
        (GetAccessibleTableRowSelectionCountPackage *) (buffer + sizeof(PackageType));
1480
    *type = cGetAccessibleTableRowSelectionCountPackage;
1481
    pkg->vmID = vmID;
1482
    pkg->accessibleTable = accessibleTable;
1483

1484
    // need to call only the HWND/VM that contains this AC
1485
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1486
    if (destABWindow != (HWND) 0) {
1487
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1488
            PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleTableRowSelectionCount succeeded");
1489
            return pkg->rCount;
1490
        }
1491
    }
1492
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::getAccessibleTableRowSelectionCount failed");
1493
    return 0;
1494
}
1495

1496
BOOL
1497
WinAccessBridge::isAccessibleTableRowSelected(long vmID, JOBJECT64 accessibleTable, jint row) {
1498

1499
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1500
    PrintDebugString("[INFO]: ##### WinAccessBridge::isAccessibleTableRowSelected(%X, %p)", vmID, accessibleTable);
1501
#else // JOBJECT64 is jlong (64 bit)
1502
    PrintDebugString("[INFO]: ##### WinAccessBridge::isAccessibleTableRowSelected(%X, %016I64X)", vmID, accessibleTable);
1503
#endif
1504

1505
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1506
        return FALSE;
1507
    }
1508
    char buffer[sizeof(PackageType) + sizeof(IsAccessibleTableRowSelectedPackage)];
1509
    PackageType *type = (PackageType *) buffer;
1510
    IsAccessibleTableRowSelectedPackage *pkg = (IsAccessibleTableRowSelectedPackage *) (buffer + sizeof(PackageType));
1511
    *type = cIsAccessibleTableRowSelectedPackage;
1512
    pkg->vmID = vmID;
1513
    pkg->accessibleTable = accessibleTable;
1514
    pkg->row = row;
1515

1516
    // need to call only the HWND/VM that contains this AC
1517
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1518
    if (destABWindow != (HWND) 0) {
1519
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1520
            PrintDebugString("[INFO]:   ##### WinAccessBridge::isAccessibleTableRowSelected succeeded");
1521
            return pkg->rResult;
1522
        }
1523
    }
1524
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::isAccessibleTableRowSelected failed");
1525
    return FALSE;
1526
}
1527

1528
BOOL
1529
WinAccessBridge::getAccessibleTableRowSelections(long vmID, JOBJECT64 accessibleTable, jint count, jint *selections) {
1530

1531
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1532
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRowSelections(%X, %p)", vmID, accessibleTable);
1533
#else // JOBJECT64 is jlong (64 bit)
1534
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRowSelections(%X, %016I64X)", vmID, accessibleTable);
1535
#endif
1536

1537
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1538
        return FALSE;
1539
    }
1540
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableRowSelectionsPackage)];
1541
    PackageType *type = (PackageType *) buffer;
1542
    GetAccessibleTableRowSelectionsPackage *pkg =
1543
        (GetAccessibleTableRowSelectionsPackage *) (buffer + sizeof(PackageType));
1544
    *type = cGetAccessibleTableRowSelectionsPackage;
1545
    pkg->vmID = vmID;
1546
    pkg->accessibleTable = accessibleTable;
1547
    pkg->count = count;
1548

1549
    // need to call only the HWND/VM that contains this AC
1550
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1551
    if (destABWindow != (HWND) 0) {
1552
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1553
            PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleTableRowSelections succeeded");
1554
            memcpy(selections, pkg->rSelections, count * sizeof(jint));
1555
            return TRUE;
1556
        }
1557
    }
1558
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::getAccessibleTableRowSelections failed");
1559
    return FALSE;
1560
}
1561

1562

1563
jint
1564
WinAccessBridge::getAccessibleTableColumnSelectionCount(long vmID, JOBJECT64 accessibleTable) {
1565

1566
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1567
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumnSelectionCount(%X, %p)", vmID,
1568
                     accessibleTable);
1569
#else // JOBJECT64 is jlong (64 bit)
1570
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumnSelectionCount(%X, %016I64X)", vmID,
1571
                     accessibleTable);
1572
#endif
1573

1574
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1575
        return FALSE;
1576
    }
1577
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableColumnSelectionCountPackage)];
1578
    PackageType *type = (PackageType *) buffer;
1579
    GetAccessibleTableColumnSelectionCountPackage *pkg =
1580
        (GetAccessibleTableColumnSelectionCountPackage *) (buffer + sizeof(PackageType));
1581
    *type = cGetAccessibleTableColumnSelectionCountPackage;
1582
    pkg->vmID = vmID;
1583
    pkg->accessibleTable = accessibleTable;
1584

1585
    // need to call only the HWND/VM that contains this AC
1586
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1587
    if (destABWindow != (HWND) 0) {
1588
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1589
            PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleTableColumnSelectionCount succeeded");
1590
            return pkg->rCount;
1591
        }
1592
    }
1593
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::getAccessibleTableColumnSelectionCount failed");
1594
    return 0;
1595
}
1596

1597
BOOL
1598
WinAccessBridge::isAccessibleTableColumnSelected(long vmID, JOBJECT64 accessibleTable, jint column) {
1599
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1600
    PrintDebugString("[INFO]: ##### WinAccessBridge::isAccessibleTableColumnSelected(%X, %p)", vmID, accessibleTable);
1601
#else // JOBJECT64 is jlong (64 bit)
1602
    PrintDebugString("[INFO]: ##### WinAccessBridge::isAccessibleTableColumnSelected(%X, %016I64X)", vmID, accessibleTable);
1603
#endif
1604

1605
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1606
        return FALSE;
1607
    }
1608
    char buffer[sizeof(PackageType) + sizeof(IsAccessibleTableColumnSelectedPackage)];
1609
    PackageType *type = (PackageType *) buffer;
1610
    IsAccessibleTableColumnSelectedPackage *pkg = (IsAccessibleTableColumnSelectedPackage *) (buffer + sizeof(PackageType));
1611
    *type = cIsAccessibleTableColumnSelectedPackage;
1612
    pkg->vmID = vmID;
1613
    pkg->accessibleTable = accessibleTable;
1614
    pkg->column = column;
1615

1616
    // need to call only the HWND/VM that contains this AC
1617
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1618
    if (destABWindow != (HWND) 0) {
1619
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1620
            PrintDebugString("[INFO]:   ##### WinAccessBridge::isAccessibleTableColumnSelected succeeded");
1621
            return pkg->rResult;
1622
        }
1623
    }
1624
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::isAccessibleTableColumnSelected failed");
1625
    return FALSE;
1626
}
1627

1628
BOOL
1629
WinAccessBridge::getAccessibleTableColumnSelections(long vmID, JOBJECT64 accessibleTable, jint count,
1630
                                                    jint *selections) {
1631

1632
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1633
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumnSelections(%X, %p)", vmID, accessibleTable);
1634
#else // JOBJECT64 is jlong (64 bit)
1635
    PrintDebugString("[ERROR]: ##### WinAccessBridge::getAccessibleTableColumnSelections(%X, %016I64X)", vmID, accessibleTable);
1636
#endif
1637

1638
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1639
        return FALSE;
1640
    }
1641
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableColumnSelectionsPackage)];
1642
    PackageType *type = (PackageType *) buffer;
1643
    GetAccessibleTableColumnSelectionsPackage *pkg =
1644
        (GetAccessibleTableColumnSelectionsPackage *) (buffer + sizeof(PackageType));
1645
    *type = cGetAccessibleTableColumnSelectionsPackage;
1646
    pkg->vmID = vmID;
1647
    pkg->count = count;
1648
    pkg->accessibleTable = accessibleTable;
1649

1650
    // need to call only the HWND/VM that contains this AC
1651
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1652
    if (destABWindow != (HWND) 0) {
1653
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1654
            PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleTableColumnSelections succeeded");
1655
            memcpy(selections, pkg->rSelections, count * sizeof(jint));
1656
            return TRUE;
1657
        }
1658
    }
1659
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::getAccessibleTableColumnSelections failed");
1660
    return FALSE;
1661
}
1662

1663
jint
1664
WinAccessBridge::getAccessibleTableRow(long vmID, JOBJECT64 accessibleTable, jint index) {
1665

1666
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1667
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRow(%X, %p, index=%d)", vmID,
1668
                     accessibleTable, index);
1669
#else // JOBJECT64 is jlong (64 bit)
1670
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableRow(%X, %016I64X, index=%d)", vmID,
1671
                     accessibleTable, index);
1672
#endif
1673

1674
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1675
        return FALSE;
1676
    }
1677
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableRowPackage)];
1678
    PackageType *type = (PackageType *) buffer;
1679
    GetAccessibleTableRowPackage *pkg =
1680
        (GetAccessibleTableRowPackage *) (buffer + sizeof(PackageType));
1681
    *type = cGetAccessibleTableRowPackage;
1682
    pkg->vmID = vmID;
1683
    pkg->accessibleTable = accessibleTable;
1684
    pkg->index = index;
1685

1686
    // need to call only the HWND/VM that contains this AC
1687
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1688
    if (destABWindow != (HWND) 0) {
1689
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1690
            PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleTableRow succeeded");
1691
            return pkg->rRow;
1692
        }
1693
    }
1694
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::getAccessibleTableRow failed");
1695
    return 0;
1696
}
1697

1698
jint
1699
WinAccessBridge::getAccessibleTableColumn(long vmID, JOBJECT64 accessibleTable, jint index) {
1700

1701
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1702
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumn(%X, %p, index=%d)", vmID,
1703
                     accessibleTable, index);
1704
#else // JOBJECT64 is jlong (64 bit)
1705
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableColumn(%X, %016I64X, index=%d)", vmID,
1706
                     accessibleTable, index);
1707
#endif
1708

1709
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1710
        return FALSE;
1711
    }
1712
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableColumnPackage)];
1713
    PackageType *type = (PackageType *) buffer;
1714
    GetAccessibleTableColumnPackage *pkg =
1715
        (GetAccessibleTableColumnPackage *) (buffer + sizeof(PackageType));
1716
    *type = cGetAccessibleTableColumnPackage;
1717
    pkg->vmID = vmID;
1718
    pkg->accessibleTable = accessibleTable;
1719
    pkg->index = index;
1720

1721
    // need to call only the HWND/VM that contains this AC
1722
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1723
    if (destABWindow != (HWND) 0) {
1724
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1725
            PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleTableColumn succeeded");
1726
            return pkg->rColumn;
1727
        }
1728
    }
1729
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::getAccessibleTableColumn failed");
1730
    return 0;
1731
}
1732

1733
jint
1734
WinAccessBridge::getAccessibleTableIndex(long vmID, JOBJECT64 accessibleTable, jint row, jint column) {
1735

1736
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1737
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableIndex(%X, %p, row=%d, col=%d)", vmID,
1738
                     accessibleTable, row, column);
1739
#else // JOBJECT64 is jlong (64 bit)
1740
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleTableIndex(%X, %016I64X, row=%d, col=%d)", vmID,
1741
                     accessibleTable, row, column);
1742
#endif
1743

1744
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1745
        return FALSE;
1746
    }
1747
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleTableIndexPackage)];
1748
    PackageType *type = (PackageType *) buffer;
1749
    GetAccessibleTableIndexPackage *pkg =
1750
        (GetAccessibleTableIndexPackage *) (buffer + sizeof(PackageType));
1751
    *type = cGetAccessibleTableIndexPackage;
1752
    pkg->vmID = vmID;
1753
    pkg->accessibleTable = accessibleTable;
1754
    pkg->row = row;
1755
    pkg->column = column;
1756

1757
    // need to call only the HWND/VM that contains this AC
1758
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1759
    if (destABWindow != (HWND) 0) {
1760
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1761
            PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleTableIndex succeeded");
1762
            return pkg->rIndex;
1763
        }
1764
    }
1765
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::getAccessibleTableIndex failed");
1766
    return 0;
1767
}
1768

1769
/********** end AccessibleTable routines ******************************/
1770

1771
BOOL
1772
WinAccessBridge::getAccessibleRelationSet(long vmID, JOBJECT64 accessibleContext,
1773
                                          AccessibleRelationSetInfo *relationSetInfo) {
1774

1775
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1776
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleRelationSet(%X, %p, %X)", vmID,
1777
                     accessibleContext, relationSetInfo);
1778
#else // JOBJECT64 is jlong (64 bit)
1779
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleRelationSet(%X, %016I64X, %X)", vmID,
1780
                     accessibleContext, relationSetInfo);
1781
#endif
1782

1783
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1784
        return FALSE;
1785
    }
1786

1787
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleRelationSetPackage)];
1788
    PackageType *type = (PackageType *) buffer;
1789
    GetAccessibleRelationSetPackage *pkg = (GetAccessibleRelationSetPackage *) (buffer + sizeof(PackageType));
1790
    *type = cGetAccessibleRelationSetPackage;
1791
    pkg->vmID = vmID;
1792
    pkg->accessibleContext = accessibleContext;
1793

1794
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1795
    if (destABWindow != (HWND) 0) {
1796
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1797
            PrintDebugString("[INFO]:   ##### pkg->rAccessibleRelationSetInfo.relationCount = %X",
1798
                             pkg->rAccessibleRelationSetInfo.relationCount);
1799
            memcpy(relationSetInfo, &(pkg->rAccessibleRelationSetInfo), sizeof(AccessibleRelationSetInfo));
1800
            PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleRelationSet succeeded");
1801
            return TRUE;
1802
        }
1803
    }
1804
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::getAccessibleRelationSet failed");
1805
    return FALSE;
1806
}
1807

1808

1809
/********** AccessibleHypertext routines ***********/
1810

1811
BOOL
1812
WinAccessBridge::getAccessibleHypertext(long vmID, JOBJECT64 accessibleContext,
1813
                                        AccessibleHypertextInfo *hypertextInfo) {
1814

1815
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1816
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHypertext(%X, %p, %X)", vmID,
1817
                     accessibleContext, hypertextInfo);
1818
#else // JOBJECT64 is jlong (64 bit)
1819
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHypertext(%X, %016I64X, %X)", vmID,
1820
                     accessibleContext, hypertextInfo);
1821
#endif
1822

1823
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1824
        return FALSE;
1825
    }
1826

1827
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleHypertextPackage)];
1828
    PackageType *type = (PackageType *) buffer;
1829
    GetAccessibleHypertextPackage *pkg = (GetAccessibleHypertextPackage *) (buffer + sizeof(PackageType));
1830
    *type = cGetAccessibleHypertextPackage;
1831
    pkg->vmID = vmID;
1832
    pkg->accessibleContext = accessibleContext;
1833

1834
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1835
    if (destABWindow != (HWND) 0) {
1836
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1837
            memcpy(hypertextInfo, &(pkg->rAccessibleHypertextInfo), sizeof(AccessibleHypertextInfo));
1838

1839
            PrintDebugString("[INFO]:   ##### hypertextInfo.linkCount = %d", hypertextInfo->linkCount);
1840
            PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleHypertext succeeded");
1841

1842
            return TRUE;
1843
        }
1844
    }
1845
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::getAccessibleHypertext failed");
1846
    return FALSE;
1847
}
1848

1849

1850
BOOL
1851
WinAccessBridge::activateAccessibleHyperlink(long vmID, JOBJECT64 accessibleContext,
1852
                                             JOBJECT64 accessibleHyperlink) {
1853

1854
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1855
    PrintDebugString("[INFO]: WinAccessBridge::activateAccessibleHyperlink(%p %p)", accessibleContext,
1856
                     accessibleHyperlink);
1857
#else // JOBJECT64 is jlong (64 bit)
1858
    PrintDebugString("[INFO]: WinAccessBridge::activateAccessibleHyperlink(%016I64X %016I64X)", accessibleContext,
1859
                     accessibleHyperlink);
1860
#endif
1861

1862
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1863
        return FALSE;
1864
    }
1865

1866
    char buffer[sizeof(PackageType) + sizeof(ActivateAccessibleHyperlinkPackage)];
1867
    PackageType *type = (PackageType *) buffer;
1868
    ActivateAccessibleHyperlinkPackage *pkg = (ActivateAccessibleHyperlinkPackage *) (buffer + sizeof(PackageType));
1869
    *type = cActivateAccessibleHyperlinkPackage;
1870
    pkg->vmID = vmID;
1871
    pkg->accessibleContext = accessibleContext;
1872
    pkg->accessibleHyperlink = accessibleHyperlink;
1873

1874
    HWND destABWindow = javaVMs->findAccessBridgeWindow(pkg->vmID);
1875
    if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1876
        return pkg->rResult;
1877
    }
1878
    PrintDebugString("[ERROR]:  WinAccessBridge::activateAccessibleHyperlink returning FALSE (sendMemoryPackage failed)");
1879
    return FALSE;
1880
}
1881

1882
/*
1883
 * Returns the number of hyperlinks in a component
1884
 * Maps to AccessibleHypertext.getLinkCount.
1885
 * Returns -1 on error.
1886
 */
1887
jint
1888
WinAccessBridge::getAccessibleHyperlinkCount(const long vmID,
1889
                                             const AccessibleContext accessibleContext) {
1890

1891
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1892
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHyperlinkCount(%X, %p)",
1893
                     vmID, accessibleContext);
1894
#else // JOBJECT64 is jlong (64 bit)
1895
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHyperlinkCount(%X, %016I64X)",
1896
                     vmID, accessibleContext);
1897
#endif
1898

1899
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1900
        return FALSE;
1901
    }
1902

1903
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleHyperlinkCountPackage)];
1904
    PackageType *type = (PackageType *) buffer;
1905
    GetAccessibleHyperlinkCountPackage *pkg = (GetAccessibleHyperlinkCountPackage *) (buffer + sizeof(PackageType));
1906
    *type = cGetAccessibleHyperlinkCountPackage;
1907
    pkg->vmID = vmID;
1908
    pkg->accessibleContext = accessibleContext;
1909

1910
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1911
    if (destABWindow != (HWND) 0) {
1912
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1913
            PrintDebugString("[INFO]:   ##### hypetext link count = %d", pkg->rLinkCount);
1914
            PrintDebugString("[INFO]:  ##### WinAccessBridge::getAccessibleHyperlinkCount succeeded");
1915
            return pkg->rLinkCount;
1916
        }
1917
    }
1918
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::getAccessibleHyperlinkCount failed");
1919
    return -1;
1920
}
1921

1922
/*
1923
 * This method is used to iterate through the hyperlinks in a component.  It
1924
 * returns hypertext information for a component starting at hyperlink index
1925
 * nStartIndex.  No more than MAX_HYPERLINKS AccessibleHypertextInfo objects will
1926
 * be returned for each call to this method.
1927
 * returns FALSE on error.
1928
 */
1929
BOOL
1930
WinAccessBridge::getAccessibleHypertextExt(const long vmID,
1931
                                           const AccessibleContext accessibleContext,
1932
                                           const jint startIndex,
1933
                                           /* OUT */ AccessibleHypertextInfo *hypertextInfo) {
1934

1935
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1936
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHypertextExt(%X, %p %p)", vmID,
1937
                     accessibleContext, hypertextInfo);
1938
#else // JOBJECT64 is jlong (64 bit)
1939
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHypertextExt(%X, %016I64X %p)", vmID,
1940
                     accessibleContext, hypertextInfo);
1941
#endif
1942

1943
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1944
        return FALSE;
1945
    }
1946

1947
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleHypertextExtPackage)];
1948
    PackageType *type = (PackageType *) buffer;
1949
    GetAccessibleHypertextExtPackage *pkg = (GetAccessibleHypertextExtPackage *) (buffer + sizeof(PackageType));
1950
    *type = cGetAccessibleHypertextExtPackage;
1951
    pkg->vmID = vmID;
1952
    pkg->accessibleContext = accessibleContext;
1953
    pkg->startIndex = startIndex;
1954

1955
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
1956
    if (destABWindow != (HWND) 0) {
1957
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
1958
            PrintDebugString("[INFO]:   ##### pkg->rSuccess = %d", pkg->rSuccess);
1959

1960
            memcpy(hypertextInfo, &(pkg->rAccessibleHypertextInfo), sizeof(AccessibleHypertextInfo));
1961
            if (pkg->rSuccess == TRUE) {
1962
                PrintDebugString("[INFO]:   ##### hypertextInfo.linkCount = %d", hypertextInfo->linkCount);
1963
            } else {
1964
                PrintDebugString("[ERROR]:   ##### WinAccessBridge::getAccessibleHypertextExt failed");
1965
            }
1966
            return pkg->rSuccess;
1967
        }
1968
    }
1969
    PrintDebugString("[ERROR]:  ##### WinAccessBridge::getAccessibleHypertextExt failed");
1970
    return FALSE;
1971
}
1972

1973

1974
/*
1975
 * Returns the index into an array of hyperlinks that is associated with
1976
 * a character index in document;
1977
 * Maps to AccessibleHypertext.getLinkIndex.
1978
 * Returns -1 on error.
1979
 */
1980
jint
1981
WinAccessBridge::getAccessibleHypertextLinkIndex(const long vmID,
1982
                                                 const AccessibleHyperlink hypertext,
1983
                                                 const jint charIndex) {
1984

1985
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
1986
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHypertextLinkIndex(%X, %p)",
1987
                     vmID, hypertext);
1988
#else // JOBJECT64 is jlong (64 bit)
1989
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHypertextLinkIndex(%X, %016I64X)",
1990
                     vmID, hypertext);
1991
#endif
1992

1993
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
1994
        return FALSE;
1995
    }
1996

1997
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleHypertextLinkIndexPackage)];
1998
    PackageType *type = (PackageType *) buffer;
1999
    GetAccessibleHypertextLinkIndexPackage *pkg = (GetAccessibleHypertextLinkIndexPackage *) (buffer + sizeof(PackageType));
2000
    *type = cGetAccessibleHypertextLinkIndexPackage;
2001
    pkg->vmID = vmID;
2002
    pkg->hypertext = hypertext;
2003
    pkg->charIndex = charIndex;
2004

2005
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2006
    if (destABWindow != (HWND) 0) {
2007
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2008
            PrintDebugString("[INFO]:   ##### hypetext link index = %d", pkg->rLinkIndex);
2009
            PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleHypertextLinkIndex  succeeded");
2010
            return pkg->rLinkIndex;
2011
        }
2012
    }
2013
    PrintDebugString("[ERROR]  ##### WinAccessBridge::getAccessibleHypertextLinkIndex  failed");
2014
    return -1;
2015
}
2016

2017
/*
2018
 * Returns the nth hyperlink in a document.
2019
 * Maps to AccessibleHypertext.getLink.
2020
 * Returns -1 on error
2021
 */
2022
BOOL
2023
WinAccessBridge::getAccessibleHyperlink(const long vmID,
2024
                                        const AccessibleHyperlink hypertext,
2025
                                        const jint linkIndex,
2026
                                        /* OUT */ AccessibleHyperlinkInfo *hyperlinkInfo) {
2027

2028
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2029
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHyperlink(%X, %p, %p)", vmID,
2030
                     hypertext, hyperlinkInfo);
2031
#else // JOBJECT64 is jlong (64 bit)
2032
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleHyperlink(%X, %016I64X, %p)", vmID,
2033
                     hypertext, hyperlinkInfo);
2034
#endif
2035

2036
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2037
        return FALSE;
2038
    }
2039

2040
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleHyperlinkPackage)];
2041
    PackageType *type = (PackageType *) buffer;
2042
    GetAccessibleHyperlinkPackage *pkg = (GetAccessibleHyperlinkPackage *) (buffer + sizeof(PackageType));
2043
    *type = cGetAccessibleHyperlinkPackage;
2044
    pkg->vmID = vmID;
2045
    pkg->hypertext = hypertext;
2046
    pkg->linkIndex = linkIndex;
2047

2048
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2049
    if (destABWindow != (HWND) 0) {
2050
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2051
            memcpy(hyperlinkInfo, &(pkg->rAccessibleHyperlinkInfo),
2052
                   sizeof(AccessibleHyperlinkInfo));
2053
            PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleHypertext succeeded");
2054
            return TRUE;
2055
        }
2056
    }
2057
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::getAccessibleHypertext failed");
2058
    return FALSE;
2059
}
2060

2061

2062
/********** AccessibleKeyBinding routines ***********/
2063

2064
BOOL
2065
WinAccessBridge::getAccessibleKeyBindings(long vmID, JOBJECT64 accessibleContext,
2066
                                          AccessibleKeyBindings *keyBindings) {
2067

2068
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2069
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleKeyBindings(%X, %p, %p)", vmID,
2070
                     accessibleContext, keyBindings);
2071
#else // JOBJECT64 is jlong (64 bit)
2072
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleKeyBindings(%X, %016I64X, %p)", vmID,
2073
                     accessibleContext, keyBindings);
2074
#endif
2075

2076
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2077
        return FALSE;
2078
    }
2079

2080
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleKeyBindingsPackage)];
2081
    PackageType *type = (PackageType *) buffer;
2082
    GetAccessibleKeyBindingsPackage *pkg = (GetAccessibleKeyBindingsPackage *) (buffer + sizeof(PackageType));
2083
    *type = cGetAccessibleKeyBindingsPackage;
2084
    pkg->vmID = vmID;
2085
    pkg->accessibleContext = accessibleContext;
2086

2087
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2088
    if (destABWindow != (HWND) 0) {
2089
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2090
            memcpy(keyBindings, &(pkg->rAccessibleKeyBindings), sizeof(AccessibleKeyBindings));
2091

2092
            PrintDebugString("[INFO]:   ##### keyBindings.keyBindingsCount = %d", keyBindings->keyBindingsCount);
2093
            for (int i = 0; i < keyBindings->keyBindingsCount; ++i) {
2094
                PrintDebugString("[INFO]:   Key Binding # %d"\
2095
                "                           Modifiers: 0x%x"\
2096
                "                           Character (hex):  0x%x"\
2097
                "                           Character (wide char):  %lc"\
2098
                , i+1, keyBindings->keyBindingInfo[i].modifiers, keyBindings->keyBindingInfo[i].character, keyBindings->keyBindingInfo[i].character);
2099
            }
2100
            PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleKeyBindings succeeded");
2101

2102
            return TRUE;
2103
        }
2104
    }
2105
    PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleKeyBindings failed");
2106
    return FALSE;
2107
}
2108

2109
BOOL
2110
WinAccessBridge::getAccessibleIcons(long vmID, JOBJECT64 accessibleContext, AccessibleIcons *icons) {
2111

2112
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2113
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleIcons(%X, %p, %p)", vmID,
2114
                     accessibleContext, icons);
2115
#else // JOBJECT64 is jlong (64 bit)
2116
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleIcons(%X, %016I64X, %p)", vmID,
2117
                     accessibleContext, icons);
2118
#endif
2119

2120
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2121
        return FALSE;
2122
    }
2123

2124
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleIconsPackage)];
2125
    PackageType *type = (PackageType *) buffer;
2126
    GetAccessibleIconsPackage *pkg = (GetAccessibleIconsPackage *) (buffer + sizeof(PackageType));
2127
    *type = cGetAccessibleIconsPackage;
2128
    pkg->vmID = vmID;
2129
    pkg->accessibleContext = accessibleContext;
2130

2131
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2132
    if (destABWindow != (HWND) 0) {
2133
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2134
            memcpy(icons, &(pkg->rAccessibleIcons), sizeof(AccessibleIcons));
2135

2136
            PrintDebugString("[INFO]:   ##### icons.iconsCount = %d", icons->iconsCount);
2137
            PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleIcons succeeded");
2138

2139
            return TRUE;
2140
        }
2141
    }
2142
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::getAccessibleIcons failed");
2143
    return FALSE;
2144
}
2145

2146
BOOL
2147
WinAccessBridge::getAccessibleActions(long vmID, JOBJECT64 accessibleContext, AccessibleActions *actions) {
2148

2149
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2150
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleActions(%X, %p, %p)", vmID,
2151
                     accessibleContext, actions);
2152
#else // JOBJECT64 is jlong (64 bit)
2153
    PrintDebugString("[INFO]: ##### WinAccessBridge::getAccessibleActions(%X, %016I64X, %p)", vmID,
2154
                     accessibleContext, actions);
2155
#endif
2156

2157
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2158
        return FALSE;
2159
    }
2160

2161
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleActionsPackage)];
2162
    PackageType *type = (PackageType *) buffer;
2163
    GetAccessibleActionsPackage *pkg = (GetAccessibleActionsPackage *) (buffer + sizeof(PackageType));
2164
    *type = cGetAccessibleActionsPackage;
2165
    pkg->vmID = vmID;
2166
    pkg->accessibleContext = accessibleContext;
2167

2168
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2169
    if (destABWindow != (HWND) 0) {
2170
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2171
            memcpy(actions, &(pkg->rAccessibleActions), sizeof(AccessibleActions));
2172

2173
            PrintDebugString("[INFO]:   ##### actions.actionsCount = %d", actions->actionsCount);
2174
            PrintDebugString("[INFO]:   ##### WinAccessBridge::getAccessibleActions succeeded");
2175

2176
            return TRUE;
2177
        }
2178
    }
2179
    PrintDebugString("[ERROR]:   ##### WinAccessBridge::getAccessibleActions failed");
2180
    return FALSE;
2181
}
2182

2183
BOOL
2184
WinAccessBridge::doAccessibleActions(long vmID, JOBJECT64 accessibleContext,
2185
                                     AccessibleActionsToDo *actionsToDo, jint *failure) {
2186

2187
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2188
    PrintDebugString("[INFO]: WinAccessBridge::doAccessibleActions(%p #actions %d %ls)", accessibleContext,
2189
                     actionsToDo->actionsCount,
2190
                     actionsToDo->actions[0].name);
2191
#else // JOBJECT64 is jlong (64 bit)
2192
    PrintDebugString("[INFO]: WinAccessBridge::doAccessibleActions(%016I64X #actions %d %ls)", accessibleContext,
2193
                     actionsToDo->actionsCount,
2194
                     actionsToDo->actions[0].name);
2195
#endif
2196

2197
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2198
        return FALSE;
2199
    }
2200
    char buffer[sizeof(PackageType) + sizeof(DoAccessibleActionsPackage)];
2201
    PackageType *type = (PackageType *) buffer;
2202
    DoAccessibleActionsPackage *pkg = (DoAccessibleActionsPackage *) (buffer + sizeof(PackageType));
2203
    *type = cDoAccessibleActionsPackage;
2204
    pkg->vmID = vmID;
2205
    pkg->accessibleContext = accessibleContext;
2206
    memcpy((void *)(&(pkg->actionsToDo)), (void *)actionsToDo, sizeof(AccessibleActionsToDo));
2207
    pkg->failure = -1;
2208

2209
    HWND destABWindow = javaVMs->findAccessBridgeWindow(pkg->vmID);
2210
    if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2211
        *failure = pkg->failure;
2212
        return pkg->rResult;
2213
    }
2214
    PrintDebugString("[ERROR]:   WinAccessBridge::doAccessibleActions returning FALSE (sendMemoryPackage failed)");
2215
    return FALSE;
2216
}
2217

2218
/* ====== Utility methods ====== */
2219

2220
/**
2221
 * Sets a text field to the specified string. Returns whether successful.
2222
 */
2223
BOOL
2224
WinAccessBridge::setTextContents (const long vmID, const AccessibleContext accessibleContext,
2225
                                  const wchar_t *text) {
2226

2227
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2228
        return FALSE;
2229
    }
2230
    char buffer[sizeof(PackageType) + sizeof(SetTextContentsPackage)];
2231
    PackageType *type = (PackageType *) buffer;
2232
    SetTextContentsPackage *pkg = (SetTextContentsPackage *) (buffer + sizeof(PackageType));
2233
    *type = cSetTextContentsPackage;
2234
    pkg->vmID = vmID;
2235
    pkg->accessibleContext = accessibleContext;
2236
    wcsncpy(pkg->text, text, sizeof(pkg->text)/sizeof(wchar_t)); // wide character copy
2237

2238
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2239
    PrintDebugString("[INFO]: WinAccessBridge::setTextContents(%X, %016I64X %ls)", vmID, accessibleContext, text);
2240
#else // JOBJECT64 is jlong (64 bit)
2241
    PrintDebugString("[INFO]: WinAccessBridge::setTextContents(%X, %p %ls)", vmID, accessibleContext, text);
2242
#endif
2243
    // need to call only the HWND/VM that contains this AC
2244
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2245
    if (destABWindow != (HWND) 0) {
2246
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2247
            return pkg->rResult;
2248
        }
2249
    }
2250
    return FALSE;
2251
}
2252

2253
/**
2254
 * Returns the Accessible Context of a Page Tab object that is the
2255
 * ancestor of a given object.  If the object is a Page Tab object
2256
 * or a Page Tab ancestor object was found, returns the object
2257
 * AccessibleContext.
2258
 * If there is no ancestor object that has an Accessible Role of Page Tab,
2259
 * returns (AccessibleContext)0.
2260
 */
2261
AccessibleContext
2262
WinAccessBridge::getParentWithRole (const long vmID, const AccessibleContext accessibleContext, const wchar_t *role) {
2263

2264
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2265
        return (JOBJECT64)0;
2266
    }
2267
    char buffer[sizeof(PackageType) + sizeof(GetParentWithRolePackage)];
2268
    PackageType *type = (PackageType *) buffer;
2269
    GetParentWithRolePackage *pkg = (GetParentWithRolePackage *) (buffer + sizeof(PackageType));
2270
    *type = cGetParentWithRolePackage;
2271
    pkg->vmID = vmID;
2272
    pkg->accessibleContext = accessibleContext;
2273
    memcpy((void *)(&(pkg->role)), (void *)role, sizeof(pkg->role));
2274

2275
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2276
    PrintDebugString("[INFO]: WinAccessBridge::getParentWithRole(%X, %p)", vmID, accessibleContext);
2277
#else // JOBJECT64 is jlong (64 bit)
2278
    PrintDebugString("[INFO]: WinAccessBridge::getParentWithRole(%X, %016I64X)", vmID, accessibleContext);
2279
#endif
2280
    PrintDebugString("[INFO]:   pkg->vmID: %X"\
2281
                     "          pkg->accessibleContext: %p"\
2282
                     "          pkg->role: %ls"\
2283
                     , pkg->vmID, pkg->accessibleContext, pkg->role);
2284
    // need to call only the HWND/VM that contains this AC
2285
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2286
    if (destABWindow != (HWND) 0) {
2287
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2288
            PrintDebugString("[INFO]:   pkg->rAccessibleContext: %p", pkg->rAccessibleContext);
2289
            return pkg->rAccessibleContext;
2290
        }
2291
    }
2292
    return (JOBJECT64) 0;
2293
}
2294

2295

2296
/**
2297
 * Returns the Accessible Context for the top level object in
2298
 * a Java Window.  This is same Accessible Context that is obtained
2299
 * from GetAccessibleContextFromHWND for that window.  Returns
2300
 * (AccessibleContext)0 on error.
2301
 */
2302
AccessibleContext
2303
WinAccessBridge::getTopLevelObject (const long vmID, const AccessibleContext accessibleContext) {
2304

2305
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2306
        return (JOBJECT64)0;
2307
    }
2308
    char buffer[sizeof(PackageType) + sizeof(GetTopLevelObjectPackage)];
2309
    PackageType *type = (PackageType *) buffer;
2310
    GetTopLevelObjectPackage *pkg = (GetTopLevelObjectPackage *) (buffer + sizeof(PackageType));
2311
    *type = cGetTopLevelObjectPackage;
2312
    pkg->vmID = vmID;
2313
    pkg->accessibleContext = accessibleContext;
2314

2315
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2316
    PrintDebugString("[INFO]: WinAccessBridge::getTopLevelObject(%X, %p)", vmID, accessibleContext);
2317
#else // JOBJECT64 is jlong (64 bit)
2318
    PrintDebugString("[INFO]: WinAccessBridge::getTopLevelObject(%X, %016I64X)", vmID, accessibleContext);
2319
#endif
2320
    // need to call only the HWND/VM that contains this AC
2321
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2322
    if (destABWindow != (HWND) 0) {
2323
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2324
            return pkg->rAccessibleContext;
2325
        }
2326
    }
2327
    return (JOBJECT64) 0;
2328
}
2329

2330
/**
2331
 * If there is an Ancestor object that has an Accessible Role of
2332
 * Internal Frame, returns the Accessible Context of the Internal
2333
 * Frame object.  Otherwise, returns the top level object for that
2334
 * Java Window.  Returns (AccessibleContext)0 on error.
2335
 */
2336
AccessibleContext
2337
WinAccessBridge::getParentWithRoleElseRoot (const long vmID, const AccessibleContext accessibleContext, const wchar_t *role) {
2338

2339
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2340
        return (JOBJECT64)0;
2341
    }
2342
    char buffer[sizeof(PackageType) + sizeof(GetParentWithRoleElseRootPackage)];
2343
    PackageType *type = (PackageType *) buffer;
2344
    GetParentWithRoleElseRootPackage *pkg = (GetParentWithRoleElseRootPackage *) (buffer + sizeof(PackageType));
2345
    *type = cGetParentWithRoleElseRootPackage;
2346
    pkg->vmID = vmID;
2347
    pkg->accessibleContext = accessibleContext;
2348
    memcpy((void *)(&(pkg->role)), (void *)role, sizeof(pkg->role));
2349

2350
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2351
    PrintDebugString("[INFO]: WinAccessBridge::getParentWithRoleElseRoot(%X, %p)", vmID, accessibleContext);
2352
#else // JOBJECT64 is jlong (64 bit)
2353
    PrintDebugString("[INFO]: WinAccessBridge::getParentWithRoleElseRoot(%X, %016I64X)", vmID, accessibleContext);
2354
#endif
2355
    // need to call only the HWND/VM that contains this AC
2356
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2357
    if (destABWindow != (HWND) 0) {
2358
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2359
            return pkg->rAccessibleContext;
2360
        }
2361
    }
2362
    return (JOBJECT64) 0;
2363
}
2364

2365
/**
2366
 * Returns how deep in the object hierarchy a given object is.
2367
 * The top most object in the object hierarchy has an object depth of 0.
2368
 * Returns -1 on error.
2369
 */
2370
int
2371
WinAccessBridge::getObjectDepth (const long vmID, const AccessibleContext accessibleContext) {
2372

2373
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2374
        return -1;
2375
    }
2376
    char buffer[sizeof(PackageType) + sizeof(GetObjectDepthPackage)];
2377
    PackageType *type = (PackageType *) buffer;
2378
    GetObjectDepthPackage *pkg = (GetObjectDepthPackage *) (buffer + sizeof(PackageType));
2379
    *type = cGetObjectDepthPackage;
2380
    pkg->vmID = vmID;
2381
    pkg->accessibleContext = accessibleContext;
2382

2383
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2384
    PrintDebugString("[INFO]: WinAccessBridge::getObjectDepth(%X, %p)", vmID, accessibleContext);
2385
#else // JOBJECT64 is jlong (64 bit)
2386
    PrintDebugString("[INFO]: WinAccessBridge::getObjectDepth(%X, %016I64X)", vmID, accessibleContext);
2387
#endif
2388
    // need to call only the HWND/VM that contains this AC
2389
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2390
    if (destABWindow != (HWND) 0) {
2391
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2392
            return pkg->rResult;
2393
        }
2394
    }
2395
    return -1;
2396
}
2397

2398
/**
2399
 * Returns the Accessible Context of the currently ActiveDescendent of an object.
2400
 * Returns (AccessibleContext)0 on error.
2401
 */
2402
AccessibleContext
2403
WinAccessBridge::getActiveDescendent (const long vmID, const AccessibleContext accessibleContext) {
2404

2405
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2406
        return (JOBJECT64)0;
2407
    }
2408
    char buffer[sizeof(PackageType) + sizeof(GetActiveDescendentPackage)];
2409
    PackageType *type = (PackageType *) buffer;
2410
    GetActiveDescendentPackage *pkg = (GetActiveDescendentPackage *) (buffer + sizeof(PackageType));
2411
    *type = cGetActiveDescendentPackage;
2412
    pkg->vmID = vmID;
2413
    pkg->accessibleContext = accessibleContext;
2414

2415
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2416
    PrintDebugString("[INFO]: WinAccessBridge::getActiveDescendent(%X, %p)", vmID, accessibleContext);
2417
#else // JOBJECT64 is jlong (64 bit)
2418
    PrintDebugString("[INFO]: WinAccessBridge::getActiveDescendent(%X, %016I64X)", vmID, accessibleContext);
2419
#endif
2420
    // need to call only the HWND/VM that contains this AC
2421
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2422
    if (destABWindow != (HWND) 0) {
2423
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2424
            return pkg->rAccessibleContext;
2425
        }
2426
    }
2427
    return (JOBJECT64) 0;
2428
}
2429

2430
/**
2431
 * Additional methods for Teton
2432
 */
2433

2434
/**
2435
 * Gets the AccessibleName for a component based upon the JAWS algorithm. Returns
2436
 * whether successful.
2437
 *
2438
 * Bug ID 4916682 - Implement JAWS AccessibleName policy
2439
 */
2440
BOOL
2441
WinAccessBridge::getVirtualAccessibleName(long vmID, AccessibleContext accessibleContext,
2442
                                          wchar_t *name, int len) {
2443

2444
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2445
        return FALSE;
2446
    }
2447
    char buffer[sizeof(PackageType) + sizeof(GetVirtualAccessibleNamePackage)];
2448
    PackageType *type = (PackageType *) buffer;
2449
    GetVirtualAccessibleNamePackage *pkg = (GetVirtualAccessibleNamePackage *) (buffer + sizeof(PackageType));
2450
    *type = cGetVirtualAccessibleNamePackage;
2451
    pkg->vmID = vmID;
2452
    pkg->accessibleContext = accessibleContext;
2453
    size_t max = (len > sizeof(pkg->rName)) ? sizeof(pkg->rName) : len;
2454
    pkg->len = (int)max;
2455

2456
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2457
    PrintDebugString("[INFO]: WinAccessBridge::getVirtualAccessibleName(%X, %p)", vmID, accessibleContext);
2458
#else // JOBJECT64 is jlong (64 bit)
2459
    PrintDebugString("[INFO]: WinAccessBridge::getVirtualAccessibleName(%X, %016I64X)", vmID, accessibleContext);
2460
#endif
2461
    // need to call only the HWND/VM that contains this AC
2462
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2463
    if (destABWindow != (HWND) 0) {
2464
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2465
            wcsncpy(name, pkg->rName, max);
2466
            PrintDebugString("[INFO]:     WinAccessBridge::getVirtualAccessibleName: Virtual name = %ls", name);
2467
            return TRUE;
2468
        }
2469
    }
2470
    return FALSE;
2471
}
2472

2473
/**
2474
 * Request focus for a component. Returns whether successful;
2475
 *
2476
 * Bug ID 4944757 - requestFocus method needed
2477
 */
2478
BOOL
2479
WinAccessBridge::requestFocus(long vmID, AccessibleContext accessibleContext) {
2480

2481
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2482
        return FALSE;
2483
    }
2484
    char buffer[sizeof(PackageType) + sizeof(RequestFocusPackage)];
2485
    PackageType *type = (PackageType *) buffer;
2486
    RequestFocusPackage *pkg = (RequestFocusPackage *) (buffer + sizeof(PackageType));
2487
    *type = cRequestFocusPackage;
2488
    pkg->vmID = vmID;
2489
    pkg->accessibleContext = accessibleContext;
2490

2491
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2492
    PrintDebugString("[INFO]: WinAccessBridge::requestFocus(%X, %p)", vmID, accessibleContext);
2493
#else // JOBJECT64 is jlong (64 bit)
2494
    PrintDebugString("[INFO]: WinAccessBridge::requestFocus(%X, %016I64X)", vmID, accessibleContext);
2495
#endif
2496
    // need to call only the HWND/VM that contains this AC
2497
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2498
    if (destABWindow != (HWND) 0) {
2499
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2500
            return TRUE;
2501
        }
2502
    }
2503
    return FALSE;
2504
}
2505

2506
/**
2507
 * Selects text between two indices.  Selection includes the text at the start index
2508
 * and the text at the end index. Returns whether successful;
2509
 *
2510
 * Bug ID 4944758 - selectTextRange method needed
2511
 */
2512
BOOL
2513
WinAccessBridge::selectTextRange(long vmID, AccessibleContext accessibleContext, int startIndex, int endIndex) {
2514
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2515
        return FALSE;
2516
    }
2517
    char buffer[sizeof(PackageType) + sizeof(SelectTextRangePackage)];
2518
    PackageType *type = (PackageType *) buffer;
2519
    SelectTextRangePackage *pkg = (SelectTextRangePackage *) (buffer + sizeof(PackageType));
2520
    *type = cSelectTextRangePackage;
2521
    pkg->vmID = vmID;
2522
    pkg->accessibleContext = accessibleContext;
2523
    pkg->startIndex = startIndex;
2524
    pkg->endIndex = endIndex;
2525

2526
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2527
    PrintDebugString("[INFO]:     WinAccessBridge::selectTextRange(%X, %p %d %d)", vmID, accessibleContext,
2528
                     startIndex, endIndex);
2529
#else // JOBJECT64 is jlong (64 bit)
2530
    PrintDebugString("[INFO]:     WinAccessBridge::selectTextRange(%X, %016I64X %d %d)", vmID, accessibleContext,
2531
                     startIndex, endIndex);
2532
#endif
2533
    // need to call only the HWND/VM that contains this AC
2534
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2535
    if (destABWindow != (HWND) 0) {
2536
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2537
            return TRUE;
2538
        }
2539
    }
2540
    return FALSE;
2541
}
2542

2543
/**
2544
 * Get text attributes between two indices.  The attribute list includes the text at the
2545
 * start index and the text at the end index. Returns whether successful;
2546
 *
2547
 * Bug ID 4944761 - getTextAttributes between two indices method needed
2548
 */
2549
BOOL
2550
WinAccessBridge::getTextAttributesInRange(long vmID, AccessibleContext accessibleContext,
2551
                                          int startIndex, int endIndex,
2552
                                          AccessibleTextAttributesInfo *attributes, short *len) {
2553

2554
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2555
        return FALSE;
2556
    }
2557
    char buffer[sizeof(PackageType) + sizeof(GetTextAttributesInRangePackage)];
2558
    PackageType *type = (PackageType *) buffer;
2559
    GetTextAttributesInRangePackage *pkg = (GetTextAttributesInRangePackage *) (buffer + sizeof(PackageType));
2560
    *type = cGetTextAttributesInRangePackage;
2561
    pkg->vmID = vmID;
2562
    pkg->accessibleContext = accessibleContext;
2563
    pkg->startIndex = startIndex;
2564
    pkg->endIndex = endIndex;
2565
    memcpy(&(pkg->attributes), attributes, sizeof(AccessibleTextAttributesInfo));
2566

2567

2568
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2569
    PrintDebugString("[INFO]:     WinAccessBridge::getTextAttributesInRange(%X, %p %d %d)", vmID, accessibleContext,
2570
                     startIndex, endIndex);
2571
#else // JOBJECT64 is jlong (64 bit)
2572
    PrintDebugString("[INFO]:     WinAccessBridge::getTextAttributesInRange(%X, %016I64X %d %d)", vmID, accessibleContext,
2573
                     startIndex, endIndex);
2574
#endif
2575
    // need to call only the HWND/VM that contains this AC
2576
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2577
    if (destABWindow != (HWND) 0) {
2578
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2579
            *attributes = pkg->attributes;
2580
            *len = pkg->rLength;
2581
            return TRUE;
2582
        }
2583
    }
2584
    return FALSE;
2585
}
2586

2587
/**
2588
 * Gets the number of visible children of a component. Returns -1 on error.
2589
 *
2590
 * Bug ID 4944762- getVisibleChildren for list-like components needed
2591
 */
2592
int
2593
WinAccessBridge::getVisibleChildrenCount(long vmID, AccessibleContext accessibleContext) {
2594

2595
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2596
        return -1;
2597
    }
2598
    char buffer[sizeof(PackageType) + sizeof(GetVisibleChildrenCountPackage)];
2599
    PackageType *type = (PackageType *) buffer;
2600
    GetVisibleChildrenCountPackage *pkg = (GetVisibleChildrenCountPackage *) (buffer + sizeof(PackageType));
2601
    *type = cGetVisibleChildrenCountPackage;
2602
    pkg->vmID = vmID;
2603
    pkg->accessibleContext = accessibleContext;
2604

2605
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2606
    PrintDebugString("[INFO]: WinAccessBridge::getVisibleChildrenCount(%X, %p)", vmID, accessibleContext);
2607
#else // JOBJECT64 is jlong (64 bit)
2608
    PrintDebugString("[INFO]: WinAccessBridge::getVisibleChildrenCount(%X, %016I64X)", vmID, accessibleContext);
2609
#endif
2610
    // need to call only the HWND/VM that contains this AC
2611
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2612
    if (destABWindow != (HWND) 0) {
2613
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2614
            return pkg->rChildrenCount;
2615
        }
2616
    }
2617
    return -1;
2618
}
2619

2620
/**
2621
 * Gets the visible children of an AccessibleContext. Returns whether successful;
2622
 *
2623
 * Bug ID 4944762- getVisibleChildren for list-like components needed
2624
 */
2625
BOOL
2626
WinAccessBridge::getVisibleChildren(long vmID, AccessibleContext accessibleContext, int startIndex,
2627
                                    VisibleChildrenInfo *visibleChildrenInfo) {
2628

2629
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2630
        return FALSE;
2631
    }
2632
    char buffer[sizeof(PackageType) + sizeof(GetVisibleChildrenPackage)];
2633
    PackageType *type = (PackageType *) buffer;
2634
    GetVisibleChildrenPackage *pkg = (GetVisibleChildrenPackage *) (buffer + sizeof(PackageType));
2635
    *type = cGetVisibleChildrenPackage;
2636
    pkg->vmID = vmID;
2637
    pkg->accessibleContext = accessibleContext;
2638
    pkg->startIndex = startIndex;
2639

2640
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2641
    PrintDebugString("[INFO]: WinAccessBridge::getVisibleChildren(%X, %p)", vmID, accessibleContext);
2642
#else // JOBJECT64 is jlong (64 bit)
2643
    PrintDebugString("[INFO]: WinAccessBridge::getVisibleChildren(%X, %016I64X)", vmID, accessibleContext);
2644
#endif
2645
    // need to call only the HWND/VM that contains this AC
2646
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2647
    if (destABWindow != (HWND) 0) {
2648
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2649
            memcpy(visibleChildrenInfo, &(pkg->rVisibleChildrenInfo), sizeof(pkg->rVisibleChildrenInfo));
2650
            return pkg->rSuccess;
2651
        }
2652
    }
2653
    return FALSE;
2654
}
2655

2656
/**
2657
 * Set the caret to a text position. Returns whether successful;
2658
 *
2659
 * Bug ID 4944770 - setCaretPosition method needed
2660
 */
2661
BOOL
2662
WinAccessBridge::setCaretPosition(long vmID, AccessibleContext accessibleContext, int position) {
2663

2664
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2665
        return FALSE;
2666
    }
2667
    char buffer[sizeof(PackageType) + sizeof(SetCaretPositionPackage)];
2668
    PackageType *type = (PackageType *) buffer;
2669
    SetCaretPositionPackage *pkg = (SetCaretPositionPackage *) (buffer + sizeof(PackageType));
2670
    *type = cSetCaretPositionPackage;
2671
    pkg->vmID = vmID;
2672
    pkg->accessibleContext = accessibleContext;
2673
    pkg->position = position;
2674

2675
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2676
    PrintDebugString("[INFO]: WinAccessBridge::setCaretPosition(%X, %p %ls)", vmID, accessibleContext);
2677
#else // JOBJECT64 is jlong (64 bit)
2678
    PrintDebugString("[INFO]: WinAccessBridge::setCaretPosition(%X, %016I64X %ls)", vmID, accessibleContext);
2679
#endif
2680
    // need to call only the HWND/VM that contains this AC
2681
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2682
    if (destABWindow != (HWND) 0) {
2683
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2684
            return TRUE;
2685
        }
2686
    }
2687
    return FALSE;
2688
}
2689

2690

2691
/********** AccessibleText routines ***********************************/
2692

2693
/**
2694
 * getAccessibleTextInfo - fills a struct with a bunch of information
2695
 * contained in the Java Accessibility AccessibleText API
2696
 *
2697
 *
2698
 * Note: if the AccessibleContext parameter is bogus, this call will blow up
2699
 */
2700
BOOL
2701
WinAccessBridge::getAccessibleTextInfo(long vmID,
2702
                                       JOBJECT64 AccessibleContext,
2703
                                       AccessibleTextInfo *textInfo,
2704
                                       jint x, jint y) {
2705
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2706
        return FALSE;
2707
    }
2708
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleTextInfoPackage)];
2709
    PackageType *type = (PackageType *) buffer;
2710
    GetAccessibleTextInfoPackage *pkg = (GetAccessibleTextInfoPackage *) (buffer + sizeof(PackageType));
2711
    *type = cGetAccessibleTextInfoPackage;
2712
    pkg->vmID = vmID;
2713
    pkg->AccessibleContext = AccessibleContext;
2714
    pkg->x = x;
2715
    pkg->y = y;
2716

2717
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2718
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextInfo(%X, %p, %p, %d, %d)", vmID, AccessibleContext, textInfo, x, y);
2719
#else // JOBJECT64 is jlong (64 bit)
2720
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextInfo(%X, %016I64X, %p, %d, %d)", vmID, AccessibleContext, textInfo, x, y);
2721
#endif
2722
    // need to call only the HWND/VM that contains this AC
2723
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2724
    if (destABWindow != (HWND) 0) {
2725
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2726
            memcpy(textInfo, &(pkg->rTextInfo), sizeof(AccessibleTextInfo));
2727
            if (pkg->rTextInfo.charCount != -1) {
2728
                PrintDebugString("[INFO]:   charCount: %d"\
2729
                                 "          caretIndex: %d"\
2730
                                 "          indexAtPoint: %d"\
2731
                                 , textInfo->charCount, textInfo->caretIndex, textInfo->indexAtPoint);
2732
                return TRUE;
2733
            }
2734
        }
2735
    }
2736

2737
    return FALSE;
2738
}
2739

2740
/**
2741
 * getAccessibleTextItems - fills a struct with letter, word, and sentence info
2742
 * of the AccessibleText interface at a given index
2743
 *
2744
 * Note: if the AccessibleContext parameter is bogus, this call will blow up
2745
 */
2746
BOOL
2747
WinAccessBridge::getAccessibleTextItems(long vmID,
2748
                                        JOBJECT64 AccessibleContext,
2749
                                        AccessibleTextItemsInfo *textItems,
2750
                                        jint index) {
2751
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2752
        return FALSE;
2753
    }
2754
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleTextItemsPackage)];
2755
    PackageType *type = (PackageType *) buffer;
2756
    GetAccessibleTextItemsPackage *pkg = (GetAccessibleTextItemsPackage *) (buffer + sizeof(PackageType));
2757
    *type = cGetAccessibleTextItemsPackage;
2758
    pkg->vmID = vmID;
2759
    pkg->AccessibleContext = AccessibleContext;
2760
    pkg->index = index;
2761
    // zero things out, in case the call fails
2762
    pkg->rTextItemsInfo.letter = '\0';
2763
    pkg->rTextItemsInfo.word[0] = '\0';
2764
    pkg->rTextItemsInfo.sentence[0] = '\0';
2765

2766
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2767
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextItems(%X, %p, %p, %d)", vmID, AccessibleContext, textItems, index);
2768
#else // JOBJECT64 is jlong (64 bit)
2769
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextItems(%X, %016I64X, %p, %d)", vmID, AccessibleContext, textItems, index);
2770
#endif
2771
    // need to call only the HWND/VM that contains this AC
2772
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2773
    if (destABWindow != (HWND) 0) {
2774
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2775
            memcpy(textItems, &(pkg->rTextItemsInfo), sizeof(AccessibleTextItemsInfo));
2776
            if (pkg->rTextItemsInfo.letter != '/0') {
2777
                return TRUE;
2778
            }
2779
        }
2780
    }
2781

2782
    return FALSE;
2783
}
2784

2785
/**
2786
 * getAccessibleTextSelectionInfo - returns information about the selected
2787
 * text of the object implementing AccessibleText
2788
 *
2789
 * Note: if the AccessibleContext parameter is bogus, this call will blow up
2790
 */
2791
BOOL
2792
WinAccessBridge::getAccessibleTextSelectionInfo(long vmID,
2793
                                                JOBJECT64 AccessibleContext,
2794
                                                AccessibleTextSelectionInfo *selectionInfo) {
2795
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2796
        return FALSE;
2797
    }
2798
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleTextSelectionInfoPackage)];
2799
    PackageType *type = (PackageType *) buffer;
2800
    GetAccessibleTextSelectionInfoPackage *pkg = (GetAccessibleTextSelectionInfoPackage *) (buffer + sizeof(PackageType));
2801
    *type = cGetAccessibleTextSelectionInfoPackage;
2802
    pkg->vmID = vmID;
2803
    pkg->AccessibleContext = AccessibleContext;
2804

2805
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2806
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextSelectionInfo(%X, %p, %p)", vmID, AccessibleContext, selectionInfo);
2807
#else // JOBJECT64 is jlong (64 bit)
2808
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextSelectionInfo(%X, %016I64X, %p)", vmID, AccessibleContext, selectionInfo);
2809
#endif
2810
    // need to call only the HWND/VM that contains this AC
2811
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2812
    if (destABWindow != (HWND) 0) {
2813
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2814
            memcpy(selectionInfo, &(pkg->rTextSelectionItemsInfo), sizeof(AccessibleTextSelectionInfo));
2815
            // [[[FIXME]]] should test to see if valid info returned; return FALSE if not
2816
            return TRUE;
2817
        }
2818
    }
2819

2820
    return FALSE;
2821
}
2822

2823
/**
2824
 * getAccessibleTextAttributes - performs the Java code:
2825
 *   ...[[[FIXME]]] fill in this comment...
2826
 *
2827
 * Note: if the AccessibleContext parameter is bogus, this call will blow up
2828
 */
2829
BOOL
2830
WinAccessBridge::getAccessibleTextAttributes(long vmID,
2831
                                             JOBJECT64 AccessibleContext,
2832
                                             jint index,
2833
                                             AccessibleTextAttributesInfo *attributes) {
2834
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2835
        return FALSE;
2836
    }
2837
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleTextAttributeInfoPackage)];
2838
    PackageType *type = (PackageType *) buffer;
2839
    GetAccessibleTextAttributeInfoPackage *pkg = (GetAccessibleTextAttributeInfoPackage *) (buffer + sizeof(PackageType));
2840
    *type = cGetAccessibleTextAttributeInfoPackage;
2841
    pkg->vmID = vmID;
2842
    pkg->AccessibleContext = AccessibleContext;
2843
    pkg->index = index;
2844

2845
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2846
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextAttributes(%X, %p, %d, %p)", vmID, AccessibleContext, index, attributes);
2847
#else // JOBJECT64 is jlong (64 bit)
2848
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextAttributes(%X, %016I64X, %d, %p)", vmID, AccessibleContext, index, attributes);
2849
#endif
2850
    // need to call only the HWND/VM that contains this AC
2851
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2852
    if (destABWindow != (HWND) 0) {
2853
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2854
            memcpy(attributes, &(pkg->rAttributeInfo), sizeof(AccessibleTextAttributesInfo));
2855
            return TRUE;
2856
        }
2857
    }
2858

2859
    return FALSE;
2860
}
2861

2862
/**
2863
 * getAccessibleTextRect - gets the text bounding rectangle
2864
 *
2865
 * Note: if the AccessibleContext parameter is bogus, this call will blow up
2866
 */
2867
BOOL
2868
WinAccessBridge::getAccessibleTextRect(long vmID,
2869
                                       JOBJECT64 AccessibleContext,
2870
                                       AccessibleTextRectInfo *rectInfo,
2871
                                       jint index) {
2872
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2873
        return FALSE;
2874
    }
2875
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleTextRectInfoPackage)];
2876
    PackageType *type = (PackageType *) buffer;
2877
    GetAccessibleTextRectInfoPackage *pkg = (GetAccessibleTextRectInfoPackage *) (buffer + sizeof(PackageType));
2878
    *type = cGetAccessibleTextRectInfoPackage;
2879
    pkg->vmID = vmID;
2880
    pkg->AccessibleContext = AccessibleContext;
2881
    pkg->index = index;
2882

2883
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2884
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextRect(%X, %p, %p, %d)", vmID, AccessibleContext, rectInfo, index);
2885
#else // JOBJECT64 is jlong (64 bit)
2886
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextRect(%X, %016I64X, %p, %d)", vmID, AccessibleContext, rectInfo, index);
2887
#endif
2888
    // need to call only the HWND/VM that contains this AC
2889
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2890
    if (destABWindow != (HWND) 0) {
2891
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2892
            memcpy(rectInfo, (&pkg->rTextRectInfo), sizeof(AccessibleTextRectInfo));
2893
            // [[[FIXME]]] should test to see if valid info returned; return FALSE if not
2894
            return TRUE;
2895
        }
2896
    }
2897

2898
    return FALSE;
2899
}
2900

2901

2902
/**
2903
 * getAccessibleTextRect - gets the text bounding rectangle
2904
 *
2905
 * Note: if the AccessibleContext parameter is bogus, this call will blow up
2906
 */
2907
BOOL
2908
WinAccessBridge::getCaretLocation(long vmID,
2909
                                       JOBJECT64 AccessibleContext,
2910
                                       AccessibleTextRectInfo *rectInfo,
2911
                                       jint index) {
2912
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2913
        return FALSE;
2914
    }
2915
    char buffer[sizeof(PackageType) + sizeof(GetCaretLocationPackage)];
2916
    PackageType *type = (PackageType *) buffer;
2917
    GetCaretLocationPackage *pkg = (GetCaretLocationPackage *) (buffer + sizeof(PackageType));
2918
    *type = cGetCaretLocationPackage;
2919
    pkg->vmID = vmID;
2920
    pkg->AccessibleContext = AccessibleContext;
2921
    pkg->index = index;
2922

2923
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2924
    PrintDebugString("[INFO]: WinAccessBridge::getCaretLocation(%X, %p, %p, %d)", vmID, AccessibleContext, rectInfo, index);
2925
#else // JOBJECT64 is jlong (64 bit)
2926
    PrintDebugString("[INFO]: WinAccessBridge::getCaretLocation(%X, %016I64X, %p, %d)", vmID, AccessibleContext, rectInfo, index);
2927
#endif
2928
    // need to call only the HWND/VM that contains this AC
2929
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2930
    if (destABWindow != (HWND) 0) {
2931
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2932
            memcpy(rectInfo, (&pkg->rTextRectInfo), sizeof(AccessibleTextRectInfo));
2933
            return TRUE;
2934
        }
2935
    }
2936

2937
    return FALSE;
2938
}
2939

2940

2941
/**
2942
 * getEventsWaiting - gets the number of events waiting to fire
2943
 *
2944
 * Note: if the AccessibleContext parameter is bogus, this call will blow up
2945
 */
2946
int
2947
WinAccessBridge::getEventsWaiting() {
2948
    if(messageQueue) {
2949
        return(messageQueue->getEventsWaiting());
2950
    }
2951
    return(0);
2952
}
2953

2954

2955
/**
2956
 * getAccessibleTextLineBounds - gets the bounding rectangle for the text line
2957
 *
2958
 * Note: if the AccessibleContext parameter is bogus, this call will blow up
2959
 */
2960
BOOL
2961
WinAccessBridge::getAccessibleTextLineBounds(long vmID,
2962
                                             JOBJECT64 AccessibleContext,
2963
                                             jint index, jint *startIndex, jint *endIndex) {
2964
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
2965
        return FALSE;
2966
    }
2967
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleTextLineBoundsPackage)];
2968
    PackageType *type = (PackageType *) buffer;
2969
    GetAccessibleTextLineBoundsPackage *pkg = (GetAccessibleTextLineBoundsPackage *) (buffer + sizeof(PackageType));
2970
    *type = cGetAccessibleTextLineBoundsPackage;
2971
    pkg->vmID = vmID;
2972
    pkg->AccessibleContext = AccessibleContext;
2973
    pkg->index = index;
2974

2975
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
2976
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextLineBounds(%X, %p, %d, )", vmID, AccessibleContext, index);
2977
#else // JOBJECT64 is jlong (64 bit)
2978
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextLineBounds(%X, %016I64X, %d, )", vmID, AccessibleContext, index);
2979
#endif
2980
    // need to call only the HWND/VM that contains this AC
2981
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
2982
    if (destABWindow != (HWND) 0) {
2983
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
2984
            *startIndex = pkg->rLineStart;
2985
            *endIndex = pkg->rLineEnd;
2986
            // [[[FIXME]]] should test to see if valid info returned; return FALSE if not
2987
            return TRUE;
2988
        }
2989
    }
2990

2991
    return FALSE;
2992
}
2993

2994

2995
/**
2996
 * getAccessibleTextLineBounds - performs the Java code:
2997
 *   ...[[[FIXME]]] fill in this comment...
2998
 *
2999
 * Note: if the AccessibleContext parameter is bogus, this call will blow up
3000
 */
3001
BOOL
3002
WinAccessBridge::getAccessibleTextRange(long vmID,
3003
                                        JOBJECT64 AccessibleContext,
3004
                                        jint start, jint end, wchar_t *text, short len) {
3005
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
3006
        return FALSE;
3007
    }
3008
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleTextRangePackage)];
3009
    PackageType *type = (PackageType *) buffer;
3010
    GetAccessibleTextRangePackage *pkg = (GetAccessibleTextRangePackage *) (buffer + sizeof(PackageType));
3011
    *type = cGetAccessibleTextRangePackage;
3012
    pkg->vmID = vmID;
3013
    pkg->AccessibleContext = AccessibleContext;
3014
    pkg->start = start;
3015
    pkg->end = end;
3016

3017
#ifdef ACCESSBRIDGE_ARCH_LEGACY // JOBJECT64 is jobject (32 bit pointer)
3018
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextRange(%X, %p, %d, %d, )", vmID, AccessibleContext, start, end);
3019
#else // JOBJECT64 is jlong (64 bit)
3020
    PrintDebugString("[INFO]: WinAccessBridge::getAccessibleTextRange(%X, %016I64X, %d, %d, )", vmID, AccessibleContext, start, end);
3021
#endif
3022
    // need to call only the HWND/VM that contains this AC
3023
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
3024
    if (destABWindow != (HWND) 0) {
3025
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
3026
            wcsncpy(text, pkg->rText, len);
3027
            // [[[FIXME]]] should test to see if valid info returned; return FALSE if not
3028
            return TRUE;
3029
        }
3030
    }
3031

3032
    return FALSE;
3033
}
3034

3035

3036

3037

3038
/********** AccessibleValue routines ***************/
3039

3040
BOOL
3041
WinAccessBridge::getCurrentAccessibleValueFromContext(long vmID,
3042
                                                      JOBJECT64 AccessibleContext,
3043
                                                      wchar_t *value, short len) {
3044
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
3045
        return FALSE;
3046
    }
3047
    char buffer[sizeof(PackageType) + sizeof(GetCurrentAccessibleValueFromContextPackage)];
3048
    PackageType *type = (PackageType *) buffer;
3049
    GetCurrentAccessibleValueFromContextPackage *pkg = (GetCurrentAccessibleValueFromContextPackage *) (buffer + sizeof(PackageType));
3050
    *type = cGetCurrentAccessibleValueFromContextPackage;
3051
    pkg->vmID = vmID;
3052
    pkg->AccessibleContext = AccessibleContext;
3053

3054
    // need to call only the HWND/VM that contains this AC
3055
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
3056
    if (destABWindow != (HWND) 0) {
3057
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
3058
            wcsncpy(value, pkg->rValue, len);
3059
            // [[[FIXME]]] should test to see if valid info returned; return FALSE if not
3060
            return TRUE;
3061
        }
3062
    }
3063

3064
    return FALSE;
3065
}
3066

3067
BOOL
3068
WinAccessBridge::getMaximumAccessibleValueFromContext(long vmID,
3069
                                                      JOBJECT64 AccessibleContext,
3070
                                                      wchar_t *value, short len) {
3071
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
3072
        return FALSE;
3073
    }
3074
    char buffer[sizeof(PackageType) + sizeof(GetMaximumAccessibleValueFromContextPackage)];
3075
    PackageType *type = (PackageType *) buffer;
3076
    GetMaximumAccessibleValueFromContextPackage *pkg = (GetMaximumAccessibleValueFromContextPackage *) (buffer + sizeof(PackageType));
3077
    *type = cGetMaximumAccessibleValueFromContextPackage;
3078
    pkg->vmID = vmID;
3079
    pkg->AccessibleContext = AccessibleContext;
3080

3081
    // need to call only the HWND/VM that contains this AC
3082
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
3083
    if (destABWindow != (HWND) 0) {
3084
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
3085
            wcsncpy(value, pkg->rValue, len);
3086
            // [[[FIXME]]] should test to see if valid info returned; return FALSE if not
3087
            return TRUE;
3088
        }
3089
    }
3090

3091
    return FALSE;
3092
}
3093

3094
BOOL
3095
WinAccessBridge::getMinimumAccessibleValueFromContext(long vmID,
3096
                                                      JOBJECT64 AccessibleContext,
3097
                                                      wchar_t *value, short len) {
3098
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
3099
        return FALSE;
3100
    }
3101
    char buffer[sizeof(PackageType) + sizeof(GetMinimumAccessibleValueFromContextPackage)];
3102
    PackageType *type = (PackageType *) buffer;
3103
    GetMinimumAccessibleValueFromContextPackage *pkg = (GetMinimumAccessibleValueFromContextPackage *) (buffer + sizeof(PackageType));
3104
    *type = cGetMinimumAccessibleValueFromContextPackage;
3105
    pkg->vmID = vmID;
3106
    pkg->AccessibleContext = AccessibleContext;
3107

3108
    // need to call only the HWND/VM that contains this AC
3109
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
3110
    if (destABWindow != (HWND) 0) {
3111
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
3112
            wcsncpy(value, pkg->rValue, len);
3113
            // [[[FIXME]]] should test to see if valid info returned; return FALSE if not
3114
            return TRUE;
3115
        }
3116
    }
3117

3118
    return FALSE;
3119
}
3120

3121

3122
/********** AccessibleSelection routines ***************/
3123

3124
void
3125
WinAccessBridge::addAccessibleSelectionFromContext(long vmID,
3126
                                                   JOBJECT64 AccessibleContext, int i) {
3127
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
3128
        return;
3129
    }
3130
    char buffer[sizeof(PackageType) + sizeof(AddAccessibleSelectionFromContextPackage)];
3131
    PackageType *type = (PackageType *) buffer;
3132
    AddAccessibleSelectionFromContextPackage *pkg = (AddAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType));
3133
    *type = cAddAccessibleSelectionFromContextPackage;
3134
    pkg->vmID = vmID;
3135
    pkg->AccessibleContext = AccessibleContext;
3136
    pkg->index = i;
3137

3138
    // need to call only the HWND/VM that contains this AC
3139
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
3140
    if (destABWindow != (HWND) 0) {
3141
        sendMemoryPackage(buffer, sizeof(buffer), destABWindow);
3142
    }
3143
}
3144

3145
void
3146
WinAccessBridge::clearAccessibleSelectionFromContext(long vmID,
3147
                                                     JOBJECT64 AccessibleContext) {
3148
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
3149
        return;
3150
    }
3151
    char buffer[sizeof(PackageType) + sizeof(ClearAccessibleSelectionFromContextPackage)];
3152
    PackageType *type = (PackageType *) buffer;
3153
    ClearAccessibleSelectionFromContextPackage *pkg = (ClearAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType));
3154
    *type = cClearAccessibleSelectionFromContextPackage;
3155
    pkg->vmID = vmID;
3156
    pkg->AccessibleContext = AccessibleContext;
3157

3158
    // need to call only the HWND/VM that contains this AC
3159
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
3160
    if (destABWindow != (HWND) 0) {
3161
        sendMemoryPackage(buffer, sizeof(buffer), destABWindow);
3162
    }
3163
}
3164

3165
JOBJECT64
3166
WinAccessBridge::getAccessibleSelectionFromContext(long vmID,
3167
                                                   JOBJECT64 AccessibleContext, int i) {
3168
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
3169
        return (JOBJECT64)0;
3170
    }
3171
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleSelectionFromContextPackage)];
3172
    PackageType *type = (PackageType *) buffer;
3173
    GetAccessibleSelectionFromContextPackage *pkg = (GetAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType));
3174
    *type = cGetAccessibleSelectionFromContextPackage;
3175
    pkg->vmID = vmID;
3176
    pkg->AccessibleContext = AccessibleContext;
3177
    pkg->index = i;
3178

3179
    // need to call only the HWND/VM that contains this AC
3180
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
3181
    if (destABWindow != (HWND) 0) {
3182
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
3183
            return pkg->rAccessibleContext;
3184
        }
3185
    }
3186

3187
    return (JOBJECT64) 0;
3188
}
3189

3190
int
3191
WinAccessBridge::getAccessibleSelectionCountFromContext(long vmID,
3192
                                                        JOBJECT64 AccessibleContext) {
3193
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
3194
        return -1;
3195
    }
3196
    char buffer[sizeof(PackageType) + sizeof(GetAccessibleSelectionCountFromContextPackage)];
3197
    PackageType *type = (PackageType *) buffer;
3198
    GetAccessibleSelectionCountFromContextPackage *pkg = (GetAccessibleSelectionCountFromContextPackage *) (buffer + sizeof(PackageType));
3199
    *type = cGetAccessibleSelectionCountFromContextPackage;
3200
    pkg->vmID = vmID;
3201
    pkg->AccessibleContext = AccessibleContext;
3202

3203
    // need to call only the HWND/VM that contains this AC
3204
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
3205
    if (destABWindow != (HWND) 0) {
3206
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
3207
            return (int) pkg->rCount;
3208
        }
3209
    }
3210

3211
    return -1;
3212
}
3213

3214
BOOL
3215
WinAccessBridge::isAccessibleChildSelectedFromContext(long vmID,
3216
                                                      JOBJECT64 AccessibleContext, int i) {
3217
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
3218
        return FALSE;
3219
    }
3220
    char buffer[sizeof(PackageType) + sizeof(IsAccessibleChildSelectedFromContextPackage)];
3221
    PackageType *type = (PackageType *) buffer;
3222
    IsAccessibleChildSelectedFromContextPackage *pkg = (IsAccessibleChildSelectedFromContextPackage *) (buffer + sizeof(PackageType));
3223
    *type = cIsAccessibleChildSelectedFromContextPackage;
3224
    pkg->vmID = vmID;
3225
    pkg->AccessibleContext = AccessibleContext;
3226
    pkg->index = i;
3227

3228
    // need to call only the HWND/VM that contains this AC
3229
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
3230
    if (destABWindow != (HWND) 0) {
3231
        if (sendMemoryPackage(buffer, sizeof(buffer), destABWindow) == TRUE) {
3232
            if (pkg->rResult != 0) {
3233
                return TRUE;
3234
            }
3235
        }
3236
    }
3237

3238
    return FALSE;
3239
}
3240

3241

3242
void
3243
WinAccessBridge::removeAccessibleSelectionFromContext(long vmID,
3244
                                                      JOBJECT64 AccessibleContext, int i) {
3245
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
3246
        return;
3247
    }
3248
    char buffer[sizeof(PackageType) + sizeof(RemoveAccessibleSelectionFromContextPackage)];
3249
    PackageType *type = (PackageType *) buffer;
3250
    RemoveAccessibleSelectionFromContextPackage *pkg = (RemoveAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType));
3251
    *type = cRemoveAccessibleSelectionFromContextPackage;
3252
    pkg->vmID = vmID;
3253
    pkg->AccessibleContext = AccessibleContext;
3254
    pkg->index = i;
3255

3256
    // need to call only the HWND/VM that contains this AC
3257
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
3258
    if (destABWindow != (HWND) 0) {
3259
        sendMemoryPackage(buffer, sizeof(buffer), destABWindow);
3260
    }
3261
}
3262

3263
void
3264
WinAccessBridge::selectAllAccessibleSelectionFromContext(long vmID,
3265
                                                         JOBJECT64 AccessibleContext) {
3266
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
3267
        return;
3268
    }
3269
    char buffer[sizeof(PackageType) + sizeof(SelectAllAccessibleSelectionFromContextPackage)];
3270
    PackageType *type = (PackageType *) buffer;
3271
    SelectAllAccessibleSelectionFromContextPackage *pkg = (SelectAllAccessibleSelectionFromContextPackage *) (buffer + sizeof(PackageType));
3272
    *type = cSelectAllAccessibleSelectionFromContextPackage;
3273
    pkg->vmID = vmID;
3274
    pkg->AccessibleContext = AccessibleContext;
3275

3276
    // need to call only the HWND/VM that contains this AC
3277
    HWND destABWindow = javaVMs->findAccessBridgeWindow(vmID);
3278
    if (destABWindow != (HWND) 0) {
3279
        sendMemoryPackage(buffer, sizeof(buffer), destABWindow);
3280
    }
3281
}
3282

3283

3284
/*********** Event handling methods **********************************/
3285

3286
/**
3287
 * addEventNotification - tell all Java-launched AccessBridge DLLs
3288
 *                        that we want events of the specified type
3289
 *
3290
 * [[[FIXME]]] since we're just sending a long & a source window,
3291
 *                         we could use a private message rather than WM_COPYDATA
3292
 *                         (though we still may want it to be synchronous; dunno...)
3293
 *
3294
 */
3295
void
3296
WinAccessBridge::addJavaEventNotification(jlong type) {
3297
    PrintDebugString("[INFO]: WinAccessBridge::addJavaEventNotification(%016I64X)", type);
3298
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
3299
        return;
3300
    }
3301

3302
    char buffer[sizeof(PackageType) + sizeof(AddJavaEventNotificationPackage)];
3303
    PackageType *pkgType = (PackageType *) buffer;
3304
    AddJavaEventNotificationPackage *pkg = (AddJavaEventNotificationPackage *) (buffer + sizeof(PackageType));
3305
    *pkgType = cAddJavaEventNotificationPackage;
3306
    pkg->type = type;
3307
    pkg->DLLwindow = ABHandleToLong(dialogWindow);
3308

3309
    PrintDebugString("[INFO]:   ->pkgType = %X, eventType = %016I64X, DLLwindow = %p",
3310
                     *pkgType, pkg->type, pkg->DLLwindow);
3311

3312
    // send addEventNotification message to all JVMs
3313
    isVMInstanceChainInUse = true;
3314
    AccessBridgeJavaVMInstance *current = javaVMs;
3315
    while (current != (AccessBridgeJavaVMInstance *) 0) {
3316
        current->sendPackage(buffer, sizeof(buffer));           // no return values!
3317
        current = current->nextJVMInstance;
3318
    }
3319
    isVMInstanceChainInUse = false;
3320
}
3321

3322
/**
3323
 * removeEventNotification - tell all Java-launched AccessBridge DLLs
3324
 *                                                       that we no longer want events of the
3325
 *                                                       specified type
3326
 *
3327
 * [[[FIXME]]] since we're just sending a long & a source window,
3328
 *                         we could use a private message rather than WM_COPYDATA
3329
 *                         (though we still may want it to be synchronous; dunno...)
3330
 *
3331
 */
3332
void
3333
WinAccessBridge::removeJavaEventNotification(jlong type) {
3334
    PrintDebugString("[INFO]: in WinAccessBridge::removeJavaEventNotification(%016I64X)", type);
3335
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
3336
        return;
3337
    }
3338
    char buffer[sizeof(PackageType) + sizeof(RemoveJavaEventNotificationPackage)];
3339
    PackageType *pkgType = (PackageType *) buffer;
3340
    RemoveJavaEventNotificationPackage *pkg = (RemoveJavaEventNotificationPackage *) (buffer + sizeof(PackageType));
3341
    *pkgType = cRemoveJavaEventNotificationPackage;
3342
    pkg->type = type;
3343
    pkg->DLLwindow = ABHandleToLong(dialogWindow);
3344

3345
    PrintDebugString("[INFO]:   ->pkgType = %X, eventType = %016I64X, DLLwindow = %p",
3346
                     *pkgType, pkg->type, pkg->DLLwindow);
3347

3348
    // send removeEventNotification message to all JVMs
3349
    isVMInstanceChainInUse = true;
3350
    AccessBridgeJavaVMInstance *current = javaVMs;
3351
    while (current != (AccessBridgeJavaVMInstance *) 0) {
3352
        current->sendPackage(buffer, sizeof(buffer));           // no return values!
3353
        current = current->nextJVMInstance;
3354
    }
3355
    isVMInstanceChainInUse = false;
3356
}
3357

3358

3359
/*********** Event handling methods **********************************/
3360

3361
/**
3362
 * addAccessibilityEventNotification - tell all Java-launched AccessBridge DLLs
3363
 *                        that we want events of the specified type
3364
 *
3365
 * [[[FIXME]]] since we're just sending a long & a source window,
3366
 *                         we could use a private message rather than WM_COPYDATA
3367
 *                         (though we still may want it to be synchronous; dunno...)
3368
 *
3369
 */
3370
void
3371
WinAccessBridge::addAccessibilityEventNotification(jlong type) {
3372
    PrintDebugString("[INFO]: in WinAccessBridge::addAccessibilityEventNotification(%016I64X)", type);
3373
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
3374
        return;
3375
    }
3376
    char buffer[sizeof(PackageType) + sizeof(AddAccessibilityEventNotificationPackage)];
3377
    PackageType *pkgType = (PackageType *) buffer;
3378
    AddAccessibilityEventNotificationPackage *pkg = (AddAccessibilityEventNotificationPackage *) (buffer + sizeof(PackageType));
3379
    *pkgType = cAddAccessibilityEventNotificationPackage;
3380
    pkg->type = type;
3381
    pkg->DLLwindow = ABHandleToLong(dialogWindow);
3382

3383
    PrintDebugString("[INFO]:   ->pkgType = %X, eventType = %016I64X, DLLwindow = %X",
3384
                     *pkgType, pkg->type, pkg->DLLwindow);
3385

3386
    // send addEventNotification message to all JVMs
3387
    isVMInstanceChainInUse = true;
3388
    AccessBridgeJavaVMInstance *current = javaVMs;
3389
    while (current != (AccessBridgeJavaVMInstance *) 0) {
3390
        current->sendPackage(buffer, sizeof(buffer));           // no return values!
3391
        current = current->nextJVMInstance;
3392
    }
3393
    isVMInstanceChainInUse = false;
3394
}
3395

3396
/**
3397
 * removeAccessibilityEventNotification - tell all Java-launched AccessBridge DLLs
3398
 *                                                       that we no longer want events of the
3399
 *                                                       specified type
3400
 *
3401
 * [[[FIXME]]] since we're just sending a long & a source window,
3402
 *                         we could use a private message rather than WM_COPYDATA
3403
 *                         (though we still may want it to be synchronous; dunno...)
3404
 *
3405
 */
3406
void
3407
WinAccessBridge::removeAccessibilityEventNotification(jlong type) {
3408
    PrintDebugString("[INFO]: in WinAccessBridge::removeAccessibilityEventNotification(%016I64X)", type);
3409
    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {
3410
        return;
3411
    }
3412
    char buffer[sizeof(PackageType) + sizeof(RemoveAccessibilityEventNotificationPackage)];
3413
    PackageType *pkgType = (PackageType *) buffer;
3414
    RemoveAccessibilityEventNotificationPackage *pkg = (RemoveAccessibilityEventNotificationPackage *) (buffer + sizeof(PackageType));
3415
    *pkgType = cRemoveAccessibilityEventNotificationPackage;
3416
    pkg->type = type;
3417
    pkg->DLLwindow = ABHandleToLong(dialogWindow);
3418

3419
    PrintDebugString("[INFO]:   ->pkgType = %X, eventType = %016I64X, DLLwindow = %X",
3420
                     *pkgType, pkg->type, pkg->DLLwindow);
3421

3422
    // send removeEventNotification message to all JVMs
3423
    isVMInstanceChainInUse = true;
3424
    AccessBridgeJavaVMInstance *current = javaVMs;
3425
    while (current != (AccessBridgeJavaVMInstance *) 0) {
3426
        current->sendPackage(buffer, sizeof(buffer));           // no return values!
3427
        current = current->nextJVMInstance;
3428
    }
3429
    isVMInstanceChainInUse = false;
3430
}
3431

3432

3433
#define CALL_SET_EVENT_FP(function, callbackFP)         \
3434
        void WinAccessBridge::function(callbackFP fp) { \
3435
                eventHandler->function(fp, this);                       \
3436
                /* eventHandler calls back to winAccessBridgeDLL to set eventMask */    \
3437
        }
3438

3439
    void WinAccessBridge::setJavaShutdownFP(AccessBridge_JavaShutdownFP fp) {
3440
        eventHandler->setJavaShutdownFP(fp, this);
3441
    }
3442

3443
    CALL_SET_EVENT_FP(setPropertyChangeFP, AccessBridge_PropertyChangeFP)
3444
    CALL_SET_EVENT_FP(setFocusGainedFP, AccessBridge_FocusGainedFP)
3445
    CALL_SET_EVENT_FP(setFocusLostFP, AccessBridge_FocusLostFP)
3446
    CALL_SET_EVENT_FP(setCaretUpdateFP, AccessBridge_CaretUpdateFP)
3447
    CALL_SET_EVENT_FP(setMouseClickedFP, AccessBridge_MouseClickedFP)
3448
    CALL_SET_EVENT_FP(setMouseEnteredFP, AccessBridge_MouseEnteredFP)
3449
    CALL_SET_EVENT_FP(setMouseExitedFP, AccessBridge_MouseExitedFP)
3450
    CALL_SET_EVENT_FP(setMousePressedFP, AccessBridge_MousePressedFP)
3451
    CALL_SET_EVENT_FP(setMouseReleasedFP, AccessBridge_MouseReleasedFP)
3452
    CALL_SET_EVENT_FP(setMenuCanceledFP, AccessBridge_MenuCanceledFP)
3453
    CALL_SET_EVENT_FP(setMenuDeselectedFP, AccessBridge_MenuDeselectedFP)
3454
    CALL_SET_EVENT_FP(setMenuSelectedFP, AccessBridge_MenuSelectedFP)
3455
    CALL_SET_EVENT_FP(setPopupMenuCanceledFP, AccessBridge_PopupMenuCanceledFP)
3456
    CALL_SET_EVENT_FP(setPopupMenuWillBecomeInvisibleFP, AccessBridge_PopupMenuWillBecomeInvisibleFP)
3457
    CALL_SET_EVENT_FP(setPopupMenuWillBecomeVisibleFP, AccessBridge_PopupMenuWillBecomeVisibleFP)
3458

3459
    CALL_SET_EVENT_FP(setPropertyNameChangeFP, AccessBridge_PropertyNameChangeFP)
3460
    CALL_SET_EVENT_FP(setPropertyDescriptionChangeFP, AccessBridge_PropertyDescriptionChangeFP)
3461
    CALL_SET_EVENT_FP(setPropertyStateChangeFP, AccessBridge_PropertyStateChangeFP)
3462
    CALL_SET_EVENT_FP(setPropertyValueChangeFP, AccessBridge_PropertyValueChangeFP)
3463
    CALL_SET_EVENT_FP(setPropertySelectionChangeFP, AccessBridge_PropertySelectionChangeFP)
3464
    CALL_SET_EVENT_FP(setPropertyTextChangeFP, AccessBridge_PropertyTextChangeFP)
3465
    CALL_SET_EVENT_FP(setPropertyCaretChangeFP, AccessBridge_PropertyCaretChangeFP)
3466
    CALL_SET_EVENT_FP(setPropertyVisibleDataChangeFP, AccessBridge_PropertyVisibleDataChangeFP)
3467
    CALL_SET_EVENT_FP(setPropertyChildChangeFP, AccessBridge_PropertyChildChangeFP)
3468
    CALL_SET_EVENT_FP(setPropertyActiveDescendentChangeFP, AccessBridge_PropertyActiveDescendentChangeFP)
3469

3470
    CALL_SET_EVENT_FP(setPropertyTableModelChangeFP, AccessBridge_PropertyTableModelChangeFP)
3471

3472
Product

Resources

Company
