path: root/qadevOOo/tests/java/ifc/accessibility/_XAccessibleComponent.java

/*************************************************************************
 *
 *  $RCSfile: _XAccessibleComponent.java,v $
 *
 *  $Revision: 1.1 $
 *
 *  last change:$Date: 2003-01-27 18:07:25 $
 *
 *  The Contents of this file are made available subject to the terms of
 *  either of the following licenses
 *
 *         - GNU Lesser General Public License Version 2.1
 *         - Sun Industry Standards Source License Version 1.1
 *
 *  Sun Microsystems Inc., October, 2000
 *
 *  GNU Lesser General Public License Version 2.1
 *  =============================================
 *  Copyright 2000 by Sun Microsystems, Inc.
 *  901 San Antonio Road, Palo Alto, CA 94303, USA
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License version 2.1, as published by the Free Software Foundation.
 *
 *  This library 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
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *  MA  02111-1307  USA
 *
 *
 *  Sun Industry Standards Source License Version 1.1
 *  =================================================
 *  The contents of this file are subject to the Sun Industry Standards
 *  Source License Version 1.1 (the "License"); You may not use this file
 *  except in compliance with the License. You may obtain a copy of the
 *  License at http://www.openoffice.org/license.html.
 *
 *  Software provided under this License is provided on an "AS IS" basis,
 *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
 *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
 *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
 *  See the License for the specific provisions governing your rights and
 *  obligations concerning the Software.
 *
 *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
 *
 *  Copyright: 2000 by Sun Microsystems, Inc.
 *
 *  All Rights Reserved.
 *
 *  Contributor(s): _______________________________________
 *
 *
 ************************************************************************/

package ifc.accessibility;

import com.sun.star.awt.Point;
import com.sun.star.awt.Rectangle;
import com.sun.star.awt.Size;
import com.sun.star.uno.UnoRuntime;
import drafts.com.sun.star.accessibility.XAccessible;
import drafts.com.sun.star.accessibility.XAccessibleComponent;
import drafts.com.sun.star.accessibility.XAccessibleContext;
import java.util.Vector;
import lib.MultiMethodTest;

/**
 * Testing <code>drafts.com.sun.star.accessibility.XAccessibleComponent</code>
 * interface methods :
 * <ul>
 *  <li><code> contains()</code></li>
 *  <li><code> getAccessibleAt()</code></li>
 *  <li><code> getBounds()</code></li>
 *  <li><code> getLocation()</code></li>
 *  <li><code> getLocationOnScreen()</code></li>
 *  <li><code> getSize()</code></li>
 *  <li><code> grabFocus()</code></li>
 *  <li><code> getAccessibleKeyBinding()</code></li>
 * </ul> <p>
 *
 * @see drafts.com.sun.star.accessibility.XAccessibleComponent
 */
public class _XAccessibleComponent extends MultiMethodTest {

    public XAccessibleComponent oObj = null;

    private Rectangle bounds = null ;

    private static final String className =
        "drafts.com.sun.star.accessibility.XAccessibleComponent" ;

    /**
     * Walkaround for current interface naming ('drafts' prefix)
     * @return The class name to load
     */
    protected String getTestedClassName() {
        System.out.println("########### YEAH");
        return className;
    }

    /**
     * First checks 4 inner bounds (upper, lower, left and right)
     * of component bounding box to contain
     * at least one point of the component. Second 4 outer bounds
     * are checked to not contain any component points.<p>
     *
     * Has <b> OK </b> status if inner bounds contain component points
     * and outer bounds don't contain any component points. <p>
     *
     * The following method tests are to be completed successfully before :
     * <ul>
     *  <li> <code> getBounds() </code> : to have size of a component.</li>
     * </ul>
     */
    public void _contains() {
        requiredMethod("getBounds()");

        boolean result = true ;

        int curX = 0;
        //while (!oObj.contains(new Point(curX, bounds.Y)) && curX < bounds.Width+bounds.X) {
        while (!oObj.contains(new Point(curX, 0)) && curX < bounds.Width) {
            curX++;
        };
        //if ((bounds.X <= curX) && (curX < bounds.Width+bounds.X)) {
        if (curX < bounds.Width) {
            log.println("Upper bound of box contains point ("
                + curX + ",0) - OK");
        } else {
            log.println
                ("Upper bound of box contains no component points - FAILED");
            result = false;
        }

        curX = 0;
        //while (!oObj.contains(new Point(curX, bounds.Y+bounds.Height - 1))
        while (!oObj.contains(new Point(curX, bounds.Height - 1))
               && curX < bounds.Width) {

               log.println("Contains returns false for ("+curX+","+bounds.Height+")");
            curX++;
        };
        //if ((bounds.X <= curX) && (curX < bounds.Width+bounds.X)) {
        if (curX < bounds.Width) {
            log.println("Lower bound of box contains point ("
                + curX + "," + (bounds.Height - 1) + ") - OK");
        } else {
            log.println
                ("Lower bound of box contains no component points - FAILED");
            result = false;
        }

        int curY = 0;
        //while (!oObj.contains(new Point(bounds.X, curY)) && curY < bounds.Height+bounds.Y) {
        while (!oObj.contains(new Point(0, curY)) && curY < bounds.Height) {
            curY++;
        };
        //if ((bounds.Y <= curY) && (curY < bounds.Height+bounds.Y)) {
        if (curY < bounds.Height) {
            log.println("Left bound of box contains point (0,"
                + curY + ") - OK");
        } else {
            log.println
                ("Left bound of box contains no component points - FAILED");
            result = false;
        }

        curY = 0;
        //while (!oObj.contains(new Point(bounds.X+bounds.Width - 1, curY))
        //       && curY < bounds.Height+bounds.Y) {
        while (!oObj.contains(new Point(bounds.Width - 1, curY)) && curY < bounds.Height) {
            curY++;
        };
        //if ((bounds.Y <= curY) && (curY < bounds.Height + bounds.Y)) {
        if (curY < bounds.Height) {
            log.println("Right bound of box contains point ("
                + (bounds.Width - 1) + "," + curY + ") - OK");
        } else {
            log.println
                ("Right bound of box contains no component points - FAILED");
            result = false;
        }

        boolean locRes = true;
        for (int x = -1; x <= bounds.Width; x++) {
            locRes &= !oObj.contains(new Point(x, -1));
            locRes &= !oObj.contains(new Point(x, bounds.Height+bounds.Y));
        }
        if (locRes) {
            log.println("Outer upper and lower bounds contain no component "
                + "points - OK");
        } else {
            log.println("Outer upper and lower bounds CONTAIN some component "
                + "points - FAILED");
            result = false;
        }

        locRes = true;
        for (int y = -1; y <= bounds.Height; y++) {
            locRes &= !oObj.contains(new Point(-1, y));
            locRes &= !oObj.contains(new Point(bounds.X+bounds.Width, y));
        }
        if (locRes) {
            log.println("Outer left and right bounds contain no component "
                + "points - OK");
        } else {
            log.println("Outer left and right bounds CONTAIN some component "
                + "points - FAILED");
            result = false;
        }

        tRes.tested("contains()", result) ;
    }

    /**
     * Iterates through all children which implement
     * <code>XAccessibleComponent</code> (if they exist) determines their
     * boundaries and tries to get each child by <code>getAccessibleAt</code>
     * passing point which belongs to the child.
     * Also the point is checked which doesn't belong to child boundary
     * box. <p>
     *
     * Has <b> OK </b> status if in the first cases the right children
     * are returned, and in the second <code>null</code> or
     * another child is returned.
     */
    public void _getAccessibleAt() {

        boolean result = true ;
        XAccessibleComponent[] children = getChildrenComponents();

        if (children.length > 0) {
            for (int i = 0; i < children.length; i++) {
                Rectangle chBnd = children[i].getBounds();
                if (chBnd.X == -1) continue;
                log.println("Checking child with bounds " +
                    "(" + chBnd.X + "," + chBnd.Y + "),("
                    + chBnd.Width + "," + chBnd.Height + "): "
                    +  util.AccessibilityTools.accessibleToString(children[i]));

                log.println("finding the point which lies on the component");
                int curX = 0;
                int curY = 0;
                while (!children[i].contains(new Point(curX, curY))
                       && curX < chBnd.Width) {
                    curX++;
                    curY++;
                };

                if (curX==chBnd.Width) {
                    log.println("Couldn't find a point with contains");
                    continue;
                }

                // trying the point laying on child
                XAccessible xAcc = oObj.getAccessibleAt
                    (new Point(chBnd.X , chBnd.Y));
                if (xAcc == null) {
                    log.println("The child not found at point ("
                        + (chBnd.X ) + "," + chBnd.Y + ") - FAILED");
                    result = false;
                } else {
                    XAccessible xAccCh = (XAccessible) UnoRuntime.queryInterface
                        (XAccessible.class, children[i]);
                    log.println("Child found at point ("
                        + (chBnd.X ) + "," + chBnd.Y + ") - OK");
                    boolean res = util.AccessibilityTools.equals(xAccCh, xAcc);
                    if (!res) {
                        int expIndex = xAccCh.getAccessibleContext().getAccessibleIndexInParent();
                        int gotIndex = xAcc.getAccessibleContext().getAccessibleIndexInParent();
                        if (expIndex < gotIndex) {
                            log.println("The children found is not the same");
                            log.println("The expected child " +
                                xAccCh.getAccessibleContext().getAccessibleName());
                            log.print("is hidden behind the found Child ");
                            log.println(xAcc.getAccessibleContext().getAccessibleName()+" - OK");
                        } else {
                            log.println("The children found is not the same - FAILED");
                            log.println("Expected: "
                                +xAccCh.getAccessibleContext().getAccessibleName());
                            log.println("Found: "
                                +xAcc.getAccessibleContext().getAccessibleName());
                            result = false ;
                        }
                    }
                }

                // trying the point NOT laying on child
                xAcc = oObj.getAccessibleAt
                    (new Point(chBnd.X - 1, chBnd.Y - 1));
                if (xAcc == null) {
                    log.println("No children found at point ("
                        + (chBnd.X - 1) + "," + (chBnd.Y - 1) + ") - OK");
                    result &= true;
                } else {
                    XAccessible xAccCh = (XAccessible) UnoRuntime.queryInterface
                        (XAccessible.class, children[i]);
                    boolean res = util.AccessibilityTools.equals(xAccCh, xAcc);
                    if (res) {
                        log.println("The same child found outside "
                            + "its bounds - FAILED");
                        result = false ;
                    }
                }
            }
        } else {
            log.println("There are no children supporting "
                + "XAccessibleComponent");
        }

        tRes.tested("getAccessibleAt()", result) ;
    }

    /**
     * Retrieves the component bounds and stores it. <p>
     *
     * Has <b> OK </b> status if boundary position (x,y) is not negative
     * and size (Width, Height) is greater than 0.
     */
    public void _getBounds() {
        boolean result = true ;

        bounds = oObj.getBounds() ;
        result &= bounds != null
            && bounds.X >=0 && bounds.Y >=0
            && bounds.Width >0 && bounds.Height >0;

        log.println("Bounds = " + (bounds != null
             ? "(" + bounds.X + "," + bounds.Y + "),("
             + bounds.Width + "," + bounds.Height + ")" : "null"));

        tRes.tested("getBounds()", result) ;
    }

    /**
     * Gets the location. <p>
     *
     * Has <b> OK </b> status if the location is the same as location
     * of boundary obtained by <code>getBounds()</code> method.
     *
     * The following method tests are to be completed successfully before :
     * <ul>
     *  <li> <code> getBounds() </code> : to have bounds </li>
     * </ul>
     */
    public void _getLocation() {
        requiredMethod("getBounds()");

        boolean result = true ;
        Point loc = oObj.getLocation() ;

        result &= loc.X == bounds.X && loc.Y == bounds.Y ;

        tRes.tested("getLocation()", result) ;
    }

    /**
     * Get the screen location of the component and its parent
     * (if it exists and supports <code>XAccessibleComponent</code>). <p>
     *
     * Has <b> OK </b> status if component screen location equals
     * to screen location of its parent plus location of the component
     * relative to the parent. <p>
     *
     * The following method tests are to be completed successfully before :
     * <ul>
     *  <li> <code> getBounds() </code> : to have location of the component
     *      relative to its parent</li>
     * </ul>
     */
    public void _getLocationOnScreen() {
        requiredMethod("getBounds()");

        XAccessibleComponent parent = getParentComponent();

        boolean result = true ;
        Point loc = oObj.getLocationOnScreen();
        log.println("Location is (" + loc.X + "," + loc.Y + ")");

        if (parent != null) {
            Point parLoc = parent.getLocationOnScreen();
            log.println("Parent location is ("
                + parLoc.X + "," + parLoc.Y + ")");

            result &= parLoc.X + bounds.X == loc.X;
            result &= parLoc.Y + bounds.Y == loc.Y;
        }

        tRes.tested("getLocationOnScreen()", result) ;
    }

    /**
     * Obtains the size of the component. <p>
     *
     * Has <b> OK </b> status if the size is the same as in bounds. <p>
     *
     * The following method tests are to be completed successfully before :
     * <ul>
     *  <li> <code> getBounds() </code>  </li>
     * </ul>
     */
    public void _getSize() {
        requiredMethod("getBounds()");

        boolean result = true ;
        Size size = oObj.getSize() ;

        result &= size.Width == bounds.Width;
        result &= size.Height == bounds.Height;

        tRes.tested("getSize()", result) ;
    }

    /**
     * Just calls the method. <p>
     *
     * Has <b> OK </b> status if no runtime exceptions occured.
     */
    public void _grabFocus() {

        boolean result = true ;
        oObj.grabFocus() ;

        tRes.tested("grabFocus()", result) ;
    }

    /**
     * Retrieves all children (not more than 50) of the current
     * component which support <code>XAccessibleComponent</code>.
     *
     * @return The array of children. Empty array returned if
     * such children were not found or some error occured.
     */
    private XAccessibleComponent[] getChildrenComponents() {
        XAccessible xAcc = (XAccessible) UnoRuntime.queryInterface
            (XAccessible.class, oObj) ;
        if (xAcc == null) {
            log.println("Component doesn't support XAccessible.");
            return new XAccessibleComponent[0];
        }
        XAccessibleContext xAccCon = xAcc.getAccessibleContext();
        int cnt = xAccCon.getAccessibleChildCount();

        // for cases when too many children exist checking only first 50
        if (cnt > 50) cnt = 50 ;

        Vector childComp = new Vector();
        for (int i = 0; i < cnt; i++) {
            try {
                XAccessible child = xAccCon.getAccessibleChild(i);
                XAccessibleContext xAccConCh = child.getAccessibleContext();
                XAccessibleComponent xChAccComp = (XAccessibleComponent)
                    UnoRuntime.queryInterface(XAccessibleComponent.class,
                    xAccConCh);
                if (xChAccComp != null) {
                    childComp.add(xChAccComp) ;
                }
            } catch (com.sun.star.lang.IndexOutOfBoundsException e) {}
        }

        return (XAccessibleComponent[]) childComp.toArray
            (new XAccessibleComponent[childComp.size()]);
    }

    /**
     * Gets the parent of the current component which support
     * <code>XAccessibleComponent</code>.
     *
     * @return The parent or <code>null</code> if the component
     * has no parent or some errors occured.
     */
    private XAccessibleComponent getParentComponent() {
        XAccessible xAcc = (XAccessible) UnoRuntime.queryInterface
            (XAccessible.class, oObj) ;
        if (xAcc == null) {
            log.println("Component doesn't support XAccessible.");
            return null;
        }

        XAccessibleContext xAccCon = xAcc.getAccessibleContext();
        XAccessible xAccPar = xAccCon.getAccessibleParent();

        if (xAccPar == null) {
            log.println("Component has no accessible parent.");
            return null;
        }
        XAccessibleContext xAccConPar = xAccPar.getAccessibleContext();
        XAccessibleComponent parent = (XAccessibleComponent)
            UnoRuntime.queryInterface(XAccessibleComponent.class, xAccConPar);
        if (parent == null) {
            log.println
                ("Accessible parent doesn't support XAccessibleComponent");
            return null;
        }

        return parent;
    }

    /**
     * Just calls the method.
     */
    public void _getForeground() {
        int forColor = oObj.getForeground();
        log.println("getForeground(): " + forColor);
        tRes.tested("getForeground()", true);
    }

    /**
     * Just calls the method.
     */
    public void _getBackground() {
        int backColor = oObj.getBackground();
        log.println("getBackground(): " + backColor);
        tRes.tested("getBackground()", true);
    }

}