ifc/awt/_XUserInputInterception.java

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/


package ifc.awt;

import com.sun.star.accessibility.AccessibleRole;
import com.sun.star.accessibility.XAccessible;
import com.sun.star.accessibility.XAccessibleComponent;
import com.sun.star.accessibility.XAccessibleContext;
import com.sun.star.awt.KeyEvent;
import com.sun.star.awt.MouseEvent;
import com.sun.star.awt.Point;
import com.sun.star.awt.Rectangle;
import com.sun.star.awt.XKeyHandler;
import com.sun.star.awt.XMouseClickHandler;
import com.sun.star.awt.XUserInputInterception;
import com.sun.star.awt.XWindow;
import com.sun.star.frame.XModel;
import com.sun.star.lang.EventObject;
import com.sun.star.lang.XMultiServiceFactory;
import com.sun.star.uno.UnoRuntime;
import java.awt.Robot;
import java.awt.event.InputEvent;
import lib.MultiMethodTest;
import util.AccessibilityTools;

/**
* Testing <code>com.sun.star.awt.XUserInputInterception</code>
* interface methods:
* <ul>
*  <li><code> addKeyHandler() </code></li>
*  <li><code> removeKeyHandler() </code></li>
*  <li><code> addMouseClickHandler() </code></li>
*  <li><code> removeMouseClickHandler() </code></li>
* </ul><p>
* This test needs the following object relations :
* <ul>
*  <li> <code>'XUserInputInterception.XModel'</code> (of type <code>XModel</code>):
*   used as model where a mouse click or a key press could be done </li>
* </ul> <p>
* Test is <b> NOT </b> multithread compilant. <p>
* @see com.sun.star.awt.XUserInputInterception
*/
public class _XUserInputInterception extends MultiMethodTest {
    public XUserInputInterception oObj = null;

    private XModel m_XModel = null;

    /** the listener 1 for the mouse click test */
    private MyMouseClickHandler1 m_MouseListener1 = null;
    /** the listener 2 for the mouse click test */
    private MyMouseClickHandler2 m_MouseListener2 = null;

    /** the listener 1 for the key event test */
    private MyKeyHandler1 m_KeyListener1 = null;
    /** the listener 2 for the key event test */
    private MyKeyHandler2 m_KeyListener2 = null;

    /** indicates if the mousePressed event was called*/
    private boolean m_mousePressed1 = false;
    /** indicates if the mouseReleased event was called*/
    private boolean m_mouseReleased1 = false;

    /** indicates if the mousePressed event was called*/
    private boolean m_mousePressed2 = false;
    /** indicates if the mouseReleased event was called*/
    private boolean m_mouseReleased2 = false;

    /** indicates if the mousePressed event was called*/
    private boolean m_keyPressed1 = false;
    /** indicates if the mouseReleased event was called*/
    private boolean m_keyReleased1 = false;

    /** indicates if the mousePressed event was called*/
    private boolean m_keyPressed2 = false;
    /** indicates if the mouseReleased event was called*/
    private boolean m_keyReleased2 = false;

    /** get the object rlation XUserInputInterception.XModel from the
     * test environment
     */
    protected void before() {
        log.print("try to get object relation 'XUserInputInterception.XModel': ");
        m_XModel = (XModel)tEnv.getObjRelation("XUserInputInterception.XModel");
        if (m_XModel == null) log.println("failed => null");
        else log.println("OK");

    }

    /**
    * This test adds two different key listener to the object. <p>
    *
    * Has <b> OK </b> if no exception is thrown.
    */
    public void _addKeyHandler() {

        log.println("creating key listener 1");
        m_KeyListener1 = new MyKeyHandler1();

        log.println("creating key listener 2");
        m_KeyListener2 = new MyKeyHandler2();


        log.println("adding key listener 1");
        oObj.addKeyHandler(m_KeyListener1);


        log.println("adding key listener 2");
        oObj.addKeyHandler(m_KeyListener2);

        tRes.tested("addKeyHandler()", true);
    }

    /**
     * The test requires <CODE>addKeyHandler()</CODE> which adds two key listener.
     * Then one of them will be removed. In a second thread a key event is released
     * by the <CODE>robot</CODE> class.<p>
     * Has <b> OK </b> status if only one of the listener are triggered. <p>
     * The following method tests are to be completed successfully before :
     * <ul>
     *  <li> <code> addKeyHandler() </code> : adds two key listener </li>
     * </ul>
     */
    public void _removeKeyHandler() {
        requiredMethod("addKeyHandler()");

        log.println("remove key listener 2");

        oObj.removeKeyHandler(m_KeyListener2);

        log.println("starting thread to check the key listener...");
        EventTrigger et = new EventTrigger(m_XModel, EventTriggerType.KEY_TEXT_INTO_DOC);

        et.run();

        util.utils.shortWait(tParam.getInt(util.PropertyName.SHORT_WAIT) * 2);
        log.println("key listener thread should be finished.");


        boolean bOK = m_keyPressed1 & m_keyReleased1 &
                      ! m_keyPressed2 & ! m_keyReleased2;

        if (! bOK){
            log.println("The key listener has not the expectd status:");
            log.println("listener\texpected\tgot");
            log.println("keyPressed1\ttrue\t"+m_keyPressed1);
            log.println("keyReleased1\ttrue\t"+m_keyReleased1);
            log.println("keyPressed2\tfalse\t"+m_keyPressed2);
            log.println("keyReleased2\tfalse\t"+m_keyReleased2);
        }

        log.println("remove Key listener 1");
        oObj.removeKeyHandler(m_KeyListener1);

        tRes.tested("removeKeyHandler()", bOK);
    }

    /**
     * This test adds two different mouse klick listener to the object. <p>
     *
     * Has <b> OK </b> if no exception is thrown.
     */
    public void _addMouseClickHandler() {
        log.println("creating mouse listener 1");
        m_MouseListener1 = new MyMouseClickHandler1();
        log.println("creating mouse listener 2");
        m_MouseListener2 = new MyMouseClickHandler2();

        log.println("adding mouse listener 1");
        oObj.addMouseClickHandler(m_MouseListener1);
        log.println("adding mouse listener 2");
        oObj.addMouseClickHandler(m_MouseListener2);

        tRes.tested("addMouseClickHandler()", true);
    }

    /**
     *  The test requires <CODE>addMouseClickHandler()</CODE> which adds two key listener.
     * Then one of them will be removed. In a second thread a mouse klick event is released
     * by the <CODE>robot</CODE> class.<p>
     * Has <b> OK </b> status if only one of the listener are triggered. <p>
     * The following method tests are to be completed successfully before :
     * <ul>
     *  <li> <code> addMouseKlickHandler() </code> : adds two key listener </li>
     * </ul>
     */
    public void _removeMouseClickHandler() {
        requiredMethod("addMouseClickHandler");

        log.println("remove mouse listener 2");

        oObj.removeMouseClickHandler(m_MouseListener2);

        log.println("starting thread to check the mouse listener...");
        EventTrigger et = new EventTrigger(m_XModel, EventTriggerType.MOUSE_KLICK_INTO_DOC);

        et.run();

        util.utils.shortWait(tParam.getInt(util.PropertyName.SHORT_WAIT) * 2);
        log.println("mouse listener thread should be finished.");

        boolean bOK = m_mousePressed1 & m_mouseReleased1 &
                      ! m_mousePressed2 & ! m_mouseReleased2;

        if (! bOK){
            log.println("The mouse listener has not the expectd status:");
            log.println("listener\t\texpected\tgot");
            log.println("mousePressed1\ttrue\t\t"+m_mousePressed1);
            log.println("mouseReleased1\ttrue\t\t"+m_mouseReleased1);
            log.println("mousePressed2\tfalse\t\t"+m_mousePressed2);
            log.println("mouseReleased2\tfalse\t\t"+m_mouseReleased2);
        }

        log.println("remove mouse listener 1");
        oObj.removeMouseClickHandler(m_MouseListener1);

        tRes.tested("removeMouseClickHandler()", bOK);
    }


    /**
    * Forces environment recreation.
    */
    protected void after() {
        disposeEnvironment();
    }

    /**
     * Listener which added and its method must be called
     * on <code>keyPressed</code> and <code>keyReleased</code> call.
     */
    public class MyKeyHandler1 implements XKeyHandler {
        /**
         * This event sets the member <code>m_keyPressed</coed> to
         *  <code>true</code>
         * @param oEvent The key event informs about the pressed key.
         * @return returns <CODE>TRUE</CODE> in erery case
         */
        public boolean keyPressed( KeyEvent oEvent ){
            log.println("XKeyHandler 1: keyPressed-Event");
            m_keyPressed1 = true;
            return true;
        }
        /**
         * This event sets the member <code>m_keyReleased</coed> to
         *  <code>true</code>
         * @param oEvent The key event informs about the pressed key.
         * @return returns <CODE>TRUE</CODE> in erery case
         */
        public boolean keyReleased( KeyEvent oEvent ){
            log.println("XKeyHandler 1: keyReleased-Event");
            m_keyReleased1 = true;
            return true;
        }
        /**
         * This event does nothing usefull
         * @param oEvent refers to the object that fired the event.
         */
        public void disposing( EventObject oEvent ){
            log.println("XKeyHandler 1: disposing-Event");
        }
    }
    /**
     * Listener which added and its method must be called
     * on <code>keyPressed</code> and <code>keyReleased</code> call.
     */
    public class MyKeyHandler2 implements XKeyHandler {
        /**
         * This event sets the member <code>m_keyPressed</coed> to
         *  <code>true</code>
         * @param oEvent The key event informs about the pressed key.
         * @return returns <CODE>TRUE</CODE> in erery case
         */
        public boolean keyPressed( KeyEvent oEvent ){
            log.println("XKeyHandler 2: keyPressed-Event: " +
                        "This should not be happen because listener is removed!");
            m_keyPressed2 = true;
            return true;
        }
        /**
         * This event sets the member <code>m_keyReleased</coed> to
         *  <code>true</code>
         * @param oEvent The key event informs about the pressed key.
         * @return returns <CODE>TRUE</CODE> in erery case
         */
        public boolean keyReleased( KeyEvent oEvent ){
            log.println("XKeyHandler 2: keyReleased-Event: " +
                    "This should not be happen because listener is removed!");
            m_keyReleased2 = true;
            return true;
        }
        /**
         * This event does nothing usefull
         * @param oEvent refers to the object that fired the event.
         */
        public void disposing( EventObject oEvent ){
            log.println("XKeyHandler 2: disposing-Event: " +
                        "This should not be happen because listener is removed!");
        }
    }

    /**
     * Listener which added and its method must be called
     * on <code>mousePressed</code> and <code>mouseReleased</code> call.
     */
    public class MyMouseClickHandler1 implements XMouseClickHandler {
        /**
         * This event sets the member <code>m_mousePressed</coed> to
         *  <code>true</code>
         * @param oEvent The mouse event informs about the kind of mouse event.
         * @return returns <CODE>TRUE</CODE> in erery case
         */
        public boolean mousePressed( MouseEvent oEvent ){
            log.println("XMouseClickHandler 1: mousePressed-Event");
            m_mousePressed1 = true;
            return true;
        }
        /**
         * This event sets the member <code>m_mouseReleased</coed> to
         *  <code>true</code>
         * @param oEvent The mouse event informs about the kind of mouse event.
         * @return returns <CODE>TRUE</CODE> in erery case
         */
        public boolean mouseReleased( MouseEvent oEvent ){
            log.println("XMouseClickHandler 1: mouseReleased-Event");
            m_mouseReleased1 = true;
            return true;
        }
        /**
         * This event does nothing usefull
         * @param oEvent refers to the object that fired the event.
         */
        public void disposing( EventObject oEvent ){
            log.println("XMouseClickHandler 1: disposing-Event");
        }
    };

    /**
     * Listener which added and removed. Its method must NOT be called
     * on <code>mousePressed</code> and <code>mouseReleased</code> call.
     */
    public class MyMouseClickHandler2 implements XMouseClickHandler {
        /**
         * This event sets the member <code>m_mousePressed</coed> to
         *  <code>true</code>
         * @param oEvent The mouse event informs about the kind of mouse event.
         * @return returns <CODE>TRUE</CODE> in erery case
         */
        public boolean mousePressed( MouseEvent oEvent ){
            log.println("XMouseClickHandler 2: mousePressed-Event: " +
                        "This should not be happen because listener is removed!");
            m_mousePressed2 = true;
            return true;
        }
        /**
         * This event sets the member <code>m_mouseReleased</coed> to
         *  <code>true</code>
         * @param oEvent The mouse event informs about the kind of mouse event.
         * @return returns <CODE>TRUE</CODE> in erery case
         */
        public boolean mouseReleased( MouseEvent oEvent ){
            log.println("XMouseClickHandler 2: mouseReleased-Event: " +
                        "This should not be happen because listener is removed!");
            m_mouseReleased2 = true;
            return true;
        }
        /**
         * This event does nothing usefull
         * @param oEvent refers to the object that fired the event.
         */
        public void disposing( EventObject oEvent ){
            log.println("XMouseClickHandler 2: disposing-Event: " +
                    "   This should not be happen because listener is removed!");
        }
    };

    /**
     * To check the events this class is a thread which click a mouse button and
     * press a key with the <CODE>Robot</CODE> class
     * @see java.awt.Robot
     */
    private class EventTrigger extends Thread{

        /**
         * represents a <CODE>AccessibilityTools</CODE>
         */
        private final AccessibilityTools at = new AccessibilityTools();
        /**
         * represents an <CODE>EventType</CODE>
         * @see EventTest.EventTriggerType
         */
        private int eventType = 0;
        /**
         * represents a <CODE>XModel</CODE> of a document
         */
        private XModel xModel = null;

        /**
         * Creates an instacne of this class. The parameter <CODE>eType</CODE> represents
         * the kind of event wich will be triggert at <CODE>run()</CODE>
         * @param model the model of a document
         * @param eType the kind of event which should be trigger
         */
        public EventTrigger(XModel model, int eType)
        {
            this.xModel = model;
            this.eventType = eType;
        }

        /**
         * Triggers the event wich is represented by <CODE>eventType</CODE>
         * The scenarios are:
         * <ul>
         *    <li>EventTest.EventTriggerType.MOUSE_KLICK_INTO_DOC
         *        which calls
         *        <li><CODE>clickIntoDoc</CODE></LI>
         *        </LI>
         *    <li>EventTest.EventTriggerType.KEY_TEXT_INTO_DOC
         *        which calls
         *            <li><CODE>clickIntodoc</CODE></LI>
         *            <li><CODE>keyIntoDoc</CODE></LI>
         *    </LI>
         * </UL>
         */
        public void run(){

            switch (this.eventType){

                case EventTriggerType.MOUSE_KLICK_INTO_DOC:
                    clickIntoDoc();
                    break;
                case EventTriggerType.KEY_TEXT_INTO_DOC:
                    clickIntoDoc();
                    keyIntoDoc();
                    break;

            }
        }
        /**
         * This method cklicks into the middel of a document. It uses Accessibility
         * to get the document and query for its position and its range to calculate
         * the middle. This values was used for <CODE>Robot</CODE> Class. This
         * Robot class is able to move the mouse and to cklick a mouse button
         * @see java.awt.Robot
        */
        private void clickIntoDoc(){
            try{

                util.DesktopTools.bringWindowToFront(xModel);

                XWindow xWindow = at.getCurrentWindow(
                                          (XMultiServiceFactory) tParam.getMSF(),
                                          xModel);

                XAccessible xRoot = at.getAccessibleObject(xWindow);


                XAccessibleContext xPanel = at.getAccessibleObjectForRole(xRoot, AccessibleRole.PANEL);
                XAccessibleComponent xPanelCont = (XAccessibleComponent) UnoRuntime.queryInterface(XAccessibleComponent.class, xPanel);

                // the position of the panel
                Point point = xPanelCont.getLocationOnScreen();

                // the range of the panel
                Rectangle rect = xPanelCont.getBounds();

                try {
                    Robot rob = new Robot();
                    int x = point.X + (rect.Width / 2);
                    int y = point.Y + (rect.Height / 2);
                    log.println("try to klick into the middle of the document");
                    rob.mouseMove(x, y);
                    rob.mousePress(InputEvent.BUTTON1_MASK);
                    rob.mouseRelease(InputEvent.BUTTON1_MASK);
                } catch (java.awt.AWTException e) {
                    log.println("couldn't press mouse button");
                }
            } catch (java.lang.Exception e){
                log.println("could not click into the scroll bar: " + e.toString());
            }
        }

        /**
         * This method press the "A" key. Therefore it uses the <CODE>Robot</CODE>
         * class.
         * @see java.awt.Robot
        */
        private void keyIntoDoc(){
            try {
                Robot rob = new Robot();
                log.println("try to press 'A'");
                rob.keyPress(java.awt.event.KeyEvent.VK_A);
                rob.keyRelease(java.awt.event.KeyEvent.VK_A);
            } catch (java.awt.AWTException e) {
                log.println("couldn't press key");
            }

        }
    }

    /** This interface represents all possible actions which could be used
     * in the <CODE>EventTrigger</CODE> class.
     * @see EventTest.EventTrigger
    */
    private interface EventTriggerType{

        /** klick the mouse into the scroll bar*/
        final public static int MOUSE_KLICK_INTO_DOC = 1;

        /** write some text into a spread sheet*/
        final public static int KEY_TEXT_INTO_DOC = 2;
    }
}