/*******************************************************************************

 * Copyright (c) 2012 BREDEX GmbH.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     BREDEX GmbH - initial API and implementation 

 *******************************************************************************/

package org.eclipse.jubula.rc.common.caps;

import java.awt.AWTException;

import java.awt.Dimension;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.RenderingHints;

import java.awt.Toolkit;

import java.awt.datatransfer.StringSelection;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.IOException;

import javax.imageio.ImageIO;

import org.eclipse.jubula.rc.common.driver.ClickOptions;

import org.eclipse.jubula.rc.common.driver.IRobot;

import org.eclipse.jubula.rc.common.driver.KeyTyper;

import org.eclipse.jubula.rc.common.exception.ExecutionEvent;

import org.eclipse.jubula.rc.common.exception.OsNotSupportedException;

import org.eclipse.jubula.rc.common.exception.RobotException;

import org.eclipse.jubula.rc.common.exception.StepExecutionException;

import org.eclipse.jubula.rc.common.implclasses.Comparer;

import org.eclipse.jubula.rc.common.implclasses.IBaseImplementationClass;

import org.eclipse.jubula.rc.common.implclasses.Verifier;

import org.eclipse.jubula.rc.common.logger.AutServerLogger;

import org.eclipse.jubula.rc.common.util.KeyStrokeUtil;

import org.eclipse.jubula.tools.constants.StringConstants;

import org.eclipse.jubula.tools.objects.event.EventFactory;

import org.eclipse.jubula.tools.objects.event.TestErrorEvent;

import org.eclipse.jubula.tools.utils.ExternalCommandExecutor;

import org.eclipse.jubula.tools.utils.TimeUtil;

import org.eclipse.jubula.tools.utils.ExternalCommandExecutor.MonitorTask;

/**

 * 

 * @author BREDEX GmbH

 *

 */

public abstract class AbstractApplicationCAPs

    implements IBaseImplementationClass {

    /**

     * String for sequential numbering for screenshots

     */

    public static final String RENAME = "rename"; //$NON-NLS-1$

    /**

     * String for overwriting for screenshots

     */

    public static final String OVERWRITE = "overwrite"; //$NON-NLS-1$

    /**

     * The default format to use when writing images to disk.

     */

    private static final String DEFAULT_IMAGE_FORMAT = "png"; //$NON-NLS-1$

    /**

     * The string used to separate filename and file extension.

     */

    private static final String EXTENSION_SEPARATOR = "."; //$NON-NLS-1$

    /** constants for communication */

    private static final String POS_UNIT_PIXEL = "Pixel"; //$NON-NLS-1$

    /** constants for communication */

    private static final String POS_UNI_PERCENT = "Percent"; //$NON-NLS-1$

    /**

     * The logging.

     */

    private static AutServerLogger log = 

        new AutServerLogger(AbstractApplicationCAPs.class);

    /**

     * @param text text to type

     */

    public void gdInputText(String text) {

        getRobot().type(getFocusOwner(), text);

    }

    /**

     * Executes the given command and waits for it to finish. If the 

     * execution does not finish in good time, a timeout will occur. If the 

     * exit code for the execution is not the same as the expected code, the 

     * test step fails.

     * 

     * @param cmd The command to execute.

     * @param expectedExitCode The expected exit code of the command.

     * @param local <code>true</code> if the command should be executed on the

     *        local (client) machine. Otherwise (should run on the server side),

     *        this value should be <code>false</code>.

     * @param timeout The amount of time (in milliseconds) to wait for the 

     *        execution to finish.

     */

    public void gdExecuteExternalCommand(String cmd, int expectedExitCode, 

        boolean local, int timeout) {

        if (!local) {

            MonitorTask mt = new ExternalCommandExecutor().executeCommand(

                null, cmd, timeout);

            if (!mt.wasCmdValid()) {

                throw new StepExecutionException(

                    "Command not found.", //$NON-NLS-1$

                    EventFactory.createActionError(

                        TestErrorEvent.NO_SUCH_COMMAND));

            }

            if (mt.hasTimeoutOccurred()) {

                throw new StepExecutionException(

                    "Timeout received before completing execution of script.", //$NON-NLS-1$

                    EventFactory.createActionError(

                        TestErrorEvent.CONFIRMATION_TIMEOUT));

            }

            int actualExitValue = mt.getExitCode();

            if (actualExitValue != expectedExitCode) {

                throw new StepExecutionException(

                    "Verification of exit code failed.", //$NON-NLS-1$

                    EventFactory.createVerifyFailed(

                        String.valueOf(expectedExitCode), 

                        String.valueOf(actualExitValue)));

            }

        } 

    }

    /**

     * {@inheritDoc}

     */

    public void setComponent(Object graphicsComponent) {

        // Do nothing; Application has no correspaonding component

    }

    /**

     * Takes a screenshot and saves the image to disk.

     * 

     * @param destination

     *          Path and filename for the created image. If the extension is not

     *          ".jpeg" (case-insensitive), ".jpeg" will be appended to the 

     *          filename.

     * @param delay

     *          Amount of time to wait (in milliseconds) before taking the

     *          screenshot.

     * @param fileAccess

     *          Determines how the file will be created if a file with the

     *          given name and path already exists:<br>

     *          <code>SwingApplicationImplClass.RENAME</code> -

     *          The screenshot will be saved with a sequential integer appended 

     *          to the filename.<br>

     *          <code>SwingApplicationImplClass.OVERWRITE</code> -

     *          The screenshot will overwrite the file.

     * @param scaling

     *          Degree to which the image should be scaled, in percent. A

     *          <code>scaling</code> value of <code>100</code> produces an

     *          unscaled image. This value must be greater than <code>0</code>

     *          and less than or equal to <code>200</code>.

     * @param createDirs

     *          Determines whether a path will be created if it does not already

     *          exist. A value of <code>true</code> means that all necessary 

     *          directories that do not exist will be created automatically.

     */

    public void gdTakeScreenshot(String destination, int delay,

            String fileAccess, int scaling, boolean createDirs) {

        // Determine current screen size

        Toolkit toolkit = Toolkit.getDefaultToolkit();

        Dimension screenSize = toolkit.getScreenSize();

        // If screen !(resolution%2==0) --> bad scaling

        int screenWidth = (int)screenSize.getWidth();

        int screenHeight = (int)screenSize.getHeight();

        if (!(screenWidth % 2 == 0)) {

            screenWidth = screenWidth - 1;

        }

        if (!(screenHeight % 2 == 0)) {

            screenHeight = screenHeight - 1;

        }

        screenSize.setSize(screenWidth, screenHeight);

        Rectangle screenRect = new Rectangle(screenSize);

        takeScreenshot(destination, delay, fileAccess, scaling, createDirs,

                screenRect);

    }

    /**

     * Takes a screenshot and saves the image to disk.

     * 

     * @param destination

     *            Path and filename for the created image. If the extension is

     *            not ".jpeg" (case-insensitive), ".jpeg" will be appended to

     *            the filename.

     * @param delay

     *            Amount of time to wait (in milliseconds) before taking the

     *            screenshot.

     * @param fileAccess

     *            Determines how the file will be created if a file with the

     *            given name and path already exists:<br>

     *            <code>SwingApplicationImplClass.RENAME</code> - The screenshot

     *            will be saved with a sequential integer appended to the

     *            filename.<br>

     *            <code>SwingApplicationImplClass.OVERWRITE</code> - The

     *            screenshot will overwrite the file.

     * @param scaling

     *            Degree to which the image should be scaled, in percent. A

     *            <code>scaling</code> value of <code>100</code> produces an

     *            unscaled image. This value must be greater than <code>0</code>

     *            and less than or equal to <code>200</code>.

     * @param createDirs

     *            Determines whether a path will be created if it does not

     *            already exist. A value of <code>true</code> means that all

     *            necessary directories that do not exist will be created

     *            automatically.

     * @param marginTop

     *            the extra top margin

     * @param marginRight

     *            the extra right margin

     * @param marginBottom

     *            the extra bottom margin

     * @param marginLeft

     *            the extra left margin

     */

    public void gdTakeScreenshotOfActiveWindow(String destination, int delay,

            String fileAccess, int scaling, boolean createDirs, int marginTop,

            int marginRight, int marginBottom, int marginLeft) {

        Rectangle activeWindowBounds = getActiveWindowBounds();

        if (activeWindowBounds == null) {

            throw new StepExecutionException("No active window found", //$NON-NLS-1$

                    EventFactory

                        .createActionError(TestErrorEvent.NO_ACTIVE_WINDOW));

        }

        int x = activeWindowBounds.x - marginLeft;

        int y = activeWindowBounds.y - marginTop;

        int width = activeWindowBounds.width + marginLeft + marginRight;

        int height = activeWindowBounds.height + marginTop + marginBottom;

        if (width < 1 || height < 1) {

            throw new StepExecutionException("Margin parameter lead to negative height or width", //$NON-NLS-1$

                    EventFactory

                        .createActionError(TestErrorEvent.INVALID_INPUT));

        }

        Rectangle screenRect = new Rectangle(x, y, width, height);

        takeScreenshot(destination, delay, fileAccess, scaling, createDirs,

                screenRect);

    }

    /**

     * @return an awt rectangle which represents the absolute active window

     *         bounds; may return null e.g. if no active window could be found

     */

    public abstract Rectangle getActiveWindowBounds();

    /**

     * Takes a screenshot and saves the image to disk, in JPEG format.

     * 

     * @param destination

     *          Path and filename for the created image. If the extension is not

     *          ".jpeg" (case-insensitive), ".jpeg" will be appended to the 

     *          filename.

     * @param delay

     *          Amount of time to wait (in milliseconds) before taking the

     *          screenshot.

     * @param fileAccess

     *          Determines how the file will be created if a file with the

     *          given name and path already exists:<br>

     *          <code>SwingApplicationImplClass.RENAME</code> -

     *          The screenshot will be saved with a sequential integer appended 

     *          to the filename.<br>

     *          <code>SwingApplicationImplClass.OVERWRITE</code> -

     *          The screenshot will overwrite the file.

     * @param scaling

     *          Degree to which the image should be scaled, in percent. A

     *          <code>scaling</code> value of <code>100</code> produces an

     *          unscaled image. This value must be greater than <code>0</code>

     *          and less than or equal to <code>200</code>.

     * @param createDirs

     *          Determines whether a path will be created if it does not already

     *          exist. A value of <code>true</code> means that all necessary 

     *          directories that do not exist will be created automatically.

     * @param screenShotRect 

     *          the rectangle to take the screenshot of

     */

    private void takeScreenshot(String destination, int delay,

            String fileAccess, int scaling, boolean createDirs,

            Rectangle screenShotRect) {

        if (scaling <= 0 || scaling > 200) {

            throw new StepExecutionException(

                    "Invalid scaling factor: Must be between 1 and 200", //$NON-NLS-1$

                    EventFactory.createActionError(

                            TestErrorEvent.INVALID_PARAM_VALUE));

        }

        double scaleFactor = scaling * 0.01;

        // Check if file name is valid

        String outFileName = destination;

        String imageExtension = getExtension(outFileName);

        if (imageExtension.length() == 0) {

            // If not, then we simply append the default extension

            imageExtension = DEFAULT_IMAGE_FORMAT;

            outFileName += EXTENSION_SEPARATOR + imageExtension;

        }

        // Wait for a user-specified time

        if (delay > 0) {

            TimeUtil.delay(delay);

        }

        // Create path, if necessary

        File pic = new File(outFileName);

        if (pic.getParent() == null) {

            throw new StepExecutionException(

                    "Invalid file name: specify a file name", //$NON-NLS-1$

                    EventFactory.createActionError(

                            TestErrorEvent.INVALID_PARAM_VALUE));

        }

        File path = new File(pic.getParent());

        if (createDirs && !path.exists() && !path.mkdirs()) {

            throw new StepExecutionException(

                "Directory path does not exist and could not be created", //$NON-NLS-1$

                EventFactory.createActionError(

                    TestErrorEvent.FILE_IO_ERROR));

        }

        // Rename file if file already exists

        // FIXME zeb This naming scheme can lead to sorting problems when 

        //           filenames have varying numbers of digits (ex. "pic_9" and 

        //           "pic_10")

        if (fileAccess.equals(RENAME)) {

            String completeExtension = 

                EXTENSION_SEPARATOR + imageExtension.toLowerCase();

            int extensionIndex = 

                pic.getName().toLowerCase().lastIndexOf(completeExtension);

            String fileName = pic.getName().substring(0, extensionIndex);

            for (int i = 1; pic.exists(); i++) {

                pic = new File(pic.getParent(), fileName + "_" + i + completeExtension); //$NON-NLS-1$

            }

        }

        takeScreenshot(screenShotRect, scaleFactor, pic);

    }

    /**

     * Takes a screenshot and saves the image to disk. This method will attempt

     * to encode the image according to the file extension of the given

     * output file. If this is not possible (because the encoding type

     * is not supported), then the default encoding type will be used. If

     * the default encoding type is used, an appropriate extension will be added

     * to the filename.

     * 

     * @param captureRect

     *          Rect to capture in screen coordinates.

     * @param scaleFactor

     *          Degree to which the image should be scaled, in percent. A

     *          <code>scaleFactor</code> of <code>100</code> produces an

     *          unscaled image. This value must be greater than <code>0</code>

     *          and less than or equal to <code>200</code>.

     * @param outputFile

     *          Path and filename for the created image.

     */

    public void takeScreenshot(

            Rectangle captureRect, double scaleFactor, File outputFile) {

        // Create screenshot

        java.awt.Robot robot;

        File out = outputFile;

        try {

            robot = new java.awt.Robot();

            BufferedImage image = robot.createScreenCapture(captureRect);

            int scaledWidth = (int) Math.floor(image.getWidth() * scaleFactor);

            int scaledHeight = 

                (int) Math.floor(image.getHeight() * scaleFactor);

            BufferedImage imageOut = 

                new BufferedImage(scaledWidth,

                    scaledHeight, BufferedImage.TYPE_INT_RGB);

            // Scale it to the new size on-the-fly

            Graphics2D graphics2D = imageOut.createGraphics();

            graphics2D.setRenderingHint(RenderingHints.KEY_RENDERING,

                    RenderingHints.VALUE_RENDER_QUALITY);

            graphics2D.drawImage(image, 0, 0, scaledWidth, scaledHeight, null);

            // Save captured image using given format, if supported.

            String extension = getExtension(out.getName());

            if (extension.length() == 0

                    || !ImageIO.getImageWritersBySuffix(extension).hasNext()

                    || !ImageIO.write(imageOut, extension, out)) {

                // Otherwise, save using default format

                out = new File(outputFile.getPath() 

                        + EXTENSION_SEPARATOR + DEFAULT_IMAGE_FORMAT);

                if (!ImageIO.write(imageOut, DEFAULT_IMAGE_FORMAT, out)) {

                    // This should never happen, so log as error if it does.

                    // In this situation, the screenshot will not be saved, but

                    // the test step will still be marked as successful.

                    log.error("Screenshot could not be saved. " + //$NON-NLS-1$

                            "Default image format (" + DEFAULT_IMAGE_FORMAT  //$NON-NLS-1$

                            + ") is not supported."); //$NON-NLS-1$

                }

            }

        } catch (AWTException e) {

            throw new RobotException(e);

        } catch (IOException e) {

            throw new StepExecutionException(

                    "Screenshot could not be saved", //$NON-NLS-1$

                    EventFactory.createActionError(

                            TestErrorEvent.FILE_IO_ERROR));

        }

    }

    /**

     * Waits a specified time. 

     * @param timeMilliSec the time to wait in MilliSec

     */

    public void gdWait(int timeMilliSec) {

        TimeUtil.delay(timeMilliSec);

    }

    /**

     * shows a ConfirmDialog and Pause the Execution of the Test until Window 

     * is closed

     */

    public void gdPause() {

        throw new ExecutionEvent(ExecutionEvent.PAUSE_EXECUTION);

    }

    /**

     * Does nothing! The restart is implemented in the client but the server

     * must have an action to execute.

     */

    public void gdRestart() {

        // nothing

    }

    /**

     * Types the given text without checking location or event confirmation.

     * 

     * @param text The text to type.

     */

    public void gdNativeInputText(String text) {

        try {

            KeyTyper.getInstance().nativeTypeString(text);

        } catch (AWTException e) {

            throw new RobotException(e);

        }

    }

    /**

     * Action to perform a manual test step on server side; opens a window and

     * wait's for real user interaction

     * 

     * @param actionToPerform

     *            a textual description of the action to perform in the AUT

     * @param expectedBehavior

     *            a textual description of the expected behaviour

     * @param timeout

     *            the timeout

     */

    public void gdManualTestStep(String actionToPerform, 

            String expectedBehavior, int timeout) {

    // empty implementation: implementation can be found in the corresponding

    // postExecutionCommand

    }

    /**

     * Perform a keystroke specified according <a

     * href=http://java.sun.com/j2se/1.4.2/docs/api/javax/swing/KeyStroke.html#getKeyStroke(java.lang.String)>

     * string representation of a keystroke </a>.

     * This method does not wait for event confirmation, as we have no way of 

     * confirming events on OS-native widgets.

     * 

     * @param modifierSpec the string representation of the modifiers

     * @param keySpec the string representation of the key

     */

    public void gdNativeKeyStroke(String modifierSpec, String keySpec) {        

        if (keySpec == null || keySpec.trim().length() == 0) {

            throw new StepExecutionException("The base key of the key stroke " //$NON-NLS-1$

                + "must not be null or empty", //$NON-NLS-1$

                EventFactory.createActionError());

        }

        try {

            KeyTyper typer = KeyTyper.getInstance();

            String keyStrokeSpec = keySpec.trim().toUpperCase();

            String mod = KeyStrokeUtil.getModifierString(modifierSpec);

            if (mod.length() > 0) {

                keyStrokeSpec = mod + " " + keyStrokeSpec; //$NON-NLS-1$

            }

            typer.type(keyStrokeSpec, null, null, null);

        } catch (AWTException e) {

            throw new RobotException(e);

        }

    }

    /**

     * Action to set the value of a variable in the Client.

     * 

     * @param variable The name of the variable.

     * @param value The new value for the variable.

     * @return the new value for the variable.

     */

    public String gdSetValue(String variable, String value) {

        return value;

    }

    /**

     * @return The Robot instance

     */

    protected abstract IRobot getRobot();

    /**

     * 

     * @param filename A filename for which to find the extension.

     * @return the file extension for the given filename. For example,

     *         "png" for "example.png". Returns an empty string if the given

     *         name has no extension. This is the case if the given name does

     *         not contain an instance of the extension separator or ends with

     *         the extension separator. For example, "example" or "example.".

     */

    private String getExtension(String filename) {

        File file = new File(filename);

        int extensionIndex = file.getName().lastIndexOf(EXTENSION_SEPARATOR);

        return extensionIndex == -1 

                    || extensionIndex == file.getName().length() - 1 

                ? StringConstants.EMPTY

                : file.getName().substring(extensionIndex + 1); 

    }

    /**

     * method to copy a string to the system clipboard

     * 

     * @param text The text to copy

     */

    public void gdCopyToClipboard(final String text) {      

        StringSelection strSel = new StringSelection(text);

        try {

            Toolkit.getDefaultToolkit().getSystemClipboard()

                .setContents(strSel, null);

        } catch (IllegalStateException ise) {

            throw new StepExecutionException(

                    "Clipboard not available.", //$NON-NLS-1$

                    EventFactory.createActionError(

                            TestErrorEvent.CLIPBOARD_NOT_AVAILABLE));

        }

    }

    /**

     * method to compare to values

     * 

     * @param value1

     *            the first value for comparison

     * @param comparisonMethod

     *            the comparison method

     * @param value2

     *            the second value for comparison

     */

    public void gdCheckValues(final String value1,

            final String comparisonMethod, final String value2) {

        Comparer.compare(value1, value2, comparisonMethod);

    }

    /**

     * method to compare to strings

     * 

     * @param value1

     *            the first value for comparison

     * @param operator

     *            the comparison method

     * @param value2

     *            the second value for comparison

     */

    public void gdCheckStringValues(final String value1,

            final String operator, final String value2) {

        Verifier.match(value1, value2, operator);

    }

    /**

     * Does nothing! The start timer is implemented in the client but the server

     * must have an action to execute.

     * @param timerName the name for the timer

     * @param variableName the variable name to store the current time in millisecs in

     */

    public void gdStartTimer(String timerName, String variableName) {

    // empty

    }

    /**

     * Does nothing! The read timer is implemented in the client but the server

     * must have an action to execute.

     * @param timerName the name for the timer

     * @param variableName the variable name to store the current time delta in millisecs in

     */

    public void gdReadTimer(String timerName, String variableName) {

    // empty

    }

    /**

     * activate the AUT

     * 

     * @param method activation method

     */

    public void gdActivate(String method) {

        getRobot().activateApplication(method);

    }

    /**

     * clicks into the active window.

     * 

     * @param count amount of clicks

     * @param button what mouse button should be used

     * @param xPos what x position

     * @param xUnits should x position be pixel or percent values

     * @param yPos what y position

     * @param yUnits should y position be pixel or percent values

     * @throws StepExecutionException error

     */

    public void gdClickDirect(int count, int button, 

        int xPos, String xUnits, int yPos, String yUnits) 

        throws StepExecutionException {

        Object activeWindow = getActiveWindow();

        if (activeWindow != null) {

            getRobot().click(activeWindow, null, 

                ClickOptions.create()

                    .setClickCount(count)

                    .setConfirmClick(false)

                    .setMouseButton(button), 

                xPos, 

                xUnits.equalsIgnoreCase(POS_UNIT_PIXEL), 

                yPos, 

                yUnits.equalsIgnoreCase(POS_UNIT_PIXEL));

        } else {

            throw new StepExecutionException("No active window.", //$NON-NLS-1$

                EventFactory.createActionError(

                    TestErrorEvent.NO_ACTIVE_WINDOW));

        }

    }

    /**

     * Checks for the existence of a window with the given title

     * 

     * @param title

     *            the title

     * @param operator

     *            the comparing operator

     * @param exists

     *            <code>True</code> if the window is expected to exist and be

     *            visible, otherwise <code>false</code>.

     */

//    public void gdCheckExistenceOfWindow(final String title, String operator,

//            boolean exists) {

//        Verifier.equals(exists, isWindowOpen(title, operator));

//    }

    /**

     * Just a server side method, not useable as action.

     * 

     * @param keyCode The key code

     */

    public void gdKeyType(int keyCode) {

        getRobot().keyType(null, keyCode);

    }

    /**

     * Just a server side method, not useable as action.

     * 

     * note : this action only works if application got focus,

     * because using defaultToolkit does not work. You have to

     * use component.getToolKit()s

     * @param key to set

     *      numlock Num Lock 1

     *      caplock Caps Lock 2 

     *      scolllock Scroll 3

     * @param activated 

     *      boolean

     */

    public void gdToggle(int key, boolean activated) {

        int event = getEventCode(key);

        if (event != 0) {

            try {

                getRobot().keyToggle(getFocusOwner(), 

                    event, activated);

            } catch (UnsupportedOperationException usoe) {

                throw new StepExecutionException(

                    TestErrorEvent.UNSUPPORTED_OPERATION_ERROR,

                    EventFactory.createActionError(

                        TestErrorEvent.UNSUPPORTED_OPERATION_ERROR));

            } catch (OsNotSupportedException e) {

                throw new StepExecutionException(

                        TestErrorEvent.UNSUPPORTED_OPERATION_ERROR,

                        EventFactory.createActionError(

                            TestErrorEvent.UNSUPPORTED_OPERATION_ERROR));

            }

        }

    }

    /**

     * perform a keystroke

     * @param modifierSpec the string representation of the modifiers

     * @param keySpec the string representation of the key

     */

    public abstract void gdKeyStroke(String modifierSpec, String keySpec);

    /**

     * 

     * @return the Focus Owner

     */

    protected abstract Object getFocusOwner();

    /**

     * 

     * @param key to set

     *      numlock Num Lock 1

     *      caplock Caps Lock 2 

     *      scolllock Scroll 3

     * @return the toolkit specific eventcode

     */

    protected abstract int getEventCode(int key);

    /**

     * 

     * @return The active application window, or <code>null</code> if no 

     *         application window is currently active.

     */

    protected abstract Object getActiveWindow();

}

/*******************************************************************************

 * Copyright (c) 2012 BREDEX GmbH.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     BREDEX GmbH - initial API and implementation 

 *******************************************************************************/

package org.eclipse.jubula.rc.swing.swing.caps;

import java.awt.AWTEvent;

import java.awt.Component;

import java.awt.Dialog;

import java.awt.Frame;

import java.awt.Rectangle;

import java.awt.Toolkit;

import java.awt.Window;

import java.awt.event.AWTEventListener;

import java.awt.event.ComponentEvent;

import java.awt.event.KeyEvent;

import java.awt.event.WindowEvent;

import java.util.Collection;

import java.util.ConcurrentModificationException;

import java.util.Iterator;

import org.eclipse.jubula.rc.common.AUTServer;

import org.eclipse.jubula.rc.common.caps.AbstractApplicationCAPs;

import org.eclipse.jubula.rc.common.driver.ClickOptions;

import org.eclipse.jubula.rc.common.driver.IRobot;

import org.eclipse.jubula.rc.common.exception.StepExecutionException;

import org.eclipse.jubula.rc.common.implclasses.MatchUtil;

import org.eclipse.jubula.rc.common.implclasses.Verifier;

import org.eclipse.jubula.rc.common.listener.EventLock;

import org.eclipse.jubula.rc.common.logger.AutServerLogger;

import org.eclipse.jubula.rc.common.util.KeyStrokeUtil;

import org.eclipse.jubula.rc.swing.components.SwingComponent;

import org.eclipse.jubula.rc.swing.listener.ComponentHandler;

import org.eclipse.jubula.rc.swing.listener.FocusTracker;

import org.eclipse.jubula.rc.swing.swing.implclasses.EventListener;

import org.eclipse.jubula.rc.swing.swing.implclasses.WindowHelper;

import org.eclipse.jubula.rc.swing.swing.interfaces.IGraphicApplication;

import org.eclipse.jubula.tools.constants.StringConstants;

import org.eclipse.jubula.tools.objects.event.EventFactory;

import org.eclipse.jubula.tools.objects.event.TestErrorEvent;

import org.eclipse.jubula.tools.utils.TimeUtil;

/**

 * 

 * @author BREDEX GmbH

 *

 */

public class SwingApplicationCAPs extends AbstractApplicationCAPs implements

        IGraphicApplication {

    /**

     * This condition is true if the event is an 'window opened' event

     * and the event source is a frame/dialog with a certain title.

     * It is also true if the event is a 'component shown' event and the 

     * event source is a frame/dialog with a certain title.

     */

    private static class WindowOpenedCondition 

        implements EventListener.Condition {

        /**

         * the title

         */

        private final String m_title;

        /** the matches operation */

        private final String m_operator;

        /**

         * constructor

         * 

         * @param title the title

         * @param operator the matches operation

         */

        public WindowOpenedCondition(String title, String operator) {

            m_title = title;

            m_operator = operator;

        }

        /**

         * {@inheritDoc}

         */

        public boolean isTrue(AWTEvent event) {

            if (event.getID() != WindowEvent.WINDOW_OPENED

                && event.getID() != ComponentEvent.COMPONENT_SHOWN) {

                return false;

            }

            if (event.getSource() instanceof Frame) {

                Frame frame = (Frame)event.getSource();

                return MatchUtil.getInstance().match(

                    frame.getTitle(), m_title, m_operator);

            } else if (event.getSource() instanceof Dialog) {

                Dialog dialog = (Dialog)event.getSource();

                return MatchUtil.getInstance().match(

                    dialog.getTitle(), m_title, m_operator);

            } else {

                return false;

            }

        }

    }

    /**

     * This condition is true if the event is an 'window activated' event

     * and the event source is a frame/dialog with a certain title.

     */

    private static class WindowActivatedCondition 

        implements EventListener.Condition {

        /**

         * the title

         */

        private final String m_title;

        /** the matches operation */

        private final String m_operator;

        /**

         * constructor

         * 

         * @param title the title

         * @param operator the matches operation

         */

        public WindowActivatedCondition(String title, String operator) {

            m_title = title;

            m_operator = operator;

        }

        /**

         * {@inheritDoc}

         */

        public boolean isTrue(AWTEvent event) {

            if (event.getID() != WindowEvent.WINDOW_ACTIVATED) {

                return false;

            }

            if (event.getSource() instanceof Frame) {

                Frame frame = (Frame)event.getSource();

                return MatchUtil.getInstance().match(

                    frame.getTitle(), m_title, m_operator);

            } else if (event.getSource() instanceof Dialog) {

                Dialog dialog = (Dialog)event.getSource();

                return MatchUtil.getInstance().match(

                    dialog.getTitle(), m_title, m_operator);

            } else {

                return false;

            }

        }

    }

    /**

     * This condition is true if the event is an 'window closed' event

     * and the event source is a frame/dialog with a certain title.

     * It is also true if the event is a 'component hidden' event and the 

     * event source is a frame/dialog with a certain title.

     */

    private static class WindowClosedCondition 

        implements EventListener.Condition {

        /**

         * the title

         */

        private final String m_title;

        /** the matches operation */

        private final String m_operator;

        /**

         * constructor

         * 

         * @param title the title

         * @param operator the matches operation

         */

        public WindowClosedCondition(String title, String operator) {

            m_title = title;

            m_operator = operator;

        }

        /**

         * {@inheritDoc}

         */

        public boolean isTrue(AWTEvent event) {

            if (event.getID() != WindowEvent.WINDOW_CLOSED

                && event.getID() != ComponentEvent.COMPONENT_HIDDEN) {

                return false;

            }

            if (event.getSource() instanceof Frame) {

                Frame frame = (Frame)event.getSource();

                return MatchUtil.getInstance().match(

                    frame.getTitle(), m_title, m_operator);

            } else if (event.getSource() instanceof Dialog) {

                Dialog dialog = (Dialog)event.getSource();

                return MatchUtil.getInstance().match(

                    dialog.getTitle(), m_title, m_operator);

            } else {

                return false;

            }

        }

    }

    /**

     * The logging.

     */

    private static AutServerLogger log = 

        new AutServerLogger(SwingApplicationCAPs.class);

    /**

     * {@inheritDoc}

     */

    public String[] getTextArrayFromComponent() {

        return null;

    }

    /**

     * Types <code>text</code> into the component. This replaces the shown

     * content.

     * @param text the text to type in

     * @deprecated Removed without substitution:

     * Testcases with this action are fragile, because this action assumes the

     * availabality of a text component. Any other case breaks the test.

     */

    public void gdReplaceText(String text) {

        getRobot().click(FocusTracker.getFocusOwner(), null, 

            ClickOptions.create().setClickCount(3).left());

        if (StringConstants.EMPTY.equals(text)) {

            getRobot().keyStroke("DELETE"); //$NON-NLS-1$

        }

        gdInputText(text);

    }

    /**

     * Waits <code>timeMillSec</code> if the application opens a window

     * with the given title.

     * 

     * @param title the title

     * @param operator the comparing operator

     * @param pTimeout the time in ms

     * @param delay delay after the window is shown

     */

    public void gdWaitForWindow(final String title, String operator, 

        int pTimeout, int delay) {

        EventListener.Condition cond = 

            new WindowOpenedCondition(title, operator);

        EventLock lock = new EventLock();

        AWTEventListener listener = new EventListener(lock, cond);

        Toolkit.getDefaultToolkit().addAWTEventListener(listener,

                AWTEvent.WINDOW_EVENT_MASK | AWTEvent.COMPONENT_EVENT_MASK);

        if (isWindowOpen(title, operator)) {

            lock.release();

        }

        try {

            synchronized (lock) {

                long timeout = pTimeout;

                long done = System.currentTimeMillis() + timeout;

                long now;

                while (!lock.isReleased() && (timeout > 0)) {

                    try {

                        lock.wait(timeout);

                        now = System.currentTimeMillis();

                        timeout = done - now;

                    } catch (InterruptedException e) {

                        // ignore

                    }

                }

            }

        } finally {

            Toolkit.getDefaultToolkit().removeAWTEventListener(listener);

        }

        if (!lock.isReleased() && !isWindowOpen(title, operator)) {

            throw new StepExecutionException("window did not open", //$NON-NLS-1$

                    EventFactory.createActionError(

                            TestErrorEvent.TIMEOUT_EXPIRED));

        }

        TimeUtil.delay(delay);

    }

    /**

     * Waits <code>timeMillSec</code> if the application activates a window

     * with the given title.

     * 

     * @param title the title

     * @param operator the comparing operator

     * @param pTimeout the time in ms

     * @param delay delay after the window is activated

     */

    public void gdWaitForWindowActivation(final String title, String operator, 

        int pTimeout, int delay) {

        EventListener.Condition cond = new WindowActivatedCondition(title, 

                operator);

        EventLock lock = new EventLock();

        AWTEventListener listener = new EventListener(lock, cond);

        Toolkit.getDefaultToolkit().addAWTEventListener(listener,

                AWTEvent.WINDOW_EVENT_MASK);

        if (isWindowActive(title, operator)) {

            lock.release();

        }

        try {

            synchronized (lock) {

                long timeout = pTimeout;

                long done = System.currentTimeMillis() + timeout;

                long now;

                while (!lock.isReleased() && (timeout > 0)) {

                    try {

                        lock.wait(timeout);

                        now = System.currentTimeMillis();

                        timeout = done - now;

                    } catch (InterruptedException e) {

                        // ignore

                    }

                }

            }

        } finally {

            Toolkit.getDefaultToolkit().removeAWTEventListener(listener);

        }

        if (!lock.isReleased() && !isWindowActive(title, operator)) {

            throw new StepExecutionException("window was not activated", //$NON-NLS-1$

                    EventFactory.createActionError(

                            TestErrorEvent.TIMEOUT_EXPIRED));

        }

        TimeUtil.delay(delay);

    }

    /**

     * Waits <code>timeMillSec</code> if the application closes (or hides) 

     * a window with the given title. If no window with the given title can

     * be found, then it is assumed that the window has already closed.

     * 

     * @param title the title

     * @param operator the comparing operator

     * @param pTimeout the time in ms

     * @param delay delay after the window is closed

     */

    public void gdWaitForWindowToClose(final String title, String operator, 

        int pTimeout, int delay) {

        EventListener.Condition cond = 

            new WindowClosedCondition(title, operator);

        EventLock lock = new EventLock();

        AWTEventListener listener = new EventListener(lock, cond);

        Toolkit.getDefaultToolkit().addAWTEventListener(listener,

                AWTEvent.WINDOW_EVENT_MASK);

        if (!isWindowOpen(title, operator)) {

            lock.release();

        }

        try {

            synchronized (lock) {

                long timeout = pTimeout;

                long done = System.currentTimeMillis() + timeout;

                long now;

                while (!lock.isReleased() && (timeout > 0)) {

                    try {

                        lock.wait(timeout);

                        now = System.currentTimeMillis();

                        timeout = done - now;

                    } catch (InterruptedException e) {

                        // ignore

                    }

                }

            }

        } finally {

            Toolkit.getDefaultToolkit().removeAWTEventListener(listener);

        }

        if (!lock.isReleased() && isWindowOpen(title, operator)) {

            throw new StepExecutionException("window did not close", //$NON-NLS-1$

                    EventFactory.createActionError(

                            TestErrorEvent.TIMEOUT_EXPIRED));

        }

        TimeUtil.delay(delay);

    }

    /**

     * Checks for the existence of a window with the given title

     * 

     * @param title

     *            the title

     * @param operator

     *            the comparing operator

     * @param exists

     *            <code>True</code> if the window is expected to exist and be

     *            visible, otherwise <code>false</code>.

     */

    public void gdCheckExistenceOfWindow(final String title, String operator,

            boolean exists) {

        Verifier.equals(exists, isWindowOpen(title, operator));

    }

    /**

     * {@inheritDoc}

     */

    public Rectangle getActiveWindowBounds() {

        Window activeWindow = WindowHelper.getActiveWindow();

        if (activeWindow != null) {

            Rectangle activeWindowBounds = 

                new Rectangle(activeWindow.getBounds()); 

            activeWindowBounds.setLocation(activeWindow.getLocationOnScreen());

            return activeWindowBounds;

        }

        return null;

    }

    /**

     * {@inheritDoc}

     */

    protected IRobot getRobot() {

        return AUTServer.getInstance().getRobot();

    }

    /**

     * perform a keystroke specified according <a

     * href=http://java.sun.com/j2se/1.4.2/docs/api/javax/swing/KeyStroke.html#getKeyStroke(java.lang.String)>

     * string representation of a keystroke </a>,

     * 

     * @param modifierSpec the string representation of the modifiers

     * @param keySpec the string representation of the key

     */

    public void gdKeyStroke(String modifierSpec, String keySpec) {

        if (keySpec == null || keySpec.trim().length() == 0) {

            throw new StepExecutionException(

                "The base key of the key stroke must not be null or empty", //$NON-NLS-1$

                EventFactory.createActionError());

        }

        String key = keySpec.trim().toUpperCase();

        String mod = KeyStrokeUtil.getModifierString(modifierSpec);

        if (mod.length() > 0) {

            getRobot().keyStroke(mod.toString() + " " + key); //$NON-NLS-1$

        } else {

            int code = getKeyCode(key);

            if (code != -1) {

                gdKeyType(code);

            } else {

                getRobot().keyStroke(key);

            }

        }

    }

    /**

     * {@inheritDoc}

     */

    protected Object getFocusOwner() {

        return FocusTracker.getFocusOwner();

    }

    /**

     * {@inheritDoc}

     */

    protected int getEventCode(int key) {

        int event = 0;

        switch (key) {

            case 1 : 

                event = KeyEvent.VK_NUM_LOCK;

                break;

            case 2 : 

                event = KeyEvent.VK_CAPS_LOCK;

                break;

            case 3 : 

                event = KeyEvent.VK_SCROLL_LOCK;

                break;

            default : 

                break;

        }

        return event;

    }

    /**

     * {@inheritDoc}

     */

    protected Object getActiveWindow() {

        return WindowHelper.getActiveWindow();

    }

    /**

     * Returns <code>true</code> if a window with the given title is open and 

     * visible.

     * 

     * @param title the title

     * @param operator the matches/equals operator

     * @return if the window is open and visible

     */

    private boolean isWindowOpen(String title, String operator) {

        boolean wasInterrupted;

        do {

            try {

                wasInterrupted = false;

                Collection components = ComponentHandler.getAutHierarchy()

                        .getHierarchyMap().keySet();

                for (Iterator it = components.iterator(); it.hasNext();) {

                    Component c = ((SwingComponent)it.next())

                        .getRealComponent();

                    if (c.isShowing()) {

                        if (c instanceof Frame) {

                            Frame frame = (Frame)c;

                            if (MatchUtil.getInstance().match(frame.getTitle(), 

                                title, operator)) {

                                return true;

                            }

                        }

                        if (c instanceof Dialog) {

                            Dialog dialog = (Dialog)c;

                            if (MatchUtil.getInstance().match(dialog.getTitle(),

                                title, operator)) {

                                return true;

                            }

                        }

                    }

                }

            } catch (ConcurrentModificationException e) {

                log.debug("hierarchy modified while traversing", e); //$NON-NLS-1$

                wasInterrupted = true;

            }

        } while (wasInterrupted);

        return false;

    }

    /**

     * Returns <code>true</code> if a window with the given title has focus

     * 

     * @param title the title

     * @param operator the matches/equals operator

     * @return if the window has focus

     */

    private boolean isWindowActive(String title, String operator) {

        Window activeWindow = WindowHelper.getActiveWindow();

        if (activeWindow != null) {

            String windowTitle = null;

            if (activeWindow instanceof Dialog) {

                windowTitle = ((Dialog)activeWindow).getTitle();

            } else if (activeWindow instanceof Frame) {

                windowTitle = ((Frame)activeWindow).getTitle();

            }

            if (MatchUtil.getInstance().match(windowTitle, title, operator)) {

                return true;

            }

        }

        return false;

    }

    /**

     * @param keyCodeName

     *            The name of a key code, e.g. <code>TAB</code> for a

     *            tabulator key code

     * @return The key code or <code>-1</code>, if the key code name doesn't

     *         exist in the <code>KeyEvent</code> class

     * @throws StepExecutionException

     *             If the key code name cannot be converted to a key code due to

     *             the reflection call

     */

    public int getKeyCode(String keyCodeName) throws StepExecutionException {

        int code = -1;

        String codeName = "VK_" + keyCodeName; //$NON-NLS-1$

        try {

            code = KeyEvent.class.getField(codeName).getInt(KeyEvent.class);

        } catch (IllegalArgumentException e) {

            throw new StepExecutionException(e.getMessage(), EventFactory

                .createActionError());

        } catch (SecurityException e) {

            throw new StepExecutionException(e.getMessage(), EventFactory

                .createActionError());

        } catch (IllegalAccessException e) {

            throw new StepExecutionException(e.getMessage(), EventFactory

                .createActionError());

        } catch (NoSuchFieldException e) {

            if (log.isInfoEnabled()) {

                log.info("The key expression '" + keyCodeName //$NON-NLS-1$

                    + "' is not a key code, typed as key stroke instead"); //$NON-NLS-1$

            }

        }

        return code;

    }

}

/*******************************************************************************

 * Copyright (c) 2012 BREDEX GmbH.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     BREDEX GmbH - initial API and implementation 

 *******************************************************************************/

package org.eclipse.jubula.rc.swt.caps;

import java.awt.Rectangle;

import java.util.Collection;

import java.util.ConcurrentModificationException;

import java.util.Iterator;

import org.eclipse.jubula.rc.common.AUTServer;

import org.eclipse.jubula.rc.common.caps.AbstractApplicationCAPs;

import org.eclipse.jubula.rc.common.driver.ClickOptions;

import org.eclipse.jubula.rc.common.driver.IEventThreadQueuer;

import org.eclipse.jubula.rc.common.driver.IRobot;

import org.eclipse.jubula.rc.common.driver.IRobotFactory;

import org.eclipse.jubula.rc.common.driver.IRunnable;

import org.eclipse.jubula.rc.common.exception.StepExecutionException;

import org.eclipse.jubula.rc.common.implclasses.MatchUtil;

import org.eclipse.jubula.rc.common.implclasses.Verifier;

import org.eclipse.jubula.rc.common.listener.EventLock;

import org.eclipse.jubula.rc.common.logger.AutServerLogger;

import org.eclipse.jubula.rc.common.util.KeyStrokeUtil;

import org.eclipse.jubula.rc.common.util.WorkaroundUtil;

import org.eclipse.jubula.rc.swt.SwtAUTServer;

import org.eclipse.jubula.rc.swt.components.SwtComponent;

import org.eclipse.jubula.rc.swt.driver.EventThreadQueuerSwtImpl;

import org.eclipse.jubula.rc.swt.driver.RobotFactoryConfig;

import org.eclipse.jubula.rc.swt.implclasses.EventListener;

import org.eclipse.jubula.rc.swt.implclasses.EventListener.Condition;

import org.eclipse.jubula.rc.swt.interfaces.IGraphicApplication;

import org.eclipse.jubula.rc.swt.listener.ComponentHandler;

import org.eclipse.jubula.rc.swt.listener.FocusTracker;

import org.eclipse.jubula.rc.swt.utils.SwtPointUtil;

import org.eclipse.jubula.tools.constants.StringConstants;

import org.eclipse.jubula.tools.objects.event.EventFactory;

import org.eclipse.jubula.tools.objects.event.TestErrorEvent;

import org.eclipse.jubula.tools.utils.EnvironmentUtils;

import org.eclipse.jubula.tools.utils.TimeUtil;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Event;

import org.eclipse.swt.widgets.Listener;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.swt.widgets.Widget;

/**

 * 

 * @author BREDEX GmbH

 *

 */

public class SwtApplicationCAPs extends AbstractApplicationCAPs implements

        IGraphicApplication {

    /** The logging. */

    private static AutServerLogger log = 

        new AutServerLogger(SwtApplicationCAPs.class);

    /**

     * This condition is true if the event source is a Shell with a matching

     * title.

     *

     * @author BREDEX GmbH

     * @created Jun 17, 2009

     */

    private static class WindowEventCondition implements Condition {

        /** the expected window title */

        private String m_windowTitle;

        /** the operator used for matching the window title */

        private String m_matchingOperator;

        /** 

         * determines whether the event source being disposed should be 

         * treated as a match 

         */

        private boolean m_valForDisposed;

        /**

         * Constructor

         * 

         * @param windowTitle The expected window title.

         * @param matchingOperator The operator used for matching the

         *                         window title.

         * @param valForDisposed Whether the event source being disposed

         *                       should be treated as a match.

         */

        public WindowEventCondition(String windowTitle, 

                String matchingOperator, boolean valForDisposed) {

            m_windowTitle = windowTitle;

            m_matchingOperator = matchingOperator;

            m_valForDisposed = valForDisposed;

        }

        /**

         * {@inheritDoc}

         */

        public boolean isTrue(Event event) {

            if (event.widget instanceof Shell) {

                Shell window = (Shell)event.widget;

                if (window.isDisposed()) {

                    return m_valForDisposed;

                }

                return MatchUtil.getInstance().match(window.getText(), 

                        m_windowTitle, m_matchingOperator);

            }

            return false;

        }

    }

    /** The Robot factory. */

    private IRobotFactory m_robotFactory;

    /**

     * @return The Robot factory instance

     */

    private IRobotFactory getRobotFactory() {

        if (m_robotFactory == null) {

            m_robotFactory = new RobotFactoryConfig().getRobotFactory();

        }

        return m_robotFactory;

    }

    /**

     * {@inheritDoc}

     */

    public String[] getTextArrayFromComponent() {

        return null;

    }

    /**

     * Types <code>text</code> into the component. This replaces the shown

     * content.

     * @param text the text to type in

     * @deprecated Removed without substitution:

     * Testcases with this action are fragile, because this action assumes the

     * availabality of a text component. Any other case breaks the test.

     */

    public void gdReplaceText(String text) {

        // The number of clicks differs from the Swing implementation

        // because a double-click selects all of the text

        getRobot().click(FocusTracker.getFocusOwner(), null, 

            ClickOptions.create().setClickCount(2).left());

        if (StringConstants.EMPTY.equals(text)) {

            getRobot().keyStroke("DELETE"); //$NON-NLS-1$

        }

        gdInputText(text);

    }

    /**

     * Waits <code>timeMillSec</code> if the application opens a window with the given title.

     * @param title the title

     * @param operator the comparing operator

     * @param timeout the time in ms

     * @param delay delay after the window is shown

     */

    public void gdWaitForWindow(final String title, final String operator, 

        int timeout, int delay) {

        final EventListener.Condition cond = 

            new WindowEventCondition(title, operator, false);

        final EventLock lock = new EventLock();

        final Listener listener = new EventListener(lock, cond);

        final Display display = 

            ((SwtAUTServer)AUTServer.getInstance()).getAutDisplay();

        final IEventThreadQueuer queuer = new EventThreadQueuerSwtImpl();

        queuer.invokeAndWait("addWindowOpenedListeners", new IRunnable() { //$NON-NLS-1$

            public Object run() {

                display.addFilter(SWT.Activate, listener);

                display.addFilter(SWT.Show, listener);

                if (isWindowOpen(title, operator)) {

                    lock.release();

                }

                return null;

            }

        });

        try {

            synchronized (lock) {

                long currentTimeout = timeout;

                long done = System.currentTimeMillis() + timeout; 

                long now;

                while (!lock.isReleased() && (currentTimeout > 0)) {

                    try {

                        lock.wait(currentTimeout);                    

                        now = System.currentTimeMillis();

                        currentTimeout = done - now;

                    } catch (InterruptedException e) {

                        // ignore

                    }

                }                    

            }

        } finally {

            queuer.invokeAndWait("removeWindowOpenedListeners", new IRunnable() { //$NON-NLS-1$

                public Object run() {

                    display.removeFilter(SWT.Activate, listener);

                    display.removeFilter(SWT.Show, listener);

                    return null;

                }

            });

        }

        if (!lock.isReleased()) {

            throw new StepExecutionException("window did not open", //$NON-NLS-1$

                    EventFactory.createActionError(

                            TestErrorEvent.TIMEOUT_EXPIRED));

        }

        TimeUtil.delay(delay);

    }

    /**

     * Waits <code>timeMillSec</code> if the application activates a window

     * with the given title.

     * 

     * @param title the title

     * @param operator the comparing operator

     * @param timeout the time in ms

     * @param delay delay after the window is activated

     */

    public void gdWaitForWindowActivation(final String title, 

            final String operator, final int timeout, int delay) {

        final EventListener.Condition cond = 

            new WindowEventCondition(title, operator, false);

        final EventLock lock = new EventLock();

        final Listener listener = new EventListener(lock, cond);

        final Display display = 

            ((SwtAUTServer)AUTServer.getInstance()).getAutDisplay();

        final IEventThreadQueuer queuer = new EventThreadQueuerSwtImpl();

        queuer.invokeAndWait("addWindowActiveListeners", new IRunnable() { //$NON-NLS-1$

            public Object run() {

                display.addFilter(SWT.Activate, listener);

                if (isWindowActive(title, operator)) {

                    lock.release();

                }

                return null;

            }

        });

        try {

            synchronized (lock) {

                long currentTimeout = timeout;

                long done = System.currentTimeMillis() + timeout; 

                long now;

                while (!lock.isReleased() && (currentTimeout > 0)) {

                    try {

                        lock.wait(currentTimeout);                    

                        now = System.currentTimeMillis();

                        currentTimeout = done - now;

                    } catch (InterruptedException e) {

                        // ignore

                    }

                }                    

            }

        } finally {

            queuer.invokeAndWait("removeWindowActiveListeners", new IRunnable() { //$NON-NLS-1$

                public Object run() {

                    display.removeFilter(SWT.Activate, listener);

                    return null;

                }

            });

        }

        if (!lock.isReleased()) {

            throw new StepExecutionException("window was not activated", //$NON-NLS-1$

                    EventFactory.createActionError(

                            TestErrorEvent.TIMEOUT_EXPIRED));

        }

        TimeUtil.delay(delay);

    }

    /**

     * Waits <code>timeMillSec</code> if the application closes (or hides) 

     * a window with the given title. If no window with the given title can

     * be found, then it is assumed that the window has already closed.

     * 

     * @param title the title

     * @param operator the comparing operator

     * @param timeout the time in ms

     * @param delay delay after the window is activated

     */

    public void gdWaitForWindowToClose(final String title, 

            final String operator, int timeout, int delay) {

        final EventListener.Condition cond = 

            new WindowEventCondition(title, operator, true);

        final EventLock lock = new EventLock();

        final Listener listener = new EventListener(lock, cond);

        final Display display = 

            ((SwtAUTServer)AUTServer.getInstance()).getAutDisplay();

        final IEventThreadQueuer queuer = new EventThreadQueuerSwtImpl();

        queuer.invokeAndWait("addWindowClosedListeners", new IRunnable() { //$NON-NLS-1$

            public Object run() {

                display.addFilter(SWT.Close, listener);

                display.addFilter(SWT.Hide, listener);

                display.addFilter(SWT.Dispose, listener);

                if (!isWindowOpen(title, operator)) {

                    lock.release();

                }

                return null;

            }

        });

        try {

            synchronized (lock) {

                long currentTimeout = timeout;

                long done = System.currentTimeMillis() + timeout; 

                long now;

                while (!lock.isReleased() && (currentTimeout > 0)) {

                    try {

                        lock.wait(currentTimeout);                    

                        now = System.currentTimeMillis();

                        currentTimeout = done - now;

                    } catch (InterruptedException e) {

                        // ignore

                    }

                }                    

            }

        } finally {

            queuer.invokeAndWait("removeWindowClosedListeners", new IRunnable() { //$NON-NLS-1$

                public Object run() {

                    display.removeFilter(SWT.Close, listener);

                    display.removeFilter(SWT.Hide, listener);

                    display.removeFilter(SWT.Dispose, listener);

                    return null;

                }

            });

        }

        if (!lock.isReleased()) {

            throw new StepExecutionException("window did not close", //$NON-NLS-1$

                    EventFactory.createActionError(

                            TestErrorEvent.TIMEOUT_EXPIRED));

        }

        TimeUtil.delay(delay);

    }

    /**

     * Returns <code>true</code> if a window with the given title is open and 

     * visible

     * 

     * @param title the title

     * @param operator the matches/equals operator

     * @return if the window is open and visible

     */

    private boolean isWindowOpen(final String title, final String operator) {

        boolean wasInterrupted = false;

        boolean equal = false;

        do {

            try {

                wasInterrupted = false;

                Collection components = ComponentHandler

                    .getAutHierarchy().getHierarchyMap()

                        .keySet();

                for (Iterator it = components.iterator(); it.hasNext();) {

                    Widget comp = ((SwtComponent)it.next()).getRealComponent();

                    if (comp instanceof Shell 

                            && !comp.isDisposed()

                            && ((Shell)comp).isVisible()) {

                        Shell frame = (Shell)comp;

                        if (MatchUtil.getInstance().match(

                                frame.getText(), title, operator)) {

                            equal = true;

                            break;

                        }

                    }

                }

            } catch (ConcurrentModificationException e) {

                log.debug("hierarchy modified while traversing", e); //$NON-NLS-1$

                wasInterrupted = true;

            }

        } while (wasInterrupted);

        return equal;

    }

    /**

     * Checks for the existence of a window with the given title

     * 

     * @param title

     *            the title

     * @param operator

     *            the comparing operator

     * @param exists

     *            <code>True</code> if the component is expected to exist and be

     *            visible, otherwise <code>false</code>.

     */

    public void gdCheckExistenceOfWindow(final String title,

            final String operator, final boolean exists) {

        IEventThreadQueuer queuer = new EventThreadQueuerSwtImpl();

        Boolean windowExists = (Boolean)queuer.invokeAndWait(

                "isWindowOpen", new IRunnable() { //$NON-NLS-1$

                    public Object run() throws StepExecutionException {

                        return new Boolean(isWindowOpen(title, operator));

                    }

                });

        Verifier.equals(exists, windowExists.booleanValue());

    }

    /**

     * {@inheritDoc}

     */

    public Rectangle getActiveWindowBounds() {

        org.eclipse.swt.graphics.Rectangle activeWindowSize = 

            (org.eclipse.swt.graphics.Rectangle)getRobotFactory()

                .getEventThreadQueuer().invokeAndWait(

                    this.getClass().getName() + ".getActiveWindowBounds", //$NON-NLS-1$

                        new IRunnable() {

                            public Object run() { // SYNCH THREAD START

                                Display d = ((SwtAUTServer)AUTServer

                                        .getInstance()).getAutDisplay();

                                if (d != null && d.getActiveShell() != null) {

                                    return d.getActiveShell().getBounds();

                                }

                                return null;

                            }

                        });

        if (activeWindowSize != null) {

            return SwtPointUtil.toAwtRectangle(activeWindowSize);

        }

        return null;

    }

    /**

     * {@inheritDoc}

     */

    protected IRobot getRobot() {

        return AUTServer.getInstance().getRobot();

    }

    /**

     * perform a keystroke

     * @param modifierSpec the string representation of the modifiers

     * @param keySpec the string representation of the key

     */

    public void gdKeyStroke(String modifierSpec, String keySpec) {

        if (keySpec == null || keySpec.trim().length() == 0) {

            throw new StepExecutionException(

                "The base key of the key stroke must not be null or empty", //$NON-NLS-1$

                EventFactory.createActionError(

                        TestErrorEvent.INVALID_PARAM_VALUE));

        }

        String keyStrokeSpec = keySpec.trim();

        String mod = KeyStrokeUtil.getModifierString(modifierSpec);

        if (mod.length() > 0) {

            keyStrokeSpec = mod + " " + keyStrokeSpec; //$NON-NLS-1$

        }

        String keySpecification = keySpec.trim().toLowerCase();

        if (EnvironmentUtils.isMacOS() && keySpecification.length() == 1

                && keySpecification.charAt(0) == WorkaroundUtil.CHAR_B) {

            gdNativeKeyStroke(modifierSpec, keySpec);

        } else {

            // at this the key stroke specification is not fully fullfilled as the

            // key stroke spec base key is not definitly upper case

            getRobot().keyStroke(keyStrokeSpec);

        }

    }

    /**

     * {@inheritDoc}

     */

    protected Object getFocusOwner() {

        return FocusTracker.getFocusOwner();

    }

    /**

     * {@inheritDoc}

     */

    protected int getEventCode(int key) {

        int event = 0;

        switch (key) {

            case 1 : 

                event = SWT.NUM_LOCK;

                break;

            case 2 : 

                event = SWT.CAPS_LOCK;

                break;

            case 3 : 

                event = SWT.SCROLL_LOCK;

                break;

            default : 

                break;

        }

        return event;

    }

    /**

     * {@inheritDoc}

     */

    protected Object getActiveWindow() {

        Shell activeWindow = (Shell)getRobotFactory().getEventThreadQueuer()

        .invokeAndWait(this.getClass().getName() + ".getActiveWindow", //$NON-NLS-1$

            new IRunnable() {

                public Object run() { // SYNCH THREAD START

                    Display d = 

                        ((SwtAUTServer)AUTServer.getInstance()).getAutDisplay();

                    return d.getActiveShell();

                }

            }

        );

        return activeWindow;

    }

    /**

     * Returns <code>true</code> if a window with the given title is active

     * (the window with focus).

     * 

     * @param title the title

     * @param operator the matches/equals operator

     * @return if the window is open and visible

     */

    private boolean isWindowActive(final String title, final String operator) {

        final Shell activeWindow = (Shell) getActiveWindow();

        if (activeWindow == null) {

            if (log.isWarnEnabled()) {

                log.warn("No active Window found while searching for Window with title: '" //$NON-NLS-1$

                        + String.valueOf(title) + "'! " + //$NON-NLS-1$

                    "(SwtApplicationImplClass#isWindowActive(String, String))"); //$NON-NLS-1$

            }

            return false;

        }

        final String windowTitle = activeWindow.getText();

        return MatchUtil.getInstance().match(windowTitle, title, operator);

    }

}