native/jaccesswalker/jaccesswalker.cpp

/*
 * Copyright (c) 2005, 2016, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

#include "jaccesswalker.h"
#include "AccessInfo.h"

HWND ourHwnd;
HWND topLevelWindow;
int depth = -1;
FILE *logfile;
HMENU popupMenu;

char theJaccesswalkerClassName[] = "JaccesswalkerWin";
char theAccessInfoClassName[] = "AccessInfoWin";

HWND theJaccesswalkerWindow;
HWND theTreeControlWindow;
HINSTANCE theInstance;
Jaccesswalker *theJaccesswalker;
AccessibleNode *theSelectedNode;
AccessibleNode *thePopupNode;
AccessibleContext theSelectedAccessibleContext;
HWND hwndTV;    // handle of tree-view control

int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{

    if (logfile == null) {
        logfile = fopen(JACCESSWALKER_LOG, "w"); // overwrite existing log file
        logString(logfile, "Starting jaccesswalker.exe %s\n", getTimeAndDate());
    }

    theInstance = hInstance;

    // start Jaccesswalker
    theJaccesswalker = new Jaccesswalker(nCmdShow);

    return 0;
}

Jaccesswalker::Jaccesswalker(int nCmdShow) {

    HWND hwnd;
    static char szAppName[] = "jaccesswalker";
    static char szMenuName[] = "JACCESSWALKERMENU";
    MSG msg;
    WNDCLASSEX wc;

    // jaccesswalker window
    wc.cbSize = sizeof(wc);
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = WinProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = theInstance;
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor(NULL, IDI_APPLICATION);
    wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
    wc.lpszMenuName = szMenuName;
    wc.lpszClassName = szAppName;
    wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

    RegisterClassEx(&wc);

    // AccessInfo Window
    wc.cbSize = sizeof(WNDCLASSEX);

    wc.hInstance = theInstance;
    wc.lpszClassName = theAccessInfoClassName;
    wc.lpfnWndProc = (WNDPROC)AccessInfoWindowProc;
    wc.style = 0;

    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);

    wc.lpszMenuName = "";
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;

    wc.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);

    RegisterClassEx(&wc);

    // create the jaccesswalker window
    hwnd = CreateWindow(szAppName,
                        szAppName,
                        WS_OVERLAPPEDWINDOW,
                        CW_USEDEFAULT,
                        CW_USEDEFAULT,
                        CW_USEDEFAULT,
                        CW_USEDEFAULT,
                        NULL,
                        NULL,
                        theInstance,
                        NULL);

    ourHwnd = hwnd;

    /* Initialize the common controls. */
    INITCOMMONCONTROLSEX cc;
    cc.dwSize = sizeof(INITCOMMONCONTROLSEX);
    cc.dwICC = ICC_TREEVIEW_CLASSES;
    InitCommonControlsEx(&cc);

    ShowWindow(hwnd, nCmdShow);

    UpdateWindow(hwnd);

    BOOL result = initializeAccessBridge();
    if (result != FALSE) {
        while (GetMessage(&msg, NULL, 0, 0)) {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        shutdownAccessBridge();
    }
}

/*
 * the jaccesswalker window proc
 */
LRESULT CALLBACK WinProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam) {

    int command;
    short width, height;

    switch(iMsg) {

    case WM_CREATE:
        // create the accessibility tree view
        theTreeControlWindow = CreateATreeView(hwnd);

        // load the popup menu
        popupMenu = LoadMenu(theInstance, "PopupMenu");
        popupMenu = GetSubMenu(popupMenu, 0);
        break;

    case WM_CLOSE:
        EndDialog(hwnd, TRUE);
        PostQuitMessage (0);
        break;

    case WM_SIZE:
        width = LOWORD(lParam);
        height = HIWORD(lParam);
        SetWindowPos(theTreeControlWindow, NULL, 0, 0, width, height, 0);
        return FALSE;  // let windows finish handling this

    case WM_COMMAND:
        command = LOWORD(wParam);
        switch(command) {

        case cExitMenuItem:
            EndDialog(hwnd, TRUE);
            PostQuitMessage (0);
            break;

        case cRefreshTreeItem:
            // update the accessibility tree
            theJaccesswalker->buildAccessibilityTree();
            break;

        case cAPIMenuItem:
            // open a new window with the Accessibility API in it for the
            // selected element in the tree
            if (theSelectedNode != (AccessibleNode *) 0) {
                theSelectedNode->displayAPIWindow();
            }
            break;

        case cAPIPopupItem:
            // open a new window with the Accessibility API in it for the
            // element in the tree adjacent to the popup menu
            if (thePopupNode != (AccessibleNode *) 0) {
                thePopupNode->displayAPIWindow();
            }
            break;

        }
        break;

    case WM_NOTIFY:  // receive tree messages

        NMTREEVIEW *nmptr = (LPNMTREEVIEW) lParam;
        switch (nmptr->hdr.code) {

        case TVN_SELCHANGED:
            // get the selected tree node
            theSelectedNode = (AccessibleNode *) nmptr->itemNew.lParam;
            break;

        case NM_RCLICK:

            // display a popup menu over the tree node
            POINT p;
            GetCursorPos(&p);
            TrackPopupMenu(popupMenu, 0, p.x, p.y, 0, hwnd, NULL);

            // get the tree node under the popup menu
            TVHITTESTINFO hitinfo;
            ScreenToClient(theTreeControlWindow, &p);
            hitinfo.pt = p;
            HTREEITEM node = TreeView_HitTest(theTreeControlWindow, &hitinfo);

            if (node != null) {
                TVITEMEX tvItem;
                tvItem.hItem = node;
                if (TreeView_GetItem(hwndTV, &tvItem) == TRUE) {
                    thePopupNode = (AccessibleNode *)tvItem.lParam;
                }
            }
            break;
        }
    }
    return DefWindowProc(hwnd, iMsg, wParam, lParam);
}

/*
 * Accessibility information window proc
 */
LRESULT CALLBACK AccessInfoWindowProc(HWND hWnd, UINT message,
                                    UINT wParam, LONG lParam) {
    short width, height;
    HWND dlgItem;

    switch (message) {
    case WM_CREATE:
        RECT rcClient;    // dimensions of client area
        HWND hwndEdit;    // handle of tree-view control

        // Get the dimensions of the parent window's client area,
        // and create the edit control.
        GetClientRect(hWnd, &rcClient);
        hwndEdit = CreateWindow("Edit",
                                "",
                                WS_VISIBLE | WS_TABSTOP | WS_CHILD |
                                ES_MULTILINE | ES_AUTOVSCROLL |
                                ES_READONLY | WS_VSCROLL,
                                0, 0, rcClient.right, rcClient.bottom,
                                hWnd,
                                (HMENU) cAccessInfoText,
                                theInstance,
                                NULL);
        break;

    case WM_CLOSE:
        DestroyWindow(hWnd);
        break;

    case WM_SIZE:
        width = LOWORD(lParam);
        height = HIWORD(lParam);
        dlgItem = GetDlgItem(hWnd, cAccessInfoText);
        SetWindowPos(dlgItem, NULL, 0, 0, width, height, 0);
        return FALSE;  // let windows finish handling this
        break;

    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }

    return 0;
}

/**
 * Build a tree (and the treeview control) of all accessible Java components
 *
 */
void Jaccesswalker::buildAccessibilityTree() {
    TreeView_DeleteAllItems (theTreeControlWindow);
    // have MS-Windows call EnumWndProc() with all of the top-level windows
    EnumWindows((WNDENUMPROC) EnumWndProc, NULL);
}

/**
 * Create (and display) the accessible component nodes of a parent AccessibleContext
 *
 */
BOOL CALLBACK EnumWndProc(HWND hwnd, LPARAM lParam) {
    if (IsJavaWindow(hwnd)) {
        long vmID;
        AccessibleContext ac;
        if (GetAccessibleContextFromHWND(hwnd, &vmID, &ac) == TRUE) {
            theJaccesswalker->addComponentNodes(vmID, ac, (AccessibleNode *) NULL,
                                         hwnd, TVI_ROOT, theTreeControlWindow);
        }
        topLevelWindow = hwnd;
    } else {
        char szClass [MAX_PATH] = {0};
        ::GetClassNameA(hwnd, szClass, sizeof(szClass) - 1);
        if ( ( 0 == ::strcmp(szClass, "IEFrame") )
             || ( 0 == ::strcmp(szClass, "MozillaUIWindowClass") ) ) {
            EnumChildWindows(hwnd, (WNDENUMPROC) EnumChildProc, NULL);
        }
    }
    return TRUE;
}

/*
Detects whether or not the specified Java window is one from which no useable
information can be obtained.

This function tests for various scenarios I have seen in Java applets where the
Java applet had no meaningful accessible information.  It does not detect all
scenarios, just the most common ones.
*/
BOOL IsInaccessibleJavaWindow(const HWND hwnd)
{
    BOOL ret_val ( FALSE );
    {
        BOOL bT ( FALSE );
        long vmIdWindow ( 0 );
        AccessibleContext acWindow ( 0 );
        bT = GetAccessibleContextFromHWND(hwnd, &vmIdWindow, &acWindow);
        if ( ( bT ) && ( 0 != vmIdWindow ) && ( 0 != acWindow ) ) {
            AccessibleContextInfo infoWindow = {0};
            bT = GetAccessibleContextInfo(vmIdWindow, acWindow, &infoWindow);
            if ( ( bT )
                 && ( 0 == infoWindow.name [0] )
                 && ( 0 == infoWindow.description [0] )
                 && ( 0 == ::wcscmp(infoWindow.role_en_US, L"frame") ) ) {
                if ( 0 == infoWindow.childrenCount ) {
                    ret_val = TRUE;
                } else if ( 1 == infoWindow.childrenCount ) {
                    AccessibleContext acChild ( 0 );
                    acChild =
                        GetAccessibleChildFromContext(vmIdWindow, acWindow, 0);
                    if ( NULL != acChild ) {
                        AccessibleContextInfo infoChild = {0};
                        bT = GetAccessibleContextInfo( vmIdWindow, acChild,
                                                       &infoChild );
                        if ( ( bT )
                             && ( 0 == infoChild.name [0] )
                             && ( 0 == infoChild.description [0] )
                             && ( 0 == ::wcscmp(infoChild.role_en_US, L"panel") )
                             && ( 1 == infoChild.childrenCount ) ) {
                            AccessibleContext acChild1 ( 0 );
                            acChild1 = GetAccessibleChildFromContext( vmIdWindow,
                                                                      acChild, 0);
                            if ( NULL != acChild1 ) {
                                AccessibleContextInfo infoChild1 = {0};
                                bT = GetAccessibleContextInfo( vmIdWindow,
                                                               acChild1, &infoChild1 );
                                if ( ( bT )
                                     && ( 0 == infoChild1.name [0] )
                                     && ( 0 == infoChild1.description [0] )
                                     && ( 0 == ::wcscmp(infoChild1.role_en_US, L"frame") )
                                     && ( 0 == infoChild1.childrenCount ) ) {
                                    ret_val = TRUE;
                                } else if ( ( bT )
                                            && ( 0 == infoChild1.name [0] )
                                            && ( 0 == infoChild1.description [0] )
                                            && ( 0 == ::wcscmp( infoChild1.role_en_US,
                                                                L"panel") )
                                            && ( 1 == infoChild1.childrenCount ) ) {
                                    AccessibleContext acChild2 ( 0 );
                                    acChild2 = GetAccessibleChildFromContext(
                                                    vmIdWindow, acChild1, 0 );
                                    if ( NULL != acChild2 ) {
                                        AccessibleContextInfo infoChild2 = {0};
                                        bT = GetAccessibleContextInfo(
                                                vmIdWindow, acChild2, &infoChild2 );
                                        if ( ( bT )
                                             && ( 0 == infoChild2.name [0] )
                                             && ( 0 == infoChild2.description [0] )
                                             && ( 0 == ::wcscmp( infoChild2.role_en_US,
                                                                 L"frame") )
                                             && ( 0 == infoChild2.childrenCount ) ) {
                                            ret_val = TRUE;
                                        }
                                    }
                                }
                            }
                        } else if ( ( bT )
                                    && ( 0 == infoChild.name [0] )
                                    && ( 0 == infoChild.description [0] )
                                    && ( 0 == ::wcscmp( infoChild.role_en_US,
                                                        L"canvas") )
                                    && ( 0 == infoChild.childrenCount ) ) {
                            ret_val = TRUE;
                        }
                    }
                }
            } else if ( ( bT )
                        && ( 0 == infoWindow.name [0] )
                        && ( 0 == infoWindow.description [0] )
                        && ( 0 == ::wcscmp(infoWindow.role_en_US, L"panel") ) ) {
                if ( 1 == infoWindow.childrenCount ) {
                    AccessibleContext acChild ( 0 );
                    acChild = GetAccessibleChildFromContext( vmIdWindow,
                                                             acWindow, 0 );
                    if ( NULL != acChild ) {
                        AccessibleContextInfo infoChild = {0};
                        bT = GetAccessibleContextInfo( vmIdWindow,
                                                       acChild, &infoChild );
                        if ( ( bT )
                             && ( 0 == infoChild.name [0] )
                             && ( 0 == infoChild.description [0] )
                             && ( 0 == ::wcscmp(infoChild.role_en_US, L"frame") )
                             && ( 0 == infoChild.childrenCount ) ) {
                                ret_val = TRUE;
                        } else if ( ( bT )
                                    && ( 0 == infoChild.name [0] )
                                    && ( 0 == infoChild.description [0] )
                                    && ( 0 == ::wcscmp( infoChild.role_en_US,
                                                        L"panel") )
                                    && ( 1 == infoChild.childrenCount ) ) {
                            AccessibleContext acChild1 ( 0 );
                            acChild1 = GetAccessibleChildFromContext( vmIdWindow,
                                                                      acChild, 0);
                            if ( NULL != acChild1 ) {
                                AccessibleContextInfo infoChild1 = {0};
                                bT = GetAccessibleContextInfo( vmIdWindow,
                                                               acChild1,
                                                               &infoChild1 );
                                if ( ( bT )
                                     && ( 0 == infoChild1.name [0] )
                                     && ( 0 == infoChild1.description [0] )
                                     && ( 0 == ::wcscmp( infoChild1.role_en_US,
                                                         L"frame") )
                                     && ( 0 == infoChild1.childrenCount ) ) {
                                    ret_val = TRUE;
                                }
                            }
                        }
                    }
                }
            }
        } else if ( FALSE == bT ) {
            ret_val = TRUE;
        }
    }
    return ret_val;
}

BOOL CALLBACK EnumChildProc(HWND hwnd, LPARAM lParam)
{
    if ( ( IsJavaWindow(hwnd) )
         && ( FALSE == IsInaccessibleJavaWindow(hwnd) ) ) {
        long vmID ( 0 );
        AccessibleContext ac ( 0 );
        if ( TRUE == GetAccessibleContextFromHWND(hwnd, &vmID, &ac) ) {
            theJaccesswalker->addComponentNodes(
                vmID, ac, (AccessibleNode *) NULL,
                hwnd, TVI_ROOT, theTreeControlWindow);
        }
        topLevelWindow = hwnd;
    } else {
        EnumChildWindows(hwnd, (WNDENUMPROC) EnumChildProc, NULL);
    }
    return TRUE;
}

// CreateATreeView - creates a tree-view control.
// Returns the handle of the new control if successful or NULL
//     otherwise.
// hwndParent - handle of the control's parent window
HWND CreateATreeView(HWND hwndParent) {
    RECT rcClient;  // dimensions of client area

    // Get the dimensions of the parent window's client area, and create
    // the tree-view control.
    GetClientRect(hwndParent, &rcClient);
    hwndTV = CreateWindow(WC_TREEVIEW,
                          "",
                          WS_VISIBLE | WS_TABSTOP | WS_CHILD |
                          TVS_HASLINES | TVS_HASBUTTONS |
                          TVS_LINESATROOT,
                          0, 0, rcClient.right, rcClient.bottom,
                          hwndParent,
                          (HMENU) cTreeControl,
                          theInstance,
                          NULL);

    return hwndTV;
}

/**
 * Create (and display) the accessible component nodes of a parent AccessibleContext
 *
 */
void Jaccesswalker::addComponentNodes(long vmID, AccessibleContext context,
                                    AccessibleNode *parent, HWND hwnd,
                                    HTREEITEM treeNodeParent, HWND treeWnd) {

    AccessibleNode *newNode = new AccessibleNode( vmID, context, parent, hwnd,
                                                  treeNodeParent );

    AccessibleContextInfo info;
    if (GetAccessibleContextInfo(vmID, context, &info) != FALSE) {
        char s[LINE_BUFSIZE];

        wsprintf(s, "%ls", info.name);
        newNode->setAccessibleName(s);
        wsprintf(s, "%ls", info.role);
        newNode->setAccessibleRole(s);

        wsprintf(s, "%ls [%ls]", info.name, info.role);

        TVITEM tvi;
        tvi.mask = TVIF_PARAM | TVIF_TEXT;
        tvi.pszText = (char *) s; // Accessible name and role
        tvi.cchTextMax = (int)strlen(s);
        tvi.lParam = (LPARAM) newNode; // Accessibility information

        TVINSERTSTRUCT tvis;
        tvis.hParent = treeNodeParent;
        tvis.hInsertAfter = TVI_LAST;
        tvis.item = tvi;

        HTREEITEM treeNodeItem = TreeView_InsertItem(treeWnd, &tvis);

        for (int i = 0; i < info.childrenCount; i++) {
            addComponentNodes(vmID, GetAccessibleChildFromContext(vmID, context, i),
                              newNode, hwnd, treeNodeItem, treeWnd);
        }
    } else {
        char s[LINE_BUFSIZE];
        sprintf( s,
            "ERROR calling GetAccessibleContextInfo; vmID = %X, context = %p",
            vmID, (void*)context );

        TVITEM tvi;
        tvi.mask = TVIF_PARAM | TVIF_TEXT;  // text and lParam are only valid parts
        tvi.pszText = (char *) s;
        tvi.cchTextMax = (int)strlen(s);
        tvi.lParam = (LPARAM) newNode;

        TVINSERTSTRUCT tvis;
        tvis.hParent = treeNodeParent;
        tvis.hInsertAfter = TVI_LAST;  // make tree in order given
        tvis.item = tvi;

        HTREEITEM treeNodeItem = TreeView_InsertItem(treeWnd, &tvis);
    }
}

// -----------------------------

/**
 * Create an AccessibleNode
 *
 */
AccessibleNode::AccessibleNode(long JavaVMID, AccessibleContext context,
                               AccessibleNode *parent, HWND hwnd,
                               HTREEITEM parentTreeNodeItem) {
    vmID = JavaVMID;
    ac = context;
    parentNode = parent;
    baseHWND = hwnd;
    treeNodeParent = parentTreeNodeItem;

    // setting accessibleName and accessibleRole not done here,
    // in order to minimize calls to the AccessBridge
    // (since such a call is needed to enumerate children)
}

/**
 * Destroy an AccessibleNode
 *
 */
AccessibleNode::~AccessibleNode() {
    ReleaseJavaObject(vmID, ac);
}

/**
 * Set the accessibleName string
 *
 */
void AccessibleNode::setAccessibleName(char *name) {
    strncpy(accessibleName, name, MAX_STRING_SIZE);
}

/**
 * Set the accessibleRole string
 *
 */
void AccessibleNode::setAccessibleRole(char *role) {
    strncpy(accessibleRole, role, SHORT_STRING_SIZE);
}


/**
 * Create an API window to show off the info for this AccessibleContext
 */
BOOL AccessibleNode::displayAPIWindow() {

    HWND apiWindow = CreateWindow(theAccessInfoClassName,
                                  "Java Accessibility API view",
                                  WS_OVERLAPPEDWINDOW,
                                  CW_USEDEFAULT,
                                  CW_USEDEFAULT,
                                  600,
                                  750,
                                  HWND_DESKTOP,
                                  NULL,
                                  theInstance,
                                  (void *) NULL);

    if (!apiWindow) {
        printError("cannot create API window");
        return FALSE;
    }

    char buffer[HUGE_BUFSIZE];
    buffer[0] = '\0';
    getAccessibleInfo(vmID, ac, buffer, sizeof(buffer));
    displayAndLog(apiWindow, cAccessInfoText, logfile, buffer);

    ShowWindow(apiWindow, SW_SHOWNORMAL);
    UpdateWindow(apiWindow);

    return TRUE;
}